]>
Commit | Line | Data |
---|---|---|
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$ */ | |
7 | ||
8 | /////////////////////////////////////////////////////////////////////////////// | |
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 | // // | |
17 | /////////////////////////////////////////////////////////////////////////////// | |
18 | ||
19 | ||
20 | #include <TSelector.h> | |
21 | #include <TString.h> | |
22 | #include <TUrl.h> | |
23 | #include <TObjArray.h> | |
24 | ||
25 | class AliReconstructor; | |
26 | class AliRunLoader; | |
27 | class AliRawReader; | |
28 | class AliLoader; | |
29 | class AliTracker; | |
30 | class AliMagF; | |
31 | class AliVertexer; | |
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; | |
43 | class AliDetectorRecoParam; | |
44 | class AliRunInfo; | |
45 | class AliGRPObject; | |
46 | class THashTable; | |
47 | class AliTriggerRunScalers; | |
48 | class AliCTPTimeParams; | |
49 | ||
50 | #include "AliQAv1.h" | |
51 | #include "AliEventInfo.h" | |
52 | #include "AliRecoParam.h" | |
53 | ||
54 | class AliReconstruction: public TSelector { | |
55 | public: | |
56 | AliReconstruction(const char* gAliceFilename = "galice.root"); | |
57 | virtual ~AliReconstruction(); | |
58 | ||
59 | void SetGAliceFile(const char* fileName); | |
60 | void SetInput(const char* input); | |
61 | void SetOutput(const char* output); | |
62 | ||
63 | void SetEquipmentIdMap(const char *mapFile) {fEquipIdMap = mapFile;}; | |
64 | void SetEventRange(Int_t firstEvent = 0, Int_t lastEvent = -1) | |
65 | {fFirstEvent = firstEvent; fLastEvent = lastEvent;}; | |
66 | void SetNumberOfEventsPerFile(UInt_t nEvents) | |
67 | {fNumberOfEventsPerFile = nEvents;}; | |
68 | void SetOption(const char* detector, const char* option); | |
69 | void SetRecoParam(const char* detector, AliDetectorRecoParam *par); | |
70 | ||
71 | void SetRunLocalReconstruction(const char* detectors) { | |
72 | fRunLocalReconstruction = detectors;}; | |
73 | void SetRunTracking(const char* detectors) { | |
74 | fRunTracking = detectors;}; | |
75 | void SetFillESD(const char* detectors) {fFillESD = detectors;}; | |
76 | void SetRunReconstruction(const char* detectors) { | |
77 | SetRunLocalReconstruction(detectors); | |
78 | SetRunTracking(detectors); | |
79 | SetFillESD(detectors);}; | |
80 | void SetUseTrackingErrorsForAlignment(const char* detectors) | |
81 | {fUseTrackingErrorsForAlignment = detectors;}; | |
82 | void SetLoadAlignFromCDB(Bool_t load) {fLoadAlignFromCDB = load;}; | |
83 | void SetLoadAlignData(const char* detectors) | |
84 | {fLoadAlignData = detectors;}; | |
85 | ||
86 | //*** Global reconstruction flag setters | |
87 | void SetRunVertexFinder(Bool_t flag=kTRUE) {fRunVertexFinder=flag;}; | |
88 | void SetRunVertexFinderTracks(Bool_t flag=kTRUE) {fRunVertexFinderTracks=flag;}; | |
89 | void SetRunHLTTracking(Bool_t flag=kTRUE) {fRunHLTTracking=flag;}; | |
90 | void SetRunV0Finder(Bool_t flag=kTRUE) {fRunV0Finder=flag;}; | |
91 | void SetRunCascadeFinder(Bool_t flag=kTRUE) {fRunCascadeFinder=flag;}; | |
92 | void SetStopOnError(Bool_t flag=kTRUE) {fStopOnError=flag;} | |
93 | void SetWriteAlignmentData(Bool_t flag=kTRUE){fWriteAlignmentData=flag;} | |
94 | void SetWriteESDfriend(Bool_t flag=kTRUE){fWriteESDfriend=flag;} | |
95 | void SetFillTriggerESD(Bool_t flag=kTRUE){fFillTriggerESD=flag;} | |
96 | void SetDiamondProfileSPD(AliESDVertex *dp) {fDiamondProfileSPD=dp;} | |
97 | void SetDiamondProfile(AliESDVertex *dp) {fDiamondProfile=dp;} | |
98 | void SetDiamondProfileTPC(AliESDVertex *dp) {fDiamondProfileTPC=dp;} | |
99 | ||
100 | void SetCleanESD(Bool_t flag=kTRUE){fCleanESD=flag;} | |
101 | void SetUseHLTData(const char* detectors){fUseHLTData=detectors;} | |
102 | void SetV0DCAmax(Float_t d) {fV0DCAmax=d;} | |
103 | void SetV0CsPmin(Float_t d) {fV0CsPmin=d;} | |
104 | void SetDmax(Float_t d) {fDmax=d;} | |
105 | void SetZmax(Float_t z) {fZmax=z;} | |
106 | Float_t GetV0DCAmax() const {return fV0DCAmax;} | |
107 | Float_t GetV0CsPmin() const {return fV0CsPmin;} | |
108 | Float_t GetDmax() const {return fDmax;} | |
109 | Float_t GetZmax() const {return fZmax;} | |
110 | ||
111 | // CDB storage activation | |
112 | void SetDefaultStorage(const char* uri); | |
113 | void SetSpecificStorage(const char* calibType, const char* uri); | |
114 | ||
115 | Bool_t MisalignGeometry(const TString& detectors); | |
116 | ||
117 | void SetAlignObjArray(TObjArray *array) | |
118 | {fAlignObjArray = array; | |
119 | fLoadAlignFromCDB = kFALSE;} | |
120 | ||
121 | virtual Int_t Version() const {return 2;} | |
122 | virtual void Begin(TTree*); | |
123 | virtual void SlaveBegin(TTree*); | |
124 | virtual void Init(TTree *tree); | |
125 | virtual Bool_t Process(Long64_t entry); | |
126 | virtual Bool_t ProcessEvent(Int_t iEvent); | |
127 | virtual void SlaveTerminate(); | |
128 | virtual void Terminate(); | |
129 | virtual Bool_t Run(const char* input = NULL); | |
130 | void Abort(const char *method, EAbort what); | |
131 | virtual void SetOption(const char* option) { | |
132 | TSelector::SetOption(option); | |
133 | } | |
134 | ||
135 | // Trackers | |
136 | AliTracker* GetTracker(Int_t idx) const { return fTracker[idx]; } | |
137 | Bool_t CreateTrackers(const TString& detectors); | |
138 | void ImportRunLoader(AliRunLoader* rl) { fRunLoader = rl; } | |
139 | ||
140 | // Quality Assurance | |
141 | void SetQACycles(AliQAv1::DETECTORINDEX_t det, Int_t cycles) { fQACycles[det] = cycles ; } | |
142 | void SetQAWriteExpert(AliQAv1::DETECTORINDEX_t det) { fQAWriteExpert[det] = kTRUE ; } | |
143 | Bool_t SetRunQA(TString detAndAction="ALL:ALL") ; | |
144 | void SetRunGlobalQA(Bool_t flag=kTRUE){fRunGlobalQA = flag;} | |
145 | void SetQARefDefaultStorage(const char* uri); | |
146 | void InitQA(); | |
147 | void MergeQA(const char *fileName = NULL); | |
148 | void SetWriteQAExpert() { fWriteQAExpertData = kTRUE ; } | |
149 | Bool_t IsRunQA() { return fRunQA ; } | |
150 | Bool_t IsRunGlobalQA() { return fRunGlobalQA ; } | |
151 | Bool_t IsInTasks(AliQAv1::TASKINDEX_t tsk) { return fQATasks.Contains(Form("%d", tsk)) ; } | |
152 | ||
153 | // Plane Efficiency Evaluation | |
154 | void SetRunPlaneEff(Bool_t flag=kFALSE) {fRunPlaneEff = flag;} | |
155 | ||
156 | enum { | |
157 | kNDetectors = 15 // number of detectors | |
158 | }; | |
159 | static Int_t GetDetIndex(const char * detector); | |
160 | ||
161 | protected: | |
162 | virtual Bool_t ProcessEvent(void* event); | |
163 | void InitRun(const char* input); | |
164 | ||
165 | private: | |
166 | AliReconstruction(const AliReconstruction& rec); | |
167 | AliReconstruction& operator = (const AliReconstruction& rec); | |
168 | ||
169 | void InitRawReader(const char* input); | |
170 | void InitCDB(); | |
171 | Bool_t InitGRP(); | |
172 | void SetCDBLock(); | |
173 | Bool_t SetRunNumberFromData(); | |
174 | Bool_t LoadCDB(); | |
175 | Bool_t LoadTriggerScalersCDB(); | |
176 | Bool_t LoadCTPTimeParamsCDB(); | |
177 | Bool_t RunLocalEventReconstruction(const TString& detectors); | |
178 | Bool_t RunVertexFinder(AliESDEvent*& esd); | |
179 | Bool_t RunHLTTracking(AliESDEvent*& esd); | |
180 | Bool_t RunMuonTracking(AliESDEvent*& esd); | |
181 | Bool_t RunSPDTrackleting(AliESDEvent*& esd); | |
182 | Bool_t RunTracking(AliESDEvent*& esd, AliESDpid &PID); | |
183 | Bool_t CleanESD(AliESDEvent *esd); | |
184 | Bool_t FillESD(AliESDEvent*& esd, const TString& detectors); | |
185 | Bool_t FillTriggerESD(AliESDEvent*& esd); | |
186 | Bool_t FillTriggerScalers(AliESDEvent*& esd); | |
187 | Bool_t FillRawEventHeaderESD(AliESDEvent*& esd); | |
188 | ||
189 | Bool_t IsSelected(TString detName, TString& detectors) const; | |
190 | Bool_t InitRunLoader(); | |
191 | AliReconstructor* GetReconstructor(Int_t iDet); | |
192 | AliVertexer* CreateVertexer(); | |
193 | void CleanUp(); | |
194 | ||
195 | Bool_t ParseOutput(); | |
196 | ||
197 | //==========================================// | |
198 | void WriteAlignmentData(AliESDEvent* esd); | |
199 | ||
200 | void FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd); | |
201 | ||
202 | //Quality Assurance | |
203 | void CheckQA() ; | |
204 | ||
205 | // Plane Efficiency evaluation | |
206 | Bool_t FinishPlaneEff(); //ultimate tasks related to Plane Eff. evaluation | |
207 | Bool_t InitPlaneEff(); // initialize what is needed for Plane Eff. evaluation | |
208 | ||
209 | Bool_t InitAliEVE(); | |
210 | void RunAliEVE(); | |
211 | ||
212 | Bool_t InitRecoParams(); // init the array with the reconstruciton parameters | |
213 | Bool_t GetEventInfo(); // fill the event info inside the event loop | |
214 | ||
215 | const char *MatchDetectorList(const char *detectorList, UInt_t detectorMask); | |
216 | ||
217 | //*** Global reconstruction flags ******************* | |
218 | Bool_t fRunVertexFinder; // run the vertex finder | |
219 | Bool_t fRunVertexFinderTracks; // run the vertex finder with tracks | |
220 | Bool_t fRunHLTTracking; // run the HLT tracking | |
221 | Bool_t fRunMuonTracking; // run the HLT tracking | |
222 | Bool_t fRunV0Finder; // run the ESD V0 finder | |
223 | Bool_t fRunCascadeFinder; // run the ESD cascade finder | |
224 | Bool_t fStopOnError; // stop or continue on errors | |
225 | Bool_t fWriteAlignmentData; // write track space-points flag | |
226 | Bool_t fWriteESDfriend; // write ESD friend flag | |
227 | Bool_t fFillTriggerESD; // fill trigger info into ESD | |
228 | ||
229 | //*** Clean ESD flag and parameters ******************* | |
230 | Bool_t fCleanESD; // clean ESD flag | |
231 | Float_t fV0DCAmax; // max. allowed DCA between V0 daugthers | |
232 | Float_t fV0CsPmin; // min. allowed cosine of V0 pointing angle | |
233 | Float_t fDmax; // max. allowed transverse impact parameter | |
234 | Float_t fZmax; // max. allowed longitudinal impact parameter | |
235 | ||
236 | TString fRunLocalReconstruction; // run the local reconstruction for these detectors | |
237 | TString fRunTracking; // run the tracking for these detectors | |
238 | TString fFillESD; // fill ESD for these detectors | |
239 | TString fLoadCDB; // prefetch CDB entries and init reco-params for these detectors | |
240 | TString fUseTrackingErrorsForAlignment; // for these detectors | |
241 | TString fGAliceFileName; // name of the galice file | |
242 | TString fRawInput; // name of input raw-data file or directory | |
243 | TString fESDOutput; //! name of output ESD file | |
244 | TString fProofOutputFileName;//! name of output file in PROOF mode | |
245 | TString fProofOutputLocation;//! output location in PROOF mode | |
246 | Bool_t fProofOutputDataset; //! keep output file in PROOF mode in dataset or merge | |
247 | TString fProofOutputArchive; //! list of file to be kept in output zip archive in PROOF mode | |
248 | TString fEquipIdMap; // name of file with equipment id map | |
249 | Int_t fFirstEvent; // index of first event to be reconstr. | |
250 | Int_t fLastEvent; // index of last event to be reconstr. | |
251 | UInt_t fNumberOfEventsPerFile; // number of events per file in case of raw-data reconstruction | |
252 | TObjArray fOptions; // options for reconstructor objects | |
253 | Bool_t fLoadAlignFromCDB; // Load alignment data from CDB and apply it to geometry or not | |
254 | TString fLoadAlignData; // Load alignment data from CDB for these detectors | |
255 | TString fUseHLTData; // Detectors for which the HLT data is used as input | |
256 | AliRunInfo* fRunInfo; // an object which contains essential global conditions information | |
257 | AliEventInfo fEventInfo; // an object which contains essential event information | |
258 | AliTriggerRunScalers* fRunScalers; // an object which contains the trigger counters for xsection | |
259 | AliCTPTimeParams* fCTPTimeParams; // an object which contains the trigger delays | |
260 | AliRunLoader* fRunLoader; //! current run loader object | |
261 | AliRawReader* fRawReader; //! current raw data reader | |
262 | AliRawReader* fParentRawReader; //! parent raw data reader in case of AliRawReaderHLT | |
263 | ||
264 | static const char* fgkDetectorName[kNDetectors]; //! names of detectors | |
265 | AliReconstructor* fReconstructor[kNDetectors]; //! array of reconstructor objects | |
266 | AliRecoParam fRecoParam; // container for the reco-param objects for detectors | |
267 | AliLoader* fLoader[kNDetectors]; //! detector loaders | |
268 | AliTracker* fTracker[kNDetectors]; //! trackers | |
269 | AliTracker* fSPDTrackleter; //! trackleter [for SPD Plane Efficiency purposes] | |
270 | AliESDVertex* fDiamondProfileSPD; // (x,y) diamond profile from SPD for AliITSVertexer3D(Z) | |
271 | AliESDVertex* fDiamondProfile; // (x,y) diamond profile for AliVertexerTracks (ITS+TPC) | |
272 | AliESDVertex* fDiamondProfileTPC; // (x,y) diamond profile from TPC for AliVertexerTracks | |
273 | THashTable* fListOfCosmicTriggers; // list of cosmic triggers as defined by trigger coordination | |
274 | ||
275 | AliGRPObject* fGRPData; // Data from the GRP/GRP/Data CDB folder | |
276 | ||
277 | TObjArray* fAlignObjArray; //! array with the alignment objects to be applied to the geometry | |
278 | ||
279 | TString fCDBUri; //! Uri of the default CDB storage | |
280 | TString fQARefUri; //! Uri of the default QA reference storage | |
281 | TObjArray fSpecCDBUri; //! Array with detector specific CDB storages | |
282 | Bool_t fInitCDBCalled; //! flag to check if CDB storages are already initialized | |
283 | Bool_t fSetRunNumberFromDataCalled; //! flag to check if run number is already loaded from run loader | |
284 | ||
285 | //Quality Assurance | |
286 | Int_t fQACycles[ AliQAv1::kNDET]; // # events over which QA data are accumulated | |
287 | Bool_t fQAWriteExpert[AliQAv1::kNDET]; // Flag to save or not expert QA data | |
288 | TString fQADetectors ; // list of detectors to be QA'ed | |
289 | TString fQATasks ; // list of QA tasks to be performed | |
290 | Bool_t fRunQA ; // Run QA flag | |
291 | Bool_t fRunGlobalQA; // Run global QA flag | |
292 | Bool_t fSameQACycle; //! open a new QA data file or not | |
293 | Bool_t fInitQACalled; //! control of QA intialisation | |
294 | Bool_t fWriteQAExpertData ; //! decides wheter or not to write experts QA data; true by default | |
295 | ||
296 | // Plane Efficiency Evaluation | |
297 | Bool_t fRunPlaneEff ; // Evaluate Plane Efficiency | |
298 | ||
299 | // New members needed in order to split Run method | |
300 | // into InitRun,RunEvent,FinishRun methods | |
301 | AliESDEvent* fesd; //! Pointer to the ESD event object | |
302 | AliESDEvent* fhltesd; //! Pointer to the HLT ESD event object | |
303 | AliESDfriend* fesdf; //! Pointer to the ESD friend object | |
304 | TFile* ffile; //! Pointer to the ESD file | |
305 | TFile* ffileF; //! Pointer to the ESD friend file | |
306 | TTree* ftree; //! Pointer to the ESD tree | |
307 | TTree* ftreeF; //! Pointer to the ESD friend tree | |
308 | TTree* fhlttree; //! Pointer to the HLT ESD tree | |
309 | AliVertexerTracks* ftVertexer; //! Pointer to the vertexer based on ESD tracks | |
310 | Bool_t fIsNewRunLoader; // galice.root created from scratch (real raw data case) | |
311 | Bool_t fRunAliEVE; // Run AliEVE or not | |
312 | ||
313 | TTree* fChain; //! The raw-data chain in case of AliRawReaderChain | |
314 | ||
315 | ClassDef(AliReconstruction, 34) // class for running the reconstruction | |
316 | }; | |
317 | ||
318 | #endif |