StRoot  1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
StMuDst.h
1 /***************************************************************************
2  *
3  * $Id: StMuDst.h,v 1.56 2019/02/21 14:00:02 jdb Exp $
4  * Author: Frank Laue, BNL, laue@bnl.gov
5  *
6  ***************************************************************************/
7 
8 #ifndef StMuDst_h
9 #define StMuDst_h
10 
11 #include "TObject.h"
12 #include "TClonesArray.h"
13 
14 class StMuDstMaker;
15 class StMuEvent;
16 class StMuPrimaryVertex;
17 class StMuTrack;
18 class StRichSpectra;
19 class StDetectorState;
20 class StL3AlgorithmInfo;
21 #ifndef __NO_STRANGE_MUDST__
22 class StStrangeEvMuDst;
23 class StV0MuDst;
24 class StXiMuDst;
25 class StKinkMuDst;
26 class StV0Mc;
27 class StXiMc;
28 class StKinkMc;
29 class StStrangeAssoc;
30 class TCut;
31 #endif
32 class StMuEmcCollection;
33 class StMuFmsCollection;
34 class StMuRHICfCollection;
35 class StMuFcsCollection;
36 class StMuFttCollection;
37 class StMuFstCollection;
38 class StMuFwdTrackCollection;
39 class StMuPmdCollection;
40 
41 class StEvent;
42 class StTriggerData;
43 class StTrack;
44 class StTrackGeometry;
45 class StEmcCollection;
46 class StFmsCollection;
47 class StRHICfCollection;
48 
49 class StMtdCollection;
50 
51 class StMuTofHit;
52 class StTofData;
53 // run 5 - dongx
54 class StTofRawData;
55 // dongx
56 class StBTofCollection;
57 class StMuBTofHit;
58 class StBTofRawHit;
59 class StBTofHeader;
60 class StETofCollection; // fseck
61 class StMuETofCollection; // fseck
62 class StMuETofHeader; // fseck
63 class StMuETofDigi; // fseck
64 class StMuETofHit; // fseck
65 class StMuEpdHitCollection; // MALisa
66 class StMuEpdHit; // MALisa
67 class EztEventHeader;
68 class EztTrigBlob;
69 class EztFpdBlob;
70 class EztEmcRawData;
71 
72 class StDcaGeometry;
73 class StMuPrimaryTrackCovariance;
74 
75 class StMuRpsCollection;
76 class StMuMtdCollection;
77 
78 class StMuMtdHit;
79 class StMuMtdRawHit;
80 class StMuMtdHeader;
81 
82 #include "StPhysicalHelixD.hh"
83 
84 #include "TObject.h"
85 #include "StMuArrays.h"
86 #include "StMuException.hh"
87 
88 
89 
90 #define ARRAY(NAME) static TClonesArray* (NAME)##s() { return tca_##NAME##s;}
91 #define OBJECT(TYPE,FUNC) static TYPE FUNC##(unsigned int i=0) { if (FUNC##s() && (i<(unsigned int)FUNC##s()->GetEntriesFast()) ) return (##TYPE##)FUNC##s()->UncheckedAt(i); return 0;}
92 
93 #define DO(TYPE,NAME) ARRAY(NAME) OBJECT(TYPE,NAME)
94 
95 
106 class StMuDst : public TObject {
107 public:
109  StMuDst();
111  static void set(StMuDstMaker* maker);
114  static void set(TClonesArray** /* Arrays */,
115 #ifndef __NO_STRANGE_MUDST__
116  TClonesArray** /* StrangeArrays */,
117 #endif
118  TClonesArray** mc_ptca=0,
119  TClonesArray** emc_ptca=0,
120  TClonesArray** fms_ptca=0,
121  TClonesArray** rhicf_ptca=0,
122  TClonesArray** fcs_ptca=0,
123  TClonesArray** ftt_ptca=0,
124  TClonesArray** fst_ptca=0,
125  TClonesArray** fwd_ptca=0,
126  TClonesArray** pmd_ptca=0,
127  TClonesArray** tof_ptca=0,
128  TClonesArray** btof_ptca=0,
129  TClonesArray** etof_col=0, // jdb
130  TClonesArray** epd_col=0, // MALisa
131  TClonesArray** mtd_ptca=0,
132  TClonesArray** fgt_ptca=0,
133  TClonesArray** ezt_ptca=0,
134  TClonesArray *emc_tca=0,
135  StMuEmcCollection *emc_col=0,
136  StMuFmsCollection *fms_col=0,
137  StMuRHICfCollection *rhicf_col=0,
138  StMuFcsCollection *fcs_col=0,
139  StMuFttCollection *ftt_col=0,
140  StMuFstCollection *fst_col=0,
141  StMuFwdTrackCollection *fwd_track_col=0,
142  TClonesArray *pmd_tca=0,
143  StMuPmdCollection *pmd_col=0
144 );
146  static void setEmcCollection(StEmcCollection *emc_coll) { mEmcCollection=emc_coll; }
147 
148  static void setFmsCollection(StFmsCollection *fms_coll) { mFmsCollection=fms_coll; }
149 
150  static void setRHICfCollection(StRHICfCollection* rhicf_coll) { mRHICfCollection=rhicf_coll; }
151 
153  static void unset();
155  static void fixTrackIndices(TClonesArray* primary, TClonesArray* global);
157  void fixTrackIndices();
158  //fills gloabl track's mIndex2Global with the index to the respective primary track
159  static void fixTrackIndicesG(int mult=1);
161  StEvent* createStEvent();
163  static StTrackGeometry* trackGeometry(int q, StPhysicalHelixD* h);
165  static StTrack* createStTrack(const StMuTrack*);
167  static void fixTofTrackIndices(TClonesArray* btofHit, TClonesArray* primary, TClonesArray* global);
168  static void fixETofTrackIndices(TClonesArray* btofHit, TClonesArray* primary, TClonesArray* global);
169  static void fixMtdTrackIndices(TClonesArray* mtdHit, TClonesArray* primary, TClonesArray* global);
171  void fixTofTrackIndices();
172  void fixETofTrackIndices();
173  void fixMtdTrackIndices();
174 
175  void setMtdArray(StMtdCollection *mtd_coll);
176 
177  // fseck
178  void setETofArray( const StETofCollection* etof_coll );
179  void addETofHit( const StMuETofHit* hit );
180 
181 
182 
183  protected:
185  static TClonesArray** arrays;
186 #ifndef __NO_STRANGE_MUDST__
187  static TClonesArray** strangeArrays;
189 #endif
190  static TClonesArray** mcArrays;
192  static TClonesArray** emcArrays;
194  static TClonesArray** fmsArrays;
196  static TClonesArray** rhicfArrays;
198  static TClonesArray** fcsArrays;
200  static TClonesArray** fttArrays;
202  static TClonesArray** fstArrays;
204  static TClonesArray** fwdTrackArrays;
206  static TClonesArray** pmdArrays;
208  static TClonesArray** tofArrays;
210  static TClonesArray** btofArrays;
212  static TClonesArray** etofArrays;
214  static TClonesArray** epdArrays;
216  static TClonesArray** mtdArrays;
218  static TClonesArray** fgtArrays;
219  // pointer to array with MuEmcCollection (for backward compatible mode)
220  static TClonesArray *mMuEmcCollectionArray;
222  static StMuEmcCollection *mMuEmcCollection;
223  // pointer to array with MuPmdCollection (for backward compatible mode)
224  static TClonesArray *mMuPmdCollectionArray;
226  static StMuFmsCollection *mMuFmsCollection;
228  static StMuRHICfCollection *mMuRHICfCollection;
230  static StMuFcsCollection *mMuFcsCollection;
232  static StMuFttCollection *mMuFttCollection;
234  static StMuFstCollection *mMuFstCollection;
236  static StMuFwdTrackCollection *mMuFwdTrackCollection;
238  static StMuPmdCollection *mMuPmdCollection;
240  static StEmcCollection *mEmcCollection;
242  static StFmsCollection *mFmsCollection;
244  static StRHICfCollection *mRHICfCollection;
245 
247  static TClonesArray** eztArrays;
248 
250  static Int_t mCurrVertexId;
252  static TObjArray *mCurrPrimaryTracks;
254  static void collectVertexTracks();
255 
256 public:
258  static void setVertexIndex(Int_t vtx_id);
260  static Int_t currentVertexIndex() {return mCurrVertexId; }
262  static TClonesArray* array(int type) { return arrays[type]; }
263 #ifndef __NO_STRANGE_MUDST__
264  static TClonesArray* strangeArray(int type) { return strangeArrays[type]; }
266 #endif
267  static TClonesArray* mcArray(int type) { return mcArrays[type]; }
269  static TClonesArray* emcArray(int type) { return emcArrays[type]; }
271  static TClonesArray* fmsArray(int type) { return fmsArrays[type]; }
273  static TClonesArray* rhicfArray(int type) { return rhicfArrays[type]; }
275  static TClonesArray* fcsArray(int type) { return fcsArrays[type]; }
277  static TClonesArray* fttArray(int type) { return fttArrays[type]; }
279  static TClonesArray* fstArray(int type) { return fstArrays[type]; }
281  static TClonesArray* fwdTrackArray(int type) { return fwdTrackArrays[type]; }
283  static TClonesArray* pmdArray(int type) { return pmdArrays[type]; }
285  static TClonesArray* tofArray(int type) { return tofArrays[type]; }
287  static TClonesArray* btofArray(int type) { return btofArrays[type]; }
289  static TClonesArray* etofArray(int type) { return etofArrays[type]; }
291  static TClonesArray* mtdArray(int type) { return mtdArrays[type]; }
293  static TClonesArray* fgtArray(int type) { return fgtArrays[type]; }
295  static TClonesArray* eztArray(int type) { return eztArrays[type]; }
297  static TClonesArray* epdHits() { return epdArrays[muEpdHit]; } // MALisa
299  static TClonesArray* primaryVertices() { return arrays[muPrimaryVertex]; }
301  static TObjArray* primaryTracks() { return mCurrPrimaryTracks; }
303  static TObjArray* globalTracks() { return arrays[muGlobal]; }
305  static TClonesArray* otherTracks() { return arrays[muOther]; }
307  static TClonesArray* l3Tracks() { return arrays[muL3]; }
309  static TClonesArray* richSpectra() { return arrays[muRich]; }
311  static TClonesArray* detectorStates() { return arrays[muState]; }
313  static TClonesArray* l3AlgoAccept() { return arrays[muAccept]; }
315  static TClonesArray* l3AlgoReject() { return arrays[muReject]; }
316  static TClonesArray* covGlobTrack() {return arrays[muCovGlobTrack];}
317  static TClonesArray* covPrimTrack() {return arrays[muCovPrimTrack];}
318 
320  static StMuEvent* event() { return (StMuEvent*)arrays[muEvent]->UncheckedAt(0); }
322  static StMuPrimaryVertex* primaryVertex() { return (StMuPrimaryVertex*)arrays[muPrimaryVertex]->UncheckedAt(mCurrVertexId); }
324  static StMuPrimaryVertex* primaryVertex(int i) { return (StMuPrimaryVertex*)arrays[muPrimaryVertex]->UncheckedAt(i); }
326  static StMuTrack* primaryTracks(int i) { return (StMuTrack*)mCurrPrimaryTracks->UncheckedAt(i); }
328  static StMuTrack* globalTracks(int i) { return (StMuTrack*)arrays[muGlobal]->UncheckedAt(i); }
330  static StMuTrack* otherTracks(int i) { return (StMuTrack*)arrays[muOther]->UncheckedAt(i); }
332  static StMuTrack* l3Tracks(int i) { return (StMuTrack*)arrays[muL3]->UncheckedAt(i); }
334  static StRichSpectra* richSpectra(int i) { return (StRichSpectra*)arrays[muRich]->UncheckedAt(i); }
336  static StDetectorState* detectorStates(int i) { return (StDetectorState*)arrays[muState]->UncheckedAt(i); }
338  static StL3AlgorithmInfo* l3AlgoAccept(int i) { return (StL3AlgorithmInfo*)arrays[muAccept]->UncheckedAt(i); }
340  static StL3AlgorithmInfo* l3AlgoReject(int i) { return (StL3AlgorithmInfo*)arrays[muReject]->UncheckedAt(i); }
341  //returns pp2pp infomation
342  static StMuRpsCollection* RpsCollection() { return (StMuRpsCollection*)arrays[mupp2pp]->UncheckedAt(0); }
343  static StMuMtdCollection* MtdCollection() { return (StMuMtdCollection*)arrays[muMtd]->UncheckedAt(0); }
344 
345  static StDcaGeometry* covGlobTracks(int i) { return (StDcaGeometry*)arrays[muCovGlobTrack]->UncheckedAt(i); }
346  static StMuPrimaryTrackCovariance* covPrimTracks(int i) { return (StMuPrimaryTrackCovariance*)arrays[muCovPrimTrack]->UncheckedAt(i); }
347 
348 #ifndef __NO_STRANGE_MUDST__
349  static StStrangeEvMuDst* strangeEvent() { return (StStrangeEvMuDst*)strangeArrays[smuEv]->UncheckedAt(0); }
352  static StStrangeEvMuDst* strangeEventMc() { return (StStrangeEvMuDst*)strangeArrays[smuEvMc]->UncheckedAt(0); }
354  static TClonesArray* v0s() { return strangeArrays[smuV0]; }
356  static TClonesArray* v0sMc() { return strangeArrays[smuV0Mc]; }
358  static TClonesArray* v0Assoc() { return strangeArrays[smuV0Assoc]; }
360  static TClonesArray* xis() { return strangeArrays[smuXi]; }
362  static TClonesArray* xisMc() { return strangeArrays[smuXiMc]; }
364  static TClonesArray* xiAssoc() { return strangeArrays[smuXiAssoc]; }
366  static TClonesArray* kinks() { return strangeArrays[smuKink]; }
368  static TClonesArray* kinksMc() { return strangeArrays[smuKinkMc]; }
370  static TClonesArray* kinkAssoc() { return strangeArrays[smuKinkAssoc]; }
372  static TClonesArray* strangeCuts() { return strangeArrays[smuCut]; }
374  static StV0MuDst* v0s(int i) { return (StV0MuDst*)strangeArrays[smuV0]->UncheckedAt(i); }
375  static StV0Mc* v0sMc(int i) { return (StV0Mc*)strangeArrays[smuV0Mc]->UncheckedAt(i); }
376  static StStrangeAssoc* v0Assoc(int i) { return (StStrangeAssoc*)strangeArrays[smuV0Assoc]->UncheckedAt(i); }
378  static StXiMuDst* xis(int i) { return (StXiMuDst*)(void*)strangeArrays[smuXi]->UncheckedAt(i); }
379  static StXiMc* xisMc(int i) { return (StXiMc*)strangeArrays[smuXiMc]->UncheckedAt(i); }
380  static StStrangeAssoc* xiAssoc(int i) { return (StStrangeAssoc*)strangeArrays[smuXiAssoc]->UncheckedAt(i); }
382  static StKinkMuDst* kinks(int i) { return (StKinkMuDst*)(void*)strangeArrays[smuKink]->UncheckedAt(i); }
383  static StKinkMc* kinksMc(int i) { return (StKinkMc*)strangeArrays[smuKinkMc]->UncheckedAt(i); }
384  static StStrangeAssoc* kinkAssoc(int i) { return (StStrangeAssoc*)strangeArrays[smuKinkAssoc]->UncheckedAt(i); }
386  static TCut* strangeCuts(int i) { return (TCut*)strangeArrays[smuCut]->UncheckedAt(i); }
387 #endif
388  static StMuEmcCollection* muEmcCollection() { if (mMuEmcCollectionArray) return (StMuEmcCollection*) mMuEmcCollectionArray->UncheckedAt(0); else return mMuEmcCollection; }
391  static StMuFmsCollection* muFmsCollection() { return mMuFmsCollection; }
393  static StMuRHICfCollection* muRHICfCollection() { return mMuRHICfCollection; }
395  static StMuFcsCollection* muFcsCollection() { return mMuFcsCollection; }
397  static StMuFttCollection* muFttCollection() { return mMuFttCollection; }
399  static StMuFstCollection* muFstCollection() { return mMuFstCollection; }
401  static StMuFwdTrackCollection* muFwdTrackCollection() { return mMuFwdTrackCollection; }
403  static StMuPmdCollection* pmdCollection() { if (mMuPmdCollectionArray) return (StMuPmdCollection*) mMuPmdCollectionArray->UncheckedAt(0); else return mMuPmdCollection; }
405  static StEmcCollection* emcCollection() { return mEmcCollection; }
407  static StFmsCollection* fmsCollection() { return mFmsCollection; }
409  static StRHICfCollection* rhicfCollection() { return mRHICfCollection; }
410 
412  static StMuTofHit* tofHit(int i) { return (StMuTofHit*)tofArrays[muTofHit]->UncheckedAt(i); }
414  static StTofData* tofData(int i) { return (StTofData*)tofArrays[muTofData]->UncheckedAt(i); }
415  // run 5 - dongx
417  static StTofRawData* tofRawData(int i) { return (StTofRawData*)tofArrays[muTofRawData]->UncheckedAt(i); }
419  static StMuBTofHit* btofHit(int i) { return (StMuBTofHit*)btofArrays[muBTofHit]->UncheckedAt(i); }
421  static StBTofRawHit* btofRawHit(int i) { return (StBTofRawHit*)btofArrays[muBTofRawHit]->UncheckedAt(i); }
423  static StBTofHeader* btofHeader() { return (StBTofHeader*)btofArrays[muBTofHeader]->UncheckedAt(0); }
424 
425  // fseck ---
427  static StMuETofDigi* etofDigi(int i) { return (StMuETofDigi*)etofArrays[muETofDigi]->UncheckedAt(i); }
429  static StMuETofHit* etofHit(int i) { return (StMuETofHit*)etofArrays[muETofHit]->UncheckedAt(i); }
431  static StMuETofHeader* etofHeader() { return (StMuETofHeader*)etofArrays[muETofHeader]->UncheckedAt(0); }
432  // -- ---
433 
434  static StMuEpdHit* epdHit(int i) { return (StMuEpdHit*)epdArrays[muEpdHit]->UncheckedAt(i); } // MALisa
435 
436  static StMuMtdHit* mtdHit(int i) { return (StMuMtdHit*)mtdArrays[muMTDHit]->UncheckedAt(i); }
437  static StMuMtdRawHit* mtdRawHit(int i) { return (StMuMtdRawHit*)mtdArrays[muMTDRawHit]->UncheckedAt(i); }
438  static StMuMtdHeader* mtdHeader() { return (StMuMtdHeader*)mtdArrays[muMTDHeader]->UncheckedAt(0); }
439 
440 
442  static EztEventHeader* eztHeader() { return (EztEventHeader*)eztArrays[muEztHead]->UncheckedAt(0); }
443 
444 // static StMuBTofHit* btofHit(int i) { return (StMuBTofHit*)btofArrays[muBTofHit]->UncheckedAt(i); }
445 
446 
448  static EztTrigBlob* eztTrig()
449  { return (EztTrigBlob*)eztArrays[muEztTrig]->UncheckedAt(0); }
450 
452  static EztFpdBlob* eztFpd()
453  { return (EztFpdBlob*)eztArrays[muEztFpd]->UncheckedAt(0); }
454 
456  static EztEmcRawData* eztETow()
457  { return (EztEmcRawData*)eztArrays[muEztETow]->UncheckedAt(0); }
459  static EztEmcRawData* eztESmd()
460  { return (EztEmcRawData*)eztArrays[muEztESmd]->UncheckedAt(0); }
461 
462  static unsigned int numberOfPrimaryVertices() { return arrays[muPrimaryVertex]->GetEntriesFast(); }
463  static unsigned int numberOfPrimaryTracks() { return mCurrPrimaryTracks->GetEntriesFast(); }
464  static unsigned int numberOfGlobalTracks() { return arrays[muGlobal]->GetEntriesFast(); }
465  static unsigned int numberOfOtherTracks() { return arrays[muOther]->GetEntriesFast(); }
466  static unsigned int numberOfL3Tracks() { return arrays[muL3]->GetEntriesFast(); }
467  static unsigned int numberOfRichSpectras() { return arrays[muRich]->GetEntriesFast(); }
468  static unsigned int numberOfDetectorStates() { return arrays[muState]->GetEntriesFast(); }
469  static unsigned int numberOfL3AlgoAccepts() { return arrays[muAccept]->GetEntriesFast(); }
470  static unsigned int numberOfL3AlgoRejects() { return arrays[muReject]->GetEntriesFast(); }
471  static unsigned int numberOfCovGlobTracks() { return arrays[muCovGlobTrack]->GetEntriesFast(); }
472  static unsigned int numberOfCovPrimTracks() { return arrays[muCovPrimTrack]->GetEntriesFast(); }
473 #ifndef __NO_STRANGE_MUDST__
474  static unsigned int numberOfV0s() { return strangeArrays[smuV0]->GetEntriesFast(); }
475  static unsigned int numberOfV0sMc() { return strangeArrays[smuV0Mc]->GetEntriesFast(); }
476  static unsigned int numberOfV0Assoc() { return strangeArrays[smuV0Assoc]->GetEntriesFast(); }
477  static unsigned int numberOfXis() { return strangeArrays[smuXi]->GetEntriesFast(); }
478  static unsigned int numberOfXisMc() { return strangeArrays[smuXiMc]->GetEntriesFast(); }
479  static unsigned int numberOfXiAssoc() { return strangeArrays[smuXiAssoc]->GetEntriesFast(); }
480  static unsigned int numberOfKinks() { return strangeArrays[smuKink]->GetEntriesFast(); }
481  static unsigned int numberOfKinksMc() { return strangeArrays[smuKinkMc]->GetEntriesFast(); }
482  static unsigned int numberOfKinkAssoc() { return strangeArrays[smuKinkAssoc]->GetEntriesFast(); }
483  static unsigned int numberOfStrangeCuts() { return strangeArrays[smuCut]->GetEntriesFast(); }
484 #endif
485  // tofr
486  static unsigned int numberOfTofHit() { return tofArrays[muTofHit]->GetEntriesFast(); }
487  static unsigned int numberOfTofData() { return tofArrays[muTofData]->GetEntriesFast(); }
488  // run 5 - dongx
489  static unsigned int numberOfTofRawData() { return tofArrays[muTofRawData]->GetEntriesFast(); }
490  // dongx
491  static unsigned int numberOfBTofHit() { return btofArrays[muBTofHit]->GetEntriesFast(); }
492  static unsigned int numberOfBTofRawHit() { return btofArrays[muBTofRawHit]->GetEntriesFast(); }
493 
494  // fseck
495  static unsigned int numberOfETofDigi() { return etofArrays[muETofDigi]->GetEntriesFast(); }
496  static unsigned int numberOfETofHit() { return etofArrays[muETofHit]->GetEntriesFast(); }
497 
498  static unsigned int numberOfEpdHit() { return epdArrays[muEpdHit]->GetEntriesFast(); }
499 
500  static unsigned int numberOfMTDHit() { return mtdArrays[muMTDHit]->GetEntriesFast(); }
501  static unsigned int numberOfBMTDRawHit() { return mtdArrays[muMTDRawHit]->GetEntriesFast(); }
502 
503  static unsigned int GetNPrimaryVertex() { return numberOfPrimaryVertices(); }
504  static unsigned int GetNPrimaryTrack() { return numberOfPrimaryTracks(); }
505  static unsigned int GetNGlobalTrack() { return numberOfGlobalTracks(); }
506  static unsigned int GetNOtherTrack() { return numberOfOtherTracks(); }
507  static unsigned int GetNL3Track() { return numberOfL3Tracks(); }
508  static unsigned int GetNRichSpectra() { return numberOfRichSpectras(); }
509  static unsigned int GetNDetectorState() { return numberOfDetectorStates(); }
510  static unsigned int GetNL3AlgoAccept() { return numberOfL3AlgoAccepts(); }
511  static unsigned int GetNL3AlgoReject() { return numberOfL3AlgoRejects(); }
512 #ifndef __NO_STRANGE_MUDST__
513  static unsigned int GetNV0() { return numberOfV0s(); }
514  static unsigned int GetNV0Mc() { return numberOfV0sMc(); }
515  static unsigned int GetNV0Assoc() { return numberOfV0Assoc(); }
516  static unsigned int GetNXi() { return numberOfXis(); }
517  static unsigned int GetNXiMc() { return numberOfXisMc(); }
518  static unsigned int GetNXiAssoc() { return numberOfXiAssoc(); }
519  static unsigned int GetNKink() { return numberOfKinks(); }
520  static unsigned int GetNKinkMc() { return numberOfKinksMc(); }
521  static unsigned int GetNKinkAssoc() { return numberOfKinkAssoc(); }
522  static unsigned int GetNStrangeCut() { return numberOfStrangeCuts(); }
523 #endif
524  static unsigned int GetNTofHit() { return numberOfTofHit(); }
525  static unsigned int GetNTofData() { return numberOfTofData(); }
526  // run 5 - dongx
527  static unsigned int GetNTofRawData() { return numberOfTofRawData(); }
528  // dongx
529  static unsigned int GetNBTofHit() { return numberOfBTofHit(); }
530  static unsigned int GetNBTofRawHit() { return numberOfBTofRawHit(); }
531  // fseck
532  static unsigned int GetNETofDigi() { return numberOfETofDigi(); }
533  static unsigned int GetNETofHit() { return numberOfETofHit(); }
534 
535  static unsigned int GetNEpdHit() { return numberOfEpdHit(); }
536 
537  static unsigned int GetNMTDHit() { return numberOfMTDHit(); }
538  static unsigned int GetNMTDRawHit() { return numberOfBMTDRawHit(); }
539 
540  virtual void Print(Option_t *option = "") const;
541  static void printPrimaryTracks();
542  static void printGlobalTracks() ;
543  static void printVertices() ;
544 
545  friend class StMuDstMaker;
546  friend class StMuIOMaker;
547 
548  // Increment this by 1 every time the class structure is changed
549  ClassDef(StMuDst,6)
550 };
551 
552 #endif
553 
554 /***************************************************************************
555  *
556  * $Log: StMuDst.h,v $
557  * Revision 1.56 2019/02/21 14:00:02 jdb
558  * Bumped the ClassDef versions in MuDst where eTOF was added. I also added the etofTypes to the LinkDef file
559  *
560  * Revision 1.55 2019/02/21 13:32:54 jdb
561  * Inclusion of ETOF MuDst code. This code adds support for the full set of ETOF data which includes EtofDigi, EtofHit, EtofHeader. The code essentially copies similar structures from StEvent and additionally rebuilds the maps between Digis and Hits. Accessor methods are added based on the pattern from BTOF to provide access to data at various levels. The code for accessing the PID traits provided by ETOF is also provided
562  *
563  * Revision 1.54 2018/02/27 04:11:57 jdb
564  * Added epdArrays
565  *
566  * Revision 1.53 2017/01/19 23:03:27 smirnovd
567  * StMuDst: Make methods static as logic suggests
568  *
569  * Revision 1.52 2017/01/19 23:03:13 smirnovd
570  * Promise to not modify original StMuTrack when converting to StTrack
571  *
572  * Revision 1.51 2014/05/16 15:06:45 jdb
573  * chaned StMuDst{.h,.cxx} to add setMtdArray function
574  *
575  * Revision 1.50 2013/12/04 19:56:32 jdb
576  * Added StMuMtdPidTraits.{cxx, h} added Mtd items to StMuMtdHit.h, StMuDst.{cxx,h}, StMuDstMaker.cxx, StMuTrack.{cxx,h}
577  *
578  * Revision 1.49 2013/07/23 11:02:59 jeromel
579  * Undo changes (KF and other)
580  *
581  * Revision 1.47 2013/04/10 19:28:35 jeromel
582  * Step back to 04/04 version (van aware) - previous changes may be recoverred
583  *
584  * Revision 1.45 2012/11/26 23:14:32 fisyak
585  * Replace GetEntries() by GetEntriesFast(), fix print outs
586  *
587  * Revision 1.44 2012/11/15 22:26:13 sangalin
588  * Added the FGT. Fixed bugs in array offsets for the MTD.
589  *
590  * Revision 1.43 2012/09/28 22:38:05 tone421
591  * Changed array stucture of MTD upon request of the TOF group. MTD arrays now on top level, rather than within __NARRAYS__
592  *
593  * Revision 1.42 2011/05/04 19:51:32 tone421
594  * Added MTD infomation
595  *
596  * Revision 1.41 2011/04/08 01:25:50 fisyak
597  * Add branches for MC track and vertex information, add IdTruth to tracks and vertices, reserve a possiblity to remove Strange MuDst
598  *
599  * Revision 1.40 2010/05/26 04:25:50 tone421
600  * Added StTriggerData arrays in muevent and fixed an issue with PMD arrays being read....
601  *
602  * Revision 1.39 2010/03/08 19:06:51 tone421
603  * 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:
604  *
605  * http://www.star.bnl.gov/HyperNews-star/protected/get/starsoft/8092/1/1/1.html
606  *
607  * for more details.
608  *
609  * Revision 1.38 2010/02/01 23:15:27 fine
610  * replace non-static method
611  *
612  * Revision 1.37 2010/02/01 22:54:34 fine
613  * replace non-static method
614  *
615  * Revision 1.36 2010/01/25 03:57:39 tone421
616  * Added FMS and Roman pot arrays
617  *
618  * Revision 1.35 2009/08/28 14:55:55 tone421
619  * Changed tofArrays to btofArrays returned objects in numberOfBTofHit() and numberOfBTofRawHit()
620  *
621  * Revision 1.34 2009/02/20 16:37:44 tone421
622  * *** empty log message ***
623  *
624  * Revision 1.32 2008/03/19 14:51:03 fisyak
625  * Add two clone arrays for global and primary track covariance matrices, remove mSigmaDcaD and mSigmaDcaZ
626  *
627  * Revision 1.31 2007/09/18 02:29:58 mvl
628  * Added basic printing functionality. For convenience and to assist data consistency checks
629  *
630  * Revision 1.30 2005/08/22 17:29:12 mvl
631  * Made setVertexId static, changed globalTracks() to return
632  * TObjArray* (for similarity to primaryTracks.h)
633  * and added primaryVertex() to return current vertex
634  *
635  * Revision 1.29 2005/08/19 19:46:05 mvl
636  * Further updates for multiple vertices. The main changes are:
637  * 1) StMudst::primaryTracks() now returns a list (TObjArray*) of tracks
638  * belonging to the 'current' primary vertex. The index number of the
639  * 'current' vertex can be set using StMuDst::setCurrentVertex().
640  * This also affects StMuDst::primaryTracks(int i) and
641  * StMuDst::numberOfprimaryTracks().
642  * 2) refMult is now stored for all vertices, in StMuPrimaryVertex. The
643  * obvious way to access these numbers is from the StMuprimaryVertex structures,
644  * but for ebakcward compatibility a function is provided in StMuEvent as well
645  * (this is the only function taht works for existing MuDst)
646  *
647  * As an aside, I've also changes the internals of StMuDst::createStEvent and
648  * StMuDst::fixTrackIndices() to be able to deal with a larger range of index numbers for tracks as generated by Ittf.
649  *
650  * BIG FAT WARNING: StMudst2StEventMaker and StMuDstFilterMaker
651  * do not fully support the multiple vertex functionality yet.
652  *
653  * Revision 1.28 2005/07/15 21:45:08 mvl
654  * 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())
655  *
656  * Revision 1.27 2005/07/06 21:40:18 fisyak
657  * use template version of StPhysicalHelixD
658  *
659  * Revision 1.26 2005/04/12 21:56:29 mvl
660  * Changes by Xin Dong for year-5 TOF data format: extra TClonesArray and routines to fill it from StEvent (StTofRawData).
661  *
662  * Revision 1.25 2004/11/29 15:53:22 mvl
663  * Additions by Jan for Fpd ezTree
664  *
665  * Revision 1.24 2004/10/29 20:18:18 jeromel
666  * Proto arg name must not be repeated
667  *
668  * Revision 1.23 2004/10/28 00:11:33 mvl
669  * Added stuff to support ezTree mode of MuDstMaker.
670  * This is a special mode for fast-online processing of fast-detector data.
671  *
672  * Revision 1.22 2004/10/21 02:56:35 mvl
673  * Added pointer to StEmcColleciton for Emc clustering etc.
674  * Also made some technical changes for backward compatibility mode with
675  * StMuIOMaker (pointers to TClonesArray for StMuEmcCollection)
676  *
677  * Revision 1.21 2004/10/19 01:45:26 mvl
678  * Changes to split Emc and Pmd collections. Minor change to track copying logic
679  *
680  * Revision 1.20 2004/08/25 04:05:56 mvl
681  * Added getters for StStrangeAssocs
682  *
683  * Revision 1.19 2004/07/27 02:35:23 mvl
684  * Added access methods for Strangeness Monte-Carlo arrays
685  *
686  * Revision 1.18 2004/05/02 04:10:13 perev
687  * private => protected
688  *
689  * Revision 1.17 2004/04/20 18:41:11 perev
690  * Change arrays to pointer to StMuDstMaker::arrays StMuDst.h
691  *
692  * Revision 1.16 2004/04/09 22:04:52 subhasis
693  * after tof createevent fix by Xin
694  *
695  * Revision 1.15 2004/04/09 03:36:14 jeromel
696  * Removed TOF support entirely for now as we need a working version ... Will
697  * revisit later.
698  *
699  * Revision 1.14 2004/04/02 03:24:53 jeromel
700  * Changes implements PMD and TOF. TOF is clearly incomplete.
701  *
702  * Revision 1.13 2003/10/08 21:17:15 laue
703  * StMuEmcUtil updates from Alex Suaide
704  * StMuDst and StMuDstMaker fixes to take the double inheritance of the
705  * StKinkMuDsts into account. A void* had to be introduced when casting
706  * TObject* to StKinkMuDst*.
707  *
708  * Revision 1.12 2003/09/10 22:33:41 perev
709  * Grid for MuDst corrections
710  *
711  * Revision 1.11 2003/04/15 18:48:34 laue
712  * Minor changes to be able to filter MuDst.root files and an example
713  * how to do this. The StMuDstFilterMaker is just an example, it has to be
714  * customized (spoilers, chrome weels, etc.) by the user.
715  *
716  * Revision 1.10 2003/01/23 21:59:50 laue
717  * Modification to compile on Solaris.
718  *
719  * Revision 1.9 2003/01/09 18:59:45 laue
720  * initial check in of new EMC classes and the changes required
721  *
722  * Revision 1.8 2002/08/23 17:30:18 laue
723  * additional member functions added (Helen Caines' request)
724  *
725  * Revision 1.7 2002/08/20 19:55:49 laue
726  * Doxygen comments added
727  *
728  * Revision 1.6 2002/05/20 17:23:31 laue
729  * StStrangeCuts added
730  *
731  * Revision 1.5 2002/04/01 22:42:30 laue
732  * improved chain filter options
733  *
734  * Revision 1.4 2002/03/20 16:04:11 laue
735  * minor changes, mostly added access functions
736  *
737  * Revision 1.3 2002/03/14 04:12:44 laue
738  * bug fix: StMuL3EventSummary.cxx
739  * update: StMuDst.h StMuDst.cxx
740  *
741  * Revision 1.2 2002/03/08 20:04:31 laue
742  * change from two trees to 1 tree per file
743  *
744  * Revision 1.1 2002/03/08 17:04:17 laue
745  * initial revision
746  *
747  *
748  **************************************************************************/
StMuDst::mCurrPrimaryTracks
static TObjArray * mCurrPrimaryTracks
Temporary array to collect tracks from currect primary vertex.
Definition: StMuDst.h:252
StMuDst::muFcsCollection
static StMuFcsCollection * muFcsCollection()
returns pointer to current StMuFcsCollection
Definition: StMuDst.h:395
StMuDst::unset
static void unset()
resets the pointers to the TClonesArrays to 0
Definition: StMuDst.cxx:107
StMuDst::tofArrays
static TClonesArray ** tofArrays
array of TClonesArrays for the stuff inherited from the TOF
Definition: StMuDst.h:208
StMuDst::fmsCollection
static StFmsCollection * fmsCollection()
returns pointer to current StFmsCollection
Definition: StMuDst.h:407
StMuDst::mMuFstCollection
static StMuFstCollection * mMuFstCollection
pointer to FstCollection (manages the FstArrays)
Definition: StMuDst.h:234
StMuDst::primaryVertex
static StMuPrimaryVertex * primaryVertex()
return pointer to current primary vertex
Definition: StMuDst.h:322
StMuDst::muFmsCollection
static StMuFmsCollection * muFmsCollection()
returns pointer to current StMuFmsCollection
Definition: StMuDst.h:391
StMuDst::kinks
static StKinkMuDst * kinks(int i)
returns pointer to the i-th kink
Definition: StMuDst.h:382
StMuDst::btofHit
static StMuBTofHit * btofHit(int i)
returns pointer to the i-th muBTofHit
Definition: StMuDst.h:419
StMuDst::globalTracks
static TObjArray * globalTracks()
returns pointer to the global tracks list
Definition: StMuDst.h:303
StMuDst::fixTofTrackIndices
void fixTofTrackIndices()
Definition: StMuDst.cxx:400
StMuDst::pmdCollection
static StMuPmdCollection * pmdCollection()
returns pointer to current StMuPmdCollection
Definition: StMuDst.h:403
StMuDst::richSpectra
static StRichSpectra * richSpectra(int i)
returns pointer to i-th StRichSpectra
Definition: StMuDst.h:334
StMuDst::l3AlgoAccept
static TClonesArray * l3AlgoAccept()
returns pointer to list of accepted l3 algorithms
Definition: StMuDst.h:313
StMuDst::muFttCollection
static StMuFttCollection * muFttCollection()
returns pointer to current StMuFttCollection
Definition: StMuDst.h:397
StMuDst::set
static void set(StMuDstMaker *maker)
set the pointers to the TClonesArrays
Definition: StMuDst.cxx:146
StMuDst::mMuFttCollection
static StMuFttCollection * mMuFttCollection
pointer to FttCollection (manages the FttArrays)
Definition: StMuDst.h:232
StMuDst::pmdArray
static TClonesArray * pmdArray(int type)
returns pointer to the n-th TClonesArray from the pmd arrays
Definition: StMuDst.h:283
StMuDst::strangeCuts
static TClonesArray * strangeCuts()
returns pointer to the list of strangeCuts
Definition: StMuDst.h:372
StMuDst::l3AlgoReject
static StL3AlgorithmInfo * l3AlgoReject(int i)
returns pointer to i-th rejected StL3AlgorithmInfo
Definition: StMuDst.h:340
StMuDst::mMuFmsCollection
static StMuFmsCollection * mMuFmsCollection
pointer to FmsCollection (manages the FmsArrays)
Definition: StMuDst.h:226
StMuDst::epdHits
static TClonesArray * epdHits()
returns pointer to the EpdHitCollection
Definition: StMuDst.h:297
StMuDst::fgtArrays
static TClonesArray ** fgtArrays
array of TClonesArrays for the stuff inherited from the Fgt
Definition: StMuDst.h:218
StMuDst::l3AlgoAccept
static StL3AlgorithmInfo * l3AlgoAccept(int i)
returns pointer to i-th accepted StL3AlgorithmInfo
Definition: StMuDst.h:338
StMuDst::etofHeader
static StMuETofHeader * etofHeader()
returns pointer to the StMuETofHeader
Definition: StMuDst.h:431
StMuDst::eztFpd
static EztFpdBlob * eztFpd()
returns pointer to eztFpd
Definition: StMuDst.h:452
StMuDst::tofRawData
static StTofRawData * tofRawData(int i)
returns pointer to the i-th tofRawData
Definition: StMuDst.h:417
StMuDst::setETofArray
void setETofArray(const StETofCollection *etof_coll)
Definition: StMuDst.cxx:653
StMuDst::eztESmd
static EztEmcRawData * eztESmd()
returns pointer to eztESmd +pre/post
Definition: StMuDst.h:459
StMuDst::pmdArrays
static TClonesArray ** pmdArrays
array of TClonesArrays for the stuff inherited from the Pmd
Definition: StMuDst.h:206
StMuDst::fttArray
static TClonesArray * fttArray(int type)
returns pointer to the n-th TClonesArray from the ftt arrays
Definition: StMuDst.h:277
StMuDst::mMuEmcCollection
static StMuEmcCollection * mMuEmcCollection
pointer to EmcCollection (manages the EmcArrays)
Definition: StMuDst.h:222
StMuDst::etofHit
static StMuETofHit * etofHit(int i)
returns pointer to the i-th StMuETofHit
Definition: StMuDst.h:429
StMuDst::v0s
static TClonesArray * v0s()
returns pointer to the v0 list
Definition: StMuDst.h:354
StMuDst::primaryTracks
static StMuTrack * primaryTracks(int i)
return pointer to i-th primary track
Definition: StMuDst.h:326
StMuDst::btofArray
static TClonesArray * btofArray(int type)
returns pointer to the n-th TClonesArray from the btof arrays // dongx
Definition: StMuDst.h:287
StMuDst::primaryVertices
static TClonesArray * primaryVertices()
returns pointer to the primary vertex list
Definition: StMuDst.h:299
StMuDst::kinksMc
static TClonesArray * kinksMc()
returns pointer to the mc kink list
Definition: StMuDst.h:368
StMuDst::kinkAssoc
static TClonesArray * kinkAssoc()
returns pointer to the kink association list
Definition: StMuDst.h:370
StMuDst::mMuRHICfCollection
static StMuRHICfCollection * mMuRHICfCollection
pointer to RHICfCollection (manages the RHICfArrays)
Definition: StMuDst.h:228
StMuDst::Print
virtual void Print(Option_t *option="") const
Print basic event info.
Definition: StMuDst.cxx:999
StMuDst::fmsArrays
static TClonesArray ** fmsArrays
array of TClonesArrays for the stuff inherited from the Fms
Definition: StMuDst.h:194
StMuDst::otherTracks
static TClonesArray * otherTracks()
returns pointer to the other tracks list (all tracks that are not flagged as primary of global) ...
Definition: StMuDst.h:305
StMuDst::xisMc
static TClonesArray * xisMc()
returns pointer to the mc xi list
Definition: StMuDst.h:362
StMuDst::collectVertexTracks
static void collectVertexTracks()
Helper function to collect tracks for the current prim vertex.
Definition: StMuDst.cxx:260
StMuDst::fixTrackIndicesG
static void fixTrackIndicesG(int mult=1)
Definition: StMuDst.cxx:338
StMuDst::fixTrackIndices
void fixTrackIndices()
checks and if necessary corrects the indecies of elements pointing to each other (e.g., a primary track&#39;s index to the corresponding global track)
Definition: StMuDst.cxx:282
StMuDst::mtdArrays
static TClonesArray ** mtdArrays
array of TClonesArrays for the stuff inherited from the Mtd
Definition: StMuDst.h:216
StMuDst::muFwdTrackCollection
static StMuFwdTrackCollection * muFwdTrackCollection()
returns pointer to current StMuFwdTrackCollection
Definition: StMuDst.h:401
StMuDst::xiAssoc
static TClonesArray * xiAssoc()
returns pointer to the xi association list
Definition: StMuDst.h:364
StMuDst::fixETofTrackIndices
void fixETofTrackIndices()
Definition: StMuDst.cxx:476
StMuDst::tofData
static StTofData * tofData(int i)
returns pointer to the i-th tofData
Definition: StMuDst.h:414
StMuDst::strangeCuts
static TCut * strangeCuts(int i)
returns pointer to the i-th stranneCut (of type TCut)
Definition: StMuDst.h:386
StMuDst::strangeArray
static TClonesArray * strangeArray(int type)
returns pointer to the n-th TClonesArray from the strangeness arrays
Definition: StMuDst.h:265
StMuDst::mEmcCollection
static StEmcCollection * mEmcCollection
pointer to EmcCollecion (for Emc clusterfinding etc)
Definition: StMuDst.h:240
StMuDst::l3Tracks
static TClonesArray * l3Tracks()
returns pointer to the l3Tracks list
Definition: StMuDst.h:307
StMuDst::fstArray
static TClonesArray * fstArray(int type)
returns pointer to the n-th TClonesArray from the fst arrays
Definition: StMuDst.h:279
StMuDst::v0s
static StV0MuDst * v0s(int i)
returns pointer to the i-th v0
Definition: StMuDst.h:374
StMuDst::eztTrig
static EztTrigBlob * eztTrig()
returns pointer to eztTrig
Definition: StMuDst.h:448
StMuDst::eztArrays
static TClonesArray ** eztArrays
array of TClonesArrays for the stuff inherited from the EZT (ezTree)
Definition: StMuDst.h:247
StMuDst::fttArrays
static TClonesArray ** fttArrays
array of TClonesArrays for the stuff inherited from the Ftt
Definition: StMuDst.h:200
StMuDst::mtdArray
static TClonesArray * mtdArray(int type)
returns pointer to the n-th TClonesArray from the mtd arrays
Definition: StMuDst.h:291
StMuDst::eztArray
static TClonesArray * eztArray(int type)
returns pointer to the n-th TClonesArray from the ezt arrays
Definition: StMuDst.h:295
StMuDst::mMuPmdCollection
static StMuPmdCollection * mMuPmdCollection
pointer to PmdCollection (manages the PmdArrays)
Definition: StMuDst.h:238
StMuDst::eztHeader
static EztEventHeader * eztHeader()
returns pointer to eztHeader
Definition: StMuDst.h:442
StMuDst::strangeEvent
static StStrangeEvMuDst * strangeEvent()
returns pointer to current StStrangeEvMuDst (class holding the event wise information, e.g. event number, run number)
Definition: StMuDst.h:350
StMuDst::fmsArray
static TClonesArray * fmsArray(int type)
returns pointer to the n-th TClonesArray from the fms arrays
Definition: StMuDst.h:271
StMuDst::fixMtdTrackIndices
void fixMtdTrackIndices()
Definition: StMuDst.cxx:556
StMuDst::fcsArrays
static TClonesArray ** fcsArrays
array of TClonesArrays for the stuff inherited from the Fcs
Definition: StMuDst.h:198
StMuDst::muRHICfCollection
static StMuRHICfCollection * muRHICfCollection()
returns pointer to current StMuRHICfCollection
Definition: StMuDst.h:393
StMuDst::btofRawHit
static StBTofRawHit * btofRawHit(int i)
returns pointer to the i-th btofRawHit - dongx
Definition: StMuDst.h:421
StMuDst::eztETow
static EztEmcRawData * eztETow()
returns pointer to ETOW
Definition: StMuDst.h:456
StMuDst::detectorStates
static TClonesArray * detectorStates()
returns pointer to the list of detector states
Definition: StMuDst.h:311
StMuDst::muFstCollection
static StMuFstCollection * muFstCollection()
returns pointer to current StMuFstCollection
Definition: StMuDst.h:399
StMuDst::otherTracks
static StMuTrack * otherTracks(int i)
return pointer to i-th other track (track that is not flagged as primary of global) ...
Definition: StMuDst.h:330
StMuDst::globalTracks
static StMuTrack * globalTracks(int i)
return pointer to i-th global track
Definition: StMuDst.h:328
StMuDst::l3Tracks
static StMuTrack * l3Tracks(int i)
return pointer to i-th l3 track
Definition: StMuDst.h:332
StMuDst::primaryTracks
static TObjArray * primaryTracks()
returns pointer to a list of tracks belonging to the selected primary vertex
Definition: StMuDst.h:301
StMuDst::rhicfArray
static TClonesArray * rhicfArray(int type)
returns pointer to the n-th TClonesArray from the rhicf arrays
Definition: StMuDst.h:273
StMuDst::fcsArray
static TClonesArray * fcsArray(int type)
returns pointer to the n-th TClonesArray from the fcs arrays
Definition: StMuDst.h:275
StMuDst::etofArray
static TClonesArray * etofArray(int type)
returns pointer to the n-th TClonesArray from the etof arrays // FS
Definition: StMuDst.h:289
StMuDst::fwdTrackArray
static TClonesArray * fwdTrackArray(int type)
returns pointer to the n-th TClonesArray from the rhicf arrays
Definition: StMuDst.h:281
StMuDst::rhicfArrays
static TClonesArray ** rhicfArrays
array of TClonesArrays for the stuff inherited from the RHICf
Definition: StMuDst.h:196
StMuDst::l3AlgoReject
static TClonesArray * l3AlgoReject()
returns pointer to list rejected l3 algorithms
Definition: StMuDst.h:315
StV0Mc
Definition: StV0Mc.hh:17
StMuDst::detectorStates
static StDetectorState * detectorStates(int i)
returns pointer to i-th StDetectorState
Definition: StMuDst.h:336
StMuDst::muEmcCollection
static StMuEmcCollection * muEmcCollection()
returns pointer to current StMuEmcCollection
Definition: StMuDst.h:389
StMuDst::event
static StMuEvent * event()
returns pointer to current StMuEvent (class holding the event wise information, e.g. event number, run number)
Definition: StMuDst.h:320
StMuDst::StMuDst
StMuDst()
constructor
Definition: StMuDst.cxx:99
StMuDst::mRHICfCollection
static StRHICfCollection * mRHICfCollection
pointer to RHICfCollecion (for RHICf clusterfinding etc)
Definition: StMuDst.h:244
StMuDst::v0sMc
static TClonesArray * v0sMc()
returns pointer to the mc v0 list
Definition: StMuDst.h:356
StMuDst::trackGeometry
static StTrackGeometry * trackGeometry(int q, StPhysicalHelixD *h)
helper function to create a StTrackGeometry
Definition: StMuDst.cxx:922
StMuDst::etofDigi
static StMuETofDigi * etofDigi(int i)
returns pointer to the i-th StMuEtofDigi
Definition: StMuDst.h:427
StMuDst::tofHit
static StMuTofHit * tofHit(int i)
returns pointer to the i-th muTofHit
Definition: StMuDst.h:412
StMuDst::v0Assoc
static TClonesArray * v0Assoc()
returns pointer to the v0 association list
Definition: StMuDst.h:358
StMuDst::createStTrack
static StTrack * createStTrack(const StMuTrack *)
creates a StTrack from an StMuTrack and return pointer to it
Definition: StMuDst.cxx:936
StMuDst::xis
static TClonesArray * xis()
returns pointer to the xi list
Definition: StMuDst.h:360
StMuDst::strangeArrays
static TClonesArray ** strangeArrays
array of TClonesArrays for the stuff inherited from the StStrangeMuDst
Definition: StMuDst.h:188
StXiMc
Definition: StXiMc.hh:17
StMuDst::strangeEventMc
static StStrangeEvMuDst * strangeEventMc()
returns pointer to MC version of current StStrangeEvMuDst
Definition: StMuDst.h:352
StMuDst::addETofHit
void addETofHit(const StMuETofHit *hit)
Definition: StMuDst.cxx:679
StMuDst::emcArrays
static TClonesArray ** emcArrays
array of TClonesArrays for the stuff inherited from the Emc
Definition: StMuDst.h:192
StMuDst::btofHeader
static StBTofHeader * btofHeader()
returns pointer to the btofHeader - dongx
Definition: StMuDst.h:423
StMuDst::array
static TClonesArray * array(int type)
returns pointer to the n-th TClonesArray
Definition: StMuDst.h:262
StMuDst::mMuFcsCollection
static StMuFcsCollection * mMuFcsCollection
pointer to FcsCollection (manages the FcsArrays)
Definition: StMuDst.h:230
StMuDst::kinks
static TClonesArray * kinks()
returns pointer to the kink list
Definition: StMuDst.h:366
StMuDst::rhicfCollection
static StRHICfCollection * rhicfCollection()
returns pointer to current StRHICfCollection
Definition: StMuDst.h:409
StMuDst::epdArrays
static TClonesArray ** epdArrays
array of TClonesArrays for Epd
Definition: StMuDst.h:214
StMuDst::setMtdArray
void setMtdArray(StMtdCollection *mtd_coll)
Definition: StMuDst.cxx:632
StMuDst::emcCollection
static StEmcCollection * emcCollection()
returns pointer to current StEmcCollection
Definition: StMuDst.h:405
StMuDst::fgtArray
static TClonesArray * fgtArray(int type)
returns pointer to the n-th TClonesArray from the fgt arrays
Definition: StMuDst.h:293
StMuDst::xis
static StXiMuDst * xis(int i)
returns pointer to the i-th xi
Definition: StMuDst.h:378
StMuDst::setEmcCollection
static void setEmcCollection(StEmcCollection *emc_coll)
set pointer to current StEmcCollection
Definition: StMuDst.h:146
StMuDst::currentVertexIndex
static Int_t currentVertexIndex()
Get the index number of the current primary vertex.
Definition: StMuDst.h:260
StMuDst::etofArrays
static TClonesArray ** etofArrays
array of TClonesArrays for ETof
Definition: StMuDst.h:212
StMuDst::createStEvent
StEvent * createStEvent()
creates a StEvent from the StMuDst (this) and returns a pointer to it. (This function is not yet fini...
Definition: StMuDst.cxx:702
StMuDst::fstArrays
static TClonesArray ** fstArrays
array of TClonesArrays for the stuff inherited from the Fst
Definition: StMuDst.h:202
StMuDst::fwdTrackArrays
static TClonesArray ** fwdTrackArrays
array of TClonesArrays for the stuff inherited from the FWD Tracks
Definition: StMuDst.h:204
StMuDst::setVertexIndex
static void setVertexIndex(Int_t vtx_id)
Set the index number of the current primary vertex (used by both primaryTracks() functions and for St...
Definition: StMuDst.cxx:273
StMuDst::tofArray
static TClonesArray * tofArray(int type)
returns pointer to the n-th TClonesArray from the tof arrays
Definition: StMuDst.h:285
StMuDst::arrays
static TClonesArray ** arrays
array of TClonesArrays
Definition: StMuDst.h:185
StMuDst::mMuFwdTrackCollection
static StMuFwdTrackCollection * mMuFwdTrackCollection
pointer to FwdTrackCollection (manages the FwdTrackArrays)
Definition: StMuDst.h:236
StMuDst::mCurrVertexId
static Int_t mCurrVertexId
Index number of current primary vertex.
Definition: StMuDst.h:250
StMuDst::btofArrays
static TClonesArray ** btofArrays
array of TClonesArrays for the stuff inherited from the BTOF // dongx
Definition: StMuDst.h:210
StMuDst::emcArray
static TClonesArray * emcArray(int type)
returns pointer to the n-th TClonesArray from the emc arrays
Definition: StMuDst.h:269
StMuDst::mFmsCollection
static StFmsCollection * mFmsCollection
pointer to FmsCollecion (for Fms clusterfinding etc)
Definition: StMuDst.h:242
StMuDst::primaryVertex
static StMuPrimaryVertex * primaryVertex(int i)
return pointer to i-th primary vertex
Definition: StMuDst.h:324
StMuDst::richSpectra
static TClonesArray * richSpectra()
returns pointer to the list of rich spectra
Definition: StMuDst.h:309
Generated by   doxygen 1.8.5