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