python.HLT.MET.ConfigHelpers.AlgConfig Class Reference

Inherits ABC.

Inherited by python.HLT.MET.AlgConfigs.CellConfig, python.HLT.MET.AlgConfigs.CVFPufitConfig, python.HLT.MET.AlgConfigs.MHTConfig, python.HLT.MET.AlgConfigs.MHTPufitConfig, python.HLT.MET.AlgConfigs.NNHLTConfig, python.HLT.MET.AlgConfigs.PFOPufitConfig, python.HLT.MET.AlgConfigs.PFSumConfig, python.HLT.MET.AlgConfigs.TCConfig, python.HLT.MET.AlgConfigs.TCPufitConfig, and python.HLT.MET.AlgConfigs.TrkMHTConfig.

Collaboration diagram for python.HLT.MET.ConfigHelpers.AlgConfig:

Public Member Functions
str	algType (cls)
def	__init__ (self, **str recoDict)
str	outputKey (self)
str	fexName (self)
dict[str, Any]	interpret_reco_dict (self)
def	getMonTool (self, flags)
str	name_step (self, idx)
StepOutput	make_reco_algs (self, flags, **recoDict)
def	make_reco_ca (self, flags)
def	make_accumulator_steps (self, flags, chainDict)
def	make_hypo_alg (self)
def	make_passthrough_hypo_alg (self, step)
def	inputMakerCA (self, idx)
AlgConfig	fromRecoDict (cls, EFrecoAlg, **recoDict)

Public Attributes
	recoDict

Private Member Functions
None	_append_fex (self, flags, fex, Optional[StepOutput] inputs=None)
def	_get_subclasses (cls)

Private Attributes
	_suffix

Detailed Description

Base class to describe algorithm configurations

Each individual 'EFrecoAlg' should be described by *one* AlgConfig subclass.
It must provide its list of required inputs to the constructor and override
the make_fex method

The name of fexAlg *must* be self.fexName and the METContainerKey property
*must* be set to self.outputKey (but this class usually should take care of
this).

The subclass must also implement the @classmethod 'algType' which returns
the EFrecoAlg string that it describes.

Definition at line 94 of file ConfigHelpers.py.

Constructor & Destructor Documentation

__init__()

def python.HLT.MET.ConfigHelpers.AlgConfig.__init__	(		self,
		**str	recoDict
	)

Initialise the base class

=========
Arguments
=========
recoDict: Pass *all* the keys required for the recoDict

Definition at line 119 of file ConfigHelpers.py.

    def __init__(self, **recoDict: str):
        """Initialise the base class
 
        =========
        Arguments
        =========
        recoDict: Pass *all* the keys required for the recoDict
        """
 
        # Make sure that we got *all* the keys (i.e. the subclass didn't
        # inadvertently steal one of them from us)
        alg_type = self.algType()
        assert all(k in recoDict for k in recoKeys), (
            f"AlgConfig.__init__ for {alg_type} did not receive all the recoKeys"
            " - this suggests a problem in the subclass __init__ method!"
        )
        self.recoDict = copy(recoDict)
        self._suffix = metRecoDictToString(recoDict)
 

Member Function Documentation

_append_fex()

None python.HLT.MET.ConfigHelpers.AlgConfig._append_fex (   self,   flags,   fex, Optional[StepOutput]   inputs = None  )

private

Append the FEX to the output object

Finalizes the FEX by setting the monitoring tool and output name.

Definition at line 168 of file ConfigHelpers.py.

    def _append_fex(self, flags, fex, inputs: Optional[StepOutput] = None) -> None:
        """Append the FEX to the output object
        
        Finalizes the FEX by setting the monitoring tool and output name.
        """
        fex.MonTool = self.getMonTool(flags)
        fex.METContainerKey = self.outputKey
        acc = ComponentAccumulator()
        acc.addEventAlgo(fex, primary=True)
        return StepOutput.create(acc, inputs, MET=self.outputKey)
 

_get_subclasses()

def python.HLT.MET.ConfigHelpers.AlgConfig._get_subclasses (   cls )

private

Provides a way to iterate over all subclasses of this class

Definition at line 288 of file ConfigHelpers.py.

    def _get_subclasses(cls):
        """Provides a way to iterate over all subclasses of this class"""
        for subcls in cls.__subclasses__():
            for subsubcls in subcls.__subclasses__():
                yield subsubcls
            yield subcls
 

algType()

str python.HLT.MET.ConfigHelpers.AlgConfig.algType

(

cls

)

The algorithm that this object configures - this corresponds to the
EFrecoAlg in the METChainParts dictionary

Note that no two subclasses of AlgConfig can describe the same algorithm
(as identified by this string).

Reimplemented in python.HLT.MET.AlgConfigs.NNHLTConfig, python.HLT.MET.AlgConfigs.MHTPufitConfig, python.HLT.MET.AlgConfigs.CVFPufitConfig, python.HLT.MET.AlgConfigs.PFOPufitConfig, python.HLT.MET.AlgConfigs.PFSumConfig, python.HLT.MET.AlgConfigs.TrkMHTConfig, python.HLT.MET.AlgConfigs.MHTConfig, python.HLT.MET.AlgConfigs.TCPufitConfig, python.HLT.MET.AlgConfigs.TCConfig, and python.HLT.MET.AlgConfigs.CellConfig.

Definition at line 110 of file ConfigHelpers.py.

    def algType(cls) -> str:
        """The algorithm that this object configures - this corresponds to the
        EFrecoAlg in the METChainParts dictionary
 
        Note that no two subclasses of AlgConfig can describe the same algorithm
        (as identified by this string).
        """
        raise NotImplementedError("algType not implemented by subclass!")
 

fexName()

str python.HLT.MET.ConfigHelpers.AlgConfig.fexName

(

self

)

The name of the algorithm made by this configuration

Definition at line 146 of file ConfigHelpers.py.

    def fexName(self) -> str:
        """The name of the algorithm made by this configuration"""
        return "EFMET_{}".format(self._suffix)
 

fromRecoDict()

AlgConfig python.HLT.MET.ConfigHelpers.AlgConfig.fromRecoDict	(		cls,
			EFrecoAlg,
		**	recoDict
	)

Definition at line 296 of file ConfigHelpers.py.

    def fromRecoDict(cls, EFrecoAlg, **recoDict) -> AlgConfig:
        for subcls in cls._get_subclasses():
            if subcls.algType() == EFrecoAlg:
                return subcls(EFrecoAlg=EFrecoAlg, **recoDict)
 
        raise ValueError("Unknown EFrecoAlg '{}' requested".format(EFrecoAlg))
 

getMonTool()

def python.HLT.MET.ConfigHelpers.AlgConfig.getMonTool	(		self,
			flags
	)

Create the monitoring tool

Definition at line 154 of file ConfigHelpers.py.

    def getMonTool(self, flags):
        """Create the monitoring tool"""
        return getMETMonTool(flags)
 

inputMakerCA()

def python.HLT.MET.ConfigHelpers.AlgConfig.inputMakerCA	(		self,
			idx
	)

Get the InEventRecoCA for the given step index

Definition at line 264 of file ConfigHelpers.py.

    def inputMakerCA(self, idx):
        """Get the InEventRecoCA for the given step index"""
        from TrigT2CaloCommon.CaloDef import clusterFSInputMaker
        from AthenaConfiguration.ComponentFactory import CompFactory
        from ..CommonSequences.FullScanDefs import trkFSRoI
 
        name = self.name_step(idx) + "Reco"
        if idx == 0:
            return InEventRecoCA(name, inputMaker=clusterFSInputMaker())
        elif idx == 1:
            return None
        elif idx == 2:
            return InEventRecoCA(
                name,
                inputMaker=CompFactory.InputMakerForRoI(
                    "IM_Jet_TrackingStep",
                    RoITool=CompFactory.ViewCreatorInitialROITool(),
                    RoIs=trkFSRoI,
                ),
            )
        else:
            raise KeyError(f"No input maker for step {idx}")
 

interpret_reco_dict()

dict[str, Any] python.HLT.MET.ConfigHelpers.AlgConfig.interpret_reco_dict

(

self

)

Return a version of the reco dict with any necessary post-processing

Reimplemented in python.HLT.MET.AlgConfigs.MHTPufitConfig, and python.HLT.MET.AlgConfigs.MHTConfig.

Definition at line 150 of file ConfigHelpers.py.

    def interpret_reco_dict(self) -> dict[str, Any]:
        """Return a version of the reco dict with any necessary post-processing"""
        return self.recoDict
 

make_accumulator_steps()

def python.HLT.MET.ConfigHelpers.AlgConfig.make_accumulator_steps	(		self,
			flags,
			chainDict
	)

Make the full accumulator steps

Definition at line 193 of file ConfigHelpers.py.

    def make_accumulator_steps(self, flags, chainDict):
        """Make the full accumulator steps"""
 
        # Get the reco sequences
        reco_sequences = self.make_reco_algs(flags, **self.interpret_reco_dict()).steps
        output_steps = []
        # build up the output steps
        # We have to merge together the CAs containing the reconstruction sequences
        # and the InEventRecoCAs that contain the input makers
        for step_idx, reco_sequence in enumerate(reco_sequences):
            reco_acc = self.inputMakerCA(step_idx)
            sel_acc = None
            step_name = f"Empty_METStep{step_idx}"
            if (
                reco_acc is not None
            ):  # Define reco and hypo algorithms only if reco_acc is not None
                if step_idx == len(reco_sequences) - 1:
                    # If this is the last step we have to add the hypo alg
                    hypo_alg = self.make_hypo_alg()
                    hypo_tool = TrigMETHypoToolFromDict
                else:
                    # Otherwise, we add a passthrough hypo
                    hypo_alg = self.make_passthrough_hypo_alg(step_idx)
                    hypo_tool = streamer_hypo_tool
 
                # Now merge the reco sequence into the InEventRecoCA
                reco_acc.mergeReco(reco_sequence)
 
                # Create a selection CA
                sel_acc = SelectionCA("METAthSeq_" + self.name_step(step_idx))
                # Merge in the reconstruction sequence
                sel_acc.mergeReco(reco_acc)
                # Add its hypo alg
                sel_acc.addHypoAlgo(hypo_alg)
 
                # FIXME: We need to mark the CA as merged because during the fast menu generation
                # the merging is only done once for all chains, which is not compatible with the MET
                # menu generation code. Remove this once ATR-29211 is fixed.
                sel_acc.wasMerged()
 
                step_name = sel_acc.name
 
            # Build the menu sequence and create the actual chainStep
            output_steps.append(
                ChainStep(
                    name=step_name,
                    multiplicity=[] if sel_acc is None else [1],
                    chainDicts=[chainDict],
                    Sequences=[]
                    if sel_acc is None
                    else [
                        functools.partial(make_MET_menu_sequenceGenCfg, flags, sel_acc, hypo_tool)                                                
                    ],
                    comboHypoCfg=ComboHypoCfg
                )
            )
 
        return output_steps
    
 

