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