HIJetRecConfigCA Namespace Reference

Functions
def	HIClusterMakerCfg (flags, save=False, **kwargs)
def	HIClusterCopierCfg (flags, save=False, **kwargs)
def	HICaloJetInputConstitSeq (flags, name="HICaloConstit", **kwargs)
def	HICaloJetDef (flags, jetradius, **kwargs)
def	HITrackJetInputConstit (flags, name="HITrack", **kwargs)
def	HITrackJetDef (flags, jetradius, **kwargs)
def	HIPseudoJetAlgCfg (flags, **kwargs)
def	HIPseudoTrackJetAlgCfg (flags, name="TrackPseudoJets", **kwargs)
def	HIJetClustererCfg (flags, name="builder", jetDef=None, **kwargs)
def	HIJetAlgCfg (flags, jetDef, **kwargs)
def	HIJetCopierCfg (flags, name="builder_copy", **kwargs)
def	HIJetCopyAlgCfg (flags, jetDef_in, jetDef, **kwargs)
def	updateStdJetModifier (flags, name, **kwargs)
def	HIJetDefCloner (flags, jetDef_in, **kwargs)
def	NullModulatorCfg ()
def	HIModulatorCfg (flags, mod_key, suffix=None, **kwargs)
def	HIJetClusterSubtractorCfg (flags, name="HIJetClusterSubtractor", **kwargs)
def	HIJetCellSubtractorCfg (flags, name="HIJetCellSubtractor", **kwargs)
def	HIJetSubtractorCfg (flags, useClusters, **kwargs)
def	HIEventShapeJetIterationCfg (flags, suffix=None, useClusters=True, **kwargs)
def	HITrackSelAlgCfg (flags, name="TrackSelAlgHI", **kwargs)
def	HICaloClusterMomentsCfg (flags, name="HIClusterMoments", **kwargs)
def	HISubtractionToCellsCfg (flags, name="HIClusterSubtraction", **kwargs)
def	HISubtractionToClustersCfg (flags, name="HIClusterSubtraction", useClusters=True, **kwargs)
def	HIJetRecCfg (flags)
def	getHIJetRecAlg (jetdef, jetsName)

Variables
	__log = logging.getLogger('HIJetRecConfigCA')
	flags = initConfigFlags()
	Files
	AtlasVersion
	GlobalTag
	MaxEvents
	NumThreads
	strictMode
	python -m HIRecConfig.HIRecConfig HeavyIon.doGlobal="False" GeoModel.AtlasVersion="ATLAS-R3S-2021-03-01-00" More...
	acc = MainServicesCfg(flags)
	EMjet = AntiKt4EMTopo.clone()
	ghostdefs
	withDetails
	True
	summariseProps

Function Documentation

getHIJetRecAlg()

def HIJetRecConfigCA.getHIJetRecAlg	(		jetdef,
			jetsName
	)

Returns the configured HIJetRecAlg instance corresponding to jetdef

IMPORTANT : jetdef must have its dependencies solved (i.e. it must result from solveDependencies() )

Definition at line 754 of file HIJetRecConfigCA.py.

def getHIJetRecAlg( jetdef, jetsName):
    """Returns the configured HIJetRecAlg instance corresponding to jetdef
 
    IMPORTANT : jetdef must have its dependencies solved (i.e. it must result from solveDependencies() )
    """
    pjContNames = jetdef._internalAtt['finalPJContainer']
    jclust = CompFactory.JetClusterer(
        "builder",
        JetAlgorithm = jetdef.algorithm,
        JetRadius = jetdef.radius,
        PtMin = jetdef.ptmin,
        InputPseudoJets = pjContNames,
        GhostArea = 0.0,
        JetInputType = int(jetdef.inputdef.jetinputtype),
        RandomOption = 1,
    )
 
    mods = JetRecConfig.getJetModifierTools(jetdef)
 
    jetname = jetsName
    jra = CompFactory.JetRecAlg(
        "jetrecalg_"+jetname,
        Provider = jclust,
        Modifiers = mods,
        OutputContainer = jetname,
        )
    jra.ExtraOutputs = [('xAOD::JetContainer',f'{jetname}.Ghost{ghost}') for ghost in jetdef.ghostdefs]
 
    return jra
 
 

HICaloClusterMomentsCfg()

def HIJetRecConfigCA.HICaloClusterMomentsCfg	(		flags,
			name = "HIClusterMoments",
		**	kwargs
	)

Provides tool for cluster moments.

Definition at line 464 of file HIJetRecConfigCA.py.

def HICaloClusterMomentsCfg(flags, name="HIClusterMoments", **kwargs):
    """Provides tool for cluster moments."""
    acc = ComponentAccumulator()
 
    kwargs.setdefault("MinBadLArQuality", 4000)
    kwargs.setdefault("MomentsNames", ["CENTER_MAG",
                                       "LONGITUDINAL",
                                       "FIRST_ENG_DENS",
                                       "SECOND_ENG_DENS",
                                       "ENG_FRAC_EM",
                                       "ENG_FRAC_MAX",
                                       "ENG_FRAC_CORE",
                                       "ENG_BAD_CELLS",
                                       "N_BAD_CELLS",
                                       "N_BAD_CELLS_CORR",
                                       "BAD_CELLS_CORR_E",
                                       "BADLARQ_FRAC",
                                       "ENG_POS",
                                       "SIGNIFICANCE",
                                       "CELL_SIGNIFICANCE",
                                       "CELL_SIG_SAMPLING",
                                       "AVG_LAR_Q",
                                       "AVG_TILE_Q",
                                       "ENG_BAD_HV_CELLS",
                                       "N_BAD_HV_CELLS"])
 
    acc.setPrivateTools(CompFactory.CaloClusterMomentsMaker(name, **kwargs))
    return acc
 
 

HICaloJetDef()

def HIJetRecConfigCA.HICaloJetDef	(		flags,
			jetradius,
		**	kwargs
	)

Returns jet definition for calo jets, with already resolved dependencies.

Definition at line 77 of file HIJetRecConfigCA.py.

def HICaloJetDef(flags, jetradius, **kwargs):
    """Returns jet definition for calo jets, with already resolved dependencies."""
 
    ptmin_dict = {2:7000, 3:7000, 4:7000, 6:7000, 10:50000}
    if jetradius not in ptmin_dict and "ptmin" not in kwargs:
        __log.warning("jetradius "+str(jetradius)+" is not in the dictionary for ptmin; setting ptmin to 7000")
    kwargs.setdefault("ptmin", ptmin_dict.get(jetradius, 7000))
    kwargs.setdefault("radius", float(jetradius)/10.)
    kwargs.setdefault("inputdef", HICaloJetInputConstitSeq(flags))
    kwargs.setdefault("algorithm", "AntiKt")
    kwargs.setdefault("prefix", "")
    kwargs.setdefault("suffix", "")
 
    return solveDependencies(JetDefinition(**kwargs), flags)
 
 

HICaloJetInputConstitSeq()

def HIJetRecConfigCA.HICaloJetInputConstitSeq	(		flags,
			name = "HICaloConstit",
		**	kwargs
	)

Definition at line 62 of file HIJetRecConfigCA.py.

def HICaloJetInputConstitSeq(flags, name="HICaloConstit", **kwargs):
    kwargs.setdefault("objtype", xAODType.CaloCluster)
    kwargs.setdefault("modifiers", [])
    kwargs.setdefault("inputname", flags.HeavyIon.Jet.Internal.ClusterKey)
    kwargs.setdefault("outputname", flags.HeavyIon.Jet.Internal.ClusterKey)
    kwargs.setdefault("label", "HI")
 
    jetConstit = JetInputConstitSeq(name, **kwargs)
 
    from JetRecConfig.StandardJetConstits import stdConstitDic
    stdConstitDic.setdefault(name, jetConstit)
 
    return jetConstit
 
 

HIClusterCopierCfg()

def HIJetRecConfigCA.HIClusterCopierCfg	(		flags,
			save = False,
		**	kwargs
	)

Function to copy HI clusters to modify them in derivations.

Definition at line 48 of file HIJetRecConfigCA.py.

def HIClusterCopierCfg(flags, save=False, **kwargs):
    """Function to copy HI clusters to modify them in derivations."""
 
    acc = ComponentAccumulator()
 
    kwargs.setdefault("InputContainerKey", "HIClusters")
    kwargs.setdefault("OutputContainerKey", flags.HeavyIon.Jet.Internal.ClusterKey)
 
    HIClusterCopier = CompFactory.HIClusterCopier("HIClusterCopier",
                                                  **kwargs)
 
    acc.addEventAlgo(HIClusterCopier, primary=True)
    return acc
 

HIClusterMakerCfg()

def HIJetRecConfigCA.HIClusterMakerCfg	(		flags,
			save = False,
		**	kwargs
	)

Function to equip HI cluster builder from towers and cells, adds to output AOD stream.

Definition at line 20 of file HIJetRecConfigCA.py.

def HIClusterMakerCfg(flags, save=False, **kwargs):
    """Function to equip HI cluster builder from towers and cells, adds to output AOD stream."""
 
    acc = ComponentAccumulator()
 
    kwargs.setdefault("CaloCellContainerKey", "AllCalo")
    kwargs.setdefault("OutputContainerKey", flags.HeavyIon.Jet.Internal.ClusterKey)
 
    # get towers
    from CaloRec.CaloRecoConfig import CaloRecoCfg
    acc.merge(CaloRecoCfg(flags))
    from CaloRec.CaloTowerMakerConfig import CaloTowerMakerCfg
    towerMaker = acc.getPrimaryAndMerge(CaloTowerMakerCfg(flags))
    tower_key = towerMaker.TowerContainerName
 
    HIClusterMaker = CompFactory.HIClusterMaker("HIClusterMaker",
                                                InputTowerKey=tower_key,
                                                **kwargs)
 
    if save:
        output = ["xAOD::CaloClusterContainer#"+kwargs["OutputContainerKey"],
                  "xAOD::CaloClusterAuxContainer#"+kwargs["OutputContainerKey"]+"Aux."]
        acc.merge(addToESD(flags, output))
        acc.merge(addToAOD(flags, output))
 
    acc.addEventAlgo(HIClusterMaker, primary=True)
    return acc
 

HIEventShapeJetIterationCfg()

def HIJetRecConfigCA.HIEventShapeJetIterationCfg	(		flags,
			suffix = None,
			useClusters = True,
		**	kwargs
	)

Provides tool for event shape iteration.
   Also saves some tool, so they can be used later.

Definition at line 405 of file HIJetRecConfigCA.py.

def HIEventShapeJetIterationCfg(flags, suffix=None, useClusters=True, **kwargs):
    """Provides tool for event shape iteration.
       Also saves some tool, so they can be used later."""
    acc = ComponentAccumulator()
 
    kwargs.setdefault("InputEventShapeKey", "HIEventShape_Weighted")
    kwargs.setdefault("CaloJetSeedContainerKey", "")
 
    out_shape_name = kwargs["InputEventShapeKey"]
    if suffix is not None:
        out_shape_name += '_'+suffix
    mod_shape_key = out_shape_name+'_Modulate'
 
    if 'Modulator' not in kwargs:
        modulator = acc.popToolsAndMerge(HIModulatorCfg(
            flags, mod_key=mod_shape_key, suffix=suffix))
        kwargs.setdefault('Modulator', modulator)
    if "Subtractor" not in kwargs:
        sub_tool = acc.popToolsAndMerge(HIJetSubtractorCfg(flags, useClusters))
        kwargs.setdefault("Subtractor", sub_tool)
    if "EventShapeMapTool" not in kwargs:
        map_tool = acc.popToolsAndMerge(HIEventShapeMapToolCfg(flags))
        kwargs.setdefault("EventShapeMapTool", map_tool)
    kwargs.setdefault("OutputEventShapeKey", out_shape_name)
    kwargs.setdefault("AssociationKey", flags.HeavyIon.Jet.Internal.ClusterKey+"_DR8Assoc")
    kwargs.setdefault("ModulationScheme", 1)
    kwargs.setdefault("RemodulateUE", True)
    kwargs.setdefault("ShallowCopy", False)
    kwargs.setdefault("ModulationEventShapeKey", mod_shape_key)
    kwargs.setdefault("TrackJetSeedContainerKey", "")
 
    acc.setPrivateTools(CompFactory.HIEventShapeJetIteration(
        "HIJetIteration_"+out_shape_name, **kwargs))
 
    # save some tools for later
    jm_dict = {"Modulator": kwargs["Modulator"],
               "EventShapeMapTool": kwargs["EventShapeMapTool"],
               "Subtractor": kwargs["Subtractor"],
               "EventShapeKey": kwargs["OutputEventShapeKey"]}
 
    return jm_dict, acc
 
 

