/// Add a AliAnalysisTaskEmcalJetCDFUE task - info from char* taskname
/// \param const char* taskname ; to be retrieved from list of tasks
/// \param Double_t jetptcut
/// \param Double_t jetareacut
/// \param const char *type ; either TPC, EMCAL or USER
/// \param Int_t leadhadtype ; 0 = charged, 1 = neutral, 2 = both
/// \param const char *nrho
/// \param const char *taskname
/// \return AliAnalysisTaskEmcalJetCDFUE* task
AliAnalysisTaskEmcalJetCDFUE *AddTaskEmcalJetCDFUE ( const char* taskname,
    Double_t     jetptcut     = 1.,
    Double_t     jetptcutmax  = 250.,
    Double_t     jetareacut   = 0.001,
    const char  *type         = "TPC",     // EMCAL, TPC
    Int_t        leadhadtype  = 0,         // AliJetContainer :: Int_t fLeadingHadronType;  0 = charged, 1 = neutral, 2 = both
    const char  *nrho         = "",
    const char  *taskname     = "JetCDF" )
  {
  AliAnalysisManager* mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) { ::Error("AddTaskEmcalJetCDF", "No analysis manager to connect to."); }

  AliEmcalJetTask* jf = dynamic_cast<AliEmcalJetTask*>(mgr->GetTask(taskname));
  if (!jf) { AliError("AddTaskEmcalJetCDF :: task is not EmcalJetTask");}

  const char *ntracks            = jf->GetTracksName();
  const char *nclusters          = jf->GetClusName();
  const char *njets              = jf->GetJetsName();
  Double_t    jetradius          = jf->GetRadius();

  return AddTaskEmcalJetCDFUE ( ntracks , nclusters, njets, nrho, jetradius, jetptcut, jetptcutmax, jetareacut, type, leadhadtype, taskname );
  }
Exemple #2
0
//______________________________________________________________________________
void AddAnalysisTasks(Int_t merge){
  // Add all analysis task wagons to the train
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();

  //
  // Tender and supplies. Needs to be called for every event.
  //

  if ( VAR_OCDB_SNAPSHOT )
  {
      AliCDBManager::Instance()->SetDefaultStorage("local:///donotexist"); 
      // explicitely wrong default storage
      // so we take _EVERYTHING_ from the snapshot.
      AliCDBManager::Instance()->SetRun(0);
      AliCDBManager::Instance()->SetSnapshotMode("OCDB_rec.root");
  }

  if ( VAR_MAKE_COMPACT_ESD )
  {
      gROOT->LoadMacro("$ALICE_PHYSICS/PWG/muondep/AddTaskCompactTreeMaker.C");
      AddTaskCompactTreeMaker();
  }
  
  if (iMUONCDBConnect) {
    if (iMUONCDBConnect > 1) gROOT->LoadMacro("AddTaskMuonCDBConnect.C");
    else gROOT->LoadMacro("$ALICE_PHYSICS/PWG/muondep/AddTaskMuonCDBConnect.C");
    AliAnalysisTaskMuonCDBConnect *cdbConnect = AddTaskMuonCDBConnect();
    if (!defaultStorage.IsNull()) cdbConnect->SetDefaultStorage(defaultStorage.Data());
    if (!alignStorage.IsNull() || alignVersion >= 0 || alignSubVersion >= 0)
      cdbConnect->SetAlignStorage(alignStorage.Data(), alignVersion, alignSubVersion);
    if (!recoParamStorage.IsNull()) cdbConnect->SetRecoParamStorage(recoParamStorage.Data());
    cdbConnect->LoadMagField();
    cdbConnect->LoadGeometry();
    cdbConnect->LoadMapping();
  }
  
  UInt_t offlineTriggerMask = 0;
  if (usePhysicsSelection) {
    // Physics selection task
    gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
    mgr->RegisterExtraFile("event_stat.root");
    AliPhysicsSelectionTask *physSelTask = AddTaskPhysicsSelection(kTRUE);
    offlineTriggerMask = AliVEvent::kAny;
  }
  
  // Centrality (only Pb-Pb)
  if (iCollision && useCentrality) {
    gROOT->LoadMacro("$ALICE_PHYSICS/OADB/COMMON/MULTIPLICITY/macros/AddTaskMultSelection.C");
    AliMultSelectionTask *mult = AddTaskMultSelection(kFALSE);
  }
  
  // track selection
  AliMuonTrackCuts *trackCuts = 0x0;
  if (iMUONEfficiency) {
    trackCuts = new AliMuonTrackCuts("stdCuts", "stdCuts");
    trackCuts->SetAllowDefaultParams();
    trackCuts->SetFilterMask(AliMuonTrackCuts::kMuMatchLpt | AliMuonTrackCuts::kMuEta | AliMuonTrackCuts::kMuThetaAbs | AliMuonTrackCuts::kMuPdca);
    trackCuts->SetIsMC(kTRUE);
  }
  
  if (iMUONRefit) {
    if (iMUONRefit > 1) gROOT->LoadMacro("AddTaskMuonRefit.C");
    else gROOT->LoadMacro("$ALICE_PHYSICS/PWG/muondep/AddTaskMuonRefit.C");
    AliAnalysisTaskMuonRefit* refit = AddTaskMuonRefit(-1., -1., kTRUE, -1., -1.);
    if (!defaultStorage.IsNull()) refit->SetDefaultStorage(defaultStorage.Data());
    if (!alignStorage.IsNull()) refit->SetAlignStorage(alignStorage.Data());
    refit->RemoveMonoCathodClusters(kTRUE, kFALSE);
  }
  
  if (iMUONRefitVtx) {
    if (iMUONRefitVtx > 1) gROOT->LoadMacro("AddTaskMuonRefitVtx.C");
    else gROOT->LoadMacro("$ALICE_PHYSICS/PWG/muondep/AddTaskMuonRefitVtx.C");
    AliAnalysisTaskMuonRefitVtx* refitVtx = AddTaskMuonRefitVtx(kFALSE, kFALSE, kTRUE);
    if (!defaultStorage.IsNull()) refitVtx->SetDefaultStorage(defaultStorage.Data());
  }
  
  if(iESDMCLabelAddition) {
    if(iESDMCLabelAddition > 1) gROOT->LoadMacro("AddTaskESDMCLabelAddition.C");
    else gROOT->LoadMacro("$ALICE_PHYSICS/PWG/muondep/AddTaskESDMCLabelAddition.C");
    AliAnalysisTaskESDMCLabelAddition *esdmclabel = AddTaskESDMCLabelAddition();
    if (!defaultStorage.IsNull()) esdmclabel->SetDefaultStorage(defaultStorage.Data());
    if (!alignStorage.IsNull()) esdmclabel->SetAlignStorage(alignStorage.Data());
    if (!recoParamStorage.IsNull()) esdmclabel->SetRecoParamStorage(recoParamStorage.Data());
    esdmclabel->DecayAsFake(kTRUE);
  }
  
  if (iMUONQA) {
    if (iMUONQA > 1) gROOT->LoadMacro("AddTaskMuonQA.C");
    else gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskMuonQA.C");
    AliAnalysisTaskMuonQA* muonQA = AddTaskMuonQA(kFALSE);
    if (usePhysicsSelection) muonQA->SelectCollisionCandidates(offlineTriggerMask);
    muonQA->SetTrackCuts(trackCuts);
  }
  
  if (useMC && useTR && iMUONPerformance) {
    if (iMUONPerformance > 1) gROOT->LoadMacro("AddTaskMuonPerformance.C");
    else gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/MUON/dep/AddTaskMuonPerformance.C");
    AliAnalysisTaskMuonPerformance* muonPerformance = AddTaskMuonPerformance();
    if (usePhysicsSelection) muonPerformance->SelectCollisionCandidates(offlineTriggerMask);
    if (!defaultStorage.IsNull()) muonPerformance->SetDefaultStorage(defaultStorage.Data());
    if (!alignStorage.IsNull()) muonPerformance->SetAlignStorage(alignStorage.Data());
    if (!recoParamStorage.IsNull()) muonPerformance->SetRecoParamStorage(recoParamStorage.Data());
    muonPerformance->UseMCKinematics(kTRUE);
    muonPerformance->SetMCTrigLevelFromMatchTrk(kTRUE);
  }
  
  if (iMUONEfficiency) {
    if (iMUONEfficiency > 1) gROOT->LoadMacro("AddTaskMUONTrackingEfficiency.C");
    else gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/MUON/dep/AddTaskMUONTrackingEfficiency.C");
    AliAnalysisTaskMuonTrackingEff* muonEfficiency = AddTaskMUONTrackingEfficiency(kFALSE,kTRUE,"");
    if (usePhysicsSelection) muonEfficiency->SelectCollisionCandidates(offlineTriggerMask);
    if (!defaultStorage.IsNull()) muonEfficiency->SetDefaultStorage(defaultStorage.Data());
    if (!alignStorage.IsNull()) muonEfficiency->SetAlignStorage(alignStorage.Data());
    if (!recoParamStorage.IsNull()) muonEfficiency->SetRecoParamStorage(recoParamStorage.Data());
    muonEfficiency->SetMuonTrackCuts(*trackCuts);
    muonEfficiency->SetMuonPtCut(VAR_EFFTASK_PTMIN);
    muonEfficiency->UseMCLabel(kTRUE);
    muonEfficiency->EnableDisplay(kFALSE);
  }
  
  TString addExtraTasks = VAR_EXTRATASKS_CONFIGMACRO;
  if (!addExtraTasks.IsNull()) gROOT->ProcessLineSync(TString::Format(".x %s",addExtraTasks.Data()));

  if (iESDfilter) {
    //  ESD filter task configuration.
    gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/ESDfilter/macros/AddTaskESDFilter.C");
    if (iMUONcopyAOD) {
      printf("Registering delta AOD file\n");
      mgr->RegisterExtraFile("AliAOD.Muons.root");
    }
    AliAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(useKFILTER, iMUONcopyAOD, kFALSE, kFALSE /*usePhysicsSelection*/,kFALSE,kTRUE,kTRUE,kTRUE,1500,VAR_MUONMCMODE,kFALSE,kFALSE,kTRUE,kFALSE); // others
    taskesdfilter->DisablePmdClusters();
    taskesdfilter->DisableCaloClusters();
    taskesdfilter->DisableCells();
    taskesdfilter->DisableCaloTrigger("PHOS");
    taskesdfilter->DisableCaloTrigger("EMCAL");
    taskesdfilter->SetPropagateTrackToEMCal(kFALSE);

    if ( 0 && VAR_USE_ITS_RECO ) /* 0 for the moment to get this macro running also with AliRoot <= .... */
    {
      AliAnalysisTaskESDMuonFilter* muFilter = mgr->GetTask("ESD Muon Filter");
      if ( !muFilter )
      {
        std::cout << "ERROR : got a NULL muFilter ! so I cannot ask to keep SPD tracklets !" << std::endl;
      }
      else
      {
        muFilter->SetWithSPDtracklets(kTRUE);
      }
    }
  }
}
Exemple #3
0
AliAnalysisTaskRho* AddTaskRho (
   const char    *nJets       = "Jets",
   const char    *nTracks     = "PicoTracks",
   const char    *nClusters   = "CaloClusters",  
   const char    *nRho        = "Rho",
   Double_t       jetradius   = 0.2,
   const char    *cutType     = "TPC",
   Double_t       jetareacut  = 0.01,
   Double_t       emcareacut  = 0,
   TF1           *sfunc       = 0,
   const UInt_t   exclJets    = 2,
   const Bool_t   histo       = kFALSE,
   const char    *suffix      = ""
)
{  
  // Get the pointer to the existing analysis manager via the static access method.
  //==============================================================================
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr)
  {
    ::Error("AddTaskRho", "No analysis manager to connect to.");
    return NULL;
  }  
  
  // Check the analysis type using the event handlers connected to the analysis manager.
  //==============================================================================
  if (!mgr->GetInputEventHandler())
  {
    ::Error("AddTaskRho", "This task requires an input event handler");
    return NULL;
  }


  //-------------------------------------------------------
  // Init the task and do settings
  //-------------------------------------------------------

  TString name(Form("AliAnalysisTaskRho_%s_%s", nJets,cutType));
  if (strcmp(suffix,"") != 0) {
    name += "_";
    name += suffix;
  }

  AliAnalysisTaskRho* mgrTask = mgr->GetTask(name.Data());
  if (mgrTask) return mgrTask;

  AliAnalysisTaskRho *rhotask = new AliAnalysisTaskRho(name, histo);
  rhotask->SetExcludeLeadJets(exclJets);
  rhotask->SetScaleFunction(sfunc);
  rhotask->SetOutRhoName(nRho);

  AliParticleContainer *trackCont = rhotask->AddParticleContainer(nTracks);
  AliClusterContainer *clusterCont = rhotask->AddClusterContainer(nClusters);

  AliJetContainer *jetCont = rhotask->AddJetContainer(nJets,cutType,jetradius);
  if (jetCont) {
    jetCont->SetJetAreaCut(jetareacut);
    jetCont->SetAreaEmcCut(emcareacut);
    jetCont->SetJetPtCut(0);
    jetCont->ConnectParticleContainer(trackCont);
    jetCont->ConnectClusterContainer(clusterCont);
  }

  //-------------------------------------------------------
  // Final settings, pass to manager and set the containers
  //-------------------------------------------------------

  mgr->AddTask(rhotask);

  // Create containers for input/output
  mgr->ConnectInput(rhotask, 0, mgr->GetCommonInputContainer());
  if (histo) {
    TString contname(name);
    contname += "_histos";
    AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(contname.Data(), 
							      TList::Class(),AliAnalysisManager::kOutputContainer,
							      Form("%s", AliAnalysisManager::GetCommonFileName()));
    mgr->ConnectOutput(rhotask, 1, coutput1);
  }

  return rhotask;
}
void AddTask_GammaConvDalitzV1_pp(  Int_t trainConfig = 1,  //change different set of cuts
                                    Bool_t isMC   = kFALSE, //run MC
                                    TString fileNameInputForWeighting = "MCSpectraInput.root", // path to file for weigting input
                                    Int_t   enableMatBudWeightsPi0          = 0,              // 1 = three radial bins, 2 = 10 radial bins
                                    TString filenameMatBudWeights           = "MCInputFileMaterialBudgetWeights.root"
         ) {

  Int_t isHeavyIon = 0;

  // ================== GetAnalysisManager ===============================
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) {
    Error(Form("AddTask_GammaConvDalitzV1_%i",trainConfig), "No analysis manager found.");
    return ;
  }

  // ================== GetInputEventHandler =============================
  AliVEventHandler *inputHandler=mgr->GetInputEventHandler();

  //========= Add PID Reponse to ANALYSIS manager ====
  if(!(AliPIDResponse*)mgr->GetTask("PIDResponseTask")){
    gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
    AddTaskPIDResponse(isMC);
  }

  //=========  Set Cutnumber for V0Reader ================================
  //TString cutnumber = "00000000000840010015000000";
  TString cutnumberPhoton = "06000008400100007500000000";
  TString cutnumberEvent  = "00000103";


  AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();

  //========= Add V0 Reader to  ANALYSIS manager if not yet existent =====
  TString V0ReaderName = Form("V0ReaderV1_%s_%s",cutnumberEvent.Data(),cutnumberPhoton.Data());
  if( !(AliV0ReaderV1*)mgr->GetTask(V0ReaderName.Data()) ){

    AliV0ReaderV1 *fV0ReaderV1 = new AliV0ReaderV1(V0ReaderName.Data());

    fV0ReaderV1->SetUseOwnXYZCalculation(kTRUE);
    fV0ReaderV1->SetCreateAODs(kFALSE);// AOD Output
    fV0ReaderV1->SetUseAODConversionPhoton(kTRUE);

    AliConvEventCuts *fEventCuts=NULL;
    if(cutnumberEvent!=""){
      fEventCuts= new AliConvEventCuts(cutnumberEvent.Data(),cutnumberEvent.Data());
      fEventCuts->SetPreSelectionCutFlag(kTRUE);
      fEventCuts->SetV0ReaderName(V0ReaderName);
      if(fEventCuts->InitializeCutsFromCutString(cutnumberEvent.Data())){
        fV0ReaderV1->SetEventCuts(fEventCuts);
        fEventCuts->SetFillCutHistograms("",kTRUE);
      }
    }

    // Set AnalysisCut Number
    AliConversionPhotonCuts *fCuts=NULL;
    if(cutnumberPhoton!=""){
      fCuts= new AliConversionPhotonCuts(cutnumberPhoton.Data(),cutnumberPhoton.Data());
      fCuts->SetPreSelectionCutFlag(kTRUE);
      fCuts->SetIsHeavyIon(isHeavyIon);
      fCuts->SetV0ReaderName(V0ReaderName);
      if(fCuts->InitializeCutsFromCutString(cutnumberPhoton.Data())){
        fV0ReaderV1->SetConversionCuts(fCuts);
        fCuts->SetFillCutHistograms("",kTRUE);
      }
    }
    if(inputHandler->IsA()==AliAODInputHandler::Class()){
    // AOD mode
      fV0ReaderV1->AliV0ReaderV1::SetDeltaAODBranchName(Form("GammaConv_%s_gamma",cutnumberAODBranch.Data()));
    }
    fV0ReaderV1->Init();

    AliLog::SetGlobalLogLevel(AliLog::kInfo);

    //connect input V0Reader
    mgr->AddTask(fV0ReaderV1);
    mgr->ConnectInput(fV0ReaderV1,0,cinput);

  }


  if( !(AliDalitzElectronSelector*)mgr->GetTask("ElectronSelector") ){
    AliDalitzElectronSelector *fElectronSelector = new AliDalitzElectronSelector("ElectronSelector");
    //ConfigV0ReaderV1(fV0ReaderV1,ConvCutnumber,IsHeavyIon);
    // Set AnalysisCut Number
    AliDalitzElectronCuts *fElecCuts=0;
    TString ElecCuts = "30105400000003300000";

    if( ElecCuts!=""){
      fElecCuts= new AliDalitzElectronCuts(ElecCuts.Data(),ElecCuts.Data());
      if(fElecCuts->InitializeCutsFromCutString(ElecCuts.Data())){
        fElectronSelector->SetDalitzElectronCuts(fElecCuts);
        fElecCuts->SetFillCutHistograms("",kTRUE);
      }
    }

    fElectronSelector->Init();
    mgr->AddTask(fElectronSelector);
    //connect input fElectronSelector

    mgr->ConnectInput (fElectronSelector,0,cinput);
  }

  //================================================
  //========= Add task to the ANALYSIS manager =====
  //            find input container
  AliAnalysisTaskGammaConvDalitzV1 *task=NULL;
  task= new AliAnalysisTaskGammaConvDalitzV1(Form("GammaConvDalitzV1_%i",trainConfig));
  task->SetIsHeavyIon(0);
  task->SetIsMC(isMC);
  task->SetV0ReaderName(V0ReaderName);


  CutHandlerConvDalitz cuts;

  if(trainConfig == 1){
   	cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20475400253202221710"); // standard cut number for pp7TeV
	cuts.AddCut("00000113", "00200009360300007800004000", "0163103100900000", "20475400253202221710");
    // train configs 2 to 4 for estimation of systematics of standard cut number pp7TeV
  } else if (trainConfig == 2) {
	cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20475400253202221710");
	cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "10475400253202221710");
	cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "30475400253202221710");
	cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20475400253201221710");
	cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20475400253203221710");
	cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20475400253202121710");
	cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20475400253202321710");
	cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20475400253302221710");

  } else if (trainConfig == 3) {
	cuts.AddCut("00000113", "00200009360300007900004000", "0263103100900000", "20475400253202221710");
	cuts.AddCut("00000113", "00200009360300007200004000", "0263103100900000", "20475400253202221710");
	cuts.AddCut("00000113", "00200009360300007100004000", "0263103100900000", "20475400253202221710");
	cuts.AddCut("00000113", "00200009360300001800004000", "0263103100900000", "20475400253202221710");
	cuts.AddCut("00000113", "00200009360300002800004000", "0263103100900000", "20475400253202221710");
	cuts.AddCut("00000113", "00200049360300007800004000", "0263103100900000", "20475400253202221710");
	cuts.AddCut("00000113", "00200019360300007800004000", "0263103100900000", "20475400253202221710");
	cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20475400253202222710");

  } else if (trainConfig == 4) {
	cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20575400253202221710");
	cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20775400253202221710");
	cuts.AddCut("00000113", "00200009260300007800004000", "0263103100900000", "20475400253202221710");
	cuts.AddCut("00000113", "00200009660300007800004000", "0263103100900000", "20475400253202221710");
	cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20425400253202221710");
	cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20407200253202221710");
	cuts.AddCut("00000113", "00200009320300007800004000", "0263103100900000", "20475400253202221710");
	cuts.AddCut("00000113", "00200009305100007800004000", "0263103100900000", "20475400253202221710");
  } else if (trainConfig == 102) {
	cuts.AddCut("00010113", "00200009360300007800004000", "0263103100900000", "20475400253202221710");
	cuts.AddCut("00010113", "00200009360300007800004000", "0263103100900000", "10475400253202221710");
	cuts.AddCut("00010113", "00200009360300007800004000", "0263103100900000", "30475400253202221710");
	cuts.AddCut("00010113", "00200009360300007800004000", "0263103100900000", "20475400253201221710");
	cuts.AddCut("00010113", "00200009360300007800004000", "0263103100900000", "20475400253203221710");
	cuts.AddCut("00010113", "00200009360300007800004000", "0263103100900000", "20475400253202121710");
	cuts.AddCut("00010113", "00200009360300007800004000", "0263103100900000", "20475400253202321710");
  } else if (trainConfig == 103) {
	cuts.AddCut("00010113", "00200009266300008854404000", "0263103100900000", "20475400253202321710");
	cuts.AddCut("00010113", "00200009266300008854404000", "0263103100900000", "20475400253202301710");
  } else if (trainConfig == 104) {  // to be used with MBW
	cuts.AddCut("00010113", "00200009266300008854404000", "0263103100900000", "20475400253202321710");
	cuts.AddCut("00010113", "00200009266300008854404000", "0263103100900000", "20475400253202301710");
  } else if (trainConfig == 202) {
	cuts.AddCut("00074113", "00200009360300007800004000", "0263103100900000", "20475400253202221710");
	cuts.AddCut("00074113", "00200009360300007800004000", "0263103100900000", "10475400253202221710");
	cuts.AddCut("00074113", "00200009360300007800004000", "0263103100900000", "30475400253202221710");
	cuts.AddCut("00074113", "00200009360300007800004000", "0263103100900000", "20475400253201221710");
	cuts.AddCut("00074113", "00200009360300007800004000", "0263103100900000", "20475400253203221710");
	cuts.AddCut("00074113", "00200009360300007800004000", "0263103100900000", "20475400253202121710");
	cuts.AddCut("00074113", "00200009360300007800004000", "0263103100900000", "20475400253202321710");


 } else {
    Error(Form("GammaConvV1_%i",trainConfig), "wrong trainConfig variable no cuts have been specified for the configuration");
    return;
  }

  if(!cuts.AreValid()){
    cout << "\n\n****************************************************" << endl;
    cout << "ERROR: No valid cuts stored in CutHandlerConvDalitz! Returning..." << endl;
    cout << "****************************************************\n\n" << endl;
    return;
  }

  Int_t numberOfCuts = cuts.GetNCuts();

  TList  *EventCutList = new TList();
  TList  *ConvCutList  = new TList();
  TList  *MesonCutList = new TList();
  TList  *ElecCutList  = new TList();

  TList *HeaderList = new TList();
  TObjString *Header2 = new TObjString("BOX");
  HeaderList->Add(Header2);

  EventCutList->SetOwner(kTRUE);
  AliConvEventCuts **analysisEventCuts   = new AliConvEventCuts*[numberOfCuts];
  ConvCutList->SetOwner(kTRUE);
  AliConversionPhotonCuts **analysisCuts   = new AliConversionPhotonCuts*[numberOfCuts];
  MesonCutList->SetOwner(kTRUE);
  AliConversionMesonCuts **analysisMesonCuts   = new AliConversionMesonCuts*[numberOfCuts];
  ElecCutList->SetOwner(kTRUE);
  AliDalitzElectronCuts **analysisElecCuts   = new AliDalitzElectronCuts*[numberOfCuts];
  Bool_t initializedMatBudWeigths_existing    = kFALSE;

  for(Int_t i = 0; i<numberOfCuts; i++){
    TString cutName( Form("%s_%s_%s_%s",(cuts.GetEventCut(i)).Data(),(cuts.GetPhotonCut(i)).Data(),(cuts.GetElecCut(i)).Data(),(cuts.GetMesonCut(i)).Data() ) );

    analysisEventCuts[i] = new AliConvEventCuts();
    analysisEventCuts[i]->SetV0ReaderName(V0ReaderName);
    analysisEventCuts[i]->InitializeCutsFromCutString((cuts.GetEventCut(i)).Data());
    EventCutList->Add(analysisEventCuts[i]);
    analysisEventCuts[i]->SetFillCutHistograms("",kFALSE);

    analysisCuts[i] = new AliConversionPhotonCuts();
    if (enableMatBudWeightsPi0 > 0){
        if (isMC > 0){
            if (analysisCuts[i]->InitializeMaterialBudgetWeights(enableMatBudWeightsPi0,filenameMatBudWeights)){
                initializedMatBudWeigths_existing = kTRUE;}
            else {cout << "ERROR The initialization of the materialBudgetWeights did not work out." << endl;}
        }
        else {cout << "ERROR 'enableMatBudWeightsPi0'-flag was set > 0 even though this is not a MC task. It was automatically reset to 0." << endl;}
    }
    analysisCuts[i]->SetV0ReaderName(V0ReaderName);
    analysisCuts[i]->InitializeCutsFromCutString((cuts.GetPhotonCut(i)).Data());
    ConvCutList->Add(analysisCuts[i]);
    analysisCuts[i]->SetFillCutHistograms("",kFALSE);

    analysisMesonCuts[i] = new AliConversionMesonCuts();
    analysisMesonCuts[i]->InitializeCutsFromCutString((cuts.GetMesonCut(i)).Data());
    MesonCutList->Add(analysisMesonCuts[i]);
    analysisMesonCuts[i]->SetFillCutHistograms("");

    analysisElecCuts[i] = new AliDalitzElectronCuts();
    analysisElecCuts[i]->InitializeCutsFromCutString((cuts.GetElecCut(i)).Data());
    ElecCutList->Add(analysisElecCuts[i]);
    analysisElecCuts[i]->SetFillCutHistograms("",kFALSE,cutName);

    analysisEventCuts[i]->SetAcceptedHeader(HeaderList);

  }

  task->SetEventCutList(numberOfCuts,EventCutList);
  task->SetConversionCutList(numberOfCuts,ConvCutList);
  task->SetMesonCutList(MesonCutList);
  task->SetElectronCutList(ElecCutList);
  task->SetMoveParticleAccordingToVertex(kTRUE);
  if (initializedMatBudWeigths_existing) {
      task->SetDoMaterialBudgetWeightingOfGammasForTrueMesons(kTRUE);
  }
  //task->SetDoMesonAnalysis(kTRUE);
  //if (enableQAMesonTask) task->SetDoMesonQA(kTRUE); //Attention new switch for Pi0 QA
  //if (enableQAMesonTask) task->SetDoPhotonQA(kTRUE);  //Attention new switch small for Photon QA

  //connect containers
  AliAnalysisDataContainer *coutput =
  mgr->CreateContainer(Form("GammaConvDalitzV1_%i",trainConfig), TList::Class(),
              AliAnalysisManager::kOutputContainer,Form("GammaConvDalitzV1_%i.root",trainConfig));

  mgr->AddTask(task);
  mgr->ConnectInput(task,0,cinput);
  mgr->ConnectOutput(task,1,coutput);

  return;

}
Bool_t AddRsnEventComputations(Bool_t isMC, const char *options = "", const char *taskName = "RSNtask")
{
   // ==================================================================================================================
   // == PRELIMINARY OPERATIONS ========================================================================================
   // ==================================================================================================================
   
   // retrieve task from manager, using its name
   AliAnalysisManager *mgr  = AliAnalysisManager::GetAnalysisManager();
   AliRsnAnalysisTask *task = (AliRsnAnalysisTask*)mgr->GetTask(taskName);
   if (!task) {
      Error("RsnConfigMonitor", "Task not found");
      return kFALSE;
   }
   
   TString opt(options);
   opt.ToUpper();
   opt.ReplaceAll(" ", "");
   
   Bool_t central    = opt.Contains("CENT");
   Bool_t peripheral = opt.Contains("PERI");
   
   // ==================================================================================================================
   // == EVENT CUTS ====================================================================================================
   // ==================================================================================================================

   // event cuts are added directly to a cutSet in the task
   // we create all and then add thos which are needed
   
   // primary vertex:
   // - 2nd argument --> |Vz| range
   // - 3rd argument --> minimum required number of contributors
   // - 4th argument --> tells if TPC stand-alone vertexes must be accepted
   // we switch on the check for pileup
   AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE);
   cutVertex->SetCheckPileUp(kTRUE);
      
   // centrality:
   // - 2nd      argument --> one of the centrality evaluation methods
   // - 3rd, 4th argument --> centrality ranges in percentile (0-10 for central, 60-70 for peripheral)
   AliRsnCutValue *cutCentrality = 0x0;
   if (central) 
      cutCentrality = new AliRsnCutValue("cutCentral", AliRsnValue::kEventCentralityV0,  0.0, 10.0);
   else if (peripheral)
      cutCentrality = new AliRsnCutValue("cutPeripheral", AliRsnValue::kEventCentralityV0, 60.0, 70.0);
   
   // primary vertex is always used
   task->GetEventCuts()->AddCut(cutVertex);
   
   // set cut scheme as AND of primary vertex and centrality, if initialized
   if (cutCentrality) {
      task->GetEventCuts()->AddCut(cutCentrality);
      task->GetEventCuts()->SetCutScheme(Form("%s & %s", cutVertex->GetName(), cutCentrality->GetName()));
   } else {
      task->GetEventCuts()->SetCutScheme(cutVertex->GetName());
   }
   ::Info("AddEventStuff", "Scheme for event cuts: %s", task->GetEventCuts()->GetCutScheme().Data());
   
   // ==================================================================================================================
   // == EVENT FUNCTIONS ===============================================================================================
   // ==================================================================================================================

   // we want to add an AliRsnFunction to compute multiplicity distribution
   // it is needed in order to know how many events we have in each multiplicity bin
   
   // axes
   AliRsnValue *axisEvMultSPD = new AliRsnValue("MultSPD", AliRsnValue::kEventMultSPD, 0.0, 150.0, 1.0);
   AliRsnValue *axisEvMultMC  = new AliRsnValue("MultMC" , AliRsnValue::kEventMultMC , 0.0, 150.0, 1.0);

   // create function and add axis
   AliRsnFunction *fcnEv = new AliRsnFunction;
   if (!fcnEv->AddAxis(axisEvMultSPD)) return kFALSE;
   if (isMC && !fcnEv->AddAxis(axisEvMultMC)) return kFALSE;

   // add functions to pairs
   task->GetInfo()->AddEventFunction(fcnEv);
   
   return kTRUE;
}
Exemple #6
0
AliAnalysisTaskRhoSparse* AddTaskRhoSparse(
					   const char    *nJetsBkg    = "JetsBkg",
					   const char    *nJetsSig    = "JetsSig",
					   const char    *nTracks     = "PicoTracks",
					   const char    *nClusters   = "CaloClusters",  
					   const char    *nRho        = "Rho",
					   Double_t       jetradius   = 0.2,
					   const char    *cutType     = "TPC",
					   Double_t       jetareacut  = 0.01,
					   Double_t       jetptcut    = 0.0,
					   Double_t       emcareacut  = 0,
					   TF1           *sfunc       = 0x0,
					   const UInt_t   exclJets    = 2,
					   const Bool_t   histo       = kFALSE,
					   const char    *taskname    = "Rho",
					   const Bool_t   fRhoCMS      = kTRUE
					   )
{  

  // Get the pointer to the existing analysis manager via the static access method.
  //==============================================================================
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr)
  {
    ::Error("AddTaskRhoSparse", "No analysis manager to connect to.");
    return NULL;
  }  
  
  // Check the analysis type using the event handlers connected to the analysis manager.
  //==============================================================================
  if (!mgr->GetInputEventHandler())
  {
    ::Error("AddTaskRhoSparse", "This task requires an input event handler");
    return NULL;
  }
  
  //-------------------------------------------------------
  // Init the task and do settings
  //-------------------------------------------------------

  TString name(Form("%s_%s_%s", taskname, nJetsBkg,cutType));
  AliAnalysisTaskRhoSparse* mgrTask = static_cast<AliAnalysisTaskRhoSparse *>(mgr->GetTask(name.Data()));
  if (mgrTask) return mgrTask;

  AliAnalysisTaskRhoSparse *rhotask = new AliAnalysisTaskRhoSparse(name, histo);
  rhotask->SetHistoBins(1000,-0.1,9.9);
  rhotask->SetRhoCMS(fRhoCMS);
  rhotask->SetExcludeLeadJets(exclJets);
  rhotask->SetScaleFunction(sfunc);
  rhotask->SetOutRhoName(nRho);

  AliParticleContainer *trackCont = rhotask->AddParticleContainer(nTracks);
  AliClusterContainer *clusterCont = rhotask->AddClusterContainer(nClusters);

  AliJetContainer *bkgJetCont = rhotask->AddJetContainer(nJetsBkg,cutType,jetradius);
  if (bkgJetCont) {
    bkgJetCont->SetJetAreaCut(jetareacut);
    bkgJetCont->SetAreaEmcCut(emcareacut);
    bkgJetCont->SetJetPtCut(0.);
    bkgJetCont->ConnectParticleContainer(trackCont);
    bkgJetCont->ConnectClusterContainer(clusterCont);
  }

  AliJetContainer *sigJetCont = rhotask->AddJetContainer(nJetsSig,cutType,jetradius);
  if (sigJetCont) {
    sigJetCont->SetJetAreaCut(jetareacut);
    sigJetCont->SetAreaEmcCut(emcareacut);
    sigJetCont->SetJetPtCut(jetptcut);
    sigJetCont->ConnectParticleContainer(trackCont);
    sigJetCont->ConnectClusterContainer(clusterCont);
  }

  //-------------------------------------------------------
  // Final settings, pass to manager and set the containers
  //-------------------------------------------------------

  rhotask->SetSmallSystem(fRhoCMS);
  mgr->AddTask(rhotask);

  // Create containers for input/output
  mgr->ConnectInput(rhotask, 0, mgr->GetCommonInputContainer());
  if (histo) {
    TString contname(name);
    contname += "_histos";
    AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(contname.Data(), 
							      TList::Class(),AliAnalysisManager::kOutputContainer,
							      Form("%s", AliAnalysisManager::GetCommonFileName()));
    mgr->ConnectOutput(rhotask, 1, coutput1);
  }

  return rhotask;
}
Exemple #7
0
AliAnalysisTaskBJetTC* AddTaskBJetTC(
		const char *ntracks             = "PicoTracks",
		const char *nclusters           = "",
		const char *njets               = "Jets",
		const char *nrho                = "",
		Double_t jetradius 		= 0.4,
		Bool_t isMC 			= kFALSE,
		const char * type 		= "TPC",
		const char *taskname           	= "AliAnalysisTaskBJetTC",
		const char *njetsMC             = "Jets",
		const char *nrhoMC              = "RhoMC",
		Bool_t V0PhotonRejection 	= kFALSE,
		Bool_t DoPtRelAna		= kFALSE,
		Bool_t DoJetProb 		= kFALSE,
		TString pathToResolFunc		= "",
  		Int_t       ptHardBin           = -999,
		const char* suffix 		= "")
{


	// Get the pointer to the existing analysis manager via the static access method.
	//==============================================================================
	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
	if (!mgr)
	{
		::Error("AddTaskEmcalJetSample", "No analysis manager to connect to.");
		return NULL;
	}


	// Check the analysis type using the event handlers connected to the analysis manager.
	//==============================================================================
	if (!mgr->GetInputEventHandler())
	{
		::Error("AddTaskEmcalJetSample", "This task requires an input event handler");
		return NULL;
	}



  	if(V0PhotonRejection){

		  //=========  Set Cutnumber for V0Reader ================================
		  TString cutnumberAODBranch = "8000000060084000001500000";  // cutnumber for AOD branch
		  //TString cutnumberAODBranch = "00000003_06000008400100001000000000";  // cutnumber for AOD branch
		  TString cutnumberPhoton = "10000029200000003220400000";
		  TString cutnumberEvent = "80010103";

		  Bool_t doEtaShift = kFALSE;
		  AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
		  //========= Add V0 Reader to  ANALYSIS manager if not yet existent =====
		  TString V0ReaderName = Form("V0ReaderV1_%s_%s",cutnumberEvent.Data(),cutnumberPhoton.Data());
		  if( !(AliV0ReaderV1*)mgr->GetTask(V0ReaderName.Data()) ){
			AliV0ReaderV1 *fV0ReaderV1 = new AliV0ReaderV1(V0ReaderName.Data());
		    fV0ReaderV1->SetUseOwnXYZCalculation(kTRUE);
		    fV0ReaderV1->SetCreateAODs(kFALSE);// AOD Output
		    fV0ReaderV1->SetUseAODConversionPhoton(kTRUE);
		    if (!mgr) {
		      Error("AddTask_V0ReaderV1", "No analysis manager found.");
		      return;
		    }

		    AliConvEventCuts *fEventCuts=NULL;
		    if(cutnumberEvent!=""){
		      fEventCuts= new AliConvEventCuts(cutnumberEvent.Data(),cutnumberEvent.Data());
		      fEventCuts->SetPreSelectionCutFlag(kTRUE);
		      fEventCuts->SetPeriodEnumExplicit(AliConvEventCuts::kLHC16q);
		      fEventCuts->SetV0ReaderName(V0ReaderName);
		      fEventCuts->SetLightOutput(kTRUE);
		      if(fEventCuts->InitializeCutsFromCutString(cutnumberEvent.Data())){
			fEventCuts->DoEtaShift(doEtaShift);
			fV0ReaderV1->SetEventCuts(fEventCuts);
			fEventCuts->SetFillCutHistograms("",kTRUE);
		      }
		    }

		    // Set AnalysisCut Number
		    AliConversionPhotonCuts *fCuts=NULL;
		    if(cutnumberPhoton!=""){
		      fCuts= new AliConversionPhotonCuts(cutnumberPhoton.Data(),cutnumberPhoton.Data());
		      fCuts->SetPreSelectionCutFlag(kTRUE);
		      fCuts->SetIsHeavyIon(kTRUE);
		      fCuts->SetV0ReaderName(V0ReaderName);
		      fCuts->SetLightOutput(kTRUE);
		      fCuts->SetProcessAODCheck(kTRUE);
		      if(fCuts->InitializeCutsFromCutString(cutnumberPhoton.Data())){
			cout<<" Photon conversion is working \n";
			fV0ReaderV1->SetConversionCuts(fCuts);
			fCuts->SetFillCutHistograms("",kTRUE);
		      }
		    }
		    if( (mgr->GetInputEventHandler())->IsA()==AliAODInputHandler::Class()){
		    // AOD mode
		      cout << "AOD handler: adding " << cutnumberAODBranch.Data() << " as conversion branch" << endl;
		      fV0ReaderV1->SetDeltaAODBranchName(Form("GammaConv_%s_gamma",cutnumberAODBranch.Data()));
		    }
		    fV0ReaderV1->Init();

		    AliLog::SetGlobalLogLevel(AliLog::kInfo);

		    //connect input V0Reader
		    mgr->AddTask(fV0ReaderV1);
		    mgr->ConnectInput(fV0ReaderV1,0,cinput);

		  }
   	}


	TString name(taskname);

	TString combinedName;
	combinedName.Form("%s%s", name.Data(),suffix);

	AliAnalysisTaskBJetTC* jetTask = new AliAnalysisTaskBJetTC(combinedName);

  	jetTask->SetPtHardBin(ptHardBin);

  	jetTask->UseGammaV0Rejection(V0PhotonRejection);
	
	jetTask->DoJetProbabilityAnalysis(DoJetProb);

	jetTask->DoPtRelAnalysis(DoPtRelAna);
			
	AliTrackContainer *trackCont  = jetTask->AddTrackContainer(ntracks);
	trackCont->SetTrackFilterType(AliEmcalTrackSelection::kCustomTrackFilter);
	trackCont->SetAODFilterBits((1<<4)|(1<<9));

	AliClusterContainer *clusterCont = jetTask->AddClusterContainer(nclusters);

	TString strType(type);

	AliJetContainer *jetCont = jetTask->AddJetContainer(njets,strType,jetradius);

	if(jetCont) {
		jetCont->SetRhoName(nrho);

		jetCont->ConnectParticleContainer(trackCont);

		jetCont->ConnectClusterContainer(clusterCont);

		jetCont->SetJetEtaLimits(-0.5,0.5);

		jetCont->SetJetPtCut(0.0);

		jetCont->SetMaxTrackPt(1000);

		jetCont->SetPercAreaCut(0.6);
	}

	if(isMC)
	{
		AliJetContainer *jetContMC = jetTask->AddJetContainer(njetsMC,strType,jetradius);

		if(jetContMC) {

			jetContMC->SetRhoName(nrhoMC);

			jetContMC->SetIsParticleLevel(kTRUE);

			jetContMC->SetJetEtaLimits(-0.5,0.5);

			jetContMC->SetJetPtCut(0.0);

			jetContMC->SetMaxTrackPt(1000);

			jetContMC->SetPercAreaCut(0.6);
		}
	}
	//-------------------------------------------------------
	//  Configure analysis task
	//-------------------------------------------------------

	jetTask->SetIsPythia(isMC);

        if(V0PhotonRejection) jetTask->SetV0ReaderName(V0ReaderName);



	if(DoJetProb && !pathToResolFunc.IsNull()){
		TFile* file = TFile::Open(pathToResolFunc.Data());
		for(int i=0; i<7; i++){
			jetTask->SetResFunction((TF1*)file->Get(Form("QualityClass%i",i)), i);
		}
	}

	//-------------------------------------------------------
	// Final settings, pass to manager and set the containers
	//-------------------------------------------------------

	mgr->AddTask(jetTask);


	// Create containers for input/output
	AliAnalysisDataContainer *cinput1  = mgr->GetCommonInputContainer()  ;

	TString contname(combinedName);
	contname += "_histos";
	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(contname.Data(),
			TList::Class(),AliAnalysisManager::kOutputContainer,
			Form("%s", AliAnalysisManager::GetCommonFileName()));

	mgr->ConnectInput  (jetTask, 0,  cinput1 );

	mgr->ConnectOutput (jetTask, 1, coutput1 );

	return jetTask;
}
void AddTask_GammaCaloDalitzV1_pPb(  Int_t trainConfig = 1,  //change different set of cuts
                              Bool_t isMC   = kFALSE, //run MC
                              Int_t enableQAMesonTask = 0, //enable QA in AliAnalysisTaskGammaConvV1
                              Int_t enableQAPhotonTask = 0, // enable additional QA task
                              TString fileNameInputForWeighting = "MCSpectraInput.root", // path to file for weigting input
                              Int_t doWeightingPart = 0,  //enable Weighting
                              TString generatorName = "DPMJET",
                              TString cutnumberAODBranch = "8000000060084000001500000", // cutnumber for AOD branch
                              Bool_t enableExtendedMatching = kFALSE, //enable or disable extended matching histograms for conversion electrons <-> cluster
                              Bool_t isUsingTHnSparse = kTRUE, //enable or disable usage of THnSparses for background estimation
                              Bool_t enableV0findingEffi = kFALSE
              ) {

  Int_t isHeavyIon = 2;

  // ================== GetAnalysisManager ===============================
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) {
    Error(Form("AddTask_GammaConvV1_%i",trainConfig), "No analysis manager found.");
    return ;
  }

  // ================== GetInputEventHandler =============================
  AliVEventHandler *inputHandler=mgr->GetInputEventHandler();

  //========= Add PID Reponse to ANALYSIS manager ====
  if(!(AliPIDResponse*)mgr->GetTask("PIDResponseTask")){
    gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
    AddTaskPIDResponse(isMC);
  }

  Printf("here \n");

  //=========  Set Cutnumber for V0Reader ================================
            //06000078400100001500000000
  TString cutnumberPhoton 	= "06000078400100007500000000";
  TString cutnumberEvent 		= "80000003";
  TString cutnumberElectron   = "90005400000002000000";            //Electron Cuts



  Bool_t doEtaShift = kFALSE;
  AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();

  //========= Add V0 Reader to  ANALYSIS manager if not yet existent =====
    TString V0ReaderName = Form("V0ReaderV1_%s_%s",cutnumberEvent.Data(),cutnumberPhoton.Data());
    if( !(AliV0ReaderV1*)mgr->GetTask(V0ReaderName.Data()) ){

        AliV0ReaderV1 *fV0ReaderV1 = new AliV0ReaderV1(V0ReaderName.Data());

    fV0ReaderV1->SetUseOwnXYZCalculation(kTRUE);
    fV0ReaderV1->SetCreateAODs(kFALSE);// AOD Output
    fV0ReaderV1->SetUseAODConversionPhoton(kTRUE);
    fV0ReaderV1->SetProduceV0FindingEfficiency(enableV0findingEffi);

    if (!mgr) {
      Error("AddTask_V0ReaderV1", "No analysis manager found.");
      return;
    }

    AliConvEventCuts *fEventCuts=NULL;
    if(cutnumberEvent!=""){
      fEventCuts= new AliConvEventCuts(cutnumberEvent.Data(),cutnumberEvent.Data());
      fEventCuts->SetPreSelectionCutFlag(kTRUE);
            fEventCuts->SetV0ReaderName(V0ReaderName);
      if(fEventCuts->InitializeCutsFromCutString(cutnumberEvent.Data())){
        fEventCuts->DoEtaShift(doEtaShift);
        fV0ReaderV1->SetEventCuts(fEventCuts);
        fEventCuts->SetFillCutHistograms("",kTRUE);
      }
    }

    // Set AnalysisCut Number
    AliConversionPhotonCuts *fCuts=NULL;
    if(cutnumberPhoton!=""){
      fCuts= new AliConversionPhotonCuts(cutnumberPhoton.Data(),cutnumberPhoton.Data());
      fCuts->SetPreSelectionCutFlag(kTRUE);
      fCuts->SetIsHeavyIon(isHeavyIon);
      fCuts->SetV0ReaderName(V0ReaderName);
      if(fCuts->InitializeCutsFromCutString(cutnumberPhoton.Data())){
        fV0ReaderV1->SetConversionCuts(fCuts);
        fCuts->SetFillCutHistograms("",kTRUE);
      }
    }
    if(inputHandler->IsA()==AliAODInputHandler::Class()){
    // AOD mode
      fV0ReaderV1->AliV0ReaderV1::SetDeltaAODBranchName(Form("GammaConv_%s_gamma",cutnumberAODBranch.Data()));
    }
    fV0ReaderV1->Init();

    AliLog::SetGlobalLogLevel(AliLog::kFatal);

    //connect input V0Reader
    mgr->AddTask(fV0ReaderV1);
    mgr->ConnectInput(fV0ReaderV1,0,cinput);

  }

    //================================================
    //========= Add Electron Selector ================
    if( !(AliDalitzElectronSelector*)mgr->GetTask("ElectronSelector") ){

    AliDalitzElectronSelector *fElectronSelector = new AliDalitzElectronSelector("ElectronSelector");

    // Set AnalysisCut Number
    AliDalitzElectronCuts *fElecCuts=0;
    if( cutnumberElectron!=""){
      fElecCuts= new AliDalitzElectronCuts(cutnumberElectron.Data(),cutnumberElectron.Data());

      if(fElecCuts->InitializeCutsFromCutString(cutnumberElectron.Data())){
        fElectronSelector->SetDalitzElectronCuts(fElecCuts);
        fElecCuts->SetFillCutHistograms("",kTRUE);
      }
    }

    fElectronSelector->Init();
    mgr->AddTask(fElectronSelector);

    AliAnalysisDataContainer *cinput1  = mgr->GetCommonInputContainer();

    //connect input V0Reader

    mgr->ConnectInput (fElectronSelector,0,cinput1);

    }

  //================================================
  //========= Add task to the ANALYSIS manager =====
  //================================================
  AliAnalysisTaskGammaCaloDalitzV1 *task=NULL;
  task= new AliAnalysisTaskGammaCaloDalitzV1(Form("GammaCaloDalitz_%i",trainConfig));
  task->SetIsHeavyIon(isHeavyIon);
  task->SetIsMC(isMC);
  task->SetV0ReaderName(V0ReaderName);

  // Cut Numbers to use in Analysis
  Int_t numberOfCuts = 2;

  if ( trainConfig == 1 || trainConfig == 2 )
  numberOfCuts = 4;


  TString *eventCutArray   	= new TString[numberOfCuts];
  TString *photonCutArray  	= new TString[numberOfCuts];
  TString *clusterCutArray 	= new TString[numberOfCuts];
  TString *electronCutArray	= new TString[numberOfCuts];
  TString *mesonCutArray   	= new TString[numberOfCuts];


  //************************************************ EMCAL clusters **********************************************************
  if ( trainConfig == 1){ // min energy = 0.3 GeV/c
      eventCutArray[0] = "80000013"; photonCutArray[0] = "00200009327002008250400000"; clusterCutArray[0] = "1111100043022030000"; electronCutArray[0] = "90475400233102623710"; mesonCutArray[0] = "0263103100000000"; //standart cut, kINT7
      eventCutArray[1] = "80052013"; photonCutArray[1] = "00200009327002008250400000"; clusterCutArray[1] = "1111100043022030000"; electronCutArray[1] = "90475400233102623710"; mesonCutArray[1] = "0263103100000000"; //standard cut, kEMC7
      eventCutArray[2] = "80000013"; photonCutArray[2] = "00200009327002008250400000"; clusterCutArray[2] = "1111100043022030000"; electronCutArray[2] = "90475400233102623110"; mesonCutArray[2] = "0263103100000000"; //standart cut, kINT7
      eventCutArray[3] = "80052013"; photonCutArray[3] = "00200009327002008250400000"; clusterCutArray[3] = "1111100043022030000"; electronCutArray[3] = "90475400233102623110"; mesonCutArray[3] = "0263103100000000"; //standard cut, kEMC7
  } else if ( trainConfig == 2 ){
      eventCutArray[0] = "80000013"; photonCutArray[0] = "00200009327002008250400000"; clusterCutArray[0] = "2000000048033200000"; electronCutArray[0] = "90475400233102623710"; mesonCutArray[0] = "0263103100000000"; //standart cut, kINT7
      eventCutArray[1] = "80062013"; photonCutArray[1] = "00200009327002008250400000"; clusterCutArray[1] = "2000000048033200000"; electronCutArray[1] = "90475400233102623710"; mesonCutArray[1] = "0263103100000000"; //standard cut, kPHI7
      eventCutArray[2] = "80000013"; photonCutArray[2] = "00200009327002008250400000"; clusterCutArray[2] = "2000000048033200000"; electronCutArray[2] = "90475400233102623110"; mesonCutArray[2] = "0263103100000000"; //standart cut, kINT7
      eventCutArray[3] = "80062013"; photonCutArray[3] = "00200009327002008250400000"; clusterCutArray[3] = "2000000048033200000"; electronCutArray[3] = "90475400233102623110"; mesonCutArray[3] = "0263103100000000"; //standard cut, kPHI7
  } else if ( trainConfig == 3){ // min energy = 0.3 GeV/c
      eventCutArray[0] = "80000013"; photonCutArray[0] = "00200009327002008250400000"; clusterCutArray[0] = "1111100053032230000"; electronCutArray[0] = "90475400233102623710"; mesonCutArray[0] = "0263103100000000"; //standart cut, kINT7
      eventCutArray[1] = "80000013"; photonCutArray[1] = "00200009327002008250400000"; clusterCutArray[1] = "1331100053032230000"; electronCutArray[1] = "90475400233102623710"; mesonCutArray[1] = "0263103100000000"; //standard cut, kEMC7
  } else if ( trainConfig == 4){
      eventCutArray[0] = "80000013"; photonCutArray[0] = "00200009327002008250400000"; clusterCutArray[0] = "2000000048033200000"; electronCutArray[0] = "90475400233102623710"; mesonCutArray[0] = "0263103100000000"; //standart cut, kINT7
      eventCutArray[1] = "80000013"; photonCutArray[1] = "00200009327002008250400000"; clusterCutArray[1] = "2444400048033200000"; electronCutArray[1] = "90475400233102623710"; mesonCutArray[1] = "0263103100000000"; //standard cut, kPHI7
  } else if ( trainConfig == 5 ){
      eventCutArray[0] = "80000013"; photonCutArray[0] = "00200009327002008250400000"; clusterCutArray[0] = "1002100053032230000"; electronCutArray[0] = "90475400233102623710"; mesonCutArray[0] = "0263103100000000"; //standart cut, kINT7 with TRD
      eventCutArray[1] = "80000013"; photonCutArray[1] = "00200009327002008250400000"; clusterCutArray[1] = "1001300053032230000"; electronCutArray[1] = "90475400233102623710"; mesonCutArray[1] = "0263103100000000"; //standard cut, kINT7 No TRD
  } else if ( trainConfig == 6 ) {
      eventCutArray[0] = "80000013"; photonCutArray[0] = "00200009327002008250400000"; clusterCutArray[0] = "2000000048033300000"; electronCutArray[0] = "90475400233102623710"; mesonCutArray[0] = "0263103100000000"; //standart cut, kINT7
      eventCutArray[1] = "80000013"; photonCutArray[1] = "00200009327002008250400000"; clusterCutArray[1] = "2444400048033300000"; electronCutArray[1] = "90475400233102623710"; mesonCutArray[1] = "0263103100000000"; //standard cut, kINT7
  } else if ( trainConfig == 7 ){ // min energy = 0.3 GeV/c
      eventCutArray[0] = "80000013"; photonCutArray[0] = "00200009327002008250400000"; clusterCutArray[0] = "1221100053032230000"; electronCutArray[0] = "90475400233102623710"; mesonCutArray[0] = "0263103100000000"; //standart cut, kINT7
      eventCutArray[1] = "80000013"; photonCutArray[1] = "00200009327002008250400000"; clusterCutArray[1] = "1331100053032230000"; electronCutArray[1] = "90475400233102623710"; mesonCutArray[1] = "0263103100000000"; //standard cut, kEMC7
  } else {
    Error(Form("GammaConvDalitzCalo_%i",trainConfig), "wrong trainConfig variable no cuts have been specified for the configuration");
    return;
  }


  TList *EventCutList     = new TList();
  TList *ConvCutList      = new TList();
  TList *ClusterCutList   = new TList();
  TList *ElectronCutList  = new TList();
  TList *MesonCutList     = new TList();

  TList *HeaderList = new TList();
  if (doWeightingPart==1) {
    TObjString *Header1 = new TObjString("pi0_1");
    HeaderList->Add(Header1);
  }
  if (doWeightingPart==2){
    TObjString *Header3 = new TObjString("eta_2");
    HeaderList->Add(Header3);
  }
  if (doWeightingPart==3) {
    TObjString *Header1 = new TObjString("pi0_1");
    HeaderList->Add(Header1);
    TObjString *Header3 = new TObjString("eta_2");
    HeaderList->Add(Header3);
  }

  EventCutList->SetOwner(kTRUE);
  AliConvEventCuts **analysisEventCuts = new AliConvEventCuts*[numberOfCuts];

  ConvCutList->SetOwner(kTRUE);
  AliConversionPhotonCuts **analysisCuts = new AliConversionPhotonCuts*[numberOfCuts];

  ClusterCutList->SetOwner(kTRUE);
  AliCaloPhotonCuts **analysisClusterCuts = new AliCaloPhotonCuts*[numberOfCuts];

  ElectronCutList->SetOwner(kTRUE);
  AliDalitzElectronCuts   **analysisElectronCuts = new AliDalitzElectronCuts*[numberOfCuts];

  MesonCutList->SetOwner(kTRUE);
  AliConversionMesonCuts **analysisMesonCuts = new AliConversionMesonCuts*[numberOfCuts];

  for(Int_t i = 0; i<numberOfCuts; i++){
    //create AliCaloTrackMatcher instance, if there is none present
    TString caloCutPos = clusterCutArray[i];
    caloCutPos.Resize(1);
    TString TrackMatcherName = Form("CaloTrackMatcher_%s",caloCutPos.Data());
    if( !(AliCaloTrackMatcher*)mgr->GetTask(TrackMatcherName.Data()) ){
      AliCaloTrackMatcher* fTrackMatcher = new AliCaloTrackMatcher(TrackMatcherName.Data(),caloCutPos.Atoi());
      fTrackMatcher->SetV0ReaderName(V0ReaderName);
      mgr->AddTask(fTrackMatcher);
      mgr->ConnectInput(fTrackMatcher,0,cinput);
    }

    analysisEventCuts[i] = new AliConvEventCuts();
    analysisEventCuts[i]->SetV0ReaderName(V0ReaderName);
    analysisEventCuts[i]->InitializeCutsFromCutString(eventCutArray[i].Data());
    EventCutList->Add(analysisEventCuts[i]);
    analysisEventCuts[i]->SetFillCutHistograms("",kFALSE);

    analysisCuts[i] = new AliConversionPhotonCuts();
    analysisCuts[i]->SetV0ReaderName(V0ReaderName);
    analysisCuts[i]->InitializeCutsFromCutString(photonCutArray[i].Data());
    analysisCuts[i]->SetIsHeavyIon(isHeavyIon);
    ConvCutList->Add(analysisCuts[i]);
    analysisCuts[i]->SetFillCutHistograms("",kFALSE);

    analysisClusterCuts[i] = new AliCaloPhotonCuts();
    analysisClusterCuts[i]->SetV0ReaderName(V0ReaderName);
    analysisClusterCuts[i]->SetCaloTrackMatcherName(TrackMatcherName);
    analysisClusterCuts[i]->InitializeCutsFromCutString(clusterCutArray[i].Data());
    ClusterCutList->Add(analysisClusterCuts[i]);
    analysisClusterCuts[i]->SetExtendedMatching(enableExtendedMatching);
    analysisClusterCuts[i]->SetFillCutHistograms("");

    analysisElectronCuts[i] = new AliDalitzElectronCuts();
    if( !analysisElectronCuts[i]->InitializeCutsFromCutString(electronCutArray[i].Data())) {
      cout<< "ERROR:  analysisElectronCuts [ " <<i<<" ] "<<endl;
      return 0;
    }
    ElectronCutList->Add(analysisElectronCuts[i]);
    analysisElectronCuts[i]->SetFillCutHistograms("",kFALSE,electronCutArray[i].Data());

    analysisMesonCuts[i] = new AliConversionMesonCuts();
    analysisMesonCuts[i]->InitializeCutsFromCutString(mesonCutArray[i].Data());
    MesonCutList->Add(analysisMesonCuts[i]);
    analysisMesonCuts[i]->SetFillCutHistograms("");
    analysisEventCuts[i]->SetAcceptedHeader(HeaderList);


  }

  task->SetEventCutList(numberOfCuts,EventCutList);
  task->SetConversionCutList(numberOfCuts,ConvCutList);
  task->SetCaloCutList(numberOfCuts,ClusterCutList);
  task->SetMesonCutList(numberOfCuts,MesonCutList);
  task->SetElectronCutList(numberOfCuts,ElectronCutList);
  task->SetMoveParticleAccordingToVertex(kTRUE);
  task->SetDoMesonAnalysis(kTRUE);
  task->SetDoMesonQA(enableQAMesonTask); //Attention new switch for Pi0 QA
  task->SetDoPhotonQA(enableQAPhotonTask);  //Attention new switch small for Photon QA
  task->SetDoClusterQA(1);  //Attention new switch small for Cluster QA
        task->SetUseTHnSparse(isUsingTHnSparse);

  //connect containers
  AliAnalysisDataContainer *coutput =
    mgr->CreateContainer(Form("GammaCaloDalitz_%i",trainConfig), TList::Class(),
              AliAnalysisManager::kOutputContainer,Form("GammaCaloDalitz_%i.root",trainConfig));

  mgr->AddTask(task);
  mgr->ConnectInput(task,0,cinput);
  mgr->ConnectOutput(task,1,coutput);

  return;

}