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 // For RP selection
  14 const Double_t ptmin1 = 0.0;
  15 const Double_t ptmax1 = 10.0;
  16 const Double_t ymin1  = -1.;
  17 const Double_t ymax1  = 1.;
  18 const Int_t mintrackrefsTPC1 = 2;
  19 const Int_t mintrackrefsITS1 = 3;
  20 const Int_t charge1 = 1;
  21 Bool_t UsePIDforRP = kFALSE;
  22 const Int_t PDG1 = 211;
  23 const Int_t minclustersTPC1 = 50;
  24 const Int_t maxnsigmatovertex1 = 3;
  25
  26 // For for POI selection
  27 const Double_t ptmin2 = 0.0;
  28 const Double_t ptmax2 = 10.0;
  29 const Double_t ymin2  = -1.;
  30 const Double_t ymax2  = 1.;
  31 const Int_t mintrackrefsTPC2 = 2;
  32 const Int_t mintrackrefsITS2 = 3;
  33 const Int_t charge2 = 1;
  34 Bool_t UsePIDforPOI = kFALSE;
  35 const Int_t PDG2 = 321;
  36 const Int_t minclustersTPC2 = 50;
  37 const Int_t maxnsigmatovertex2 = 3;
  38
  39
  40 AliAnalysisTaskFlowEvent* AddTaskFlow(TString type, Bool_t* METHODS, Bool_t QA, Bool_t* WEIGHTS)
  41 {
  42   //boleans for the methods
  43   Bool_t SP       = METHODS[0];
  44   Bool_t LYZ1SUM  = METHODS[1];
  45   Bool_t LYZ1PROD = METHODS[2];
  46   Bool_t LYZ2SUM  = METHODS[3];
  47   Bool_t LYZ2PROD = METHODS[4];
  48   Bool_t LYZEP    = METHODS[5];
  49   Bool_t GFC      = METHODS[6];
  50   Bool_t QC       = METHODS[7];
  51   Bool_t FQD      = METHODS[8];
  52   Bool_t MCEP     = METHODS[9];
  53
  54   //for using weights
  55   Bool_t useWeights  = WEIGHTS[0] || WEIGHTS[1] || WEIGHTS[2];
  56   if (useWeights) cout<<"Weights are used"<<endl;
  57   else cout<<"Weights are not used"<<endl;
  58
  59
  60   // Get the pointer to the existing analysis manager via the static access method.
  61   //==============================================================================
  62   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  63   if (!mgr) {
  64     Error("AddTaskFlowEvent", "No analysis manager to connect to.");
  65     return NULL;
  66   }
  67
  68   // Check the analysis type using the event handlers connected to the analysis
  69   // manager. The availability of MC handler cann also be checked here.
  70   //==============================================================================
  71   if (!mgr->GetInputEventHandler()) {
  72     ::Error("AddTaskFlowEvent", "This task requires an input event handler");
  73     return NULL;
  74   }
  75
  76   // Open external input files
  77   //===========================================================================
  78   //weights:
  79   TFile *weightsFile = NULL;
  80   TList *weightsList = NULL;
  81
  82   if(useWeights) {
  83     //open the file with the weights:
  84     weightsFile = TFile::Open("weights.root","READ");
  85     if(weightsFile) {
  86       //access the list which holds the histos with weigths:
  87       weightsList = (TList*)weightsFile->Get("weights");
  88     }
  89     else {
  90       cout<<" WARNING: the file <weights.root> with weights from the previous run was not available."<<endl;
  91       break;
  92     }
  93   }
  94
  95   if (LYZ2SUM){
  96     // read the output file from LYZ1SUM
  97     TString inputFileNameLYZ2SUM = "outputLYZ1SUManalysis" ;
  98     inputFileNameLYZ2SUM += type;
  99     inputFileNameLYZ2SUM += ".root";
 100     cout<<"The input file is "<<inputFileNameLYZ2SUM.Data()<<endl;
 101     TFile* fInputFileLYZ2SUM = new TFile(inputFileNameLYZ2SUM.Data(),"READ");
 102     if(!fInputFileLYZ2SUM || fInputFileLYZ2SUM->IsZombie()) {
 103       cerr << " ERROR: To run LYZ2SUM you need the output file from LYZ1SUM. This file is not there! Please run LYZ1SUM first." << endl ;
 104       break;
 105     }
 106     else {
 107       TList* fInputListLYZ2SUM = (TList*)fInputFileLYZ2SUM->Get("cobjLYZ1SUM");
 108       if (!fInputListLYZ2SUM) {cout<<"list is NULL pointer!"<<endl;}
 109     }
 110     cout<<"LYZ2SUM input file/list read..."<<endl;
 111   }
 112 if (LYZ2PROD){
 113     // read the output file from LYZ1PROD
 114     TString inputFileNameLYZ2PROD = "outputLYZ1PRODanalysis" ;
 115     inputFileNameLYZ2PROD += type;
 116     inputFileNameLYZ2PROD += ".root";
 117     cout<<"The input file is "<<inputFileNameLYZ2PROD.Data()<<endl;
 118     TFile* fInputFileLYZ2PROD = new TFile(inputFileNameLYZ2PROD.Data(),"READ");
 119     if(!fInputFileLYZ2PROD || fInputFileLYZ2PROD->IsZombie()) {
 120       cerr << " ERROR: To run LYZ2PROD you need the output file from LYZ1PROD. This file is not there! Please run LYZ1PROD first." << endl ;
 121       break;
 122     }
 123     else {
 124       TList* fInputListLYZ2PROD = (TList*)fInputFileLYZ2PROD->Get("cobjLYZ1PROD");
 125       if (!fInputListLYZ2PROD) {cout<<"list is NULL pointer!"<<endl;}
 126     }
 127     cout<<"LYZ2PROD input file/list read..."<<endl;
 128   }
 129
 130   if (LYZEP) {
 131     // read the output file from LYZ2SUM
 132     TString inputFileNameLYZEP = "outputLYZ2SUManalysis" ;
 133     inputFileNameLYZEP += type;
 134     inputFileNameLYZEP += ".root";
 135     cout<<"The input file is "<<inputFileNameLYZEP.Data()<<endl;
 136     TFile* fInputFileLYZEP = new TFile(inputFileNameLYZEP.Data(),"READ");
 137     if(!fInputFileLYZEP || fInputFileLYZEP->IsZombie()) {
 138       cerr << " ERROR: To run LYZEP you need the output file from LYZ2SUM. This file is not there! Please run LYZ2SUM first." << endl ;
 139       break;
 140     }
 141     else {
 142       TList* fInputListLYZEP = (TList*)fInputFileLYZEP->Get("cobjLYZ2SUM");
 143       if (!fInputListLYZEP) {cout<<"list is NULL pointer!"<<endl;}
 144     }
 145     cout<<"LYZEP input file/list read..."<<endl;
 146   }
 147
 148
 149
 150   // Create the task, add it to the manager.
 151   //===========================================================================
 152   AliAnalysisTaskFlowEvent *taskFE = NULL;
 153   if (QA) {
 154     taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",kTRUE);
 155     taskFE->SetAnalysisType(type);
 156     mgr->AddTask(taskFE);
 157   }
 158   else {
 159     taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",kFALSE);
 160     taskFE->SetAnalysisType(type);
 161     mgr->AddTask(taskFE);
 162   }
 163
 164   // Create cuts using the correction framework (CORRFW)
 165   //===========================================================================
 166   if (QA){
 167     //Set TList for the QA histograms
 168     TList* qaRP  = new TList();
 169     TList* qaPOI = new TList();
 170   }
 171
 172   //############# cuts on MC
 173   AliCFTrackKineCuts* mcKineCuts1 = new AliCFTrackKineCuts("mcKineCuts1","MC-level kinematic cuts");
 174   mcKineCuts1->SetPtRange(ptmin1,ptmax1);
 175   mcKineCuts1->SetRapidityRange(ymin1,ymax1);
 176   //mcKineCuts1->SetChargeMC(charge1);
 177   if (QA) {
 178     mcKineCuts1->SetQAOn(qaRP);
 179   }
 180
 181   AliCFTrackKineCuts* mcKineCuts2 = new AliCFTrackKineCuts("mcKineCuts2","MC-level kinematic cuts");
 182   mcKineCuts2->SetPtRange(ptmin2,ptmax2);
 183   mcKineCuts2->SetRapidityRange(ymin2,ymax2);
 184   //mcKineCuts2->SetChargeMC(charge2);
 185   if (QA) {
 186     mcKineCuts2->SetQAOn(qaPOI);
 187   }
 188
 189   AliCFParticleGenCuts* mcGenCuts1 = new AliCFParticleGenCuts("mcGenCuts1","MC particle generation cuts for RP");
 190   mcGenCuts1->SetRequireIsPrimary();
 191   if (UsePIDforRP) {mcGenCuts1->SetRequirePdgCode(PDG1);}
 192   if (QA) {
 193     mcGenCuts1->SetQAOn(qaRP);
 194   }
 195
 196   AliCFParticleGenCuts* mcGenCuts2 = new AliCFParticleGenCuts("mcGenCuts2","MC particle generation cuts for POI");
 197   mcGenCuts2->SetRequireIsPrimary();
 198   if (UsePIDforPOI) {mcGenCuts2->SetRequirePdgCode(PDG2);}
 199   if (QA) {
 200     mcGenCuts2->SetQAOn(qaPOI);
 201   }
 202
 203   //############# Acceptance Cuts
 204   AliCFAcceptanceCuts *mcAccCuts1 = new AliCFAcceptanceCuts("mcAccCuts1","MC acceptance cuts");
 205   mcAccCuts1->SetMinNHitITS(mintrackrefsITS1);
 206   mcAccCuts1->SetMinNHitTPC(mintrackrefsTPC1);
 207   if (QA) {
 208     mcAccCuts1->SetQAOn(qaRP);
 209   }
 210
 211   AliCFAcceptanceCuts *mcAccCuts2 = new AliCFAcceptanceCuts("mcAccCuts2","MC acceptance cuts");
 212   mcAccCuts2->SetMinNHitITS(mintrackrefsITS2);
 213   mcAccCuts2->SetMinNHitTPC(mintrackrefsTPC2);
 214   if (QA) {
 215     mcAccCuts2->SetQAOn(qaPOI);
 216   }
 217   //############# Rec-Level kinematic cuts
 218   AliCFTrackKineCuts *recKineCuts1 = new AliCFTrackKineCuts("recKineCuts1","rec-level kine cuts");
 219   recKineCuts1->SetPtRange(ptmin1,ptmax1);
 220   recKineCuts1->SetRapidityRange(ymin1,ymax1);
 221   //recKineCuts1->SetChargeRec(charge1);
 222   if (QA) {
 223     recKineCuts1->SetQAOn(qaRP);
 224   }
 225
 226   AliCFTrackKineCuts *recKineCuts2 = new AliCFTrackKineCuts("recKineCuts2","rec-level kine cuts");
 227   recKineCuts2->SetPtRange(ptmin2,ptmax2);
 228   recKineCuts2->SetRapidityRange(ymin2,ymax2);
 229   //recKineCuts2->SetChargeRec(charge2);
 230   if (QA) {
 231     recKineCuts2->SetQAOn(qaPOI);
 232   }
 233
 234   AliCFTrackQualityCuts *recQualityCuts1 = new AliCFTrackQualityCuts("recQualityCuts1","rec-level quality cuts");
 235   recQualityCuts1->SetMinNClusterTPC(minclustersTPC1);
 236   recQualityCuts1->SetStatus(AliESDtrack::kITSrefit);
 237   if (QA) {
 238     recQualityCuts1->SetQAOn(qaRP);
 239   }
 240   AliCFTrackQualityCuts *recQualityCuts2 = new AliCFTrackQualityCuts("recQualityCuts2","rec-level quality cuts");
 241   recQualityCuts2->SetMinNClusterTPC(minclustersTPC2);
 242   recQualityCuts2->SetStatus(AliESDtrack::kITSrefit);
 243   if (QA) {
 244     recQualityCuts2->SetQAOn(qaPOI);
 245   }
 246
 247   AliCFTrackIsPrimaryCuts *recIsPrimaryCuts1 = new AliCFTrackIsPrimaryCuts("recIsPrimaryCuts1","rec-level isPrimary cuts");
 248   recIsPrimaryCuts1->SetMaxNSigmaToVertex(maxnsigmatovertex1);
 249   if (QA) {
 250     recIsPrimaryCuts1->SetQAOn(qaRP);
 251   }
 252
 253   AliCFTrackIsPrimaryCuts *recIsPrimaryCuts2 = new AliCFTrackIsPrimaryCuts("recIsPrimaryCuts2","rec-level isPrimary cuts");
 254   recIsPrimaryCuts2->SetMaxNSigmaToVertex(maxnsigmatovertex2);
 255   if (QA) {
 256     recIsPrimaryCuts2->SetQAOn(qaPOI);
 257   }
 258
 259   int n_species = AliPID::kSPECIES ;
 260   Double_t* prior = new Double_t[n_species];
 261
 262   prior[0] = 0.0244519 ;
 263   prior[1] = 0.0143988 ;
 264   prior[2] = 0.805747  ;
 265   prior[3] = 0.0928785 ;
 266   prior[4] = 0.0625243 ;
 267
 268   AliCFTrackCutPid* cutPID1 = NULL;
 269   if(UsePIDforRP) {
 270     AliCFTrackCutPid* cutPID1 = new AliCFTrackCutPid("cutPID1","ESD_PID for RP") ;
 271     cutPID1->SetPriors(prior);
 272     cutPID1->SetProbabilityCut(0.0);
 273     cutPID1->SetDetectors("TPC TOF");
 274     switch(TMath::Abs(PDG1)) {
 275     case 11   : cutPID1->SetParticleType(AliPID::kElectron, kTRUE); break;
 276     case 13   : cutPID1->SetParticleType(AliPID::kMuon    , kTRUE); break;
 277     case 211  : cutPID1->SetParticleType(AliPID::kPion    , kTRUE); break;
 278     case 321  : cutPID1->SetParticleType(AliPID::kKaon    , kTRUE); break;
 279     case 2212 : cutPID1->SetParticleType(AliPID::kProton  , kTRUE); break;
 280     default   : printf("UNDEFINED PID\n"); break;
 281     }
 282     if (QA) {
 283       cutPID1->SetQAOn(qaRP);
 284     }
 285   }
 286
 287   AliCFTrackCutPid* cutPID2 = NULL;
 288   if (UsePIDforPOI) {
 289     AliCFTrackCutPid* cutPID2 = new AliCFTrackCutPid("cutPID2","ESD_PID for POI") ;
 290     cutPID2->SetPriors(prior);
 291     cutPID2->SetProbabilityCut(0.0);
 292     cutPID2->SetDetectors("TPC TOF");
 293     switch(TMath::Abs(PDG2)) {
 294     case 11   : cutPID2->SetParticleType(AliPID::kElectron, kTRUE); break;
 295     case 13   : cutPID2->SetParticleType(AliPID::kMuon    , kTRUE); break;
 296     case 211  : cutPID2->SetParticleType(AliPID::kPion    , kTRUE); break;
 297     case 321  : cutPID2->SetParticleType(AliPID::kKaon    , kTRUE); break;
 298     case 2212 : cutPID2->SetParticleType(AliPID::kProton  , kTRUE); break;
 299     default   : printf("UNDEFINED PID\n"); break;
 300     }
 301     if (QA) {
 302       cutPID2->SetQAOn(qaPOI);
 303     }
 304   }
 305
 306   printf("CREATE MC KINE CUTS\n");
 307   TObjArray* mcList1 = new TObjArray(0);
 308   mcList1->AddLast(mcKineCuts1);
 309   mcList1->AddLast(mcGenCuts1);
 310
 311   TObjArray* mcList2 = new TObjArray(0);
 312   mcList2->AddLast(mcKineCuts2);
 313   mcList2->AddLast(mcGenCuts2);
 314
 315   printf("CREATE ACCEPTANCE CUTS\n");
 316   TObjArray* accList1 = new TObjArray(0) ;
 317   accList1->AddLast(mcAccCuts1);
 318
 319   TObjArray* accList2 = new TObjArray(0) ;
 320   accList2->AddLast(mcAccCuts2);
 321
 322   printf("CREATE RECONSTRUCTION CUTS\n");
 323   TObjArray* recList1 = new TObjArray(0) ;
 324   recList1->AddLast(recKineCuts1);
 325   recList1->AddLast(recQualityCuts1);
 326   recList1->AddLast(recIsPrimaryCuts1);
 327
 328   TObjArray* recList2 = new TObjArray(0) ;
 329   recList2->AddLast(recKineCuts2);
 330   recList2->AddLast(recQualityCuts2);
 331   recList2->AddLast(recIsPrimaryCuts2);
 332
 333   printf("CREATE PID CUTS\n");
 334   TObjArray* fPIDCutList1 = new TObjArray(0) ;
 335   if(UsePIDforRP) {fPIDCutList1->AddLast(cutPID1);}
 336
 337   TObjArray* fPIDCutList2 = new TObjArray(0) ;
 338   if (UsePIDforPOI)  {fPIDCutList2->AddLast(cutPID2);}
 339
 340   printf("CREATE INTERFACE AND CUTS\n");
 341   AliCFManager* cfmgr1 = new AliCFManager();
 342   cfmgr1->SetNStepParticle(4);
 343   cfmgr1->SetParticleCutsList(AliCFManager::kPartGenCuts,mcList1);
 344   cfmgr1->SetParticleCutsList(AliCFManager::kPartAccCuts,accList1);
 345   cfmgr1->SetParticleCutsList(AliCFManager::kPartRecCuts,recList1);
 346   cfmgr1->SetParticleCutsList(AliCFManager::kPartSelCuts,fPIDCutList1);
 347
 348   AliCFManager* cfmgr2 = new AliCFManager();
 349   cfmgr2->SetNStepParticle(4);
 350   cfmgr2->SetParticleCutsList(AliCFManager::kPartGenCuts,mcList2);
 351   cfmgr2->SetParticleCutsList(AliCFManager::kPartAccCuts,accList2);
 352   cfmgr2->SetParticleCutsList(AliCFManager::kPartRecCuts,recList2);
 353   cfmgr2->SetParticleCutsList(AliCFManager::kPartSelCuts,fPIDCutList2);
 354
 355   if (QA) {
 356     taskFE->SetQAList1(qaRP);
 357     taskFE->SetQAList2(qaPOI);
 358   }
 359   taskFE->SetCFManager1(cfmgr1);
 360   taskFE->SetCFManager2(cfmgr2);
 361
 362
 363
 364   // Create the analysis tasks, add them to the manager.
 365   //===========================================================================
 366   if (SP){
 367     AliAnalysisTaskScalarProduct *taskSP = new AliAnalysisTaskScalarProduct("TaskScalarProduct");
 368     mgr->AddTask(taskSP);
 369   }
 370   if (LYZ1SUM){
 371     AliAnalysisTaskLeeYangZeros *taskLYZ1SUM = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZerosSUM",kTRUE);
 372     taskLYZ1SUM->SetFirstRunLYZ(kTRUE);
 373     taskLYZ1SUM->SetUseSumLYZ(kTRUE);
 374     mgr->AddTask(taskLYZ1SUM);
 375   }
 376   if (LYZ1PROD){
 377     AliAnalysisTaskLeeYangZeros *taskLYZ1PROD = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZerosPROD",kTRUE);
 378     taskLYZ1PROD->SetFirstRunLYZ(kTRUE);
 379     taskLYZ1PROD->SetUseSumLYZ(kFALSE);
 380     mgr->AddTask(taskLYZ1PROD);
 381   }
 382   if (LYZ2SUM){
 383     AliAnalysisTaskLeeYangZeros *taskLYZ2SUM = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZerosSUM",kFALSE);
 384     taskLYZ2SUM->SetFirstRunLYZ(kFALSE);
 385     taskLYZ2SUM->SetUseSumLYZ(kTRUE);
 386     mgr->AddTask(taskLYZ2SUM);
 387   }
 388   if (LYZ2PROD){
 389     AliAnalysisTaskLeeYangZeros *taskLYZ2PROD = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZerosPROD",kFALSE);
 390     taskLYZ2PROD->SetFirstRunLYZ(kFALSE);
 391     taskLYZ2PROD->SetUseSumLYZ(kFALSE);
 392     mgr->AddTask(taskLYZ2PROD);
 393   }
 394   if (LYZEP){
 395     AliAnalysisTaskLYZEventPlane *taskLYZEP = new AliAnalysisTaskLYZEventPlane("TaskLYZEventPlane");
 396     mgr->AddTask(taskLYZEP);
 397   }
 398   if (GFC){
 399     AliAnalysisTaskCumulants *taskGFC = new AliAnalysisTaskCumulants("TaskCumulants",useWeights);
 400     taskGFC->SetUsePhiWeights(WEIGHTS[0]);
 401     taskGFC->SetUsePtWeights(WEIGHTS[1]);
 402     taskGFC->SetUseEtaWeights(WEIGHTS[2]);
 403     mgr->AddTask(taskGFC);
 404   }
 405   if (QC){
 406     AliAnalysisTaskQCumulants *taskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",useWeights);
 407     taskQC->SetUsePhiWeights(WEIGHTS[0]);
 408     taskQC->SetUsePtWeights(WEIGHTS[1]);
 409     taskQC->SetUseEtaWeights(WEIGHTS[2]);
 410     mgr->AddTask(taskQC);
 411   }
 412   if (FQD){
 413     AliAnalysisTaskFittingQDistribution *taskFQD = new AliAnalysisTaskFittingQDistribution("TaskFittingQDistribution",kFALSE);
 414     taskFQD->SetUsePhiWeights(WEIGHTS[0]);
 415     mgr->AddTask(taskFQD);
 416   }
 417   if (MCEP){
 418     AliAnalysisTaskMCEventPlane *taskMCEP = new AliAnalysisTaskMCEventPlane("TaskMCEventPlane");
 419     mgr->AddTask(taskMCEP);
 420   }
 421
 422   // Create the output container for the data produced by the task
 423   // Connect to the input and output containers
 424   //===========================================================================
 425   AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
 426   AliAnalysisDataContainer *coutputFE = mgr->CreateContainer("cobjFlowEventSimple",  AliFlowEventSimple::Class(),AliAnalysisManager::kExchangeContainer);
 427   mgr->ConnectInput(taskFE,0,cinput1);
 428   mgr->ConnectOutput(taskFE,0,coutputFE);
 429
 430   if (QA) {
 431     TString qaNameRPFE = "QAforRP_FE_";
 432     qaNameRPFE += type;
 433     qaNameRPFE += ".root";
 434     AliAnalysisDataContainer *coutputQA1FE =
 435       mgr->CreateContainer("QARPFE", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameRPFE);
 436
 437     TString qaNamePOIFE = "QAforPOI_FE_";
 438     qaNamePOIFE += type;
 439     qaNamePOIFE += ".root";
 440     AliAnalysisDataContainer *coutputQA2FE =
 441       mgr->CreateContainer("QAPOIFE", TList::Class(),AliAnalysisManager::kOutputContainer,qaNamePOIFE);
 442
 443     mgr->ConnectOutput(taskFE,1,coutputQA1FE);
 444     mgr->ConnectOutput(taskFE,2,coutputQA2FE);
 445   }
 446
 447   // Create the output containers for the data produced by the analysis tasks
 448   // Connect to the input and output containers
 449   //===========================================================================
 450   if (useWeights) {
 451     AliAnalysisDataContainer *cinputWeights = mgr->CreateContainer("cobjWeights",TList::Class(),AliAnalysisManager::kInputContainer);
 452   }
 453
 454   if(SP) {
 455     TString outputSP = "outputSPanalysis";
 456     outputSP+= type;
 457     outputSP+= ".root";
 458     AliAnalysisDataContainer *coutputSP = mgr->CreateContainer("cobjSP", TList::Class(),AliAnalysisManager::kOutputContainer,outputSP);
 459     mgr->ConnectInput(taskSP,0,coutputFE);
 460     mgr->ConnectOutput(taskSP,0,coutputSP);
 461   }
 462   if(LYZ1SUM) {
 463     TString outputLYZ1SUM = "outputLYZ1SUManalysis";
 464     outputLYZ1SUM+= type;
 465     outputLYZ1SUM+= ".root";
 466     AliAnalysisDataContainer *coutputLYZ1SUM = mgr->CreateContainer("cobjLYZ1SUM", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1SUM);
 467     mgr->ConnectInput(taskLYZ1SUM,0,coutputFE);
 468     mgr->ConnectOutput(taskLYZ1SUM,0,coutputLYZ1SUM);
 469   }
 470   if(LYZ1PROD) {
 471     TString outputLYZ1PROD = "outputLYZ1PRODanalysis";
 472     outputLYZ1PROD+= type;
 473     outputLYZ1PROD+= ".root";
 474     AliAnalysisDataContainer *coutputLYZ1PROD = mgr->CreateContainer("cobjLYZ1PROD", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1PROD);
 475     mgr->ConnectInput(taskLYZ1PROD,0,coutputFE);
 476     mgr->ConnectOutput(taskLYZ1PROD,0,coutputLYZ1PROD);
 477   }
 478   if(LYZ2SUM) {
 479     AliAnalysisDataContainer *cinputLYZ2SUM = mgr->CreateContainer("cobjLYZ2SUMin",TList::Class(),AliAnalysisManager::kInputContainer);
 480     TString outputLYZ2SUM = "outputLYZ2SUManalysis";
 481     outputLYZ2SUM+= type;
 482     outputLYZ2SUM+= ".root";
 483     AliAnalysisDataContainer *coutputLYZ2SUM = mgr->CreateContainer("cobjLYZ2SUM", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2SUM);
 484     mgr->ConnectInput(taskLYZ2SUM,0,coutputFE);
 485     mgr->ConnectInput(taskLYZ2SUM,1,cinputLYZ2SUM);
 486     mgr->ConnectOutput(taskLYZ2SUM,0,coutputLYZ2SUM);
 487     cinputLYZ2SUM->SetData(fInputListLYZ2SUM);
 488   }
 489   if(LYZ2PROD) {
 490     AliAnalysisDataContainer *cinputLYZ2PROD = mgr->CreateContainer("cobjLYZ2PRODin",TList::Class(),AliAnalysisManager::kInputContainer);
 491     TString outputLYZ2PROD = "outputLYZ2PRODanalysis";
 492     outputLYZ2PROD+= type;
 493     outputLYZ2PROD+= ".root";
 494     AliAnalysisDataContainer *coutputLYZ2PROD = mgr->CreateContainer("cobjLYZ2PROD", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2PROD);
 495     mgr->ConnectInput(taskLYZ2PROD,0,coutputFE);
 496     mgr->ConnectInput(taskLYZ2PROD,1,cinputLYZ2PROD);
 497     mgr->ConnectOutput(taskLYZ2PROD,0,coutputLYZ2PROD);
 498     cinputLYZ2PROD->SetData(fInputListLYZ2PROD);
 499   }
 500   if(LYZEP) {
 501     AliAnalysisDataContainer *cinputLYZEP = mgr->CreateContainer("cobjLYZEPin",TList::Class(),AliAnalysisManager::kInputContainer);
 502     TString outputLYZEP = "outputLYZEPanalysis";
 503     outputLYZEP+= type;
 504     outputLYZEP+= ".root";
 505     AliAnalysisDataContainer *coutputLYZEP = mgr->CreateContainer("cobjLYZEP", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZEP);
 506     mgr->ConnectInput(taskLYZEP,0,coutputFE);
 507     mgr->ConnectInput(taskLYZEP,1,cinputLYZEP);
 508     mgr->ConnectOutput(taskLYZEP,0,coutputLYZEP);
 509     cinputLYZEP->SetData(fInputListLYZEP);
 510   }
 511   if(GFC) {
 512     TString outputGFC = "outputGFCanalysis";
 513     outputGFC+= type;
 514     outputGFC+= ".root";
 515     AliAnalysisDataContainer *coutputGFC = mgr->CreateContainer("cobjGFC", TList::Class(),AliAnalysisManager::kOutputContainer,outputGFC);
 516     mgr->ConnectInput(taskGFC,0,coutputFE);
 517     mgr->ConnectOutput(taskGFC,0,coutputGFC);
 518     if (useWeights) {
 519       mgr->ConnectInput(taskGFC,1,cinputWeights);
 520       cinputWeights->SetData(weightsList);
 521     }
 522   }
 523   if(QC) {
 524     TString outputQC = "outputQCanalysis";
 525     outputQC+= type;
 526     outputQC+= ".root";
 527     AliAnalysisDataContainer *coutputQC = mgr->CreateContainer("cobjQC", TList::Class(),AliAnalysisManager::kOutputContainer,outputQC);
 528     mgr->ConnectInput(taskQC,0,coutputFE);
 529     mgr->ConnectOutput(taskQC,0,coutputQC);
 530     if (useWeights) {
 531       mgr->ConnectInput(taskQC,1,cinputWeights);
 532       cinputWeights->SetData(weightsList);
 533     }
 534   }
 535   if(FQD) {
 536     TString outputFQD = "outputFQDanalysis";
 537     outputFQD+= type;
 538     outputFQD+= ".root";
 539     AliAnalysisDataContainer *coutputFQD = mgr->CreateContainer("cobjFQD", TList::Class(),AliAnalysisManager::kOutputContainer,outputFQD);
 540     mgr->ConnectInput(taskFQD,0,coutputFE);
 541     mgr->ConnectOutput(taskFQD,0,coutputFQD);
 542     if(useWeights) {
 543       mgr->ConnectInput(taskFQD,1,cinputWeights);
 544       cinputWeights->SetData(weightsList);
 545     }
 546   }
 547   if(MCEP) {
 548     TString outputMCEP = "outputMCEPanalysis";
 549     outputMCEP+= type;
 550     outputMCEP+= ".root";
 551     AliAnalysisDataContainer *coutputMCEP = mgr->CreateContainer("cobjMCEP", TList::Class(),AliAnalysisManager::kOutputContainer,outputMCEP);
 552     mgr->ConnectInput(taskMCEP,0,coutputFE);
 553     mgr->ConnectOutput(taskMCEP,0,coutputMCEP);
 554   }
 555
 556
 557   // Return analysis task
 558   //===========================================================================
 559   return taskFE;
 560
 561
 562
 563 }
 564
 565
 566
 567
 568