[u/mrichter/AliRoot.git] / PWGJE / FlavourJetTasks / macros / AddTasksEmcalJetV0Filter.C

const Bool_t bIsInfoAOD = kTRUE;
const Bool_t bIsPhysSel = kFALSE;
const Bool_t bIsCentSel = kFALSE;
const Bool_t bIsEvPnSel = kFALSE;
const Bool_t bIsRespPID = kTRUE;

const Bool_t bAnaJetR02 = kTRUE;
const Bool_t bAnaJetR03 = kTRUE;
const Bool_t bAnaJetR04 = kTRUE;
const Bool_t bAnaInfoMC = kFALSE;

const UInt_t wTriggerMask   = AliVEvent::kINT7;
const UInt_t wCollisionType = AliPicoHeaderCJ::kPA;
//=============================================================================

const TString sPeriodIn = "LHC13b";
const TString sCentEsti = "V0A";  // "V0M"; "V0A"; "V0C"
const Double_t dCentMin =   0.;
const Double_t dCentMax = 100.;

const TString sInputTrkRD = (bIsInfoAOD ? "tracks"          : "Tracks");
const TString sInputClsRD = (bIsInfoAOD ? "caloClusters"    : "CaloClusters");
const TString sFilterTrks = (bIsInfoAOD ? "AODFilterTracks" : "ESDFilterTracks");

const TString sUsedTrksRD = "PicoTracks";
const TString sUsedClusRD = "CaloClustersCorr";

const TString sUsedTrksMC = "MCParticles";
const TString sUsedClusMC = "";

const TString sUsedRhoRD02  = "RhoRD02";  // "RhoRD"
const TString sUsedRhoRD03  = "RhoRD03";  // "RhoRD"
const TString sUsedRhoRD04  = "RhoRD04";  // "RhoRD"

const TString sUsedRhoMC02  = "";         // "RhoMC"
const TString sUsedRhoMC03  = "";         // "RhoMC"
const TString sUsedRhoMC04  = "";         // "RhoMC"

const TString sAnaType = "TPC";  // "TPC"; "EMCAL"; "USER"
const Int_t   nLeading = 0;      // 0: charged; 1: neutral; 2: both
//=============================================================================

const Int_t nJetAlgo = 1;  // 0: KT; 1: AKT
const Int_t nJetType = 1;  // 0: FullJet; 1: ChargedJet; 2: NeutralJet

const Double_t dJetPtCut   = 8.0;
const Double_t dJetAreaCut = 0.6;

const Double_t dTrkPtCut  = 0.15;
const Double_t dCluEnCut  = 0.30;
//=============================================================================

