Fixed implimentation of ClusterSelection to be compilable.
authorpbatzing <pbatzing@cern.ch>
Tue, 11 Feb 2014 12:41:02 +0000 (13:41 +0100)
committerhqvigsta <henrik.qvigstad@cern.ch>
Thu, 13 Feb 2014 12:19:12 +0000 (13:19 +0100)
Signed-off-by: hqvigsta <henrik.qvigstad@cern.ch>

PWGGA/PHOSTasks/ClusterSelection/AliPHOSClusterSelection.cxx
PWGGA/PHOSTasks/ClusterSelection/AliPHOSClusterSelection.h
PWGGA/PHOSTasks/ClusterSelection/AliPHOSClusterSelectionTask.cxx
PWGGA/PHOSTasks/ClusterSelection/AliPHOSClusterSelectionTask.h

index 50447b5..5f82113 100644 (file)
@@ -38,7 +38,7 @@ AliPHOSClusterSelection::AliPHOSClusterSelection()
   : fMinChargedParticleTrackDistance(-1.), 
     fNotUnfolded(false),
     fMaxDispR2(-1.),
-    fCoreRadius(-1.),
+    fIsCore(-1.),
     fMaxTOF(-1.)
 {
   // Defaults to the most lenient selection allowable
@@ -54,11 +54,10 @@ Bool_t AliPHOSClusterSelection::IsSelected(AliVCluster* cluster) const
   return IsSelectedCPV(cluster)
     && IsSelectedUnfolded(cluster)
     && IsSelectedDisp(cluster)
-    && IsSelectedDispCore(cluster)
     && IsSelectedTOF(cluster);
 }
 
-Bool_t IsSelectedCPV(AliVCluster* cluster) const
+Bool_t AliPHOSClusterSelection::IsSelectedCPV(AliVCluster* cluster) const
 {
   if( 0 > fMinChargedParticleTrackDistance )//No selection on CPV
     return true; 
@@ -82,11 +81,11 @@ Bool_t IsSelectedCPV(AliVCluster* cluster) const
       TArrayI * itracks = ESDcluster-> GetTracksMatched() ;
       if(itracks->GetSize()>0){
        Int_t iTr = itracks->At(0);
-       if(iTr>=0 && iTr<fEvent->GetNumberOfTracks()){
-         AliVParticle* track = fEvent->GetTrack(iTr);
+       if(iTr>=0 && iTr<EventESD->GetNumberOfTracks()){
+         AliVParticle* track = EventESD->GetTrack(iTr);
          Double_t pt = track->Pt() ;
          Short_t charge = track->Charge() ;
-         Double_t r=AliPHOSClusterSelection::TestCPV(dx, dz, pt, charge, mf) ;
+         Double_t r = AliPHOSClusterSelection::TestCPV(dx, dz, pt, charge, mf);
          cpvBit=(r>fMinChargedParticleTrackDistance) ;
        }
       }
@@ -101,7 +100,7 @@ Bool_t IsSelectedCPV(AliVCluster* cluster) const
        if ( track ) {
          Double_t pt = track->Pt();
          Short_t charge = track->Charge();
-         Double_t r = AliPHOSClusterSelection::TestCPV(dx, dz, pt, charge, mf) ;
+         Double_t r = AliPHOSClusterSelection::TestCPV(dx, dz, pt, charge, mf);
          cpvBit=(r>fMinChargedParticleTrackDistance) ;
        }
       }
@@ -111,7 +110,7 @@ Bool_t IsSelectedCPV(AliVCluster* cluster) const
 }
 
 
-Bool_t IsSelectedUnfolded(AliVCluster* cluster) const
+Bool_t AliPHOSClusterSelection::IsSelectedUnfolded(AliVCluster* cluster) const
 {
   if(!fNotUnfolded)
     return true;
@@ -121,18 +120,18 @@ Bool_t IsSelectedUnfolded(AliVCluster* cluster) const
   }
 }
 
