[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 "TDatabasePDG.h"
#include "Rtypes.h"

using namespace std;
ClassImp(AliAnalysisEt);


AliAnalysisEt::AliAnalysisEt() :
        fHistogramNameSuffix("")
        ,fCuts(0)
        ,fPdgDB(0)
        ,fPiPlusCode(0)
        ,fPiMinusCode(0)
        ,fKPlusCode(0)
        ,fKMinusCode(0)
        ,fProtonCode(0)
        ,fAntiProtonCode(0)
        ,fLambdaCode(0)
        ,fAntiLambdaCode(0)
        ,fK0SCode(0)
        ,fOmegaCode(0)
        ,fAntiOmegaCode(0)
        ,fXi0Code(0)
        ,fAntiXi0Code(0)
        ,fXiCode(0)
        ,fAntiXiCode(0)
        ,fSigmaCode(0)
        ,fAntiSigmaCode(0)
        ,fK0LCode(0)
        ,fNeutronCode(0)
        ,fAntiNeutronCode(0)
        ,fEPlusCode(0)
        ,fEMinusCode(0)
        ,fMuPlusCode(0)
        ,fMuMinusCode(0)
        ,fGammaCode(0)
        ,fPionMass(0)
        ,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)
        ,fEsdtrackCutsTPC(0)
{
}

AliAnalysisEt::~AliAnalysisEt()
{//Destructor
  delete fCuts;
  delete fPdgDB;
  if(fTreeDeposit){
    fTreeDeposit->Clear();
    delete fTreeDeposit; // optional TTree
  }
  if(fTree){
    fTree->Clear();
    delete fTree; // optional TTree
  }
  delete fEsdtrackCutsTPC;

}

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
  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.
  cout << "This event has " << event->GetNumberOfTracks() << " tracks" << endl;
  ResetEventValues();
  return 0;
}

void AliAnalysisEt::ResetEventValues()
{ // clear
  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;
  
  if (!fCuts || !fPdgDB || fPiPlusCode==0) { // some Init's needed
    cout << __FILE__ << ":" << __LINE__ << " : Init " << endl;
    if (!fCuts) {
      cout << " setting up Cuts " << endl;
      fCuts = new AliAnalysisEtCuts();
    }
    if(!fPdgDB) {
      cout << " setting up PdgDB " << endl;
      fPdgDB = new TDatabasePDG();
    }
    if (fPiPlusCode==0) {
      SetParticleCodes();
    }
  }
  return;
}


void AliAnalysisEt::SetParticleCodes()
{ // set PDG info    
  fPionMass = fPdgDB->GetParticle("pi+")->Mass();
  fPiPlusCode = fPdgDB->GetParticle("pi+")->PdgCode();
  fPiMinusCode = fPdgDB->GetParticle("pi-")->PdgCode();
  fKPlusCode = fPdgDB->GetParticle("K+")->PdgCode();
  fKMinusCode = fPdgDB->GetParticle("K-")->PdgCode();
  fProtonCode = fPdgDB->GetParticle("proton")->PdgCode();
  fAntiProtonCode = fPdgDB->GetParticle("antiproton")->PdgCode();
  fLambdaCode = fPdgDB->GetParticle("Lambda0")->PdgCode();
  fAntiLambdaCode = fPdgDB->GetParticle("Lambda0_bar")->PdgCode();
  fK0SCode = fPdgDB->GetParticle("K_S0")->PdgCode();
  fOmegaCode = fPdgDB->GetParticle("Omega-")->PdgCode();
  fAntiOmegaCode = fPdgDB->GetParticle("Omega+")->PdgCode();
  fXi0Code = fPdgDB->GetParticle("Xi0")->PdgCode();
  fAntiXi0Code = fPdgDB->GetParticle("Xi0_bar")->PdgCode();
  fXiCode = fPdgDB->GetParticle("Xi-")->PdgCode();
  fAntiXiCode = fPdgDB->GetParticle("Xi-_bar")->PdgCode();
  fSigmaCode = fPdgDB->GetParticle("Sigma-")->PdgCode();
  fAntiSigmaCode = fPdgDB->GetParticle("Sigma+")->PdgCode();
  fK0LCode = fPdgDB->GetParticle("K_L0")->PdgCode();
  fNeutronCode = fPdgDB->GetParticle("neutron")->PdgCode();
  fAntiNeutronCode = fPdgDB->GetParticle("antineutron")->PdgCode();
  fEPlusCode = fPdgDB->GetParticle("e+")->PdgCode();
  fEMinusCode = fPdgDB->GetParticle("e-")->PdgCode();
  fMuPlusCode = fPdgDB->GetParticle("mu+")->PdgCode();
  fMuMinusCode = fPdgDB->GetParticle("mu-")->PdgCode();
  fGammaCode = fPdgDB->GetParticle("gamma")->PdgCode();
  
  cout << "Resetting Codes: Pion " << fPiPlusCode
       << "," << fPiMinusCode 
       << " Kaon " << fKPlusCode 
       << "," << fKMinusCode << endl;
}
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 "TDatabasePDG.h"
cf6522d1	21	#include "Rtypes.h"
641e1e0c	22
641e1e0c	23	using namespace std;
2fbf38ac	24	ClassImp(AliAnalysisEt);
	25
	26
	27	AliAnalysisEt::AliAnalysisEt() :
	28	fHistogramNameSuffix("")
4998becf	29	,fCuts(0)
2fbf38ac	30	,fPdgDB(0)
8985c506	31	,fPiPlusCode(0)
	32	,fPiMinusCode(0)
	33	,fKPlusCode(0)
	34	,fKMinusCode(0)
	35	,fProtonCode(0)
	36	,fAntiProtonCode(0)
	37	,fLambdaCode(0)
	38	,fAntiLambdaCode(0)
	39	,fK0SCode(0)
	40	,fOmegaCode(0)
	41	,fAntiOmegaCode(0)
	42	,fXi0Code(0)
	43	,fAntiXi0Code(0)
	44	,fXiCode(0)
	45	,fAntiXiCode(0)
	46	,fSigmaCode(0)
	47	,fAntiSigmaCode(0)
	48	,fK0LCode(0)
	49	,fNeutronCode(0)
	50	,fAntiNeutronCode(0)
	51	,fEPlusCode(0)
	52	,fEMinusCode(0)
7b873813	53	,fMuPlusCode(0)
7b873813	54	,fMuMinusCode(0)
43056f1b	55	,fGammaCode(0)
8985c506	56	,fPionMass(0)
2fbf38ac	57	,fTotEt(0)
	58	,fTotEtAcc(0)
	59	,fTotNeutralEt(0)
	60	,fTotNeutralEtAcc(0)
	61	,fTotChargedEt(0)
	62	,fTotChargedEtAcc(0)
	63	,fMultiplicity(0)
	64	,fChargedMultiplicity(0)
	65	,fNeutralMultiplicity(0)
87efb15c	66	,fBaryonEt(0)
	67	,fAntiBaryonEt(0)
	68	,fMesonEt(0)
87efb15c	69	,fProtonEt(0)
43056f1b	70	,fPionEt(0)
87efb15c	71	,fChargedKaonEt(0)
	72	,fMuonEt(0)
	73	,fElectronEt(0)
43056f1b	74	,fNeutronEt(0)
	75	,fAntiNeutronEt(0)
	76	,fGammaEt(0)
87efb15c	77	,fProtonEtAcc(0)
43056f1b	78	,fPionEtAcc(0)
87efb15c	79	,fChargedKaonEtAcc(0)
	80	,fMuonEtAcc(0)
	81	,fElectronEtAcc(0)
8ea99ab0	82	,fEnergyDeposited(0)
	83	,fEnergyTPC(0)
	84	,fCharge(0)
	85	,fParticlePid(0)
	86	,fPidProb(0)
	87	,fTrackPassedCut(kFALSE)
87efb15c	88	,fEtaCut(0)
4998becf	89	,fEtaCutAcc(0)
	90	,fPhiCutAccMin(0)
	91	,fPhiCutAccMax(0)
	92	,fDetectorRadius(0)
	93	,fClusterEnergyCut(0)
	94	,fSingleCellEnergyCut(0)
