00001
00002
00003 #include "StEventTypes.h"
00004
00005
00006
00007
00008
00009
00010 #include "tables/St_g2t_emc_hit_Table.h"
00011 #include "tables/St_g2t_event_Table.h"
00012
00013 #include "StBFChain.h"
00014
00015 #include "EEmcMCData.h"
00016
00017 #include "StEEmcUtil/EEmcGeom/EEmcGeomDefs.h"
00018 #include "StEEmcUtil/EEevent/EEeventDst.h"
00019 #include "StEEmcUtil/EEevent/EEsectorDst.h"
00020
00021 #include "StMessMgr.h"
00022
00023 ClassImp(EEmcMCData)
00024
00025
00026
00027
00028 EEmcMCData::EEmcMCData()
00029 : TObject()
00030 {
00031 mEventID = -1;
00032 mLastHit = 0;
00033 mEthr = kEEmcDefaultEnergyThreshold;
00034 mSize = kEEmcDefaultMCHitSize;
00035 mHit = new struct EEmcMCHit[mSize];
00036 }
00037
00038
00039
00040 EEmcMCData::EEmcMCData(const EEmcMCData &e )
00041 : TObject(e)
00042 {
00043 mEventID = e.getEventID();
00044 mLastHit = e.getLastHit();
00045 mEthr = e.getEnergyThreshold();
00046 mSize = e.getSize();
00047 mHit = new struct EEmcMCHit[mSize];
00048 mSize = e.getHitArray(mHit,mSize);
00049 }
00050
00051
00052
00053
00054 EEmcMCData::~EEmcMCData() {
00055 mSize = 0;
00056 if(mHit) delete [] mHit;
00057 }
00058
00059
00060
00061
00062
00063 Int_t
00064 EEmcMCData::readEventFromChain(const StMaker *myMk)
00065 {
00066 St_g2t_event *g2t_event = NULL;
00067 St_g2t_emc_hit *emc_hit = NULL;
00068 St_g2t_emc_hit *smd_hit = NULL;
00069 g2t_event_st *event_head = NULL;
00070
00071
00072 if( (g2t_event=(St_g2t_event *) myMk->GetDataSet("g2t_event")) == NULL ) {
00073 LOG_ERROR << "missing MC event header" << endm;
00074 return 0;
00075 }
00076 if( (event_head= g2t_event->GetTable()) == NULL ) {
00077 LOG_ERROR << "missing MC event header table" << endm;
00078 return 0;
00079 }
00080 mEventID=event_head->n_event;
00081 emc_hit = (St_g2t_emc_hit *) myMk->GetDataSet("g2t_eem_hit");
00082 smd_hit = (St_g2t_emc_hit *) myMk->GetDataSet("g2t_esm_hit");
00083 unpackGeantHits(emc_hit, smd_hit);
00084 return mLastHit;
00085
00086 }
00087
00088
00089
00090
00091
00092 void
00093 EEmcMCData::unpackGeantHits(St_g2t_emc_hit* emc_hit, St_g2t_emc_hit* smd_hit ){
00094 int err=0;
00095 mLastHit = 0;
00096 memset(mHit,0x0,sizeof(struct EEmcMCHit)*mSize);
00097
00098
00099 if( emc_hit !=NULL ) {
00100 Int_t nhits = emc_hit->GetNRows();
00101 if(nhits<=0) {
00102 Warning("readEventFromChain","no tower hits (%d)",nhits);
00103 goto skipTower;
00104 }
00105
00106 g2t_emc_hit_st *hit = emc_hit->GetTable();
00107 for(Int_t ihit=0; ihit<nhits; ihit++,hit++) {
00108
00109 Int_t ivid = hit->volume_id;
00110 Short_t sec = 0;
00111 Short_t ssec = 0;
00112
00113 ivid %= kEEmcTowerHalfId;
00114 Short_t phi = ivid/kEEmcTowerPhiId; ivid %= kEEmcTowerPhiId;
00115 Short_t eta = ivid/kEEmcTowerEtaId; ivid %= kEEmcTowerEtaId;
00116 Short_t depth = ivid/kEEmcTowerDepId; ivid %= kEEmcTowerDepId;
00117
00118
00119 if(!ivid==0){err=1; goto crash;};
00120
00121 ssec = (phi-1)%5 + 1;
00122
00123 sec = (phi-1)/5 + 1;
00124
00125 if(!( 0<sec && sec<=kEEmcNumSectors )){err=2; goto crash;};
00126 if(!( 0<ssec && ssec<=kEEmcNumSubSectors)){err=3; goto crash;};
00127 if(!( 0<eta && eta<=kEEmcNumEtas)){err=4; goto crash;};
00128 if(!( 0<depth && depth<=kEEmcNumDepths)){err=5; goto crash;};
00129
00130 switch(depth) {
00131 case kPreShower1Depth:
00132 mHit[mLastHit].detector = kEEmcMCPreShower1Id;
00133 break;
00134 case kPreShower2Depth:
00135 mHit[mLastHit].detector = kEEmcMCPreShower2Id;
00136 break;
00137 case kTower1Depth:
00138 case kTower2Depth:
00139 mHit[mLastHit].detector = kEEmcMCTowerId;
00140 break;
00141 case kPostShowerDepth:
00142 mHit[mLastHit].detector = kEEmcMCPostShowerId;
00143 break;
00144 default:
00145 Warning("readEventFromChain","unknown depth %d",depth);
00146 goto crash;
00147 break;
00148 }
00149
00150 mHit[mLastHit].sector = sec;
00151 mHit[mLastHit].tower.ssec = ssec;
00152 mHit[mLastHit].tower.eta = eta;
00153 mHit[mLastHit].de = hit->de;
00154 mHit[mLastHit].track_p = hit->track_p;
00155 mLastHit++;
00156
00157
00158 if ((mLastHit >= mSize) && !expandMemory()) {
00159 LOG_ERROR << "failed expandMemory() for tower tails" << endm;
00160 goto crash;
00161 }
00162 }
00163 }
00164
00165 skipTower:
00166
00167
00168 if( smd_hit != NULL ) {
00169 Int_t nhits = smd_hit->GetNRows();
00170
00171 if(nhits<=0) {
00172 Warning("readEventFromChain","no smd hits (%d)",nhits);
00173 goto done;
00174 }
00175 g2t_emc_hit_st *hit = smd_hit->GetTable();
00176
00177 for(Int_t ihit=0; ihit<nhits ; ihit++,hit++) {
00178
00179
00180 Int_t ivid = hit->volume_id;
00181 Short_t det = 0;
00182 Short_t sec = 0;
00183 Short_t half = ivid/kEEmcSmdHalfId; ivid %= kEEmcSmdHalfId;
00184 Short_t phi = ivid/kEEmcSmdPhiId; ivid %= kEEmcSmdPhiId;
00185 Short_t plane = ivid/kEEmcSmdPlaneId;ivid %= kEEmcSmdPlaneId;
00186 Short_t strip = ivid/kEEmcSmdStripId;ivid %= kEEmcSmdStripId;
00187
00188 if(!ivid==0){err=10; goto crash;};
00189
00190 switch(phi) {
00191 case 1:
00192 case 4:
00193 case 7:
00194 case 10:
00195 switch(plane) {
00196 case 1: det = kEEmcMCSmdVStripId; break;
00197 case 3: det = kEEmcMCSmdUStripId; break;
00198 default: det = kUnknownId; break;
00199 }
00200 break;
00201 case 2:
00202 case 5:
00203 case 8:
00204 case 11:
00205 switch(plane) {
00206 case 2: det = kEEmcMCSmdVStripId; break;
00207 case 1: det = kEEmcMCSmdUStripId; break;
00208 default: det = kUnknownId; break;
00209 }
00210 break;
00211 case 3:
00212 case 6:
00213 case 9:
00214 case 12:
00215 switch(plane) {
00216 case 3: det = kEEmcMCSmdVStripId; break;
00217 case 2: det = kEEmcMCSmdUStripId; break;
00218 default: det = kUnknownId; break;
00219 }
00220 break;
00221 default:
00222 det = kUnknownId;
00223 break;
00224 }
00225 if(det!=kEEmcMCSmdVStripId && det!=kEEmcMCSmdUStripId ) {
00226 Warning("readEventFromChain","unknown smd layer %d %d-%d-%d-%d",det,half,phi,plane,strip);
00227 goto crash;
00228 }
00229
00230 sec = phi;
00231
00232 if(! ( 0<sec && sec <=kEEmcNumSectors )){err=12; goto crash;};
00233 if(!( 0<strip && strip<=kEEmcNumStrips )){err=13; goto crash;};
00234
00235
00236
00237 mHit[mLastHit].detector = det;
00238 mHit[mLastHit].sector = sec;
00239 mHit[mLastHit].strip = strip;
00240 mHit[mLastHit].de = hit->de;
00241 mHit[mLastHit].track_p = hit->track_p;
00242
00243 mLastHit++;
00244 if ((mLastHit >= mSize) && !expandMemory()) {
00245 LOG_ERROR << "failed expandMemory() for SMD strips" << endm;
00246 goto crash;
00247 }
00248 }
00249 }
00250
00251 done:
00252 return ;
00253
00254 crash:
00255 printf("\n\n==============================\nEEmcMCData::readEventFromChain() Fatal error while decoding .fzd hits for EEMC err=%d,\n all EEMC data erased \n=====================================\n",err);
00256 mLastHit = 0;
00257 memset(mHit,0x0,sizeof(struct EEmcMCHit)*mSize);
00258 return;
00259
00260 }
00261
00262
00263
00264
00265 Int_t
00266 EEmcMCData::getHitArray(EEmcMCHit *h, Int_t size) const
00267 {
00268 if(size<=0) {
00269 LOG_ERROR << "invalid size: " << size << endm;
00270 return 0;
00271 }
00272 if(size<mSize) {LOG_WARN << "truncating to " << size << " hits (out of " << mSize << ")" << endm;}
00273 int n = size; if (n > mSize) n = mSize;
00274 memcpy(h,mHit,size*sizeof(EEmcMCHit));
00275 return size;
00276 }
00277
00278 Int_t
00279 EEmcMCData::setHitArray(EEmcMCHit *h, Int_t size)
00280 {
00281 if(size<=0) {
00282 LOG_ERROR << "invalid size: " << size << endm;
00283 return 0;
00284 }
00285 if(size>mSize) {LOG_WARN << "truncating to " << mSize << " hits (out of " << size << ")" << endm;}
00286 int n = size; if (n > mSize) n = mSize;
00287 memcpy(h,mHit,n*sizeof(EEmcMCHit));
00288 return mSize;
00289 }
00290
00291
00292
00293 void
00294 EEmcMCData::print() const
00295 {
00296 TString detName;
00297 Int_t detId;
00298 EEmcMCHit *h = mHit;
00299 printf("EndcapEmc MC event #%d\n",mEventID);
00300 for(Int_t i=0; i<mLastHit; i++,h++) {
00301 detId=h->detector;
00302 switch(detId) {
00303 case kEEmcMCTowerId: detName = "EndcapEmcTower "; break;
00304 case kEEmcMCPreShower1Id: detName = "EndcapEmcPreShower1 "; break;
00305 case kEEmcMCPreShower2Id: detName = "EndcapEmcPreShower2 "; break;
00306 case kEEmcMCPostShowerId: detName = "EndcapEmcPostShower "; break;
00307 case kEEmcMCSmdUStripId: detName = "EndcapEmcSmdUStrip "; break;
00308 case kEEmcMCSmdVStripId: detName = "EndcapEmcSmdVStrip "; break;
00309 default: detName = "EndcapEmcUnknown "; break;
00310 }
00311
00312
00313 switch(detId) {
00314 case kEEmcMCTowerId:
00315 case kEEmcMCPreShower1Id:
00316 case kEEmcMCPreShower2Id:
00317 case kEEmcMCPostShowerId:
00318 printf("%s sec=%2d sub=%c eta=%d de=%g tr_p=%d\n",detName.Data(), h->sector,h->tower.ssec-1+'A',h->tower.eta,h->de, h->track_p);
00319 break;
00320 case kEEmcMCSmdUStripId:
00321 case kEEmcMCSmdVStripId:
00322 printf("%s sec=%2d strip=%d de=%g tr_p=%d\n",detName.Data(), h->sector,h->strip,h->de, h->track_p);
00323 break;
00324 default:
00325 LOG_WARN << "detectorId=" << detId << " is unknown" << endm;
00326 break;
00327 }
00328
00329 }
00330 }
00331
00332
00333
00334
00335 Int_t
00336 EEmcMCData::expandMemory()
00337 {
00338 Int_t newSize = mSize + kEEmcDefaultMCHitSize;
00339 EEmcMCHit* newHit = new EEmcMCHit[newSize];
00340
00341 if(mHit) {
00342 if (newHit) memcpy(newHit,mHit,mSize*sizeof(EEmcMCHit));
00343 delete [] mHit;
00344 mHit = 0;
00345 }
00346 Info("expandMemory"," MCHit memory expanded from 0x%04x to 0x%04x",mSize,newSize);
00347 mSize = newSize;
00348 mHit = newHit;
00349 return kTRUE;
00350 }
00351
00352
00353
00354
00355
00356 Int_t
00357 EEmcMCData::read (void *hit, int size)
00358 {
00359
00360 const int HitSize = sizeof(struct EEmcMCHit);
00361 const int MaxSize = mSize * HitSize;
00362 if(size>MaxSize) size=MaxSize;
00363 memcpy(mHit,hit,size);
00364 mLastHit =size/HitSize;
00365 return size;
00366 }
00367
00368
00369
00370
00371 Int_t
00372 EEmcMCData::write (void *hit, int size)
00373 {
00374 Int_t nbytes = mLastHit * sizeof(struct EEmcMCHit);
00375 if(size>nbytes) size=nbytes;
00376 memcpy(hit,mHit,size);
00377 return size;
00378 }
00379
00380
00381
00382
00383 Int_t EEmcMCData::write(EEeventDst *EEeve) {
00384
00385 EEeve->clear();
00386
00387 EEeve->setType(EEeventDst::kRawMC);
00388 EEeve->setID(mEventID);
00389
00390 EEmcMCHit *h = mHit;
00391 for(Int_t i=0; i<mLastHit; i++,h++) {
00392
00393
00394 int secID=h->sector;
00395 EEsectorDst *EEsec= (EEsectorDst *)EEeve->getSec(secID,1);
00396
00397
00398
00399 int subSec='A'+h->tower.ssec-1;
00400 if (EEsec) switch( h->detector) {
00401 case kEEmcMCTowerId:
00402 EEsec->addTwHit(subSec,h->tower.eta,h->de); break;
00403 case kEEmcMCPreShower1Id:
00404 EEsec->addPre1Hit(subSec,h->tower.eta,h->de); break;
00405 case kEEmcMCPreShower2Id:
00406 EEsec->addPre2Hit(subSec,h->tower.eta,h->de); break;
00407 case kEEmcMCPostShowerId:
00408 EEsec->addPostHit(subSec,h->tower.eta,h->de); break;
00409 case kEEmcMCSmdUStripId:
00410 EEsec->addSmdUHit(h->strip,h->de); break;
00411 case kEEmcMCSmdVStripId:
00412 EEsec->addSmdVHit(h->strip,h->de); break;
00413 default:
00414 LOG_ERROR << "invalid MC depth" << endm;
00415 break;
00416 }
00417
00418 }
00419
00420 return 0;
00421 }
00422
00423
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450
00451
00452
00453
00454
00455
00456
00457
00458
00459
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469
00470
00471
00472
00473
00474
00475
00476
00477
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
