TRD/AliTRDReconstructor.cxx

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