00001 #include "HardwareComponent.h"
00002 #include "MessageService/MsgService.h"
00003 #include <cassert>
00004 CVSID("$Id: HardwareComponent.cxx,v 1.5 2007/03/01 17:11:32 rhatcher Exp $");
00005
00006 std::vector<PlexStripEndId> HardwareComponent::fEndList(0);
00007
00008 HardwareComponent::HardwareComponent(HardwareType::Hardware_t type,
00009 RawChannelId rcid)
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 }
00065
00066 HardwareComponent::HardwareComponent(HardwareType::Hardware_t type,
00067 PlexPixelSpotId psid)
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 }
00096
00097 HardwareComponent::HardwareComponent(HardwareType::Hardware_t type,
00098 PlexStripEndId seid)
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 }
00121
00122 HardwareComponent::HardwareComponent(HardwareType::Hardware_t type,
00123 PlexPinDiodeId pdid)
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 }
00133
00134
00135 Bool_t HardwareComponent::FromString(const char* )
00136 {
00137 std::cout << "HardwareComponent::FromString not implimented" << endl;
00138 assert(0);
00139 }
00140
00141 const char* HardwareComponent::AsString(Option_t* opt) const
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 }
00184
00185 void HardwareComponent::Print(Option_t* opt) const
00186 {
00187 cout << "Component: " << AsString(opt) << endl;
00188 }
00189
00190
00191 const std::vector<PlexStripEndId>& HardwareComponent::GetStripEnds(PlexHandle plex)
00192 {
00193
00194
00195
00196
00197
00198 fEndList.clear();
00199 PlexStripEndId seid;
00200
00201
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
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
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 }
00300
00305
00306 void HardwareComponent::GetStripEndsForPixelSpot(PlexPixelSpotId psid, PlexHandle plex)
00307 {
00308 PlexStripEndId seid = plex.GetStripEndId(psid);
00309 if(seid.IsValid()) fEndList.push_back(seid);
00310 }
00311
00312 void HardwareComponent::GetStripEndsForPixel(PlexPixelSpotId psid, PlexHandle plex)
00313 {
00314
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 }
00325
00326 void HardwareComponent::GetStripEndsForPmt(PlexPixelSpotId psid, PlexHandle plex)
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 }
00335
00337
00338 void HardwareComponent::GetStripEndsForChannel(RawChannelId rcid, PlexHandle plex)
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 }
00345
00346
00347 void HardwareComponent::GetStripEndsForMinder(RawChannelId rcid, PlexHandle plex)
00348 {
00349 for(int i=0;i<16;i++) {
00350 rcid.SetMinderChannel(i);
00351 GetStripEndsForChannel(rcid,plex);
00352 }
00353 }
00354
00355
00356 void HardwareComponent::GetStripEndsForMaster(RawChannelId rcid, PlexHandle plex)
00357 {
00358 for(int i=0;i<8;i++) {
00359 rcid.SetMasterChannel(i);
00360 GetStripEndsForMinder(rcid,plex);
00361 }
00362 }
00363
00364 void HardwareComponent::GetStripEndsForVaChip(RawChannelId rcid, PlexHandle plex)
00365 {
00366 for(int i=2;i<18;i++) {
00367 rcid.SetVaChannel(i);
00368 GetStripEndsForChannel(rcid,plex);
00369 }
00370 }
00371
00372 void HardwareComponent::GetStripEndsForVfb(RawChannelId rcid, PlexHandle plex)
00373 {
00374 for(int i=0; i<3; i++) {
00375 rcid.SetVaChip(i);
00376 GetStripEndsForVaChip(rcid,plex);
00377 }
00378 }
00379
00380 void HardwareComponent::GetStripEndsForVmm(RawChannelId rcid, PlexHandle plex)
00381 {
00382 for(int i=0;i<2;i++) {
00383 rcid.SetVaAdcSel(i);
00384 GetStripEndsForVfb(rcid,plex);
00385 }
00386 }
00387
00388 void HardwareComponent::GetStripEndsForVarc(RawChannelId rcid, PlexHandle plex)
00389 {
00390 for(int i=0;i<6;i++) {
00391 rcid.SetVmm(i);
00392 GetStripEndsForVmm(rcid,plex);
00393 }
00394 }
00395
00396
00397 void HardwareComponent::GetStripEndsForCrate(RawChannelId rcid, PlexHandle plex)
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 }
00415
00416 void HardwareComponent::GetStripEndsForPlane(PlexPlaneId plane, PlexHandle )
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 }
00428
00429 void HardwareComponent::GetStripEndsForSupermodule(Int_t sm, PlexHandle plex)
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 }
00438
00439 void HardwareComponent::GetStripEndsForVetoShield(PlexHandle plex)
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 }
00447
00448 void HardwareComponent::GetStripEndsForSpectrometer(PlexHandle plex)
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 }
00456
00457
00458 void HardwareComponent::GetStripEndsForCalorimeter(PlexHandle plex)
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 }
00466
00467
00468
00469 void HardwareComponent::GetStripEndsForDetector(PlexHandle plex)
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 }
00476
00477
00478
00479
00480
00481
