StRoot  1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
StMuDstMaker.h
1 /***************************************************************************
2  *
3  * $Id: StMuDstMaker.h,v 1.66 2021/05/11 19:40:43 jdb Exp $
4  * Author: Frank Laue, BNL, laue@bnl.gov
5  ***************************************************************************/
6 #ifndef StMuDstMaker_hh
7 #define StMuDstMaker_hh
8 
9 #include <string>
10 
11 #ifndef ST_NO_NAMESPACES
12 using namespace std;
13 #endif
14 
15 #include "StMaker.h"
16 #include "StChain.h"
17 #include "StIOInterFace.h"
18 #include "St_DataSetIter.h"
19 
20 #include "StMuArrays.h"
21 
22 #include "StMuFilter.h"
23 #include "StMuL3Filter.h"
24 
25 
26 class StMuEvent;
27 class StMuDst;
28 class StMuCut;
29 
30 class StEvent;
31 class StTrackNode;
32 class StTrack;
33 class StVertex;
34 class StRichSpectra;
35 class StDetectorState;
36 class StL3AlgorithmInfo;
37 
39 
40 class StIOMaker;
41 class StTreeMaker;
42 #ifndef __NO_STRANGE_MUDST__
43 class StStrangeEvMuDst;
46 class StV0MuDst;
47 class StV0Mc;
48 class StXiMuDst;
49 class StXiMc;
50 class StKinkMuDst;
51 class StKinkMc;
52 class StStrangeAssoc;
53 class StStrangeCuts;
54 #endif
55 #include "StMuEmcCollection.h"
57 class StMuEmcUtil;
58 
60 #include "StMuFmsCollection.h"
61 class StMuFmsUtil;
62 
64  #include "StMuRHICfCollection.h"
65  class StMuRHICfUtil;
66 
68 #include "StMuFcsCollection.h"
69 class StMuFcsUtil;
70 
72 #include "StMuFttCollection.h"
73 class StMuFttUtil;
74 
76 #include "StMuFstCollection.h"
77 class StMuFstUtil;
78 
80 #include "StMuFwdTrackCollection.h"
81 class StMuFwdTrackUtil;
82 
83 #include "StMuEpdHitCollection.h" // MALisa
84 class StMuEpdUtil;
86 #include "StMuPmdCollection.h"
87 class StMuPmdUtil;
88 
89 // tof stuff
90 class StMuTofHit;
92 class StTofCollection;
94 // run 5 - dongx
96 class StMuTofUtil;
97 // new btof
98 class StBTofCollection;
100 class StMuBTofHit;
102 class StMuBTofUtil;
103 
104 // ezTree stuff
105 class StMuEzTree;
106 
107 class TFile;
108 class TTree;
109 class TChain;
110 class TClonesArray;
111 class TEventList;
112 
113 class StMuRpsCollection;
114 class StMuMtdCollection;
115 
116 class StMuMtdHit;
117 class StMuMtdRawHit;
118 class StMuMtdHeader;
119 
131 class StMuDstMaker : public StIOInterFace {
132  public:
134  StMuDstMaker(const char* name="MuDst");
136  StMuDstMaker(int mode, int nameMode, const char* dirName="./", const char* fileName="", const char* filter=".", int maxfiles=10,
137  const char* name="MuDst");
138 
139  ~StMuDstMaker();
140 
141  virtual int Init();
142  virtual void Clear(Option_t *option="");
143  virtual int Make();
144  virtual Int_t MakeRead(const StUKey &RunEvent);
145  virtual Int_t MakeRead();
146  virtual Int_t MakeWrite();
147  virtual int Finish();
148  void printArrays();
149  void SetStatus(const char *arrType,int status);
151  void SetEventList( TEventList *e ) { mEventList = e; }
153  void setTrackFilter(StMuCut* c);
154  StMuFilter* trackFilter();
156  void setL3TrackFilter(StMuCut* c);
157  StMuL3Filter* l3TrackFilter();
159 
174  void setProbabilityPidFile(const char* file=NULL);
177  StMuDst* muDst();
179  TChain* chain();
181  TTree* tree();
182 
184  virtual const char *GetFile() const;
185 
187  void setSplit(int=99);
189  void setBufferSize(int=65536*4);
191  void setCompression(int comp=9);
192 
193  StMuEmcUtil* muEmcUtil() { return mEmcUtil; }
194  StMuFmsUtil* muFmsUtil() { return mFmsUtil; }
195  StMuRHICfUtil* muRHICfUtil() { return mRHICfUtil; }
196  StMuFcsUtil* muFcsUtil() { return mFcsUtil; }
197  StMuFttUtil* muFttUtil() { return mFttUtil; }
198  StMuFstUtil* muFstUtil() { return mFstUtil; }
199  StMuFwdTrackUtil* muFwdTrackUtil() { return mFwdTrackUtil; }
200  StMuPmdUtil* muPmdUtil() { return mPmdUtil; }
201 
202  virtual const char *GetCVS() const {
203 
204  static const char cvs[]="Tag $Name: $ $Id: StMuDstMaker.h,v 1.66 2021/05/11 19:40:43 jdb Exp $ built " __DATE__ " " __TIME__ ;
205  return cvs;
206  }
207 
208 
209 
210 protected:
212  void connectEmcCollection();
213  void connectFmsCollection();
214  void connectRHICfCollection();
215  void connectFcsCollection();
216  void connectFttCollection();
217  void connectFstCollection();
218  void connectFwdTrackCollection();
219  void connectPmdCollection();
220  enum ioMode {ioRead, ioWrite};
229  enum ioNameMode {ioFix=0, ioIOMaker, ioTreeMaker};
230 
231  StEvent* mStEvent;
232  StMuDst* mStMuDst;
233 #ifndef __NO_STRANGE_MUDST__
234  StStrangeMuDstMaker* mStStrangeMuDstMaker;
235 #endif
236  StIOMaker* mIOMaker;
237  StTreeMaker* mTreeMaker;
238  StMuEmcUtil* mEmcUtil;
239  StMuFmsUtil* mFmsUtil;
240  StMuRHICfUtil* mRHICfUtil;
241  StMuFcsUtil* mFcsUtil;
242  StMuFttUtil* mFttUtil;
243  StMuFstUtil* mFstUtil;
244  StMuFwdTrackUtil* mFwdTrackUtil;
245  StMuPmdUtil* mPmdUtil;
246  StMuTofUtil* mTofUtil;
249  StMuEpdUtil* mEpdUtil; // MALisa
250  StMuEzTree* mEzTree;
251 
252  int mIoMode;
253  int mIoNameMode;
254  string mDirName;
255  string mFileName;
256  string mFilter;
257  int mMaxFiles;
258 
259  TEventList *mEventList;
260 
261  unsigned int mTrackType;
262  bool mReadTracks;
263  bool mReadV0s;
264  bool mReadXis;
265  bool mReadKinks;
266  bool mFinish;
267 
268  StMuCut* mTrackFilter;
269  StMuCut* mL3TrackFilter;
270 
271  TFile* mCurrentFile;
272  string mCurrentFileName;
273 
274  TChain* mChain;
275  TTree* mTTree;
276 
277  int mEventCounter;
278  int mSplit;
279  int mCompression;
280  int mBufferSize;
281 
282  TObjArray mVtxList; // List of pointers to vertices to keep track of track-vertex assignment when copying from StEvent
283 
284  StuProbabilityPidAlgorithm* mProbabilityPidAlgorithm;
285 
286 
287 #define saveDelete(t) { delete t; t=0;}
288 
290 
291 virtual void openWrite(string fileName);
292 virtual void write();
293 virtual void closeWrite();
294 
295  void streamerOff();
296 
297 virtual int openRead();
298 virtual void read();
299 void setBranchAddresses();
300 virtual void closeRead();
301 
302  void setBranchAddresses(TChain*);
303 
304  void assignArrays();
305  void clearArrays();
306  void zeroArrays();
307  void createArrays();
308  TClonesArray* clonesArray(TClonesArray*& p, const char* type, int size, int& counter);
309 
310  void fill();
311  void fillTrees(StEvent* ev, StMuCut* cut=0);
312  void fillEvent(StEvent* ev, StMuCut* cut=0);
313  void fillVertices(StEvent* ev);
314  void fillpp2pp(StEvent* ev);
315 
316  void fillsttrigger(StEvent* ev);
317  void fillPmd(StEvent* ev);
318  void fillEpd(StEvent* ev); // MALisa
319  void fillEmc(StEvent* ev);
320  void fillFms(StEvent* ev);
321  void fillRHICf(StEvent* ev);
322  void fillFcs(StEvent* ev);
323  void fillFtt(StEvent* ev);
324  void fillFst(StEvent* ev);
325  void fillFwdTrack(StEvent* ev);
326 #ifndef __NO_STRANGE_MUDST__
327  void fillStrange(StStrangeMuDstMaker*);
328 #endif
329  void fillMC();
330  void fillL3Tracks(StEvent* ev, StMuCut* cut=0);
331  void fillTracks(StEvent* ev, StMuCut* cut=0);
332  void fillDetectorStates(StEvent* ev);
333  void fillL3AlgorithmInfo(StEvent* ev);
334  void fillTof(StEvent* ev);
336  void fillBTof(StEvent* ev);
337  void fillETof(StEvent* ev); // jdb
338  void fillMtd(StEvent* ev);
339  void fillFgt(StEvent* ev);
340 
341  void fillEzt(StEvent* ev);
342 
343  void fillHddr();
344 
345  template <class T, class U> int addType(TClonesArray* tcaTo , U &u, T *t);
346  template <class T> int addType(TClonesArray* tcaFrom, TClonesArray* &tcaTo ,T *t);
347  template <class T> int addType(TClonesArray* tcaTo , T &t);
348  void addTrackNode(const StEvent* ev, const StTrackNode* node, StMuCut* cut, TClonesArray* gTCA=0, TClonesArray* pTCA=0, TClonesArray* oTCA=0,
349  TClonesArray* covgTCA=0, TClonesArray* covpTCA=0, bool l3=false);
350  int addTrack(TClonesArray* tca, const StEvent* event, const StTrack* track, const StVertex *vtx, StMuCut* cut, int index2Global, bool l3=false,
351  TClonesArray* covgTCA=0, TClonesArray* covpTCA=0);
352 /* int addType(TClonesArray* tcaTo , StMuEmcCollection t); */
353 
354  StRichSpectra* richSpectra(const StTrack* track);
355 
356  void setStEvent(StEvent*);
357  StEvent* stEvent();
358 #ifndef __NO_STRANGE_MUDST__
359  void setStStrangeMuDstMaker(StStrangeMuDstMaker*);
360  StStrangeMuDstMaker* stStrangeMuDstMaker();
361 #endif
362  unsigned int trackType();
363  bool readTracks();
364 #ifndef __NO_STRANGE_MUDST__
365  bool readV0s();
366  bool readXis();
367  bool readKinks();
368 #endif
369  void setTrackType(unsigned int);
370  void setReadTracks(bool);
371 #ifndef __NO_STRANGE_MUDST__
372  void setReadV0s(bool);
373  void setReadXis(bool);
374  void setReadKinks(bool);
375 #endif
376  string basename(string);
377  string dirname(string);
378  string buildFileName(string dir, string fileName, string extention);
379 
380  friend class StMuDst;
381  friend class StMuDstFilterMaker;
382 
383  // Beware that this was added to counteract contiguous memory.
384  // See implementation for caveat
385  TClonesArray* mAArrays [__NALLARRAYS__];
386  TClonesArray** mArrays; //[__NARRAYS__ ];
387 #ifndef __NO_STRANGE_MUDST__
388  TClonesArray** mStrangeArrays;//[__NSTRANGEARRAYS__];
389 #endif
390  TClonesArray** mMCArrays;//[__NMCARRAYS__];
391  TClonesArray** mEmcArrays; //[__NEMCARRAYS__ ];
392  TClonesArray** mFmsArrays; //[__NFMSARRAYS__ ];
393  TClonesArray** mRHICfArrays; //[__NRHICFARRAYS__ ];
394  TClonesArray** mFcsArrays; //[__NFCSARRAYS__ ];
395  TClonesArray** mFttArrays; //[__NFTTARRAYS__ ];
396  TClonesArray** mFstArrays; //[__NFSTARRAYS__ ];
397  TClonesArray** mFwdTrackArrays; //[__NFWDTRACKARRAYS__ ];
398  TClonesArray** mPmdArrays; //[__NPMDARRAYS__ ];
399  TClonesArray** mTofArrays; //[__NTOFARRAYS__ ];
401  TClonesArray** mBTofArrays; //[__NBTOFARRAYS__ ];
402  TClonesArray** mETofArrays; //[__NETofARRAYS__ ]; /// jdb
403  TClonesArray** mEpdArrays; //[__NEPDARRAYS__ ]; /// MALisa
404  TClonesArray** mMtdArrays; //[__NMTDARRAYS__ ];
405  TClonesArray** mFgtArrays; //[__NFGTARRAYS__ ];
406  TClonesArray** mEztArrays; //[__NEZTARRAYS__ ];
407 
408  char mStatusArrays [__NALLARRAYS__ ];
409  TClonesArray* mEmcCollectionArray; // Needed to hold old format
410  StMuEmcCollection *mEmcCollection;
411  StMuFmsCollection *mFmsCollection;
412  StMuRHICfCollection *mRHICfCollection;
413  StMuFcsCollection *mFcsCollection;
414  StMuFttCollection *mFttCollection;
415  StMuFstCollection *mFstCollection;
416  StMuFwdTrackCollection *mFwdTrackCollection;
417  TClonesArray* mPmdCollectionArray; // Needed to hold old format
418  StMuPmdCollection *mPmdCollection;
419  // StMuEpdHitCollection *mMuEpdHitCollection; // MALisa
420 
421  // Increment this by 1 every time the class structure is changed
422  ClassDef(StMuDstMaker, 9)
423 };
424 
425 inline StMuDst* StMuDstMaker::muDst() { return mStMuDst;}
426 inline TChain* StMuDstMaker::chain() { return mChain; }
427 inline TTree* StMuDstMaker::tree() { return mTTree; }
428 inline void StMuDstMaker::setTrackFilter(StMuCut* c) { mTrackFilter=c;}
429 inline void StMuDstMaker::setL3TrackFilter(StMuCut* c) { mL3TrackFilter=c;}
430 inline StMuFilter* StMuDstMaker::trackFilter() { return (StMuFilter*)mTrackFilter;}
431 inline StMuL3Filter* StMuDstMaker::l3TrackFilter() { return (StMuL3Filter*)mL3TrackFilter;}
432 #ifndef __NO_STRANGE_MUDST__
433 inline void StMuDstMaker::setStStrangeMuDstMaker(StStrangeMuDstMaker* s) {mStStrangeMuDstMaker=s;}
434 inline StStrangeMuDstMaker* StMuDstMaker::stStrangeMuDstMaker() {return mStStrangeMuDstMaker;}
435 #endif
436 inline void StMuDstMaker::setTrackType(unsigned int t) {mTrackType=t;}
437 inline unsigned int StMuDstMaker::trackType() {return mTrackType;}
438 
439 inline bool StMuDstMaker::readTracks() { return mReadTracks;}
440 #ifndef __NO_STRANGE_MUDST__
441 inline bool StMuDstMaker::readV0s() { return mReadV0s;}
442 inline bool StMuDstMaker::readXis() { return mReadXis;}
443 inline bool StMuDstMaker::readKinks() { return mReadKinks;}
444 #endif
445 inline void StMuDstMaker::setReadTracks(bool b) { mReadTracks=b;}
446 #ifndef __NO_STRANGE_MUDST__
447 inline void StMuDstMaker::setReadV0s(bool b) { mReadV0s=b;}
448 inline void StMuDstMaker::setReadXis(bool b) { mReadXis=b;}
449 inline void StMuDstMaker::setReadKinks(bool b) { mReadKinks=b;}
450 #endif
451 
452 inline void StMuDstMaker::setSplit(int split) { mSplit = split;}
453 inline void StMuDstMaker::setCompression(int comp) { mCompression = comp;}
454 inline void StMuDstMaker::setBufferSize(int buf) { mBufferSize = buf; }
455 
456 
457 #endif
458 
459 /***************************************************************************
460  *
461  * $Log: StMuDstMaker.h,v $
462  * Revision 1.66 2021/05/11 19:40:43 jdb
463  * StETofHeader update from philipp W. modified classes to include the front-end missmatch pattern
464  *
465  * Revision 1.65 2019/02/21 14:00:02 jdb
466  * Bumped the ClassDef versions in MuDst where eTOF was added. I also added the etofTypes to the LinkDef file
467  *
468  * Revision 1.64 2019/02/21 13:32:54 jdb
469  * 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
470  *
471  * Revision 1.63 2018/03/15 22:00:35 smirnovd
472  * Fix linker error by removing declared but undefined functions
473  *
474  * Revision 1.62 2018/02/27 04:15:02 jdb
475  * added EPD support and fixed long standing bug in SetStatus, cleaned up
476  *
477  * Revision 1.61 2015/08/28 18:36:03 jdb
478  * Added Akios FMS codes
479  *
480  * Revision 1.59 2013/07/23 11:02:59 jeromel
481  * Undo changes (KF and other)
482  *
483  * Revision 1.57 2013/04/10 19:28:35 jeromel
484  * Step back to 04/04 version (van aware) - previous changes may be recoverred
485  *
486  * Revision 1.55 2012/11/15 22:26:13 sangalin
487  * Added the FGT. Fixed bugs in array offsets for the MTD.
488  *
489  * Revision 1.54 2012/09/28 22:38:05 tone421
490  * Changed array stucture of MTD upon request of the TOF group. MTD arrays now on top level, rather than within __NARRAYS__
491  *
492  * Revision 1.53 2011/05/04 19:51:32 tone421
493  * Added MTD infomation
494  *
495  * Revision 1.52 2011/04/08 01:25:50 fisyak
496  * Add branches for MC track and vertex information, add IdTruth to tracks and vertices, reserve a possiblity to remove Strange MuDst
497  *
498  * Revision 1.51 2010/05/26 04:25:50 tone421
499  * Added StTriggerData arrays in muevent and fixed an issue with PMD arrays being read....
500  *
501  * Revision 1.50 2010/01/25 03:57:39 tone421
502  * Added FMS and Roman pot arrays
503  *
504  * Revision 1.49 2010/01/21 02:08:17 fine
505  * RT #1803: Restore the broken MakeRead/MakeWrite interface to fix Skip event method
506  *
507  * Revision 1.48 2009/02/20 16:37:44 tone421
508  * *** empty log message ***
509  *
510  * Revision 1.46 2008/03/19 14:51:04 fisyak
511  * Add two clone arrays for global and primary track covariance matrices, remove mSigmaDcaD and mSigmaDcaZ
512  *
513  * Revision 1.45 2007/04/20 06:26:01 mvl
514  * Removed Q-vector calculation. Will implement utility class instead.
515  *
516  * Revision 1.43 2007/02/07 07:53:09 mvl
517  * Added SetEventList function to read only pre-selected events (by J. Webb)
518  *
519  * Revision 1.42 2006/02/08 23:35:36 mvl
520  * Added overloaded version for StIOInterface::GetFile() to return name
521  * of current input or output file (depending on read or write mode)
522  * StIOInterface::GetFileName() is an alias for this function.
523  *
524  * Revision 1.41 2005/07/15 21:45:09 mvl
525  * 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())
526  *
527  * Revision 1.40 2005/04/12 21:56:29 mvl
528  * Changes by Xin Dong for year-5 TOF data format: extra TClonesArray and routines to fill it from StEvent (StTofRawData).
529  *
530  * Revision 1.39 2004/10/28 00:11:33 mvl
531  * Added stuff to support ezTree mode of MuDstMaker.
532  * This is a special mode for fast-online processing of fast-detector data.
533  *
534  * Revision 1.38 2004/10/19 01:42:29 mvl
535  * Changes for splitting Emc and Pmd collections. Emc clusters and points dropped
536  *
537  * Revision 1.37 2004/09/18 20:35:09 jeromel
538  * Little bit baffled by what CVS did around here
539  * http://www.star.bnl.gov/cgi-bin/cvsweb.cgi/StRoot/StMuDSTMaker/COMMON/StMuDstMaker.h.diff?r1=1.35&r2=1.36
540  * but re-comitting without the mess up (seems like source and h were merged)
541  *
542  * Revision 1.35 2004/09/18 01:28:18 jeromel
543  * *** empty log message ***
544  *
545  * Revision 1.34 2004/05/04 00:09:17 perev
546  *
547  * // Selecting SetBranchStatus for particular MuDst branches
548  * // Special names:
549  * // MuEventAll - all branches related to StMuEvent
550  * // StrangeAll - all branches related to StrangeMuDst
551  * // EmcAll - all branches related to Emc
552  * // PmdAll - all branches related to Pmd
553  * // TofAll - all branches related to Tof
554  * // By default all branches of MuDst are read. If user wants to read only some of
555  * // them, then:
556  * // SetStatus("*",0) // all branches off
557  * // SetStatus("MuEventAll",1) // all standard MuEvent branches ON
558  * // SetStatus("StrangeAll",1) // all standard Strange branches ON
559  * // SetStatus("EmcAll" ,1) // all standard Emc branches ON
560  * // SetStatus("PmdAll" ,1) // all standard Pmd branches ON
561  * // SetStatus("TofAll" ,1) // all standard Tof branches ON
562  * //
563  * // SetStatus("XiAssoc" ,1) // Strange branch "XiAssoc" is ON
564  * // Names of branches look StMuArrays::arrayTypes[]
565  * // It allows to speed up reading MuDst significantly
566  *
567  * Revision 1.33 2004/04/26 00:13:28 perev
568  * Cleanup+simplification
569  *
570  * Revision 1.32 2004/04/20 18:42:40 perev
571  * remove redundant arrays
572  *
573  * Revision 1.31 2004/04/15 00:26:14 perev
574  * fillHddr() added to fill time stamp ...
575  *
576  * Revision 1.30 2004/04/09 22:03:47 subhasis
577  * after tof createevent fix by Xin
578  *
579  * Revision 1.29 2004/04/09 03:36:15 jeromel
580  * Removed TOF support entirely for now as we need a working version ... Will
581  * revisit later.
582  *
583  * Revision 1.28 2004/04/02 03:24:54 jeromel
584  * Changes implements PMD and TOF. TOF is clearly incomplete.
585  *
586  * Revision 1.27 2004/02/17 04:56:36 jeromel
587  * Extended help, added crs support, restored __GNUC__ for PRETTY_FUNCTION(checked once
588  * more and yes, it is ONLY defined in GCC and so is __FUCTION__), use of a consistent
589  * internal __PRETTYF__, return NULL if no case selected (+message) and protected against
590  * NULL mChain.
591  *
592  * Revision 1.26 2003/11/09 01:02:59 perev
593  * more sofisticated clear() to fix leaks
594  *
595  * Revision 1.25 2003/10/30 20:08:13 perev
596  * Check of quality added
597  *
598  * Revision 1.24 2003/10/27 23:54:33 perev
599  * weird template bug fized and templates simplified
600  *
601  * Revision 1.23 2003/10/20 19:50:13 perev
602  * workaround added for TClonesArray::Delete + some cleanup of MuEmc
603  *
604  * Revision 1.22 2003/09/19 01:45:18 jeromel
605  * A few problems hopefully fixed i.e. one constructor lacked zeroing
606  * emcArrays were not zeroed, mStMuDst not zeroed.
607  * For maintainability zeroArrays() added.
608  *
609  * Revision 1.21 2003/09/02 17:58:44 perev
610  * gcc 3.2 updates + WarnOff
611  *
612  * Revision 1.20 2003/04/15 18:48:36 laue
613  * Minor changes to be able to filter MuDst.root files and an example
614  * how to do this. The StMuDstFilterMaker is just an example, it has to be
615  * customized (spoilers, chrome weels, etc.) by the user.
616  *
617  * Revision 1.19 2003/02/19 15:38:10 jeromel
618  * Modifications made to account for the new location of the PIDTable file.
619  * The setProbabilityPidFile() method has been modified to take care of a default
620  * file loading if unspecified. Messages will be displayed appropriatly.
621  * Macros mdoofied to not call the method (leave it handled through the default
622  * file).
623  *
624  * Revision 1.18 2003/01/29 03:04:57 laue
625  * !!DIRTY FIX FOR StMuEmcCollection
626  * !! Was memor leaking. Leak fixed, but slow and dirty.
627  * !! Propose to change the structure as soon as possible.
628  *
629  * Revision 1.17 2003/01/23 21:59:50 laue
630  * Modification to compile on Solaris.
631  *
632  * Revision 1.16 2003/01/09 18:59:45 laue
633  * initial check in of new EMC classes and the changes required
634  *
635  * Revision 1.15 2002/11/08 14:18:59 laue
636  * saveDelete(<T>) added, sets pointer=null after delete
637  *
638  * Revision 1.14 2002/09/11 21:02:41 laue
639  * added cut on track encoded method for ITTF
640  *
641  * Revision 1.13 2002/08/20 19:55:49 laue
642  * Doxygen comments added
643  *
644  * Revision 1.12 2002/05/20 17:23:31 laue
645  * StStrangeCuts added
646  *
647  * Revision 1.11 2002/05/04 23:56:30 laue
648  * some documentation added
649  *
650  * Revision 1.10 2002/04/26 20:57:31 jeromel
651  * Added GetCVS()
652  *
653  * Revision 1.9 2002/04/11 14:19:30 laue
654  * - update for RH 7.2
655  * - decrease default arrays sizes
656  * - add data base readerfor number of events in a file
657  *
658  * Revision 1.8 2002/04/01 22:42:30 laue
659  * improved chain filter options
660  *
661  * Revision 1.7 2002/03/28 05:10:34 laue
662  * update for running in the production
663  *
664  * Revision 1.6 2002/03/27 03:47:27 laue
665  * better filter options
666  *
667  * Revision 1.5 2002/03/27 00:50:11 laue
668  * bux fix from earlier check in
669  *
670  * Revision 1.4 2002/03/26 19:33:15 laue
671  * minor updates
672  *
673  * Revision 1.3 2002/03/20 16:04:11 laue
674  * minor changes, mostly added access functions
675  *
676  * Revision 1.2 2002/03/08 20:04:31 laue
677  * change from two trees to 1 tree per file
678  *
679  *
680  **************************************************************************/
TTree * tree()
Returns pointer to the current TTree, the top level io structure that holds the event, track, v0, etc. information in branches of that tree.
Definition: StMuDstMaker.h:427
StMuDst * muDst()
Definition: StMuDstMaker.h:425
StMuFstUtil * muFstUtil()
return pointer to StMuFstUtil;
Definition: StMuDstMaker.h:198
StMuEmcUtil * muEmcUtil()
return pointer to StMuEmcUtil;
Definition: StMuDstMaker.h:193
void setBufferSize(int=65536 *4)
Sets the buffer size for all branches.
Definition: StMuDstMaker.h:454
void setL3TrackFilter(StMuCut *c)
Set the track filter used for L3 tracks when creating muDsts from StEvent and writing to disk...
Definition: StMuDstMaker.h:429
virtual const char * GetCVS() const
Definition: StMuDstMaker.h:202
TClonesArray * mArrays[__NARRAYS__]
the list of TClonesArrays to copy
StMuFcsUtil * muFcsUtil()
return pointer to StMuFcsUtil;
Definition: StMuDstMaker.h:196
void setTrackFilter(StMuCut *c)
Set the track filter used for all tracks (except the L3 tracks) when creating muDsts from StEvent and...
Definition: StMuDstMaker.h:428
StMuBTofUtil * mBTofUtil
dongx
Definition: StMuDstMaker.h:248
Definition: StV0Mc.hh:17
TClonesArray ** mBTofArrays
dongx
Definition: StMuDstMaker.h:401
StMuRHICfUtil * muRHICfUtil()
return pointer to StMuRHICfUtil;
Definition: StMuDstMaker.h:195
TChain * chain()
In read mode, returns pointer to the chain of .MuDst.root files that where selected.
Definition: StMuDstMaker.h:426
Definition: StXiMc.hh:17
StMuFttUtil * muFttUtil()
return pointer to StMuFttUtil;
Definition: StMuDstMaker.h:197
Definition: StFileI.h:13
void setCompression(int comp=9)
Sets the compression level for the file and all branches. 0 means no compression, 9 is the higher com...
Definition: StMuDstMaker.h:453
void setSplit(int=99)
Sets the split level for the file and all branches. Please refer to the ROOT manual (http://root...
Definition: StMuDstMaker.h:452
StMuFmsUtil * muFmsUtil()
return pointer to StMuFmsUtil;
Definition: StMuDstMaker.h:194
void SetEventList(TEventList *e)
Set event list for reading only preselected events (generate list using chain()-&gt;Draw() ...
Definition: StMuDstMaker.h:151
StMuFwdTrackUtil * muFwdTrackUtil()
return pointer to StMuFwdTrackUtil;
Definition: StMuDstMaker.h:199
StMuPmdUtil * muPmdUtil()
return pointer to StMuPmdUtil;
Definition: StMuDstMaker.h:200