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