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