Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

HardwareComponent Class Reference

#include <HardwareComponent.h>

List of all members.

Public Member Functions

 HardwareComponent (HardwareType::Hardware_t type=HardwareType::kUnknown, Int_t id=0)
 ~HardwareComponent ()
void operator= (const HardwareComponent &other)
 HardwareComponent (HardwareType::Hardware_t type, RawChannelId rcid)
 HardwareComponent (HardwareType::Hardware_t type, PlexPixelSpotId psid)
 HardwareComponent (HardwareType::Hardware_t type, PlexStripEndId seid)
 HardwareComponent (HardwareType::Hardware_t type, PlexPinDiodeId pdid)
 HardwareComponent (HardwareType::Hardware_t type, PlexPlaneId plane)
Bool_t FromString (const char *string)
void SetType (HardwareType::Hardware_t type)
void SetId (Int_t id)
HardwareType::Hardware_t GetType () const
Int_t GetId () const
RawChannelId GetRawChannelId () const
PlexPixelSpotId GetPixelSpotId () const
PlexStripEndId GetStripEndId () const
PlexPinDiodeId GetPinDiodeId () const
PlexPlaneId GetPlaneId () const
const std::vector< PlexStripEndId > & GetStripEnds (PlexHandle plex)
void Print (Option_t *option="") const
const char * AsString (Option_t *option="") const

Private Member Functions

void GetStripEndsForPixelSpot (PlexPixelSpotId psid, PlexHandle plex)
void GetStripEndsForPixel (PlexPixelSpotId psid, PlexHandle plex)
void GetStripEndsForPmt (PlexPixelSpotId psid, PlexHandle plex)
void GetStripEndsForChannel (RawChannelId rcid, PlexHandle plex)
void GetStripEndsForMinder (RawChannelId rcid, PlexHandle plex)
void GetStripEndsForMaster (RawChannelId rcid, PlexHandle plex)
void GetStripEndsForVaChip (RawChannelId rcid, PlexHandle plex)
void GetStripEndsForVfb (RawChannelId rcid, PlexHandle plex)
void GetStripEndsForVmm (RawChannelId rcid, PlexHandle plex)
void GetStripEndsForVarc (RawChannelId rcid, PlexHandle plex)
void GetStripEndsForCrate (RawChannelId rcid, PlexHandle plex)
void GetStripEndsForPlane (PlexPlaneId plane, PlexHandle plex)
void GetStripEndsForVetoShield (PlexHandle plex)
void GetStripEndsForSupermodule (Int_t sm, PlexHandle plex)
void GetStripEndsForSpectrometer (PlexHandle plex)
void GetStripEndsForCalorimeter (PlexHandle plex)
void GetStripEndsForDetector (PlexHandle plex)

Private Attributes

HardwareType::Hardware_t fType
Int_t fId

Static Private Attributes

std::vector< PlexStripEndId > fEndList

Friends

Bool_t operator< (const HardwareComponent &lhs, const HardwareComponent &rhs)
Bool_t operator<= (const HardwareComponent &lhs, const HardwareComponent &rhs)
Bool_t operator== (const HardwareComponent &lhs, const HardwareComponent &rhs)
Bool_t operator!= (const HardwareComponent &lhs, const HardwareComponent &rhs)
Bool_t operator> (const HardwareComponent &lhs, const HardwareComponent &rhs)
Bool_t operator>= (const HardwareComponent &lhs, const HardwareComponent &rhs)

Constructor & Destructor Documentation

HardwareComponent::HardwareComponent (  HardwareType::Hardware_t  type = HardwareType::kUnknown,
Int_t  id = 0
)  [inline]
 

Definition at line 13 of file HardwareComponent.h.

00015     : fType(type), fId(id) {};

HardwareComponent::~HardwareComponent (   )  [inline]
 

Definition at line 16 of file HardwareComponent.h.

00016 {};

HardwareComponent::HardwareComponent (  HardwareType::Hardware_t  type,
RawChannelId  rcid
) 
 

Definition at line 8 of file HardwareComponent.cxx.

References HardwareType::AsString(), RawChannelId::ClearModeBits(), fId, fType, RawChannelId::GetEncoded(), MSG, RawChannelId::SetChAdd(), RawChannelId::SetMasterChannel(), RawChannelId::SetMinderChannel(), RawChannelId::SetVaAdcSel(), RawChannelId::SetVaChannel(), RawChannelId::SetVaChip(), and RawChannelId::SetVmm().

00010 {
00011   fType = type;
00012   rcid.ClearModeBits();
00013 
00014   switch(fType) {
00015 
00016   case HardwareType::kCrate:
00017     rcid.SetChAdd(0);
00018     break;
00019 
00020   case HardwareType::kChannel:
00021   case HardwareType::kMenu:
00022     break;
00023 
00024   case HardwareType::kVarc:
00025     rcid.SetVmm(0);
00026     rcid.SetVaAdcSel(0);
00027     rcid.SetVaChip(0);
00028     rcid.SetVaChannel(0);
00029     break;
00030 
00031   case HardwareType::kVmm:
00032     rcid.SetVaAdcSel(0);
00033     rcid.SetVaChip(0);
00034     rcid.SetVaChannel(0);
00035     break;
00036 
00037   case HardwareType::kVfb:
00038     rcid.SetVaChip(0);
00039     rcid.SetVaChannel(0);
00040     break;
00041 
00042   case HardwareType::kVaChip:
00043     rcid.SetVaChannel(0);
00044     break;
00045 
00046   case HardwareType::kMaster:
00047     rcid.SetMasterChannel(0);
00048     rcid.SetMinderChannel(0);
00049     break;
00050 
00051   case HardwareType::kMinder:
00052     rcid.SetMinderChannel(0);
00053     break;
00054 
00055   default:
00056     fId=0;
00057     MSG("Hardware",Msg::kError) << "Attempted to set hardware type " 
00058                                 << HardwareType::AsString(type)
00059                                 << " with RawChannelId. Invalid." << std::endl;
00060     return;
00061     
00062   }
00063   fId = rcid.GetEncoded();
00064 }

HardwareComponent::HardwareComponent (  HardwareType::Hardware_t  type,
PlexPixelSpotId  psid
) 
 

Definition at line 66 of file HardwareComponent.cxx.

References HardwareType::AsString(), fId, fType, PlexPixelSpotId::GetEncoded(), MSG, PlexPixelSpotId::SetPixel(), and PlexPixelSpotId::SetSpot().

00068 {
00069   fType = type;
00070 
00071   switch(fType) {
00072   case HardwareType::kPmt:
00073   case HardwareType::kPmtBase:
00074     psid.SetPixel(0);
00075     psid.SetSpot(0);
00076     break;
00077 
00078   case HardwareType::kPixel:
00079     psid.SetSpot(0);
00080     break;
00081 
00082   case HardwareType::kPixelSpot:
00083     break;
00084 
00085   default:
00086     fId=0;
00087     MSG("Hardware",Msg::kError) << "Attempted to set hardware type " 
00088                                 << HardwareType::AsString(type)
00089                                 << " with PixelSpotId. Invalid." << std::endl;
00090     return;
00091     
00092   }
00093   fId = psid.GetEncoded();
00094   
00095 }

HardwareComponent::HardwareComponent (  HardwareType::Hardware_t  type,
PlexStripEndId  seid
) 
 

Definition at line 97 of file HardwareComponent.cxx.

References HardwareType::AsString(), fId, fType, PlexStripEndId::GetEncoded(), MSG, PlexStripEndId::SetEnd(), and PlexStripEndId::SetSubPart().

00099 {
00100   fType = type;
00101 
00102   switch(fType) {
00103   case HardwareType::kStrip:
00104     seid.SetSubPart(StripEnd::kWhole);
00105     seid.SetEnd(StripEnd::kWhole);
00106     break;
00107 
00108   case HardwareType::kStripEnd:
00109     break;
00110 
00111   default:
00112     fId=0;
00113     MSG("Hardware",Msg::kError) << "Attempted to set hardware type " 
00114                                 << HardwareType::AsString(type)
00115                                 << " with PixelSpotId. Invalid." << std::endl;
00116     return;
00117     
00118   }
00119   fId = seid.GetEncoded();   
00120 }

HardwareComponent::HardwareComponent (  HardwareType::Hardware_t  type,
PlexPinDiodeId  pdid
) 
 

Definition at line 122 of file HardwareComponent.cxx.

References HardwareType::AsString(), fId, fType, PlexPinDiodeId::GetEncoded(), and MSG.

00124 {
00125   if(fType != HardwareType::kPinDiode) {
00126     fId = 0;
00127     MSG("Hardware",Msg::kError) << "Attempted to set hardware type " 
00128                                 << HardwareType::AsString(type)
00129                                 << " with PlexPinDiodeId. Invalid." << std::endl;
00130   }
00131   fId = pdid.GetEncoded();
00132 }

HardwareComponent::HardwareComponent (  HardwareType::Hardware_t  type,
PlexPlaneId  plane
) 
 

Member Function Documentation

const char * HardwareComponent::AsString (  Option_t *  option = ""  )  const
 

Definition at line 141 of file HardwareComponent.cxx.

References fId, Form(), fType, GetPinDiodeId(), GetPixelSpotId(), GetPlaneId(), GetRawChannelId(), and GetStripEndId().

Referenced by Print(), and BadHardware::Print().

00142 {
00143   switch(fType) {
00144   case HardwareType::kCrate:
00145   case HardwareType::kChannel:
00146   case HardwareType::kVarc:
00147   case HardwareType::kVmm:
00148   case HardwareType::kVfb:
00149   case HardwareType::kVaChip:
00150   case HardwareType::kMaster:
00151   case HardwareType::kMinder:
00152   case HardwareType::kMenu:
00153     return Form("%10s %s",HardwareType::AsString(fType),GetRawChannelId().AsString(opt));    
00154   case HardwareType::kPmt:
00155   case HardwareType::kPmtBase:
00156   case HardwareType::kPixel:
00157   case HardwareType::kPixelSpot:
00158     return Form("%10s %s",HardwareType::AsString(fType),GetPixelSpotId().AsString(opt));
00159 
00160   case HardwareType::kStripEnd:
00161   case HardwareType::kStrip:
00162     return Form("%10s %s",HardwareType::AsString(fType),GetStripEndId().AsString(opt));
00163 
00164   case HardwareType::kPinDiode:
00165     return Form("%10s %s",HardwareType::AsString(fType),GetPinDiodeId().AsString(opt));
00166 
00167   case HardwareType::kPlane:
00168     return Form("%10s %s",HardwareType::AsString(fType),GetPlaneId().AsString(opt));
00169 
00170   case HardwareType::kSupermodule:
00171     return Form("%10s %d",HardwareType::AsString(fType),fId);
00172 
00173   case HardwareType::kVetoShield:
00174   case HardwareType::kSpectrometer:
00175   case HardwareType::kCalorimeter:
00176   case HardwareType::kDetector:
00177     return Form("%10s %d",HardwareType::AsString(fType));
00178 
00179   default:
00180     break;
00181   };
00182   return Form("%10s %10d",HardwareType::AsString(fType),fId);
00183 }

Bool_t HardwareComponent::FromString (  const char *  string  ) 
 

Definition at line 135 of file HardwareComponent.cxx.

00136 {
00137   std::cout << "HardwareComponent::FromString not implimented" << endl;
00138   assert(0);
00139 }

Int_t HardwareComponent::GetId (   )  const [inline]
 

Definition at line 37 of file HardwareComponent.h.

00037 { return fId; };

PlexPinDiodeId HardwareComponent::GetPinDiodeId (   )  const [inline]
 

Definition at line 41 of file HardwareComponent.h.

Referenced by AsString().

00041 { return PlexPinDiodeId(fId); };

PlexPixelSpotId HardwareComponent::GetPixelSpotId (  void   )  const [inline]
 

Definition at line 39 of file HardwareComponent.h.

Referenced by AsString(), and GetStripEnds().

