DerivationFrameworkCaloConfig Namespace Reference

Functions
def	CaloCellDecoratorCfg (flags, **kwargs)
def	MaxCellDecoratorCfg (flags, name="MaxCellDecorator", **kwargs)
def	GainDecoratorCfg (flags, **kwargs)
def	EgammaCoreCellRecoveryCfg (flags, **kwargs)
def	CaloFillRectangularClusterCfg (flags, **kwargs)
def	ClusterEnergyPerLayerDecoratorCfg (flags, **kwargs)
def	CaloCellDecoratorKernelCfg (flags, name="CaloCellDecoratorKernel", **kwargs)
def	MaxCellDecoratorKernelCfg (flags, name="MaxCellDecoratorKernel", **kwargs)
def	CaloDecoratorKernelCfg (flags, name="CaloDecoratorKernel", **kwargs)
def	CaloClusterThinningCfg (flags, **kwargs)
def	JetCaloClusterThinningCfg (flags, **kwargs)
def	getGainLayerNames (tool)
	additional utilities to return the list of decorations added by the tools More...
def	getGainDecorations (acc, flags, kernel, collections=None, info=["E", "nCells"])
def	getClusterEnergyPerLayerDecorations (acc, kernel)

Function Documentation

CaloCellDecoratorCfg()

def DerivationFrameworkCaloConfig.CaloCellDecoratorCfg	(		flags,
		**	kwargs
	)

Definition at line 6 of file DerivationFrameworkCaloConfig.py.

def CaloCellDecoratorCfg(flags, **kwargs):
    acc = ComponentAccumulator()
    kwargs.setdefault("SGKey_electrons", flags.Egamma.Keys.Output.Electrons)
    kwargs.setdefault("SGKey_photons", flags.Egamma.Keys.Output.Photons)
    acc.setPrivateTools(CompFactory.DerivationFramework.CaloCellDecorator(**kwargs))
    from LArCabling.LArCablingConfig import LArOnOffIdMappingCfg
 
    acc.merge(LArOnOffIdMappingCfg(flags))
    return acc
 
 

CaloCellDecoratorKernelCfg()

def DerivationFrameworkCaloConfig.CaloCellDecoratorKernelCfg	(		flags,
			name = "CaloCellDecoratorKernel",
		**	kwargs
	)

Definition at line 105 of file DerivationFrameworkCaloConfig.py.

def CaloCellDecoratorKernelCfg(flags, name="CaloCellDecoratorKernel", **kwargs):
    acc = ComponentAccumulator()
 
    augmentationTools = [
        acc.addPublicTool(acc.popToolsAndMerge(CaloCellDecoratorCfg(flags)))
    ]
 
    kwargs.setdefault("AugmentationTools", augmentationTools)
 
    acc.addEventAlgo(CompFactory.DerivationFramework.DerivationKernel(name, **kwargs))
    return acc
 
 

CaloClusterThinningCfg()

def DerivationFrameworkCaloConfig.CaloClusterThinningCfg	(		flags,
		**	kwargs
	)

Definition at line 153 of file DerivationFrameworkCaloConfig.py.

def CaloClusterThinningCfg(flags, **kwargs):
    acc = ComponentAccumulator()
    CaloClusterThinning = CompFactory.DerivationFramework.CaloClusterThinning
    acc.addPublicTool(CaloClusterThinning(**kwargs), primary=True)
    return acc
 

CaloDecoratorKernelCfg()

def DerivationFrameworkCaloConfig.CaloDecoratorKernelCfg	(		flags,
			name = "CaloDecoratorKernel",
		**	kwargs
	)

Definition at line 131 of file DerivationFrameworkCaloConfig.py.