make_hypo_alg()

def python.HLT.MET.ConfigHelpers.AlgConfig.make_hypo_alg

(

self

)

The hypo alg used for this configuration

Definition at line 253 of file ConfigHelpers.py.

    def make_hypo_alg(self):
        """The hypo alg used for this configuration"""
        return CompFactory.TrigMissingETHypoAlg(
            f"METHypoAlg_{self._suffix}", METContainerKey=self.outputKey
        )
 

make_passthrough_hypo_alg()

def python.HLT.MET.ConfigHelpers.AlgConfig.make_passthrough_hypo_alg	(		self,
			step
	)

Definition at line 259 of file ConfigHelpers.py.

    def make_passthrough_hypo_alg(self, step):
        return CompFactory.TrigStreamerHypoAlg(
            "METPassThroughHypo_" + self.name_step(step)
        )
 

make_reco_algs()

StepOutput python.HLT.MET.ConfigHelpers.AlgConfig.make_reco_algs	(		self,
			flags,
		**	recoDict
	)

Create the reconstruction sequences including the FEX

Returns a list of CAs split by step

Reimplemented in python.HLT.MET.AlgConfigs.NNHLTConfig, python.HLT.MET.AlgConfigs.MHTPufitConfig, python.HLT.MET.AlgConfigs.CVFPufitConfig, python.HLT.MET.AlgConfigs.PFOPufitConfig, python.HLT.MET.AlgConfigs.PFSumConfig, python.HLT.MET.AlgConfigs.TrkMHTConfig, python.HLT.MET.AlgConfigs.MHTConfig, python.HLT.MET.AlgConfigs.TCPufitConfig, python.HLT.MET.AlgConfigs.TCConfig, and python.HLT.MET.AlgConfigs.CellConfig.

Definition at line 162 of file ConfigHelpers.py.

    def make_reco_algs(self, flags, **recoDict) -> StepOutput:
        """Create the reconstruction sequences including the FEX
 
        Returns a list of CAs split by step
        """
 

make_reco_ca()

def python.HLT.MET.ConfigHelpers.AlgConfig.make_reco_ca	(		self,
			flags
	)

Make the reconstruction sequences for the new JO style

Definition at line 179 of file ConfigHelpers.py.

    def make_reco_ca(self, flags):
        """Make the reconstruction sequences for the new JO style"""
        # Retrieve the inputs
        log.verbose("Create inputs for %s", self._suffix)
        steps, inputs = self.inputRegistry.build_steps(
            flags, self._inputs, metFSRoIs, self.recoDict, return_ca=True
        )
        # Create the FEX and add it to the last input sequence
        fex = self.make_fex_accumulator(flags, self.fexName, inputs)
        fex.MonTool = self.getMonTool(flags)
        fex.METContainerKey = self.outputKey
        steps[-1].addEventAlgo(fex)
        return steps
 

name_step()

str python.HLT.MET.ConfigHelpers.AlgConfig.name_step	(		self,
			idx
	)

Definition at line 158 of file ConfigHelpers.py.

    def name_step(self, idx) -> str:
        return f"step{ascii_uppercase[idx]}_{self._suffix}"
 

outputKey()

str python.HLT.MET.ConfigHelpers.AlgConfig.outputKey

(

self

)

The MET container object produced by this algorithm

Definition at line 139 of file ConfigHelpers.py.

    def outputKey(self) -> str:
        """The MET container object produced by this algorithm"""
        from TrigEDMConfig.TriggerEDM import recordable
 
        return recordable("HLT_MET_{}".format(self._suffix))
 

Member Data Documentation

_suffix

python.HLT.MET.ConfigHelpers.AlgConfig._suffix

private

Definition at line 136 of file ConfigHelpers.py.

recoDict

python.HLT.MET.ConfigHelpers.AlgConfig.recoDict

Definition at line 135 of file ConfigHelpers.py.

---

The documentation for this class was generated from the following file:

• ConfigHelpers.py