minor fixes for previous commit

diff --git a/PWGGA/CaloTrackCorrelations/AliAnaInsideClusterInvariantMass.cxx b/PWGGA/CaloTrackCorrelations/AliAnaInsideClusterInvariantMass.cxx
index 283cff6939905d5f36f54983d0d4dc9a411e9681..be8dc82bbfa71646396a5e752ce093db979c7c7a 100755 (executable)
--- a/PWGGA/CaloTrackCorrelations/AliAnaInsideClusterInvariantMass.cxx
+++ b/PWGGA/CaloTrackCorrelations/AliAnaInsideClusterInvariantMass.cxx
@@ -55,6 +55,7 @@ AliAnaInsideClusterInvariantMass::AliAnaInsideClusterInvariantMass() :
   fCalorimeter(""), 
   fM02MaxCut(0),    fM02MinCut(0),       
   fMinNCells(0),    fMinBadDist(0),
+  fFillAngleHisto(kFALSE),
   fFillTMResidualHisto(kFALSE),
   fFillSSExtraHisto(kFALSE)
 {
@@ -370,28 +371,30 @@ TList * AliAnaInsideClusterInvariantMass::GetCreateOutputObjects()
       fhM02NLocMaxN[i][j]   ->SetXTitle("E (GeV)");
       outputContainer->Add(fhM02NLocMaxN[i][j]) ; 
       
-
-      fhMCGenFracNLocMax1[i][j]     = new TH2F(Form("hMCGenFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
-                                               Form("#lambda_{0}^{2} vs E for N max  = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
-                                               nptbins,ptmin,ptmax,200,0,2); 
-      fhMCGenFracNLocMax1[i][j]   ->SetYTitle("#lambda_{0}^{2}");
-      fhMCGenFracNLocMax1[i][j]   ->SetXTitle("E (GeV)");
-      outputContainer->Add(fhMCGenFracNLocMax1[i][j]) ; 
-      
-      fhMCGenFracNLocMax2[i][j]     = new TH2F(Form("hMCGenFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
-                                               Form("#lambda_{0}^{2} vs E for N max  = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
-                                               nptbins,ptmin,ptmax,200,0,2); 
-      fhMCGenFracNLocMax2[i][j]   ->SetYTitle("#lambda_{0}^{2}");
-      fhMCGenFracNLocMax2[i][j]   ->SetXTitle("E (GeV)");
-      outputContainer->Add(fhMCGenFracNLocMax2[i][j]) ; 
-      
-      
-      fhMCGenFracNLocMaxN[i][j]    = new TH2F(Form("hMCGenFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
-                                              Form("#lambda_{0}^{2} vs E for N max  > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
-                                              nptbins,ptmin,ptmax,200,0,2); 
-      fhMCGenFracNLocMaxN[i][j]   ->SetYTitle("#lambda_{0}^{2}");
-      fhMCGenFracNLocMaxN[i][j]   ->SetXTitle("E (GeV)");
-      outputContainer->Add(fhMCGenFracNLocMaxN[i][j]) ; 
+      if(i > 0) // skip first entry in array, general case not filled
+      {
+        fhMCGenFracNLocMax1[i][j]     = new TH2F(Form("hMCGenFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
+                                                 Form("#lambda_{0}^{2} vs E for N max  = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
+                                                 nptbins,ptmin,ptmax,200,0,2); 
+        fhMCGenFracNLocMax1[i][j]   ->SetYTitle("E_{reco} / E_{gen}");
+        fhMCGenFracNLocMax1[i][j]   ->SetXTitle("E (GeV)");
+        outputContainer->Add(fhMCGenFracNLocMax1[i][j]) ; 
+        
+        fhMCGenFracNLocMax2[i][j]     = new TH2F(Form("hMCGenFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
+                                                 Form("#lambda_{0}^{2} vs E for N max  = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
+                                                 nptbins,ptmin,ptmax,200,0,2); 
+        fhMCGenFracNLocMax2[i][j]   ->SetYTitle("E_{reco} / E_{gen}");
+        fhMCGenFracNLocMax2[i][j]   ->SetXTitle("E (GeV)");
+        outputContainer->Add(fhMCGenFracNLocMax2[i][j]) ; 
+        
+        
+        fhMCGenFracNLocMaxN[i][j]    = new TH2F(Form("hMCGenFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
+                                                Form("#lambda_{0}^{2} vs E for N max  > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
+                                                nptbins,ptmin,ptmax,200,0,2); 
+        fhMCGenFracNLocMaxN[i][j]   ->SetYTitle("E_{reco} / E_{gen}");
+        fhMCGenFracNLocMaxN[i][j]   ->SetXTitle("E (GeV)");
+        outputContainer->Add(fhMCGenFracNLocMaxN[i][j]) ; 
+      }
       
       if(fFillSSExtraHisto)
       {
@@ -492,49 +495,52 @@ TList * AliAnaInsideClusterInvariantMass::GetCreateOutputObjects()
       
     } // matched, not matched
     
-    for(Int_t j = 0; j < 4; j++)
-    {  
-      fhMassMCGenFracNLocMax1Ebin[i][j]  = new TH2F(Form("hMassMCGenFracNLocMax1%sEbin%d",pname[i].Data(),j),
-                                                    Form("Invariant mass of 2 highest energy cells vs E, %s, E bin %d",ptype[i].Data(),j),
-                                                    200,0,2,mbins,mmin,mmax); 
-      fhMassMCGenFracNLocMax1Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
-      fhMassMCGenFracNLocMax1Ebin[i][j]->SetXTitle("E_{reco} / E_{gen}");
-      outputContainer->Add(fhMassMCGenFracNLocMax1Ebin[i][j]) ;   
-      
-      fhMassMCGenFracNLocMax2Ebin[i][j]  = new TH2F(Form("hMassMCGenFracNLocMax2%sEbin%d",pname[i].Data(),j),
-                                                    Form("Invariant mass of 2 local maxima cells vs E, %s, E bin %d",ptype[i].Data(),j),
-                                                    200,0,2,mbins,mmin,mmax); 
-      fhMassMCGenFracNLocMax2Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
-      fhMassMCGenFracNLocMax2Ebin[i][j]->SetXTitle("E_{reco} / E_{gen}");
-      outputContainer->Add(fhMassMCGenFracNLocMax2Ebin[i][j]) ;   
-      
-      fhMassMCGenFracNLocMaxNEbin[i][j]  = new TH2F(Form("hMassMCGenFracNLocMaxN%sEbin%d",pname[i].Data(),j),
-                                                    Form("Invariant mass of N>2 local maxima cells vs E, %s, E bin %d",ptype[i].Data(),j),
-                                                    200,0,2,mbins,mmin,mmax); 
-      fhMassMCGenFracNLocMaxNEbin[i][j]->SetYTitle("M (GeV/c^{2})");
-      fhMassMCGenFracNLocMaxNEbin[i][j]->SetXTitle("E_{reco} / E_{gen}");
-      outputContainer->Add(fhMassMCGenFracNLocMaxNEbin[i][j]) ;   
-      
-      fhM02MCGenFracNLocMax1Ebin[i][j]     = new TH2F(Form("hM02MCGenFracNLocMax1%sEbin%d",pname[i].Data(),j),
-                                                      Form("#lambda_{0}^{2} vs E for N max  = 1 %s, E bin %d",ptype[i].Data(), j),
-                                                      200,0,2,ssbins,ssmin,ssmax); 
-      fhM02MCGenFracNLocMax1Ebin[i][j]   ->SetYTitle("#lambda_{0}^{2}");
-      fhM02MCGenFracNLocMax1Ebin[i][j]   ->SetXTitle("E_{reco} / E_{gen}");
-      outputContainer->Add(fhM02MCGenFracNLocMax1Ebin[i][j]) ; 
-      
-      fhM02MCGenFracNLocMax2Ebin[i][j]     = new TH2F(Form("hM02MCGenFracNLocMax2%sEbin%d",pname[i].Data(),j),
-                                                      Form("#lambda_{0}^{2} vs E for N max  = 2 %s, E bin %d",ptype[i].Data(),j),
-                                                      200,0,2,ssbins,ssmin,ssmax); 
-      fhM02MCGenFracNLocMax2Ebin[i][j]   ->SetYTitle("#lambda_{0}^{2}");
-      fhM02MCGenFracNLocMax2Ebin[i][j]   ->SetXTitle("E_{reco} / E_{gen}");
-      outputContainer->Add(fhM02MCGenFracNLocMax2Ebin[i][j]) ; 
-      
-      fhM02MCGenFracNLocMaxNEbin[i][j]    = new TH2F(Form("hM02MCGenFracNLocMaxN%sEbin%d",pname[i].Data(),j),
-                                                     Form("#lambda_{0}^{2} vs E for N max  > 2 %s, E bin %d",ptype[i].Data(),j),
-                                                     200,0,2,ssbins,ssmin,ssmax); 
-      fhM02MCGenFracNLocMaxNEbin[i][j]   ->SetYTitle("#lambda_{0}^{2}");
-      fhM02MCGenFracNLocMaxNEbin[i][j]   ->SetXTitle("E_{reco} / E_{gen}");
-      outputContainer->Add(fhM02MCGenFracNLocMaxNEbin[i][j]) ; 
+    if(i>0) // skip first entry in array, general case not filled
+    {
+      for(Int_t j = 0; j < 4; j++)
+      {  
+        fhMassMCGenFracNLocMax1Ebin[i][j]  = new TH2F(Form("hMassMCGenFracNLocMax1%sEbin%d",pname[i].Data(),j),
+                                                      Form("Invariant mass of 2 highest energy cells vs E, %s, E bin %d",ptype[i].Data(),j),
+                                                      200,0,2,mbins,mmin,mmax); 
+        fhMassMCGenFracNLocMax1Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
+        fhMassMCGenFracNLocMax1Ebin[i][j]->SetXTitle("E_{reco} / E_{gen}");
+        outputContainer->Add(fhMassMCGenFracNLocMax1Ebin[i][j]) ;   
+        
+        fhMassMCGenFracNLocMax2Ebin[i][j]  = new TH2F(Form("hMassMCGenFracNLocMax2%sEbin%d",pname[i].Data(),j),
+                                                      Form("Invariant mass of 2 local maxima cells vs E, %s, E bin %d",ptype[i].Data(),j),
+                                                      200,0,2,mbins,mmin,mmax); 
+        fhMassMCGenFracNLocMax2Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
+        fhMassMCGenFracNLocMax2Ebin[i][j]->SetXTitle("E_{reco} / E_{gen}");
+        outputContainer->Add(fhMassMCGenFracNLocMax2Ebin[i][j]) ;   
+        
+        fhMassMCGenFracNLocMaxNEbin[i][j]  = new TH2F(Form("hMassMCGenFracNLocMaxN%sEbin%d",pname[i].Data(),j),
+                                                      Form("Invariant mass of N>2 local maxima cells vs E, %s, E bin %d",ptype[i].Data(),j),
+                                                      200,0,2,mbins,mmin,mmax); 
+        fhMassMCGenFracNLocMaxNEbin[i][j]->SetYTitle("M (GeV/c^{2})");
+        fhMassMCGenFracNLocMaxNEbin[i][j]->SetXTitle("E_{reco} / E_{gen}");
+        outputContainer->Add(fhMassMCGenFracNLocMaxNEbin[i][j]) ;   
+        
+        fhM02MCGenFracNLocMax1Ebin[i][j]     = new TH2F(Form("hM02MCGenFracNLocMax1%sEbin%d",pname[i].Data(),j),
+                                                        Form("#lambda_{0}^{2} vs E for N max  = 1 %s, E bin %d",ptype[i].Data(), j),
+                                                        200,0,2,ssbins,ssmin,ssmax); 
+        fhM02MCGenFracNLocMax1Ebin[i][j]   ->SetYTitle("#lambda_{0}^{2}");
+        fhM02MCGenFracNLocMax1Ebin[i][j]   ->SetXTitle("E_{reco} / E_{gen}");
+        outputContainer->Add(fhM02MCGenFracNLocMax1Ebin[i][j]) ; 
+        
+        fhM02MCGenFracNLocMax2Ebin[i][j]     = new TH2F(Form("hM02MCGenFracNLocMax2%sEbin%d",pname[i].Data(),j),
+                                                        Form("#lambda_{0}^{2} vs E for N max  = 2 %s, E bin %d",ptype[i].Data(),j),
+                                                        200,0,2,ssbins,ssmin,ssmax); 
+        fhM02MCGenFracNLocMax2Ebin[i][j]   ->SetYTitle("#lambda_{0}^{2}");
+        fhM02MCGenFracNLocMax2Ebin[i][j]   ->SetXTitle("E_{reco} / E_{gen}");
+        outputContainer->Add(fhM02MCGenFracNLocMax2Ebin[i][j]) ; 
+        
+        fhM02MCGenFracNLocMaxNEbin[i][j]    = new TH2F(Form("hM02MCGenFracNLocMaxN%sEbin%d",pname[i].Data(),j),
+                                                       Form("#lambda_{0}^{2} vs E for N max  > 2 %s, E bin %d",ptype[i].Data(),j),
+                                                       200,0,2,ssbins,ssmin,ssmax); 
+        fhM02MCGenFracNLocMaxNEbin[i][j]   ->SetYTitle("#lambda_{0}^{2}");
+        fhM02MCGenFracNLocMaxNEbin[i][j]   ->SetXTitle("E_{reco} / E_{gen}");
+        outputContainer->Add(fhM02MCGenFracNLocMaxNEbin[i][j]) ; 
+      }
     }
   } // MC particle list
  
@@ -545,21 +551,21 @@ TList * AliAnaInsideClusterInvariantMass::GetCreateOutputObjects()
     {
       fhMCAsymM02NLocMax1MCPi0Ebin[i]  = new TH2F(Form("hMCAsymM02NLocMax1MCPi0Ebin%d",i),
                                                  Form("Asymmetry of MC #pi^{0} of 2 highest energy cells #lambda_{0}^{2}, E bin %d",i),
-                                                 ssbins,ssmin,ssmax,200,0,2); 
+                                                 ssbins,ssmin,ssmax,100,0,1); 
       fhMCAsymM02NLocMax1MCPi0Ebin[i]->SetYTitle("Decay asymmetry");
       fhMCAsymM02NLocMax1MCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}");
       outputContainer->Add(fhMCAsymM02NLocMax1MCPi0Ebin[i]) ;   
       
       fhMCAsymM02NLocMax2MCPi0Ebin[i]  = new TH2F(Form("hMCAsymM02NLocMax2MCPi0Ebin%d",i),
                                                  Form("Asymmetry of MC #pi^{0} of 2 local maxima cells #lambda_{0}^{2}, E bin %d",i),
-                                                 ssbins,ssmin,ssmax,200,0,2); 
+                                                 ssbins,ssmin,ssmax,100,0,1); 
       fhMCAsymM02NLocMax2MCPi0Ebin[i]->SetYTitle("Decay asymmetry");
       fhMCAsymM02NLocMax2MCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}");
       outputContainer->Add(fhMCAsymM02NLocMax2MCPi0Ebin[i]) ;   
       
       fhMCAsymM02NLocMaxNMCPi0Ebin[i]  = new TH2F(Form("hMCAsymM02NLocMaxNMCPi0Ebin%d",i),
                                                  Form("Asymmetry of MC #pi^{0} of N>2 local maxima cells vs #lambda_{0}^{2}, E bin %d",i),
-                                                 ssbins,ssmin,ssmax,200,0,2); 
+                                                 ssbins,ssmin,ssmax,100,0,1); 
       fhMCAsymM02NLocMaxNMCPi0Ebin[i]->SetYTitle("Decay asymmetry");
       fhMCAsymM02NLocMaxNMCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}");
       outputContainer->Add(fhMCAsymM02NLocMaxNMCPi0Ebin[i]) ; 
@@ -711,51 +717,54 @@ TList * AliAnaInsideClusterInvariantMass::GetCreateOutputObjects()
     }
   }
   
-  for(Int_t j = 0; j < 2; j++)
-  {  
-    
-    fhAnglePairLocMax1[j]  = new TH2F(Form("hAnglePairLocMax1%s",sMatched[j].Data()),
-                                      Form("Opening angle of 2 highest energy cells vs pair Energy, %s",sMatched[j].Data()),
-                                      nptbins,ptmin,ptmax,200,0,0.2); 
-    fhAnglePairLocMax1[j]->SetYTitle("#alpha (rad)");
-    fhAnglePairLocMax1[j]->SetXTitle("E (GeV)");
-    outputContainer->Add(fhAnglePairLocMax1[j]) ;   
-    
-    fhAnglePairLocMax2[j]  = new TH2F(Form("hAnglePairLocMax2%s",sMatched[j].Data()),
-                                      Form("Opening angle of 2 local maxima cells vs Energy, %s",sMatched[j].Data()),
-                                      nptbins,ptmin,ptmax,200,0,0.2); 
-    fhAnglePairLocMax2[j]->SetYTitle("#alpha (rad)");
-    fhAnglePairLocMax2[j]->SetXTitle("E (GeV)");
-    outputContainer->Add(fhAnglePairLocMax2[j]) ;   
-    
-    fhAnglePairLocMaxN[j]  = new TH2F(Form("hAnglePairLocMaxN%s",sMatched[j].Data()),
-                                      Form("Opening angle of N>2 local maxima cells vs Energy, %s",sMatched[j].Data()),
-                                      nptbins,ptmin,ptmax,200,0,0.2); 
-    fhAnglePairLocMaxN[j]->SetYTitle("#alpha (rad)");
-    fhAnglePairLocMaxN[j]->SetXTitle("E (GeV)");
-    outputContainer->Add(fhAnglePairLocMaxN[j]) ;   
-    
-    fhAnglePairMassLocMax1[j]  = new TH2F(Form("hAnglePairMassLocMax1%s",sMatched[j].Data()),
-                                          Form("Opening angle of 2 highest energy cells vs Mass for E > 7 GeV, %s",sMatched[j].Data()),
-                                          mbins,mmin,mmax,200,0,0.2); 
-    fhAnglePairMassLocMax1[j]->SetXTitle("M (GeV/c^{2})");
-    fhAnglePairMassLocMax1[j]->SetYTitle("#alpha (rad)");
-    outputContainer->Add(fhAnglePairMassLocMax1[j]) ;   
-    
-    fhAnglePairMassLocMax2[j]  = new TH2F(Form("hAnglePairMassLocMax2%s",sMatched[j].Data()),
-                                          Form("Opening angle of 2 local maxima cells vs Mass for E > 7 GeV, %s",sMatched[j].Data()),
-                                          mbins,mmin,mmax,200,0,0.2); 
-    fhAnglePairMassLocMax2[j]->SetXTitle("M (GeV/c^{2})");
-    fhAnglePairMassLocMax2[j]->SetYTitle("#alpha (rad)");
-    outputContainer->Add(fhAnglePairMassLocMax2[j]) ;   
-    
-    fhAnglePairMassLocMaxN[j]  = new TH2F(Form("hAnglePairMassLocMaxN%s",sMatched[j].Data()),
-                                          Form("Opening angle of N>2 local maxima cells vs Mass for E > 7 GeV, %s",sMatched[j].Data()),
-                                          mbins,mmin,mmax,200,0,0.2); 
-    fhAnglePairMassLocMaxN[j]->SetXTitle("M (GeV/c^{2})");
-    fhAnglePairMassLocMaxN[j]->SetYTitle("#alpha (rad)");
-    outputContainer->Add(fhAnglePairMassLocMaxN[j]) ;  
-    
+  if(fFillAngleHisto)
+  {
+    for(Int_t j = 0; j < 2; j++)
+    {  
+      
+      fhAnglePairLocMax1[j]  = new TH2F(Form("hAnglePairLocMax1%s",sMatched[j].Data()),
+                                        Form("Opening angle of 2 highest energy cells vs pair Energy, %s",sMatched[j].Data()),
+                                        nptbins,ptmin,ptmax,200,0,0.2); 
+      fhAnglePairLocMax1[j]->SetYTitle("#alpha (rad)");
+      fhAnglePairLocMax1[j]->SetXTitle("E (GeV)");
+      outputContainer->Add(fhAnglePairLocMax1[j]) ;   
+      
+      fhAnglePairLocMax2[j]  = new TH2F(Form("hAnglePairLocMax2%s",sMatched[j].Data()),
+                                        Form("Opening angle of 2 local maxima cells vs Energy, %s",sMatched[j].Data()),
+                                        nptbins,ptmin,ptmax,200,0,0.2); 
+      fhAnglePairLocMax2[j]->SetYTitle("#alpha (rad)");
+      fhAnglePairLocMax2[j]->SetXTitle("E (GeV)");
+      outputContainer->Add(fhAnglePairLocMax2[j]) ;   
+      
+      fhAnglePairLocMaxN[j]  = new TH2F(Form("hAnglePairLocMaxN%s",sMatched[j].Data()),
+                                        Form("Opening angle of N>2 local maxima cells vs Energy, %s",sMatched[j].Data()),
+                                        nptbins,ptmin,ptmax,200,0,0.2); 
+      fhAnglePairLocMaxN[j]->SetYTitle("#alpha (rad)");
+      fhAnglePairLocMaxN[j]->SetXTitle("E (GeV)");
+      outputContainer->Add(fhAnglePairLocMaxN[j]) ;   
+      
+      fhAnglePairMassLocMax1[j]  = new TH2F(Form("hAnglePairMassLocMax1%s",sMatched[j].Data()),
+                                            Form("Opening angle of 2 highest energy cells vs Mass for E > 7 GeV, %s",sMatched[j].Data()),
+                                            mbins,mmin,mmax,200,0,0.2); 
+      fhAnglePairMassLocMax1[j]->SetXTitle("M (GeV/c^{2})");
+      fhAnglePairMassLocMax1[j]->SetYTitle("#alpha (rad)");
+      outputContainer->Add(fhAnglePairMassLocMax1[j]) ;   
+      
+      fhAnglePairMassLocMax2[j]  = new TH2F(Form("hAnglePairMassLocMax2%s",sMatched[j].Data()),
+                                            Form("Opening angle of 2 local maxima cells vs Mass for E > 7 GeV, %s",sMatched[j].Data()),
+                                            mbins,mmin,mmax,200,0,0.2); 
+      fhAnglePairMassLocMax2[j]->SetXTitle("M (GeV/c^{2})");
+      fhAnglePairMassLocMax2[j]->SetYTitle("#alpha (rad)");
+      outputContainer->Add(fhAnglePairMassLocMax2[j]) ;   
+      
+      fhAnglePairMassLocMaxN[j]  = new TH2F(Form("hAnglePairMassLocMaxN%s",sMatched[j].Data()),
+                                            Form("Opening angle of N>2 local maxima cells vs Mass for E > 7 GeV, %s",sMatched[j].Data()),
+                                            mbins,mmin,mmax,200,0,0.2); 
+      fhAnglePairMassLocMaxN[j]->SetXTitle("M (GeV/c^{2})");
+      fhAnglePairMassLocMaxN[j]->SetYTitle("#alpha (rad)");
+      outputContainer->Add(fhAnglePairMassLocMaxN[j]) ;  
+      
+    }
   }
   
   return outputContainer ;
@@ -935,9 +944,10 @@ void  AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms()
       TLorentzVector primary = GetMCAnalysisUtils()->GetMother(cluster->GetLabel(),GetReader(),ok);
       eprim = primary.E();
       
-      if(mcindex == kmcPi0)
+      if(mcindex == kmcPi0 || mcindex == kmcEta)
       {
-        asymGen = GetMCAnalysisUtils()->GetMCDecayAsymmetryForPDG(cluster->GetLabel(),111,GetReader(),ok);
+        if(mcindex == kmcPi0) asymGen = TMath::Abs(GetMCAnalysisUtils()->GetMCDecayAsymmetryForPDG(cluster->GetLabel(),111,GetReader(),ok));
+        else                  asymGen = TMath::Abs(GetMCAnalysisUtils()->GetMCDecayAsymmetryForPDG(cluster->GetLabel(),221,GetReader(),ok));
       }
       
     } 
@@ -1090,11 +1100,12 @@ void  AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms()
     
     if     (nMax==1) 
     { 
-      fhAnglePairLocMax1[matched]->Fill(en,angle);
       fhMassNLocMax1[0][matched] ->Fill(en,mass ); 
       
+      if(fFillAngleHisto) 
+      {
+        fhAnglePairLocMax1[matched]->Fill(en,angle);
       if( en > 7 ) 
-      {      
         fhAnglePairMassLocMax1[matched]->Fill(mass,angle);
       }
       
@@ -1104,12 +1115,13 @@ void  AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms()
     }  
     else if(nMax==2) 
     {
-      fhAnglePairLocMax2[matched]->Fill(en,angle);
       fhMassNLocMax2[0] [matched]->Fill(en,mass );
       
-      if( en > 7 )
+      if(fFillAngleHisto) 
       {
-        fhAnglePairMassLocMax2[matched]->Fill(mass,angle);        
+        fhAnglePairLocMax2[matched]->Fill(en,angle);
+        if( en > 7 ) 
+          fhAnglePairMassLocMax2[matched]->Fill(mass,angle);
       }
       
       if     (pidTag==AliCaloPID::kPhoton) fhM02ConLocMax2[0][matched]->Fill(en,l0);
@@ -1118,12 +1130,13 @@ void  AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms()
     }
     else if(nMax >2) 
     {
-      fhAnglePairLocMaxN[matched]->Fill(en,angle);
       fhMassNLocMaxN[0] [matched]->Fill(en,mass );
       
-      if( en > 7 ) 
-      {      
-        fhAnglePairMassLocMaxN[matched]->Fill(mass,angle);
+      if(fFillAngleHisto) 
+      {
+        fhAnglePairLocMaxN[matched]->Fill(en,angle);
+        if( en > 7 ) 
+          fhAnglePairMassLocMaxN[matched]->Fill(mass,angle);
       }
       
       if     (pidTag==AliCaloPID::kPhoton) fhM02ConLocMaxN[0][matched]->Fill(en,l0);

diff --git a/PWGGA/CaloTrackCorrelations/AliAnaInsideClusterInvariantMass.h b/PWGGA/CaloTrackCorrelations/AliAnaInsideClusterInvariantMass.h
index 9e96c9019330a8b8dc1f2eb2b4e26c1e9fdbff5e..ee6209203f948fdc1a588ed02cc3313929a79477 100755 (executable)
--- a/PWGGA/CaloTrackCorrelations/AliAnaInsideClusterInvariantMass.h
+++ b/PWGGA/CaloTrackCorrelations/AliAnaInsideClusterInvariantMass.h
@@ -50,8 +50,11 @@ class AliAnaInsideClusterInvariantMass : public AliAnaCaloTrackCorrBaseClass {
 
   void         SetMinBadChannelDistance(Float_t cut)     { fMinBadDist  = cut ; }
 
-  void         SwitchOnFillExtraSSHistograms()           { fFillSSExtraHisto   = kTRUE  ; }
-  void         SwitchOffFillExtraSSHistograms()          { fFillSSExtraHisto   = kFALSE ; }
+  void         SwitchOnFillAngleHistograms()             { fFillAngleHisto      = kTRUE  ; }
+  void         SwitchOffFillAngleHistograms()            { fFillAngleHisto      = kFALSE ; }
+  
+  void         SwitchOnFillExtraSSHistograms()           { fFillSSExtraHisto    = kTRUE  ; }
+  void         SwitchOffFillExtraSSHistograms()          { fFillSSExtraHisto    = kFALSE ; }
 
   void         SwitchOnFillTMResidualHistograms()        { fFillTMResidualHisto = kTRUE  ; }
   void         SwitchOffFillTMResidualHistograms()       { fFillTMResidualHisto = kFALSE ; }
@@ -68,6 +71,7 @@ class AliAnaInsideClusterInvariantMass : public AliAnaCaloTrackCorrBaseClass {
   Int_t        fMinNCells   ;          // Study clusters with ncells larger than cut
   Float_t      fMinBadDist  ;          // Minimal distance to bad channel to accept cluster
   
+  Bool_t       fFillAngleHisto;        // Fill splitted clusters angle histograms
   Bool_t       fFillTMResidualHisto ;  // Fill track matching histos, residuals
   Bool_t       fFillSSExtraHisto ;     // Fill shower shape extra histos
   
@@ -166,7 +170,7 @@ class AliAnaInsideClusterInvariantMass : public AliAnaCaloTrackCorrBaseClass {
   AliAnaInsideClusterInvariantMass(              const AliAnaInsideClusterInvariantMass & g) ; // cpy ctor
   AliAnaInsideClusterInvariantMass & operator = (const AliAnaInsideClusterInvariantMass & g) ; // cpy assignment
   
-  ClassDef(AliAnaInsideClusterInvariantMass,13)
+  ClassDef(AliAnaInsideClusterInvariantMass,14)
   
 } ;
 

diff --git a/PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.cxx b/PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.cxx
index 4d81f7dbbfd74891dae705f177bf54d8dbf604ba..6d306b4c96bb1e04c0beaa218479757335cd14f0 100755 (executable)
--- a/PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.cxx
+++ b/PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.cxx
@@ -68,7 +68,7 @@ AliAnaPi0EbE::AliAnaPi0EbE() :
 
     // MC histos
     fhMCPt(),                      fhMCPhi(),                    fhMCEta(),
-    fhMCPi0PtFraction(0),          fhMCEtaPtFraction(0),
+    fhMCPi0PtGenRecoFraction(0),   fhMCEtaPtGenRecoFraction(0),
     fhMCPi0DecayPt(0),             fhMCPi0DecayPtFraction(0),      
     fhMCEtaDecayPt(0),             fhMCEtaDecayPtFraction(0),
     fhMCOtherDecayPt(0),           
@@ -888,27 +888,27 @@ TList *  AliAnaPi0EbE::GetCreateOutputObjects()
   {
     if(GetReader()->GetDataType() != AliCaloTrackReader::kMC && fAnaType==kSSCalo)
     {
-      fhMCPi0PtFraction = new TH2F("hMCPi0PtFraction","Number of clusters from #pi^{0} (2 #gamma) identified as #pi^{0} (#eta), pT versus pT / pT mother",
-                                   nptbins,ptmin,ptmax,100,0,1); 
-      fhMCPi0PtFraction->SetXTitle("p^{rec}_{T} (GeV/c)");
-      fhMCPi0PtFraction->SetYTitle("E^{gen}_{T} / E^{gen-mother}_{T}");
-      outputContainer->Add(fhMCPi0PtFraction) ; 
+      fhMCPi0PtGenRecoFraction = new TH2F("hMCPi0PtGenRecoFraction","Number of clusters from #pi^{0} (2 #gamma) identified as #pi^{0} (#eta), pT versus E primary #pi^{0} / E reco",
+                                   nptbins,ptmin,ptmax,200,0,2); 
+      fhMCPi0PtGenRecoFraction->SetXTitle("p^{rec}_{T} (GeV/c)");
+      fhMCPi0PtGenRecoFraction->SetYTitle("E^{ #pi^{0} mother} / E^{rec}");
+      outputContainer->Add(fhMCPi0PtGenRecoFraction) ; 
             
-      fhMCEtaPtFraction = new TH2F("hMCEtaPtFraction","Number of clusters from #eta (2 #gamma) identified as #pi^{0} (#eta), pT versus pT / pT mother",
-                                   nptbins,ptmin,ptmax,100,0,1); 
-      fhMCEtaPtFraction->SetXTitle("p^{rec}_{T} (GeV/c)");
-      fhMCEtaPtFraction->SetYTitle("E^{gen}_{T} / E^{gen-mother}_{T}");
-      outputContainer->Add(fhMCEtaPtFraction) ; 
+      fhMCEtaPtGenRecoFraction = new TH2F("hMCEtaPtGenRecoFraction","Number of clusters from #eta (2 #gamma) identified as #pi^{0} (#eta),pT versus E primary #eta / E reco",
+                                   nptbins,ptmin,ptmax,200,0,2); 
+      fhMCEtaPtGenRecoFraction->SetXTitle("p^{rec}_{T} (GeV/c)");
+      fhMCEtaPtGenRecoFraction->SetYTitle("E^{ #eta mother} / E^{rec}");
+      outputContainer->Add(fhMCEtaPtGenRecoFraction) ; 
       
       fhMCPi0DecayPt = new TH1F("hMCPi0DecayPt","Number of #gamma from #pi^{0} decay  identified as #pi^{0} (#eta)",nptbins,ptmin,ptmax); 
       fhMCPi0DecayPt->SetYTitle("N");
       fhMCPi0DecayPt->SetXTitle("p^{rec}_{T} (GeV/c)");
       outputContainer->Add(fhMCPi0DecayPt) ; 
       
-      fhMCPi0DecayPtFraction = new TH2F("hMCPi0DecayPtFraction","Number of #gamma from #pi^{0} decay  identified as #pi^{0} (#eta), pT versus pT / pT mother",
+      fhMCPi0DecayPtFraction = new TH2F("hMCPi0DecayPtFraction","Number of #gamma from #pi^{0} decay  identified as #pi^{0} (#eta), pT versus E primary  #gamma / E primary #pi^{0}",
                                         nptbins,ptmin,ptmax,100,0,1); 
       fhMCPi0DecayPtFraction->SetXTitle("p^{rec}_{T} (GeV/c)");
-      fhMCPi0DecayPtFraction->SetYTitle("E^{gen}_{T} / E^{gen-mother}_{T}");
+      fhMCPi0DecayPtFraction->SetYTitle("E^{gen} / E^{gen-mother}");
       outputContainer->Add(fhMCPi0DecayPtFraction) ; 
       
       fhMCEtaDecayPt = new TH1F("hMCEtaDecayPt","Number of #gamma from #eta decay  identified as #pi^{0} (#eta)",nptbins,ptmin,ptmax); 
@@ -916,10 +916,10 @@ TList *  AliAnaPi0EbE::GetCreateOutputObjects()
       fhMCEtaDecayPt->SetXTitle("p^{rec}_{T} (GeV/c)");
       outputContainer->Add(fhMCEtaDecayPt) ; 
       
-      fhMCEtaDecayPtFraction = new TH2F("hMCEtaDecayPtFraction","Number of #gamma from #eta decay  identified as #pi^{0} (#eta), pT versus pT / pT mother",
+      fhMCEtaDecayPtFraction = new TH2F("hMCEtaDecayPtFraction","Number of #gamma from #eta decay  identified as #pi^{0} (#eta), pT versus E primary  #gamma / E primary #eta",
                                         nptbins,ptmin,ptmax,100,0,1); 
       fhMCEtaDecayPtFraction->SetXTitle("p^{rec}_{T} (GeV/c)");
-      fhMCEtaDecayPtFraction->SetYTitle("E^{gen}_{T} / E^{gen-mother}_{T}");
+      fhMCEtaDecayPtFraction->SetYTitle("E^{gen} / E^{gen-mother}");
       outputContainer->Add(fhMCEtaDecayPtFraction) ; 
       
       fhMCOtherDecayPt = new TH1F("hMCOtherDecayPt","Number of #gamma decay (not #eta or #pi^{0})  identified as #pi^{0} (#eta)",nptbins,ptmin,ptmax); 
@@ -1859,7 +1859,7 @@ void  AliAnaPi0EbE::MakeAnalysisFillHistograms()
       fhMCPhi[mcIndex] ->Fill(pt,phi);
       fhMCEta[mcIndex] ->Fill(pt,eta);
       
-      if(mcIndex==kmcPhoton && fAnaType==kSSCalo)
+      if((mcIndex==kmcPhoton || mcIndex==kmcPi0 || mcIndex==kmcEta) && fAnaType==kSSCalo)
       {
         Float_t efracMC = 0;
         Int_t label = pi0->GetLabel();
@@ -1873,14 +1873,14 @@ void  AliAnaPi0EbE::MakeAnalysisFillHistograms()
           TLorentzVector grandmom = GetMCAnalysisUtils()->GetMotherWithPDG(label,111,GetReader(),ok); 
           if(grandmom.E() > 0 && ok) 
           {
-            efracMC =  mom.E()/grandmom.E();
-            fhMCPi0PtFraction ->Fill(pt,efracMC);
+            efracMC =  grandmom.E()/ener;
+            fhMCPi0PtGenRecoFraction ->Fill(pt,efracMC);
           }
         }        
         else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay))
         {
           fhMCPi0DecayPt->Fill(pt);
-          TLorentzVector grandmom = GetMCAnalysisUtils()->GetMotherWithPDG(label,111,GetReader(),ok); 
+          TLorentzVector grandmom = GetMCAnalysisUtils()->GetMotherWithPDG(label,111,GetReader(),ok);
           if(grandmom.E() > 0 && ok) 
           {
             efracMC =  mom.E()/grandmom.E();
@@ -1892,8 +1892,8 @@ void  AliAnaPi0EbE::MakeAnalysisFillHistograms()
           TLorentzVector grandmom = GetMCAnalysisUtils()->GetMotherWithPDG(label,221,GetReader(),ok); 
           if(grandmom.E() > 0 && ok) 
           {
-            efracMC =  mom.E()/grandmom.E();
-            fhMCEtaPtFraction ->Fill(pt,efracMC);
+            efracMC =  grandmom.E()/ener;
+            fhMCEtaPtGenRecoFraction ->Fill(pt,efracMC);
           }
         }        
         else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEtaDecay))

diff --git a/PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.h b/PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.h
index 7211909565c841aca5ef49444afd1280e279b6bf..dad82db7e8fa518cf03e9dea6209d453844ec95c 100755 (executable)
--- a/PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.h
+++ b/PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.h
@@ -184,13 +184,13 @@ class AliAnaPi0EbE : public AliAnaCaloTrackCorrBaseClass {
   TH2F         * fhMCPhi[6];                  //! Phi of identified as pi0, coming from X
   TH2F         * fhMCEta[6];                  //! eta of identified as pi0, coming from X
 
-  TH2F         * fhMCPi0PtFraction;           //! SS id, clusters id as pi0, coming from 2 photon, pi0 decay, pt vs pt decay / pt mother
-  TH2F         * fhMCEtaPtFraction;           //! SS id, clusters id as pi0, coming from 2 photon, eta decay, pt vs pt decay / pt mother  
-  TH1F         * fhMCPi0DecayPt;              //! SS id, clusters id as pi0, coming from 1 photon, pi0 decay, pt
-  TH2F         * fhMCPi0DecayPtFraction;      //! SS id, clusters id as pi0, coming from 1 photon, pi0 decay, pt vs pt decay / pt mother
-  TH1F         * fhMCEtaDecayPt;              //! SS id, clusters id as pi0, coming from 1 photon, eta decay, pt
-  TH2F         * fhMCEtaDecayPtFraction;      //! SS id, clusters id as pi0, coming from 1 photon, eta decay, pt vs pt decay / pt mother  
-  TH1F         * fhMCOtherDecayPt;            //! SS id, clusters id as pi0, coming from 1 photon, other decay, pt
+  TH2F         * fhMCPi0PtGenRecoFraction;    //! SS id, clusters id as pi0 (eta), coming from 2 photon, pi0 primary, pt vs E prim pi0 / E reco
+  TH2F         * fhMCEtaPtGenRecoFraction;    //! SS id, clusters id as pi0 (eta), coming from 2 photon, eta primary, pt vs E prim eta / E reco  
+  TH1F         * fhMCPi0DecayPt;              //! SS id, clusters id as pi0 (eta), coming from 1 photon, pi0 decay primary, pt
+  TH2F         * fhMCPi0DecayPtFraction;      //! SS id, clusters id as pi0 (eta), coming from 1 photon, pi0 decay primary, pt vs pt decay / pt mother
+  TH1F         * fhMCEtaDecayPt;              //! SS id, clusters id as pi0 (eta), coming from 1 photon, eta decay primary, pt
+  TH2F         * fhMCEtaDecayPtFraction;      //! SS id, clusters id as pi0 (eta), coming from 1 photon, eta decay primary, pt vs pt decay / pt mother  
+  TH1F         * fhMCOtherDecayPt;            //! SS id, clusters id as pi0 (eta), coming from 1 photon, other decay primary, pt
 
   TH2F         * fhMassPairMCPi0;             //! pair mass, origin is same pi0
   TH2F         * fhMassPairMCEta;             //! pair mass, origin is same eta
@@ -232,7 +232,7 @@ class AliAnaPi0EbE : public AliAnaCaloTrackCorrBaseClass {
   AliAnaPi0EbE(              const AliAnaPi0EbE & pi0ebe) ; // cpy ctor
   AliAnaPi0EbE & operator = (const AliAnaPi0EbE & pi0ebe) ; // cpy assignment
   
-  ClassDef(AliAnaPi0EbE,19)
+  ClassDef(AliAnaPi0EbE,20)
 } ;