-Bool_t IsSelectedDisp(AliVCluster* cluster) const
+Bool_t AliPHOSClusterSelection::IsSelectedDisp(AliVCluster* cluster) const
 {
   if(0 > fMaxDispR2)
     return true;
   else{
     Double_t m02 = 0.,m20 = 0.;
-    if(fCoreRadius<0){//No core calculation
+    if(fIsCore<0){//No core calculation
       m02 = cluster->GetM02();
       m20 = cluster->GetM20();
       return AliPHOSClusterSelection::TestLambda(cluster->E(),m20,m02) ;
     }
-    else{//TODO: Core calculation for general R 
+    else{//DispCore
       AliVCaloCells* cells = static_cast<AliVCaloCells*> (AliPHOSClusterSelection::GetCurrentEvent()->GetPHOSCells());//Need the cells
       AliPHOSClusterSelection::EvalCoreLambdas(cluster, cells, m02, m20);
       return AliPHOSClusterSelection::TestLambda(cluster->E(),m20,m02);
@@ -141,7 +140,7 @@ Bool_t IsSelectedDisp(AliVCluster* cluster) const
 
 }
 
-Bool_t IsSelectedTOF(AliVCluster* cluster) const
+Bool_t AliPHOSClusterSelection::IsSelectedTOF(AliVCluster* cluster) const
 {
   if(0 > fMaxTOF)
     return true;
@@ -180,12 +179,11 @@ AliPHOSClusterSelection* AliPHOSClusterSelection::SetMaxDispR2(Float_t maxR2)
   return this;
 }
 
-AliPHOSClusterSelection* AliPHOSClusterSelection::SetCoreRadius(Float_t radius)
+AliPHOSClusterSelection* AliPHOSClusterSelection::SetIsCore(Bool_t isCore)
 {
-  // 'radius' sets the core radius used for the dispersion cut evaluation.
-  // If 'radius' is negative, the whole cluster is used.
+  // 'isCore' sets wether core version of Disp is used. -1 gives no core.
   
-  fCoreRadius = radius;
+  fIsCore = isCore;
   return this;
 }
 
@@ -194,7 +192,7 @@ AliPHOSClusterSelection* AliPHOSClusterSelection::SetMaxTOF(Float_t maxTOF)
   // 'maxTOF' sets the maximum allowed time of flight for the cluster.
   // If 'maxTOF' is negative, all clusters are selected and the selection is "disabled".
   
-  fCoreRadius = radius;
+  fMaxTOF = maxTOF;
   return this;
 }
 
@@ -217,47 +215,42 @@ TString AliPHOSClusterSelection::ToString() const
 
 Float_t AliPHOSClusterSelection::GetMinChargedParticleTrackDistance(const TString& string)
 {
-  //TObjArray * objarray = string.Tokenize("_");
-  TObjString * objstring = string.Tokenize("_")->At(0);
-  Float_t flt= objstring->GetString()->Atof();
-  delete objstring;
+  TString * s =&(static_cast<TObjString*>(string.Tokenize("_")->At(0))->String());
+  Float_t flt= s->Atof();
+  //delete s; //s is defined in the stack, no delete necessary
   return flt;
 }
 
 Bool_t AliPHOSClusterSelection::GetUnfolded(const TString& string)
 {
-  TObjString * objstring = string.Tokenize("_")->At(1);
-  Bool_t bl = objstring->GetString()->Atoi(); 
-  delete objstring;
+  TString * s =&(static_cast<TObjString*>(string.Tokenize("_")->At(1))->String());
+  Bool_t bl = s->Atoi(); 
   return bl;
 }
 
 Float_t AliPHOSClusterSelection::GetMaxDispR2(const TString& string)
 {
-  TObjString * objstring = string.Tokenize("_")->At(2);
-  Float_t flt = objstring->Atof(); 
-  delete objstring;
+  TString * s =&(static_cast<TObjString*>(string.Tokenize("_")->At(2))->String());
+  Float_t flt = s->Atof(); 
   return flt;
 }
 
-Float_t AliPHOSClusterSelection::GetCoreRadius(const TString& string)
+Bool_t AliPHOSClusterSelection::GetIsCore(const TString& string)
 {
-  TObjArray * objstring = string.Tokenize("_")->At(3);
-  Float_t flt = objstring->Atof(); 
-  delete objstring;
-  return flt;
+  TString * s =&(static_cast<TObjString*>(string.Tokenize("_")->At(3))->String());
+  Bool_t blt = s->Atoi(); 
+  return blt;
 }
 
 Float_t AliPHOSClusterSelection::GetMaxTOF(const TString& string)
 {
-  TObjArray * objstring = string.Tokenize("_")->At(4);
-  Float_t flt = objstring->Atof(); 
-  delete objstring;
+  TString * s =&(static_cast<TObjString*>(string.Tokenize("_")->At(4))->String());
+  Float_t flt = s->Atof(); 
   return flt;
 }
 
 
-Double_t AliPHOSClusterSelection::TestCPV(Double_t dx, Double_t dz, Double_t pt, Int_t charge, Double_t mf){
+Double_t AliPHOSClusterSelection::TestCPV(Double_t dx, Double_t dz, Double_t pt, Int_t charge, Double_t mf) const {
   //Parameterization of LHC10h period
   //_true if neutral_
   //Copied from Pi0Flow task
@@ -289,13 +282,13 @@ Double_t AliPHOSClusterSelection::TestCPV(Double_t dx, Double_t dz, Double_t pt,
 }
 
 //____________________________________________________________________________
-void  AliPHOSClusterSelection::EvalCoreLambdas(AliVCluster * clu, AliVCaloCells * cells,Double_t &m02, Double_t &m20){ 
+void  AliPHOSClusterSelection::EvalCoreLambdas(AliVCluster  * clu, AliVCaloCells * cells,Double_t &m02, Double_t &m20) const
+{ 
   //calculate dispecrsion of the cluster in the circle with radius distanceCut around the maximum
   //Copied from pi0flowtask
-
-  const Double_t rCut=fCoreRadius;//TODO: This now works only for R=4.5 as the dispersion cut is not tuned for other values  
+  Int_t fRunNumber;
   const Double32_t * elist = clu->GetCellsAmplitudeFraction() ;  
-// Calculates the center of gravity in the local PHOS-module coordinates
+  // Calculates the center of gravity in the local PHOS-module coordinates
   Float_t wtot = 0;
   const Int_t mulDigit=clu->GetNCells() ;
   Double_t xc[mulDigit] ;
@@ -310,85 +303,95 @@ void  AliPHOSClusterSelection::EvalCoreLambdas(AliVCluster * clu, AliVCaloCells
     Float_t zi=0. ;
     Int_t absId = clu->GetCellAbsId(iDigit) ;
 
+
+    AliESDEvent* EventESD = dynamic_cast<AliESDEvent*> (AliPHOSClusterSelection::GetCurrentEvent());//dynamic cast to test for ESD or AOD
+
+    AliAODEvent* EventAOD = dynamic_cast<AliAODEvent*> (AliPHOSClusterSelection::GetCurrentEvent());
+    if(EventESD)
+      fRunNumber = EventESD->GetRunNumber() ;
+    if(EventAOD)
+      fRunNumber = EventESD->GetRunNumber() ;
+
     AliOADBContainer geomContainer("phosGeo");//Initialize Geometry
     geomContainer.InitFromFile("$ALICE_ROOT/OADB/PHOS/PHOSGeometry.root","PHOSRotationMatrixes");
     TObjArray *matrixes = (TObjArray*)geomContainer.GetObject(fRunNumber,"PHOSRotationMatrixes");
     AliPHOSGeometry * fPHOSGeo =  AliPHOSGeometry::GetInstance("IHEP") ;
     for(Int_t mod=0; mod<5; mod++) {
       if(!matrixes->At(mod)) {
-       if( fDebug )
-         AliInfo(Form("No PHOS Matrix for mod:%d, geo=%p\n", mod, fPHOSGeo));
+       AliInfo(Form("No PHOS Matrix for mod:%d, geo=%p\n", mod, fPHOSGeo));
        continue;
       }
 
 
-    fPHOSGeo->AbsToRelNumbering(absId, relid) ;
-    fPHOSGeo->RelPosInModule(relid, xi, zi);
-    xc[iDigit]=xi ;
-    zc[iDigit]=zi ;
-    Double_t ei = elist[iDigit]*cells->GetCellAmplitude(absId) ;
-    wi[iDigit]=0. ;
-    if (clu->E()>0 && ei>0) {
-      wi[iDigit] = TMath::Max( 0., logWeight + TMath::Log( ei / clu->E() ) ) ;
-      Double_t w=wi[iDigit];
-      x    += xc[iDigit] * w ;
-      z    += zc[iDigit] * w ;
-      wtot += w ;
+      fPHOSGeo->AbsToRelNumbering(absId, relid) ;
+      fPHOSGeo->RelPosInModule(relid, xi, zi);
+      xc[iDigit]=xi ;
+      zc[iDigit]=zi ;
+      Double_t ei = elist[iDigit]*cells->GetCellAmplitude(absId) ;
+      wi[iDigit]=0. ;
+      if (clu->E()>0 && ei>0) {
+       wi[iDigit] = TMath::Max( 0., logWeight + TMath::Log( ei / clu->E() ) ) ;
+       Double_t w=wi[iDigit];
+       x    += xc[iDigit] * w ;
+       z    += zc[iDigit] * w ;
+       wtot += w ;
+      }
+    }
+    if (wtot>0) {
+      x /= wtot ;
+      z /= wtot ;
     }
-  }
-  if (wtot>0) {
-    x /= wtot ;
-    z /= wtot ;
-  }
      
-  wtot = 0. ;
-  Double_t dxx  = 0.;
-  Double_t dzz  = 0.;
-  Double_t dxz  = 0.;
-  Double_t xCut = 0. ;
-  Double_t zCut = 0. ;
-  for(Int_t iDigit=0; iDigit<mulDigit; iDigit++) {
-    Double_t w=wi[iDigit];
-    if (w>0.) {
-        Double_t xi= xc[iDigit] ;
-        Double_t zi= zc[iDigit] ;
-       if((xi-x)*(xi-x)+(zi-z)*(zi-z) < rCut*rCut){
-          xCut += w * xi ;
-          zCut += w * zi ; 
-          dxx  += w * xi * xi ;
-          dzz  += w * zi * zi ;
-          dxz  += w * xi * zi ; 
+    wtot = 0. ;
+    Double_t dxx  = 0.;
+    Double_t dzz  = 0.;
+    Double_t dxz  = 0.;
+    Double_t xCut = 0. ;
+    Double_t zCut = 0. ;
+    for(Int_t iDigit1=0; iDigit1<mulDigit; iDigit1++) {
+      Double_t w=wi[iDigit1];
+      if (w>0.) {
+        Double_t xi1= xc[iDigit1] ;
+        Double_t zi1= zc[iDigit1] ;
+       if((xi1-x)*(xi1-x)+(zi1-z)*(zi1-z) < 4.5*4.5){
+          xCut += w * xi1 ;
+          zCut += w * zi1 ; 
+          dxx  += w * xi1 * xi1 ;
+          dzz  += w * zi1 * zi1 ;
+          dxz  += w * xi1 * zi1 ; 
           wtot += w ;
        }
-    }
+      }
     
-  }
-  if (wtot>0) {
-    xCut/= wtot ;
-    zCut/= wtot ;
-    dxx /= wtot ;
-    dzz /= wtot ;
-    dxz /= wtot ;
-    dxx -= xCut * xCut ;
-    dzz -= zCut * zCut ;
-    dxz -= xCut * zCut ;
-
-    m02 =  0.5 * (dxx + dzz) + TMath::Sqrt( 0.25 * (dxx - dzz) * (dxx - dzz) + dxz * dxz )  ;
-    m20 =  0.5 * (dxx + dzz) - TMath::Sqrt( 0.25 * (dxx - dzz) * (dxx - dzz) + dxz * dxz )  ;
-  }
-  else {
-    m20=m02=0.;
-  }
+    }
+    if (wtot>0) {
+      xCut/= wtot ;
+      zCut/= wtot ;
+      dxx /= wtot ;
+      dzz /= wtot ;
+      dxz /= wtot ;
+      dxx -= xCut * xCut ;
+      dzz -= zCut * zCut ;
+      dxz -= xCut * zCut ;
+
+      m02 =  0.5 * (dxx + dzz) + TMath::Sqrt( 0.25 * (dxx - dzz) * (dxx - dzz) + dxz * dxz )  ;
+      m20 =  0.5 * (dxx + dzz) - TMath::Sqrt( 0.25 * (dxx - dzz) * (dxx - dzz) + dxz * dxz )  ;
+    }
+    else {
+      m20=m02=0.;
+    }
 
+  }
 }
 
 //_____________________________________________________________________________
-Bool_t AliAnalysisTaskPi0Flow::TestLambda(Double_t pt,Double_t l1,Double_t l2){
+Bool_t AliPHOSClusterSelection::TestLambda(Double_t pt,Double_t l1,Double_t l2) const 
+{
   //Evaluates if lambdas correspond to photon cluster
   //Tuned using pp data 
   //copied from Pi0FlowTask
   Double_t l2Mean, l1Mean, l2Sigma, l1Sigma, c, R2;
-  if(fCoreRadius<0){
+  if(fIsCore<0){
     l2Mean  = 1.53126+9.50835e+06/(1.+1.08728e+07*pt+1.73420e+06*pt*pt) ;
     l1Mean  = 1.12365+0.123770*TMath::Exp(-pt*0.246551)+5.30000e-03*pt ;
     l2Sigma = 6.48260e-02+7.60261e+10/(1.+1.53012e+11*pt+5.01265e+05*pt*pt)+9.00000e-03*pt;
@@ -409,7 +412,7 @@ Bool_t AliAnalysisTaskPi0Flow::TestLambda(Double_t pt,Double_t l1,Double_t l2){
       0.5*(l2-l2Mean)*(l2-l2Mean)/l2Sigma/l2Sigma +
       0.5*c*(l1-l1Mean)*(l2-l2Mean)/l1Sigma/l2Sigma ;
   }
-  return (R2<fMaxDispR2*MaxDispR2);//TODO: Check if this should be 2. order
+  return (R2<fMaxDispR2*fMaxDispR2);//TODO: Check if this should be 2. order
 }
 
 
@@ -421,7 +424,7 @@ AliVEvent* AliPHOSClusterSelection::GetCurrentEvent() const
   
   AliAnalysisManager* analysisManager = dynamic_cast<AliAnalysisManager*>(AliAnalysisManager::GetAnalysisManager());
   AliInputEventHandler* inputHandler = dynamic_cast<AliInputEventHandler*>(analysisManager->GetInputEventHandler());
-  AliMultiInputEventHandler *multiInputHandler = dynamic_cast<AliMultiInputEventHandler *>(fInputHandler);
+  AliMultiInputEventHandler *multiInputHandler = dynamic_cast<AliMultiInputEventHandler *>(inputHandler);
   if (multiInputHandler)
     inputHandler = dynamic_cast<AliInputEventHandler *>(multiInputHandler->GetFirstInputEventHandler());
   
index 93d89c7..fee2e04 100644 (file)
 
 
 class AliVCluster;
+class AliVCaloCells;
+
 class AliESDCaloCluster;
 class AliAODCaloCluster;
 class AliVEvent;
 
 #include "TObject.h"
 
-class AliPHOSClusterSelection : TObject {
+class AliPHOSClusterSelection : public TObject {
  public:
   AliPHOSClusterSelection();
   virtual ~AliPHOSClusterSelection();
@@ -34,31 +36,31 @@ class AliPHOSClusterSelection : TObject {
   AliPHOSClusterSelection* SetMinChargedParticleTrackDistance(Float_t distance);
   AliPHOSClusterSelection* SetNotUnfolded(Bool_t notUnfolded);
   AliPHOSClusterSelection* SetMaxDispR2(Float_t maxR2);
-  AliPHOSClusterSelection* SetCoreRadius(Float_t radius);
+  AliPHOSClusterSelection* SetIsCore(Bool_t isCore);
   AliPHOSClusterSelection* SetMaxTOF(Float_t maxTOF);
   
-  AliPHOSClusterSelection* SetMinSelection();
+  //AliPHOSClusterSelection* SetMinSelection();
 
   virtual TString ToString() const;
-  static Float_t  GetMinChargedParticleTrackDistance(const TString string);
-  static Bool_t   GetUnfolded(const TString string);
-  static Float_t  GetMaxDispR2(const TString string);
-  static Float_t  GetCoreRadius(const TString string);
-  static Float_t  GetMaxTOF(const TString string);
+  static Float_t  GetMinChargedParticleTrackDistance(const TString& string);
+  static Bool_t   GetUnfolded(const TString& string);
+  static Float_t  GetMaxDispR2(const TString& string);
+  static Bool_t  GetIsCore(const TString& string);
+  static Float_t  GetMaxTOF(const TString& string);
 
 
  protected:
   AliPHOSClusterSelection(const AliPHOSClusterSelection&); // not implemented
   AliPHOSClusterSelection& operator=(const AliPHOSClusterSelection&); // not implemented
   
-  Double_t TestCPV(Double_t dx, Double_t dz, Double_t pt, Int_t charge, Double_t mf);//Copied from Pi0Flow task
-  void  AliPHOSClusterSelection::EvalCoreLambdas(AliVCluster * clu, AliVCaloCells * cells,Double_t &m02, Double_t &m20);//Copied from Pi0Flow task
-  Bool_t AliAnalysisTaskPi0Flow::TestLambda(Double_t pt,Double_t l1,Double_t l2);//Copied from Pi0FlowTask
+  Double_t TestCPV(Double_t dx, Double_t dz, Double_t pt, Int_t charge, Double_t mf) const;//Copied from Pi0Flow task
+  void  EvalCoreLambdas(AliVCluster  *  clu, AliVCaloCells * cells,Double_t &m02, Double_t &m20) const;//Copied from Pi0Flow task
+  Bool_t TestLambda(Double_t pt,Double_t l1,Double_t l2) const;//Copied from Pi0FlowTask
   // Selection Parameters
   Float_t fMinChargedParticleTrackDistance; // CPV, Charged Particle Veto
   Bool_t fNotUnfolded; // if true, rejects Unfolded Clusters
   Float_t fMaxDispR2; // dispersion cut
-  Float_t fCoreRadius; // Core radius
+  Float_t fIsCore; // If true, core radius disp is calculated
   Float_t fMaxTOF; // TOF cut
 
   AliVEvent* GetCurrentEvent() const;
index ef082b4..11e407b 100644 (file)
 
 #include "TBits.h"
 #include "TRefArray.h"
+#include "TMap.h"
+#include "AliAnalysisManager.h"
 
 #include "AliVCluster.h"
+#include "AliPHOSClusterSelection.h"
 
 // Analysis task to fill histograms with PHOS ESD or AOD clusters and cells
 // Authors : Henrik Qvigstad
@@ -26,7 +29,7 @@
 #include "AliPHOSClusterSelectionTask.h"
 ClassImp(AliPHOSClusterSelectionTask);
 
-AliPHOSClusterSelectionTask::AliPHOSClusterSelectionTask(const char* name = "AliPHOSClusterSelectionTask")
+AliPHOSClusterSelectionTask::AliPHOSClusterSelectionTask(const char* name)
   : AliAnalysisTaskSE(name),
     fClusters(0x0),
     fSelectionMap(0x0)
@@ -56,7 +59,8 @@ void AliPHOSClusterSelectionTask::UserExec(Option_t *option)
 
   // Remove Clusters
   for(int index = 0; index < fClusters->GetEntriesFast(); ++index) { // TODO: check if array is indexed from 0
-    AliVCluster* cluster = (AliVCluster*) fClusters->At(iClu); // TODO: check that fClusters is always compressed
+    AliVCluster* cluster = (AliVCluster*) fClusters->At(index); // TODO: check that fClusters is always compressed
+
 
     if( cluster->E() < kMinClusterEnergy // Low Energy Clusters
        || cluster->GetDistanceToBadChannel() < kMinBCDistance // to close to Bad Channel
@@ -66,8 +70,8 @@ void AliPHOSClusterSelectionTask::UserExec(Option_t *option)
       fClusters->RemoveAt(index);
   }
 
-  // Compact array after removel of clusters
-  fClusters->Compact();
+  // Remove empty slots from array after removal of clusters
+  fClusters->Compress();
 
   // initialize fSelectionMap
   if( fSelectionMap )
@@ -76,6 +80,7 @@ void AliPHOSClusterSelectionTask::UserExec(Option_t *option)
     fSelectionMap = new TMap;
     fSelectionMap->SetOwnerValue();
   }
+
 }
 
 TRefArray* AliPHOSClusterSelectionTask::GetPHOSClusters() const
@@ -86,7 +91,7 @@ TRefArray* AliPHOSClusterSelectionTask::GetPHOSClusters() const
   return fClusters;
 }
 
-TRefArray* AliPHOSClusterSelectionTask::GetPHOSClustersSelected(const AliPHOSClusterSelection* selection, bool useMap, bool addMap )
+TRefArray* AliPHOSClusterSelectionTask::GetPHOSClustersSelected( AliPHOSClusterSelection* selection, bool useMap, bool addMap )
 {
   // useMap - Use The Resulting Array of previous selection (stored in map
   // addMap - Add This Selection to the 'map' for use in future calls of this function.
@@ -94,9 +99,10 @@ TRefArray* AliPHOSClusterSelectionTask::GetPHOSClustersSelected(const AliPHOSClu
   if( !fClusters  || !fSelectionMap )
     AliFatal("fCluster not initialized, do not run this function before ::UserExec");
 
+
   if( useMap ) {
     // Check if Selection is already done
-    TRefArray* array = dynamic_selection<TRefArray*> ( fSelectionMap->GetValue(selection) );
+    TRefArray* array = dynamic_cast<TRefArray*> ( fSelectionMap->GetValue(selection) );
     if( array )
       return array;
   }
@@ -105,6 +111,8 @@ TRefArray* AliPHOSClusterSelectionTask::GetPHOSClustersSelected(const AliPHOSClu
   TRefArray* newArray = new TRefArray( * DeterminePHOSClustersSelected(selection) );
   if(addMap)
     fSelectionMap->Add(selection, newArray); // key, value
+
+  return newArray;
 }
 
 TRefArray* AliPHOSClusterSelectionTask::DeterminePHOSClustersSelected(const AliPHOSClusterSelection* selection)
@@ -137,14 +145,14 @@ AliPHOSClusterSelectionTask* AliPHOSClusterSelectionTask::GetTask(const char* na
 
   AliAnalysisManager* analysisManager = dynamic_cast<AliAnalysisManager*>(AliAnalysisManager::GetAnalysisManager());
   if( !analysisManager )
-    AliError("No AnalysisManager");
+    Printf("ERROR: No AnalysisManager");
   AliAnalysisTask* task = analysisManager->GetTask(name);
   if( !task )
-    AliError( Form("No task with name: %s", name) );
+    Printf( Form("ERROR: No task with name: %s", name) );
 
-  AliPHOSClusterSelectionTask* sTask = dynamic_cast<AliAnalysisTask*>(task);
+  AliPHOSClusterSelectionTask* sTask = dynamic_cast<AliPHOSClusterSelectionTask*>(task);
   if( !sTask)
-    AliError( Form("No AliPHOSClusterSelectionTask with name: %s", name) );
+    Printf( Form("ERROR:: No AliPHOSClusterSelectionTask with name: %s", name) );
 
   return sTask;
 }
index caec355..16910cc 100644 (file)
 /* $Id$ */
 
 class TRefArray;
+class TMap;
 
 class AliVCluster;
 
+class AliPHOSClusterSelection;
+
 #include "AliAnalysisTaskSE.h"
+#include "AliLog.h"
+
 
-class AliPHOSClusterSelectionTask : AliAnalysisTaskSE {
+class AliPHOSClusterSelectionTask : public AliAnalysisTaskSE {
  public:
   AliPHOSClusterSelectionTask(const char* name = "AliPHOSClusterSelectionTask");
   virtual ~AliPHOSClusterSelectionTask();
@@ -28,7 +33,7 @@ class AliPHOSClusterSelectionTask : AliAnalysisTaskSE {
   /* virtual void   Terminate(Option_t *); */
 
   TRefArray* GetPHOSClusters() const;
-  TRefArray* GetPHOSClustersSelected(const AliPHOSClusterSelection* selection, bool useMap=true, bool addMap=true);
+  TRefArray* GetPHOSClustersSelected( AliPHOSClusterSelection* selection, bool useMap=true, bool addMap=true);
 
   static AliPHOSClusterSelectionTask* GetTask(const char* name = "AliPHOSClusterSelectionTask");
 
@@ -42,10 +47,10 @@ class AliPHOSClusterSelectionTask : AliAnalysisTaskSE {
   TMap* fSelectionMap; // maps: ClusterSelection -> RefArray of Clusters
 
   // cluster cut variables:
-  static const Double_t kMinClusterEnergy;
-  static const Double_t kMinBCDistance;  //distance to nearest bad channel
-  static const Int_t    kMinNCells;
-  static const Double_t kMinM02;
+  static const Double_t kMinClusterEnergy = 0.3;
+  static const Double_t kMinBCDistance = 2.5;  //distance to nearest bad channel
+  static const Int_t    kMinNCells = 3 ;
+  static const Double_t kMinM02 = 0.2;
   
   ClassDef(AliPHOSClusterSelectionTask, 1);
 };