ATLAS Offline Software
ConfigFactory.py
Go to the documentation of this file.
1 # Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
2 
3 # This file defines a factory method that can create a configuration
4 # block sequence based on a passed in name. This avoids having to
5 # import all the various config block sequence makers in the
6 # configuration code, and also would make it easier to create them
7 # from a text configuration file.
8 
9 # This relies heavily on the blocks exposing all configurable
10 # parameters as options, since there is no other mechanism to
11 # configure them through this interface.
12 
13 # The implementation itself is probably not the best possible, it
14 # lacks all extensibility, gathers all information in a single place,
15 # etc. Still for now (08 Dec 22) this ought to be good enough.
16 
17 
18 import inspect
19 from AnalysisAlgorithmsConfig.ConfigSequence import ConfigSequence
20 
21 from AnaAlgorithm.Logging import logging
22 logCPAlgCfgFactory = logging.getLogger('CPAlgCfgFactory')
23 
24 
25 def getDefaultArgs(func):
26  """return dict(par, val) with all func parameters with defualt values"""
27  signature = inspect.signature(func)
28  return {
29  k: v.default
30  for k, v in signature.parameters.items()
31  if v.default is not inspect.Parameter.empty
32  }
33 
34 
35 def getFuncArgs(func):
36  """return list of input parameters"""
37  if inspect.isclass(func):
38  args = list(inspect.signature(func.__init__).parameters.keys())
39  args.remove('self')
40  else:
41  args = list(inspect.signature(func).parameters.keys())
42  return args
43 
44 
45 # class for config block information
46 class FactoryBlock():
47  """
48  """
49  def __init__(self, alg, factoryName, algName, options, defaults, subAlgs=None):
50  self.alg = alg
51  self.factoryName = factoryName
52  self.algName = algName
53  self.options = options
54  self.defaults = defaults
55  if subAlgs is None:
56  self.subAlgs = {}
57  else:
58  self.subAlgs = subAlgs
59 
60 
61  def makeConfig(self, funcOptions):
62  """
63  Parameters
64  ----------
65  funcName: str
66  name associated with the algorithm. This name must have been added to the
67  list of available algorithms
68  funcOptions: dict
69  dictionary containing options for the algorithm read from the YAML file
70 
71  Returns
72  -------
73  configSequence
74  """
75  configSeq = ConfigSequence()
76 
77  func = self.alg
78  funcName = self.algName
79  funcDefaults = getDefaultArgs(func)
80  defaults = self.defaults
81 
82  args = {}
83  # loop over all options for the function
84  for arg in getFuncArgs(func):
85  # supplied from config file
86  if arg in funcOptions:
87  args[arg] = funcOptions[arg]
88  # defaults set in function def
89  elif arg in funcDefaults:
90  args[arg] = funcDefaults[arg]
91  # defaults provided when func was added
92  elif defaults is not None and arg in defaults:
93  args[arg] = defaults[arg]
94  elif arg == 'seq':
95  # 'seq' should be first arg of func (not needed for class)
96  args[arg] = configSeq
97  elif arg == 'kwargs':
98  # cannot handle arbitrary parameters
99  continue
100  else:
101  raise ValueError(f"{arg} is required for {funcName}")
102  if inspect.isclass(func):
103  configSeq.append(func(**args))
104  else:
105  func(**args)
106  configSeq.setFactoryName(self.factoryName)
107  return configSeq, args.keys()
108 
109 
111  """This class provides a configuration manager that is intended to allow the user to:
112  - define and configure functions that return an algSequence(?) object
113  """
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 
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 
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 
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 
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
python.ConfigFactory.FactoryBlock.__init__
def __init__(self, alg, factoryName, algName, options, defaults, subAlgs=None)
Definition: ConfigFactory.py:49
python.ConfigFactory.ConfigFactory.printAlgs
def printAlgs(self, printOpts=True)
Definition: ConfigFactory.py:173
python.ConfigFactory.ConfigFactory
Definition: ConfigFactory.py:110
python.ConfigFactory.getDefaultArgs
def getDefaultArgs(func)
Definition: ConfigFactory.py:25
python.ConfigFactory.getFuncArgs
def getFuncArgs(func)
Definition: ConfigFactory.py:35
python.ConfigFactory.FactoryBlock
Definition: ConfigFactory.py:46
python.ConfigFactory.FactoryBlock.defaults
defaults
Definition: ConfigFactory.py:54
python.ConfigFactory.ConfigFactory.addDefaultAlgs
def addDefaultAlgs(self)
Definition: ConfigFactory.py:230
python.ConfigFactory.FactoryBlock.factoryName
factoryName
Definition: ConfigFactory.py:51
python.ConfigFactory.FactoryBlock.makeConfig
def makeConfig(self, funcOptions)
Definition: ConfigFactory.py:61
python.ConfigFactory.ConfigFactory.makeConfig
def makeConfig(self, name, **kwargs)
Definition: ConfigFactory.py:203
python.ConfigFactory.FactoryBlock.alg
alg
Definition: ConfigFactory.py:50
python.ConfigFactory.ConfigFactory._order
_order
Definition: ConfigFactory.py:117
histSizes.list
def list(name, path='/')
Definition: histSizes.py:38
python.ConfigFactory.FactoryBlock.options
options
Definition: ConfigFactory.py:53
python.ConfigFactory.ConfigFactory._algs
_algs
Definition: ConfigFactory.py:116
python.ConfigFactory.ConfigFactory.addAlgConfigBlock
def addAlgConfigBlock(self, algName, alg, defaults=None, pos=None, superBlocks=None)
Definition: ConfigFactory.py:122
python.ConfigFactory.ConfigFactory.__init__
def __init__(self, addDefaultBlocks=True)
Definition: ConfigFactory.py:114
python.ConfigFactory.ConfigFactory.ROOTNAME
ROOTNAME
Definition: ConfigFactory.py:115
python.ConfigFactory.FactoryBlock.subAlgs
subAlgs
Definition: ConfigFactory.py:56
python.ConfigFactory.FactoryBlock.algName
algName
Definition: ConfigFactory.py:52