StRoot: StStrangeMuDstMaker/StStrangeMuDstMaker.h Source File

00001 
00011 #ifndef STAR_StStrangeMuDstMaker
00012 #define STAR_StStrangeMuDstMaker
00013 #include "StMaker.h"
00014 #include "TClonesArray.h"
00015 #include "StStrangeControllerBase.h"
00016 
00017 class TFile;
00018 class TTree;
00019 class TChain;
00020 class StStrangeMuDst;
00021 class StStrangeEvMuDst;
00022 class StV0I;
00023 class StV0MuDst;
00024 class StV0Mc;
00025 class StXiI;
00026 class StXiMuDst;
00027 class StXiMc;
00028 class StKinkI;
00029 class StKinkMuDst;
00030 class StKinkMc;
00031 class StStrangeAssoc;
00032 class StFile;
00033 class StStrangeCuts;
00034 
00036 enum StrDstType  {
00038   evT = 0,
00040   v0T,
00042   xiT,
00044   kinkT,
00045   strDstT};
00046 
00048 static const char* strTypeNames[strDstT] = {"Ev","V0","Xi","Kink"};
00050 enum StrangeEnum {StrangeNoKeep, StrangeNoFile, StrangeWrite, StrangeRead};
00051 
00052 class StStrangeMuDstMaker : public StMaker {
00053  public: 
00054   StStrangeMuDstMaker(const char *name="strangeMuDst");
00055   virtual ~StStrangeMuDstMaker();
00056   void DoT0JitterAbort(Bool_t doIt=kTRUE);
00058   void AbortEvent() { abortEvent = kTRUE; }
00059 
00061 
00062   void SetCorrectionFile(char*);
00063   void SetFractionFile(char*);
00065 
00067 
00068   void SetRead (const char* eFile=0, const char* treeName=0);
00069   void SetRead (StFile* eFiles, const char* treeName=0);
00070   void SetWrite(const char* eFile);
00071   void SetWrite(){SetWrite(0);}
00072   void SetNoKeep();
00073   char* GetFile();
00075 
00077 
00078   void DoV0(Bool_t doIt=kTRUE);
00079   void DoXi(Bool_t doIt=kTRUE);
00080   void DoKink(Bool_t doIt=kTRUE);
00081   void DoMc(Bool_t doIt=kTRUE);
00082   void Do(Int_t dstType, Bool_t doIt=kTRUE);
00083   void Do(const char* name, Bool_t doIt=kTRUE);
00084   Bool_t GetDoMc();
00086 
00088 
00089   Int_t GetNV0I(Bool_t MC=kFALSE)   { return (MC ? GetNV0Mc()   : GetNV0()); }
00090   Int_t GetNXiI(Bool_t MC=kFALSE)   { return (MC ? GetNXiMc()   : GetNXi()); }
00091   Int_t GetNKinkI(Bool_t MC=kFALSE) { return (MC ? GetNKinkMc() : GetNKink()); }
00092 
00093   Int_t GetNV0()        { return v0->GetN(); }
00094   Int_t GetNV0Mc()      { return v0->GetNMc(); }
00095   Int_t GetNV0Assoc()   { return v0->GetNAssoc(); }
00096   Int_t GetNXi()        { return xi->GetN(); }
00097   Int_t GetNXiMc()      { return xi->GetNMc(); }
00098   Int_t GetNXiAssoc()   { return xi->GetNAssoc(); }
00099   Int_t GetNKink()      { return kink->GetN(); }
00100   Int_t GetNKinkMc()    { return kink->GetNMc(); }
00101   Int_t GetNKinkAssoc() { return kink->GetNAssoc(); }
00103 
00105 
00106 
00107   StStrangeMuDst* GetDatum(Int_t i=0, Bool_t MC=kFALSE, Int_t dstType=evT);
00108 
00109   StStrangeEvMuDst* GetEventI(Bool_t MC=kFALSE);
00110   StV0I*   GetV0I(Int_t i=0, Bool_t MC=kFALSE);
00111   StXiI*   GetXiI(Int_t i=0, Bool_t MC=kFALSE); 
00112   StKinkI* GetKinkI(Int_t i=0, Bool_t MC=kFALSE);
00113 
00114   StStrangeEvMuDst* GetEvent(); 
00115   StStrangeEvMuDst* GetMcEvent();
00116 
00117   StV0MuDst*      GetV0(Int_t i=0);
00119   StV0Mc*         GetV0Mc(Int_t i=0);
00120 
00121   StXiMuDst*      GetXi(Int_t i=0);
00124   StXiMc*         GetXiMc(Int_t i=0);
00125 
00126   StKinkMuDst*    GetKink(Int_t i=0);
00128   StKinkMc*       GetKinkMc(Int_t i=0);
00129 
00130   StStrangeAssoc* GetXiAssoc(Int_t i=0);
00131   StStrangeAssoc* GetV0Assoc(Int_t i=0);   
00132   StStrangeAssoc* GetKinkAssoc(Int_t i=0);
00133 
00134   StStrangeCuts& Cuts();
00136 
00138 
00139   TTree* GetTree();
00140   TClonesArray* GetEvClonesArray();
00141   TClonesArray* GetEvMcArray();
00142   TClonesArray* GetCutsArray();
00143 
00144   TClonesArray* GetV0ClonesArray()   { return v0->GetDataArray(); }
00145   TClonesArray* GetV0McArray()       { return v0->GetMcArray(); }
00146   TClonesArray* GetV0AssocArray()    { return v0->GetAssocArray(); }
00147   TClonesArray* GetXiClonesArray()   { return xi->GetDataArray(); }
00148   TClonesArray* GetXiMcArray()       { return xi->GetMcArray(); }
00149   TClonesArray* GetXiAssocArray()    { return xi->GetAssocArray(); }
00150   TClonesArray* GetKinkClonesArray() { return kink->GetDataArray(); }
00151   TClonesArray* GetKinkMcArray()     { return kink->GetMcArray(); }
00152   TClonesArray* GetKinkAssocArray()  { return kink->GetAssocArray(); }
00154 
00156 
00157   virtual Int_t Init();
00158   virtual Int_t Make();
00159   virtual void  Clear(Option_t *option="");
00160   virtual Int_t Finish();
00161   virtual const char *GetCVS() const {
00162     static const char cvs[]="Tag $Name:  $ $Id: StStrangeMuDstMaker.h,v 3.20 2009/09/02 19:39:44 genevb Exp $ built "__DATE__" "__TIME__ ; 
00163     return cvs;
00164   }
00166   
00168 
00169   void SubDst(StStrangeMuDstMaker* maker);
00170   void SubDst(StStrangeMuDstMaker& maker);
00171   void SubDst(const char* maker_name);
00172   StStrangeMuDstMaker* GetSubDst();
00174   
00176 
00177 
00178   void SelectEvent();
00180   void UnselectEvent();
00181   // ...or select portions (use i<0 to select all of the V0s, etc...
00182   void SelectV0(Int_t i=-1)     { v0->Select(i); }
00183   void SelectXi(Int_t i=-1)     { xi->Select(i); }
00184   void SelectKink(Int_t i=-1)   { kink->Select(i); }
00185   void UnselectV0(Int_t i=-1)   { v0->Unselect(i); }
00186   void UnselectXi(Int_t i=-1)   { xi->Unselect(i); }
00187   void UnselectKink(Int_t i=-1) { kink->Unselect(i); }
00189 
00191 
00192   void SetV0BufferSize(Int_t b)   { bsize[v0T]=b; }
00193   void SetXiBufferSize(Int_t b)   { bsize[xiT]=b; }
00194   void SetKinkBufferSize(Int_t b) { bsize[kinkT]=b; }
00196 
00198 
00199   StStrangeControllerBase* Get(const char* name) const;
00200   StStrangeControllerBase* Get(Int_t dstType) const;
00202   
00203 
00204  protected:
00206 
00207   virtual void InitReadDst();
00208   virtual void InitCreateDst();
00209   virtual void InitCreateSubDst();
00210   virtual Int_t MakeReadDst();
00211   virtual Int_t MakeCreateDst();
00212   virtual Int_t MakeCreateMcDst();
00213   virtual Int_t MakeCreateSubDst();
00215   
00217 
00218   void SetFile(const char* eFile);
00219   void SetTreeName(const char* treeName);
00220   Int_t OpenFile();
00221   Int_t CloseFile();
00222   void CheckFile();
00224 
00225   Int_t MatchName(const char* name) const;
00226 
00227   TTree* tree;                   
00228   TChain* chain;                 
00229   StStrangeCuts* cuts;           
00230   char file[1024];               
00231   TFile* muDst;                  
00232 
00233   Bool_t abortEvent;
00234   Bool_t firstEvent;
00235   Int_t evNumber;
00236   Int_t outFileNum;
00237   Bool_t fileBlind;
00238 
00239   Bool_t doT[strDstT];
00240   Bool_t doMc;
00241   Int_t  bsize[strDstT];
00242 
00243   Bool_t doT0JitterAbort;
00244 
00245   TClonesArray* evClonesArray;   
00246   TClonesArray* evMcArray;       
00247   TClonesArray* cutsArray;       
00248 
00249   StStrangeMuDstMaker* dstMaker; 
00250   TObjArray subMakers;
00251 
00252   
00253   // Sub-controllers
00254   StStrangeControllerBase* v0;    
00255   StStrangeControllerBase* xi;    
00256   StStrangeControllerBase* kink;  
00257   StStrangeControllerBase* cont[strDstT];  
00258  private:
00259   virtual void  ClearForReal(Option_t *option="");
00260 
00261   ClassDef(StStrangeMuDstMaker,4)
00262 };
00263 
00264 inline void StStrangeMuDstMaker::DoT0JitterAbort(Bool_t doIt) 
00265             { doT0JitterAbort = doIt; }
00266 inline void StStrangeMuDstMaker::DoV0(Bool_t doIt)
00267             { doT[v0T] = doIt; }
00268 inline void StStrangeMuDstMaker::DoXi(Bool_t doIt)
00269             { doT[xiT] = doIt; }
00270 inline void StStrangeMuDstMaker::DoKink(Bool_t doIt)
00271             { doT[kinkT] = doIt; }
00272 inline void StStrangeMuDstMaker::Do(Int_t dstType, Bool_t doIt)
00273             { doT[dstType] = doIt; }
00274 inline void StStrangeMuDstMaker::Do(const char* name, Bool_t doIt)
00275             { Do(MatchName(name),doIt); }
00276 inline void StStrangeMuDstMaker::DoMc(Bool_t doIt)
00277             { doMc = doIt; }
00278 inline Bool_t StStrangeMuDstMaker::GetDoMc()
00279             { return doMc; }
00280 inline TClonesArray* StStrangeMuDstMaker::GetEvClonesArray()
00281             { return evClonesArray; }
00282 inline TClonesArray* StStrangeMuDstMaker::GetEvMcArray()
00283             { return evMcArray; }
00284 inline TClonesArray* StStrangeMuDstMaker::GetCutsArray()
00285             { return cutsArray; }
00286 inline StStrangeMuDst* StStrangeMuDstMaker::GetDatum(Int_t i, Bool_t MC,
00287                                                      Int_t dstType)
00288             { if (dstType) return cont[dstType]->Get(i,(int) MC);
00289               else return (StStrangeMuDst*) GetEventI(MC); }
00290 inline StStrangeEvMuDst* StStrangeMuDstMaker::GetEvent()
00291             { return (evClonesArray ?
00292             (StStrangeEvMuDst*) evClonesArray->At(0) : 0); }
00293 inline StStrangeEvMuDst* StStrangeMuDstMaker::GetMcEvent()
00294             { return (evMcArray ?
00295             (StStrangeEvMuDst*) evMcArray->At(0) : 0); }
00296 inline StStrangeEvMuDst* StStrangeMuDstMaker::GetEventI(Bool_t MC)
00297             { return (MC ? GetMcEvent() : GetEvent()); }
00298 inline StV0I* StStrangeMuDstMaker::GetV0I(Int_t i, Bool_t MC)
00299             { return (StV0I*) (MC ? v0->GetMc(i) : v0->Get(i)); }
00300 inline StXiI* StStrangeMuDstMaker::GetXiI(Int_t i, Bool_t MC)
00301             { return (StXiI*) (MC ? xi->GetMc(i) : xi->Get(i)); }
00302 inline StKinkI* StStrangeMuDstMaker::GetKinkI(Int_t i, Bool_t MC)
00303             { return (StKinkI*) (MC ? kink->GetMc(i) : kink->Get(i)); }
00304 inline StV0MuDst* StStrangeMuDstMaker::GetV0(Int_t i)
00305             { return (StV0MuDst*) v0->Get(i); }
00306 inline StXiMuDst* StStrangeMuDstMaker::GetXi(Int_t i)
00307             { return (StXiMuDst*) xi->Get(i); }
00308 inline StKinkMuDst* StStrangeMuDstMaker::GetKink(Int_t i)
00309             { return (StKinkMuDst*) kink->Get(i); }
00310 inline StV0Mc* StStrangeMuDstMaker::GetV0Mc(Int_t i)
00311             { return (StV0Mc*) v0->GetMc(i); }
00312 inline StXiMc* StStrangeMuDstMaker::GetXiMc(Int_t i)
00313             { return (StXiMc*) xi->GetMc(i); }
00314 inline StKinkMc* StStrangeMuDstMaker::GetKinkMc(Int_t i)
00315             { return (StKinkMc*) kink->GetMc(i); }
00316 inline StStrangeAssoc* StStrangeMuDstMaker::GetV0Assoc(Int_t i)
00317             { return v0->GetAssoc(i); }
00318 inline StStrangeAssoc* StStrangeMuDstMaker::GetXiAssoc(Int_t i)
00319             { return xi->GetAssoc(i); }
00320 inline StStrangeAssoc* StStrangeMuDstMaker::GetKinkAssoc(Int_t i)
00321             { return kink->GetAssoc(i); }
00322 inline TTree* StStrangeMuDstMaker::GetTree()
00323             { return tree; }
00324 inline StStrangeCuts& StStrangeMuDstMaker::Cuts()
00325             { return (*cuts); }
00326 inline void StStrangeMuDstMaker::SubDst(StStrangeMuDstMaker& maker)
00327             { SubDst(&maker); }
00328 inline void StStrangeMuDstMaker::SubDst(const char* maker_name)
00329             { SubDst((StStrangeMuDstMaker*) GetMaker(maker_name)); }
00330 inline StStrangeMuDstMaker* StStrangeMuDstMaker::GetSubDst()
00331             { return dstMaker; }
00332 inline StStrangeControllerBase* StStrangeMuDstMaker::Get(Int_t dstType) const
00333             { return cont[dstType]; }
00334 inline StStrangeControllerBase* StStrangeMuDstMaker::Get(const char* name) const
00335             { return cont[MatchName(name)]; }
00336 inline Int_t StStrangeMuDstMaker::MatchName(const char* name) const
00337             { for (Int_t i=1; i<strDstT; i++)
00338                 if (!(strcmp(name,strTypeNames[i]))) return i;
00339               return 0; }
00340 
00341 #endif
00342 
00343 //____________________________________________________________________
00344 //
00345 // $Id: StStrangeMuDstMaker.h,v 3.20 2009/09/02 19:39:44 genevb Exp $
00346 // $Log: StStrangeMuDstMaker.h,v $
00347 // Revision 3.20  2009/09/02 19:39:44  genevb
00348 // Fixes to pointer and string conversions (RT ticket 1612), prep for 64-bit
00349 //
00350 // Revision 3.19  2009/08/26 16:56:06  fine
00351 // fix the compilation issues under SL5_64_bits  gcc 4.3.2
00352 //
00353 // Revision 3.18  2004/11/02 17:54:07  genevb
00354 // Leave corrupt file protection to ROOT / Remove my protection
00355 //
00356 // Revision 3.17  2004/07/12 21:45:35  genevb
00357 // Handle missing Event branch info condition
00358 //
00359 // Revision 3.16  2003/10/20 00:21:47  genevb
00360 // Fix a typo for Assoc introduced in vers. 3.13
00361 //
00362 // Revision 3.15  2003/09/02 17:59:04  perev
00363 // gcc 3.2 updates + WarnOff
00364 //
00365 // Revision 3.14  2003/07/09 21:58:30  genevb
00366 // Use Get/SetMode() from StMaker
00367 //
00368 // Revision 3.13  2003/05/30 21:20:19  genevb
00369 // doxygen savvy, encoding of FTPC mults, change virtual funcs
00370 //
00371 // Revision 3.12  2003/02/16 21:28:45  jeromel
00372 // GetCVS() added
00373 //
00374 // Revision 3.11  2003/02/10 16:02:24  genevb
00375 // Now read files using TChains; no splitting of MuDst file
00376 //
00377 // Revision 3.10  2002/06/21 02:44:10  genevb
00378 // handle events without primary vertex better
00379 //
00380 // Revision 3.9  2002/05/29 19:08:16  genevb
00381 // Better handling of improperly closed files
00382 //
00383 // Revision 3.8  2002/04/30 16:02:48  genevb
00384 // Common muDst, improved MC code, better kinks, StrangeCuts now a branch
00385 //
00386 // Revision 3.7  2001/09/14 21:39:02  genevb
00387 // Adjustments to not depend on order in which maker Clear() is called
00388 //
00389 // Revision 3.6  2001/08/23 13:20:56  genevb
00390 // Many bug workarounds...
00391 //
00392 // Revision 3.5  2001/05/04 20:15:14  genevb
00393 // Common interfaces and reorganization of components, add MC event info
00394 //
00395 // Revision 3.4  2000/12/18 21:35:18  genevb
00396 // Introduced variable buffer-sizing
00397 //
00398 // Revision 3.3  2000/09/28 20:16:05  jones
00399 // Added doT0JitterAbort() optio; added fix to CheckFile in case of no file
00400 //
00401 // Revision 3.2  2000/09/07 02:22:10  genevb
00402 // Added AbortEvent() functionality
00403 //
00404 // Revision 3.1  2000/07/17 20:28:40  genevb
00405 // File size limitation workaround, some under the hood improvements
00406 //
00407 // Revision 3.0  2000/07/14 12:56:50  genevb
00408 // Revision 3 has event multiplicities and dedx information for vertex tracks
00409 //
00410 // Revision 2.1  2000/06/09 22:17:11  genevb
00411 // Allow MC data to be copied between DSTs, other small improvements
00412 //
00413 // Revision 2.0  2000/06/02 22:11:54  genevb
00414 // New version of Strangeness micro DST package
00415 //
00416 // Revision 1.5  2000/04/18 02:30:04  genevb
00417 // Added multi-file capabilities
00418 //
00419 // Revision 1.4  2000/04/06 14:51:11  genevb
00420 // Fixed bug with storing event info when making subDST
00421 //
00422 // Revision 1.3  2000/04/05 20:23:53  genevb
00423 // Introduce creating sub-Micro DSTs, dynamic expansion of clones arrays as needed, SetNoKeep() function
00424 //
00425 // Revision 1.2  2000/03/29 20:52:13  genevb
00426 // Added StKinkMuDst, replaced arrays
00427 //
00428 // Revision 1.1  2000/03/29 03:10:07  genevb
00429 // Introduction of Strangeness Micro DST package
00430 //