From a6dd11e97da6b43b7a458dc8938111702af002a2 Mon Sep 17 00:00:00 2001 From: cblume Date: Mon, 28 Aug 2006 14:37:05 +0000 Subject: [PATCH] Update of clusterizer --- TRD/AliTRDarrayF.cxx | 18 ++- TRD/AliTRDarrayF.h | 2 +- TRD/AliTRDarrayI.cxx | 16 +- TRD/AliTRDarrayI.h | 2 +- TRD/AliTRDcluster.cxx | 2 +- TRD/AliTRDclusterizer.cxx | 23 ++- TRD/AliTRDclusterizerV1.cxx | 303 ++++++++++++++++++++++-------------- TRD/AliTRDdataArray.cxx | 18 ++- TRD/AliTRDdataArrayF.cxx | 19 ++- TRD/AliTRDdataArrayI.cxx | 20 ++- TRD/AliTRDv1.cxx | 15 +- 11 files changed, 289 insertions(+), 149 deletions(-) diff --git a/TRD/AliTRDarrayF.cxx b/TRD/AliTRDarrayF.cxx index 554ef5a1ae3..264badb0f15 100644 --- a/TRD/AliTRDarrayF.cxx +++ b/TRD/AliTRDarrayF.cxx @@ -70,11 +70,17 @@ void AliTRDarrayF::Expand(Int_t n) // The user is responsible for the appropriate size of the array. // - if (n < 0) return; - fArray = (Float_t*) TStorage::ReAlloc(fArray - ,n * sizeof(Float_t) - ,fN * sizeof(Float_t)); - if (fArray != 0) fN = n; - + if (n < 0) { + return; + } + + fArray = (Float_t *) TStorage::ReAlloc(fArray + ,n *sizeof(Float_t) + ,fN*sizeof(Float_t)); + + if (fArray != 0) { + fN = n; + } + } diff --git a/TRD/AliTRDarrayF.h b/TRD/AliTRDarrayF.h index f7d8eaefd12..c502c92acc3 100644 --- a/TRD/AliTRDarrayF.h +++ b/TRD/AliTRDarrayF.h @@ -3,7 +3,7 @@ /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * * See cxx source for full Copyright notice */ -/* $Id: AliTRDarrayF.h,v */ +/* $Id$*/ #include #include diff --git a/TRD/AliTRDarrayI.cxx b/TRD/AliTRDarrayI.cxx index 1e1936dd679..605f6880ccb 100644 --- a/TRD/AliTRDarrayI.cxx +++ b/TRD/AliTRDarrayI.cxx @@ -70,11 +70,17 @@ void AliTRDarrayI::Expand(Int_t n) // The user is responsible for the appropriate size of the array. // - if (n < 0) return; - fArray = (Int_t*) TStorage::ReAlloc(fArray - ,n * sizeof(Int_t) - ,fN * sizeof(Int_t)); - if (fArray != 0) fN = n; + if (n < 0) { + return; + } + + fArray = (Int_t *) TStorage::ReAlloc(fArray + ,n *sizeof(Int_t) + ,fN*sizeof(Int_t)); + + if (fArray != 0) { + fN = n; + } } diff --git a/TRD/AliTRDarrayI.h b/TRD/AliTRDarrayI.h index c6fef3eba2a..bb59602f61c 100644 --- a/TRD/AliTRDarrayI.h +++ b/TRD/AliTRDarrayI.h @@ -3,7 +3,7 @@ /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * * See cxx source for full Copyright notice */ -/* $Id: AliTRDarrayI.h,v */ +/* $Id$*/ #include #include diff --git a/TRD/AliTRDcluster.cxx b/TRD/AliTRDcluster.cxx index 64d2c642d1f..49fc1658c17 100644 --- a/TRD/AliTRDcluster.cxx +++ b/TRD/AliTRDcluster.cxx @@ -38,7 +38,7 @@ AliTRDcluster::AliTRDcluster() ,fCenter(0) { // - // default constructor + // Default constructor // for (Int_t i = 0; i < 7; i++) { diff --git a/TRD/AliTRDclusterizer.cxx b/TRD/AliTRDclusterizer.cxx index 9ea7f049a6d..ed3a96eba10 100644 --- a/TRD/AliTRDclusterizer.cxx +++ b/TRD/AliTRDclusterizer.cxx @@ -240,9 +240,21 @@ Bool_t AliTRDclusterizer::WriteClusters(Int_t det) AliInfo(Form("Writing the cluster tree %s for event %d." ,fClusterTree->GetName(),fRunLoader->GetEventNumber())); - AliLoader *loader = fRunLoader->GetLoader("TRDLoader"); - loader->WriteRecPoints("OVERWRITE"); + if (fRecPoints) { + + branch->SetAddress(&fRecPoints); + + AliLoader *loader = fRunLoader->GetLoader("TRDLoader"); + loader->WriteRecPoints("OVERWRITE"); + } + else { + + AliError("Cluster tree does not exist. Cannot write clusters.\n"); + return kFALSE; + + } + return kTRUE; } @@ -267,7 +279,6 @@ AliTRDcluster* AliTRDclusterizer::AddCluster(Double_t *pos, Int_t timebin AliTRDcluster *c = new AliTRDcluster(); c->SetDetector(det); - c->AddTrackIndex(tracks); c->SetQ(amp); c->SetX(pos[2]); c->SetY(pos[0]); @@ -277,6 +288,10 @@ AliTRDcluster* AliTRDclusterizer::AddCluster(Double_t *pos, Int_t timebin c->SetLocalTimeBin(timebin); c->SetCenter(center); + if (tracks) { + c->AddTrackIndex(tracks); + } + switch (iType) { case 0: c->Set2pad(); @@ -311,7 +326,7 @@ Double_t AliTRDclusterizer::CalcXposFromTimebin(Float_t timebin, Int_t idet AliTRDcalibDB *calibration = AliTRDcalibDB::Instance(); if (!calibration) { - AliError("Cannot calibration object"); + AliError("Cannot find calibration object"); return -1; } diff --git a/TRD/AliTRDclusterizerV1.cxx b/TRD/AliTRDclusterizerV1.cxx index d777409529d..5f73b867b63 100644 --- a/TRD/AliTRDclusterizerV1.cxx +++ b/TRD/AliTRDclusterizerV1.cxx @@ -60,7 +60,7 @@ AliTRDclusterizerV1::AliTRDclusterizerV1() } //_____________________________________________________________________________ -AliTRDclusterizerV1::AliTRDclusterizerV1(const Text_t* name, const Text_t* title) +AliTRDclusterizerV1::AliTRDclusterizerV1(const Text_t *name, const Text_t *title) :AliTRDclusterizer(name,title) ,fDigitsManager(new AliTRDdigitsManager()) { @@ -145,7 +145,7 @@ Bool_t AliTRDclusterizerV1::ReadDigits() } //_____________________________________________________________________________ -Bool_t AliTRDclusterizerV1::ReadDigits(AliRawReader* rawReader) +Bool_t AliTRDclusterizerV1::ReadDigits(AliRawReader *rawReader) { // // Reads the digits arrays from the ddl file @@ -174,12 +174,11 @@ Bool_t AliTRDclusterizerV1::MakeClusters() Int_t iPad = 0; AliTRDdataArrayI *digitsIn; - AliTRDdataArrayI *track0; - AliTRDdataArrayI *track1; - AliTRDdataArrayI *track2; + AliTRDdataArrayI *tracksIn; // Get the geometry AliTRDgeometry *geo = AliTRDgeometry::GetGeometry(fRunLoader); + AliTRDcalibDB *calibration = AliTRDcalibDB::Instance(); if (!calibration) { AliError("No AliTRDcalibDB instance available\n"); @@ -205,27 +204,29 @@ Bool_t AliTRDclusterizerV1::MakeClusters() } // ADC threshols - Float_t ADCthreshold = simParam->GetADCthreshold(); + Float_t ADCthreshold = simParam->GetADCthreshold(); // Threshold value for the maximum - Float_t maxThresh = recParam->GetClusMaxThresh(); + Float_t maxThresh = recParam->GetClusMaxThresh(); // Threshold value for the digit signal - Float_t sigThresh = recParam->GetClusSigThresh(); + Float_t sigThresh = recParam->GetClusSigThresh(); // Iteration limit for unfolding procedure const Float_t kEpsilon = 0.01; const Int_t kNclus = 3; const Int_t kNsig = 5; - const Int_t kNtrack = 3 * kNclus; + const Int_t kNdict = AliTRDdigitsManager::kNDict; + const Int_t kNtrack = kNdict * kNclus; Int_t iType = 0; Int_t iUnfold = 0; Double_t ratioLeft = 1.0; Double_t ratioRight = 1.0; + Int_t iClusterROC = 0; + Double_t padSignal[kNsig]; Double_t clusterSignal[kNclus]; Double_t clusterPads[kNclus]; - Int_t clusterTracks[kNtrack]; Int_t chamBeg = 0; Int_t chamEnd = AliTRDgeometry::Ncham(); @@ -235,6 +236,8 @@ Bool_t AliTRDclusterizerV1::MakeClusters() Int_t sectEnd = AliTRDgeometry::Nsect(); Int_t nTimeTotal = calibration->GetNumberOfTimeBins(); + Int_t dummy[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + AliDebug(1,Form("Number of Time Bins = %d.\n",nTimeTotal)); // Start clustering in every chamber @@ -242,7 +245,20 @@ Bool_t AliTRDclusterizerV1::MakeClusters() for (iplan = planBeg; iplan < planEnd; iplan++) { for (isect = sectBeg; isect < sectEnd; isect++) { - Int_t idet = geo->GetDetector(iplan,icham,isect); + Int_t idet = geo->GetDetector(iplan,icham,isect); + + // Get the digits + digitsIn = fDigitsManager->GetDigits(idet); + // This is to take care of switched off super modules + if (digitsIn->GetNtime() == 0) { + continue; + } + digitsIn->Expand(); + AliTRDdataArrayI *tracksTmp = fDigitsManager->GetDictionary(idet,0); + tracksTmp->Expand(); + + AliDebug(1,Form("Analyzing chamber %d, plane %d, sector %d.\n" + ,icham,iplan,isect)); Int_t nRowMax = commonParam->GetRowMax(iplan,icham,isect); Int_t nColMax = commonParam->GetColMax(iplan); @@ -256,27 +272,14 @@ Bool_t AliTRDclusterizerV1::MakeClusters() Int_t nClusters5pad = 0; Int_t nClustersLarge = 0; - AliDebug(1,Form("Analyzing chamber %d, plane %d, sector %d.\n" - ,icham,iplan,isect)); - - // Get the digits - digitsIn = fDigitsManager->GetDigits(idet); - // This is to take care of switched off super modules - if (digitsIn->GetNtime() == 0) { - continue; - } - digitsIn->Expand(); - track0 = fDigitsManager->GetDictionary(idet,0); - track0->Expand(); - track1 = fDigitsManager->GetDictionary(idet,1); - track1->Expand(); - track2 = fDigitsManager->GetDictionary(idet,2); - track2->Expand(); - + // Apply the gain and the tail cancelation via digital filter AliTRDdataArrayF *digitsOut = new AliTRDdataArrayF(digitsIn->GetNrow() ,digitsIn->GetNcol() ,digitsIn->GetNtime()); - Transform(digitsIn, digitsOut,idet,nRowMax,nColMax,nTimeTotal,ADCthreshold); + Transform(digitsIn,digitsOut,idet,nRowMax,nColMax,nTimeTotal,ADCthreshold); + + // Input digits are not needed any more + digitsIn->Compress(1,0); // Loop through the chamber and find the maxima for ( row = 0; row < nRowMax; row++) { @@ -290,16 +293,23 @@ Bool_t AliTRDclusterizerV1::MakeClusters() // Look for the maximum if (signalM >= maxThresh) { if ((TMath::Abs(signalL) <= signalM) && - (TMath::Abs(signalR) <= signalM) && - ((TMath::Abs(signalL) + TMath::Abs(signalR)) > sigThresh)) { - // Maximum found, mark the position by a negative signal - digitsOut->SetDataUnchecked(row,col-1,time,-signalM); + (TMath::Abs(signalR) <= signalM)) { + if ((TMath::Abs(signalL) + TMath::Abs(signalR)) > sigThresh) { + // Maximum found, mark the position by a negative signal + digitsOut->SetDataUnchecked(row,col-1,time,-signalM); + } } } } } } + tracksTmp->Compress(1,0); + + // The index to the first cluster of a given ROC + Int_t firstClusterROC = -1; + // The number of cluster in a given ROC + Int_t nClusterROC = 0; // Now check the maxima and calculate the cluster position for ( row = 0; row < nRowMax ; row++) { @@ -307,33 +317,31 @@ Bool_t AliTRDclusterizerV1::MakeClusters() for ( col = 1; col < nColMax-1; col++) { // Maximum found ? - if (digitsOut->GetDataUnchecked(row,col,time) < 0) { + if (digitsOut->GetDataUnchecked(row,col,time) < 0.0) { for (iPad = 0; iPad < kNclus; iPad++) { Int_t iPadCol = col - 1 + iPad; - clusterSignal[iPad] = TMath::Abs(digitsOut->GetDataUnchecked(row - ,iPadCol - ,time)); - clusterTracks[3*iPad ] = track0->GetDataUnchecked(row,iPadCol,time) - 1; - clusterTracks[3*iPad+1] = track1->GetDataUnchecked(row,iPadCol,time) - 1; - clusterTracks[3*iPad+2] = track2->GetDataUnchecked(row,iPadCol,time) - 1; + clusterSignal[iPad] = + TMath::Abs(digitsOut->GetDataUnchecked(row,iPadCol,time)); } // Count the number of pads in the cluster Int_t nPadCount = 0; - Int_t ii = 0; + Int_t ii; + // Look to the left + ii = 0; while (TMath::Abs(digitsOut->GetDataUnchecked(row,col-ii ,time)) >= sigThresh) { nPadCount++; ii++; if (col-ii < 0) break; } + // Look to the right ii = 0; while (TMath::Abs(digitsOut->GetDataUnchecked(row,col+ii+1,time)) >= sigThresh) { nPadCount++; ii++; if (col+ii+1 >= nColMax) break; } - nClusters++; switch (nPadCount) { case 2: @@ -389,8 +397,8 @@ Bool_t AliTRDclusterizerV1::MakeClusters() if (fivePadCluster) { for (iPad = 0; iPad < kNsig; iPad++) { padSignal[iPad] = TMath::Abs(digitsOut->GetDataUnchecked(row - ,col-1+iPad - ,time)); + ,col-1+iPad + ,time)); } // Unfold the two maxima and set the signal on // the overlapping pad to the ratio @@ -406,7 +414,7 @@ Bool_t AliTRDclusterizerV1::MakeClusters() + clusterSignal[2]; // The position of the cluster - clusterPads[0] = row + 0.5; + clusterPads[0] = row + 0.5; // Take the shift of the additional time bins into account clusterPads[2] = time + 0.5; @@ -420,12 +428,12 @@ Bool_t AliTRDclusterizerV1::MakeClusters() else { // Calculate the position of the cluster by using the // center of gravity method - for (Int_t i = 0; i < 5; i++) { - padSignal[i] = 0; + for (Int_t i = 0; i < kNsig; i++) { + padSignal[i] = 0.0; } - padSignal[2] = TMath::Abs(digitsOut->GetDataUnchecked(row,col ,time)); // central pad - padSignal[1] = TMath::Abs(digitsOut->GetDataUnchecked(row,col-1,time)); // left pad - padSignal[3] = TMath::Abs(digitsOut->GetDataUnchecked(row,col+1,time)); // right pad + padSignal[2] = TMath::Abs(digitsOut->GetDataUnchecked(row,col ,time)); // Central pad + padSignal[1] = TMath::Abs(digitsOut->GetDataUnchecked(row,col-1,time)); // Left pad + padSignal[3] = TMath::Abs(digitsOut->GetDataUnchecked(row,col+1,time)); // Right pad if ((col > 2) && (TMath::Abs(digitsOut->GetDataUnchecked(row,col-2,time)) < padSignal[1])) { padSignal[0] = TMath::Abs(digitsOut->GetDataUnchecked(row,col-2,time)); @@ -440,70 +448,128 @@ Bool_t AliTRDclusterizerV1::MakeClusters() Double_t q0 = clusterSignal[0]; Double_t q1 = clusterSignal[1]; Double_t q2 = clusterSignal[2]; - Double_t clusterSigmaY2 = (q1*(q0+q2)+4*q0*q2) / - (clusterCharge*clusterCharge); + Double_t clusterSigmaY2 = (q1 * (q0 + q2) + 4.0 * q0 * q2) + / (clusterCharge*clusterCharge); // // Calculate the position and the error // // Correct for t0 - Int_t clusterTimeBin = TMath::Nint(time - calibration->GetT0(idet, col, row)); - + Int_t clusterTimeBin = TMath::Nint(time - calibration->GetT0(idet,col,row)); Double_t colSize = padPlane->GetColSize(col); Double_t rowSize = padPlane->GetRowSize(row); Double_t clusterPos[3]; - clusterPos[0] = padPlane->GetColPos(col) - (clusterPads[1]+0.5)*colSize; - clusterPos[1] = padPlane->GetRowPos(row) - 0.5*rowSize; + clusterPos[0] = padPlane->GetColPos(col) - (clusterPads[1] + 0.5) * colSize; + clusterPos[1] = padPlane->GetRowPos(row) - 0.5 * rowSize; clusterPos[2] = CalcXposFromTimebin(clusterPads[2],idet,col,row); Double_t clusterSig[2]; - clusterSig[0] = (clusterSigmaY2 + 1./12.) * colSize*colSize; - clusterSig[1] = rowSize * rowSize / 12.; - + clusterSig[0] = (clusterSigmaY2 + 1.0/12.0) * colSize*colSize; + clusterSig[1] = rowSize * rowSize / 12.0; - // Add the cluster to the output array - AliTRDcluster * cluster = AddCluster(clusterPos - ,clusterTimeBin - ,idet - ,clusterCharge - ,clusterTracks - ,clusterSig - ,iType - ,clusterPads[1]); - - printf("Add a cluster: q=%f, det=%d, x=%f, y=%f, z=%f\n",clusterCharge - ,idet,clusterPos[0],clusterPos[1],clusterPos[2]); - - Short_t signals[7]={ 0, 0, 0, 0, 0, 0, 0 }; + // Add the cluster to the output array + // The track indices will be stored later + AliTRDcluster *cluster = AddCluster(clusterPos + ,clusterTimeBin + ,idet + ,clusterCharge + ,dummy + ,clusterSig + ,iType + ,clusterPads[1]); + + // Store the amplitudes of the pads in the cluster for later analysis + Short_t signals[7] = { 0, 0, 0, 0, 0, 0, 0 }; for (Int_t jPad = col-3; jPad <= col+3; jPad++) { - if ((jPad < 0) || (jPad >= nColMax-1)) { + if ((jPad < 0) || + (jPad >= nColMax-1)) { continue; } signals[jPad-col+3] = TMath::Nint(TMath::Abs(digitsOut->GetDataUnchecked(row,jPad,time))); } cluster->SetSignals(signals); - } + // Temporarily store the row, column and time bin of the center pad + // Used to later on assign the track indices + cluster->SetLabel( row,0); + cluster->SetLabel( col,1); + cluster->SetLabel(time,2); - } - } - } + // Store the index of the first cluster in the current ROC + if (firstClusterROC < 0) { + firstClusterROC = RecPoints()->GetEntriesFast() - 1; + } + // Count the number of cluster in the current ROC + nClusterROC++; + + } // if: Maximum found ? + + } // loop: pad columns + } // loop: time bins + } // loop: pad rows delete digitsOut; - // Compress the arrays - track0->Compress(1,0); - track1->Compress(1,0); - track2->Compress(1,0); + // + // Add the track indices to the found clusters + // + + // Temporary array to collect the track indices + Int_t *idxTracks = new Int_t[kNtrack*nClusterROC]; + + // Loop through the dictionary arrays one-by-one + // to keep memory consumption low + for (Int_t iDict = 0; iDict < kNdict; iDict++) { + + tracksIn = fDigitsManager->GetDictionary(idet,iDict); + tracksIn->Expand(); + + // Loop though the clusters found in this ROC + for (iClusterROC = 0; iClusterROC < nClusterROC; iClusterROC++) { + + AliTRDcluster *cluster = (AliTRDcluster *) + RecPoints()->UncheckedAt(firstClusterROC+iClusterROC); + row = cluster->GetLabel(0); + col = cluster->GetLabel(1); + time = cluster->GetLabel(2); + + for (iPad = 0; iPad < kNclus; iPad++) { + Int_t iPadCol = col - 1 + iPad; + Int_t index = tracksIn->GetDataUnchecked(row,iPadCol,time) - 1; + idxTracks[3*iPad+iDict + iClusterROC*kNtrack] = index; + } + + } + + // Compress the arrays + tracksIn->Compress(1,0); + + } + + // Copy the track indices into the cluster + // Loop though the clusters found in this ROC + for (iClusterROC = 0; iClusterROC < nClusterROC; iClusterROC++) { + + AliTRDcluster *cluster = (AliTRDcluster *) + RecPoints()->UncheckedAt(firstClusterROC+iClusterROC); + cluster->SetLabel(-9999,0); + cluster->SetLabel(-9999,1); + cluster->SetLabel(-9999,2); + + cluster->AddTrackIndex(&idxTracks[iClusterROC*kNtrack]); + + } + + delete [] idxTracks; // Write the cluster and reset the array WriteClusters(idet); ResetRecPoints(); - } - } - } + } // loop: Sectors + } // loop: Planes + } // loop: Chambers return kTRUE; @@ -517,15 +583,21 @@ Double_t AliTRDclusterizerV1::GetCOG(Double_t signal[5]) // Used for clusters with more than 3 pads - where LUT not applicable // - Double_t sum = signal[0]+signal[1]+signal[2]+signal[3]+signal[4]; - Double_t res = (0.0*(-signal[0]+signal[4])+(-signal[1]+signal[3]))/sum; + Double_t sum = signal[0] + + signal[1] + + signal[2] + + signal[3] + + signal[4]; + + Double_t res = (0.0 * (-signal[0] + signal[4]) + + (-signal[1] + signal[3])) / sum; return res; } //_____________________________________________________________________________ -Double_t AliTRDclusterizerV1::Unfold(Double_t eps, Int_t plane, Double_t* padSignal) +Double_t AliTRDclusterizerV1::Unfold(Double_t eps, Int_t plane, Double_t *padSignal) { // // Method to unfold neighbouring maxima. @@ -534,21 +606,21 @@ Double_t AliTRDclusterizerV1::Unfold(Double_t eps, Int_t plane, Double_t* padSig // The resulting ratio is then returned to the calling method. // - AliTRDcalibDB* calibration = AliTRDcalibDB::Instance(); + AliTRDcalibDB *calibration = AliTRDcalibDB::Instance(); if (!calibration) { AliError("No AliTRDcalibDB instance available\n"); return kFALSE; } Int_t irc = 0; - Int_t itStep = 0; // Count iteration steps + Int_t itStep = 0; // Count iteration steps - Double_t ratio = 0.5; // Start value for ratio - Double_t prevRatio = 0; // Store previous ratio + Double_t ratio = 0.5; // Start value for ratio + Double_t prevRatio = 0.0; // Store previous ratio - Double_t newLeftSignal[3] = {0}; // Array to store left cluster signal - Double_t newRightSignal[3] = {0}; // Array to store right cluster signal - Double_t newSignal[3] = {0}; + Double_t newLeftSignal[3] = { 0.0, 0.0, 0.0 }; // Array to store left cluster signal + Double_t newRightSignal[3] = { 0.0, 0.0, 0.0 }; // Array to store right cluster signal + Double_t newSignal[3] = { 0.0, 0.0, 0.0 }; // Start the iteration while ((TMath::Abs(prevRatio - ratio) > eps) && (itStep < 10)) { @@ -560,7 +632,7 @@ Double_t AliTRDclusterizerV1::Unfold(Double_t eps, Int_t plane, Double_t* padSig Double_t maxLeft = (ratio*padSignal[2] - padSignal[0]) / (padSignal[0] + padSignal[1] + ratio*padSignal[2]); Double_t maxRight = (padSignal[4] - (1-ratio)*padSignal[2]) - / ((1-ratio)*padSignal[2] + padSignal[3] + padSignal[4]); + / ((1.0 - ratio)*padSignal[2] + padSignal[3] + padSignal[4]); // Set cluster charge ratio irc = calibration->PadResponse(1.0,maxLeft ,plane,newSignal); @@ -574,7 +646,7 @@ Double_t AliTRDclusterizerV1::Unfold(Double_t eps, Int_t plane, Double_t* padSig // Calculate new overlapping ratio ratio = TMath::Min((Double_t)1.0,newLeftSignal[2] / - (newLeftSignal[2] + newRightSignal[0])); + (newLeftSignal[2] + newRightSignal[0])); } @@ -583,52 +655,53 @@ Double_t AliTRDclusterizerV1::Unfold(Double_t eps, Int_t plane, Double_t* padSig } //_____________________________________________________________________________ -void AliTRDclusterizerV1::Transform(AliTRDdataArrayI* digitsIn, - AliTRDdataArrayF* digitsOut, - Int_t idet, Int_t nRowMax, - Int_t nColMax, Int_t nTimeTotal, - Float_t ADCthreshold) +void AliTRDclusterizerV1::Transform(AliTRDdataArrayI *digitsIn + , AliTRDdataArrayF *digitsOut + , Int_t idet, Int_t nRowMax + , Int_t nColMax, Int_t nTimeTotal + , Float_t ADCthreshold) { // // Apply gain factor - // Apply tail cancellation: Transform digitsIn to digitsOut + // Apply tail cancelation: Transform digitsIn to digitsOut // Int_t iRow = 0; Int_t iCol = 0; Int_t iTime = 0; - AliTRDRecParam* recParam = AliTRDRecParam::Instance(); + AliTRDRecParam *recParam = AliTRDRecParam::Instance(); if (!recParam) { AliError("No AliTRDRecParam instance available\n"); return; } - AliTRDcalibDB* calibration = AliTRDcalibDB::Instance(); + AliTRDcalibDB *calibration = AliTRDcalibDB::Instance(); if (!calibration) { AliError("No AliTRDcalibDB instance available\n"); return; } - Double_t *inADC = new Double_t[nTimeTotal]; // adc data before tail cancellation - Double_t *outADC = new Double_t[nTimeTotal]; // adc data after tail cancellation + Double_t *inADC = new Double_t[nTimeTotal]; // ADC data before tail cancellation + Double_t *outADC = new Double_t[nTimeTotal]; // ADC data after tail cancellation AliDebug(1,Form("Tail cancellation (nExp = %d) for detector %d.\n" ,recParam->GetTCnexp(),idet)); for (iRow = 0; iRow < nRowMax; iRow++ ) { for (iCol = 0; iCol < nColMax; iCol++ ) { + for (iTime = 0; iTime < nTimeTotal; iTime++) { // // Add gain // Double_t gain = calibration->GetGainFactor(idet,iCol,iRow); - if (gain == 0) { + if (gain == 0.0) { AliError("Not a valid gain\n"); } - inADC[iTime] = digitsIn->GetDataUnchecked(iRow,iCol,iTime); - inADC[iTime] /= gain; - outADC[iTime] = inADC[iTime]; + inADC[iTime] = digitsIn->GetDataUnchecked(iRow,iCol,iTime); + inADC[iTime] /= gain; + outADC[iTime] = inADC[iTime]; } @@ -659,8 +732,8 @@ void AliTRDclusterizerV1::Transform(AliTRDdataArrayI* digitsIn, } //_____________________________________________________________________________ -void AliTRDclusterizerV1::DeConvExp(Double_t *source, Double_t *target, - Int_t n, Int_t nexp) +void AliTRDclusterizerV1::DeConvExp(Double_t *source, Double_t *target + , Int_t n, Int_t nexp) { // // Tail cancellation by deconvolution for PASA v4 TRF @@ -691,7 +764,7 @@ void AliTRDclusterizerV1::DeConvExp(Double_t *source, Double_t *target, coefficients[0] = C1; coefficients[1] = C2; - Double_t Dt = 0.100; + Double_t Dt = 0.1; rates[0] = TMath::Exp(-Dt/(R1)); rates[1] = TMath::Exp(-Dt/(R2)); @@ -709,7 +782,7 @@ void AliTRDclusterizerV1::DeConvExp(Double_t *source, Double_t *target, reminder[k] = 0.0; } for (i = 0; i < n; i++) { - result = (source[i] - correction); // no rescaling + result = (source[i] - correction); // No rescaling target[i] = result; for (k = 0; k < nexp; k++) { diff --git a/TRD/AliTRDdataArray.cxx b/TRD/AliTRDdataArray.cxx index 5df81463921..e3447519994 100644 --- a/TRD/AliTRDdataArray.cxx +++ b/TRD/AliTRDdataArray.cxx @@ -106,7 +106,10 @@ AliTRDdataArray::~AliTRDdataArray() // AliTRDdataArray destructor // - if (fIndex) delete fIndex; + if (fIndex) { + delete fIndex; + fIndex = 0; + } } @@ -198,12 +201,16 @@ Bool_t AliTRDdataArray::CheckBounds(Int_t idx1, Int_t idx2) // Does the boundary checking // - if ((idx2 >= fNdim2) || (idx2 < 0)) + if ((idx2 >= fNdim2) || + (idx2 < 0)) { return OutOfBoundsError(idx1,idx2); + } Int_t index = (*fIndex).At(idx2) + idx1; - if ((index < 0) || (index > fNelems)) + if ((index < 0) || + (index > fNelems)) { return OutOfBoundsError(idx1,idx2); + } return kTRUE; @@ -230,7 +237,10 @@ void AliTRDdataArray::Reset() // Reset the array (old content gets deleted) // - if (fIndex) delete fIndex; + if (fIndex) { + delete fIndex; + } + fIndex = new AliTRDarrayI(); fIndex->Set(0); diff --git a/TRD/AliTRDdataArrayF.cxx b/TRD/AliTRDdataArrayF.cxx index 7e4ed79e7f7..7c69bb7e4c6 100644 --- a/TRD/AliTRDdataArrayF.cxx +++ b/TRD/AliTRDdataArrayF.cxx @@ -76,7 +76,10 @@ AliTRDdataArrayF::~AliTRDdataArrayF() // Destructor // - if (fElements) delete fElements; + if (fElements) { + delete fElements; + fElements = 0; + } } @@ -89,9 +92,14 @@ void AliTRDdataArrayF::Allocate(Int_t nrow, Int_t ncol, Int_t ntime) // The row- and column dimensions are compressible. // - if (fNelems < 0) AliTRDdataArray::Allocate(nrow,ncol,ntime); + if (fNelems < 0) { + AliTRDdataArray::Allocate(nrow,ncol,ntime); + } + + if (fElements) { + delete fElements; + } - if (fElements) delete fElements; fElements = new AliTRDarrayF(); fElements->Set(fNelems); @@ -119,7 +127,10 @@ void AliTRDdataArrayF::Reset() // Reset the array (old content gets deleted) // - if (fElements) delete fElements; + if (fElements) { + delete fElements; + } + fElements = new AliTRDarrayF(); fElements->Set(0); diff --git a/TRD/AliTRDdataArrayI.cxx b/TRD/AliTRDdataArrayI.cxx index dc351936ee0..f6816364f46 100644 --- a/TRD/AliTRDdataArrayI.cxx +++ b/TRD/AliTRDdataArrayI.cxx @@ -75,7 +75,10 @@ AliTRDdataArrayI::~AliTRDdataArrayI() // Destructor // - if (fElements) delete fElements; + if (fElements) { + delete fElements; + fElements = 0; + } } @@ -88,9 +91,14 @@ void AliTRDdataArrayI::Allocate(Int_t nrow, Int_t ncol, Int_t ntime) // The row- and column dimensions are compressible. // - if (fNelems < 0) AliTRDdataArray::Allocate(nrow,ncol,ntime); + if (fNelems < 0) { + AliTRDdataArray::Allocate(nrow,ncol,ntime); + } + + if (fElements) { + delete fElements; + } - if (fElements) delete fElements; fElements = new AliTRDarrayI(); fElements->Set(fNelems); @@ -118,7 +126,11 @@ void AliTRDdataArrayI::Reset() // Reset the array (old content gets deleted) // - if (fElements) delete fElements; + if (fElements) { + delete fElements; + } + + fElements = new AliTRDarrayI(); fElements->Set(0); diff --git a/TRD/AliTRDv1.cxx b/TRD/AliTRDv1.cxx index e4fd93223c2..84e22e09c74 100644 --- a/TRD/AliTRDv1.cxx +++ b/TRD/AliTRDv1.cxx @@ -342,10 +342,17 @@ void AliTRDv1::StepManager() // switch (fTypeOfStepManager) { - case 0 : StepManagerErmilova(); break; // 0 is Ermilova - case 1 : StepManagerGeant(); break; // 1 is Geant - case 2 : StepManagerFixedStep(); break; // 2 is fixed step - default : AliWarning("Not a valid Step Manager."); + case 0: + StepManagerErmilova(); + break; + case 1: + StepManagerGeant(); + break; + case 2: + StepManagerFixedStep(); + break; + default: + AliWarning("Not a valid Step Manager."); } } -- 2.39.3