2fbf38ac	95	,fHistEt(0)
	96	,fHistChargedEt(0)
	97	,fHistNeutralEt(0)
	98	,fHistEtAcc(0)
	99	,fHistChargedEtAcc(0)
	100	,fHistNeutralEtAcc(0)
	101	,fHistMult(0)
	102	,fHistChargedMult(0)
	103	,fHistNeutralMult(0)
	104	,fHistPhivsPtPos(0)
	105	,fHistPhivsPtNeg(0)
	106	,fHistBaryonEt(0)
	107	,fHistAntiBaryonEt(0)
	108	,fHistMesonEt(0)
87efb15c	109	,fHistProtonEt(0)
43056f1b	110	,fHistPionEt(0)
87efb15c	111	,fHistChargedKaonEt(0)
	112	,fHistMuonEt(0)
	113	,fHistElectronEt(0)
43056f1b	114	,fHistNeutronEt(0)
	115	,fHistAntiNeutronEt(0)
	116	,fHistGammaEt(0)
87efb15c	117	,fHistProtonEtAcc(0)
43056f1b	118	,fHistPionEtAcc(0)
87efb15c	119	,fHistChargedKaonEtAcc(0)
	120	,fHistMuonEtAcc(0)
	121	,fHistElectronEtAcc(0)
2fbf38ac	122	,fHistTMDeltaR(0)
ce546038	123	,fTree(0)
8ea99ab0	124	,fTreeDeposit(0)
b5821c13	125	,fEsdtrackCutsTPC(0)
2fbf38ac	126	{
2fbf38ac	127	}
	128
	129	AliAnalysisEt::~AliAnalysisEt()
464aa50c	130	{//Destructor
951efd81	131	delete fCuts;
	132	delete fPdgDB;
	133	if(fTreeDeposit){
	134	fTreeDeposit->Clear();
	135	delete fTreeDeposit; // optional TTree
	136	}
	137	if(fTree){
	138	fTree->Clear();
	139	delete fTree; // optional TTree
	140	}
	141	delete fEsdtrackCutsTPC;
2fbf38ac	142
	143	}
	144
	145	void AliAnalysisEt::FillOutputList(TList *list)
cf6522d1	146	{ // histograms to be added to output
2fbf38ac	147	list->Add(fHistEt);
	148	list->Add(fHistChargedEt);
	149	list->Add(fHistNeutralEt);
	150
	151	list->Add(fHistEtAcc);
	152	list->Add(fHistChargedEtAcc);
	153	list->Add(fHistNeutralEtAcc);
	154
	155	list->Add(fHistMult);
	156	list->Add(fHistChargedMult);
	157	list->Add(fHistNeutralMult);
	158
	159	list->Add(fHistPhivsPtPos);
	160	list->Add(fHistPhivsPtNeg);
	161
	162	list->Add(fHistBaryonEt);
	163	list->Add(fHistAntiBaryonEt);
	164	list->Add(fHistMesonEt);
	165
43056f1b	166	list->Add(fHistProtonEt);
	167	list->Add(fHistPionEt);
	168	list->Add(fHistChargedKaonEt);
	169	list->Add(fHistMuonEt);
	170	list->Add(fHistElectronEt);
	171
	172	list->Add(fHistNeutronEt);
	173	list->Add(fHistAntiNeutronEt);
	174	list->Add(fHistGammaEt);
	175
87efb15c	176	list->Add(fHistProtonEtAcc);
43056f1b	177	list->Add(fHistPionEtAcc);
87efb15c	178	list->Add(fHistChargedKaonEtAcc);
	179	list->Add(fHistMuonEtAcc);
	180	list->Add(fHistElectronEtAcc);
	181
2fbf38ac	182	list->Add(fHistTMDeltaR);
ce546038	183
	184	if (fCuts) {
	185	if (fCuts->GetHistMakeTree()) {
	186	list->Add(fTree);
	187	}
	188	}
8ea99ab0	189	list->Add(fTreeDeposit);
ce546038	190
2fbf38ac	191	}
	192
	193	void AliAnalysisEt::Init()
0065531a	194	{// clear variables, set up cuts and PDG info
0065531a	195	ResetEventValues();
2fbf38ac	196	}
	197
	198	void AliAnalysisEt::CreateHistograms()
cf6522d1	199	{ // create histograms..
13b0d3c1	200	// histogram binning for E_T, p_T and Multiplicity: defaults for p+p
	201	Int_t nbinsEt = 1000;
	202	Double_t minEt = 0.0001;
	203	Double_t maxEt = 100;
	204	Int_t nbinsPt = 200;
	205	Double_t minPt = 0;
	206	Double_t maxPt = 20;
	207	Int_t nbinsMult = 200;
	208	Double_t minMult = -0.5; // offset -0.5 to have integer bins centered around 0
	209	Double_t maxMult = nbinsMult + minMult; // 1 bin per integer value
2fbf38ac	210
ce546038	211	// see if we should change histogram limits etc, and possibly create a tree
ce546038	212	if (fCuts) {
8ea99ab0	213	//if (fCuts->GetHistMakeTree()) {
	214	CreateTrees();
	215	//}
0fa8c632	216
	217	nbinsMult = fCuts->GetHistNbinsMult();
	218	minMult = fCuts->GetHistMinMult();
	219	maxMult = fCuts->GetHistMaxMult();
	220
	221	nbinsEt = fCuts->GetHistNbinsTotEt();
	222	minEt = fCuts->GetHistMinTotEt();
	223	maxEt = fCuts->GetHistMaxTotEt();
	224
	225	nbinsPt = fCuts->GetHistNbinsParticlePt();
	226	minPt = fCuts->GetHistMinParticlePt();
	227	maxPt = fCuts->GetHistMaxParticlePt();
ce546038	228	}
ce546038	229
2fbf38ac	230	TString histname = "fHistEt" + fHistogramNameSuffix;
13b0d3c1	231	fHistEt = new TH1F(histname.Data(), "Total E_{T} Distribution", nbinsEt, minEt, maxEt);
2fbf38ac	232	fHistEt->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
	233	fHistEt->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");
	234
	235	histname = "fHistChargedEt" + fHistogramNameSuffix;
13b0d3c1	236	fHistChargedEt = new TH1F(histname.Data(), "Total Charged E_{T} Distribution", nbinsEt, minEt, maxEt);
2fbf38ac	237	fHistChargedEt->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
	238	fHistChargedEt->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");
	239
	240	histname = "fHistNeutralEt" + fHistogramNameSuffix;
13b0d3c1	241	fHistNeutralEt = new TH1F(histname.Data(), "Total Neutral E_{T} Distribution", nbinsEt, minEt, maxEt);
2fbf38ac	242	fHistNeutralEt->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
	243	fHistNeutralEt->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");
	244
	245	histname = "fHistEtAcc" + fHistogramNameSuffix;
13b0d3c1	246	fHistEtAcc = new TH1F(histname.Data(), "Total E_{T} Distribution in Acceptance", nbinsEt, minEt, maxEt);
2fbf38ac	247	fHistEtAcc->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
	248	fHistEtAcc->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");
	249
	250	histname = "fHistChargedEtAcc" + fHistogramNameSuffix;
13b0d3c1	251	fHistChargedEtAcc = new TH1F(histname.Data(), "Total Charged E_{T} Distribution in Acceptance", nbinsEt, minEt, maxEt);
2fbf38ac	252	fHistChargedEtAcc->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
	253	fHistChargedEtAcc->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");
	254
	255	histname = "fHistNeutralEtAcc" + fHistogramNameSuffix;
13b0d3c1	256	fHistNeutralEtAcc = new TH1F(histname.Data(), "Total Neutral E_{T} Distribution in Acceptance", nbinsEt, minEt, maxEt);
2fbf38ac	257	fHistNeutralEtAcc->GetXaxis()->SetTitle("E_{T} (GeV/c^{2})");
	258	fHistNeutralEtAcc->GetYaxis()->SetTitle("dN/dE_{T} (c^{2}/GeV)");
	259	std::cout << histname << std::endl;
	260	histname = "fHistMult" + fHistogramNameSuffix;
13b0d3c1	261	fHistMult = new TH1F(histname.Data(), "Total Multiplicity", nbinsMult, minMult, maxMult);
2fbf38ac	262	fHistMult->GetXaxis()->SetTitle("N");
	263	fHistMult->GetYaxis()->SetTitle("Multiplicity");
	264
	265	histname = "fHistChargedMult" + fHistogramNameSuffix;
13b0d3c1	266	fHistChargedMult = new TH1F(histname.Data(), "Charged Multiplicity", nbinsMult, minMult, maxMult);
2fbf38ac	267	fHistChargedMult->GetXaxis()->SetTitle("N");
	268	fHistChargedMult->GetYaxis()->SetTitle("Multiplicity");
	269
	270	histname = "fHistNeutralMult" + fHistogramNameSuffix;
13b0d3c1	271	fHistNeutralMult = new TH1F(histname.Data(), "Neutral Multiplicity", nbinsMult, minMult, maxMult);
2fbf38ac	272	fHistNeutralMult->GetXaxis()->SetTitle("N");
	273	fHistNeutralMult->GetYaxis()->SetTitle("Multiplicity");
	274
	275	histname = "fHistPhivsPtPos" + fHistogramNameSuffix;
13b0d3c1	276	fHistPhivsPtPos = new TH2F(histname.Data(), "Phi vs pT of positively charged tracks hitting the calorimeter", 200, 0, 2*TMath::Pi(), nbinsPt, minPt, maxPt);
2fbf38ac	277
2fbf38ac	278	histname = "fHistPhivsPtNeg" + fHistogramNameSuffix;
13b0d3c1	279	fHistPhivsPtNeg = new TH2F(histname.Data(), "Phi vs pT of negatively charged tracks hitting the calorimeter", 200, 0, 2*TMath::Pi(), nbinsPt, minPt, maxPt);
2fbf38ac	280
2fbf38ac	281	histname = "fHistBaryonEt" + fHistogramNameSuffix;
13b0d3c1	282	fHistBaryonEt = new TH1F(histname.Data(), "E_{T} for baryons", nbinsEt, minEt, maxEt);
2fbf38ac	283
2fbf38ac	284	histname = "fHistAntiBaryonEt" + fHistogramNameSuffix;
13b0d3c1	285	fHistAntiBaryonEt = new TH1F(histname.Data(), "E_{T} for anti baryons", nbinsEt, minEt, maxEt);
2fbf38ac	286
2fbf38ac	287	histname = "fHistMesonEt" + fHistogramNameSuffix;
13b0d3c1	288	fHistMesonEt = new TH1F(histname.Data(), "E_{T} for mesons", nbinsEt, minEt, maxEt);
2fbf38ac	289
87efb15c	290	histname = "fHistProtonEt" + fHistogramNameSuffix;
	291	fHistProtonEt = new TH1F(histname.Data(), "E_{T} for (anti-)protons", nbinsEt, minEt, maxEt);
	292
43056f1b	293	histname = "fHistPionEt" + fHistogramNameSuffix;
	294	fHistPionEt = new TH1F(histname.Data(), "E_{T} for #pi^+/#pi^-", nbinsEt, minEt, maxEt);
	295
87efb15c	296	histname = "fHistKaonEt" + fHistogramNameSuffix;
	297	fHistChargedKaonEt = new TH1F(histname.Data(), "E_{T} for charged kaons", nbinsEt, minEt, maxEt);
	298
	299	histname = "fHistMuonEt" + fHistogramNameSuffix;
	300	fHistMuonEt = new TH1F(histname.Data(), "E_{T} for muons", nbinsEt, minEt, maxEt);
	301
	302	histname = "fHistElectronEt" + fHistogramNameSuffix;
	303	fHistElectronEt = new TH1F(histname.Data(), "E_{T} for electrons/positrons", nbinsEt, minEt, maxEt);
	304
43056f1b	305	histname = "fHistNeutronEt" + fHistogramNameSuffix;
	306	fHistNeutronEt = new TH1F(histname.Data(), "E_{T} for neutrons", nbinsEt, minEt, maxEt);
	307
	308	histname = "fHistAntiNeutronEt" + fHistogramNameSuffix;
	309	fHistAntiNeutronEt = new TH1F(histname.Data(), "E_{T} for anti-neutrons", nbinsEt, minEt, maxEt);
	310
	311	histname = "fHistGammaEt" + fHistogramNameSuffix;
	312	fHistGammaEt = new TH1F(histname.Data(), "E_{T} for gammas", nbinsEt, minEt, maxEt);
	313
87efb15c	314	histname = "fHistProtonEtAcc" + fHistogramNameSuffix;
	315	fHistProtonEtAcc = new TH1F(histname.Data(), "E_{T} for (anti-)protons in calorimeter acceptance", nbinsEt, minEt, maxEt);
	316
43056f1b	317	histname = "fHistPionEtAcc" + fHistogramNameSuffix;
	318	fHistPionEtAcc = new TH1F(histname.Data(), "E_{T} for #pi^+/#pi^- in calorimeter acceptance", nbinsEt, minEt, maxEt);
	319
87efb15c	320	histname = "fHistKaonEtAcc" + fHistogramNameSuffix;
	321	fHistChargedKaonEtAcc = new TH1F(histname.Data(), "E_{T} for charged kaons in calorimeter acceptance", nbinsEt, minEt, maxEt);
	322
	323	histname = "fHistMuonEtAcc" + fHistogramNameSuffix;
	324	fHistMuonEtAcc = new TH1F(histname.Data(), "E_{T} for muons in calorimeter acceptance", nbinsEt, minEt, maxEt);
	325
	326	histname = "fHistElectronEtAcc" + fHistogramNameSuffix;
	327	fHistElectronEtAcc = new TH1F(histname.Data(), "E_{T} for electrons/positrons in calorimeter acceptance", nbinsEt, minEt, maxEt);
	328
cf6522d1	329	//
2fbf38ac	330	histname = "fHistTMDeltaR" + fHistogramNameSuffix;
	331	fHistTMDeltaR = new TH1F(histname.Data(), "#Delta R for calorimeter clusters", 200, 0, 50);
	332
	333	}
	334
