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
  11 // SETTING THE CUTS
  12
  13 //----------Event selection----------
  14 Bool_t UseMultCutforESD = kTRUE;
  15 //Bool_t UseMultCutforESD = kFALSE;
  16 const Int_t multminESD = 1;  //used for CORRFW cuts
  17 const Int_t multmaxESD = 1000000; //used for CORRFW cuts
  18
  19 Bool_t requireVtxCuts = kTRUE;
  20 Double_t vertexXmin = -1.0;
  21 Double_t vertexXmax = 1.0;
  22 Double_t vertexYmin = -1.0;
  23 Double_t vertexYmax = 1.0;
  24 Double_t vertexZmin = -15.0; //-1.e99;
  25 Double_t vertexZmax = 15.0; //1.e99;
  26
  27 //Bool_t UseMultCut = kTRUE;
  28 Bool_t UseMultCut = kFALSE;
  29 const Int_t multmin = 10;     //used for AliFlowEventSimple (to set the centrality)
  30 const Int_t multmax = 40;     //used for AliFlowEventSimple (to set the centrality)
  31 //const Int_t multmin = 10;     //used for AliFlowEventSimple (to set the centrality)
  32 //const Int_t multmax = 1000000;     //used for AliFlowEventSimple (to set the centrality)
  33
  34
  35 //----------For RP selection----------
  36 //KINEMATICS (on generated and reconstructed tracks)
  37 Bool_t UseKineforRP =  kTRUE;
  38 const Double_t ptminRP = 0.0;
  39 const Double_t ptmaxRP = 10.0;
  40 const Double_t etaminRP  = -0.9;
  41 const Double_t etamaxRP  = 0.9;
  42 const Int_t    chargeRP = 1;  //not used
  43
  44 //PID (on generated and reconstructed tracks)
  45 Bool_t UsePIDforRP = kFALSE;
  46 const Int_t PdgRP = 211;
  47
  48 //TRACK QUALITY (on reconstructed tracks only)
  49 //see /CORRFW/AliCFTrackQualityCuts class
  50 Bool_t UseTrackQualityforRP =  kTRUE;
  51 const Int_t    minClustersTpcRP = 80;           //default = -1;
  52 const Double_t maxChi2PerClusterTpcRP = 3.5;    //default = 1.e+09;
  53 const UShort_t minDedxClusterTpcRP = 0;
  54 const Int_t    minClustersItsRP = 2;            //panos
  55 const Double_t maxChi2PerClusterItsRP = 1.e+09;
  56 const Int_t    minClustersTrdRP = -1;
  57 const Int_t    minTrackletTrdRP = -1;
  58 const Int_t    minTrackletTrdPidRP = -1;
  59 const Double_t maxChi2PerClusterTrdRP = 1.e+09;
  60 const ULong_t  statusRP = AliESDtrack::kTPCrefit;   //AliESDtrack::kTPCrefit &  AliESDtrack::kITSrefit
  61
  62 //PRIMARY (on reconstructed tracks only)
  63 //see /CORRFW/AliCFTrackIsPrimaryCuts class
  64 Bool_t UsePrimariesforRP = kTRUE;
  65 const Bool_t   spdVertexRP = kFALSE;
  66 const Bool_t   tpcVertexRP = kFALSE;
  67 const Float_t  minDcaToVertexXyRP = 0.;
  68 const Float_t  minDcaToVertexZRP = 0.;
  69 const Float_t  maxDcaToVertexXyRP = 2.4;         //default = 1.e+10;  //2.4;
  70 const Float_t  maxDcaToVertexZRP = 3.2;          //default = 1.e+10;  //3.2;
  71 const Bool_t   dcaToVertex2dRP = kFALSE;         //default = kFALSE;
  72 const Bool_t   absDcaToVertexRP = kTRUE;         //default = kTRUE;
  73 const Double_t minNSigmaToVertexRP = 0.;
  74 const Double_t maxNSigmaToVertexRP = 1.e+10; //3.; //1.e+10
  75 const Double_t maxSigmaDcaXySP = 1.e+10;
  76 const Double_t maxSigmaDcaZSP = 1.e+10;
  77 const Bool_t   requireSigmaToVertexSP = kFALSE;
  78 const Bool_t   acceptKinkDaughtersSP = kFALSE;  //default = kTRUE;
  79
  80 //ACCEPTANCE (on generated tracks only : AliMCParticle)
  81 //see /CORRFW/AliCFAcceptanceCuts class
  82 Bool_t UseAcceptanceforRP =  kFALSE;
  83 const Int_t  minTrackrefsItsRP = 0;//3;
  84 const Int_t  minTrackrefsTpcRP = 0;//2;
  85 const Int_t  minTrackrefsTrdRP = 0;
  86 const Int_t  minTrackrefsTofRP = 0;
  87 const Int_t  minTrackrefsMuonRP = 0;
  88 //default for all is 0
  89
  90 //----------For POI selection----------
  91 //KINEMATICS (on generated and reconstructed tracks)
  92 Bool_t UseKineforPOI = kTRUE;
  93 const Double_t ptminPOI = 0.0;
  94 const Double_t ptmaxPOI = 10.0;
  95 const Double_t etaminPOI  = -0.9;
  96 const Double_t etamaxPOI  = 0.9;
  97 const Int_t    chargePOI = 1;  //not used
  98
  99 //PID (on generated and reconstructed tracks)
 100 Bool_t UsePIDforPOI = kFALSE;
 101 const Int_t PdgPOI = 321;
 102
 103 //TRACK QUALITY (on reconstructed tracks only)
 104 //see /CORRFW/AliCFTrackQualityCuts class
 105 Bool_t UseTrackQualityforPOI = kTRUE;
 106 const Int_t    minClustersTpcPOI = 80;
 107 const Double_t maxChi2PerClusterTpcPOI = 3.5;
 108 const UShort_t minDedxClusterTpcPOI = 0;
 109 const Int_t    minClustersItsPOI = 2;
 110 const Double_t maxChi2PerClusterItsPOI = 1.e+09;
 111 const Int_t    minClustersTrdPOI = -1;
 112 const Int_t    minTrackletTrdPOI = -1;
 113 const Int_t    minTrackletTrdPidPOI = -1;
 114 const Double_t maxChi2PerClusterTrdPOI = 1.e+09;
 115 const ULong_t  statusPOI = AliESDtrack::kTPCrefit;
 116
 117 //PRIMARY (on reconstructed tracks only)
 118 //see /CORRFW/AliCFTrackIsPrimaryCuts class
 119 Bool_t UsePrimariesforPOI = kTRUE;
 120 const Bool_t   spdVertexPOI = kFALSE;
 121 const Bool_t   tpcVertexPOI = kFALSE;
 122 const Float_t  minDcaToVertexXyPOI = 0.;
 123 const Float_t  minDcaToVertexZPOI = 0.;
 124 const Float_t  maxDcaToVertexXyPOI = 2.4;
 125 const Float_t  maxDcaToVertexZPOI = 3.2;
 126 const Bool_t   dcaToVertex2dPOI =  kFALSE;
 127 const Bool_t   absDcaToVertexPOI = kTRUE;
 128 const Double_t minNSigmaToVertexPOI = 0.;
 129 const Double_t maxNSigmaToVertexPOI = 1.e+10;
 130 const Double_t maxSigmaDcaXyPOI = 1.e+10;
 131 const Double_t maxSigmaDcaZPOI = 1.e+10;
 132 const Bool_t   requireSigmaToVertexPOI = kFALSE;
 133 const Bool_t   acceptKinkDaughtersPOI = kFALSE;
 134
 135 //ACCEPTANCE (on generated tracks only : AliMCParticle)
 136 //see /CORRFW/AliCFAcceptanceCuts class
 137 Bool_t UseAcceptanceforPOI = kFALSE;
 138 const Int_t minTrackrefsItsPOI = 3;
 139 const Int_t minTrackrefsTpcPOI = 2;
 140 const Int_t minTrackrefsTrdPOI = 0;
 141 const Int_t minTrackrefsTofPOI = 0;
 142 const Int_t minTrackrefsMuonPOI = 0;
 143
 144
 145 //----------For Adding Flow to the Event----------
 146 const Bool_t AddToEvent = kFALSE;
 147 Double_t ellipticFlow = 0.05;
 148
 149
 150 AliAnalysisTaskFlowEvent* AddTaskFlow(TString type, Bool_t* METHODS, Bool_t QA, Bool_t* WEIGHTS)
 151 {
 152   //boleans for the methods
 153   Bool_t SP       = METHODS[0];
 154   Bool_t LYZ1SUM  = METHODS[1];
 155   Bool_t LYZ1PROD = METHODS[2];
 156   Bool_t LYZ2SUM  = METHODS[3];
 157   Bool_t LYZ2PROD = METHODS[4];
 158   Bool_t LYZEP    = METHODS[5];
 159   Bool_t GFC      = METHODS[6];
 160   Bool_t QC       = METHODS[7];
 161   Bool_t FQD      = METHODS[8];
 162   Bool_t MCEP     = METHODS[9];
 163
 164   //for using weights
 165   Bool_t useWeights  = WEIGHTS[0] || WEIGHTS[1] || WEIGHTS[2];
 166   if (useWeights) cout<<"Weights are used"<<endl;
 167   else cout<<"Weights are not used"<<endl;
 168
 169
 170   // Get the pointer to the existing analysis manager via the static access method.
 171   //==============================================================================
 172   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
 173   if (!mgr) {
 174     Error("AddTaskFlowEvent", "No analysis manager to connect to.");
 175     return NULL;
 176   }
 177
 178   // Check the analysis type using the event handlers connected to the analysis
 179   // manager. The availability of MC handler cann also be checked here.
 180   //==============================================================================
 181   if (!mgr->GetInputEventHandler()) {
 182     ::Error("AddTaskFlowEvent", "This task requires an input event handler");
 183     return NULL;
 184   }
 185
 186   // Open external input files
 187   //===========================================================================
 188   //weights:
 189   TFile *weightsFile = NULL;
 190   TList *weightsList = NULL;
 191
 192   if(useWeights) {
 193     //open the file with the weights:
 194     weightsFile = TFile::Open("weights.root","READ");
 195     if(weightsFile) {
 196       //access the list which holds the histos with weigths:
 197       weightsList = (TList*)weightsFile->Get("weights");
 198     }
 199     else {
 200       cout<<" WARNING: the file <weights.root> with weights from the previous run was not available."<<endl;
 201       break;
 202     }
 203   }
 204
 205   //LYZ2
 206   if (LYZ2SUM || LYZ2PROD) {
 207     //read the outputfile of the first run
 208     TString outputFileName = "AnalysisResults1.root";
 209     TString pwd(gSystem->pwd());
 210     pwd+="/";
 211     pwd+=outputFileName.Data();
 212     TFile *outputFile = NULL;
 213     if(gSystem->AccessPathName(pwd.Data(),kFileExists)) {
 214       cout<<"WARNING: You do not have an output file:"<<endl;
 215       cout<<"         "<<pwd.Data()<<endl;
 216       exit(0);
 217     } else {
 218       outputFile = TFile::Open(pwd.Data(),"READ");
 219     }
 220
 221     if (LYZ2SUM){
 222       // read the output directory from LYZ1SUM
 223       TString inputFileNameLYZ2SUM = "outputLYZ1SUManalysis" ;
 224       inputFileNameLYZ2SUM += type;
 225       cout<<"The input directory is "<<inputFileNameLYZ2SUM.Data()<<endl;
 226       TFile* fInputFileLYZ2SUM = (TFile*)outputFile->FindObjectAny(inputFileNameLYZ2SUM.Data());
 227       if(!fInputFileLYZ2SUM || fInputFileLYZ2SUM->IsZombie()) {
 228         cerr << " ERROR: To run LYZ2SUM you need the output file from LYZ1SUM. This file is not there! Please run LYZ1SUM first." << endl ;
 229         break;
 230       }
 231       else {
 232         TList* fInputListLYZ2SUM = (TList*)fInputFileLYZ2SUM->Get("cobjLYZ1SUM");
 233         if (!fInputListLYZ2SUM) {cout<<"list is NULL pointer!"<<endl;}
 234       }
 235       cout<<"LYZ2SUM input file/list read..."<<endl;
 236     }
 237
 238     if (LYZ2PROD){
 239       // read the output directory from LYZ1PROD
 240       TString inputFileNameLYZ2PROD = "outputLYZ1PRODanalysis" ;
 241       inputFileNameLYZ2PROD += type;
 242       cout<<"The input directory is "<<inputFileNameLYZ2PROD.Data()<<endl;
 243       TFile* fInputFileLYZ2PROD = (TFile*)outputFile->FindObjectAny(inputFileNameLYZ2PROD.Data());
 244       if(!fInputFileLYZ2PROD || fInputFileLYZ2PROD->IsZombie()) {
 245         cerr << " ERROR: To run LYZ2PROD you need the output file from LYZ1PROD. This file is not there! Please run LYZ1PROD first." << endl ;
 246         break;
 247       }
 248       else {
 249         TList* fInputListLYZ2PROD = (TList*)fInputFileLYZ2PROD->Get("cobjLYZ1PROD");
 250         if (!fInputListLYZ2PROD) {cout<<"list is NULL pointer!"<<endl;}
 251       }
 252       cout<<"LYZ2PROD input file/list read..."<<endl;
 253     }
 254   }
 255
 256
 257   if (LYZEP) {
 258     //read the outputfile of the second run
 259     TString outputFileName = "AnalysisResults2.root";
 260     TString pwd(gSystem->pwd());
 261     pwd+="/";
 262     pwd+=outputFileName.Data();
 263     TFile *outputFile = NULL;
 264     if(gSystem->AccessPathName(pwd.Data(),kFileExists)) {
 265       cout<<"WARNING: You do not have an output file:"<<endl;
 266       cout<<"         "<<pwd.Data()<<endl;
 267       exit(0);
 268     } else {
 269       outputFile = TFile::Open(pwd.Data(),"READ");
 270     }
 271
 272     // read the output file from LYZ2SUM
 273     TString inputFileNameLYZEP = "outputLYZ2SUManalysis" ;
 274     inputFileNameLYZEP += type;
 275     cout<<"The input file is "<<inputFileNameLYZEP.Data()<<endl;
 276     TFile* fInputFileLYZEP = (TFile*)outputFile->FindObjectAny(inputFileNameLYZEP.Data());
 277     if(!fInputFileLYZEP || fInputFileLYZEP->IsZombie()) {
 278       cerr << " ERROR: To run LYZEP you need the output file from LYZ2SUM. This file is not there! Please run LYZ2SUM first." << endl ;
 279       break;
 280     }
 281     else {
 282       TList* fInputListLYZEP = (TList*)fInputFileLYZEP->Get("cobjLYZ2SUM");
 283       if (!fInputListLYZEP) {cout<<"list is NULL pointer!"<<endl;}
 284     }
 285     cout<<"LYZEP input file/list read..."<<endl;
 286   }
 287
 288
 289
 290   // Create the task, add it to the manager.
 291   //===========================================================================
 292   AliAnalysisTaskFlowEvent *taskFE = NULL;
 293   if (QA) {
 294     if(AddToEvent) {
 295       taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",kTRUE,1);
 296       taskFE->SetEllipticFlowValue(ellipticFlow); }    //TEST
 297     else {taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",kTRUE); }
 298     taskFE->SetAnalysisType(type);
 299     if (UseMultCut) {
 300       taskFE->SetMinMult(multmin);
 301       taskFE->SetMaxMult(multmax);}
 302     mgr->AddTask(taskFE);
 303   }
 304   else {
 305     taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",kFALSE);
 306     taskFE->SetAnalysisType(type);
 307     if (UseMultCut) {
 308       taskFE->SetMinMult(multmin);
 309       taskFE->SetMaxMult(multmax); }
 310     mgr->AddTask(taskFE);
 311   }
 312
 313   // Create cuts using the correction framework (CORRFW)
 314   //===========================================================================
 315   if (QA){
 316     //Set TList for the QA histograms
 317     TList* qaRP  = new TList();
 318     TList* qaPOI = new TList();
 319   }
 320
 321   //----------Event cuts----------
 322   AliCFEventGenCuts* mcEventCuts = new AliCFEventGenCuts("mcEventCuts","MC-level event cuts");
 323   mcEventCuts->SetNTracksCut(multminESD,multmaxESD);
 324   mcEventCuts->SetRequireVtxCuts(requireVtxCuts);
 325   mcEventCuts->SetVertexXCut(vertexXmin, vertexXmax);
 326   mcEventCuts->SetVertexYCut(vertexYmin, vertexYmax);
 327   mcEventCuts->SetVertexZCut(vertexZmin, vertexZmax);
 328   if (QA) {
 329     mcEventCuts->SetQAOn(qaRP);
 330   }
 331   AliCFEventRecCuts* recEventCuts = new AliCFEventRecCuts("recEventCuts","rec-level event cuts");
 332   recEventCuts->SetNTracksCut(multminESD,multmaxESD);
 333   recEventCuts->SetRequireVtxCuts(requireVtxCuts);
 334   recEventCuts->SetVertexXCut(vertexXmin, vertexXmax);
 335   recEventCuts->SetVertexYCut(vertexYmin, vertexYmax);
 336   recEventCuts->SetVertexZCut(vertexZmin, vertexZmax);
 337   if (QA) {
 338     recEventCuts->SetQAOn(qaRP);
 339   }
 340
 341   //----------Cuts for RP----------
 342   //KINEMATICS (MC and reconstructed)
 343   AliCFTrackKineCuts* mcKineCutsRP = new AliCFTrackKineCuts("mcKineCutsRP","MC-level kinematic cuts");
 344   mcKineCutsRP->SetPtRange(ptminRP,ptmaxRP);
 345   mcKineCutsRP->SetEtaRange(etaminRP,etamaxRP);
 346   //mcKineCutsRP->SetChargeMC(chargeRP);
 347   if (QA) {
 348     mcKineCutsRP->SetQAOn(qaRP);
 349   }
 350
 351   AliCFTrackKineCuts *recKineCutsRP = new AliCFTrackKineCuts("recKineCutsRP","rec-level kine cuts");
 352   recKineCutsRP->SetPtRange(ptminRP,ptmaxRP);
 353   recKineCutsRP->SetEtaRange(etaminRP,etamaxRP);
 354   //recKineCutsRP->SetChargeRec(chargeRP);
 355   if (QA) {
 356     recKineCutsRP->SetQAOn(qaRP);
 357   }
 358
 359   //PID (MC and reconstructed)
 360   AliCFParticleGenCuts* mcGenCutsRP = new AliCFParticleGenCuts("mcGenCutsRP","MC particle generation cuts for RP");
 361   mcGenCutsRP->SetRequireIsPrimary();
 362   if (UsePIDforRP) {mcGenCutsRP->SetRequirePdgCode(PdgRP);}
 363   if (QA) {
 364     mcGenCutsRP->SetQAOn(qaRP);
 365   }
 366
 367   int n_species = AliPID::kSPECIES ;
 368   Double_t* prior = new Double_t[n_species];
 369
 370   prior[0] = 0.0244519 ;
 371   prior[1] = 0.0143988 ;
 372   prior[2] = 0.805747  ;
 373   prior[3] = 0.0928785 ;
 374   prior[4] = 0.0625243 ;
 375
 376   AliCFTrackCutPid* cutPidRP = NULL;
 377   if(UsePIDforRP) {
 378     cutPidRP = new AliCFTrackCutPid("cutPidRP","ESD_PID for RP") ;
 379     cutPidRP->SetPriors(prior);
 380     cutPidRP->SetProbabilityCut(0.0);
 381     cutPidRP->SetDetectors("TPC TOF");
 382     switch(TMath::Abs(PDG1)) {
 383     case 11   : cutPidRP->SetParticleType(AliPID::kElectron, kTRUE); break;
 384     case 13   : cutPidRP->SetParticleType(AliPID::kMuon    , kTRUE); break;
 385     case 211  : cutPidRP->SetParticleType(AliPID::kPion    , kTRUE); break;
 386     case 321  : cutPidRP->SetParticleType(AliPID::kKaon    , kTRUE); break;
 387     case 2212 : cutPidRP->SetParticleType(AliPID::kProton  , kTRUE); break;
 388     default   : printf("UNDEFINED PID\n"); break;
 389     }
 390     if (QA) {
 391       cutPidRP->SetQAOn(qaRP);
 392     }
 393   }
 394
 395   //TRACK QUALITY
 396   AliCFTrackQualityCuts *recQualityCutsRP = new AliCFTrackQualityCuts("recQualityCutsRP","rec-level quality cuts");
 397   recQualityCutsRP->SetMinNClusterTPC(minClustersTpcRP);
 398   //recQualityCutsRP->SetMinFoundClusterTPC(minFoundClustersTpcRP); //only for internal TPC QA
 399   recQualityCutsRP->SetMaxChi2PerClusterTPC(maxChi2PerClusterTpcRP);
 400   recQualityCutsRP->SetMinNdEdxClusterTPC(minDedxClusterTpcRP);     //to reject secondaries
 401
 402   recQualityCutsRP->SetMinNClusterITS(minClustersItsRP);
 403   recQualityCutsRP->SetMaxChi2PerClusterITS(maxChi2PerClusterItsRP);
 404
 405   recQualityCutsRP->SetMinNClusterTRD(minClustersTrdRP);
 406   recQualityCutsRP->SetMinNTrackletTRD(minTrackletTrdRP);
 407   recQualityCutsRP->SetMinNTrackletTRDpid(minTrackletTrdPidRP);
 408   recQualityCutsRP->SetMaxChi2PerTrackletTRD(maxChi2PerClusterTrdRP);
 409   recQualityCutsRP->SetStatus(statusRP);
 410   if (QA) {
 411     recQualityCutsRP->SetQAOn(qaRP);
 412   }
 413
 414   /*
 415   //How to set this?
 416   void SetMaxCovDiagonalElements(Float_t c1=1.e+09, Float_t c2=1.e+09, Float_t c3=1.e+09, Float_t c4=1.e+09, Float_t c5=1.e+09)
 417     {fCovariance11Max=c1;fCovariance22Max=c2;fCovariance33Max=c3;fCovariance44Max=c4;fCovariance55Max=c5;}
 418   */
 419
 420   //PRIMARIES
 421   AliCFTrackIsPrimaryCuts *recIsPrimaryCutsRP = new AliCFTrackIsPrimaryCuts("recIsPrimaryCutsRP","rec-level isPrimary cuts");
 422   recIsPrimaryCutsRP->UseSPDvertex(spdVertexRP);
 423   recIsPrimaryCutsRP->UseTPCvertex(tpcVertexRP);
 424   recIsPrimaryCutsRP->SetMinDCAToVertexXY(minDcaToVertexXyRP);
 425   recIsPrimaryCutsRP->SetMinDCAToVertexZ(minDcaToVertexZRP);
 426   recIsPrimaryCutsRP->SetMaxDCAToVertexXY(maxDcaToVertexXyRP);
 427   recIsPrimaryCutsRP->SetMaxDCAToVertexZ(maxDcaToVertexZRP);
 428   recIsPrimaryCutsRP->SetDCAToVertex2D(dcaToVertex2dRP);
 429   recIsPrimaryCutsRP->SetAbsDCAToVertex(absDcaToVertexRP);
 430   recIsPrimaryCutsRP->SetMinNSigmaToVertex(minNSigmaToVertexRP);
 431   recIsPrimaryCutsRP->SetMaxNSigmaToVertex(maxNSigmaToVertexRP);
 432   recIsPrimaryCutsRP->SetMaxSigmaDCAxy(maxSigmaDcaXySP);
 433   recIsPrimaryCutsRP->SetMaxSigmaDCAz(maxSigmaDcaZSP);
 434   recIsPrimaryCutsRP->SetRequireSigmaToVertex(requireSigmaToVertexSP);
 435   recIsPrimaryCutsRP->SetAcceptKinkDaughters(acceptKinkDaughtersSP);
 436   if (QA) {
 437     recIsPrimaryCutsRP->SetQAOn(qaRP);
 438   }
 439
 440   //ACCEPTANCE
 441   AliCFAcceptanceCuts *mcAccCutsRP = new AliCFAcceptanceCuts("mcAccCutsRP","MC acceptance cuts");
 442   mcAccCutsRP->SetMinNHitITS(minTrackrefsItsRP);
 443   mcAccCutsRP->SetMinNHitTPC(minTrackrefsTpcRP);
 444   mcAccCutsRP->SetMinNHitTRD(minTrackrefsTrdRP);
 445   mcAccCutsRP->SetMinNHitTOF(minTrackrefsTofRP);
 446   mcAccCutsRP->SetMinNHitMUON(minTrackrefsMuonRP);
 447   if (QA) {
 448     mcAccCutsRP->SetQAOn(qaRP);
 449   }
 450
 451
 452   //----------Cuts for POI----------
 453   //KINEMATICS (MC and reconstructed)
 454   AliCFTrackKineCuts* mcKineCutsPOI = new AliCFTrackKineCuts("mcKineCutsPOI","MC-level kinematic cuts");
 455   mcKineCutsPOI->SetPtRange(ptminPOI,ptmaxPOI);
 456   mcKineCutsPOI->SetEtaRange(etaminPOI,etamaxPOI);
 457   //mcKineCutsPOI->SetChargeMC(chargePOI);
 458   if (QA) {
 459     mcKineCutsPOI->SetQAOn(qaPOI);
 460   }
 461
 462   AliCFTrackKineCuts *recKineCutsPOI = new AliCFTrackKineCuts("recKineCutsPOI","rec-level kine cuts");
 463   recKineCutsPOI->SetPtRange(ptminPOI,ptmaxPOI);
 464   recKineCutsPOI->SetEtaRange(etaminPOI,etamaxPOI);
 465   //recKineCutsPOI->SetChargeRec(chargePOI);
 466   if (QA) {
 467     recKineCutsPOI->SetQAOn(qaPOI);
 468   }
 469
 470   //PID (MC and reconstructed)
 471   AliCFParticleGenCuts* mcGenCutsPOI = new AliCFParticleGenCuts("mcGenCutsPOI","MC particle generation cuts for POI");
 472   mcGenCutsPOI->SetRequireIsPrimary();
 473   if (UsePIDforPOI) {mcGenCutsPOI->SetRequirePdgCode(PdgPOI);}
 474   if (QA) {
 475     mcGenCutsPOI->SetQAOn(qaPOI);
 476   }
 477
 478   AliCFTrackCutPid* cutPidPOI = NULL;
 479   if (UsePIDforPOI) {
 480     cutPidPOI = new AliCFTrackCutPid("cutPidPOI","ESD_PID for POI") ;
 481     cutPidPOI->SetPriors(prior);
 482     cutPidPOI->SetProbabilityCut(0.0);
 483     cutPidPOI->SetDetectors("TPC TOF");
 484     switch(TMath::Abs(PDG2)) {
 485     case 11   : cutPidPOI->SetParticleType(AliPID::kElectron, kTRUE); break;
 486     case 13   : cutPidPOI->SetParticleType(AliPID::kMuon    , kTRUE); break;
 487     case 211  : cutPidPOI->SetParticleType(AliPID::kPion    , kTRUE); break;
 488     case 321  : cutPidPOI->SetParticleType(AliPID::kKaon    , kTRUE); break;
 489     case 2212 : cutPidPOI->SetParticleType(AliPID::kProton  , kTRUE); break;
 490     default   : printf("UNDEFINED PID\n"); break;
 491     }
 492     if (QA) {
 493       cutPidPOI->SetQAOn(qaPOI);
 494     }
 495   }
 496
 497   //TRACK QUALITY
 498   AliCFTrackQualityCuts *recQualityCutsPOI = new AliCFTrackQualityCuts("recQualityCutsPOI","rec-level quality cuts");
 499   recQualityCutsPOI->SetMinNClusterTPC(minClustersTpcPOI);
 500   //recQualityCutsPOI->SetMinFoundClusterTPC(minFoundClustersTpcPOI); //only for internal TPC QA
 501   recQualityCutsPOI->SetMaxChi2PerClusterTPC(maxChi2PerClusterTpcPOI);
 502   recQualityCutsPOI->SetMinNdEdxClusterTPC(minDedxClusterTpcPOI);     //to reject secondaries
 503
 504   recQualityCutsPOI->SetMinNClusterITS(minClustersItsPOI);
 505   recQualityCutsPOI->SetMaxChi2PerClusterITS(maxChi2PerClusterItsPOI);
 506
 507   recQualityCutsPOI->SetMinNClusterTRD(minClustersTrdPOI);
 508   recQualityCutsPOI->SetMinNTrackletTRD(minTrackletTrdPOI);
 509   recQualityCutsPOI->SetMinNTrackletTRDpid(minTrackletTrdPidPOI);
 510   recQualityCutsPOI->SetMaxChi2PerTrackletTRD(maxChi2PerClusterTrdPOI);
 511   recQualityCutsPOI->SetStatus(statusPOI);
 512   if (QA) {
 513     recQualityCutsPOI->SetQAOn(qaPOI);
 514   }
 515
 516   //PRIMARIES
 517   AliCFTrackIsPrimaryCuts *recIsPrimaryCutsPOI = new AliCFTrackIsPrimaryCuts("recIsPrimaryCutsPOI","rec-level isPrimary cuts");
 518   recIsPrimaryCutsPOI->UseSPDvertex(spdVertexPOI);
 519   recIsPrimaryCutsPOI->UseTPCvertex(tpcVertexPOI);
 520   recIsPrimaryCutsPOI->SetMinDCAToVertexXY(minDcaToVertexXyPOI);
 521   recIsPrimaryCutsPOI->SetMinDCAToVertexZ(minDcaToVertexZPOI);
 522   recIsPrimaryCutsPOI->SetMaxDCAToVertexXY(maxDcaToVertexXyPOI);
 523   recIsPrimaryCutsPOI->SetMaxDCAToVertexZ(maxDcaToVertexZPOI);
 524   recIsPrimaryCutsPOI->SetDCAToVertex2D(dcaToVertex2dPOI);
 525   recIsPrimaryCutsPOI->SetAbsDCAToVertex(absDcaToVertexPOI);
 526   recIsPrimaryCutsPOI->SetMinNSigmaToVertex(minNSigmaToVertexPOI);
 527   recIsPrimaryCutsPOI->SetMaxNSigmaToVertex(maxNSigmaToVertexPOI);
 528   recIsPrimaryCutsPOI->SetMaxSigmaDCAxy(maxSigmaDcaXyPOI);
 529   recIsPrimaryCutsPOI->SetMaxSigmaDCAz(maxSigmaDcaZPOI);
 530   recIsPrimaryCutsPOI->SetRequireSigmaToVertex(requireSigmaToVertexPOI);
 531   recIsPrimaryCutsPOI->SetAcceptKinkDaughters(acceptKinkDaughtersPOI);
 532   if (QA) {
 533     recIsPrimaryCutsPOI->SetQAOn(qaPOI);
 534   }
 535
 536   //ACCEPTANCE
 537   AliCFAcceptanceCuts *mcAccCutsPOI = new AliCFAcceptanceCuts("mcAccCutsPOI","MC acceptance cuts");
 538   mcAccCutsPOI->SetMinNHitITS(minTrackrefsItsPOI);
 539   mcAccCutsPOI->SetMinNHitTPC(minTrackrefsTpcPOI);
 540   mcAccCutsPOI->SetMinNHitTRD(minTrackrefsTrdPOI);
 541   mcAccCutsPOI->SetMinNHitTOF(minTrackrefsTofPOI);
 542   mcAccCutsPOI->SetMinNHitMUON(minTrackrefsMuonPOI);
 543   if (QA) {
 544     mcAccCutsPOI->SetQAOn(qaPOI);
 545   }
 546
 547
 548
 549   //----------Create Cut Lists----------
 550   printf("CREATE EVENT CUTS\n");
 551   TObjArray* mcEventList = new TObjArray(0);
 552   if (UseMultCutforESD) mcEventList->AddLast(mcEventCuts);//cut on mult and vertex
 553
 554   TObjArray* recEventList = new TObjArray(0);
 555   if (UseMultCutforESD) recEventList->AddLast(recEventCuts);//cut on mult and vertex
 556
 557   printf("CREATE MC KINE CUTS\n");
 558   TObjArray* mcListRP = new TObjArray(0);
 559   if (UseKineforRP) mcListRP->AddLast(mcKineCutsRP); //cut on pt/eta/phi
 560   mcListRP->AddLast(mcGenCutsRP); //cut on primary and if (UsePIDforRP) MC PID
 561
 562   TObjArray* mcListPOI = new TObjArray(0);
 563   if (UseKineforPOI) mcListPOI->AddLast(mcKineCutsPOI); //cut on pt/eta/phi
 564   mcListPOI->AddLast(mcGenCutsPOI); //cut on primary and if (UsePIDforPOI) MC PID
 565
 566   printf("CREATE MC ACCEPTANCE CUTS\n");
 567   TObjArray* accListRP = new TObjArray(0) ;
 568   if (UseAcceptanceforRP) accListRP->AddLast(mcAccCutsRP); //cut on number of track references
 569
 570   TObjArray* accListPOI = new TObjArray(0) ;
 571   if (UseAcceptanceforPOI) accListPOI->AddLast(mcAccCutsPOI); //cut on number of track references
 572
 573   printf("CREATE ESD RECONSTRUCTION CUTS\n");
 574   TObjArray* recListRP = new TObjArray(0) ;
 575   if (UseKineforRP)         recListRP->AddLast(recKineCutsRP); //cut on pt/eta/phi
 576   if (UseTrackQualityforRP) recListRP->AddLast(recQualityCutsRP);
 577   if (UsePrimariesforRP)    recListRP->AddLast(recIsPrimaryCutsRP); //cut if it is a primary
 578
 579   TObjArray* recListPOI = new TObjArray(0) ;
 580   if (UseKineforPOI)         recListPOI->AddLast(recKineCutsPOI); //cut on pt/eta/phi
 581   if (UseTrackQualityforPOI) recListPOI->AddLast(recQualityCutsPOI);
 582   if (UsePrimariesforPOI)    recListPOI->AddLast(recIsPrimaryCutsPOI); //cut if it is a primary
 583
 584   printf("CREATE ESD PID CUTS\n");
 585   TObjArray* fPIDCutListRP = new TObjArray(0) ;
 586   if(UsePIDforRP) {fPIDCutListRP->AddLast(cutPidRP);} //cut on ESD PID
 587
 588   TObjArray* fPIDCutListPOI = new TObjArray(0) ;
 589   if (UsePIDforPOI)  {fPIDCutListPOI->AddLast(cutPidPOI);} //cut on ESD PID
 590
 591
 592   //----------Add Cut Lists to the CF Manager----------
 593   printf("CREATE INTERFACE AND CUTS\n");
 594   AliCFManager* cfmgrRP = new AliCFManager();
 595   cfmgrRP->SetNStepEvent(3);
 596   cfmgrRP->SetEventCutsList(AliCFManager::kEvtGenCuts,mcEventList);
 597   cfmgrRP->SetEventCutsList(AliCFManager::kEvtRecCuts,recEventList);
 598   cfmgrRP->SetNStepParticle(4);
 599   cfmgrRP->SetParticleCutsList(AliCFManager::kPartGenCuts,mcListRP);
 600   cfmgrRP->SetParticleCutsList(AliCFManager::kPartAccCuts,accListRP);
 601   cfmgrRP->SetParticleCutsList(AliCFManager::kPartRecCuts,recListRP);
 602   cfmgrRP->SetParticleCutsList(AliCFManager::kPartSelCuts,fPIDCutListRP);
 603
 604   AliCFManager* cfmgrPOI = new AliCFManager();
 605   cfmgrPOI->SetNStepEvent(3);
 606   cfmgrPOI->SetEventCutsList(AliCFManager::kEvtGenCuts,mcEventList);
 607   cfmgrPOI->SetEventCutsList(AliCFManager::kEvtRecCuts,recEventList);
 608   cfmgrPOI->SetNStepParticle(4);
 609   cfmgrPOI->SetParticleCutsList(AliCFManager::kPartGenCuts,mcListPOI);
 610   cfmgrPOI->SetParticleCutsList(AliCFManager::kPartAccCuts,accListPOI);
 611   cfmgrPOI->SetParticleCutsList(AliCFManager::kPartRecCuts,recListPOI);
 612   cfmgrPOI->SetParticleCutsList(AliCFManager::kPartSelCuts,fPIDCutListPOI);
 613
 614   if (QA) {
 615     taskFE->SetQAList1(qaRP);
 616     taskFE->SetQAList2(qaPOI);
 617   }
 618   taskFE->SetCFManager1(cfmgrRP);
 619   taskFE->SetCFManager2(cfmgrPOI);
 620
 621
 622
 623   // Create the analysis tasks, add them to the manager.
 624   //===========================================================================
 625   if (SP){
 626     AliAnalysisTaskScalarProduct *taskSP = new AliAnalysisTaskScalarProduct("TaskScalarProduct");
 627     mgr->AddTask(taskSP);
 628   }
 629   if (LYZ1SUM){
 630     AliAnalysisTaskLeeYangZeros *taskLYZ1SUM = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZerosSUM",kTRUE);
 631     taskLYZ1SUM->SetFirstRunLYZ(kTRUE);
 632     taskLYZ1SUM->SetUseSumLYZ(kTRUE);
 633     mgr->AddTask(taskLYZ1SUM);
 634   }
 635   if (LYZ1PROD){
 636     AliAnalysisTaskLeeYangZeros *taskLYZ1PROD = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZerosPROD",kTRUE);
 637     taskLYZ1PROD->SetFirstRunLYZ(kTRUE);
 638     taskLYZ1PROD->SetUseSumLYZ(kFALSE);
 639     mgr->AddTask(taskLYZ1PROD);
 640   }
 641   if (LYZ2SUM){
 642     AliAnalysisTaskLeeYangZeros *taskLYZ2SUM = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZerosSUM",kFALSE);
 643     taskLYZ2SUM->SetFirstRunLYZ(kFALSE);
 644     taskLYZ2SUM->SetUseSumLYZ(kTRUE);
 645     mgr->AddTask(taskLYZ2SUM);
 646   }
 647   if (LYZ2PROD){
 648     AliAnalysisTaskLeeYangZeros *taskLYZ2PROD = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZerosPROD",kFALSE);
 649     taskLYZ2PROD->SetFirstRunLYZ(kFALSE);
 650     taskLYZ2PROD->SetUseSumLYZ(kFALSE);
 651     mgr->AddTask(taskLYZ2PROD);
 652   }
 653   if (LYZEP){
 654     AliAnalysisTaskLYZEventPlane *taskLYZEP = new AliAnalysisTaskLYZEventPlane("TaskLYZEventPlane");
 655     mgr->AddTask(taskLYZEP);
 656   }
 657   if (GFC){
 658     AliAnalysisTaskCumulants *taskGFC = new AliAnalysisTaskCumulants("TaskCumulants",useWeights);
 659     taskGFC->SetUsePhiWeights(WEIGHTS[0]);
 660     taskGFC->SetUsePtWeights(WEIGHTS[1]);
 661     taskGFC->SetUseEtaWeights(WEIGHTS[2]);
 662     mgr->AddTask(taskGFC);
 663   }
 664   if (QC){
 665     AliAnalysisTaskQCumulants *taskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",useWeights);
 666     taskQC->SetUsePhiWeights(WEIGHTS[0]);
 667     taskQC->SetUsePtWeights(WEIGHTS[1]);
 668     taskQC->SetUseEtaWeights(WEIGHTS[2]);
 669     mgr->AddTask(taskQC);
 670   }
 671   if (FQD){
 672     AliAnalysisTaskFittingQDistribution *taskFQD = new AliAnalysisTaskFittingQDistribution("TaskFittingQDistribution",kFALSE);
 673     taskFQD->SetUsePhiWeights(WEIGHTS[0]);
 674     mgr->AddTask(taskFQD);
 675   }
 676   if (MCEP){
 677     AliAnalysisTaskMCEventPlane *taskMCEP = new AliAnalysisTaskMCEventPlane("TaskMCEventPlane");
 678     mgr->AddTask(taskMCEP);
 679   }
 680
 681   // Create the output container for the data produced by the task
 682   // Connect to the input and output containers
 683   //===========================================================================
 684   AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
 685   AliAnalysisDataContainer *coutputFE = mgr->CreateContainer("cobjFlowEventSimple",  AliFlowEventSimple::Class(),AliAnalysisManager::kExchangeContainer);
 686   mgr->ConnectInput(taskFE,0,cinput1);
 687   mgr->ConnectOutput(taskFE,0,coutputFE);
 688
 689   if (QA) {
 690     TString qaNameRPFE = AliAnalysisManager::GetCommonFileName();
 691     qaNameRPFE += ":QAforRP_FE_";
 692     qaNameRPFE += type;
 693
 694     AliAnalysisDataContainer *coutputQA1FE =
 695       mgr->CreateContainer("QARPFE", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameRPFE);
 696
 697     TString qaNamePOIFE = AliAnalysisManager::GetCommonFileName();
 698     qaNamePOIFE += ":QAforPOI_FE_";
 699     qaNamePOIFE += type;
 700
 701     AliAnalysisDataContainer *coutputQA2FE =
 702       mgr->CreateContainer("QAPOIFE", TList::Class(),AliAnalysisManager::kOutputContainer,qaNamePOIFE);
 703
 704     mgr->ConnectOutput(taskFE,1,coutputQA1FE);
 705     mgr->ConnectOutput(taskFE,2,coutputQA2FE);
 706   }
 707
 708   // Create the output containers for the data produced by the analysis tasks
 709   // Connect to the input and output containers
 710   //===========================================================================
 711   if (useWeights) {
 712     AliAnalysisDataContainer *cinputWeights = mgr->CreateContainer("cobjWeights",TList::Class(),AliAnalysisManager::kInputContainer);
 713   }
 714
 715   if(SP) {
 716     TString outputSP = AliAnalysisManager::GetCommonFileName();
 717     outputSP += ":outputSPanalysis";
 718     outputSP+= type;
 719
 720     AliAnalysisDataContainer *coutputSP = mgr->CreateContainer("cobjSP", TList::Class(),AliAnalysisManager::kOutputContainer,outputSP);
 721     mgr->ConnectInput(taskSP,0,coutputFE);
 722     mgr->ConnectOutput(taskSP,0,coutputSP);
 723   }
 724   if(LYZ1SUM) {
 725     TString outputLYZ1SUM = AliAnalysisManager::GetCommonFileName();
 726     outputLYZ1SUM += ":outputLYZ1SUManalysis";
 727     outputLYZ1SUM+= type;
 728
 729     AliAnalysisDataContainer *coutputLYZ1SUM = mgr->CreateContainer("cobjLYZ1SUM", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1SUM);
 730     mgr->ConnectInput(taskLYZ1SUM,0,coutputFE);
 731     mgr->ConnectOutput(taskLYZ1SUM,0,coutputLYZ1SUM);
 732   }
 733   if(LYZ1PROD) {
 734     TString outputLYZ1PROD = AliAnalysisManager::GetCommonFileName();
 735     outputLYZ1PROD += ":outputLYZ1PRODanalysis";
 736     outputLYZ1PROD+= type;
 737
 738     AliAnalysisDataContainer *coutputLYZ1PROD = mgr->CreateContainer("cobjLYZ1PROD", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1PROD);
 739     mgr->ConnectInput(taskLYZ1PROD,0,coutputFE);
 740     mgr->ConnectOutput(taskLYZ1PROD,0,coutputLYZ1PROD);
 741   }
 742   if(LYZ2SUM) {
 743     AliAnalysisDataContainer *cinputLYZ2SUM = mgr->CreateContainer("cobjLYZ2SUMin",TList::Class(),AliAnalysisManager::kInputContainer);
 744     TString outputLYZ2SUM = AliAnalysisManager::GetCommonFileName();
 745     outputLYZ2SUM += ":outputLYZ2SUManalysis";
 746     outputLYZ2SUM+= type;
 747
 748     AliAnalysisDataContainer *coutputLYZ2SUM = mgr->CreateContainer("cobjLYZ2SUM", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2SUM);
 749     mgr->ConnectInput(taskLYZ2SUM,0,coutputFE);
 750     mgr->ConnectInput(taskLYZ2SUM,1,cinputLYZ2SUM);
 751     mgr->ConnectOutput(taskLYZ2SUM,0,coutputLYZ2SUM);
 752     cinputLYZ2SUM->SetData(fInputListLYZ2SUM);
 753   }
 754   if(LYZ2PROD) {
 755     AliAnalysisDataContainer *cinputLYZ2PROD = mgr->CreateContainer("cobjLYZ2PRODin",TList::Class(),AliAnalysisManager::kInputContainer);
 756     TString outputLYZ2PROD = AliAnalysisManager::GetCommonFileName();
 757     outputLYZ2PROD += ":outputLYZ2PRODanalysis";
 758     outputLYZ2PROD+= type;
 759
 760     AliAnalysisDataContainer *coutputLYZ2PROD = mgr->CreateContainer("cobjLYZ2PROD", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2PROD);
 761     mgr->ConnectInput(taskLYZ2PROD,0,coutputFE);
 762     mgr->ConnectInput(taskLYZ2PROD,1,cinputLYZ2PROD);
 763     mgr->ConnectOutput(taskLYZ2PROD,0,coutputLYZ2PROD);
 764     cinputLYZ2PROD->SetData(fInputListLYZ2PROD);
 765   }
 766   if(LYZEP) {
 767     AliAnalysisDataContainer *cinputLYZEP = mgr->CreateContainer("cobjLYZEPin",TList::Class(),AliAnalysisManager::kInputContainer);
 768     TString outputLYZEP = AliAnalysisManager::GetCommonFileName();
 769     outputLYZEP += ":outputLYZEPanalysis";
 770     outputLYZEP+= type;
 771
 772     AliAnalysisDataContainer *coutputLYZEP = mgr->CreateContainer("cobjLYZEP", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZEP);
 773     mgr->ConnectInput(taskLYZEP,0,coutputFE);
 774     mgr->ConnectInput(taskLYZEP,1,cinputLYZEP);
 775     mgr->ConnectOutput(taskLYZEP,0,coutputLYZEP);
 776     cinputLYZEP->SetData(fInputListLYZEP);
 777   }
 778   if(GFC) {
 779     TString outputGFC = AliAnalysisManager::GetCommonFileName();
 780     outputGFC += ":outputGFCanalysis";
 781     outputGFC+= type;
 782
 783     AliAnalysisDataContainer *coutputGFC = mgr->CreateContainer("cobjGFC", TList::Class(),AliAnalysisManager::kOutputContainer,outputGFC);
 784     mgr->ConnectInput(taskGFC,0,coutputFE);
 785     mgr->ConnectOutput(taskGFC,0,coutputGFC);
 786     if (useWeights) {
 787       mgr->ConnectInput(taskGFC,1,cinputWeights);
 788       cinputWeights->SetData(weightsList);
 789     }
 790   }
 791   if(QC) {
 792     TString outputQC = AliAnalysisManager::GetCommonFileName();
 793     outputQC += ":outputQCanalysis";
 794     outputQC+= type;
 795
 796     AliAnalysisDataContainer *coutputQC = mgr->CreateContainer("cobjQC", TList::Class(),AliAnalysisManager::kOutputContainer,outputQC);
 797     mgr->ConnectInput(taskQC,0,coutputFE);
 798     mgr->ConnectOutput(taskQC,0,coutputQC);
 799     if (useWeights) {
 800       mgr->ConnectInput(taskQC,1,cinputWeights);
 801       cinputWeights->SetData(weightsList);
 802     }
 803   }
 804   if(FQD) {
 805     TString outputFQD = AliAnalysisManager::GetCommonFileName();
 806     outputFQD += ":outputFQDanalysis";
 807     outputFQD+= type;
 808
 809     AliAnalysisDataContainer *coutputFQD = mgr->CreateContainer("cobjFQD", TList::Class(),AliAnalysisManager::kOutputContainer,outputFQD);
 810     mgr->ConnectInput(taskFQD,0,coutputFE);
 811     mgr->ConnectOutput(taskFQD,0,coutputFQD);
 812     if(useWeights) {
 813       mgr->ConnectInput(taskFQD,1,cinputWeights);
 814       cinputWeights->SetData(weightsList);
 815     }
 816   }
 817   if(MCEP) {
 818     TString outputMCEP = AliAnalysisManager::GetCommonFileName();
 819     outputMCEP += ":outputMCEPanalysis";
 820     outputMCEP+= type;
 821
 822     AliAnalysisDataContainer *coutputMCEP = mgr->CreateContainer("cobjMCEP", TList::Class(),AliAnalysisManager::kOutputContainer,outputMCEP);
 823     mgr->ConnectInput(taskMCEP,0,coutputFE);
 824     mgr->ConnectOutput(taskMCEP,0,coutputMCEP);
 825   }
 826
 827
 828   // Return analysis task
 829   //===========================================================================
 830   return taskFE;
 831
 832
 833
 834 }
 835
 836
 837
 838
 839