X-Git-Url: http://git.uio.no/git/?p=u%2Fmrichter%2FAliRoot.git;a=blobdiff_plain;f=TRD%2FAliTRDReconstructor.cxx;h=1f47c83015e1a60fe471022c833880bd80e14719;hp=d54a2fa01adfbaa9fec95bb0a2bac479762a95c3;hb=7fe40b010b76b48cd8d0527ec540e9f218885a6d;hpb=ad5dd6ec225393bb610318f3c81f205bc0657b4b diff --git a/TRD/AliTRDReconstructor.cxx b/TRD/AliTRDReconstructor.cxx index d54a2fa01ad..1f47c83015e 100644 --- a/TRD/AliTRDReconstructor.cxx +++ b/TRD/AliTRDReconstructor.cxx @@ -18,91 +18,88 @@ /////////////////////////////////////////////////////////////////////////////// // // // 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 "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 "AliESDTrdTrigger.h" +#include "AliTRDtrackletWord.h" +#include "AliTRDtrackletMCM.h" +#include "AliTRDonlineTrackMatching.h" #define SETFLG(n,f) ((n) |= f) #define CLRFLG(n,f) ((n) &= ~f) ClassImp(AliTRDReconstructor) -TClonesArray *AliTRDReconstructor::fgClusters = 0x0; -TClonesArray *AliTRDReconstructor::fgTracklets = 0x0; -Char_t* AliTRDReconstructor::fgSteerNames[kNsteer] = { +AliESDTrdTrigger AliTRDReconstructor::fgTriggerFlags; +AliTRDonlineTrackMatching AliTRDReconstructor::fgOnlineTrackMatcher; +TClonesArray *AliTRDReconstructor::fgClusters = NULL; +TClonesArray *AliTRDReconstructor::fgTracklets = NULL; +TClonesArray *AliTRDReconstructor::fgTracks = NULL; +Char_t const * AliTRDReconstructor::fgSteerNames[kNsteer] = { "DigitsConversion " - ,"Tail Cancellation " - ,"Clusters LUT " - ,"Clusters GAUSS " - ,"Clusters Sharing " - ,"NN PID " - ,"8 dEdx slices in ESD " ,"Write Clusters " ,"Write Online Tracklets " - ,"Drift Gas Argon " ,"Stand Alone Tracking " - ,"Vertex Constrain " - ,"Tracklet Improve " ,"HLT Mode " - ,"Cosmic Reconstruction " - ,"Process Online Tracklets" + ,"Process Online Trklts " + ,"Debug Streaming " + ,"Cl. Radial Correction " }; -Char_t* AliTRDReconstructor::fgSteerFlags[kNsteer] = { +Char_t const * AliTRDReconstructor::fgSteerFlags[kNsteer] = { "dc"// digits conversion [false] - ,"tc"// apply tail cancellation [true] - ,"lut"// look-up-table for cluster shape in the r-phi direction - ,"gs"// gauss cluster shape in the r-phi direction - ,"sh"// cluster sharing between tracks - ,"nn"// PID method in reconstruction (NN) [true] - ,"8s"// 8 dEdx slices in ESD [true] ,"cw"// write clusters [true] ,"tw"// write online tracklets [false] - ,"ar"// drift gas [false] - do not update the number of exponentials in the TC ! ,"sa"// track seeding (stand alone tracking) [true] - ,"vc"// vertex constrain on stand alone track finder [false] - ,"ti"// improve tracklets in stand alone track finder [true] ,"hlt"// HLT reconstruction [false] - ,"cos"// Cosmic Reconstruction [false] ,"tp"// also use online tracklets for reconstruction [false] + ,"deb"// Write debug stream [false] + ,"cc" // Cluster radial correction during reconstruction [false] }; -Char_t* AliTRDReconstructor::fgTaskNames[kNtasks] = { - "RawReader" - ,"Clusterizer" +Char_t const * AliTRDReconstructor::fgTaskNames[AliTRDrecoParam::kTRDreconstructionTasks] = { + "Clusterizer" ,"Tracker" ,"PID" }; -Char_t* AliTRDReconstructor::fgTaskFlags[kNtasks] = { - "rr" - ,"cl" +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 @@ -110,57 +107,40 @@ 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); - // vertex constrain for stand alone track finder - SETFLG(fSteerParam, kVertexConstrained); - // improve tracklets for stand alone track finder - SETFLG(fSteerParam, kImproveTracklet); - // use look up table for cluster r-phi position - SETFLG(fSteerParam, kLUT); - // use tail cancellation - SETFLG(fSteerParam, kTC); - - 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(fClusterizer){ + delete fClusterizer; + fClusterizer = NULL; + } if(fgClusters) { - fgClusters->Delete(); delete fgClusters; + fgClusters->Delete(); + delete fgClusters; + fgClusters = NULL; } if(fgTracklets) { - fgTracklets->Delete(); delete fgTracklets; + fgTracklets->Delete(); + delete fgTracklets; + fgTracklets = NULL; + } + if(fgTracks) { + fgTracks->Delete(); + delete fgTracks; + fgTracks = NULL; } if(fSteerParam&kOwner){ - for(Int_t itask = 0; itask < kNtasks; itask++) + for(Int_t itask = 0; itask < AliTRDrecoParam::kTRDreconstructionTasks; itask++) if(fDebugStream[itask]) delete fDebugStream[itask]; } } @@ -172,7 +152,23 @@ void AliTRDReconstructor::Init(){ // Init Options // SetOption(GetOption()); - Options(fSteerParam, fStreamLevel); + Options(fSteerParam); + + if(!fClusterizer){ + fClusterizer = new AliTRDclusterizer(fgTaskNames[AliTRDrecoParam::kClusterizer], fgTaskNames[AliTRDrecoParam::kClusterizer]); + fClusterizer->SetReconstructor(this); + AliInfo(Form("Build TRD clusterizer[%p]", (void*)fClusterizer)); + } + + // 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); + } + } } //_____________________________________________________________________________ @@ -183,16 +179,21 @@ void AliTRDReconstructor::ConvertDigits(AliRawReader *rawReader // Convert raw data digits into digit objects in a root tree // - //AliInfo("Convert raw data digits into digit objects [RawReader -> Digit TTree]"); + AliDebug(1, "Convert raw data digits into digit objects [RawReader -> Digit TTree]"); + AliDebug(2, Form("clusters[%p] tracklets[%p] tracks[%p]", (void*)fgClusters, (void*)fgTracklets, (void*)fgTracks)); - AliTRDrawData rawData; rawReader->Reset(); rawReader->Select("TRD"); + ResetContainers(); + + AliTRDrawData rawData; + AliTRDdigitsManager *manager = rawData.Raw2Digits(rawReader); manager->MakeBranch(digitsTree); manager->WriteDigits(); delete manager; + for (Int_t iSector = 0; iSector < 18; iSector++) fgTriggerFlags.SetFlags(iSector, rawData.GetTriggerFlags(iSector)); } //_____________________________________________________________________________ @@ -203,28 +204,22 @@ void AliTRDReconstructor::Reconstruct(AliRawReader *rawReader // Reconstruct clusters // - //AliInfo("Reconstruct TRD clusters from RAW data [RawReader -> Cluster TTree]"); - - + AliDebug(1, "Reconstruct TRD clusters from RAW data [RawReader -> Cluster TTree]"); + AliDebug(2, Form("clusters[%p] tracklets[%p] tracks[%p]", (void*)fgClusters, (void*)fgTracklets, (void*)fgTracks)); + if(!fClusterizer){ + AliFatal("Clusterizer not available!"); + return; + } rawReader->Reset(); rawReader->Select("TRD"); - - // New (fast) cluster finder - AliTRDclusterizer clusterer(fgTaskNames[kClusterizer], fgTaskNames[kClusterizer]); - clusterer.SetReconstructor(this); - clusterer.OpenOutput(clusterTree); - clusterer.SetUseLabels(kFALSE); - clusterer.Raw2ClustersChamber(rawReader); - - if(IsWritingClusters()) return; - - // take over ownership of clusters - fgClusters = clusterer.RecPoints(); - clusterer.SetClustersOwner(kFALSE); - - // take over ownership of online tracklets - fgTracklets = clusterer.TrackletsArray(); - clusterer.SetTrackletsOwner(kFALSE); + ResetContainers(); + fClusterizer->OpenOutput(clusterTree); + fClusterizer->SetUseLabels(kFALSE); + fClusterizer->SetStoreRawSignals(kTRUE); + fClusterizer->ResetRecPoints(); + fClusterizer->Raw2ClustersChamber(rawReader); + fgNTimeBins = fClusterizer->GetNTimeBins(); + for (Int_t iSector = 0; iSector < 18; iSector++) fgTriggerFlags.SetFlags(iSector, fClusterizer->GetTriggerFlags(iSector)); } //_____________________________________________________________________________ @@ -235,23 +230,24 @@ void AliTRDReconstructor::Reconstruct(TTree *digitsTree // Reconstruct clusters // - //AliInfo("Reconstruct TRD clusters from Digits [Digit TTree -> Cluster TTree]"); - - AliTRDclusterizer clusterer(fgTaskNames[kClusterizer], fgTaskNames[kClusterizer]); - clusterer.SetReconstructor(this); - clusterer.OpenOutput(clusterTree); - clusterer.ReadDigits(digitsTree); - clusterer.MakeClusters(); - - if(IsWritingClusters()) return; - - // take over ownership of clusters - fgClusters = clusterer.RecPoints(); - clusterer.SetClustersOwner(kFALSE); + AliDebug(1, "Reconstruct TRD clusters from Digits [Digit TTree -> Cluster TTree]"); + AliDebug(2, Form("Start :: clusters[%p] tracklets[%p] tracks[%p]", (void*)fgClusters, (void*)fgTracklets, (void*)fgTracks)); + if(!fClusterizer){ + AliFatal("Clusterizer not available!"); + return; + } - // take over ownership of online tracklets - fgTracklets = clusterer.TrackletsArray(); - clusterer.SetTrackletsOwner(kFALSE); + ResetContainers(); + AliTRDclusterizer clusterizer(fgTaskNames[AliTRDrecoParam::kClusterizer], fgTaskNames[AliTRDrecoParam::kClusterizer]); + clusterizer.SetReconstructor(this); + clusterizer.SetUseLabels(kTRUE); + clusterizer.SetStoreRawSignals(kTRUE); + clusterizer.OpenOutput(clusterTree); + clusterizer.ReadDigits(digitsTree); + clusterizer.ReadTracklets(); + clusterizer.ReadTracks(); + clusterizer.MakeClusters(); + fgNTimeBins = clusterizer.GetNTimeBins(); } //_____________________________________________________________________________ @@ -264,6 +260,7 @@ AliTracker *AliTRDReconstructor::CreateTracker() const //return new AliTRDtracker(NULL); AliTRDtrackerV1 *tracker = new AliTRDtrackerV1(); tracker->SetReconstructor(this); + AliInfo(Form("Build TRD tracker[%p]", (void*)tracker)); return tracker; } @@ -271,88 +268,174 @@ AliTracker *AliTRDReconstructor::CreateTracker() const //_____________________________________________________________________________ void AliTRDReconstructor::FillESD(TTree* /*digitsTree*/ , TTree* /*clusterTree*/ - , AliESDEvent* /*esd*/) const + , AliESDEvent* esd) const { // // Fill ESD // -} + // ----- filling tracklets ----- + AliDebug(1, Form("Loading onl.tracklets(%i) to ESD", fgTracklets ? fgTracklets->GetEntriesFast() : 0)); + Int_t trackletIndex[1080] = { 0 }; + TList trklList; + AliTRDrawStream::SortTracklets(fgTracklets, trklList, trackletIndex); + TIter trackletIter(&trklList); + while (AliTRDtrackletBase* tracklet = (AliTRDtrackletBase*) trackletIter()) { + Int_t label = -2; // mark raw tracklets with label -2 + if (AliTRDtrackletMCM *trklMCM = dynamic_cast (tracklet)) label = trklMCM->GetLabel(); + esd->AddTrdTracklet(tracklet->GetTrackletWord(), tracklet->GetHCId(), label); + } + + // ----- filling GTU tracks ----- + AliDebug(1, Form("Loading gtu.tracks(%i) to ESD", fgTracks ? fgTracks->GetEntriesFast() : 0)); + if (fgTracks) { + for (Int_t iTrack = 0; iTrack < fgTracks->GetEntriesFast(); iTrack++) { + AliESDTrdTrack *trdTrack = (AliESDTrdTrack*) ((*fgTracks)[iTrack]); + + UInt_t stack = trdTrack->GetStack(); + + Int_t refIndex[6]; + AliTRDrawStream::AssignTracklets(trdTrack, trackletIndex, refIndex); + + for (Int_t iLayer = 0; iLayer < 6; ++iLayer) { + Int_t det = trdTrack->GetSector()*30 + stack*6 + iLayer; + AliESDTrdTracklet *trkl = refIndex[iLayer] > -1 ? esd->GetTrdTracklet(refIndex[iLayer]) : 0x0; + if (trkl) { + AliDebug(5, Form("adding tracklet with index %i: 0x%08x", + refIndex[iLayer], trkl->GetTrackletWord())); + if (trkl->GetDetector() != det) + AliError(Form("inconsistent assignment of tracklet 0x%08x in det %i to track in %i", + trkl->GetTrackletWord(), trkl->GetDetector(), det)); + trdTrack->AddTrackletReference(trkl, iLayer); + } + } + // only add the track when it's complete (including tracklet references) + esd->AddTrdTrack(trdTrack); + } + } + esd->SetTrdTrigger(&fgTriggerFlags); + // ----- matching GTU tracks to global tracks ----- + AliDebug(1, Form("TRD track matching with %i ESD, %i TRD tracks", + esd->GetNumberOfTracks(), esd->GetNumberOfTrdTracks())); + fgOnlineTrackMatcher.ProcessEvent(esd); +} //_____________________________________________________________________________ void AliTRDReconstructor::SetOption(Option_t *opt) { -// Read option string into the steer param. -// + // + // 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; + Bool_t processed = kFALSE; TString sopt(((TObjString*)(*opar)[ipar])->String()); for(Int_t iopt=0; ioptGetEntriesFast() < 3) continue; - TString taskstr(((TObjString*)(*stl)[1])->String()); - TString levelstring(((TObjString*)(*stl)[2])->String()); - Int_t level = levelstring.Atoi(); - - // Set the stream Level - PROCESSED = kFALSE; - for(Int_t it=0; itDelete(); + delete opar; } //_____________________________________________________________________________ -void AliTRDReconstructor::SetStreamLevel(Int_t level, ETRDReconstructorTask task){ +void AliTRDReconstructor::Options(UInt_t steer) +{ // - // Set the Stream Level for one of the tasks Clusterizer, Tracker or PID + // Print the options // - const Int_t minLevel[4] = {1, 1, 2, 1}; // the minimum debug level upon which a debug stream is created for different tasks - //AliInfo(Form("Setting Stream Level for Task %s to %d", taskname.Data(),level)); - fStreamLevel[(Int_t)task] = level; - // Initialize DebugStreamer if not yet done - if(level >= minLevel[task] && !fDebugStream[task]){ - TDirectory *savedir = gDirectory; - fDebugStream[task] = new TTreeSRedirector(Form("TRD.Debug%s.root", fgTaskNames[task])); - savedir->cd(); - SETFLG(fSteerParam, kOwner); + + for(Int_t iopt=0; iopt>iopt)&1)?" : ON":" : OFF"):"")); } } + //_____________________________________________________________________________ -void AliTRDReconstructor::Options(UInt_t steer, UChar_t *stream) +TClonesArray* AliTRDReconstructor::GetClusters() { - for(Int_t iopt=0; iopt>iopt)&1)?" : ON":" : OFF"):"")); +// Build/ Retrieve cluster array + if(!fgClusters){ + fgClusters = new TClonesArray("AliTRDcluster", Int_t(GetRecoParam()->GetNClusters())); + fgClusters->SetOwner(); + AliInfoGeneral("AliTRDReconstructor", Form("Allocate cluster array @ %p", (void*)fgClusters)); } - AliDebugGeneral("AliTRDReconstructor", 1, " Debug Streaming"); - for(Int_t it=0; it 0) { + if(fgTracklets && (TClass::GetClass(trkltype) != fgTracklets->GetClass())){ + fgTracklets->Delete(); + delete fgTracklets; + } + if (!fgTracklets) { + fgTracklets = new TClonesArray(trkltype, 200); + fgTracklets->SetOwner(kTRUE); + AliInfoGeneral("AliTRDReconstructor", Form("Allocate online tracklets[%s] array @ %p", trkltype, (void*)fgTracklets)); + } + } + return fgTracklets; +} + +//_____________________________________________________________________________ +TClonesArray* AliTRDReconstructor::GetTracks() +{ +// Build/ Retrieve cluster array + if(!fgTracks){ + fgTracks = new TClonesArray("AliESDTrdTrack", 100); + fgTracks->SetOwner(); + AliInfoGeneral("AliTRDReconstructor", Form("Allocate online tracks array @ %p", (void*)fgTracks)); + } + return fgTracks; +} + +//_____________________________________________________________________________ +void AliTRDReconstructor::ResetContainers() const +{ +// prepare data containers for a new event + + if(fgClusters){ + AliDebug(1, Form("Removing %5d clusters @ %p", fgClusters->GetEntriesFast(), (void*)fgClusters)); + fgClusters->Clear(); + } + if(fgTracklets){ + AliDebug(1, Form("Removing %3d online tracklets @ %p", fgTracklets->GetEntriesFast(), (void*)fgTracklets)); + fgTracklets->Clear(); + } + if(fgTracks){ + AliDebug(1, Form("Removing %3d online tracks @ %p", fgTracks->GetEntriesFast(), (void*)fgTracks)); + fgTracks->Clear(); + } + for (Int_t iSector = 0; iSector < 18; iSector++) + fgTriggerFlags.SetFlags(iSector, 0); +}