8ea99ab0	335	void AliAnalysisEt::CreateTrees()
ce546038	336	{ // create tree..
ce546038	337	TString treename = "fTree" + fHistogramNameSuffix;
8ea99ab0	338	if(fCuts->GetHistMakeTree())
	339	{
	340
	341	fTree = new TTree(treename, treename);
	342	fTree->Branch("fTotEt",&fTotEt,"fTotEt/D");
	343	fTree->Branch("fTotEtAcc",&fTotEtAcc,"fTotEtAcc/D");
	344	fTree->Branch("fTotNeutralEt",&fTotNeutralEt,"fTotNeutralEt/D");
	345	fTree->Branch("fTotNeutralEtAcc",&fTotNeutralEtAcc,"fTotNeutralEtAcc/D");
	346	fTree->Branch("fTotChargedEt",&fTotChargedEt,"fTotChargedEt/D");
	347	fTree->Branch("fTotChargedEtAcc",&fTotChargedEtAcc,"fTotChargedEtAcc/D");
	348	fTree->Branch("fMultiplicity",&fMultiplicity,"fMultiplicity/I");
	349	fTree->Branch("fChargedMultiplicity",&fChargedMultiplicity,"fChargedMultiplicity/I");
	350	fTree->Branch("fNeutralMultiplicity",&fNeutralMultiplicity,"fNeutralMultiplicity/I");
	351	fTree->Branch("fBaryonEt",&fBaryonEt,"fBaryonEt/D");
	352	fTree->Branch("fAntiBaryonEt",&fAntiBaryonEt,"fAntiBaryonEt/D");
	353	fTree->Branch("fMesonEt",&fMesonEt,"fMesonEt/D");
8ea99ab0	354	fTree->Branch("fProtonEt",&fProtonEt,"fProtonEt/D");
	355	fTree->Branch("fChargedKaonEt",&fChargedKaonEt,"fChargedKaonEt/D");
	356	fTree->Branch("fMuonEt",&fMuonEt,"fMuonEt/D");
	357	fTree->Branch("fElectronEt",&fElectronEt,"fElectronEt/D");
	358	fTree->Branch("fProtonEtAcc",&fProtonEtAcc,"fProtonEtAcc/D");
	359	fTree->Branch("fChargedKaonEtAcc",&fChargedKaonEtAcc,"fChargedKaonEtAcc/D");
	360	fTree->Branch("fMuonEtAcc",&fMuonEtAcc,"fMuonEtAcc/D");
	361	fTree->Branch("fElectronEtAcc",&fElectronEtAcc,"fElectronEtAcc/D");
	362	}
	363
	364	if(fCuts->GetHistMakeTreeDeposit())
	365	{
	366	treename = "fTreeDeposit" + fHistogramNameSuffix;
	367	fTreeDeposit = new TTree(treename, treename);
	368
	369	fTreeDeposit->Branch("fEnergyDeposited", &fEnergyDeposited, "fEnergyDeposited/F");
	370	fTreeDeposit->Branch("fEnergyTPC", &fEnergyTPC, "fEnergyTPC/F");
	371	fTreeDeposit->Branch("fCharge", &fCharge, "fCharge/S");
	372	fTreeDeposit->Branch("fParticlePid", &fParticlePid, "fParticlePid/S");
	373	fTreeDeposit->Branch("fPidProb", &fPidProb, "fPidProb/F");
	374	fTreeDeposit->Branch("fTrackPassedCut", &fTrackPassedCut, "fTrackPassedCut/B");
	375
	376	}
7b873813	377
ce546038	378	return;
ce546038	379	}
2fbf38ac	380	void AliAnalysisEt::FillHistograms()
cf6522d1	381	{ // fill histograms..
2fbf38ac	382	fHistEt->Fill(fTotEt);
	383	fHistChargedEt->Fill(fTotChargedEt);
	384	fHistNeutralEt->Fill(fTotNeutralEt);
	385
	386	fHistEtAcc->Fill(fTotEtAcc);
	387	fHistChargedEtAcc->Fill(fTotChargedEtAcc);
	388	fHistNeutralEtAcc->Fill(fTotNeutralEtAcc);
	389
	390	fHistMult->Fill(fMultiplicity);
	391	fHistChargedMult->Fill(fChargedMultiplicity);
	392	fHistNeutralMult->Fill(fNeutralMultiplicity);
	393
ce546038	394	fHistBaryonEt->Fill(fBaryonEt);
	395	fHistAntiBaryonEt->Fill(fAntiBaryonEt);
	396	fHistMesonEt->Fill(fMesonEt);
2fbf38ac	397
87efb15c	398	fHistProtonEt->Fill(fProtonEt);
43056f1b	399	fHistPionEt->Fill(fPionEt);
87efb15c	400	fHistChargedKaonEt->Fill(fChargedKaonEt);
	401	fHistMuonEt->Fill(fMuonEt);
	402	fHistElectronEt->Fill(fElectronEt);
43056f1b	403	fHistNeutronEt->Fill(fNeutronEt);
	404	fHistAntiNeutronEt->Fill(fAntiNeutronEt);
	405	fHistGammaEt->Fill(fGammaEt);
87efb15c	406
87efb15c	407	fHistProtonEtAcc->Fill(fProtonEtAcc);
43056f1b	408	fHistPionEtAcc->Fill(fPionEtAcc);
87efb15c	409	fHistChargedKaonEtAcc->Fill(fChargedKaonEtAcc);
	410	fHistMuonEtAcc->Fill(fMuonEtAcc);
	411	fHistElectronEtAcc->Fill(fElectronEtAcc);
ce546038	412
	413	if (fCuts) {
	414	if (fCuts->GetHistMakeTree()) {
	415	fTree->Fill();
	416	}
	417	}
	418
2fbf38ac	419	}
0065531a	420
641e1e0c	421	Int_t AliAnalysisEt::AnalyseEvent(AliVEvent *event)
0065531a	422	{ //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.
	423	cout << "This event has " << event->GetNumberOfTracks() << " tracks" << endl;
	424	ResetEventValues();
641e1e0c	425	return 0;
641e1e0c	426	}
2fbf38ac	427
2fbf38ac	428	void AliAnalysisEt::ResetEventValues()
cf6522d1	429	{ // clear
0065531a	430	fTotEt = 0;
	431	fTotEtAcc = 0;
	432	fTotNeutralEt = 0;
	433	fTotNeutralEtAcc = 0;
	434	fTotChargedEt = 0;
	435	fTotChargedEtAcc = 0;
	436	fMultiplicity = 0;
	437	fChargedMultiplicity = 0;
	438	fNeutralMultiplicity = 0;
87efb15c	439	fBaryonEt = 0;
	440	fAntiBaryonEt = 0;
	441	fMesonEt = 0;
87efb15c	442	fProtonEt = 0;
7b873813	443	fPionEt = 0;
87efb15c	444	fChargedKaonEt = 0;
	445	fMuonEt = 0;
	446	fElectronEt = 0;
7b873813	447	fNeutronEt = 0;
	448	fAntiNeutronEt = 0;
	449	fGammaEt = 0;
87efb15c	450	fProtonEtAcc = 0;
7b873813	451	fPionEtAcc = 0;
87efb15c	452	fChargedKaonEtAcc = 0;
87efb15c	453	fMuonEtAcc = 0;
ce546038	454	fElectronEtAcc = 0;
43056f1b	455
0065531a	456	if (!fCuts \|\| !fPdgDB \|\| fPiPlusCode==0) { // some Init's needed
	457	cout << __FILE__ << ":" << __LINE__ << " : Init " << endl;
	458	if (!fCuts) {
	459	cout << " setting up Cuts " << endl;
	460	fCuts = new AliAnalysisEtCuts();
	461	}
	462	if(!fPdgDB) {
	463	cout << " setting up PdgDB " << endl;
	464	fPdgDB = new TDatabasePDG();
	465	}
0065531a	466	if (fPiPlusCode==0) {
99a6613d	467	SetParticleCodes();
99a6613d	468	}
0065531a	469	}
0065531a	470	return;
2fbf38ac	471	}
99a6613d	472
0065531a	473
99a6613d	474	void AliAnalysisEt::SetParticleCodes()
cf6522d1	475	{ // set PDG info
8985c506	476	fPionMass = fPdgDB->GetParticle("pi+")->Mass();
	477	fPiPlusCode = fPdgDB->GetParticle("pi+")->PdgCode();
	478	fPiMinusCode = fPdgDB->GetParticle("pi-")->PdgCode();
	479	fKPlusCode = fPdgDB->GetParticle("K+")->PdgCode();
	480	fKMinusCode = fPdgDB->GetParticle("K-")->PdgCode();
	481	fProtonCode = fPdgDB->GetParticle("proton")->PdgCode();
	482	fAntiProtonCode = fPdgDB->GetParticle("antiproton")->PdgCode();
	483	fLambdaCode = fPdgDB->GetParticle("Lambda0")->PdgCode();
	484	fAntiLambdaCode = fPdgDB->GetParticle("Lambda0_bar")->PdgCode();
	485	fK0SCode = fPdgDB->GetParticle("K_S0")->PdgCode();
	486	fOmegaCode = fPdgDB->GetParticle("Omega-")->PdgCode();
	487	fAntiOmegaCode = fPdgDB->GetParticle("Omega+")->PdgCode();
	488	fXi0Code = fPdgDB->GetParticle("Xi0")->PdgCode();
	489	fAntiXi0Code = fPdgDB->GetParticle("Xi0_bar")->PdgCode();
	490	fXiCode = fPdgDB->GetParticle("Xi-")->PdgCode();
	491	fAntiXiCode = fPdgDB->GetParticle("Xi-_bar")->PdgCode();
	492	fSigmaCode = fPdgDB->GetParticle("Sigma-")->PdgCode();
	493	fAntiSigmaCode = fPdgDB->GetParticle("Sigma+")->PdgCode();
	494	fK0LCode = fPdgDB->GetParticle("K_L0")->PdgCode();
	495	fNeutronCode = fPdgDB->GetParticle("neutron")->PdgCode();
	496	fAntiNeutronCode = fPdgDB->GetParticle("antineutron")->PdgCode();
	497	fEPlusCode = fPdgDB->GetParticle("e+")->PdgCode();
	498	fEMinusCode = fPdgDB->GetParticle("e-")->PdgCode();
7b873813	499	fMuPlusCode = fPdgDB->GetParticle("mu+")->PdgCode();
7b873813	500	fMuMinusCode = fPdgDB->GetParticle("mu-")->PdgCode();
43056f1b	501	fGammaCode = fPdgDB->GetParticle("gamma")->PdgCode();
43056f1b	502
8985c506	503	cout << "Resetting Codes: Pion " << fPiPlusCode
	504	<< "," << fPiMinusCode
	505	<< " Kaon " << fKPlusCode
	506	<< "," << fKMinusCode << endl;
99a6613d	507	}
99a6613d	508