Allow running without tree by using
authorloizides <loizides@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 8 Mar 2011 08:47:59 +0000 (08:47 +0000)
committerloizides <loizides@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 8 Mar 2011 08:47:59 +0000 (08:47 +0000)
  clusterizer->SetDigitsArr(arr);
  clusterizer->SetOutput(0);
 and get resulting clusters using
  clusterizer->GetRecPoints()

Make flag to indicate that input is calibrated a member (it was static before)

Add void AliEMCALClusterizer::InitParameters(const AliEMCALRecParam* recParam) so that
one can pass a recParam object by hand. AliEMCALClusterizer::InitParameters() simply
returns InitParameters(AliEMCALReconstructor::GetRecParam());

General cleanup to improve readability of code.

EMCAL/AliEMCALClusterizer.cxx
EMCAL/AliEMCALClusterizer.h

index 69519eb..4737d6a 100644 (file)
@@ -59,11 +59,9 @@ class AliCDBStorage;
 
 ClassImp(AliEMCALClusterizer)
 
-Bool_t AliEMCALClusterizer::fgkIsInputCalibrated = kFALSE;
-
-
 //____________________________________________________________________________
 AliEMCALClusterizer::AliEMCALClusterizer():
+  fIsInputCalibrated(kFALSE),
   fDigitsArr(NULL),
   fTreeR(NULL),
   fRecPoints(NULL),
@@ -80,11 +78,11 @@ AliEMCALClusterizer::AliEMCALClusterizer():
   // ctor
   
   Init();
-  
 }
 
 //____________________________________________________________________________
 AliEMCALClusterizer::AliEMCALClusterizer(AliEMCALGeometry* geometry): 
+  fIsInputCalibrated(kFALSE),
   fDigitsArr(NULL),
   fTreeR(NULL),
   fRecPoints(NULL),
@@ -98,14 +96,12 @@ AliEMCALClusterizer::AliEMCALClusterizer(AliEMCALGeometry* geometry):
   fECALocMaxCut(0.),fECAW0(0.),fMinECut(0.),
   fClusterUnfolding(NULL)
 {
-  // ctor with the indication of the file where header Tree and digits Tree are stored
-  // use this contructor to avoid usage of Init() which uses runloader
-  // change needed by HLT - MP
-  
-  // Note for the future: the use on runloader should be avoided or optional at least
-  // another way is to make Init virtual and protected at least such that the deriving classes can overload
-  // Init() ;
-  //
+  // Ctor with the indication of the file where header Tree and digits Tree are stored.
+  // Use this contructor to avoid usage of Init() which uses runloader.
+  // Change needed by HLT - MP.
+  // Note for the future: the use on runloader should be avoided or optional at least.
+  // Another way is to make Init virtual and protected at least 
+  // such that the deriving classes can overload Init();
   
   if (!fGeom)
   {
@@ -121,7 +117,10 @@ AliEMCALClusterizer::AliEMCALClusterizer(AliEMCALGeometry* geometry):
 }
 
 //____________________________________________________________________________
-AliEMCALClusterizer::AliEMCALClusterizer(AliEMCALGeometry* geometry, AliEMCALCalibData * calib, AliCaloCalibPedestal * caloped): 
+AliEMCALClusterizer::AliEMCALClusterizer(AliEMCALGeometry *geometry, 
+                                         AliEMCALCalibData *calib, 
+                                         AliCaloCalibPedestal *caloped): 
+  fIsInputCalibrated(kFALSE),
   fDigitsArr(NULL),
   fTreeR(NULL),
   fRecPoints(NULL),
@@ -147,113 +146,95 @@ AliEMCALClusterizer::AliEMCALClusterizer(AliEMCALGeometry* geometry, AliEMCALCal
     fPar5[i] = 0.;
     fPar6[i] = 0.;
   }
-  
 }
 
-
 //____________________________________________________________________________
 AliEMCALClusterizer::~AliEMCALClusterizer()
 {
   // dtor
   //Already deleted in AliEMCALReconstructor.
 
-//   if(fGeom)      delete fGeom;
-//   if(fCalibData) delete fCalibData;
-//   if(fCaloPed)   delete fCaloPed;
-
-//   if (fDigitsArr) {
-//     fDigitsArr->Clear("C");
-//     delete fDigitsArr;
-//   }
-//   if (fRecPoints) {
-//     fRecPoints->Delete();
-//     delete fRecPoints;
-//  }
-  
   if(fClusterUnfolding) delete fClusterUnfolding;
 }
 
 //____________________________________________________________________________
-Float_t  AliEMCALClusterizer::Calibrate(const Float_t amp, const Float_t time, const Int_t absId) 
+Float_t AliEMCALClusterizer::Calibrate(const Float_t amp, const Float_t time, const Int_t absId) 
 {
-  
   // Convert digitized amplitude into energy.
   // Calibration parameters are taken from calibration data base for raw data,
   // or from digitizer parameters for simulated data.
-  if(fCalibData){
-    
-    if (fGeom==0)
-      AliFatal("Did not get geometry from EMCALLoader") ;
-    
-    Int_t iSupMod = -1;
-    Int_t nModule = -1;
-    Int_t nIphi   = -1;
-    Int_t nIeta   = -1;
-    Int_t iphi    = -1;
-    Int_t ieta    = -1;
-    
-    Bool_t bCell = fGeom->GetCellIndex(absId, iSupMod, nModule, nIphi, nIeta) ;
-    if(!bCell) {
-      fGeom->PrintGeometry();
-      AliError(Form("Wrong cell id number : %i", absId));
-      //assert(0); // GCB: This aborts reconstruction of raw simulations where simulation had more SM than default geometry, 
-      //change to return 0, to avoid aborting good generations.
-      return 0;
-    }
-    
-    fGeom->GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
-         
-    // Check if channel is bad (dead or hot), in this case return 0.   
-    // Gustavo: 15-12-09 In case of RAW data this selection is already done, but not in simulation.
-    // for the moment keep it here but remember to do the selection at the sdigitizer level 
-    // and remove it from here
-    Int_t channelStatus = (Int_t)(fCaloPed->GetDeadMap(iSupMod))->GetBinContent(ieta,iphi);
-    if(channelStatus == AliCaloCalibPedestal::kHot || channelStatus == AliCaloCalibPedestal::kDead) {
-                 AliDebug(2,Form("Tower from SM %d, ieta %d, iphi %d is BAD : status %d !!!",iSupMod,ieta,iphi, channelStatus));
-                 return 0;
-    }
-    //Check if time is too large or too small, indication of a noisy channel, remove in this case
-    if(time > fTimeMax || time < fTimeMin) return 0;
-    
-    if (AliEMCALClusterizer::fgkIsInputCalibrated == kTRUE)
+
+  //Return energy with default parameters if calibration is not available
+  if (!fCalibData) {
+    if (fIsInputCalibrated == kTRUE)
     {
       AliDebug(10, Form("Input already calibrated!"));
       return amp;
-    }
-         
-    fADCchannelECA  = fCalibData->GetADCchannel (iSupMod,ieta,iphi);
-    fADCpedestalECA = fCalibData->GetADCpedestal(iSupMod,ieta,iphi);
+    }    
     
+    return -fADCpedestalECA + amp * fADCchannelECA ; 
+  }
+  
+  if (fGeom==0)
+    AliFatal("Did not get geometry from EMCALLoader") ;
     
-    return -fADCpedestalECA + amp * fADCchannelECA ;        
+  Int_t iSupMod = -1;
+  Int_t nModule = -1;
+  Int_t nIphi   = -1;
+  Int_t nIeta   = -1;
+  Int_t iphi    = -1;
+  Int_t ieta    = -1;
     
+  Bool_t bCell = fGeom->GetCellIndex(absId, iSupMod, nModule, nIphi, nIeta) ;
+  if(!bCell) {
+    fGeom->PrintGeometry();
+    AliError(Form("Wrong cell id number : %i", absId));
+    //assert(0); // GCB: This aborts reconstruction of raw simulations 
+    //where simulation had more SM than default geometry, 
+    //change to return 0, to avoid aborting good generations.
+    return 0;
   }
-  else{ //Return energy with default parameters if calibration is not available
     
-    if (AliEMCALClusterizer::fgkIsInputCalibrated == kTRUE)
-    {
-      AliDebug(10, Form("Input already calibrated!"));
-      return amp;
-    }    
+  fGeom->GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
+         
+  // Check if channel is bad (dead or hot), in this case return 0.     
+  // Gustavo: 15-12-09 In case of RAW data this selection is already done, but not in simulation.
+  // for the moment keep it here but remember to do the selection at the sdigitizer level 
+  // and remove it from here
+  Int_t channelStatus = (Int_t)(fCaloPed->GetDeadMap(iSupMod))->GetBinContent(ieta,iphi);
+  if(channelStatus == AliCaloCalibPedestal::kHot || channelStatus == AliCaloCalibPedestal::kDead) {
+    AliDebug(2,Form("Tower from SM %d, ieta %d, iphi %d is BAD : status %d !!!",iSupMod,ieta,iphi, channelStatus));
+    return 0;
+  }
+  //Check if time is too large or too small, indication of a noisy channel, remove in this case
+  if(time > fTimeMax || time < fTimeMin) return 0;
     
-    return -fADCpedestalECA + amp * fADCchannelECA ; 
+  if (fIsInputCalibrated)
+  {
+    AliDebug(10, Form("Input already calibrated!"));
+    return amp;
   }
-  
+         
+  fADCchannelECA  = fCalibData->GetADCchannel (iSupMod,ieta,iphi);
+  fADCpedestalECA = fCalibData->GetADCpedestal(iSupMod,ieta,iphi);
+      
+  return -fADCpedestalECA + amp * fADCchannelECA ;        
 }
 
 //____________________________________________________________________________
 void AliEMCALClusterizer::GetCalibrationParameters() 
 {
   // Set calibration parameters:
-  // if calibration database exists, they are read from database,
+  // If calibration database exists, they are read from database,
   // otherwise, they are taken from digitizer.
-  //
   // It is a user responsilibity to open CDB before reconstruction, 
   // for example: 
   // AliCDBStorage* storage = AliCDBManager::Instance()->GetStorage("local://CalibDB");
+
+  if (fIsInputCalibrated)
+    return;
   
   //Check if calibration is stored in data base
-  
   if(!fCalibData)
   {
     AliCDBEntry *entry = (AliCDBEntry*) 
@@ -263,7 +244,6 @@ void AliEMCALClusterizer::GetCalibrationParameters()
   
   if(!fCalibData)
     AliFatal("Calibration parameters not found in CDB!");
-  
 }
 
 //____________________________________________________________________________
@@ -276,9 +256,11 @@ void AliEMCALClusterizer::GetCaloCalibPedestal()
   // It is a user responsilibity to open CDB before reconstruction, 
   // for example: 
   // AliCDBStorage* storage = AliCDBManager::Instance()->GetStorage("local://CalibDB");
+
+  if (fIsInputCalibrated)
+    return;
   
-  //Check if calibration is stored in data base
-  
+  // Check if calibration is stored in data base
   if(!fCaloPed)
     {
       AliCDBEntry *entry = (AliCDBEntry*) 
@@ -288,7 +270,6 @@ void AliEMCALClusterizer::GetCaloCalibPedestal()
   
   if(!fCaloPed)
     AliFatal("Pedestal info not found in CDB!");
-  
 }
 
 //____________________________________________________________________________
@@ -304,7 +285,7 @@ void AliEMCALClusterizer::Init()
   }
   
   if(!fGeom){ 
-    fGeom =  AliEMCALGeometry::GetInstance(AliEMCALGeometry::GetDefaultGeometryName());
+    fGeom = AliEMCALGeometry::GetInstance(AliEMCALGeometry::GetDefaultGeometryName());
   }
   
   AliDebug(1,Form("geom %p",fGeom));
@@ -319,60 +300,64 @@ void AliEMCALClusterizer::Init()
     fPar5[i] = 0.;
     fPar6[i] = 0.;
   }
-  
 }
 
 //____________________________________________________________________________
 void AliEMCALClusterizer::InitParameters()
 { 
+  // Initializes the parameters for the Clusterizer from AliEMCALReconstructor::GetRecParam().
+
+  return InitParameters(AliEMCALReconstructor::GetRecParam());
+}
+
+//____________________________________________________________________________
+void AliEMCALClusterizer::InitParameters(const AliEMCALRecParam* recParam)
+{ 
   // Initializes the parameters for the Clusterizer
+
   fNumberOfECAClusters = 0 ;
   fCalibData           = 0 ;
   fCaloPed             = 0 ;
        
-  const AliEMCALRecParam* recParam = AliEMCALReconstructor::GetRecParam();
   if(!recParam) {
     AliFatal("Reconstruction parameters for EMCAL not set!");
-  } else {
-    fECAClusteringThreshold = recParam->GetClusteringThreshold();
-    fECAW0                  = recParam->GetW0();
-    fMinECut                = recParam->GetMinECut();    
-    fToUnfold               = recParam->GetUnfold();
-    fECALocMaxCut           = recParam->GetLocMaxCut();
-    fTimeCut                = recParam->GetTimeCut();
-    fTimeMin                = recParam->GetTimeMin();
-    fTimeMax                = recParam->GetTimeMax();
-    
-    AliDebug(1,Form("Reconstruction parameters: fECAClusteringThreshold=%.3f GeV, fECAW=%.3f, fMinECut=%.3f GeV, fToUnfold=%d, fECALocMaxCut=%.3f GeV, fTimeCut=%e s,fTimeMin=%e s,fTimeMax=%e s",
-                    fECAClusteringThreshold,fECAW0,fMinECut,fToUnfold,fECALocMaxCut,fTimeCut, fTimeMin, fTimeMax));
+  } 
+
+  fECAClusteringThreshold = recParam->GetClusteringThreshold();
+  fECAW0                  = recParam->GetW0();
+  fMinECut                = recParam->GetMinECut();    
+  fToUnfold               = recParam->GetUnfold();
+  fECALocMaxCut           = recParam->GetLocMaxCut();
+  fTimeCut                = recParam->GetTimeCut();
+  fTimeMin                = recParam->GetTimeMin();
+  fTimeMax                = recParam->GetTimeMax();
     
-    if(fToUnfold){
-      
-      Int_t i=0;
-      for (i = 0; i < 8; i++) {
-        fSSPars[i] = recParam->GetSSPars(i);
-      }//end of loop over parameters
-      for (i = 0; i < 3; i++) {
-        fPar5[i] = recParam->GetPar5(i);
-        fPar6[i] = recParam->GetPar6(i);
-      }//end of loop over parameters
-      
-      InitClusterUnfolding();
+  AliDebug(1,Form("Reconstruction parameters: fECAClusteringThreshold=%.3f GeV, fECAW=%.3f, fMinECut=%.3f GeV, "
+                  "fToUnfold=%d, fECALocMaxCut=%.3f GeV, fTimeCut=%e s,fTimeMin=%e s,fTimeMax=%e s",
+                  fECAClusteringThreshold,fECAW0,fMinECut,fToUnfold,fECALocMaxCut,fTimeCut, fTimeMin, fTimeMax));
+
+  if (fToUnfold) {
+    Int_t i=0;
+    for (i = 0; i < 8; i++) {
+      fSSPars[i] = recParam->GetSSPars(i);
+    } //end of loop over parameters
+    for (i = 0; i < 3; i++) {
+      fPar5[i] = recParam->GetPar5(i);
+      fPar6[i] = recParam->GetPar6(i);
+    } //end of loop over parameters
       
-      for (i = 0; i < 8; i++) {
-        AliDebug(1,Form("unfolding shower shape parameters: fSSPars=%f \n",fSSPars[i]));
-      }
-      for (i = 0; i < 3; i++) {
-        AliDebug(1,Form("unfolding parameter 5: fPar5=%f \n",fPar5[i]));
-        AliDebug(1,Form("unfolding parameter 6: fPar6=%f \n",fPar6[i]));
-      }
+    InitClusterUnfolding();
       
-    }// to unfold
-  }// recparam not null
-  
+    for (i = 0; i < 8; i++) {
+      AliDebug(1,Form("unfolding shower shape parameters: fSSPars=%f \n",fSSPars[i]));
+    }
+    for (i = 0; i < 3; i++) {
+      AliDebug(1,Form("unfolding parameter 5: fPar5=%f \n",fPar5[i]));
+      AliDebug(1,Form("unfolding parameter 6: fPar6=%f \n",fPar6[i]));
+    }
+  } // to unfold
 }
 