def CaloDecoratorKernelCfg(flags, name="CaloDecoratorKernel", **kwargs):
    acc = MaxCellDecoratorKernelCfg(flags)
 
    augmentationTools = [
        acc.addPublicTool(acc.popToolsAndMerge(GainDecoratorCfg(flags)))
    ]
 
    # might need some modification if cell-level reweighting is implemented
    cluster_sizes = (3, 7), (5, 5), (7, 11)
    for neta, nphi in cluster_sizes:
        cename = "ClusterEnergyPerLayerDecorator_%sx%s" % (neta, nphi)
        ClusterEnergyPerLayerDecorator = acc.popToolsAndMerge(
            ClusterEnergyPerLayerDecoratorCfg(flags, neta=neta, nphi=nphi, name=cename)
        )
        augmentationTools.append(acc.addPublicTool(ClusterEnergyPerLayerDecorator))
 
    kwargs.setdefault("AugmentationTools", augmentationTools)
 
    acc.addEventAlgo(CompFactory.DerivationFramework.DerivationKernel(name, **kwargs))
    return acc
 
 

CaloFillRectangularClusterCfg()

def DerivationFrameworkCaloConfig.CaloFillRectangularClusterCfg	(		flags,
		**	kwargs
	)

Definition at line 72 of file DerivationFrameworkCaloConfig.py.

def CaloFillRectangularClusterCfg(flags, **kwargs):
    acc = ComponentAccumulator()
    kwargs.setdefault("cells_name", flags.Egamma.Keys.Input.CaloCells)
    kwargs.setdefault("fill_cluster", True)
    acc.setPrivateTools(CompFactory.CaloFillRectangularCluster(**kwargs))
    return acc
 
 

ClusterEnergyPerLayerDecoratorCfg()

def DerivationFrameworkCaloConfig.ClusterEnergyPerLayerDecoratorCfg	(		flags,
		**	kwargs
	)

Definition at line 80 of file DerivationFrameworkCaloConfig.py.

def ClusterEnergyPerLayerDecoratorCfg(flags, **kwargs):
    acc = ComponentAccumulator()
    electronKey = kwargs.setdefault("SGKey_electrons", flags.Egamma.Keys.Output.Electrons)
    photonKey = kwargs.setdefault("SGKey_photons", flags.Egamma.Keys.Output.Photons)
    kwargs.setdefault("SGKey_caloCells", flags.Egamma.Keys.Input.CaloCells)
    neta = kwargs.pop("neta", 5)
    nphi = kwargs.pop("nphi", 5)
    kwargs.setdefault("layers", [ 0, 1, 2, 3 ])
    decorBase = "E{}x{}_Lr".format(neta, nphi)
    kwargs.setdefault("SGKey_photons_decorations", [photonKey+"."+decorBase+str(layer) for layer in kwargs['layers']])
    kwargs.setdefault("SGKey_electrons_decorations", [electronKey+"."+decorBase+str(layer) for layer in kwargs['layers']])
    #FIXME The above two lines can be simplified when SG::WriteDecorHandleKeyArray is updated
    toolArgs = {}
    toolArgs.update({"eta_size": neta})
    toolArgs.update({"phi_size": nphi})
    kwargs.setdefault(
        "CaloFillRectangularClusterTool",
        acc.popToolsAndMerge(CaloFillRectangularClusterCfg(flags, **toolArgs)),
    )
    acc.setPrivateTools(
        CompFactory.DerivationFramework.ClusterEnergyPerLayerDecorator(**kwargs)
    )
    return acc
 
 

EgammaCoreCellRecoveryCfg()

def DerivationFrameworkCaloConfig.EgammaCoreCellRecoveryCfg	(		flags,
		**	kwargs
	)

Definition at line 58 of file DerivationFrameworkCaloConfig.py.

def EgammaCoreCellRecoveryCfg(flags, **kwargs):
    acc = ComponentAccumulator()
    # needed for reading cells, do not rely on other config to do that
    from LArGeoAlgsNV.LArGMConfig import LArGMCfg
    acc.merge(LArGMCfg(flags))
    from TileGeoModel.TileGMConfig import TileGMCfg
    acc.merge(TileGMCfg(flags))
    #
    acc.setPrivateTools(
        CompFactory.DerivationFramework.EGammaClusterCoreCellRecovery(**kwargs)
    )
    return acc
 
 

GainDecoratorCfg()

def DerivationFrameworkCaloConfig.GainDecoratorCfg	(		flags,
		**	kwargs
	)

Definition at line 37 of file DerivationFrameworkCaloConfig.py.

def GainDecoratorCfg(flags, **kwargs):
    acc = ComponentAccumulator()
    decorationPattern = kwargs.pop("decoration_pattern", "{}_Lr{}_{}G")
    kwargs.setdefault("gain_names", { 0 : "Hi", 1 : "Med", 2 : "Low" })
    kwargs.setdefault("layers", [0, 1, 2, 3])
    decorNames = []
    for x, gain in kwargs["gain_names"].items():
        for layer in kwargs["layers"]:
            decorNames += [decorationPattern.format("E", layer, gain)]
            decorNames += [decorationPattern.format("rnoW", layer, gain)]
            decorNames += [decorationPattern.format("nCells", layer, gain)]
    electronKey = kwargs.setdefault("SGKey_electrons", flags.Egamma.Keys.Output.Electrons)
    kwargs.setdefault("SGKey_electrons_decorations", [electronKey + "." + decor for decor in decorNames])
    photonKey = kwargs.setdefault("SGKey_photons", flags.Egamma.Keys.Output.Photons)
    kwargs.setdefault("SGKey_photons_decorations", [photonKey + "." + decor for decor in decorNames])
    #FIXME Decorations can be simplified once SG::WriteDecorHandleKeyArray is updated
    kwargs.setdefault("name", "GainDecor")
    acc.setPrivateTools(CompFactory.DerivationFramework.GainDecorator(**kwargs))
    return acc
 
 

getClusterEnergyPerLayerDecorations()

def DerivationFrameworkCaloConfig.getClusterEnergyPerLayerDecorations	(		acc,
			kernel
	)

getClusterEnergyPerLayerDecorationsLegacy( acc, kernel ) -> return a list of names of the
decorations added to the egamma object, given the ClusterEnergyPerLayerDecorations
object (e.g. Photons.E7x11_Lr0, ...)

Definition at line 210 of file DerivationFrameworkCaloConfig.py.

def getClusterEnergyPerLayerDecorations(acc, kernel):
    """getClusterEnergyPerLayerDecorationsLegacy( acc, kernel ) -> return a list of names of the
    decorations added to the egamma object, given the ClusterEnergyPerLayerDecorations
    object (e.g. Photons.E7x11_Lr0, ...)"""
    properties = "SGKey_photons", "SGKey_electrons"
    ClusterEnergyPerLayerDecorators = []
    for tool in acc.getEventAlgo(kernel).AugmentationTools:
        if tool.getType() == "DerivationFramework::ClusterEnergyPerLayerDecorator":
            ClusterEnergyPerLayerDecorators.append(tool)
 
    decorations = []
    for tool in ClusterEnergyPerLayerDecorators:
        collections = filter(bool, (getattr(tool, x) for x in properties))
        for part in collections:
            key = "SGKey_{}_decorations".format(str(part).lower())
            decorations.extend(getattr(tool, key))
    return decorations

getGainDecorations()

def DerivationFrameworkCaloConfig.getGainDecorations	(		acc,
			flags,
			kernel,
			collections = None,
			info = ["E", "nCells"]
	)

getGainDecorations( acc, kernel collections=["Electrons", "Photons"] ) ->
Return a list with the 'ExtraContent' to be added to the decorations to save the gain
information per layer

Definition at line 181 of file DerivationFrameworkCaloConfig.py.

def getGainDecorations(
    acc,
    flags,
    kernel,
    collections=None,
    info=["E", "nCells"],
):
    """getGainDecorations( acc, kernel collections=["Electrons", "Photons"] ) ->
    Return a list with the 'ExtraContent' to be added to the decorations to save the gain
    information per layer"""
 
    if collections is None:
        collections = [flags.Egamma.Keys.Output.Electrons, flags.Egamma.Keys.Output.Photons]
 
    GainDecoratorTool = None
    for tool in acc.getEventAlgo(kernel).AugmentationTools:
        if tool.getType() == "DerivationFramework::GainDecorator":
            GainDecoratorTool = tool
 
    if GainDecoratorTool:
        return [
            "{part}.{info}".format(part=part, info=info)
            for part in collections
            for info in getGainLayerNames(GainDecoratorTool)
        ]
    else:
        return ""
 
 

getGainLayerNames()

def DerivationFrameworkCaloConfig.getGainLayerNames

(

tool

)

additional utilities to return the list of decorations added by the tools

getGainLayerNames( tool ) -> return a list of names of the decorations added to the
egamma tool, given the GainDecorator tool

Definition at line 170 of file DerivationFrameworkCaloConfig.py.

def getGainLayerNames(tool):
    """getGainLayerNames( tool ) -> return a list of names of the decorations added to the
    egamma tool, given the GainDecorator tool"""
    return [
        tool.decoration_pattern.format(info=info, layer=layer, gain=gain)
        for info in ["E", "nCells"]
        for layer in tool.layers
        for gain in tool.gain_names.values()
    ]
 
 

JetCaloClusterThinningCfg()

def DerivationFrameworkCaloConfig.JetCaloClusterThinningCfg	(		flags,
		**	kwargs
	)

Definition at line 159 of file DerivationFrameworkCaloConfig.py.

def JetCaloClusterThinningCfg(flags, **kwargs):
    acc = ComponentAccumulator()
    JetCaloClusterThinning = CompFactory.DerivationFramework.JetCaloClusterThinning
    acc.addPublicTool(JetCaloClusterThinning(**kwargs), primary=True)
    return acc
 

MaxCellDecoratorCfg()

def DerivationFrameworkCaloConfig.MaxCellDecoratorCfg	(		flags,
			name = "MaxCellDecorator",
		**	kwargs
	)

Definition at line 17 of file DerivationFrameworkCaloConfig.py.

def MaxCellDecoratorCfg(flags, name="MaxCellDecorator", **kwargs):
    acc = ComponentAccumulator()
    electronKey = kwargs.setdefault("SGKey_electrons", flags.Egamma.Keys.Output.Electrons)
    baseDecorations =["maxEcell_time", "maxEcell_energy", "maxEcell_gain",
                      "maxEcell_onlId", "maxEcell_x", "maxEcell_y", "maxEcell_z"]
    electronDecorations = [electronKey + "." + decor for decor in baseDecorations]
    kwargs.setdefault("SGKey_egammaClusters", "")
    if kwargs["SGKey_egammaClusters"] != '':
        electronDecorations += [electronKey + "." + "dR"]
    # FIXME The electronDecorations definition can be simplified after
    # SG::WriteDecorHandleKeyArray is updated.
    kwargs.setdefault("SGKey_electrons_decorations", electronDecorations)
    kwargs.setdefault("SGKey_photons", flags.Egamma.Keys.Output.Photons)
    acc.setPrivateTools(CompFactory.DerivationFramework.MaxCellDecorator(name, **kwargs))
    from LArCabling.LArCablingConfig import LArOnOffIdMappingCfg
 
    acc.merge(LArOnOffIdMappingCfg(flags))
    return acc
 
 

MaxCellDecoratorKernelCfg()

def DerivationFrameworkCaloConfig.MaxCellDecoratorKernelCfg	(		flags,
			name = "MaxCellDecoratorKernel",
		**	kwargs
	)

Definition at line 118 of file DerivationFrameworkCaloConfig.py.

def MaxCellDecoratorKernelCfg(flags, name="MaxCellDecoratorKernel", **kwargs):
    acc = ComponentAccumulator()
 
    augmentationTools = [
        acc.addPublicTool(acc.popToolsAndMerge(MaxCellDecoratorCfg(flags)))
    ]
 
    kwargs.setdefault("AugmentationTools", augmentationTools)
 
    acc.addEventAlgo(CompFactory.DerivationFramework.DerivationKernel(name, **kwargs))
    return acc