[u/mrichter/AliRoot.git] / PWGLF / totEt / AliAnalysisEtTrackMatchCorrections.cxx



#include "AliAnalysisEtTrackMatchCorrections.h"

ClassImp(AliAnalysisEtTrackMatchCorrections);

AliAnalysisEtTrackMatchCorrections::AliAnalysisEtTrackMatchCorrections() : TNamed("TMCorr","TMCorr")
    ,fChargedContr(new TF1)
    ,fNeutralContr(new TF1)
    ,fGammaContr(new TF1)
    ,fSecondaryContr(new TF1)
									 ,fRecoEff(0)
    ,fMeanCharged(0)
    ,fMeanNeutral(0)
    ,fMeanGamma(0)
    ,fMeanSecondary(0)
								      // ,fNeutronCorrection(0)
{
  //fNeutronCorrection = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
  for(int i=0;i<20;i++){
    fNeutronCorrection[i] = 0.0;
    fHadronCorrection[i] = 0.0;
    fKaonCorrection[i] = 0.0;
    fSecondaryCorrection[i] = 0.0;
  }
}

AliAnalysisEtTrackMatchCorrections::AliAnalysisEtTrackMatchCorrections(const TString name, const TF1 &chargedContr, const TF1 &neutralContr, const TF1 &gammaContr, const TF1 &secondaryContr, const TH2F &recoEff,
								       Double_t meanCharged, Double_t meanNeutral, Double_t meanGammas, Double_t meanSecondary) : TNamed(name,name)
																				,fChargedContr(new TF1(chargedContr))
																				,fNeutralContr(new TF1(neutralContr))
																				,fGammaContr(new TF1(gammaContr))
																				,fSecondaryContr(new TF1(secondaryContr))										    	,fRecoEff(new TH2F(recoEff))
								      //,fRecoEff(0)
																				,fMeanCharged(meanCharged)
																				,fMeanNeutral(meanNeutral)
																				,fMeanGamma(meanGammas)
																				,fMeanSecondary(meanSecondary)
{
  for(int i=0;i<20;i++){
    fNeutronCorrection[i] = 0.0;
    fHadronCorrection[i] = 0.0;
    fKaonCorrection[i] = 0.0;
    fSecondaryCorrection[i] = 0.0;
  }
}

//! Copy constructor
AliAnalysisEtTrackMatchCorrections::AliAnalysisEtTrackMatchCorrections(const AliAnalysisEtTrackMatchCorrections &obj) : TNamed(obj)
    ,fChargedContr(new TF1(*(obj.fChargedContr)))
    ,fNeutralContr(new TF1(*(obj.fNeutralContr)))
    ,fGammaContr(new TF1(*(obj.fGammaContr)))
    ,fSecondaryContr(new TF1(*(obj.fSecondaryContr)))
    ,fRecoEff(new TH2F(*(obj.fRecoEff)))
    ,fMeanCharged(obj.fMeanCharged)
    ,fMeanNeutral(obj.fMeanNeutral)
    ,fMeanGamma(obj.fMeanGamma)
    ,fMeanSecondary(obj.fMeanSecondary)
    
{
  for(int i=0;i<20;i++){
    fNeutronCorrection[i] = obj.fNeutronCorrection[i];
    fHadronCorrection[i] = obj.fHadronCorrection[i];
    fKaonCorrection[i] = obj.fKaonCorrection[i];
    fSecondaryCorrection[i] = obj.fSecondaryCorrection[i];
  }
}

//! Destructor
AliAnalysisEtTrackMatchCorrections::~AliAnalysisEtTrackMatchCorrections()
{
//   delete fChargedContr;
//   delete fNeutralContr;
//   delete fGammaContr;
//   delete fSecondaryContr;
//   delete fRecoEff;
}

//! Assignment operator
AliAnalysisEtTrackMatchCorrections& AliAnalysisEtTrackMatchCorrections::operator=(const AliAnalysisEtTrackMatchCorrections &other)
{
    if (this != &other)
    {
        *fChargedContr = *(other.fChargedContr);
        *fNeutralContr = *(other.fNeutralContr);
        *fGammaContr = *(other.fGammaContr);
	;        *fSecondaryContr = *(other.fSecondaryContr);
	fMeanCharged = other.fMeanCharged;
	fMeanNeutral = other.fMeanNeutral;
	fMeanGamma = other.fMeanGamma;
	fMeanSecondary = other.fMeanSecondary;
	
    }
    return *this;
}

