X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TRD%2FAliTRDReconstructor.cxx;h=a457fb75f81ecb9d84bbc7c83977126161ac83fe;hb=e8e7f17efbb765725f413cebe06c46ddcaab3629;hp=1ea05c6c3fffbf5cab8b47e599096090468f5943;hpb=8997183731be7ca9e11aafddffef7e0e4d99df0d;p=u%2Fmrichter%2FAliRoot.git diff --git a/TRD/AliTRDReconstructor.cxx b/TRD/AliTRDReconstructor.cxx index 1ea05c6c3ff..a457fb75f81 100644 --- a/TRD/AliTRDReconstructor.cxx +++ b/TRD/AliTRDReconstructor.cxx @@ -18,42 +18,83 @@ /////////////////////////////////////////////////////////////////////////////// // // // Class for TRD reconstruction // +// // +// For the special options which can be used during reconstruction and their // +// default values pls. see function SetOption(). // // // /////////////////////////////////////////////////////////////////////////////// -#include #include #include -#include +#include +#include +#include -#include "AliRunLoader.h" #include "AliRawReader.h" #include "AliLog.h" -#include "AliESDTrdTrack.h" -#include "AliESDEvent.h" #include "AliTRDReconstructor.h" #include "AliTRDclusterizer.h" -#include "AliTRDtracker.h" -#include "AliTRDpidESD.h" -#include "AliTRDgtuTrack.h" #include "AliTRDrawData.h" +#include "AliTRDrawStream.h" #include "AliTRDdigitsManager.h" #include "AliTRDtrackerV1.h" -#include "AliTRDrecoParam.h" - -#include "TTreeStream.h" +#include "AliESDEvent.h" +#include "AliESDTrdTrack.h" +#include "AliESDTrdTracklet.h" +#include "AliTRDtrackletWord.h" #define SETFLG(n,f) ((n) |= f) #define CLRFLG(n,f) ((n) &= ~f) ClassImp(AliTRDReconstructor) -TClonesArray *AliTRDReconstructor::fgClusters = 0x0; +TClonesArray *AliTRDReconstructor::fgClusters = NULL; +TClonesArray *AliTRDReconstructor::fgTracklets = NULL; +TClonesArray *AliTRDReconstructor::fgTracks = NULL; +Char_t const * AliTRDReconstructor::fgSteerNames[kNsteer] = { + "DigitsConversion " + ,"Write Clusters " + ,"Write Online Tracklets " + ,"Stand Alone Tracking " + ,"HLT Mode " + ,"Process Online Trklts " + ,"Debug Streaming " + ,"Cl. Radial Correction " +}; +Char_t const * AliTRDReconstructor::fgSteerFlags[kNsteer] = { + "dc"// digits conversion [false] + ,"cw"// write clusters [true] + ,"tw"// write online tracklets [false] + ,"sa"// track seeding (stand alone tracking) [true] + ,"hlt"// HLT reconstruction [false] + ,"tp"// also use online tracklets for reconstruction [false] + ,"deb"// Write debug stream [false] + ,"cc" // Cluster radial correction during reconstruction [false] +}; +Char_t const * AliTRDReconstructor::fgTaskNames[AliTRDrecoParam::kTRDreconstructionTasks] = { + "Clusterizer" + ,"Tracker" + ,"PID" +}; +Char_t const * AliTRDReconstructor::fgTaskFlags[AliTRDrecoParam::kTRDreconstructionTasks] = { + "cl" + ,"tr" + ,"pd" +}; +Int_t AliTRDReconstructor::fgNTimeBins = -1; +const Float_t AliTRDReconstructor::fgkMinClustersInTrack = 0.5; // +const Float_t AliTRDReconstructor::fgkLabelFraction = 0.8; // +const Double_t AliTRDReconstructor::fgkMaxChi2 = 12.0; // +const Double_t AliTRDReconstructor::fgkMaxSnp = 0.95; // Maximum local sine of the azimuthal angle +const Double_t AliTRDReconstructor::fgkMaxStep = 2.0; // Maximal step size in propagation +const Double_t AliTRDReconstructor::fgkEpsilon = 1.e-5; // Precision of radial coordinate + //_____________________________________________________________________________ AliTRDReconstructor::AliTRDReconstructor() :AliReconstructor() ,fSteerParam(0) + ,fClusterizer(NULL) { // setting default "ON" steering parameters // owner of debug streamers @@ -61,48 +102,42 @@ AliTRDReconstructor::AliTRDReconstructor() // write clusters [cw] SETFLG(fSteerParam, kWriteClusters); // track seeding (stand alone tracking) [sa] - SETFLG(fSteerParam, kSeeding); - // PID method in reconstruction (NN) [nn] - SETFLG(fSteerParam, kSteerPID); - // number of dEdx slices in the ESD track [8s] - //SETFLG(fSteerParam, kEightSlices); - - memset(fStreamLevel, 0, kNtasks*sizeof(UChar_t)); - memset(fDebugStream, 0, sizeof(TTreeSRedirector *) * kNtasks); - // Xe tail cancellation parameters - fTCParams[0] = 1.156; // r1 - fTCParams[1] = 0.130; // r2 - fTCParams[2] = 0.114; // c1 - fTCParams[3] = 0.624; // c2 - // Ar tail cancellation parameters - fTCParams[4] = 6.; // r1 - fTCParams[5] = 0.62; // r2 - fTCParams[6] = 0.0087;// c1 - fTCParams[7] = 0.07; // c2 -} - -//_____________________________________________________________________________ -AliTRDReconstructor::AliTRDReconstructor(const AliTRDReconstructor &r) - :AliReconstructor(r) - ,fSteerParam(r.fSteerParam) -{ - memcpy(fStreamLevel, r.fStreamLevel, kNtasks*sizeof(UChar_t)); - memcpy(fTCParams, r.fTCParams, 8*sizeof(Double_t)); - memcpy(fDebugStream, r.fDebugStream, sizeof(TTreeSRedirector *) *kNtasks); - // ownership of debug streamers is not taken - CLRFLG(fSteerParam, kOwner); + //SETFLG(fSteerParam, kSeeding); + // Cluster radial correction during reconstruction [cc] + //SETFLG(fSteerParam, kClRadialCorr); + memset(fDebugStream, 0, sizeof(TTreeSRedirector *) * AliTRDrecoParam::kTRDreconstructionTasks); } //_____________________________________________________________________________ AliTRDReconstructor::~AliTRDReconstructor() { + // + // Destructor + // + if(fgClusters) { - fgClusters->Delete(); delete fgClusters; + fgClusters->Delete(); + delete fgClusters; + fgClusters = NULL; } - if(TESTBIT(fSteerParam, kOwner)){ - for(Int_t itask = 0; itask < kNtasks; itask++) + if(fgTracklets) { + fgTracklets->Delete(); + delete fgTracklets; + fgTracklets = NULL; + } + if(fgTracks) { + fgTracks->Delete(); + delete fgTracks; + fgTracks = NULL; + } + if(fSteerParam&kOwner){ + for(Int_t itask = 0; itask < AliTRDrecoParam::kTRDreconstructionTasks; itask++) if(fDebugStream[itask]) delete fDebugStream[itask]; } + if(fClusterizer){ + delete fClusterizer; + fClusterizer = NULL; + } } @@ -112,17 +147,22 @@ void AliTRDReconstructor::Init(){ // Init Options // SetOption(GetOption()); + Options(fSteerParam); - AliInfo(Form("\tDigitsConversion [dc] : %s", fSteerParam&kDigitsConversion?"yes":"no")); - AliInfo(Form("\tWrite Clusters [cw] : %s", fSteerParam&kWriteClusters?"yes":"no")); - AliInfo(Form("\tWrite Online Tracklets [tw] : %s", fSteerParam&kWriteTracklets?"yes":"no")); - AliInfo(Form("\tDrift Gas Argon [ar] : %s", fSteerParam&kDriftGas?"yes":"no")); - AliInfo(Form("\tStand Alone Tracking [sa] : %s", fSteerParam&kSeeding?"yes":"no")); - AliInfo(Form("\tHLT Tracking [hlt] : %s", fSteerParam&kHLT?"yes":"no")); - AliInfo(Form("\tCosmic Reconstruction [cos] : %s", fSteerParam&kCosmic?"yes":"no")); - AliInfo(Form("\tNN PID [nn] : %s", fSteerParam&kSteerPID?"yes":"no")); - AliInfo(Form("\t8 dEdx slices in ESD [8s] : %s", fSteerParam&kEightSlices?"yes":"no")); - AliInfo(Form("\tStreaming Levels : Clusterizer[%d] Tracker[%d] PID[%d]", fStreamLevel[kClusterizer], fStreamLevel[kTracker], fStreamLevel[kPID])); + if(!fClusterizer){ + fClusterizer = new AliTRDclusterizer(fgTaskNames[AliTRDrecoParam::kClusterizer], fgTaskNames[AliTRDrecoParam::kClusterizer]); + fClusterizer->SetReconstructor(this); + } + + // Make Debug Streams when Debug Streaming + if(IsDebugStreaming()){ + for(Int_t task = 0; task < AliTRDrecoParam::kTRDreconstructionTasks; task++){ + TDirectory *savedir = gDirectory; + fDebugStream[task] = new TTreeSRedirector(Form("TRD.Debug%s.root", fgTaskNames[task])); + savedir->cd(); + SETFLG(fSteerParam, kOwner); + } + } } //_____________________________________________________________________________ @@ -132,9 +172,8 @@ void AliTRDReconstructor::ConvertDigits(AliRawReader *rawReader // // Convert raw data digits into digit objects in a root tree // - AliInfo("Feature not available for the moment."); return; - AliInfo("Convert raw data digits into digit objects [RawReader -> Digit TTree]"); + //AliInfo("Convert raw data digits into digit objects [RawReader -> Digit TTree]"); AliTRDrawData rawData; rawReader->Reset(); @@ -144,6 +183,13 @@ void AliTRDReconstructor::ConvertDigits(AliRawReader *rawReader manager->WriteDigits(); delete manager; + // take over ownership of online tracklets + fgTracklets = rawData.TrackletsArray(); + rawData.SetTrackletsOwner(0x0); + + // take over GTU tracks + fgTracks = rawData.TracksArray(); + rawData.SetTracksOwner(0x0); } //_____________________________________________________________________________ @@ -160,18 +206,32 @@ void AliTRDReconstructor::Reconstruct(AliRawReader *rawReader rawReader->Reset(); rawReader->Select("TRD"); - // New (fast) cluster finder - AliTRDclusterizer clusterer("clusterer","TRD clusterizer",this); - //clusterer.SetReconstructor(this); // ^| "this" tells the digitsmanager that we are reading raw files - clusterer.OpenOutput(clusterTree); // it is not strictly necessaray but will give a speed up - clusterer.SetAddLabels(kFALSE); - clusterer.Raw2ClustersChamber(rawReader); + if(!fClusterizer){ + AliFatal("Clusterizer not available!"); + return; + } + + fClusterizer->ResetRecPoints(); + + fClusterizer->OpenOutput(clusterTree); + fClusterizer->SetUseLabels(kFALSE); + fClusterizer->Raw2ClustersChamber(rawReader); + + fgNTimeBins = fClusterizer->GetNTimeBins(); + // take over ownership of online tracklets + fgTracklets = fClusterizer->TrackletsArray(); + fClusterizer->SetTrackletsOwner(kFALSE); + + // take over GTU tracks + fgTracks = fClusterizer->TracksArray(); + fClusterizer->SetTracksOwner(kFALSE); + if(IsWritingClusters()) return; // take over ownership of clusters - fgClusters = clusterer.RecPoints(); - clusterer.SetClustersOwner(kFALSE); + fgClusters = fClusterizer->RecPoints(); + fClusterizer->SetClustersOwner(kFALSE); } //_____________________________________________________________________________ @@ -183,13 +243,27 @@ void AliTRDReconstructor::Reconstruct(TTree *digitsTree // //AliInfo("Reconstruct TRD clusters from Digits [Digit TTree -> Cluster TTree]"); - - AliTRDclusterizer clusterer("clusterer","TRD clusterizer"); - clusterer.SetReconstructor(this); // ^| no this, because we are reading from digitsTree - clusterer.OpenOutput(clusterTree); // it is necessary to NOT have the "this" here! + + AliTRDclusterizer clusterer(fgTaskNames[AliTRDrecoParam::kClusterizer], fgTaskNames[AliTRDrecoParam::kClusterizer]); + clusterer.SetReconstructor(this); + clusterer.OpenOutput(clusterTree); clusterer.ReadDigits(digitsTree); clusterer.MakeClusters(); + // read tracklets and tracks if not done during reading of raw data + if (!fgTracklets) { + clusterer.ReadTracklets(); + fgTracklets = clusterer.TrackletsArray(); + clusterer.SetTrackletsOwner(kFALSE); + } + if (!fgTracks) { + clusterer.ReadTracks(); + fgTracks = clusterer.TracksArray(); + clusterer.SetTracksOwner(kFALSE); + } + + fgNTimeBins = clusterer.GetNTimeBins(); + if(IsWritingClusters()) return; // take over ownership of clusters @@ -214,106 +288,181 @@ AliTracker *AliTRDReconstructor::CreateTracker() const //_____________________________________________________________________________ void AliTRDReconstructor::FillESD(TTree* /*digitsTree*/ , TTree* /*clusterTree*/ - , AliESDEvent* /*esd*/) const + , AliESDEvent* esd) const { // // Fill ESD // + // ----- filling tracklets ----- + Int_t trackletIndex[1080] = { 0 }; + AliDebug(1, Form("Filling tracklets from %p (%i)", + fgTracklets, fgTracklets ? fgTracklets->GetEntriesFast() : 0)); + if (fgTracklets) { + Int_t nTracklets = fgTracklets->GetEntriesFast(); + + Int_t lastHC = -1; + for (Int_t iTracklet = 0; iTracklet < nTracklets; iTracklet++) { + AliTRDtrackletBase *trkl = (AliTRDtrackletBase*) ((*fgTracklets)[iTracklet]); + Int_t hc = trkl->GetHCId(); + // hc += trkl->GetY() > 0 ? 1 : 0; + if ((hc < 0) || (hc >= 1080)) { + AliError(Form("HC for tracklet: 0x%08x out of range: %i", trkl->GetTrackletWord(), trkl->GetHCId())); + continue; } + AliDebug(5, Form("hc: %4i : 0x%08x z: %2i", hc, trkl->GetTrackletWord(), trkl->GetZbin())); + if (hc != lastHC) { + AliDebug(2, Form("set tracklet index for HC %i to %i", hc, iTracklet)); + trackletIndex[hc] = iTracklet + 1; + lastHC = hc; + } + } + for (Int_t iDet = 0; iDet < 540; iDet++) { + Int_t trklIndexA = trackletIndex[2*iDet + 0] - 1; + Int_t trklIndexB = trackletIndex[2*iDet + 1] - 1; + Int_t trklIndex = esd->GetNumberOfTrdTracklets(); + AliTRDtrackletBase *trklA = trklIndexA > -1 ? (AliTRDtrackletBase*) ((*fgTracklets)[trklIndexA]) : 0x0; + AliTRDtrackletBase *trklB = trklIndexB > -1 ? (AliTRDtrackletBase*) ((*fgTracklets)[trklIndexB]) : 0x0; + while (trklA != 0x0 || trklB != 0x0) { + AliDebug(5, Form("det %i - A: %i/%i -> %p, B: %i/%i -> %p", + iDet, trklIndexA, nTracklets, trklA, trklIndexB, nTracklets, trklB)); + if (trklA == 0x0) { + AliESDTrdTracklet esdTracklet(trklB->GetTrackletWord(), trklB->GetHCId()); + esd->AddTrdTracklet(&esdTracklet); + trklIndexB++; + trklB = trklIndexB < nTracklets ? (AliTRDtrackletBase*) ((*fgTracklets)[trklIndexB]) : 0x0; + if (trklB && trklB->GetHCId() != 2*iDet + 1) + trklB = 0x0; + } + else if (trklB == 0x0) { + AliESDTrdTracklet esdTracklet(trklA->GetTrackletWord(), trklA->GetHCId()); + esd->AddTrdTracklet(&esdTracklet); + trklIndexA++; + trklA = trklIndexA < nTracklets ? (AliTRDtrackletBase*) ((*fgTracklets)[trklIndexA]) : 0x0; + if (trklA && trklA->GetHCId() != 2*iDet) + trklA = 0x0; + } + else { + if ((trklA->GetZbin() < trklB->GetZbin()) || + ((trklA->GetZbin() == trklB->GetZbin()) && (trklA->GetYbin() < trklB->GetYbin()))) { + AliESDTrdTracklet esdTracklet(trklA->GetTrackletWord(), trklA->GetHCId()); + esd->AddTrdTracklet(&esdTracklet); + trklIndexA++; + trklA = trklIndexA < nTracklets ? (AliTRDtrackletBase*) ((*fgTracklets)[trklIndexA]) : 0x0; + if (trklA && trklA->GetHCId() != 2*iDet) + trklA = 0x0; + } + else { + AliESDTrdTracklet esdTracklet(trklB->GetTrackletWord(), trklB->GetHCId()); + esd->AddTrdTracklet(&esdTracklet); + trklIndexB++; + trklB = trklIndexB < nTracklets ? (AliTRDtrackletBase*) ((*fgTracklets)[trklIndexB]) : 0x0; + if (trklB && trklB->GetHCId() != 2*iDet + 1) + trklB = 0x0; + } + } + } + // updating tracklet indices as in ESD + if (esd->GetNumberOfTrdTracklets() != trklIndex) { + trackletIndex[2*iDet + 0] = trackletIndex[2*iDet + 1] = trklIndex; + } + else + trackletIndex[2*iDet + 0] = trackletIndex[2*iDet + 1] = -1; + } + } + + // ----- filling GTU tracks ----- + AliDebug(1, Form("Now filling ESD with GTU tracks from %p (%i)", + fgTracks, fgTracks ? fgTracks->GetEntriesFast() : 0)); + if (fgTracks) { + for (Int_t iTrack = 0; iTrack < fgTracks->GetEntriesFast(); iTrack++) { + AliESDTrdTrack *trdTrack = (AliESDTrdTrack*) ((*fgTracks)[iTrack]); + + UInt_t mask = trdTrack->GetLayerMask(); + UInt_t stack = trdTrack->GetStack(); + + for (Int_t iLayer = 0; iLayer < 6; iLayer++) { + if (mask & (1 << iLayer)) { + + Int_t det = trdTrack->GetSector()*30 + stack*6 + iLayer; + Int_t idx = trdTrack->GetTrackletIndex(iLayer); + + if ((det < 0) || (det > 539)) { + AliError(Form("Invalid detector no. from track: %i", 2*det)); + continue; + } + if (trackletIndex[2*det] >= 0) { + if ((trackletIndex[2*det] + idx > -1) && + (trackletIndex[2*det] + idx < esd->GetNumberOfTrdTracklets())) { + AliESDTrdTracklet *trkl = esd->GetTrdTracklet(trackletIndex[2*det] + idx); + if (trkl) { + AliDebug(5, Form("adding tracklet: 0x%08x", trkl->GetTrackletWord())); + trdTrack->AddTrackletReference(trkl, iLayer); + } + } + } + } + } + // only add the track when it's complete (including tracklet references) + esd->AddTrdTrack(trdTrack); + } + } + + // clearing variables for next event + fgTracklets = 0x0; + fgTracks = 0x0; +} //_____________________________________________________________________________ void AliTRDReconstructor::SetOption(Option_t *opt) { -// Read option string into the steer param. -// -// Default steer param values -// -// digits conversion [dc] = false -// drift gas [ar] = false - do not update the number of exponentials in the TC ! -// write clusters [cw] = true -// write online tracklets [tw] = false -// track seeding (stand alone tracking) [sa] = true -// PID method in reconstruction (NN) [nn] = true -// 8 dEdx slices in ESD [8s] = false -// HLT tracking [hlt] = false -// Cosmic Reconstruction [cos] = false -// + // + // Read option string into the steer param. + // + // The following string options are available during reconstruction. + // In square brackets the default values are given. + // "dc" : digits conversion [false] + // "cw" : write clusters [true] + // "tw" : write online tracklets [false] + // "sa" : track seeding (stand alone tracking) [true] + // "hlt" : HLT reconstruction [false] + // "tp" : also use online tracklets for reconstruction [false] + // "deb" : Write debug stream [false] + // "cc" : Cluster radial correction during reconstruction [false] + // + // To check the actual options used during reconstruction include the following line in your rec.C script + // AliLog::SetClassDebugLevel("AliTRDReconstructor", 1); AliReconstructor::SetOption(opt); TString s(opt); TObjArray *opar = s.Tokenize(","); for(Int_t ipar=0; iparGetEntriesFast(); ipar++){ + Bool_t processed = kFALSE; TString sopt(((TObjString*)(*opar)[ipar])->String()); - if(sopt.Contains("dc")){ - SETFLG(fSteerParam, kDigitsConversion); - if(sopt.Contains("!")) CLRFLG(fSteerParam, kDigitsConversion); - continue; - } else if(sopt.Contains("cw")){ - SETFLG(fSteerParam, kWriteClusters); - if(sopt.Contains("!")) CLRFLG(fSteerParam, kWriteClusters); - continue; - } else if(sopt.Contains("sa")){ - SETFLG(fSteerParam, kSeeding); - if(sopt.Contains("!")) CLRFLG(fSteerParam, kSeeding); - continue; - } else if(sopt.Contains("nn")){ - SETFLG(fSteerParam, kSteerPID); - if(sopt.Contains("!")) CLRFLG(fSteerParam, kSteerPID); - continue; - } else if(sopt.Contains("8s")){ - SETFLG(fSteerParam, kEightSlices); - if(sopt.Contains("!")) CLRFLG(fSteerParam, kEightSlices); - continue; - } else if(sopt.Contains("tw")){ - SETFLG(fSteerParam, kWriteTracklets); - if(sopt.Contains("!")) CLRFLG(fSteerParam, kWriteTracklets); - continue; - } else if(sopt.Contains("ar")){ - SETFLG(fSteerParam, kDriftGas); - if(sopt.Contains("!")) CLRFLG(fSteerParam, kDriftGas); - continue; - } else if(sopt.Contains("hlt")){ - SETFLG(fSteerParam, kHLT); - if(sopt.Contains("!")) CLRFLG(fSteerParam, kHLT); - continue; - } else if(sopt.Contains("cos")){ - SETFLG(fSteerParam, kCosmic); - if(sopt.Contains("!")) CLRFLG(fSteerParam, kCosmic); - } else if(sopt.Contains("sl")){ - TObjArray *stl = sopt.Tokenize("_"); - if(stl->GetEntriesFast() < 3) continue; - TString taskstr(((TObjString*)(*stl)[1])->String()); - TString levelstring(((TObjString*)(*stl)[2])->String()); - // Set the stream Level - Int_t level = levelstring.Atoi(); - ETRDReconstructorTask task = kTracker; - if(taskstr.CompareTo("raw") == 0) task = kRawReader; - else if(taskstr.CompareTo("cl") == 0) task = kClusterizer; - else if(taskstr.CompareTo("tr") == 0) task = kTracker; - else if(taskstr.CompareTo("pi") == 0) task = kPID; - SetStreamLevel(level, task); - continue; + for(Int_t iopt=0; iopt= minLevel[task] && !fDebugStream[task]){ - TDirectory *savedir = gDirectory; - fDebugStream[task] = new TTreeSRedirector(Form("TRD.%sDebug.root", taskname[task].Data())); - savedir->cd(); - SETFLG(fSteerParam, kOwner); + + for(Int_t iopt=0; iopt>iopt)&1)?" : ON":" : OFF"):"")); } } +