From 4a403ac3d7a3cf5f41590972a55da740fbe8ef8d Mon Sep 17 00:00:00 2001 From: pchrist Date: Fri, 10 Dec 2010 10:41:36 +0000 Subject: [PATCH] New classes for the EBYE charge and multiplicity fluctuations - version 0 (Satya) --- .../Fluctuations/AliEbyECFAnalysisTask.cxx | 111 ++++++ .../EBYE/Fluctuations/AliEbyECFAnalysisTask.h | 52 +++ .../AliEbyEChargeFluctuationAnalysis.cxx | 215 ++++++++++++ .../AliEbyEChargeFluctuationAnalysis.h | 68 ++++ PWG2/EBYE/Fluctuations/AliEbyEEventBase.cxx | 320 ++++++++++++++++++ PWG2/EBYE/Fluctuations/AliEbyEEventBase.h | 144 ++++++++ .../Fluctuations/AliEbyEMFAnalysisTask.cxx | 112 ++++++ .../EBYE/Fluctuations/AliEbyEMFAnalysisTask.h | 53 +++ ...AliEbyEMultiplicityFluctuationAnalysis.cxx | 124 +++++++ .../AliEbyEMultiplicityFluctuationAnalysis.h | 67 ++++ PWG2/EBYE/Fluctuations/macro/AddTaskCF.C | 53 +++ PWG2/EBYE/Fluctuations/macro/AddTaskMF.C | 53 +++ .../Fluctuations/macro/ConfigureCFAnalysis.C | 13 + .../macro/ConfigureEbyEBaseObject.C | 80 +++++ .../Fluctuations/macro/ConfigureMFAnalysis.C | 13 + PWG2/EBYE/Fluctuations/macro/file.txt | 23 ++ PWG2/EBYE/Fluctuations/macro/runTaskCF.C | 148 ++++++++ PWG2/EBYE/Fluctuations/macro/runTaskMF.C | 146 ++++++++ 18 files changed, 1795 insertions(+) create mode 100755 PWG2/EBYE/Fluctuations/AliEbyECFAnalysisTask.cxx create mode 100755 PWG2/EBYE/Fluctuations/AliEbyECFAnalysisTask.h create mode 100644 PWG2/EBYE/Fluctuations/AliEbyEChargeFluctuationAnalysis.cxx create mode 100644 PWG2/EBYE/Fluctuations/AliEbyEChargeFluctuationAnalysis.h create mode 100644 PWG2/EBYE/Fluctuations/AliEbyEEventBase.cxx create mode 100644 PWG2/EBYE/Fluctuations/AliEbyEEventBase.h create mode 100755 PWG2/EBYE/Fluctuations/AliEbyEMFAnalysisTask.cxx create mode 100755 PWG2/EBYE/Fluctuations/AliEbyEMFAnalysisTask.h create mode 100644 PWG2/EBYE/Fluctuations/AliEbyEMultiplicityFluctuationAnalysis.cxx create mode 100644 PWG2/EBYE/Fluctuations/AliEbyEMultiplicityFluctuationAnalysis.h create mode 100644 PWG2/EBYE/Fluctuations/macro/AddTaskCF.C create mode 100644 PWG2/EBYE/Fluctuations/macro/AddTaskMF.C create mode 100644 PWG2/EBYE/Fluctuations/macro/ConfigureCFAnalysis.C create mode 100644 PWG2/EBYE/Fluctuations/macro/ConfigureEbyEBaseObject.C create mode 100644 PWG2/EBYE/Fluctuations/macro/ConfigureMFAnalysis.C create mode 100644 PWG2/EBYE/Fluctuations/macro/file.txt create mode 100644 PWG2/EBYE/Fluctuations/macro/runTaskCF.C create mode 100644 PWG2/EBYE/Fluctuations/macro/runTaskMF.C diff --git a/PWG2/EBYE/Fluctuations/AliEbyECFAnalysisTask.cxx b/PWG2/EBYE/Fluctuations/AliEbyECFAnalysisTask.cxx new file mode 100755 index 00000000000..8a44d9cc637 --- /dev/null +++ b/PWG2/EBYE/Fluctuations/AliEbyECFAnalysisTask.cxx @@ -0,0 +1,111 @@ + +/************************************************************************** + * 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. * + **************************************************************************/ + +/*------------------------------------------------------------------------- + * AliEbyECFAnalysisTask Class + * This class deals with runing Charge Fluctuation Task + * origin: Satyajit Jena + * CF: Charge Fluctuation + *------------------------------------------------------------------------*/ + + +#include "TChain.h" +#include "TString.h" +#include "TList.h" +#include "TFile.h" +#include "TTree.h" +#include "TH1F.h" +#include "TH2F.h" +#include "TH3D.h" +#include "TCanvas.h" +#include "AliAnalysisManager.h" +#include "AliVEvent.h" +#include "AliESD.h" +#include "AliESDEvent.h" +#include "AliAODEvent.h" +#include "AliEbyEEventBase.h" +#include "AliEbyEChargeFluctuationAnalysis.h" +#include "AliEbyECFAnalysisTask.h" + +ClassImp(AliEbyECFAnalysisTask) + +//________________________________________________________________________ +AliEbyECFAnalysisTask::AliEbyECFAnalysisTask(const char *name) + : AliAnalysisTaskSE(name), + fListPhy(0), + fEbyECFBase(0), + fEvtCounter(0), + fECnt(0) + +{ + // DefineInput(0, TChain::Class()); + DefineOutput(1, TList::Class()); +} + +//________________________________________________________________________ +void AliEbyECFAnalysisTask::UserCreateOutputObjects() +{ + fListPhy = new TList(); + + fEvtCounter = new TH1F("hEvtCounter","Event Statistic",50,0,50); + fListPhy->Add(fEvtCounter); + + fListPhy->Add(dynamic_cast(fEbyECFBase->GetEbyEEventBaseObject())->GetQA()); + fListPhy->Add(fEbyECFBase->GetListCFQA()); + fListPhy->Add(fEbyECFBase->GetListMeasureCF()); + + PostData(1, fListPhy); +} + +//________________________________________________________________________ +void AliEbyECFAnalysisTask::UserExec(Option_t *) +{ + + fEvtCounter->Fill(0); + fECnt++; + + TString gAnalType = dynamic_cast(fEbyECFBase->GetEbyEEventBaseObject())->GetAnalysisLevel(); + + if(gAnalType == "ESD") + { + AliESDEvent* gESD = dynamic_cast(InputEvent()); + if (!gESD) { + Printf("ERROR: gESD not available"); + return; + } + const AliESDVertex *vertex = dynamic_cast(fEbyECFBase->GetEbyEEventBaseObject())->GetVertex(gESD,dynamic_cast(fEbyECFBase->GetEbyEEventBaseObject())->GetAnalysisMode(),dynamic_cast(fEbyECFBase->GetEbyEEventBaseObject())->GetVxMax(),dynamic_cast(fEbyECFBase->GetEbyEEventBaseObject())->GetVyMax(),dynamic_cast(fEbyECFBase->GetEbyEEventBaseObject())->GetVzMax()); + if(vertex){ + + fEbyECFBase->Analyze(gESD); + } + + } + PostData(1, fListPhy); + +} + +//______________________________________________________________________// +void AliEbyECFAnalysisTask::Terminate(Option_t *) { + +fListPhy = dynamic_cast (GetOutputData(1)); + if (!fListPhy) { + Error("Terminate","Out Put List not available"); + return; + } + + Info("AliEbyECFAnalysisTask","Charge Fluctuation Job Successfully finished"); + +} diff --git a/PWG2/EBYE/Fluctuations/AliEbyECFAnalysisTask.h b/PWG2/EBYE/Fluctuations/AliEbyECFAnalysisTask.h new file mode 100755 index 00000000000..42bcac7e520 --- /dev/null +++ b/PWG2/EBYE/Fluctuations/AliEbyECFAnalysisTask.h @@ -0,0 +1,52 @@ +#ifndef ALIEBYECFANALYSISTASK_H +#define ALIEBYECFANALYSISTASK_H + + +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +/*------------------------------------------------------------------------- + * AliEbyECFAnalysisTask Class + * This class deals with runing Charge Fluctuation Task + * origin: Satyajit Jena + * + *------------------------------------------------------------------------*/ + +class TString; +class TH1F; +class TH2F; + +class TList; + +#include "AliAnalysisTaskSE.h" + +class AliEbyEEventBase; +class AliEbyEChargeFluctuationAnalysis; + +class AliEbyECFAnalysisTask: public AliAnalysisTaskSE { + public: + AliEbyECFAnalysisTask(const char *name = "AliEbyECFAnalysisTask"); + virtual ~AliEbyECFAnalysisTask() {} + + virtual void UserCreateOutputObjects(); + virtual void UserExec(Option_t *option); + virtual void Terminate(Option_t *); + + void SetAnalysisObject(AliEbyEChargeFluctuationAnalysis *const analysis) { fEbyECFBase = analysis;} + + private: + + TList *fListPhy; + + AliEbyEChargeFluctuationAnalysis *fEbyECFBase; + TH1F *fEvtCounter; + Int_t fECnt; + + AliEbyECFAnalysisTask(const AliEbyECFAnalysisTask&); + AliEbyECFAnalysisTask& operator=(const AliEbyECFAnalysisTask&); + + ClassDef(AliEbyECFAnalysisTask, 1); +}; + +#endif + diff --git a/PWG2/EBYE/Fluctuations/AliEbyEChargeFluctuationAnalysis.cxx b/PWG2/EBYE/Fluctuations/AliEbyEChargeFluctuationAnalysis.cxx new file mode 100644 index 00000000000..5a45f7aa5ec --- /dev/null +++ b/PWG2/EBYE/Fluctuations/AliEbyEChargeFluctuationAnalysis.cxx @@ -0,0 +1,215 @@ +/************************************************************************** + * 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. * + **************************************************************************/ + +/*------------------------------------------------------------------------- + * + * AliEbyEChargeFluctuationAnalysis base class + * This class deals with the Charge fluctuation + * Origin: Satyajit Jena + * + ------------------------------------------------------------------------*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "AliEbyEEventBase.h" +#include "AliEbyEChargeFluctuationAnalysis.h" + + +ClassImp(AliEbyEChargeFluctuationAnalysis) + +//____________________________________________________________________// +AliEbyEChargeFluctuationAnalysis::AliEbyEChargeFluctuationAnalysis() : + TObject(), + fListCFQA(0), + fListMeasureCF(0), + fEbyEBase(0) +{ + InitHistos(); + //Default constructor +} + + +//____________________________________________________________________// +AliEbyEChargeFluctuationAnalysis::~AliEbyEChargeFluctuationAnalysis() { + //Default destructor + if(fEbyEBase) delete fEbyEBase; + if(fListCFQA) delete fListCFQA; + if(fListMeasureCF) delete fListMeasureCF; + +} + +//____________________________________________________________________// +void AliEbyEChargeFluctuationAnalysis::InitHistos() { + + fListCFQA = new TList(); + fListCFQA->SetName("MFQaList"); + + fListMeasureCF = new TList(); + fListMeasureCF->SetName("MFMeasureList"); + + TH1F *fEvtStat = new TH1F("hEventCounterMH"," Event Counters for MF Analysis", 20,0,20); + fListCFQA->Add(fEvtStat); // --:0 + + + // Int_t kCentBin = fEbyEBase->GetCentralityBin(); + Int_t kCentBin = 50; +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); + 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); + 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); + 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); + 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); + 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); + fNFluc->GetXaxis()->SetTitle(" #-"); + fNFluc->GetYaxis()->SetTitle("Frequency"); + fListMeasureCF->Add(fNFluc); // -->:5 + +} + + +//____________________________________________________________________// +void AliEbyEChargeFluctuationAnalysis::Analyze(AliESDEvent* esd) { + + // Analysis from ESD + ((TH1F*)(fListCFQA->At(0)))->Fill(1.); + + Int_t kCent = 1; + + 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; + array->Add(track); + } + + Calculate(array,kCent); + + delete array; +} + + +//____________________________________________________________________// +void AliEbyEChargeFluctuationAnalysis::Analyze(AliAODEvent* aod) { + // Analysis from AOD + ((TH1F*)(fListCFQA->At(0)))->Fill(1.); + + printf("%d\n",aod->GetNTracks()); + + +} + + +//____________________________________________________________________// +void AliEbyEChargeFluctuationAnalysis::Analyze(AliStack* stack) { + // Analysis from MC stack + ((TH1F*)(fListCFQA->At(0)))->Fill(1.); + + printf("%d \n",stack->GetNtrack()); + +} + +//____________________________________________________________________________// +void AliEbyEChargeFluctuationAnalysis::Calculate(TObjArray *gTrackArray, Int_t cent){ + + Int_t i = 0; + 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}; + + for(i = 0; i < gNtrack; i++) { + if(gAnalysisLevel == "ESD") + track = dynamic_cast(gTrackArray->At(i)); + else if(gAnalysisLevel == "AOD") + track = dynamic_cast(gTrackArray->At(i)); + else if(gAnalysisLevel == "MC") + track = dynamic_cast(gTrackArray->At(i)); + Short_t charge = track->Charge(); + if(charge > 0) pCharge += 1; + if(charge < 0) nCharge += 1; + } + + par[0] = (Double_t)pCharge; + par[1] = (Double_t)nCharge; + par[2] = (Double_t)pCharge + (Double_t)nCharge; + + 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]); + +} diff --git a/PWG2/EBYE/Fluctuations/AliEbyEChargeFluctuationAnalysis.h b/PWG2/EBYE/Fluctuations/AliEbyEChargeFluctuationAnalysis.h new file mode 100644 index 00000000000..a87bad2a132 --- /dev/null +++ b/PWG2/EBYE/Fluctuations/AliEbyEChargeFluctuationAnalysis.h @@ -0,0 +1,68 @@ +#ifndef ALIEBYECHARGEFLUCTUATIONANALYSIS_H +#define ALIEBYECHARGEFLUCTUATIONANALYSIS_H + +/*------------------------------------------------------------------------ + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. + * See cxx source for full Copyright notice + * + *-----------------------------------------------------------------------*/ + +/*------------------------------------------------------------------------- + * + * AliEbyEChargeFluctuationAnalysis base class + * This class deals with the Charge fluctuation + * Origin: Satyajit Jena + * + ------------------------------------------------------------------------*/ + +#include "TObject.h" +#include "TH1I.h" + +class TF1; +class TH2D; +class TH1F; +class TList; +class AliAODEvent; +class AliAODtrack; +class AliESDEvent; +class AliESDtrack; +class AliStack; +class AliESDVertex; + +class AliEbyEEventBase; + + +class AliEbyEChargeFluctuationAnalysis : public TObject { + public: + + AliEbyEChargeFluctuationAnalysis(); + virtual ~AliEbyEChargeFluctuationAnalysis(); + + void SetBaseAnalysis(AliEbyEEventBase * const baseAnalysis) { + fEbyEBase = baseAnalysis;} + AliEbyEEventBase *GetEbyEEventBaseObject() const { + return fEbyEBase;} + + void InitHistos(); + + void Analyze(AliESDEvent *esd); + void Analyze(AliAODEvent *aod); + void Analyze(AliStack *stack); + + void Calculate(TObjArray *gTrackArray, Int_t cent); + TList *GetListCFQA() const {return fListCFQA;} + TList *GetListMeasureCF() const {return fListMeasureCF;} + + + 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 + +ClassDef(AliEbyEChargeFluctuationAnalysis,1); +}; + +#endif diff --git a/PWG2/EBYE/Fluctuations/AliEbyEEventBase.cxx b/PWG2/EBYE/Fluctuations/AliEbyEEventBase.cxx new file mode 100644 index 00000000000..b125be4ea30 --- /dev/null +++ b/PWG2/EBYE/Fluctuations/AliEbyEEventBase.cxx @@ -0,0 +1,320 @@ +/************************************************************************** + * 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. * + **************************************************************************/ + +//----------------------------------------------------------------- +// AliEbyEEventBase class +// This is the class to deal with the EbyE Fluctuation analysis +// Origin: Satyajit Jena, sjena@cern.ch +//----------------------------------------------------------------- +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +class AliLog; +class AliESDVertex; + +#include "AliEbyEEventBase.h" + +ClassImp(AliEbyEEventBase) + +//____________________________________________________________________// +AliEbyEEventBase::AliEbyEEventBase() : TObject(), + fAnalysisLevel("ESD"), + fAnalysisMode(kTPC), + fDebugMode(kFALSE), + fPhySel(0), + fListQA(0), + fNBinsX(0), + fMinX(0), + fMaxX(0), + fNBinsY(0), + fMinY(0), + fMaxY(0), + fVxMax(20.), + fVyMax(20.), + fVzMax(20.), + fCentralityType(kFlat), + fCentralityBin(50), + fCentralityEstimator("V0M"), + fCentralityPointer(0), + fFile1(""), + fFile2("") { + //Default constructor + + fListQA = new TList(); + fListQA->SetName("fListQA"); + TH1F *gHistVx = new TH1F("gHistVx", + "Vx distribution;V_{x} [cm];Entries", + 100,-5.,5.); + gHistVx->SetFillColor(kRed-2); + fListQA->Add(gHistVx);//0 + TH1F *gHistVxAccepted = new TH1F("gHistVxaccepted", + "Vx distribution;V_{x} [cm];Entries", + 100,-5.,5.); + fListQA->Add(gHistVxAccepted); //1 + TH1F *gHistVy = new TH1F("gHistVy", + "Vy distribution;V_{y} [cm];Entries", + 100,-5.,5.); + gHistVy->SetFillColor(kRed-2); + fListQA->Add(gHistVy);//2 + TH1F *gHistVyAccepted = new TH1F("gHistVyaccepted", + "Vy distribution;V_{y} [cm];Entries", + 100,-5.,5.); + fListQA->Add(gHistVyAccepted);//3 + TH1F *gHistVz = new TH1F("gHistVz", + "Vz distribution;V_{z} [cm];Entries", + 100,-25.,25.); + gHistVz->SetFillColor(kRed-2); + fListQA->Add(gHistVz);//4 + TH1F *gHistVzAccepted = new TH1F("gHistVzaccepted", + "Vz distribution;V_{z} [cm];Entries", + 100,-25.,25.); + fListQA->Add(gHistVzAccepted);//5 + + + TH2F *hCentralityQA = new TH2F("HCentralityQA","Tracks In Centrality",fCentralityBin+1,0,(Double_t)fCentralityBin+1,1000,0,20000); + fListQA->Add(hCentralityQA);//6 +} + +//____________________________________________________________________// +AliEbyEEventBase::~AliEbyEEventBase() { + if(fListQA) delete fListQA; + +} + +//____________________________________________________________________// +const AliESDVertex* AliEbyEEventBase::GetVertex(AliESDEvent* esd, + AnalysisMode mode, + Double_t gVxMax, + Double_t gVyMax, + Double_t gVzMax) { + // Vertex selection + const AliESDVertex* vertex = 0; + if((mode == kITS)||(mode == kTPCnITS)) + vertex = esd->GetPrimaryVertexSPD(); + else if(mode == kTPC){ + Double_t kBz = esd->GetMagneticField(); + AliVertexerTracks vertexer(kBz); + vertexer.SetTPCMode(); + AliESDVertex *vTPC = vertexer.FindPrimaryVertex(esd); + esd->SetPrimaryVertexTPC(vTPC); + for (Int_t i=0; iGetNumberOfTracks(); i++) { + AliESDtrack *t = esd->GetTrack(i); + t->RelateToVertexTPC(vTPC, kBz, kVeryBig); + } + delete vTPC; + vertex = esd->GetPrimaryVertexTPC(); + } + else if(mode == kGlobal) + vertex = esd->GetPrimaryVertex(); + else + Printf("GetVertex: ERROR: Invalid second argument %d", mode); + + if(!vertex) { + // if(fDebugMode) + Printf("GetVertex: Event rejected because there is no valid vertex object"); + return 0; + } + + + // check resolution + Double_t zRes = vertex->GetZRes(); + if(zRes == 0) { + if(fDebugMode) + Printf("GetVertex: Event rejected because the value of the vertex resolution in z is 0"); + return 0; + } + ((TH1F *)(fListQA->At(0)))->Fill(vertex->GetXv()); + ((TH1F *)(fListQA->At(2)))->Fill(vertex->GetYv()); + ((TH1F *)(fListQA->At(4)))->Fill(vertex->GetZv()); + + //check position + if(TMath::Abs(vertex->GetXv()) > gVxMax) { + if(fDebugMode) + Printf("GetVertex: Event rejected because it has a Vx value of %lf cm (accepted interval: -%lf - %lf)",TMath::Abs(vertex->GetXv()),gVxMax,gVxMax); + return 0; + } + if(TMath::Abs(vertex->GetYv()) > gVyMax) { + if(fDebugMode) + Printf("GetVertex: Event rejected because it has a Vy value of %lf cm (accepted interval: -%lf - %lf)",TMath::Abs(vertex->GetYv()),gVyMax,gVyMax); + return 0; + } + if(TMath::Abs(vertex->GetZv()) > gVzMax) { + if(fDebugMode) + Printf("GetVertex: Event rejected because it has a Vz value of %lf cm (accepted interval: -%lf - %lf)",TMath::Abs(vertex->GetZv()),gVzMax,gVzMax); + return 0; + } + ((TH1F *)(fListQA->At(1)))->Fill(vertex->GetXv()); + ((TH1F *)(fListQA->At(3)))->Fill(vertex->GetYv()); + ((TH1F *)(fListQA->At(5)))->Fill(vertex->GetZv()); + + return vertex; +} + +//____________________________________________________________________// +Int_t AliEbyEEventBase::GetCentrality(AliESDEvent *esd) const { + //Get the centrality + AliESDCentrality *centrality = esd->GetCentrality(); + Int_t cent = -1; + + if(fCentralityType == 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 == "MC") cent = FindCentralityMC(mult); + if(cent > -1) ((TH2F *)(fListQA->At(6)))->Fill(cent,mult); + return cent; + } + + if(fCentralityType == 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 == "MC") cent = FindCentralityMC(mult); + if(cent > -1) ((TH2F *)(fListQA->At(6)))->Fill(cent,mult); + return cent; + } + + if(fCentralityType == kAll) { + if(centrality->IsEventInCentralityClass(0,100,fCentralityEstimator)) return 0; + } + if(fCentralityType == kFlat) { + for(int i = 0; i < 50; i++) { + if(centrality->IsEventInCentralityClass(i*2,i*2+2,fCentralityEstimator)) { + cent = i; + break; + } + } + } + + if(fCentralityType == kAcc) { + for(int i = 0; i < 50; i++) { + if(centrality->IsEventInCentralityClass(0,i*2+2,fCentralityEstimator)) { + cent = i; + break; + } + } + } + + return cent; +} + +//____________________________________________________________________// +Int_t AliEbyEEventBase::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(fCentralityType == kHardFlat) { + for(Int_t i = 0; i < 100; i+=2) { + + if( (mult < data[i]) && (mult >= data[i+2]) ) + return i/2; + } + } + if(fCentralityType == kHardAcc) { + for(int i = 0; i < 100; i+=2) { + if((mult < data[0]) && (mult >data[i+2]) ) { + return i/2; + } + } + } + +return -2; + + +} + +//____________________________________________________________________// +Int_t AliEbyEEventBase::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(fCentralityType == kHardFlat) { + for(Int_t i = 0; i < 100; i+=2) { + if( (mult < data[i]) && (mult >= data[i+2]) ) + return i/2; + } + } + if(fCentralityType == kHardAcc) { + for(int i = 0; i < 100; i+=2) { + if((mult < data[0]) && (mult >= data[i+2]) ) { + return i/2; + } + } + } + + return -3; +} + diff --git a/PWG2/EBYE/Fluctuations/AliEbyEEventBase.h b/PWG2/EBYE/Fluctuations/AliEbyEEventBase.h new file mode 100644 index 00000000000..d64aede80a8 --- /dev/null +++ b/PWG2/EBYE/Fluctuations/AliEbyEEventBase.h @@ -0,0 +1,144 @@ +#ifndef ALIEBYEEVENTBASE_H +#define ALIEBYEEVENTBASE_H + + +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +/*------------------------------------------------------------------------- + * AliEbyEEventBase Base Class + * This class deals with Selectoin of Events fot MF and CF Analysis + * origin: Satyajit Jena + * + *------------------------------------------------------------------------*/ + +#include "TObject.h" +#include "TString.h" +class TH1F; +class TH2F; +class TList; + +#include "AliPhysicsSelection.h" +#include "AliBackgroundSelection.h" +#include "AliPID.h" +#include "AliESDCentrality.h" +#include "AliCentralitySelectionTask.h" +class AliESDEvent; +class AliESDtrack; +class AliESDVertex; +class AliAODTrack; +class AliMCParticle; + +class AliEbyEEventBase : public TObject { + public: + enum TriggerMode { kMB1 = 0, kMB2, kSPDFASTOR }; + enum AnalysisMode { kInvalid = -1, kTPC = 0, kITS, kTPCnITS, kForward, kGlobal }; + enum CentralityType { kHardFlat = 0, kHardAcc, kAll, kFlat, kAcc}; + //____________________________________________________________________________// + AliEbyEEventBase(); + virtual ~AliEbyEEventBase(); + //____________________________________________________________________________// + 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; + fNBinsY = nBinsY; fMinY = gYmin; fMaxY = gYmax; + } + + Int_t GetNBinsX() const {return fNBinsX;} + Int_t GetNBinsY() const {return fNBinsY;} + Double_t GetMinX() const {return fMinX;} + Double_t GetMinY() const {return fMinY;} + Double_t GetMaxX() const {return fMaxX;} + Double_t GetMaxY() const {return fMaxY;} + + // Bool_t IsInPhaseSpace(AliESDtrack *track); + + //____________________________________________________________________________// + + const AliESDVertex *GetVertex(AliESDEvent *esd, + AnalysisMode mode, + Double_t gVx = 100., + Double_t gVy = 100., + Double_t gVz = 100.); + + void SetAcceptedVertexDiamond(Double_t gVx, Double_t gVy, Double_t gVz) { + fVxMax = gVx; + fVyMax = gVy; + fVzMax = gVz; + } + 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();} + 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 FindCentralityMC(Double_t mult) const; + //____________________________________________________________________________// + private: + + TString fAnalysisLevel; //! ESD or AOD or MC + AnalysisMode fAnalysisMode; //! Global, TPC, TPCnITS kForward, kGlobal + Bool_t fDebugMode; + AliPhysicsSelection *fPhySel; //! Physics Seletection + + + TList *fListQA; + + Int_t fNBinsX; //! number of bins in y or eta + Double_t fMinX; //! max value of y or eta + Double_t fMaxX; //! max value of y or eta + Int_t fNBinsY; //! number of bins in pT + Double_t fMinY; //! Min value of pT + Double_t fMaxY; //! Max value of pT + + Double_t fVxMax; //!vertex x + Double_t fVyMax; //!vertex x + Double_t fVzMax; //!vertex x + + 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 + + + ClassDef(AliEbyEEventBase,1); +}; + +#endif diff --git a/PWG2/EBYE/Fluctuations/AliEbyEMFAnalysisTask.cxx b/PWG2/EBYE/Fluctuations/AliEbyEMFAnalysisTask.cxx new file mode 100755 index 00000000000..4b71a6aae3a --- /dev/null +++ b/PWG2/EBYE/Fluctuations/AliEbyEMFAnalysisTask.cxx @@ -0,0 +1,112 @@ + +/************************************************************************** + * 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. * + **************************************************************************/ + +/*------------------------------------------------------------------------- + * AliEbyEMFAnalysisTask Class + * This class deals with runing Multiplicity Fluctuation Task + * origin: Satyajit Jena + * MF: Multiplicity Fluctuation + *------------------------------------------------------------------------*/ + +#include "TChain.h" +#include "TString.h" +#include "TList.h" +#include "TFile.h" +#include "TTree.h" +#include "TH1F.h" +#include "TH2F.h" +#include "TH3D.h" +#include "TCanvas.h" +#include "AliAnalysisManager.h" +#include "AliVEvent.h" +#include "AliESD.h" +#include "AliESDEvent.h" +#include "AliAODEvent.h" +#include "AliEbyEEventBase.h" +#include "AliEbyEMultiplicityFluctuationAnalysis.h" +#include "AliEbyEMFAnalysisTask.h" + +ClassImp(AliEbyEMFAnalysisTask) + +//________________________________________________________________________ +AliEbyEMFAnalysisTask::AliEbyEMFAnalysisTask(const char *name) + : AliAnalysisTaskSE(name), + fListPhy(0), + fEbyEMFBase(0), + fEvtCounter(0), + fECnt(0) + +{ + // DefineInput(0, TChain::Class()); + DefineOutput(1, TList::Class()); +} + +//________________________________________________________________________ +void AliEbyEMFAnalysisTask::UserCreateOutputObjects() +{ + fListPhy = new TList(); + + fEvtCounter = new TH1F("hEvtCounter","Event Statistic",50,0,50); + fListPhy->Add(fEvtCounter); + fListPhy->Add(dynamic_cast(fEbyEMFBase->GetEbyEEventBaseObject())->GetQA()); + fListPhy->Add(fEbyEMFBase->GetListMFQA()); + fListPhy->Add(fEbyEMFBase->GetListMeasureMF()); + + PostData(1, fListPhy); +} + +//________________________________________________________________________ +void AliEbyEMFAnalysisTask::UserExec(Option_t *) +{ + + fEvtCounter->Fill(0); + fECnt++; + + TString gAnalType = dynamic_cast(fEbyEMFBase->GetEbyEEventBaseObject())->GetAnalysisLevel(); + + if(gAnalType == "ESD") + { + AliESDEvent* gESD = dynamic_cast(InputEvent()); + if (!gESD) { + Printf("ERROR: gESD not available"); + return; + } + + const AliESDVertex *vertex = dynamic_cast(fEbyEMFBase->GetEbyEEventBaseObject())->GetVertex(gESD,dynamic_cast(fEbyEMFBase->GetEbyEEventBaseObject())->GetAnalysisMode(),dynamic_cast(fEbyEMFBase->GetEbyEEventBaseObject())->GetVxMax(),dynamic_cast(fEbyEMFBase->GetEbyEEventBaseObject())->GetVyMax(),dynamic_cast(fEbyEMFBase->GetEbyEEventBaseObject())->GetVzMax()); + + if(vertex){ + + fEbyEMFBase->Analyze(gESD); + + } + + } + PostData(1, fListPhy); + +} + +//______________________________________________________________________// +void AliEbyEMFAnalysisTask::Terminate(Option_t *) { + +fListPhy = dynamic_cast (GetOutputData(1)); + if (!fListPhy) { + Error("Terminate","Out Put List not available"); + return; + } + + Info("AliEbyEMFAnalysisTask"," AliEbyEMFAnalysisTask Successfully finished"); + +} diff --git a/PWG2/EBYE/Fluctuations/AliEbyEMFAnalysisTask.h b/PWG2/EBYE/Fluctuations/AliEbyEMFAnalysisTask.h new file mode 100755 index 00000000000..dc304deac55 --- /dev/null +++ b/PWG2/EBYE/Fluctuations/AliEbyEMFAnalysisTask.h @@ -0,0 +1,53 @@ +#ifndef ALIEBYEMFANALYSISTASK_H +#define ALIEBYEMFANALYSISTASK_H + + +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +/*------------------------------------------------------------------------- + * AliEbyEMFAnalysisTask Class + * This class deals with runing Multiplicity Fluctuation Task + * origin: Satyajit Jena + * + *------------------------------------------------------------------------*/ + + +class TString; +class TH1F; +class TH2F; + +class TList; + +#include "AliAnalysisTaskSE.h" + +class AliEbyEEventBase; +class AliEbyEMultiplicityFluctuationAnalysis; + +class AliEbyEMFAnalysisTask: public AliAnalysisTaskSE { + public: + AliEbyEMFAnalysisTask(const char *name = "AliEbyEMFAnalysisTask"); + virtual ~AliEbyEMFAnalysisTask() {} + + virtual void UserCreateOutputObjects(); + virtual void UserExec(Option_t *option); + virtual void Terminate(Option_t *); + + void SetAnalysisObject(AliEbyEMultiplicityFluctuationAnalysis *const analysis) { fEbyEMFBase = analysis;} + + private: + + TList *fListPhy; + + AliEbyEMultiplicityFluctuationAnalysis *fEbyEMFBase; + TH1F *fEvtCounter; + Int_t fECnt; + + AliEbyEMFAnalysisTask(const AliEbyEMFAnalysisTask&); + AliEbyEMFAnalysisTask& operator=(const AliEbyEMFAnalysisTask&); + + ClassDef(AliEbyEMFAnalysisTask, 1); +}; + +#endif + diff --git a/PWG2/EBYE/Fluctuations/AliEbyEMultiplicityFluctuationAnalysis.cxx b/PWG2/EBYE/Fluctuations/AliEbyEMultiplicityFluctuationAnalysis.cxx new file mode 100644 index 00000000000..842af498c38 --- /dev/null +++ b/PWG2/EBYE/Fluctuations/AliEbyEMultiplicityFluctuationAnalysis.cxx @@ -0,0 +1,124 @@ +/************************************************************************** + * 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. * + **************************************************************************/ + +/*------------------------------------------------------------------------- + * + * AliEbyEMultiplicityFluctuationAnalysis base class + * This class deals with the multiplicity fluctuation + * Origin: Satyajit Jena + * + ------------------------------------------------------------------------*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "AliEbyEEventBase.h" +#include "AliEbyEMultiplicityFluctuationAnalysis.h" + +ClassImp(AliEbyEMultiplicityFluctuationAnalysis) + +//____________________________________________________________________// +AliEbyEMultiplicityFluctuationAnalysis::AliEbyEMultiplicityFluctuationAnalysis() : + TObject(), + fListMFQA(0), + fListMeasureMF(0), + fEbyEBase(0) +{ + //Default constructor + InitHistos(); + +} + +//____________________________________________________________________// +AliEbyEMultiplicityFluctuationAnalysis::~AliEbyEMultiplicityFluctuationAnalysis() { + + //Default destructor + if(fEbyEBase) delete fEbyEBase; + if(fListMFQA) delete fListMFQA; + if(fListMeasureMF) delete fListMeasureMF; + +} + +//____________________________________________________________________// +void AliEbyEMultiplicityFluctuationAnalysis::InitHistos() { + + fListMFQA = new TList(); + fListMFQA->SetName("MFQaList"); + + fListMeasureMF = new TList(); + fListMeasureMF->SetName("MFMeasureList"); + + 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 + + +} + + +//____________________________________________________________________// +void AliEbyEMultiplicityFluctuationAnalysis::Analyze(AliESDEvent* esd) { + + // Analysis from ESD + Int_t cent = 0; + + ((TH1F*)(fListMFQA->At(0)))->Fill(1.); + Int_t itr = esd->GetNumberOfTracks(); + ((TH2F*)(fListMeasureMF->At(0)))->Fill(cent,itr); + +} + + +//____________________________________________________________________// +void AliEbyEMultiplicityFluctuationAnalysis::Analyze(AliAODEvent* aod) { + // Analysis from AOD + ((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.); + + printf("%d \n",stack->GetNtrack()); + + +} diff --git a/PWG2/EBYE/Fluctuations/AliEbyEMultiplicityFluctuationAnalysis.h b/PWG2/EBYE/Fluctuations/AliEbyEMultiplicityFluctuationAnalysis.h new file mode 100644 index 00000000000..3013d59c6c2 --- /dev/null +++ b/PWG2/EBYE/Fluctuations/AliEbyEMultiplicityFluctuationAnalysis.h @@ -0,0 +1,67 @@ +#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 + * + ------------------------------------------------------------------------*/ + + +#include "TObject.h" +#include "TH1I.h" + +class TF1; +class TH2D; +class TH1F; +class TList; +class AliAODEvent; +class AliAODtrack; +class AliESDEvent; +class AliESDtrack; +class AliStack; + +class AliEbyEEventBase; + +class AliEbyEMultiplicityFluctuationAnalysis : public TObject { + public: + + AliEbyEMultiplicityFluctuationAnalysis(); + virtual ~AliEbyEMultiplicityFluctuationAnalysis(); + + void SetBaseAnalysis(AliEbyEEventBase * const baseAnalysis) { fEbyEBase = baseAnalysis;} + AliEbyEEventBase *GetEbyEEventBaseObject() const { return fEbyEBase;} + + void InitHistos(); + + void Analyze(AliESDEvent *esd); + void Analyze(AliAODEvent *aod); + void Analyze(AliStack *stack); + + TList *GetListMFQA() const {return fListMFQA;} + TList *GetListMeasureMF() {return fListMeasureMF;} + + private: + + 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); +}; + +#endif diff --git a/PWG2/EBYE/Fluctuations/macro/AddTaskCF.C b/PWG2/EBYE/Fluctuations/macro/AddTaskCF.C new file mode 100644 index 00000000000..5174d769a38 --- /dev/null +++ b/PWG2/EBYE/Fluctuations/macro/AddTaskCF.C @@ -0,0 +1,53 @@ +/************************************************ + Charge Flatuation analysis task + + Auther: Satyajit Jena + Email: sjena@cern.ch + Mon Oct 25 12:47:38 CEST 2010 + +*************************************************/ + +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; + } + + TString type = mgr->GetInputEventHandler()->GetDataType(); + TString OutName; + OutName="CF."+type; + TString outputFileName = AliAnalysisManager::GetCommonFileName(); + + // getting default name + + outputFileName += ":PWG2EbyE_CF"; // adding directory type + + gROOT->LoadMacro("$ALICE_ROOT/PWG2/EBYE/Fluctuations/macro/ConfigureCFAnalysis.C"); + + AliEbyEChargeFluctuationAnalysis *analysis = GetAnalysisCFObject(); + + AliEbyECFAnalysisTask *taskCF + = new AliEbyECFAnalysisTask("AliEbyECFAnalysisTask"); + + taskCF->SetAnalysisObject(analysis); + + mgr->AddTask(taskCF); + + AliAnalysisDataContainer *cout + = mgr->CreateContainer(OutName, TList::Class(), + AliAnalysisManager::kOutputContainer, + outputFileName.Data()); + + mgr->ConnectInput(taskCF, 0, mgr->GetCommonInputContainer()); + mgr->ConnectOutput(taskCF, 1, cout); + return taskCF; + +} + diff --git a/PWG2/EBYE/Fluctuations/macro/AddTaskMF.C b/PWG2/EBYE/Fluctuations/macro/AddTaskMF.C new file mode 100644 index 00000000000..d3883316637 --- /dev/null +++ b/PWG2/EBYE/Fluctuations/macro/AddTaskMF.C @@ -0,0 +1,53 @@ +/************************************************ + 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("AddTaskMF", "ERROR: No Analysis Manager"); + return NULL; + } + + if (!mgr->GetInputEventHandler()) { + Error("AddTaskMF", "ERROR: No input event handler"); + return NULL; + } + + TString type = mgr->GetInputEventHandler()->GetDataType(); + TString OutName; + OutName="MF."+type; + TString outputFileName = AliAnalysisManager::GetCommonFileName(); + + // getting default name + + outputFileName += ":PWG2EbyE_MF"; // adding directory type + + gROOT->LoadMacro("$ALICE_ROOT/PWG2/EBYE/Fluctuations/macro/ConfigureMFAnalysis.C"); + + AliEbyEMultiplicityFluctuationAnalysis *analysis = GetAnalysisMFObject(); + + AliEbyEMFAnalysisTask *taskMF + = new AliEbyEMFAnalysisTask("AliEbyEMFAnalysisTask"); + + taskMF->SetAnalysisObject(analysis); + + mgr->AddTask(taskMF); + + AliAnalysisDataContainer *cout + = mgr->CreateContainer(OutName, TList::Class(), + AliAnalysisManager::kOutputContainer, + outputFileName.Data()); + + mgr->ConnectInput(taskMF, 0, mgr->GetCommonInputContainer()); + mgr->ConnectOutput(taskMF, 1, cout); + return taskMF; + +} + diff --git a/PWG2/EBYE/Fluctuations/macro/ConfigureCFAnalysis.C b/PWG2/EBYE/Fluctuations/macro/ConfigureCFAnalysis.C new file mode 100644 index 00000000000..96de80889b2 --- /dev/null +++ b/PWG2/EBYE/Fluctuations/macro/ConfigureCFAnalysis.C @@ -0,0 +1,13 @@ +//__________________________________________________// +AliEbyEChargeFluctuationAnalysis *GetAnalysisCFObject() { + + gROOT->LoadMacro("$ALICE_ROOT/PWG2/EBYE/Fluctuations/macro/ConfigureEbyEBaseObject.C"); + AliEbyEEventSelector *base = 0; + base = GetEbyEAnalysisBaseObject(); + + AliEbyEChargeFluctuationAnalysis *analysis = new AliEbyEChargeFluctuationAnalysis(); + + analysis->SetBaseAnalysis(base); + return analysis; +} + diff --git a/PWG2/EBYE/Fluctuations/macro/ConfigureEbyEBaseObject.C b/PWG2/EBYE/Fluctuations/macro/ConfigureEbyEBaseObject.C new file mode 100644 index 00000000000..6811fe27008 --- /dev/null +++ b/PWG2/EBYE/Fluctuations/macro/ConfigureEbyEBaseObject.C @@ -0,0 +1,80 @@ +/************************************************************************* + Configure Macro to set all cuts for Fluctuation Study + AliEbyEEventSelector | Implimented + Origin: Satyajit Jena + Date:Mon Nov 22 22:15:40 CET 2010 + *************************************************************************/ + +AliEbyEEventSelector *GetEbyEAnalysisBaseObject(const char* analysisLevel = "ESD", + const char* esdAnalysisType = "kGlobal", + Bool_t kUseOnlineTrigger = kFALSE, + Bool_t kUseOfflineTrigger = kFALSE, + const char* CentralityType = "HardType") + +{ + + AliEbyEEventSelector *base = new AliEbyEEventSelector(); + base->SetAnalysisLevel(analysisLevel); + + base->SetCentralityBin(50); + if(CentralityType == "HardType") { + base->SetCentralityType(AliEbyEEventSelector::kHardFlat); + base->SetCentralityEstimator("V0M"); + + printf(" I am Inside centrality Flat \n"); + } + + if (CentralityType == "Central") { + base->SetCentralityType(AliEbyEEventSelector::kFlat); + base->SetCentralityEstimator("V0M"); + base->SetCentralityInputFiles("$ALICE_ROOT/ANALYSIS/macros/AliCentralityBy1D_LHC10g2a_100.root", + "$ALICE_ROOT/ANALYSIS/macros/AliCentralityByFunction_LHC10g2a_100.root"); + } + + if(analysisLevel == "ESD") { + /* if(kAnalyzeMC) + base->SetTriggerMode(AliEbyEEventSelector::kMB2); + if(kUseOnlineTrigger) base->UseOnlineTrigger(); + if(kUseOfflineTrigger) base->OfflineTriggerInit(); + + */ + + switch(esdAnalysisType) { + case "TPC": + base->SetAnalysisMode(AliEbyEEventSelector::kTPC); + base->SetPhaseSpace(10, -0.5, 0.5, 16, 0.5, 0.9); + break; + + case "ITS": + base->SetAnalysisMode(AliEbyEEventSelector::kITS); + base->SetPhaseSpace(9, -0.9, 0.9, 6, 0.45, 1.05); + break; + + case "TPCnITS": + base->SetAnalysisMode(AliEbyEEventSelector::kTPCnITS); + base->SetPhaseSpace(9, -0.9, 0.9, 6, 0.45, 1.05); + break; + + case "Global": + base->SetAnalysisMode(AliEbyEEventSelector::kGlobal); + base->SetPhaseSpace(20, -1.0, 1.0, 48, 0.3, 1.5); + break; + + case "Forward": + base->SetAnalysisMode(AliEbyEEventSelector::kForward); + base->SetPhaseSpace(20, -1.0, 1.0, 48, 0.3, 1.5); + break; + + default: + break; + } + base->SetAcceptedVertexDiamond(1.,1.,10.); + + } + 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); + + return base; +} diff --git a/PWG2/EBYE/Fluctuations/macro/ConfigureMFAnalysis.C b/PWG2/EBYE/Fluctuations/macro/ConfigureMFAnalysis.C new file mode 100644 index 00000000000..7f58f2a54bc --- /dev/null +++ b/PWG2/EBYE/Fluctuations/macro/ConfigureMFAnalysis.C @@ -0,0 +1,13 @@ +//__________________________________________________// +AliEbyEMultiplicityFluctuationAnalysis *GetAnalysisMFObject() { + + gROOT->LoadMacro("$ALICE_ROOT/PWG2/EBYE/Fluctuations/macro/ConfigureEbyEBaseObject.C"); + AliEbyEEventSelector *base = 0; + base = GetEbyEAnalysisBaseObject(); + + AliEbyEMultiplicityFluctuationAnalysis *analysis = new AliEbyEMultiplicityFluctuationAnalysis(); + + analysis->SetBaseAnalysis(base); + return analysis; +} + diff --git a/PWG2/EBYE/Fluctuations/macro/file.txt b/PWG2/EBYE/Fluctuations/macro/file.txt new file mode 100644 index 00000000000..506cee77602 --- /dev/null +++ b/PWG2/EBYE/Fluctuations/macro/file.txt @@ -0,0 +1,23 @@ +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.100/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1000/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1010/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1020/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1030/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1040/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1050/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1060/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1070/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1080/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1090/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.110/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1100/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1110/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1120/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1130/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1140/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1150/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1160/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1170/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1180/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1190/AliESDs.root +/Users/sjena/data/temp/pass1_plusplusplus/10000137161001.1200/AliESDs.root diff --git a/PWG2/EBYE/Fluctuations/macro/runTaskCF.C b/PWG2/EBYE/Fluctuations/macro/runTaskCF.C new file mode 100644 index 00000000000..9acc915e38f --- /dev/null +++ b/PWG2/EBYE/Fluctuations/macro/runTaskCF.C @@ -0,0 +1,148 @@ +/**************************************************************** + +runs for Analysis Charge Fluctuation Task +Author: Satyajit Jena +Email: sjena@cern.ch + +Running in Local = analmode = local, +input list of files, number of esds +useMC and format + +and AFF = analmode = "proof" and +data set. + +*******************************************************************/ + +void runTaskCF(TString analmode = "local") +{ + + // TString analmode = "local"; + // TString analmode = "proof"; + TString dataset = "/PMD/sjena/LHC10a10_2360Gev_pythia"; + Bool_t useMC = kFALSE; + TString format="esd"; + TString output = "test.root"; + + + if(analmode.CompareTo("local") == 0) + { + if(!LoadLibraries(analmode)) + { + printf("Library Not loaded\n"); + return; + } + runLocal("file.txt",5, useMC, format, output); + + } + else if(analmode.CompareTo("proof") == 0) + { + if(!LoadLibraries(analmode)) return; + runproof(dataset, useMC); + + + } + 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) + { + TString proofCluster="alice-caf.cern.ch"; + TString alirootVer = "VO_ALICE@AliRoot::v4-20-11-AN"; + + gEnv->SetValue("XSec.GSI.DelegProxy","2"); + TProof *p = TProof::Open(proofCluster.Data()); + + p->ShowPackages(); + p->EnablePackage(alirootVer.Data()); + + return kTRUE; + + } + else + { + printf(" ERROR: Give proper running mode \n"); + return kFALSE; + } + +} +//______________________________________________________________________ +// Running local +void runLocal(TString input,int nfile, Bool_t useMC, TString format,TString OutPutFile) +{ + + 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("$ALICE_ROOT/PWG2/EBYE/Fluctuations/AliEbyEEventSelector.cxx++g"); +// gROOT->LoadMacro("$ALICE_ROOT/PWG2/EBYE/Fluctuations/AliEbyEChargeFluctuationAnalysis.cxx++g"); +// gROOT->LoadMacro("$ALICE_ROOT/PWG2/EBYE/Fluctuations/AliEbyECFAnalysisTask.cxx++g"); + gROOT->LoadMacro("$ALICE_ROOT/PWG2/EBYE/Fluctuations/macro/AddTaskCF.C"); + AddTaskCF(); + + mgr->SetDebugLevel(0); + + if (!mgr->InitAnalysis()) return; + mgr->PrintStatus(); + + mgr->InitAnalysis(); + mgr->StartAnalysis("local", chain); + + +} + + +//________________________________________________________ +//Running in proof + +void runproof(TString dataset, Bool_t useMC) +{ + + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) mgr = new AliAnalysisManager("FirstCheck"); + + AliVEventHandler* esdH = new AliESDInputHandler(); + mgr->SetInputEventHandler(esdH); + + gProof->LoadMacro("$ALICE_ROOT/PWG2/EBYE/Fluctuations/AliEbyEEventSelector.cxx++g"); + gProof->LoadMacro("$ALICE_ROOT/PWG2/EBYE/Fluctuations/AliEbyEMFAnalysisTask.cxx++g"); + gProof->LoadMacro("$ALICE_ROOT/PWG2/EBYE/Fluctuations/macro/AddTaskMF.C"); + AddTaskMF(); + + mgr->SetDebugLevel(0); + + if (!mgr->InitAnalysis()) + return; + + mgr->PrintStatus(); + mgr->InitAnalysis(); + + mgr->StartAnalysis("proof",dataset.Data()); + +} + +//_________________ +//Runningin grid diff --git a/PWG2/EBYE/Fluctuations/macro/runTaskMF.C b/PWG2/EBYE/Fluctuations/macro/runTaskMF.C new file mode 100644 index 00000000000..1ce0d2b3ea0 --- /dev/null +++ b/PWG2/EBYE/Fluctuations/macro/runTaskMF.C @@ -0,0 +1,146 @@ +/**************************************************************** + +Lunch the Analysis Task for Multiplicity Fluctuation +Author: Satyajit Jena +Email: sjena@cern.ch + +Running in Local = analmode = local, +input list of files, number of esds +useMC and format + +and AFF = analmode = "proof" and +data set. + +*******************************************************************/ + +void runTaskMF(TString analmode = "local") +{ + + TString dataset = "/PMD/sjena/LHC10a10_2360Gev_pythia"; + Bool_t useMC = kFALSE; + TString format="esd"; + TString output = "test.root"; + + + if(analmode.CompareTo("local") == 0) + { + if(!LoadLibraries(analmode)) + { + printf("Library Not loaded\n"); + return; + } + runLocal("file.txt",5, useMC, format, output); + + } + else if(analmode.CompareTo("proof") == 0) + { + if(!LoadLibraries(analmode)) return; + runproof(dataset, useMC); + + + } + 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) + { + TString proofCluster="alice-caf.cern.ch"; + TString alirootVer = "VO_ALICE@AliRoot::v4-20-11-AN"; + + gEnv->SetValue("XSec.GSI.DelegProxy","2"); + TProof *p = TProof::Open(proofCluster.Data()); + + p->ShowPackages(); + p->EnablePackage(alirootVer.Data()); + + return kTRUE; + + } + else + { + printf(" ERROR: Give proper running mode \n"); + return kFALSE; + } + +} +//______________________________________________________________________ +// Running local +void runLocal(TString input,int nfile, Bool_t useMC, TString format,TString OutPutFile) +{ + + 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("$ALICE_ROOT/PWG2/EBYE/Fluctuations/AliEbyEEventSelector.cxx++g"); +// gROOT->LoadMacro("$ALICE_ROOT/PWG2/EBYE/Fluctuations/AliEbyEMultiplicityFluctuationAnalysis.cxx++g"); +// gROOT->LoadMacro("$ALICE_ROOT/PWG2/EBYE/Fluctuations/AliEbyEMFAnalysisTask.cxx++g"); + gROOT->LoadMacro("$ALICE_ROOT/PWG2/EBYE/Fluctuations/macro/AddTaskMF.C"); + AddTaskMF(); + + mgr->SetDebugLevel(0); + + if (!mgr->InitAnalysis()) return; + mgr->PrintStatus(); + + mgr->InitAnalysis(); + mgr->StartAnalysis("local", chain); + + +} + + +//________________________________________________________ +//Running in proof + +void runproof(TString dataset, Bool_t useMC) +{ + + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) mgr = new AliAnalysisManager("FirstCheck"); + + AliVEventHandler* esdH = new AliESDInputHandler(); + mgr->SetInputEventHandler(esdH); + + gProof->LoadMacro("$ALICE_ROOT/PWG2/EBYE/Fluctuations/AliEbyEEventSelector.cxx++g"); + gProof->LoadMacro("$ALICE_ROOT/PWG2/EBYE/Fluctuations/AliEbyEMFAnalysisTask.cxx++g"); + gProof->LoadMacro("$ALICE_ROOT/PWG2/EBYE/Fluctuations/macro/AddTaskMF.C"); + AddTaskMF(); + + mgr->SetDebugLevel(0); + + if (!mgr->InitAnalysis()) + return; + + mgr->PrintStatus(); + mgr->InitAnalysis(); + + mgr->StartAnalysis("proof",dataset.Data()); + +} + +//_________________ +//Runningin grid -- 2.43.0