]>
Commit | Line | Data |
---|---|---|
1 | /************************************************************************** | |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | /* $Id$ */ | |
17 | ||
18 | /////////////////////////////////////////////////////////////////////////////// | |
19 | // // | |
20 | // Class for TRD reconstruction // | |
21 | // // | |
22 | // For the special options which can be used during reconstruction and their // | |
23 | // default values pls. see function SetOption(). // | |
24 | // // | |
25 | /////////////////////////////////////////////////////////////////////////////// | |
26 | ||
27 | #include <TObjString.h> | |
28 | #include <TObjArray.h> | |
29 | #include <TTreeStream.h> | |
30 | #include <TDirectory.h> | |
31 | #include <TRef.h> | |
32 | ||
33 | #include "AliRawReader.h" | |
34 | #include "AliLog.h" | |
35 | ||
36 | #include "AliTRDReconstructor.h" | |
37 | #include "AliTRDclusterizer.h" | |
38 | #include "AliTRDrawData.h" | |
39 | #include "AliTRDrawStream.h" | |
40 | #include "AliTRDdigitsManager.h" | |
41 | #include "AliTRDtrackerV1.h" | |
42 | #include "AliESDEvent.h" | |
43 | #include "AliESDTrdTrack.h" | |
44 | #include "AliESDTrdTracklet.h" | |
45 | #include "AliESDTrdTrigger.h" | |
46 | #include "AliTRDtrackletWord.h" | |
47 | #include "AliTRDtrackletMCM.h" | |
48 | #include "AliTRDonlineTrackMatching.h" | |
49 | ||
50 | #define SETFLG(n,f) ((n) |= f) | |
51 | #define CLRFLG(n,f) ((n) &= ~f) | |
52 | ||
53 | ClassImp(AliTRDReconstructor) | |
54 | ||
55 | AliESDTrdTrigger AliTRDReconstructor::fgTriggerFlags; | |
56 | AliTRDonlineTrackMatching AliTRDReconstructor::fgOnlineTrackMatcher; | |
57 | TClonesArray *AliTRDReconstructor::fgClusters = NULL; | |
58 | TClonesArray *AliTRDReconstructor::fgTracklets = NULL; | |
59 | TClonesArray *AliTRDReconstructor::fgTracks = NULL; | |
60 | Char_t const * AliTRDReconstructor::fgSteerNames[kNsteer] = { | |
61 | "DigitsConversion " | |
62 | ,"Write Clusters " | |
63 | ,"Write Online Tracklets " | |
64 | ,"Stand Alone Tracking " | |
65 | ,"HLT Mode " | |
66 | ,"Process Online Trklts " | |
67 | ,"Debug Streaming " | |
68 | ,"Cl. Radial Correction " | |
69 | }; | |
70 | Char_t const * AliTRDReconstructor::fgSteerFlags[kNsteer] = { | |
71 | "dc"// digits conversion [false] | |
72 | ,"cw"// write clusters [true] | |
73 | ,"tw"// write online tracklets [false] | |
74 | ,"sa"// track seeding (stand alone tracking) [true] | |
75 | ,"hlt"// HLT reconstruction [false] | |
76 | ,"tp"// also use online tracklets for reconstruction [false] | |
77 | ,"deb"// Write debug stream [false] | |
78 | ,"cc" // Cluster radial correction during reconstruction [false] | |
79 | }; | |
80 | Char_t const * AliTRDReconstructor::fgTaskNames[AliTRDrecoParam::kTRDreconstructionTasks] = { | |
81 | "Clusterizer" | |
82 | ,"Tracker" | |
83 | ,"PID" | |
84 | }; | |
85 | Char_t const * AliTRDReconstructor::fgTaskFlags[AliTRDrecoParam::kTRDreconstructionTasks] = { | |
86 | "cl" | |
87 | ,"tr" | |
88 | ,"pd" | |
89 | }; | |
90 | Int_t AliTRDReconstructor::fgNTimeBins = -1; | |
91 | const Float_t AliTRDReconstructor::fgkMinClustersInTrack = 0.5; // | |
92 | const Float_t AliTRDReconstructor::fgkLabelFraction = 0.8; // | |
93 | const Double_t AliTRDReconstructor::fgkMaxChi2 = 12.0; // | |
94 | const Double_t AliTRDReconstructor::fgkMaxSnp = 0.95; // Maximum local sine of the azimuthal angle | |
95 | const Double_t AliTRDReconstructor::fgkMaxStep = 2.0; // Maximal step size in propagation | |
96 | const Double_t AliTRDReconstructor::fgkEpsilon = 1.e-5; // Precision of radial coordinate | |
97 | ||
98 | //_____________________________________________________________________________ | |
99 | AliTRDReconstructor::AliTRDReconstructor() | |
100 | :AliReconstructor() | |
101 | ,fSteerParam(0) | |
102 | ,fClusterizer(NULL) | |
103 | { | |
104 | // setting default "ON" steering parameters | |
105 | // owner of debug streamers | |
106 | SETFLG(fSteerParam, kOwner); | |
107 | // write clusters [cw] | |
108 | SETFLG(fSteerParam, kWriteClusters); | |
109 | // track seeding (stand alone tracking) [sa] | |
110 | //SETFLG(fSteerParam, kSeeding); | |
111 | // Cluster radial correction during reconstruction [cc] | |
112 | //SETFLG(fSteerParam, kClRadialCorr); | |
113 | memset(fDebugStream, 0, sizeof(TTreeSRedirector *) * AliTRDrecoParam::kTRDreconstructionTasks); | |
114 | } | |
115 | ||
116 | //_____________________________________________________________________________ | |
117 | AliTRDReconstructor::~AliTRDReconstructor() | |
118 | { | |
119 | // | |
120 | // Destructor | |
121 | // | |
122 | ||
123 | if(fClusterizer){ | |
124 | delete fClusterizer; | |
125 | fClusterizer = NULL; | |
126 | } | |
127 | if(fgClusters) { | |
128 | fgClusters->Delete(); | |
129 | delete fgClusters; | |
130 | fgClusters = NULL; | |
131 | } | |
132 | if(fgTracklets) { | |
133 | fgTracklets->Delete(); | |
134 | delete fgTracklets; | |
135 | fgTracklets = NULL; | |
136 | } | |
137 | if(fgTracks) { | |
138 | fgTracks->Delete(); | |
139 | delete fgTracks; | |
140 | fgTracks = NULL; | |
141 | } | |
142 | if(fSteerParam&kOwner){ | |
143 | for(Int_t itask = 0; itask < AliTRDrecoParam::kTRDreconstructionTasks; itask++) | |
144 | if(fDebugStream[itask]) delete fDebugStream[itask]; | |
145 | } | |
146 | } | |
147 | ||
148 | ||
149 | //_____________________________________________________________________________ | |
150 | void AliTRDReconstructor::Init(){ | |
151 | // | |
152 | // Init Options | |
153 | // | |
154 | SetOption(GetOption()); | |
155 | Options(fSteerParam); | |
156 | ||
157 | if(!fClusterizer){ | |
158 | fClusterizer = new AliTRDclusterizer(fgTaskNames[AliTRDrecoParam::kClusterizer], fgTaskNames[AliTRDrecoParam::kClusterizer]); | |
159 | fClusterizer->SetReconstructor(this); | |
160 | AliInfo(Form("Build TRD clusterizer[%p]", (void*)fClusterizer)); | |
161 | } | |
162 | ||
163 | // Make Debug Streams when Debug Streaming | |
164 | if(IsDebugStreaming()){ | |
165 | for(Int_t task = 0; task < AliTRDrecoParam::kTRDreconstructionTasks; task++){ | |
166 | TDirectory *savedir = gDirectory; | |
167 | fDebugStream[task] = new TTreeSRedirector(Form("TRD.Debug%s.root", fgTaskNames[task])); | |
168 | savedir->cd(); | |
169 | SETFLG(fSteerParam, kOwner); | |
170 | } | |
171 | } | |
172 | } | |
173 | ||
174 | //_____________________________________________________________________________ | |
175 | void AliTRDReconstructor::ConvertDigits(AliRawReader *rawReader | |
176 | , TTree *digitsTree) const | |
177 | { | |
178 | // | |
179 | // Convert raw data digits into digit objects in a root tree | |
180 | // | |
181 | ||
182 | AliDebug(1, "Convert raw data digits into digit objects [RawReader -> Digit TTree]"); | |
183 | AliDebug(2, Form("clusters[%p] tracklets[%p] tracks[%p]", (void*)fgClusters, (void*)fgTracklets, (void*)fgTracks)); | |
184 | ||
185 | rawReader->Reset(); | |
186 | rawReader->Select("TRD"); | |
187 | ResetContainers(); | |
188 | ||
189 | AliTRDrawData rawData; | |
190 | ||
191 | AliTRDdigitsManager *manager = rawData.Raw2Digits(rawReader); | |
192 | manager->MakeBranch(digitsTree); | |
193 | manager->WriteDigits(); | |
194 | delete manager; | |
195 | ||
196 | for (Int_t iSector = 0; iSector < 18; iSector++) fgTriggerFlags.SetFlags(iSector, rawData.GetTriggerFlags(iSector)); | |
197 | } | |
198 | ||
199 | //_____________________________________________________________________________ | |
200 | void AliTRDReconstructor::Reconstruct(AliRawReader *rawReader | |
201 | , TTree *clusterTree) const | |
202 | { | |
203 | // | |
204 | // Reconstruct clusters | |
205 | // | |
206 | ||
207 | AliDebug(1, "Reconstruct TRD clusters from RAW data [RawReader -> Cluster TTree]"); | |
208 | AliDebug(2, Form("clusters[%p] tracklets[%p] tracks[%p]", (void*)fgClusters, (void*)fgTracklets, (void*)fgTracks)); | |
209 | if(!fClusterizer){ | |
210 | AliFatal("Clusterizer not available!"); | |
211 | return; | |
212 | } | |
213 | rawReader->Reset(); | |
214 | rawReader->Select("TRD"); | |
215 | ResetContainers(); | |
216 | fClusterizer->OpenOutput(clusterTree); | |
217 | fClusterizer->SetUseLabels(kFALSE); | |
218 | fClusterizer->SetStoreRawSignals(kTRUE); | |
219 | fClusterizer->ResetRecPoints(); | |
220 | fClusterizer->Raw2ClustersChamber(rawReader); | |
221 | fgNTimeBins = fClusterizer->GetNTimeBins(); | |
222 | for (Int_t iSector = 0; iSector < 18; iSector++) fgTriggerFlags.SetFlags(iSector, fClusterizer->GetTriggerFlags(iSector)); | |
223 | } | |
224 | ||
225 | //_____________________________________________________________________________ | |
226 | void AliTRDReconstructor::Reconstruct(TTree *digitsTree | |
227 | , TTree *clusterTree) const | |
228 | { | |
229 | // | |
230 | // Reconstruct clusters | |
231 | // | |
232 | ||
233 | AliDebug(1, "Reconstruct TRD clusters from Digits [Digit TTree -> Cluster TTree]"); | |
234 | AliDebug(2, Form("Start :: clusters[%p] tracklets[%p] tracks[%p]", (void*)fgClusters, (void*)fgTracklets, (void*)fgTracks)); | |
235 | if(!fClusterizer){ | |
236 | AliFatal("Clusterizer not available!"); | |
237 | return; | |
238 | } | |
239 | ||
240 | ResetContainers(); | |
241 | AliTRDclusterizer clusterizer(fgTaskNames[AliTRDrecoParam::kClusterizer], fgTaskNames[AliTRDrecoParam::kClusterizer]); | |
242 | clusterizer.SetReconstructor(this); | |
243 | clusterizer.SetUseLabels(kTRUE); | |
244 | clusterizer.SetStoreRawSignals(kTRUE); | |
245 | clusterizer.OpenOutput(clusterTree); | |
246 | clusterizer.ReadDigits(digitsTree); | |
247 | clusterizer.ReadTracklets(); | |
248 | clusterizer.ReadTracks(); | |
249 | clusterizer.MakeClusters(); | |
250 | fgNTimeBins = clusterizer.GetNTimeBins(); | |
251 | } | |
252 | ||
253 | //_____________________________________________________________________________ | |
254 | AliTracker *AliTRDReconstructor::CreateTracker() const | |
255 | { | |
256 | // | |
257 | // Create a TRD tracker | |
258 | // | |
259 | ||
260 | //return new AliTRDtracker(NULL); | |
261 | AliTRDtrackerV1 *tracker = new AliTRDtrackerV1(); | |
262 | tracker->SetReconstructor(this); | |
263 | AliInfo(Form("Build TRD tracker[%p]", (void*)tracker)); | |
264 | return tracker; | |
265 | ||
266 | } | |
267 | ||
268 | //_____________________________________________________________________________ | |
269 | void AliTRDReconstructor::FillESD(TTree* /*digitsTree*/ | |
270 | , TTree* /*clusterTree*/ | |
271 | , AliESDEvent* esd) const | |
272 | { | |
273 | // | |
274 | // Fill ESD | |
275 | // | |
276 | ||
277 | // ----- filling tracklets ----- | |
278 | AliDebug(1, Form("Loading onl.tracklets(%i) to ESD", fgTracklets ? fgTracklets->GetEntriesFast() : 0)); | |
279 | Int_t trackletIndex[1080] = { 0 }; | |
280 | TList trklList; | |
281 | AliTRDrawStream::SortTracklets(fgTracklets, trklList, trackletIndex); | |
282 | TIter trackletIter(&trklList); | |
283 | while (AliTRDtrackletBase* tracklet = (AliTRDtrackletBase*) trackletIter()) { | |
284 | Int_t label = -2; // mark raw tracklets with label -2 | |
285 | if (AliTRDtrackletMCM *trklMCM = dynamic_cast<AliTRDtrackletMCM*> (tracklet)) label = trklMCM->GetLabel(); | |
286 | esd->AddTrdTracklet(new AliESDTrdTracklet(tracklet->GetTrackletWord(), tracklet->GetHCId(), label)); | |
287 | } | |
288 | ||
289 | // ----- filling GTU tracks ----- | |
290 | AliDebug(1, Form("Loading gtu.tracks(%i) to ESD", fgTracks ? fgTracks->GetEntriesFast() : 0)); | |
291 | if (fgTracks) { | |
292 | for (Int_t iTrack = 0; iTrack < fgTracks->GetEntriesFast(); iTrack++) { | |
293 | AliESDTrdTrack *trdTrack = (AliESDTrdTrack*) ((*fgTracks)[iTrack]); | |
294 | ||
295 | UInt_t stack = trdTrack->GetStack(); | |
296 | ||
297 | Int_t refIndex[6]; | |
298 | AliTRDrawStream::AssignTracklets(trdTrack, trackletIndex, refIndex); | |
299 | ||
300 | for (Int_t iLayer = 0; iLayer < 6; ++iLayer) { | |
301 | Int_t det = trdTrack->GetSector()*30 + stack*6 + iLayer; | |
302 | AliESDTrdTracklet *trkl = refIndex[iLayer] > -1 ? esd->GetTrdTracklet(refIndex[iLayer]) : 0x0; | |
303 | if (trkl) { | |
304 | AliDebug(5, Form("adding tracklet with index %i: 0x%08x", | |
305 | refIndex[iLayer], trkl->GetTrackletWord())); | |
306 | if (trkl->GetDetector() != det) | |
307 | AliError(Form("inconsistent assignment of tracklet 0x%08x in det %i to track in %i", | |
308 | trkl->GetTrackletWord(), trkl->GetDetector(), det)); | |
309 | trdTrack->AddTrackletReference(trkl, iLayer); | |
310 | } | |
311 | } | |
312 | // only add the track when it's complete (including tracklet references) | |
313 | esd->AddTrdTrack(trdTrack); | |
314 | } | |
315 | } | |
316 | esd->SetTrdTrigger(&fgTriggerFlags); | |
317 | ||
318 | // ----- matching GTU tracks to global tracks ----- | |
319 | AliDebug(1, Form("TRD track matching with %i ESD, %i TRD tracks", | |
320 | esd->GetNumberOfTracks(), esd->GetNumberOfTrdTracks())); | |
321 | fgOnlineTrackMatcher.ProcessEvent(esd); | |
322 | } | |
323 | ||
324 | //_____________________________________________________________________________ | |
325 | void AliTRDReconstructor::SetOption(Option_t *opt) | |
326 | { | |
327 | // | |
328 | // Read option string into the steer param. | |
329 | // | |
330 | // The following string options are available during reconstruction. | |
331 | // In square brackets the default values are given. | |
332 | // "dc" : digits conversion [false] | |
333 | // "cw" : write clusters [true] | |
334 | // "tw" : write online tracklets [false] | |
335 | // "sa" : track seeding (stand alone tracking) [true] | |
336 | // "hlt" : HLT reconstruction [false] | |
337 | // "tp" : also use online tracklets for reconstruction [false] | |
338 | // "deb" : Write debug stream [false] | |
339 | // "cc" : Cluster radial correction during reconstruction [false] | |
340 | // | |
341 | // To check the actual options used during reconstruction include the following line in your rec.C script | |
342 | // AliLog::SetClassDebugLevel("AliTRDReconstructor", 1); | |
343 | ||
344 | AliReconstructor::SetOption(opt); | |
345 | ||
346 | TString s(opt); | |
347 | TObjArray *opar = s.Tokenize(","); | |
348 | for(Int_t ipar=0; ipar<opar->GetEntriesFast(); ipar++){ | |
349 | Bool_t processed = kFALSE; | |
350 | TString sopt(((TObjString*)(*opar)[ipar])->String()); | |
351 | for(Int_t iopt=0; iopt<kNsteer; iopt++){ | |
352 | if(!sopt.Contains(fgSteerFlags[iopt])) continue; | |
353 | SETFLG(fSteerParam, BIT(iopt)); | |
354 | if(sopt.Contains("!")) CLRFLG(fSteerParam, BIT(iopt)); | |
355 | processed = kTRUE; | |
356 | break; | |
357 | } | |
358 | if(processed) continue; | |
359 | ||
360 | AliWarning(Form("Unknown option flag %s.", sopt.Data())); | |
361 | } | |
362 | opar->Delete(); | |
363 | delete opar; | |
364 | } | |
365 | ||
366 | //_____________________________________________________________________________ | |
367 | void AliTRDReconstructor::Options(UInt_t steer) | |
368 | { | |
369 | // | |
370 | // Print the options | |
371 | // | |
372 | ||
373 | for(Int_t iopt=0; iopt<kNsteer; iopt++){ | |
374 | AliDebugGeneral("AliTRDReconstructor", 1, Form(" %s[%s]%s", fgSteerNames[iopt], fgSteerFlags[iopt], steer ?(((steer>>iopt)&1)?" : ON":" : OFF"):"")); | |
375 | } | |
376 | } | |
377 | ||
378 | ||
379 | //_____________________________________________________________________________ | |
380 | TClonesArray* AliTRDReconstructor::GetClusters() | |
381 | { | |
382 | // Build/ Retrieve cluster array | |
383 | if(!fgClusters){ | |
384 | fgClusters = new TClonesArray("AliTRDcluster", Int_t(GetRecoParam()->GetNClusters())); | |
385 | fgClusters->SetOwner(); | |
386 | AliInfoGeneral("AliTRDReconstructor", Form("Allocate cluster array @ %p", (void*)fgClusters)); | |
387 | } | |
388 | return fgClusters; | |
389 | } | |
390 | ||
391 | //_____________________________________________________________________________ | |
392 | TClonesArray* AliTRDReconstructor::GetTracklets(const char *trkltype) | |
393 | { | |
394 | // Build/ Retrieve online tracklets array | |
395 | ||
396 | if (trkltype && strlen(trkltype) > 0) { | |
397 | if(fgTracklets && (TClass::GetClass(trkltype) != fgTracklets->GetClass())){ | |
398 | fgTracklets->Delete(); | |
399 | delete fgTracklets; | |
400 | } | |
401 | if (!fgTracklets) { | |
402 | fgTracklets = new TClonesArray(trkltype, 200); | |
403 | fgTracklets->SetOwner(kTRUE); | |
404 | AliInfoGeneral("AliTRDReconstructor", Form("Allocate online tracklets[%s] array @ %p", trkltype, (void*)fgTracklets)); | |
405 | } | |
406 | } | |
407 | return fgTracklets; | |
408 | } | |
409 | ||
410 | //_____________________________________________________________________________ | |
411 | TClonesArray* AliTRDReconstructor::GetTracks() | |
412 | { | |
413 | // Build/ Retrieve cluster array | |
414 | if(!fgTracks){ | |
415 | fgTracks = new TClonesArray("AliESDTrdTrack", 100); | |
416 | fgTracks->SetOwner(); | |
417 | AliInfoGeneral("AliTRDReconstructor", Form("Allocate online tracks array @ %p", (void*)fgTracks)); | |
418 | } | |
419 | return fgTracks; | |
420 | } | |
421 | ||
422 | //_____________________________________________________________________________ | |
423 | void AliTRDReconstructor::ResetContainers() const | |
424 | { | |
425 | // prepare data containers for a new event | |
426 | ||
427 | if(fgClusters){ | |
428 | AliDebug(1, Form("Removing %5d clusters @ %p", fgClusters->GetEntriesFast(), (void*)fgClusters)); | |
429 | fgClusters->Clear(); | |
430 | } | |
431 | if(fgTracklets){ | |
432 | AliDebug(1, Form("Removing %3d online tracklets @ %p", fgTracklets->GetEntriesFast(), (void*)fgTracklets)); | |
433 | fgTracklets->Clear(); | |
434 | } | |
435 | if(fgTracks){ | |
436 | AliDebug(1, Form("Removing %3d online tracks @ %p", fgTracks->GetEntriesFast(), (void*)fgTracks)); | |
437 | fgTracks->Clear(); | |
438 | } | |
439 | } |