add sub-cluster min energy cut
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 14 Nov 2013 13:49:09 +0000 (13:49 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 14 Nov 2013 13:49:09 +0000 (13:49 +0000)
PWG/CaloTrackCorrBase/AliCaloPID.cxx
PWG/CaloTrackCorrBase/AliCaloPID.h
PWGGA/CaloTrackCorrelations/AliAnaInsideClusterInvariantMass.cxx
PWGGA/CaloTrackCorrelations/AliAnaInsideClusterInvariantMass.h

index a1d516d..22828eb 100755 (executable)
@@ -323,6 +323,11 @@ void AliCaloPID::InitParameters()
   fSplitEFracMin[1]   = 0.0 ; // 0.96
   fSplitEFracMin[2]   = 0.0 ; // 0.7
 
+  fSubClusterEMin[0]  = 0.0; // 3 GeV
+  fSubClusterEMin[1]  = 0.0; // 1 GeV
+  fSubClusterEMin[2]  = 0.0; // 1 GeV
+  
+  
   fSplitWidthSigma = 3. ;
   
 }
@@ -826,9 +831,21 @@ Int_t AliCaloPID::GetIdentifiedParticleTypeFromClusterSplitting(AliVCluster* clu
   if(nMax < 3)  splitFracCut = fSplitEFracMin[nMax-1];
   else          splitFracCut = fSplitEFracMin[2];
   if((e1+e2)/eClus < splitFracCut) return kNeutralUnknown ;
-  
+
   if(fDebug > 0) printf("\t pass Split E frac cut\n");
-    
+  
+  // Consider sub-clusters with minimum energy
+  Float_t minECut = fSubClusterEMin[2];
+  if     (nMax == 2)  minECut = fSubClusterEMin[1];
+  else if(nMax == 1)  minECut = fSubClusterEMin[0];
+  if(e1 < minECut || e2 < minECut)
+  {
+    //printf("Reject: e1 %2.1f, e2 %2.1f, cut %2.1f\n",e1,e2,minECut);
+    return kNeutralUnknown ;
+  }
+
+  if(fDebug > 0) printf("\t pass min sub-cluster E cut\n");
+  
   // Asymmetry of cluster
   Float_t asy =-10;
   if(e1+e2 > 0) asy = (e1-e2) / (e1+e2);
index 5126a03..2447c17 100755 (executable)
@@ -227,8 +227,11 @@ class AliCaloPID : public TObject {
   void    SetClusterSplittingMinNCells(Int_t c) { fSplitMinNCells = c         ; }
   Int_t   GetClusterSplittingMinNCells() const  { return fSplitMinNCells      ; }
   
-  void    SetSplitEnergyFractionMinimum(Int_t i, Float_t min){ if (i < 3 && i >=0 ) fSplitEFracMin[i]  = min   ; }
-  Float_t GetSplitEnergyFractionMinimum(Int_t i) const       { if( i < 3 && i >=0 ) return fSplitEFracMin[i]   ;  else return 0 ; }
+  void    SetSplitEnergyFractionMinimum(Int_t i, Float_t min){ if (i < 3 && i >=0 ) fSplitEFracMin[i]  = min ; }
+  Float_t GetSplitEnergyFractionMinimum(Int_t i) const       { if( i < 3 && i >=0 ) return fSplitEFracMin[i] ;  else return 0 ; }
+
+  void    SetSubClusterEnergyMinimum   (Int_t i, Float_t min){ if (i < 3 && i >=0 ) fSubClusterEMin[i] = min ; }
+  Float_t GetSubClusterEnergyMinimum   (Int_t i) const       { if( i < 3 && i >=0 ) return fSubClusterEMin[i];  else return 0 ; }
   
   Float_t GetPi0MinMass()                const { return fMassPi0Min           ; } // Simple cut case
   Float_t GetEtaMinMass()                const { return fMassEtaMin           ; } // Simple cut case
@@ -323,13 +326,14 @@ private:
   Float_t   fAsyMinParam[2][4] ;                // 3 param for fit on asymmetry minimum, for 2 cases, NLM=1 and NLM>=2
   Float_t   fSplitEFracMin[3]  ;                // Do not use clusters with too large energy in cluster compared
                                                 // to energy in splitted clusters, depeding on NLM
+  Float_t   fSubClusterEMin[3]  ;               // Do not use sub-clusters with too low energy depeding on NLM
   Float_t   fSplitWidthSigma;                   // Cut on mass+-width*fSplitWidthSigma
   Float_t   fMassShiftHighECell;                // Shift cuts 5 MeV for Ecell > 150 MeV, default Ecell > 50 MeV
 
   AliCaloPID & operator = (const AliCaloPID & cpid) ; // cpy assignment
   AliCaloPID(              const AliCaloPID & cpid) ; // cpy ctor
   
-  ClassDef(AliCaloPID,20)
+  ClassDef(AliCaloPID,21)
   
 } ;
 
index c35a159..d37cd99 100755 (executable)
@@ -65,6 +65,9 @@ AliAnaInsideClusterInvariantMass::AliAnaInsideClusterInvariantMass() :
   fhM02AsyCutNLocMax1(0),                    fhM02AsyCutNLocMax2(0),                    fhM02AsyCutNLocMaxN(0),
   fhMassM02CutNLocMax1(0),                   fhMassM02CutNLocMax2(0),                   fhMassM02CutNLocMaxN(0),
   fhAsymM02CutNLocMax1(0),                   fhAsymM02CutNLocMax2(0),                   fhAsymM02CutNLocMaxN(0),
+  fhMassEnCutNLocMax1(0),                    fhMassEnCutNLocMax2(0),                    fhMassEnCutNLocMaxN(0),
+  fhM02EnCutNLocMax1(0),                     fhM02EnCutNLocMax2(0),                     fhM02EnCutNLocMaxN(0),
+  fhAsymEnCutNLocMax1(0),                    fhAsymEnCutNLocMax2(0),                    fhAsymEnCutNLocMaxN(0),
   fhMassSplitECutNLocMax1(0),                fhMassSplitECutNLocMax2(0),                fhMassSplitECutNLocMaxN(0),
   fhMCGenFracAfterCutsNLocMax1MCPi0(0),      fhMCGenFracAfterCutsNLocMax2MCPi0(0),      fhMCGenFracAfterCutsNLocMaxNMCPi0(0),
   fhMCGenSplitEFracAfterCutsNLocMax1MCPi0(0),fhMCGenSplitEFracAfterCutsNLocMax2MCPi0(0),fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0(0),
@@ -1777,7 +1780,7 @@ void AliAnaInsideClusterInvariantMass::FillHistograms2(const Float_t en,     con
   Bool_t m02On = GetCaloPID()->IsSplitShowerShapeCutOn();
   Bool_t asyOn = GetCaloPID()->IsSplitAsymmetryCutOn();
   
-  //printf("splitFracMin %f, val %f, m02ok %d, asyok %d\n",splitFracMin,splitFrac,m02OK,asyOK);
+  //printf("splitFracMin %f, val %f, m02ok %d, asyok %d, m02On %d, asyOn %d\n",splitFracMin,splitFrac,m02OK,asyOK,m02On,asyOn);
   
   if(m02On && m02OK)
   {
@@ -1812,6 +1815,14 @@ void AliAnaInsideClusterInvariantMass::FillHistograms2(const Float_t en,     con
       if(splitFrac > splitFracMin && fhMassSplitECutNLocMax1) fhMassSplitECutNLocMax1->Fill(en,mass );
     } 
     
+    Float_t ensubcut = GetCaloPID()->GetSubClusterEnergyMinimum(0);
+    if(!matched && ensubcut > 0.1 && ensubcut < e1 && ensubcut < e2 )
+    {
+      fhMassEnCutNLocMax1->Fill(en,mass );
+      fhM02EnCutNLocMax1 ->Fill(en,l0   );
+      fhAsymEnCutNLocMax1->Fill(en,asym );
+    }
+    
     if((m02OK && asyOK) && (asyOn || m02On))
     {
       fhSplitEFractionAfterCutsNLocMax1[0][matched]->Fill(en,splitFrac);
@@ -1824,7 +1835,7 @@ void AliAnaInsideClusterInvariantMass::FillHistograms2(const Float_t en,     con
       }
     }
   }
-  else if(nMax==2)
+  else if( nMax == 2 )
   {
     fhMassNLocMax2[0][matched]->Fill(en,mass );
     fhAsymNLocMax2[0][matched]->Fill(en,asym );
@@ -1844,6 +1855,14 @@ void AliAnaInsideClusterInvariantMass::FillHistograms2(const Float_t en,     con
       if(splitFrac > splitFracMin && fhMassSplitECutNLocMax2) fhMassSplitECutNLocMax2->Fill(en,mass );
     } 
     
+    Float_t ensubcut = GetCaloPID()->GetSubClusterEnergyMinimum(1);
+    if(!matched && ensubcut > 0.1 && ensubcut < e1 && ensubcut < e2 )
+    {
+      fhMassEnCutNLocMax2->Fill(en,mass );
+      fhM02EnCutNLocMax2 ->Fill(en,l0   );
+      fhAsymEnCutNLocMax2->Fill(en,asym );
+    }
+    
     if((m02OK && asyOK) && (asyOn || m02On))
     {
       fhSplitEFractionAfterCutsNLocMax2[0][matched]->Fill(en,splitFrac);
@@ -1856,7 +1875,7 @@ void AliAnaInsideClusterInvariantMass::FillHistograms2(const Float_t en,     con
       }
     }
   }
-  else if(nMax >2)
+  else if( nMax > 2 )
   {
     fhMassNLocMaxN[0][matched]->Fill(en,mass);
     fhAsymNLocMaxN[0][matched]->Fill(en,asym);
@@ -1876,6 +1895,14 @@ void AliAnaInsideClusterInvariantMass::FillHistograms2(const Float_t en,     con
       if(splitFrac > splitFracMin && fhMassSplitECutNLocMaxN) fhMassSplitECutNLocMaxN->Fill(en,mass );
     } 
     
+    Float_t ensubcut = GetCaloPID()->GetSubClusterEnergyMinimum(2);
+    if(!matched && ensubcut > 0.1 && ensubcut < e1 && ensubcut < e2 )
+    {
+      fhMassEnCutNLocMaxN->Fill(en,mass );
+      fhM02EnCutNLocMaxN ->Fill(en,l0   );
+      fhAsymEnCutNLocMaxN->Fill(en,asym );
+    }
+    
     if((m02OK && asyOK) && (asyOn || m02On))
     {
       fhSplitEFractionAfterCutsNLocMaxN[0][matched]->Fill(en,splitFrac);
@@ -3124,19 +3151,19 @@ TList * AliAnaInsideClusterInvariantMass::GetCreateOutputObjects()
         
         if(asyOn)
         {
-          fhMassAsyCutNLocMax1  = new TH2F("hMassAsyCutNLocMax1","Invariant mass of splitted cluster with NLM=1 vs E, M02 cut, no TM",
+          fhMassAsyCutNLocMax1  = new TH2F("hMassAsyCutNLocMax1","Invariant mass of splitted cluster with NLM=1 vs E, Asy cut, no TM",
                                            nptbins,ptmin,ptmax,mbins,mmin,mmax);
           fhMassAsyCutNLocMax1->SetYTitle("M (GeV/c^{2})");
           fhMassAsyCutNLocMax1->SetXTitle("E (GeV)");
           outputContainer->Add(fhMassAsyCutNLocMax1) ;
           
-          fhMassAsyCutNLocMax2  = new TH2F("hMassAsyCutNLocMax2","Invariant mass of splitted cluster with NLM=2 vs E, M02 cut, no TM",
+          fhMassAsyCutNLocMax2  = new TH2F("hMassAsyCutNLocMax2","Invariant mass of splitted cluster with NLM=2 vs E, Asy cut, no TM",
                                            nptbins,ptmin,ptmax,mbins,mmin,mmax);
           fhMassAsyCutNLocMax2->SetYTitle("M (GeV/c^{2})");
           fhMassAsyCutNLocMax2->SetXTitle("E (GeV)");
           outputContainer->Add(fhMassAsyCutNLocMax2) ;
           
-          fhMassAsyCutNLocMaxN  = new TH2F("hMassAsyCutNLocMaxN","Invariant mass of splitted cluster with NLM>2 vs E, M02 cut, no TM",
+          fhMassAsyCutNLocMaxN  = new TH2F("hMassAsyCutNLocMaxN","Invariant mass of splitted cluster with NLM>2 vs E, Asy cut, no TM",
                                            nptbins,ptmin,ptmax,mbins,mmin,mmax);
           fhMassAsyCutNLocMaxN->SetYTitle("M (GeV/c^{2})");
           fhMassAsyCutNLocMaxN->SetXTitle("E (GeV)");
@@ -3159,7 +3186,124 @@ TList * AliAnaInsideClusterInvariantMass::GetCreateOutputObjects()
           fhM02AsyCutNLocMaxN->SetYTitle("#lambda_{0}^{2}");
           fhM02AsyCutNLocMaxN->SetXTitle("E (GeV)");
           outputContainer->Add(fhM02AsyCutNLocMaxN) ;
-      }
+        }
+        
+        {
+          if(m02On)
+          {
+            fhMassM02CutNLocMax1  = new TH2F("hMassM02CutNLocMax1","Invariant mass of splitted cluster with NLM=1 vs E, M02 cut, no TM",
+                                             nptbins,ptmin,ptmax,mbins,mmin,mmax);
+            fhMassM02CutNLocMax1->SetYTitle("M (GeV/c^{2})");
+            fhMassM02CutNLocMax1->SetXTitle("E (GeV)");
+            outputContainer->Add(fhMassM02CutNLocMax1) ;
+            
+            fhMassM02CutNLocMax2  = new TH2F("hMassM02CutNLocMax2","Invariant mass of splitted cluster with NLM=2 vs E, M02 cut, no TM",
+                                             nptbins,ptmin,ptmax,mbins,mmin,mmax);
+            fhMassM02CutNLocMax2->SetYTitle("M (GeV/c^{2})");
+            fhMassM02CutNLocMax2->SetXTitle("E (GeV)");
+            outputContainer->Add(fhMassM02CutNLocMax2) ;
+            
+            fhMassM02CutNLocMaxN  = new TH2F("hMassM02CutNLocMaxN","Invariant mass of splitted cluster with NLM>2 vs E, M02 cut, no TM",
+                                             nptbins,ptmin,ptmax,mbins,mmin,mmax);
+            fhMassM02CutNLocMaxN->SetYTitle("M (GeV/c^{2})");
+            fhMassM02CutNLocMaxN->SetXTitle("E (GeV)");
+            outputContainer->Add(fhMassM02CutNLocMaxN) ;
+            
+            fhAsymM02CutNLocMax1  = new TH2F("hAsymM02CutNLocMax1","Asymmetry of NLM=1  vs cluster Energy, M02Cut, no TM", nptbins,ptmin,ptmax,200,-1,1);
+            fhAsymM02CutNLocMax1->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
+            fhAsymM02CutNLocMax1->SetXTitle("E (GeV)");
+            outputContainer->Add(fhAsymM02CutNLocMax1) ;
+            
+            fhAsymM02CutNLocMax2  = new TH2F("hAsymM02CutNLocMax2","Asymmetry of NLM=2  vs cluster Energy, M02Cut, no TM", nptbins,ptmin,ptmax,200,-1,1);
+            fhAsymM02CutNLocMax2->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
+            fhAsymM02CutNLocMax2->SetXTitle("E (GeV)");
+            outputContainer->Add(fhAsymM02CutNLocMax2) ;
+            
+            fhAsymM02CutNLocMaxN  = new TH2F("hAsymM02CutNLocMaxN","Asymmetry of NLM>2  vs cluster Energy, M02Cut, no TM", nptbins,ptmin,ptmax,200,-1,1);
+            fhAsymM02CutNLocMaxN->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
+            fhAsymM02CutNLocMaxN->SetXTitle("E (GeV)");
+            outputContainer->Add(fhAsymM02CutNLocMaxN) ;
+            
+            if(splitOn)
+            {
+              fhMassSplitECutNLocMax1  = new TH2F("hMassSplitECutNLocMax1","Invariant mass of splitted cluster with NLM=1 vs E, (E1+E2)/E cut, M02 cut, no TM",
+                                                  nptbins,ptmin,ptmax,mbins,mmin,mmax);
+              fhMassSplitECutNLocMax1->SetYTitle("M (GeV/c^{2})");
+              fhMassSplitECutNLocMax1->SetXTitle("E (GeV)");
+              outputContainer->Add(fhMassSplitECutNLocMax1) ;
+              
+              fhMassSplitECutNLocMax2  = new TH2F("hMassSplitECutNLocMax2","Invariant mass of splitted cluster with NLM=2 vs E, (E1+E2)/E cut, M02 cut, no TM",
+                                                  nptbins,ptmin,ptmax,mbins,mmin,mmax);
+              fhMassSplitECutNLocMax2->SetYTitle("M (GeV/c^{2})");
+              fhMassSplitECutNLocMax2->SetXTitle("E (GeV)");
+              outputContainer->Add(fhMassSplitECutNLocMax2) ;
+              
+              fhMassSplitECutNLocMaxN  = new TH2F("hMassSplitECutNLocMaxN","Invariant mass of splitted cluster with NLM>2 vs E, (E1+E2)/E cut, M02 cut, no TM",
+                                                  nptbins,ptmin,ptmax,mbins,mmin,mmax);
+              fhMassSplitECutNLocMaxN->SetYTitle("M (GeV/c^{2})");
+              fhMassSplitECutNLocMaxN->SetXTitle("E (GeV)");
+              outputContainer->Add(fhMassSplitECutNLocMaxN) ;
+            }
+          }//m02on
+          
+          if(GetCaloPID()->GetSubClusterEnergyMinimum(0) > 0.1)
+          {
+            fhMassEnCutNLocMax1  = new TH2F("hMassEnCutNLocMax1",Form("Invariant mass of splitted cluster with NLM=1 vs E, E > %1.1f GeV, no TM",GetCaloPID()->GetSubClusterEnergyMinimum(0)),
+                                             nptbins,ptmin,ptmax,mbins,mmin,mmax);
+            fhMassEnCutNLocMax1->SetYTitle("M (GeV/c^{2})");
+            fhMassEnCutNLocMax1->SetXTitle("E (GeV)");
+            outputContainer->Add(fhMassEnCutNLocMax1) ;
+            
+            fhMassEnCutNLocMax2  = new TH2F("hMassEnCutNLocMax2",Form("Invariant mass of splitted cluster with NLM=2 vs E, E > %1.1f GeV, no TM",GetCaloPID()->GetSubClusterEnergyMinimum(1)),
+                                             nptbins,ptmin,ptmax,mbins,mmin,mmax);
+            fhMassEnCutNLocMax2->SetYTitle("M (GeV/c^{2})");
+            fhMassEnCutNLocMax2->SetXTitle("E (GeV)");
+            outputContainer->Add(fhMassEnCutNLocMax2) ;
+            
+            fhMassEnCutNLocMaxN  = new TH2F("hMassEnCutNLocMaxN",Form("Invariant mass of splitted cluster with NLM>2 vs E, E > %1.1f GeV, no TM",GetCaloPID()->GetSubClusterEnergyMinimum(2)),
+                                             nptbins,ptmin,ptmax,mbins,mmin,mmax);
+            fhMassEnCutNLocMaxN->SetYTitle("M (GeV/c^{2})");
+            fhMassEnCutNLocMaxN->SetXTitle("E (GeV)");
+            outputContainer->Add(fhMassEnCutNLocMaxN) ;
+            
+            fhM02EnCutNLocMax1  = new TH2F("hM02EnCutNLocMax1",Form("#lambda_{0}^{2} of NLM=1  vs cluster Energy, E > %1.1f GeV, no TM",GetCaloPID()->GetSubClusterEnergyMinimum(0)),
+                                            nptbins,ptmin,ptmax, ssbins,ssmin,ssmax);
+            fhM02EnCutNLocMax1->SetYTitle("#lambda_{0}^{2}");
+            fhM02EnCutNLocMax1->SetXTitle("E (GeV)");
+            outputContainer->Add(fhM02EnCutNLocMax1) ;
+            
+            fhM02EnCutNLocMax2  = new TH2F("hM02EnCutNLocMax2",Form("#lambda_{0}^{2} of NLM=2  vs cluster Energy, E > %1.1f GeV, no TM",GetCaloPID()->GetSubClusterEnergyMinimum(1)),
+                                            nptbins,ptmin,ptmax, ssbins,ssmin,ssmax);
+            fhM02EnCutNLocMax2->SetYTitle("#lambda_{0}^{2}");
+            fhM02EnCutNLocMax2->SetXTitle("E (GeV)");
+            outputContainer->Add(fhM02EnCutNLocMax2) ;
+            
+            fhM02EnCutNLocMaxN  = new TH2F("hM02EnCutNLocMaxN",Form("#lambda_{0}^{2} of NLM>2  vs cluster Energy, E > %1.1f GeV, no TM",GetCaloPID()->GetSubClusterEnergyMinimum(2)),
+                                            nptbins,ptmin,ptmax, ssbins,ssmin,ssmax);
+            fhM02EnCutNLocMaxN->SetYTitle("#lambda_{0}^{2}");
+            fhM02EnCutNLocMaxN->SetXTitle("E (GeV)");
+            outputContainer->Add(fhM02EnCutNLocMaxN) ;
+            
+            fhAsymEnCutNLocMax1  = new TH2F("hAsymEnCutNLocMax1",Form("Asymmetry of NLM=1  vs cluster Energy, E > %1.1f GeV, no TM",GetCaloPID()->GetSubClusterEnergyMinimum(0))
+                                            , nptbins,ptmin,ptmax,200,-1,1);
+            fhAsymEnCutNLocMax1->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
+            fhAsymEnCutNLocMax1->SetXTitle("E (GeV)");
+            outputContainer->Add(fhAsymEnCutNLocMax1) ;
+            
+            fhAsymEnCutNLocMax2  = new TH2F("hAsymEnCutNLocMax2",Form("Asymmetry of NLM=2  vs cluster Energy, E > %1.1f GeV, no TM",GetCaloPID()->GetSubClusterEnergyMinimum(1))
+                                            , nptbins,ptmin,ptmax,200,-1,1);
+            fhAsymEnCutNLocMax2->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
+            fhAsymEnCutNLocMax2->SetXTitle("E (GeV)");
+            outputContainer->Add(fhAsymEnCutNLocMax2) ;
+            
+            fhAsymEnCutNLocMaxN  = new TH2F("hAsymEnCutNLocMaxN",Form("Asymmetry of NLM>2  vs cluster Energy, E > %1.1f GeV, no TM",GetCaloPID()->GetSubClusterEnergyMinimum(2))
+                                            , nptbins,ptmin,ptmax,200,-1,1);
+            fhAsymEnCutNLocMaxN->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
+            fhAsymEnCutNLocMaxN->SetXTitle("E (GeV)");
+            outputContainer->Add(fhAsymEnCutNLocMaxN) ;
+
+          }
+        }
       }
       
       if(asyOn || m02On)
index 06f8818..a8503a3 100755 (executable)
@@ -235,21 +235,33 @@ class AliAnaInsideClusterInvariantMass : public AliAnaCaloTrackCorrBaseClass {
   TH2F       * fhSplitEFractionvsAsyNLocMax2[2] ;       //! sum of splitted cluster energy / cluster energy for N Local Maxima = 2 vs |A|
   TH2F       * fhSplitEFractionvsAsyNLocMaxN[2] ;       //! sum of splitted cluster energy / cluster energy for N Local Maxima > 2 vs |A|  
 
-  TH2F       * fhMassAsyCutNLocMax1  ;                  //! Asy(E) selection, not matched, Mass of split clusters, NLM = 1
-  TH2F       * fhMassAsyCutNLocMax2  ;                  //! Asy(E) selection, not matched, Mass of split clusters, NLM = 1
-  TH2F       * fhMassAsyCutNLocMaxN  ;                  //! Asy(E) selection, not matched, Mass of split clusters, NLM > 2
+  TH2F       * fhMassAsyCutNLocMax1  ;                  //! Mass(E) asym selection, not matched, Mass of split clusters, NLM = 1
+  TH2F       * fhMassAsyCutNLocMax2  ;                  //! Mass(E) asym selection, not matched, Mass of split clusters, NLM = 1
+  TH2F       * fhMassAsyCutNLocMaxN  ;                  //! Mass(E) asym selection, not matched, Mass of split clusters, NLM > 2
   
-  TH2F       * fhM02AsyCutNLocMax1  ;                   //! Asy(E) selection, not matched, M02, NLM = 1
-  TH2F       * fhM02AsyCutNLocMax2  ;                   //! Asy(E) selection, not matched, M02, NLM = 2
-  TH2F       * fhM02AsyCutNLocMaxN  ;                   //! Asy(E) selection, not matched, M02, NLM > 2
+  TH2F       * fhM02AsyCutNLocMax1  ;                   //! M02(E) asym selection, not matched, M02, NLM = 1
+  TH2F       * fhM02AsyCutNLocMax2  ;                   //! M02(E) asym selection, not matched, M02, NLM = 2
+  TH2F       * fhM02AsyCutNLocMaxN  ;                   //! M02(E) asym selection, not matched, M02, NLM > 2
   
-  TH2F       * fhMassM02CutNLocMax1  ;                  //! M02(E) selection, not matched, Mass of split clusters, NLM = 1
-  TH2F       * fhMassM02CutNLocMax2  ;                  //! M02(E) selection, not matched, Mass of split clusters, NLM = 1
-  TH2F       * fhMassM02CutNLocMaxN  ;                  //! M02(E) selection, not matched, Mass of split clusters, NLM > 2
+  TH2F       * fhMassM02CutNLocMax1  ;                  //! Mass(E) M02 selection, not matched, Mass of split clusters, NLM = 1
+  TH2F       * fhMassM02CutNLocMax2  ;                  //! Mass(E) M02 selection, not matched, Mass of split clusters, NLM = 1
+  TH2F       * fhMassM02CutNLocMaxN  ;                  //! Mass(E) M02 selection, not matched, Mass of split clusters, NLM > 2
 
-  TH2F       * fhAsymM02CutNLocMax1  ;                  //! M02(E) selection, not matched, energy asymmetry of split clusters, NLM = 1
-  TH2F       * fhAsymM02CutNLocMax2  ;                  //! M02(E) selection, not matched, energy asymmetry of split clusters, NLM = 2
-  TH2F       * fhAsymM02CutNLocMaxN  ;                  //! M02(E) selection, not matched, energy asymmetry of split clusters, NLM > 2
+  TH2F       * fhAsymM02CutNLocMax1  ;                  //! Asym(E) M02 selection, not matched, energy asymmetry of split clusters, NLM = 1
+  TH2F       * fhAsymM02CutNLocMax2  ;                  //! Asym(E) M02 selection, not matched, energy asymmetry of split clusters, NLM = 2
+  TH2F       * fhAsymM02CutNLocMaxN  ;                  //! Asym(E) M02 selection, not matched, energy asymmetry of split clusters, NLM > 2
+  
+  TH2F       * fhMassEnCutNLocMax1  ;                   //! Mass(E) E sub-cluster cut selection, not matched, Mass of split clusters, NLM = 1
+  TH2F       * fhMassEnCutNLocMax2  ;                   //! Mass(E) E sub-cluster cut selection, not matched, Mass of split clusters, NLM = 1
+  TH2F       * fhMassEnCutNLocMaxN  ;                   //! Mass(E) E sub-cluster cut selection, not matched, Mass of split clusters, NLM > 2
+
+  TH2F       * fhM02EnCutNLocMax1  ;                    //! M02(E) E sub-cluster cut selection, not matched, Mass of split clusters, NLM = 1
+  TH2F       * fhM02EnCutNLocMax2  ;                    //! M02(E) E sub-cluster cut selection, not matched, Mass of split clusters, NLM = 1
+  TH2F       * fhM02EnCutNLocMaxN  ;                    //! M02(E) E sub-cluster cut selection, not matched, Mass of split clusters, NLM > 2
+
+  TH2F       * fhAsymEnCutNLocMax1  ;                   //! Asym(E) E sub-cluster cut selection, not matched, Mass of split clusters, NLM = 1
+  TH2F       * fhAsymEnCutNLocMax2  ;                   //! Asym(E) E sub-cluster cut selection, not matched, Mass of split clusters, NLM = 1
+  TH2F       * fhAsymEnCutNLocMaxN  ;                   //! Asym(E) E sub-cluster cut selection, not matched, Mass of split clusters, NLM > 2
   
   TH2F       * fhMassSplitECutNLocMax1 ;                //! 85% of split energy, not matched, Mass of split clusters, NLM = 1
   TH2F       * fhMassSplitECutNLocMax2 ;                //! 85% of split energy, not matched, Mass of split clusters, NLM = 1
@@ -728,7 +740,7 @@ class AliAnaInsideClusterInvariantMass : public AliAnaCaloTrackCorrBaseClass {
   AliAnaInsideClusterInvariantMass(              const AliAnaInsideClusterInvariantMass & split) ; // cpy ctor
   AliAnaInsideClusterInvariantMass & operator = (const AliAnaInsideClusterInvariantMass & split) ; // cpy assignment
   
-  ClassDef(AliAnaInsideClusterInvariantMass,26)
+  ClassDef(AliAnaInsideClusterInvariantMass,27)
   
 } ;