HIJetAlgCfg()

def HIJetRecConfigCA.HIJetAlgCfg	(		flags,
			jetDef,
		**	kwargs
	)

Creates a jet reconstruction algorithm.

Definition at line 159 of file HIJetRecConfigCA.py.

def HIJetAlgCfg(flags, jetDef, **kwargs):
    """Creates a jet reconstruction algorithm."""
    acc = ComponentAccumulator()
 
    if "Provider" not in kwargs:
        jclust = acc.popToolsAndMerge(HIJetClustererCfg(flags, jetDef=jetDef))
        kwargs.setdefault("Provider", jclust)
    if "Modifiers" not in kwargs:
        kwargs.setdefault("Modifiers", JetRecConfig.getJetModifierTools(jetDef))
    if "OutputContainer" not in kwargs:
        kwargs.setdefault("OutputContainer", jetDef.fullname())
    kwargs.setdefault("name", "JRA_build"+kwargs["OutputContainer"])
 
    acc.addEventAlgo(CompFactory.JetRecAlg(**kwargs))
    return acc
 
 

HIJetCellSubtractorCfg()

def HIJetRecConfigCA.HIJetCellSubtractorCfg	(		flags,
			name = "HIJetCellSubtractor",
		**	kwargs
	)

Provides tool for cell subtraction.

Definition at line 388 of file HIJetRecConfigCA.py.

def HIJetCellSubtractorCfg(flags, name="HIJetCellSubtractor", **kwargs):
    """Provides tool for cell subtraction."""
    acc = ComponentAccumulator()
 
    acc.setPrivateTools(CompFactory.HIJetCellSubtractorTool(name, **kwargs))
    return acc
 
 

HIJetClustererCfg()

def HIJetRecConfigCA.HIJetClustererCfg	(		flags,
			name = "builder",
			jetDef = None,
		**	kwargs
	)

Creates a tool for clustering.

Definition at line 144 of file HIJetRecConfigCA.py.

def HIJetClustererCfg(flags, name="builder", jetDef=None, **kwargs):
    """Creates a tool for clustering."""
    acc = ComponentAccumulator()
 
    if jetDef is not None:
        kwargs.setdefault("JetAlgorithm", jetDef.algorithm)
        kwargs.setdefault("JetRadius", jetDef.radius)
        kwargs.setdefault("PtMin", jetDef.ptmin)
    kwargs.setdefault("GhostArea", 0.01)
    kwargs.setdefault("InputPseudoJets", "PseudoJet"+flags.HeavyIon.Jet.Internal.ClusterKey+"_GhostTracks")
 
    acc.setPrivateTools(CompFactory.JetClusterer(name, **kwargs))
    return acc
 
 

HIJetClusterSubtractorCfg()

def HIJetRecConfigCA.HIJetClusterSubtractorCfg	(		flags,
			name = "HIJetClusterSubtractor",
		**	kwargs
	)

Provides tool for cluster subtraction.

Definition at line 374 of file HIJetRecConfigCA.py.

def HIJetClusterSubtractorCfg(flags, name="HIJetClusterSubtractor", **kwargs):
    """Provides tool for cluster subtraction."""
    acc = ComponentAccumulator()
 
    kwargs.setdefault("ConfigDir", "HIJetCorrection/")
    kwargs.setdefault("UseSamplings", False)
    if "InputFile" not in kwargs:
        from HIJetRec.HIJetRecUtilsCA import getHIClusterGeoWeightFile
        kwargs.setdefault("InputFile", getHIClusterGeoWeightFile(flags))
 
    acc.setPrivateTools(CompFactory.HIJetClusterSubtractorTool(name, **kwargs))
    return acc
 
 

HIJetCopierCfg()

def HIJetRecConfigCA.HIJetCopierCfg	(		flags,
			name = "builder_copy",
		**	kwargs
	)

Creates a tool to copy jets.

Definition at line 176 of file HIJetRecConfigCA.py.

def HIJetCopierCfg(flags, name="builder_copy", **kwargs):
    """Creates a tool to copy jets."""
    acc = ComponentAccumulator()
 
    kwargs.setdefault("InputJets", "")
    kwargs.setdefault("DecorDeps", [])
    kwargs.setdefault("ShallowCopy", False)
    kwargs.setdefault("ShallowIO", False)
 
    acc.setPrivateTools(CompFactory.JetCopier(name, **kwargs))
    return acc
 
 

HIJetCopyAlgCfg()

def HIJetRecConfigCA.HIJetCopyAlgCfg	(		flags,
			jetDef_in,
			jetDef,
		**	kwargs
	)

Creates an algorithm to copy jets.

Definition at line 189 of file HIJetRecConfigCA.py.

def HIJetCopyAlgCfg(flags, jetDef_in, jetDef, **kwargs):
    """Creates an algorithm to copy jets."""
    acc = ComponentAccumulator()
 
    if "Provider" not in kwargs:
        jcopy = acc.popToolsAndMerge(HIJetCopierCfg(flags, InputJets=jetDef_in.fullname()))
        kwargs.setdefault("Provider", jcopy)
    acc.merge(HIJetAlgCfg(flags, jetDef, **kwargs))
    return acc
 
 

HIJetDefCloner()

def HIJetRecConfigCA.HIJetDefCloner	(		flags,
			jetDef_in,
		**	kwargs
	)

Clones jet definitions based on the template.
   Updates stdJetModifiers if necessary.
   Overwrites suffix and modifiers, and return jet definition with already resolved dependencies.

Definition at line 313 of file HIJetRecConfigCA.py.

def HIJetDefCloner(flags, jetDef_in, **kwargs):
    """Clones jet definitions based on the template.
       Updates stdJetModifiers if necessary.
       Overwrites suffix and modifiers, and return jet definition with already resolved dependencies."""
 
    jetDef_new = jetDef_in.clone()
 
    if "prefix" in kwargs:
        jetDef_new.prefix = kwargs["prefix"]
    if "suffix" in kwargs:
        jetDef_new.suffix = kwargs["suffix"]
    if "modifiers" in kwargs:
        jetDef_new.modifiers = []
        for modifier in kwargs["modifiers"]:
            updateStdJetModifier(flags, modifier, jetDef=jetDef_new)
            jetDef_new.modifiers.append(modifier)
 
    return solveDependencies(jetDef_new,flags)
 
 

HIJetRecCfg()

def HIJetRecConfigCA.HIJetRecCfg

(

flags

)

Configures Heavy Ion Jet reconstruction.

Definition at line 529 of file HIJetRecConfigCA.py.

def HIJetRecCfg(flags):
    """Configures Heavy Ion Jet reconstruction."""
    acc = ComponentAccumulator()
 
    if not flags.HeavyIon.isDerivation:
        # get HIClusters
        acc.merge(HIClusterMakerCfg(flags))
    else:
        # copy HIClusters
        acc.merge(HIClusterCopierCfg(flags))
 
 
    # get weighted event shape
    eventshapeKey = flags.HeavyIon.HIJetPrefix+"HIEventShapeWeighted"
    acc.merge(HIEventShapeMakerCfg(flags,
                                   name="HIEventShapeMaker_Weighted",
                                   doWeighted=True,
                                   InputTowerKey=flags.HeavyIon.Jet.Internal.ClusterKey,
                                   OutputContainerKey=eventshapeKey))
 
    # get jet definition
    # R=0.2 calojets are use as seeds for UE subtraction
    jetDef2 = HICaloJetDef(flags, jetradius=2, prefix=flags.HeavyIon.HIJetPrefix, suffix="_Unsubtracted")
 
    # get jet definitions for physics
    jetDef = []
    jetRlist = flags.HeavyIon.Jet.RValues #Default [0.2,0.4], Others R's should be build in Derivations or pass in preExec
    for jetR in jetRlist:
        jetDef.append(HICaloJetDef(flags, jetradius=jetR, prefix=flags.HeavyIon.HIJetPrefix, suffix="_Unsubtracted"))
        __log.info("HI Jet Collection for Reco: "+jetDef[-1].fullname())
 
    # get calo pseudojets
    acc.merge(HIPseudoJetAlgCfg(flags))
 
    # HIJetTracks are used for GhostTracks association and later to build TrackJets seeds
    pseudoTrkJetCont = "HIJetTracks"
    pseudoGhostTrks = "PseudoJetGhostTracks"
 
    acc.merge(HITrackSelAlgCfg(flags, OutputContainer=pseudoTrkJetCont))
    acc.merge(HIPseudoTrackJetAlgCfg(
        flags, name="GhostTrackPseudoJets", InputContainer=pseudoTrkJetCont, OutputContainer=pseudoGhostTrks, Label="GhostTrack"))
 
    
 
    pjContNames = ["PseudoJet"+flags.HeavyIon.Jet.Internal.ClusterKey,pseudoGhostTrks]
 
    mergeAlg = CompFactory.PseudoJetMerger(
        "PJmerge_HIGhostTrack",
        InputPJContainers = pjContNames,
        OutputContainer = "PseudoJet"+flags.HeavyIon.Jet.Internal.ClusterKey+"_GhostTracks"
    )
    acc.addEventAlgo(mergeAlg)
 
    # build jets
    acc.merge(HIJetAlgCfg(flags, jetDef=jetDef2))
    for jd in jetDef:
        acc.merge(HIJetAlgCfg(flags, jetDef=jd))
 
    # copy unsubtracted jets; create seed0
    jetDef_seed0 = HIJetDefCloner(flags, jetDef_in=jetDef2,
                                  prefix=flags.HeavyIon.HIJetPrefix,
                                  suffix="_seed0",
                                  modifiers=["HIJetAssoc", "HIJetMaxOverMean", "HIJetDiscrim", "Filter:5000"])
    acc.merge(HIJetCopyAlgCfg(flags, jetDef2, jetDef_seed0))
 
    # first iteration, iter0
    jm_dict0, acc_iter0 = HIEventShapeJetIterationCfg(flags,
                                                      suffix="iter0",
                                                      InputEventShapeKey=eventshapeKey,
                                                      CaloJetSeedContainerKey=jetDef_seed0.fullname())
    iter0 = acc.popToolsAndMerge(acc_iter0)
    acc.addEventAlgo(CompFactory.JetAlgorithm("jetalgHI_iter0", Tools=[iter0]))
 
    # jet modifier from the first iteration
    updateStdJetModifier(flags, "subtr0", **jm_dict0)
 
    # set jet energy scale configuration
    calib_seq = "EtaJES"
    if not flags.Input.isMC:
        calib_seq += "_Insitu"
 
    # copy jets from the first iteration; create seed1
    jetDef_seed1 = HIJetDefCloner(flags, jetDef_in=jetDef2,
                                  prefix=flags.HeavyIon.HIJetPrefix,
                                  suffix="_seed1",
                                  modifiers=["HIJetAssoc", "subtr0", "HIJetCalib:{}___{}___{}".format(2, calib_seq, not flags.Input.isMC), "Filter:{}".format(flags.HeavyIon.Jet.SeedPtMin)])
    acc.merge(HIJetCopyAlgCfg(flags, jetDef2, jetDef_seed1))
 
    # configuring track jets, seeds for second iteration
    if flags.HeavyIon.Jet.doTrackJetSeed:
        pseudoTrks = "PseudoTracks"
 
        acc.merge(HIPseudoTrackJetAlgCfg(
            flags, InputContainer=pseudoTrkJetCont, OutputContainer=pseudoTrks))
 
        jetDef_trk = HITrackJetDef(flags,
                                      jetradius=4,
                                      modifiers=["HIJetAssoc", "Filter:{}".format(flags.HeavyIon.Jet.TrackJetPtMin),"Sort"])
        trkJetSeedCont = jetDef_trk.fullname()
 
        trkJetClust = acc.popToolsAndMerge(HIJetClustererCfg(flags, 
                                                             jetDef=jetDef_trk, 
                                                             InputPseudoJets=pseudoTrks))
        acc.merge(HIJetAlgCfg(flags, jetDef_trk, Provider=trkJetClust))
    else:
        trkJetSeedCont = ""
 
    # second iteration, iter1
    jm_dict1, acc_iter1 = HIEventShapeJetIterationCfg(flags,
                                                      suffix="iter1",
                                                      InputEventShapeKey=eventshapeKey,
                                                      CaloJetSeedContainerKey=jetDef_seed1.fullname(),
                                                      TrackJetSeedContainerKey=trkJetSeedCont)
    iter1 = acc.popToolsAndMerge(acc_iter1)
    acc.addEventAlgo(CompFactory.JetAlgorithm("jetalgHI_iter1", Tools=[iter1]))
 
    # event shape for egamma
    jm_dict1_eg, acc_iter1_eg = HIEventShapeJetIterationCfg(flags,
                                                            suffix="iter_egamma",
                                                            useClusters=False,
                                                            InputEventShapeKey=flags.HeavyIon.Global.EventShape,
                                                            OutputEventShapeKey=flags.HeavyIon.Egamma.EventShape,
                                                            CaloJetSeedContainerKey=jetDef_seed1.fullname())
    iter1_eg = acc.popToolsAndMerge(acc_iter1_eg)
    acc.addEventAlgo(CompFactory.JetAlgorithm("jetalgHI_iter1_egamma", Tools=[iter1_eg]))
 
    # constituents subtraction for egamma, cell-level
    cluster_key_eGamma_deep = flags.HeavyIon.Jet.Internal.ClusterKey+"_eGamma_deep"
    if not flags.HeavyIon.isDerivation:
        subtrToCelltool = acc.popToolsAndMerge(
            HISubtractionToCellsCfg(flags,
                                    name="HIClusterSubtraction_egamma",
                                    EventShapeKey=jm_dict1_eg["EventShapeKey"],
                                    OutClusterKey=cluster_key_eGamma_deep,
                                    Modulator=jm_dict1["Modulator"],
                                    EventShapeMapTool=jm_dict1["EventShapeMapTool"],
                                    SetMoments=True,
                                    ApplyOriginCorrection=False)
        )
        acc.addEventAlgo(CompFactory.JetAlgorithm("jetalgHI_subtrToCellTool", Tools=[subtrToCelltool]))
 
    # jet modifier from the second iteration
    updateStdJetModifier(flags, "subtr1", **jm_dict1)
 
    # constituents subtraction for jets, tower-level
    clusterKey = cluster_key_eGamma_deep
    if flags.HeavyIon.isDerivation:
        clusterKey = flags.HeavyIon.Jet.Internal.ClusterKey
    subtrToClusterTool = acc.popToolsAndMerge(
        HISubtractionToClustersCfg(flags,
                                   name="HIClusterSubtraction_final",
                                   EventShapeKey=jm_dict1["EventShapeKey"],
                                   ClusterKey=clusterKey,
                                   OutClusterKey=flags.HeavyIon.Jet.ClusterKey,
                                   Modulator=jm_dict1["Modulator"],
                                   EventShapeMapTool=jm_dict1["EventShapeMapTool"],
                                   ApplyOriginCorrection=False)
    )
    acc.addEventAlgo(CompFactory.JetAlgorithm(
        "jetalgHI_subtrToClusterTool", Tools=[subtrToClusterTool]))
 
    # jet modifier from the tower-level subtraction
    updateStdJetModifier(flags, "consmod",
                         ClusterKey=flags.HeavyIon.Jet.ClusterKey,
                         Subtractor=jm_dict1["Subtractor"])
 
    # store final version of HIClusters
    if flags.HeavyIon.Jet.WriteHIClusters:
        output_hicluster = ["xAOD::CaloClusterContainer#"+flags.HeavyIon.Jet.ClusterKey,
                            "xAOD::CaloClusterAuxContainer#"+flags.HeavyIon.Jet.ClusterKey+"Aux."]
        acc.merge(addToESD(flags, output_hicluster))
        acc.merge(addToAOD(flags, output_hicluster))
 
    # configure final jets and store them
    extramods = ["Sort","Width","CaloEnergies","LArHVCorr","CaloQuality","TrackMoments","JVF","JVT"]# adding modifiers to final jets
    for jd in jetDef:
        print("Printing flags: isDerivation: ", flags.HeavyIon.isDerivation, "doHIBTagging: ", flags.HeavyIon.doHIBTagging, "isMC: ", flags.Input.isMC,  "jet radius: ", jd.radius)
        if flags.HeavyIon.isDerivation and flags.HeavyIon.doHIBTagging and jd.radius==0.4:
            extramods += flags.HeavyIon.FTagModifiers
            if flags.Input.isMC:
                extramods += flags.HeavyIon.FTagTruthModifiers
        jetDef_final = HIJetDefCloner(flags,
                                      jetDef_in=jd,
                                      prefix=flags.HeavyIon.HIJetPrefix,
                                      suffix="",
                                      modifiers=["subtr1", "consmod", "HIJetCalib:{}___{}___{}".format(str(float(jd.radius)*10).replace('.0',''),calib_seq, not flags.Input.isMC), "Filter:{}".format(flags.HeavyIon.Jet.RecoOutputPtMin)]+extramods)
        if flags.HeavyIon.isDerivation and flags.HeavyIon.doHIBTagging and flags.Input.isMC and jd.radius==0.4:
            jetDef_final.ghostdefs += ["Truth","BHadronsInitial", "BHadronsFinal", "BQuarksFinal","CHadronsInitial", "CHadronsFinal", "CQuarksFinal","TausFinal", "TQuarksFinal","Partons"]
            jetDef_final = solveDependencies(jetDef_final, flags)
            pjaList = getPseudoJetAlgs(jetDef_final)
            pjaList = pjaList[1:] # removing pseudoJets from HIClusters - already created
            for pjalg in pjaList:
                if pjalg.Label=='GhostTrack': #pseudo jet algorithm for ghost tracks crashing, reusing pj thost tracks from HI track jets
                    continue
                    pjalg.name="GhostTrackPseudoJets"
                    pjalg.InputContainer=pseudoTrkJetCont
                    pjalg.OutputContainer=pseudoGhostTrks
                if pjalg.Label=='merged':
                    inpjcnt = pjalg.InputPJContainers
                    inpjcnt.remove('PseudoJetGhostJetSelectedTracks')
                    inpjcnt.append(pseudoGhostTrks)
                    pjalg.InputPJContainers = inpjcnt
                acc.addEventAlgo(pjalg)
                finalpjs = str(pjalg.OutputContainer)
                # Set the name of the final PseudoJetContainer to be used as input :
                jetDef_final._internalAtt['finalPJContainer'] = finalpjs
            jetRecAlg = getHIJetRecAlg(jetDef_final, jetDef_final.fullname())
            acc.addEventAlgo(jetRecAlg)
        else:
            acc.merge(HIJetCopyAlgCfg(flags, jd, jetDef_final))
 
        output = ["xAOD::JetContainer#"+jetDef_final.fullname(),
                  "xAOD::JetAuxContainer#"+jetDef_final.fullname()+"Aux.-PseudoJet"]
        acc.merge(addToESD(flags, output))
        acc.merge(addToAOD(flags, output))
 
    # store track jets
    if flags.HeavyIon.Jet.doTrackJetSeed:
        output = ["xAOD::JetContainer#"+jetDef_trk.fullname(),
                  "xAOD::JetAuxContainer#"+jetDef_trk.fullname()+"Aux.-PseudoJet"]
        acc.merge(addToESD(flags, output))
        acc.merge(addToAOD(flags, output))
 
    return acc
 

HIJetSubtractorCfg()

def HIJetRecConfigCA.HIJetSubtractorCfg	(		flags,
			useClusters,
		**	kwargs
	)

Common function for clsuter and cell subtraction configuration.

Definition at line 396 of file HIJetRecConfigCA.py.

def HIJetSubtractorCfg(flags, useClusters, **kwargs):
    """Common function for clsuter and cell subtraction configuration."""
 
    if useClusters:
        return HIJetClusterSubtractorCfg(flags, **kwargs)
    else:
        return HIJetCellSubtractorCfg(flags, **kwargs)
 
 

HIModulatorCfg()

def HIJetRecConfigCA.HIModulatorCfg	(		flags,
			mod_key,
			suffix = None,
		**	kwargs
	)

Provides modulator tool.

Definition at line 344 of file HIJetRecConfigCA.py.

def HIModulatorCfg(flags, mod_key, suffix=None, **kwargs):
    """Provides modulator tool."""
 
    kwargs.setdefault("harmonics", flags.HeavyIon.Jet.HarmonicsForSubtraction)
    if len(kwargs["harmonics"]) == 0:
        return NullModulatorCfg()
    acc = ComponentAccumulator()
    kwargs.setdefault("name", "Modulator_"+mod_key+
                      "".join(["_V"+str(h) for h in kwargs["harmonics"]]))
    if suffix is not None:
        kwargs["name"] += '_'+suffix
    kwargs.setdefault("DoV2", 2 in kwargs["harmonics"])
    kwargs.setdefault("DoV3", 3 in kwargs["harmonics"])
    kwargs.setdefault("DoV4", 4 in kwargs["harmonics"])
    del kwargs["harmonics"]
    kwargs.setdefault("EventShapeKey", mod_key)
 
    acc.setPrivateTools(CompFactory.HIUEModulatorTool(**kwargs))
 
    if 'label' in kwargs:
        label = kwargs['label']
        for key in kwargs:
            if key not in ["name", "DoV2", "DoV3", "DoV4", "EventShapeKey"]:
                del kwargs[key]
 
        stdJetModifiers[label] = JetModifier("HIUEModulatorTool", **kwargs)
 
    return acc
 
 

