[u/mrichter/AliRoot.git] / PWG4 / totEt / AliAnalysisEt.cxx

//_________________________________________________________________________
//  Utility Class for transverse energy studies
//  Base class for ESD & MC analysis
//  - reconstruction and MonteCarlo output
// implementation file
//
//*-- Authors: Oystein Djuvsland (Bergen), David Silvermyr (ORNL)
//_________________________________________________________________________

#include "AliAnalysisEt.h"
#include "TMath.h"
#include "TList.h"
#include "TH1F.h"
#include "TH2F.h"
#include "TTree.h"
#include <iostream>
#include "AliAnalysisEtCuts.h"
#include "AliESDtrackCuts.h"
#include "AliVEvent.h"
#include "Rtypes.h"
#include "TString.h"

using namespace std;
ClassImp(AliAnalysisEt);


AliAnalysisEt::AliAnalysisEt() : AliAnalysisEtCommon()
			       ,fTotEt(0)
			       ,fTotEtAcc(0)
			       ,fTotNeutralEt(0)
			       ,fTotNeutralEtAcc(0)
			       ,fTotChargedEt(0)
			       ,fTotChargedEtAcc(0)
			       ,fMultiplicity(0)
			       ,fChargedMultiplicity(0)
			       ,fNeutralMultiplicity(0)
			       ,fBaryonEt(0)
			       ,fAntiBaryonEt(0)
			       ,fMesonEt(0)
			       ,fProtonEt(0)
			       ,fPionEt(0)
			       ,fChargedKaonEt(0)
			       ,fMuonEt(0)
			       ,fElectronEt(0)
			       ,fNeutronEt(0)
			       ,fAntiNeutronEt(0)
			       ,fGammaEt(0)
			       ,fProtonEtAcc(0)
			       ,fPionEtAcc(0)
			       ,fChargedKaonEtAcc(0)
			       ,fMuonEtAcc(0)
			       ,fElectronEtAcc(0)
			       ,fEnergyDeposited(0)
			       ,fEnergyTPC(0)
			       ,fCharge(0)
			       ,fParticlePid(0)
			       ,fPidProb(0)
			       ,fTrackPassedCut(kFALSE)
			       ,fEtaCut(0)
			       ,fEtaCutAcc(0)
			       ,fPhiCutAccMin(0)
			       ,fPhiCutAccMax(0)
			       ,fDetectorRadius(0)
			       ,fClusterEnergyCut(0) 
			       ,fSingleCellEnergyCut(0)
			       ,fHistEt(0)
			       ,fHistChargedEt(0)
			       ,fHistNeutralEt(0)
			       ,fHistEtAcc(0)
			       ,fHistChargedEtAcc(0)
			       ,fHistNeutralEtAcc(0)
			       ,fHistMult(0)
			       ,fHistChargedMult(0)
			       ,fHistNeutralMult(0)
			       ,fHistPhivsPtPos(0)
			       ,fHistPhivsPtNeg(0)
			       ,fHistBaryonEt(0)
			       ,fHistAntiBaryonEt(0)
			       ,fHistMesonEt(0)
			       ,fHistProtonEt(0)
			       ,fHistPionEt(0)
			       ,fHistChargedKaonEt(0)
			       ,fHistMuonEt(0)
			       ,fHistElectronEt(0)
			       ,fHistNeutronEt(0)
			       ,fHistAntiNeutronEt(0)
			       ,fHistGammaEt(0)
			       ,fHistProtonEtAcc(0)
			       ,fHistPionEtAcc(0)
			       ,fHistChargedKaonEtAcc(0)
			       ,fHistMuonEtAcc(0)
			       ,fHistElectronEtAcc(0)
			       ,fHistTMDeltaR(0)
			       ,fTree(0)
			       ,fTreeDeposit(0)
			       ,fCentrality(0)
{
}

AliAnalysisEt::~AliAnalysisEt()
{//Destructor
  if(fTreeDeposit){
    fTreeDeposit->Clear();
    delete fTreeDeposit; // optional TTree
  }
  if(fTree){
    fTree->Clear();
    delete fTree; // optional TTree
  }
  delete fHistEt; //Et spectrum
  delete fHistChargedEt; //Charged Et spectrum 
  delete fHistNeutralEt; //Neutral Et spectrum
  delete fHistEtAcc; //Et in acceptance
  delete fHistChargedEtAcc; //Charged Et in acceptance
  delete fHistNeutralEtAcc; //Et in acceptance
  delete fHistMult; //Multiplicity
  delete fHistChargedMult; //Charged multiplicity
  delete fHistNeutralMult; //Neutral multiplicity
  delete fHistPhivsPtPos; //phi vs pT plot for positive tracks
  delete fHistPhivsPtNeg; //phi vs pT plot for negative tracks
  delete fHistBaryonEt; /** Et of identified baryons */    
  delete fHistAntiBaryonEt; /** Et of identified anti-baryons */
  delete fHistMesonEt; /** Et of identified mesons */
  delete fHistProtonEt; /** Et of identified protons */
  delete fHistPionEt; /** Et of identified protons */
  delete fHistChargedKaonEt; /** Et of identified charged kaons */
  delete fHistMuonEt; /** Et of identified muons */
  delete fHistElectronEt; /** Et of identified electrons */
  delete fHistNeutronEt; /** Et of neutrons (MC only for now) */
  delete fHistAntiNeutronEt; /** Et of anti-neutrons (MC only for now) */
  delete fHistGammaEt; /** Et of gammas (MC only for now) */
  delete fHistProtonEtAcc; /** Et of identified protons in calorimeter acceptance */    
  delete fHistPionEtAcc; /** Et of identified protons in calorimeter acceptance */    
  delete fHistChargedKaonEtAcc; /** Et of identified charged kaons in calorimeter acceptance */    
  delete fHistMuonEtAcc; /** Et of identified muons in calorimeter acceptance */
  delete fHistElectronEtAcc; /** Et of identified electrons in calorimeter acceptance */
  delete fHistTMDeltaR; /* Track matching plots; Rec only for now */
}

void AliAnalysisEt::FillOutputList(TList *list)
{ // histograms to be added to output
    list->Add(fHistEt);
    list->Add(fHistChargedEt);
    list->Add(fHistNeutralEt);

    list->Add(fHistEtAcc);
    list->Add(fHistChargedEtAcc);
    list->Add(fHistNeutralEtAcc);

    list->Add(fHistMult);
    list->Add(fHistChargedMult);
    list->Add(fHistNeutralMult);

    list->Add(fHistPhivsPtPos);
    list->Add(fHistPhivsPtNeg);

    list->Add(fHistBaryonEt);
    list->Add(fHistAntiBaryonEt);
    list->Add(fHistMesonEt);

    list->Add(fHistProtonEt);
    list->Add(fHistPionEt);
    list->Add(fHistChargedKaonEt);
    list->Add(fHistMuonEt);
    list->Add(fHistElectronEt);
    
    list->Add(fHistNeutronEt);
    list->Add(fHistAntiNeutronEt);
    list->Add(fHistGammaEt);
    
    list->Add(fHistProtonEtAcc);
    list->Add(fHistPionEtAcc);
    list->Add(fHistChargedKaonEtAcc);
    list->Add(fHistMuonEtAcc);
    list->Add(fHistElectronEtAcc);

    list->Add(fHistTMDeltaR);

    if (fCuts) {
      if (fCuts->GetHistMakeTree()) {
	list->Add(fTree);
      }
    }
    list->Add(fTreeDeposit);

}

void AliAnalysisEt::Init()
{// clear variables, set up cuts and PDG info
  AliAnalysisEtCommon::Init();
  ResetEventValues();
}

void AliAnalysisEt::CreateHistograms()
{ // create histograms..
  // histogram binning for E_T, p_T and Multiplicity: defaults for p+p
  Int_t nbinsEt = 1000;
  Double_t minEt = 0.0001;
  Double_t maxEt = 100;
  Int_t nbinsPt = 200;
  Double_t minPt = 0;
  Double_t maxPt = 20;
  Int_t nbinsMult = 200;
  Double_t minMult = -0.5; // offset -0.5 to have integer bins centered around 0
  Double_t maxMult = nbinsMult + minMult; // 1 bin per integer value

  // see if we should change histogram limits etc, and possibly create a tree
  if (fCuts) {
    //if (fCuts->GetHistMakeTree()) {
      CreateTrees();
    //}

    nbinsMult = fCuts->GetHistNbinsMult();
    minMult = fCuts->GetHistMinMult();
    maxMult = fCuts->GetHistMaxMult();

    nbinsEt = fCuts->GetHistNbinsTotEt();
    minEt = fCuts->GetHistMinTotEt();
    maxEt = fCuts->GetHistMaxTotEt();

    nbinsPt = fCuts->GetHistNbinsParticlePt();
    minPt = fCuts->GetHistMinParticlePt();
    maxPt = fCuts->GetHistMaxParticlePt();
  }

    TString histname = "fHistEt" + fHistogramNameSuffix;
    fHistEt = new TH1F(histname.Data(), "Total E_{T} Distribution", nbinsEt, minEt, maxEt);
    fHistEt->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
    fHistEt->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");

    histname = "fHistChargedEt" + fHistogramNameSuffix;
    fHistChargedEt = new TH1F(histname.Data(), "Total Charged E_{T} Distribution", nbinsEt, minEt, maxEt);
    fHistChargedEt->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
    fHistChargedEt->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");

    histname = "fHistNeutralEt" + fHistogramNameSuffix;
    fHistNeutralEt = new TH1F(histname.Data(), "Total Neutral E_{T} Distribution", nbinsEt, minEt, maxEt);
    fHistNeutralEt->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
    fHistNeutralEt->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");

    histname = "fHistEtAcc" + fHistogramNameSuffix;
    fHistEtAcc = new TH1F(histname.Data(), "Total E_{T} Distribution in Acceptance", nbinsEt, minEt, maxEt);
    fHistEtAcc->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
    fHistEtAcc->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");

    histname = "fHistChargedEtAcc" + fHistogramNameSuffix;
    fHistChargedEtAcc = new TH1F(histname.Data(), "Total Charged E_{T} Distribution in Acceptance", nbinsEt, minEt, maxEt);
    fHistChargedEtAcc->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
    fHistChargedEtAcc->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");

    histname = "fHistNeutralEtAcc" + fHistogramNameSuffix;
    fHistNeutralEtAcc = new TH1F(histname.Data(), "Total Neutral E_{T} Distribution in Acceptance", nbinsEt, minEt, maxEt);
    fHistNeutralEtAcc->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
    fHistNeutralEtAcc->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");
    std::cout << histname << std::endl;
    histname = "fHistMult" + fHistogramNameSuffix;
    fHistMult = new TH1F(histname.Data(), "Total Multiplicity", nbinsMult, minMult, maxMult);
    fHistMult->GetXaxis()->SetTitle("N");
    fHistMult->GetYaxis()->SetTitle("Multiplicity");

    histname = "fHistChargedMult" + fHistogramNameSuffix;
    fHistChargedMult = new TH1F(histname.Data(), "Charged Multiplicity", nbinsMult, minMult, maxMult);
    fHistChargedMult->GetXaxis()->SetTitle("N");
    fHistChargedMult->GetYaxis()->SetTitle("Multiplicity");

    histname = "fHistNeutralMult" + fHistogramNameSuffix;
    fHistNeutralMult = new TH1F(histname.Data(), "Neutral Multiplicity", nbinsMult, minMult, maxMult);
    fHistNeutralMult->GetXaxis()->SetTitle("N");
    fHistNeutralMult->GetYaxis()->SetTitle("Multiplicity");

    histname = "fHistPhivsPtPos" + fHistogramNameSuffix;
    fHistPhivsPtPos = new TH2F(histname.Data(), "Phi vs pT of positively charged tracks hitting the calorimeter", 	200, 0, 2*TMath::Pi(), nbinsPt, minPt, maxPt);

    histname = "fHistPhivsPtNeg" + fHistogramNameSuffix;
    fHistPhivsPtNeg = new TH2F(histname.Data(), "Phi vs pT of negatively charged tracks hitting the calorimeter", 	200, 0, 2*TMath::Pi(), nbinsPt, minPt, maxPt);

    histname = "fHistBaryonEt" + fHistogramNameSuffix;
    fHistBaryonEt = new TH1F(histname.Data(), "E_{T} for baryons",  nbinsEt, minEt, maxEt);

    histname = "fHistAntiBaryonEt" + fHistogramNameSuffix;
    fHistAntiBaryonEt = new TH1F(histname.Data(), "E_{T} for anti baryons",  nbinsEt, minEt, maxEt);

    histname = "fHistMesonEt" + fHistogramNameSuffix;
    fHistMesonEt = new TH1F(histname.Data(), "E_{T} for mesons",  nbinsEt, minEt, maxEt);

    histname = "fHistProtonEt" + fHistogramNameSuffix;
    fHistProtonEt = new TH1F(histname.Data(), "E_{T} for (anti-)protons", nbinsEt, minEt, maxEt);

    histname = "fHistPionEt" + fHistogramNameSuffix;
    fHistPionEt = new TH1F(histname.Data(), "E_{T} for #pi^+/#pi^-", nbinsEt, minEt, maxEt);

    histname = "fHistKaonEt" + fHistogramNameSuffix;
    fHistChargedKaonEt = new TH1F(histname.Data(), "E_{T} for charged kaons", nbinsEt, minEt, maxEt);

    histname = "fHistMuonEt" + fHistogramNameSuffix;
    fHistMuonEt = new TH1F(histname.Data(), "E_{T} for muons", nbinsEt, minEt, maxEt);

    histname = "fHistElectronEt" + fHistogramNameSuffix;
    fHistElectronEt = new TH1F(histname.Data(), "E_{T} for electrons/positrons", nbinsEt, minEt, maxEt);

    histname = "fHistNeutronEt" + fHistogramNameSuffix;
    fHistNeutronEt = new TH1F(histname.Data(), "E_{T} for neutrons", nbinsEt, minEt, maxEt);

    histname = "fHistAntiNeutronEt" + fHistogramNameSuffix;
    fHistAntiNeutronEt = new TH1F(histname.Data(), "E_{T} for anti-neutrons", nbinsEt, minEt, maxEt);

    histname = "fHistGammaEt" + fHistogramNameSuffix;
    fHistGammaEt = new TH1F(histname.Data(), "E_{T} for gammas", nbinsEt, minEt, maxEt);

    histname = "fHistProtonEtAcc" + fHistogramNameSuffix;
    fHistProtonEtAcc = new TH1F(histname.Data(), "E_{T} for (anti-)protons in calorimeter acceptance", nbinsEt, minEt, maxEt);

    histname = "fHistPionEtAcc" + fHistogramNameSuffix;
    fHistPionEtAcc = new TH1F(histname.Data(), "E_{T} for #pi^+/#pi^- in calorimeter acceptance", nbinsEt, minEt, maxEt);

    histname = "fHistKaonEtAcc" + fHistogramNameSuffix;
    fHistChargedKaonEtAcc = new TH1F(histname.Data(), "E_{T} for charged kaons in calorimeter acceptance", nbinsEt, minEt, maxEt);

    histname = "fHistMuonEtAcc" + fHistogramNameSuffix;
    fHistMuonEtAcc = new TH1F(histname.Data(), "E_{T} for muons in calorimeter acceptance", nbinsEt, minEt, maxEt);

    histname = "fHistElectronEtAcc" + fHistogramNameSuffix;
    fHistElectronEtAcc = new TH1F(histname.Data(), "E_{T} for electrons/positrons in calorimeter acceptance", nbinsEt, minEt, maxEt);

    //
    histname = "fHistTMDeltaR" + fHistogramNameSuffix;
    fHistTMDeltaR = new TH1F(histname.Data(), "#Delta R for calorimeter clusters", 200, 0, 50);

}

void AliAnalysisEt::CreateTrees()
{ // create tree..
  TString treename = "fTree" + fHistogramNameSuffix;
  if(fCuts->GetHistMakeTree())
  {
  
    fTree = new TTree(treename, treename);
    fTree->Branch("fTotEt",&fTotEt,"fTotEt/D");
    fTree->Branch("fTotEtAcc",&fTotEtAcc,"fTotEtAcc/D");
    fTree->Branch("fTotNeutralEt",&fTotNeutralEt,"fTotNeutralEt/D");
    fTree->Branch("fTotNeutralEtAcc",&fTotNeutralEtAcc,"fTotNeutralEtAcc/D");
    fTree->Branch("fTotChargedEt",&fTotChargedEt,"fTotChargedEt/D");
    fTree->Branch("fTotChargedEtAcc",&fTotChargedEtAcc,"fTotChargedEtAcc/D");
    fTree->Branch("fMultiplicity",&fMultiplicity,"fMultiplicity/I");
    fTree->Branch("fChargedMultiplicity",&fChargedMultiplicity,"fChargedMultiplicity/I");
    fTree->Branch("fNeutralMultiplicity",&fNeutralMultiplicity,"fNeutralMultiplicity/I");
    fTree->Branch("fBaryonEt",&fBaryonEt,"fBaryonEt/D");
    fTree->Branch("fAntiBaryonEt",&fAntiBaryonEt,"fAntiBaryonEt/D");
    fTree->Branch("fMesonEt",&fMesonEt,"fMesonEt/D");
    fTree->Branch("fProtonEt",&fProtonEt,"fProtonEt/D");
    fTree->Branch("fChargedKaonEt",&fChargedKaonEt,"fChargedKaonEt/D");
    fTree->Branch("fMuonEt",&fMuonEt,"fMuonEt/D");
    fTree->Branch("fElectronEt",&fElectronEt,"fElectronEt/D");
    fTree->Branch("fProtonEtAcc",&fProtonEtAcc,"fProtonEtAcc/D");
    fTree->Branch("fChargedKaonEtAcc",&fChargedKaonEtAcc,"fChargedKaonEtAcc/D");
    fTree->Branch("fMuonEtAcc",&fMuonEtAcc,"fMuonEtAcc/D");
    fTree->Branch("fElectronEtAcc",&fElectronEtAcc,"fElectronEtAcc/D");
  }
  
  if(fCuts->GetHistMakeTreeDeposit())
  {
    treename = "fTreeDeposit" + fHistogramNameSuffix;
    fTreeDeposit = new TTree(treename, treename);
  
    fTreeDeposit->Branch("fEnergyDeposited", &fEnergyDeposited, "fEnergyDeposited/F");
    fTreeDeposit->Branch("fEnergyTPC", &fEnergyTPC, "fEnergyTPC/F");
    fTreeDeposit->Branch("fCharge", &fCharge, "fCharge/S");
    fTreeDeposit->Branch("fParticlePid", &fParticlePid, "fParticlePid/S");
    fTreeDeposit->Branch("fPidProb", &fPidProb, "fPidProb/F");
    fTreeDeposit->Branch("fTrackPassedCut", &fTrackPassedCut, "fTrackPassedCut/B");
 
  }

  return;
}
void AliAnalysisEt::FillHistograms()
{ // fill histograms..
    fHistEt->Fill(fTotEt);
    fHistChargedEt->Fill(fTotChargedEt);
    fHistNeutralEt->Fill(fTotNeutralEt);

    fHistEtAcc->Fill(fTotEtAcc);
    fHistChargedEtAcc->Fill(fTotChargedEtAcc);
    fHistNeutralEtAcc->Fill(fTotNeutralEtAcc);

    fHistMult->Fill(fMultiplicity);
    fHistChargedMult->Fill(fChargedMultiplicity);
    fHistNeutralMult->Fill(fNeutralMultiplicity);

    fHistBaryonEt->Fill(fBaryonEt);
    fHistAntiBaryonEt->Fill(fAntiBaryonEt);
    fHistMesonEt->Fill(fMesonEt);

    fHistProtonEt->Fill(fProtonEt);
    fHistPionEt->Fill(fPionEt);
    fHistChargedKaonEt->Fill(fChargedKaonEt);
    fHistMuonEt->Fill(fMuonEt);
    fHistElectronEt->Fill(fElectronEt);
    fHistNeutronEt->Fill(fNeutronEt);
    fHistAntiNeutronEt->Fill(fAntiNeutronEt);
    fHistGammaEt->Fill(fGammaEt);
    
    fHistProtonEtAcc->Fill(fProtonEtAcc);
    fHistPionEtAcc->Fill(fPionEtAcc);
    fHistChargedKaonEtAcc->Fill(fChargedKaonEtAcc);
    fHistMuonEtAcc->Fill(fMuonEtAcc);
    fHistElectronEtAcc->Fill(fElectronEtAcc);

    if (fCuts) {
      if (fCuts->GetHistMakeTree()) {
	fTree->Fill();
      }
    }

}

Int_t AliAnalysisEt::AnalyseEvent(AliVEvent *event)
{ //this line is basically here to eliminate a compiler warning that event is not used.  Making it a virtual function did not work with the plugin.
  AliAnalysisEtCommon::AnalyseEvent(event);
  ResetEventValues();
  return 0;
}

void AliAnalysisEt::ResetEventValues()
{ // clear
  AliAnalysisEtCommon::ResetEventValues();
  fTotEt = 0;
  fTotEtAcc = 0;
  fTotNeutralEt = 0;
  fTotNeutralEtAcc = 0;
  fTotChargedEt  = 0;
  fTotChargedEtAcc = 0;
  fMultiplicity = 0;
  fChargedMultiplicity = 0;
  fNeutralMultiplicity = 0;
  fBaryonEt = 0;
  fAntiBaryonEt = 0;
  fMesonEt = 0;
  fProtonEt = 0;
  fPionEt = 0;
  fChargedKaonEt = 0;
  fMuonEt = 0;
  fElectronEt = 0;
  fNeutronEt = 0;
  fAntiNeutronEt = 0;
  fGammaEt = 0;
  fProtonEtAcc = 0;
  fPionEtAcc = 0;
  fChargedKaonEtAcc = 0;
  fMuonEtAcc = 0;
  fElectronEtAcc = 0;
  return;
}
Commit	Line	Data
cf6522d1	1	//_________________________________________________________________________
	2	// Utility Class for transverse energy studies
	3	// Base class for ESD & MC analysis
	4	// - reconstruction and MonteCarlo output
	5	// implementation file
	6	//
	7	//*-- Authors: Oystein Djuvsland (Bergen), David Silvermyr (ORNL)
	8	//_________________________________________________________________________
	9
2fbf38ac	10	#include "AliAnalysisEt.h"
	11	#include "TMath.h"
	12	#include "TList.h"
	13	#include "TH1F.h"
	14	#include "TH2F.h"
ce546038	15	#include "TTree.h"
2fbf38ac	16	#include <iostream>
2fbf38ac	17	#include "AliAnalysisEtCuts.h"
951efd81	18	#include "AliESDtrackCuts.h"
641e1e0c	19	#include "AliVEvent.h"
cf6522d1	20	#include "Rtypes.h"
0f97be4c	21	#include "TString.h"
641e1e0c	22
641e1e0c	23	using namespace std;
2fbf38ac	24	ClassImp(AliAnalysisEt);
	25
	26
7d2d1773	27	AliAnalysisEt::AliAnalysisEt() : AliAnalysisEtCommon()
7d2d1773	28	,fTotEt(0)
	29	,fTotEtAcc(0)
	30	,fTotNeutralEt(0)
	31	,fTotNeutralEtAcc(0)
	32	,fTotChargedEt(0)
	33	,fTotChargedEtAcc(0)
	34	,fMultiplicity(0)
	35	,fChargedMultiplicity(0)
	36	,fNeutralMultiplicity(0)
	37	,fBaryonEt(0)
	38	,fAntiBaryonEt(0)
	39	,fMesonEt(0)
	40	,fProtonEt(0)
	41	,fPionEt(0)
	42	,fChargedKaonEt(0)
	43	,fMuonEt(0)
	44	,fElectronEt(0)
	45	,fNeutronEt(0)
	46	,fAntiNeutronEt(0)
	47	,fGammaEt(0)
	48	,fProtonEtAcc(0)
	49	,fPionEtAcc(0)
	50	,fChargedKaonEtAcc(0)
	51	,fMuonEtAcc(0)
	52	,fElectronEtAcc(0)
	53	,fEnergyDeposited(0)
	54	,fEnergyTPC(0)
	55	,fCharge(0)
	56	,fParticlePid(0)
	57	,fPidProb(0)
	58	,fTrackPassedCut(kFALSE)
	59	,fEtaCut(0)
	60	,fEtaCutAcc(0)
	61	,fPhiCutAccMin(0)
	62	,fPhiCutAccMax(0)
	63	,fDetectorRadius(0)
	64	,fClusterEnergyCut(0)
	65	,fSingleCellEnergyCut(0)
	66	,fHistEt(0)
	67	,fHistChargedEt(0)
	68	,fHistNeutralEt(0)
	69	,fHistEtAcc(0)
	70	,fHistChargedEtAcc(0)
	71	,fHistNeutralEtAcc(0)
	72	,fHistMult(0)
	73	,fHistChargedMult(0)
	74	,fHistNeutralMult(0)
	75	,fHistPhivsPtPos(0)
	76	,fHistPhivsPtNeg(0)
	77	,fHistBaryonEt(0)
	78	,fHistAntiBaryonEt(0)
	79	,fHistMesonEt(0)
	80	,fHistProtonEt(0)
	81	,fHistPionEt(0)
	82	,fHistChargedKaonEt(0)
	83	,fHistMuonEt(0)
	84	,fHistElectronEt(0)
	85	,fHistNeutronEt(0)
	86	,fHistAntiNeutronEt(0)
	87	,fHistGammaEt(0)
	88	,fHistProtonEtAcc(0)
	89	,fHistPionEtAcc(0)
	90	,fHistChargedKaonEtAcc(0)
	91	,fHistMuonEtAcc(0)
92	,fHistElectronEtAcc(0)
93	,fHistTMDeltaR(0)
94	,fTree(0)
95	,fTreeDeposit(0)
5501aa9c	96	,fCentrality(0)
2fbf38ac	97	{
2fbf38ac	98	}
	99
	100	AliAnalysisEt::~AliAnalysisEt()
464aa50c	101	{//Destructor
951efd81	102	if(fTreeDeposit){
	103	fTreeDeposit->Clear();
	104	delete fTreeDeposit; // optional TTree
	105	}
	106	if(fTree){
	107	fTree->Clear();
	108	delete fTree; // optional TTree
	109	}
7d2d1773	110	delete fHistEt; //Et spectrum
	111	delete fHistChargedEt; //Charged Et spectrum
	112	delete fHistNeutralEt; //Neutral Et spectrum
	113	delete fHistEtAcc; //Et in acceptance
	114	delete fHistChargedEtAcc; //Charged Et in acceptance
	115	delete fHistNeutralEtAcc; //Et in acceptance
	116	delete fHistMult; //Multiplicity
	117	delete fHistChargedMult; //Charged multiplicity
	118	delete fHistNeutralMult; //Neutral multiplicity
	119	delete fHistPhivsPtPos; //phi vs pT plot for positive tracks
	120	delete fHistPhivsPtNeg; //phi vs pT plot for negative tracks
	121	delete fHistBaryonEt; /** Et of identified baryons */
	122	delete fHistAntiBaryonEt; /** Et of identified anti-baryons */
	123	delete fHistMesonEt; /** Et of identified mesons */
	124	delete fHistProtonEt; /** Et of identified protons */
	125	delete fHistPionEt; /** Et of identified protons */
	126	delete fHistChargedKaonEt; /** Et of identified charged kaons */
	127	delete fHistMuonEt; /** Et of identified muons */
	128	delete fHistElectronEt; /** Et of identified electrons */
	129	delete fHistNeutronEt; /** Et of neutrons (MC only for now) */
	130	delete fHistAntiNeutronEt; /** Et of anti-neutrons (MC only for now) */
	131	delete fHistGammaEt; /** Et of gammas (MC only for now) */
	132	delete fHistProtonEtAcc; /** Et of identified protons in calorimeter acceptance */
	133	delete fHistPionEtAcc; /** Et of identified protons in calorimeter acceptance */
	134	delete fHistChargedKaonEtAcc; /** Et of identified charged kaons in calorimeter acceptance */
	135	delete fHistMuonEtAcc; /** Et of identified muons in calorimeter acceptance */
	136	delete fHistElectronEtAcc; /** Et of identified electrons in calorimeter acceptance */
	137	delete fHistTMDeltaR; /* Track matching plots; Rec only for now */
2fbf38ac	138	}
	139
	140	void AliAnalysisEt::FillOutputList(TList *list)
cf6522d1	141	{ // histograms to be added to output
2fbf38ac	142	list->Add(fHistEt);
	143	list->Add(fHistChargedEt);
	144	list->Add(fHistNeutralEt);
	145
	146	list->Add(fHistEtAcc);
	147	list->Add(fHistChargedEtAcc);
	148	list->Add(fHistNeutralEtAcc);
	149
	150	list->Add(fHistMult);
	151	list->Add(fHistChargedMult);
	152	list->Add(fHistNeutralMult);
	153
	154	list->Add(fHistPhivsPtPos);
	155	list->Add(fHistPhivsPtNeg);
	156
	157	list->Add(fHistBaryonEt);
	158	list->Add(fHistAntiBaryonEt);
	159	list->Add(fHistMesonEt);
	160
43056f1b	161	list->Add(fHistProtonEt);
	162	list->Add(fHistPionEt);
	163	list->Add(fHistChargedKaonEt);
	164	list->Add(fHistMuonEt);
	165	list->Add(fHistElectronEt);
	166
	167	list->Add(fHistNeutronEt);
	168	list->Add(fHistAntiNeutronEt);
	169	list->Add(fHistGammaEt);
	170
87efb15c	171	list->Add(fHistProtonEtAcc);
43056f1b	172	list->Add(fHistPionEtAcc);
87efb15c	173	list->Add(fHistChargedKaonEtAcc);
	174	list->Add(fHistMuonEtAcc);
	175	list->Add(fHistElectronEtAcc);
	176
2fbf38ac	177	list->Add(fHistTMDeltaR);
ce546038	178
	179	if (fCuts) {
	180	if (fCuts->GetHistMakeTree()) {
	181	list->Add(fTree);
	182	}
	183	}
8ea99ab0	184	list->Add(fTreeDeposit);
ce546038	185
2fbf38ac	186	}
	187
	188	void AliAnalysisEt::Init()
