AliRoot Core  edcc906 (edcc906)
AliReconstruction.h
Go to the documentation of this file.
1 #ifndef ALIRECONSTRUCTION_H
2 #define ALIRECONSTRUCTION_H
3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4  * See cxx source for full Copyright notice */
5 
6 /* $Id: AliReconstruction.h 63911 2013-08-19 16:46:41Z hristov $ */
7 
9 // //
10 // class for running the reconstruction //
11 // Clusters and tracks are created for all detectors and all events by //
12 // typing: //
13 // //
14 // AliReconstruction rec; //
15 // rec.Run(); //
16 // //
18 
19 
20 #include <TSelector.h>
21 #include <TString.h>
22 #include <TObjArray.h>
23 
24 class AliReconstructor;
25 class AliRunLoader;
26 class AliRawReader;
27 class AliLoader;
28 class AliTracker;
29 class AliMagF;
30 class AliVertexer;
31 class AliTrackleter;
32 class AliESDVertex;
33 class AliESDEvent;
34 class AliESDfriend;
35 class AliESDpid;
36 class AliVertexerTracks;
37 class TFile;
38 class TTree;
39 class TList;
40 class AliQAManager;
41 class TMap;
42 class AliRecoParam;
44 class AliRunInfo;
45 class AliGRPObject;
46 class THashTable;
48 class AliCTPTimeParams;
49 class AliAnalysisManager;
51 class THashList;
52 class AliMCEventHandler;
53 class AliGRPRecoParam;
54 
55 #include "AliQAv1.h"
56 #include "AliEventInfo.h"
57 #include "AliRecoParam.h"
58 
59 using std::ofstream;
60 
61 class AliReconstruction: public TSelector {
62 public:
63  AliReconstruction(const char* gAliceFilename = "galice.root");
64  virtual ~AliReconstruction();
65 
66  void SetGAliceFile(const char* fileName);
67  void SetInput(const char* input);
68  void SetOutput(const char* output);
69 
70  void SetEquipmentIdMap(const char *mapFile) {fEquipIdMap = mapFile;};
71  void SetEventRange(Int_t firstEvent = 0, Int_t lastEvent = -1)
72  {fFirstEvent = firstEvent; fLastEvent = lastEvent;};
73  void SetNumberOfEventsPerFile(UInt_t nEvents)
74  {fNumberOfEventsPerFile = nEvents;};
75  void SetFractionFriends(Double_t frac = 0.04) {fFractionFriends = frac;};
76  void SetFractionHLTESD(Double_t frac = 0.05) {fFractionHLTESD = frac;};
78  void SetMaxFriendTracks(Int_t n) {fMaxFriendTracks = n;}
79  void SetSkipFriendsCutZ(double z) {fSkipFriendsCutZ = z;}
80  //
81  Double_t GetFractionHLTESD() const {return fFractionHLTESD;};
82  Double_t GetFractionFriends() const {return fFractionFriends;};
84  Int_t GetMaxFriendTracks() const {return fMaxFriendTracks;}
85  Double_t GetSkipFriendsCutZ() const {return fSkipFriendsCutZ;}
86  //
87  void SetOption(const char* detector, const char* option);
88  void SetRecoParam(const char* detector, AliDetectorRecoParam *par);
89 
90  void SetCosmicAlias(const char* nm="kCosmic") {fCosmicAlias = nm;}
91  void SetLaserAlias(const char* nm="kCalibLaser") {fLaserAlias = nm;}
92 
93  TString& GetCosmicAlias() const {return (TString&)fCosmicAlias;}
94  TString& GetLaserAlias() const {return (TString&)fLaserAlias;}
95 
96  void SetRunLocalReconstruction(const char* detectors) {
97  fRunLocalReconstruction = detectors;};
98  void SetRunTracking(const char* detectors) {
99  fRunTracking = detectors;};
100  void SetFillESD(const char* detectors) {fFillESD = detectors;};
101  void SetRunReconstruction(const char* detectors) {
102  SetRunLocalReconstruction(detectors);
103  SetRunTracking(detectors);
104  SetFillESD(detectors);};
105  void SetDeleteRecPoints(const char* dets) {fDeleteRecPoints = dets;}
106  void SetDeleteDigits(const char* dets) {fDeleteDigits = dets;}
107  void SetUseTrackingErrorsForAlignment(const char* detectors)
108  {fUseTrackingErrorsForAlignment = detectors;};
109  void SetLoadAlignFromCDB(Bool_t load) {fLoadAlignFromCDB = load;};
110  void SetLoadAlignData(const char* detectors)
111  {fLoadAlignData = detectors;};
112 
113  void SetRun1PIDforTracking(Bool_t val=kTRUE);
114  void SetTreeBuffSize(Long64_t sz=30000000) {fTreeBuffSize = sz;}
115  //*** Global reconstruction flag setters
116  void SetRunMultFinder(Bool_t flag=kTRUE) {fRunMultFinder=flag;};
117  void SetRunVertexFinder(Bool_t flag=kTRUE) {fRunVertexFinder=flag;};
118  void SetRunVertexFinderTracks(Bool_t flag=kTRUE) {fRunVertexFinderTracks=flag;};
119  void SetRunV0Finder(Bool_t flag=kTRUE) {fRunV0Finder=flag;};
120  void SetRunCascadeFinder(Bool_t flag=kTRUE) {fRunCascadeFinder=flag;};
121  void SetStopOnError(Bool_t flag=kTRUE) {fStopOnError=flag;}
123  void SetWriteAlignmentData(Bool_t flag=kTRUE){fWriteAlignmentData=flag;}
124  void SetWriteESDfriend(Bool_t flag=kTRUE){fWriteESDfriend=flag;}
125  void SetWriteHLTESD(Bool_t flag=kTRUE) {fWriteHLTESD=flag;}
126  void SetFillTriggerESD(Bool_t flag=kTRUE){fFillTriggerESD=flag;}
130  void ResetFriends();
131 
132  void SetSkipIncompleteDAQ(Bool_t v=kTRUE) { fSkipIncompleteDAQ = v; }
134  void SetCleanESD(Bool_t flag=kTRUE){fCleanESD=flag;}
135  void SetUseHLTData(const char* detectors){fUseHLTData=detectors;}
136  void SetV0DCAmax(Float_t d) {fV0DCAmax=d;}
137  void SetV0CsPmin(Float_t d) {fV0CsPmin=d;}
138  void SetDmax(Float_t d) {fDmax=d;}
139  void SetZmax(Float_t z) {fZmax=z;}
140  Float_t GetV0DCAmax() const {return fV0DCAmax;}
141  Float_t GetV0CsPmin() const {return fV0CsPmin;}
142  Float_t GetDmax() const {return fDmax;}
143  Float_t GetZmax() const {return fZmax;}
144 
145  Bool_t HasNextEventAfter(Int_t eventId);
146 
147  //
148  Bool_t IsRunMultFinder() const {return fRunMultFinder;}
149 
150  // CDB storage activation
151  void SetDefaultStorage(const char* uri);
152  void SetSpecificStorage(const char* calibType, const char* uri);
153  void SetCDBSnapshotMode(const char* snapshotFileName);
154  void AddCheckRecoCDBvsSimuCDB(const char* cdbpath,const char* comment="");
155  void RemCheckRecoCDBvsSimuCDB(const char* cdbpath);
157  void RectifyCDBurl(TString& url);
159  void CheckRecoCDBvsSimuCDB();
160  Bool_t MisalignGeometry(const TString& detectors);
161 
164  fLoadAlignFromCDB = kFALSE;}
165 
166  virtual Int_t Version() const {return 2;}
167  virtual void Begin(TTree*);
168  virtual void SlaveBegin(TTree*);
169  virtual void Init(TTree *tree);
170  virtual Bool_t Process(Long64_t entry);
171  virtual Bool_t ProcessEvent(Int_t iEvent);
172  virtual void SlaveTerminate();
173  virtual void Terminate();
174  virtual Bool_t Run(const char* input = NULL);
175  void Abort(const char *method, EAbort what);
176  virtual void SetOption(const char* option) {
177  TSelector::SetOption(option);
178  }
179 
180  // Trackers
181  AliTracker* GetTracker(Int_t idx) const { return fTracker[idx]; }
182  Bool_t CreateTrackers(const TString& detectors);
184 
185  // Quality Assurance
186  void SetQACycles(AliQAv1::DETECTORINDEX_t det, Int_t cycles) { fQACycles[det] = cycles ; }
188  Bool_t SetRunQA(TString detAndAction="ALL:ALL") ;
189  void SetRunGlobalQA(Bool_t flag=kTRUE){fRunGlobalQA = flag;}
190  void SetQARefDefaultStorage(const char* uri);
191  void InitQA();
192  void MergeQA(const char *fileName = NULL);
194  Bool_t IsRunQA() const { return fRunQA ; }
195  Bool_t IsRunGlobalQA() const { return fRunGlobalQA ; }
196  Bool_t IsInTasks(AliQAv1::TASKINDEX_t tsk) { return fQATasks.Contains(Form("%d", tsk)) ; }
197 
198  // Plane Efficiency Evaluation
199  void SetRunPlaneEff(Bool_t flag=kFALSE) {fRunPlaneEff = flag;}
200 
201  enum {
202  kNDetectors = 18 // number of detectors + AD +FIT //alla
203  };
204  static Int_t GetDetIndex(const char * detector);
205  static const char** GetDetectorNames() { return fgkDetectorName; }
206 
207  // Upgrade
208  void SetUpgradeModule(const char* detectors) {fUpgradeModule = detectors; MatchUpgradeDetector() ; }
209  void MatchUpgradeDetector();
210 
211  // Connection to analysis manager.
212  // If a macro is set it should contain a function returning an analysis
213  // manager object. The macro is ignored in case the analysis manager is
214  // set via SetAnalysisManager
215  void SetAnalysisMacro(const char *macropath) {fAnalysisMacro = macropath;}
216  const char *GetAnalysisMacro() const {return fAnalysisMacro.Data();}
217  void SetAnalysisManager(AliAnalysisManager *mgr) {fAnalysis = mgr;}
218  AliAnalysisManager *GetAnalysisManager() const {return fAnalysis;}
219 
220  // A method to declare defined trigger classes even if they are not
221  // present in the run, needed for proper event selection based on trigger
222  void DeclareTriggerClasses(const char *trClasses) {fDeclTriggerClasses = trClasses;}
223  //
224  //
225  void CleanProcessedEvent();
226 
227  AliESDEvent* GetESDEvent() const { return fesd; }
228  AliESDfriend* GetESDfriend() const { return fesdf; }
230  AliRawReader* GetRawReader() const { return fRawReader; }
231 
232  Bool_t HasEnoughResources(int ev);
233  void SetStopOnResourcesExcess(int vRSS=3000,int vVMEM=4000);
234  //
235  //
236  virtual Bool_t ProcessEvent(void* event);
237  void InitRun(const char* input);
238 
241 
242 protected:
243  // Functions needed to select events for which we store the ESD friends
244  Bool_t IsHighPt() const;
245  Bool_t IsCosmicOrCalibSpecie() const;
246  void WriteESDfriend();
247  Bool_t DecideFriendsStorage();
248 
249 private:
252 
253  void InitRawReader(const char* input);
254  void InitCDB();
255  Bool_t InitGRP();
256  void SetCDBLock();
257  Bool_t SetRunNumberFromData();
258  Bool_t LoadCDB();
259  Bool_t LoadTriggerScalersCDB();
260  Bool_t LoadCTPTimeParamsCDB();
261  Bool_t ReadIntensityInfoCDB();
262  Bool_t RunLocalEventReconstruction(const TString& detectors);
263  Bool_t RunVertexFinder(AliESDEvent*& esd);
264  Bool_t RunMuonTracking(AliESDEvent*& esd);
265  Bool_t RunMFTTrackingMU(AliESDEvent*& esd); // AU
266  Bool_t RunSPDTrackleting(AliESDEvent*& esd);
267  Bool_t RunMultFinder(AliESDEvent*& esd);
268  Bool_t RunTracking(AliESDEvent*& esd, AliESDpid &PID);
269  Bool_t CleanESD(AliESDEvent *esd,const AliGRPRecoParam *grpRecoParam);
270  Bool_t FillESD(AliESDEvent*& esd, const TString& detectors);
271  Bool_t FillTriggerESD(AliESDEvent*& esd);
272  Bool_t FillTriggerScalers(AliESDEvent*& esd);
273  Bool_t FillRawEventHeaderESD(AliESDEvent*& esd);
274  Bool_t FillMCEventHeaderESD(AliESDEvent*& esd);
275  void DeleteRecPoints(const TString& detectors);
276  void DeleteDigits(const TString& detectors);
277 
278  Bool_t IsSelected(TString detName, TString& detectors) const;
279  Bool_t InitRunLoader();
280  AliReconstructor* GetReconstructor(Int_t iDet);
283  void CleanUp();
284 
285  Bool_t ParseOutput();
286 
287  //==========================================//
288  void WriteAlignmentData(AliESDEvent* esd);
289 
290  void FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd);
291 
292  //Quality Assurance
293  // void CheckQA() ;
294 
295  // Plane Efficiency evaluation
296  Bool_t FinishPlaneEff(); //ultimate tasks related to Plane Eff. evaluation
297  Bool_t InitPlaneEff(); // initialize what is needed for Plane Eff. evaluation
298 
299  Bool_t InitAliEVE();
300  void RunAliEVE();
301 
302  Bool_t InitRecoParams(); // init the array with the reconstruciton parameters
303  Bool_t GetEventInfo(); // fill the event info inside the event loop
304  void ProcessTriggerAliases();
305  Bool_t TriggerMatches2Alias(const char* trigName, const char* alias);
306  const char *MatchDetectorList(const char *detectorList, UInt_t detectorMask);
307 
308  //*** Global reconstruction flags *******************
309  Bool_t fRunVertexFinder; // run the vertex finder
310  Bool_t fRunVertexFinderTracks; // run the vertex finder with tracks
311  Bool_t fRunMuonTracking; // run the MUON tracking
312  Bool_t fRunMFTTrackingMU; // run the MFT+MUON tracking // AU
313  Bool_t fRunV0Finder; // run the ESD V0 finder
314  Bool_t fRunCascadeFinder; // run the ESD cascade finder
315  Bool_t fRunMultFinder; // run the trackleter for ITS clusters
316  Bool_t fStopOnError; // stop or continue on errors
317  Bool_t fStopOnMissingTriggerFile; // stop if the simulated trigger file is absent
318  Bool_t fWriteAlignmentData; // write track space-points flag
319  Bool_t fWriteESDfriend; // write ESD friend flag
320  Bool_t fWriteHLTESD; // write HLT ESD tree
321  Bool_t fFillTriggerESD; // fill trigger info into ESD
322  //
323  Bool_t fWriteThisFriend; // decision to store or not friends for given event
324  Bool_t fSkipFriendsForLargeZ; // if true, TPC only tracks with |Z|>fSkipFriendsCutZ never stored
325  Int_t fMaxFriendTracks; // max number of friend tracks to store per event
326  Double_t fFractionFriends; // fraction of ESD friends to be stored
327  Double_t fFractionHLTESD; // fraction of HLT ESD events to store
328  Double_t fSkipFriendsCutZ; // friends of TPC only tracks with large Z have low priority
329 
330  //*** Clean ESD flag and parameters *******************
331  Bool_t fSkipIncompleteDAQ; // skip events with "incomplete DAQ" attribute
332  Bool_t fCleanESD; // clean ESD flag
333  Float_t fV0DCAmax; // max. allowed DCA between V0 daugthers
334  Float_t fV0CsPmin; // min. allowed cosine of V0 pointing angle
335  Float_t fDmax; // max. allowed transverse impact parameter
336  Float_t fZmax; // max. allowed longitudinal impact parameter
337 
338  TString fCosmicAlias; // alias for cosmic triggers
339  TString fLaserAlias; // alias for laser triggers
340  //
341  TString fRunLocalReconstruction; // run the local reconstruction for these detectors
342  TString fRunTracking; // run the tracking for these detectors
343  TString fFillESD; // fill ESD for these detectors
344  TString fDeleteRecPoints; // delete recpoints after each event
345  TString fDeleteDigits; // delete digits after each event
346  TString fLoadCDB; // prefetch CDB entries and init reco-params for these detectors
347  TString fUseTrackingErrorsForAlignment; // for these detectors
348  TString fGAliceFileName; // name of the galice file
349  TString fRawInput; // name of input raw-data file or directory
350  TString fESDOutput;
355  TString fEquipIdMap; // name of file with equipment id map
356  Int_t fFirstEvent; // index of first event to be reconstr.
357  Int_t fLastEvent; // index of last event to be reconstr.
358  UInt_t fNumberOfEventsPerFile; // number of events per file in case of raw-data reconstruction
359  TObjArray fOptions; // options for reconstructor objects
360  Bool_t fLoadAlignFromCDB; // Load alignment data from CDB and apply it to geometry or not
361  TString fLoadAlignData; // Load alignment data from CDB for these detectors
362  TString fUseHLTData; // Detectors for which the HLT data is used as input
363  AliRunInfo* fRunInfo; // an object which contains essential global conditions information
364  AliEventInfo fEventInfo; // an object which contains essential event information
365  AliTriggerRunScalers* fRunScalers; // an object which contains the trigger counters for xsection
366  AliCTPTimeParams* fCTPTimeParams; // an object which contains the trigger delays
367  AliCTPTimeParams* fCTPTimeAlign; // an object which contains the CTP (mis)alignment data
369  AliRawReader* fRawReader;
370  AliRawReader* fParentRawReader;
371 
372  static const char* fgkDetectorName[kNDetectors];
374  AliRecoParam fRecoParam; // container for the reco-param objects for detectors
378  AliESDVertex* fDiamondProfileSPD; // (x,y) diamond profile from SPD for AliITSVertexer3D(Z)
379  AliESDVertex* fDiamondProfile; // (x,y) diamond profile for AliVertexerTracks (ITS+TPC)
380  AliESDVertex* fDiamondProfileTPC; // (x,y) diamond profile from TPC for AliVertexerTracks
381  THashTable* fListOfCosmicTriggers; // list of cosmic triggers as defined by trigger coordination (RS for BWD comp)
382  THashList* fAlias2Trigger; // list of aliases with string of triggers per alias
383 
384  AliGRPObject* fGRPData; // Data from the GRP/GRP/Data CDB folder
385 
387 
388  TString fCDBUri;
389  TString fQARefUri;
391  TObjArray fCheckRecoCDBvsSimuCDB; // Array for CDB items which must be the same in the sim and rec
392  Bool_t fInitCDBCalled;
395 
396  //Quality Assurance
397  Int_t fQACycles[ AliQAv1::kNDET]; // # events over which QA data are accumulated
398  Bool_t fQAWriteExpert[AliQAv1::kNDET]; // Flag to save or not expert QA data
399  TString fQADetectors ; // list of detectors to be QA'ed
400  TString fQATasks ; // list of QA tasks to be performed
401  Bool_t fRunQA ; // Run QA flag
402  Bool_t fRunGlobalQA; // Run global QA flag
403  Bool_t fSameQACycle;
404  Bool_t fInitQACalled;
406 
407  // Plane Efficiency Evaluation
408  Bool_t fRunPlaneEff ; // Evaluate Plane Efficiency
409 
410  // PID
411  AliESDpid* fESDpid; // PID object
412 
413  // New members needed in order to split Run method
414  // into InitRun,RunEvent,FinishRun methods
419  TFile* ffile;
420  TFile* ffileF;
421  TTree* ftree;
422  TTree* ftreeF;
423  TTree* fhlttree;
425  Bool_t fIsNewRunLoader; // galice.root created from scratch (real raw data case)
426  Bool_t fRunAliEVE; // Run AliEVE or not
427  Double_t fBeamInt[2][2];
428 
429  TTree* fChain;
430 
431  // Counters used in WriteESDfriend()
432  Int_t fNall;
433  Int_t fNspecie;
434  Int_t fSspecie;
435  Int_t fNhighPt;
436  Int_t fShighPt;
437 
438  // Counters for SetAutoFlush configuration
439  Long64_t fTreeBuffSize; // allowed uncompressed buffer size per tree
440  Long64_t fMemCountESD;
441  Long64_t fMemCountESDF;
442  Long64_t fMemCountESDHLT;
443  //
444  // Upgrade detector reconstruction
445  TString fUpgradeModule;
447  // optional MCHandler to access MC info in case of embedding
448  AliMCEventHandler* fMCEventHandlerExt; // only externally set
449  // Connect an analysis manager in the event loop
450  TString fAnalysisMacro; // Full path to a macro creating an analysis manager train
451  AliAnalysisManager *fAnalysis;
453  TString fDeclTriggerClasses; // Declared defined trigger classes
454  //
455  Bool_t fStopped; // flag that reco is stopped due to the limited resources
456  Int_t fMaxRSS; // max RSS memory, MB
457  Int_t fMaxVMEM; // max VMEM memory, MB
458  Int_t fNAbandonedEv; // number of abandoned events
459  static const char* fgkStopEvFName; // filename for stop.event stamp
460  //
461  ClassDef(AliReconstruction, 53) // class for running the reconstruction
462 };
463 
464 #endif
Bool_t fIsNewRunLoader
Pointer to the vertexer based on ESD tracks.
virtual Bool_t Process(Long64_t entry)
void SetWriteAlignmentData(Bool_t flag=kTRUE)
Bool_t RunLocalEventReconstruction(const TString &detectors)
Long64_t fMemCountESDF
accumulated ESD size before AutoSave
void SetQARefDefaultStorage(const char *uri)
AliRecoInputHandler * fRecoHandler
Analysis manager.
TString fQARefUri
Uri of the default CDB storage.
AliAnalysisManager * GetAnalysisManager() const
Bool_t RunMultFinder(AliESDEvent *&esd)
TString fUseTrackingErrorsForAlignment
Bool_t fSetRunNumberFromDataCalled
flag true if we are setting the CDB Manager in snapshot mode
AliTracker * fTracker[kNDetectors]
detector loaders
virtual Bool_t Run(const char *input=NULL)
Float_t GetV0DCAmax() const
void SetSpecificStorage(const char *calibType, const char *uri)
void FillRawDataErrorLog(Int_t iEvent, AliESDEvent *esd)
AliRunLoader * fRunLoader
TFile * ffile
Pointer to the empty ESD friend object.
void SetStopOnMissingTriggerFile(Bool_t flag=kTRUE)
AliReconstructor * fReconstructor[kNDetectors]
names of detectors
void SetRunPlaneEff(Bool_t flag=kFALSE)
#define TObjArray
void SetEquipmentIdMap(const char *mapFile)
void SetSkipFriendsCutZ(double z)
Bool_t fProofOutputDataset
output location in PROOF mode
void SetAlignObjArray(TObjArray *array)
void RemCheckRecoCDBvsSimuCDB(const char *cdbpath)
AliESDEvent * fhltesd
Pointer to the ESD event object.
Bool_t IsInTasks(AliQAv1::TASKINDEX_t tsk)
virtual void Terminate()
void SetMaxFriendTracks(Int_t n)
void SetDeleteRecPoints(const char *dets)
Bool_t RunMuonTracking(AliESDEvent *&esd)
Long64_t fTreeBuffSize
Number of events, sampled from fNhighPt.
Long64_t fMemCountESDHLT
accumulated ESD size before AutoSave
AliCTPTimeParams * fCTPTimeParams
Bool_t HasEnoughResources(int ev)
static TString comment
Definition: ConfigCosmic.C:131
void SetStopOnResourcesExcess(int vRSS=3000, int vVMEM=4000)
void SetStopOnError(Bool_t flag=kTRUE)
AliESDVertex * fDiamondProfileTPC
Double_t GetFractionHLTESD() const
void SetLaserAlias(const char *nm="kCalibLaser")
void SetUseHLTData(const char *detectors)
AliTracker * fSPDTrackleter
trackers
AliMCEventHandler * GetMCEventHandler() const
Bool_t fUpgradeMask[kNDetectors]
Bool_t fQAWriteExpert[AliQAv1::kNDET]
virtual Bool_t ProcessEvent(Int_t iEvent)
void SetFillESD(const char *detectors)
Bool_t CreateTrackers(const TString &detectors)
void ImportRunLoader(AliRunLoader *rl)
Double_t GetSkipFriendsCutZ() const
void SetTreeBuffSize(Long64_t sz=30000000)
Int_t fQACycles[AliQAv1::kNDET]
flag to check if run number is already loaded from run loader
AliRunLoader * GetRunLoader() const
const TObjArray * GetCheckRecoCDBvsSimuCDB() const
void InitRun(const char *input)
Bool_t fCDBSnapshotMode
flag to check if CDB storages are already initialized
Bool_t fWriteQAExpertData
control of QA intialisation
Bool_t SetRunQA(TString detAndAction="ALL:ALL")
Bool_t fRunPlaneEff
decides wheter or not to write experts QA data; true by default
AliEventInfo fEventInfo
AliLoader * fLoader[kNDetectors]
TTree * tree
TString fDeclTriggerClasses
Input handler adapted for reconstruction.
AliESDfriend * fesdf
Pointer to the HLT ESD event object.
Float_t GetV0CsPmin() const
AliRawReader * fRawReader
current run loader object
AliTrackleter * CreateMultFinder()
TString fileName(const char *dir, int runNumber, const char *da, int i, const char *type)
TString & GetCosmicAlias() const
virtual void SlaveBegin(TTree *)
virtual void Begin(TTree *)
AliRawReader * GetRawReader() const
Bool_t HasNextEventAfter(Int_t eventId)
static const char * fgkDetectorName[kNDetectors]
parent raw data reader in case of AliRawReaderHLT
static const char ** GetDetectorNames()
TObjArray * array
Definition: AnalyzeLaser.C:12
THashTable * fListOfCosmicTriggers
void SetOutput(const char *output)
void SetDeleteDigits(const char *dets)
void SetWriteESDfriend(Bool_t flag=kTRUE)
void SetZmax(Float_t z)
Bool_t IsRunQA() const
Bool_t FillTriggerScalers(AliESDEvent *&esd)
void SetGAliceFile(const char *fileName)
Bool_t MisalignGeometry(const TString &detectors)
Double_t fBeamInt[2][2]
Bool_t FillESD(AliESDEvent *&esd, const TString &detectors)
Bool_t RunSPDTrackleting(AliESDEvent *&esd)
void SetNumberOfEventsPerFile(UInt_t nEvents)
Bool_t fInitQACalled
open a new QA data file or not
AliTriggerRunScalers * fRunScalers
AliRecoParam fRecoParam
array of reconstructor objects
void WriteAlignmentData(AliESDEvent *esd)
void SetRunGlobalQA(Bool_t flag=kTRUE)
TString fProofOutputLocation
name of output file in PROOF mode
void SetRunCascadeFinder(Bool_t flag=kTRUE)
void AddCheckRecoCDBvsSimuCDB(const char *cdbpath, const char *comment="")
virtual Int_t Version() const
AliAnalysisManager * fAnalysis
Int_t fShighPt
Number of events, selected by IsHighPt.
Bool_t CleanESD(AliESDEvent *esd, const AliGRPRecoParam *grpRecoParam)
AliReconstructor * GetReconstructor(Int_t iDet)
Bool_t FillMCEventHeaderESD(AliESDEvent *&esd)
Bool_t FillTriggerESD(AliESDEvent *&esd)
void SetRunReconstruction(const char *detectors)
void SetDiamondProfileTPC(AliESDVertex *dp)
void SetLoadAlignFromCDB(Bool_t load)
void SetRunLocalReconstruction(const char *detectors)
Float_t GetDmax() const
void SetRunVertexFinder(Bool_t flag=kTRUE)
Int_t fSspecie
Number of events, selected by IsCosmicOrCalibSpecie.
void MergeQA(const char *fileName=NULL)
AliESDfriend * GetESDfriend() const
void Abort(const char *method, EAbort what)
void SetDefaultStorage(const char *uri)
TObjArray fCheckRecoCDBvsSimuCDB
Array with detector specific CDB storages.
static Int_t GetDetIndex(const char *detector)
void DeleteDigits(const TString &detectors)
TString fProofOutputArchive
keep output file in PROOF mode in dataset or merge
void SetCleanESD(Bool_t flag=kTRUE)
TObjArray fSpecCDBUri
Uri of the default QA reference storage.
AliESDVertex * fDiamondProfileSPD
trackleter [for SPD Plane Efficiency purposes]
Float_t GetZmax() const
void SetSkipIncompleteDAQ(Bool_t v=kTRUE)
TTree * ftree
Pointer to the ESD friend file.
AliReconstruction(const char *gAliceFilename="galice.root")
void SetWriteHLTESD(Bool_t flag=kTRUE)
void SetAnalysisMacro(const char *macropath)
void rec(const char *filename="raw.root")
Definition: rec.C:1
void SetCDBSnapshotMode(const char *snapshotFileName)
static const char * fgkStopEvFName
void InitRawReader(const char *input)
void SetEventRange(Int_t firstEvent=0, Int_t lastEvent=-1)
Int_t fNspecie
Number of reconstructed events.
TTree * fChain
mean beam intensities from AliLHCData
void SetFillTriggerESD(Bool_t flag=kTRUE)
TString fProofOutputFileName
name of output ESD file
AliVertexerTracks * ftVertexer
Pointer to the HLT ESD tree.
Bool_t TriggerMatches2Alias(const char *trigName, const char *alias)
void RectifyCDBurl(TString &url)
AliCTPTimeParams * fCTPTimeAlign
Bool_t GetSkipFriendsForLargeZ() const
const char * MatchDetectorList(const char *detectorList, UInt_t detectorMask)
AliESDVertex * fDiamondProfile
void SetDiamondProfile(AliESDVertex *dp)
TString fEquipIdMap
list of file to be kept in output zip archive in PROOF mode
Bool_t RunVertexFinder(AliESDEvent *&esd)
void SetCosmicAlias(const char *nm="kCosmic")
Bool_t IsCosmicOrCalibSpecie() const
void SetUseTrackingErrorsForAlignment(const char *detectors)
void SetFractionFriends(Double_t frac=0.04)
AliESDfriend * fesdfDummy
Pointer to the ESD friend object.
Bool_t RunTracking(AliESDEvent *&esd, AliESDpid &PID)
TTree * ftreeF
Pointer to the ESD tree.
TString & GetLaserAlias() const
void DeclareTriggerClasses(const char *trClasses)
void SetRunVertexFinderTracks(Bool_t flag=kTRUE)
DETECTORINDEX_t
Definition: AliQAv1.h:23
void SetFractionHLTESD(Double_t frac=0.05)
void SetQAWriteExpert(AliQAv1::DETECTORINDEX_t det)
void SetAnalysisManager(AliAnalysisManager *mgr)
virtual void SetOption(const char *option)
void SetInput(const char *input)
TString fUpgradeModule
accumulated ESD size before AutoSave
AliReconstruction & operator=(const AliReconstruction &rec)
void SetRunMultFinder(Bool_t flag=kTRUE)
void SetDiamondProfileSPD(AliESDVertex *dp)
Bool_t IsRunMultFinder() const
void SetMCEventHandler(AliMCEventHandler *hmc)
void SetDmax(Float_t d)
AliVertexer * CreateVertexer()
TASKINDEX_t
Definition: AliQAv1.h:30
void SetQACycles(AliQAv1::DETECTORINDEX_t det, Int_t cycles)
void SetV0CsPmin(Float_t d)
Bool_t IsSelected(TString detName, TString &detectors) const
virtual void Init(TTree *tree)
AliMCEventHandler * fMCEventHandlerExt
Int_t GetMaxFriendTracks() const
void SetOption(const char *detector, const char *option)
Int_t fNall
The raw-data chain in case of AliRawReaderChain.
AliRawReader * fParentRawReader
current raw data reader
void SetRun1PIDforTracking(Bool_t val=kTRUE)
TString fCDBUri
array with the alignment objects to be applied to the geometry
Bool_t RunMFTTrackingMU(AliESDEvent *&esd)
AliGRPObject * fGRPData
void SetRunV0Finder(Bool_t flag=kTRUE)
TTree * fhlttree
Pointer to the ESD friend tree.
Bool_t IsHighPt() const
Bool_t FillRawEventHeaderESD(AliESDEvent *&esd)
void SetSkipFriendsForLargeZ(Bool_t v)
TFile * ffileF
Pointer to the ESD file.
void SetV0DCAmax(Float_t d)
Bool_t IsRunGlobalQA() const
Double_t GetFractionFriends() const
AliESDEvent * GetESDEvent() const
void SetRunTracking(const char *detectors)
THashList * fAlias2Trigger
void SetRecoParam(const char *detector, AliDetectorRecoParam *par)
const char * GetAnalysisMacro() const
virtual void SlaveTerminate()
void DeleteRecPoints(const TString &detectors)
void SetUpgradeModule(const char *detectors)
void SetLoadAlignData(const char *detectors)
AliTracker * GetTracker(Int_t idx) const
TObjArray * fAlignObjArray
Int_t fNhighPt
Number of events, sampled from fNspecie.