Bool_t AddTasksEmcalJetV0Filter()
{
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();

  if (bIsInfoAOD) {
    gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddAODHandler.C");
    AliAODInputHandler *aodIH = AddAODHandler();
  } else {
    gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddESDHandler.C");
    AliESDInputHandler *esdIH = AddESDHandler();
//  esdIH->SetReadFriends(kFALSE);
  }

  if (bAnaInfoMC && (!bIsInfoAOD)) {
    gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddMCHandler.C");
    AliMCEventHandler *mctEH = AddMCHandler(kTRUE);
  }

  gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddAODOutputHandler.C");
  AliAODHandler *aodH = AddAODOutputHandler();
  aodH->SetOutputFileName("AliAOD.PicoV0Jets.root");
  aodH->SetFillAOD(kTRUE);
  aodH->SetCreateNonStandardAOD();
  mgr->SetOutputEventHandler(aodH);
//=============================================================================

  if (bIsPhysSel) {
    gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalPhysicsSelection.C");
    AliEmcalPhysicsSelectionTask *taksPhysSel = AddTaskEmcalPhysicsSelection(kTRUE, kTRUE, wTriggerMask, 5., 5., 10., kTRUE, -1, -1, -1, -1);
    if (bAnaInfoMC) {
      AliEmcalPhysicsSelection *pPhysSel = static_cast<AliEmcalPhysicsSelection*>(taksPhysSel->GetPhysicsSelection());
      if (!pPhysSel) return kTRUE; pPhysSel->SetAnalyzeMC();
    }
  }

  if (bIsCentSel) {
    gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C");
    AliCentralitySelectionTask *taskCentSel = AddTaskCentrality(kTRUE, bIsAOD);
    if (wTriggerMask) taskCentSel->SelectCollisionCandidates(wTriggerMask);
    if (bAnaInfoMC)   taskCentSel->SetMCInput();
  }

  if (bIsEvPnSel) {
    gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskEventplane.C");
    AliEPSelectionTask *taskEventPlane = AddTaskEventplane();
    if (wTriggerMask) taskEventPlane->SelectCollisionCandidates(wTriggerMask);
    if (bAnaInfoMC)   taskEventPlane->SetUseMCRP();
  }

  if (bIsRespPID) {
    gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
    AliAnalysisTaskSE *taskRespPID = AddTaskPIDResponse(bAnaInfoMC);
    if (wTriggerMask)  taskRespPID->SelectCollisionCandidates(wTriggerMask);
  }
//=============================================================================

  gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalSetup.C");
  AliEmcalSetupTask *taskSetupEMCal = AddTaskEmcalSetup();
  if (wTriggerMask)  taskSetupEMCal->SelectCollisionCandidates(wTriggerMask);
  taskSetupEMCal->SetGeoPath("$ALICE_ROOT/OADB/EMCAL");

  if (bIsInfoAOD) {
    gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalAodTrackFilter.C");
    AliEmcalAodTrackFilterTask *taskTrkFilterAOD = AddTaskEmcalAodTrackFilter(sFilterTrks.Data(),
                                                                              sInputTrkRD.Data(),
                                                                              sPeriodIn.Data());
    if (wTriggerMask) taskTrkFilterAOD->SelectCollisionCandidates(wTriggerMask);
  } else {
    gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalEsdTrackFilter.C");
    AliEmcalEsdTrackFilterTask *taskTrkFilterESD = AddTaskEmcalEsdTrackFilter(sFilterTrks.Data(),
                                                                              Form("Hybrid_%s",sPeriodIn.Data()));
    if (wTriggerMask) taskTrkFilterESD->SelectCollisionCandidates(wTriggerMask);
    esdfilter->SetDoPropagation(kTRUE);
    esdfilter->SetDist(440.);
  }

  gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalPicoTrackMaker.C");
  AliEmcalPicoTrackMaker *taskPicoTrackRD = AddTaskEmcalPicoTrackMaker(sUsedTrksRD.Data(),
                                                                       sFilterTrks.Data());
  if (wTriggerMask) taskPicoTrackRD->SelectCollisionCandidates(wTriggerMask);
  if (bAnaInfoMC)   taskPicoTrackRD->SetMC(kTRUE);
//=============================================================================

  gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskEmcalJet.C");
  gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskRhoSparse.C");

  if (bAnaJetR02) {
    AliEmcalJetTask *taskAktRD02 = AddTaskEmcalJet(((nJetType!=2) ? sUsedTrksRD.Data() : ""),
                                                   ((nJetType!=1) ? sUsedClusRD.Data() : ""),
                                                   nJetAlgo,
                                                   0.2,
                                                   nJetType,
                                                   dTrkPtCut,
                                                   dCluEnCut);
    if (wTriggerMask) taskAktRD02->SelectCollisionCandidates(wTriggerMask);

    if (!sUsedRhoRD02.IsNull()) {
      AliEmcalJetTask *taskKtRD02 = AddTaskEmcalJet(((nJetType!=2) ? sUsedTrksRD.Data() : ""),
                                                    ((nJetType!=1) ? sUsedClusRD.Data() : ""),
                                                    0,  // KT
                                                    0.2,
                                                    nJetType);
      if (wTriggerMask) taskKtRD02->SelectCollisionCandidates(wTriggerMask);
      taskKtRD02->SetMinJetPt(0.);

      AliAnalysisTaskRhoSparse *taskRhoRD02 = AddTaskRhoSparse(taskKtRD02->GetName(),
                                                               taskAktRD02->GetName(),
                                                               ((nJetType!=2) ? sUsedTrksRD.Data() : ""),
                                                               ((nJetType!=1) ? sUsedClusRD.Data() : ""),
                                                               sUsedRhoRD02.Data(),
                                                               0.2,
                                                               sAnaType.Data(),
                                                               0.01,                 // jet area cut
                                                               0.15,                 // jet pT cut
                                                               0.,                   // EMC area
                                                               0x0,                  // scale fxn
                                                               2,                    // excluded leadings
                                                               kTRUE,                // output histogram
                                                               sUsedRhoRD02.Data(),  // task name
                                                               kTRUE);               // use CMS rho
      if (wTriggerMask) taskRhoRD02->SelectCollisionCandidates(wTriggerMask);
      taskRhoRD02->SetCentRange(dCentMin, dCentMax);
      taskRhoRD02->SetCentralityEstimator(sCentEsti.Data());
    }
  }

  if (bAnaJetR03) {
    AliEmcalJetTask *taskAktRD03 = AddTaskEmcalJet(((nJetType!=2) ? sUsedTrksRD.Data() : ""),
                                                   ((nJetType!=1) ? sUsedClusRD.Data() : ""),
                                                   nJetAlgo,
                                                   0.3,
                                                   nJetType,
                                                   dTrkPtCut,
                                                   dCluEnCut);
    if (wTriggerMask) taskAktRD03->SelectCollisionCandidates(wTriggerMask);

    if (!sUsedRhoRD03.IsNull()) {
      AliEmcalJetTask *taskKtRD03 = AddTaskEmcalJet(((nJetType!=2) ? sUsedTrksRD.Data() : ""),
                                                    ((nJetType!=1) ? sUsedClusRD.Data() : ""),
                                                    0,  // KT
                                                    0.3,
                                                    nJetType);
      if (wTriggerMask) taskKtRD03->SelectCollisionCandidates(wTriggerMask);
      taskKtRD03->SetMinJetPt(0.);

      AliAnalysisTaskRhoSparse *taskRhoRD03 = AddTaskRhoSparse(taskKtRD03->GetName(),
                                                               taskAktRD03->GetName(),
                                                               ((nJetType!=2) ? sUsedTrksRD.Data() : ""),
                                                               ((nJetType!=1) ? sUsedClusRD.Data() : ""),
                                                               sUsedRhoRD03.Data(),
                                                               0.3,
                                                               sAnaType.Data(),
                                                               0.01,                 // jet area cut
                                                               0.15,                 // jet pT cut
                                                               0.,                   // EMC area
                                                               0x0,                  // scale fxn
                                                               2,                    // excluded leadings
                                                               kTRUE,                // output histogram
                                                               sUsedRhoRD03.Data(),  // task name
                                                               kTRUE);               // use CMS rho
      if (wTriggerMask) taskRhoRD03->SelectCollisionCandidates(wTriggerMask);
      taskRhoRD03->SetCentRange(dCentMin, dCentMax);
      taskRhoRD03->SetCentralityEstimator(sCentEsti.Data());
    }
  }

  if (bAnaJetR04) {
    AliEmcalJetTask *taskAktRD04 = AddTaskEmcalJet(((nJetType!=2) ? sUsedTrksRD.Data() : ""),
                                                   ((nJetType!=1) ? sUsedClusRD.Data() : ""),
                                                   nJetAlgo,
                                                   0.4,
                                                   nJetType,
                                                   dTrkPtCut,
                                                   dCluEnCut);
    if (wTriggerMask) taskAktRD04->SelectCollisionCandidates(wTriggerMask);

    if (!sUsedRhoRD04.IsNull()) {
      AliEmcalJetTask *taskKtRD04 = AddTaskEmcalJet(((nJetType!=2) ? sUsedTrksRD.Data() : ""),
                                                    ((nJetType!=1) ? sUsedClusRD.Data() : ""),
                                                    0,  // KT
                                                    0.4,
                                                    nJetType);
      if (wTriggerMask) taskKtRD04->SelectCollisionCandidates(wTriggerMask);
      taskKtRD04->SetMinJetPt(0.);

      AliAnalysisTaskRhoSparse *taskRhoRD04 = AddTaskRhoSparse(taskKtRD04->GetName(),
                                                               taskAktRD04->GetName(),
                                                               ((nJetType!=2) ? sUsedTrksRD.Data() : ""),
                                                               ((nJetType!=1) ? sUsedClusRD.Data() : ""),
                                                               sUsedRhoRD04.Data(),
                                                               0.4,
                                                               sAnaType.Data(),
                                                               0.01,                 // jet area cut
                                                               0.15,                 // jet pT cut
                                                               0.,                   // EMC area
                                                               0x0,                  // scale fxn
                                                               2,                    // excluded leadings
                                                               kTRUE,                // output histogram
                                                               sUsedRhoRD04.Data(),  // task name
                                                               kTRUE);               // use CMS rho
      if (wTriggerMask) taskRhoRD04->SelectCollisionCandidates(wTriggerMask);
      taskRhoRD04->SetCentRange(dCentMin, dCentMax);
      taskRhoRD04->SetCentralityEstimator(sCentEsti.Data());
    }
  }
//=============================================================================

  if (bAnaInfoMC) {
    gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskMCTrackSelector.C");
    AliEmcalMCTrackSelector *taskPicoTrackMC = AddTaskMCTrackSelector(sUsedTrksMC.Data(),
                                                                      kFALSE,  // NK
                                                                      kTRUE);  // CH
    if (wTriggerMask) taskPicoTrackMC->SelectCollisionCandidates(wTriggerMask);
  }
//=============================================================================

  AliAnalysisTaskSEPicoV0Maker *taskPicoV0Maker = new AliAnalysisTaskSEPicoV0Maker("AliAnalysisTaskSEPicoV0Maker", bAnaInfoMC);
  if (wTriggerMask) {
    taskPicoV0Maker->SetTriggerMask(wTriggerMask);
    taskPicoV0Maker->SelectCollisionCandidates(wTriggerMask);
  }

  taskPicoV0Maker->SetCollitionType(wCollisionType);
  taskPicoV0Maker->SetCentralityEstimator(sCentEsti.Data());
  taskPicoV0Maker->SetVertexContributorN(2);
//taskPicoV0Maker->SetRefitV0ESD();
//taskPicoV0Maker->SetSkipFastOnly();
//taskPicoV0Maker->SetDMPjetMC();

  mgr->AddTask(taskPicoV0Maker);
  mgr->ConnectInput(taskPicoV0Maker,  0, mgr->GetCommonInputContainer());
  mgr->ConnectOutput(taskPicoV0Maker, 1, mgr->CreateContainer("listPicoV0MakerEH",
                                                              TList::Class(),
                                                              AliAnalysisManager::kOutputContainer,
                                                              AliAnalysisManager::GetCommonFileName()));

  if (bAnaInfoMC) mgr->ConnectOutput(taskPicoV0Maker, 2, mgr->CreateContainer("listPicoV0MakerMC",
                                                                              TList::Class(),
                                                                              AliAnalysisManager::kOutputContainer,
                                                                              AliAnalysisManager::GetCommonFileName()));
//=============================================================================

  AliAnalysisTaskEmcalJetV0Filter *taskEmcalJetV0Filter = new AliAnalysisTaskEmcalJetV0Filter("AliAnalysisTaskEmcalJetV0Filter");
  if (wTriggerMask) taskEmcalJetV0Filter->SelectCollisionCandidates(wTriggerMask);

  taskEmcalJetV0Filter->SetIsAnaPicoV0(kTRUE);
  taskEmcalJetV0Filter->SetAnaPicoV0MC(bAnaInfoMC);

  taskEmcalJetV0Filter->SetCentRange(dCentMin, dCentMax);
  taskEmcalJetV0Filter->SetCentralityEstimator(sCentEsti.Data());
//taskEmcalJetV0Filter->SetForceBeamType(0);
//taskEmcalJetV0Filter->SetIsPythia(kTRUE);

  if (bAnaJetR02) {
    AliJetContainer *pContJetsRD02 = taskEmcalJetV0Filter->AddJetContainer(taskAktRD02->GetName(), sAnaType.Data(), 0.2);
    pContJetsRD02->SetPercAreaCut(dJetAreaCut);
    pContJetsRD02->SetJetPtCut(dJetPtCut);
    pContJetsRD02->SetRhoName(sUsedRhoRD02.Data());
//  pContJetsRD02->SetLocalRhoName();
    pContJetsRD02->SetLeadingHadronType(nLeading);
    pContJetsRD02->ConnectParticleContainer(taskEmcalJetV0Filter->AddParticleContainer((nJetType!=2) ? sUsedTrksRD.Data() : ""));
    pContJetsRD02->ConnectClusterContainer( taskEmcalJetV0Filter->AddClusterContainer( (nJetType!=1) ? sUsedClusRD.Data() : ""));
    pContJetsRD02->SetNameTitle("AliEMcalJetContainerRD02", "AliEMcalJetContainerRD02");
    taskEmcalJetV0Filter->SetNameJetRD02("AliEMcalJetContainerRD02");
  }

  if (bAnaJetR03) {
    AliJetContainer *pContJetsRD03 = taskEmcalJetV0Filter->AddJetContainer(taskAktRD03->GetName(), sAnaType.Data(), 0.3);
    pContJetsRD03->SetPercAreaCut(dJetAreaCut);
    pContJetsRD03->SetJetPtCut(dJetPtCut);
    pContJetsRD03->SetRhoName(sUsedRhoRD03.Data());
//  pContJetsRD03->SetLocalRhoName();
    pContJetsRD03->SetLeadingHadronType(nLeading);
    pContJetsRD03->ConnectParticleContainer(taskEmcalJetV0Filter->AddParticleContainer((nJetType!=2) ? sUsedTrksRD.Data() : ""));
    pContJetsRD03->ConnectClusterContainer( taskEmcalJetV0Filter->AddClusterContainer( (nJetType!=1) ? sUsedClusRD.Data() : ""));
    pContJetsRD03->SetNameTitle("AliEMcalJetContainerRD03", "AliEMcalJetContainerRD03");
    taskEmcalJetV0Filter->SetNameJetRD03("AliEMcalJetContainerRD03");
  }

  if (bAnaJetR04) {
    AliJetContainer *pContJetsRD04 = taskEmcalJetV0Filter->AddJetContainer(taskAktRD04->GetName(), sAnaType.Data(), 0.4);
    pContJetsRD04->SetPercAreaCut(dJetAreaCut);
    pContJetsRD04->SetJetPtCut(dJetPtCut);
    pContJetsRD04->SetRhoName(sUsedRhoRD04.Data());
//  pContJetsRD04->SetLocalRhoName();
    pContJetsRD04->SetLeadingHadronType(nLeading);
    pContJetsRD04->ConnectParticleContainer(taskEmcalJetV0Filter->AddParticleContainer((nJetType!=2) ? sUsedTrksRD.Data() : ""));
    pContJetsRD04->ConnectClusterContainer( taskEmcalJetV0Filter->AddClusterContainer( (nJetType!=1) ? sUsedClusRD.Data() : ""));
    pContJetsRD04->SetNameTitle("AliEMcalJetContainerRD04", "AliEMcalJetContainerRD04");
    taskEmcalJetV0Filter->SetNameJetRD04("AliEMcalJetContainerRD04");
  }

  mgr->AddTask(taskEmcalJetV0Filter);
  mgr->ConnectInput(taskEmcalJetV0Filter,  0, mgr->GetCommonInputContainer());
  mgr->ConnectOutput(taskEmcalJetV0Filter, 1, mgr->CreateContainer("listEmcalJet",
                                                                   TList::Class(),
                                                                   AliAnalysisManager::kOutputContainer,
                                                                   AliAnalysisManager::GetCommonFileName()));

  return kFALSE;
}
Commit	Line	Data
b254f323	1	const Bool_t bIsInfoAOD = kTRUE;
	2	const Bool_t bIsPhysSel = kFALSE;
	3	const Bool_t bIsCentSel = kFALSE;
	4	const Bool_t bIsEvPnSel = kFALSE;
	5	const Bool_t bIsRespPID = kTRUE;
	6
	7	const Bool_t bAnaJetR02 = kTRUE;
	8	const Bool_t bAnaJetR03 = kTRUE;
	9	const Bool_t bAnaJetR04 = kTRUE;
	10	const Bool_t bAnaInfoMC = kFALSE;
	11
	12	const UInt_t wTriggerMask = AliVEvent::kINT7;
	13	const UInt_t wCollisionType = AliPicoHeaderCJ::kPA;
	14	//=============================================================================
	15
	16	const TString sPeriodIn = "LHC13b";
	17	const TString sCentEsti = "V0A"; // "V0M"; "V0A"; "V0C"
	18	const Double_t dCentMin = 0.;
	19	const Double_t dCentMax = 100.;
	20
	21	const TString sInputTrkRD = (bIsInfoAOD ? "tracks" : "Tracks");
	22	const TString sInputClsRD = (bIsInfoAOD ? "caloClusters" : "CaloClusters");
	23	const TString sFilterTrks = (bIsInfoAOD ? "AODFilterTracks" : "ESDFilterTracks");
	24
	25	const TString sUsedTrksRD = "PicoTracks";
	26	const TString sUsedClusRD = "CaloClustersCorr";
	27
	28	const TString sUsedTrksMC = "MCParticles";
	29	const TString sUsedClusMC = "";
	30
	31	const TString sUsedRhoRD02 = "RhoRD02"; // "RhoRD"
	32	const TString sUsedRhoRD03 = "RhoRD03"; // "RhoRD"
	33	const TString sUsedRhoRD04 = "RhoRD04"; // "RhoRD"
	34
	35	const TString sUsedRhoMC02 = ""; // "RhoMC"
	36	const TString sUsedRhoMC03 = ""; // "RhoMC"
	37	const TString sUsedRhoMC04 = ""; // "RhoMC"
	38
	39	const TString sAnaType = "TPC"; // "TPC"; "EMCAL"; "USER"
	40	const Int_t nLeading = 0; // 0: charged; 1: neutral; 2: both
	41	//=============================================================================
	42
	43	const Int_t nJetAlgo = 1; // 0: KT; 1: AKT
	44	const Int_t nJetType = 1; // 0: FullJet; 1: ChargedJet; 2: NeutralJet
	45
	46	const Double_t dJetPtCut = 8.0;
	47	const Double_t dJetAreaCut = 0.6;
	48
	49	const Double_t dTrkPtCut = 0.15;
	50	const Double_t dCluEnCut = 0.30;
	51	//=============================================================================
	52
	53	Bool_t AddTasksEmcalJetV0Filter()
	54	{
	55	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
	56
	57	if (bIsInfoAOD) {
	58	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddAODHandler.C");
	59	AliAODInputHandler *aodIH = AddAODHandler();
	60	} else {
	61	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddESDHandler.C");
	62	AliESDInputHandler *esdIH = AddESDHandler();
	63	// esdIH->SetReadFriends(kFALSE);
	64	}
65
66	if (bAnaInfoMC && (!bIsInfoAOD)) {
67	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddMCHandler.C");
68	AliMCEventHandler *mctEH = AddMCHandler(kTRUE);
69	}
70
71	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddAODOutputHandler.C");
72	AliAODHandler *aodH = AddAODOutputHandler();
73	aodH->SetOutputFileName("AliAOD.PicoV0Jets.root");
74	aodH->SetFillAOD(kTRUE);
75	aodH->SetCreateNonStandardAOD();
76	mgr->SetOutputEventHandler(aodH);
77	//=============================================================================
78
79	if (bIsPhysSel) {
80	gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalPhysicsSelection.C");
81	AliEmcalPhysicsSelectionTask *taksPhysSel = AddTaskEmcalPhysicsSelection(kTRUE, kTRUE, wTriggerMask, 5., 5., 10., kTRUE, -1, -1, -1, -1);
82	if (bAnaInfoMC) {
83	AliEmcalPhysicsSelection pPhysSel = static_cast<AliEmcalPhysicsSelection>(taksPhysSel->GetPhysicsSelection());
84	if (!pPhysSel) return kTRUE; pPhysSel->SetAnalyzeMC();
85	}
86	}
87
88	if (bIsCentSel) {
1c06a186	89	gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C");
b254f323	90	AliCentralitySelectionTask *taskCentSel = AddTaskCentrality(kTRUE, bIsAOD);
	91	if (wTriggerMask) taskCentSel->SelectCollisionCandidates(wTriggerMask);
	92	if (bAnaInfoMC) taskCentSel->SetMCInput();
	93	}
	94
	95	if (bIsEvPnSel) {
	96	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskEventplane.C");
	97	AliEPSelectionTask *taskEventPlane = AddTaskEventplane();
	98	if (wTriggerMask) taskEventPlane->SelectCollisionCandidates(wTriggerMask);
	99	if (bAnaInfoMC) taskEventPlane->SetUseMCRP();
	100	}
	101
	102	if (bIsRespPID) {
	103	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
	104	AliAnalysisTaskSE *taskRespPID = AddTaskPIDResponse(bAnaInfoMC);
	105	if (wTriggerMask) taskRespPID->SelectCollisionCandidates(wTriggerMask);
	106	}
	107	//=============================================================================
	108
	109	gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalSetup.C");
	110	AliEmcalSetupTask *taskSetupEMCal = AddTaskEmcalSetup();
	111	if (wTriggerMask) taskSetupEMCal->SelectCollisionCandidates(wTriggerMask);
	112	taskSetupEMCal->SetGeoPath("$ALICE_ROOT/OADB/EMCAL");
	113
	114	if (bIsInfoAOD) {
	115	gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalAodTrackFilter.C");
	116	AliEmcalAodTrackFilterTask *taskTrkFilterAOD = AddTaskEmcalAodTrackFilter(sFilterTrks.Data(),
	117	sInputTrkRD.Data(),
	118	sPeriodIn.Data());
	119	if (wTriggerMask) taskTrkFilterAOD->SelectCollisionCandidates(wTriggerMask);
	120	} else {
	121	gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalEsdTrackFilter.C");
	122	AliEmcalEsdTrackFilterTask *taskTrkFilterESD = AddTaskEmcalEsdTrackFilter(sFilterTrks.Data(),
	123	Form("Hybrid_%s",sPeriodIn.Data()));
	124	if (wTriggerMask) taskTrkFilterESD->SelectCollisionCandidates(wTriggerMask);
	125	esdfilter->SetDoPropagation(kTRUE);
	126	esdfilter->SetDist(440.);
	127	}
	128
	129	gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalPicoTrackMaker.C");
	130	AliEmcalPicoTrackMaker *taskPicoTrackRD = AddTaskEmcalPicoTrackMaker(sUsedTrksRD.Data(),
	131	sFilterTrks.Data());
	132	if (wTriggerMask) taskPicoTrackRD->SelectCollisionCandidates(wTriggerMask);
	133	if (bAnaInfoMC) taskPicoTrackRD->SetMC(kTRUE);
	134	//=============================================================================
	135
	136	gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskEmcalJet.C");
	137	gROOT->LoadMacro("$ALICE_ROOT/PWGJE/EMCALJetTasks/macros/AddTaskRhoSparse.C");
	138
	139	if (bAnaJetR02) {
	140	AliEmcalJetTask *taskAktRD02 = AddTaskEmcalJet(((nJetType!=2) ? sUsedTrksRD.Data() : ""),
	141	((nJetType!=1) ? sUsedClusRD.Data() : ""),
	142	nJetAlgo,
	143	0.2,
	144	nJetType,
	145	dTrkPtCut,
	146	dCluEnCut);
	147	if (wTriggerMask) taskAktRD02->SelectCollisionCandidates(wTriggerMask);
	148
	149	if (!sUsedRhoRD02.IsNull()) {
	150	AliEmcalJetTask *taskKtRD02 = AddTaskEmcalJet(((nJetType!=2) ? sUsedTrksRD.Data() : ""),
	151	((nJetType!=1) ? sUsedClusRD.Data() : ""),
	152	0, // KT
	153	0.2,
154	nJetType);
155	if (wTriggerMask) taskKtRD02->SelectCollisionCandidates(wTriggerMask);
156	taskKtRD02->SetMinJetPt(0.);
157
158	AliAnalysisTaskRhoSparse *taskRhoRD02 = AddTaskRhoSparse(taskKtRD02->GetName(),
159	taskAktRD02->GetName(),
160	((nJetType!=2) ? sUsedTrksRD.Data() : ""),
161	((nJetType!=1) ? sUsedClusRD.Data() : ""),
162	sUsedRhoRD02.Data(),
163	0.2,
164	sAnaType.Data(),
165	0.01, // jet area cut
166	0.15, // jet pT cut
167	0., // EMC area
168	0x0, // scale fxn
169	2, // excluded leadings
170	kTRUE, // output histogram
171	sUsedRhoRD02.Data(), // task name
172	kTRUE); // use CMS rho
173	if (wTriggerMask) taskRhoRD02->SelectCollisionCandidates(wTriggerMask);
174	taskRhoRD02->SetCentRange(dCentMin, dCentMax);
175	taskRhoRD02->SetCentralityEstimator(sCentEsti.Data());
176	}
177	}
178
179	if (bAnaJetR03) {
180	AliEmcalJetTask *taskAktRD03 = AddTaskEmcalJet(((nJetType!=2) ? sUsedTrksRD.Data() : ""),
181	((nJetType!=1) ? sUsedClusRD.Data() : ""),
182	nJetAlgo,
183	0.3,
184	nJetType,
185	dTrkPtCut,
186	dCluEnCut);
187	if (wTriggerMask) taskAktRD03->SelectCollisionCandidates(wTriggerMask);
188
189	if (!sUsedRhoRD03.IsNull()) {
190	AliEmcalJetTask *taskKtRD03 = AddTaskEmcalJet(((nJetType!=2) ? sUsedTrksRD.Data() : ""),
191	((nJetType!=1) ? sUsedClusRD.Data() : ""),
192	0, // KT
193	0.3,
194	nJetType);
195	if (wTriggerMask) taskKtRD03->SelectCollisionCandidates(wTriggerMask);
196	taskKtRD03->SetMinJetPt(0.);
197
198	AliAnalysisTaskRhoSparse *taskRhoRD03 = AddTaskRhoSparse(taskKtRD03->GetName(),
199	taskAktRD03->GetName(),
200	((nJetType!=2) ? sUsedTrksRD.Data() : ""),
201	((nJetType!=1) ? sUsedClusRD.Data() : ""),
202	sUsedRhoRD03.Data(),
203	0.3,
204	sAnaType.Data(),
205	0.01, // jet area cut
206	0.15, // jet pT cut
207	0., // EMC area
208	0x0, // scale fxn
209	2, // excluded leadings
210	kTRUE, // output histogram
211	sUsedRhoRD03.Data(), // task name
212	kTRUE); // use CMS rho
213	if (wTriggerMask) taskRhoRD03->SelectCollisionCandidates(wTriggerMask);
214	taskRhoRD03->SetCentRange(dCentMin, dCentMax);
215	taskRhoRD03->SetCentralityEstimator(sCentEsti.Data());
216	}
217	}
218
219	if (bAnaJetR04) {
220	AliEmcalJetTask *taskAktRD04 = AddTaskEmcalJet(((nJetType!=2) ? sUsedTrksRD.Data() : ""),
221	((nJetType!=1) ? sUsedClusRD.Data() : ""),
222	nJetAlgo,
223	0.4,
224	nJetType,
225	dTrkPtCut,
226	dCluEnCut);
227	if (wTriggerMask) taskAktRD04->SelectCollisionCandidates(wTriggerMask);
228
229	if (!sUsedRhoRD04.IsNull()) {
230	AliEmcalJetTask *taskKtRD04 = AddTaskEmcalJet(((nJetType!=2) ? sUsedTrksRD.Data() : ""),
231	((nJetType!=1) ? sUsedClusRD.Data() : ""),
232	0, // KT
233	0.4,
234	nJetType);
235	if (wTriggerMask) taskKtRD04->SelectCollisionCandidates(wTriggerMask);
236	taskKtRD04->SetMinJetPt(0.);
237
238	AliAnalysisTaskRhoSparse *taskRhoRD04 = AddTaskRhoSparse(taskKtRD04->GetName(),
239	taskAktRD04->GetName(),
240	((nJetType!=2) ? sUsedTrksRD.Data() : ""),
241	((nJetType!=1) ? sUsedClusRD.Data() : ""),
242	sUsedRhoRD04.Data(),
243	0.4,
244	sAnaType.Data(),
245	0.01, // jet area cut
246	0.15, // jet pT cut
247	0., // EMC area
248	0x0, // scale fxn
249	2, // excluded leadings
250	kTRUE, // output histogram
251	sUsedRhoRD04.Data(), // task name
252	kTRUE); // use CMS rho
253	if (wTriggerMask) taskRhoRD04->SelectCollisionCandidates(wTriggerMask);
254	taskRhoRD04->SetCentRange(dCentMin, dCentMax);
255	taskRhoRD04->SetCentralityEstimator(sCentEsti.Data());
256	}
257	}
258	//=============================================================================
259
260	if (bAnaInfoMC) {
261	gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskMCTrackSelector.C");
262	AliEmcalMCTrackSelector *taskPicoTrackMC = AddTaskMCTrackSelector(sUsedTrksMC.Data(),
263	kFALSE, // NK
264	kTRUE); // CH
265	if (wTriggerMask) taskPicoTrackMC->SelectCollisionCandidates(wTriggerMask);
266	}
267	//=============================================================================
268
269	AliAnalysisTaskSEPicoV0Maker *taskPicoV0Maker = new AliAnalysisTaskSEPicoV0Maker("AliAnalysisTaskSEPicoV0Maker", bAnaInfoMC);
270	if (wTriggerMask) {
271	taskPicoV0Maker->SetTriggerMask(wTriggerMask);
272	taskPicoV0Maker->SelectCollisionCandidates(wTriggerMask);
273	}
274
275	taskPicoV0Maker->SetCollitionType(wCollisionType);
276	taskPicoV0Maker->SetCentralityEstimator(sCentEsti.Data());
277	taskPicoV0Maker->SetVertexContributorN(2);
278	//taskPicoV0Maker->SetRefitV0ESD();
279	//taskPicoV0Maker->SetSkipFastOnly();
280	//taskPicoV0Maker->SetDMPjetMC();
281
282	mgr->AddTask(taskPicoV0Maker);
283	mgr->ConnectInput(taskPicoV0Maker, 0, mgr->GetCommonInputContainer());
284	mgr->ConnectOutput(taskPicoV0Maker, 1, mgr->CreateContainer("listPicoV0MakerEH",
285	TList::Class(),
286	AliAnalysisManager::kOutputContainer,
287	AliAnalysisManager::GetCommonFileName()));
288
289	if (bAnaInfoMC) mgr->ConnectOutput(taskPicoV0Maker, 2, mgr->CreateContainer("listPicoV0MakerMC",
290	TList::Class(),
291	AliAnalysisManager::kOutputContainer,
292	AliAnalysisManager::GetCommonFileName()));
293	//=============================================================================
294
295	AliAnalysisTaskEmcalJetV0Filter *taskEmcalJetV0Filter = new AliAnalysisTaskEmcalJetV0Filter("AliAnalysisTaskEmcalJetV0Filter");
296	if (wTriggerMask) taskEmcalJetV0Filter->SelectCollisionCandidates(wTriggerMask);
297
298	taskEmcalJetV0Filter->SetIsAnaPicoV0(kTRUE);
299	taskEmcalJetV0Filter->SetAnaPicoV0MC(bAnaInfoMC);
300
301	taskEmcalJetV0Filter->SetCentRange(dCentMin, dCentMax);
302	taskEmcalJetV0Filter->SetCentralityEstimator(sCentEsti.Data());
303	//taskEmcalJetV0Filter->SetForceBeamType(0);
304	//taskEmcalJetV0Filter->SetIsPythia(kTRUE);
305
306	if (bAnaJetR02) {
307	AliJetContainer *pContJetsRD02 = taskEmcalJetV0Filter->AddJetContainer(taskAktRD02->GetName(), sAnaType.Data(), 0.2);
308	pContJetsRD02->SetPercAreaCut(dJetAreaCut);
309	pContJetsRD02->SetJetPtCut(dJetPtCut);
310	pContJetsRD02->SetRhoName(sUsedRhoRD02.Data());
311	// pContJetsRD02->SetLocalRhoName();
312	pContJetsRD02->SetLeadingHadronType(nLeading);
313	pContJetsRD02->ConnectParticleContainer(taskEmcalJetV0Filter->AddParticleContainer((nJetType!=2) ? sUsedTrksRD.Data() : ""));
314	pContJetsRD02->ConnectClusterContainer( taskEmcalJetV0Filter->AddClusterContainer( (nJetType!=1) ? sUsedClusRD.Data() : ""));
315	pContJetsRD02->SetNameTitle("AliEMcalJetContainerRD02", "AliEMcalJetContainerRD02");
316	taskEmcalJetV0Filter->SetNameJetRD02("AliEMcalJetContainerRD02");
317	}
318
319	if (bAnaJetR03) {
320	AliJetContainer *pContJetsRD03 = taskEmcalJetV0Filter->AddJetContainer(taskAktRD03->GetName(), sAnaType.Data(), 0.3);
321	pContJetsRD03->SetPercAreaCut(dJetAreaCut);
322	pContJetsRD03->SetJetPtCut(dJetPtCut);
323	pContJetsRD03->SetRhoName(sUsedRhoRD03.Data());
324	// pContJetsRD03->SetLocalRhoName();
325	pContJetsRD03->SetLeadingHadronType(nLeading);
326	pContJetsRD03->ConnectParticleContainer(taskEmcalJetV0Filter->AddParticleContainer((nJetType!=2) ? sUsedTrksRD.Data() : ""));
327	pContJetsRD03->ConnectClusterContainer( taskEmcalJetV0Filter->AddClusterContainer( (nJetType!=1) ? sUsedClusRD.Data() : ""));
328	pContJetsRD03->SetNameTitle("AliEMcalJetContainerRD03", "AliEMcalJetContainerRD03");
329	taskEmcalJetV0Filter->SetNameJetRD03("AliEMcalJetContainerRD03");
330	}
331
332	if (bAnaJetR04) {
333	AliJetContainer *pContJetsRD04 = taskEmcalJetV0Filter->AddJetContainer(taskAktRD04->GetName(), sAnaType.Data(), 0.4);
334	pContJetsRD04->SetPercAreaCut(dJetAreaCut);
335	pContJetsRD04->SetJetPtCut(dJetPtCut);
336	pContJetsRD04->SetRhoName(sUsedRhoRD04.Data());
337	// pContJetsRD04->SetLocalRhoName();
338	pContJetsRD04->SetLeadingHadronType(nLeading);
339	pContJetsRD04->ConnectParticleContainer(taskEmcalJetV0Filter->AddParticleContainer((nJetType!=2) ? sUsedTrksRD.Data() : ""));
340	pContJetsRD04->ConnectClusterContainer( taskEmcalJetV0Filter->AddClusterContainer( (nJetType!=1) ? sUsedClusRD.Data() : ""));
341	pContJetsRD04->SetNameTitle("AliEMcalJetContainerRD04", "AliEMcalJetContainerRD04");
342	taskEmcalJetV0Filter->SetNameJetRD04("AliEMcalJetContainerRD04");
343	}
344
345	mgr->AddTask(taskEmcalJetV0Filter);
346	mgr->ConnectInput(taskEmcalJetV0Filter, 0, mgr->GetCommonInputContainer());
347	mgr->ConnectOutput(taskEmcalJetV0Filter, 1, mgr->CreateContainer("listEmcalJet",
348	TList::Class(),
349	AliAnalysisManager::kOutputContainer,
350	AliAnalysisManager::GetCommonFileName()));
351
352	return kFALSE;
353	}