0065531a	189	{// clear variables, set up cuts and PDG info
7d2d1773	190	AliAnalysisEtCommon::Init();
0065531a	191	ResetEventValues();
2fbf38ac	192	}
	193
	194	void AliAnalysisEt::CreateHistograms()
cf6522d1	195	{ // create histograms..
13b0d3c1	196	// histogram binning for E_T, p_T and Multiplicity: defaults for p+p
	197	Int_t nbinsEt = 1000;
	198	Double_t minEt = 0.0001;
	199	Double_t maxEt = 100;
	200	Int_t nbinsPt = 200;
	201	Double_t minPt = 0;
	202	Double_t maxPt = 20;
	203	Int_t nbinsMult = 200;
	204	Double_t minMult = -0.5; // offset -0.5 to have integer bins centered around 0
	205	Double_t maxMult = nbinsMult + minMult; // 1 bin per integer value
2fbf38ac	206
ce546038	207	// see if we should change histogram limits etc, and possibly create a tree
ce546038	208	if (fCuts) {
8ea99ab0	209	//if (fCuts->GetHistMakeTree()) {
	210	CreateTrees();
	211	//}
0fa8c632	212
	213	nbinsMult = fCuts->GetHistNbinsMult();
	214	minMult = fCuts->GetHistMinMult();
	215	maxMult = fCuts->GetHistMaxMult();
	216
	217	nbinsEt = fCuts->GetHistNbinsTotEt();
	218	minEt = fCuts->GetHistMinTotEt();
	219	maxEt = fCuts->GetHistMaxTotEt();
	220
	221	nbinsPt = fCuts->GetHistNbinsParticlePt();
	222	minPt = fCuts->GetHistMinParticlePt();
	223	maxPt = fCuts->GetHistMaxParticlePt();
ce546038	224	}
ce546038	225
2fbf38ac	226	TString histname = "fHistEt" + fHistogramNameSuffix;
13b0d3c1	227	fHistEt = new TH1F(histname.Data(), "Total E_{T} Distribution", nbinsEt, minEt, maxEt);
2fbf38ac	228	fHistEt->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
	229	fHistEt->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");
	230
	231	histname = "fHistChargedEt" + fHistogramNameSuffix;
13b0d3c1	232	fHistChargedEt = new TH1F(histname.Data(), "Total Charged E_{T} Distribution", nbinsEt, minEt, maxEt);
2fbf38ac	233	fHistChargedEt->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
	234	fHistChargedEt->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");
	235
	236	histname = "fHistNeutralEt" + fHistogramNameSuffix;
13b0d3c1	237	fHistNeutralEt = new TH1F(histname.Data(), "Total Neutral E_{T} Distribution", nbinsEt, minEt, maxEt);
2fbf38ac	238	fHistNeutralEt->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
	239	fHistNeutralEt->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");
	240
	241	histname = "fHistEtAcc" + fHistogramNameSuffix;
13b0d3c1	242	fHistEtAcc = new TH1F(histname.Data(), "Total E_{T} Distribution in Acceptance", nbinsEt, minEt, maxEt);
2fbf38ac	243	fHistEtAcc->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
	244	fHistEtAcc->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");
	245
	246	histname = "fHistChargedEtAcc" + fHistogramNameSuffix;
13b0d3c1	247	fHistChargedEtAcc = new TH1F(histname.Data(), "Total Charged E_{T} Distribution in Acceptance", nbinsEt, minEt, maxEt);
2fbf38ac	248	fHistChargedEtAcc->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
	249	fHistChargedEtAcc->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");
	250
	251	histname = "fHistNeutralEtAcc" + fHistogramNameSuffix;
13b0d3c1	252	fHistNeutralEtAcc = new TH1F(histname.Data(), "Total Neutral E_{T} Distribution in Acceptance", nbinsEt, minEt, maxEt);
2fbf38ac	253	fHistNeutralEtAcc->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
	254	fHistNeutralEtAcc->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");
	255	std::cout << histname << std::endl;
	256	histname = "fHistMult" + fHistogramNameSuffix;
13b0d3c1	257	fHistMult = new TH1F(histname.Data(), "Total Multiplicity", nbinsMult, minMult, maxMult);
2fbf38ac	258	fHistMult->GetXaxis()->SetTitle("N");
	259	fHistMult->GetYaxis()->SetTitle("Multiplicity");
	260
	261	histname = "fHistChargedMult" + fHistogramNameSuffix;
13b0d3c1	262	fHistChargedMult = new TH1F(histname.Data(), "Charged Multiplicity", nbinsMult, minMult, maxMult);
2fbf38ac	263	fHistChargedMult->GetXaxis()->SetTitle("N");
	264	fHistChargedMult->GetYaxis()->SetTitle("Multiplicity");
	265
	266	histname = "fHistNeutralMult" + fHistogramNameSuffix;
13b0d3c1	267	fHistNeutralMult = new TH1F(histname.Data(), "Neutral Multiplicity", nbinsMult, minMult, maxMult);
2fbf38ac	268	fHistNeutralMult->GetXaxis()->SetTitle("N");
	269	fHistNeutralMult->GetYaxis()->SetTitle("Multiplicity");
	270
	271	histname = "fHistPhivsPtPos" + fHistogramNameSuffix;
13b0d3c1	272	fHistPhivsPtPos = new TH2F(histname.Data(), "Phi vs pT of positively charged tracks hitting the calorimeter", 200, 0, 2*TMath::Pi(), nbinsPt, minPt, maxPt);
2fbf38ac	273
2fbf38ac	274	histname = "fHistPhivsPtNeg" + fHistogramNameSuffix;
13b0d3c1	275	fHistPhivsPtNeg = new TH2F(histname.Data(), "Phi vs pT of negatively charged tracks hitting the calorimeter", 200, 0, 2*TMath::Pi(), nbinsPt, minPt, maxPt);
2fbf38ac	276
2fbf38ac	277	histname = "fHistBaryonEt" + fHistogramNameSuffix;
13b0d3c1	278	fHistBaryonEt = new TH1F(histname.Data(), "E_{T} for baryons", nbinsEt, minEt, maxEt);
2fbf38ac	279
2fbf38ac	280	histname = "fHistAntiBaryonEt" + fHistogramNameSuffix;
13b0d3c1	281	fHistAntiBaryonEt = new TH1F(histname.Data(), "E_{T} for anti baryons", nbinsEt, minEt, maxEt);
2fbf38ac	282
2fbf38ac	283	histname = "fHistMesonEt" + fHistogramNameSuffix;
13b0d3c1	284	fHistMesonEt = new TH1F(histname.Data(), "E_{T} for mesons", nbinsEt, minEt, maxEt);
2fbf38ac	285
87efb15c	286	histname = "fHistProtonEt" + fHistogramNameSuffix;
	287	fHistProtonEt = new TH1F(histname.Data(), "E_{T} for (anti-)protons", nbinsEt, minEt, maxEt);
	288
43056f1b	289	histname = "fHistPionEt" + fHistogramNameSuffix;
	290	fHistPionEt = new TH1F(histname.Data(), "E_{T} for #pi^+/#pi^-", nbinsEt, minEt, maxEt);
	291
87efb15c	292	histname = "fHistKaonEt" + fHistogramNameSuffix;
	293	fHistChargedKaonEt = new TH1F(histname.Data(), "E_{T} for charged kaons", nbinsEt, minEt, maxEt);
	294
	295	histname = "fHistMuonEt" + fHistogramNameSuffix;
	296	fHistMuonEt = new TH1F(histname.Data(), "E_{T} for muons", nbinsEt, minEt, maxEt);
	297
	298	histname = "fHistElectronEt" + fHistogramNameSuffix;
	299	fHistElectronEt = new TH1F(histname.Data(), "E_{T} for electrons/positrons", nbinsEt, minEt, maxEt);
	300
43056f1b	301	histname = "fHistNeutronEt" + fHistogramNameSuffix;
	302	fHistNeutronEt = new TH1F(histname.Data(), "E_{T} for neutrons", nbinsEt, minEt, maxEt);
	303
	304	histname = "fHistAntiNeutronEt" + fHistogramNameSuffix;
	305	fHistAntiNeutronEt = new TH1F(histname.Data(), "E_{T} for anti-neutrons", nbinsEt, minEt, maxEt);
	306
	307	histname = "fHistGammaEt" + fHistogramNameSuffix;
	308	fHistGammaEt = new TH1F(histname.Data(), "E_{T} for gammas", nbinsEt, minEt, maxEt);
	309
87efb15c	310	histname = "fHistProtonEtAcc" + fHistogramNameSuffix;
	311	fHistProtonEtAcc = new TH1F(histname.Data(), "E_{T} for (anti-)protons in calorimeter acceptance", nbinsEt, minEt, maxEt);
	312
43056f1b	313	histname = "fHistPionEtAcc" + fHistogramNameSuffix;
	314	fHistPionEtAcc = new TH1F(histname.Data(), "E_{T} for #pi^+/#pi^- in calorimeter acceptance", nbinsEt, minEt, maxEt);
	315
87efb15c	316	histname = "fHistKaonEtAcc" + fHistogramNameSuffix;
	317	fHistChargedKaonEtAcc = new TH1F(histname.Data(), "E_{T} for charged kaons in calorimeter acceptance", nbinsEt, minEt, maxEt);
	318
	319	histname = "fHistMuonEtAcc" + fHistogramNameSuffix;
	320	fHistMuonEtAcc = new TH1F(histname.Data(), "E_{T} for muons in calorimeter acceptance", nbinsEt, minEt, maxEt);
	321
	322	histname = "fHistElectronEtAcc" + fHistogramNameSuffix;
	323	fHistElectronEtAcc = new TH1F(histname.Data(), "E_{T} for electrons/positrons in calorimeter acceptance", nbinsEt, minEt, maxEt);
	324
cf6522d1	325	//
2fbf38ac	326	histname = "fHistTMDeltaR" + fHistogramNameSuffix;
	327	fHistTMDeltaR = new TH1F(histname.Data(), "#Delta R for calorimeter clusters", 200, 0, 50);
	328
	329	}
	330
8ea99ab0	331	void AliAnalysisEt::CreateTrees()
ce546038	332	{ // create tree..
ce546038	333	TString treename = "fTree" + fHistogramNameSuffix;
8ea99ab0	334	if(fCuts->GetHistMakeTree())
	335	{
	336
	337	fTree = new TTree(treename, treename);
	338	fTree->Branch("fTotEt",&fTotEt,"fTotEt/D");
	339	fTree->Branch("fTotEtAcc",&fTotEtAcc,"fTotEtAcc/D");
	340	fTree->Branch("fTotNeutralEt",&fTotNeutralEt,"fTotNeutralEt/D");
	341	fTree->Branch("fTotNeutralEtAcc",&fTotNeutralEtAcc,"fTotNeutralEtAcc/D");
	342	fTree->Branch("fTotChargedEt",&fTotChargedEt,"fTotChargedEt/D");
	343	fTree->Branch("fTotChargedEtAcc",&fTotChargedEtAcc,"fTotChargedEtAcc/D");
	344	fTree->Branch("fMultiplicity",&fMultiplicity,"fMultiplicity/I");
	345	fTree->Branch("fChargedMultiplicity",&fChargedMultiplicity,"fChargedMultiplicity/I");
	346	fTree->Branch("fNeutralMultiplicity",&fNeutralMultiplicity,"fNeutralMultiplicity/I");
	347	fTree->Branch("fBaryonEt",&fBaryonEt,"fBaryonEt/D");
	348	fTree->Branch("fAntiBaryonEt",&fAntiBaryonEt,"fAntiBaryonEt/D");
	349	fTree->Branch("fMesonEt",&fMesonEt,"fMesonEt/D");
8ea99ab0	350	fTree->Branch("fProtonEt",&fProtonEt,"fProtonEt/D");
	351	fTree->Branch("fChargedKaonEt",&fChargedKaonEt,"fChargedKaonEt/D");
	352	fTree->Branch("fMuonEt",&fMuonEt,"fMuonEt/D");
	353	fTree->Branch("fElectronEt",&fElectronEt,"fElectronEt/D");
	354	fTree->Branch("fProtonEtAcc",&fProtonEtAcc,"fProtonEtAcc/D");
	355	fTree->Branch("fChargedKaonEtAcc",&fChargedKaonEtAcc,"fChargedKaonEtAcc/D");
	356	fTree->Branch("fMuonEtAcc",&fMuonEtAcc,"fMuonEtAcc/D");
	357	fTree->Branch("fElectronEtAcc",&fElectronEtAcc,"fElectronEtAcc/D");
	358	}
	359
	360	if(fCuts->GetHistMakeTreeDeposit())
	361	{
	362	treename = "fTreeDeposit" + fHistogramNameSuffix;
	363	fTreeDeposit = new TTree(treename, treename);
	364
	365	fTreeDeposit->Branch("fEnergyDeposited", &fEnergyDeposited, "fEnergyDeposited/F");
	366	fTreeDeposit->Branch("fEnergyTPC", &fEnergyTPC, "fEnergyTPC/F");
	367	fTreeDeposit->Branch("fCharge", &fCharge, "fCharge/S");
	368	fTreeDeposit->Branch("fParticlePid", &fParticlePid, "fParticlePid/S");
	369	fTreeDeposit->Branch("fPidProb", &fPidProb, "fPidProb/F");
	370	fTreeDeposit->Branch("fTrackPassedCut", &fTrackPassedCut, "fTrackPassedCut/B");
	371
	372	}
7b873813	373
ce546038	374	return;
ce546038	375	}
2fbf38ac	376	void AliAnalysisEt::FillHistograms()
cf6522d1	377	{ // fill histograms..
2fbf38ac	378	fHistEt->Fill(fTotEt);
	379	fHistChargedEt->Fill(fTotChargedEt);
	380	fHistNeutralEt->Fill(fTotNeutralEt);
	381
	382	fHistEtAcc->Fill(fTotEtAcc);
	383	fHistChargedEtAcc->Fill(fTotChargedEtAcc);
	384	fHistNeutralEtAcc->Fill(fTotNeutralEtAcc);
	385
	386	fHistMult->Fill(fMultiplicity);
	387	fHistChargedMult->Fill(fChargedMultiplicity);
	388	fHistNeutralMult->Fill(fNeutralMultiplicity);
	389
ce546038	390	fHistBaryonEt->Fill(fBaryonEt);
	391	fHistAntiBaryonEt->Fill(fAntiBaryonEt);
	392	fHistMesonEt->Fill(fMesonEt);
2fbf38ac	393
87efb15c	394	fHistProtonEt->Fill(fProtonEt);
43056f1b	395	fHistPionEt->Fill(fPionEt);
87efb15c	396	fHistChargedKaonEt->Fill(fChargedKaonEt);
	397	fHistMuonEt->Fill(fMuonEt);
	398	fHistElectronEt->Fill(fElectronEt);
43056f1b	399	fHistNeutronEt->Fill(fNeutronEt);
	400	fHistAntiNeutronEt->Fill(fAntiNeutronEt);
	401	fHistGammaEt->Fill(fGammaEt);
87efb15c	402
87efb15c	403	fHistProtonEtAcc->Fill(fProtonEtAcc);
43056f1b	404	fHistPionEtAcc->Fill(fPionEtAcc);
87efb15c	405	fHistChargedKaonEtAcc->Fill(fChargedKaonEtAcc);
	406	fHistMuonEtAcc->Fill(fMuonEtAcc);
	407	fHistElectronEtAcc->Fill(fElectronEtAcc);
ce546038	408
	409	if (fCuts) {
	410	if (fCuts->GetHistMakeTree()) {
	411	fTree->Fill();
	412	}
	413	}
	414
2fbf38ac	415	}
0065531a	416
641e1e0c	417	Int_t AliAnalysisEt::AnalyseEvent(AliVEvent *event)
0065531a	418	{ //this line is basically here to eliminate a compiler warning that event is not used. Making it a virtual function did not work with the plugin.
7d2d1773	419	AliAnalysisEtCommon::AnalyseEvent(event);
0065531a	420	ResetEventValues();
641e1e0c	421	return 0;
641e1e0c	422	}
2fbf38ac	423
2fbf38ac	424	void AliAnalysisEt::ResetEventValues()
cf6522d1	425	{ // clear
7d2d1773	426	AliAnalysisEtCommon::ResetEventValues();
0065531a	427	fTotEt = 0;
	428	fTotEtAcc = 0;
	429	fTotNeutralEt = 0;
	430	fTotNeutralEtAcc = 0;
	431	fTotChargedEt = 0;
	432	fTotChargedEtAcc = 0;
	433	fMultiplicity = 0;
	434	fChargedMultiplicity = 0;
	435	fNeutralMultiplicity = 0;
87efb15c	436	fBaryonEt = 0;
	437	fAntiBaryonEt = 0;
	438	fMesonEt = 0;
87efb15c	439	fProtonEt = 0;
7b873813	440	fPionEt = 0;
87efb15c	441	fChargedKaonEt = 0;
	442	fMuonEt = 0;
	443	fElectronEt = 0;
7b873813	444	fNeutronEt = 0;
	445	fAntiNeutronEt = 0;
	446	fGammaEt = 0;
87efb15c	447	fProtonEtAcc = 0;
7b873813	448	fPionEtAcc = 0;
87efb15c	449	fChargedKaonEtAcc = 0;
87efb15c	450	fMuonEtAcc = 0;
ce546038	451	fElectronEtAcc = 0;
0065531a	452	return;
2fbf38ac	453	}
99a6613d	454