HIPseudoJetAlgCfg()

def HIJetRecConfigCA.HIPseudoJetAlgCfg	(		flags,
		**	kwargs
	)

Creates a pseudo jet algorithm

Definition at line 116 of file HIJetRecConfigCA.py.

def HIPseudoJetAlgCfg(flags, **kwargs):
    """Creates a pseudo jet algorithm"""
    acc = ComponentAccumulator()
 
    kwargs.setdefault("name", "pjcs"+flags.HeavyIon.Jet.Internal.ClusterKey)
    kwargs.setdefault("InputContainer", flags.HeavyIon.Jet.Internal.ClusterKey)
    kwargs.setdefault("OutputContainer", "PseudoJet"+flags.HeavyIon.Jet.Internal.ClusterKey)
    kwargs.setdefault("Label", "LCTopo")
    kwargs.setdefault("SkipNegativeEnergy", False)
    kwargs.setdefault("TreatNegativeEnergyAsGhost", True)
 
    acc.addEventAlgo(CompFactory.PseudoJetAlgorithm(**kwargs))
    return acc
 
 

HIPseudoTrackJetAlgCfg()

def HIJetRecConfigCA.HIPseudoTrackJetAlgCfg	(		flags,
			name = "TrackPseudoJets",
		**	kwargs
	)

Creates a pseudo track jet algorithm.

Definition at line 131 of file HIJetRecConfigCA.py.

def HIPseudoTrackJetAlgCfg(flags, name="TrackPseudoJets", **kwargs):
    """Creates a pseudo track jet algorithm."""
    acc = ComponentAccumulator()
 
    kwargs.setdefault("InputContainer", "HIJetTracks")
    kwargs.setdefault("OutputContainer", "PseudoTracks")
    kwargs.setdefault("Label", "Tracks")
    kwargs.setdefault("SkipNegativeEnergy", True)
 
    acc.addEventAlgo(CompFactory.PseudoJetAlgorithm(name, **kwargs))
    return acc
 
 

HISubtractionToCellsCfg()

def HIJetRecConfigCA.HISubtractionToCellsCfg	(		flags,
			name = "HIClusterSubtraction",
		**	kwargs
	)

Provides tool for cell subtraction.
   Re-uses tool for cluster subtraction.

Definition at line 494 of file HIJetRecConfigCA.py.

def HISubtractionToCellsCfg(flags, name="HIClusterSubtraction", **kwargs):
    """Provides tool for cell subtraction.
       Re-uses tool for cluster subtraction."""
 
    return HISubtractionToClustersCfg(flags, name, useClusters=False, **kwargs)
 
 

HISubtractionToClustersCfg()