00039 { return PlexPixelSpotId(fId); };

PlexPlaneId HardwareComponent::GetPlaneId (   )  const [inline]
 

Definition at line 42 of file HardwareComponent.h.

Referenced by AsString(), and GetStripEnds().

00042 { return PlexPlaneId(fId); };

RawChannelId HardwareComponent::GetRawChannelId (  void   )  const [inline]
 

Definition at line 38 of file HardwareComponent.h.

Referenced by AsString(), and GetStripEnds().

00038 { return RawChannelId(fId); };

PlexStripEndId HardwareComponent::GetStripEndId (   )  const [inline]
 

Definition at line 40 of file HardwareComponent.h.

Referenced by AsString(), and GetStripEnds().

00040 { return PlexStripEndId(fId); };

const std::vector< PlexStripEndId > & HardwareComponent::GetStripEnds (  PlexHandle  plex  ) 
 

Definition at line 191 of file HardwareComponent.cxx.

References fEndList, fId, fType, GetPixelSpotId(), GetPlaneId(), GetRawChannelId(), GetStripEndId(), GetStripEndsForCalorimeter(), GetStripEndsForChannel(), GetStripEndsForCrate(), GetStripEndsForDetector(), GetStripEndsForMaster(), GetStripEndsForMinder(), GetStripEndsForPixel(), GetStripEndsForPixelSpot(), GetStripEndsForPlane(), GetStripEndsForPmt(), GetStripEndsForSpectrometer(), GetStripEndsForSupermodule(), GetStripEndsForVaChip(), GetStripEndsForVarc(), GetStripEndsForVetoShield(), GetStripEndsForVfb(), GetStripEndsForVmm(), PlexStripEndId::IsValid(), MAXMSG, and PlexStripEndId::SetEnd().

Referenced by Coroner::RecordBadStrips().

00192 {
00193   // 
00194   // Return a list of strip ends that are connected to this object, using
00195   // the given plex handle.
00196   //
00197 
00198   fEndList.clear();
00199   PlexStripEndId seid; // workspace.
00200 
00201   // Start with the easy case, move to the harder ones.
00202   
00203   switch(fType) {
00204   case HardwareType::kStripEnd:
00205     seid = GetStripEndId();
00206     if(seid.IsValid()) fEndList.push_back(seid);
00207     break;
00208 
00209   case HardwareType::kStrip:
00210     seid = GetStripEndId();
00211 
00212     seid.SetEnd(StripEnd::kPositive);
00213     if(seid.IsValid()) fEndList.push_back(seid);
00214 
00215     seid.SetEnd(StripEnd::kNegative);
00216     if(seid.IsValid()) fEndList.push_back(seid);    
00217     break;
00218 
00219   // Pmt stuff:
00220   case HardwareType::kPixelSpot:
00221     GetStripEndsForPixelSpot(GetPixelSpotId(),plex);
00222     break;
00223 
00224   case HardwareType::kPixel:
00225     GetStripEndsForPixel(GetPixelSpotId(),plex);
00226     break;
00227 
00228   case HardwareType::kPmt:
00229   case HardwareType::kPmtBase:
00230     GetStripEndsForPmt(GetPixelSpotId(),plex);
00231     break;
00232 
00233   // Channel stuff:
00234   case HardwareType::kChannel:
00235   case HardwareType::kMenu:
00236     GetStripEndsForChannel(GetRawChannelId(),plex);
00237     break;
00238 
00239   case HardwareType::kMinder:
00240     GetStripEndsForMinder(GetRawChannelId(),plex);
00241     break;
00242 
00243   case HardwareType::kMaster:
00244     GetStripEndsForMaster(GetRawChannelId(),plex);
00245     break;
00246 
00247   case HardwareType::kVaChip:
00248     GetStripEndsForVaChip(GetRawChannelId(),plex);
00249     break;
00250 
00251   case HardwareType::kVfb:
00252     GetStripEndsForVfb(GetRawChannelId(),plex);
00253     break;
00254 
00255   case HardwareType::kVmm:
00256     GetStripEndsForVmm(GetRawChannelId(),plex);
00257     break;
00258 
00259   case HardwareType::kVarc:
00260     GetStripEndsForVarc(GetRawChannelId(),plex);
00261     break;
00262 
00263   case HardwareType::kCrate:
00264     GetStripEndsForCrate(GetRawChannelId(),plex);
00265     break;
00266 
00267   case HardwareType::kPinDiode:
00268     break;
00269 
00270   case HardwareType::kPlane:
00271     GetStripEndsForPlane(GetPlaneId(),plex);
00272     break;
00273 
00274   case HardwareType::kSupermodule:
00275     GetStripEndsForSupermodule(fId,plex);
00276     break;
00277 
00278   case HardwareType::kVetoShield:
00279     GetStripEndsForVetoShield(plex);
00280     break;
00281 
00282   case HardwareType::kSpectrometer:
00283     GetStripEndsForSpectrometer(plex);
00284     break;
00285 
00286   case HardwareType::kCalorimeter:
00287     GetStripEndsForCalorimeter(plex);
00288     break;
00289   
00290   case HardwareType::kDetector:
00291     GetStripEndsForDetector(plex);
00292     break;
00293 
00294   default:
00295     MAXMSG("Hardware",Msg::kError,100) << "Unknown hardware type " << fType << ". No strip end list made." << endl;
00296     break;
00297   }
00298   return fEndList;
00299 }

void HardwareComponent::GetStripEndsForCalorimeter (  PlexHandle  plex  )  [private]
 

Definition at line 458 of file HardwareComponent.cxx.

References fEndList, and PlexHandle::GetAllStripEnds().

Referenced by GetStripEnds().

00459 {  
00460   const std::vector<PlexStripEndId>& strips = plex.GetAllStripEnds();
00461   for(UInt_t i=0;i<strips.size();i++) {
00462     if(!strips[i].IsNearSpect()) 
00463       fEndList.push_back(strips[i]); 
00464   }
00465 }

void HardwareComponent::GetStripEndsForChannel (  RawChannelId  rcid,
PlexHandle  plex
)  [private]
 

Definition at line 338 of file HardwareComponent.cxx.

References fEndList, and PlexHandle::GetSEIdAltL().

Referenced by GetStripEnds(), GetStripEndsForMinder(), and GetStripEndsForVaChip().

00339 {
00340   PlexSEIdAltL altl = plex.GetSEIdAltL(rcid);
00341   for(unsigned int i=0;i<altl.size();i++) {
00342     fEndList.push_back(altl[i].GetSEId());
00343   }
00344 }

void HardwareComponent::GetStripEndsForCrate (  RawChannelId  rcid,
PlexHandle  plex
)  [private]
 

Definition at line 397 of file HardwareComponent.cxx.

References RawChannelId::AsString(), RawChannelId::GetElecType(), GetStripEndsForMaster(), GetStripEndsForVarc(), MSG, RawChannelId::SetGeographicAddress(), and RawChannelId::SetVarcId().

Referenced by GetStripEnds().

00398 {
00399   if(rcid.GetElecType()==ElecType::kQIE) {
00400     for(int varc = 0; varc < 4; varc ++) {
00401       rcid.SetVarcId(varc);
00402       GetStripEndsForVarc(rcid,plex);
00403     }
00404 
00405   } else if(rcid.GetElecType()==ElecType::kVA) {
00406     for(int geo=9; geo<21; geo++) {
00407       rcid.SetGeographicAddress(geo);
00408       GetStripEndsForMaster(rcid,plex);
00409     }
00410     
00411   } else {
00412     MSG("Hardware",Msg::kError) << "Unknown hardware type for crate " << rcid.AsString() << endl;
00413   }
00414 }

void HardwareComponent::GetStripEndsForDetector (  PlexHandle  plex  )  [private]
 

Definition at line 469 of file HardwareComponent.cxx.

References fEndList, and PlexHandle::GetAllStripEnds().

Referenced by GetStripEnds().

