StRoot: StGammaMaker/StGammaRawMaker.cxx Source File

00001 #include "StMessMgr.h"
00002 
00003 #include "StEEmcPool/StEEmcA2EMaker/StEEmcA2EMaker.h"
00004 #include "StEEmcUtil/EEmcGeom/EEmcGeomDefs.h"
00005 #include "StEEmcUtil/EEmcGeom/EEmcGeomSimple.h"
00006 
00007 #include "StEventTypes.h"
00008 
00009 #include "StMuDSTMaker/COMMON/StMuDstMaker.h"
00010 #include "StMuDSTMaker/COMMON/StMuDst.h"
00011 #include "StMuDSTMaker/COMMON/StMuPrimaryVertex.h"
00012 #include "StMuDSTMaker/COMMON/StMuTrack.h"
00013 
00014 #include "StEmcUtil/geometry/StEmcGeom.h"
00015 #include "StEmcUtil/others/emcDetectorName.h"
00016 #include "StEmcADCtoEMaker/StBemcData.h"
00017 #include "StEmcADCtoEMaker/StEmcADCtoEMaker.h"
00018 #include "StEmcRawMaker/defines.h"
00019 #include "StEmcRawMaker/StBemcRaw.h"
00020 #include "StEmcRawMaker/StBemcTables.h"
00021 #include "StEmcRawMaker/StEmcRawMaker.h"
00022 
00023 #include "StGammaRawMaker.h"
00024 
00025 ClassImp(StGammaRawMaker);
00026 
00028 //                 Constructor                  //
00030 StGammaRawMaker::StGammaRawMaker(const char *name): StMaker(name)
00031 {
00032 
00033     SetTowerCutoff(0.0);
00034     SetTrackCutoff(0.0);
00035     
00036     mUseBemc = false;
00037     mUseEemc = false;
00038 
00039     mBemcGainShift = 0.0;
00040     
00041 }
00042 
00044 //                  Destructor                  //
00046 StGammaRawMaker::~StGammaRawMaker()
00047 {}
00048 
00050 //                 Maker Init                   //
00052 Int_t StGammaRawMaker::Init()
00053 {
00054 
00055     mEEmcGeometry = new EEmcGeomSimple();
00056     mTables = new StBemcTables();
00057     mCorrupt = false;
00058     
00059     return StMaker::Init();
00060     
00061 }
00062 
00064 //                 Maker Clear                  //
00066 void StGammaRawMaker::Clear(Option_t *opts)
00067 {
00068 
00069     // Clear detector object vectors
00070     mTracks.clear();
00071     mTowers.clear();
00072     mStrips.clear();
00073     mPreshower1.clear();
00074     mPreshower2.clear();
00075     mPostshower.clear();
00076 
00077     // for efficiency, we could clear only those elements which have been "hit"
00078     for (Int_t index = 0; index < kEEmcNumSectors * kEEmcNumSubSectors * kEEmcNumEtas; index++)
00079     {
00080     
00081         for(Int_t layer = 0; layer < 4; layer++)
00082         {
00083         
00084             mEEtowers[index][layer] = 0;
00085 
00086             for(Int_t sec = 0; sec < kEEmcNumSectors; sec++)
00087             {
00088     
00089                 for(Int_t plane = 0; plane < kEEmcNumSmdUVs; plane++)
00090                 {
00091       
00092                     for(Int_t strip = 0; strip < kEEmcNumStrips; strip++)
00093                     {
00094                     
00095                         mEEstrips[sec][plane][strip] = 0;
00096                            
00097                     }
00098                        
00099                 } // Planes
00100             
00101             } // Sectors
00102         
00103         } // Layers
00104     
00105     } // Index
00106 
00107     // Clear BTOW and BPRS arrays of pointers
00108     memset(mBarrelEmcTower, 0, sizeof(mBarrelEmcTower));
00109     memset(mBarrelEmcPreshower, 0, sizeof(mBarrelEmcPreshower));
00110     
00111     // Clear BSMDE and BSMDP maps
00112     mBarrelSmdEtaStrip.clear();
00113     mBarrelSmdPhiStrip.clear();
00114     
00115 }
00116 
00118 //                  Maker Make                  //
00120 Int_t StGammaRawMaker::Make()
00121 {
00122 
00123     mMuDstMaker = dynamic_cast<StMuDstMaker*>(GetMakerInheritsFrom("StMuDstMaker"));
00124     if(!mMuDstMaker)
00125     {
00126         LOG_WARN << "Make - No MuDst found!" << endm;
00127         return kStWarn;
00128     }
00129 
00130     // Retrieve StGammaEventMaker from the chain
00131     mGammaEvent = 0;
00132     
00133     if(!GetMaker("mGammaEventMaker")) 
00134     {
00135         LOG_WARN << "StGammaEventMaker not in chain, no tree for you" << endm;
00136         return kStWarn;
00137     }
00138     else 
00139     {
00140         StGammaEventMaker *mGammaEventMaker = dynamic_cast<StGammaEventMaker*>(GetMakerInheritsFrom("StGammaEventMaker"));
00141         mGammaEvent = mGammaEventMaker->event();
00142     }
00143     
00144     // Retrieve MuDst
00145     if(!GetDataSet("MuDst")) 
00146     {
00147         LOG_WARN << "No MuDst" << endm;
00148         return kStWarn;
00149     }
00150     
00151     // Skip events without a reconstructed vertex
00152     if(!StMuDst::numberOfPrimaryVertices() ) return kStOK;
00153 
00154     GetTracks();
00155     if(mUseBemc) GetBarrel();
00156     if(mUseEemc) GetEndcap();
00157 
00158     return kStOk;
00159     
00160 }
00161 
00163 //    Retrieve (primary) track information      //
00165 void StGammaRawMaker::GetTracks()
00166 { 
00167 
00168     // Retrieve MuDst
00169     if(!GetDataSet("MuDst")) 
00170     {
00171         LOG_WARN << "No MuDst" << endm;
00172         return;
00173     }
00174 
00175     // Loop over primary tracks and store in StGammaEvent
00176     
00177     //TIter next(StMuDst::globalTracks()); // do we want global tracks here?????
00178     TIter next(StMuDst::primaryTracks());
00179     
00180     while(StMuTrack* track = (StMuTrack*)next()) 
00181     {
00182     
00183         if(track->momentum().perp() < mTrackCutoff) continue;
00184     
00185         if(Accept(track)) 
00186         {
00187             StGammaTrack *mGammaTrack = mGammaEvent->newTrack(track);
00188             mTracks.push_back(*mGammaTrack);
00189         }
00190         
00191     }
00192 
00193 }
00194 
00196 //       Retrieve BEMC tower, preshower,        //
00197 //             and SMD information              //
00199 void StGammaRawMaker::GetBarrel()
00200 {
00201 
00202     // Load status tables
00203     mTables->loadTables(this);
00204     
00205     // Retrieve BEMC detector collection 
00206     // Retrieve MuDst
00207     if(!GetDataSet("MuDst")) 
00208     {
00209         LOG_WARN << "No MuDst" << endm;
00210         return;
00211     }
00212     
00213     StEmcCollection *emc = 0;
00214     
00215     StEvent *event = dynamic_cast<StEvent*>( GetInputDS("StEvent") );
00216     emc = event ? event->emcCollection() : StMuDst::emcCollection();
00217     if(!emc) return;
00218     
00219     StEmcDetector* btow = emc->detector(kBarrelEmcTowerId);     // BTOW
00220     StEmcDetector* bprs = emc->detector(kBarrelEmcPreShowerId); // BPRS
00221     StEmcDetector* smde = emc->detector(kBarrelSmdEtaStripId);  // SMDE
00222     StEmcDetector* smdp = emc->detector(kBarrelSmdPhiStripId);  // SMDP
00223     
00224     // Check for corruption in the detectors
00225     mCorrupt = false;
00226 
00227     // StEmcDetector == NULL implies corruption for pre-October 2004 BEMC code
00228     if(!btow) 
00229     {
00230         mCorrupt = true;
00231         return;
00232     }
00233   
00234     // Check for corruption in post-October 2004 BEMC code
00235     // Crate corruption key: 
00236     //     crateUnknown = 0
00237     //     crateNotPresent = 1
00238     //     crateOK = 2
00239     //     crateHeaderCorrupt = 3
00240     for(int crate = 1; crate <= MAXCRATES; crate++) 
00241     {
00242         StEmcCrateStatus crateStatus = btow->crateStatus(crate);
00243         if(crateStatus == crateHeaderCorrupt) 
00244         {
00245             mCorrupt = true;
00246             return;
00247         }
00248     }
00249   
00250     /*
00251     //And now we can implement Alex's new StEmcAdc2EMaker test
00252     StEmcADCtoEMaker *adc2e = dynamic_cast<StGammaEventMaker*>GetMakerInheritsFrom("StEmcADCtoEMaker");
00253     if(adc2e)
00254     {
00255         mCorrupt = adc2e->isCorrupted();
00256         if(mCorrupt == true) return;
00257     }
00258     else
00259     {
00260         LOG_DEBUG << "GetBarrel() - StEmcADCtoEMaker not found in chain" << endl;
00261     }
00262     */
00263         
00264 
00265     // Instantiate Variables
00266     float pedestal;
00267     float rms;
00268     float bEta;
00269     float bPhi;
00270     int CAP=0; //this argument matters only for SMD
00271 
00272 
00273     // Loop over BEMC modules to access tower and preshower information
00274     for(int m = 1; m <= 120; m++) 
00275     { 
00276     
00277         // Retrieve tower information if the collection exists
00278         if(btow)
00279         {
00280             
00281             StEmcGeom *geom = StEmcGeom::instance("bemc"); 
00282             StEmcModule *module = btow->module(m);
00283             
00284             StSPtrVecEmcRawHit& rawHits = module->hits();
00285             
00286             //loop on hits in modules
00287             for(UInt_t k = 0; k < rawHits.size(); k++) 
00288             {
00289             
00290                 StEmcRawHit* tempRawHit = rawHits[k];
00291                 
00292                 int id = tempRawHit->softId(BTOW);
00293  
00294                 // Ignore excluded towers
00295                 bool excludedTower = false;
00296 
00297                 for(UInt_t i = 0; i < mExcludedBemcTowers.size(); ++i)
00298                 {
00299                     if(id == mExcludedBemcTowers.at(i)) excludedTower = true;
00300                 }
00301 
00302                 if(excludedTower)
00303                 {
00304                     LOG_DEBUG << " Excluding tower "<< id << endm;
00305                     continue;
00306                 }
00307 
00308                 int status;
00309                 int ADC = tempRawHit->adc(); //not pedestal subtracted!
00310                 double energy = tempRawHit->energy();
00311                 float x, y, z;
00312                 geom->getXYZ(id, x, y, z);
00313                 TVector3 position(x, y, z);
00314                 position -= TVector3(StMuDst::event()->primaryVertexPosition().xyz());
00315                 bEta = position.Eta();
00316                 bPhi = position.Phi();
00317                 mTables->getStatus(BTOW, id, status);
00318                 mTables->getPedestal(BTOW, id, CAP, pedestal, rms);
00319 
00320                 // Require signal significantly above pedestal
00321                 if(ADC < 7) continue;
00322                 double pADC = ADC - pedestal;
00323                 if(pADC < 5.0 * rms) continue;  
00324  
00325                 // Vary energy per gain shift
00326                 energy = (1.0 + mBemcGainShift) * energy;
00327                 
00328                 // min pT cut next
00329                 if ( energy / TMath::CosH(bEta) < mTowerCutoff ) continue;
00330         
00331                 StGammaTower *btower = mGammaEvent->newTower();
00332                 
00333                 btower->id     = id;
00334                 btower->layer  = kBEmcTower;
00335                 btower->stat   = status;
00336                 btower->fail   = (int)(status != 1);
00337                 btower->energy = energy;
00338                 btower->eta    = bEta;
00339                 btower->phi    = bPhi;
00340 
00341                 LOG_DEBUG << " TowerID =" << id << ", Status = " << status << ", Energy = " << energy << endm;
00342                 LOG_DEBUG << " Eta = " << bEta << ", Phi = " << bPhi << ", ADC = " << ADC << endm;
00343 
00344 
00345                 mTowers.push_back(*btower);
00346                 mBarrelEmcTower[btower->id] = btower;
00347                 
00348             }
00349             
00350         }
00351     
00352         // Retrieve preshower information if the collection exists
00353         if(bprs)
00354         {
00355         
00356             StEmcGeom* geom = StEmcGeom::instance("bprs"); 
00357             StEmcModule* module = bprs->module(m);
00358             StSPtrVecEmcRawHit& rawHits=module->hits();
00359             
00360             // Loop over hits
00361             for(UInt_t k = 0; k < rawHits.size(); k++) 
00362             {
00363             
00364                 StEmcRawHit* tempRawHit = rawHits[k];
00365                 int id, bprs_status;
00366                 int ADC = tempRawHit->adc();
00367                 double energy = tempRawHit->energy();
00368                 id = tempRawHit->softId(BPRS);
00369                 float x, y, z;
00370                 geom->getXYZ(id,x,y,z);
00371                 TVector3 position(x, y, z);
00372                 position -= TVector3(StMuDst::event()->primaryVertexPosition().xyz());
00373                 bEta = position.Eta();
00374                 bPhi = position.Phi();
00375                 mTables->getStatus(BPRS, id, bprs_status);
00376                 mTables->getPedestal(BPRS, id, CAP, pedestal, rms);
00377 
00378                 // Require signal significantly above pedestal
00379                 if(ADC < 15) continue;
00380                 double pADC = ADC-pedestal;
00381                 if ( pADC < 5.0 * rms ) continue;
00382                 
00383                 StGammaTower *mPreShower = mGammaEvent->newPreshower1();
00384             
00385                 mPreShower->id     = id;
00386                 mPreShower->layer  = kBEmcPres;
00387                 mPreShower->stat   = bprs_status;
00388                 mPreShower->fail   = (int)(bprs_status != 1);
00389                 mPreShower->energy = energy;
00390                 mPreShower->eta    = bEta;
00391                 mPreShower->phi    = bPhi;
00392 
00393                     LOG_DEBUG << " BPRS ID =" << id << ", Status = " << bprs_status << ", Energy = " << energy << endm;
00394                 LOG_DEBUG << " Eta = " << bEta << ", Phi = " << bPhi << ", ADC = " << ADC << endm;
00395 
00396                 mPreshower1.push_back(*mPreShower);
00397 
00398             }
00399             
00400         }  
00401 
00402     } // Modules
00403   
00404     // Retrieve SMDE information if the collection exists
00405     if(smde) 
00406     {
00407     
00408         StEmcGeom* geom = StEmcGeom::instance("bsmde");
00409         
00410         for (UInt_t i = 1; i <= smde->numberOfModules(); i++) 
00411         {
00412         
00413             StEmcModule* module = smde->module(i);
00414             if (module) 
00415             {
00416             
00417                 StSPtrVecEmcRawHit& hits = module->hits();
00418                 
00419                 for (size_t k = 0; k < hits.size(); ++k) 
00420                 {
00421                 
00422                     StEmcRawHit* hit = hits[k];
00423                     Int_t smde_id = hit->softId(BSMDE);
00424 
00425                     Int_t smde_status = 0;
00426                     mTables->getStatus(BSMDE,smde_id,smde_status);
00427                     mTables->getPedestal(BSMDE, smde_id, hit->calibrationType(), pedestal, rms); 
00428 
00429                     Float_t eta = -999;
00430                     geom->getEta(smde_id,eta);
00431                     
00432                     // Remove strips too close to pedestal 
00433                     if( (hit->adc() - pedestal) < 3.0 * rms) continue;
00434 
00435                     StGammaStrip *bstrip = mGammaEvent->newStrip();
00436                     
00437                     bstrip->index = smde_id;
00438                     bstrip->sector = hit->module();
00439                     bstrip->plane  = kBEmcSmdEta;
00440                     bstrip->stat   = smde_status;
00441                     bstrip->fail   = (int)(smde_status != 1);
00442                     bstrip->energy = hit->energy();
00443                     bstrip->adc    = hit->adc();
00444                     bstrip->position = 230.705 * sinh(eta);
00445 
00446                     double offset = fabs(eta) < 0.5 ? 0.73 : 0.94;
00447                 
00448                     bstrip->right = bstrip->position + offset;
00449                     bstrip->left = bstrip->position - offset;
00450 
00451                     LOG_DEBUG << " eStrip ID =" << smde_id << ", Status = " << smde_status << endm;
00452                     LOG_DEBUG << " Energy = " << hit->energy() << ", Module = " << hit->module() << endm;
00453 
00454                     mStrips.push_back(*bstrip);
00455                     mBarrelSmdEtaStrip[bstrip->index] = bstrip;
00456                     
00457                    } // Hits
00458 
00459             } // if(module)
00460             
00461         } // Modules
00462     
00463     } // if(smde)
00464 
00465     // Retrieve SMDP information if the collection exists
00466     if(smdp) 
00467     {
00468     
00469         StEmcGeom* geom = StEmcGeom::instance("bsmdp");
00470         
00471         for (UInt_t i = 1; i <= smdp->numberOfModules(); i++) 
00472         {
00473     
00474             StEmcModule* module = smdp->module(i);
00475             if(module) 
00476             {
00477             
00478                 StSPtrVecEmcRawHit& hits = module->hits();
00479                 for (size_t k = 0; k < hits.size(); ++k) 
00480                 {
00481                 
00482                     StEmcRawHit* hit = hits[k];
00483                     Int_t smdp_id = hit->softId(BSMDP);
00484 
00485                     Int_t smdp_status = 0;
00486                     mTables->getStatus(BSMDP,smdp_id,smdp_status);
00487                     mTables->getPedestal(BSMDP, smdp_id, hit->calibrationType(), pedestal, rms);
00488 
00489                     Float_t phi = -999;
00490                     geom->getPhi(smdp_id,phi);
00491                     
00492                     // Remove strips too close to pedestal
00493                     if( (hit->adc() - pedestal) < 3.0 * rms) continue;
00494 
00495                     StGammaStrip *bstrip = mGammaEvent->newStrip();
00496                     
00497                     bstrip->index = smdp_id;
00498                     bstrip->sector = hit->module();
00499                     bstrip->plane  = kBEmcSmdPhi;
00500                     bstrip->stat   = smdp_status;
00501                     bstrip->fail   = (int)(smdp_status != 1);
00502                     bstrip->energy = hit->energy(); 
00503                     bstrip->adc    = hit->adc();
00504                     bstrip->position = phi;
00505 
00506                     double offset = 0.00293;
00507 
00508                     bstrip->left = phi - offset;
00509                     bstrip->right = phi + offset;
00510     
00511                     LOG_DEBUG << " pStrip ID =" << smdp_id << ", Status = " << smdp_status << endm;
00512                     LOG_DEBUG << " Energy = " << hit->energy() << ", Module = " << hit->module() << endm;
00513 
00514                     mStrips.push_back(*bstrip);
00515                     mBarrelSmdPhiStrip[bstrip->index] = bstrip;
00516                     
00517                 } // Hits
00518                   
00519             } // if(module)
00520         
00521         } // Modules
00522   
00523     } // if(smdp)
00524     
00525     return;
00526         
00527 }
00528 
00530 //       Retrieve BEMC tower, preshower,        //
00531 //       postshower, and SMD information        //
00533 void StGammaRawMaker::GetEndcap()
00534 {
00535 
00536 
00537     // Retrieve vertex information
00538     StMuPrimaryVertex *primaryVertex = mMuDstMaker->muDst()->primaryVertex();
00539     if(!primaryVertex) return; // we're going to need tracking, therefore vertex
00540     
00541     Float_t zvertex = primaryVertex->position().z();
00542     
00543     // Retrieve StEEmcA2eMaker
00544     StEEmcA2EMaker *adc2e = dynamic_cast<StEEmcA2EMaker*>(GetMakerInheritsFrom("StEEmcA2EMaker"));
00545     if (!adc2e)
00546     {
00547       LOG_WARN << "GetEndcap() - StEEmcA2EMaker not found!" << endm;
00548       return;
00549     }
00550 
00551     // Define depths for determining the momentum of each detector element
00552     const Float_t depths[] = 
00553     {
00554         kEEmcZSMD,   // Towers go to SMD depth
00555         kEEmcZPRE1,  // Pre/postshowers go to their own depth
00556         kEEmcZPRE2,
00557         kEEmcZPOST
00558     };
00559 
00560     Int_t enumerations[] = {kEEmcTower, kEEmcPre1, kEEmcPre2, kEEmcPost };
00561 
00562     // Loop over endcap layers
00563     for(Int_t layer = 0; layer < 4; layer++)
00564     {
00565     
00566         // Loop over hits in the current layer
00567         for (Int_t ihit = 0; ihit < adc2e->numberOfHitTowers(layer); ihit++)
00568         {
00569         
00570             StEEmcTower tower = adc2e->hittower(ihit, layer);     
00571             
00572             UInt_t sec = (UInt_t)tower.sector();
00573             UInt_t sub = (UInt_t)tower.subsector();
00574             UInt_t eta = (UInt_t)tower.etabin();
00575             
00576             TVector3 center = mEEmcGeometry->getTowerCenter(sec,sub,eta);
00577             Float_t  depth = depths[layer];
00578             center.SetMag( depth/center.CosTheta() );
00579 
00580             Float_t R        = center.Perp();
00581             Float_t Z        = depth-zvertex;
00582             Float_t TanTheta = R/Z;
00583             Float_t Phi      = center.Phi();
00584 
00585             TVector3 Momentum;
00586             Momentum.SetMagThetaPhi(tower.energy(), TMath::ATan(TanTheta), Phi );
00587             
00588             StGammaTower  *etower;
00589             
00590             if(layer == 0)       etower = mGammaEvent->newTower();
00591             else if (layer == 1) etower = mGammaEvent->newPreshower1();
00592             else if (layer == 2) etower = mGammaEvent->newPreshower2();
00593             else if (layer == 3) etower = mGammaEvent->newPostshower();
00594             
00595             etower->id     = tower.index();
00596             etower->layer  = enumerations[ tower.layer() ];
00597             etower->stat   = tower.stat();
00598             etower->fail   = tower.fail();
00599             etower->energy = tower.energy();
00600             etower->eta    = Momentum.Eta();
00601             etower->phi    = Momentum.Phi();
00602 
00603             if( Accept(*etower) ) 
00604             {
00605             
00606                 if(layer == 0) 
00607                 {
00608                 
00609                     if( etower->energy / TMath::CosH(etower->eta) > mTowerCutoff )
00610                     {
00611                         mTowers.push_back(*etower);
00612                         mEEtowers[ etower->id ][ etower->layer ] = etower;
00613                     }
00614                     
00615                 }
00616                 else if(layer == 1) 
00617                 {
00618                     mPreshower1.push_back(*etower);
00619                     mEEtowers[ etower->id ][ etower->layer ] = etower;
00620                 }
00621                 else if(layer == 2)
00622                 {
00623                     mPreshower2.push_back(*etower);
00624                     mEEtowers[ etower->id ][ etower->layer ] = etower;
00625                 }
00626                 else if(layer == 3)
00627                 {
00628                     mPostshower.push_back(*etower);
00629                     mEEtowers[ etower->id ][ etower->layer ] = etower;
00630                 }
00631                 else continue; 
00632                 
00633             } // if(Accept)
00634 
00635         } // Hits
00636     
00637     } // Layers
00638 
00639     // Loop over SMD strips
00640     Int_t smdenum[] = {kEEmcSmdu, kEEmcSmdv};
00641     
00642     for (Int_t sector = 0; sector < 12; sector++)
00643     {
00644     
00645         for(Int_t plane = 0; plane < 2; plane++)
00646         {
00647         
00648             for (Int_t ihit = 0; ihit < adc2e->numberOfHitStrips(sector, plane); ihit++)
00649             {
00650             
00651                 StEEmcStrip strip = adc2e->hitstrip(sector, plane, ihit);
00652                 
00653                 StGammaStrip *gstrip = mGammaEvent->newStrip();
00654                 gstrip->index = strip.index();
00655                 gstrip->sector = strip.sector();
00656                 gstrip->plane  = smdenum[ strip.plane() ];
00657                 gstrip->stat   = strip.stat();
00658                 gstrip->fail   = strip.fail();
00659                 gstrip->energy = strip.energy();
00660                 
00661                 mEEstrips[ gstrip->sector ][ gstrip->plane ][ gstrip->index ]= gstrip;
00662                 
00663                 if( Accept(*gstrip) )
00664                 {
00665                     mStrips.push_back(*gstrip);
00666                 }
00667         
00668             } // Hits
00669 
00670         } // Planes
00671         
00672     } // Sectors
00673 
00674 }
00675 
00677 //         Check StGammaTrack behavior          //
00679 Bool_t StGammaRawMaker::Accept(StGammaTrack &track)
00680 {
00681     return true;
00682 }
00683 
00685 //         Check StGammaTower behavior          //
00687 Bool_t StGammaRawMaker::Accept( StGammaTower &tower )
00688 {
00689 
00690   if(tower.fail) return false;
00691 
00692   return true;
00693   
00694 }
00695 
00697 //         Check StGammaStrip behavior          //
00699 Bool_t StGammaRawMaker::Accept( StGammaStrip &strip )
00700 {
00701 
00702   if(strip.fail) return false;
00703 
00704   return true;
00705     
00706 }
00707 
00709 //           Check StMuTrack behavior           //
00711 Bool_t StGammaRawMaker::Accept( StMuTrack* track )
00712 {
00713 
00714     return (track->flag() > 0        && // Good fit
00715             track->flag() / 100 != 7 && // FTPC only
00716             track->flag() / 100 != 8 && // FTPC+primary vertex
00717             track->flag() / 100 != 9 && // Beam background
00718             (double)track->nHitsFit() / (double)track->nHitsPoss() > 0.51 );
00719           
00720 }
00721 
00722 
00724 //         Return pointer to tower with         //
00725 //             given id and layer               //
00726 //                                              //
00727 //   0 - Endcap Tower                           //
00728 //   1 - Endcap Preshower 1                     //
00729 //   2 - Endcap Preshower 2                     //
00730 //   3 - Endcap Postshower                      //
00731 //                                              //
00732 //  10 - Barrel Tower                           //
00733 //  11 - Barrel Preshower                       //
00734 //                                              //
00736 StGammaTower *StGammaRawMaker::tower(Int_t id, Int_t layer)
00737 {
00738 
00739     if (layer >= kEEmcTower && layer <= kEEmcPost)
00740     {
00741         return mEEtowers[id][layer];
00742     }
00743     else if(layer == kBEmcTower)
00744     {
00745         return mBarrelEmcTower[id];
00746     }
00747     else if(layer == kBEmcPres)
00748     {
00749         return mBarrelEmcPreshower[id];
00750     }
00751     
00752     return 0;
00753   
00754 }
00755 
00757 //         Return pointer to strip with         //
00758 //        given sector, plane, and index        //
00759 //                                              //
00760 //   Plane:                                     //
00761 //   1 - ESMD U Plane                           //
00762 //   2 - ESMD V Plane                           //
00763 //                                              //
00764 //  10 - BSMD Eta Plane                         //
00765 //  11 - BSMD Phi Plane                         //
00766 //                                              //
00768 StGammaStrip *StGammaRawMaker::strip(Int_t sec, Int_t plane, Int_t index)
00769 {
00770 
00771     if(plane == kEEmcSmdu || plane == kEEmcSmdv)
00772     {
00773         return mEEstrips[sec][plane][index];
00774     }
00775     else if(plane == kBEmcSmdEta)
00776     {
00777         return mBarrelSmdEtaStrip[index];
00778     }
00779     else if(plane == kBEmcSmdPhi)
00780     {
00781         return mBarrelSmdPhiStrip[index];
00782     }
00783     
00784     return 0;
00785   
00786 }
00787 
00789 //      Add eta strip from external source      //
00791 void StGammaRawMaker::AddEtaStrip(StGammaStrip *strip)
00792 {
00793 
00794     int smdStatus = 0;
00795 
00796     mTables->getStatus(BSMDE, strip->index, smdStatus);
00797 
00798     strip->stat   = smdStatus;
00799     strip->fail   = (int)(smdStatus != 1);
00800 
00801     mStrips.push_back(*strip);
00802     mBarrelSmdEtaStrip[strip->index] = strip;
00803 
00804     return;
00805 
00806 }
00807 
00809 //      Add eta strip from external source      //
00811 void StGammaRawMaker::AddPhiStrip(StGammaStrip *strip)
00812 {
00813 
00814     int smdStatus = 0;
00815     
00816     mTables->getStatus(BSMDP, strip->index, smdStatus);
00817     
00818     strip->stat   = smdStatus;
00819     strip->fail   = (int)(smdStatus != 1);
00820  
00821     mStrips.push_back(*strip);
00822     mBarrelSmdPhiStrip[strip->index] = strip;
00823 
00824     return;
00825 
00826 }