PWG2/FLOW/macros/AddTaskFlow.C

   1 /////////////////////////////////////////////////////////////////////////////////////////////
   2 //
   3 // AddTask* macro for flow analysis
   4 // Creates a Flow Event task and adds it to the analysis manager.
   5 // Sets the cuts using the correction framework (CORRFW) classes.
   6 // Also creates Flow Analysis tasks and connects them to the output of the flow event task.
   7 //
   8 /////////////////////////////////////////////////////////////////////////////////////////////
   9
  10 // Define the range for eta subevents (for SP method)
  11 Double_t minA = -0.9;
  12 Double_t maxA = -0.5;
  13 Double_t minB = 0.5;
  14 Double_t maxB = 0.9;
  15 /*
  16 //PMD As RP
  17 Double_t minB = 2.3;
  18 Double_t maxB = 3.1;
  19 Double_t minA = 3.1;
  20 Double_t maxA = 3.9;
  21 */
  22
  23 // AFTERBURNER
  24 Bool_t useAfterBurner=kFALSE;
  25 Double_t v1=0.0;
  26 Double_t v2=0.0;
  27 Double_t v3=0.0;
  28 Double_t v4=0.0;
  29 Int_t numberOfTrackClones=0; //non-flow
  30
  31 // Define a range of the detector to exclude
  32 Bool_t ExcludeRegion = kFALSE;
  33 Double_t excludeEtaMin = -0.;
  34 Double_t excludeEtaMax = 0.;
  35 Double_t excludePhiMin = 0.;
  36 Double_t excludePhiMax = 0.;
  37
  38 // use physics selection class
  39 Bool_t  UsePhysicsSelection = kTRUE;
  40
  41 // charge of poi
  42 const Int_t    chargePOI = 1;
  43
  44 // QA
  45 Bool_t runQAtask=kFALSE;
  46 Bool_t FillQAntuple=kFALSE;
  47 Bool_t DoQAcorrelations=kFALSE;
  48
  49 // RUN SETTINGS
  50 // Flow analysis method can be:(set to kTRUE or kFALSE)
  51 Bool_t MCEP     = kTRUE;  // correlation with Monte Carlo reaction plane
  52 Bool_t SP       = kTRUE;  // scalar product method (similar to eventplane method)
  53 Bool_t GFC      = kTRUE;  // cumulants based on generating function
  54 Bool_t QC       = kTRUE;  // cumulants using Q vectors
  55 Bool_t FQD      = kTRUE;  // fit of the distribution of the Q vector (only integrated v)
  56 Bool_t LYZ1SUM  = kTRUE;  // Lee Yang Zeroes using sum generating function (integrated v)
  57 Bool_t LYZ1PROD = kFALSE;  // Lee Yang Zeroes using product generating function (integrated v)
  58 Bool_t LYZ2SUM  = kFALSE; // Lee Yang Zeroes using sum generating function (second pass differential v)
  59 Bool_t LYZ2PROD = kFALSE; // Lee Yang Zeroes using product generating function (second pass differential v)
  60 Bool_t LYZEP    = kFALSE; // Lee Yang Zeroes Event plane using sum generating function (gives eventplane + weight)
  61 Bool_t MH       = kTRUE;  // azimuthal correlators in mixed harmonics
  62 Bool_t NL       = kFALSE;  // nested loops (for instance distribution of phi1-phi2 for all distinct pairs)
  63
  64 Bool_t METHODS[] = {SP,LYZ1SUM,LYZ1PROD,LYZ2SUM,LYZ2PROD,LYZEP,GFC,QC,FQD,MCEP,MH,NL};
  65
  66 // Boolean to use/not use weights for the Q vector
  67 Bool_t WEIGHTS[] = {kFALSE,kFALSE,kFALSE}; //Phi, v'(pt), v'(eta)
  68
  69 // SETTING THE CUTS
  70
  71 //---------Data selection----------
  72 //kMC, kGlobal, kTPCstandalone, kSPDtracklet, kPMD
  73 AliFlowTrackCuts::trackParameterType rptype = AliFlowTrackCuts::kGlobal;
  74 AliFlowTrackCuts::trackParameterType poitype = AliFlowTrackCuts::kGlobal;
  75
  76 //---------Parameter mixing--------
  77 //kPure - no mixing, kTrackWithMCkine, kTrackWithMCPID, kTrackWithMCpt
  78 AliFlowTrackCuts::trackParameterMix rpmix = AliFlowTrackCuts::kPure;
  79 AliFlowTrackCuts::trackParameterMix poimix = AliFlowTrackCuts::kPure;
  80
  81
  82 const char* rptypestr = AliFlowTrackCuts::GetParamTypeName(rptype);
  83 const char* poitypestr = AliFlowTrackCuts::GetParamTypeName(poitype);
  84
  85 void AddTaskFlow(Float_t centrMin=-1,
  86                  Float_t centrMax=-1,
  87                  TString fileNameBase="AnalysisResults" ) {
  88   TString centralityName("");
  89   if((centrMin > 0)||(centrMax > 0)) {
  90     centralityName+=Form("%.0f",centrMin);
  91     centralityName+="-";
  92     centralityName+=Form("%.0f",centrMax);
  93   }
  94
  95   TString fileName(fileNameBase);
  96   fileName.Append(".root");
  97   //===========================================================================
  98   printf("CREATE CUTS\n");
  99   cout << "Used for RP: "<< rptypestr << endl;
 100   cout << "Used for POI: "<< poitypestr << endl;
 101   // EVENTS CUTS:
 102   AliFlowEventCuts* cutsEvent = new AliFlowEventCuts("event cuts");
 103   if((centrMin > 0)||(centrMax > 0)) {
 104     cutsEvent->SetCentralityPercentileRange(centrMin,centrMax);
 105     cutsEvent->SetCentralityPercentileMethod(AliFlowEventCuts::kV0);
 106     cutsEvent->SetRefMultMethod(AliFlowEventCuts::kV0);
 107     //cutsEvent->SetCentralityPercentileMethod(AliFlowEventCuts::kSPD1tracklets);
 108     cutsEvent->SetNContributorsRange(2);
 109     cutsEvent->SetPrimaryVertexZrange(-10.,10.);
 110     cutsEvent->SetCutSPDvertexerAnomaly(); //"Francesco's cut"
 111     cutsEvent->SetCutZDCtiming();
 112   }
 113
 114   // RP TRACK CUTS:
 115   AliFlowTrackCuts* cutsRP = new AliFlowTrackCuts("rp cuts");
 116   cutsRP->SetParamType(rptype);
 117   cutsRP->SetParamMix(rpmix);
 118   cutsRP->SetPtRange(0.2,5.);
 119   cutsRP->SetEtaRange(-0.8,0.8);
 120   //cutsRP->SetRequireCharge(kTRUE);
 121   //cutsRP->SetCharge(chargeRP);
 122   //cutsRP->SetPID(PdgRP);
 123   if(rptype != AliFlowTrackCuts::kMC) {
 124     cutsRP->SetMinNClustersTPC(70);
 125     cutsRP->SetMinChi2PerClusterTPC(0.1);
 126     cutsRP->SetMaxChi2PerClusterTPC(4.0);
 127     cutsRP->SetMinNClustersITS(2);
 128     cutsRP->SetRequireITSRefit(kTRUE);
 129     cutsRP->SetRequireTPCRefit(kTRUE);
 130     //cutsRP->SetMaxChi2PerClusterITS(1.e+09);
 131     cutsRP->SetMaxDCAToVertexXY(0.3);
 132     cutsRP->SetMaxDCAToVertexZ(0.3);
 133     //cutsRP->SetDCAToVertex2D(kTRUE);
 134     //cutsRP->SetMaxNsigmaToVertex(1.e+10);
 135     //cutsRP->SetRequireSigmaToVertex(kFALSE);
 136     cutsRP->SetAcceptKinkDaughters(kFALSE);
 137   }
 138   if(rptype == AliFlowTrackCuts::kPMD) {
 139     cutsRP->SetEtaRange(2.3,3.9);
 140     cutsRP->SetPmdDetPlane(0);
 141     cutsRP->SetPmdAdc(270);
 142     cutsRP->SetPmdNcell(1);
 143   }
 144
 145
 146   // POI TRACK CUTS:
 147   AliFlowTrackCuts* cutsPOI = new AliFlowTrackCuts("poi cuts");
 148   cutsPOI->SetParamType(poitype);
 149   cutsPOI->SetParamMix(poimix);
 150   cutsPOI->SetPtRange(0.0,10.);
 151   cutsPOI->SetEtaRange(-1.2,1.2);
 152   if(chargePOI != 0)
 153     cutsPOI->SetCharge(chargePOI);
 154   //cutsPOI->SetRequireCharge(kTRUE);
 155   //cutsPOI->SetPID(PdgRP);
 156   if(rptype != AliFlowTrackCuts::kMC) {
 157     cutsPOI->SetMinNClustersTPC(80);
 158     cutsPOI->SetMinChi2PerClusterTPC(0.1);
 159     cutsPOI->SetMaxChi2PerClusterTPC(4.0);
 160     cutsPOI->SetRequireITSRefit(kTRUE);
 161     cutsPOI->SetRequireTPCRefit(kTRUE);
 162     cutsPOI->SetMinNClustersITS(2);
 163     //cutsPOI->SetMaxChi2PerClusterITS(1.e+09);
 164     cutsPOI->SetMaxDCAToVertexXY(0.3);
 165     cutsPOI->SetMaxDCAToVertexZ(0.3);
 166     //cutsPOI->SetDCAToVertex2D(kTRUE);
 167     //cutsPOI->SetMaxNsigmaToVertex(1.e+10);
 168     //cutsPOI->SetRequireSigmaToVertex(kFALSE);
 169     cutsPOI->SetAcceptKinkDaughters(kFALSE);
 170     //cutsPOI->SetPID(AliPID::kProton, AliFlowTrackCuts::kTOFpid);
 171     //cutsPOI->SetPID(AliPID::kPion, AliFlowTrackCuts::kTPCpid);
 172     //cutsPOI->SetPID(AliPID::kProton, AliFlowTrackCuts::kTPCTOFpid);
 173     //cutsPOI->SetTPCTOFpidCrossOverPt(0.4);
 174     //francesco's TPC Bethe Bloch for data:
 175     //cutsPOI->GetESDpid().GetTPCResponse().SetBetheBlochParameters(4.36414e-02,1.75977e+01,1.14385e-08,2.27907e+00,3.36699e+00);
 176     //cutsPOI->GetESDpid().GetTPCResponse().SetMip(49);
 177   }
 178   if(poitype == AliFlowTrackCuts::kPMD) {
 179     cutsPOI->SetEtaRange(2.3,3.9);
 180     cutsPOI->SetPmdDetPlane(0);
 181     cutsPOI->SetPmdAdc(270);
 182     cutsPOI->SetPmdNcell(1);
 183   }
 184
 185
 186   Bool_t useWeights  = WEIGHTS[0] || WEIGHTS[1] || WEIGHTS[2];
 187   if (useWeights) cout<<"Weights are used"<<endl;
 188   else cout<<"Weights are not used"<<endl;
 189
 190   // Get the pointer to the existing analysis manager via the static access method.
 191   //==============================================================================
 192   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
 193   if (!mgr) {
 194     Error("AddTaskFlowEvent", "No analysis manager to connect to.");
 195     return NULL;
 196   }
 197
 198   // Check the analysis type using the event handlers connected to the analysis
 199   // manager. The availability of MC handler can also be checked here.
 200   //==============================================================================
 201   if (!mgr->GetInputEventHandler()) {
 202     ::Error("AddTaskFlowEvent", "This task requires an input event handler");
 203     return NULL;
 204   }
 205
 206   // Open external input files
 207   //===========================================================================
 208   //weights:
 209   TFile *weightsFile = NULL;
 210   TList *weightsList = NULL;
 211
 212   if(useWeights) {
 213     //open the file with the weights:
 214     weightsFile = TFile::Open("weights.root","READ");
 215     if(weightsFile) {
 216       //access the list which holds the histos with weigths:
 217       weightsList = (TList*)weightsFile->Get("weights");
 218     }
 219     else {
 220       cout<<" WARNING: the file <weights.root> with weights from the previous run was not available."<<endl;
 221       break;
 222     }
 223   }
 224
 225   //LYZ2
 226   if (LYZ2SUM || LYZ2PROD) {
 227     //read the outputfile of the first run
 228     TString outputFileName = "AnalysisResults1.root";
 229     TString pwd(gSystem->pwd());
 230     pwd+="/";
 231     pwd+=outputFileName.Data();
 232     TFile *outputFile = NULL;
 233     if(gSystem->AccessPathName(pwd.Data(),kFileExists)) {
 234       cout<<"WARNING: You do not have an output file:"<<endl;
 235       cout<<"         "<<pwd.Data()<<endl;
 236       exit(0);
 237     } else { outputFile = TFile::Open(pwd.Data(),"READ");}
 238
 239     if (LYZ2SUM){
 240       // read the output directory from LYZ1SUM
 241       TString inputFileNameLYZ2SUM = "outputLYZ1SUManalysis" ;
 242       inputFileNameLYZ2SUM += rptypestr;
 243       cout<<"The input directory is "<<inputFileNameLYZ2SUM.Data()<<endl;
 244       TFile* fInputFileLYZ2SUM = (TFile*)outputFile->FindObjectAny(inputFileNameLYZ2SUM.Data());
 245       if(!fInputFileLYZ2SUM || fInputFileLYZ2SUM->IsZombie()) {
 246         cerr << " ERROR: To run LYZ2SUM you need the output file from LYZ1SUM. This file is not there! Please run LYZ1SUM first." << endl ;
 247         break;
 248       }
 249       else {
 250         TList* fInputListLYZ2SUM = (TList*)fInputFileLYZ2SUM->Get("cobjLYZ1SUM");
 251         if (!fInputListLYZ2SUM) {cout<<"list is NULL pointer!"<<endl;}
 252       }
 253       cout<<"LYZ2SUM input file/list read..."<<endl;
 254     }
 255
 256     if (LYZ2PROD){
 257       // read the output directory from LYZ1PROD
 258       TString inputFileNameLYZ2PROD = "outputLYZ1PRODanalysis" ;
 259       inputFileNameLYZ2PROD += rptypestr;
 260       cout<<"The input directory is "<<inputFileNameLYZ2PROD.Data()<<endl;
 261       TFile* fInputFileLYZ2PROD = (TFile*)outputFile->FindObjectAny(inputFileNameLYZ2PROD.Data());
 262       if(!fInputFileLYZ2PROD || fInputFileLYZ2PROD->IsZombie()) {
 263         cerr << " ERROR: To run LYZ2PROD you need the output file from LYZ1PROD. This file is not there! Please run LYZ1PROD first." << endl ;
 264         break;
 265       }
 266       else {
 267         TList* fInputListLYZ2PROD = (TList*)fInputFileLYZ2PROD->Get("cobjLYZ1PROD");
 268         if (!fInputListLYZ2PROD) {cout<<"list is NULL pointer!"<<endl;}
 269       }
 270       cout<<"LYZ2PROD input file/list read..."<<endl;
 271     }
 272   }
 273
 274   if (LYZEP) {
 275     //read the outputfile of the second run
 276     TString outputFileName = "AnalysisResults2.root";
 277     TString pwd(gSystem->pwd());
 278     pwd+="/";
 279     pwd+=outputFileName.Data();
 280     TFile *outputFile = NULL;
 281     if(gSystem->AccessPathName(pwd.Data(),kFileExists)) {
 282       cout<<"WARNING: You do not have an output file:"<<endl;
 283       cout<<"         "<<pwd.Data()<<endl;
 284       exit(0);
 285     } else {
 286       outputFile = TFile::Open(pwd.Data(),"READ");
 287     }
 288
 289     // read the output file from LYZ2SUM
 290     TString inputFileNameLYZEP = "outputLYZ2SUManalysis" ;
 291     inputFileNameLYZEP += rptypestr;
 292     cout<<"The input file is "<<inputFileNameLYZEP.Data()<<endl;
 293     TFile* fInputFileLYZEP = (TFile*)outputFile->FindObjectAny(inputFileNameLYZEP.Data());
 294     if(!fInputFileLYZEP || fInputFileLYZEP->IsZombie()) {
 295       cerr << " ERROR: To run LYZEP you need the output file from LYZ2SUM. This file is not there! Please run LYZ2SUM first." << endl ;
 296       break;
 297     }
 298     else {
 299       TList* fInputListLYZEP = (TList*)fInputFileLYZEP->Get("cobjLYZ2SUM");
 300       if (!fInputListLYZEP) {cout<<"list is NULL pointer!"<<endl;}
 301     }
 302     cout<<"LYZEP input file/list read..."<<endl;
 303   }
 304
 305
 306   // Create the FMD task and add it to the manager
 307   //===========================================================================
 308   if (rptypestr == "FMD") {
 309     AliFMDAnalysisTaskSE *taskfmd = NULL;
 310     if (rptypestr == "FMD") {
 311       taskfmd = new AliFMDAnalysisTaskSE("TaskFMD");
 312       mgr->AddTask(taskfmd);
 313
 314       AliFMDAnaParameters* pars = AliFMDAnaParameters::Instance();
 315       pars->Init();
 316       pars->SetProcessPrimary(kTRUE); //for MC only
 317       pars->SetProcessHits(kFALSE);
 318
 319       //pars->SetRealData(kTRUE); //for real data
 320       //pars->SetProcessPrimary(kFALSE); //for real data
 321     }
 322   }
 323
 324   // Create the task, add it to the manager.
 325   //===========================================================================
 326   AliAnalysisTaskFlowEvent *taskFE = NULL;
 327
 328   if(useAfterBurner)
 329     {
 330       taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent","",kFALSE,1);
 331       taskFE->SetFlow(v1,v2,v3,v4);
 332       taskFE->SetNonFlowNumberOfTrackClones(numberOfTrackClones);
 333       taskFE->SetAfterburnerOn();
 334     }
 335   else {taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent","",kFALSE); }
 336   if (ExcludeRegion) {
 337     taskFE->DefineDeadZone(excludeEtaMin, excludeEtaMax, excludePhiMin, excludePhiMax);
 338   }
 339   taskFE->SetSubeventEtaRange(minA, maxA, minB, maxB);
 340   if (UsePhysicsSelection) {
 341     //taskFE->SelectCollisionCandidates(AliVEvent::kUserDefined);
 342     taskFE->SelectCollisionCandidates(AliVEvent::kMB);
 343     cout<<"Using Physics Selection"<<endl;
 344   }
 345   mgr->AddTask(taskFE);
 346
 347   // Pass cuts for RPs and POIs to the task:
 348   taskFE->SetCutsEvent(cutsEvent);
 349
 350   // Pass cuts for RPs and POIs to the task:
 351   taskFE->SetCutsRP(cutsRP);
 352   taskFE->SetCutsPOI(cutsPOI);
 353
 354   // Create the analysis tasks, add them to the manager.
 355   //===========================================================================
 356   if (SP){
 357     AliAnalysisTaskScalarProduct *taskSP = new AliAnalysisTaskScalarProduct("TaskScalarProduct",WEIGHTS[0]);
 358     taskSP->SetRelDiffMsub(1.0);
 359     taskSP->SetApplyCorrectionForNUA(kTRUE);
 360     mgr->AddTask(taskSP);
 361   }
 362   if (LYZ1SUM){
 363     AliAnalysisTaskLeeYangZeros *taskLYZ1SUM = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZerosSUM",kTRUE);
 364     taskLYZ1SUM->SetFirstRunLYZ(kTRUE);
 365     taskLYZ1SUM->SetUseSumLYZ(kTRUE);
 366     mgr->AddTask(taskLYZ1SUM);
 367   }
 368   if (LYZ1PROD){
 369     AliAnalysisTaskLeeYangZeros *taskLYZ1PROD = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZerosPROD",kTRUE);
 370     taskLYZ1PROD->SetFirstRunLYZ(kTRUE);
 371     taskLYZ1PROD->SetUseSumLYZ(kFALSE);
 372     mgr->AddTask(taskLYZ1PROD);
 373   }
 374   if (LYZ2SUM){
 375     AliAnalysisTaskLeeYangZeros *taskLYZ2SUM = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZerosSUM",kFALSE);
 376     taskLYZ2SUM->SetFirstRunLYZ(kFALSE);
 377     taskLYZ2SUM->SetUseSumLYZ(kTRUE);
 378     mgr->AddTask(taskLYZ2SUM);
 379   }
 380   if (LYZ2PROD){
 381     AliAnalysisTaskLeeYangZeros *taskLYZ2PROD = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZerosPROD",kFALSE);
 382     taskLYZ2PROD->SetFirstRunLYZ(kFALSE);
 383     taskLYZ2PROD->SetUseSumLYZ(kFALSE);
 384     mgr->AddTask(taskLYZ2PROD);
 385   }
 386   if (LYZEP){
 387     AliAnalysisTaskLYZEventPlane *taskLYZEP = new AliAnalysisTaskLYZEventPlane("TaskLYZEventPlane");
 388     mgr->AddTask(taskLYZEP);
 389   }
 390   if (GFC){
 391     AliAnalysisTaskCumulants *taskGFC = new AliAnalysisTaskCumulants("TaskCumulants",useWeights);
 392     taskGFC->SetUsePhiWeights(WEIGHTS[0]);
 393     taskGFC->SetUsePtWeights(WEIGHTS[1]);
 394     taskGFC->SetUseEtaWeights(WEIGHTS[2]);
 395     mgr->AddTask(taskGFC);
 396   }
 397   if (QC){
 398     AliAnalysisTaskQCumulants *taskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",useWeights);
 399     taskQC->SetUsePhiWeights(WEIGHTS[0]);
 400     taskQC->SetUsePtWeights(WEIGHTS[1]);
 401     taskQC->SetUseEtaWeights(WEIGHTS[2]);
 402     taskQC->SetnBinsMult(10000);
 403     taskQC->SetMinMult(0.);
 404     taskQC->SetMaxMult(10000.);
 405     taskQC->SetApplyCorrectionForNUA(kTRUE);
 406     mgr->AddTask(taskQC);
 407   }
 408   if (FQD){
 409     AliAnalysisTaskFittingQDistribution *taskFQD = new AliAnalysisTaskFittingQDistribution("TaskFittingQDistribution",kFALSE);
 410     taskFQD->SetUsePhiWeights(WEIGHTS[0]);
 411     taskFQD->SetqMin(0.);
 412     taskFQD->SetqMax(1000.);
 413     taskFQD->SetqNbins(10000);
 414     mgr->AddTask(taskFQD);
 415   }
 416   if (MCEP){
 417     AliAnalysisTaskMCEventPlane *taskMCEP = new AliAnalysisTaskMCEventPlane("TaskMCEventPlane");
 418     mgr->AddTask(taskMCEP);
 419   }
 420   if (MH){
 421     AliAnalysisTaskMixedHarmonics *taskMH = new AliAnalysisTaskMixedHarmonics("TaskMixedHarmonics",useWeights);
 422    taskMH->SetHarmonic(1); // n in cos[n(phi1+phi2-2phi3)] and cos[n(psi1+psi2-2phi3)]
 423     taskMH->SetNoOfMultipicityBins(10000);
 424     taskMH->SetMultipicityBinWidth(1.);
 425     taskMH->SetMinMultiplicity(1.);
 426     taskMH->SetCalculateVsM(kTRUE);
 427     taskMH->SetCorrectForDetectorEffects(kTRUE);
 428     taskMH->SetEvaluateDifferential3pCorrelator(kTRUE); // evaluate <<cos[n(psi1+psi2-2phi3)]>> (Remark: two nested loops)
 429     if(chargePOI == 0)
 430       taskMH->SetOppositeChargesPOI(kTRUE);
 431     else
 432       taskMH->SetOppositeChargesPOI(kFALSE); // POIs psi1 and psi2 in cos[n(psi1+psi2-2phi3)] will have opposite charges
 433     mgr->AddTask(taskMH);
 434   }
 435   if (NL){
 436     AliAnalysisTaskNestedLoops *taskNL = new AliAnalysisTaskNestedLoops("TaskNestedLoops",useWeights);
 437     taskNL->SetHarmonic(1); // n in cos[n(phi1+phi2-2phi3)] and cos[n(psi1+psi2-2phi3)]
 438     taskNL->SetEvaluateNestedLoopsForRAD(kTRUE); // RAD = Relative Angle Distribution
 439     taskNL->SetEvaluateNestedLoopsForMH(kTRUE); // evalaute <<cos[n(phi1+phi2-2phi3)]>> (Remark: three nested loops)
 440     taskNL->SetEvaluateDifferential3pCorrelator(kFALSE); // evaluate <<cos[n(psi1+psi2-2phi3)]>>  (Remark: three nested loops)
 441     taskNL->SetOppositeChargesPOI(kFALSE); // POIs psi1 and psi2 in cos[n(psi1+psi2-2phi3)] will have opposite charges
 442     mgr->AddTask(taskNL);
 443   }
 444
 445   // Create the output container for the data produced by the task
 446   // Connect to the input and output containers
 447   //===========================================================================
 448   AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
 449
 450   if (rptypestr == "FMD") {
 451     AliAnalysisDataContainer *coutputFMD =
 452       mgr->CreateContainer(Form("BackgroundCorrected_%s",centralityName.Data()), TList::Class(), AliAnalysisManager::kExchangeContainer);
 453     //input and output taskFMD
 454     mgr->ConnectInput(taskfmd, 0, cinput1);
 455     mgr->ConnectOutput(taskfmd, 1, coutputFMD);
 456     //input into taskFE
 457     mgr->ConnectInput(taskFE,1,coutputFMD);
 458   }
 459
 460   AliAnalysisDataContainer *coutputFE =
 461   mgr->CreateContainer(Form("cobjFlowEventSimple_%s",centralityName.Data()),AliFlowEventSimple::Class(),AliAnalysisManager::kExchangeContainer);
 462   mgr->ConnectInput(taskFE,0,cinput1);
 463   mgr->ConnectOutput(taskFE,1,coutputFE);
 464
 465
 466   // Create the output containers for the data produced by the analysis tasks
 467   // Connect to the input and output containers
 468   //===========================================================================
 469   if (useWeights) {
 470     AliAnalysisDataContainer *cinputWeights = mgr->CreateContainer(Form("cobjWeights_%s",centralityName.Data()),
 471                                                                    TList::Class(),AliAnalysisManager::kInputContainer);
 472   }
 473
 474   if(SP) {
 475     TString outputSP = fileName;
 476     outputSP += ":outputSPanalysis";
 477     outputSP+= rptypestr;
 478     TString cobjSP = "cobjSP";
 479     if((centrMin > 0)||(centrMax > 0)) {
 480       cobjSP += "_"; cobjSP += centralityName.Data(); }
 481     AliAnalysisDataContainer *coutputSP = mgr->CreateContainer(cobjSP.Data(),
 482                                                                TList::Class(),AliAnalysisManager::kOutputContainer,outputSP);
 483     mgr->ConnectInput(taskSP,0,coutputFE);
 484     mgr->ConnectOutput(taskSP,1,coutputSP);
 485     if (WEIGHTS[0]) {
 486       mgr->ConnectInput(taskSP,1,cinputWeights);
 487       cinputWeights->SetData(weightsList);
 488     }
 489   }
 490   if(LYZ1SUM) {
 491     TString outputLYZ1SUM = fileName;
 492     outputLYZ1SUM += ":outputLYZ1SUManalysis";
 493     outputLYZ1SUM+= rptypestr;
 494     TString cobjLYZ1SUM = "cobjLYZ1SUM";
 495     if((centrMin > 0)||(centrMax > 0)) {
 496       cobjLYZ1SUM += "_"; cobjLYZ1SUM += centralityName.Data(); }
 497     AliAnalysisDataContainer *coutputLYZ1SUM = mgr->CreateContainer(cobjLYZ1SUM.Data(),
 498                                                                     TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1SUM);
 499     mgr->ConnectInput(taskLYZ1SUM,0,coutputFE);
 500     mgr->ConnectOutput(taskLYZ1SUM,1,coutputLYZ1SUM);
 501   }
 502   if(LYZ1PROD) {
 503     TString outputLYZ1PROD = fileName;
 504     outputLYZ1PROD += ":outputLYZ1PRODanalysis";
 505     outputLYZ1PROD+= rptypestr;
 506     TString cobjLYZ1PROD = "cobjLYZ1PROD";
 507     if((centrMin > 0)||(centrMax > 0)) {
 508       cobjLYZ1PROD += "_"; cobjLYZ1PROD += centralityName.Data(); }
 509     AliAnalysisDataContainer *coutputLYZ1PROD = mgr->CreateContainer(cobjLYZ1PROD.Data(),
 510                                                                      TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1PROD);
 511     mgr->ConnectInput(taskLYZ1PROD,0,coutputFE);
 512     mgr->ConnectOutput(taskLYZ1PROD,1,coutputLYZ1PROD);
 513   }
 514   if(LYZ2SUM) {
 515     AliAnalysisDataContainer *cinputLYZ2SUM = mgr->CreateContainer(Form("cobjLYZ2SUMin_%s",centralityName.Data()),
 516                                                                    TList::Class(),AliAnalysisManager::kInputContainer);
 517     TString outputLYZ2SUM = fileName;
 518     outputLYZ2SUM += ":outputLYZ2SUManalysis";
 519     outputLYZ2SUM+= rptypestr;
 520     TString cobjLYZ2SUM = "cobjLYZ2SUM";
 521     if((centrMin > 0)||(centrMax > 0)) {
 522       cobjLYZ2SUM += "_"; cobjLYZ2SUM += centralityName.Data(); }
 523     AliAnalysisDataContainer *coutputLYZ2SUM = mgr->CreateContainer(cobjLYZ2SUM.Data(),
 524                                                                     TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2SUM);
 525     mgr->ConnectInput(taskLYZ2SUM,0,coutputFE);
 526     mgr->ConnectInput(taskLYZ2SUM,1,cinputLYZ2SUM);
 527     mgr->ConnectOutput(taskLYZ2SUM,1,coutputLYZ2SUM);
 528     cinputLYZ2SUM->SetData(fInputListLYZ2SUM);
 529   }
 530   if(LYZ2PROD) {
 531     AliAnalysisDataContainer *cinputLYZ2PROD = mgr->CreateContainer(Form("cobjLYZ2PRODin_%s",centralityName.Data()),
 532                                                                     TList::Class(),AliAnalysisManager::kInputContainer);
 533     TString outputLYZ2PROD = fileName;
 534     outputLYZ2PROD += ":outputLYZ2PRODanalysis";
 535     outputLYZ2PROD+= rptypestr;
 536     TString cobjLYZ2PROD = "cobjLYZ2PROD";
 537     if((centrMin > 0)||(centrMax > 0)) {
 538       cobjLYZ2PROD += "_"; cobjLYZ2PROD += centralityName.Data(); }
 539     AliAnalysisDataContainer *coutputLYZ2PROD = mgr->CreateContainer(cobjLYZ2PROD.Data(),
 540                                                                      TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2PROD);
 541     mgr->ConnectInput(taskLYZ2PROD,0,coutputFE);
 542     mgr->ConnectInput(taskLYZ2PROD,1,cinputLYZ2PROD);
 543     mgr->ConnectOutput(taskLYZ2PROD,1,coutputLYZ2PROD);
 544     cinputLYZ2PROD->SetData(fInputListLYZ2PROD);
 545   }
 546   if(LYZEP) {
 547     AliAnalysisDataContainer *cinputLYZEP = mgr->CreateContainer(Form("cobjLYZEPin_%s",centralityName.Data()),
 548                                                                  TList::Class(),AliAnalysisManager::kInputContainer);
 549     TString outputLYZEP = fileName;
 550     outputLYZEP += ":outputLYZEPanalysis";
 551     outputLYZEP+= rptypestr;
 552     TString cobjLYZEP = "cobjLYZEP";
 553     if((centrMin > 0)||(centrMax > 0)) {
 554       cobjLYZEP += "_"; cobjLYZEP += centralityName.Data(); }
 555     AliAnalysisDataContainer *coutputLYZEP = mgr->CreateContainer(cobjLYZEP.Data(),
 556                                                                   TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZEP);
 557     mgr->ConnectInput(taskLYZEP,0,coutputFE);
 558     mgr->ConnectInput(taskLYZEP,1,cinputLYZEP);
 559     mgr->ConnectOutput(taskLYZEP,1,coutputLYZEP);
 560     cinputLYZEP->SetData(fInputListLYZEP);
 561   }
 562   if(GFC) {
 563     TString outputGFC = fileName;
 564     outputGFC += ":outputGFCanalysis";
 565     outputGFC+= rptypestr;
 566     TString cobjGFC = "cobjLYZ1PROD";
 567     if((centrMin > 0)||(centrMax > 0)) {
 568       cobjGFC += "_"; cobjGFC += centralityName.Data(); }
 569     AliAnalysisDataContainer *coutputGFC = mgr->CreateContainer(cobjGFC.Data(),
 570                                                                 TList::Class(),AliAnalysisManager::kOutputContainer,outputGFC);
 571     mgr->ConnectInput(taskGFC,0,coutputFE);
 572     mgr->ConnectOutput(taskGFC,1,coutputGFC);
 573     if (useWeights) {
 574       mgr->ConnectInput(taskGFC,1,cinputWeights);
 575       cinputWeights->SetData(weightsList);
 576     }
 577   }
 578   if(QC) {
 579     TString outputQC = fileName;
 580     outputQC += ":outputQCanalysis";
 581     outputQC+= rptypestr;
 582     TString cobjQC = "cobjQC";
 583     if((centrMin > 0)||(centrMax > 0)) {
 584       cobjQC += "_"; cobjQC += centralityName.Data(); }
 585     AliAnalysisDataContainer *coutputQC = mgr->CreateContainer(cobjQC.Data(),
 586                                                                TList::Class(),AliAnalysisManager::kOutputContainer,outputQC);
 587     mgr->ConnectInput(taskQC,0,coutputFE);
 588     mgr->ConnectOutput(taskQC,1,coutputQC);
 589     if (useWeights) {
 590       mgr->ConnectInput(taskQC,1,cinputWeights);
 591       cinputWeights->SetData(weightsList);
 592     }
 593   }
 594   if(FQD) {
 595     TString outputFQD = fileName;
 596     outputFQD += ":outputFQDanalysis";
 597     outputFQD+= rptypestr;
 598     TString cobjFQD = "cobjFQD";
 599     if((centrMin > 0)||(centrMax > 0)) {
 600       cobjFQD += "_"; cobjFQD += centralityName.Data(); }
 601     AliAnalysisDataContainer *coutputFQD = mgr->CreateContainer(cobjFQD.Data(),
 602                                                                 TList::Class(),AliAnalysisManager::kOutputContainer,outputFQD);
 603     mgr->ConnectInput(taskFQD,0,coutputFE);
 604     mgr->ConnectOutput(taskFQD,1,coutputFQD);
 605     if(useWeights) {
 606       mgr->ConnectInput(taskFQD,1,cinputWeights);
 607       cinputWeights->SetData(weightsList);
 608     }
 609   }
 610   if(MCEP) {
 611     TString outputMCEP = fileName;
 612     outputMCEP += ":outputMCEPanalysis";
 613     outputMCEP+= rptypestr;
 614     TString cobjMCEP = "cobjMCEP";
 615     if((centrMin > 0)||(centrMax > 0)) {
 616       cobjMCEP += "_"; cobjMCEP += centralityName.Data(); }
 617     AliAnalysisDataContainer *coutputMCEP = mgr->CreateContainer(cobjMCEP.Data(),
 618                                                                  TList::Class(),AliAnalysisManager::kOutputContainer,outputMCEP);
 619     mgr->ConnectInput(taskMCEP,0,coutputFE);
 620     mgr->ConnectOutput(taskMCEP,1,coutputMCEP);
 621   }
 622   if(MH) {
 623     TString outputMH = fileName;
 624     outputMH += ":outputMHanalysis";
 625     outputMH += rptypestr;
 626     TString cobjMH = "cobjMH";
 627     if((centrMin > 0)||(centrMax > 0)) {
 628       cobjMH += "_"; cobjMH += centralityName.Data(); }
 629     AliAnalysisDataContainer *coutputMH = mgr->CreateContainer(cobjMH.Data(),
 630                                                                TList::Class(),AliAnalysisManager::kOutputContainer,outputMH);
 631     mgr->ConnectInput(taskMH,0,coutputFE);
 632     mgr->ConnectOutput(taskMH,1,coutputMH);
 633     //if (useWeights) {
 634     //  mgr->ConnectInput(taskMH,1,cinputWeights);
 635     //  cinputWeights->SetData(weightsList);
 636     //}
 637   }
 638   if(NL) {
 639     TString outputNL = fileName;
 640     outputNL += ":outputNLanalysis";
 641     outputNL += rptypestr;
 642     TString cobjNL = "cobjNL";
 643     if((centrMin > 0)||(centrMax > 0)) {
 644       cobjNL += "_"; cobjNL += centralityName.Data(); }
 645     AliAnalysisDataContainer *coutputNL = mgr->CreateContainer(cobjNL.Data(),
 646                                                                TList::Class(),AliAnalysisManager::kOutputContainer,outputNL);
 647     mgr->ConnectInput(taskNL,0,coutputFE);
 648     mgr->ConnectOutput(taskNL,1,coutputNL);
 649     //if (useWeights) {
 650     //  mgr->ConnectInput(taskNL,1,cinputWeights);
 651     //  cinputWeights->SetData(weightsList);
 652     //}
 653   }
 654
 655   ///////////////////////////////////////////////////////////////////////////////////////////
 656   if (runQAtask)
 657   {
 658     AliAnalysisTaskQAflow* taskQAflow = new AliAnalysisTaskQAflow("TaskQAflow");
 659     taskQAflow->SetEventCuts(cutsEvent);
 660     taskQAflow->SetTrackCuts(cutsRP);
 661     taskQAflow->SetFillNTuple(FillQAntuple);
 662     taskQAflow->SetDoCorrelations(DoQAcorrelations);
 663     mgr->AddTask(taskQAflow);
 664
 665     if((centrMin > 0)||(centrMax > 0))
 666       Printf("centralityName %s",centralityName.Data());
 667     TString taskQAoutputFileName(fileNameBase);
 668     taskQAoutputFileName.Append("_QA.root");
 669
 670     TString taskQAname = "flowQA";
 671     if((centrMin > 0)||(centrMax > 0)) {
 672       taskQAname += "_"; taskQAname += centralityName.Data();}
 673     AliAnalysisDataContainer* coutputQAtask = mgr->CreateContainer(taskQAname.Data(),
 674                                               TObjArray::Class(),
 675                                               AliAnalysisManager::kOutputContainer,
 676                                               taskQAoutputFileName);
 677
 678     TString taskQATreeName = "flowQAntuple";
 679     if((centrMin > 0)||(centrMax > 0)) {
 680       taskQATreeName += "_"; taskQATreeName += centralityName.Data();}
 681     AliAnalysisDataContainer* coutputQAtaskTree = mgr->CreateContainer(taskQATreeName.data(),
 682                                               TNtuple::Class(),
 683                                               AliAnalysisManager::kOutputContainer,
 684                                               taskQAoutputFileName);
 685     mgr->ConnectInput(taskQAflow,0,mgr->GetCommonInputContainer());
 686     mgr->ConnectInput(taskQAflow,1,coutputFE);
 687     mgr->ConnectOutput(taskQAflow,1,coutputQAtask);
 688     if (FillQAntuple) mgr->ConnectOutput(taskQAflow,2,coutputQAtaskTree);
 689   }
 690 }
 691
 692
 693
 694
 695