-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * *
- * Author: Satyajit Jena. *
- * 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. *
- **************************************************************************/
-
-/* $Id$ sjena*/
-
-//-------------------------------------------------------------------------
-// AliEbyEFluctuationAnalysisTask
-// This is the class to deal with the EbyE Charge Fluctuation analysis
-// Origin: Satyajit Jena, sjena@cern.ch
-//-------------------------------------------------------------------------
-
-#include "Riostream.h"
#include "TChain.h"
#include "TTree.h"
#include "TH1F.h"
#include "TH2F.h"
#include "TCanvas.h"
-#include "TList.h"
-#include "AliAnalysisTaskSE.h"
+#include "TParticle.h"
+#include "AliAnalysisTask.h"
#include "AliAnalysisManager.h"
+
#include "AliStack.h"
-#include "AliESDtrackCuts.h"
+#include "AliMCEvent.h"
#include "AliESDEvent.h"
#include "AliESDInputHandler.h"
-#include "AliESDVZERO.h"
-#include "AliAODEvent.h"
-#include "AliMCEvent.h"
-#include "AliMultiplicity.h"
-#include "AliVertexerTracks.h"
+#include "AliESDtrackCuts.h"
#include "AliCentrality.h"
-#include "AliEbyEFluctuationAnalysisTask.h"
-ClassImp(AliEbyEFluctuationAnalysisTask)
+#include "AliEbyEFluctuationAnalysisTask.h"
-//________________________________________________________________________
-AliEbyEFluctuationAnalysisTask::AliEbyEFluctuationAnalysisTask()
- :AliAnalysisTaskSE(),
- fTrackCut(0),
- fListQA(0),
- fListResults(0),
- fAnalysisType("ESD"),
- fAnalysisMode("TPC"),
- fCentType("M"),
- fCentBin(10),
- fCentMode("F"),
- fCentEstimator("V0M"),
- fVx(5.),
- fVy(5.),
- fVz(10.),
- fHistEventStats(0),
- fhVertex(0),
- fhVzeroMult(0),
- fCentVsMult(0),
- fhVnT(0) {
- // Dummy constructor ALWAYS needed for I/O.
- for(Int_t i = 0; i < 20; i++) fHCentrality[i] = NULL;
-}
+// Event by event charge fluctuation analysis
+// Authors: Satyajit Jena and Panos Cristakoglou
+//
+ClassImp(AliEbyEFluctuationAnalysisTask)
//________________________________________________________________________
AliEbyEFluctuationAnalysisTask::AliEbyEFluctuationAnalysisTask(const char *name)
- :AliAnalysisTaskSE(name),
- fTrackCut(0),
- fListQA(0),
- fListResults(0),
- fAnalysisType("ESD"),
- fAnalysisMode("TPC"),
- fCentType("M"),
- fCentBin(5),
- fCentMode("F"),
- fCentEstimator("V0M"),
- fVx(5.),
- fVy(5.),
- fVz(10.),
- fHistEventStats(0),
- fhVertex(0),
- fhVzeroMult(0),
- fCentVsMult(0),
- fhVnT(0) {
- //Constructor
- for(Int_t i = 0; i < 20; i++) fHCentrality[i] = NULL;
-
- DefineOutput(1, TList::Class());
- DefineOutput(2, TList::Class());
-}
-
-//________________________________________________________________________
-AliEbyEFluctuationAnalysisTask::~AliEbyEFluctuationAnalysisTask() {
- //Destructor
- if (!AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
- if(fListQA) delete fListQA;
- if(fTrackCut) delete fTrackCut;
+ : AliAnalysisTaskSE(name), fESD(0), fOutputList(0),
+ fHistEventStats(0), fHistCentrality(0),
+ fHistNMultMC(0), fHistNPlusNMinusMC(0),
+ fESDtrackCuts(0),
+ fAnalysisType("ESD"), fAnalysisMode("TPC"),
+ fCentralityEstimator("V0M"), fCentralityBins20(kFALSE),
+ fVxMax(3.), fVyMax(3.), fVzMax(10.) {
+ // Constructor
+
+ for(Int_t iBin = 1; iBin <= nCentralityBins; iBin++) {
+ fHistNMult[iBin-1] = NULL;
+ fHistNPlusNMinus[iBin-1] = NULL;
}
+
+ // Define input and output slots here
+ // Input slot #0 works with a TChain
+ DefineInput(0, TChain::Class());
+ // Output slot #0 id reserved by the base class for AOD
+ // Output slot #1 writes into a TH1 container
+ DefineOutput(1, TList::Class());
}
//________________________________________________________________________
void AliEbyEFluctuationAnalysisTask::UserCreateOutputObjects() {
- //Output objects
- fListQA = new TList();
- fListQA->SetName("fListQA");
-
- //InitTrackCuts();
-
- Int_t lbin = 100/fCentBin + 2;
-
- TString gCutName[4] = {"Total","Offline trigger","Vertex","Analyzed"};
- fHistEventStats = new TH1F("fHistEventStats","Event statistics;;N_{events}",4,0.5,4.5);
+ // Create histograms
+ // Called once
+
+ fOutputList = new TList();
+
+ //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());
-
- fListQA->Add(fHistEventStats);
-
- fhVertex = new TH2F("hVertex","Vertexer;Bin For Different Vertexer;Value",7,0,7,1000,-25,25);
- fListQA->Add(fhVertex);
-
- fhVzeroMult = new TH2F("hVzMultilicity","",lbin,0,(Double_t)lbin,1000,0,25000);
- fListQA->Add(fhVzeroMult);
-
- fhVnT = new TH2F("hVzAndTrack","",lbin,0,(Double_t)lbin,1000,0,25000);
- fListQA->Add(fhVnT);
-
- fCentVsMult = new TH2F("hCentVsMult","Centrality vs Multiplicity[N_{+} + N_{-}];Centrality; Multiplicity[N_{+} + N_{-}]",lbin,0,(Double_t)lbin,4000,0,25000);
-
- fListQA->Add(fCentVsMult);
-
- //===========================================================//
- fListResults = new TList();
- fListResults->SetName("fListResults");
- TString histName;
- for(Int_t iBin = 0; iBin < 20 ; iBin++) {
- histName = "fHistPN"; histName += "Centrality"; histName += iBin;
- fHCentrality[iBin] = new TH2F(histName.Data(),
+ fOutputList->Add(fHistEventStats);
+
+ //ESD analysis
+ if(fAnalysisType == "ESD") {
+ fHistCentrality = new TH1F("fHistCentrality",";Centrality bin;Events",
+ nCentralityBins,0.5,nCentralityBins+0.5);
+ fOutputList->Add(fHistCentrality);
+
+ TString histName;
+ for(Int_t iBin = 1; iBin <= nCentralityBins; iBin++) {
+ histName = "fHistNMult"; histName += "Centrality"; histName += iBin;
+ fHistNMult[iBin-1] = new TH1F(histName.Data(),
+ ";N_{mult.}",
+ 500,0,3000);
+ fOutputList->Add(fHistNMult[iBin-1]);
+ }
+ for(Int_t iBin = 1; iBin <= nCentralityBins; iBin++) {
+ histName = "fHistNPlusNMinus"; histName += "Centrality"; histName += iBin;
+ fHistNPlusNMinus[iBin-1] = new TH2F(histName.Data(),
+ ";N_{+};N_{-}",
+ 2000,0.5,2000.5,2000,0.5,2000.5);
+ fOutputList->Add(fHistNPlusNMinus[iBin-1]);
+ }
+ }//ESD analysis
+ else if(fAnalysisType == "MC") {
+ TString histName = "fHistNMultMC";
+ fHistNMultMC = new TH1F(histName.Data(),
+ ";N_{mult.}",
+ 600,0,6000);
+ fOutputList->Add(fHistNMultMC);
+
+ histName = "fHistNPlusNMinusMC";
+ fHistNPlusNMinusMC = new TH2F(histName.Data(),
";N_{+};N_{-}",
- 2000,0.5,2000.5,2000,0.5,2000.5);
- fListResults->Add(fHCentrality[iBin]);
- }
-
- PostData(1, fListQA);
- PostData(2, fListResults);
+ 3000,0.5,3000.5,3000,0.5,3000.5);
+ fOutputList->Add(fHistNPlusNMinusMC);
+ }//MC analysis
}
//________________________________________________________________________
void AliEbyEFluctuationAnalysisTask::UserExec(Option_t *) {
- //Analysis part
- fHistEventStats->Fill(1); //all events
- TString gAnalysisLevel = "ESD";
-
- //AliCentrality *centrality = esd->GetCentrality();
- Double_t mult = 0;
- Int_t pch = 0;
- Int_t nch = 0;
- Int_t cent = 0;
+ // Main loop
+ // Called for each event
+ Int_t nPlus = 0, nMinus = 0;
+
+ // Post output data.
//ESD analysis
- if(fAnalysisType.CompareTo("ESD") == 0) {
- AliESDEvent* gESD = dynamic_cast<AliESDEvent*>(InputEvent()); // from Task
- if (!gESD) {
- Printf("ERROR: gESD not available");
+ if(fAnalysisType == "ESD") {
+ fESD = dynamic_cast<AliESDEvent*>(InputEvent());
+ if (!fESD) {
+ printf("ERROR: fESD not available\n");
+ return;
+ }
+
+ fHistEventStats->Fill(1); //all events
+
+ //Bool_t isSelected = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kMB);
+ //if(isSelected) {
+ fHistEventStats->Fill(2); //triggered + centrality
+ Printf("Event accepted");
+
+ //Centrality stuff
+ AliCentrality *centrality = fESD->GetCentrality();
+ Int_t nCentrality = 0;
+ if(fCentralityBins20)
+ nCentrality = centrality->GetCentralityClass5(fCentralityEstimator.Data());
+ else
+ nCentrality = centrality->GetCentralityClass10(fCentralityEstimator.Data());
+
+ if((nCentrality < 0)||(nCentrality > 19)) return;
+
+ if(fAnalysisMode = "TPC") {
+ const AliESDVertex *vertex = fESD->GetPrimaryVertexTPC();
+ if(vertex) {
+ if(vertex->GetNContributors() > 0) {
+ if(vertex->GetZRes() != 0) {
+ fHistEventStats->Fill(3); //events with a proper vertex
+ if(TMath::Abs(vertex->GetXv()) < fVxMax) {
+ if(TMath::Abs(vertex->GetYv()) < fVyMax) {
+ if(TMath::Abs(vertex->GetZv()) < fVzMax) {
+ fHistEventStats->Fill(4); //analyzed events
+
+ //Printf("Centrality percentile: %lf - Centrality: %d - Total tracks: %d",
+ //centrality->GetCentralityPercentile(fCentralityEstimator.Data()),
+ //nCentrality,fESD->GetNumberOfTracks());
+
+ // Track loop to fill a pT spectrum
+ for (Int_t iTracks = 0; iTracks < fESD->GetNumberOfTracks(); iTracks++) {
+ AliESDtrack* track = fESD->GetTrack(iTracks);
+ if (!track) {
+ printf("ERROR: Could not receive track %d\n", iTracks);
+ continue;
+ }
+
+ //ESD track cuts
+ if(fESDtrackCuts) {
+ AliESDtrack *tpcOnlyTrack = fESDtrackCuts->GetTPCOnlyTrack(fESD,iTracks);
+ if(!tpcOnlyTrack) continue;
+
+ if(!fESDtrackCuts->AcceptTrack(tpcOnlyTrack)) continue;
+
+ Short_t gCharge = tpcOnlyTrack->Charge();
+ if(gCharge > 0) nPlus += 1;
+ if(gCharge < 0) nMinus += 1;
+ }//ESD track cut object
+ }//track loop
+ //if((nCentrality >= 1)&&(nCentrality <= 20)) {
+
+ fHistCentrality->Fill(nCentrality);
+ fHistNPlusNMinus[nCentrality-1]->Fill(nPlus,nMinus);
+ fHistNMult[nCentrality-1]->Fill(nPlus+nMinus);
+ //}
+ }//Vz cut
+ }//Vy cut
+ }//Vx cut
+ }//Vz resolution
+ }//number of contributors
+ }//valid vertex
+ }//TPC analysis mode
+ //}//physics selection
+ }//ESD analysis level
+
+ //MC analysis
+ if(fAnalysisType == "MC") {
+ AliMCEvent* mcEvent = MCEvent();
+ if (!mcEvent) {
+ Printf("ERROR: Could not retrieve MC event");
+ return;
+ }
+ AliStack* stack = mcEvent->Stack();
+ if (!stack) {
+ Printf("ERROR: Could not retrieve MC stack");
return;
}
-
- Bool_t isSelected = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kMB);
- if(!isSelected) return;
- fHistEventStats->Fill(2); //physics selection
-
- AliESDVZERO* esdV0 = gESD->GetVZEROData();
- mult = esdV0->GetMTotV0A() + esdV0->GetMTotV0C();
-
- const AliESDVertex *vertex = GetVertex(gESD);
- if(!vertex) return;
- fHistEventStats->Fill(3); //vertexcut
-
- AliCentrality *centrality = gESD->GetCentrality();
- cent = centrality->GetCentralityClass5(fCentEstimator.Data());
-
- // cent = GetCentrality(gESD);
- if(cent < 0 || cent > 19 ) return;
- fHistEventStats->Fill(4); //Analysed Events
- //Track loop
- for (Int_t iTracks = 0; iTracks < gESD->GetNumberOfTracks(); iTracks++) {
- AliESDtrack* track = gESD->GetTrack(iTracks);
+ fHistEventStats->Fill(1);
+ fHistEventStats->Fill(2);
+ fHistEventStats->Fill(3);
+ fHistEventStats->Fill(4); //analyzed events
+ for (Int_t iTracks = 0; iTracks < mcEvent->GetNumberOfTracks(); iTracks++) {
+ AliVParticle* track = mcEvent->GetTrack(iTracks);
if (!track) {
- Printf("ERROR: Could not receive track %d", iTracks);
+ Printf("ERROR: Could not receive track %d (mc loop)", iTracks);
continue;
}
- if(fTrackCut) {
- if(fAnalysisMode = "TPC") {
- AliESDtrack *tpcOnlyTrack = fTrackCut->GetTPCOnlyTrack(gESD,iTracks);
- if(!tpcOnlyTrack) continue;
- if(!fTrackCut->AcceptTrack(tpcOnlyTrack)) continue;
- }
- else
- if(!fTrackCut->AcceptTrack(track)) continue;
- }
+ if(!stack->IsPhysicalPrimary(iTracks)) continue;
+ if((track->Pt() < 0.3) && (track->Pt() > 1.5)) continue;
+ if(TMath::Abs(track->Eta()) > 0.8) continue;
+
+ Short_t gCharge = track->Charge();
+ if(gCharge > 0) nPlus += 1;
+ if(gCharge < 0) nMinus += 1;
+ }//particle loop
+ fHistNPlusNMinusMC->Fill(nPlus,nMinus);
+ fHistNMultMC->Fill(nPlus+nMinus);
+
+ }//MC analysis level
- //----------------
- Short_t charge = track->Charge();
- if(charge > 0) pch += 1;
- if(charge < 0) nch += 1;
- //---------------
- }//track loop
- }//ESD analysis
- fCentVsMult->Fill(cent,pch+nch);
- fHCentrality[cent]->Fill(pch,nch);
-
- fhVnT->Fill(cent,mult);
- fhVnT->Fill(cent,pch+nch);
-}
+ PostData(1, fOutputList);
+}
//________________________________________________________________________
void AliEbyEFluctuationAnalysisTask::Terminate(Option_t *) {
- //Terminate
- fListQA = dynamic_cast<TList*> (GetOutputData(1));
- if(!fListQA) { Printf("ERROR: could not retrieve TList fListQA"); return; }
-}
+ // Draw result to the screen
+ // Called once at the end of the query
-//____________________________________________________________________//
-Int_t AliEbyEFluctuationAnalysisTask::GetCentrality(AliESDEvent *esd) const {
- //Return the centrality
- Int_t cent = -1;
-
- Int_t lbin = 100/fCentBin + 1;
-
- AliESDVZERO* esdV0 = esd->GetVZEROData();
- Double_t mult = esdV0->GetMTotV0A() + esdV0->GetMTotV0C();
- fhVzeroMult->Fill(lbin,mult);
-
- if(fCentType.CompareTo("M") == 0) {
-
- if(fAnalysisType.CompareTo("ESD") == 0)
- cent = FindCentralityESD(mult);
- if(fAnalysisType.CompareTo("MC") == 0)
- cent = FindCentralityMC(mult);
- if(cent > -1) fhVzeroMult->Fill(cent,mult);
- return cent;
+ fOutputList = dynamic_cast<TList*> (GetOutputData(1));
+ if (!fOutputList) {
+ printf("ERROR: Output list not available\n");
+ return;
}
-
-
- if(fCentType.CompareTo("G") == 0) {
- // printf("========= Inside Official Centrality Selection ======\n");
- AliCentrality *centrality = esd->GetCentrality();
- if(fCentBin == 10)
- cent = centrality->GetCentralityClass10(fCentEstimator);
- else
- cent = centrality->GetCentralityClass5(fCentEstimator);
-
- return cent;
- }
-
- return cent;
-}
-
-//____________________________________________________________________//
-Int_t AliEbyEFluctuationAnalysisTask::FindCentralityESD(Double_t mult) const {
- //hardcoded centrality bins (to be removed)
- Double_t data[101] = { 250000.0,
- 17760.0, 16870.0, 16070.0, 15360.0, 14660.0,
- 13970.0, 13320.0, 12700.0, 12140.0, 11570.0,
- 11020.0, 10530.0, 10030.0, 9560.0, 9110.0,
- 8680.0, 8270.0, 7870.0, 7490.0, 7120.0,
- 6780.0, 6440.0, 6120.0, 5810.0, 5510.0,
- 5230.0, 4950.0, 4690.0, 4440.0, 4190.0,
- 3960.0, 3740.0, 3530.0, 3330.0, 3130.0,
- 2940.0, 2770.0, 2600.0, 2440.0, 2290.0,
- 2150.0, 2010.0, 1880.0, 1760.0, 1640.0,
- 1540.0, 1440.0, 1350.0, 1260.0, 1180.0,
- 1110.0, 1030.0, 970.0, 900.0, 840.0,
- 790.0, 740.0, 700.0, 650.0, 610.0,
- 580.0, 540.0, 510.0, 480.0, 450.0,
- 430.0, 400.0, 380.0, 360.0, 340.0,
- 320.0, 300.0, 290.0, 270.0, 250.0,
- 240.0, 230.0, 210.0, 200.0, 190.0,
- 180.0, 170.0, 160.0, 150.0, 150.0,
- 140.0, 130.0, 120.0, 120.0, 110.0,
- 100.0, 100.0, 90.0, 90.0, 80.0,
- 80.0, 80.0, 70.0, 70.0, 70.0 };
-
-
- if(fCentMode.CompareTo("F") == 0) {
- for(Int_t i = 0; i < 100; i+=fCentBin) {
-
- if( (mult < data[i]) && (mult >= data[i+fCentBin]) )
- return i/fCentBin;
- }
- }
- if(fCentMode.CompareTo("A") == 0) {
- for(int i = 0; i < 100; i+=fCentBin) {
- if((mult < data[0]) && (mult >data[i+fCentBin]) ) {
- return i/fCentBin;
- }
- }
- }
-
-return -2;
-
-
-}
-
-//____________________________________________________________________//
-Int_t AliEbyEFluctuationAnalysisTask::FindCentralityMC(Double_t mult) const {
- //hardcoded centrality bins (MC) ==> to be removed
- Double_t data[101] = { 250000.0, 17760.0, 16870.0, 16070.0, 15360.0,
- 14660.0, 13970.0, 13320.0, 12700.0, 12140.0,
- 11570.0, 11020.0, 10530.0, 10030.0, 9560.0, 9110.0,
- 8680.0, 8270.0, 7870.0, 7490.0, 7120.0,
- 6780.0, 6440.0, 6120.0, 5810.0, 5510.0,
- 5230.0, 4950.0, 4690.0, 4440.0, 4190.0,
- 3960.0, 3740.0, 3530.0, 3330.0, 3130.0,
- 2940.0, 2770.0, 2600.0, 2440.0, 2290.0,
- 2150.0, 2010.0, 1880.0, 1760.0, 1640.0,
- 1540.0, 1440.0, 1350.0, 1260.0, 1180.0,
- 1110.0, 1030.0, 970.0, 900.0, 840.0,
- 790.0, 740.0, 700.0, 650.0, 610.0,
- 580.0, 540.0, 510.0, 480.0, 450.0,
- 430.0, 400.0, 380.0, 360.0, 340.0,
- 320.0, 300.0, 290.0, 270.0, 250.0,
- 240.0, 230.0, 210.0, 200.0, 190.0,
- 180.0, 170.0, 160.0, 150.0, 150.0,
- 140.0, 130.0, 120.0, 120.0, 110.0,
- 100.0, 100.0, 90.0, 90.0, 80.0,
- 80.0, 80.0, 70.0, 70.0, 70.0
- };
-
- if(fCentMode.CompareTo("F") == 0) {
- for(Int_t i = 0; i < 100; i+=fCentBin) {
- if( (mult < data[i]) && (mult >= data[i+fCentBin]) )
- return i/fCentBin;
- }
- }
- if(fCentMode.CompareTo("A") == 0) {
- for(int i = 0; i < 100; i+=fCentBin) {
- if((mult < data[0]) && (mult >= data[i+fCentBin]) ) {
- return i/fCentBin;
- }
- }
- }
-
- return -3;
-}
-
-//____________________________________________________________________//
-const AliESDVertex* AliEbyEFluctuationAnalysisTask::GetVertex(AliESDEvent* esd) {
- //Return the primary vertex
- const AliESDVertex* vertex = 0;
-
- if(fAnalysisMode = "TPC")
- vertex = esd->GetPrimaryVertexTPC();
- if(fAnalysisMode = "Hybrid")
- vertex = esd->GetPrimaryVertexSPD();
- if(fAnalysisMode = "Global")
- vertex = esd->GetPrimaryVertex();
-
- if(vertex) {
- if(vertex->GetNContributors() > 0) {
- if(vertex->GetZRes() != 0) {
- fhVertex->Fill(1,vertex->GetXv());
- fhVertex->Fill(2,vertex->GetYv());
- fhVertex->Fill(3,vertex->GetZv());
-
- if(TMath::Abs(vertex->GetXv()) < fVx) {
- if(TMath::Abs(vertex->GetYv()) < fVy) {
- if(TMath::Abs(vertex->GetZv()) < fVz) {
-
- fhVertex->Fill(4,vertex->GetXv());
- fhVertex->Fill(5,vertex->GetYv());
- fhVertex->Fill(6,vertex->GetZv());
- return vertex;
-
- }
- }
- }
- }
- }
- }
-
- return vertex;
}
-#ifndef AliEbyEFluctuationAnalysisTask_cxx
-#define AliEbyEFluctuationAnalysisTask_cxx
-
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice */
-//-------------------------------------------------------------------------
-// AliEbyEFluctuationAnalysisTask
-// This is the class to deal with the EbyE Charge Fluctuation analysis
-// Origin: Satyajit Jena, sjena@cern.ch
-//-------------------------------------------------------------------------
-
-class TH1F;
-class TH2F;
-class TList;
-class TTree;
-class AliESDVertex;
-class AliESDtrackCuts;
-class AliESDEvent;
-
-#ifndef ALIANALYSISTASKSE_H
-#include "AliAnalysisTaskSE.h"
-#endif
-
-
-class AliEbyEFluctuationAnalysisTask : public AliAnalysisTaskSE {
- public:
- AliEbyEFluctuationAnalysisTask();
- AliEbyEFluctuationAnalysisTask(const char *name);
- virtual ~AliEbyEFluctuationAnalysisTask();
-
- virtual void UserCreateOutputObjects();
- virtual void UserExec(Option_t *option);
- virtual void Terminate(Option_t *);
-
- void SetAnalysisCutObject(AliESDtrackCuts *const trackCuts) {
- fTrackCut = trackCuts;}
- void SetCentralityType(const char *centtype,
- const char *centmode,
- Int_t cbin) { //To be removed
- fCentType = centtype;
- fCentMode = centmode;
- fCentBin = cbin;
- }
-
- void SetAnalysisType(const char *analysistype) { fAnalysisType = analysistype;}
- void SetAnalysisMode(const char *analysisMode) { fAnalysisMode = analysisMode;}
- void SetCentralityEstimator(const char *centestimator) { fCentEstimator = centestimator;}
- void SetCentType(const char *centtype) { fCentType = centtype;}
-
- void SetVertex(Double_t vx, Double_t vy, Double_t vz) {fVx = vx; fVy = vy; fVz = vz; }
-
- Int_t GetCentrality(AliESDEvent *esd) const;
- Int_t FindCentralityESD(Double_t mult) const;
- Int_t FindCentralityMC(Double_t mult) const;
-
- const AliESDVertex *GetVertex(AliESDEvent* esd);
-
- private:
- AliESDtrackCuts *fTrackCut;//cut object
-
- TList *fListQA;//! Output QA list
- TList *fListResults;//!Output results list
- TString fAnalysisType;//"ESD","MC","AOD"
- TString fAnalysisMode;//"TPC","Global","Hybrid"
- TString fCentType;//to be removed
- Int_t fCentBin;
- TString fCentMode;
- TString fCentEstimator;//Centrality estimator "V0M","TKL","TRK","FMD","CL0","CL1"
- Double_t fVx;//Vx
- Double_t fVy;//Vy
- Double_t fVz;//Vz
-
- TH1F *fHistEventStats;//event stats
- TH2F *fhVertex; // 1-vx,2-vy,3-vz,4-vxacc,5-vyAcc,6-vzAcc
- TH2F *fhVzeroMult;//V0 amplitude
- TH2F *fCentVsMult; //centraltiy vs multiplicity
- TH2F *fhVnT;//
- TH2F *fHCentrality[20];//nPos vs nNeg vs centrality
-
- //_________________________________________________
- AliEbyEFluctuationAnalysisTask(const AliEbyEFluctuationAnalysisTask&); // not implemented
- AliEbyEFluctuationAnalysisTask& operator=(const AliEbyEFluctuationAnalysisTask&); // not implemented
-
- ClassDef(AliEbyEFluctuationAnalysisTask, 1);
-};
-
-#endif
-
+#ifndef AliEbyEFluctuationAnalysisTask_cxx\r
+#define AliEbyEFluctuationAnalysisTask_cxx\r
+\r
+// Event by event charge fluctuation analysis\r
+// Authors: Satyajit Jena and Panos Cristakoglou\r
+\r
+class TH1F;\r
+class TH2F;\r
+class TString;\r
+class AliESDEvent;\r
+class AliESDtrackCuts;\r
+\r
+#include "AliAnalysisTaskSE.h"\r
+\r
+const Int_t nCentralityBins = 20;\r
+\r
+class AliEbyEFluctuationAnalysisTask : public AliAnalysisTaskSE {\r
+ public:\r
+ AliEbyEFluctuationAnalysisTask() : AliAnalysisTaskSE(), fESD(0), fOutputList(0), fHistEventStats(0), fHistCentrality(0), fHistNMultMC(0), fHistNPlusNMinusMC(0), fESDtrackCuts(0), fAnalysisType(0), fAnalysisMode(0), fCentralityEstimator("V0M"), fCentralityBins20(kFALSE), fVxMax(3.0),fVyMax(3.0), fVzMax(10.) {}\r
+ AliEbyEFluctuationAnalysisTask(const char *name);\r
+ virtual ~AliEbyEFluctuationAnalysisTask() {}\r
+ \r
+ virtual void UserCreateOutputObjects();\r
+ virtual void UserExec(Option_t *option);\r
+ virtual void Terminate(Option_t *);\r
+ \r
+ void SetAnalysisCutObject(AliESDtrackCuts *const trackCuts) {\r
+ fESDtrackCuts = trackCuts;}\r
+ void SetVertexDiamond(Double_t vx, Double_t vy, Double_t vz) {\r
+ fVxMax = vx;\r
+ fVyMax = vy;\r
+ fVzMax = vz;\r
+ }\r
+ \r
+ //Centrality\r
+ void SetCentralityEstimator(const char* centralityEstimator) {\r
+ fCentralityEstimator = centralityEstimator;}\r
+ void SetCentralityBins20() {fCentralityBins20 = kTRUE;}\r
+\r
+ void SetAnalysisType(const char* analysisType) {\r
+ fAnalysisType = analysisType;}\r
+ void SetAnalysisMode(const char* analysisMode) {\r
+ fAnalysisMode = analysisMode;}\r
+\r
+ private:\r
+ AliESDEvent *fESD; //! ESD object\r
+ TList *fOutputList; //! Output list\r
+ TH1F *fHistEventStats; //!event stats\r
+ TH1F *fHistCentrality; //!centrality\r
+ TH1F *fHistNMult[nCentralityBins]; //! nmult\r
+ TH2F *fHistNPlusNMinus[nCentralityBins];//!nplus vs nminus correlation\r
+ TH1F *fHistNMultMC; //!nmult MC\r
+ TH2F *fHistNPlusNMinusMC;//!nplus vs nminus correlation\r
+\r
+ AliESDtrackCuts *fESDtrackCuts; //ESD track cuts\r
+\r
+ TString fAnalysisType;//"MC", "ESD", "AOD"\r
+ TString fAnalysisMode;//"TPC", "Global"\r
+\r
+ TString fCentralityEstimator;//"V0M","TRK","TKL","ZDC","FMD"\r
+ Bool_t fCentralityBins20;//centrality bins of 5% width\r
+\r
+ Double_t fVxMax;//vxmax\r
+ Double_t fVyMax;//vymax\r
+ Double_t fVzMax;//vzmax\r
+\r
+ AliEbyEFluctuationAnalysisTask(const AliEbyEFluctuationAnalysisTask&); // not implemented\r
+ AliEbyEFluctuationAnalysisTask& operator=(const AliEbyEFluctuationAnalysisTask&); // not implemented\r
+ \r
+ ClassDef(AliEbyEFluctuationAnalysisTask, 1); // example of analysis\r
+};\r
+\r
+#endif\r
//void runTaskFluctuations(Int_t mode = mPROOF, Int_t nRuns = 600000,
//Bool_t DATA = kTRUE, const Char_t* dataDir="/alice/data/LHC10h_000137161_p1_4plus#esdTree", Int_t offset=0) {
-//void runTaskFluctuations(Int_t mode = mLocal, Bool_t DATA = kTRUE) {
+void runTaskFluctuations(Int_t mode = mLocal, Bool_t DATA = kTRUE) {
//void runTaskFluctuations(Int_t mode = mGrid, Bool_t DATA = kTRUE) {
-//void runTaskFluctuations(Int_t mode = mGridPAR, Bool_t DATA = kTRUE) {
-void runTaskFluctuations(Int_t mode = mLocalPAR, Bool_t DATA = kTRUE) {
// Time:
TStopwatch timer;
timer.Start();
gROOT->LoadMacro("CreateAlienHandler.C");
AliAnalysisGrid *alienHandler = CreateAlienHandler();
if (!alienHandler) return;
- //gROOT->LoadMacro("AliEbyEFluctuationAnalysisTask.cxx++");
+ gROOT->LoadMacro("AliEbyEFluctuationAnalysisTask.cxx++");
}
// Chains:
if(mode==mLocal || mode == mLocalPAR) {
- //gROOT->LoadMacro("AliEbyEFluctuationAnalysisTask.cxx++");
- if (analysisType!="AOD") {
+ gROOT->LoadMacro("AliEbyEFluctuationAnalysisTask.cxx++");
+ if (analysisType=="ESD") {
TChain* chain = new TChain("esdTree");
- chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set1/AliESDs.root");
- chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set2/AliESDs.root");
- chain->Add("/home/pchrist/ALICE/HeavyIons/Data/137161/pass1_4plus/Set3/AliESDs.root");
+ chain->Add("/data/alice2/pchrist/HeavyIons/Data/Pass1_4Plus/Set1/AliESDs.root");
+ chain->Add("/data/alice2/pchrist/HeavyIons/Data/Pass1_4Plus/Set2/AliESDs.root");
+ chain->Add("/data/alice2/pchrist/HeavyIons/Data/Pass1_4Plus/Set3/AliESDs.root");
+ chain->Add("/data/alice2/pchrist/HeavyIons/Data/Pass1_4Plus/Set4/AliESDs.root");
+ chain->Add("/data/alice2/pchrist/HeavyIons/Data/Pass1_4Plus/Set5/AliESDs.root");
+ chain->Add("/data/alice2/pchrist/HeavyIons/Data/Pass1_4Plus/Set6/AliESDs.root");
+ chain->Add("/data/alice2/pchrist/HeavyIons/Data/Pass1_4Plus/Set7/AliESDs.root");
+ chain->Add("/data/alice2/pchrist/HeavyIons/Data/Pass1_4Plus/Set8/AliESDs.root");
+ chain->Add("/data/alice2/pchrist/HeavyIons/Data/Pass1_4Plus/Set9/AliESDs.root");
+ chain->Add("/data/alice2/pchrist/HeavyIons/Data/Pass1_4Plus/Set10/AliESDs.root");
}
- else
+ else if(analysisType == "MC") {
+ TChain *chain = new TChain("TE");
+ chain->AddFile("galice.root");
+ }
+ else
TChain* chain = CreateAODChain(dataDir, nRuns, offset);
}
//Proof
if(mode == mPROOF) {
gROOT->ProcessLine(Form(".include %s/include", gSystem->ExpandPathName("$ALICE_ROOT")));
- //gProof->Load("AliEbyEFluctuationAnalysisTask.cxx++");
+ gProof->Load("AliEbyEFluctuationAnalysisTask.cxx++");
}
// Create analysis manager:
} // end of if(analysisType == "AOD")
if(analysisType == "MC") {
AliVEventHandler* esdH = new AliESDInputHandler;
- mgr->SetInputEventHandler(esdH);
+ mgr->SetInputEventHandler(esdH);
AliMCEventHandler *mc = new AliMCEventHandler();
+ mc->SetReadTR(kFALSE);
mgr->SetMCtruthEventHandler(mc);
} // end of if(analysisType == "MC")
-
+
+ // Task to check the offline trigger:
+ //if(mode == mLocal || mode == mGrid || mode == mGridPAR)
+ if(analysisType != "MC") {
+ gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
+ AliPhysicsSelectionTask* physicsSelTask = AddTaskPhysicsSelection(!DATA);
+ if(!DATA){physicsSelTask->GetPhysicsSelection()->SetAnalyzeMC();}
+ // Enable debug printouts:
+ mgr->SetDebugLevel(2);
+
+ //Add the centrality determination task
+ gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C");
+ AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
+ //taskCentrality->SelectCollisionCandidates(AliVEvent::kMB);
+ }
+
// Load the analysis task:
gROOT->LoadMacro("AddTaskFluctuations.C");
AliEbyEFluctuationAnalysisTask* taskFA = AddTaskFluctuations(analysisType.Data(),
analysisMode.Data());
-
- // Task to check the offline trigger:
- //if(mode == mLocal || mode == mGrid || mode == mGridPAR)
- gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
- AliPhysicsSelectionTask* physicsSelTask = AddTaskPhysicsSelection();
- if(!DATA){physicsSelTask->GetPhysicsSelection()->SetAnalyzeMC();}
- // Enable debug printouts:
- mgr->SetDebugLevel(2);
-
- //Add the centrality determination task
- gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C");
- AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
- taskCentrality->SelectCollisionCandidates(AliVEvent::kMB);
// Run the analysis:
if(!mgr->InitAnalysis()){return;}
mgr->PrintStatus();
if(mode == mLocal || mode == mLocalPAR)
- //mgr->StartAnalysis("local",chain);
+ mgr->StartAnalysis("local",chain);
else if(mode == mPROOF)
mgr->StartAnalysis("proof",dataDir,nRuns,offset);
else if(mode == mGrid || mode == mGridPAR)
- //mgr->StartAnalysis("grid");
+ mgr->StartAnalysis("grid");
// Print real and CPU time used for analysis:
timer.Stop();
gSystem->Load("libAOD");
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
+ // Use AliRoot includes to compile our task
+ gROOT->ProcessLine(".include $ALICE_ROOT/include");
if(mode==mLocal || mode==mGrid)
gSystem->Load("libPWG2ebye");
if(mode==mGridPAR)
//--------------------------------------------------------
//If you want to use root and par files from aliroot
//--------------------------------------------------------
- gSystem->Load("libSTEERBase");
- gSystem->Load("libESD");
- gSystem->Load("libAOD");
- gSystem->Load("libANALYSIS");
- gSystem->Load("libANALYSISalice");
- //SetupPar("STEERBase");
- //SetupPar("ESD");
- //SetupPar("AOD");
- //SetupPar("ANALYSIS");
- //SetupPar("ANALYSISalice");
+ SetupPar("STEERBase");
+ SetupPar("ESD");
+ SetupPar("AOD");
+ SetupPar("ANALYSIS");
+ SetupPar("ANALYSISalice");
SetupPar("PWG2ebye");
}
//TProof::Open("prf000-iep-grid.saske.sk");
gProof->EnablePackage("VO_ALICE@AliRoot::v4-21-12-AN");
- gSystem->Load("libSTEERBase");
- gSystem->Load("libESD");
- gSystem->Load("libAOD");
- gSystem->Load("libANALYSIS");
- gSystem->Load("libANALYSISalice");
-
+
// Clear the Packages
//gProof->ClearPackage("STEERBase.par");
//gProof->ClearPackage("ESD.par");
//gProof->UploadPackage("ANALYSIS.par");
//gProof->UploadPackage("ANALYSISalice.par");
//gProof->UploadPackage("CORRFW.par");
- gProof->UploadPackage("PWG2ebye.par");
+ //gProof->UploadPackage("PWG2ebye");
// Enable the Packages
//gProof->EnablePackage("STEERBase");
//gProof->EnablePackage("AOD");
//gProof->EnablePackage("ANALYSIS");
//gProof->EnablePackage("ANALYSISalice");
- gProof->EnablePackage("PWG2ebye");
+ //gProof->EnablePackage("PWG2ebye");
// Show enables Packages
//gProof->ShowEnabledPackages();
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff