From: miweber Date: Mon, 30 Apr 2012 12:43:18 +0000 (+0000) Subject: Triggered Balance Function analysis (multidimensions) X-Git-Url: http://git.uio.no/git/?p=u%2Fmrichter%2FAliRoot.git;a=commitdiff_plain;h=f8b2d882c0d8423e1741639b0fda2e6ff30203da Triggered Balance Function analysis (multidimensions) --- diff --git a/PWGCF/EBYE/BalanceFunctions/AliAnalysisTaskTriggeredBF.cxx b/PWGCF/EBYE/BalanceFunctions/AliAnalysisTaskTriggeredBF.cxx new file mode 100755 index 00000000000..e781e7c354c --- /dev/null +++ b/PWGCF/EBYE/BalanceFunctions/AliAnalysisTaskTriggeredBF.cxx @@ -0,0 +1,460 @@ +#include "TChain.h" +#include "TList.h" +#include "TCanvas.h" +#include "TLorentzVector.h" +#include "TGraphErrors.h" +#include "TH1F.h" +#include "TH2F.h" +#include "TArrayF.h" +#include "TF1.h" +#include "TRandom.h" + +#include "AliLog.h" + +#include "AliAnalysisTaskSE.h" +#include "AliAnalysisManager.h" + +#include "AliESDVertex.h" +#include "AliESDEvent.h" +#include "AliESDInputHandler.h" +#include "AliAODEvent.h" +#include "AliAODTrack.h" +#include "AliAODInputHandler.h" +#include "AliGenEventHeader.h" +#include "AliGenHijingEventHeader.h" +#include "AliMCEventHandler.h" +#include "AliMCEvent.h" +#include "AliMixInputEventHandler.h" +#include "AliStack.h" + +#include "TH2D.h" +#include "AliTHn.h" + +#include "AliAnalysisTaskTriggeredBF.h" +#include "AliBalanceTriggered.h" + + +// Analysis task for the TriggeredBF code +// Authors: Panos.Christakoglou@nikhef.nl, m.weber@cern.ch + +ClassImp(AliAnalysisTaskTriggeredBF) + +//________________________________________________________________________ +AliAnalysisTaskTriggeredBF::AliAnalysisTaskTriggeredBF(const char *name) +: AliAnalysisTaskSE(name), + fBalance(0), + fRunShuffling(kFALSE), + fShuffledBalance(0), + fList(0), + fListTriggeredBF(0), + fListTriggeredBFS(0), + fHistListPIDQA(0), + fHistEventStats(0), + fHistCentStats(0), + fHistTriggerStats(0), + fHistTrackStats(0), + fHistVx(0), + fHistVy(0), + fHistVz(0), + fHistClus(0), + fHistDCA(0), + fHistChi2(0), + fHistPt(0), + fHistEta(0), + fHistPhi(0), + fHistPhiBefore(0), + fHistPhiAfter(0), + fHistV0M(0), + fHistRefTracks(0), + fCentralityEstimator("V0M"), + fUseCentrality(kFALSE), + fCentralityPercentileMin(0.), + fCentralityPercentileMax(5.), + fImpactParameterMin(0.), + fImpactParameterMax(20.), + fUseMultiplicity(kFALSE), + fNumberOfAcceptedTracksMin(0), + fNumberOfAcceptedTracksMax(10000), + fHistNumberOfAcceptedTracks(0), + fUseOfflineTrigger(kFALSE), + fVxMax(0.3), + fVyMax(0.3), + fVzMax(10.), + nAODtrackCutBit(128), + fPtMin(0.3), + fPtMax(1.5), + fEtaMin(-0.8), + fEtaMax(-0.8), + fDCAxyCut(-1), + fDCAzCut(-1), + fTPCchi2Cut(-1), + fNClustersTPCCut(-1) +{ + // Constructor + // Define input and output slots here + // Input slot #0 works with a TChain + DefineInput(0, TChain::Class()); + // Output slot #0 writes into a TH1 container + DefineOutput(1, TList::Class()); + DefineOutput(2, TList::Class()); + DefineOutput(3, TList::Class()); +} + +//________________________________________________________________________ +AliAnalysisTaskTriggeredBF::~AliAnalysisTaskTriggeredBF() { + + // Destructor + +} + +//________________________________________________________________________ +void AliAnalysisTaskTriggeredBF::UserCreateOutputObjects() { + // Create histograms + // Called once + if(!fBalance) { + fBalance = new AliBalanceTriggered(); + fBalance->SetAnalysisLevel("AOD"); + } + if(fRunShuffling) { + if(!fShuffledBalance) { + fShuffledBalance = new AliBalanceTriggered(); + fShuffledBalance->SetAnalysisLevel("AOD"); + } + } + + //QA list + fList = new TList(); + fList->SetName("listQA"); + fList->SetOwner(); + + //Balance Function list + fListTriggeredBF = new TList(); + fListTriggeredBF->SetName("listTriggeredBF"); + fListTriggeredBF->SetOwner(); + + if(fRunShuffling) { + fListTriggeredBFS = new TList(); + fListTriggeredBFS->SetName("listTriggeredBFShuffled"); + fListTriggeredBFS->SetOwner(); + } + + + //Event stats. + TString gCutName[4] = {"Total","Offline trigger", + "Vertex","Analyzed"}; + fHistEventStats = new TH1F("fHistEventStats", + "Event statistics;;N_{events}", + 4,0.5,4.5); + for(Int_t i = 1; i <= 4; i++) + fHistEventStats->GetXaxis()->SetBinLabel(i,gCutName[i-1].Data()); + fList->Add(fHistEventStats); + + TString gCentName[9] = {"V0M","FMD","TRK","TKL","CL0","CL1","V0MvsFMD","TKLvsV0M","ZEMvsZDC"}; + fHistCentStats = new TH2F("fHistCentStats", + "Centrality statistics;;Cent percentile", + 9,-0.5,8.5,220,-5,105); + for(Int_t i = 1; i <= 9; i++) + fHistCentStats->GetXaxis()->SetBinLabel(i,gCentName[i-1].Data()); + fList->Add(fHistCentStats); + + fHistTriggerStats = new TH1F("fHistTriggerStats","Trigger statistics;TriggerBit;N_{events}",130,0,130); + fList->Add(fHistTriggerStats); + + fHistTrackStats = new TH1F("fHistTrackStats","Event statistics;TrackFilterBit;N_{events}",130,0,130); + fList->Add(fHistTrackStats); + + fHistNumberOfAcceptedTracks = new TH1F("fHistNumberOfAcceptedTracks",";N_{acc.};Entries",4001,-0.5,4000.5); + fList->Add(fHistNumberOfAcceptedTracks); + + // Vertex distributions + fHistVx = new TH1F("fHistVx","Primary vertex distribution - x coordinate;V_{x} (cm);Entries",100,-0.5,0.5); + fList->Add(fHistVx); + fHistVy = new TH1F("fHistVy","Primary vertex distribution - y coordinate;V_{y} (cm);Entries",100,-0.5,0.5); + fList->Add(fHistVy); + fHistVz = new TH1F("fHistVz","Primary vertex distribution - z coordinate;V_{z} (cm);Entries",100,-20.,20.); + fList->Add(fHistVz); + + // QA histograms + fHistClus = new TH2F("fHistClus","# Cluster (TPC vs. ITS)",10,0,10,200,0,200); + fList->Add(fHistClus); + fHistChi2 = new TH1F("fHistChi2","Chi2/NDF distribution",200,0,10); + fList->Add(fHistChi2); + fHistDCA = new TH2F("fHistDCA","DCA (xy vs. z)",400,-5,5,400,-5,5); + fList->Add(fHistDCA); + fHistPt = new TH1F("fHistPt","p_{T} distribution",200,0,10); + fList->Add(fHistPt); + fHistEta = new TH1F("fHistEta","#eta distribution",200,-2,2); + fList->Add(fHistEta); + fHistPhi = new TH1F("fHistPhi","#phi distribution",200,-20,380); + fList->Add(fHistPhi); + fHistPhiBefore = new TH1F("fHistPhiBefore","#phi distribution",200,0.,2*TMath::Pi()); + fList->Add(fHistPhiBefore); + fHistPhiAfter = new TH1F("fHistPhiAfter","#phi distribution",200,0.,2*TMath::Pi()); + fList->Add(fHistPhiAfter); + fHistV0M = new TH2F("fHistV0M","V0 Multiplicity C vs. A",500, 0, 20000, 500, 0, 20000); + fList->Add(fHistV0M); + TString gRefTrackName[6] = {"tracks","tracksPos","tracksNeg","tracksTPConly","clusITS0","clusITS1"}; + fHistRefTracks = new TH2F("fHistRefTracks","Nr of Ref tracks/event vs. ref track estimator;;Nr of tracks",6, 0, 6, 400, 0, 20000); + for(Int_t i = 1; i <= 6; i++) + fHistRefTracks->GetXaxis()->SetBinLabel(i,gRefTrackName[i-1].Data()); + fList->Add(fHistRefTracks); + + + + // Balance function histograms + // Initialize histograms if not done yet + if(!fBalance->GetHistNp()){ + AliWarning("Histograms not yet initialized! --> Will be done now"); + AliWarning("--> Add 'gBalance->InitHistograms()' in your configBalanceFunction"); + fBalance->InitHistograms(); + } + + if(fRunShuffling) { + if(!fShuffledBalance->GetHistNp()) { + AliWarning("Histograms (shuffling) not yet initialized! --> Will be done now"); + AliWarning("--> Add 'gBalance->InitHistograms()' in your configBalanceFunction"); + fShuffledBalance->InitHistograms(); + } + } + + fListTriggeredBF->Add(fBalance->GetHistNp()); + fListTriggeredBF->Add(fBalance->GetHistNn()); + fListTriggeredBF->Add(fBalance->GetHistNpn()); + fListTriggeredBF->Add(fBalance->GetHistNnn()); + fListTriggeredBF->Add(fBalance->GetHistNpp()); + fListTriggeredBF->Add(fBalance->GetHistNnp()); + + if(fRunShuffling) { + fListTriggeredBFS->Add(fShuffledBalance->GetHistNp()); + fListTriggeredBFS->Add(fShuffledBalance->GetHistNn()); + fListTriggeredBFS->Add(fShuffledBalance->GetHistNpn()); + fListTriggeredBFS->Add(fShuffledBalance->GetHistNnn()); + fListTriggeredBFS->Add(fShuffledBalance->GetHistNpp()); + fListTriggeredBFS->Add(fShuffledBalance->GetHistNnp()); + } + + + + + // Post output data. + PostData(1, fList); + PostData(2, fListTriggeredBF); + if(fRunShuffling) PostData(3, fListTriggeredBFS); +} + +//________________________________________________________________________ +void AliAnalysisTaskTriggeredBF::UserExec(Option_t *) { + // Main loop + // Called for each event + + TString gAnalysisLevel = fBalance->GetAnalysisLevel(); + + Float_t fCentrality = 0.; + + // vector holding the charges/kinematics of all tracks (charge,y,eta,phi,p0,p1,p2,pt,E) + vector *chargeVector[9]; // original charge + for(Int_t i = 0; i < 9; i++){ + chargeVector[i] = new vector; + } + + Double_t v_charge; + Double_t v_y; + Double_t v_eta; + Double_t v_phi; + Double_t v_p[3]; + Double_t v_pt; + Double_t v_E; + + // ------------------------------------------------------------- + // AOD analysis (vertex and track cuts also here!!!!) + if(gAnalysisLevel == "AOD") { + AliAODEvent* aodEventMain = dynamic_cast(InputEvent()); + if(!aodEventMain) { + AliError("aodEventMain not available"); + return; + } + + + AliAODHeader *aodHeaderMain = aodEventMain->GetHeader(); + + // event selection done in AliAnalysisTaskSE::Exec() --> this is not used + fHistEventStats->Fill(1); //all events + + Bool_t isSelectedMain = kTRUE; + + if(fUseOfflineTrigger) + isSelectedMain = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected(); + + if(isSelectedMain) { + fHistEventStats->Fill(2); //triggered events + + //Centrality stuff (centrality in AOD header) + if(fUseCentrality) { + fCentrality = aodHeaderMain->GetCentralityP()->GetCentralityPercentile(fCentralityEstimator.Data()); + + // QA for centrality estimators + fHistCentStats->Fill(0.,aodHeaderMain->GetCentralityP()->GetCentralityPercentile("V0M")); + fHistCentStats->Fill(1.,aodHeaderMain->GetCentralityP()->GetCentralityPercentile("FMD")); + fHistCentStats->Fill(2.,aodHeaderMain->GetCentralityP()->GetCentralityPercentile("TRK")); + fHistCentStats->Fill(3.,aodHeaderMain->GetCentralityP()->GetCentralityPercentile("TKL")); + fHistCentStats->Fill(4.,aodHeaderMain->GetCentralityP()->GetCentralityPercentile("CL0")); + fHistCentStats->Fill(5.,aodHeaderMain->GetCentralityP()->GetCentralityPercentile("CL1")); + fHistCentStats->Fill(6.,aodHeaderMain->GetCentralityP()->GetCentralityPercentile("V0MvsFMD")); + fHistCentStats->Fill(7.,aodHeaderMain->GetCentralityP()->GetCentralityPercentile("TKLvsV0M")); + fHistCentStats->Fill(8.,aodHeaderMain->GetCentralityP()->GetCentralityPercentile("ZEMvsZDC")); + + // take only events inside centrality class + if((fCentrality < fCentralityPercentileMin) || (fCentrality > fCentralityPercentileMax)) + return; + + // centrality QA (V0M) + fHistV0M->Fill(aodEventMain->GetVZEROData()->GetMTotV0A(), aodEventMain->GetVZEROData()->GetMTotV0C()); + + // centrality QA (reference tracks) + fHistRefTracks->Fill(0.,aodHeaderMain->GetRefMultiplicity()); + fHistRefTracks->Fill(1.,aodHeaderMain->GetRefMultiplicityPos()); + fHistRefTracks->Fill(2.,aodHeaderMain->GetRefMultiplicityNeg()); + fHistRefTracks->Fill(3.,aodHeaderMain->GetTPConlyRefMultiplicity()); + fHistRefTracks->Fill(4.,aodHeaderMain->GetNumberOfITSClusters(0)); + fHistRefTracks->Fill(5.,aodHeaderMain->GetNumberOfITSClusters(1)); + fHistRefTracks->Fill(6.,aodHeaderMain->GetNumberOfITSClusters(2)); + fHistRefTracks->Fill(7.,aodHeaderMain->GetNumberOfITSClusters(3)); + fHistRefTracks->Fill(8.,aodHeaderMain->GetNumberOfITSClusters(4)); + } + + const AliAODVertex *vertexMain = aodEventMain->GetPrimaryVertex(); + + if(vertexMain) { + Double32_t fCovMain[6]; + vertexMain->GetCovarianceMatrix(fCovMain); + + if(vertexMain->GetNContributors() > 0) { + if(fCovMain[5] != 0) { + fHistEventStats->Fill(3); //events with a proper vertex + if(TMath::Abs(vertexMain->GetX()) < fVxMax) { + if(TMath::Abs(vertexMain->GetY()) < fVyMax) { + if(TMath::Abs(vertexMain->GetZ()) < fVzMax) { + fHistEventStats->Fill(4); //analyzed events + fHistVx->Fill(vertexMain->GetX()); + fHistVy->Fill(vertexMain->GetY()); + fHistVz->Fill(vertexMain->GetZ()); + + // Loop over tracks in main event + for (Int_t iTracksMain = 0; iTracksMain < aodEventMain->GetNumberOfTracks(); iTracksMain++) { + AliAODTrack* aodTrackMain = dynamic_cast(aodEventMain->GetTrack(iTracksMain)); + if (!aodTrackMain) { + AliError(Form("Could not receive track %d", iTracksMain)); + continue; + } + + // AOD track cuts + + // For ESD Filter Information: ANALYSIS/macros/AddTaskESDfilter.C + // take only TPC only tracks + fHistTrackStats->Fill(aodTrackMain->GetFilterMap()); + if(!aodTrackMain->TestFilterBit(nAODtrackCutBit)) continue; + + v_charge = aodTrackMain->Charge(); + v_y = aodTrackMain->Y(); + v_eta = aodTrackMain->Eta(); + v_phi = aodTrackMain->Phi() * TMath::RadToDeg(); + v_E = aodTrackMain->E(); + v_pt = aodTrackMain->Pt(); + aodTrackMain->PxPyPz(v_p); + + Float_t DCAxy = aodTrackMain->DCA(); // this is the DCA from global track (not exactly what is cut on) + Float_t DCAz = aodTrackMain->ZAtDCA(); // this is the DCA from global track (not exactly what is cut on) + + + // Kinematics cuts from ESD track cuts + if( v_pt < fPtMin || v_pt > fPtMax) continue; + if( v_eta < fEtaMin || v_eta > fEtaMax) continue; + + // Extra DCA cuts (for systematic studies [!= -1]) + if( fDCAxyCut != -1 && fDCAzCut != -1){ + if(TMath::Sqrt((DCAxy*DCAxy)/(fDCAxyCut*fDCAxyCut)+(DCAz*DCAz)/(fDCAzCut*fDCAzCut)) > 1 ){ + continue; // 2D cut + } + } + + // Extra TPC cuts (for systematic studies [!= -1]) + if( fTPCchi2Cut != -1 && aodTrackMain->Chi2perNDF() > fTPCchi2Cut){ + continue; + } + if( fNClustersTPCCut != -1 && aodTrackMain->GetTPCNcls() < fNClustersTPCCut){ + continue; + } + + // fill QA histograms + fHistClus->Fill(aodTrackMain->GetITSNcls(),aodTrackMain->GetTPCNcls()); + fHistDCA->Fill(DCAz,DCAxy); + fHistChi2->Fill(aodTrackMain->Chi2perNDF()); + fHistPt->Fill(v_pt); + fHistEta->Fill(v_eta); + fHistPhi->Fill(v_phi); + + // fill charge vector + chargeVector[0]->push_back(v_charge); + chargeVector[1]->push_back(v_y); + chargeVector[2]->push_back(v_eta); + chargeVector[3]->push_back(v_phi); + chargeVector[4]->push_back(v_p[0]); + chargeVector[5]->push_back(v_p[1]); + chargeVector[6]->push_back(v_p[2]); + chargeVector[7]->push_back(v_pt); + chargeVector[8]->push_back(v_E); + + } //track loop + + // calculate balance function + fBalance->FillBalance(fCentrality,chargeVector); + // clean charge vector afterwards + for(Int_t i = 0; i < 9; i++){ + chargeVector[i]->clear(); + } + + }//Vz cut + }//Vy cut + }//Vx cut + }//proper vertex resolution + }//proper number of contributors + }//vertex object valid + }//triggered event + }//AOD analysis + else{ + AliError("Triggered Balance Function analysis only for AODs!"); + } +} + +//________________________________________________________________________ +void AliAnalysisTaskTriggeredBF::FinishTaskOutput(){ + + if (!fBalance) { + AliError("fBalance not available"); + return; + } + if(fRunShuffling) { + if (!fShuffledBalance) { + AliError("fShuffledBalance not available"); + return; + } + } + +} + +//________________________________________________________________________ +void AliAnalysisTaskTriggeredBF::Terminate(Option_t *) { + // Called once at the end of the query + + // not implemented ... + +} + +void AliAnalysisTaskTriggeredBF::UserExecMix(Option_t *) +{ + + // not yet done for event mixing! + return; + +} + diff --git a/PWGCF/EBYE/BalanceFunctions/AliAnalysisTaskTriggeredBF.h b/PWGCF/EBYE/BalanceFunctions/AliAnalysisTaskTriggeredBF.h new file mode 100755 index 00000000000..3da0a2b4a46 --- /dev/null +++ b/PWGCF/EBYE/BalanceFunctions/AliAnalysisTaskTriggeredBF.h @@ -0,0 +1,159 @@ +#ifndef ALIANALYSISTASKTRIGGEREDBF_CXX +#define ALIANALYSISTASKTRIGGEREDBF_CXX + +// Analysis task for the TriggeredBF code +// Authors: Panos Cristakoglou@cern.ch, m.weber@cern.ch + +class TList; +class TH1F; +class TH2F; +class TF1; + +class AliBalanceTriggered; +class AliESDtrackCuts; + +#include "AliAnalysisTaskSE.h" +#include "AliBalanceTriggered.h" + + + +class AliAnalysisTaskTriggeredBF : public AliAnalysisTaskSE { + public: + AliAnalysisTaskTriggeredBF(const char *name = "AliAnalysisTaskTriggeredBF"); + virtual ~AliAnalysisTaskTriggeredBF(); + + + virtual void UserCreateOutputObjects(); + virtual void UserExec(Option_t *option); + virtual void UserExecMix(Option_t*); + virtual void FinishTaskOutput(); + virtual void Terminate(Option_t *); + + void SetAnalysisObject(AliBalanceTriggered *const analysis) { + fBalance = analysis; + } + void SetShufflingObject(AliBalanceTriggered *const analysisShuffled) { + fRunShuffling = kTRUE; + fShuffledBalance = analysisShuffled; + } + + void SetVertexDiamond(Double_t vx, Double_t vy, Double_t vz) { + fVxMax = vx; + fVyMax = vy; + fVzMax = vz; + } + + //==============AOD analysis==============// + void SetAODtrackCutBit(Int_t bit){ + nAODtrackCutBit = bit; + } + + void SetKinematicsCutsAOD(Double_t ptmin, Double_t ptmax, Double_t etamin, Double_t etamax){ + fPtMin = ptmin; + fPtMax = ptmax; + fEtaMin = etamin; + fEtaMax = etamax; + + } + + void SetExtraDCACutsAOD(Double_t DCAxy, Double_t DCAz){ + fDCAxyCut = DCAxy; + fDCAzCut = DCAz; + } + + void SetExtraTPCCutsAOD(Double_t maxTPCchi2, Int_t minNClustersTPC){ + fTPCchi2Cut = maxTPCchi2; + fNClustersTPCCut = minNClustersTPC; + } + + //Centrality + void SetCentralityEstimator(const char* centralityEstimator) {fCentralityEstimator = centralityEstimator;} + const char* GetCentralityEstimator(void) {return fCentralityEstimator;} + void SetCentralityPercentileRange(Double_t min, Double_t max) { + fUseCentrality = kTRUE; + fCentralityPercentileMin=min; + fCentralityPercentileMax=max; + } + void SetImpactParameterRange(Double_t min, Double_t max) { + fUseCentrality = kTRUE; + fImpactParameterMin=min; + fImpactParameterMax=max; + } + + //multiplicity + void SetMultiplicityRange(Int_t min, Int_t max) { + fUseMultiplicity = kTRUE; + fNumberOfAcceptedTracksMin = min; + fNumberOfAcceptedTracksMax = max;} + + void UseOfflineTrigger() {fUseOfflineTrigger = kTRUE;} + + + private: + AliBalanceTriggered *fBalance; //TriggeredBF object + Bool_t fRunShuffling;//run shuffling or not + AliBalanceTriggered *fShuffledBalance; //TriggeredBF object (shuffled) + TList *fList; //fList object + TList *fListTriggeredBF; //fList object + TList *fListTriggeredBFS; //fList object + TList *fHistListPIDQA; //! list of histograms + + TH1F *fHistEventStats; //event stats + TH2F *fHistCentStats; //centrality stats + TH1F *fHistTriggerStats; //trigger stats + TH1F *fHistTrackStats; //Track filter bit stats + TH1F *fHistVx; //x coordinate of the primary vertex + TH1F *fHistVy; //y coordinate of the primary vertex + TH1F *fHistVz; //z coordinate of the primary vertex + + TH2F *fHistClus;// + TH2F *fHistDCA;// + TH1F *fHistChi2;// + TH1F *fHistPt;// + TH1F *fHistEta;// + TH1F *fHistPhi;// + TH1F *fHistPhiBefore;// + TH1F *fHistPhiAfter;// + TH2F *fHistV0M;// + TH2F *fHistRefTracks;// + + + TString fCentralityEstimator; //"V0M","TRK","TKL","ZDC","FMD" + Bool_t fUseCentrality;//use the centrality (PbPb) or not (pp) + Double_t fCentralityPercentileMin;//centrality percentile min + Double_t fCentralityPercentileMax;//centrality percentile max + Double_t fImpactParameterMin;//impact parameter min (used for MC) + Double_t fImpactParameterMax;//impact parameter max (used for MC) + + Bool_t fUseMultiplicity;//use the multiplicity cuts + Int_t fNumberOfAcceptedTracksMin;//min. number of number of accepted tracks (used for the multiplicity dependence study - pp) + Int_t fNumberOfAcceptedTracksMax;//max. number of number of accepted tracks (used for the multiplicity dependence study - pp) + TH1F *fHistNumberOfAcceptedTracks;//hisot to store the number of accepted tracks + + Bool_t fUseOfflineTrigger;//Usage of the offline trigger selection + + Double_t fVxMax;//vxmax + Double_t fVyMax;//vymax + Double_t fVzMax;//vzmax + + Int_t nAODtrackCutBit;//track cut bit from track selection (only used for AODs) + + Double_t fPtMin;//only used for AODs + Double_t fPtMax;//only used for AODs + Double_t fEtaMin;//only used for AODs + Double_t fEtaMax;//only used for AODs + + Double_t fDCAxyCut;//only used for AODs + Double_t fDCAzCut;//only used for AODs + + Double_t fTPCchi2Cut;//only used for AODs + Int_t fNClustersTPCCut;//only used for AODs + + + AliAnalysisTaskTriggeredBF(const AliAnalysisTaskTriggeredBF&); // not implemented + AliAnalysisTaskTriggeredBF& operator=(const AliAnalysisTaskTriggeredBF&); // not implemented + + ClassDef(AliAnalysisTaskTriggeredBF, 1); // example of analysis +}; + +#endif diff --git a/PWGCF/EBYE/BalanceFunctions/AliBalanceEventMixing.h b/PWGCF/EBYE/BalanceFunctions/AliBalanceEventMixing.h index 5ff4481b619..dcd080a9e20 100644 --- a/PWGCF/EBYE/BalanceFunctions/AliBalanceEventMixing.h +++ b/PWGCF/EBYE/BalanceFunctions/AliBalanceEventMixing.h @@ -141,7 +141,7 @@ class AliBalanceEventMixing : public TObject { AliBalanceEventMixing & operator=(const AliBalanceEventMixing & ) {return *this;} - ClassDef(AliBalanceEventMixing, 3) + ClassDef(AliBalanceEventMixing, 1) }; #endif diff --git a/PWGCF/EBYE/BalanceFunctions/AliBalanceTriggered.cxx b/PWGCF/EBYE/BalanceFunctions/AliBalanceTriggered.cxx new file mode 100644 index 00000000000..7c296e2d5d0 --- /dev/null +++ b/PWGCF/EBYE/BalanceFunctions/AliBalanceTriggered.cxx @@ -0,0 +1,455 @@ +/************************************************************************** + * Author: Panos Christakoglou. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + +//----------------------------------------------------------------- +// Balance Function class +// This is the class to deal with the Balance Function analysis +// Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch +// Modified: Michael Weber, m.weber@cern.ch +//----------------------------------------------------------------- + + +//ROOT +#include +#include +#include +#include + + +#include +#include +#include +#include +#include + +#include "AliVParticle.h" +#include "AliMCParticle.h" +#include "AliESDtrack.h" +#include "AliAODTrack.h" + +#include "AliBalanceTriggered.h" + +ClassImp(AliBalanceTriggered) + +//____________________________________________________________________// +AliBalanceTriggered::AliBalanceTriggered() : + TObject(), + bShuffle(kFALSE), + fAnalysisLevel("AOD"), + fHistP(0x0), + fHistN(0x0), + fHistPN(0x0), + fHistNP(0x0), + fHistPP(0x0), + fHistNN(0x0) +{ + // Default constructor + +} + + +//____________________________________________________________________// +AliBalanceTriggered::AliBalanceTriggered(const AliBalanceTriggered& balance): + TObject(balance), bShuffle(balance.bShuffle), + fAnalysisLevel(balance.fAnalysisLevel), + fHistP(balance.fHistP), + fHistN(balance.fHistN), + fHistPN(balance.fHistPN), + fHistNP(balance.fHistNP), + fHistPP(balance.fHistPP), + fHistNN(balance.fHistNN) +{ + //copy constructor + +} + +//____________________________________________________________________// +AliBalanceTriggered::~AliBalanceTriggered() { + // Destructor + + delete fHistP; + delete fHistN; + delete fHistPN; + delete fHistNP; + delete fHistPP; + delete fHistNN; + + +} + +//____________________________________________________________________// +void AliBalanceTriggered::InitHistograms() { + + //Initialize the histograms + + TString title = ""; // histogram title + Int_t anaSteps = 1; // analysis steps + + // single particle histograms + Int_t iBinSingle[nTrackVarsSingle]; // binning for track variables + Double_t* dBinsSingle[nTrackVarsSingle]; // bins for track variables + TString axisTitleSingle[nTrackVarsSingle]; // axis titles for track variables + + // two particle histograms + Int_t iBinPair[nTrackVarsPair]; // binning for track variables + Double_t* dBinsPair[nTrackVarsPair]; // bins for track variables + TString axisTitlePair[nTrackVarsPair]; // axis titles for track variables + + + //----------------------------------------------------------- + // histogram settings (hard coded!) + //----------------------------------------------------------- + + // eta + const Int_t kNEtaBins = 40; + Double_t etaBins[kNEtaBins+1]; + for(Int_t i = 0; i < kNEtaBins+1; i++){ + etaBins[i] = -1.0 + i * 0.05; + } + iBinSingle[0] = kNEtaBins; + dBinsSingle[0] = etaBins; + axisTitleSingle[0] = "#eta"; + + // delta eta + const Int_t kNDeltaEtaBins = 40; + Double_t deltaEtaBins[kNDeltaEtaBins+1]; + for(Int_t i = 0; i < kNDeltaEtaBins+1; i++){ + deltaEtaBins[i] = -2.0 + i * 0.1; + } + iBinPair[0] = kNDeltaEtaBins; + dBinsPair[0] = deltaEtaBins; + axisTitlePair[0] = "#Delta #eta"; + + // phi + const Int_t kNPhiBins = 72; + Double_t phiBins[kNPhiBins+1]; + for(Int_t i = 0; i < kNPhiBins+1; i++){ + phiBins[i] = 0.0 + i * 5.; + } + iBinSingle[1] = kNPhiBins; + dBinsSingle[1] = phiBins; + axisTitleSingle[1] = "#phi (#circ)"; + + // delta phi + const Int_t kNDeltaPhiBins = 72; + Double_t deltaPhiBins[kNDeltaPhiBins+1]; + for(Int_t i = 0; i < kNDeltaPhiBins+1; i++){ + deltaPhiBins[i] = -180.0 + i * 5.; + } + iBinPair[1] = kNDeltaPhiBins; + dBinsPair[1] = deltaPhiBins; + axisTitlePair[1] = "#Delta #phi (#circ)"; + + // pT + const Int_t kNPtBins = 22; + Double_t pTBins[kNPtBins+1] = {0.15, 0.2, 0.3, 0.4, 0.5, 0.75, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 12.0, 15.0, 20.0}; + iBinSingle[2] = kNPtBins; + dBinsSingle[2] = pTBins; + axisTitleSingle[2] = "p_{T,trig} (GeV/c)"; + + iBinPair[2] = kNPtBins; + dBinsPair[2] = pTBins; + axisTitlePair[2] = "p_{T} (GeV/c)"; + + iBinPair[3] = kNPtBins; + dBinsPair[3] = pTBins; + axisTitlePair[3] = "p_{T,trig} (GeV/c)"; + + // centrality + const Int_t kNCentBins = 9; + Double_t centBins[kNCentBins+1] = {0.,5.,10.,20.,30.,40.,50.,60.,70.,80.}; + + iBinSingle[3] = kNCentBins; + dBinsSingle[3] = centBins; + axisTitleSingle[3] = "centrality"; + + iBinPair[4] = kNCentBins; + dBinsPair[4] = centBins; + axisTitlePair[4] = "centrality"; + + //----------------------------------------------------------- + + + + // User settings (depending on the analysis settings [only one at the moment]) + if(fAnalysisLevel == "AOD"){ + title = "hdEtaVsdPhi"; + } + + //----------------------------------------------------------- + //----------------------------------------------------------- + // Histogram creation + + // histogram for negative particles + fHistN = new AliTHn(Form("fHistN"), Form("%s_N",title.Data()), anaSteps, nTrackVarsSingle, iBinSingle); + for (Int_t j=0; jSetBinLimits(j, dBinsSingle[j]); + fHistN->SetVarTitle(j, axisTitleSingle[j]); + } + + // histogram for positive particles + fHistP = new AliTHn(Form("fHistP"), Form("%s_P",title.Data()), anaSteps, nTrackVarsSingle, iBinSingle); + for (Int_t j=0; jSetBinLimits(j, dBinsSingle[j]); + fHistP->SetVarTitle(j, axisTitleSingle[j]); + } + + // histogram for +- pairs + fHistPN = new AliTHn(Form("fHistPN"), Form("%s_PN",title.Data()), anaSteps, nTrackVarsPair, iBinPair); + for (Int_t j=0; jSetBinLimits(j, dBinsPair[j]); + fHistPN->SetVarTitle(j, axisTitlePair[j]); + } + + // histogram for -+ pairs + fHistNP = new AliTHn(Form("fHistNP"), Form("%s_NP",title.Data()), anaSteps, nTrackVarsPair, iBinPair); + for (Int_t j=0; jSetBinLimits(j, dBinsPair[j]); + fHistNP->SetVarTitle(j, axisTitlePair[j]); + } + + // histogram for ++ pairs + fHistPP = new AliTHn(Form("fHistPP"), Form("%s_PP",title.Data()), anaSteps, nTrackVarsPair, iBinPair); + for (Int_t j=0; jSetBinLimits(j, dBinsPair[j]); + fHistPP->SetVarTitle(j, axisTitlePair[j]); + } + + // histogram for -- pairs + fHistNN = new AliTHn(Form("fHistNN"), Form("%s_NN",title.Data()), anaSteps, nTrackVarsPair, iBinPair); + for (Int_t j=0; jSetBinLimits(j, dBinsPair[j]); + fHistNN->SetVarTitle(j, axisTitlePair[j]); + } + + //----------------------------------------------------------- + //----------------------------------------------------------- + + +} + +//____________________________________________________________________// +void AliBalanceTriggered::FillBalance(Float_t fCentrality,vector **chargeVector) { + // Calculates the balance function + + + // Initialize histograms if not done yet + if(!fHistPN){ + AliWarning("Histograms not yet initialized! --> Will be done now"); + AliWarning("This works only in local mode --> Add 'gBalance->InitHistograms()' in your configBalanceFunction"); + InitHistograms(); + } + + Int_t gNtrack = chargeVector[0]->size(); + Double_t trackVarsSingle[nTrackVarsSingle]; + Double_t trackVarsPair[nTrackVarsPair]; + + // 1st particle loop + for(Int_t i = 0; i < gNtrack;i++){ + + Short_t charge = (Short_t) chargeVector[0]->at(i); + trackVarsSingle[0] = chargeVector[2]->at(i); //eta + trackVarsSingle[1] = chargeVector[3]->at(i); //phi + trackVarsSingle[2] = chargeVector[7]->at(i); //pt trigger + trackVarsSingle[3] = fCentrality; //centrality (really as variable here????) + + //fill single particle histograms + if(charge > 0) fHistP->Fill(trackVarsSingle,0,1.); + else fHistN->Fill(trackVarsSingle,0,1.); + + // 2nd particle loop + for(Int_t j = 0; j < i; j++) { + + // need check for single particle region!!!??? + // + + Short_t charge2 = (Short_t) chargeVector[0]->at(j); + trackVarsPair[0] = chargeVector[2]->at(i) - chargeVector[2]->at(j) ; //delta eta + trackVarsPair[1] = chargeVector[3]->at(i) - chargeVector[3]->at(j); //delta phi + trackVarsPair[2] = chargeVector[7]->at(j); //pt + trackVarsPair[3] = chargeVector[7]->at(i); //pt trigger + trackVarsPair[4] = fCentrality; //centrality (really as variable here????) + + if( charge > 0 && charge2 < 0) fHistPN->Fill(trackVarsPair,0,1.); + else if( charge < 0 && charge2 > 0) fHistNP->Fill(trackVarsPair,0,1.); + else if( charge > 0 && charge2 > 0) fHistPP->Fill(trackVarsPair,0,1.); + else if( charge < 0 && charge2 < 0) fHistNN->Fill(trackVarsPair,0,1.); + else AliWarning("Wrong charge combination!"); + + }//end of 2nd particle loop + }//end of 1st particle loop +} + + +TH1D* AliBalanceTriggered::GetBalanceFunctionHistogram1D(Int_t var, Double_t pTMin, Double_t pTMax, Double_t centrMin, Double_t centrMax){ + + // check which variable should be analyzed + // 0 = Delta eta + // 1 = Delta phi + + if( var < 0 || var > 1){ + AliError("Only Variable 0 (= Delta eta) or 1 (= Delta phi) allowed"); + return NULL; + } + + + // Choose region to analyze + // for Single Histograms (P,N): 2 = pT,trigger; 3 = centrality + // for Pair Histograms (PN,NP,NN,PP): 2 = pT; 3 = pT,trigger; 4 = centrality + + // pT trigger + fHistP->GetGrid(0)->GetGrid()->GetAxis(2)->SetRange(pTMin,pTMax); + fHistN->GetGrid(0)->GetGrid()->GetAxis(2)->SetRange(pTMin,pTMax); + fHistPN->GetGrid(0)->GetGrid()->GetAxis(2)->SetRange(pTMin,pTMax); + fHistNP->GetGrid(0)->GetGrid()->GetAxis(2)->SetRange(pTMin,pTMax); + fHistPP->GetGrid(0)->GetGrid()->GetAxis(2)->SetRange(pTMin,pTMax); + fHistNN->GetGrid(0)->GetGrid()->GetAxis(2)->SetRange(pTMin,pTMax); + + // pT + fHistPN->GetGrid(0)->GetGrid()->GetAxis(3)->SetRange(pTMin,pTMax); + fHistNP->GetGrid(0)->GetGrid()->GetAxis(3)->SetRange(pTMin,pTMax); + fHistPP->GetGrid(0)->GetGrid()->GetAxis(3)->SetRange(pTMin,pTMax); + fHistNN->GetGrid(0)->GetGrid()->GetAxis(3)->SetRange(pTMin,pTMax); + + // centrality + fHistP->GetGrid(0)->GetGrid()->GetAxis(3)->SetRange(centrMin,centrMax); + fHistN->GetGrid(0)->GetGrid()->GetAxis(3)->SetRange(centrMin,centrMax); + fHistPN->GetGrid(0)->GetGrid()->GetAxis(4)->SetRange(centrMin,centrMax); + fHistNP->GetGrid(0)->GetGrid()->GetAxis(4)->SetRange(centrMin,centrMax); + fHistPP->GetGrid(0)->GetGrid()->GetAxis(4)->SetRange(centrMin,centrMax); + fHistNN->GetGrid(0)->GetGrid()->GetAxis(4)->SetRange(centrMin,centrMax); + + + // Project into the wanted space (1st: analysis step, 2nd: axis) + TH1D* hTemp1 = (TH1D*)fHistPN->Project(0,var); + TH1D* hTemp2 = (TH1D*)fHistNP->Project(0,var); + TH1D* hTemp3 = (TH1D*)fHistPP->Project(0,var); + TH1D* hTemp4 = (TH1D*)fHistNN->Project(0,var); + TH1D* hTemp5 = (TH1D*)fHistP->Project(0,var); + TH1D* hTemp6 = (TH1D*)fHistN->Project(0,var); + + TH1D* gHistBalanceFunctionHistogram = (TH1D*)hTemp1->Clone(); + gHistBalanceFunctionHistogram->Reset(); + + // Calculate BF + if((hTemp1)&&(hTemp2)&&(hTemp3)&&(hTemp4)) { + hTemp1->Sumw2(); + hTemp2->Sumw2(); + hTemp3->Sumw2(); + hTemp4->Sumw2(); + hTemp1->Add(hTemp3,-1.); + hTemp1->Scale(1./hTemp5->GetEntries()); + hTemp2->Add(hTemp4,-1.); + hTemp2->Scale(1./hTemp6->GetEntries()); + gHistBalanceFunctionHistogram->Add(hTemp1,hTemp2,1.,1.); + gHistBalanceFunctionHistogram->Scale(0.5/1.); + } + + return gHistBalanceFunctionHistogram; +} + +TH1D* AliBalanceTriggered::GetHistogram1D(Int_t histo, Int_t var, Double_t pTMin, Double_t pTMax, Double_t centrMin, Double_t centrMax){ + + // check which variable should be analyzed + // + // pair histograms: + // 0 = Delta eta + // 1 = Delta phi + // 2 = pT, trigger + // 3 = centrality + // + // pair histograms: + // 0 = Delta eta + // 1 = Delta phi + // 2 = pT + // 3 = pT, trigger + // 4 = centrality + + if(histo < 0 || histo > 5){ + AliError("Only 6 histograms available: 0(P), 1(N), 2(PN), 3(NP), 4(PP), 5(NN)"); + return NULL; + } + + if( histo > 1 && (var < 0 || var > 5)){ + AliError("Only Variable 0 to 4 allowed for pair histograms (histo > 1)"); + return NULL; + } + if( histo < 2 && (var < 0 || var > 4)){ + AliError("Only Variable 0 to 3 allowed for single histograms (histo < 2)"); + return NULL; + } + + // get the histogram + AliTHn *gTHn = NULL; + switch(histo){ + + case 0: + gTHn = fHistP; + break; + + case 1: + gTHn = fHistN; + break; + + case 2: + gTHn = fHistPN; + break; + + case 3: + gTHn = fHistNP; + break; + + case 4: + gTHn = fHistPP; + break; + + case 5: + gTHn = fHistNN; + break; + + default: + break; + + } + + if(!gTHn){ + AliError(Form("AliTHn number %d = NULL",histo)); + return NULL; + } + + // Choose region to analyze + // for Single Histograms (P,N): 2 = pT,trigger; 3 = centrality + // for Pair Histograms (PN,NP,NN,PP): 2 = pT; 3 = pT,trigger; 4 = centrality + + // pT trigger + gTHn->GetGrid(0)->GetGrid()->GetAxis(2)->SetRange(pTMin,pTMax); + + // pT + if(histo > 1) gTHn->GetGrid(0)->GetGrid()->GetAxis(3)->SetRange(pTMin,pTMax); + + // centrality + if(histo < 2) gTHn->GetGrid(0)->GetGrid()->GetAxis(3)->SetRange(centrMin,centrMax); + else gTHn->GetGrid(0)->GetGrid()->GetAxis(4)->SetRange(centrMin,centrMax); + + + // Project into the wanted space (1st: analysis step, 2nd: axis) + TH1D* gHisto = (TH1D*)gTHn->Project(0,var); + + return gHisto; +} diff --git a/PWGCF/EBYE/BalanceFunctions/AliBalanceTriggered.h b/PWGCF/EBYE/BalanceFunctions/AliBalanceTriggered.h new file mode 100644 index 00000000000..7b58eab18ca --- /dev/null +++ b/PWGCF/EBYE/BalanceFunctions/AliBalanceTriggered.h @@ -0,0 +1,84 @@ +#ifndef ALIBALANCETRIGGERED_H +#define ALIBALANCETRIGGERED_H +/* See cxx source for full Copyright notice */ + + +//------------------------------------------------------------------------- +// Class AliBalanceTriggered +// This is the class for the Balance Function analysis +// +// Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch +// Modified: Michael Weber, m.weber@cern.ch +//------------------------------------------------------------------------- + +#include +#include "TString.h" + +class TGraphErrors; +class TH1D; +class AliTHn; + +const Int_t nTrackVarsSingle = 4; // track variables in histogram (eta, phi, pTtrig, centrality) +const Int_t nTrackVarsPair = 5; // track variables in histogram (dEta, dPhi, pT, pTtrig, centrality) + +class AliBalanceTriggered : public TObject { + public: + + AliBalanceTriggered(); + AliBalanceTriggered(const AliBalanceTriggered& balance); + ~AliBalanceTriggered(); + + // analysis setters + void SetAnalysisLevel(const char* analysisLevel) { + fAnalysisLevel = analysisLevel;} + void SetShuffle(Bool_t shuffle) {bShuffle = shuffle;} + + // analysis getters + const char* GetAnalysisLevel() {return fAnalysisLevel.Data();} + const Bool_t GetShuffle() {return bShuffle;} + + // initialize histograms + void InitHistograms(void); + + // histogram setters + void SetHistNp(AliTHn *gHist) { fHistP = gHist;} + void SetHistNn(AliTHn *gHist) { fHistN = gHist;} + void SetHistNpn(AliTHn *gHist) { fHistPN = gHist;} + void SetHistNnp(AliTHn *gHist) { fHistNP = gHist;} + void SetHistNpp(AliTHn *gHist) { fHistPP = gHist;} + void SetHistNnn(AliTHn *gHist) { fHistNN = gHist;} + + // histogram getters + AliTHn *GetHistNp() { return fHistP;} + AliTHn *GetHistNn() { return fHistN;} + AliTHn *GetHistNpn() { return fHistPN;} + AliTHn *GetHistNnp() { return fHistNP;} + AliTHn *GetHistNpp() { return fHistPP;} + AliTHn *GetHistNnn() { return fHistNN;} + + // Fill balance function histograms + void FillBalance(Float_t fCentrality,vector **chargeVector); + + // Get the balance function histogram + TH1D *GetBalanceFunctionHistogram1D(Int_t var, Double_t pTMin, Double_t pTMax, Double_t centrMin, Double_t centrMax); + + // Get 1D histogram + TH1D* GetHistogram1D(Int_t histo, Int_t var, Double_t pTMin, Double_t pTMax, Double_t centrMin, Double_t centrMax); + + private: + Bool_t bShuffle; //shuffled balance function object + TString fAnalysisLevel; // ESD, AOD or MC + + AliTHn *fHistP; //N+ + AliTHn *fHistN; //N- + AliTHn *fHistPN; //N+- + AliTHn *fHistNP; //N-+ + AliTHn *fHistPP; //N++ + AliTHn *fHistNN; //N-- + + AliBalanceTriggered & operator=(const AliBalanceTriggered & ) {return *this;} + + ClassDef(AliBalanceTriggered, 1) +}; + +#endif diff --git a/PWGCF/EBYE/macros/AddTaskBalanceTriggered.C b/PWGCF/EBYE/macros/AddTaskBalanceTriggered.C new file mode 100644 index 00000000000..69d9f5e2a8c --- /dev/null +++ b/PWGCF/EBYE/macros/AddTaskBalanceTriggered.C @@ -0,0 +1,153 @@ +// now in options + +//PID config +Bool_t kUseNSigmaPID = kFALSE; +Double_t nSigmaMax = 3.0; +Bool_t kUseBayesianPID = kTRUE; +Double_t gMinAcceptedProbability = 0.7; + +//_________________________________________________________// +AliAnalysisTaskTriggeredBF *AddTaskBalanceTriggered(Double_t centrMin=0., + Double_t centrMax=100., + Bool_t gRunShuffling=kFALSE, + TString centralityEstimator="V0M", + Double_t vertexZ=10., + Double_t DCAxy=-1, + Double_t DCAz=-1, + Double_t ptMin=0.15, + Double_t ptMax=20, + Double_t etaMin=-0.8, + Double_t etaMax=0.8, + Double_t maxTPCchi2 = -1, + Int_t minNClustersTPC = -1, + Bool_t kUsePID = kFALSE, + Int_t AODfilterBit = 128, + Bool_t bCentralTrigger = kFALSE, + TString fileNameBase="AnalysisResults") { + + // Creates a balance function analysis task and adds it to the analysis manager. + // Get the pointer to the existing analysis manager via the static access method. + TString centralityName(""); + centralityName+=Form("%.0f",centrMin); + centralityName+="-"; + centralityName+=Form("%.0f",centrMax); + centralityName+="_"; + centralityName+=Form("%s",centralityEstimator.Data()); + centralityName+="_"; + centralityName+=Form("vZ%.1f",vertexZ); + centralityName+="_"; + centralityName+=Form("DCAxy%.1f",DCAxy); + centralityName+="_"; + centralityName+=Form("DCAz%.1f",DCAz); + centralityName+="_Pt"; + centralityName+=Form("%.1f",ptMin); + centralityName+="-"; + centralityName+=Form("%.1f",ptMax); + centralityName+="_Eta"; + centralityName+=Form("%.1f",etaMin); + centralityName+="-"; + centralityName+=Form("%.1f",etaMax); + centralityName+="_Chi"; + centralityName+=Form("%.1f",maxTPCchi2); + centralityName+="_nClus"; + centralityName+=Form("%d",minNClustersTPC); + centralityName+="_Bit"; + centralityName+=Form("%d",AODfilterBit); + if(bCentralTrigger) centralityName+="_withCentralTrigger"; + + + + TString outputFileName(fileNameBase); + outputFileName.Append(".root"); + + //=========================================================================== + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) { + ::Error("AddTaskTriggeredBF", "No analysis manager to connect to."); + return NULL; + } + + // Check the analysis type using the event handlers connected to the analysis manager. + //=========================================================================== + if (!mgr->GetInputEventHandler()) { + ::Error("AddTaskTriggeredBF", "This task requires an input event handler"); + return NULL; + } + TString analysisType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD" + if(dynamic_cast (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler())) analysisType = "MC"; + + // setup the balance function objects + AliBalanceTriggered *bf = 0; // Balance Function object + AliBalanceTriggered *bfs = 0; // shuffled Balance function object + + if (analysisType=="AOD"){ + + bf = new AliBalanceTriggered(); + bf->SetAnalysisLevel(analysisType); + bf->SetShuffle(kFALSE); + bf->InitHistograms(); + + if(gRunShuffling){ + bfs = new AliBalanceTriggered(); + bfs->SetAnalysisLevel(analysisType); + bfs->SetShuffle(kTRUE); + bfs->InitHistograms(); + } + } + else{ + ::Error("AddTaskTriggeredBF", "analysis type NOT supported."); + return NULL; + } + + // Create the task, add it to manager and configure it. + //=========================================================================== + AliAnalysisTaskTriggeredBF *taskTriggeredBF = new AliAnalysisTaskTriggeredBF("TaskTriggeredBF"); + taskTriggeredBF->SetAnalysisObject(bf); + if(gRunShuffling) taskTriggeredBF->SetShufflingObject(bfs); + + taskTriggeredBF->SetCentralityPercentileRange(centrMin,centrMax); + if(analysisType == "AOD") { + // pt and eta cut (pt_min, pt_max, eta_min, eta_max) + taskTriggeredBF->SetAODtrackCutBit(AODfilterBit); + taskTriggeredBF->SetKinematicsCutsAOD(ptMin,ptMax,etaMin,etaMax); + + // set extra DCA cuts (-1 no extra cut) + taskTriggeredBF->SetExtraDCACutsAOD(DCAxy,DCAz); + + // set extra TPC chi2 / nr of clusters cut + taskTriggeredBF->SetExtraTPCCutsAOD(maxTPCchi2, minNClustersTPC); + + } + + // offline trigger selection (AliVEvent.h) + // taskTriggeredBF->UseOfflineTrigger(); // NOT used (selection is done with the AliAnalysisTaskSE::SelectCollisionCandidates()) + // with this only selected events are analyzed (first 2 bins in event QA histogram are the same)) + // documentation in https://twiki.cern.ch/twiki/bin/viewauth/ALICE/PWG1EvSelDocumentation + if(bCentralTrigger) taskTriggeredBF->SelectCollisionCandidates(AliVEvent::kMB | AliVEvent::kCentral | AliVEvent::kSemiCentral); + else taskTriggeredBF->SelectCollisionCandidates(AliVEvent::kMB); + + // centrality estimator (default = V0M) + taskTriggeredBF->SetCentralityEstimator(centralityEstimator); + + // vertex cut (x,y,z) + taskTriggeredBF->SetVertexDiamond(.3,.3,vertexZ); + + //bf->PrintAnalysisSettings(); + mgr->AddTask(taskTriggeredBF); + + // Create ONLY the output containers for the data produced by the task. + // Get and connect other common input/output containers via the manager as below + //============================================================================== + TString outputFileName = AliAnalysisManager::GetCommonFileName(); + outputFileName += ":PWGCFEbyE.outputBalanceFunctionAnalysis"; + AliAnalysisDataContainer *coutQA = mgr->CreateContainer(Form("listQA_%s",centralityName.Data()), TList::Class(),AliAnalysisManager::kOutputContainer,outputFileName.Data()); + AliAnalysisDataContainer *coutTriggeredBF = mgr->CreateContainer(Form("listTriggeredBF_%s",centralityName.Data()), TList::Class(),AliAnalysisManager::kOutputContainer,outputFileName.Data()); + if(gRunShuffling) AliAnalysisDataContainer *coutTriggeredBFS = mgr->CreateContainer(Form("listTriggeredBFShuffled_%s",centralityName.Data()), TList::Class(),AliAnalysisManager::kOutputContainer,outputFileName.Data()); + + mgr->ConnectInput(taskTriggeredBF, 0, mgr->GetCommonInputContainer()); + mgr->ConnectOutput(taskTriggeredBF, 1, coutQA); + mgr->ConnectOutput(taskTriggeredBF, 2, coutTriggeredBF); + if(gRunShuffling) mgr->ConnectOutput(taskTriggeredBF, 3, coutTriggeredBFS); + + return taskTriggeredBF; +}