Update of clusterizer
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 28 Aug 2006 14:37:05 +0000 (14:37 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 28 Aug 2006 14:37:05 +0000 (14:37 +0000)
TRD/AliTRDarrayF.cxx
TRD/AliTRDarrayF.h
TRD/AliTRDarrayI.cxx
TRD/AliTRDarrayI.h
TRD/AliTRDcluster.cxx
TRD/AliTRDclusterizer.cxx
TRD/AliTRDclusterizerV1.cxx
TRD/AliTRDdataArray.cxx
TRD/AliTRDdataArrayF.cxx
TRD/AliTRDdataArrayI.cxx
TRD/AliTRDv1.cxx

index 554ef5a..264badb 100644 (file)
@@ -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;
+  } 
+
 }
 
index f7d8eae..c502c92 100644 (file)
@@ -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 <TObject.h>
 #include <TArrayF.h>
index 1e1936d..605f688 100644 (file)
@@ -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;
+  }
  
 }
 
index c6fef3e..bb59602 100644 (file)
@@ -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 <TObject.h>
 #include <TArrayI.h>
index 64d2c64..49fc165 100644 (file)
@@ -38,7 +38,7 @@ AliTRDcluster::AliTRDcluster()
   ,fCenter(0)
 { 
   //
-  // default constructor
+  // Default constructor
   //
 
   for (Int_t i = 0; i < 7; i++) {
index 9ea7f04..ed3a96e 100644 (file)
@@ -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;
   }
 
index d777409..5f73b86 100644 (file)
@@ -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++) {
index 5df8146..e344751 100644 (file)
@@ -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); 
 
index 7e4ed79..7c69bb7 100644 (file)
@@ -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); 
 
index dc35193..f681636 100644 (file)
@@ -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); 
 
index e4fd932..84e22e0 100644 (file)
@@ -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.");
   }
 
 }