def HIJetRecConfigCA.HISubtractionToClustersCfg	(		flags,
			name = "HIClusterSubtraction",
			useClusters = True,
		**	kwargs
	)

Provides tool for cluster subtraction.

Definition at line 501 of file HIJetRecConfigCA.py.

def HISubtractionToClustersCfg(flags, name="HIClusterSubtraction", useClusters=True, **kwargs):
    """Provides tool for cluster subtraction."""
    acc = ComponentAccumulator()
 
    kwargs.setdefault('EventShapeKey', 'EventShapeKey')
    kwargs.setdefault('ClusterKey', flags.HeavyIon.Jet.Internal.ClusterKey)
    kwargs.setdefault('OutClusterKey', 'ClusterKey_deep')
    kwargs.setdefault('UpdateOnly', False)
    kwargs.setdefault('ApplyOriginCorrection', True)
    kwargs.setdefault('SetMoments', False)
    if 'Modulator' not in kwargs:
        modulator = acc.popToolsAndMerge(NullModulatorCfg())
        kwargs.setdefault('Modulator', modulator)
    if "EventShapeMapTool" not in kwargs:
        map_tool = acc.popToolsAndMerge(HIEventShapeMapToolCfg(flags))
        kwargs.setdefault("EventShapeMapTool", map_tool)
    if "Subtractor" not in kwargs:
        sub_tool = acc.popToolsAndMerge(HIJetSubtractorCfg(flags, useClusters))
        kwargs.setdefault("Subtractor", sub_tool)
    if kwargs["SetMoments"] and "ClusterCorrectionTools" not in kwargs:
        clusterCorrectionTools = acc.popToolsAndMerge(
            HICaloClusterMomentsCfg(flags, "HIClusterMoments"))
        kwargs.setdefault("ClusterCorrectionTools", [clusterCorrectionTools])
 
    acc.setPrivateTools(CompFactory.HIClusterSubtraction(name, **kwargs))
    return acc
 
 

HITrackJetDef()

def HIJetRecConfigCA.HITrackJetDef	(		flags,
			jetradius,
		**	kwargs
	)

Returns jet definition for track jets, with already resolved dependencies.

Definition at line 101 of file HIJetRecConfigCA.py.

def HITrackJetDef(flags, jetradius, **kwargs):
    """Returns jet definition for track jets, with already resolved dependencies."""
 
    import JetRecTools.JetRecToolsConfig as jrtcfg
    JetInputExternal("JetSelectedTracks",
                     xAODType.TrackParticle,
                     # in std context, this is InDetTrackParticles (see StandardJetContext)
                     prereqs=["InDetTrackParticles"],
                     algoBuilder=lambda jdef, _: jrtcfg.getTrackSelAlg(jdef, trackSelOpt=False))
    kwargs.setdefault("ptmin", 5000)
    kwargs.setdefault("inputdef", HITrackJetInputConstit(flags))
 
    return HICaloJetDef(flags, jetradius=jetradius, **kwargs)
 
 

HITrackJetInputConstit()

def HIJetRecConfigCA.HITrackJetInputConstit	(		flags,
			name = "HITrack",
		**	kwargs
	)

Definition at line 93 of file HIJetRecConfigCA.py.

def HITrackJetInputConstit(flags, name="HITrack", **kwargs):
    kwargs.setdefault("objtype", xAODType.TrackParticle)
    kwargs.setdefault("containername", "JetSelectedTracks")
 
    jetConstit = JetInputConstit(name, **kwargs)
    return jetConstit
 
 

HITrackSelAlgCfg()

def HIJetRecConfigCA.HITrackSelAlgCfg	(		flags,
			name = "TrackSelAlgHI",
		**	kwargs
	)

Provides track selection algorithm for track jet reconstruction.

Definition at line 448 of file HIJetRecConfigCA.py.

def HITrackSelAlgCfg(flags, name="TrackSelAlgHI", **kwargs):
    """Provides track selection algorithm for track jet reconstruction."""
    acc = ComponentAccumulator()
 
    if "TrackSelector" not in kwargs:
        from InDetConfig.InDetTrackSelectionToolConfig import HI_InDetTrackSelectionToolForHITrackJetsCfg
        tracksel = acc.popToolsAndMerge(HI_InDetTrackSelectionToolForHITrackJetsCfg(flags))
        kwargs.setdefault("TrackSelector", tracksel)
    kwargs.setdefault("InputContainer", "InDetTrackParticles")
    kwargs.setdefault("OutputContainer", "HIJetTracks")
    kwargs.setdefault("DecorDeps", [])
 
    acc.addEventAlgo(CompFactory.JetTrackSelectionAlg(name, **kwargs))
    return acc
 
 

NullModulatorCfg()

def HIJetRecConfigCA.NullModulatorCfg

(

)

Provides modulator tool without any modulations.

Definition at line 333 of file HIJetRecConfigCA.py.

def NullModulatorCfg():
    """Provides modulator tool without any modulations."""
    acc = ComponentAccumulator()
    acc.setPrivateTools(CompFactory.HIUEModulatorTool('NullUEModulator',
                                                      EventShapeKey='',
                                                      DoV2=False,
                                                      DoV3=False,
                                                      DoV4=False))
    return acc
 
 

updateStdJetModifier()

def HIJetRecConfigCA.updateStdJetModifier	(		flags,
			name,
		**	kwargs
	)

Updates the stdJetModifiers dictionary, based on the provided name. 
   Some of the modifiers expect certain kwargs. 
   Some of the modifiers ignore kwargs which makes the code simpler.

Definition at line 200 of file HIJetRecConfigCA.py.

def updateStdJetModifier(flags, name, **kwargs):
    """Updates the stdJetModifiers dictionary, based on the provided name. 
       Some of the modifiers expect certain kwargs. 
       Some of the modifiers ignore kwargs which makes the code simpler."""
 
    if "Filter:" in name:
        # already there, do nothing
        return
    if "JetDeltaRLabel:" in name:
        # already there, do nothing
        return
    if "JetDeltaRInitialLabel:" in name:
        # already there, do nothing
        return
    if "HIJetCalib:" in name:
        # add generic "HIJetCalib" modifier
        if "HIJetCalib" not in stdJetModifiers:
            updateStdJetModifier(flags, "HIJetCalib", **kwargs)
        return
    if name in stdJetModifiers:
        # already there, do nothing
        return
 
    if name == "HIJetAssoc":
        stdJetModifiers.update(
            HIJetAssoc=JetModifier("HIJetDRAssociationTool",
                                   "HIJetDRAssociation",
                                   ContainerKey=flags.HeavyIon.Jet.Internal.ClusterKey,
                                   DeltaR=0.8,
                                   AssociationName=flags.HeavyIon.Jet.Internal.ClusterKey+"_DR8Assoc"))
        return
 
    if name == "HIJetMaxOverMean":
        if "jetDef" not in kwargs:
            __log.warning(
                "HIJetMaxOverMean needs 'jetDef' in its kwargs; HIJetMaxOverMean is not added to stdJetModifiers")
            return
        stdJetModifiers.update(
            HIJetMaxOverMean=JetModifier("HIJetMaxOverMeanTool",
                                         "HIJetMaxOverMean",
                                         JetContainer=kwargs["jetDef"].fullname()))
        return
 
    if name == "HIJetDiscrim":
        stdJetModifiers.update(
            HIJetDiscrim=JetModifier("HIJetDiscriminatorTool",
                                     "HIJetDiscriminator",
                                     MaxOverMeanCut=4,
                                     MinimumETMaxCut=3000))
        return
 
    if name == "subtr0":
        if "Modulator" not in kwargs or "EventShapeMapTool" not in kwargs or \
           "Subtractor" not in kwargs or "EventShapeKey" not in kwargs:
            __log.warning(
                "subtr0 needs 'Modulator', 'EventShapeMapTool', 'Subtractor', and 'EventShapeKey' in its kwargs; subtr0 is not added to stdJetModifiers")
            return
 
        stdJetModifiers.update(
            subtr0=JetModifier("HIJetConstituentSubtractionTool",
                               "HICS_HIEventShapeWeighted_iter0",
                               MomentName="JetSubtractedScaleMomentum",
                               SetMomentOnly=False,
                               ApplyOriginCorrection=True,
                               **kwargs))
        return
 
    if name == "HIJetCalib":
        stdJetModifiers.update(
            HIJetCalib=JetModifier("JetCalibrationTool",
                                   "HICalibTool_{modspec}",
                                   JetCollection=lambda _, modspec: "AntiKt{}HI".format(modspec.split('___')[0]) if modspec.split('___')[0] in flags.HeavyIon.Jet.CaliRValues else "AntiKt4HI",
                                   PrimaryVerticesContainerName="",
                                   ConfigFile='JES_MC16_HI_Jan2021_5TeV.config', # JES_MC16_HI_Jan2021_5TeV.config JES_MC15c_HI_Nov2016.config
                                   CalibSequence=lambda _, modspec: modspec.split('___')[1],
                                   IsData=lambda _, modspec: modspec.split('___')[2] == 'True'))
        return
 
    if name == "subtr1":
        if "Modulator" not in kwargs or "EventShapeMapTool" not in kwargs or \
           "Subtractor" not in kwargs or "EventShapeKey" not in kwargs:
            __log.warning(
                "subtr1 needs 'Modulator', 'EventShapeMapTool', 'Subtractor', and 'EventShapeKey' in its kwargs; subtr1 is not added to stdJetModifiers")
            return
 
        stdJetModifiers.update(
            subtr1=JetModifier("HIJetConstituentSubtractionTool",
                               "HICS_HIEventShapeWeighted_iter1",
                               MomentName="JetSubtractedScaleMomentum",
                               SetMomentOnly=False,
                               ApplyOriginCorrection=True,
                               **kwargs))
        return
 
    if name == "consmod":
        if "ClusterKey" not in kwargs or "Subtractor" not in kwargs:
            __log.warning(
                "consmod needs 'ClusterKey' and 'Subtractor' in its kwargs; consmod is not added to stdJetModifiers")
            return
 
        stdJetModifiers.update(
            consmod=JetModifier(
                "HIJetConstituentModifierTool",
                "HIJetConstituentModifierTool_final",
                ApplyOriginCorrection=True,
                **kwargs))
        return
 
    __log.warning("updateStdJetModifier does not know modifier "+
                  name+"; it is not added to stdJetModifiers")
    return
 
 

Variable Documentation

__log

HIJetRecConfigCA.__log = logging.getLogger('HIJetRecConfigCA')

private

Definition at line 17 of file HIJetRecConfigCA.py.

acc

HIJetRecConfigCA.acc = MainServicesCfg(flags)

Definition at line 802 of file HIJetRecConfigCA.py.

AtlasVersion

HIJetRecConfigCA.AtlasVersion

Definition at line 790 of file HIJetRecConfigCA.py.

EMjet

HIJetRecConfigCA.EMjet = AntiKt4EMTopo.clone()

Definition at line 810 of file HIJetRecConfigCA.py.

Files

HIJetRecConfigCA.Files

Definition at line 789 of file HIJetRecConfigCA.py.

flags

HIJetRecConfigCA.flags = initConfigFlags()

Definition at line 788 of file HIJetRecConfigCA.py.

ghostdefs

HIJetRecConfigCA.ghostdefs

Definition at line 811 of file HIJetRecConfigCA.py.

GlobalTag

HIJetRecConfigCA.GlobalTag

Definition at line 791 of file HIJetRecConfigCA.py.

MaxEvents

HIJetRecConfigCA.MaxEvents

Definition at line 792 of file HIJetRecConfigCA.py.

NumThreads

HIJetRecConfigCA.NumThreads

Definition at line 793 of file HIJetRecConfigCA.py.

strictMode

HIJetRecConfigCA.strictMode

python -m HIRecConfig.HIRecConfig HeavyIon.doGlobal="False" GeoModel.AtlasVersion="ATLAS-R3S-2021-03-01-00"

Definition at line 798 of file HIJetRecConfigCA.py.

summariseProps

HIJetRecConfigCA.summariseProps

Definition at line 819 of file HIJetRecConfigCA.py.

True

HIJetRecConfigCA.True

Definition at line 819 of file HIJetRecConfigCA.py.

withDetails

HIJetRecConfigCA.withDetails

Definition at line 819 of file HIJetRecConfigCA.py.