[u/mrichter/AliRoot.git] / PWGJE / EMCALJetTasks / macros / AddTaskJetMultiPreparation.C

AliAnalysisTaskSE* AddTaskJetMultiPreparation(
  const char*    periodstr          = "LHC13b",
  TString        usedTracks         = "PicoTracks",
  const char*    usedMCParticles    = "MCParticlesSelected",
  const char*    usedClusters       = "CaloClusters",
  TString        outClusName        = "CaloClustersCorr",
  const Double_t hadCorr            = 2.0,
  const Double_t Eexcl              = 0.00,
  const Double_t phiMatch           = 0.03,
  const Double_t etaMatch           = 0.015,
  const Double_t minPtEt            = 0.15,
  const UInt_t   pSel               = AliVEvent::kAny,
  const Bool_t   trackclus          = kTRUE,
  const Bool_t   doHistos           = kFALSE,
  const Bool_t   makePicoTracks     = kTRUE,
  const Bool_t   makeTrigger        = kFALSE,
  const Bool_t   isEmcalTrain       = kFALSE,
  const Double_t trackEff           = 1.0,
  const Bool_t   doAODTrackProp     = kFALSE
)
{
    // Add task macros for all jet related helper tasks.
    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
    if (!mgr)
    {
        Error("AddTaskJetPreparation","No analysis manager found.");
        return 0;
    }

    AliVEventHandler *evhand = mgr->GetInputEventHandler();
    if (!evhand)
    {
        Error("AddTaskJetPreparation", "This task requires an input event handler");
        return NULL;
    }

    // Convert hadCorr & trackEff to TStrings to be used in naming conventions
    TString sTrackEff = "";
    TString sHadCorr = "";
    Int_t tEff = Int_t(trackEff*100);
    Int_t hC = Int_t(hadCorr*100);
    
    if (trackEff<0.1)
    {
        sTrackEff = Form("00%d",tEff);
    }
    else if (trackEff<1.0)
    {
        sTrackEff = Form("0%d",tEff);
    }
    else
    {
        sTrackEff = Form("%d",tEff);
    }
    
    if (hadCorr<0.1)
    {
        sHadCorr = Form("00%d",hC);
    }
    else if (hadCorr<1.0)
    {
        sHadCorr = Form("0%d",hC);
    }
    else
    {
        sHadCorr = Form("%d",hC);
    }
    
    // Establish names for output collections and tasks
    TString sPicoTracks = usedTracks + "_" + sTrackEff;
    TString sEmcalTriggers = "EmcalTriggers_" + sTrackEff;
    TString sEmcalTracks = "EmcalTracks_" + sTrackEff;
    TString sEmcalClusters = "EmcalClusters_" + sTrackEff;
    TString sCaloClustersCorr = outClusName + "_" + sTrackEff + "_" + sHadCorr;
    
    TString sESDTrackFilterName = "AliEmcalEsdTrackFilterTask";
    TString sAODTrackPropagatorName = "AliEmcalTrackPropagatorTaskAOD";
    TString sEmcalPicoTrackMakerName = "EmcalPicoTrackMaker_" + sTrackEff;
    TString sEmcalParticleMakerName = "EmcalParticleMaker_" + sTrackEff;
    TString sEmcalTriggerMakerName = "EmcalTriggerMaker_" + sTrackEff;
    TString sEmcalTriggerMakerSetupOutName = "EmcalTriggerMakerSetupOut_" + sTrackEff;
    TString sMCTrackSelectorName = "AliEmcalMCTrackSelector";
    
    // Set trackcuts according to period. Every period used should be definied here
    TString period(periodstr);
    TString clusterColName(usedClusters);
    TString particleColName(usedMCParticles);
    TString dType("ESD");
    
    if (!evhand->InheritsFrom("AliESDInputHandler"))
    {
        dType = "AOD";
    }

    if ((dType == "AOD") && (clusterColName == "CaloClusters"))
    {
        clusterColName = "caloClusters";
    }
    if ((dType == "ESD") && (clusterColName == "caloClusters"))
    {
        clusterColName = "CaloClusters";
    }

    if (0)
    {
        gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalTrackPropagator.C");
        AliEmcalTrackPropagatorTask *proptask = AddTaskEmcalTrackPropagator();
        proptask->SelectCollisionCandidates(pSel);
    }

    if (makePicoTracks && (dType == "ESD" || dType == "AOD") )
    {
        TString inputTracks = "AODFilterTracks";
        const Double_t edist = 440;
        if (dType == "ESD")
        {
            inputTracks = "ESDFilterTracks";
            TString trackCuts(Form("Hybrid_%s",period.Data()));
            
            // Hybrid tracks maker for ESD
            AliEmcalEsdTrackFilterTask *esdFilter = mgr->GetTask(sESDTrackFilterName.Data());
            if (!esdFilter)
            {
                gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalEsdTrackFilter.C");
                AliEmcalEsdTrackFilterTask *esdFilter = AddTaskEmcalEsdTrackFilter(inputTracks.Data(),trackCuts.Data());
                esdFilter->SetDoPropagation(kTRUE);
                esdFilter->SetDist(edist);
                esdFilter->SelectCollisionCandidates(pSel);
            }
        }
        else if (dType == "AOD")
        {
            // Track propagator to extend track to the EMCal surface
            AliEmcalAodTrackFilterTask *aodFilter = mgr->GetTask(sAODTrackPropagatorName.Data());
            if (!aodFilter)
            {
                gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalAodTrackFilter.C");
                AliEmcalAodTrackFilterTask *aodFilter = AddTaskEmcalAodTrackFilter(inputTracks.Data(),"tracks",period.Data());
                aodFilter->SetDist(edist);
                aodFilter->SelectCollisionCandidates(pSel);
                if (doAODTrackProp == kTRUE)
                {
                    aodFilter->SetDoPropagation(kTRUE);
                }
            }
        }

        // Produce PicoTracks
        AliEmcalPicoTrackMaker *pTrackTask = mgr->GetTask(sEmcalPicoTrackMakerName.Data());
        if (!pTrackTask)
        {
            gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalPicoTrackMaker.C");
            pTrackTask = AddTaskEmcalPicoTrackMaker(sPicoTracks.Data(), inputTracks.Data(),0,1000,-10,10,-10,10,trackEff,sEmcalPicoTrackMakerName.Data());
            pTrackTask->SelectCollisionCandidates(pSel);
        }
    }

    // Trigger maker
    if (makeTrigger)
    {
        AliEmcalTriggerMaker *emcalTriggers = mgr->GetTask(sEmcalTriggerMakerName.Data());
        if (!emcalTriggers)
        {
            gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalTriggerMaker.C");
            emcalTriggers = AddTaskEmcalTriggerMaker(sEmcalTriggers.Data(),sEmcalTriggerMakerSetupOutName.Data(),0,0,sEmcalTriggerMakerName.Data(),0,0,0,0,0,0);
            emcalTriggers->SelectCollisionCandidates(pSel);
        }
    }

    // Produce particles used for hadronic correction, then match!
    AliEmcalParticleMaker *emcalParts = mgr->GetTask(sEmcalParticleMakerName.Data());
    if (!emcalParts)
    {
        gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalParticleMaker.C");
        emcalParts = AddTaskEmcalParticleMaker(sPicoTracks.Data(),clusterColName.Data(),sEmcalTracks.Data(),sEmcalClusters.Data(),sEmcalParticleMakerName.Data());
        emcalParts->SelectCollisionCandidates(pSel);

        // Relate tracks and clusters
        gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalClusTrackMatcher.C");
        AliEmcalClusTrackMatcherTask *emcalClus = AddTaskEmcalClusTrackMatcher(sEmcalTracks.Data(),sEmcalClusters.Data(),0.1,doHistos);
        emcalClus->SetModifyObjs(kFALSE);
        emcalClus->SelectCollisionCandidates(pSel);
        if (isEmcalTrain)
        {
            RequestMemory(emcalClus,100*1024);
        }
    }

    // Make Corrected CaloClusters
    gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskHadCorr.C");
    AliHadCorrTask *hCorr = AddTaskHadCorr(sEmcalTracks.Data(),sEmcalClusters.Data(),sCaloClustersCorr.Data(),hadCorr,minPtEt,phiMatch,etaMatch,Eexcl,trackclus,doHistos);
    hCorr->SelectCollisionCandidates(pSel);
    if (isEmcalTrain)
    {
        if (doHistos)
        {
            RequestMemory(hCorr,500*1024);
        }
    }

    // Produce MC particles
    if(particleColName != "")
    {
        AliEmcalMCTrackSelector *mcPartTask = mgr->GetTask(sMCTrackSelectorName.Data());
        if (!mcPartTask)
        {
            gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskMCTrackSelector.C");
            AliEmcalMCTrackSelector *mcPartTask = AddTaskMCTrackSelector(particleColName.Data(), kFALSE, kFALSE);
            mcPartTask->SelectCollisionCandidates(pSel);
        }
    }

    // Return one task that represents the jet preparation on LEGO trains
    return emcalParts;
}
Commit	Line	Data
6bda5230	1	AliAnalysisTaskSE* AddTaskJetMultiPreparation(
6bda5230 CY	2	const char* periodstr = "LHC13b",
	3	TString usedTracks = "PicoTracks",
	4	const char* usedMCParticles = "MCParticlesSelected",
	5	const char* usedClusters = "CaloClusters",
	6	TString outClusName = "CaloClustersCorr",
	7	const Double_t hadCorr = 2.0,
	8	const Double_t Eexcl = 0.00,
	9	const Double_t phiMatch = 0.03,
	10	const Double_t etaMatch = 0.015,
	11	const Double_t minPtEt = 0.15,
	12	const UInt_t pSel = AliVEvent::kAny,
	13	const Bool_t trackclus = kTRUE,
	14	const Bool_t doHistos = kFALSE,
	15	const Bool_t makePicoTracks = kTRUE,
825d120f	16	const Bool_t makeTrigger = kFALSE,
6bda5230 CY	17	const Bool_t isEmcalTrain = kFALSE,
	18	const Double_t trackEff = 1.0,
	19	const Bool_t doAODTrackProp = kFALSE
	20	)
	21	{
	22	// Add task macros for all jet related helper tasks.
	23	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
	24	if (!mgr)
	25	{
	26	Error("AddTaskJetPreparation","No analysis manager found.");
	27	return 0;
	28	}
	29
825d120f	30	AliVEventHandler *evhand = mgr->GetInputEventHandler();
	31	if (!evhand)
	32	{
	33	Error("AddTaskJetPreparation", "This task requires an input event handler");
	34	return NULL;
	35	}
	36
6bda5230 CY	37	// Convert hadCorr & trackEff to TStrings to be used in naming conventions
	38	TString sTrackEff = "";
	39	TString sHadCorr = "";
	40	Int_t tEff = Int_t(trackEff*100);
	41	Int_t hC = Int_t(hadCorr*100);
	42
	43	if (trackEff<0.1)
	44	{
	45	sTrackEff = Form("00%d",tEff);
	46	}
	47	else if (trackEff<1.0)
	48	{
	49	sTrackEff = Form("0%d",tEff);
	50	}
	51	else
	52	{
	53	sTrackEff = Form("%d",tEff);
	54	}
	55
	56	if (hadCorr<0.1)
	57	{
	58	sHadCorr = Form("00%d",hC);
	59	}
	60	else if (hadCorr<1.0)
	61	{
	62	sHadCorr = Form("0%d",hC);
	63	}
	64	else
	65	{
	66	sHadCorr = Form("%d",hC);
	67	}
	68
	69	// Establish names for output collections and tasks
	70	TString sPicoTracks = usedTracks + "_" + sTrackEff;
825d120f	71	TString sEmcalTriggers = "EmcalTriggers_" + sTrackEff;
6bda5230 CY	72	TString sEmcalTracks = "EmcalTracks_" + sTrackEff;
6bda5230 CY	73	TString sEmcalClusters = "EmcalClusters_" + sTrackEff;
6bda5230 CY	74	TString sCaloClustersCorr = outClusName + "_" + sTrackEff + "_" + sHadCorr;
	75
	76	TString sESDTrackFilterName = "AliEmcalEsdTrackFilterTask";
	77	TString sAODTrackPropagatorName = "AliEmcalTrackPropagatorTaskAOD";
	78	TString sEmcalPicoTrackMakerName = "EmcalPicoTrackMaker_" + sTrackEff;
	79	TString sEmcalParticleMakerName = "EmcalParticleMaker_" + sTrackEff;
	80	TString sEmcalTriggerMakerName = "EmcalTriggerMaker_" + sTrackEff;
	81	TString sEmcalTriggerMakerSetupOutName = "EmcalTriggerMakerSetupOut_" + sTrackEff;
	82	TString sMCTrackSelectorName = "AliEmcalMCTrackSelector";
	83
	84	// Set trackcuts according to period. Every period used should be definied here
	85	TString period(periodstr);
	86	TString clusterColName(usedClusters);
	87	TString particleColName(usedMCParticles);
825d120f	88	TString dType("ESD");
	89
	90	if (!evhand->InheritsFrom("AliESDInputHandler"))
	91	{
	92	dType = "AOD";
	93	}
6bda5230 CY	94
	95	if ((dType == "AOD") && (clusterColName == "CaloClusters"))
	96	{
	97	clusterColName = "caloClusters";
	98	}
	99	if ((dType == "ESD") && (clusterColName == "caloClusters"))
	100	{
	101	clusterColName = "CaloClusters";
	102	}
	103
825d120f	104	if (0)
	105	{
	106	gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalTrackPropagator.C");
	107	AliEmcalTrackPropagatorTask *proptask = AddTaskEmcalTrackPropagator();
	108	proptask->SelectCollisionCandidates(pSel);
	109	}
	110
6bda5230 CY	111	if (makePicoTracks && (dType == "ESD" \|\| dType == "AOD") )
6bda5230 CY	112	{
825d120f	113	TString inputTracks = "AODFilterTracks";
6bda5230 CY	114	const Double_t edist = 440;
	115	if (dType == "ESD")
	116	{
825d120f	117	inputTracks = "ESDFilterTracks";
6bda5230 CY	118	TString trackCuts(Form("Hybrid_%s",period.Data()));
	119
	120	// Hybrid tracks maker for ESD
	121	AliEmcalEsdTrackFilterTask *esdFilter = mgr->GetTask(sESDTrackFilterName.Data());
	122	if (!esdFilter)
	123	{
	124	gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalEsdTrackFilter.C");
	125	AliEmcalEsdTrackFilterTask *esdFilter = AddTaskEmcalEsdTrackFilter(inputTracks.Data(),trackCuts.Data());
	126	esdFilter->SetDoPropagation(kTRUE);
	127	esdFilter->SetDist(edist);
	128	esdFilter->SelectCollisionCandidates(pSel);
	129	}
	130	}
	131	else if (dType == "AOD")
	132	{
	133	// Track propagator to extend track to the EMCal surface
	134	AliEmcalAodTrackFilterTask *aodFilter = mgr->GetTask(sAODTrackPropagatorName.Data());
	135	if (!aodFilter)
	136	{
	137	gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalAodTrackFilter.C");
	138	AliEmcalAodTrackFilterTask *aodFilter = AddTaskEmcalAodTrackFilter(inputTracks.Data(),"tracks",period.Data());
	139	aodFilter->SetDist(edist);
	140	aodFilter->SelectCollisionCandidates(pSel);
	141	if (doAODTrackProp == kTRUE)
	142	{
	143	aodFilter->SetDoPropagation(kTRUE);
	144	}
	145	}
	146	}
	147
	148	// Produce PicoTracks
	149	AliEmcalPicoTrackMaker *pTrackTask = mgr->GetTask(sEmcalPicoTrackMakerName.Data());
	150	if (!pTrackTask)
	151	{
	152	gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalPicoTrackMaker.C");
	153	pTrackTask = AddTaskEmcalPicoTrackMaker(sPicoTracks.Data(), inputTracks.Data(),0,1000,-10,10,-10,10,trackEff,sEmcalPicoTrackMakerName.Data());
	154	pTrackTask->SelectCollisionCandidates(pSel);
	155	}
	156	}
	157
825d120f	158	// Trigger maker
	159	if (makeTrigger)
	160	{
	161	AliEmcalTriggerMaker *emcalTriggers = mgr->GetTask(sEmcalTriggerMakerName.Data());
	162	if (!emcalTriggers)
	163	{
	164	gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalTriggerMaker.C");
	165	emcalTriggers = AddTaskEmcalTriggerMaker(sEmcalTriggers.Data(),sEmcalTriggerMakerSetupOutName.Data(),0,0,sEmcalTriggerMakerName.Data(),0,0,0,0,0,0);
	166	emcalTriggers->SelectCollisionCandidates(pSel);
	167	}
	168	}
	169
	170	// Produce particles used for hadronic correction, then match!
6bda5230 CY	171	AliEmcalParticleMaker *emcalParts = mgr->GetTask(sEmcalParticleMakerName.Data());
	172	if (!emcalParts)
	173	{
	174	gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalParticleMaker.C");
	175	emcalParts = AddTaskEmcalParticleMaker(sPicoTracks.Data(),clusterColName.Data(),sEmcalTracks.Data(),sEmcalClusters.Data(),sEmcalParticleMakerName.Data());
	176	emcalParts->SelectCollisionCandidates(pSel);
	177
6bda5230 CY	178	// Relate tracks and clusters
	179	gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskEmcalClusTrackMatcher.C");
	180	AliEmcalClusTrackMatcherTask *emcalClus = AddTaskEmcalClusTrackMatcher(sEmcalTracks.Data(),sEmcalClusters.Data(),0.1,doHistos);
825d120f	181	emcalClus->SetModifyObjs(kFALSE);
6bda5230 CY	182	emcalClus->SelectCollisionCandidates(pSel);
	183	if (isEmcalTrain)
	184	{
	185	RequestMemory(emcalClus,100*1024);
	186	}
	187	}
	188
	189	// Make Corrected CaloClusters
	190	gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskHadCorr.C");
	191	AliHadCorrTask *hCorr = AddTaskHadCorr(sEmcalTracks.Data(),sEmcalClusters.Data(),sCaloClustersCorr.Data(),hadCorr,minPtEt,phiMatch,etaMatch,Eexcl,trackclus,doHistos);
	192	hCorr->SelectCollisionCandidates(pSel);
	193	if (isEmcalTrain)
	194	{
	195	if (doHistos)
	196	{
	197	RequestMemory(hCorr,500*1024);
	198	}
	199	}
	200
	201	// Produce MC particles
	202	if(particleColName != "")
	203	{
	204	AliEmcalMCTrackSelector *mcPartTask = mgr->GetTask(sMCTrackSelectorName.Data());
	205	if (!mcPartTask)
	206	{
	207	gROOT->LoadMacro("$ALICE_ROOT/PWG/EMCAL/macros/AddTaskMCTrackSelector.C");
	208	AliEmcalMCTrackSelector *mcPartTask = AddTaskMCTrackSelector(particleColName.Data(), kFALSE, kFALSE);
	209	mcPartTask->SelectCollisionCandidates(pSel);
	210	}
	211	}
	212
	213	// Return one task that represents the jet preparation on LEGO trains
	214	return emcalParts;
	215	}