ATLAS Offline Software
Public Member Functions | Public Attributes | Private Attributes | List of all members
python.ConfigFactory.ConfigFactory Class Reference
Collaboration diagram for python.ConfigFactory.ConfigFactory:

Public Member Functions

def __init__ (self, addDefaultBlocks=True)
 
def addAlgConfigBlock (self, algName, alg, defaults=None, pos=None, superBlocks=None)
 
def printAlgs (self, printOpts=True)
 
def makeConfig (self, name, **kwargs)
 
def addDefaultAlgs (self)
 

Public Attributes

 ROOTNAME
 

Private Attributes

 _algs
 
 _order
 

Detailed Description

This class provides a configuration manager that is intended to allow the user to:
    - define and configure functions that return an algSequence(?) object

Definition at line 110 of file ConfigFactory.py.

Constructor & Destructor Documentation

◆ __init__()

def python.ConfigFactory.ConfigFactory.__init__ (   self,
  addDefaultBlocks = True 
)

Definition at line 114 of file ConfigFactory.py.

114  def __init__(self, addDefaultBlocks=True):
115  self.ROOTNAME = 'root' # constant
116  self._algs = {}
117  self._order = {self.ROOTNAME: []}
118  if addDefaultBlocks:
119  self.addDefaultAlgs()
120 
121 

Member Function Documentation

◆ addAlgConfigBlock()

def python.ConfigFactory.ConfigFactory.addAlgConfigBlock (   self,
  algName,
  alg,
  defaults = None,
  pos = None,
  superBlocks = None 
)
Add class to list of available algorithms

Definition at line 122 of file ConfigFactory.py.

122  def addAlgConfigBlock(self, algName, alg, defaults=None, pos=None, superBlocks=None):
123  """Add class to list of available algorithms"""
124  if not callable(alg):
125  raise ValueError(f"{algName} is not a callable.")
126  opts = getFuncArgs(alg)
127 
128  if superBlocks is None:
129  superBlocks = [self.ROOTNAME]
130  elif not isinstance(superBlocks, list):
131  superBlocks = [superBlocks]
132 
133  # add new alg block to subAlgs dict of super block
134  for block in superBlocks:
135  if block not in self._order:
136  self._order[block] = []
137  order = self._order[block]
138 
139  if block == self.ROOTNAME:
140  algs = self._algs
141  else:
142  if block not in self._algs:
143  raise ValueError(f"{block} not added")
144  algs = self._algs[block].subAlgs
145 
146  if alg in algs:
147  raise ValueError(f"{algName} has already been added.")
148 
149  if block != self.ROOTNAME:
150  factoryName = f"{block}.{algName}"
151  else :
152  factoryName = algName
153 
154  # create FactoryBlock with alg information
155  algs[algName] = FactoryBlock(
156  alg=alg,
157  factoryName=factoryName,
158  algName=algName,
159  options=opts,
160  defaults=defaults,
161  subAlgs={}
162  )
163  # insert into order (list)
164  if pos is None:
165  order.append(algName)
166  elif pos in order:
167  order.insert(order.index(pos), algName)
168  else:
169  raise ValueError(f"{pos} does not exit in already added config blocks")
170  return
171 
172 

◆ addDefaultAlgs()

def python.ConfigFactory.ConfigFactory.addDefaultAlgs (   self)
add algorithms and options

Definition at line 230 of file ConfigFactory.py.