-
 //____________________________________________________________________________
 void AliEMCALClusterizer::Print(Option_t * /*option*/)const
 {
@@ -380,53 +365,52 @@ void AliEMCALClusterizer::Print(Option_t * /*option*/)const
   
   TString message("\n") ; 
   
-  if( strcmp(GetName(), "") !=0 ){
-    
-    // Print parameters
+  if (strcmp(GetName(),"") == 0) {
+    printf("AliEMCALClusterizer not initialized\n");
+    return;
+  }
     
-    TString taskName(Version()) ;
+  // Print parameters
+  TString taskName(Version()) ;
     
-    printf("--------------- "); 
-    printf("%s",taskName.Data()) ; 
-    printf(" "); 
-    printf("Clusterizing digits: "); 
-    printf("\n                       ECA Local Maximum cut    = %f", fECALocMaxCut); 
-    printf("\n                       ECA Logarithmic weight   = %f", fECAW0); 
-    if(fToUnfold){
-      printf("\nUnfolding on\n");
-      printf("Unfolding parameters: fSSpars: \n");
-      Int_t i=0;
-      for (i = 0; i < 8; i++) {
-        printf("fSSPars[%d] = %f \n", i, fSSPars[i]);
-      }
-      printf("Unfolding parameter 5 and 6: fPar5 and fPar6: \n");
-      for (i = 0; i < 3; i++) {
-        printf("fPar5[%d] = %f \n", i, fPar5[i]);
-        printf("fPar6[%d] = %f \n", i, fPar6[i]);
-      }
+  printf("--------------- "); 
+  printf("%s",taskName.Data()) ; 
+  printf(" "); 
+  printf("Clusterizing digits: "); 
+  printf("\n                       ECA Local Maximum cut    = %f", fECALocMaxCut); 
+  printf("\n                       ECA Logarithmic weight   = %f", fECAW0); 
+  if (fToUnfold) {
+    printf("\nUnfolding on\n");
+    printf("Unfolding parameters: fSSpars: \n");
+    Int_t i=0;
+    for (i = 0; i < 8; i++) {
+      printf("fSSPars[%d] = %f \n", i, fSSPars[i]);
+    }
+    printf("Unfolding parameter 5 and 6: fPar5 and fPar6: \n");
+    for (i = 0; i < 3; i++) {
+      printf("fPar5[%d] = %f \n", i, fPar5[i]);
+      printf("fPar6[%d] = %f \n", i, fPar6[i]);
     }
-    else
-      printf("\nUnfolding off\n");
-    
-    printf("------------------------------------------------------------------"); 
   }
   else
-    printf("AliEMCALClusterizer not initialized ") ;
+    printf("\nUnfolding off\n");
+    
+  printf("------------------------------------------------------------------"); 
 }
 
 //____________________________________________________________________________
 void AliEMCALClusterizer::PrintRecPoints(Option_t * option)
 {
   // Prints list of RecPoints produced at the current pass of AliEMCALClusterizer
-  if(strstr(option,"deb")) {
+
+  if (strstr(option,"deb")) {
     printf("PrintRecPoints: Clusterization result:") ; 
-    
     printf("           Found %d ECA Rec Points\n ", 
            fRecPoints->GetEntriesFast()) ; 
   }
   
-  if(strstr(option,"all")) {
-    if(strstr(option,"deb")) {
+  if (strstr(option,"all")) {
+    if (strstr(option,"deb")) {
       printf("\n-----------------------------------------------------------------------\n") ;
       printf("Clusters in ECAL section\n") ;
       printf("Index    Ene(GeV) Multi Module     GX    GY   GZ  lX    lY   lZ   Dispersion Lambda 1   Lambda 2  # of prim  Primaries list\n") ;
@@ -434,26 +418,26 @@ void AliEMCALClusterizer::PrintRecPoints(Option_t * option)
     Int_t index; 
     for (index =  0 ; index < fRecPoints->GetEntries() ; index++) {
       AliEMCALRecPoint * rp = dynamic_cast<AliEMCALRecPoint * >(fRecPoints->At(index)) ; 
-      if(rp){
-        TVector3  globalpos;  
-        //rp->GetGlobalPosition(globalpos);
-        TVector3  localpos;  
-        rp->GetLocalPosition(localpos);
-        Float_t lambda[2]; 
-        rp->GetElipsAxis(lambda);
-        
-        Int_t nprimaries=0;
-        Int_t * primaries = rp->GetPrimaries(nprimaries);
+      if (!rp) 
+        continue;
+
+      TVector3  globalpos;  
+      //rp->GetGlobalPosition(globalpos);
+      TVector3  localpos;  
+      rp->GetLocalPosition(localpos);
+      Float_t lambda[2]; 
+      rp->GetElipsAxis(lambda);
         
-        if(strstr(option,"deb")) 
-          printf("\n%6d  %8.4f  %3d     %4.1f    %4.1f %4.1f  %4.1f %4.1f %4.1f    %4.1f   %4f  %4f    %2d     : ", 
-                 rp->GetIndexInList(), rp->GetEnergy(), rp->GetMultiplicity(),
-                 globalpos.X(), globalpos.Y(), globalpos.Z(), localpos.X(), localpos.Y(), localpos.Z(), 
-                 rp->GetDispersion(), lambda[0], lambda[1], nprimaries) ; 
-        if(strstr(option,"deb")){ 
-          for (Int_t iprimary=0; iprimary<nprimaries; iprimary++) {
-            printf("%d ", primaries[iprimary] ) ; 
-          }
+      Int_t nprimaries=0;
+      Int_t * primaries = rp->GetPrimaries(nprimaries);
+      if(strstr(option,"deb")) 
+        printf("\n%6d  %8.4f  %3d     %4.1f    %4.1f %4.1f  %4.1f %4.1f %4.1f    %4.1f   %4f  %4f    %2d     : ", 
+               rp->GetIndexInList(), rp->GetEnergy(), rp->GetMultiplicity(),
+               globalpos.X(), globalpos.Y(), globalpos.Z(), localpos.X(), localpos.Y(), localpos.Z(), 
+               rp->GetDispersion(), lambda[0], lambda[1], nprimaries) ; 
+      if(strstr(option,"deb")){ 
+        for (Int_t iprimary=0; iprimary<nprimaries; iprimary++) {
+          printf("%d ", primaries[iprimary] ) ; 
         }
       }
     }
@@ -466,15 +450,16 @@ void AliEMCALClusterizer::PrintRecPoints(Option_t * option)
 //___________________________________________________________________
 void  AliEMCALClusterizer::PrintRecoInfo()
 {
-  //print reco version
+  // Print reco version
+
   printf(" AliEMCALClusterizer::PrintRecoInfo() : version %s \n", Version() );
-  
 }
 
 //____________________________________________________________________________
 void AliEMCALClusterizer::SetInput(TTree *digitsTree)
 {
   // Read the digits from the input tree
+
   TBranch *branch = digitsTree->GetBranch("EMCAL");
   if (!branch) { 
     AliError("can't get the branch with the EMCAL digits !");
@@ -490,23 +475,21 @@ void AliEMCALClusterizer::SetInput(TTree *digitsTree)
 void AliEMCALClusterizer::SetOutput(TTree *clustersTree)
 {
   // Read the digits from the input tree
-  fTreeR = clustersTree;
-  
+
   AliDebug(9, "Making array for EMCAL clusters");
-  fRecPoints = new TObjArray(100) ;
-  Int_t split = 0;
-  Int_t bufsize = 32000;
-  fTreeR->Branch("EMCALECARP", "TObjArray", &fRecPoints, bufsize, split);
+  fRecPoints = new TObjArray(1000);
+  if (clustersTree) {
+    fTreeR = clustersTree;
+    Int_t split = 0;
+    Int_t bufsize = 32000;
+    fTreeR->Branch("EMCALECARP", "TObjArray", &fRecPoints, bufsize, split);
+  }
 }
 
 //___________________________________________________________________
-void   AliEMCALClusterizer::SetInputCalibrated(Bool_t val)
+void AliEMCALClusterizer::SetInputCalibrated(Bool_t val)
 {
-  //
-  // input is calibrated - the case when we run already on ESD
-  //
-  AliEMCALClusterizer::fgkIsInputCalibrated = val;
-}
-
-
+  // Flag to indicate that input is calibrated - the case when we run already on ESD
 
+  fIsInputCalibrated = val;
+}
index 2e2e52b..77866d7 100644 (file)
@@ -19,54 +19,55 @@ class TTree;
 // --- Standard library ---
 
 // --- AliRoot header files ---
-class AliEMCALGeometry ;
-class AliEMCALCalibData ;
-class AliCaloCalibPedestal ;
+class AliEMCALGeometry;
+class AliEMCALCalibData;
+class AliCaloCalibPedestal;
+class AliEMCALRecParam;
 #include "AliEMCALUnfolding.h"
 
 class AliEMCALClusterizer : public TObject {
 
 public:
 
-  AliEMCALClusterizer() ;        // default ctor
-  virtual ~AliEMCALClusterizer() ; // dtorEM
-  AliEMCALClusterizer(AliEMCALGeometry* geometry);
-  AliEMCALClusterizer(AliEMCALGeometry* geometry, AliEMCALCalibData * calib, AliCaloCalibPedestal * pedestal);
+  AliEMCALClusterizer();
+  virtual ~AliEMCALClusterizer();
+  AliEMCALClusterizer(AliEMCALGeometry *geometry);
+  AliEMCALClusterizer(AliEMCALGeometry *geometry, AliEMCALCalibData *calib, AliCaloCalibPedestal *pedestal);
 
   virtual void    Digits2Clusters(Option_t *option) = 0;
 
-  virtual Float_t Calibrate(const Float_t amp, const Float_t time, const Int_t cellId) ;  // Tranforms Amp to energy 
-  virtual void    Init() ;
-  virtual void    InitParameters() ; //{ AliInfo("Overload this method."); }
+  virtual Float_t Calibrate(const Float_t amp, const Float_t time, const Int_t cellId);
+  virtual void    Init();
+  virtual void    InitParameters();
+  virtual void    InitParameters(const AliEMCALRecParam* recParam);
 
   //Get/Set reconstruction parameters
-  virtual void  GetCalibrationParameters(void) ;
-  virtual void  GetCaloCalibPedestal(void) ;
-  virtual void  SetCalibrationParameters(AliEMCALCalibData * calib)   { fCalibData = calib ; }
-  virtual void  SetCaloCalibPedestal(AliCaloCalibPedestal  * caloped) { fCaloPed   = caloped ; }
+  virtual void  GetCalibrationParameters(void);
+  virtual void  GetCaloCalibPedestal(void);
+  virtual void  SetCalibrationParameters(AliEMCALCalibData *calib)   { fCalibData = calib;   }
+  virtual void  SetCaloCalibPedestal(AliCaloCalibPedestal  *caloped) { fCaloPed   = caloped; }
   
-  virtual Float_t GetTimeMin()           const { return fTimeMin ; }
-  virtual Float_t GetTimeMax()           const { return fTimeMax ; }
-  virtual Float_t GetTimeCut()           const { return fTimeCut ; }
-  //virtual void    GetNumberOfClustersFound(int numb )const { numb = fNumberOfECAClusters ;} 
-  virtual Float_t GetECAClusteringThreshold()        const { return fECAClusteringThreshold;}  
-  virtual Float_t GetECALocalMaxCut()                const { return fECALocMaxCut;} 
-  virtual Float_t GetECALogWeight()                  const { return fECAW0;}
-  virtual Float_t GetMinECut()                       const { return fMinECut;}
-
-  virtual void SetTimeMin(Float_t t)                                           { fTimeMin = t ;}
-  virtual void SetTimeMax(Float_t t)                                           { fTimeMax = t ;}
-  virtual void SetTimeCut(Float_t t)                                           { fTimeCut = t ;}
-  virtual void SetECAClusteringThreshold(Float_t th)  { fECAClusteringThreshold = th ; }
-  virtual void SetMinECut(Float_t mine)               { fMinECut = mine; }
-  virtual void SetECALocalMaxCut(Float_t cut)         { fECALocMaxCut = cut ; }
-  virtual void SetECALogWeight(Float_t w)             { fECAW0 = w ; }
+  virtual Float_t GetTimeMin()           const { return fTimeMin; }
+  virtual Float_t GetTimeMax()           const { return fTimeMax; }
+  virtual Float_t GetTimeCut()           const { return fTimeCut; }
+  virtual Float_t GetECAClusteringThreshold()   const { return fECAClusteringThreshold; }  
+  virtual Float_t GetECALocalMaxCut()           const { return fECALocMaxCut;           } 
+  virtual Float_t GetECALogWeight()             const { return fECAW0;                  }
+  virtual Float_t GetMinECut()                  const { return fMinECut;                }
+
+  virtual void SetTimeMin(Float_t t)                 { fTimeMin = t; }
+  virtual void SetTimeMax(Float_t t)                 { fTimeMax = t; }
+  virtual void SetTimeCut(Float_t t)                 { fTimeCut = t; }
+  virtual void SetECAClusteringThreshold(Float_t th)  { fECAClusteringThreshold = th; }
+  virtual void SetMinECut(Float_t mine)               { fMinECut = mine;     }
+  virtual void SetECALocalMaxCut(Float_t cut)         { fECALocMaxCut = cut; }
+  virtual void SetECALogWeight(Float_t w)             { fECAW0 = w;          }
   
   //Unfolding
-  virtual void SetUnfolding(Bool_t toUnfold = kTRUE ) { fToUnfold = toUnfold ;}  
-  virtual void SetSSPars   (Int_t ipar, Double_t par) { fSSPars[ipar] = par  ;}
-  virtual void SetPar5     (Int_t ipar, Double_t par) { fPar5  [ipar] = par  ;}
-  virtual void SetPar6     (Int_t ipar, Double_t par) { fPar6  [ipar] = par  ;}
+  virtual void SetUnfolding(Bool_t toUnfold = kTRUE ) { fToUnfold = toUnfold; }  
+  virtual void SetSSPars   (Int_t ipar, Double_t par) { fSSPars[ipar] = par;  }
+  virtual void SetPar5     (Int_t ipar, Double_t par) { fPar5  [ipar] = par;  }
+  virtual void SetPar6     (Int_t ipar, Double_t par) { fPar6  [ipar] = par;  }
   virtual void InitClusterUnfolding() {
     fClusterUnfolding=new AliEMCALUnfolding(fGeom,fECALocMaxCut,fSSPars,fPar5,fPar6);
   }
@@ -74,56 +75,57 @@ public:
   virtual void SetInput(TTree *digitsTree);
   virtual void SetOutput(TTree *clustersTree);
   
-  virtual void Print(Option_t * option)const ;
-  virtual void PrintRecPoints(Option_t * option);
-  virtual void PrintRecoInfo();                        //*MENU*
+  virtual void Print(Option_t *option) const ;
+  virtual void PrintRecPoints(Option_t *option);
+  virtual void PrintRecoInfo();
 
-  static void     SetInputCalibrated(Bool_t val);
+  void    SetInputCalibrated(Bool_t val);
   
-  virtual const char * Version() const {Warning("Version", "Not Defined") ; return 0 ; } 
+  virtual const char *Version() const { Warning("Version", "Not Defined"); return 0; } 
+
+  // add for clusterizing task
+  virtual void              SetDigitsArr(TClonesArray *arr) { fDigitsArr = arr;  }
+  virtual const TObjArray  *GetRecPoints() const            { return fRecPoints; }
 
 protected:
 
   virtual void MakeClusters() = 0;
   
-  static Bool_t fgkIsInputCalibrated; // to enable reclusterization from ESD cells
+  Bool_t fIsInputCalibrated; // to enable reclusterization from ESD cells
   
-  TClonesArray *fDigitsArr; // Array with EMCAL digits
-  TTree *fTreeR;            // Tree with output clusters
-  TObjArray    *fRecPoints; // Array with EMCAL clusters
+  TClonesArray *fDigitsArr;  // array with EMCAL digits
+  TTree        *fTreeR;      // tree with output clusters
+  TObjArray    *fRecPoints;  // array with EMCAL clusters
   
-  AliEMCALGeometry     * fGeom;       //! pointer to geometry for utilities
-  AliEMCALCalibData    * fCalibData ; //! Calibration database if aval
-  AliCaloCalibPedestal * fCaloPed   ; //! Tower status map if aval
+  AliEMCALGeometry     *fGeom;      //!pointer to geometry for utilities
+  AliEMCALCalibData    *fCalibData; //!calibration database if aval
+  AliCaloCalibPedestal *fCaloPed;   //!tower status map if aval
   
-  Float_t fADCchannelECA ;           // width of one ADC channel for EC section (GeV)
-  Float_t fADCpedestalECA ;          // pedestal of ADC for EC section (GeV) 
+  Float_t fADCchannelECA;           // width of one ADC channel for EC section (GeV)
+  Float_t fADCpedestalECA;          // pedestal of ADC for EC section (GeV) 
 
-  Float_t fTimeMin ;                 // Minimum time of physical signal in a cell/digit
-  Float_t fTimeMax ;                 // Maximum time of physical signal in a cell/digit
-  Float_t fTimeCut ;                 // Maximum time difference between the digits inside EMC cluster
+  Float_t fTimeMin;                 // minimum time of physical signal in a cell/digit
+  Float_t fTimeMax;                 // maximum time of physical signal in a cell/digit
+  Float_t fTimeCut;                 // maximum time difference between the digits inside EMC cluster
 
-  Bool_t  fDefaultInit;              //! Says if the task was created by defaut ctor (only parameters are initialized)
-  Bool_t  fToUnfold ;                // To perform unfolding 
-  Int_t   fNumberOfECAClusters ;     // number of clusters found in EC section
+  Bool_t  fDefaultInit;             //!says if the task was created by defaut ctor (only parameters are initialized)
+  Bool_t  fToUnfold;                // says if unfolding should be performed 
+  Int_t   fNumberOfECAClusters;     // number of clusters found in EC section
   
-  Float_t fECAClusteringThreshold ;  // minimum energy to seed a EC digit in a cluster
-  Float_t fECALocMaxCut ;            // minimum energy difference to distinguish local maxima in a cluster
-  Float_t fECAW0 ;                   // logarithmic weight for the cluster center of gravity calculation
-  Float_t fMinECut;                  // Minimum energy for a digit to be a member of a cluster
+  Float_t fECAClusteringThreshold;  // minimum energy to seed a EC digit in a cluster
+  Float_t fECALocMaxCut;            // minimum energy difference to distinguish local maxima in a cluster
+  Float_t fECAW0;                   // logarithmic weight for the cluster center of gravity calculation
+  Float_t fMinECut;                 // minimum energy for a digit to be a member of a cluster
   
-  AliEMCALUnfolding * fClusterUnfolding ; //! pointer to unfolding object
-  Double_t fSSPars[8];// Shower shape parameters 
-  Double_t fPar5[3];  // Shower shape parameter 5
-  Double_t fPar6[3];  // Shower shape parameter 6
+  AliEMCALUnfolding *fClusterUnfolding; //!pointer to unfolding object
+  Double_t fSSPars[8];                  // shower shape parameters 
+  Double_t fPar5[3];                    // shower shape parameter 5
+  Double_t fPar6[3];                    // shower shape parameter 6
 
-private:
-  AliEMCALClusterizer(const AliEMCALClusterizer &); //copy ctor
+ private:
+  AliEMCALClusterizer(const AliEMCALClusterizer &);
   AliEMCALClusterizer & operator = (const AliEMCALClusterizer &);
   
-  
-  
-  ClassDef(AliEMCALClusterizer,4)  // Clusterization algorithm class 
-} ;
-
+  ClassDef(AliEMCALClusterizer,5)  // Clusterization algorithm class 
+};
 #endif // AliEMCALCLUSTERIZER_H