// Destructor
//
+ if(fClusterizer){
+ delete fClusterizer;
+ fClusterizer = NULL;
+ }
if(fgClusters) {
fgClusters->Delete();
delete fgClusters;
for(Int_t itask = 0; itask < AliTRDrecoParam::kTRDreconstructionTasks; itask++)
if(fDebugStream[itask]) delete fDebugStream[itask];
}
- if(fClusterizer){
- delete fClusterizer;
- fClusterizer = NULL;
- }
}
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
// 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;
+ rawData.SetTracklets(GetTracklets("AliTRDtrackletMCM")); // link allocated online tracklets
+ rawData.SetTracks(GetTracks()); // link allocated online tracks
+
AliTRDdigitsManager *manager = rawData.Raw2Digits(rawReader);
manager->MakeBranch(digitsTree);
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);
-
- for (Int_t iSector = 0; iSector < 18; iSector++) {
- fgTriggerFlags.SetFlags(iSector, rawData.GetTriggerFlags(iSector));
- }
+ for (Int_t iSector = 0; iSector < 18; iSector++) fgTriggerFlags.SetFlags(iSector, rawData.GetTriggerFlags(iSector));
}
//_____________________________________________________________________________
// Reconstruct clusters
//
- //AliInfo("Reconstruct TRD clusters from RAW data [RawReader -> Cluster TTree]");
-
-
- rawReader->Reset();
- rawReader->Select("TRD");
-
+ 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;
}
-
- fClusterizer->ResetRecPoints();
-
+ rawReader->Reset();
+ rawReader->Select("TRD");
+ ResetContainers();
fClusterizer->OpenOutput(clusterTree);
fClusterizer->SetUseLabels(kFALSE);
fClusterizer->SetStoreRawSignals(kTRUE);
+ fClusterizer->ResetRecPoints();
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);
-
- for (Int_t iSector = 0; iSector < 18; iSector++) {
- fgTriggerFlags.SetFlags(iSector, fClusterizer->GetTriggerFlags(iSector));
- }
-
- if(IsWritingClusters()) return;
-
- // take over ownership of clusters
- fgClusters = fClusterizer->RecPoints();
- fClusterizer->SetClustersOwner(kFALSE);
+ for (Int_t iSector = 0; iSector < 18; iSector++) fgTriggerFlags.SetFlags(iSector, fClusterizer->GetTriggerFlags(iSector));
}
//_____________________________________________________________________________
// Reconstruct clusters
//
- //AliInfo("Reconstruct TRD clusters from Digits [Digit TTree -> Cluster TTree]");
-
- AliTRDclusterizer clusterer(fgTaskNames[AliTRDrecoParam::kClusterizer], fgTaskNames[AliTRDrecoParam::kClusterizer]);
- clusterer.SetReconstructor(this);
- clusterer.SetUseLabels(kTRUE);
- clusterer.SetStoreRawSignals(kTRUE);
- 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);
+ 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;
}
- fgNTimeBins = clusterer.GetNTimeBins();
-
- if(IsWritingClusters()) return;
-
- // take over ownership of clusters
- fgClusters = clusterer.RecPoints();
- clusterer.SetClustersOwner(kFALSE);
+ if(fgClusters){
+ AliDebug(1, Form("Removing %5d clusters @ %p", fgClusters->GetEntriesFast(), (void*)fgClusters));
+ fgClusters->Clear();
+ }
+ AliTRDclusterizer clusterizer(fgTaskNames[AliTRDrecoParam::kClusterizer], fgTaskNames[AliTRDrecoParam::kClusterizer]);
+ clusterizer.SetReconstructor(this);
+ clusterizer.SetUseLabels(kTRUE);
+ clusterizer.SetStoreRawSignals(kTRUE);
+ clusterizer.OpenOutput(clusterTree);
+ clusterizer.ReadDigits(digitsTree);
+ clusterizer.MakeClusters();
+ fgNTimeBins = clusterizer.GetNTimeBins();
}
//_____________________________________________________________________________
//return new AliTRDtracker(NULL);
AliTRDtrackerV1 *tracker = new AliTRDtrackerV1();
tracker->SetReconstructor(this);
+ AliInfo(Form("Build TRD tracker[%p]", (void*)tracker));
return tracker;
}
//
// ----- filling tracklets -----
- AliDebug(1, Form("Filling tracklets from %p (%i)",
- fgTracklets, fgTracklets ? fgTracklets->GetEntriesFast() : 0));
+ 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<AliTRDtrackletMCM*> (tracklet))
- label = trklMCM->GetLabel();
-
- AliESDTrdTracklet *esdTracklet = new AliESDTrdTracklet(tracklet->GetTrackletWord(), tracklet->GetHCId(), label);
-
- esd->AddTrdTracklet(esdTracklet);
+ if (AliTRDtrackletMCM *trklMCM = dynamic_cast<AliTRDtrackletMCM*> (tracklet)) label = trklMCM->GetLabel();
+ esd->AddTrdTracklet(new AliESDTrdTracklet(tracklet->GetTrackletWord(), tracklet->GetHCId(), label));
}
// ----- filling GTU tracks -----
- AliDebug(1, Form("Now filling ESD with GTU tracks from %p (%i)",
- fgTracks, fgTracks ? fgTracks->GetEntriesFast() : 0));
+ 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]);
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);
- }
+ 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);
-
- // clearing variables for next event
- fgTracklets = 0x0;
- fgTracks = 0x0;
}
//_____________________________________________________________________________
AliWarning(Form("Unknown option flag %s.", sopt.Data()));
}
+ opar->Delete();
delete opar;
}
}
}
+
+//_____________________________________________________________________________
+TClonesArray* AliTRDReconstructor::GetClusters()
+{
+// 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));
+ }
+ return fgClusters;
+}
+
+//_____________________________________________________________________________
+TClonesArray* AliTRDReconstructor::GetTracklets(const char *trkltype)
+{
+// Build/ Retrieve online tracklets array
+
+ if (trkltype != 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();
+ }
+}
virtual void FillESD(AliRawReader *, TTree *clusterTree, AliESDEvent *esd) const { FillESD((TTree * )NULL, clusterTree, esd); }
virtual void FillESD(TTree *digitsTree, TTree *clusterTree, AliESDEvent *esd) const;
- static TClonesArray* GetClusters() {return fgClusters;}
- static TClonesArray* GetTracklets() { return fgTracklets;}
- static TClonesArray* GetTracks() { return fgTracks;}
+ static TClonesArray* GetClusters();
+ static TClonesArray* GetTracklets(const char *trkltype = "AliTRDtrackletMCM");
+ static TClonesArray* GetTracks();
static Int_t GetNTimeBins() { return fgNTimeBins;}
Int_t GetNdEdxSlices() const { return (Int_t)AliTRDpidUtil::GetNdEdxSlices(GetPIDMethod());}
AliTRDpidUtil::ETRDPIDMethod GetPIDMethod() const { return GetRecoParam()->IsPIDNeuralNetwork() ? AliTRDpidUtil::kNN : AliTRDpidUtil::kLQ;}
virtual void Reconstruct(AliRawReader *rawReader, TTree *clusterTree) const;
virtual void Reconstruct(TTree *digitsTree, TTree *clusterTree) const;
- static void SetClusters(TClonesArray *clusters) { fgClusters = clusters;}
- static void SetTracklets(TClonesArray *tracklets) { fgTracklets = tracklets;}
- static void SetTracks(TClonesArray *tracks) { fgTracks = tracks;}
+ static void SetClusters(TClonesArray *clusters) { fgClusters = clusters;}
+ static void SetTracklets(TClonesArray *tracklets) { fgTracklets = tracklets;}
+ static void SetTracks(TClonesArray *tracks) { fgTracks = tracks;}
void SetOption(Option_t *opt);
private:
AliTRDReconstructor(const AliTRDReconstructor &r); //Not implemented
AliTRDReconstructor& operator = (const AliTRDReconstructor&); //Not implemented
+ void ResetContainers() const;
static Char_t const *fgSteerNames[kNsteer];//! steering names
static Char_t const *fgSteerFlags[kNsteer];//! steering flags
// AliTRDclusterizer destructor
//
- if (fRecPoints/* && IsClustersOwner()*/){
- fRecPoints->Delete();
- delete fRecPoints;
- }
-
- if (fTracklets){
- fTracklets->Delete();
- delete fTracklets;
- }
-
- if (fTracks){
- fTracks->Delete();
- delete fTracks;
- }
-
if (fDigitsManager) {
delete fDigitsManager;
fDigitsManager = NULL;
delete fRawStream;
fRawStream = NULL;
}
-
}
//_____________________________________________________________________________
trackletLoader->Load();
TTree *trackletTree = trackletLoader->Tree();
- if (trackletTree) {
- TBranch *trklbranch = trackletTree->GetBranch("mcmtrklbranch");
- TClonesArray *trklArray = TrackletsArray("AliTRDtrackletMCM");
- if (trklbranch && trklArray) {
- AliTRDtrackletMCM *trkl = 0x0;
- trklbranch->SetAddress(&trkl);
- for (Int_t iTracklet = 0; iTracklet < trklbranch->GetEntries(); iTracklet++) {
- trklbranch->GetEntry(iTracklet);
- new ((*trklArray)[trklArray->GetEntries()]) AliTRDtrackletMCM(*trkl);
- }
- return kTRUE;
- }
- }
- return kFALSE;
+ if (trackletTree) {
+ TBranch *trklbranch = trackletTree->GetBranch("mcmtrklbranch");
+ TClonesArray *trklArray = TrackletsArray("AliTRDtrackletMCM");
+ if (trklbranch && trklArray) {
+ AliTRDtrackletMCM *trkl = 0x0;
+ trklbranch->SetAddress(&trkl);
+ for (Int_t iTracklet = 0; iTracklet < trklbranch->GetEntries(); iTracklet++) {
+ trklbranch->GetEntry(iTracklet);
+ new ((*trklArray)[trklArray->GetEntries()]) AliTRDtrackletMCM(*trkl);
+ }
+ return kTRUE;
+ }
+ }
+ return kFALSE;
}
Bool_t AliTRDclusterizer::ReadTracks()
if(fReconstructor->IsWritingClusters()) WriteClusters(-1);
- AliInfo(Form("Number of found clusters : %d", RecPoints()->GetEntriesFast()));
+ AliInfo(Form("Found :: clusters[%d] tracklets[%d] tracks[%d]",
+ RecPoints()?RecPoints()->GetEntriesFast():0,
+ TrackletsArray()?TrackletsArray()->GetEntriesFast():0,
+ TracksArray()?TracksArray()->GetEntriesFast():0));
return fReturn;
fRawStream = NULL;
}
- AliInfo(Form("Number of found clusters : %d", fNoOfClusters));
+ AliInfo(Form("Found :: clusters[%d] tracklets[%d] tracks[%d]",
+ RecPoints()?RecPoints()->GetEntriesFast():0,
+ TrackletsArray()?TrackletsArray()->GetEntriesFast():0,
+ TracksArray()?TracksArray()->GetEntriesFast():0));
return kTRUE;
}
Float_t noiseMiddleThresh = fMinMaxCutSigma*fCalNoiseDetValue*fCalNoiseROC->GetValue(Max.col, Max.row);
if (Signals[1] <= noiseMiddleThresh) return kFALSE;
- UChar_t status[3]={
+ Char_t status[3]={
fCalPadStatusROC->GetStatus(Max.col-1, Max.row)
,fCalPadStatusROC->GetStatus(Max.col, Max.row)
,fCalPadStatusROC->GetStatus(Max.col+1, Max.row)
void AliTRDclusterizer::CreateCluster(const MaxStruct &Max)
{
//
- // Creates a cluster at the given position and saves it in fRecPoints
+ // Creates a cluster at the given position and saves it in RecPoints
//
Int_t nPadCount = 1;
for (int k = 0; k < 2; k++) {
correction += reminder[k] = rates[k] * (reminder[k] + coefficients[k] * result);
}
-
- }
-
-}
-
-//_____________________________________________________________________________
-void AliTRDclusterizer::ResetRecPoints()
-{
- //
- // Resets the list of rec points
- //
-
- if (fRecPoints) {
- fRecPoints->Clear();
- fNoOfClusters = 0;
- // delete fRecPoints;
}
}
// Returns the list of rec points
//
- if (!fRecPoints) {
- if(!(fRecPoints = AliTRDReconstructor::GetClusters())){
- // determine number of clusters which has to be allocated
- Float_t nclusters = fReconstructor->GetRecoParam()->GetNClusters();
-
- fRecPoints = new TClonesArray("AliTRDcluster", Int_t(nclusters));
- }
- //SetClustersOwner(kTRUE);
- AliTRDReconstructor::SetClusters(0x0);
- }
+ fRecPoints = AliTRDReconstructor::GetClusters();
+ if (!fRecPoints) AliError("Missing cluster array");
return fRecPoints;
-
}
//_____________________________________________________________________________
//
// Returns the array of on-line tracklets
//
-
- if (trkltype.Length() != 0) {
- if (!fTracklets) {
- fTracklets = new TClonesArray(trkltype, 200);
- }
- else if (TClass::GetClass(trkltype.Data()) != fTracklets->GetClass()){
- fTracklets->Delete();
- delete fTracklets;
- fTracklets = new TClonesArray(trkltype, 200);
- }
- }
+ fTracklets = AliTRDReconstructor::GetTracklets(trkltype.Data());
+ if (!fTracklets) AliError("Missing online tracklets array");
return fTracklets;
}
{
// return array of GTU tracks (create TClonesArray if necessary)
- if (!fTracks) {
- fTracks = new TClonesArray("AliESDTrdTrack",100);
- }
+ fTracks = AliTRDReconstructor::GetTracks();
+ if (!fTracks) AliError("Missing online tracks array");
return fTracks;
}
Bool_t ReadTracks();
Bool_t WriteClusters(Int_t det);
- void ResetRecPoints();
+ void ResetRecPoints() { fNoOfClusters = 0;}
virtual TClonesArray *RecPoints();
- virtual TClonesArray *TrackletsArray(const TString &trkltype = "");
+ virtual TClonesArray *TrackletsArray(const TString &trkltype = "AliTRDtrackletMCM");
virtual TClonesArray *TracksArray();
Bool_t Raw2Clusters(AliRawReader *rawReader);
// Destructor
//
- if (fTracklets){
- fTracklets->Delete();
- delete fTracklets;
- }
-
- if (fTracks){
- fTracks->Delete();
- delete fTracks;
- }
-
delete fMcmSim;
}
if (!trklTreeLoader->Tree())
trklTreeLoader->MakeTree();
- input.SetTrackletArray(TrackletsArray());
- input.SetTrackArray(TracksArray());
+ input.SetTrackletArray(fTracklets);
+ input.SetTrackArray(fTracks);
// Loop through the digits
Int_t det = 0;
x = ((kNTBin)<<26) | (bcCtr<<10) | (ptCtr<<6) | (ptPhase<<2) | 1;
if (nw < maxSize) buf[nw++] = x; else of++;
}
-
-TClonesArray *AliTRDrawData::TrackletsArray()
-{
- // Returns the array of on-line tracklets
-
- if (!fTracklets) {
- fTracklets = new TClonesArray("AliTRDtrackletWord", 200);
- }
- return fTracklets;
-}
-
-TClonesArray* AliTRDrawData::TracksArray()
-{
- // return array of GTU tracks (create TClonesArray if necessary)
-
- if (!fTracks) {
- fTracks = new TClonesArray("AliESDTrdTrack",100);
- }
- return fTracks;
-}
virtual AliTRDdigitsManager *Raw2Digits(AliRawReader *rawReader);
- virtual TClonesArray *TrackletsArray();
- virtual TClonesArray *TracksArray();
- void SetTrackletsOwner(TClonesArray *trkl = 0x0) { fTracklets = trkl; } // set to own the given array
- void SetTracksOwner(TClonesArray *trk = 0x0) { fTracks = trk; } // set to own the given array
+ void SetTracklets(TClonesArray *trkl = NULL) { fTracklets = trkl; } // link the given array
+ void SetTracks(TClonesArray *trk = NULL) { fTracks = trk; } // link the given array
UInt_t GetTriggerFlags(const Int_t sector) const { return fTrgFlags[sector]; }
//
// Destructor
//
-
+
if(fgRieman) delete fgRieman; fgRieman = NULL;
if(fgTiltedRieman) delete fgTiltedRieman; fgTiltedRieman = NULL;
if(fgTiltedRiemanConstrained) delete fgTiltedRiemanConstrained; fgTiltedRiemanConstrained = NULL;
if(fTracksESD){ fTracksESD->Delete(); delete fTracksESD; }
if(fTracks) {fTracks->Delete(); delete fTracks;}
if(fTracklets) {fTracklets->Delete(); delete fTracklets;}
- if(fClusters) {
+ if(IsClustersOwner() && fClusters) {
+ AliInfo(Form("tracker[%p] removing %d own clusters @ %p", (void*)this, fClusters->GetEntries(), (void*)fClusters));
fClusters->Delete(); delete fClusters;
}
if(fGeom) delete fGeom;
covarPolZ.Invert();
// Update the tracklets
- Double_t x1, dy, dz;
+ Double_t dy, dz;
Double_t cov[15];
memset(cov, 0, sizeof(Double_t) * 15);
for(Int_t iLayer = 0; iLayer < AliTRDtrackerV1::kNPlanes; iLayer++) {
x = tracklets[iLayer].GetX0();
- x1 = x - xref;
+// x1 = x - xref;
y = 0;
z = 0;
dy = 0;
return kFALSE;
}
branch->SetAddress(&clusterArray);
-
+
if(!fClusters){
Float_t nclusters = fkRecoParam->GetNClusters();
if(fkReconstructor->IsHLT()) nclusters /= AliTRDgeometry::kNsector;
fClusters = new TClonesArray("AliTRDcluster", Int_t(nclusters));
fClusters->SetOwner(kTRUE);
+ SetClustersOwner();
+ AliInfo(Form("Tracker owning clusters @ %p", (void*)fClusters));
}
// Loop through all entries in the tree
fkRecoParam = fkReconstructor->GetRecoParam(); // load reco param for this event
- if(!fkReconstructor->IsWritingClusters()){
- fClusters = AliTRDReconstructor::GetClusters();
+// if(!fkReconstructor->IsWritingClusters()) AliInfo(Form("IsWritingClusters[%c]", fkReconstructor->IsWritingClusters()?'y':'n'));
+ if(!(fClusters = AliTRDReconstructor::GetClusters())){
+ AliWarning("Clusters unavailable from TRD reconstructor. Trying reading from tree ...");
} else {
if(!ReadClusters(cTree)) {
- AliError("Problem with reading the clusters !");
+ AliError("Reading clusters from tree failed.");
return 1;
}
}
- SetClustersOwner();
if(!fClusters || !fClusters->GetEntriesFast()){
AliInfo("No TRD clusters");
return 1;
- }
+ } else AliInfo(Form("Using :: clusters[%d] onl.tracklets[%d] onl.tracks[%d]",
+ fClusters?fClusters->GetEntriesFast():0,
+ AliTRDReconstructor::GetTracklets()?AliTRDReconstructor::GetTracklets()->GetEntriesFast():0,
+ AliTRDReconstructor::GetTracks()?AliTRDReconstructor::GetTracks()->GetEntriesFast():0));
- //Int_t nin =
BuildTrackingContainers();
- //Int_t ncl = fClusters->GetEntriesFast();
- //AliInfo(Form("Clusters %d [%6.2f %% in the active volume]", ncl, 100.*float(nin)/ncl));
-
return 0;
}
if(!clusters || !clusters->GetEntriesFast()){
AliInfo("No TRD clusters");
return 1;
- }
+ } else AliInfo(Form("Using :: external.clusters[%d]", clusters->GetEntriesFast()));
+
fClusters = clusters;
- SetClustersOwner();
fkRecoParam = fkReconstructor->GetRecoParam(); // load reco param for this event
BuildTrackingContainers();
- //Int_t ncl = fClusters->GetEntriesFast();
- //AliInfo(Form("Clusters %d [%6.2f %% in the active volume]", ncl, 100.*float(nin)/ncl));
-
return 0;
}
fTracklets->Delete();
if(HasRemoveContainers()){delete fTracklets; fTracklets = NULL;}
}
- if(fClusters){
- if(IsClustersOwner()) fClusters->Delete();
-
- // save clusters array in the reconstructor for further use.
- if(!fkReconstructor->IsWritingClusters()){
- AliTRDReconstructor::SetClusters(fClusters);
- SetClustersOwner(kFALSE);
- } else AliTRDReconstructor::SetClusters(NULL);
+ if(fClusters && IsClustersOwner()){
+ AliInfo(Form("tracker[%p] clearing %d own clusters @ %p", (void*)this, fClusters->GetEntries(), (void*)fClusters));
+ fClusters->Delete();
+//
+// // save clusters array in the reconstructor for further use.
+// if(!fkReconstructor->IsWritingClusters()){
+// AliTRDReconstructor::SetClusters(fClusters);
+// SetClustersOwner(kFALSE);
+// } else AliTRDReconstructor::SetClusters(NULL);
}
for (int i = 0; i < AliTRDgeometry::kNsector; i++) fTrSec[i].Clear();
Double_t chi2[4];
// this should be data member of AliTRDtrack TODO
- Double_t seedQuality[kMaxTracksStack];
+// Double_t seedQuality[kMaxTracksStack];
// unpack control parameters
Int_t config = ipar[0];
}
//AliInfo(Form("Passed likelihood %f[%e].", TMath::Log(1.E-9 + like), like));
- // book preliminary results
- seedQuality[ntracks] = like;
+ // book preliminry results
+ //seedQuality[ntracks] = like;
fSeedLayer[ntracks] = config;/*sLayer;*/
// attach clusters to the extrapolation seeds
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff