StRoot: StMuDSTMaker/COMMON/StMuDst.h Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StMuDst.h,v 1.42 2011/05/04 19:51:32 tone421 Exp $
00004  * Author: Frank Laue, BNL, laue@bnl.gov
00005  *
00006  ***************************************************************************/
00007 
00008 #ifndef StMuDst_h
00009 #define StMuDst_h
00010 
00011 #include "TObject.h"
00012 #include "TClonesArray.h"
00013 
00014 class StMuDstMaker;
00015 class StMuEvent;
00016 class StMuPrimaryVertex;
00017 class StMuTrack;
00018 class StRichSpectra;
00019 class StDetectorState;
00020 class StL3AlgorithmInfo;
00021 #ifndef __NO_STRANGE_MUDST__
00022 class StStrangeEvMuDst;
00023 class StV0MuDst;
00024 class StXiMuDst;
00025 class StKinkMuDst;
00026 class StV0Mc;
00027 class StXiMc;
00028 class StKinkMc;
00029 class StStrangeAssoc;
00030 class TCut;
00031 #endif
00032 class StMuEmcCollection;
00033 class StMuFmsCollection;
00034 class StMuPmdCollection;
00035 
00036 class StEvent;
00037 class StTriggerData;
00038 class StTrack;
00039 class StTrackGeometry;
00040 class StEmcCollection;
00041 class StFmsCollection;;
00042 
00043 class StMuTofHit;
00044 class StTofData;
00045 // run 5 - dongx
00046 class StTofRawData;
00047 // dongx
00048 class StBTofCollection;
00049 class StMuBTofHit;
00050 class StBTofRawHit;
00051 class StBTofHeader;
00052 
00053 class EztEventHeader;
00054 class EztTrigBlob;
00055 class EztFpdBlob;
00056 class EztEmcRawData;
00057 
00058 class StDcaGeometry;
00059 class StMuPrimaryTrackCovariance;
00060 
00061 class StMuRpsCollection;
00062 class StMuMtdCollection;
00063 
00064 
00065 #include "StPhysicalHelixD.hh"
00066 
00067 #include "TObject.h"
00068 #include "StMuArrays.h"
00069 #include "StMuException.hh"
00070 
00071 
00072 
00073 #define ARRAY(NAME)  static TClonesArray* (NAME)##s() { return tca_##NAME##s;}
00074 #define OBJECT(TYPE,FUNC) static TYPE FUNC##(unsigned int i=0) { if (FUNC##s() && (i<(unsigned int)FUNC##s()->GetEntries()) ) return (##TYPE##)FUNC##s()->UncheckedAt(i); return 0;}
00075 
00076 #define DO(TYPE,NAME) ARRAY(NAME)    OBJECT(TYPE,NAME)
00077 
00078 
00089 class StMuDst : public TObject {
00090 public:
00092   StMuDst(); 
00094   static void set(StMuDstMaker* maker);
00097     static void set(TClonesArray** /* Arrays */, 
00098 #ifndef __NO_STRANGE_MUDST__
00099                     TClonesArray** /* StrangeArrays */, 
00100 #endif
00101                     TClonesArray** mc_ptca=0, 
00102                     TClonesArray** emc_ptca=0, 
00103                     TClonesArray** fms_ptca=0, 
00104                     TClonesArray** pmd_ptca=0, 
00105                     TClonesArray** tof_ptca=0, 
00106                     TClonesArray** btof_ptca=0, 
00107                     TClonesArray *emc_tca=0, 
00108                     StMuEmcCollection *emc_col=0, 
00109                     StMuFmsCollection *fms_col=0, 
00110                     TClonesArray *pmd_tca=0, 
00111                     StMuPmdCollection *pmd_col=0, 
00112                     TClonesArray** ezt_ptca=0);
00114   static void setEmcCollection(StEmcCollection *emc_coll) { mEmcCollection=emc_coll; }
00115   
00116   static void setFmsCollection(StFmsCollection *fms_coll) { mFmsCollection=fms_coll; }
00117 
00119   static void unset();
00121   static void fixTrackIndices(TClonesArray* primary, TClonesArray* global);
00123   void fixTrackIndices();
00124   //fills gloabl track's mIndex2Global with the index to the respective primary track
00125   static void fixTrackIndicesG(int mult=1);
00127   StEvent* createStEvent();
00129   StTrackGeometry* trackGeometry(int q, StPhysicalHelixD* h);
00131   StTrack* createStTrack(StMuTrack*);
00133   static void fixTofTrackIndices(TClonesArray* btofHit, TClonesArray* primary, TClonesArray* global);
00135   void fixTofTrackIndices();
00136 
00137  protected:
00139   static TClonesArray** arrays;
00140 #ifndef __NO_STRANGE_MUDST__
00142   static TClonesArray** strangeArrays;
00143 #endif
00144   static TClonesArray** mcArrays;
00146   static TClonesArray** emcArrays;
00148   static TClonesArray** fmsArrays;
00150   static TClonesArray** pmdArrays;
00152   static TClonesArray** tofArrays;
00154   static TClonesArray** btofArrays;  
00155   // pointer to array with MuEmcCollection (for backward compatible mode)
00156   static TClonesArray *mMuEmcCollectionArray;
00158   static StMuEmcCollection *mMuEmcCollection;
00159   // pointer to array with MuPmdCollection (for backward compatible mode)
00160   static TClonesArray *mMuPmdCollectionArray;
00162   static StMuFmsCollection *mMuFmsCollection; 
00164   static StMuPmdCollection *mMuPmdCollection;
00166   static StEmcCollection *mEmcCollection;
00168   static StFmsCollection *mFmsCollection;
00170   static TClonesArray** eztArrays;
00171 
00173   static Int_t     mCurrVertexId;
00175   static TObjArray *mCurrPrimaryTracks;
00177   static void collectVertexTracks();
00178   
00179 public:
00181   static void setVertexIndex(Int_t vtx_id);
00183   static Int_t currentVertexIndex() {return mCurrVertexId; }
00185   static TClonesArray* array(int type) { return arrays[type]; }
00186 #ifndef __NO_STRANGE_MUDST__
00188   static TClonesArray* strangeArray(int type) { return strangeArrays[type]; }
00189 #endif
00190   static TClonesArray* mcArray(int type) { return mcArrays[type]; }
00192   static TClonesArray* emcArray(int type) { return emcArrays[type]; }
00194   static TClonesArray* fmsArray(int type) { return fmsArrays[type]; }
00196   static TClonesArray* pmdArray(int type) { return pmdArrays[type]; }
00198   static TClonesArray* tofArray(int type) { return tofArrays[type]; }
00200   static TClonesArray* btofArray(int type) { return btofArrays[type]; }
00202   static TClonesArray* eztArray(int type) { return eztArrays[type]; }
00203 
00205   static TClonesArray* primaryVertices() { return arrays[muPrimaryVertex]; }
00207   static TObjArray* primaryTracks() { return mCurrPrimaryTracks; } 
00209   static TObjArray* globalTracks() { return arrays[muGlobal]; }
00211   static TClonesArray* otherTracks() { return arrays[muOther]; }
00213   static TClonesArray* l3Tracks() { return arrays[muL3]; }
00215   static TClonesArray* richSpectra() { return arrays[muRich]; }
00217   static TClonesArray* detectorStates() { return arrays[muState]; }
00219   static TClonesArray* l3AlgoAccept() { return arrays[muAccept]; }
00221   static TClonesArray* l3AlgoReject() { return arrays[muReject]; }
00222   static TClonesArray* covGlobTrack() {return arrays[muCovGlobTrack];}
00223   static TClonesArray* covPrimTrack() {return arrays[muCovPrimTrack];}
00224 
00226   static StMuEvent* event() { return (StMuEvent*)arrays[muEvent]->UncheckedAt(0); }
00228   static StMuPrimaryVertex* primaryVertex() { return (StMuPrimaryVertex*)arrays[muPrimaryVertex]->UncheckedAt(mCurrVertexId); }
00230   static StMuPrimaryVertex* primaryVertex(int i) { return (StMuPrimaryVertex*)arrays[muPrimaryVertex]->UncheckedAt(i); }
00232   static StMuTrack* primaryTracks(int i) { return (StMuTrack*)mCurrPrimaryTracks->UncheckedAt(i); }
00234   static StMuTrack* globalTracks(int i) { return (StMuTrack*)arrays[muGlobal]->UncheckedAt(i); }
00236   static StMuTrack* otherTracks(int i) { return (StMuTrack*)arrays[muOther]->UncheckedAt(i); }
00238   static StMuTrack* l3Tracks(int i) { return (StMuTrack*)arrays[muL3]->UncheckedAt(i); }
00240   static StRichSpectra* richSpectra(int i) { return (StRichSpectra*)arrays[muRich]->UncheckedAt(i); }
00242   static StDetectorState* detectorStates(int i) { return (StDetectorState*)arrays[muState]->UncheckedAt(i); }
00244   static StL3AlgorithmInfo* l3AlgoAccept(int i) { return (StL3AlgorithmInfo*)arrays[muAccept]->UncheckedAt(i); }
00246   static StL3AlgorithmInfo* l3AlgoReject(int i) { return (StL3AlgorithmInfo*)arrays[muReject]->UncheckedAt(i); }
00247   //returns pp2pp infomation
00248   static StMuRpsCollection* RpsCollection() { return (StMuRpsCollection*)arrays[mupp2pp]->UncheckedAt(0); }
00249   static StMuMtdCollection* MtdCollection() { return (StMuMtdCollection*)arrays[muMtd]->UncheckedAt(0); }
00250 
00251         static StDcaGeometry* covGlobTracks(int i) { return (StDcaGeometry*)arrays[muCovGlobTrack]->UncheckedAt(i); }
00252   static StMuPrimaryTrackCovariance* covPrimTracks(int i) { return (StMuPrimaryTrackCovariance*)arrays[muCovPrimTrack]->UncheckedAt(i); }
00253  
00254 #ifndef __NO_STRANGE_MUDST__
00256   static StStrangeEvMuDst* strangeEvent() { return (StStrangeEvMuDst*)strangeArrays[smuEv]->UncheckedAt(0); }
00258   static StStrangeEvMuDst* strangeEventMc() { return (StStrangeEvMuDst*)strangeArrays[smuEvMc]->UncheckedAt(0); }
00260   static TClonesArray* v0s() { return strangeArrays[smuV0]; }
00262   static TClonesArray* v0sMc() { return strangeArrays[smuV0Mc]; }
00264   static TClonesArray* v0Assoc() { return strangeArrays[smuV0Assoc]; }
00266   static TClonesArray* xis() { return strangeArrays[smuXi]; }
00268   static TClonesArray* xisMc() { return strangeArrays[smuXiMc]; }
00270   static TClonesArray* xiAssoc() { return strangeArrays[smuXiAssoc]; }
00272   static TClonesArray* kinks() { return strangeArrays[smuKink]; }
00274   static TClonesArray* kinksMc() { return strangeArrays[smuKinkMc]; }
00276   static TClonesArray* kinkAssoc() { return strangeArrays[smuKinkAssoc]; }
00278   static TClonesArray* strangeCuts() { return strangeArrays[smuCut]; }
00280   static StV0MuDst* v0s(int i) { return (StV0MuDst*)strangeArrays[smuV0]->UncheckedAt(i); }
00281   static StV0Mc* v0sMc(int i) { return (StV0Mc*)strangeArrays[smuV0Mc]->UncheckedAt(i); }
00282   static StStrangeAssoc* v0Assoc(int i) { return (StStrangeAssoc*)strangeArrays[smuV0Assoc]->UncheckedAt(i); }
00284   static StXiMuDst* xis(int i) { return (StXiMuDst*)(void*)strangeArrays[smuXi]->UncheckedAt(i); }
00285   static StXiMc* xisMc(int i) { return (StXiMc*)strangeArrays[smuXiMc]->UncheckedAt(i); }
00286   static StStrangeAssoc* xiAssoc(int i) { return (StStrangeAssoc*)strangeArrays[smuXiAssoc]->UncheckedAt(i); }
00288   static StKinkMuDst* kinks(int i) { return (StKinkMuDst*)(void*)strangeArrays[smuKink]->UncheckedAt(i); }
00289   static StKinkMc* kinksMc(int i) { return (StKinkMc*)strangeArrays[smuKinkMc]->UncheckedAt(i); }
00290   static StStrangeAssoc* kinkAssoc(int i) { return (StStrangeAssoc*)strangeArrays[smuKinkAssoc]->UncheckedAt(i); }
00292   static TCut* strangeCuts(int i) { return (TCut*)strangeArrays[smuCut]->UncheckedAt(i); }
00293 #endif
00295   static StMuEmcCollection* muEmcCollection() { if (mMuEmcCollectionArray) return (StMuEmcCollection*) mMuEmcCollectionArray->UncheckedAt(0); else return mMuEmcCollection; }
00297   static StMuFmsCollection* muFmsCollection() { return mMuFmsCollection; }
00299   static StMuPmdCollection* pmdCollection() { if (mMuPmdCollectionArray)  return (StMuPmdCollection*) mMuPmdCollectionArray->UncheckedAt(0); else return mMuPmdCollection; }
00301   static StEmcCollection* emcCollection() {  return mEmcCollection; }
00303   static StFmsCollection* fmsCollection() {  return mFmsCollection; }
00304 
00306   static StMuTofHit* tofHit(int i) { return (StMuTofHit*)tofArrays[muTofHit]->UncheckedAt(i); }
00308   static StTofData* tofData(int i) { return (StTofData*)tofArrays[muTofData]->UncheckedAt(i); }
00309   // run 5 - dongx
00311   static StTofRawData* tofRawData(int i) { return (StTofRawData*)tofArrays[muTofRawData]->UncheckedAt(i); }
00313   static StMuBTofHit* btofHit(int i) { return (StMuBTofHit*)btofArrays[muBTofHit]->UncheckedAt(i); }
00315   static StBTofRawHit* btofRawHit(int i) { return (StBTofRawHit*)btofArrays[muBTofRawHit]->UncheckedAt(i); }
00317   static StBTofHeader* btofHeader() { return (StBTofHeader*)btofArrays[muBTofHeader]->UncheckedAt(0); }
00318 
00320   static  EztEventHeader* eztHeader() { return (EztEventHeader*)eztArrays[muEztHead]->UncheckedAt(0); }
00321 
00323   static  EztTrigBlob* eztTrig() 
00324         { return (EztTrigBlob*)eztArrays[muEztTrig]->UncheckedAt(0); }
00325 
00327   static  EztFpdBlob* eztFpd() 
00328         { return (EztFpdBlob*)eztArrays[muEztFpd]->UncheckedAt(0); }
00329 
00331   static  EztEmcRawData* eztETow() 
00332         { return (EztEmcRawData*)eztArrays[muEztETow]->UncheckedAt(0); }
00334   static  EztEmcRawData* eztESmd() 
00335         { return (EztEmcRawData*)eztArrays[muEztESmd]->UncheckedAt(0); }
00336 
00337   static unsigned int numberOfPrimaryVertices()  { return arrays[muPrimaryVertex]->GetEntries(); }
00338   static unsigned int numberOfPrimaryTracks()  { return mCurrPrimaryTracks->GetEntries(); }
00339   static unsigned int numberOfGlobalTracks()   { return arrays[muGlobal]->GetEntries(); }
00340   static unsigned int numberOfOtherTracks()    { return arrays[muOther]->GetEntries(); }
00341   static unsigned int numberOfL3Tracks()       { return arrays[muL3]->GetEntries(); }
00342   static unsigned int numberOfRichSpectras()   { return arrays[muRich]->GetEntries(); }
00343   static unsigned int numberOfDetectorStates() { return arrays[muState]->GetEntries(); }
00344   static unsigned int numberOfL3AlgoAccepts()  { return arrays[muAccept]->GetEntries(); }
00345   static unsigned int numberOfL3AlgoRejects()  { return arrays[muReject]->GetEntries(); }
00346   static unsigned int numberOfCovGlobTracks()  { return arrays[muCovGlobTrack]->GetEntries(); }
00347   static unsigned int numberOfCovPrimTracks()  { return arrays[muCovPrimTrack]->GetEntries(); }
00348 #ifndef __NO_STRANGE_MUDST__
00349   static unsigned int numberOfV0s()            { return strangeArrays[smuV0]->GetEntries(); }
00350   static unsigned int numberOfV0sMc()          { return strangeArrays[smuV0Mc]->GetEntries(); }
00351   static unsigned int numberOfV0Assoc()        { return strangeArrays[smuV0Assoc]->GetEntries(); }
00352   static unsigned int numberOfXis()            { return strangeArrays[smuXi]->GetEntries(); }
00353   static unsigned int numberOfXisMc()          { return strangeArrays[smuXiMc]->GetEntries(); }
00354   static unsigned int numberOfXiAssoc()        { return strangeArrays[smuXiAssoc]->GetEntries(); }  
00355   static unsigned int numberOfKinks()          { return strangeArrays[smuKink]->GetEntries(); }
00356   static unsigned int numberOfKinksMc()        { return strangeArrays[smuKinkMc]->GetEntries(); } 
00357   static unsigned int numberOfKinkAssoc()      { return strangeArrays[smuKinkAssoc]->GetEntries(); }
00358   static unsigned int numberOfStrangeCuts()    { return strangeArrays[smuCut]->GetEntries(); }
00359 #endif
00360   // tofr
00361   static unsigned int numberOfTofHit()        { return tofArrays[muTofHit]->GetEntries(); }
00362   static unsigned int numberOfTofData()       { return tofArrays[muTofData]->GetEntries(); }
00363   // run 5 - dongx
00364   static unsigned int numberOfTofRawData()    { return tofArrays[muTofRawData]->GetEntries(); }
00365   // dongx
00366   static unsigned int numberOfBTofHit()       { return btofArrays[muBTofHit]->GetEntries(); }
00367   static unsigned int numberOfBTofRawHit()    { return btofArrays[muBTofRawHit]->GetEntries(); }
00368 
00369   static unsigned int GetNPrimaryVertex()    { return numberOfPrimaryVertices(); }  
00370   static unsigned int GetNPrimaryTrack()    { return numberOfPrimaryTracks(); }  
00371   static unsigned int GetNGlobalTrack()     { return numberOfGlobalTracks(); }   
00372   static unsigned int GetNOtherTrack()      { return numberOfOtherTracks(); }    
00373   static unsigned int GetNL3Track()         { return numberOfL3Tracks(); }       
00374   static unsigned int GetNRichSpectra()     { return numberOfRichSpectras(); }   
00375   static unsigned int GetNDetectorState()   { return numberOfDetectorStates(); } 
00376   static unsigned int GetNL3AlgoAccept()    { return numberOfL3AlgoAccepts(); }  
00377   static unsigned int GetNL3AlgoReject()    { return numberOfL3AlgoRejects(); }  
00378 #ifndef __NO_STRANGE_MUDST__
00379   static unsigned int GetNV0()              { return numberOfV0s(); }            
00380   static unsigned int GetNV0Mc()            { return numberOfV0sMc(); }            
00381   static unsigned int GetNV0Assoc()         { return numberOfV0Assoc(); }            
00382   static unsigned int GetNXi()              { return numberOfXis(); }            
00383   static unsigned int GetNXiMc()            { return numberOfXisMc(); }            
00384   static unsigned int GetNXiAssoc()         { return numberOfXiAssoc(); }            
00385   static unsigned int GetNKink()            { return numberOfKinks(); }
00386   static unsigned int GetNKinkMc()          { return numberOfKinksMc(); }            
00387   static unsigned int GetNKinkAssoc()       { return numberOfKinkAssoc(); }            
00388   static unsigned int GetNStrangeCut()      { return numberOfStrangeCuts(); }    
00389 #endif
00390   static unsigned int GetNTofHit()          { return numberOfTofHit(); }
00391   static unsigned int GetNTofData()         { return numberOfTofData(); }
00392   // run 5 - dongx
00393   static unsigned int GetNTofRawData()      { return numberOfTofRawData(); }
00394   // dongx
00395   static unsigned int GetNBTofHit()         { return numberOfBTofHit(); }
00396   static unsigned int GetNBTofRawHit()      { return numberOfBTofRawHit(); }
00397 
00398   virtual void Print(Option_t *option = "") const; 
00399   static void printPrimaryTracks();
00400   static void printGlobalTracks() ;
00401   static void printVertices() ;
00402 
00403   friend class StMuDstMaker;
00404   friend class StMuIOMaker;
00405   ClassDef(StMuDst,0)
00406 };
00407 
00408 #endif
00409 
00410 /***************************************************************************
00411  *
00412  * $Log: StMuDst.h,v $
00413  * Revision 1.42  2011/05/04 19:51:32  tone421
00414  * Added MTD infomation
00415  *
00416  * Revision 1.41  2011/04/08 01:25:50  fisyak
00417  * Add branches for MC track and vertex information, add IdTruth to  tracks and vertices, reserve a possiblity to remove Strange MuDst
00418  *
00419  * Revision 1.40  2010/05/26 04:25:50  tone421
00420  * Added StTriggerData arrays in muevent and fixed an issue with PMD arrays being read....
00421  *
00422  * Revision 1.39  2010/03/08 19:06:51  tone421
00423  * Two things. Global tracks how are filled with an index to primary at birth. Added StMuDst::fixTrackIndicesG(), which is used for matching the primary track indices to global tracks. Previously, this was quite slow -  see this post:
00424  *
00425  * http://www.star.bnl.gov/HyperNews-star/protected/get/starsoft/8092/1/1/1.html
00426  *
00427  * for more details.
00428  *
00429  * Revision 1.38  2010/02/01 23:15:27  fine
00430  * replace non-static method
00431  *
00432  * Revision 1.37  2010/02/01 22:54:34  fine
00433  * replace non-static method
00434  *
00435  * Revision 1.36  2010/01/25 03:57:39  tone421
00436  * Added FMS and Roman pot arrays
00437  *
00438  * Revision 1.35  2009/08/28 14:55:55  tone421
00439  * Changed tofArrays to btofArrays returned objects in numberOfBTofHit() and numberOfBTofRawHit()
00440  *
00441  * Revision 1.34  2009/02/20 16:37:44  tone421
00442  * *** empty log message ***
00443  *
00444  * Revision 1.32  2008/03/19 14:51:03  fisyak
00445  * Add two clone arrays for global and primary track covariance matrices, remove mSigmaDcaD and mSigmaDcaZ
00446  *
00447  * Revision 1.31  2007/09/18 02:29:58  mvl
00448  * Added basic printing functionality. For convenience and to assist data consistency checks
00449  *
00450  * Revision 1.30  2005/08/22 17:29:12  mvl
00451  * Made setVertexId static, changed globalTracks() to return
00452  * TObjArray* (for similarity to primaryTracks.h)
00453  * and added primaryVertex() to return current vertex
00454  *
00455  * Revision 1.29  2005/08/19 19:46:05  mvl
00456  * Further updates for multiple vertices. The main changes are:
00457  * 1) StMudst::primaryTracks() now returns a list (TObjArray*) of tracks
00458  *    belonging to the 'current' primary vertex. The index number of the
00459  *    'current' vertex can be set using StMuDst::setCurrentVertex().
00460  *    This also affects StMuDst::primaryTracks(int i) and
00461  *    StMuDst::numberOfprimaryTracks().
00462  * 2) refMult is now stored for all vertices, in StMuPrimaryVertex. The
00463  *    obvious way to access these numbers is from the StMuprimaryVertex structures,
00464  *    but for ebakcward compatibility a function is provided in StMuEvent as well
00465  *    (this is the only function taht works for existing MuDst)
00466  *
00467  * As an aside, I've also changes the internals of StMuDst::createStEvent and
00468  * StMuDst::fixTrackIndices() to be able to deal with a larger range of index numbers for tracks as generated by Ittf.
00469  *
00470  * BIG FAT WARNING: StMudst2StEventMaker and StMuDstFilterMaker
00471  * do not fully support the multiple vertex functionality yet.
00472  *
00473  * Revision 1.28  2005/07/15 21:45:08  mvl
00474  * Added support for multiple primary vertices (StMuPrimaryVertex). Track Dcas are now calculated with repect to the first vertex in the list (highest rank), but another vertex number can be specified. Tarcks also store the index of the vertex they belong to (StMuTrack::vertexIndex())
00475  *
00476  * Revision 1.27  2005/07/06 21:40:18  fisyak
00477  * use template version of StPhysicalHelixD
00478  *
00479  * Revision 1.26  2005/04/12 21:56:29  mvl
00480  * Changes by Xin Dong for year-5 TOF data format: extra TClonesArray and routines to fill it from StEvent (StTofRawData).
00481  *
00482  * Revision 1.25  2004/11/29 15:53:22  mvl
00483  * Additions by Jan for Fpd ezTree
00484  *
00485  * Revision 1.24  2004/10/29 20:18:18  jeromel
00486  * Proto arg name must not be repeated
00487  *
00488  * Revision 1.23  2004/10/28 00:11:33  mvl
00489  * Added stuff to support ezTree mode of MuDstMaker.
00490  * This is a special mode for fast-online processing of fast-detector data.
00491  *
00492  * Revision 1.22  2004/10/21 02:56:35  mvl
00493  * Added pointer to StEmcColleciton for Emc clustering etc.
00494  * Also made some technical changes for backward compatibility mode with
00495  * StMuIOMaker (pointers to TClonesArray for StMuEmcCollection)
00496  *
00497  * Revision 1.21  2004/10/19 01:45:26  mvl
00498  * Changes to split Emc and Pmd collections. Minor change to track copying logic
00499  *
00500  * Revision 1.20  2004/08/25 04:05:56  mvl
00501  * Added getters for StStrangeAssocs
00502  *
00503  * Revision 1.19  2004/07/27 02:35:23  mvl
00504  * Added access methods for Strangeness Monte-Carlo arrays
00505  *
00506  * Revision 1.18  2004/05/02 04:10:13  perev
00507  * private => protected
00508  *
00509  * Revision 1.17  2004/04/20 18:41:11  perev
00510  * Change arrays to pointer to StMuDstMaker::arrays StMuDst.h
00511  *
00512  * Revision 1.16  2004/04/09 22:04:52  subhasis
00513  * after tof createevent fix by Xin
00514  *
00515  * Revision 1.15  2004/04/09 03:36:14  jeromel
00516  * Removed TOF support entirely for now as we need a working version ... Will
00517  * revisit later.
00518  *
00519  * Revision 1.14  2004/04/02 03:24:53  jeromel
00520  * Changes implements PMD and TOF.  TOF is clearly incomplete.
00521  *
00522  * Revision 1.13  2003/10/08 21:17:15  laue
00523  * StMuEmcUtil updates from Alex Suaide
00524  * StMuDst and StMuDstMaker fixes to take the double inheritance of the
00525  * StKinkMuDsts into account. A void* had to be introduced when casting
00526  * TObject* to StKinkMuDst*.
00527  *
00528  * Revision 1.12  2003/09/10 22:33:41  perev
00529  * Grid for MuDst corrections
00530  *
00531  * Revision 1.11  2003/04/15 18:48:34  laue
00532  * Minor changes to be able to filter MuDst.root files and an example
00533  * how to do this. The StMuDstFilterMaker is just an example, it has to be
00534  * customized (spoilers, chrome weels, etc.) by the user.
00535  *
00536  * Revision 1.10  2003/01/23 21:59:50  laue
00537  * Modification to compile on Solaris.
00538  *
00539  * Revision 1.9  2003/01/09 18:59:45  laue
00540  * initial check in of new EMC classes and the changes required
00541  *
00542  * Revision 1.8  2002/08/23 17:30:18  laue
00543  * additional member functions added (Helen Caines' request)
00544  *
00545  * Revision 1.7  2002/08/20 19:55:49  laue
00546  * Doxygen comments added
00547  *
00548  * Revision 1.6  2002/05/20 17:23:31  laue
00549  * StStrangeCuts added
00550  *
00551  * Revision 1.5  2002/04/01 22:42:30  laue
00552  * improved chain filter options
00553  *
00554  * Revision 1.4  2002/03/20 16:04:11  laue
00555  * minor changes, mostly added access functions
00556  *
00557  * Revision 1.3  2002/03/14 04:12:44  laue
00558  * bug fix: StMuL3EventSummary.cxx
00559  * update: StMuDst.h StMuDst.cxx
00560  *
00561  * Revision 1.2  2002/03/08 20:04:31  laue
00562  * change from two trees to 1 tree per file
00563  *
00564  * Revision 1.1  2002/03/08 17:04:17  laue
00565  * initial revision
00566  *
00567  *
00568  **************************************************************************/