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','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 
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
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