00470 {  
00471   const std::vector<PlexStripEndId>& strips = plex.GetAllStripEnds();
00472   for(UInt_t i=0;i<strips.size();i++) {
00473     fEndList.push_back(strips[i]); 
00474   }
00475 }

void HardwareComponent::GetStripEndsForMaster (  RawChannelId  rcid,
PlexHandle  plex
)  [private]
 

Definition at line 356 of file HardwareComponent.cxx.

References GetStripEndsForMinder(), and RawChannelId::SetMasterChannel().

Referenced by GetStripEnds(), and GetStripEndsForCrate().

00357 {
00358   for(int i=0;i<8;i++) {
00359     rcid.SetMasterChannel(i);
00360     GetStripEndsForMinder(rcid,plex);
00361   }
00362 }

void HardwareComponent::GetStripEndsForMinder (  RawChannelId  rcid,
PlexHandle  plex
)  [private]
 

Definition at line 347 of file HardwareComponent.cxx.

References GetStripEndsForChannel(), and RawChannelId::SetMinderChannel().

Referenced by GetStripEnds(), and GetStripEndsForMaster().

00348 {
00349   for(int i=0;i<16;i++) {
00350     rcid.SetMinderChannel(i);
00351     GetStripEndsForChannel(rcid,plex);
00352   }
00353 }

void HardwareComponent::GetStripEndsForPixel (  PlexPixelSpotId  psid,
PlexHandle  plex
)  [private]
 

Definition at line 312 of file HardwareComponent.cxx.

References PlexMuxBoxId::GetElecType(), GetStripEndsForPixelSpot(), and PlexPixelSpotId::SetSpot().

Referenced by GetStripEnds(), and GetStripEndsForPmt().

00313 {
00314   // either 8 spots for FD or 1 spot for ND
00315   if(psid.GetElecType()==ElecType::kVA) {
00316     for(int ispot=1;ispot<8;ispot++) {
00317       psid.SetSpot(ispot);
00318       GetStripEndsForPixelSpot(psid,plex);
00319     }
00320   } else {
00321     psid.SetSpot(1);
00322     GetStripEndsForPixelSpot(psid,plex);
00323   }
00324 }

void HardwareComponent::GetStripEndsForPixelSpot (  PlexPixelSpotId  psid,
PlexHandle  plex
)  [private]
 

Definition at line 306 of file HardwareComponent.cxx.

References fEndList, PlexHandle::GetStripEndId(), and PlexStripEndId::IsValid().

Referenced by GetStripEnds(), and GetStripEndsForPixel().

00307 {
00308   PlexStripEndId seid = plex.GetStripEndId(psid);
00309   if(seid.IsValid()) fEndList.push_back(seid);
00310 }

void HardwareComponent::GetStripEndsForPlane (  PlexPlaneId  plane,
PlexHandle  plex
)  [private]
 

Definition at line 416 of file HardwareComponent.cxx.

References fEndList, PlexStripEndId::IsValid(), PlexPlaneId::NumberOfStrips(), and PlexStripEndId::SetEnd().

Referenced by GetStripEnds().

00417 {
00418   for(UInt_t i=0;i<plane.NumberOfStrips();i++) {
00419     PlexStripEndId seid = PlexStripEndId(plane,i);
00420 
00421     seid.SetEnd(StripEnd::kPositive);
00422     if(seid.IsValid()) fEndList.push_back(seid);
00423 
00424     seid.SetEnd(StripEnd::kNegative);
00425     if(seid.IsValid()) fEndList.push_back(seid); 
00426   }
00427 }

void HardwareComponent::GetStripEndsForPmt (  PlexPixelSpotId  psid,
PlexHandle  plex
)  [private]
 

Definition at line 326 of file HardwareComponent.cxx.

References PlexMuxBoxId::GetElecType(), GetStripEndsForPixel(), and PlexPixelSpotId::SetPixel().

Referenced by GetStripEnds().

00327 {
00328   int npix = 16;
00329   if(psid.GetElecType()==ElecType::kQIE) npix = 64;
00330   for(int ipix=0;ipix<npix;ipix++) {
00331     psid.SetPixel(ipix);
00332     GetStripEndsForPixel(psid,plex);
00333   }
00334 }