230  def addDefaultAlgs(self):
231  """add algorithms and options"""
232 
233  # CommonServices
234  from AsgAnalysisAlgorithms.AsgAnalysisConfig import CommonServices
235  self.addAlgConfigBlock(algName="CommonServices", alg=CommonServices)
236 
237  # pileup reweighting
238  from AsgAnalysisAlgorithms.AsgAnalysisConfig import PileupReweightingBlock
239  self.addAlgConfigBlock(algName="PileupReweighting", alg=PileupReweightingBlock)
240 
241  # event cleaning
242  from AsgAnalysisAlgorithms.EventCleaningConfig import EventCleaningBlock
243  self.addAlgConfigBlock(algName="EventCleaning", alg=EventCleaningBlock)
244 
245  # trigger
246  from TriggerAnalysisAlgorithms.TriggerAnalysisConfig import Trigger
247  self.addAlgConfigBlock(algName="Trigger", alg=Trigger)
248  from TriggerAnalysisAlgorithms.TriggerAnalysisSFConfig import TriggerAnalysisSFBlock
249  self.addAlgConfigBlock(algName="TriggerMatching", alg=TriggerAnalysisSFBlock)
250 
251  # jets
252  from JetAnalysisAlgorithms.JetAnalysisConfig import makeJetAnalysisConfig
253  self.addAlgConfigBlock(algName="Jets", alg=makeJetAnalysisConfig)
254  from JetAnalysisAlgorithms.JetJvtAnalysisConfig import JetJvtAnalysisConfig
255  self.addAlgConfigBlock(algName="JVT", alg=JetJvtAnalysisConfig,
256  superBlocks="Jets")
257  from JetAnalysisAlgorithms.BJetCalibAnalysisConfig import BJetCalibAnalysisConfig
258  self.addAlgConfigBlock(algName="BJetCalib", alg=BJetCalibAnalysisConfig,
259  superBlocks="Jets")
260  from FTagAnalysisAlgorithms.FTagTrigMatchAnalysisConfig import FTagJetTrigMatchingBlock
261  self.addAlgConfigBlock(algName="FTagTriggerMatching", alg=FTagJetTrigMatchingBlock,
262  superBlocks="Jets")
263  from FTagAnalysisAlgorithms.FTagAnalysisConfig import FTagConfig
264  self.addAlgConfigBlock(algName="FlavourTagging", alg=FTagConfig,
265  defaults={'selectionName': ''},
266  superBlocks="Jets")
267  from FTagAnalysisAlgorithms.FTagSFAnalysisConfig import FlavourTaggingEventSF
268  self.addAlgConfigBlock(algName="FlavourTaggingEventSF",
269  alg=FlavourTaggingEventSF,
270  defaults={'selectionName': ''},
271  superBlocks="Jets")
272  from FTagAnalysisAlgorithms.XbbAnalysisConfig import XbbConfig
273  self.addAlgConfigBlock(algName="XbbTagging", alg=XbbConfig,
274  superBlocks="Jets")
275 
276  # electrons
277  from EgammaAnalysisAlgorithms.ElectronAnalysisConfig import ElectronCalibrationConfig
278  self.addAlgConfigBlock(algName="Electrons", alg=ElectronCalibrationConfig)
279  from EgammaAnalysisAlgorithms.ElectronAnalysisConfig import ElectronWorkingPointConfig
280  self.addAlgConfigBlock(algName="WorkingPoint", alg=ElectronWorkingPointConfig,
281  superBlocks="Electrons")
282  from EgammaAnalysisAlgorithms.ElectronAnalysisConfig import ElectronLRTMergedConfig
283  self.addAlgConfigBlock(algName="LRTMerging", alg=ElectronLRTMergedConfig,
284  superBlocks="Electrons")
285  from EgammaAnalysisAlgorithms.ElectronAnalysisConfig import ElectronTriggerAnalysisSFBlock
286  self.addAlgConfigBlock(algName="TriggerSF", alg=ElectronTriggerAnalysisSFBlock,
287  superBlocks="Electrons")
288 
289  # photons
290  from EgammaAnalysisAlgorithms.PhotonAnalysisConfig import PhotonCalibrationConfig
291  self.addAlgConfigBlock(algName="Photons", alg=PhotonCalibrationConfig)
292  from EgammaAnalysisAlgorithms.PhotonAnalysisConfig import PhotonWorkingPointConfig
293  self.addAlgConfigBlock(algName="WorkingPoint", alg=PhotonWorkingPointConfig,
294  superBlocks="Photons")
295  from EgammaAnalysisAlgorithms.PhotonExtraVariablesConfig import PhotonExtraVariablesBlock
296  self.addAlgConfigBlock(algName="ExtraVariables", alg=PhotonExtraVariablesBlock,
297  superBlocks="Photons")
298 
299  # muons
300  from MuonAnalysisAlgorithms.MuonAnalysisConfig import MuonCalibrationConfig
301  self.addAlgConfigBlock(algName="Muons", alg=MuonCalibrationConfig)
302  from MuonAnalysisAlgorithms.MuonAnalysisConfig import MuonWorkingPointConfig
303  self.addAlgConfigBlock(algName="WorkingPoint", alg=MuonWorkingPointConfig,
304  superBlocks="Muons")
305  from MuonAnalysisAlgorithms.MuonAnalysisConfig import MuonTriggerAnalysisSFBlock
306  self.addAlgConfigBlock(algName="TriggerSF", alg=MuonTriggerAnalysisSFBlock,
307  superBlocks="Muons")
308  from MuonAnalysisAlgorithms.MuonAnalysisConfig import MuonLRTMergedConfig
309  self.addAlgConfigBlock(algName="LRTMerging", alg=MuonLRTMergedConfig,
310  superBlocks="Muons")
311  from MuonAnalysisAlgorithms.MuonAnalysisConfig import MuonContainerMergingConfig
312  self.addAlgConfigBlock(algName="ContainerMerging", alg=MuonContainerMergingConfig,
313  superBlocks="Muons")
314 
315  # tauJets
316  from TauAnalysisAlgorithms.TauAnalysisConfig import TauCalibrationConfig
317  self.addAlgConfigBlock(algName="TauJets", alg=TauCalibrationConfig)
318  from TauAnalysisAlgorithms.TauAnalysisConfig import TauWorkingPointConfig
319  self.addAlgConfigBlock(algName="WorkingPoint", alg=TauWorkingPointConfig,
320  superBlocks="TauJets")
321  from TauAnalysisAlgorithms.TauAnalysisConfig import TauTriggerAnalysisSFBlock
322  self.addAlgConfigBlock(algName="TriggerSF", alg=TauTriggerAnalysisSFBlock,
323  superBlocks="TauJets")
324 
325  # diTauJets
326  from TauAnalysisAlgorithms.DiTauAnalysisConfig import DiTauCalibrationConfig
327  self.addAlgConfigBlock(algName="DiTauJets", alg=DiTauCalibrationConfig)
328  from TauAnalysisAlgorithms.DiTauAnalysisConfig import DiTauWorkingPointConfig
329  self.addAlgConfigBlock(algName="WorkingPoint", alg=DiTauWorkingPointConfig,
330  superBlocks="DiTauJets")
331 
332  # tracks
333  from TrackingAnalysisAlgorithms.TrackingAnalysisConfig import InDetTrackCalibrationConfig
334  self.addAlgConfigBlock(algName="InDetTracks", alg=InDetTrackCalibrationConfig)
335  from TrackingAnalysisAlgorithms.TrackingAnalysisConfig import InDetTrackWorkingPointConfig
336  self.addAlgConfigBlock(algName="WorkingPoint", alg=InDetTrackWorkingPointConfig,
337  superBlocks="InDetTracks")
338 
339  # SystObjectLink
340  from AsgAnalysisAlgorithms.SystObjectLinkConfig import SystObjectLinkBlock
341  self.addAlgConfigBlock(algName="SystObjectLink", alg=SystObjectLinkBlock,
342  superBlocks=[self.ROOTNAME, "Jets", "Electrons", "Photons", "Muons", "TauJets"])
343 
344  # Particle-level truth algorithms
345  from TruthParticleLevelAnalysisAlgorithms.ParticleLevelElectronsConfig import ParticleLevelElectronsBlock
346  self.addAlgConfigBlock(algName="PL_Electrons", alg=ParticleLevelElectronsBlock)
347  from TruthParticleLevelAnalysisAlgorithms.ParticleLevelMuonsConfig import ParticleLevelMuonsBlock
348  self.addAlgConfigBlock(algName="PL_Muons", alg=ParticleLevelMuonsBlock)
349  from TruthParticleLevelAnalysisAlgorithms.ParticleLevelNeutrinosConfig import ParticleLevelNeutrinosBlock
350  self.addAlgConfigBlock(algName="PL_Neutrinos", alg=ParticleLevelNeutrinosBlock)
351  from TruthParticleLevelAnalysisAlgorithms.ParticleLevelJetsConfig import ParticleLevelJetsBlock
352  self.addAlgConfigBlock(algName="PL_Jets", alg=ParticleLevelJetsBlock)
353  from TruthParticleLevelAnalysisAlgorithms.ParticleLevelTausConfig import ParticleLevelTausBlock
354  self.addAlgConfigBlock(algName="PL_Taus", alg=ParticleLevelTausBlock)
355  from TruthParticleLevelAnalysisAlgorithms.ParticleLevelPhotonsConfig import ParticleLevelPhotonsBlock
356  self.addAlgConfigBlock(algName="PL_Photons", alg=ParticleLevelPhotonsBlock)
357  from TruthParticleLevelAnalysisAlgorithms.ParticleLevelMissingETConfig import ParticleLevelMissingETBlock
358  self.addAlgConfigBlock(algName="PL_MissingET", alg=ParticleLevelMissingETBlock)
359  from TruthParticleLevelAnalysisAlgorithms.ParticleLevelOverlapRemovalConfig import ParticleLevelOverlapRemovalBlock
360  self.addAlgConfigBlock(algName="PL_OverlapRemoval", alg=ParticleLevelOverlapRemovalBlock)
361 
362  # IFF truth classification
363  from AsgAnalysisAlgorithms.AsgAnalysisConfig import IFFLeptonDecorationBlock
364  self.addAlgConfigBlock(algName="IFFClassification", alg=IFFLeptonDecorationBlock,
365  superBlocks=["Electrons", "Muons",
366  "PL_Electrons", "PL_Muons"])
367  # MCTC truth classification
368  from AsgAnalysisAlgorithms.AsgAnalysisConfig import MCTCLeptonDecorationBlock
369  self.addAlgConfigBlock(algName="MCTCClassification", alg=MCTCLeptonDecorationBlock,
370  superBlocks=["Electrons", "Muons", "TauJets",
371  "PL_Electrons", "PL_Muons", "PL_Taus"])
372 
373  # generator level analysis
374  from AsgAnalysisAlgorithms.AsgAnalysisConfig import GeneratorAnalysisBlock
375  self.addAlgConfigBlock(algName="GeneratorLevelAnalysis", alg=GeneratorAnalysisBlock)
376 
377  # pT/Eta Selection
378  from AsgAnalysisAlgorithms.AsgAnalysisConfig import PtEtaSelectionBlock
379  self.addAlgConfigBlock(algName="PtEtaSelection", alg=PtEtaSelectionBlock,
380  defaults={'selectionName': ''},
381  superBlocks=[self.ROOTNAME,
382  "Jets", "Electrons", "Photons", "Muons", "TauJets", "DiTauJets",
383  "PL_Jets", "PL_Electrons", "PL_Photons", "PL_Muons", "PL_Taus", "PL_Neutrinos"])
384 
385  # met
386  from MetAnalysisAlgorithms.MetAnalysisConfig import MetAnalysisConfig
387  self.addAlgConfigBlock(algName="MissingET", alg=MetAnalysisConfig)
388 
389  # overlap removal
390  from AsgAnalysisAlgorithms.OverlapAnalysisConfig import OverlapAnalysisConfig
391  self.addAlgConfigBlock(algName="OverlapRemoval", alg=OverlapAnalysisConfig,
392  defaults={'configName': 'OverlapRemoval'})
393 
394  # object-based cutflow
395  from AsgAnalysisAlgorithms.AsgAnalysisConfig import ObjectCutFlowBlock
396  self.addAlgConfigBlock(algName='ObjectCutFlow', alg=ObjectCutFlowBlock)
397 
398  # jet reclustering
399  from JetAnalysisAlgorithms.JetReclusteringConfig import JetReclusteringBlock
400  self.addAlgConfigBlock(algName="JetReclustering", alg=JetReclusteringBlock)
401 
402  # jet reclustering calibration
403  from JetAnalysisAlgorithms.ReclusteredJetCalibrationConfig import ReclusteredJetCalibrationBlock
404  self.addAlgConfigBlock(algName="ReclusteredJetCalibration", alg=ReclusteredJetCalibrationBlock)
405 
406  # event selection
407  from EventSelectionAlgorithms.EventSelectionConfig import makeMultipleEventSelectionConfigs
408  self.addAlgConfigBlock(algName='EventSelection', alg=makeMultipleEventSelectionConfigs)
409 
410  # event-based cutflow
411  from AsgAnalysisAlgorithms.AsgAnalysisConfig import EventCutFlowBlock
412  self.addAlgConfigBlock(algName='EventCutFlow', alg=EventCutFlowBlock,
413  defaults={'containerName': 'EventInfo', 'selectionName': ''})
414 
415  # bootstraps
416  from AsgAnalysisAlgorithms.BootstrapGeneratorConfig import BootstrapGeneratorConfig
417  self.addAlgConfigBlock(algName='Bootstraps', alg=BootstrapGeneratorConfig)
418 
419  # per-event scale factor calculation
420  from AsgAnalysisAlgorithms.AsgAnalysisConfig import PerEventSFBlock
421  self.addAlgConfigBlock(algName='PerEventSF', alg=PerEventSFBlock)
422 
423  # per-event unified lepton scale factor calculation
424  from AsgAnalysisAlgorithms.LeptonSFCalculatorConfig import LeptonSFCalculatorBlock
425  self.addAlgConfigBlock(algName='LeptonSF', alg=LeptonSFCalculatorBlock)
426 
427  # thinning
428  from AsgAnalysisAlgorithms.AsgAnalysisConfig import OutputThinningBlock
429  self.addAlgConfigBlock(algName="Thinning", alg=OutputThinningBlock,
430  defaults={'configName': 'Thinning'})
431 
432  # selection decorations
433  from AsgAnalysisAlgorithms.AsgAnalysisConfig import SelectionDecorationBlock
434  self.addAlgConfigBlock(algName='SelectionDecoration',
435  alg=SelectionDecorationBlock)
436 
437  # di-tau mass calculator
438  from TauAnalysisAlgorithms.DiTauMassConfig import DiTauMassBlock
439  self.addAlgConfigBlock(algName="DiTauMMC", alg=DiTauMassBlock)
440 
441  # IFF fake background estimator
442  from AsgAnalysisAlgorithms.FakeBkgConfig import FakeBkgBlock
443  self.addAlgConfigBlock(algName='FakeBkgCalculator', alg=FakeBkgBlock)
444 
445  # VGamma overlap removal
446  from AsgAnalysisAlgorithms.VGammaORConfig import VGammaORBlock
447  self.addAlgConfigBlock(algName='VGammaOR', alg=VGammaORBlock)
448 
449  # output
450  from AsgAnalysisAlgorithms.OutputAnalysisConfig import OutputAnalysisConfig
451  self.addAlgConfigBlock(algName="Output", alg=OutputAnalysisConfig,
452  defaults={'configName': 'Output'})
453 
454  # IOStats printouts
455  from AsgAnalysisAlgorithms.AsgAnalysisConfig import IOStatsBlock
456  self.addAlgConfigBlock(algName="IOStats", alg=IOStatsBlock)
457 
458  # configuration printer
459  from AsgAnalysisAlgorithms.PrintToolConfigAlgConfig import PrintToolConfigAlgBlock
460  self.addAlgConfigBlock(algName="PrintConfiguration", alg=PrintToolConfigAlgBlock)
461 
462  return

◆ makeConfig()

def python.ConfigFactory.ConfigFactory.makeConfig (   self,
  name,
**  kwargs 
)
Returns:
    configSeq: configSequence object

Definition at line 203 of file ConfigFactory.py.

203  def makeConfig(self, name, **kwargs):
204  """
205  Returns:
206  configSeq: configSequence object
207  """
208  try:
209  if '.' in name:
210  algContext, algName = name.split('.')
211  block = self._algs[algContext].subAlgs[algName]
212  else:
213  block = self._algs[name]
214  except KeyError:
215  raise ValueError(f"{name} config block not found. Make sure context is correct.")
216  # Optional **kwargs are in the process of being retired. While the process is not fully complete
217  # we still need to allow them to be passed. However, for blocks where they have already been retired
218  # we want to raise an error so users don't experience undesirable behaviour where their extra options
219  # are being ignored, or run into related cryptic crashes.
220  already_fixed_blocks = {
221  'Electrons','Photons','Muons','TauJets','DiTauJets','MissingET','FlavourTagging','FlavourTaggingEventSF','XbbTagging',
222  'InDetTracks','KLFitter','PtEtaSelection','ObjectCutFlow','EventCutFlow','Thinning',
223  'IFFClassification','MCTCClassification','PerEventSF','SelectionDecoration','SystObjectLink'}
224  if kwargs and name.split('.')[-1] in already_fixed_blocks:
225  raise ValueError(f"Config block '{name}' no longer accepts **kwargs. Use config.setOptionValue('option', value) instead!")
226  configSeq, _ = block.makeConfig(kwargs)
227  return configSeq
228 
229 

◆ printAlgs()

def python.ConfigFactory.ConfigFactory.printAlgs (   self,
  printOpts = True 
)
Prints algorithms exposed to configuration

Definition at line 173 of file ConfigFactory.py.

173  def printAlgs(self, printOpts=True):
174  """Prints algorithms exposed to configuration"""
175  printed = [] # some subblocks exist for multiple superblocks
176  def printAlg(algs):
177  for alg, algInfo in algs.items():
178  algName = algInfo.alg.__name__
179  algOptions = algInfo.options
180  if algName not in printed:
181  printed.append(algName)
182  logCPAlgCfgFactory.info(f"\033[4m{alg}\033[0m -> \033[4m{algName}\033[0m")
183  if printOpts:
184  try:
185  if inspect.isclass(algInfo.alg):
186  # block
187  algInfo.alg().printOptions(verbose=printOpts)
188  else:
189  # make function
190  seq = ConfigSequence()
191  algInfo.alg(seq=seq)
192  seq.printOptions(verbose=printOpts)
193  except Exception:
194  # either a TypeError or something else due to missing args
195  # try to print something for casses with required args
196  for opt in algOptions:
197  logCPAlgCfgFactory.info(f" {opt}")
198  printAlg(algInfo.subAlgs)
199  printAlg(self._algs)
200  return
201 
202 

Member Data Documentation

◆ _algs

python.ConfigFactory.ConfigFactory._algs
private

Definition at line 116 of file ConfigFactory.py.

◆ _order

python.ConfigFactory.ConfigFactory._order
private

Definition at line 117 of file ConfigFactory.py.

◆ ROOTNAME

python.ConfigFactory.ConfigFactory.ROOTNAME

Definition at line 115 of file ConfigFactory.py.


The documentation for this class was generated from the following file:
python.processes.powheg.ZZj_MiNNLO.ZZj_MiNNLO.__init__
def __init__(self, base_directory, **kwargs)
Constructor: all process options are set here.
Definition: ZZj_MiNNLO.py:18
python.ConfigFactory.getFuncArgs
def getFuncArgs(func)
Definition: ConfigFactory.py:35