StRoot: StMiniMcEvent/StMiniMcEvent.cxx Source File

00001 //
00002 // $Id: StMiniMcEvent.cxx,v 1.9 2012/03/15 23:37:20 perev Exp $
00003 //
00004 
00005 #include "StMiniMcEvent.h"
00006 #include "StContamPair.h"
00007 
00008 #include "Stiostream.h"
00009 
00010 Int_t StMiniMcEvent::mSFirst=1; 
00011 ClassImp(StMiniMcEvent)
00012 
00013 //___________________
00014 
00015 StMiniMcEvent::StMiniMcEvent() :
00016     mEventId(0),
00017     mRunId(0),
00018     mOriginMult(0),
00019     mCentralMult(0),
00020     mCentrality(0),
00021     mNUncorrectedNegativePrimaries(0),
00022     mNUncorrectedPrimaries(0),
00023     mNUncorrectedGlobals(0),
00024     mNFtpcWUncorrectedPrimaries(0),
00025     mNFtpcEUncorrectedPrimaries(0),
00026     mMcMult(0),
00027     mNMcNch(0),      
00028     mNMcFtpcWNch(0),
00029     mNMcFtpcENch(0),
00030     mNMcHminus(0),
00031     mNMcGlobal(0),
00032     mNMcGoodGlobal20(0),
00033     mNRcGlobal(0),
00034     mNRcGoodGlobal20(0),
00035     mVertexX(999),
00036     mVertexY(999),
00037     mVertexZ(999),
00038     mMcVertexX(999),
00039     mMcVertexY(999),
00040     mMcVertexZ(999),
00041     mMagField(0),
00042     mCenterOfMassEnergy(0),
00043     mBackgroundRate(0),
00044     mBeamMassNumberEast(0),
00045     mBeamMassNumberWest(0),
00046     mCtb(0),
00047     mZdcE(0),
00048     mZdcW(0),
00049     mNMcTrack(0),
00050     mNMatchedPair(0),
00051     mNMergedPair(0),
00052     mNSplitPair(0),
00053     mNGhostPair(0),
00054     mNContamPair(0),
00055     mNMatGlobPair(0)
00056 {
00057   cout << "###StMiniMcEvent::StMiniMcEvent()" << endl;
00058   //
00059   // TClonesArray only created on the heap
00060   // the first time a StMiniMcEvent object is constructed
00061   //
00062   
00063   //
00064   // initialize the size of the track array
00065   //
00066   const Int_t nMcTrack     = 6000;
00067   const Int_t nMatchedPair = 6000;
00068   const Int_t nMergedPair  = 500;
00069   const Int_t nSplitPair   = 500;
00070   const Int_t nGhostPair   = 500;
00071   const Int_t nContamPair  = 500;
00072   const Int_t nMatGlobPair = 6000;
00073   if(mSFirst){ 
00074     cout << "\tCreating the clones arrays" << endl;
00075     mSFirst = 0; // flag so we dont create any more arrays;
00076   }
00077   mMcTracks     = new TClonesArray("StTinyMcTrack",nMcTrack);
00078   mMatchedPairs = new TClonesArray("StMiniMcPair",nMatchedPair);
00079   mMergedPairs  = new TClonesArray("StMiniMcPair",nMergedPair);
00080   mSplitPairs   = new TClonesArray("StMiniMcPair",nSplitPair);
00081   
00082   mGhostPairs   = new TClonesArray("StMiniMcPair",nGhostPair);
00083   mContamPairs  = new TClonesArray("StContamPair",nContamPair); 
00084   mMatGlobPairs = new TClonesArray("StMiniMcPair",nMatGlobPair);
00085   memset (mVertexCovMatrix, 0, 6*sizeof(Float_t));
00086 }
00087 
00088 //__________________
00089 
00090 StMiniMcEvent::~StMiniMcEvent()
00091 {
00092 }
00093 
00094 //_________________
00095 
00096 
00097 StTinyMcTrack *StMiniMcEvent::addMcTrack(StTinyMcTrack* trk)
00098 {
00099   TClonesArray &tracks = *mMcTracks;
00100   if (trk) 
00101     return new(tracks[mNMcTrack++]) StTinyMcTrack(*trk);
00102   else 
00103     return new(tracks[mNMcTrack++]) StTinyMcTrack();
00104 }
00105 //________________________________________________________________________________
00106 StContamPair *StMiniMcEvent::addContamPair(StContamPair* trk)
00107 {
00108   TClonesArray &tracks = *mContamPairs;
00109   if (trk) 
00110     return new(tracks[mNContamPair++]) StContamPair(*trk);
00111   else 
00112     return new(tracks[mNContamPair++]) StContamPair();
00113 }
00114 
00115 //________________
00116 
00117 StMiniMcPair* StMiniMcEvent::addTrackPair(StMiniMcPair* pair,Category category)
00118 {
00119   TClonesArray *tracks;
00120   Int_t *nPair;
00121 
00122   // special case for contamination pairs (make it a new function?)
00123   // downcast..
00124   //
00125   switch(category){
00126 
00127   case MATCHED:
00128     tracks = mMatchedPairs; nPair = &mNMatchedPair;
00129     break;
00130   case MERGED:
00131     tracks = mMergedPairs;  nPair = &mNMergedPair;
00132     break;
00133   case SPLIT:
00134     tracks = mSplitPairs;   nPair = &mNSplitPair;
00135     break;
00136   case GHOST:
00137     tracks = mGhostPairs;  nPair = &mNGhostPair;
00138     break;  
00139   case MATGLOB:
00140     tracks = mMatGlobPairs; nPair = &mNMatGlobPair;
00141     break;
00142   default:
00143     Fatal("StMiniMcEvent", "WRONG CATEGORY  IN StMiniMcEvent::addPair()");
00144 //    std::exit(-1);
00145     break;
00146   }
00147 
00148   if (pair) 
00149     return new((*tracks)[(*nPair)++]) StMiniMcPair(*pair);
00150   else 
00151     return new((*tracks)[(*nPair)++]) StMiniMcPair();
00152 }
00153 
00154 #if 0
00155 TClonesArray* 
00156 StMiniMcEvent::tracks(Category category)
00157 {
00158   switch(category){
00159   case MC:
00160     return mMcTracks; 
00161   case MATCHED:
00162     return mMatchedPairs;
00163   case MERGED:
00164     return mMergedPairs;
00165   case SPLIT:
00166     return mSplitPairs;
00167   case GHOST:
00168     return mGhostPairs;
00169   case CONTAM:
00170     return mContamPairs;
00171   case MATGLOB:
00172     return mMatGlobPairs;
00173   default:
00174     cout << "****WRONG CATEGORY****"<< endl
00175          << "StMiniMcEvent::tracks()" << endl;
00176     return 0;
00177   }
00178 
00179 }
00180 #endif
00181 TClonesArray* 
00182 StMiniMcEvent::tracks(Category category) const
00183 {
00184   switch(category){
00185   case MC:
00186     return mMcTracks; 
00187   case MATCHED:
00188     return mMatchedPairs;
00189   case MERGED:
00190     return mMergedPairs;
00191   case SPLIT:
00192     return mSplitPairs;
00193   case GHOST:
00194     return mGhostPairs;
00195   case CONTAM:
00196     return mContamPairs;
00197   case MATGLOB:
00198     return mMatGlobPairs;
00199   default:
00200     cout << "****WRONG CATEGORY****"<< endl
00201          << "StMiniMcEvent::tracks()" << endl;
00202     return 0;
00203   }
00204 
00205 }
00206 
00207 //_________________
00208 //
00209 // clear all the track arrays for the next event
00210 //
00211 
00212 void
00213 StMiniMcEvent::Clear(Option_t *option)
00214 {
00215   mMcTracks->Clear(); 
00216   mMatchedPairs->Clear();
00217   mMergedPairs->Clear();
00218   mSplitPairs->Clear();
00219   mGhostPairs->Clear();
00220   mContamPairs->Clear();
00221   mMatGlobPairs->Clear();
00222   
00223   mNMcTrack = mNMatchedPair = mNMergedPair = mNSplitPair 
00224             = mNGhostPair   = mNContamPair = mNMatGlobPair = 0;
00225   
00226 }
00227 #define PrMinMc(A) cout << #A":" << m ## A << "\t"
00228 //________________________________________________________________________________
00229 void StMiniMcEvent::Print(Option_t *option) const {
00230   cout << "StMiniMcEvent\t";  PrMinMc(RunId);PrMinMc(EventId);
00231   PrMinMc(OriginMult);  // StEvent::primaryVertex(0)->numberOfDaughters()
00232   PrMinMc(CentralMult); // reco, primary trk, flag>0, |eta|<0.75 
00233   PrMinMc(Centrality);  // centrality bin, Nch cuts, P02gd, 2k2
00234   cout << endl;
00235   PrMinMc(NUncorrectedNegativePrimaries); // from StuRefMult
00236   PrMinMc(NUncorrectedPrimaries); // from StuRefMult
00237   PrMinMc(NFtpcWUncorrectedPrimaries); // reco, primaries, flag>0, glTrk->helix->dist(vtx)<3, prim.pt<3, gl.fitPts>=5, 2.8 < eta < 3.8
00238   PrMinMc(NFtpcEUncorrectedPrimaries); // reco, primaries, flag>0, glTrk->helix->dist(vtx)<3, prim.pt<3, gl.fitPts>=5,-2.8 > eta >-3.8
00239   cout << endl;
00240   PrMinMc(McMult);      // embedding: n mc tracks; (StMcEvent::numberOfPrimaryTracks()  simulation: same as mOriginMult 
00241   PrMinMc(NMcNch);      // mc, primary, charge!=0, |eta|<0.5
00242   PrMinMc(NMcFtpcWNch); // mc, primary, charge!=0, 2.8 < eta < 3.8
00243   PrMinMc(NMcFtpcENch); // mc, primary, charge!=0,-2.8 > eta >-3.8
00244   PrMinMc(NMcHminus);   // mc, primary, charg  <0, |eta|<0.5
00245   cout << endl;
00246   PrMinMc(NMcGlobal);             // mc, primary, |eta|<4
00247   PrMinMc(NMcGoodGlobal20);     // mc, primary, |eta|<4, MC TPC hits >=20
00248 
00249   PrMinMc(NRcGlobal);           // reco, primaries flag > 0
00250   PrMinMc(NRcGoodGlobal20);     // reco, primaries flag > 0, 20 fit hits
00251   cout << endl;
00252   PrMinMc(McMult); PrMinMc(NMcNch); PrMinMc(NMcFtpcWNch); PrMinMc(NMcFtpcENch); PrMinMc(NMcHminus); cout << endl;
00253   PrMinMc(MagField); 
00254   cout << "Vertex X/Y/Z = " << mVertexX << "/" << mVertexY << "/" <<  mVertexZ
00255        << "\tMc Vertex X/Y/Z = " << mMcVertexX << "/" <<mMcVertexY << "/" <<mMcVertexZ << endl;
00256 
00257   PrMinMc(CenterOfMassEnergy);
00258   PrMinMc(BackgroundRate);
00259   PrMinMc(BeamMassNumberEast);
00260   PrMinMc(BeamMassNumberWest); cout << endl;
00261 
00262   PrMinMc(Ctb);
00263   PrMinMc(ZdcE);
00264   PrMinMc(ZdcW); cout << endl;
00265   PrMinMc(NMcTrack);     
00266   PrMinMc(NMatchedPair);
00267   PrMinMc(NMergedPair);
00268   PrMinMc(NSplitPair);
00269   PrMinMc(NGhostPair);
00270   PrMinMc(NContamPair);
00271   PrMinMc(NMatGlobPair); cout << endl;
00272   StTinyMcTrack *mctrak = 0;
00273   StMiniMcPair  *mcpair = 0;
00274   StTinyRcTrack *rctrak = 0;
00275   Category Kase[] = {MC,MATCHED,MERGED,SPLIT,CONTAM,GHOST,MATGLOB};
00276   for (Int_t K = MC; K <= MATGLOB; K++) {
00277     TClonesArray*  Tracks = ( TClonesArray* ) tracks(Kase[K]);
00278     Int_t N = Tracks->GetEntriesFast();
00279     for (int l = 0; l < N; l++) {
00280       switch (K) {
00281       case MC:
00282         mctrak  = (StTinyMcTrack *) Tracks->At(l);
00283         if (! l) {
00284           cout << "McTracks ====================================" << endl;
00285           mctrak->Print("desc");
00286         }
00287         mctrak->Print();
00288         break;
00289       default:
00290         mcpair  = (StMiniMcPair  *) Tracks->At(l);
00291         mctrak  = (StTinyMcTrack *) mcpair;
00292         rctrak  = (StTinyRcTrack *) mcpair;
00293         if (! l) {
00294           if (K == MATCHED)  cout << "MATCHED ======================" << endl;
00295           if (K == MERGED)   cout << "MERGED ======================" << endl;  
00296           if (K == SPLIT)    cout << "SPLIT ======================" << endl;   
00297           if (K == CONTAM)   cout << "CONTAM ======================" << endl;  
00298           if (K == GHOST)    cout << "GHOST ======================" << endl;   
00299           if (K == MATGLOB)  cout << "MATGLOB ======================" << endl;
00300           mctrak->Print("desc"); rctrak->Print("desc");
00301         }
00302         mctrak->Print("");  rctrak->Print();
00303         break;
00304       }
00305     }
00306   }
00307 }
00308 #undef PrMinMc
00309 //__________________
00310 //
00311 // $Log $
00312 //
00313 
00314