void HardwareComponent::GetStripEndsForSpectrometer (  PlexHandle  plex  )  [private]
 

Definition at line 448 of file HardwareComponent.cxx.

References fEndList, and PlexHandle::GetAllStripEnds().

Referenced by GetStripEnds().

00449 {  
00450   const std::vector<PlexStripEndId>& strips = plex.GetAllStripEnds();
00451   for(UInt_t i=0;i<strips.size();i++) {
00452     if(strips[i].IsNearSpect()) 
00453       fEndList.push_back(strips[i]); 
00454   }
00455 }

void HardwareComponent::GetStripEndsForSupermodule (  Int_t  sm,
PlexHandle  plex
)  [private]
 

Definition at line 429 of file HardwareComponent.cxx.

References fEndList, and PlexHandle::GetAllStripEnds().

Referenced by GetStripEnds().

00430 {
00431   const std::vector<PlexStripEndId>& strips = plex.GetAllStripEnds();
00432   for(UInt_t i=0;i<strips.size();i++) {
00433     if(strips[i].GetSuperModule()==sm) 
00434       fEndList.push_back(strips[i]); 
00435   }
00436 
00437 }

void HardwareComponent::GetStripEndsForVaChip (  RawChannelId  rcid,
PlexHandle  plex
)  [private]
 

Definition at line 364 of file HardwareComponent.cxx.

References GetStripEndsForChannel(), and RawChannelId::SetVaChannel().

Referenced by GetStripEnds(), and GetStripEndsForVfb().

00365 {
00366   for(int i=2;i<18;i++) {
00367     rcid.SetVaChannel(i);
00368     GetStripEndsForChannel(rcid,plex);
00369   }
00370 }

void HardwareComponent::GetStripEndsForVarc (  RawChannelId  rcid,
PlexHandle  plex
)  [private]
 

Definition at line 388 of file HardwareComponent.cxx.

References GetStripEndsForVmm(), and RawChannelId::SetVmm().

Referenced by GetStripEnds(), and GetStripEndsForCrate().

00389 {
00390   for(int i=0;i<6;i++) {
00391     rcid.SetVmm(i);
00392     GetStripEndsForVmm(rcid,plex);
00393   }
00394 }

void HardwareComponent::GetStripEndsForVetoShield (  PlexHandle  plex  )  [private]
 

Definition at line 439 of file HardwareComponent.cxx.

References fEndList, and PlexHandle::GetAllStripEnds().

Referenced by GetStripEnds().

00440 {
00441   const std::vector<PlexStripEndId>& strips = plex.GetAllStripEnds();
00442   for(UInt_t i=0;i<strips.size();i++) {
00443     if(strips[i].IsVetoShield()) 
00444       fEndList.push_back(strips[i]); 
00445   }
00446 }

void HardwareComponent::GetStripEndsForVfb (  RawChannelId  rcid,
PlexHandle  plex
)  [private]
 

Definition at line 372 of file HardwareComponent.cxx.

References GetStripEndsForVaChip(), and RawChannelId::SetVaChip().

Referenced by GetStripEnds(), and GetStripEndsForVmm().

00373 {
00374   for(int i=0; i<3; i++) {
00375     rcid.SetVaChip(i);
00376     GetStripEndsForVaChip(rcid,plex);
00377   }
00378 }

void HardwareComponent::GetStripEndsForVmm (  RawChannelId  rcid,
PlexHandle  plex
)  [private]
 

Definition at line 380 of file HardwareComponent.cxx.

References GetStripEndsForVfb(), and RawChannelId::SetVaAdcSel().

Referenced by GetStripEnds(), and GetStripEndsForVarc().

00381 {
00382   for(int i=0;i<2;i++) {
00383     rcid.SetVaAdcSel(i);
00384     GetStripEndsForVfb(rcid,plex);
00385   }
00386 }

HardwareType::Hardware_t HardwareComponent::GetType (   )  const [inline]
 

Definition at line 36 of file HardwareComponent.h.

00036 { return fType; };

