コード例 #1
0
def main(configFileName, nFiles, nEvents, d2h, doRecLevel, doSignalOnly, doMCTruth, doWrongPID, doResponse, noInclusiveJets, efficiency, selectGen, taskName="JetDmesonAna", debugLevel=0):

    f = open(configFileName, 'r')
    config = yaml.load(f)
    f.close()

    physSel = ExtractTriggerSelection(config["trigger"])
    print("Trigger selection is {}".format(physSel))

    ROOT.gSystem.Load("libCGAL")

    ROOT.AliTrackContainer.SetDefTrackCutsPeriod(config["run_period"])

    mode = None
    if config["mode"] == "AOD":
        mode = helperFunctions.AnaMode.AOD
    elif config["mode"] == "ESD":
        mode = helperFunctions.AnaMode.ESD
    else:
        print "Error: mode has to be either ESD or AOD!"
        exit(1)

    print("{0} analysis chosen.".format(config["mode"]))
    print("Setting local analysis for {0} files from list {1} max events = {2}".format(nFiles, config["file_list"], nEvents))

    # Analysis manager
    mgr = ROOT.AliAnalysisManager(taskName)

    helperFunctions.LoadMacros()

    if mode is helperFunctions.AnaMode.AOD:
        helperFunctions.AddAODHandler()
    elif mode is helperFunctions.AnaMode.ESD:
        helperFunctions.AddESDHandler()

    # task = helperFunctions.AddTaskCDBConnect()
    # task.SetFallBackToRaw(True)

    # Physics selection task
    if not config["MC"]:
        ROOT.AddTaskPhysicsSelection()

    if config["cent_type"] == "new":
        ROOT.AddTaskMultSelection(False)
    elif config["cent_type"] == "old":
        print("Not configured for old centrality framework!")
        return

    if config["full_jets"]:
        helperFunctions.PrepareEMCAL("userQAconfiguration.yaml")

    if config["MC"]:
        print "Running on a MC production"
    else:
        print "Running on data"

    # PID response
    helperFunctions.AddTaskPIDResponse(config["MC"], True, True, config["reco_pass"])

    if config["full_jets"]:
        pSpectraTask = ROOT.AddTaskEmcalJetQA("usedefault", "usedefault", "usedefault")
        pSpectraTask.SetNeedEmcalGeom(True)
    else:
        pSpectraTask = ROOT.AddTaskEmcalJetQA("usedefault", "", "")
        pSpectraTask.SetNeedEmcalGeom(False)

    pSpectraTask.SelectCollisionCandidates(physSel)
    pSpectraTask.SetPtBin(1, 150)
    if config["beam_type"] == "PbPb": pSpectraTask.SetCentRange(0, 90)

    if config["ue_sub"]:
        pKtChJetTask = ROOT.AddTaskEmcalJet("usedefault", "", ROOT.AliJetContainer.kt_algorithm, 0.4, ROOT.AliJetContainer.kChargedJet, 0.15, 0., 0.005, ROOT.AliJetContainer.pt_scheme, "Jet", 0., False, False)
        pKtChJetTask.SelectCollisionCandidates(physSel)

        pChJetTask = ROOT.AddTaskEmcalJet("usedefault", "", ROOT.AliJetContainer.antikt_algorithm, 0.4, ROOT.AliJetContainer.kChargedJet, 0.15, 0., 0.005, ROOT.AliJetContainer.pt_scheme, "Jet", 0., False, False)
        pChJetTask.SelectCollisionCandidates(physSel)

        pRhoTask = ROOT.AliAnalysisTaskRhoDev.AddTaskRhoDev("usedefault", 0.15, "", 0.30, "Rho", 0.4, ROOT.AliEmcalJet.kTPCfid, ROOT.AliJetContainer.kChargedJet, True)
        pRhoTask.SelectCollisionCandidates(physSel)
        pRhoTask.SetVzRange(-10, 10)
        pRhoTask.SetEventSelectionAfterRun(True)
        jetCont = ROOT.AliJetContainer(ROOT.AliJetContainer.kChargedJet, ROOT.AliJetContainer.kt_algorithm, ROOT.AliJetContainer.pt_scheme, 0.4, pRhoTask.GetParticleContainer("tracks"), 0)
        jetCont.SetJetPtCut(1)
        jetCont.SetJetAcceptanceType(ROOT.AliEmcalJet.kTPCfid)
        jetCont.SetName("Signal")
        pRhoTask.AdoptJetContainer(jetCont)
        if config["beam_type"] == "pp":
            pRhoTask.SetRhoSparse(True)
        elif config["beam_type"] == "PbPb":
            pRhoTask.SetRhoSparse(False)
        elif config["beam_type"] == "pPb":
            pRhoTask.SetRhoSparse(True)

        pRhoExclLeadJetsTask = ROOT.AliAnalysisTaskRhoDev.AddTaskRhoDev("usedefault", 0.15, "", 0.30, "RhoExclLeadJets", 0.4, ROOT.AliEmcalJet.kTPCfid, ROOT.AliJetContainer.kChargedJet, True)
        pRhoExclLeadJetsTask.SelectCollisionCandidates(physSel)
        pRhoExclLeadJetsTask.SetVzRange(-10, 10)
        pRhoExclLeadJetsTask.SetEventSelectionAfterRun(True)
        pRhoExclLeadJetsTask.SetExcludeLeadJets(2)
        jetCont = ROOT.AliJetContainer(ROOT.AliJetContainer.kChargedJet, ROOT.AliJetContainer.kt_algorithm, ROOT.AliJetContainer.pt_scheme, 0.4, pRhoExclLeadJetsTask.GetParticleContainer("tracks"), 0)
        jetCont.SetJetPtCut(1)
        jetCont.SetJetAcceptanceType(ROOT.AliEmcalJet.kTPCfid)
        jetCont.SetName("Signal")
        pRhoExclLeadJetsTask.AdoptJetContainer(jetCont)
        if config["beam_type"] == "pp":
            pRhoExclLeadJetsTask.SetRhoSparse(True)
        elif config["beam_type"] == "PbPb":
            pRhoExclLeadJetsTask.SetRhoSparse(False)
        elif config["beam_type"] == "pPb":
            pRhoExclLeadJetsTask.SetRhoSparse(True)

        pRhoTransTask = ROOT.AliAnalysisTaskRhoTransDev.AddTaskRhoTransDev("usedefault", 0.15, "", 0.30, "RhoTrans", 0.4, ROOT.AliEmcalJet.kTPCfid, ROOT.AliJetContainer.kChargedJet, True)
        pRhoTransTask.SelectCollisionCandidates(physSel)
        pRhoTransTask.SetVzRange(-10, 10)
        pRhoTransTask.SetEventSelectionAfterRun(True)

        pUEstudies = ROOT.AliAnalysisTaskJetUEStudies.AddTaskJetUEStudies("usedefault", "", 0.15, 0.30)
        jetCont = pUEstudies.AddJetContainer(ROOT.AliJetContainer.kChargedJet, ROOT.AliJetContainer.antikt_algorithm, ROOT.AliJetContainer.pt_scheme, 0.4, ROOT.AliJetContainer.kTPCfid, "tracks", "")
        jetCont.SetRhoName("Rho")
        pUEstudies.AddAltRho("RhoTrans")
        pUEstudies.AddAltRho("RhoExclLeadJets")

        if config["MC"]:
            pGenKtChJetTask = ROOT.AddTaskEmcalJet("mcparticles", "", ROOT.AliJetContainer.kt_algorithm, 0.4, ROOT.AliJetContainer.kChargedJet, 0., 0., 0.005, ROOT.AliJetContainer.pt_scheme, "Jet", 0., False, False)
            pGenKtChJetTask.SelectCollisionCandidates(physSel)

            pGenChJetTask = ROOT.AddTaskEmcalJet("mcparticles", "", ROOT.AliJetContainer.antikt_algorithm, 0.4, ROOT.AliJetContainer.kChargedJet, 0., 0., 0.005, ROOT.AliJetContainer.pt_scheme, "Jet", 0., False, False)
            pGenChJetTask.SelectCollisionCandidates(physSel)

            pGenRhoTask = ROOT.AliAnalysisTaskRhoDev.AddTaskRhoDev("mcparticles", 0, "", 0, "RhoGen", 0.4, ROOT.AliEmcalJet.kTPCfid, ROOT.AliJetContainer.kChargedJet, True)
            pGenRhoTask.SelectCollisionCandidates(physSel)
            pGenRhoTask.SetVzRange(-10, 10)
            pGenRhoTask.SetEventSelectionAfterRun(True)
            jetCont = ROOT.AliJetContainer(ROOT.AliJetContainer.kChargedJet, ROOT.AliJetContainer.kt_algorithm, ROOT.AliJetContainer.pt_scheme, 0.4, pGenRhoTask.GetParticleContainer("mcparticles"), 0)
            jetCont.SetJetPtCut(1)
            jetCont.SetJetAcceptanceType(ROOT.AliEmcalJet.kTPCfid)
            jetCont.SetName("Signal")
            pGenRhoTask.AdoptJetContainer(jetCont)
            if config["beam_type"] == "pp":
                pGenRhoTask.SetRhoSparse(True)
            elif config["beam_type"] == "PbPb":
                pGenRhoTask.SetRhoSparse(False)
            elif config["beam_type"] == "pPb":
                pGenRhoTask.SetRhoSparse(True)

            pGenRhoExclLeadJetsTask = ROOT.AliAnalysisTaskRhoDev.AddTaskRhoDev("mcparticles", 0, "", 0, "RhoExclLeadJetsGen", 0.4, ROOT.AliEmcalJet.kTPCfid, ROOT.AliJetContainer.kChargedJet, True)
            pGenRhoExclLeadJetsTask.SelectCollisionCandidates(physSel)
            pGenRhoExclLeadJetsTask.SetVzRange(-10, 10)
            pGenRhoExclLeadJetsTask.SetEventSelectionAfterRun(True)
            pGenRhoExclLeadJetsTask.SetExcludeLeadJets(2)
            jetCont = ROOT.AliJetContainer(ROOT.AliJetContainer.kChargedJet, ROOT.AliJetContainer.kt_algorithm, ROOT.AliJetContainer.pt_scheme, 0.4, pGenRhoExclLeadJetsTask.GetParticleContainer("mcparticles"), 0)
            jetCont.SetJetPtCut(1)
            jetCont.SetJetAcceptanceType(ROOT.AliEmcalJet.kTPCfid)
            jetCont.SetName("Signal")
            pGenRhoExclLeadJetsTask.AdoptJetContainer(jetCont)
            if config["beam_type"] == "pp":
                pGenRhoExclLeadJetsTask.SetRhoSparse(True)
            elif config["beam_type"] == "PbPb":
                pGenRhoExclLeadJetsTask.SetRhoSparse(False)
            elif config["beam_type"] == "pPb":
                pGenRhoExclLeadJetsTask.SetRhoSparse(True)

            pRhoGenTransTask = ROOT.AliAnalysisTaskRhoTransDev.AddTaskRhoTransDev("mcparticles", 0, "", 0, "RhoTransGen", 0.4, ROOT.AliEmcalJet.kTPCfid, ROOT.AliJetContainer.kChargedJet, True)
            pRhoGenTransTask.SelectCollisionCandidates(physSel)
            pRhoGenTransTask.SetVzRange(-10, 10)
            pRhoGenTransTask.SetEventSelectionAfterRun(True)

            pUEstudies = ROOT.AliAnalysisTaskJetUEStudies.AddTaskJetUEStudies("mcparticles", "", 0., 0., "gen")
            jetCont = pUEstudies.AddJetContainer(ROOT.AliJetContainer.kChargedJet, ROOT.AliJetContainer.antikt_algorithm, ROOT.AliJetContainer.pt_scheme, 0.4, ROOT.AliJetContainer.kTPCfid, "mcparticles", "")
            jetCont.SetRhoName("RhoGen")
            pUEstudies.AddAltRho("RhoTransGen")
            pUEstudies.AddAltRho("RhoExclLeadJetsGen")
            pUEstudies.SetMaxMomentumThridJet(15)
            pUEstudies.SetBackToBackJetPtFraction(0.8)

    if not noInclusiveJets:
        # Charged jet analysis
        if config["charged_jets"]:
            pChJetTask = ROOT.AddTaskEmcalJet("usedefault", "", ROOT.AliJetContainer.antikt_algorithm, 0.4, ROOT.AliJetContainer.kChargedJet, 0.15, 0., 0.005, ROOT.AliJetContainer.pt_scheme, "Jet", 0., False, False)
            pChJetTask.SelectCollisionCandidates(physSel)

            # pChJetTask = ROOT.AddTaskEmcalJet("usedefault", "", 1, 0.6, ROOT.AliJetContainer.kChargedJet, 0.15, 0., 0.005, ROOT.AliJetContainer.pt_scheme, "Jet", 0., False, False)
            # pChJetTask.SelectCollisionCandidates(physSel)

            if config["MC"]:
                pGenChJetTask = ROOT.AddTaskEmcalJet("mcparticles", "", ROOT.AliJetContainer.antikt_algorithm, 0.4, ROOT.AliJetContainer.kChargedJet, 0., 0., 0.005, ROOT.AliJetContainer.pt_scheme, "Jet", 0., False, False)
                pGenChJetTask.SelectCollisionCandidates(physSel)

        # Full jet analysis
        if config["full_jets"]:
            pJetTask = ROOT.AddTaskEmcalJet("usedefault", "usedefault", ROOT.AliJetContainer.antikt_algorithm, 0.2, ROOT.AliJetContainer.kFullJet, 0.15, 0.30, 0.005, ROOT.AliJetContainer.pt_scheme, "Jet", 0., False, False)
            pJetTask.SelectCollisionCandidates(physSel)

            # pJetTask = ROOT.AddTaskEmcalJet("usedefault", "usedefault", 1, 0.4, ROOT.AliJetContainer.kFullJet, 0.15, 0.30, 0.005, ROOT.AliJetContainer.pt_scheme, "Jet", 0., False, False)
            # pJetTask.SelectCollisionCandidates(physSel)

            if config["MC"]:
                pGenJetTask = ROOT.AddTaskEmcalJet("mcparticles", "", ROOT.AliJetContainer.antikt_algorithm, 0.4, ROOT.AliJetContainer.kFullJet, 0., 0., 0.005, ROOT.AliJetContainer.pt_scheme, "Jet", 0., False, False)
                pGenJetTask.SelectCollisionCandidates(physSel)

        ROOT.AliAnalysisManager.SetCommonFileName("AnalysisResults_jets.root")
        if config["full_jets"]:
            if config["ue_sub"]:
                anaType = ROOT.AliAnalysisTaskEmcalJetTreeBase.kJetPbPb
                rhoName = "Rho"
                rhoGenName = "RhoGen"
            else:
                anaType = ROOT.AliAnalysisTaskEmcalJetTreeBase.kJetPP
                rhoName = ""
                rhoGenName = ""
            pJetSpectraTask = ROOT.AliAnalysisTaskEmcalJetTreeBase.AddTaskEmcalJetTree("usedefault", "usedefault", 0.15, 0.30, anaType)
            pJetSpectraTask.SetNeedEmcalGeom(True)
        else:
            if config["ue_sub"]:
                anaType = ROOT.AliAnalysisTaskEmcalJetTreeBase.kJetPbPbCharged
                rhoName = "Rho"
                rhoGenName = "RhoGen"
            else:
                anaType = ROOT.AliAnalysisTaskEmcalJetTreeBase.kJetPPCharged
                rhoName = ""
                rhoGenName = ""
            pJetSpectraTask = ROOT.AliAnalysisTaskEmcalJetTreeBase.AddTaskEmcalJetTree("usedefault", "", 0.15, 0.30, anaType)
            pJetSpectraTask.SetNeedEmcalGeom(False)
        ROOT.AliAnalysisManager.SetCommonFileName("AnalysisResults.root")

        if config["MC"]:
            partCont = pJetSpectraTask.AddParticleContainer("mcparticles")
            partCont.SetMinPt(0)
        pJetSpectraTask.SelectCollisionCandidates(physSel)
        if config["beam_type"] == "PbPb": pJetSpectraTask.SetCentRange(0, 90)

        if config["charged_jets"]:
            jetCont = pJetSpectraTask.AddJetContainer(ROOT.AliJetContainer.kChargedJet, ROOT.AliJetContainer.antikt_algorithm, ROOT.AliJetContainer.pt_scheme, 0.4, ROOT.AliJetContainer.kTPCfid, "tracks", "")
            jetCont.SetRhoName(rhoName)
            # jetCont = pJetSpectraTask.AddJetContainer(ROOT.AliJetContainer.kChargedJet, ROOT.AliJetContainer.antikt_algorithm, ROOT.AliJetContainer.pt_scheme, 0.6, ROOT.AliJetContainer.kTPCfid)
            # jetCont.SetRhoName(rhoName)
            if config["MC"]:
                jetCont = pJetSpectraTask.AddJetContainer(ROOT.AliJetContainer.kChargedJet, ROOT.AliJetContainer.antikt_algorithm, ROOT.AliJetContainer.pt_scheme, 0.4, ROOT.AliJetContainer.kTPCfid, "mcparticles", "")
                jetCont.SetRhoName(rhoGenName)

        if config["full_jets"]:
            jetCont = pJetSpectraTask.AddJetContainer(ROOT.AliJetContainer.kFullJet, ROOT.AliJetContainer.antikt_algorithm, ROOT.AliJetContainer.pt_scheme, 0.2, ROOT.AliJetContainer.kEMCALfid, "tracks", "caloClusters")
            jetCont.SetRhoName(rhoName)
            # jetCont = pJetSpectraTask.AddJetContainer(ROOT.AliJetContainer.kFullJet, ROOT.AliJetContainer.antikt_algorithm, ROOT.AliJetContainer.pt_scheme, 0.4, ROOT.AliJetContainer.kEMCALfid)
            # jetCont.SetRhoName(rhoName)
            if config["MC"]:
                jetCont = pJetSpectraTask.AddJetContainer(ROOT.AliJetContainer.kFullJet, ROOT.AliJetContainer.antikt_algorithm, ROOT.AliJetContainer.pt_scheme, 0.4, ROOT.AliJetContainer.kTPCfid, "mcparticles", "")
                jetCont.SetRhoName(rhoGenName)

    # ROOT.AddTaskCleanupVertexingHF()

    if d2h: ROOT.AddTaskD0Mass(0, config["MC"], False, False, 0, 0, 0, 0, "Loose", config["rdhf_cuts_dzero"])

    if config["cent_bins"]:
        for cmin, cnmax in zip(config["cent_bins"][:-1], config["cent_bins"][1:]):
            pDMesonJetsTask = AddDMesonJetTask(mgr, config, doRecLevel, doSignalOnly, doMCTruth, doWrongPID, doResponse, cmin, cnmax)
            pDMesonJetsTask.SelectCollisionCandidates(physSel)
            pDMesonJetsTask.SetTrackEfficiency(efficiency)
    else:
        pDMesonJetsTask = AddDMesonJetTask(mgr, config, doRecLevel, doSignalOnly, doMCTruth, doWrongPID, doResponse, None, None)
        pDMesonJetsTask.SelectCollisionCandidates(physSel)
        pDMesonJetsTask.SetTrackEfficiency(efficiency)

    tasks = mgr.GetTasks()
    for task in tasks:
        if isinstance(task, ROOT.AliAnalysisTaskEmcalLight):
            task.SetIsPythia(config["is_pythia"])
            if selectGen: pDMesonJetsTask.SelectGeneratorName(selectGen)
            if config["is_pythia"]: task.SetMaxMinimumBiasPtHard(5)
            if config["run_period"] == "LHC15o": task.SetSwitchOffLHC15oFaultyBranches(True)
            if config["beam_type"] == "pp":
                task.SetForceBeamType(ROOT.AliAnalysisTaskEmcalLight.kpp)
            elif config["beam_type"] == "PbPb":
                task.SetForceBeamType(ROOT.AliAnalysisTaskEmcalLight.kAA)
            elif config["beam_type"] == "pPb":
                task.SetForceBeamType(ROOT.AliAnalysisTaskEmcalLight.kpA)
            if config["cent_type"] == "new":
                task.SetCentralityEstimation(ROOT.AliAnalysisTaskEmcalLight.kNewCentrality)
            elif config["cent_type"] == "old":
                task.SetCentralityEstimation(ROOT.AliAnalysisTaskEmcalLight.kOldCentrality)
            else:
                task.SetCentralityEstimation(ROOT.AliAnalysisTaskEmcalLight.kNoCentrality)

        if isinstance(task, ROOT.AliAnalysisTaskEmcal):
            if config["beam_type"] == "pp":
                task.SetForceBeamType(ROOT.AliAnalysisTaskEmcal.kpp)
            elif config["beam_type"] == "PbPb":
                task.SetForceBeamType(ROOT.AliAnalysisTaskEmcal.kAA)
                task.SetUseNewCentralityEstimation(True)

    res = mgr.InitAnalysis()

    if not res:
        print "Error initializing the analysis!"
        exit(1)

    mgr.PrintStatus()

    outFile = ROOT.TFile("train.root", "RECREATE")
    outFile.cd()
    mgr.Write()
    outFile.Close()

    chain = None
    if mode is helperFunctions.AnaMode.AOD:
        ROOT.gROOT.LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/CreateAODChain.C")
        chain = ROOT.CreateAODChain(config["file_list"], nFiles, 0, False , "AliAOD.VertexingHF.root")
    elif mode is helperFunctions.AnaMode.ESD:
        ROOT.gROOT.LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/CreateESDChain.C");
        chain = ROOT.CreateESDChain(config["file_list"], nFiles, 0, False)

    if debugLevel == 0:
        mgr.SetUseProgressBar(1, 250)
    else:
        # To have more debug info
        mgr.AddClassDebug("AliAnalysisTaskDmesonJets", ROOT.AliLog.kDebug + 100)
        mgr.AddClassDebug("AliAnalysisTaskDmesonJets::AnalysisEngine", ROOT.AliLog.kDebug + 100)

    mgr.SetDebugLevel(debugLevel)

    # start analysis
    print "Starting Analysis..."
    mgr.StartAnalysis("local", chain, nEvents)
コード例 #2
0
def AddTriggerQATasks(config, trigger, physSel):

    if config["track_qa"] and config["cluster_qa"]:
        pJetQATask = ROOT.AddTaskEmcalJetQA("usedefault", "usedefault",
                                            "usedefault", trigger["label"])
        pJetQATask.SetNeedEmcalGeom(True)
    elif config["cluster_qa"]:
        pJetQATask = ROOT.AddTaskEmcalJetQA("", "usedefault", "usedefault",
                                            trigger["label"])
        pJetQATask.SetNeedEmcalGeom(True)
    elif config["track_qa"]:
        pJetQATask = ROOT.AddTaskEmcalJetQA("", "usedefault", "usedefault",
                                            trigger["label"])

    if config["track_qa"] or config["cluster_qa"]:
        if trigger.has_key("accept"):
            for acc in trigger["accept"]:
                pJetQATask.AddAcceptedTriggerClass(acc)
        if trigger.has_key("reject"):
            for rej in trigger["reject"]:
                pJetQATask.AddRejectedTriggerClass(rej)
        pJetQATask.SelectCollisionCandidates(physSel)
        pJetQATask.SetPtBin(1, 150)

    # Trigger QA
    if config["trigger_qa"]:
        if config["run_period"] == "LHC16q":
            pTriggerQATask = ROOT.AddTaskEmcalTriggerQA(
                "EmcalTriggers", "", "", ROOT.AliAnalysisTaskEmcalLight.kpp,
                False, trigger["label"])
            pTriggerQATask.EnableDCal(True)
        elif config["run_period"] == "LHC16d" or config[
                "run_period"] == "LHC16e" or config["run_period"] == "LHC16f":
            pTriggerQATask = ROOT.AddTaskEmcalTriggerQA(
                "EmcalTriggers", "", "", ROOT.AliAnalysisTaskEmcalLight.kpp,
                False, trigger["label"])
            pTriggerQATask.EnableDCal(True)
        elif config["run_period"] == "LHC16c":
            pTriggerQATask = ROOT.AddTaskEmcalTriggerQA(
                "EmcalTriggers", "", "", ROOT.AliAnalysisTaskEmcalLight.kpp,
                False, trigger["label"])
            pTriggerQATask.EnableDCal(True)
        elif config["run_period"] == "LHC16b":
            pTriggerQATask = ROOT.AddTaskEmcalTriggerQA(
                "EmcalTriggers", "", "", ROOT.AliAnalysisTaskEmcalLight.kpp,
                False, trigger["label"])
            pTriggerQATask.EnableDCal(True)
        elif config["run_period"] == "LHC15o":
            pTriggerQATask = ROOT.AddTaskEmcalTriggerQA(
                "EmcalTriggers", "", "", ROOT.AliAnalysisTaskEmcalLight.kAA,
                True, trigger["label"])
            pTriggerQATask.SetUseNewCentralityEstimation(True)
            pTriggerQATask.EnableDCal(True)
        elif config["run_period"] == "LHC15j":
            pTriggerQATask = ROOT.AddTaskEmcalTriggerQA(
                "EmcalTriggers", "", "", ROOT.AliAnalysisTaskEmcalLight.kpp,
                False, trigger["label"])
            pTriggerQATask.EnableDCal(True)
        elif config["run_period"].startswith("LHC13"):
            pTriggerQATask = ROOT.AddTaskEmcalTriggerQA(
                "EmcalTriggers", "", "", ROOT.AliAnalysisTaskEmcalLight.kpp,
                False, trigger["label"])
            pTriggerQATask.EnableDCal(False)
        elif config["run_period"].startswith("LHC12"):
            pTriggerQATask = ROOT.AddTaskEmcalTriggerQA(
                "EmcalTriggers", "", "", ROOT.AliAnalysisTaskEmcalLight.kpp,
                False, trigger["label"])
            pTriggerQATask.EnableDCal(False)
        elif config["run_period"] == "LHC11h":
            pTriggerQATask = ROOT.AddTaskEmcalTriggerQA(
                "EmcalTriggers", "", "", ROOT.AliAnalysisTaskEmcalLight.kAA,
                True, trigger["label"])
            pTriggerQATask.EnableDCal(False)
        elif config["run_period"].startswith(
                "LHC11") and config["run_period"] != "LHC11h":
            pTriggerQATask = ROOT.AddTaskEmcalTriggerQA(
                "EmcalTriggers", "", "", ROOT.AliAnalysisTaskEmcalLight.kpp,
                False, trigger["label"])
            pTriggerQATask.EnableDCal(False)

        if trigger.has_key("accept"):
            for acc in trigger["accept"]:
                pTriggerQATask.AddAcceptedTriggerClass(acc)
        if trigger.has_key("reject"):
            for rej in trigger["reject"]:
                pTriggerQATask.AddRejectedTriggerClass(rej)

        if config.has_key("bad_fastor"):
            pTriggerQATask.GetTriggerQA().ReadFastORBadChannelFromFile(
                config["bad_fastor"])
        # pTriggerQATask.EnableHistogramsByTimeStamp(120)
        pTriggerQATask.SetADCperBin(8)
        pTriggerQATask.SetMinAmplitude(0)
        pTriggerQATask.SelectCollisionCandidates(physSel)

    if config["charged_jets"] or config["full_jets"] or config["neutral_jets"]:
        pSpectraTask = ROOT.AddTaskEmcalJetSpectraQA("usedefault",
                                                     "usedefault", 0.15, 0.30,
                                                     trigger["label"])
        pSpectraTask.SelectCollisionCandidates(physSel)
        pSpectraTask.SetPtBin(1, 250)
        if trigger.has_key("accept"):
            for acc in trigger["accept"]:
                pSpectraTask.AddAcceptedTriggerClass(acc)
        if trigger.has_key("reject"):
            for rej in trigger["reject"]:
                pSpectraTask.AddRejectedTriggerClass(rej)

    if config["charged_jets"]:
        pSpectraTask.AddJetContainer(ROOT.AliJetContainer.kChargedJet,
                                     ROOT.AliJetContainer.antikt_algorithm,
                                     ROOT.AliJetContainer.pt_scheme, 0.4,
                                     ROOT.AliJetContainer.kTPCfid)
        pSpectraTask.AddJetContainer(ROOT.AliJetContainer.kChargedJet,
                                     ROOT.AliJetContainer.antikt_algorithm,
                                     ROOT.AliJetContainer.pt_scheme, 0.6,
                                     ROOT.AliJetContainer.kTPCfid)

    if config["full_jets"]:
        pSpectraTask.AddJetContainer(ROOT.AliJetContainer.kFullJet,
                                     ROOT.AliJetContainer.antikt_algorithm,
                                     ROOT.AliJetContainer.pt_scheme, 0.2,
                                     ROOT.AliJetContainer.kEMCALfid)
        pSpectraTask.AddJetContainer(ROOT.AliJetContainer.kFullJet,
                                     ROOT.AliJetContainer.antikt_algorithm,
                                     ROOT.AliJetContainer.pt_scheme, 0.4,
                                     ROOT.AliJetContainer.kEMCALfid)

    if config["neutral_jets"]:
        jetCont = pSpectraTask.AddJetContainer(
            ROOT.AliJetContainer.kNeutralJet,
            ROOT.AliJetContainer.antikt_algorithm,
            ROOT.AliJetContainer.pt_scheme, 0.2,
            ROOT.AliJetContainer.kEMCALfid)
        jetCont.SetLeadingHadronType(1)
        jetCont = pSpectraTask.AddJetContainer(
            ROOT.AliJetContainer.kNeutralJet,
            ROOT.AliJetContainer.antikt_algorithm,
            ROOT.AliJetContainer.pt_scheme, 0.4,
            ROOT.AliJetContainer.kEMCALfid)
        jetCont.SetLeadingHadronType(1)