//__________________________________________________________________
AliAnaInsideClusterInvariantMass::AliAnaInsideClusterInvariantMass() :
- AliAnaCaloTrackCorrBaseClass(),
- fCalorimeter(""),
- fMinNCells(0), fMinBadDist(0),
- fHistoECut(0), fCheckSplitDistToBad(0),
- fFillAngleHisto(kFALSE),
- fFillTMHisto(kFALSE),
- fFillTMResidualHisto(kFALSE),
- fFillSSExtraHisto(kFALSE),
- fFillMCHisto(kFALSE),
- fFillSSWeightHisto(kFALSE),
- fFillEbinHisto(0),
- fFillMCOverlapHisto(0),
- fFillNCellHisto(0),
- fFillIdConvHisto(0),
- fFillIdEtaHisto(0),
- fFillHighMultHisto(0),
- fFillArmenterosHisto(0),
- fSSWeightN(0), fSSECellCutN(0),
- fWSimu(0),
- fhMassAsyCutNLocMax1(0), fhMassAsyCutNLocMax2(0), fhMassAsyCutNLocMaxN(0),
- fhM02AsyCutNLocMax1(0), fhM02AsyCutNLocMax2(0), fhM02AsyCutNLocMaxN(0),
- fhMassM02CutNLocMax1(0), fhMassM02CutNLocMax2(0), fhMassM02CutNLocMaxN(0),
- fhAsymM02CutNLocMax1(0), fhAsymM02CutNLocMax2(0), fhAsymM02CutNLocMaxN(0),
- fhMassSplitECutNLocMax1(0), fhMassSplitECutNLocMax2(0), fhMassSplitECutNLocMaxN(0),
- fhMCGenFracAfterCutsNLocMax1MCPi0(0),
- fhMCGenFracAfterCutsNLocMax2MCPi0(0),
- fhMCGenFracAfterCutsNLocMaxNMCPi0(0),
- fhMCGenSplitEFracAfterCutsNLocMax1MCPi0(0),
- fhMCGenSplitEFracAfterCutsNLocMax2MCPi0(0),
- fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0(0),
- fhNCellMassEHighNLocMax1MCPi0(0), fhNCellM02EHighNLocMax1MCPi0(0),
- fhNCellMassELowNLocMax1MCPi0(0), fhNCellM02ELowNLocMax1MCPi0(0),
- fhNCellMassEHighNLocMax2MCPi0(0), fhNCellM02EHighNLocMax2MCPi0(0),
- fhNCellMassELowNLocMax2MCPi0(0), fhNCellM02ELowNLocMax2MCPi0(0),
- fhNCellMassEHighNLocMaxNMCPi0(0), fhNCellM02EHighNLocMaxNMCPi0(0),
- fhNCellMassELowNLocMaxNMCPi0(0), fhNCellM02ELowNLocMaxNMCPi0(0),
- fhCentralityPi0NLocMax1(0), fhCentralityEtaNLocMax1(0),
- fhCentralityPi0NLocMax2(0), fhCentralityEtaNLocMax2(0),
- fhCentralityPi0NLocMaxN(0), fhCentralityEtaNLocMaxN(0),
- fhEventPlanePi0NLocMax1(0), fhEventPlaneEtaNLocMax1(0),
- fhEventPlanePi0NLocMax2(0), fhEventPlaneEtaNLocMax2(0),
- fhEventPlanePi0NLocMaxN(0), fhEventPlaneEtaNLocMaxN(0),
- fhClusterEtaPhiNLocMax1(0), fhClusterEtaPhiNLocMax2(0), fhClusterEtaPhiNLocMaxN(0),
- fhPi0EtaPhiNLocMax1(0), fhPi0EtaPhiNLocMax2(0), fhPi0EtaPhiNLocMaxN(0),
- fhEtaEtaPhiNLocMax1(0), fhEtaEtaPhiNLocMax2(0), fhEtaEtaPhiNLocMaxN(0),
- fhPi0EPairDiffTimeNLM1(0), fhPi0EPairDiffTimeNLM2(0), fhPi0EPairDiffTimeNLMN(0),
- fhEtaEPairDiffTimeNLM1(0), fhEtaEPairDiffTimeNLM2(0), fhEtaEPairDiffTimeNLMN(0),
- fhMCPi0HighNLMPair(0), fhMCPi0LowNLMPair(0),
- fhMCPi0AnyNLMPair(0), fhMCPi0NoneNLMPair(0),
- fhMCPi0HighNLMPairNoMCMatch(0), fhMCPi0LowNLMPairNoMCMatch(0),
- fhMCPi0AnyNLMPairNoMCMatch(0), fhMCPi0NoneNLMPairNoMCMatch(0),
- fhMCPi0HighNLMPairOverlap(0), fhMCPi0LowNLMPairOverlap(0),
- fhMCPi0AnyNLMPairOverlap(0), fhMCPi0NoneNLMPairOverlap(0),
- fhMCPi0HighNLMPairNoMCMatchOverlap(0), fhMCPi0LowNLMPairNoMCMatchOverlap(0),
- fhMCPi0AnyNLMPairNoMCMatchOverlap(0), fhMCPi0NoneNLMPairNoMCMatchOverlap(0),
- fhMCPi0DecayPhotonHitHighLM(0), fhMCPi0DecayPhotonAdjHighLM(0),
- fhMCPi0DecayPhotonHitOtherLM(0), fhMCPi0DecayPhotonAdjOtherLM(0),
- fhMCPi0DecayPhotonAdjacent(0), fhMCPi0DecayPhotonHitNoLM(0),
- fhMCPi0DecayPhotonHitHighLMOverlap(0), fhMCPi0DecayPhotonAdjHighLMOverlap(0),
- fhMCPi0DecayPhotonHitOtherLMOverlap(0), fhMCPi0DecayPhotonAdjOtherLMOverlap(0),
- fhMCPi0DecayPhotonAdjacentOverlap(0), fhMCPi0DecayPhotonHitNoLMOverlap(0),
- fhMCEOverlapType(0), fhMCEOverlapTypeMatch(0)
+ AliAnaCaloTrackCorrBaseClass(), fCalorimeter(""),
+ fMinNCells(0), fMinBadDist(0),
+ fHistoECut(0), fCheckSplitDistToBad(0), fFillAngleHisto(kFALSE),
+ fFillTMHisto(kFALSE), fFillTMResidualHisto(kFALSE), fFillSSExtraHisto(kFALSE),
+ fFillMCHisto(kFALSE), fFillSSWeightHisto(kFALSE), fFillEbinHisto(0),
+ fFillMCOverlapHisto(0), fFillNCellHisto(0), fFillIdConvHisto(0),
+ fFillIdEtaHisto(0), fFillHighMultHisto(0), fFillArmenterosHisto(0),
+ fSSWeightN(0), fSSECellCutN(0), fWSimu(0),
+ fhMassAsyCutNLocMax1(0), fhMassAsyCutNLocMax2(0), fhMassAsyCutNLocMaxN(0),
+ fhM02AsyCutNLocMax1(0), fhM02AsyCutNLocMax2(0), fhM02AsyCutNLocMaxN(0),
+ fhMassM02CutNLocMax1(0), fhMassM02CutNLocMax2(0), fhMassM02CutNLocMaxN(0),
+ fhAsymM02CutNLocMax1(0), fhAsymM02CutNLocMax2(0), fhAsymM02CutNLocMaxN(0),
+ fhMassSplitECutNLocMax1(0), fhMassSplitECutNLocMax2(0), fhMassSplitECutNLocMaxN(0),
+ fhMCGenFracAfterCutsNLocMax1MCPi0(0), fhMCGenFracAfterCutsNLocMax2MCPi0(0), fhMCGenFracAfterCutsNLocMaxNMCPi0(0),
+ fhMCGenSplitEFracAfterCutsNLocMax1MCPi0(0),fhMCGenSplitEFracAfterCutsNLocMax2MCPi0(0),fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0(0),
+ fhNCellMassEHighNLocMax1MCPi0(0), fhNCellM02EHighNLocMax1MCPi0(0),
+ fhNCellMassELowNLocMax1MCPi0(0), fhNCellM02ELowNLocMax1MCPi0(0),
+ fhNCellMassEHighNLocMax2MCPi0(0), fhNCellM02EHighNLocMax2MCPi0(0),
+ fhNCellMassELowNLocMax2MCPi0(0), fhNCellM02ELowNLocMax2MCPi0(0),
+ fhNCellMassEHighNLocMaxNMCPi0(0), fhNCellM02EHighNLocMaxNMCPi0(0),
+ fhNCellMassELowNLocMaxNMCPi0(0), fhNCellM02ELowNLocMaxNMCPi0(0),
+ fhAnglePairPrimPi0RecoNLocMax1(0), fhAnglePairPrimPi0RecoNLocMax2(0), fhAnglePairPrimPi0RecoNLocMaxN(0),
+ fhAnglePairPrimPi0vsRecoNLocMax1(0), fhAnglePairPrimPi0vsRecoNLocMax2(0), fhAnglePairPrimPi0vsRecoNLocMaxN(0),
+ fhCentralityPi0NLocMax1(0), fhCentralityEtaNLocMax1(0),
+ fhCentralityPi0NLocMax2(0), fhCentralityEtaNLocMax2(0),
+ fhCentralityPi0NLocMaxN(0), fhCentralityEtaNLocMaxN(0),
+ fhEventPlanePi0NLocMax1(0), fhEventPlaneEtaNLocMax1(0),
+ fhEventPlanePi0NLocMax2(0), fhEventPlaneEtaNLocMax2(0),
+ fhEventPlanePi0NLocMaxN(0), fhEventPlaneEtaNLocMaxN(0),
+ fhClusterEtaPhiNLocMax1(0), fhClusterEtaPhiNLocMax2(0), fhClusterEtaPhiNLocMaxN(0),
+ fhPi0EtaPhiNLocMax1(0), fhPi0EtaPhiNLocMax2(0), fhPi0EtaPhiNLocMaxN(0),
+ fhEtaEtaPhiNLocMax1(0), fhEtaEtaPhiNLocMax2(0), fhEtaEtaPhiNLocMaxN(0),
+ fhPi0EPairDiffTimeNLM1(0), fhPi0EPairDiffTimeNLM2(0), fhPi0EPairDiffTimeNLMN(0),
+ fhEtaEPairDiffTimeNLM1(0), fhEtaEPairDiffTimeNLM2(0), fhEtaEPairDiffTimeNLMN(0),
+ fhMCPi0HighNLMPair(0), fhMCPi0LowNLMPair(0),
+ fhMCPi0AnyNLMPair(0), fhMCPi0NoneNLMPair(0),
+ fhMCPi0HighNLMPairNoMCMatch(0), fhMCPi0LowNLMPairNoMCMatch(0),
+ fhMCPi0AnyNLMPairNoMCMatch(0), fhMCPi0NoneNLMPairNoMCMatch(0),
+ fhMCPi0HighNLMPairOverlap(0), fhMCPi0LowNLMPairOverlap(0),
+ fhMCPi0AnyNLMPairOverlap(0), fhMCPi0NoneNLMPairOverlap(0),
+ fhMCPi0HighNLMPairNoMCMatchOverlap(0), fhMCPi0LowNLMPairNoMCMatchOverlap(0),
+ fhMCPi0AnyNLMPairNoMCMatchOverlap(0), fhMCPi0NoneNLMPairNoMCMatchOverlap(0),
+ fhMCPi0DecayPhotonHitHighLM(0), fhMCPi0DecayPhotonAdjHighLM(0),
+ fhMCPi0DecayPhotonHitOtherLM(0), fhMCPi0DecayPhotonAdjOtherLM(0),
+ fhMCPi0DecayPhotonAdjacent(0), fhMCPi0DecayPhotonHitNoLM(0),
+ fhMCPi0DecayPhotonHitHighLMOverlap(0), fhMCPi0DecayPhotonAdjHighLMOverlap(0),
+ fhMCPi0DecayPhotonHitOtherLMOverlap(0), fhMCPi0DecayPhotonAdjOtherLMOverlap(0),
+ fhMCPi0DecayPhotonAdjacentOverlap(0), fhMCPi0DecayPhotonHitNoLMOverlap(0),
+ fhMCEOverlapType(0), fhMCEOverlapTypeMatch(0)
{
//default ctor
fhSplitEFractionNLocMax2[i][j]=0;
fhSplitEFractionNLocMaxN[i][j]=0;
+ fhAnglePairNLocMax1 [i][j] = 0;
+ fhAnglePairNLocMax2 [i][j] = 0;
+ fhAnglePairNLocMaxN [i][j] = 0;
+ fhAnglePairMassNLocMax1[i][j] = 0;
+ fhAnglePairMassNLocMax2[i][j] = 0;
+ fhAnglePairMassNLocMaxN[i][j] = 0;
+
fhMCGenFracNLocMax1[i][j]= 0;
fhMCGenFracNLocMax2[i][j]= 0;
fhMCGenFracNLocMaxN[i][j]= 0;
for(Int_t i = 0; i < 2; i++)
{
- fhAnglePairNLocMax1 [i] = 0;
- fhAnglePairNLocMax2 [i] = 0;
- fhAnglePairNLocMaxN [i] = 0;
- fhAnglePairMassNLocMax1[i] = 0;
- fhAnglePairMassNLocMax2[i] = 0;
- fhAnglePairMassNLocMaxN[i] = 0;
fhSplitEFractionvsAsyNLocMax1[i] = 0;
fhSplitEFractionvsAsyNLocMax2[i] = 0;
fhSplitEFractionvsAsyNLocMaxN[i] = 0;
}
-//___________________________________________________________________________________________________________________
-void AliAnaInsideClusterInvariantMass::FillAngleHistograms(const Int_t nMax, const Bool_t matched,
- const Float_t en, const Float_t angle, const Float_t mass)
+//_____________________________________________________________________________________________________________________
+void AliAnaInsideClusterInvariantMass::FillAngleHistograms(const Int_t nMax, const Bool_t matched, const Int_t mcIndex,
+ const Float_t en, const Float_t angle, const Float_t mass,
+ const Float_t anglePrim)
{
// Fill histograms related to opening angle
if (nMax==1)
{
- fhAnglePairNLocMax1[matched]->Fill(en,angle);
- if( en > fHistoECut ) fhAnglePairMassNLocMax1[matched]->Fill(mass,angle);
+ fhAnglePairNLocMax1[0][matched]->Fill(en,angle);
+ if( en > 15 ) fhAnglePairMassNLocMax1[0][matched]->Fill(mass,angle);
}
else if(nMax==2)
{
- fhAnglePairNLocMax2[matched]->Fill(en,angle);
- if( en > fHistoECut ) fhAnglePairMassNLocMax2[matched]->Fill(mass,angle);
+ fhAnglePairNLocMax2[0][matched]->Fill(en,angle);
+ if( en > fHistoECut ) fhAnglePairMassNLocMax2[0][matched]->Fill(mass,angle);
}
else if(nMax >2)
{
- fhAnglePairNLocMaxN[matched]->Fill(en,angle);
- if( en > fHistoECut ) fhAnglePairMassNLocMaxN[matched]->Fill(mass,angle);
+ fhAnglePairNLocMaxN[0][matched]->Fill(en,angle);
+ if( en > fHistoECut ) fhAnglePairMassNLocMaxN[0][matched]->Fill(mass,angle);
+ }
+
+ if(IsDataMC() && mcIndex > 0 && mcIndex < 7)
+ {
+ if (nMax==1)
+ {
+ fhAnglePairNLocMax1[mcIndex][matched]->Fill(en,angle);
+ if( en > fHistoECut ) fhAnglePairMassNLocMax1[mcIndex][matched]->Fill(mass,angle);
+ if((mcIndex == kmcPi0 || mcIndex == kmcPi0Conv) && !matched && anglePrim > 0)
+ {
+ fhAnglePairPrimPi0RecoNLocMax1->Fill(en,angle/anglePrim);
+ if(en > 15) fhAnglePairPrimPi0vsRecoNLocMax1->Fill(anglePrim,angle);
+
+ }
+ }
+ else if(nMax==2)
+ {
+ fhAnglePairNLocMax2[mcIndex][matched]->Fill(en,angle);
+ if( en > fHistoECut ) fhAnglePairMassNLocMax2[mcIndex][matched]->Fill(mass,angle);
+ if((mcIndex == kmcPi0 || mcIndex == kmcPi0Conv) && !matched && anglePrim > 0)
+ {
+ fhAnglePairPrimPi0RecoNLocMax2->Fill(en,angle/anglePrim);
+ if(en > 10) fhAnglePairPrimPi0vsRecoNLocMax2->Fill(anglePrim,angle);
+ }
+ }
+ else if(nMax >2)
+ {
+ fhAnglePairNLocMaxN[mcIndex][matched]->Fill(en,angle);
+ if( en > fHistoECut ) fhAnglePairMassNLocMaxN[mcIndex][matched]->Fill(mass,angle);
+ if((mcIndex == kmcPi0 || mcIndex == kmcPi0Conv) && !matched && anglePrim > 0)
+ {
+ fhAnglePairPrimPi0RecoNLocMaxN->Fill(en,angle/anglePrim);
+ if(en > 10) fhAnglePairPrimPi0vsRecoNLocMaxN->Fill(anglePrim,angle);
+ }
+ }
+
}
+
}
const Float_t m02, const Int_t pid)
{
// Fill Armeteros type histograms
+
+ // Get pTArm and AlphaArm
+
+ Float_t momentumSquaredMother = pi0.P()*pi0.P();
+ Float_t momentumDaughter1AlongMother = 0.;
+ Float_t momentumDaughter2AlongMother = 0.;
+
+ if (momentumSquaredMother > 0.)
+ {
+ momentumDaughter1AlongMother = (g1.Px()*pi0.Px() + g1.Py()*pi0.Py()+ g1.Pz()*pi0.Pz()) / sqrt(momentumSquaredMother);
+ momentumDaughter2AlongMother = (g2.Px()*pi0.Px() + g2.Py()*pi0.Py()+ g2.Pz()*pi0.Pz()) / sqrt(momentumSquaredMother);
+ }
+
+ Float_t momentumSquaredDaughter1 = g1.P()*g1.P();
+ Float_t ptArmSquared = momentumSquaredDaughter1 - momentumDaughter1AlongMother*momentumDaughter1AlongMother;
+
+ Float_t pTArm = 0.;
+ if (ptArmSquared > 0.)
+ pTArm = sqrt(ptArmSquared);
+
+ Float_t alphaArm = 0.;
+ if(momentumDaughter1AlongMother +momentumDaughter2AlongMother > 0)
+ alphaArm = (momentumDaughter1AlongMother -momentumDaughter2AlongMother) / (momentumDaughter1AlongMother + momentumDaughter2AlongMother);
+
Float_t en = pi0.Energy();
Float_t asym = TMath::Abs( g1.Energy()-g2.Energy() )/( g1.Energy()+g2.Energy() ) ;
-
+
+ if(GetDebug() > 2 ) printf("AliAnaInsideClusterInvariantMass::FillArmenterosHistograms() - E %f, alphaArm %f, pTArm %f\n",en,alphaArm,pTArm);
+
Bool_t m02OK = GetCaloPID()->IsInPi0M02Range(en,m02,nMax);
Bool_t asyOK = GetCaloPID()->IsInPi0SplitAsymmetryRange(en,asym,nMax);
Bool_t m02On = GetCaloPID()->IsSplitShowerShapeCutOn();
Bool_t asyOn = GetCaloPID()->IsSplitAsymmetryCutOn();
-
- // TO DO THE CALCULATIONS
- Float_t epsilon = 0;
- Float_t alpha = 0;
-// Float_t angle = g2.Angle(g1.Vect());
-// Float_t phiPi0 = pi0.Phi();
-// Float_t phiGam1 = g1.Phi();
-// Float_t phiGam2 = g2.Phi();
-//
-// printf("Phi: Pi0 %f, G1 %f, G2, %f, OpAng %f, G1-G2 %f, Pi0-G1 %f, Pi0-G2 %f, \n",phiPi0,phiGam1,phiGam2,angle,phiGam2-phiGam1,phiPi0-phiGam1,phiPi0-phiGam2);
if (nMax==1)
{
- fhArmNLocMax1[0][ebin]->Fill(epsilon,alpha);
+ fhArmNLocMax1[0][ebin]->Fill(alphaArm,pTArm);
if((m02OK && asyOK) && (asyOn || m02On))
- fhArmAfterCutsNLocMax1[0][ebin]->Fill(epsilon,alpha);
+ fhArmAfterCutsNLocMax1[0][ebin]->Fill(alphaArm,pTArm);
if(pid==AliCaloPID::kPi0)
- fhArmPi0NLocMax1[0][ebin]->Fill(epsilon,alpha);
+ fhArmPi0NLocMax1[0][ebin]->Fill(alphaArm,pTArm);
}
else if(nMax==2)
{
- fhArmNLocMax2[0][ebin]->Fill(epsilon,alpha);
+ fhArmNLocMax2[0][ebin]->Fill(alphaArm,pTArm);
if((m02OK && asyOK) && (asyOn || m02On))
- fhArmAfterCutsNLocMax2[0][ebin]->Fill(epsilon,alpha);
+ fhArmAfterCutsNLocMax2[0][ebin]->Fill(alphaArm,pTArm);
if(pid==AliCaloPID::kPi0)
- fhArmPi0NLocMax2[0][ebin]->Fill(epsilon,alpha);
+ fhArmPi0NLocMax2[0][ebin]->Fill(alphaArm,pTArm);
}
else if(nMax >2)
{
- fhArmNLocMaxN[0][ebin]->Fill(epsilon,alpha);
+ fhArmNLocMaxN[0][ebin]->Fill(alphaArm,pTArm);
if((m02OK && asyOK) && (asyOn || m02On))
- fhArmAfterCutsNLocMaxN[0][ebin]->Fill(epsilon,alpha);
+ fhArmAfterCutsNLocMaxN[0][ebin]->Fill(alphaArm,pTArm);
if(pid==AliCaloPID::kPi0)
- fhArmPi0NLocMaxN[0][ebin]->Fill(epsilon,alpha);
+ fhArmPi0NLocMaxN[0][ebin]->Fill(alphaArm,pTArm);
}
if(IsDataMC() && mcIndex > 0 && mcIndex < 7)
{
if (nMax==1)
{
- fhArmNLocMax1[mcIndex][ebin]->Fill(epsilon,alpha);
+ fhArmNLocMax1[mcIndex][ebin]->Fill(alphaArm,pTArm);
if((m02OK && asyOK) && (asyOn || m02On))
- fhArmAfterCutsNLocMax1[mcIndex][ebin]->Fill(epsilon,alpha);
+ fhArmAfterCutsNLocMax1[mcIndex][ebin]->Fill(alphaArm,pTArm);
if(pid==AliCaloPID::kPi0)
- fhArmPi0NLocMax1[mcIndex][ebin]->Fill(epsilon,alpha);
+ fhArmPi0NLocMax1[mcIndex][ebin]->Fill(alphaArm,pTArm);
}
else if(nMax==2)
{
- fhArmNLocMax2[mcIndex][ebin]->Fill(epsilon,alpha);
+ fhArmNLocMax2[mcIndex][ebin]->Fill(alphaArm,pTArm);
if((m02OK && asyOK) && (asyOn || m02On))
- fhArmAfterCutsNLocMax2[mcIndex][ebin]->Fill(epsilon,alpha);
+ fhArmAfterCutsNLocMax2[mcIndex][ebin]->Fill(alphaArm,pTArm);
if(pid==AliCaloPID::kPi0)
- fhArmPi0NLocMax2[mcIndex][ebin]->Fill(epsilon,alpha);
+ fhArmPi0NLocMax2[mcIndex][ebin]->Fill(alphaArm,pTArm);
}
else if(nMax >2)
{
- fhArmNLocMaxN[mcIndex][ebin]->Fill(epsilon,alpha);
+ fhArmNLocMaxN[mcIndex][ebin]->Fill(alphaArm,pTArm);
if((m02OK && asyOK) && (asyOn || m02On))
- fhArmAfterCutsNLocMaxN[mcIndex][ebin]->Fill(epsilon,alpha);
+ fhArmAfterCutsNLocMaxN[mcIndex][ebin]->Fill(alphaArm,pTArm);
if(pid==AliCaloPID::kPi0)
- fhArmPi0NLocMaxN[mcIndex][ebin]->Fill(epsilon,alpha);
+ fhArmPi0NLocMaxN[mcIndex][ebin]->Fill(alphaArm,pTArm);
}
}
TString pname[] ={"","Photon","Conversion", "Pi0", "Pi0Conv", "Eta","Hadron"};
TString snlm [] = {"1","2","N"};
+ TString sEBin[] = {"8 < E < 12 GeV","12 < E < 16 GeV", "16 < E < 20 GeV", "E > 20 GeV" };
+
Int_t n = 1;
if(IsDataMC()) n = 7;
{
fhMassSplitEFractionNLocMax1Ebin[i][j] = new TH2F(Form("hMassSplitEFractionNLocMax1%sEbin%d",pname[i].Data(),j),
- Form("Invariant mass of 2 highest energy cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j),
+ Form("Invariant mass of 2 highest energy cells vs (E1+E2)/Ecluster, %s, %s",ptype[i].Data(),sEBin[j].Data()),
120,0,1.2,mbins,mmin,mmax);
fhMassSplitEFractionNLocMax1Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
fhMassSplitEFractionNLocMax1Ebin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}");
outputContainer->Add(fhMassSplitEFractionNLocMax1Ebin[i][j]) ;
fhMassSplitEFractionNLocMax2Ebin[i][j] = new TH2F(Form("hMassSplitEFractionNLocMax2%sEbin%d",pname[i].Data(),j),
- Form("Invariant mass of 2 local maxima cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j),
+ Form("Invariant mass of 2 local maxima cells vs (E1+E2)/Ecluster, %s, %s",ptype[i].Data(),sEBin[j].Data()),
120,0,1.2,mbins,mmin,mmax);
fhMassSplitEFractionNLocMax2Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
fhMassSplitEFractionNLocMax2Ebin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}");
outputContainer->Add(fhMassSplitEFractionNLocMax2Ebin[i][j]) ;
fhMassSplitEFractionNLocMaxNEbin[i][j] = new TH2F(Form("hMassSplitEFractionNLocMaxN%sEbin%d",pname[i].Data(),j),
- Form("Invariant mass of N>2 local maxima cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j),
+ Form("Invariant mass of N>2 local maxima cells vs (E1+E2)/Ecluster, %s, %s",ptype[i].Data(),sEBin[j].Data()),
120,0,1.2,mbins,mmin,mmax);
fhMassSplitEFractionNLocMaxNEbin[i][j]->SetYTitle("M (GeV/c^{2})");
fhMassSplitEFractionNLocMaxNEbin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}");
if(i>0 && fFillMCHisto) // skip first entry in array, general case not filled
{
fhMCGenFracNLocMaxEbin[i][j] = new TH2F(Form("hMCGenFracNLocMax%sEbin%d",pname[i].Data(),j),
- Form("NLM vs E, %s, E bin %d",ptype[i].Data(),j),
+ Form("NLM vs E, %s, %s",ptype[i].Data(),sEBin[j].Data()),
200,0,2,nMaxBins,0,nMaxBins);
fhMCGenFracNLocMaxEbin[i][j]->SetYTitle("NLM");
fhMCGenFracNLocMaxEbin[i][j]->SetXTitle("E_{gen} / E_{reco}");
outputContainer->Add(fhMCGenFracNLocMaxEbin[i][j]) ;
fhMCGenFracNLocMaxEbinMatched[i][j] = new TH2F(Form("hMCGenFracNLocMax%sEbin%dMatched",pname[i].Data(),j),
- Form("NLM vs E, %s, E bin %d, matched to a track",ptype[i].Data(),j),
+ Form("NLM vs E, %s, %s, matched to a track",ptype[i].Data(),sEBin[j].Data()),
200,0,2,nMaxBins,0,nMaxBins);
fhMCGenFracNLocMaxEbinMatched[i][j]->SetYTitle("NLM");
fhMCGenFracNLocMaxEbinMatched[i][j]->SetXTitle("E_{gen} / E_{reco}");
outputContainer->Add(fhMCGenFracNLocMaxEbinMatched[i][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),
+ Form("Invariant mass of 2 highest energy cells vs E, %s, %s",ptype[i].Data(),sEBin[j].Data()),
200,0,2,mbins,mmin,mmax);
fhMassMCGenFracNLocMax1Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
fhMassMCGenFracNLocMax1Ebin[i][j]->SetXTitle("E_{gen} / E_{reco}");
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),
+ Form("Invariant mass of 2 local maxima cells vs E, %s, %s",ptype[i].Data(),sEBin[j].Data()),
200,0,2,mbins,mmin,mmax);
fhMassMCGenFracNLocMax2Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
fhMassMCGenFracNLocMax2Ebin[i][j]->SetXTitle("E_{gen} / E_{reco}");
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),
+ Form("Invariant mass of N>2 local maxima cells vs E, %s, %s",ptype[i].Data(),sEBin[j].Data()),
200,0,2,mbins,mmin,mmax);
fhMassMCGenFracNLocMaxNEbin[i][j]->SetYTitle("M (GeV/c^{2})");
fhMassMCGenFracNLocMaxNEbin[i][j]->SetXTitle("E_{gen} / E_{reco}");
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),
+ Form("#lambda_{0}^{2} vs E for N max = 1 %s, %s",ptype[i].Data(),sEBin[j].Data()),
200,0,2,ssbins,ssmin,ssmax);
fhM02MCGenFracNLocMax1Ebin[i][j] ->SetYTitle("#lambda_{0}^{2}");
fhM02MCGenFracNLocMax1Ebin[i][j] ->SetXTitle("E_{gen} / E_{reco}");
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),
+ Form("#lambda_{0}^{2} vs E for N max = 2 %s, %s",ptype[i].Data(),sEBin[j].Data()),
200,0,2,ssbins,ssmin,ssmax);
fhM02MCGenFracNLocMax2Ebin[i][j] ->SetYTitle("#lambda_{0}^{2}");
fhM02MCGenFracNLocMax2Ebin[i][j] ->SetXTitle("E_{gen} / E_{reco}");
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),
+ Form("#lambda_{0}^{2} vs E for N max > 2 %s, %s",ptype[i].Data(),sEBin[j].Data()),
200,0,2,ssbins,ssmin,ssmax);
fhM02MCGenFracNLocMaxNEbin[i][j] ->SetYTitle("#lambda_{0}^{2}");
fhM02MCGenFracNLocMaxNEbin[i][j] ->SetXTitle("E_{gen} / E_{reco}");
for(Int_t i = 0; i < 4; i++)
{
fhMassM02NLocMax1Ebin[i] = new TH2F(Form("hMassM02NLocMax1Ebin%d",i),
- Form("Invariant mass of split clusters vs #lambda_{0}^{2}, NLM=1, E bin %d",i),
+ Form("Invariant mass of split clusters vs #lambda_{0}^{2}, NLM=1, %s",sEBin[i].Data()),
ssbins,ssmin,ssmax,mbins,mmin,mmax);
fhMassM02NLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
fhMassM02NLocMax1Ebin[i]->SetXTitle("#lambda_{0}^{2}");
outputContainer->Add(fhMassM02NLocMax1Ebin[i]) ;
fhMassM02NLocMax2Ebin[i] = new TH2F(Form("hMassM02NLocMax2Ebin%d",i),
- Form("Invariant mass of split clusters vs #lambda_{0}^{2}, NLM=2, E bin %d",i),
+ Form("Invariant mass of split clusters vs #lambda_{0}^{2}, NLM=2, %s",sEBin[i].Data()),
ssbins,ssmin,ssmax,mbins,mmin,mmax);
fhMassM02NLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
fhMassM02NLocMax2Ebin[i]->SetXTitle("#lambda_{0}^{2}");
outputContainer->Add(fhMassM02NLocMax2Ebin[i]) ;
fhMassM02NLocMaxNEbin[i] = new TH2F(Form("hMassM02NLocMaxNEbin%d",i),
- Form("Invariant mass of split clusters vs vs #lambda_{0}^{2}, NLM>2, E bin %d",i),
+ Form("Invariant mass of split clusters vs vs #lambda_{0}^{2}, NLM>2, %s",sEBin[i].Data()),
ssbins,ssmin,ssmax,mbins,mmin,mmax);
fhMassM02NLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
fhMassM02NLocMaxNEbin[i]->SetXTitle("#lambda_{0}^{2}");
fhMassAsyNLocMax1Ebin[i] = new TH2F(Form("hMassAsyNLocMax1Ebin%d",i),
- Form("Invariant mass of split clusters vs split asymmetry, NLM=1, E bin %d",i),
+ Form("Invariant mass of split clusters vs split asymmetry, NLM=1, %s",sEBin[i].Data()),
200,-1,1,mbins,mmin,mmax);
fhMassAsyNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
fhMassAsyNLocMax1Ebin[i]->SetXTitle("asymmetry");
outputContainer->Add(fhMassAsyNLocMax1Ebin[i]) ;
fhMassAsyNLocMax2Ebin[i] = new TH2F(Form("hMassAsyNLocMax2Ebin%d",i),
- Form("Invariant mass of split clusters vs split asymmetry, NLM=2, E bin %d",i),
+ Form("Invariant mass of split clusters vs split asymmetry, NLM=2, %s",sEBin[i].Data()),
200,-1,1,mbins,mmin,mmax);
fhMassAsyNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
fhMassAsyNLocMax2Ebin[i]->SetXTitle("asymmetry");
outputContainer->Add(fhMassAsyNLocMax2Ebin[i]) ;
fhMassAsyNLocMaxNEbin[i] = new TH2F(Form("hMassAsyNLocMaxNEbin%d",i),
- Form("Invariant mass of split clusters vs split asymmetry, NLM>2, E bin %d",i),
+ Form("Invariant mass of split clusters vs split asymmetry, NLM>2, %s",sEBin[i].Data()),
200,-1,1,mbins,mmin,mmax);
fhMassAsyNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
fhMassAsyNLocMaxNEbin[i]->SetXTitle("asymmetry");
if(IsDataMC() && fFillMCHisto)
{
fhMCAsymM02NLocMax1MCPi0Ebin[i] = new TH2F(Form("hMCAsymM02NLocMax1MCPi0Ebin%d",i),
- Form("Asymmetry of MC #pi^{0} vs #lambda_{0}^{2}, NLM=1, E bin %d",i),
+ Form("Asymmetry of MC #pi^{0} vs #lambda_{0}^{2}, NLM=1, %s",sEBin[i].Data()),
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} vs #lambda_{0}^{2}, NLM=2, E bin %d",i),
+ Form("Asymmetry of MC #pi^{0} vs #lambda_{0}^{2}, NLM=2, %s",sEBin[i].Data()),
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} vs #lambda_{0}^{2}, NLM>2, E bin %d",i),
+ Form("Asymmetry of MC #pi^{0} vs #lambda_{0}^{2}, NLM>2, %s",sEBin[i].Data()),
ssbins,ssmin,ssmax,100,0,1);
fhMCAsymM02NLocMaxNMCPi0Ebin[i]->SetYTitle("Decay asymmetry");
fhMCAsymM02NLocMaxNMCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}");
fhAsyMCGenRecoNLocMax1EbinPi0[i] = new TH2F(Form("hAsyMCGenRecoNLocMax1Ebin%dPi0",i),
- Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM=1, E bin %d",i),
+ Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM=1, %s",sEBin[i].Data()),
200,-1,1,200,-1,1);
fhAsyMCGenRecoNLocMax1EbinPi0[i]->SetYTitle("M (GeV/c^{2})");
fhAsyMCGenRecoNLocMax1EbinPi0[i]->SetXTitle("asymmetry");
outputContainer->Add(fhAsyMCGenRecoNLocMax1EbinPi0[i]) ;
fhAsyMCGenRecoNLocMax2EbinPi0[i] = new TH2F(Form("hAsyMCGenRecoNLocMax2Ebin%dPi0",i),
- Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM=2, E bin %d",i),
+ Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM=2, %s",sEBin[i].Data()),
200,-1,1,200,-1,1);
fhAsyMCGenRecoNLocMax2EbinPi0[i]->SetYTitle("M (GeV/c^{2})");
fhAsyMCGenRecoNLocMax2EbinPi0[i]->SetXTitle("asymmetry");
outputContainer->Add(fhAsyMCGenRecoNLocMax2EbinPi0[i]) ;
fhAsyMCGenRecoNLocMaxNEbinPi0[i] = new TH2F(Form("hAsyMCGenRecoNLocMaxNEbin%dPi0",i),
- Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM>2, E bin %d",i),
+ Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM>2, %s",sEBin[i].Data()),
200,-1,1,200,-1,1);
fhAsyMCGenRecoNLocMaxNEbinPi0[i]->SetYTitle("M (GeV/c^{2})");
fhAsyMCGenRecoNLocMaxNEbinPi0[i]->SetXTitle("asymmetry");
if(fFillSSExtraHisto)
{
fhMassDispEtaNLocMax1Ebin[i] = new TH2F(Form("hMassDispEtaNLocMax1Ebin%d",i),
- Form("Invariant mass of 2 highest energy cells #sigma_{#eta #eta}^{2}, E bin %d",i),
+ Form("Invariant mass of 2 highest energy cells #sigma_{#eta #eta}^{2}, %s",sEBin[i].Data()),
ssbins,ssmin,ssmax,mbins,mmin,mmax);
fhMassDispEtaNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
fhMassDispEtaNLocMax1Ebin[i]->SetXTitle("#sigma_{#eta #eta}^{2}");
outputContainer->Add(fhMassDispEtaNLocMax1Ebin[i]) ;
fhMassDispEtaNLocMax2Ebin[i] = new TH2F(Form("hMassDispEtaNLocMax2Ebin%d",i),
- Form("Invariant mass of 2 local maxima cells #sigma_{#eta #eta}^{2}, E bin %d",i),
+ Form("Invariant mass of 2 local maxima cells #sigma_{#eta #eta}^{2}, %s",sEBin[i].Data()),
ssbins,ssmin,ssmax,mbins,mmin,mmax);
fhMassDispEtaNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
fhMassDispEtaNLocMax2Ebin[i]->SetXTitle("#sigma_{#eta #eta}^{2}");
outputContainer->Add(fhMassDispEtaNLocMax2Ebin[i]) ;
fhMassDispEtaNLocMaxNEbin[i] = new TH2F(Form("hMassDispEtaNLocMaxNEbin%d",i),
- Form("Invariant mass of N>2 local maxima cells vs #sigma_{#eta #eta}^{2}, E bin %d",i),
+ Form("Invariant mass of N>2 local maxima cells vs #sigma_{#eta #eta}^{2}, %s",sEBin[i].Data()),
ssbins,ssmin,ssmax,mbins,mmin,mmax);
fhMassDispEtaNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
fhMassDispEtaNLocMaxNEbin[i]->SetXTitle("#sigma_{#eta #eta}^{2}");
outputContainer->Add(fhMassDispEtaNLocMaxNEbin[i]) ;
fhMassDispPhiNLocMax1Ebin[i] = new TH2F(Form("hMassDispPhiNLocMax1Ebin%d",i),
- Form("Invariant mass of 2 highest energy cells #sigma_{#phi #phi}^{2}, E bin %d",i),
+ Form("Invariant mass of 2 highest energy cells #sigma_{#phi #phi}^{2}, %s",sEBin[i].Data()),
ssbins,ssmin,ssmax,mbins,mmin,mmax);
fhMassDispPhiNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
fhMassDispPhiNLocMax1Ebin[i]->SetXTitle("#sigma_{#phi #phi}^{2}");
outputContainer->Add(fhMassDispPhiNLocMax1Ebin[i]) ;
fhMassDispPhiNLocMax2Ebin[i] = new TH2F(Form("hMassDispPhiNLocMax2Ebin%d",i),
- Form("Invariant mass of 2 local maxima cells #sigma_{#phi #phi}^{2}, E bin %d",i),
+ Form("Invariant mass of 2 local maxima cells #sigma_{#phi #phi}^{2}, %s",sEBin[i].Data()),
ssbins,ssmin,ssmax,mbins,mmin,mmax);
fhMassDispPhiNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
fhMassDispPhiNLocMax2Ebin[i]->SetXTitle("#sigma_{#phi #phi}^{2}");
outputContainer->Add(fhMassDispPhiNLocMax2Ebin[i]) ;
fhMassDispPhiNLocMaxNEbin[i] = new TH2F(Form("hMassDispPhiNLocMaxNEbin%d",i),
- Form("Invariant mass of N>2 local maxima cells vs #sigma_{#phi #phi}^{2}, E bin %d",i),
+ Form("Invariant mass of N>2 local maxima cells vs #sigma_{#phi #phi}^{2}, %s",sEBin[i].Data()),
ssbins,ssmin,ssmax,mbins,mmin,mmax);
fhMassDispPhiNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
fhMassDispPhiNLocMaxNEbin[i]->SetXTitle("#sigma_{#phi #phi}^{2}");
outputContainer->Add(fhMassDispPhiNLocMaxNEbin[i]) ;
fhMassDispAsyNLocMax1Ebin[i] = new TH2F(Form("hMassDispAsyNLocMax1Ebin%d",i),
- Form("Invariant mass of 2 highest energy cells A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), E bin %d",i),
+ Form("Invariant mass of 2 highest energy cells A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), %s",sEBin[i].Data()),
200,-1,1,mbins,mmin,mmax);
fhMassDispAsyNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
fhMassDispAsyNLocMax1Ebin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
outputContainer->Add(fhMassDispAsyNLocMax1Ebin[i]) ;
fhMassDispAsyNLocMax2Ebin[i] = new TH2F(Form("hMassDispAsyNLocMax2Ebin%d",i),
- Form("Invariant mass of 2 local maxima cells A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), E bin %d",i),
+ Form("Invariant mass of 2 local maxima cells A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), %s",sEBin[i].Data()),
200,-1,1,mbins,mmin,mmax);
fhMassDispAsyNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
fhMassDispAsyNLocMax2Ebin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
outputContainer->Add(fhMassDispAsyNLocMax2Ebin[i]) ;
fhMassDispAsyNLocMaxNEbin[i] = new TH2F(Form("hMassDispAsyNLocMaxNEbin%d",i),
- Form("Invariant mass of N>2 local maxima cells vs A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), E bin %d",i),
+ Form("Invariant mass of N>2 local maxima cells vs A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), %s",sEBin[i].Data()),
200,-1,1,mbins,mmin,mmax);
fhMassDispAsyNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
fhMassDispAsyNLocMaxNEbin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
if(fFillAngleHisto)
{
- for(Int_t j = 0; j < nMatched; j++)
- {
+ for(Int_t i = 0; i < n; i++)
+ {
+ for(Int_t j = 0; j < nMatched; j++)
+ {
+
+ fhM02ConNLocMax1[i][j] = new TH2F(Form("hM02ConNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
+ Form("#lambda_{0}^{2} vs E, %s, for NLM = 1",ptype[i].Data()),
+ nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+
+
+ fhAnglePairNLocMax1[i][j] = new TH2F(Form("hAnglePairNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
+ Form("Opening angle split sub-clusters of cluster NLM=1 vs pair Energy, %s, %s",ptype[i].Data(),sMatched[j].Data()),
+ nptbins,ptmin,ptmax,200,0,0.2);
+ fhAnglePairNLocMax1[i][j]->SetYTitle("#alpha (rad)");
+ fhAnglePairNLocMax1[i][j]->SetXTitle("E (GeV)");
+ outputContainer->Add(fhAnglePairNLocMax1[i][j]) ;
+
+ fhAnglePairNLocMax2[i][j] = new TH2F(Form("hAnglePairNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
+ Form("Opening angle split sub-clusters of cluster NLM=2 cells vs Energy, %s, %s",ptype[i].Data(),sMatched[j].Data()),
+ nptbins,ptmin,ptmax,200,0,0.2);
+ fhAnglePairNLocMax2[i][j]->SetYTitle("#alpha (rad)");
+ fhAnglePairNLocMax2[i][j]->SetXTitle("E (GeV)");
+ outputContainer->Add(fhAnglePairNLocMax2[i][j]) ;
+
+ fhAnglePairNLocMaxN[i][j] = new TH2F(Form("hAnglePairNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
+ Form("Opening angle split sub-clusters of cluster NLM>2 vs Energy, %s, %s",ptype[i].Data(),sMatched[j].Data()),
+ nptbins,ptmin,ptmax,200,0,0.2);
+ fhAnglePairNLocMaxN[i][j]->SetYTitle("#alpha (rad)");
+ fhAnglePairNLocMaxN[i][j]->SetXTitle("E (GeV)");
+ outputContainer->Add(fhAnglePairNLocMaxN[i][j]) ;
+
+ fhAnglePairMassNLocMax1[i][j] = new TH2F(Form("hAnglePairMassNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
+ Form("Opening angle split sub-clusters of cluster NLM=1 vs Mass for E > 12 GeV, %s, %s",ptype[i].Data(),sMatched[j].Data()),
+ mbins,mmin,mmax,200,0,0.2);
+ fhAnglePairMassNLocMax1[i][j]->SetXTitle("M (GeV/c^{2})");
+ fhAnglePairMassNLocMax1[i][j]->SetYTitle("#alpha (rad)");
+ outputContainer->Add(fhAnglePairMassNLocMax1[i][j]) ;
+
+ fhAnglePairMassNLocMax2[i][j] = new TH2F(Form("hAnglePairMassNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
+ Form("Opening angle split sub-clusters of cluster NLM=2 vs Mass for E > 12 GeV, %s, %s",ptype[i].Data(),sMatched[j].Data()),
+ mbins,mmin,mmax,200,0,0.2);
+ fhAnglePairMassNLocMax2[i][j]->SetXTitle("M (GeV/c^{2})");
+ fhAnglePairMassNLocMax2[i][j]->SetYTitle("#alpha (rad)");
+ outputContainer->Add(fhAnglePairMassNLocMax2[i][j]) ;
+
+ fhAnglePairMassNLocMaxN[i][j] = new TH2F(Form("hAnglePairMassNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
+ Form("Opening angle split sub-clusters of cluster NLM>2 vs Mass for E > 12 GeV, %s, %s",ptype[i].Data(),sMatched[j].Data()),
+ mbins,mmin,mmax,200,0,0.2);
+ fhAnglePairMassNLocMaxN[i][j]->SetXTitle("M (GeV/c^{2})");
+ fhAnglePairMassNLocMaxN[i][j]->SetYTitle("#alpha (rad)");
+ outputContainer->Add(fhAnglePairMassNLocMaxN[i][j]) ;
+
+ }
+ }
+
+ if(IsDataMC())
+ {
+ fhAnglePairPrimPi0RecoNLocMax1 = new TH2F("fhAnglePairPrimPi0RecoNLocMax1",
+ "Opening angle split neutral sub-clusters reconstructed / generated #pi^{0} vs pair Energy, NLM=1",
+ nptbins,ptmin,ptmax,300,0,3);
+ fhAnglePairPrimPi0RecoNLocMax1->SetYTitle("#alpha_{reco} / #alpha_{gen}");
+ fhAnglePairPrimPi0RecoNLocMax1->SetXTitle("E (GeV)");
+ outputContainer->Add(fhAnglePairPrimPi0RecoNLocMax1) ;
+
+ fhAnglePairPrimPi0RecoNLocMax2 = new TH2F("fhAnglePairPrimPi0RecoNLocMax2",
+ "Opening angle split neutral sub-clusters reconstructed / generated #pi^{0} vs pair Energy, NLM=2",
+ nptbins,ptmin,ptmax,300,0,3);
+ fhAnglePairPrimPi0RecoNLocMax2->SetYTitle("#alpha_{reco} / #alpha_{gen}");
+ fhAnglePairPrimPi0RecoNLocMax2->SetXTitle("E (GeV)");
+ outputContainer->Add(fhAnglePairPrimPi0RecoNLocMax2) ;
+
+ fhAnglePairPrimPi0RecoNLocMaxN = new TH2F("fhAnglePairPrimPi0RecoNLocMaxN",
+ "Opening angle split neutral sub-clusters reconstructed / generated #pi^{0} vs pair Energy, NLM>2",
+ nptbins,ptmin,ptmax,300,0,3);
+ fhAnglePairPrimPi0RecoNLocMaxN->SetYTitle("#alpha_{reco} / #alpha_{gen}");
+ fhAnglePairPrimPi0RecoNLocMaxN->SetXTitle("E (GeV)");
+ outputContainer->Add(fhAnglePairPrimPi0RecoNLocMaxN) ;
+
- fhAnglePairNLocMax1[j] = new TH2F(Form("hAnglePairNLocMax1%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);
- fhAnglePairNLocMax1[j]->SetYTitle("#alpha (rad)");
- fhAnglePairNLocMax1[j]->SetXTitle("E (GeV)");
- outputContainer->Add(fhAnglePairNLocMax1[j]) ;
-
- fhAnglePairNLocMax2[j] = new TH2F(Form("hAnglePairNLocMax2%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);
- fhAnglePairNLocMax2[j]->SetYTitle("#alpha (rad)");
- fhAnglePairNLocMax2[j]->SetXTitle("E (GeV)");
- outputContainer->Add(fhAnglePairNLocMax2[j]) ;
-
- fhAnglePairNLocMaxN[j] = new TH2F(Form("hAnglePairNLocMaxN%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);
- fhAnglePairNLocMaxN[j]->SetYTitle("#alpha (rad)");
- fhAnglePairNLocMaxN[j]->SetXTitle("E (GeV)");
- outputContainer->Add(fhAnglePairNLocMaxN[j]) ;
-
- fhAnglePairMassNLocMax1[j] = new TH2F(Form("hAnglePairMassNLocMax1%s",sMatched[j].Data()),
- Form("Opening angle of 2 highest energy cells vs Mass for E > 12 GeV, %s",sMatched[j].Data()),
- mbins,mmin,mmax,200,0,0.2);
- fhAnglePairMassNLocMax1[j]->SetXTitle("M (GeV/c^{2})");
- fhAnglePairMassNLocMax1[j]->SetYTitle("#alpha (rad)");
- outputContainer->Add(fhAnglePairMassNLocMax1[j]) ;
-
- fhAnglePairMassNLocMax2[j] = new TH2F(Form("hAnglePairMassNLocMax2%s",sMatched[j].Data()),
- Form("Opening angle of 2 local maxima cells vs Mass for E > 12 GeV, %s",sMatched[j].Data()),
- mbins,mmin,mmax,200,0,0.2);
- fhAnglePairMassNLocMax2[j]->SetXTitle("M (GeV/c^{2})");
- fhAnglePairMassNLocMax2[j]->SetYTitle("#alpha (rad)");
- outputContainer->Add(fhAnglePairMassNLocMax2[j]) ;
-
- fhAnglePairMassNLocMaxN[j] = new TH2F(Form("hAnglePairMassNLocMaxN%s",sMatched[j].Data()),
- Form("Opening angle of N>2 local maxima cells vs Mass for E > 12 GeV, %s",sMatched[j].Data()),
- mbins,mmin,mmax,200,0,0.2);
- fhAnglePairMassNLocMaxN[j]->SetXTitle("M (GeV/c^{2})");
- fhAnglePairMassNLocMaxN[j]->SetYTitle("#alpha (rad)");
- outputContainer->Add(fhAnglePairMassNLocMaxN[j]) ;
+ fhAnglePairPrimPi0vsRecoNLocMax1 = new TH2F("fhAnglePairPrimPi0vsRecoNLocMax1",
+ "Opening angle split neutral sub-clusters reconstructed vs generated #pi^{0} for E > 15 GeV, NLM=1",
+ 200,0,0.2,200,0,0.2);
+ fhAnglePairPrimPi0vsRecoNLocMax1->SetYTitle("#alpha_{reco}");
+ fhAnglePairPrimPi0vsRecoNLocMax1->SetXTitle("#alpha_{gen}");
+ outputContainer->Add(fhAnglePairPrimPi0vsRecoNLocMax1) ;
+
+ fhAnglePairPrimPi0vsRecoNLocMax2 = new TH2F("fhAnglePairPrimPi0vsRecoNLocMax2",
+ "Opening angle split neutral sub-clusters reconstructed vs generated #pi^{0} for E > 10 GeV, NLM=2",
+ 200,0,0.2,200,0,0.2);
+ fhAnglePairPrimPi0vsRecoNLocMax2->SetYTitle("#alpha_{reco}");
+ fhAnglePairPrimPi0vsRecoNLocMax2->SetXTitle("#alpha_{gen}");
+ outputContainer->Add(fhAnglePairPrimPi0vsRecoNLocMax2) ;
+
+ fhAnglePairPrimPi0vsRecoNLocMaxN = new TH2F("fhAnglePairPrimPi0vsRecoNLocMaxN",
+ "Opening angle split neutral sub-clusters reconstructed vs generated #pi^{0} for E > 10 GeV, NLM=2",
+ 200,0,0.2,200,0,0.2);
+ fhAnglePairPrimPi0vsRecoNLocMaxN->SetYTitle("#alpha_{reco}");
+ fhAnglePairPrimPi0vsRecoNLocMaxN->SetXTitle("#alpha_{gen}");
+ outputContainer->Add(fhAnglePairPrimPi0vsRecoNLocMaxN) ;
}
}
if(i < 5)
{
fhMCPi0MassM02Overlap0[j][i-1] = new TH2F(Form("hMCPi0MassM02Overlap0NLocMax%sEbin%d",snlm[j].Data(),i-1),
- Form("Overlap 0, Mass vs #lambda_{0}^{2}, NLM=%s, E bin %d",snlm[j].Data(),i-1),
+ Form("Overlap 0, Mass vs #lambda_{0}^{2}, NLM=%s, %s",snlm[j].Data(),sEBin[i-1].Data()),
ssbins,ssmin,ssmax,mbins,mmin,mmax);
fhMCPi0MassM02Overlap0[j][i-1]->SetYTitle("M (GeV/c^{2})");
fhMCPi0MassM02Overlap0[j][i-1]->SetXTitle("#lambda_{0}^{2}");
outputContainer->Add(fhMCPi0MassM02Overlap0[j][i-1]) ;
fhMCPi0MassM02Overlap1[j][i-1] = new TH2F(Form("hMCPi0MassM02Overlap1NLocMax%sEbin%d",snlm[j].Data(),i-1),
- Form("Overlap 1, Mass vs #lambda_{0}^{2}, NLM=%s, E bin %d",snlm[j].Data(),i-1),
+ Form("Overlap 1, Mass vs #lambda_{0}^{2}, NLM=%s, %s",snlm[j].Data(),sEBin[i-1].Data()),
ssbins,ssmin,ssmax,mbins,mmin,mmax);
fhMCPi0MassM02Overlap1[j][i-1]->SetYTitle("M (GeV/c^{2})");
fhMCPi0MassM02Overlap1[j][i-1]->SetXTitle("#lambda_{0}^{2}");
outputContainer->Add(fhMCPi0MassM02Overlap1[j][i-1]) ;
fhMCPi0MassM02OverlapN[j][i-1] = new TH2F(Form("hMCPi0MassM02OverlapNNLocMax%sEbin%d",snlm[j].Data(),i-1),
- Form("Overlap N, Mass vs #lambda_{0}^{2}, NLM=%s, E bin %d",snlm[j].Data(),i-1),
+ Form("Overlap N, Mass vs #lambda_{0}^{2}, NLM=%s, %s",snlm[j].Data(),sEBin[i-1].Data()),
ssbins,ssmin,ssmax,mbins,mmin,mmax);
fhMCPi0MassM02OverlapN[j][i-1]->SetYTitle("M (GeV/c^{2})");
fhMCPi0MassM02OverlapN[j][i-1]->SetXTitle("#lambda_{0}^{2}");
if(i < 5)
{
fhMCPi0MassM02Overlap0Match[j][i-1] = new TH2F(Form("hMCPi0MassM02Overlap0NLocMax%sEbin%dMatched",snlm[j].Data(),i-1),
- Form("Overlap 0, Mass vs #lambda_{0}^{2}, NLM=%s, E bin %d, Track Matched",snlm[j].Data(),i-1),
+ Form("Overlap 0, Mass vs #lambda_{0}^{2}, NLM=%s, %s, Track Matched",snlm[j].Data(),sEBin[i-1].Data()),
ssbins,ssmin,ssmax,mbins,mmin,mmax);
fhMCPi0MassM02Overlap0Match[j][i-1]->SetYTitle("M (GeV/c^{2})");
fhMCPi0MassM02Overlap0Match[j][i-1]->SetXTitle("#lambda_{0}^{2}");
outputContainer->Add(fhMCPi0MassM02Overlap0Match[j][i-1]) ;
fhMCPi0MassM02Overlap1Match[j][i-1] = new TH2F(Form("hMCPi0MassM02Overlap1NLocMax%sEbin%dMatched",snlm[j].Data(),i-1),
- Form("Overlap 1, Mass vs #lambda_{0}^{2}, NLM=%s, E bin %d, Track Matched",snlm[j].Data(),i-1),
+ Form("Overlap 1, Mass vs #lambda_{0}^{2}, NLM=%s, %s, Track Matched",snlm[j].Data(),sEBin[i-1].Data()),
ssbins,ssmin,ssmax,mbins,mmin,mmax);
fhMCPi0MassM02Overlap1Match[j][i-1]->SetYTitle("M (GeV/c^{2})");
fhMCPi0MassM02Overlap1Match[j][i-1]->SetXTitle("#lambda_{0}^{2}");
outputContainer->Add(fhMCPi0MassM02Overlap1Match[j][i-1]) ;
fhMCPi0MassM02OverlapNMatch[j][i-1] = new TH2F(Form("hMCPi0MassM02OverlapNNLocMax%sEbin%dMatched",snlm[j].Data(),i-1),
- Form("Overlap N, Mass vs #lambda_{0}^{2}, NLM=%s, E bin %d, Track Matched",snlm[j].Data(),i-1),
+ Form("Overlap N, Mass vs #lambda_{0}^{2}, NLM=%s, %s, Track Matched",snlm[j].Data(),sEBin[i-1].Data()),
ssbins,ssmin,ssmax,mbins,mmin,mmax);
fhMCPi0MassM02OverlapNMatch[j][i-1]->SetYTitle("M (GeV/c^{2})");
fhMCPi0MassM02OverlapNMatch[j][i-1]->SetXTitle("#lambda_{0}^{2}");
if(fFillArmenterosHisto)
{
+ Int_t narmbins = 400;
+ Float_t armmin = 0;
+ Float_t armmax = 0.4;
+
for(Int_t i = 0; i < 7; i++) // MC bin
{
for(Int_t j = 0; j < 4; j++) // E bin
{
fhArmNLocMax1[i][j] = new TH2F(Form("hArmNLocMax1EBin%d%s",j,pname[i].Data()),
- Form("Armenteros of splitted cluster with NLM=1, E bin %d, %s",j,ptype[i].Data()),
- 200, -1, 1, nptbins,ptmin,ptmax);
- fhArmNLocMax1[i][j]->SetYTitle("#epsilon");
- fhArmNLocMax1[i][j]->SetXTitle("#alpha");
+ Form("Armenteros of splitted cluster with NLM=1, %s, %s",sEBin[j].Data(),ptype[i].Data()),
+ 200, -1, 1, narmbins,armmin,armmax);
+ fhArmNLocMax1[i][j]->SetYTitle("p_{T}^{Arm}");
+ fhArmNLocMax1[i][j]->SetXTitle("#alpha^{Arm}");
outputContainer->Add(fhArmNLocMax1[i][j]) ;
fhArmNLocMax2[i][j] = new TH2F(Form("hArmNLocMax2EBin%d%s",j,pname[i].Data()),
- Form("Armenteros of splitted cluster with NLM=2, E bin %d, %s",j,ptype[i].Data()),
- 200, -1, 1, nptbins,ptmin,ptmax);
- fhArmNLocMax2[i][j]->SetYTitle("#epsilon");
- fhArmNLocMax2[i][j]->SetXTitle("#alpha");
+ Form("Armenteros of splitted cluster with NLM=2, %s, %s",sEBin[j].Data(),ptype[i].Data()),
+ 200, -1, 1, narmbins,armmin,armmax);
+ fhArmNLocMax2[i][j]->SetYTitle("p_{T}^{Arm}");
+ fhArmNLocMax2[i][j]->SetXTitle("#alpha^{Arm}");
outputContainer->Add(fhArmNLocMax2[i][j]) ;
fhArmNLocMaxN[i][j] = new TH2F(Form("hArmNLocMaxNEBin%d%s",j,pname[i].Data()),
- Form("Armenteros of splitted cluster with NLM>2, E bin %d, %s",j,ptype[i].Data()),
- 200, -1, 1, nptbins,ptmin,ptmax);
- fhArmNLocMaxN[i][j]->SetYTitle("#epsilon");
- fhArmNLocMaxN[i][j]->SetXTitle("#alpha");
+ Form("Armenteros of splitted cluster with NLM>2, %s, %s",sEBin[j].Data(),ptype[i].Data()),
+ 200, -1, 1, narmbins,armmin,armmax);
+ fhArmNLocMaxN[i][j]->SetYTitle("p_{T}^{Arm}");
+ fhArmNLocMaxN[i][j]->SetXTitle("#alpha^{Arm}");
outputContainer->Add(fhArmNLocMaxN[i][j]) ;
if(asyOn || m02On)
{
fhArmAfterCutsNLocMax1[i][j] = new TH2F(Form("hArmAfterCutsNLocMax1EBin%d%s",j,pname[i].Data()),
- Form("Armenteros of splitted cluster with NLM=1, E bin %d, %s",j,ptype[i].Data()),
- 200, -1, 1, nptbins,ptmin,ptmax);
- fhArmAfterCutsNLocMax1[i][j]->SetYTitle("#epsilon");
- fhArmAfterCutsNLocMax1[i][j]->SetXTitle("#alpha");
+ Form("Armenteros of splitted cluster with NLM=1, %s, %s",sEBin[j].Data(),ptype[i].Data()),
+ 200, -1, 1, narmbins,armmin,armmax);
+ fhArmAfterCutsNLocMax1[i][j]->SetYTitle("p_{T}^{Arm}");
+ fhArmAfterCutsNLocMax1[i][j]->SetXTitle("#alpha^{Arm}");
outputContainer->Add(fhArmAfterCutsNLocMax1[i][j]) ;
fhArmAfterCutsNLocMax2[i][j] = new TH2F(Form("hArmAfterCutsNLocMax2EBin%d%s",j,pname[i].Data()),
- Form("Armenteros of splitted cluster with NLM=2, E bin %d, %s",j,ptype[i].Data()),
- 200, -1, 1, nptbins,ptmin,ptmax);
- fhArmAfterCutsNLocMax2[i][j]->SetYTitle("#epsilon");
- fhArmAfterCutsNLocMax2[i][j]->SetXTitle("#alpha");
+ Form("Armenteros of splitted cluster with NLM=2, %s, %s",sEBin[j].Data(),ptype[i].Data()),
+ 200, -1, 1, narmbins,armmin,armmax);
+ fhArmAfterCutsNLocMax2[i][j]->SetYTitle("p_{T}^{Arm}");
+ fhArmAfterCutsNLocMax2[i][j]->SetXTitle("#alpha^{Arm}");
outputContainer->Add(fhArmAfterCutsNLocMax2[i][j]) ;
fhArmAfterCutsNLocMaxN[i][j] = new TH2F(Form("hArmAfterCutsNLocMaxNEBin%d%s",j,pname[i].Data()),
- Form("Armenteros of splitted cluster with NLM>2, E bin %d, %s",j,ptype[i].Data()),
- 200, -1, 1, nptbins,ptmin,ptmax);
- fhArmAfterCutsNLocMaxN[i][j]->SetYTitle("#epsilon");
- fhArmAfterCutsNLocMaxN[i][j]->SetXTitle("#alpha");
+ Form("Armenteros of splitted cluster with NLM>2, %s, %s",sEBin[j].Data(),ptype[i].Data()),
+ 200, -1, 1, narmbins,armmin,armmax);
+ fhArmAfterCutsNLocMaxN[i][j]->SetYTitle("p_{T}^{Arm}");
+ fhArmAfterCutsNLocMaxN[i][j]->SetXTitle("#alpha^{Arm}");
outputContainer->Add(fhArmAfterCutsNLocMaxN[i][j]) ;
}
fhArmPi0NLocMax1[i][j] = new TH2F(Form("hArmPi0NLocMax1EBin%d%s",j,pname[i].Data()),
- Form("Armenteros of splitted cluster with NLM=1, E bin %d, %s",j,ptype[i].Data()),
- 200, -1, 1, nptbins,ptmin,ptmax);
- fhArmPi0NLocMax1[i][j]->SetYTitle("#epsilon");
- fhArmPi0NLocMax1[i][j]->SetXTitle("#alpha");
+ Form("Armenteros of splitted cluster with NLM=1, %s, %s",sEBin[j].Data(),ptype[i].Data()),
+ 200, -1, 1, narmbins,armmin,armmax);
+ fhArmPi0NLocMax1[i][j]->SetYTitle("p_{T}^{Arm}");
+ fhArmPi0NLocMax1[i][j]->SetXTitle("#alpha^{Arm}");
outputContainer->Add(fhArmPi0NLocMax1[i][j]) ;
fhArmPi0NLocMax2[i][j] = new TH2F(Form("hArmPi0NLocMax2EBin%d%s",j,pname[i].Data()),
- Form("Armenteros of splitted cluster with NLM=2, E bin %d, %s",j,ptype[i].Data()),
- 200, -1, 1, nptbins,ptmin,ptmax);
- fhArmPi0NLocMax2[i][j]->SetYTitle("#epsilon");
- fhArmPi0NLocMax2[i][j]->SetXTitle("#alpha");
+ Form("Armenteros of splitted cluster with NLM=2, %s, %s",sEBin[j].Data(),ptype[i].Data()),
+ 200, -1, 1, narmbins,armmin,armmax);
+ fhArmPi0NLocMax2[i][j]->SetYTitle("p_{T}^{Arm}");
+ fhArmPi0NLocMax2[i][j]->SetXTitle("#alpha^{Arm}");
outputContainer->Add(fhArmPi0NLocMax2[i][j]) ;
fhArmPi0NLocMaxN[i][j] = new TH2F(Form("hArmPi0NLocMaxNEBin%d%s",j,pname[i].Data()),
- Form("Armenteros of splitted cluster with NLM>2, E bin %d, %s",j,ptype[i].Data()),
- 200, -1, 1, nptbins,ptmin,ptmax);
- fhArmPi0NLocMaxN[i][j]->SetYTitle("#epsilon");
- fhArmPi0NLocMaxN[i][j]->SetXTitle("#alpha");
+ Form("Armenteros of splitted cluster with NLM>2, %s, %s",sEBin[j].Data(),ptype[i].Data()),
+ 200, -1, 1, narmbins,armmin,armmax);
+ fhArmPi0NLocMaxN[i][j]->SetYTitle("p_{T}^{Arm}");
+ fhArmPi0NLocMaxN[i][j]->SetXTitle("#alpha^{Arm}");
outputContainer->Add(fhArmPi0NLocMaxN[i][j]) ;
}
//______________________________________________________________________________________________________________
void AliAnaInsideClusterInvariantMass::GetMCPrimaryKine(AliVCluster* cluster, const Int_t mcindex,
const Int_t mctag, const Bool_t matched,
- Float_t & eprim, Float_t & asymGen, Int_t & noverlaps )
+ Float_t & eprim, Float_t & asymGen, Float_t & angleGen, Int_t & noverlaps )
{
// Check origin of the candidates, get primary kinematics if overlapped meson decay
{
if(mcindex == kmcPi0 || mcindex == kmcPi0Conv)
{
- asymGen = TMath::Abs(GetMCAnalysisUtils()->GetMCDecayAsymmetryForPDG(mcLabel,111,GetReader(),ok));
+ GetMCAnalysisUtils()->GetMCDecayAsymmetryAngleForPDG(mcLabel,111,GetReader(),asymGen,angleGen,ok);
+ asymGen = TMath::Abs(asymGen);
TLorentzVector grandmom = GetMCAnalysisUtils()->GetMotherWithPDG(mcLabel,111,GetReader(),ok,mesonLabel);
if(grandmom.E() > 0 && ok) eprim = grandmom.E();
}
else
{
- asymGen = TMath::Abs(GetMCAnalysisUtils()->GetMCDecayAsymmetryForPDG(mcLabel,221,GetReader(),ok));
+ GetMCAnalysisUtils()->GetMCDecayAsymmetryAngleForPDG(mcLabel,221,GetReader(),asymGen,angleGen,ok);
+ asymGen = TMath::Abs(asymGen);
TLorentzVector grandmom = GetMCAnalysisUtils()->GetMotherWithPDG(mcLabel,221,GetReader(),ok,mesonLabel);
if(grandmom.E() > 0 && ok) eprim = grandmom.E();
}
// MC data histograms and some related calculations
// mc tag, n overlaps, asym of generated mesons
- Int_t mcindex = -1;
- Int_t mctag = -1;
- Float_t eprim = -1;
- Float_t asymGen = -2;
- Int_t noverlaps = 0;
+ Int_t mcindex = -1;
+ Int_t mctag = -1;
+ Float_t eprim = -1;
+ Float_t asymGen = -2;
+ Float_t angleGen = 2000;
+ Int_t noverlaps = 0;
if(IsDataMC())
{
// MC primary kine, generation fractions
- GetMCPrimaryKine(cluster,mcindex,mctag,matched,eprim,asymGen,noverlaps);
+ GetMCPrimaryKine(cluster,mcindex,mctag,matched,eprim,asymGen,angleGen,noverlaps);
// For cluster with MC pi0 and more than 1 maxima
//
if(fFillAngleHisto)
- FillAngleHistograms(matched,nMax,en,angle,mass);
+ FillAngleHistograms(nMax,matched,mcindex,en,angle,mass,angleGen);
if(fFillArmenterosHisto && ebin >= 0)
FillArmenterosHistograms(nMax, ebin, mcindex, lv, lv1, lv2, l0, pidTag);
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff