[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)
{
}

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