void HardwareComponent::operator= (  const HardwareComponent &  other  )  [inline]
 

Definition at line 19 of file HardwareComponent.h.

References fId, and fType.

00019 { fType = other.fType; fId = other.fId; };

void HardwareComponent::Print (  Option_t *  option = ""  )  const
 

Definition at line 185 of file HardwareComponent.cxx.

References AsString().

00186 {
00187   cout << "Component: " << AsString(opt) << endl;
00188 }

void HardwareComponent::SetId (  Int_t  id  )  [inline]
 

Definition at line 33 of file HardwareComponent.h.

00033 { fId = id; };

void HardwareComponent::SetType (  HardwareType::Hardware_t  type  )  [inline]
 

Definition at line 32 of file HardwareComponent.h.

00032 { fType = type; };

Friends And Related Function Documentation

Bool_t operator!= (  const HardwareComponent &  lhs,
const HardwareComponent &  rhs
)  [friend]
 

Definition at line 101 of file HardwareComponent.h.

00102 { 
00103   if(lhs.fId   != rhs.fId) return true;
00104   if( lhs.fType!=rhs.fType ) return true;
00105   return false;
00106 }

Bool_t operator< (  const HardwareComponent &  lhs,
const HardwareComponent &  rhs
)  [friend]
 

Definition at line 86 of file HardwareComponent.h.

00087 { 
00088   if( lhs.fType==rhs.fType ) return (lhs.fId  < rhs.fId);
00089   else                       return (lhs.fType< rhs.fType);
00090 }

Bool_t operator<= (  const HardwareComponent &  lhs,
const HardwareComponent &  rhs
)  [friend]
 

Definition at line 91 of file HardwareComponent.h.

00092 { 
00093   if( lhs.fType==rhs.fType ) return (lhs.fId  <= rhs.fId);
00094   else                       return (lhs.fType<= rhs.fType);
00095 }

Bool_t operator== (  const HardwareComponent &  lhs,
const HardwareComponent &  rhs
)  [friend]
 

Definition at line 96 of file HardwareComponent.h.

00097 { 
00098   if( lhs.fType==rhs.fType ) return (lhs.fId  == rhs.fId);
00099   return false;
00100 }

Bool_t operator> (  const HardwareComponent &  lhs,
const HardwareComponent &  rhs
)  [friend]
 

Definition at line 107 of file HardwareComponent.h.

00108 { 
00109   if( lhs.fType==rhs.fType ) return (lhs.fId  > rhs.fId);
00110   else                       return (lhs.fType> rhs.fType);
00111 }

Bool_t operator>= (  const HardwareComponent &  lhs,
const HardwareComponent &  rhs
)  [friend]
 

Definition at line 112 of file HardwareComponent.h.

00113 { 
00114   if( lhs.fType==rhs.fType ) return (lhs.fId  >= rhs.fId);
00115   else                       return (lhs.fType>= rhs.fType);
00116 }

Member Data Documentation

std::vector< PlexStripEndId > HardwareComponent::fEndList [static, private]
 

Referenced by GetStripEnds(), GetStripEndsForCalorimeter(), GetStripEndsForChannel(), GetStripEndsForDetector(), GetStripEndsForPixelSpot(), GetStripEndsForPlane(), GetStripEndsForSpectrometer(), GetStripEndsForSupermodule(), and GetStripEndsForVetoShield().

Int_t HardwareComponent::fId [private]
 

Definition at line 10 of file HardwareComponent.h.

Referenced by AsString(), GetStripEnds(), HardwareComponent(), operator!=(), operator<(), operator<=(), operator=(), operator==(), operator>(), and operator>=().

HardwareType::Hardware_t HardwareComponent::fType [private]
 

Definition at line 9 of file HardwareComponent.h.

Referenced by AsString(), GetStripEnds(), HardwareComponent(), operator!=(), operator<(), operator<=(), operator=(), operator==(), operator>(), and operator>=().

The documentation for this class was generated from the following files:
Generated on Thu Apr 1 23:09:52 2010 for loon by  doxygen 1.3.9.1