Double_t AliAnalysisEtTrackMatchCorrections::TrackMatchingEfficiency(Float_t pT, Int_t cent) const{
  Double_t eff = 1.0;
  if(fRecoEff) eff =  fRecoEff->GetBinContent(fRecoEff->GetXaxis()->FindBin(pT),fRecoEff->GetYaxis()->FindBin(cent));
  //cout <<"eff "<<eff<<endl;
  //cout <<"eff "<<eff<<" bin pT "<<fRecoEff->GetXaxis()->FindBin(pT)<<" bin centrality "<<fRecoEff->GetYaxis()->FindBin(cent)<<endl;
  if(eff>1e-5){return eff;}
  else{return 1.0;}
}
Commit	Line	Data
	1
	2
	3	#include "AliAnalysisEtTrackMatchCorrections.h"
	4
	5	ClassImp(AliAnalysisEtTrackMatchCorrections);
	6
	7	AliAnalysisEtTrackMatchCorrections::AliAnalysisEtTrackMatchCorrections() : TNamed("TMCorr","TMCorr")
	8	,fChargedContr(new TF1)
	9	,fNeutralContr(new TF1)
	10	,fGammaContr(new TF1)
	11	,fSecondaryContr(new TF1)
	12	,fRecoEff(0)
	13	,fMeanCharged(0)
	14	,fMeanNeutral(0)
	15	,fMeanGamma(0)
	16	,fMeanSecondary(0)
	17	// ,fNeutronCorrection(0)
	18	{
	19	//fNeutronCorrection = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
	20	for(int i=0;i<20;i++){
	21	fNeutronCorrection[i] = 0.0;
	22	fHadronCorrection[i] = 0.0;
	23	fKaonCorrection[i] = 0.0;
	24	fSecondaryCorrection[i] = 0.0;
	25	}
	26	}
	27
	28	AliAnalysisEtTrackMatchCorrections::AliAnalysisEtTrackMatchCorrections(const TString name, const TF1 &chargedContr, const TF1 &neutralContr, const TF1 &gammaContr, const TF1 &secondaryContr, const TH2F &recoEff,
	29	Double_t meanCharged, Double_t meanNeutral, Double_t meanGammas, Double_t meanSecondary) : TNamed(name,name)
	30	,fChargedContr(new TF1(chargedContr))
	31	,fNeutralContr(new TF1(neutralContr))
	32	,fGammaContr(new TF1(gammaContr))
	33	,fSecondaryContr(new TF1(secondaryContr)) ,fRecoEff(new TH2F(recoEff))
	34	//,fRecoEff(0)
	35	,fMeanCharged(meanCharged)
	36	,fMeanNeutral(meanNeutral)
	37	,fMeanGamma(meanGammas)
	38	,fMeanSecondary(meanSecondary)
	39	{
	40	for(int i=0;i<20;i++){
	41	fNeutronCorrection[i] = 0.0;
	42	fHadronCorrection[i] = 0.0;
	43	fKaonCorrection[i] = 0.0;
	44	fSecondaryCorrection[i] = 0.0;
	45	}
	46	}
	47
	48	//! Copy constructor
	49	AliAnalysisEtTrackMatchCorrections::AliAnalysisEtTrackMatchCorrections(const AliAnalysisEtTrackMatchCorrections &obj) : TNamed(obj)
	50	,fChargedContr(new TF1(*(obj.fChargedContr)))
	51	,fNeutralContr(new TF1(*(obj.fNeutralContr)))
	52	,fGammaContr(new TF1(*(obj.fGammaContr)))
	53	,fSecondaryContr(new TF1(*(obj.fSecondaryContr)))
	54	,fRecoEff(new TH2F(*(obj.fRecoEff)))
	55	,fMeanCharged(obj.fMeanCharged)
	56	,fMeanNeutral(obj.fMeanNeutral)
	57	,fMeanGamma(obj.fMeanGamma)
	58	,fMeanSecondary(obj.fMeanSecondary)
	59
	60	{
	61	for(int i=0;i<20;i++){
	62	fNeutronCorrection[i] = obj.fNeutronCorrection[i];
	63	fHadronCorrection[i] = obj.fHadronCorrection[i];
	64	fKaonCorrection[i] = obj.fKaonCorrection[i];
	65	fSecondaryCorrection[i] = obj.fSecondaryCorrection[i];
	66	}
	67	}
	68
	69	//! Destructor
	70	AliAnalysisEtTrackMatchCorrections::~AliAnalysisEtTrackMatchCorrections()
	71	{
	72	// delete fChargedContr;
	73	// delete fNeutralContr;
	74	// delete fGammaContr;
	75	// delete fSecondaryContr;
	76	// delete fRecoEff;
	77	}
	78
	79	//! Assignment operator
	80	AliAnalysisEtTrackMatchCorrections& AliAnalysisEtTrackMatchCorrections::operator=(const AliAnalysisEtTrackMatchCorrections &other)
	81	{
	82	if (this != &other)
	83	{
	84	fChargedContr = (other.fChargedContr);
	85	fNeutralContr = (other.fNeutralContr);
	86	fGammaContr = (other.fGammaContr);
	87	; fSecondaryContr = (other.fSecondaryContr);
	88	fMeanCharged = other.fMeanCharged;
	89	fMeanNeutral = other.fMeanNeutral;
	90	fMeanGamma = other.fMeanGamma;
	91	fMeanSecondary = other.fMeanSecondary;
	92
	93	}
	94	return *this;
	95	}
	96
	97	Double_t AliAnalysisEtTrackMatchCorrections::TrackMatchingEfficiency(Float_t pT, Int_t cent) const{
	98	Double_t eff = 1.0;
	99	if(fRecoEff) eff = fRecoEff->GetBinContent(fRecoEff->GetXaxis()->FindBin(pT),fRecoEff->GetYaxis()->FindBin(cent));
	100	//cout <<"eff "<<eff<<endl;
	101	//cout <<"eff "<<eff<<" bin pT "<<fRecoEff->GetXaxis()->FindBin(pT)<<" bin centrality "<<fRecoEff->GetYaxis()->FindBin(cent)<<endl;
	102	if(eff>1e-5){return eff;}
	103	else{return 1.0;}
	104	}