}
//________________________________________________________________________
-void AliEbyECFAnalysisTask::UserCreateOutputObjects()
-{
+void AliEbyECFAnalysisTask::UserCreateOutputObjects() {
+ //
fListPhy = new TList();
fEvtCounter = new TH1F("hEvtCounter","Event Statistic",50,0,50);
fListPhy->Add(fEvtCounter);
+
+
fListPhy->Add(dynamic_cast<AliEbyEEventBase*>(fEbyECFBase->GetEbyEEventBaseObject())->GetQA());
fListPhy->Add(fEbyECFBase->GetListCFQA());
fListPhy->Add(fEbyECFBase->GetListMeasureCF());
}
//________________________________________________________________________
-void AliEbyECFAnalysisTask::UserExec(Option_t *)
-{
-
+void AliEbyECFAnalysisTask::UserExec(Option_t *) {
+ //
fEvtCounter->Fill(0);
fECnt++;
//______________________________________________________________________//
void AliEbyECFAnalysisTask::Terminate(Option_t *) {
-
+ //
fListPhy = dynamic_cast<TList*> (GetOutputData(1));
if (!fListPhy) {
Error("Terminate","Out Put List not available");
TObject(),
fListCFQA(0),
fListMeasureCF(0),
- fEbyEBase(0)
+ fEbyEBase(0),
+ fhNpAverage(0),
+ fhNnAverage(0),
+ fhNCAverage(0),
+ fhNetAverage(0),
+ fhNnSNpAverage(0)
{
- InitHistos();
+ //InitHistos();
//Default constructor
}
if(fListCFQA) delete fListCFQA;
if(fListMeasureCF) delete fListMeasureCF;
+}
+//____________________________________________________________________//
+
+void AliEbyEChargeFluctuationAnalysis::ReadFromFile() {
+ //To read Average values from input histograms
+
+ TFile *file = TFile::Open("InputFluctuationAnalysis.root");
+ fhNpAverage = (TH1F*)file->Get("hNpAverage");
+ fhNnAverage = (TH1F*)file->Get("hNnAverage");
+ fhNCAverage = (TH1F*)file->Get("hNCAverage");
+ fhNetAverage = (TH1F*)file->Get("hNetAverage");
+ fhNnSNpAverage = (TH1F*)file->Get("hNnSNpAverage");
+
}
//____________________________________________________________________//
// Int_t kCentBin = fEbyEBase->GetCentralityBin();
Int_t kCentBin = 50;
-Int_t kMultBin = 2000;
+ Int_t kMultBin = 2000;
Double_t kMultMin = 0.0;
Double_t kMultMax = 2000;
-
+
TH2F *fhCentralityV0 = new TH2F("hCentralityV0", "Total Charge Fuctuation", kCentBin,0, (Double_t)kCentBin, 3000,0,30000);
fhCentralityV0->GetXaxis()->SetTitle(" #-");
fhCentralityV0->GetYaxis()->SetTitle("Frequency");
fListCFQA->Add(fhCentralityV0); // --:1
- TH2F *fNChargeFluc = new TH2F("hNChargeFluc", "Total Charge Fuctuation",kCentBin,0, (Double_t)kCentBin, kMultBin,kMultMin, kMultMax);
+ TH2F *fNChargeFluc = new TH2F("hNpCharge", "Possitive Charge",kCentBin,0, (Double_t)kCentBin, kMultBin,kMultMin, kMultMax);
fNChargeFluc->GetXaxis()->SetTitle(" #-");
fNChargeFluc->GetYaxis()->SetTitle("Frequency");
fListMeasureCF->Add(fNChargeFluc); // -->:0
- TH2F *fNpChargeFluc = new TH2F("hNpChargeFluc", "Possitive Charge Fuctuation",kCentBin,0, (Double_t)kCentBin, kMultBin,kMultMin, kMultMax);
+ TH2F *fNpChargeFluc = new TH2F("hNnCharge", "Negative Charge",kCentBin,0, (Double_t)kCentBin, kMultBin,kMultMin, kMultMax);
fNpChargeFluc->GetXaxis()->SetTitle(" #-");
fNpChargeFluc->GetYaxis()->SetTitle("Frequency");
fListMeasureCF->Add(fNpChargeFluc); // -->:1
- TH2F *fNnChargeFluc = new TH2F("hNnChargeFluc", "Negative Charge Fuctuation", kCentBin,0, (Double_t)kCentBin, kMultBin,kMultMin, kMultMax);
+ TH2F *fNnChargeFluc = new TH2F("hNCharge", "[ (+) + (-)]", kCentBin,0, (Double_t)kCentBin, kMultBin,kMultMin, kMultMax);
fNnChargeFluc->GetXaxis()->SetTitle(" #-");
fNnChargeFluc->GetYaxis()->SetTitle("Frequency");
fListMeasureCF->Add(fNpChargeFluc); // -->:2
- TH2F *fNnbpFluc = new TH2F("hNnbpFluc", "[-/+] Fuctuation",kCentBin,0, (Double_t)kCentBin, 100,0,10);
+ TH2F *fNnbpFluc = new TH2F("hNPmN", " [ (+) - (-)] ",kCentBin,0, (Double_t)kCentBin, 100,0,10);
fNnbpFluc->GetXaxis()->SetTitle(" #-");
fNnbpFluc->GetYaxis()->SetTitle("Frequency");
fListMeasureCF->Add(fNnbpFluc); // -->:3
- TH2F *fNpbnFluc = new TH2F("hNpbnFluc", "[+/-] Fuctuation",kCentBin,0, (Double_t)kCentBin, 100,0,10);
+ TH2F *fNpbnFluc = new TH2F("hNpByNpa", "[ +/<+> ] ",kCentBin,0, (Double_t)kCentBin, 100,0,10);
fNpbnFluc->GetXaxis()->SetTitle(" #-");
fNpbnFluc->GetYaxis()->SetTitle("Frequency");
fListMeasureCF->Add(fNpbnFluc); // -->:4
- TH2F *fNFluc = new TH2F("hNFluc", "N [(+/-) - (-/+)] Fuctuation",kCentBin,0, (Double_t)kCentBin,100,-5,5);
+ TH2F *fNFluc = new TH2F("hNnByNna", "[ -/<-> ]",kCentBin,0, (Double_t)kCentBin,100,-5,5);
fNFluc->GetXaxis()->SetTitle(" #-");
fNFluc->GetYaxis()->SetTitle("Frequency");
fListMeasureCF->Add(fNFluc); // -->:5
+
+ TH2F *fNFluc1 = new TH2F("hNpByPmNa", "[ +/<+ - -> ]",kCentBin,0, (Double_t)kCentBin,100,-5,5);
+ fNFluc1->GetXaxis()->SetTitle(" #-");
+ fNFluc1->GetYaxis()->SetTitle("Frequency");
+ fListMeasureCF->Add(fNFluc1); // -->:6
+
+
+ TH2F *fNFluc2 = new TH2F("hNnByPmNa", "[ -/<+ - -> ]",kCentBin,0, (Double_t)kCentBin,100,-5,5);
+ fNFluc2->GetXaxis()->SetTitle(" #-");
+ fNFluc2->GetYaxis()->SetTitle("Frequency");
+ fListMeasureCF->Add(fNFluc2); // -->:7
+
+ TH2F *fNFluc3 = new TH2F("hNpByPpNa", "[ +/<+ + -> ]",kCentBin,0, (Double_t)kCentBin,100,-5,5);
+ fNFluc3->GetXaxis()->SetTitle(" #-");
+ fNFluc3->GetYaxis()->SetTitle("Frequency");
+ fListMeasureCF->Add(fNFluc3); // -->:8
+
+ TH2F *fNFluc4 = new TH2F("hNnByPpNa", "[ -/<+ + -> ]",kCentBin,0, (Double_t)kCentBin,100,-5,5);
+ fNFluc4->GetXaxis()->SetTitle(" #-");
+ fNFluc4->GetYaxis()->SetTitle("Frequency");
+ fListMeasureCF->Add(fNFluc4); // -->:9
+
+ TH2F *fNFluc5 = new TH2F("hNpNnByNpNaa", "[ (+)(-)/<(-)(+)> ]",kCentBin,0, (Double_t)kCentBin,100,-5,5);
+ fNFluc5->GetXaxis()->SetTitle(" #-");
+ fNFluc5->GetYaxis()->SetTitle("Frequency");
+ fListMeasureCF->Add(fNFluc5); // -->:10
}
// Analysis from ESD
((TH1F*)(fListCFQA->At(0)))->Fill(1.);
- Int_t kCent = 1;
-
+ Int_t kCent = fEbyEBase->GetCentrality(esd);
+
+
TObjArray *array = new TObjArray();
Int_t itr = esd->GetNumberOfTracks();
+
+ // printf(" Centrality bin %d and Number of Good Track %d\n",itr,kCent);
+
for (Int_t iTracks = 0; iTracks < itr; iTracks++)
{
AliESDtrack* track = esd->GetTrack(iTracks);
if (!track) continue;
- array->Add(track);
+ if(fEbyEBase->IsInPhaseSpace(track))
+ array->Add(track);
}
Calculate(array,kCent);
//____________________________________________________________________________//
void AliEbyEChargeFluctuationAnalysis::Calculate(TObjArray *gTrackArray, Int_t cent){
- Int_t i = 0;
+
+ ((TH1F*)(fListCFQA->At(0)))->Fill(1,1);
+ if(cent < 0) return;
+ ((TH1F*)(fListCFQA->At(0)))->Fill(10,1);
+
+ Int_t gNtrack = gTrackArray->GetEntries();
+ if(gNtrack < 1) return;
+
+ ((TH1F*)(fListCFQA->At(0)))->Fill(20,1);
+
AliVParticle* track = 0;
Int_t pCharge = 0;
Int_t nCharge = 0;
- Int_t gNtrack = gTrackArray->GetEntries();
+
+
TString gAnalysisLevel = fEbyEBase->GetAnalysisLevel();
- Double_t par[6] = {0.0};
+ Double_t par[16];
+ for(Int_t i = 0; i < 8; i++) par[i] = 0.0;
+ Double_t pr[5];
+ for(Int_t i = 0; i < 5; i++) pr[i] = 0.0;
- for(i = 0; i < gNtrack; i++) {
+
+
+ for(Int_t i = 0; i < gNtrack; i++) {
if(gAnalysisLevel == "ESD")
track = dynamic_cast<AliESDtrack*>(gTrackArray->At(i));
- else if(gAnalysisLevel == "AOD")
- track = dynamic_cast<AliAODTrack *>(gTrackArray->At(i));
- else if(gAnalysisLevel == "MC")
- track = dynamic_cast<AliMCParticle *>(gTrackArray->At(i));
Short_t charge = track->Charge();
- if(charge > 0) pCharge += 1;
- if(charge < 0) nCharge += 1;
+ if(charge > 0) {
+ pCharge += 1;
+ ((TH1F*)(fListCFQA->At(3)))->Fill(cent,1);
+ ((TH1F*)(fListCFQA->At(5)))->Fill(cent,1);
+ }
+ if(charge < 0) {
+ nCharge += 1;
+ ((TH1F*)(fListCFQA->At(4)))->Fill(cent,1);
+ ((TH1F*)(fListCFQA->At(5)))->Fill(cent,1);
+ }
}
+ ((TH1F*)(fListCFQA->At(0)))->Fill(131+cent,pCharge);
+ ((TH1F*)(fListCFQA->At(0)))->Fill(5,nCharge);
+ ((TH1F*)(fListCFQA->At(0)))->Fill(6,pCharge+nCharge);
+ ((TH2F*)(fListCFQA->At(1)))->Fill(cent,pCharge+nCharge);
+
+ pr[0] = fhNpAverage->GetBinContent(cent+1);
+ pr[1] = fhNnAverage->GetBinContent(cent+1);
+ pr[2] = fhNCAverage->GetBinContent(cent+1);
+ pr[3] = fhNetAverage->GetBinContent(cent+1);
+ pr[4] = fhNnSNpAverage->GetBinContent(cent+1);
+
+
par[0] = (Double_t)pCharge;
par[1] = (Double_t)nCharge;
par[2] = (Double_t)pCharge + (Double_t)nCharge;
+ par[3] = (Double_t)pCharge - (Double_t)nCharge;
+ par[4] = (Double_t)pCharge*((Double_t)pCharge - 1);
+ par[5] = (Double_t)nCharge*((Double_t)nCharge - 1);
+ par[6] = (Double_t)pCharge*(Double_t)nCharge;
+
+ if(pr[0] != 0) par[7] = par[0]/pr[0]; // +/<+>
+ if(pr[1] != 0) par[8] = par[0]/pr[1]; // -/<->
+ if(pr[2] != 0) par[9] = par[0]/pr[2]; // ++-/<++->
+ if(pr[2] != 0) par[10] = par[0]/pr[2]; // +--/<++->
+ if(pr[3] != 0) par[11] = par[0]/pr[3]; // ++-/<+-->
+ if(pr[3] != 0) par[12] = par[0]/pr[3]; // +--/<+-->
+ if(pr[4] != 0) par[13] = par[0]/pr[4]; //+*-/<+*->
- if(pCharge != 0 ) par[3] = (Double_t)pCharge/(Double_t)nCharge;
- if(nCharge != 0 ) par[4] = (Double_t)nCharge/(Double_t)pCharge;
-
- par[5] = (Double_t)pCharge - (Double_t)nCharge;
-
- ((TH2F*)(fListMeasureCF->At(0)))->Fill(cent, par[2]);
- ((TH2F*)(fListMeasureCF->At(1)))->Fill(cent, par[0]);
- ((TH2F*)(fListMeasureCF->At(2)))->Fill(cent, par[1]);
- ((TH2F*)(fListMeasureCF->At(3)))->Fill(cent, par[4]);
- ((TH2F*)(fListMeasureCF->At(4)))->Fill(cent, par[3]);
- ((TH2F*)(fListMeasureCF->At(5)))->Fill(cent, par[5]);
+ par[14] = (par[7] + par[8])*(par[7] + par[8]); // eqn - 1
+ // par[15] = (par[4]/pr[0]*[pr[0] + par[8])*(par[7] + par[8]); // eqn - 1
+
+ Float_t value = 0;
+ if( pr[0] != 0 || pr[1] != 0)
+ value = par[0]/pr[0] + par[1]/pr[1];
+
+ printf("Centrality: %2d NTrack: %8d +ve : %8d -ve : %8d %10.6f %10.6f %10.6f\n",cent, gNtrack, pCharge, nCharge, pr[0], pr[1],value);
+
+
+ ((TH2F*)(fListMeasureCF->At(0)))->Fill(cent, par[0]); //+
+ ((TH2F*)(fListMeasureCF->At(1)))->Fill(cent, par[1]); //-
+ ((TH2F*)(fListMeasureCF->At(2)))->Fill(cent, par[2]); //++-
+ ((TH2F*)(fListMeasureCF->At(3)))->Fill(cent, par[3]); //+--
+ ((TH2F*)(fListMeasureCF->At(4)))->Fill(cent, par[4]); //+/-
+ ((TH2F*)(fListMeasureCF->At(5)))->Fill(cent, value); //-/+
+ ((TH2F*)(fListMeasureCF->At(6)))->Fill(cent, value*value); //+/-
+ ((TH2F*)(fListMeasureCF->At(7)))->Fill(cent, par[7]);
+ ((TH2F*)(fListMeasureCF->At(8)))->Fill(pCharge,nCharge);
+ ((TH3F*)(fListMeasureCF->At(9)))->Fill(cent, pCharge,nCharge);
+
}
AliEbyEChargeFluctuationAnalysis();
virtual ~AliEbyEChargeFluctuationAnalysis();
-
+
void SetBaseAnalysis(AliEbyEEventBase * const baseAnalysis) {
fEbyEBase = baseAnalysis;}
AliEbyEEventBase *GetEbyEEventBaseObject() const {
return fEbyEBase;}
-
+
void InitHistos();
void Analyze(AliESDEvent *esd);
void Calculate(TObjArray *gTrackArray, Int_t cent);
TList *GetListCFQA() const {return fListCFQA;}
TList *GetListMeasureCF() const {return fListMeasureCF;}
-
+
+ void ReadFromFile();
private:
-TList *fListCFQA; //! Global list
-TList *fListMeasureCF; //! List Of Mesures for Multiplisity Fluctuation
-AliEbyEEventBase *fEbyEBase;//EbyE Events base
-
-AliEbyEChargeFluctuationAnalysis(const AliEbyEChargeFluctuationAnalysis&); //! Not implemented
-AliEbyEChargeFluctuationAnalysis& operator=(const AliEbyEChargeFluctuationAnalysis&); //! Not implemented
+
+ TList *fListCFQA; //! Global list
+ TList *fListMeasureCF; //! List Of Mesures for Multiplisity Fluctuation
+ AliEbyEEventBase *fEbyEBase;//! EbyE Events base
+
+ TH1F *fhNpAverage;
+ TH1F *fhNnAverage;
+ TH1F *fhNCAverage;
+ TH1F *fhNetAverage;
+ TH1F *fhNnSNpAverage;
-ClassDef(AliEbyEChargeFluctuationAnalysis,1);
+
+ AliEbyEChargeFluctuationAnalysis(const AliEbyEChargeFluctuationAnalysis&); //! Not implemented
+ AliEbyEChargeFluctuationAnalysis& operator=(const AliEbyEChargeFluctuationAnalysis&); //! Not implemented
+
+ ClassDef(AliEbyEChargeFluctuationAnalysis,1);
};
#endif
#include <AliTPCPIDResponse.h>
#include <AliAODTrack.h>
#include <AliMCParticle.h>
-#include <AliESDCentrality.h>
-#include <AliCentralitySelectionTask.h>
+
#include <AliESDVZERO.h>
class AliLog;
class AliESDVertex;
fVzMax(20.),
fCentralityType(kFlat),
fCentralityBin(50),
- fCentralityEstimator("V0M"),
- fCentralityPointer(0),
- fFile1(""),
- fFile2("") {
+ fCentralityEstimator("V0M")
+{
+
+ printf(" AliEbyEEventBase ========== \n");
//Default constructor
+ InitQA();
+}
+
+//____________________________________________________________________//
+AliEbyEEventBase::~AliEbyEEventBase() {
+ //Destructor
+ if(fListQA) delete fListQA;
+
+}
+//____________________________________________________________________//
+void AliEbyEEventBase::InitQA() {
+ //Initialize QA objects
fListQA = new TList();
fListQA->SetName("fListQA");
TH1F *gHistVx = new TH1F("gHistVx",
"Vx distribution;V_{x} [cm];Entries",
- 100,-5.,5.);
+ 500,-5.,5.);
gHistVx->SetFillColor(kRed-2);
fListQA->Add(gHistVx);//0
TH1F *gHistVxAccepted = new TH1F("gHistVxaccepted",
"Vx distribution;V_{x} [cm];Entries",
- 100,-5.,5.);
+ 500,-2.5,2.5);
fListQA->Add(gHistVxAccepted); //1
TH1F *gHistVy = new TH1F("gHistVy",
"Vy distribution;V_{y} [cm];Entries",
- 100,-5.,5.);
+ 500,-5.,5.);
gHistVy->SetFillColor(kRed-2);
fListQA->Add(gHistVy);//2
TH1F *gHistVyAccepted = new TH1F("gHistVyaccepted",
"Vy distribution;V_{y} [cm];Entries",
- 100,-5.,5.);
+ 200,-5.,5.);
fListQA->Add(gHistVyAccepted);//3
TH1F *gHistVz = new TH1F("gHistVz",
"Vz distribution;V_{z} [cm];Entries",
- 100,-25.,25.);
+ 500,-25.,25.);
gHistVz->SetFillColor(kRed-2);
fListQA->Add(gHistVz);//4
TH1F *gHistVzAccepted = new TH1F("gHistVzaccepted",
"Vz distribution;V_{z} [cm];Entries",
- 100,-25.,25.);
+ 500,-25.,25.);
fListQA->Add(gHistVzAccepted);//5
fListQA->Add(hCentralityQA);//6
}
+
+
//____________________________________________________________________//
-AliEbyEEventBase::~AliEbyEEventBase() {
- if(fListQA) delete fListQA;
+Bool_t AliEbyEEventBase::IsInPhaseSpace(AliESDtrack* const track) {
+ //Check if particle is in phase space
+ Double_t gDca = 0.0, gPt = 0.0, gNclus = 0.0, gChi = 0.0;
+ Double_t eta = 0.0;
+
+ if((fAnalysisMode == kTPC) || (fAnalysisMode == kTPCnITS) ) {
+ AliExternalTrackParam *tpcTrack = (AliExternalTrackParam *)track->GetTPCInnerParam();
+ if(!tpcTrack) {
+ gDca = 0.0; gPt = 0.0; gNclus = 0.0; gChi = 0.0; eta = -10.0;
+ }
+ else {
+ // gDca = tpcTrack->GetDCA();
+ gPt = tpcTrack->Pt();
+ gNclus = tpcTrack->GetTPCNcls();
+ gChi = track->GetTPCchi2()/gNclus;
+ eta = tpcTrack->Eta();
+ }
+ }//standalone TPC
+
+ // eta, ptmin, ptmax, dcaxyz, TPC clusters, kisquare/clustertpc
+
+ if( TMath::Abs(eta) > fNBinsX ) {
+ return kFALSE;
+ }
+
+ if( gPt < fMinX || gPt > fMaxX) {
+ return kFALSE;
+ }
+
+ /* if(TMath::Abs(gDca) > fNBinsY ){
+ return kFALSE;
+ }
+ */
+ if(gNclus < fMaxY) {
+ return kFALSE;
+ }
+
+ if(gChi > fMinY) {
+ return kFALSE;
+ }
+
+
+
+ return kTRUE;
}
//____________________________________________________________________//
//____________________________________________________________________//
Int_t AliEbyEEventBase::GetCentrality(AliESDEvent *esd) const {
//Get the centrality
- AliESDCentrality *centrality = esd->GetCentrality();
+ // AliCentrality *centrality = esd->GetCentrality();
Int_t cent = -1;
-
- if(fCentralityType == kHardFlat) {
+
+ if(fCentralityType == AliEbyEEventBase::kHardFlat) {
AliESDVZERO* esdV0 = esd->GetVZEROData();
Double_t mult = esdV0->GetMTotV0A() + esdV0->GetMTotV0C();
((TH2F *)(fListQA->At(6)))->Fill(50,mult);
- if(fAnalysisLevel == "ESD") cent = FindCentralityESD(mult);
+ if(fAnalysisLevel == "ESD") cent = FindCentralityESD10(mult);
if(fAnalysisLevel == "MC") cent = FindCentralityMC(mult);
if(cent > -1) ((TH2F *)(fListQA->At(6)))->Fill(cent,mult);
+
return cent;
}
- if(fCentralityType == kHardAcc) {
+ if(fCentralityType == AliEbyEEventBase::kHardAcc) {
AliESDVZERO* esdV0 = esd->GetVZEROData();
Double_t mult = esdV0->GetMTotV0A() + esdV0->GetMTotV0C();
((TH2F *)(fListQA->At(6)))->Fill(50,mult);
- if(fAnalysisLevel == "ESD") cent = FindCentralityESD(mult);
+ if(fAnalysisLevel == "ESD") cent = FindCentralityESD10(mult);
if(fAnalysisLevel == "MC") cent = FindCentralityMC(mult);
if(cent > -1) ((TH2F *)(fListQA->At(6)))->Fill(cent,mult);
return cent;
}
- if(fCentralityType == kAll) {
+
+ /*
+ if(fCentralityType == AliEbyEEventBase::kAll) {
if(centrality->IsEventInCentralityClass(0,100,fCentralityEstimator)) return 0;
}
- if(fCentralityType == kFlat) {
+ if(fCentralityType ==AliEbyEEventBase::kFlat) {
for(int i = 0; i < 50; i++) {
- if(centrality->IsEventInCentralityClass(i*2,i*2+2,fCentralityEstimator)) {
- cent = i;
- break;
- }
+ if(centrality->IsEventInCentralityClass(i*2,i*2+2,fCentralityEstimator)) {
+ cent = i;
+ break;
+ }
}
}
- if(fCentralityType == kAcc) {
+ if(fCentralityType == AliEbyEEventBase::kAcc) {
for(int i = 0; i < 50; i++) {
if(centrality->IsEventInCentralityClass(0,i*2+2,fCentralityEstimator)) {
cent = i;
}
}
+ */
+ printf("on to %d p\n",cent);
return cent;
}
80.0, 80.0, 70.0, 70.0, 70.0 };
- if(fCentralityType == kHardFlat) {
+ if(fCentralityType == AliEbyEEventBase::kHardFlat) {
for(Int_t i = 0; i < 100; i+=2) {
if( (mult < data[i]) && (mult >= data[i+2]) )
return i/2;
}
}
- if(fCentralityType == kHardAcc) {
+ if(fCentralityType == AliEbyEEventBase::kHardAcc) {
for(int i = 0; i < 100; i+=2) {
if((mult < data[0]) && (mult >data[i+2]) ) {
return i/2;
//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(fCentralityType == kHardFlat) {
+ 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(fCentralityType == AliEbyEEventBase::kHardFlat) {
for(Int_t i = 0; i < 100; i+=2) {
if( (mult < data[i]) && (mult >= data[i+2]) )
return i/2;
}
}
- if(fCentralityType == kHardAcc) {
+ if(fCentralityType == AliEbyEEventBase::kHardAcc) {
for(int i = 0; i < 100; i+=2) {
if((mult < data[0]) && (mult >= data[i+2]) ) {
return i/2;
return -3;
}
+
+//____________________________________________________________________//
+Int_t AliEbyEEventBase::FindCentralityESD5(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(fCentralityType == AliEbyEEventBase::kHardFlat) {
+ for(Int_t i = 0; i < 100; i+=5) {
+
+ if( (mult < data[i]) && (mult >= data[i+5]) )
+ return i/5;
+ }
+ }
+ if(fCentralityType == AliEbyEEventBase::kHardAcc) {
+ for(int i = 0; i < 100; i+=5) {
+ if((mult < data[0]) && (mult >data[i+5]) ) {
+ return i/5;
+ }
+ }
+ }
+
+return -2;
+
+
+}
+
+
+//____________________________________________________________________//
+Int_t AliEbyEEventBase::FindCentralityESD10(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(fCentralityType == AliEbyEEventBase::kHardFlat) {
+ for(Int_t i = 0; i < 100; i+=10) {
+
+ if( (mult < data[i]) && (mult >= data[i+10]) )
+ return i/10;
+ }
+ }
+ if(fCentralityType == AliEbyEEventBase::kHardAcc) {
+ for(int i = 0; i < 100; i+=10) {
+ if((mult < data[0]) && (mult >data[i+10]) ) {
+ return i/10;
+ }
+ }
+ }
+
+return -2;
+
+
+}
#include "AliPhysicsSelection.h"
#include "AliBackgroundSelection.h"
#include "AliPID.h"
-#include "AliESDCentrality.h"
-#include "AliCentralitySelectionTask.h"
+
class AliESDEvent;
class AliESDtrack;
class AliESDVertex;
class AliEbyEEventBase : public TObject {
public:
- enum TriggerMode { kMB1 = 0, kMB2, kSPDFASTOR };
+
enum AnalysisMode { kInvalid = -1, kTPC = 0, kITS, kTPCnITS, kForward, kGlobal };
+ // Global all: TPC: TPC standalone: ITC its only: TPCnITC both tpc and its: Forward Forward det
+
enum CentralityType { kHardFlat = 0, kHardAcc, kAll, kFlat, kAcc};
- //____________________________________________________________________________//
+
+ //kHard : own calculation
+ //All : centrality frame work
+ //Flat:: one centrality by hand
+
+
AliEbyEEventBase();
virtual ~AliEbyEEventBase();
- //____________________________________________________________________________//
- void SetAnalysisLevel(const char* type) {fAnalysisLevel = type; }
+ void InitQA();
+
+ void SetAnalysisLevel(const char* type) {fAnalysisLevel = type; }
const char *GetAnalysisLevel() {return fAnalysisLevel.Data(); }
void SetAnalysisMode(AnalysisMode analysismode) {fAnalysisMode = analysismode;}
AnalysisMode GetAnalysisMode() const {return fAnalysisMode;}
void SetDebugMode() {fDebugMode = kTRUE;}
- //____________________________________________________________________________//
- /* void OfflineTriggerInit() {
- kUseOfflineTrigger = kTRUE;
- fPhySel = new AliPhysicsSelection();
- fPhySel->AddBackgroundIdentification(new AliBackgroundSelection());
- fPhySel->SetAnalyzeMC(fAnalysisMC);
- }
-
- Bool_t IsOfflineTriggerUsed() {return kUseOfflineTrigger;}
- AliPhysicsSelection *GetPhysicsSelectionObject() {return fPhySel;}*/
- //____________________________________________________________________________//
-
+
void SetPhaseSpace(Int_t nBinsX, Double_t gXmin, Double_t gXmax,
Int_t nBinsY, Double_t gYmin, Double_t gYmax) {
fNBinsX = nBinsX; fMinX = gXmin; fMaxX = gXmax;
Double_t GetMaxX() const {return fMaxX;}
Double_t GetMaxY() const {return fMaxY;}
- // Bool_t IsInPhaseSpace(AliESDtrack *track);
-
- //____________________________________________________________________________//
+ Bool_t IsInPhaseSpace(AliESDtrack *track);
const AliESDVertex *GetVertex(AliESDEvent *esd,
AnalysisMode mode,
Double_t GetVxMax() const {return fVxMax;}
Double_t GetVyMax() const {return fVyMax;}
Double_t GetVzMax() const {return fVzMax;}
- //____________________________________________________________________________//
-
+
TList *GetQA() {return fListQA;}
- //____________________________________________________________________________//
-
+
void SetCentralityType(CentralityType centralitytype) {fCentralityType = centralitytype;}
+
CentralityType GetCentralityType() const {return fCentralityType;}
- void SetCentralityBin(Int_t cBin) { fCentralityBin = cBin;}
Int_t GetCentrality(AliESDEvent *esd) const;
+
void SetCentralityEstimator(const char *estimator) { fCentralityEstimator = estimator;}
const char *GetCentralityEstimator() {return fCentralityEstimator.Data();}
+
+ void SetCentralityBin(Int_t cBin) { fCentralityBin = cBin;}
const Int_t GetCentralityBin() {return fCentralityBin;}
- void SetCentralityInputFiles(const char * file1, const char * file2) { fFile1 = file1; fFile2 = file2;
- fCentralityPointer->SetPercentileFile(fFile1);
- fCentralityPointer->SetPercentileFile2(fFile2);
- }
- AliCentralitySelectionTask *GetCentralityObject() {return fCentralityPointer;}
+
Int_t FindCentralityESD(Double_t mult) const;
+ Int_t FindCentralityESD5(Double_t mult) const;
+ Int_t FindCentralityESD10(Double_t mult) const;
Int_t FindCentralityMC(Double_t mult) const;
- //____________________________________________________________________________//
+
+
private:
TString fAnalysisLevel; //! ESD or AOD or MC
CentralityType fCentralityType; //! All | EquiDivision | Accumulated |
Int_t fCentralityBin; //! Centrality Bin
TString fCentralityEstimator; //! Centrality Estimator
- AliCentralitySelectionTask *fCentralityPointer;
- TString fFile1; //! file used by centrality task. Set here for bookkeeping
- TString fFile2; //! file used by centrality task. Set here for bookkeeping
+
//____________________________________________________________________________//
AliEbyEEventBase(const AliEbyEEventBase&); // Not implemented
AliEbyEEventBase& operator=(const AliEbyEEventBase&); // Not implemented
--- /dev/null
+
+/**************************************************************************
+ * 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. *
+ **************************************************************************/
+
+/*-------------------------------------------------------------------------
+ *
+ * AliEbyEFluctuationAnalysis base class
+ * This class deals with the Multiplicity fluctuation
+ * Origin: Satyajit Jena <sjena@cern.ch>
+ *
+ ------------------------------------------------------------------------*/
+
+#include <Riostream.h>
+#include <TFile.h>
+#include <TSystem.h>
+#include "TH1F.h"
+#include "TH2F.h"
+#include <TH3I.h>
+
+#include <TParticle.h>
+#include <TList.h>
+
+#include <AliExternalTrackParam.h>
+#include <AliAODEvent.h>
+#include <AliESDEvent.h>
+#include <AliESDtrack.h>
+#include <AliAODTrack.h>
+#include <AliMCParticle.h>
+#include <AliPID.h>
+#include <AliStack.h>
+#include <AliCFContainer.h>
+#include <AliCFEffGrid.h>
+#include <AliCFDataGrid.h>
+#include <AliTPCPIDResponse.h>
+#include <AliESDpid.h>
+
+#include "AliESDtrackCuts.h"
+#include "AliEbyEEventBase.h"
+#include "AliEbyEFluctuationAnalysis.h"
+
+ClassImp(AliEbyEFluctuationAnalysis)
+
+//____________________________________________________________________//
+AliEbyEFluctuationAnalysis::AliEbyEFluctuationAnalysis() :
+ TObject(),
+ fListMeasure(0),
+ fEbyEBase(0),
+ fESDtrackCuts(0)
+{
+ //Default constructor
+ InitHistos();
+}
+
+//____________________________________________________________________//
+AliEbyEFluctuationAnalysis::~AliEbyEFluctuationAnalysis() {
+ //Default destructor
+ if(fListMeasure) delete fListMeasure;
+ if(fEbyEBase) delete fEbyEBase;
+ if(fESDtrackCuts) delete fESDtrackCuts;
+}
+
+//____________________________________________________________________//
+void AliEbyEFluctuationAnalysis::InitHistos() {
+ fListMeasure = new TList();
+ fListMeasure->SetName("MeasuresList");
+ Int_t cent = 50;
+
+ // cent = fEbyEBase->GetCentralityBin();
+
+ TH1F *fEvtStat = new TH1F("hEventStatistuc","Analysis Event Counter", 10,0,10);
+ fListMeasure->Add(fEvtStat); //
+
+ TH2F *fCvsM = new TH2F("hCentralityVsMultiplisity", "Correlation Plots; Centrality; Multiplicity",
+ 6000,0,6000,cent,0,(Double_t)cent);
+ fListMeasure->Add(fCvsM); // Correlation Histo centrality and Multiplicity
+
+ TH2F *fCharge[cent];
+
+ char hname[40]; char htitle[100];
+ Int_t binm = 100/cent;
+
+ for(Int_t i = 0; i < cent; i++ ) { // Preparing Histograms for Each Centrality Bin
+
+ sprintf(hname,"hNPinCent%02d",i);
+ sprintf(htitle,"N_{+} vs N_{-} in Centrality %02d%% - %02d%%; N_{+}; N_{-}\n",i*binm, (i+1)*binm);
+
+ fCharge[i] = new TH2F(hname,htitle,3000,0.5,3000.5,3000,0.5,3000.5);
+ fListMeasure->Add(fCharge[i]);
+ }
+
+
+}
+
+
+//____________________________________________________________________//
+void AliEbyEFluctuationAnalysis::Analyze(AliESDEvent* esd) {
+
+ // Analysis from ESD
+ ((TH1F*)(fListMeasure->At(0)))->Fill(1);
+
+ Int_t kCent = 1;
+ kCent = fEbyEBase->GetCentrality(esd);
+
+ TObjArray *array = new TObjArray();
+ Int_t itr = esd->GetNumberOfTracks();
+
+ for (Int_t iTracks = 0; iTracks < itr; iTracks++)
+ {
+ AliESDtrack* track = esd->GetTrack(iTracks);
+ if (!track) continue;
+ if(!fESDtrackCuts->AcceptTrack(track)) continue;
+ array->Add(track);
+ }
+
+ Calculate(array,kCent);
+
+ delete array;
+}
+
+
+//____________________________________________________________________//
+void AliEbyEFluctuationAnalysis::Analyze(AliAODEvent* aod) {
+ // Analysis from AOD
+
+ printf("%d\n",aod->GetNTracks());
+
+
+}
+
+
+//____________________________________________________________________//
+void AliEbyEFluctuationAnalysis::Analyze(AliStack* stack) {
+ // Analysis from MC stack
+
+
+ printf("%d \n",stack->GetNtrack());
+
+}
+
+//____________________________________________________________________________//
+void AliEbyEFluctuationAnalysis::Calculate(TObjArray *gTrackArray, Int_t cent){
+
+ ((TH1F*)(fListMeasure->At(0)))->Fill(1,1);
+ if(cent < 0) return;
+ ((TH1F*)(fListMeasure->At(0)))->Fill(2,1);
+ Int_t gNtrack = gTrackArray->GetEntries();
+ if(gNtrack < 1) return;
+ ((TH1F*)(fListMeasure->At(0)))->Fill(3,1);
+
+ AliVParticle* track = 0;
+ Int_t pCharge = 0;
+ Int_t nCharge = 0;
+ ((TH1F*)(fListMeasure->At(1)))->Fill(3,1);
+
+ TString gAnalysisLevel = fEbyEBase->GetAnalysisLevel();
+ for(Int_t i = 0; i < gNtrack; i++) {
+ if(gAnalysisLevel == "ESD")
+ track = dynamic_cast<AliESDtrack*>(gTrackArray->At(i));
+ Short_t charge = track->Charge();
+ if(charge > 0) pCharge += 1;
+ if(charge < 0) nCharge += 1;
+ }
+
+ ((TH2F*)(fListMeasure->At(2)))->Fill(cent,pCharge, nCharge); //+ vs -
+
+
+}
--- /dev/null
+/**************************************************************************
+ * 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$ */
+
+
+#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 "AliAnalysisManager.h"
+#include "AliStack.h"
+#include "AliESDtrackCuts.h"
+#include "AliESDEvent.h"
+#include "AliESDInputHandler.h"
+#include "AliAODEvent.h"
+#include "AliMCEvent.h"
+#include "AliMultiplicity.h"
+#include "AliEbyEFluctuationAnalysis.h"
+#include "AliEbyEEventBase.h"
+
+#include "AliEbyEFluctuationTask.h"
+
+ClassImp(AliEbyEFluctuationTask)
+
+//________________________________________________________________________
+AliEbyEFluctuationTask::AliEbyEFluctuationTask()
+:AliAnalysisTaskSE(),
+ fListPhy(0),
+ fEbyEMFBase(0),
+ fEvtCounter(0),
+ fECnt(0)
+{
+ // Dummy constructor ALWAYS needed for I/O.
+}
+
+//________________________________________________________________________
+AliEbyEFluctuationTask::AliEbyEFluctuationTask(const char *name)
+ :AliAnalysisTaskSE(name),
+ fListPhy(0),
+ fEbyEMFBase(0),
+ fEvtCounter(0),
+ fECnt(0)
+{
+
+ DefineOutput(1, TList::Class());
+}
+
+//________________________________________________________________________
+AliEbyEFluctuationTask::~AliEbyEFluctuationTask()
+{
+
+ if (fListPhy && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
+ delete fListPhy;
+ }
+}
+
+//________________________________________________________________________
+void AliEbyEFluctuationTask::UserCreateOutputObjects()
+{
+
+ fListPhy = new TList();
+ fListPhy->SetOwner();
+ fEvtCounter = new TH1F("hEvtCounter","Event Statistic",50,0,50);
+ fListPhy->Add(fEvtCounter);
+
+ fListPhy->Add(dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetQA());
+ fListPhy->Add(fEbyEMFBase->GetListMeasure());
+
+ PostData(1, fListPhy);
+}
+
+//________________________________________________________________________
+void AliEbyEFluctuationTask::UserExec(Option_t *)
+{
+
+ fEvtCounter->Fill(0);
+ fECnt++;
+
+ TString gAnalType = dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetAnalysisLevel();
+
+ if(gAnalType == "ESD")
+ {
+ AliESDEvent* gESD = dynamic_cast<AliESDEvent*>(InputEvent());
+ if (!gESD) {
+ Printf("ERROR: gESD not available");
+ return;
+ }
+ const AliESDVertex *vertex = dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetVertex(gESD,dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetAnalysisMode(),dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetVxMax(),dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetVyMax(),dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetVzMax());
+ if(vertex){
+
+
+ fEbyEMFBase->Analyze(gESD);
+ }
+
+ }
+
+}
+
+
+//________________________________________________________________________
+void AliEbyEFluctuationTask::Terminate(Option_t *)
+{
+ // Draw result to screen, or perform fitting, normalizations
+ // Called once at the end of the query
+
+ fListPhy = dynamic_cast<TList*> (GetOutputData(1));
+ if(!fListPhy) { Printf("ERROR: could not retrieve TList fOutput"); return; }
+
+
+}
* AliEbyEMFAnalysisTask Class
* This class deals with runing Multiplicity Fluctuation Task
* origin: Satyajit Jena <sjena@cern.ch>
- * MF: Multiplicity Fluctuation
+ * MF: Multiplicity Fluctuation
*------------------------------------------------------------------------*/
+
#include "TChain.h"
#include "TString.h"
#include "TList.h"
#include "AliESD.h"
#include "AliESDEvent.h"
#include "AliAODEvent.h"
-#include "AliEbyEEventBase.h"
+
#include "AliEbyEMultiplicityFluctuationAnalysis.h"
#include "AliEbyEMFAnalysisTask.h"
+#include "AliEbyEEventBase.h"
ClassImp(AliEbyEMFAnalysisTask)
fEbyEMFBase(0),
fEvtCounter(0),
fECnt(0)
-
+
{
// DefineInput(0, TChain::Class());
DefineOutput(1, TList::Class());
fEvtCounter = new TH1F("hEvtCounter","Event Statistic",50,0,50);
fListPhy->Add(fEvtCounter);
- fListPhy->Add(dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetQA());
+
+ // fListPhy->Add(dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetQA());
fListPhy->Add(fEbyEMFBase->GetListMFQA());
fListPhy->Add(fEbyEMFBase->GetListMeasureMF());
Printf("ERROR: gESD not available");
return;
}
-
const AliESDVertex *vertex = dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetVertex(gESD,dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetAnalysisMode(),dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetVxMax(),dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetVyMax(),dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetVzMax());
-
if(vertex){
-
+
+
fEbyEMFBase->Analyze(gESD);
-
}
}
- PostData(1, fListPhy);
+
}
return;
}
- Info("AliEbyEMFAnalysisTask"," AliEbyEMFAnalysisTask Successfully finished");
+ Info("AliEbyEMFAnalysisTask","Multiplicity Fluctuation Job Successfully finished");
}
* \r
*------------------------------------------------------------------------*/\r
\r
-\r
class TString;\r
class TH1F;\r
class TH2F;\r
\r
#include "AliAnalysisTaskSE.h"\r
\r
-class AliEbyEEventBase;\r
+//class AliEbyEEventBase;\r
class AliEbyEMultiplicityFluctuationAnalysis;\r
\r
class AliEbyEMFAnalysisTask: public AliAnalysisTaskSE {\r
\r
void SetAnalysisObject(AliEbyEMultiplicityFluctuationAnalysis *const analysis) { fEbyEMFBase = analysis;}\r
\r
+ \r
+\r
private:\r
\r
TList *fListPhy;\r
AliEbyEMultiplicityFluctuationAnalysis *fEbyEMFBase;\r
TH1F *fEvtCounter;\r
Int_t fECnt;\r
- \r
+ \r
AliEbyEMFAnalysisTask(const AliEbyEMFAnalysisTask&); \r
AliEbyEMFAnalysisTask& operator=(const AliEbyEMFAnalysisTask&); \r
\r
--- /dev/null
+/**************************************************************************
+ * 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$ */
+
+#include "AliEbyEMFAnalysisTaskT.h"
+#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 "AliAnalysisManager.h"
+#include "AliStack.h"
+#include "AliESDtrackCuts.h"
+#include "AliESDEvent.h"
+#include "AliESDInputHandler.h"
+#include "AliAODEvent.h"
+#include "AliMCEvent.h"
+#include "AliMultiplicity.h"
+#include "AliEbyEMultiplicityFluctuationAnalysis.h"
+#include "AliEbyEEventBase.h"
+
+
+ClassImp(AliEbyEMFAnalysisTaskT)
+
+//________________________________________________________________________
+AliEbyEMFAnalysisTaskT::AliEbyEMFAnalysisTaskT()
+:AliAnalysisTaskSE(),
+ fListPhy(0),
+ fEbyEMFBase(0),
+ fEvtCounter(0),
+ fECnt(0),
+ fTree(0)
+{
+ // Dummy constructor ALWAYS needed for I/O.
+}
+
+//________________________________________________________________________
+AliEbyEMFAnalysisTaskT::AliEbyEMFAnalysisTaskT(const char *name)
+ :AliAnalysisTaskSE(name),
+ fListPhy(0),
+ fEbyEMFBase(0),
+ fEvtCounter(0),
+ fECnt(0),
+ fTree(0)
+{
+
+ DefineOutput(1, TList::Class());
+ DefineOutput(2, TTree::Class());
+}
+
+//________________________________________________________________________
+AliEbyEMFAnalysisTaskT::~AliEbyEMFAnalysisTaskT()
+{
+
+ if (fListPhy && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
+ delete fListPhy;
+ }
+ if(fTree) delete fTree;
+}
+
+//________________________________________________________________________
+void AliEbyEMFAnalysisTaskT::UserCreateOutputObjects()
+{
+
+ fListPhy = new TList();
+ fListPhy->SetOwner();
+ fEvtCounter = new TH1F("hEvtCounter","Event Statistic",50,0,50);
+ fListPhy->Add(fEvtCounter);
+
+ fListPhy->Add(dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetQA());
+ fListPhy->Add(fEbyEMFBase->GetListMFQA());
+ fListPhy->Add(fEbyEMFBase->GetListMeasureMF());
+
+ // fTree = new TTree("thisss","mine");
+
+ fTree = fEbyEMFBase->GetFluctuationTree();
+
+
+
+ PostData(1, fListPhy);
+ // PostData(2,fEbyEMFBase->GetFluctuationTree());
+ PostData(2, fTree);
+}
+
+//________________________________________________________________________
+void AliEbyEMFAnalysisTaskT::UserExec(Option_t *)
+{
+
+ fEvtCounter->Fill(0);
+ fECnt++;
+
+ TString gAnalType = dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetAnalysisLevel();
+
+ if(gAnalType == "ESD")
+ {
+ AliESDEvent* gESD = dynamic_cast<AliESDEvent*>(InputEvent());
+ if (!gESD) {
+ Printf("ERROR: gESD not available");
+ return;
+ }
+ const AliESDVertex *vertex = dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetVertex(gESD,dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetAnalysisMode(),dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetVxMax(),dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetVyMax(),dynamic_cast<AliEbyEEventBase*>(fEbyEMFBase->GetEbyEEventBaseObject())->GetVzMax());
+ if(vertex){
+
+
+ fEbyEMFBase->Analyze(gESD);
+ }
+
+ }
+
+}
+
+
+//________________________________________________________________________
+void AliEbyEMFAnalysisTaskT::Terminate(Option_t *)
+{
+ // Draw result to screen, or perform fitting, normalizations
+ // Called once at the end of the query
+
+ fListPhy = dynamic_cast<TList*> (GetOutputData(1));
+ if(!fListPhy) { Printf("ERROR: could not retrieve TList fOutput"); return; }
+
+
+}
+
/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
/*-------------------------------------------------------------------------
*
- * AliEbyEMultiplicityFluctuationAnalysis base class
- * This class deals with the multiplicity fluctuation
- * Origin: Satyajit Jena <sjena@cern.ch>
+ * AliEbyEMultiplicityFluctuationAnalysis base class
+ * This class deals with the Multiplicity fluctuation
+ * Origin: Satyajit Jena <sjena@cern.ch>
*
------------------------------------------------------------------------*/
#include <AliCFDataGrid.h>
#include <AliTPCPIDResponse.h>
#include <AliESDpid.h>
+
+#include "AliESDtrackCuts.h"
#include "AliEbyEEventBase.h"
#include "AliEbyEMultiplicityFluctuationAnalysis.h"
TObject(),
fListMFQA(0),
fListMeasureMF(0),
- fEbyEBase(0)
+ fEbyEBase(0),
+ fESDtrackCuts(0),
+ fIsTreeMode(kFALSE),
+ iNpossitive(0),
+ iNnegative(0),
+ iCentrality(0)
{
- //Default constructor
+ if(fIsTreeMode) fFluctuationTree = NULL;
InitHistos();
-
+ //Default constructor
}
+
//____________________________________________________________________//
AliEbyEMultiplicityFluctuationAnalysis::~AliEbyEMultiplicityFluctuationAnalysis() {
-
//Default destructor
- if(fEbyEBase) delete fEbyEBase;
+
if(fListMFQA) delete fListMFQA;
if(fListMeasureMF) delete fListMeasureMF;
-
+ if(fEbyEBase) delete fEbyEBase;
+ if(fESDtrackCuts) delete fESDtrackCuts;
+ if(fFluctuationTree) delete fFluctuationTree;
+ /* if(fIsTreeMode) delete fIsTreeMode;
+ if(iNpossitive) delete iNpossitive;
+ if(iNnegative) delete iNnegative;
+ if(iCentrality) delete iCentrality;
+ */
}
//____________________________________________________________________//
void AliEbyEMultiplicityFluctuationAnalysis::InitHistos() {
+ if(fIsTreeMode) {
+ fFluctuationTree = new TTree("EbyET","FluctaionContainer");
+ fFluctuationTree->Branch("Positive",&iNpossitive,"iNpossitive/I");
+ fFluctuationTree->Branch("Negative",&iNnegative,"iNnegative/I");
+ fFluctuationTree->Branch("Centrality",&iCentrality,"iCentrality/I");
+ }
+
fListMFQA = new TList();
fListMFQA->SetName("MFQaList");
fListMeasureMF = new TList();
fListMeasureMF->SetName("MFMeasureList");
+ // Int_t kCentBin = fEbyEBase->GetCentralityBin();
+ Int_t kCentBin = 50;
+ Int_t kMultBin = 6000;
+ Double_t kMultMin = 0.0;
+ Double_t kMultMax = 6000;
+
+
TH1F *fEvtStat = new TH1F("hEventCounterMH"," Event Counters for MF Analysis", 20,0,20);
fListMFQA->Add(fEvtStat); // --:0
-
- TH2F *fhMultiplicity = new TH2F("hMultiplicity"," Multiplisity in Centrality Bin", 50,0,50, 3000,0,3000);
- fListMeasureMF->Add(fhMultiplicity); //! -->:0
+
+ TH2F *fhCentralityV0 = new TH2F("hCentralityV0", "Total Charge Fuctuation", kCentBin,0, (Double_t)kCentBin, 3000,0,30000);
+ fListMFQA->Add(fhCentralityV0); // --:1
+
+ TH1F *fhCentDist= new TH1F("hCentDist", "Total Charge Fuctuation", kCentBin,0, (Double_t)kCentBin);
+ fListMFQA->Add(fhCentDist); // --:2
+ TH1F *fEvtStat1 = new TH1F("hEventNp"," Event Counters for +", 60,0,60);
+ fListMFQA->Add(fEvtStat1); // --:3
+
+ TH1F *fEvtStat2 = new TH1F("hEventNn"," Event Counters for +", 60,0,60);
+ fListMFQA->Add(fEvtStat2); // --:4
+
+ TH1F *fEvtStat3 = new TH1F("hEventNppNn"," Event Counters for + + -", 60,0,60);
+ fListMFQA->Add(fEvtStat3); // --:5
+
+
+
+ TH2F *fNpCharge = new TH2F("hNpCharge", "Possitive Charge ",kCentBin,0, (Double_t)kCentBin, kMultBin,kMultMin, kMultMax);
+ fListMeasureMF->Add(fNpCharge); // -->:0
+
+ TH2F *fNnCharge = new TH2F("hNnCharge", "Negative Charge ", kCentBin,0, (Double_t)kCentBin, kMultBin,kMultMin, kMultMax);
+ fListMeasureMF->Add(fNnCharge); // -->:1
+
+ TH2F *fNCharge = new TH2F("hNCharge", "Total Charge [+ + -]",kCentBin,0, (Double_t)kCentBin, 2*kMultBin,kMultMin, 2*kMultMax);
+ fListMeasureMF->Add(fNCharge); // -->:2
+
+ TH2F *fNetCharge = new TH2F("hNetCharge", "Net Charge [+ - -]",kCentBin,0, (Double_t)kCentBin, kMultBin,kMultMin, kMultMax);
+ fListMeasureMF->Add(fNetCharge); // -->:3
+
+ TH2F *fNnbp = new TH2F("hNnbp", "[-/+] ",kCentBin,0, (Double_t)kCentBin, 1000,0,20);
+ fListMeasureMF->Add(fNnbp); // -->:4
+
+ TH2F *fNpbn = new TH2F("hNpbn", "[+/-] ",kCentBin,0, (Double_t)kCentBin, 1000,0,20);
+ fListMeasureMF->Add(fNpbn); // -->:5
+
+ TH2F *fNpbyNnmNnbyNp = new TH2F("hNpbyNnmNnbyNp", "[(+/-) - (-/+)] ",kCentBin,0, (Double_t)kCentBin,100,-5,5);
+ fListMeasureMF->Add(fNpbyNnmNnbyNp); // -->:6
+
+ TH2F *fNpStarNn = new TH2F("hNpbyNnmNnbyNp", "[(+)(-)] ",kCentBin,0, (Double_t)kCentBin,kMultBin,kMultMin, kMultMax*kMultMax);
+ fListMeasureMF->Add(fNpStarNn); // -->:7
+
+ TH2F *fCorrPvsN = new TH2F("hCorrPvsN", " + ~ -",200,0,6000,200,0,6000);
+ fListMeasureMF->Add(fCorrPvsN); // -->:8
+
+ TH3F *fCorCent = new TH3F("hCorrCentrality", "Number of +ve ~ Number of -ve",kCentBin,0, (Double_t)kCentBin,200,0,6000,200,0,6000);
+ fListMeasureMF->Add(fCorCent); // -->:9
+
+
+
}
void AliEbyEMultiplicityFluctuationAnalysis::Analyze(AliESDEvent* esd) {
// Analysis from ESD
- Int_t cent = 0;
-
((TH1F*)(fListMFQA->At(0)))->Fill(1.);
+
+ Int_t kCent = 1;
+ kCent = fEbyEBase->GetCentrality(esd);
+
+ ((TH1F*)(fListMFQA->At(2)))->Fill(kCent);
+
+ TObjArray *array = new TObjArray();
Int_t itr = esd->GetNumberOfTracks();
- ((TH2F*)(fListMeasureMF->At(0)))->Fill(cent,itr);
+
+ for (Int_t iTracks = 0; iTracks < itr; iTracks++)
+ {
+ AliESDtrack* track = esd->GetTrack(iTracks);
+ if (!track) continue;
+ if(!fESDtrackCuts->AcceptTrack(track)) continue;
+ array->Add(track);
+ }
+ Calculate(array,kCent);
+
+ delete array;
}
//____________________________________________________________________//
void AliEbyEMultiplicityFluctuationAnalysis::Analyze(AliAODEvent* aod) {
// Analysis from AOD
- ((TH1F*)(fListMFQA->At(0)))->Fill(1.);
- printf("%d\n",aod->GetNTracks());
+ ((TH1F*)(fListMFQA->At(0)))->Fill(1.);
+ printf("%d\n",aod->GetNTracks());
+
}
+
//____________________________________________________________________//
void AliEbyEMultiplicityFluctuationAnalysis::Analyze(AliStack* stack) {
// Analysis from MC stack
- ((TH1F*)(fListMFQA->At(0)))->Fill(1.);
+ ((TH1F*)(fListMFQA->At(0)))->Fill(1.);
printf("%d \n",stack->GetNtrack());
+}
+
+//____________________________________________________________________________//
+void AliEbyEMultiplicityFluctuationAnalysis::Calculate(TObjArray *gTrackArray, Int_t cent){
+
+ ((TH1F*)(fListMFQA->At(0)))->Fill(1,1);
+ if(cent < 0) return;
+ ((TH1F*)(fListMFQA->At(0)))->Fill(10,1);
+
+ Int_t gNtrack = gTrackArray->GetEntries();
+ if(gNtrack < 1) return;
+
+ ((TH1F*)(fListMFQA->At(0)))->Fill(20,1);
+
+ iNpossitive = 0;
+ iNnegative = 0;
+ iCentrality = 0;
+
+ AliVParticle* track = 0;
+ Int_t pCharge = 0;
+ Int_t nCharge = 0;
+
+
+ TString gAnalysisLevel = fEbyEBase->GetAnalysisLevel();
+ Double_t par[8];
+ for(Int_t i = 0; i < 8; i++) par[i] = 0.0;
+ Double_t pr[8];
+ for(Int_t i = 0; i < 8; i++) pr[i] = 0.0;
+
+
+
+ for(Int_t i = 0; i < gNtrack; i++) {
+ if(gAnalysisLevel == "ESD")
+ track = dynamic_cast<AliESDtrack*>(gTrackArray->At(i));
+ Short_t charge = track->Charge();
+ if(charge > 0) {
+ pCharge += 1;
+ ((TH1F*)(fListMFQA->At(3)))->Fill(cent,1);
+ ((TH1F*)(fListMFQA->At(5)))->Fill(cent,1);
+ }
+ if(charge < 0) {
+ nCharge += 1;
+ ((TH1F*)(fListMFQA->At(4)))->Fill(cent,1);
+ ((TH1F*)(fListMFQA->At(5)))->Fill(cent,1);
+ }
+ }
+
+ ((TH1F*)(fListMFQA->At(0)))->Fill(131+cent,pCharge);
+ ((TH1F*)(fListMFQA->At(0)))->Fill(5,nCharge);
+ ((TH1F*)(fListMFQA->At(0)))->Fill(6,pCharge+nCharge);
+ ((TH2F*)(fListMFQA->At(1)))->Fill(cent,pCharge+nCharge);
+
+
+ par[0] = (Double_t)pCharge;
+ par[1] = (Double_t)nCharge;
+ par[2] = (Double_t)pCharge + (Double_t)nCharge;
+ par[3] = (Double_t)pCharge - (Double_t)nCharge;
+
+ if(pCharge != 0 ) par[4] = (Double_t)pCharge/(Double_t)nCharge;
+ if(nCharge != 0 ) par[5] = (Double_t)nCharge/(Double_t)pCharge;
+
+ par[6] = (Double_t)pCharge - (Double_t)nCharge;
+ par[7] = (Double_t)pCharge*(Double_t)nCharge;
+
+ // printf("Centrality: %2d NTrack: %8d +ve : %8d -ve : %8d %10.6f %10.6f %10.6f\n",
+ //cent, gNtrack, pCharge, nCharge, pr[0], pr[1],value);
+
+
+ ((TH2F*)(fListMeasureMF->At(0)))->Fill(cent, par[0]); //+
+ ((TH2F*)(fListMeasureMF->At(1)))->Fill(cent, par[1]); //-
+ ((TH2F*)(fListMeasureMF->At(2)))->Fill(cent, par[2]); //++-
+ ((TH2F*)(fListMeasureMF->At(3)))->Fill(cent, par[3]); //+--
+ ((TH2F*)(fListMeasureMF->At(4)))->Fill(cent, par[4]); //+/-
+ ((TH2F*)(fListMeasureMF->At(5)))->Fill(cent, par[5]); //-/+
+ ((TH2F*)(fListMeasureMF->At(6)))->Fill(cent, par[6]); //+/-
+ ((TH2F*)(fListMeasureMF->At(7)))->Fill(cent, par[7]);
+ ((TH2F*)(fListMeasureMF->At(8)))->Fill(pCharge,nCharge);
+ ((TH3F*)(fListMeasureMF->At(9)))->Fill(cent, pCharge,nCharge);
+
+ if(fIsTreeMode) {
+ iNpossitive = pCharge;
+ iNnegative = nCharge;
+ iCentrality = cent;
+ // fFluctuationTree->Fill();
+
+ }
}
#ifndef ALIEBYEMULTIPLICITYFLUCTUATIONANALYSIS_H
#define ALIEBYEMULTIPLICITYFLUCTUATIONANALYSIS_H
-
/*------------------------------------------------------------------------
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved.
* See cxx source for full Copyright notice
/*-------------------------------------------------------------------------
*
- * AliEbyEMultiplicityFluctuationAnalysis base class
- * This class deals with the multiplicity fluctuation
- * Origin: Satyajit Jena <sjena@cern.ch>
+ * AliEbyEMultiplicityFluctuationAnalysis base class
+ * This class deals with the Multiplicity fluctuation
+ * Origin: Satyajit Jena <sjena@cern.ch>
*
------------------------------------------------------------------------*/
-
#include "TObject.h"
#include "TH1I.h"
class TH2D;
class TH1F;
class TList;
+class TTree;
class AliAODEvent;
class AliAODtrack;
class AliESDEvent;
class AliESDtrack;
class AliStack;
-
+class AliESDVertex;
+class AliESDtrackCuts;
class AliEbyEEventBase;
+
class AliEbyEMultiplicityFluctuationAnalysis : public TObject {
public:
AliEbyEMultiplicityFluctuationAnalysis();
virtual ~AliEbyEMultiplicityFluctuationAnalysis();
- void SetBaseAnalysis(AliEbyEEventBase * const baseAnalysis) { fEbyEBase = baseAnalysis;}
- AliEbyEEventBase *GetEbyEEventBaseObject() const { return fEbyEBase;}
+ void SetBaseAnalysis(AliEbyEEventBase * const baseAnalysis) {
+ fEbyEBase = baseAnalysis;}
+
+
+ AliEbyEEventBase *GetEbyEEventBaseObject() const {
+ return fEbyEBase;}
void InitHistos();
void Analyze(AliAODEvent *aod);
void Analyze(AliStack *stack);
+ void Calculate(TObjArray *gTrackArray, Int_t cent);
TList *GetListMFQA() const {return fListMFQA;}
- TList *GetListMeasureMF() {return fListMeasureMF;}
+ TList *GetListMeasureMF() const {return fListMeasureMF;}
+ void SetAnalysisCutObject(AliESDtrackCuts *const trackCuts) {
+ fESDtrackCuts = trackCuts;}
+ void SetTreeMode(Bool_t istree) { fIsTreeMode = istree;}
+
+ TTree *GetFluctuationTree() const {return fFluctuationTree;}
+
private:
+ TList *fListMFQA; //! Global list
+ TList *fListMeasureMF; //! List Of Mesures for Multiplisity Fluctuation
+ AliEbyEEventBase *fEbyEBase;//! EbyE Events base
+ AliESDtrackCuts *fESDtrackCuts;
+ Bool_t fIsTreeMode;
+ Int_t iNpossitive;
+ Int_t iNnegative;
+ Int_t iCentrality;
+ TTree *fFluctuationTree;
- TList *fListMFQA; //! Global list
- TList *fListMeasureMF; //! List Of Mesures for Multiplisity Fluctuation
-
- AliEbyEEventBase *fEbyEBase;//EbyE Events base
-
- //____________________________________________________________________________//
- AliEbyEMultiplicityFluctuationAnalysis(const AliEbyEMultiplicityFluctuationAnalysis&); //! Not implemented
- AliEbyEMultiplicityFluctuationAnalysis& operator=(const AliEbyEMultiplicityFluctuationAnalysis&); //! Not implemented
-
- ClassDef(AliEbyEMultiplicityFluctuationAnalysis,1);
+AliEbyEMultiplicityFluctuationAnalysis(const AliEbyEMultiplicityFluctuationAnalysis&); //! Not implemented
+AliEbyEMultiplicityFluctuationAnalysis& operator=(const AliEbyEMultiplicityFluctuationAnalysis&); //! Not implemented
+
+ClassDef(AliEbyEMultiplicityFluctuationAnalysis,1);
};
#endif
--- /dev/null
+/************************************************
+ Multiplisity Flatuation analysis task
+
+ Auther: Satyajit Jena
+ Email: sjena@cern.ch
+ Mon Oct 25 12:47:38 CEST 2010
+
+*************************************************/
+
+AliEbyEMFAnalysisTask *AddTaskMF()
+{
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) {
+ Error("AddTask", "ERROR: No Analysis Manager");
+ return NULL;
+ }
+
+ if (!mgr->GetInputEventHandler()) {
+ Error("AddTaskMF", "ERROR: No input event handler");
+ return NULL;
+ }
+
+
+ // AliEbyEEventBase *base = GetEbyEAnalysisBaseObject();
+ AliEbyEMultiplicityFluctuationAnalysis *analysis = GetAnalysisMFObject();
+ AliESDtrackCuts *trackCuts = GetTrackCutsObject();
+ // analysis->SetBaseAnalysis(base);
+ analysis->SetAnalysisCutObject(trackCuts);
+
+ AliEbyEMFAnalysisTask *taskMF = new AliEbyEMFAnalysisTask("AliEbyEMFAnalysisTask");
+ taskMF->SetAnalysisObject(analysis);
+ mgr->AddTask(taskMF);
+
+ AliAnalysisDataContainer *cout
+ = mgr->CreateContainer("MF", TList::Class(),
+ AliAnalysisManager::kOutputContainer,
+ "AnalysisOutput.mf.root");
+
+ mgr->ConnectInput(taskMF, 0, mgr->GetCommonInputContainer());
+ mgr->ConnectOutput(taskMF, 1, cout);
+ return taskMF;
+
+}
+
+//_______________________________________________________________________________//
+AliEbyEFluctuationTask *AddTaskF()
+{
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) {
+ Error("AddTaskF", "ERROR: No Analysis Manager");
+ return NULL;
+ }
+
+ if (!mgr->GetInputEventHandler()) {
+ Error("AddTaskF", "ERROR: No input event handler");
+ return NULL;
+ }
+
+
+ // AliEbyEEventBase *base = GetEbyEAnalysisBaseObject();
+ AliEbyEFluctuationAnalysis *analysis = GetAnalysisFluctuationObject();
+ AliESDtrackCuts *trackCuts = GetTrackCutsObject();
+ // analysis->SetBaseAnalysis(base);
+ analysis->SetAnalysisCutObject(trackCuts);
+
+ AliEbyEFluctuationTask *taskF = new AliEbyEFluctuationTask("AliEbyEFluctuationTask");
+ taskF->SetAnalysisObject(analysis);
+ mgr->AddTask(taskF);
+
+ AliAnalysisDataContainer *cout
+ = mgr->CreateContainer("Fluc", TList::Class(),
+ AliAnalysisManager::kOutputContainer,
+ "AnalysisOutput.root");
+
+ mgr->ConnectInput(taskF, 0, mgr->GetCommonInputContainer());
+ mgr->ConnectOutput(taskF, 1, cout);
+ return taskF;
+
+}
+
+//_______________________________________________________________________________//
+
+
+AliEbyEMFAnalysisTaskT *AddTaskMFT()
+{
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) {
+ Error("AddTask", "ERROR: No Analysis Manager");
+ return NULL;
+ }
+
+ if (!mgr->GetInputEventHandler()) {
+ Error("AddTaskMFT", "ERROR: No input event handler");
+ return NULL;
+ }
+
+
+ // AliEbyEEventBase *base = GetEbyEAnalysisBaseObject();
+ AliEbyEMultiplicityFluctuationAnalysis *analysis = GetAnalysisMFObject();
+ AliESDtrackCuts *trackCuts = GetTrackCutsObject();
+
+ // analysis->SetBaseAnalysis(base);
+ analysis->SetTreeMode(kTRUE);
+ analysis->SetAnalysisCutObject(trackCuts);
+
+ AliEbyEMFAnalysisTaskT *taskMF = new AliEbyEMFAnalysisTaskT("AliEbyEMFAnalysisTaskT");
+ taskMF->SetAnalysisObject(analysis);
+ mgr->AddTask(taskMF);
+
+ AliAnalysisDataContainer *cout
+ = mgr->CreateContainer("MFT", TList::Class(),
+ AliAnalysisManager::kOutputContainer,
+ "AnalysisOutput.mf.root");
+
+ AliAnalysisDataContainer *cout1
+ = mgr->CreateContainer("EbyET", TTree::Class(),
+ AliAnalysisManager::kOutputContainer,
+ "IntermediateMf.root");
+
+ mgr->ConnectInput(taskMF, 0, mgr->GetCommonInputContainer());
+ mgr->ConnectOutput(taskMF, 1, cout);
+ mgr->ConnectOutput(taskMF, 2, cout1);
+ return taskMF;
+
+}
+
+//_______________________________________________________________________________//
+
+AliEbyECFAnalysisTask *AddTaskCF()
+{
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) {
+ Error("AddTaskCF", "ERROR: No Analysis Manager");
+ return NULL;
+ }
+
+ if (!mgr->GetInputEventHandler()) {
+ Error("AddTaskCF", "ERROR: No input event handler");
+ return NULL;
+ }
+
+
+ AliEbyEChargeFluctuationAnalysis *analysis = GetAnalysisCFObject();
+ AliEbyECFAnalysisTask *taskCF = new AliEbyECFAnalysisTask("AliEbyECFAnalysisTask");
+
+ taskCF->SetAnalysisObject(analysis);
+
+ mgr->AddTask(taskCF);
+
+ AliAnalysisDataContainer *cout
+ = mgr->CreateContainer("CF", TList::Class(),
+ AliAnalysisManager::kOutputContainer,
+ "AnalysisOutput.cf.root");
+
+ mgr->ConnectInput(taskCF, 0, mgr->GetCommonInputContainer());
+ mgr->ConnectOutput(taskCF, 1, cout);
+ return taskCF;
+
+}
+
+
+//_______________________________________________________________________________//
+AliEbyEEventBase *GetEbyEAnalysisBaseObject(const char* analysisLevel = "ESD",
+ const char* esdAnalysisType = "TPC",
+ const char* CentralityType = "HardType",
+ const char* centEstimator = "V0M")
+
+{
+
+ printf(" Configuring Base Class \n");
+ /*---------------------------------------------------
+ | analysisLevel : ESD, AOD, MC
+ | esdAnalysisType: TPC, ITC, TPCnITS, FORWARD, GLOBAL
+ | CentralityType:
+ | HardType: Hard Coded [ from vzero multiplicity ]
+ | Acc:
+ | Flat:
+ | All :
+ | Centrality Estimator: V0M, ZDC, ..... decided later
+ | Centrality Bin: 10(10%), 20(5%) , 50(2%)
+ ------------------------------------------------------*/
+
+ AliEbyEEventBase *base = new AliEbyEEventBase();
+ // base->InitQA();
+ base->SetAnalysisLevel(analysisLevel);
+
+ base->SetCentralityBin(50);
+ if(CentralityType == "HardType") {
+
+ base->SetCentralityType(AliEbyEEventBase::kHardFlat);
+ base->SetCentralityEstimator("V0M");
+
+ }
+
+ if (CentralityType == "Central") {
+ base->SetCentralityType(AliEbyEEventBase::kFlat);
+ base->SetCentralityEstimator("V0M");
+ }
+
+ if(analysisLevel == "ESD") {
+ switch(esdAnalysisType) {
+ case "TPC":
+ base->SetAnalysisMode(AliEbyEEventBase::kTPC);
+ base->SetPhaseSpace(0.5, 0.3, 1.5, 3.0, 70, 4);
+ // eta, ptmin, ptmax, dcaxyz, TPC clusters, kisquare/clustertpc
+ break;
+
+ case "ITS":
+ base->SetAnalysisMode(AliEbyEEventBase::kITS);
+ base->SetPhaseSpace(9, -0.9, 0.9, 6, 0.45, 1.05);
+ break;
+
+ case "TPCnITS":
+ base->SetAnalysisMode(AliEbyEEventBase::kTPCnITS);
+ base->SetPhaseSpace(9, -0.9, 0.9, 6, 0.45, 1.05);
+ break;
+
+ case "Global":
+ base->SetAnalysisMode(AliEbyEEventBase::kGlobal);
+ base->SetPhaseSpace(20, -1.0, 1.0, 48, 0.3, 1.5);
+ break;
+
+ case "Forward":
+ base->SetAnalysisMode(AliEbyEEventBase::kForward);
+ base->SetPhaseSpace(20, -1.0, 1.0, 48, 0.3, 1.5);
+ break;
+
+ default:
+ break;
+ }
+ base->SetAcceptedVertexDiamond(10.,10.,25.);
+
+ }
+ if(analysisLevel == "MC")
+ base->SetPhaseSpace(10, -0.5, 0.5, 16, 0.5, 0.9);
+ if(analysisLevel == "AOD")
+ base->SetPhaseSpace(10, -0.5, 0.5, 16, 0.5, 0.9);
+ printf("Event Base Created ---------------- OK\n");
+ return base;
+}
+
+
+//_______________________________________________________________________________//
+AliEbyEChargeFluctuationAnalysis *GetAnalysisCFObject() {
+ AliEbyEEventBase *base = GetEbyEAnalysisBaseObject();
+ AliEbyEChargeFluctuationAnalysis *analysis = new AliEbyEChargeFluctuationAnalysis();
+
+
+ analysis->SetBaseAnalysis(base);
+ printf("TaskCF: Charge Fluctuation Base Created ---------------- OK\n");
+ return analysis;
+}
+
+//_________________________________________________________________________________//
+AliEbyEMultiplicityFluctuationAnalysis *GetAnalysisMFObject() {
+ AliEbyEEventBase *base = GetEbyEAnalysisBaseObject();
+ AliEbyEMultiplicityFluctuationAnalysis *analysis = new AliEbyEMultiplicityFluctuationAnalysis();
+ analysis->SetBaseAnalysis(base);
+ printf("TaskMF: Multiplicity Fluctuation Base Created ---------------- OK\n");
+ return analysis;
+}
+
+//_________________________________________________________________________________//
+AliEbyEFluctuationAnalysis *GetAnalysisFluctuationObject() {
+ AliEbyEEventBase *base = GetEbyEAnalysisBaseObject();
+ AliEbyEFluctuationAnalysis *analysis = new AliEbyEFluctuationAnalysis();
+ analysis->SetBaseAnalysis(base);
+ printf("TaskF: Fluctuation Base Created ---------------- OK\n");
+ return analysis;
+}
+
+//_________________________________________________________________________________//
+
+AliESDtrackCuts *GetTrackCutsObject() {
+
+ AliESDtrackCuts *cuts = new AliESDtrackCuts("bfTrackCuts","bfTrackCuts");
+ // cuts->SetMinNClustersTPC(80);
+ // cuts->SetMinNClustersITS(2);
+ // cuts->SetMaxChi2PerClusterTPC(4.0);
+
+ // cuts->SetRequireTPCRefit();
+ // cuts->SetRequireITSRefit();
+ // cuts->SetAcceptKinkDaughters(kFALSE);
+
+ //
+
+ cuts->SetMaxDCAToVertexXY(0.3);
+ cuts->SetMaxDCAToVertexZ(3);
+ cuts->SetPtRange(0.0,1.5);
+ cuts->SetEtaRange(-0.8,0.8);
+ cuts->SaveHistograms("EbyECuts");
+
+ return cuts;
+}
--- /dev/null
+AliCentralitySelectionTask *AddTaskCentrality()
+{
+// Macro to connect a centrality selection task to an existing analysis manager.
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) {
+ ::Error("AddTaskCentrality", "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("AddTaskCentrality", "This task requires an input event handler");
+ return NULL;
+ }
+ TString inputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
+ if (inputDataType != "ESD") {
+ ::Error("AddTaskCentrality", "This task works only on ESD analysis");
+ return NULL;
+ }
+ AliCentralitySelectionTask *centralityTask = new AliCentralitySelectionTask("CentralitySelection");
+ centralityTask->SelectCollisionCandidates(AliVEvent::kMB);
+ mgr->AddTask(centralityTask);
+
+ AliAnalysisDataContainer *cinput0 = mgr->GetCommonInputContainer();
+ AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("CentralityStat",
+ TList::Class(), AliAnalysisManager::kOutputContainer,
+ "EventStat_temp.root");
+
+ mgr->ConnectInput(centralityTask, 0, mgr->GetCommonInputContainer());
+ mgr->ConnectOutput(centralityTask,1,coutput1);
+
+ return centralityTask;
+}
--- /dev/null
+AliPhysicsSelectionTask* AddTaskPhysicsSelection(Bool_t mCAnalysisFlag = kFALSE, Bool_t withBckgndRejection = kTRUE, UInt_t computeBG = 0)
+{
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) {
+ ::Error("AddTaskPhysicsSelection", "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("AddTaskPhysicsSelection", "This task requires an input event handler");
+ return NULL;
+ }
+ TString inputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
+
+ // Configure analysis
+ //===========================================================================
+
+
+
+ AliPhysicsSelectionTask *task = new AliPhysicsSelectionTask("");
+ mgr->AddTask(task);
+
+ AliPhysicsSelection* physSel = task->GetPhysicsSelection();
+ if (withBckgndRejection)
+ physSel->AddBackgroundIdentification(new AliBackgroundSelection());
+ if (mCAnalysisFlag)
+ physSel->SetAnalyzeMC();
+ if (computeBG)
+ physSel->SetComputeBG(computeBG);
+
+ AliAnalysisDataContainer *cinput0 = mgr->GetCommonInputContainer();
+ AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("cstatsout",
+ TList::Class(),
+ AliAnalysisManager::kOutputContainer,
+ "EventStat_temp.root");
+
+ mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
+ mgr->ConnectOutput(task,1,coutput1);
+
+ return task;
+}
--- /dev/null
+void TestCompile()
+{
+
+ gSystem->Load("libSTEERBase.so");
+ gSystem->Load("libVMC.so");
+ gSystem->Load("libESD.so");
+ gSystem->Load("libAOD.so");
+ gSystem->Load("libANALYSIS.so");
+ gSystem->Load("libANALYSISalice.so");
+ gSystem->Load("libPWG2ebye.so");
+ gSystem->AddIncludePath("-I$ALICE_ROOT/include");
+ printf("Library is Loaded \n");
+
+
+ gROOT->LoadMacro("../AliEbyEEventBase.cxx++g");
+ gROOT->LoadMacro("../AliEbyEMultiplicityFluctuationAnalysis.cxx++g");
+ gROOT->LoadMacro("../AliEbyEMFAnalysisTask.cxx++g");
+ gROOT->LoadMacro("../AliEbyEFluctuationAnalysis.cxx++g");
+ gROOT->LoadMacro("../AliEbyEFluctuationTask.cxx++g");
+ gROOT->LoadMacro("../AliEbyEMFAnalysisTaskT.cxx++g");
+ gROOT->LoadMacro("../AliEbyEChargeFluctuationAnalysis.cxx++g");
+ gROOT->LoadMacro("../AliEbyECFAnalysisTask.cxx++g");
+
+ gROOT->LoadMacro("AddFluctuationTask.C");
+
+ AliAnalysisManager *mgr = new AliAnalysisManager("Analysis");
+ AliVEventHandler* esdH = new AliESDInputHandler();
+ mgr->SetInputEventHandler(esdH);
+
+ AddTaskMF();
+ AddTaskMFT();
+ AddTaskCF();
+ AddTaskF();
+
+ mgr->InitAnalysis();
+ mgr->PrintStatus();
+
+
+
+}
--- /dev/null
+/****************************************************************
+
+Lunch the Analysis Task for Fluctuation Study
+Author: Satyajit Jena
+Email: sjena@cern.ch
+
+Task : MF, MFT, CF, OF
+Running in Local = analmode = local, proof, grid
+
+*******************************************************************/
+
+
+TString tasktype = "MF"; //OF, MF, MFT, CF
+
+//CAF-AAF Related
+TString dataset = "/alice/data/LHC10h_000137162_p1_3plus";
+TString proofCluster = "alice-caf.cern.ch";
+TString alirootVer = "VO_ALICE@AliRoot::v4-21-12-AN";
+
+
+Bool_t UsePar = kFALSE; // Do you want to use par
+Bool_t UseTrigger = kFALSE; // activate trigger seletction
+Bool_t UseCentrality = kFALSE; // activate centrality slection
+
+
+void runFluctuationTask(TString analmode = "local")
+{
+
+ if(analmode.CompareTo("local") == 0 ) {
+ if(!LoadLibraries(analmode)) {
+ printf("Library Not loaded\n");
+ return;
+ }
+ runLocal("file.txt",1000);
+
+ }
+ else if(analmode.CompareTo("proof") == 0) {
+ if(!LoadLibraries(analmode)) return;
+ runproof(dataset);
+ }
+ else printf("load error\n");
+}
+
+//___________________________________________________________________________________
+Bool_t LoadLibraries(TString mode = "local")
+{
+
+ if(mode.CompareTo("local") == 0) {
+ gSystem->Load("libSTEERBase.so");
+ gSystem->Load("libVMC.so");
+ gSystem->Load("libESD.so");
+ gSystem->Load("libAOD.so");
+ gSystem->Load("libANALYSIS.so");
+ gSystem->Load("libANALYSISalice.so");
+ // gSystem->Load("libPWG2ebye.so");
+ gSystem->AddIncludePath("-I$ALICE_ROOT/include");
+ printf("Library is Loaded \n");
+ return kTRUE;
+ }
+ else if(mode.CompareTo("proof") == 0) {
+ gEnv->SetValue("XSec.GSI.DelegProxy","2");
+ TProof *p = TProof::Open(proofCluster.Data());
+ p->ShowPackages();
+ p->EnablePackage(alirootVer.Data());
+ return kTRUE;
+ }
+ else if(mode.CompareTo("proof") == 0) {
+ printf("Satya FIXME \n");
+ }
+ else {
+ printf(" ERROR: Give proper running mode \n");
+ return kFALSE;
+ }
+
+}
+
+//______________________________________________________________________
+Bool_t LoadIfParAnalysis(TString mode = "local") {
+ // FIXME: For par file upload methods..
+
+
+
+}
+
+//______________________________________________________________________
+// Running local
+void runLocal(TString input,int nfile)
+{
+
+ gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C");
+ TChain* chain = CreateESDChain(input, nfile);
+
+ AliAnalysisManager *mgr = new AliAnalysisManager("Analysis");
+ AliVEventHandler* esdH = new AliESDInputHandler();
+ mgr->SetInputEventHandler(esdH);
+
+
+ // gROOT->LoadMacro("AddTaskPhysicsSelection.C");
+ // gROOT->LoadMacro("AddTaskCentrality.C");
+
+ // AliPhysicsSelectionTask* physicsSelTask = AddTaskPhysicsSelection();
+ // AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
+
+
+ if(!UsePar) gROOT->LoadMacro("../AliEbyEEventBase.cxx++g");
+
+ if(tasktype.CompareTo("CF") == 0) {
+ if(!par) {
+ gROOT->LoadMacro("../AliEbyEMultiplicityFluctuationAnalysis.cxx++g");
+ gROOT->LoadMacro("../AliEbyEChargeFluctuationAnalysis.cxx++g");
+ }
+
+ gROOT->LoadMacro("AddFluctuationTask.C");
+ AddTaskCF();
+ }
+ else if(tasktype.CompareTo("MF") == 0) {
+ if(!UsePar) {
+ gROOT->LoadMacro("../AliEbyEMultiplicityFluctuationAnalysis.cxx++g");
+ gROOT->LoadMacro("../AliEbyEMFAnalysisTask.cxx++g");
+ }
+ gROOT->LoadMacro("AddFluctuationTask.C");
+ AddTaskMF();
+ }
+ else if(tasktype.CompareTo("OF") == 0) {
+ if(!UsePar) {
+ gROOT->LoadMacro("../AliEbyEFluctuationAnalysis.cxx++g");
+ gROOT->LoadMacro("../AliEbyEFluctuationTask.cxx++g");
+ }
+ gROOT->LoadMacro("AddFluctuationTask.C");
+ AddTaskF();
+ }
+ else if (tasktype.CompareTo("MFT") == 0) {
+ if(!UsePar) {
+ gROOT->LoadMacro("../AliEbyEMultiplicityFluctuationAnalysis.cxx++g");
+ gROOT->LoadMacro("../AliEbyEMFAnalysisTaskT.cxx++g");
+ }
+ gROOT->LoadMacro("AddFluctuationTask.C");
+ AddTaskMFT();
+ }
+ else return;
+
+
+
+
+ mgr->SetDebugLevel(0);
+ if (!mgr->InitAnalysis()) return;
+ mgr->PrintStatus();
+ mgr->StartAnalysis("local", chain);
+
+
+}
+
+
+//________________________________________________________
+//Running in proof
+
+void runproof(TString dataset)
+{
+
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) mgr = new AliAnalysisManager("FirstCheck");
+
+ AliVEventHandler* esdH = new AliESDInputHandler();
+ mgr->SetInputEventHandler(esdH);
+
+ if(UseTrigger) {
+ gProof->Load("AddTaskPhysicsSelection.C");
+ AliPhysicsSelectionTask* physicsSelTask = AddTaskPhysicsSelection();
+ }
+
+ if(UseCentrality) {
+ gProof->Load("AddTaskCentrality.C");
+ AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
+ }
+
+ if(!UsePar) gProof->Load("../AliEbyEEventBase.cxx++g");
+
+ if(tasktype.CompareTo("CF") == 0) {
+ if(!UsePar) {
+ gProof->Load("../AliEbyEMultiplicityFluctuationAnalysis.cxx++g");
+ gProof->Load("../AliEbyEChargeFluctuationAnalysis.cxx++g");
+ }
+ gProof->Load("AddFluctuationTask.C");
+ AddTaskCF();
+ }
+ else if(tasktype.CompareTo("MF") == 0) {
+ if(!UsePar) {
+ gProof->Load("../AliEbyEMultiplicityFluctuationAnalysis.cxx++g");
+ gProof->Load("../AliEbyEMFAnalysisTask.cxx++g");
+ }
+ gProof->Load("AddFluctuationTask.C");
+ AddTaskMF();
+ }
+
+ else if(tasktype.CompareTo("OF") == 0) {
+ if(!UsePar) {
+ gProof->Load("../AliEbyEFluctuationAnalysis.cxx++g");
+ gProof->Load("../AliEbyEAnalysisTask.cxx++g");
+ }
+ gProof->Load("AddFluctuationTask.C");
+ AddTaskF();
+ }
+
+ else if (tasktype.CompareTo("MFT") == 0) {
+ if(!UsePar) {
+ gProof->Load("../AliEbyEMultiplicityFluctuationAnalysis.cxx++g");
+ gProof->Load("../AliEbyEMFAnalysisTaskT.cxx++g");
+ }
+ gProof->Load("AddFluctuationTask.C");
+ AddTaskMFT();
+ }
+ else return;
+
+ mgr->SetDebugLevel(0);
+ if (!mgr->InitAnalysis())
+ return;
+
+ mgr->PrintStatus();
+
+ mgr->StartAnalysis("proof",dataset.Data());
+
+}
+
+
+//______________________________________________________________________________
+AliAnalysisGrid* CreateAlienHandler(const char *taskname, const char *gridmode,
+ const char *proofcluster, const char *proofdataset)
+{
+ AliAnalysisAlien *plugin = new AliAnalysisAlien();
+ // Set the run mode (can be "full", "test", "offline", "submit" or "terminate")
+ plugin->SetRunMode(gridmode);
+
+ // Set versions of used packages
+ plugin->SetAPIVersion("V1.1x");
+ plugin->SetROOTVersion("v5-27-06b");
+ plugin->SetAliROOTVersion("v4-21-08-AN");
+
+ // Declare input data to be processed.
+
+ // Method 1: Create automatically XML collections using alien 'find' command.
+ // Define production directory LFN
+ plugin->SetGridDataDir("/alice/data/2010/LHC10b");
+ // On real reconstructed data:
+ // plugin->SetGridDataDir("/alice/data/2009/LHC09d");
+ // Set data search pattern
+ //plugin->SetDataPattern("*ESDs.root"); // THIS CHOOSES ALL PASSES
+ // Data pattern for reconstructed data
+ plugin->SetDataPattern("*ESDs/pass2/*ESDs.root"); // CHECK LATEST PASS OF DATA SET IN ALIENSH
+ plugin->SetRunPrefix("000"); // real data, comment out for MC
+ // ...then add run numbers to be considered
+ plugin->AddRunNumber(115514);
+ //plugin->SetRunRange(114917,115322);
+ plugin->SetNrunsPerMaster(1);
+ plugin->SetOutputToRunNo();
+ // comment out the next line when using the "terminate" option, unless
+ // you want separate merged files for each run
+ plugin->SetMergeViaJDL();
+
+ // Method 2: Declare existing data files (raw collections, xml collections, root file)
+ // If no path mentioned data is supposed to be in the work directory (see SetGridWorkingDir())
+ // XML collections added via this method can be combined with the first method if
+ // the content is compatible (using or not tags)
+ // plugin->AddDataFile("tag.xml");
+ // plugin->AddDataFile("/alice/data/2008/LHC08c/000057657/raw/Run57657.Merged.RAW.tag.root");
+
+ // Define alien work directory where all files will be copied. Relative to alien $HOME.
+ plugin->SetGridWorkingDir(taskname);
+
+ // Declare alien output directory. Relative to working directory.
+ plugin->SetGridOutputDir("out"); // In this case will be $HOME/taskname/out
+
+ // Declare the analysis source files names separated by blancs. To be compiled runtime
+ // using ACLiC on the worker nodes.
+ plugin->SetAnalysisSource("AliAnalysisTaskEx01.cxx");
+
+ // Declare all libraries (other than the default ones for the framework. These will be
+ // loaded by the generated analysis macro. Add all extra files (task .cxx/.h) here.
+ plugin->SetAdditionalLibs("AliAnalysisTaskEx01.h AliAnalysisTaskEx01.cxx");
+
+ // Declare the output file names separated by blancs.
+ // (can be like: file.root or file.root@ALICE::Niham::File)
+ // To only save certain files, use SetDefaultOutputs(kFALSE), and then
+ // SetOutputFiles("list.root other.filename") to choose which files to save
+ plugin->SetDefaultOutputs();
+ //plugin->SetOutputFiles("list.root");
+
+ // Optionally set a name for the generated analysis macro (default MyAnalysis.C)
+ plugin->SetAnalysisMacro(Form("%s.C",taskname));
+
+ // Optionally set maximum number of input files/subjob (default 100, put 0 to ignore)
+ plugin->SetSplitMaxInputFileNumber(100);
+
+ // Optionally modify the executable name (default analysis.sh)
+ plugin->SetExecutable(Form("%s.sh",taskname));
+
+ // set number of test files to use in "test" mode
+ plugin->SetNtestFiles(10);
+
+ // Optionally resubmit threshold.
+ plugin->SetMasterResubmitThreshold(90);
+
+ // Optionally set time to live (default 30000 sec)
+ plugin->SetTTL(30000);
+
+ // Optionally set input format (default xml-single)
+ plugin->SetInputFormat("xml-single");
+
+ // Optionally modify the name of the generated JDL (default analysis.jdl)
+ plugin->SetJDLName(Form("%s.jdl",taskname));
+
+ // Optionally modify job price (default 1)
+ plugin->SetPrice(1);
+
+ // Optionally modify split mode (default 'se')
+ plugin->SetSplitMode("se");
+
+ //----------------------------------------------------------
+ //--- PROOF MODE SPECIFIC SETTINGS ------------
+ //----------------------------------------------------------
+ // Proof cluster
+ plugin->SetProofCluster(proofcluster);
+ // Dataset to be used
+ plugin->SetProofDataSet(proofdataset);
+ // May need to reset proof. Supported modes: 0-no reset, 1-soft, 2-hard
+ plugin->SetProofReset(0);
+ // May limit number of workers
+ plugin->SetNproofWorkers(0);
+ // May limit the number of workers per slave
+ plugin->SetNproofWorkersPerSlave(1);
+ // May use a specific version of root installed in proof
+ plugin->SetRootVersionForProof("current");
+ // May set the aliroot mode. Check http://aaf.cern.ch/node/83
+ plugin->SetAliRootMode("default"); // Loads AF libs by default
+ // May request ClearPackages (individual ClearPackage not supported)
+ plugin->SetClearPackages(kFALSE);
+ // Plugin test mode works only providing a file containing test file locations, used in "local" mode also
+ plugin->SetFileForTestMode("file1.text"); // file should contain path name to a local directory containg *ESDs.root etc
+ // Request connection to alien upon connection to grid
+ plugin->SetProofConnectGrid(kFALSE);
+
+ return plugin;
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff