//================================================================================================================
-AliAnalysisTaskQCumulants::AliAnalysisTaskQCumulants(const char *name, Bool_t on):
+AliAnalysisTaskQCumulants::AliAnalysisTaskQCumulants(const char *name, Bool_t on, Bool_t useWeights):
AliAnalysisTask(name,""),
fESD(NULL),
fAOD(NULL),
fListHistos(NULL),
fQAInt(NULL),
fQADiff(NULL),
- fQA(on)
+ fQA(on),
+ fUseWeights(useWeights),
+ fUsePhiWeights(kFALSE),
+ fUsePtWeights(kFALSE),
+ fUseEtaWeights(kFALSE),
+ fListWeights(NULL)
{
//constructor
cout<<"AliAnalysisTaskQCumulants::AliAnalysisTaskQCumulants(const char *name)"<<endl;
// Input slot #0 works with a TChain
DefineInput(0, TChain::Class());
+ // Input slot #1 is needed for the weights
+ if(useWeights)
+ {
+ DefineInput(1, TList::Class());
+ }
+
// Output slot #0 writes into a TList container
DefineOutput(0, TList::Class());
if(on)
DefineOutput(1, TList::Class());
DefineOutput(2, TList::Class());
}
+
}
AliAnalysisTaskQCumulants::AliAnalysisTaskQCumulants():
fListHistos(NULL),
fQAInt(NULL),
fQADiff(NULL),
- fQA(kFALSE)
+ fQA(kFALSE),
+ fUseWeights(kFALSE),
+ fUsePhiWeights(kFALSE),
+ fUsePtWeights(kFALSE),
+ fUseEtaWeights(kFALSE),
+ fListWeights(NULL)
{
//dummy constructor
cout<<"AliAnalysisTaskQCumulants::AliAnalysisTaskQCumulants()"<<endl;
//analyser
fQCA = new AliFlowAnalysisWithQCumulants();
fQCA->Init();
-
+
+ //weights:
+ if(fUseWeights)
+ {
+ //pass the flags to class:
+ if(fUsePhiWeights) fQCA->SetUsePhiWeights(fUsePhiWeights);
+ if(fUsePtWeights) fQCA->SetUsePtWeights(fUsePtWeights);
+ if(fUseEtaWeights) fQCA->SetUseEtaWeights(fUseEtaWeights);
+ //get data from input slot #1 which is used for weights:
+ if(GetNinputs()==2)
+ {
+ fListWeights = (TList*)GetInputData(1);
+ }
+ //pass the list with weights to class:
+ if(fListWeights) fQCA->SetWeightsList(fListWeights);
+ }
+
if(fQCA->GetHistList())
{
fListHistos = fQCA->GetHistList();
{
Printf("ERROR: Could not retrieve histogram list");
}
-
+
//PostData(0,fListHistos);
}
{
PostData(1,fQAInt);
PostData(2,fQADiff);
- }
+ }
}
//================================================================================================================
//accessing the output list which contains the merged 2D and 3D profiles from all worker nodes
fListHistos = (TList*)GetOutputData(0);
//fListHistos->Print();
-
+
if(fListHistos)
{
//final results (integrated flow)
class AliAnalysisTaskQCumulants : public AliAnalysisTask{
public:
AliAnalysisTaskQCumulants();
- AliAnalysisTaskQCumulants(const char *name, Bool_t QAon = kFALSE);
+ AliAnalysisTaskQCumulants(const char *name, Bool_t QAon = kFALSE, Bool_t useWeights=kFALSE);
virtual ~AliAnalysisTaskQCumulants(){};
virtual void ConnectInputData(Option_t *);
TList* GetQAList2() {return this->fQADiff; }
void SetQAOn(Bool_t kt) {this->fQA = kt; }
Bool_t GetQAOn() {return this->fQA; }
+
+ void SetUsePhiWeights(Bool_t const uPhiW) {this->fUsePhiWeights = uPhiW;};
+ Bool_t GetUsePhiWeights() const {return this->fUsePhiWeights;};
+ void SetUsePtWeights(Bool_t const uPtW) {this->fUsePtWeights = uPtW;};
+ Bool_t GetUsePtWeights() const {return this->fUsePtWeights;};
+ void SetUseEtaWeights(Bool_t const uEtaW) {this->fUseEtaWeights = uEtaW;};
+ Bool_t GetUseEtaWeights() const {return this->fUseEtaWeights;};
private:
AliAnalysisTaskQCumulants(const AliAnalysisTaskQCumulants& aatqc);
AliCFManager* fCFManager2; //correction framework manager
TList *fListHistos; //collection of output
- TList* fQAInt; // QA histogram list
- TList* fQADiff; // QA histogram list
+ TList* fQAInt; // QA histogram list
+ TList* fQADiff; // QA histogram list
- Bool_t fQA; // flag to set the filling of the QA hostograms
+ Bool_t fQA; // flag to set the filling of the QA hostograms
+
+ Bool_t fUseWeights; // use any weights
+ Bool_t fUsePhiWeights; // phi weights
+ Bool_t fUsePtWeights; // v_2(pt) weights
+ Bool_t fUseEtaWeights; // v_2(eta) weights
+ TList* fListWeights; // list with weights
ClassDef(AliAnalysisTaskQCumulants, 1);
};
void SetDirectCorrelations(TProfile* const dc) {this->fDirectCorrelations = dc;};
TProfile* GetDirectCorrelations() const {return this->fDirectCorrelations;};
- void SetUsePhiWeights(Bool_t const) {this->fUsePhiWeights = kTRUE;};
+ void SetUsePhiWeights(Bool_t const uPhiW) {this->fUsePhiWeights = uPhiW;};
Bool_t GetUsePhiWeights() const {return this->fUsePhiWeights;};
- void SetUsePtWeights(Bool_t const) {this->fUsePtWeights = kTRUE;};
+ void SetUsePtWeights(Bool_t const uPtW) {this->fUsePtWeights = uPtW;};
Bool_t GetUsePtWeights() const {return this->fUsePtWeights;};
- void SetUseEtaWeights(Bool_t const) {this->fUseEtaWeights = kTRUE;};
+ void SetUseEtaWeights(Bool_t const uEtaW) {this->fUseEtaWeights = uEtaW;};
Bool_t GetUseEtaWeights() const {return this->fUseEtaWeights;};
//----------------------------------------------------------------------------------------------------------------
{
wEta=etaWeights->GetBinContent(1+(Int_t)(TMath::Floor(dEta/dBinWidthEta)))/dNormEta;
}
-
+
//building up the weighted Q-vector:
dQX += wPhi*wPt*wEta*TMath::Cos(iOrder*dPhi);
dQY += wPhi*wPt*wEta*TMath::Sin(iOrder*dPhi);
//SETTING THE ANALYSIS
//Flow analysis methods can be: (set to kTRUE or kFALSE)
-Bool_t SP = kTRUE;
-Bool_t LYZ1 = kTRUE;
+Bool_t SP = kFALSE;
+Bool_t LYZ1 = kFALSE;
Bool_t LYZ2 = kFALSE;
Bool_t LYZEP = kFALSE;
-Bool_t GFC = kTRUE;
+Bool_t GFC = kFALSE;
Bool_t QC = kTRUE;
-Bool_t FQD = kTRUE;
-Bool_t MCEP = kTRUE;
+Bool_t FQD = kFALSE;
+Bool_t MCEP = kFALSE;
//Type of analysis can be:
const Int_t minclustersTPC2 = 50;
const Int_t maxnsigmatovertex2 = 3;
+//WEIGHTS SETTINGS:
+//to use or not to use the weights - that is a question!
+Bool_t usePhiWeights = kTRUE; //Phi
+Bool_t usePtWeights = kFALSE; //v'(pt)
+Bool_t useEtaWeights = kFALSE; //v'(eta)
+Bool_t useWeights = usePhiWeights||usePtWeights||usePtWeights;
-//void runAliAnalysisTaskFlow(Int_t nRuns = 10, const Char_t* dataDir="/data/alice2/kolk/Therminator_midcentral", Int_t offset = 0)
-void runAliAnalysisTaskFlow(Int_t nRuns = -1, const Char_t* dataDir="/Users/snelling/alice_data/Therminator_midcentral", Int_t offset = 0)
+void runAliAnalysisTaskFlow(Int_t nRuns = 4, const Char_t* dataDir="/data/alice2/kolk/Therminator_midcentral", Int_t offset = 0)
+//void runAliAnalysisTaskFlow(Int_t nRuns = -1, const Char_t* dataDir="/Users/snelling/alice_data/Therminator_midcentral", Int_t offset = 0)
{
TStopwatch timer;
cfmgr2->SetParticleCutsList(AliCFManager::kPartRecCuts,recList2);
cfmgr2->SetParticleCutsList(AliCFManager::kPartSelCuts,fPIDCutList2);
+ //weights:
+ TFile *weightsFile = NULL;
+ TList *weightsList = NULL;
+
+ if(useWeights)
+ {
+ //open the file with the weights:
+ weightsFile = TFile::Open("weights.root","READ");
+ if(weightsFile)
+ {
+ //access the list which holds the histos with weigths:
+ weightsList = (TList*)weightsFile->Get("weights");
+ }else{cout<<" WARNING: the file <weights.root> with weights from the previuos run was not accessed."<<endl;}
+ }//end of if(useWeights)
if (LYZ2){
// read the input file from the first run
mgr->AddTask(taskGFC);
}
if (QC){
- if (QA) { AliAnalysisTaskQCumulants *taskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",kTRUE);}
- else { AliAnalysisTaskQCumulants *taskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",kFALSE);}
+ if (QA) { AliAnalysisTaskQCumulants *taskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",kTRUE,useWeights);}
+ else { AliAnalysisTaskQCumulants *taskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",kFALSE,useWeights);}
taskQC->SetAnalysisType(type);
+ taskQC->SetUsePhiWeights(usePhiWeights);
+ taskQC->SetUsePtWeights(usePtWeights);
+ taskQC->SetUseEtaWeights(useEtaWeights);
taskQC->SetCFManager1(cfmgr1);
taskQC->SetCFManager2(cfmgr2);
if (QA) {
// Create containers for input/output
-
AliAnalysisDataContainer *cinput1 =
mgr->CreateContainer("cchain1",TChain::Class(),AliAnalysisManager::kInputContainer);
+
+ //AliAnalysisDataContainer *cinputWeights = NULL;
+ if(useWeights)
+ {
+ cinputWeights = mgr->CreateContainer("cobjWeights",TList::Class(),AliAnalysisManager::kInputContainer);
+ }
if (LYZ2){
AliAnalysisDataContainer *cinputLYZ2 =
mgr->ConnectOutput(taskQC,0,coutputQC);
if (QA) { mgr->ConnectOutput(taskQC,1,coutputQA1QC);
mgr->ConnectOutput(taskQC,2,coutputQA2QC); }
+ if(useWeights)
+ {
+ mgr->ConnectInput(taskQC,1,cinputWeights);
+ cinputWeights->SetData(weightsList);
+ }
}
if (FQD) {
mgr->ConnectInput(taskFQD,0,cinput1);
///////////////////////////////////////////////////////////////////////////////////
-//RUN SETTINGS
-
+//RUN SETTINGS:
//Flow analysis method can be:(set to kTRUE or kFALSE)
-Bool_t SP = kTRUE;
+Bool_t SP = kFALSE;
Bool_t LYZ1 = kTRUE;
Bool_t LYZ2 = kFALSE;
Bool_t LYZEP = kFALSE;
-Bool_t GFC = kFALSE;
+Bool_t GFC = kTRUE;
Bool_t QC = kTRUE;
Bool_t FQD = kTRUE;
-Bool_t MCEP = kFALSE;
+Bool_t MCEP = kTRUE;
//analysis type can be ESD, AOD, MC, ESDMC0, ESDMC1
const TString type = "ESD";
//Bolean to fill/not fill the QA histograms
Bool_t QA = kFALSE;
-//SETTING THE CUTS
-
+//SETTING THE CUTS:
//for integrated flow
const Double_t ptmin1 = 0.0;
-const Double_t ptmax1 = 1000.0;
+const Double_t ptmax1 = 10.0;
const Double_t ymin1 = -1.;
const Double_t ymax1 = 1.;
const Int_t mintrackrefsTPC1 = 2;
const Int_t mintrackrefsITS1 = 3;
const Int_t charge1 = 1;
-Bool_t UsePIDIntegratedFlow = kFALSE;
+Bool_t UsePIDIntegratedFlow = kTRUE;
const Int_t PDG1 = 211;
const Int_t minclustersTPC1 = 50;
const Int_t maxnsigmatovertex1 = 3;
//for differential flow
const Double_t ptmin2 = 0.0;
-const Double_t ptmax2 = 1000.0;
+const Double_t ptmax2 = 10.0;
const Double_t ymin2 = -1.;
const Double_t ymax2 = 1.;
const Int_t mintrackrefsTPC2 = 2;
const Int_t mintrackrefsITS2 = 3;
const Int_t charge2 = 1;
-Bool_t UsePIDDifferentialFlow = kFALSE;
+Bool_t UsePIDDifferentialFlow = kTRUE;
const Int_t PDG2 = 211;
const Int_t minclustersTPC2 = 50;
const Int_t maxnsigmatovertex2 = 3;
+//WEIGHTS SETTINGS:
+//to use or not to use the weights - that is a question!
+Bool_t usePhiWeights = kTRUE; //Phi
+Bool_t usePtWeights = kFALSE; //v'(pt)
+Bool_t useEtaWeights = kFALSE; //v'(eta)
+Bool_t useWeights = usePhiWeights||usePtWeights||usePtWeights;
+
//ESD (pp)
//void runProofFlow(const Char_t* data="/COMMON/COMMON/LHC08c11_10TeV_0.5T", Int_t nRuns=-1, Int_t offset=0) {
//void runProofFlow(const Char_t* data="/COMMON/COMMON/LHC08c18_0.9TeV_0T_Phojet", Int_t nRuns=-1, Int_t offset=0) {
//ESD (therminator)
-//void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_midcentral_ESD", Int_t nRuns=-1, Int_t offset=0) {
+void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_midcentral_ESD", Int_t nRuns=-1, Int_t offset=0) {
-void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_c2030", Int_t nRuns=-1, Int_t offset=0) {
+//void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_c2030", Int_t nRuns=-1, Int_t offset=0) {
//void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_central", Int_t nRuns=-1, Int_t offset=0) {
//AOD
//void runProofFlow(const Char_t* data="/PWG2/nkolk/myDataSet", Int_t nRuns=-1, Int_t offset=0) {
-//void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_midcentral_AOD", Int_t nRuns=-1, Int_t offset=0) {
+//void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_midcentral_AOD", Int_t nRuns=44, Int_t offset=0) {
TStopwatch timer;
timer.Start();
gProof->EnablePackage("PWG2AOD");
gProof->UploadPackage("CORRFW.par");
gProof->EnablePackage("CORRFW");
- // gProof->ClearPackage("PWG2flow");
+ gProof->ClearPackage("PWG2flow");
gProof->UploadPackage("PWG2flow.par");
gProof->EnablePackage("PWG2flow");
cfmgr2->SetParticleCutsList(AliCFManager::kPartRecCuts,recList2);
cfmgr2->SetParticleCutsList(AliCFManager::kPartSelCuts,fPIDCutList2);
+ //weights:
+ TFile *weightsFile = NULL;
+ TList *weightsList = NULL;
+
+ if(useWeights)
+ {
+ //open the file with the weights:
+ weightsFile = TFile::Open("weights.root","READ");
+ if(weightsFile)
+ {
+ //access the list which holds the histos with weigths:
+ weightsList = (TList*)weightsFile->Get("weights");
+ }else{cout<<" WARNING: the file <weights.root> with weights from the previuos run was not accessed."<<endl;}
+ }//end of if(useWeights)
+
if (LYZ2){
// read the input file from the first run
TString inputFileNameLYZ2 = "outputLYZ1analysis" ;
inputFileNameLYZ2 += type;
- inputFileNameLYZ2 += "_firstrun.root";
+ inputFileNameLYZ2 += ".root";
cout<<"The input file is "<<inputFileNameLYZ2.Data()<<endl;
TFile* fInputFileLYZ2 = new TFile(inputFileNameLYZ2.Data(),"READ");
if(!fInputFileLYZ2 || fInputFileLYZ2->IsZombie()) {
// read the input file from the second LYZ run
TString inputFileNameLYZEP = "outputLYZ2analysis" ;
inputFileNameLYZEP += type;
- inputFileNameLYZEP += "_secondrun.root";
+ inputFileNameLYZEP += ".root";
cout<<"The input file is "<<inputFileNameLYZEP.Data()<<endl;
TFile* fInputFileLYZEP = new TFile(inputFileNameLYZEP.Data(),"READ");
if(!fInputFileLYZEP || fInputFileLYZEP->IsZombie()) {
else {
TList* fInputListLYZEP = (TList*)fInputFileLYZEP->Get("cobjLYZ2");
if (!fInputListLYZEP) {cout<<"list is NULL pointer!"<<endl;}
- }kTRUE;
+ };
cout<<"LYZEP input file/list read..."<<endl;
}
AliMCEventHandler *mc = new AliMCEventHandler();
mgr->SetMCtruthEventHandler(mc); }
-
+
//____________________________________________//
// tasks
if (SP){
mgr->AddTask(taskGFC);
}
if (QC){
- if (QA) { AliAnalysisTaskQCumulants *taskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",kTRUE);}
- else { AliAnalysisTaskQCumulants *taskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",kFALSE);}
+ if (QA) { AliAnalysisTaskQCumulants *taskQCtaskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",kTRUE,useWeights);}
+ else { AliAnalysisTaskQCumulants *taskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",kFALSE,useWeights);}
taskQC->SetAnalysisType(type);
+ taskQC->SetUsePhiWeights(usePhiWeights);
+ taskQC->SetUsePtWeights(usePtWeights);
+ taskQC->SetUseEtaWeights(useEtaWeights);
taskQC->SetCFManager1(cfmgr1);
taskQC->SetCFManager2(cfmgr2);
if (QA) {
taskMCEP->SetQAList2(qaDiffMCEP); }
mgr->AddTask(taskMCEP);
}
-
-
+
// Create containers for input/output
AliAnalysisDataContainer *cinput1 =
mgr->CreateContainer("cchain1",TChain::Class(),AliAnalysisManager::kInputContainer);
+
+ if(useWeights)
+ {
+ AliAnalysisDataContainer *cinputWeights = mgr->CreateContainer("cobjWeights",TList::Class(),AliAnalysisManager::kInputContainer);
+ }
if (LYZ2){
AliAnalysisDataContainer *cinputLYZ2 = mgr->CreateContainer("cobjLYZ2in",TList::Class(),AliAnalysisManager::kInputContainer); }
if(LYZ1) {
TString outputLYZ1 = "outputLYZ1analysis";
outputLYZ1+= type;
- outputLYZ1+= "_firstrun.root";
+ outputLYZ1+= ".root";
AliAnalysisDataContainer *coutputLYZ1 = mgr->CreateContainer("cobjLYZ1", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1);
}
if(LYZ2) {
TString outputLYZ2 = "outputLYZ2analysis";
outputLYZ2+= type;
- outputLYZ2+= "_secondrun.root";
+ outputLYZ2+= ".root";
AliAnalysisDataContainer *coutputLYZ2 = mgr->CreateContainer("cobjLYZ2", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2);
}
outputMCEP+= ".root";
AliAnalysisDataContainer *coutputMCEP = mgr->CreateContainer("cobjMCEP", TList::Class(),AliAnalysisManager::kOutputContainer,outputMCEP);
}
-
-
+
if (QA) {
if(SP) {
TString qaNameIntSP = "QAforInt_SP_";
mgr->ConnectOutput(taskQC,0,coutputQC);
if (QA) { mgr->ConnectOutput(taskQC,1,coutputQA1QC);
mgr->ConnectOutput(taskQC,2,coutputQA2QC); }
+ if(useWeights)
+ {
+ mgr->ConnectInput(taskQC,1,cinputWeights);
+ cinputWeights->SetData(weightsList);
+ }
+
}
if (FQD) {
mgr->ConnectInput(taskFQD,0,cinput1);
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff