Classes
class	CaloClusterCorrSetup

class	CaloCorrectionConfigError

Functions
def	split_version_spec (cspec)
	Code to handle creating the list of correction tools. More...

def	_find_version_from_cool_tag (flags, coolTag, corrclass)

def	makecorr (flags, versions, name, basename, suffix, version, key, sampling, source, confclass, corrclass, generation='', order=0, **kw)

def	_is_jo_source (s)

def	_is_pool_source (s)

def	_is_cool_source (s)

def	_config_from_jo (corr, jo, key, sampling, valid_keys, order)

def	_config_from_pool (flags, corr, poolfile, sgkey)

def	_config_from_cool (flags, corr, folder, tag)

def	_matchlen (a, b)

def	_longest_match (key, valid_keys)

def	_mung_prefix (corr, key, valid_keys)

def	folder (tool)

def	tag (tool)

def	sgkey (tool)

Variables
dictionary	_poolfiles_seen = {}

dictionary	_folders_used = {}

dictionary	_alltools = {}

Function Documentation

◆ _config_from_cool()

def common._config_from_cool	(	flags,
		corr,
		folder,
		tag
	)

private

Definition at line 950 of file common.py.

 def _config_from_cool (flags, corr, folder, tag):
     # Folder name has form /CALO/CORRCLASS/NAME
     # Find the subdetector name string to use.
     fsplit = folder.split ('/')
     if fsplit[2] == 'Ofl':
        corrclass = folder.split ('/')[4]
     else:   
        corrclass = folder.split ('/')[3]
     sndict = flags.Calo.ClusterCorrection.dbSubdetName
     subdetname = sndict.get (corrclass)
     if not subdetname:
         subdetname = sndict.get (None)
  
     corr.DBHandleKey = folder
  
     # We can't use more than one tag from a folder.
     oldtag = _folders_used.get (folder)
     if oldtag is not None and oldtag != tag:
         return False
  
     ca = ComponentAccumulator()
  
     _folders_used[folder] = tag
     if oldtag is None:
         from IOVDbSvc.IOVDbSvcConfig import addFolders
         tagstr = '' if tag =='@GLOBAL' else tag
         sdsuffix = '_OFL' if 'Ofl' in folder else ''
         ca.merge (addFolders (flags,
                               folder,
                               detDb = subdetname + sdsuffix,
                               className = 'CaloRec::ToolConstants',
                               tag = tagstr))
                                
         log = logging.getLogger ('CaloClusterCorrection')
         log.debug ("Adding cool folder `%s' for subdetector name %s" %
                    (folder, subdetname))
     return ca
  
  
 # When we're reading from pool/cool, the prefix _must_ be one that
 # exists in the file.  Here, we see if the key is on the list of known
 # keys.  If not, then we substitute.

◆ _config_from_jo()

def common._config_from_jo	(	corr,
		jo,
		key,
		sampling,
		valid_keys,
		order
	)

private

Definition at line 862 of file common.py.

 def _config_from_jo (corr, jo, key, sampling, valid_keys, order):
     # Split off the last dotted field as paramclass.
     xjo = jo.split ('.')
     paramclass = xjo[-1]
     modname = '.'.join (xjo[:-1])
  
     # If not otherwise specified, try to find the module
     # in CaloClusterCorrection.
     if modname.find ('.') < 0:
         modname = 'CaloClusterCorrection.' + modname
  
     # Import the module and look up the class.
     mod = __import__ (modname, globals(), locals(), [paramclass])
     parms = getattr (mod, paramclass)
  
     # It may be sampling-dependent.
     if isinstance (parms, dict) and sampling is not None:
         parms = parms[sampling]
  
     if order != 0 and hasattr (corr, 'order'):
         corr.order = order
     if hasattr (corr, 'isDummy'):
         corr.isDummy = 0
  
     log = logging.getLogger ('CaloClusterCorrection')
  
     # Go through the names in the class and assign them to the tool.
     for (k, val) in parms.__dict__.items():
         # Skip internal names.
         if k[0] != '_':
             try:
                 # First try looking up the key.
                 # Note: don't test on val's type here --- it may
                 # be an object instance that implements __getitem__.
                 # We have to try the lookup and catch the error.
                 val = val[key]
             except KeyError:
                 # We can do a lookup, but didn't find the key.
                 # Use the default key instead.
                 default_keys = parms.__dict__.get ('_default_keys')
                 if default_keys:
                     defkey = _longest_match (key, default_keys)
                 elif valid_keys:
                     defkey = _longest_match (key, valid_keys)
                 else:
                     defkey = CALOCORR_DEFAULT_KEY
                 val = val[defkey]
  
                 log.debug (" correction %s from JO using %s instead of %s" %
                            (corr.getName(), defkey, key))
  
             except TypeError:
                 # Can't look up a key in val --- just use val as-is.
                 pass
  
             setattr (corr, k, val)
     return True
  
  
 # Configure a correction tool from POOL.

◆ _config_from_pool()

def common._config_from_pool	(	flags,
		corr,
		poolfile,
		sgkey
	)

private

Definition at line 922 of file common.py.

 def _config_from_pool (flags, corr, poolfile, sgkey):
     if not poolfile or not poolfiles[poolfile]:
         return False
     
     ca = ComponentAccumulator()
  
     # If this is the first time we've seen this file,
     # add it to CondProxyProvider.
     if poolfile not in  _poolfiles_seen:
         from EventSelectorAthenaPool.CondProxyProviderConfig import CondProxyProviderCfg
         ca.merge (CondProxyProviderCfg (flags, [poolfiles[poolfile]]))
  
     # Tell the tool to look in pool for this key.
     corr.DBHandleKey = sgkey
  
     # Set up a conditions algorithm to convert from the data in DetectorStore
     # to a conditions object.
     ToolConstantsCondAlg = CompFactory.ToolConstantsCondAlg # CaloRec
  
     name = 'ToolConstantsCondAlg_' + sgkey.replace ('.', '_')
     alg = ToolConstantsCondAlg (name,
                                 DetStoreKey = sgkey,
                                 ToolConstantsKey = sgkey)
     ca.addCondAlgo (alg)
     return ca
  
  
 # Configure a correction tool from COOL.

◆ _find_version_from_cool_tag()

def common._find_version_from_cool_tag	(	flags,
		coolTag,
		corrclass
	)

private

Definition at line 142 of file common.py.

 def _find_version_from_cool_tag (flags, coolTag, corrclass):
     if coolTag == 'GLOBAL':
         coolTag = flags.IOVDb.GlobalTag
  
     if flags.Input.isMC:    
         folderset = "/CALO/Ofl/" + corrclass
         connstring = 'COOLOFL_CALO/OFLP200'
     else:   
         folderset = "/CALO/" + corrclass
         connstring = 'COOLONL_CALO/' + flags.IOVDb.DatabaseInstance
  
     from CoolConvUtilities import AtlCoolLib
     db = AtlCoolLib.indirectOpen (connstring, readOnly=True)
     ff = db.getFolderSet (folderset)
     t = ff.resolveTag (coolTag)
     #  CaloOflSwClusterCorrections.00-02-12-calhits-v9
     l = t.split ('-')
     return '-'.join (l[4:])
  
  

◆ _is_cool_source()

def common._is_cool_source ( s )

private

Definition at line 857 of file common.py.

 def _is_cool_source (s):
     return s == CALOCORR_COOL
  
  
 # Configure a correction tool from job options.

◆ _is_jo_source()

def common._is_jo_source ( s )

private

Definition at line 843 of file common.py.

 def _is_jo_source (s):
     if s == CALOCORR_COOL: return 0
     if s == CALOCORR_POOL: return 0
     if s in poolfiles: return 0
     if s.find ('.') > 0: return 1
     return 0
  
  
 # Test to see if S looks like a pool source.

◆ _is_pool_source()

def common._is_pool_source ( s )

private

Definition at line 852 of file common.py.

 def _is_pool_source (s):
     return s in poolfiles
  
  
 # Test to see if S looks like a cool source.

◆ _longest_match()

def common._longest_match	(	key,
		valid_keys
	)

private

Definition at line 997 of file common.py.

 def _longest_match (key, valid_keys):
     if not isinstance (valid_keys, list):
         valid_keys = [valid_keys]
     if valid_keys is None or key in valid_keys:
         return key
     new_key = valid_keys[0]
     for k in valid_keys[1:]:
         if _matchlen (key, k) > _matchlen (key, new_key):
             new_key = k
     return new_key

◆ _matchlen()

def common._matchlen	(	a,
		b
	)

private

Definition at line 992 of file common.py.

 def _matchlen (a, b):
     i = 0
     while i < len(a) and i < len(b) and a[i] == b[i]:
         i = i+1
     return i

◆ _mung_prefix()

def common._mung_prefix	(	corr,
		key,
		valid_keys
	)

private

Definition at line 1007 of file common.py.

 def _mung_prefix (corr, key, valid_keys):
     if valid_keys is None or key in valid_keys: return
  
     # Find the best match.
     new_key = _longest_match (key, valid_keys)
  
     new_prefix = new_key + corr.prefix[len(key):]
     corr.prefix = new_prefix
     return
  
 # Return the folder for a tool.

◆ folder()

def common.folder ( tool )

Definition at line 1018 of file common.py.

 def folder (tool):
     return _alltools[tool.getName()][0]
  
  
 # Return the tag for a tool.

◆ makecorr()

def common.makecorr	(		flags,
			versions,
			name,
			basename,
			suffix,
			version,
			key,
			sampling,
			source,
			confclass,
			corrclass,
			generation = `''`,
			order = `0`,
		**	kw
	)

Definition at line 645 of file common.py.

 def makecorr (flags,
               versions,
               name,
               basename,
               suffix,
               version,
               key,
               sampling,
               source,
               confclass,
               corrclass,
               generation = '',
               order = 0,
               **kw):
  
     # If no version specified, use the last one in the table.
     if version is None:
         version = versions[-1][0]
  
     # Try to find the requested version.
     for v in versions:
         if v[0] == version:
             break
     else:
         if version.startswith ('@'):
             # A COOL tag is requested.
             # Look for a table entry of `@'; otherwise, use the last entry.
             for v in versions:
                 if v[0] == '@':
                     break
             else:
                 v = versions[-1]
         else:
             raise CaloCorrectionConfigError \
                   ("Can't find version `%s' for correction named `%s'." %
                    (version, basename))
  
     # The valid keys.
     valid_keys = None
     if len (v) >= 4:
         valid_keys = v[3]
  
     # Handle @VALID_KEYS request.
     if key == '@VALID_KEYS':
         return valid_keys
  
     # Use the default source if one wasn't specified.
     if source is None:
         source = flags.Calo.ClusterCorrection.defaultSource
  
     # Test to see if this correction specifies nopool.
     nopool = CALOCORR_NOPOOL in v[2]
  
     # Don't try to write a nopool tool to pool.
     if nopool and source == CALOCORR_TOPOOL:
         return None
  
     # Find the SG key and cool tag.
     if version.startswith ('@'):
         sgkey = None
         if version == '@GLOBAL':
             fulltag = version
         else:
             fulltag = version[1:]
  
         if not nopool:
             # Must read from cool in this case.
             source = CALOCORR_COOL
     else:
         # Construct the SG key name.
         tmp = basename
         if version != '':
             tmp = tmp + "-" + version
         sgkey = "%s.%s" % (corrclass, tmp)
         fulltag = "%s.%s%s" % (corrclass, generation, tmp)
         if flags.Input.isMC:
             fulltag = fulltag[0:4] + 'Ofl' + fulltag[4:]
  
     # The cool folder name.
     if not flags.Input.isMC:
        folder = "/CALO/%s/%s" % (corrclass, basename)
     else:   
        folder = "/CALO/Ofl/%s/%s" % (corrclass, basename)
  
     # Prefix to locate constants in the ToolConstants block.
     prefix = key + sampnames[sampling] + "."
   
     # Construct a default tool name if one isn't specified.
     if name is None:
         name = basename
         name = name + sampnames[sampling]
         if version != '':
             vv = version
             if vv[0] == '@':
                 vv = vv[1:]
             vv = vv.split('-')[-1]
             name = name + "_" + vv
         if key != '':
             name = name + "_" + key
  
     # Add a suffix if given.
     if suffix is not None:
         name = name + suffix
  
     # If this tool was defined earlier, check consistency.
     if name in _alltools:
         if _alltools[name] != (folder, fulltag, sgkey):
             raise CaloCorrectionConfigError ( #pragma: NO COVER
                   "Inconsistent configuration of tool %s.  Old (folder,tag,sgkey)=%s; new=%s" % #pragma: NO COVER
                    (name, _alltools[name], (folder, fulltag, sgkey))) #pragma: NO COVER
     else:
         _alltools[name] = (folder, fulltag, sgkey)
  
     # If no class was explicitly specified, take it from the table.
     if confclass is None:
         confclass = v[1]
  
     # It may be sampling-dependent.
     if isinstance (confclass, dict) and sampling is not None:
         confclass = confclass[sampling]
  
     result = ComponentAccumulator()
  
     # Create the tool!
     corr = confclass (name)
  
     # Set the prefix for all pool-capable tools.
     if not nopool:
         corr.prefix = prefix
  
     # Try to find a source from which to configure it.
     if not isinstance (source, list):
         source = [source]
     avail = v[2]
     wherefrom = None
     for s in source:
         if s == CALOCORR_JO or s == CALOCORR_TOPOOL:
             sel = [x for x in avail if _is_jo_source (x)]
             if len (sel) > 0 and _config_from_jo(corr, sel[0], key,
                                                  sampling , valid_keys,
                                                  order):
                 wherefrom = sel[0]
                 break
  
         elif s == CALOCORR_POOL:
             sel = [x for x in avail if _is_pool_source (x)]
             if len (sel) > 0:
                 ca2 = _config_from_pool (flags, corr, sel[0], sgkey)
                 if ca2:
                     result.merge (ca2)
                     _mung_prefix (corr, key, valid_keys)
                     wherefrom = sel[0]
                     break
  
         elif s == CALOCORR_COOL:
             sel = [x for x in avail if _is_cool_source (x)]
             if len (sel) > 0:
                 ca2 = _config_from_cool (flags, corr, folder, fulltag)
                 if ca2:
                     result.merge (ca2)
                     _mung_prefix (corr, key, valid_keys)
                     wherefrom = 'cool'
                     break
  
         elif _is_jo_source (s):
             if _config_from_jo (corr, s, key, sampling, valid_keys, order):
                 wherefrom = s
                 break
  
         elif _is_pool_source (s):
             ca2 = _config_from_pool (flags, corr, s, sgkey)
             if ca2:
                 result.merge (ca2)
                 _mung_prefix (corr, key, valid_keys)
                 wherefrom = s
                 break
  
     if wherefrom is None:
         raise CaloCorrectionConfigError \
               ("Can't find any source to configure tool `%s'.  Sources: %s" %
                (name, source))
   
     log = logging.getLogger ('CaloClusterCorrection')
     log.debug (" correction %s (%s, from %s)" % (name, confclass.__name__,
                                                 wherefrom))
  
     # If any other keyword arguments were passed, make those assignments.
     # This will override anything otherwise read from JO/pool.
     for (k, val) in kw.items():
         if val is not None:
             setattr (corr, k, val)
  
     # Done!
     result.setPrivateTools (corr)
     return result
  
  
 # Test to see if S looks like a job options source.

◆ sgkey()

def common.sgkey ( tool )

Definition at line 1028 of file common.py.

 def sgkey (tool):
     return _alltools[tool.getName()][2]

◆ split_version_spec()

def common.split_version_spec ( cspec )

Code to handle creating the list of correction tools.

The common code is in the class CaloClusterCorrSetup. You are expected to derive from it for your cluster type, and then create an instance. The following class variables must be defined in the derived class: name: A short descriptive name of the type of cluster (to be written to the log file)

version_override_flag_name: Name of flag. If set, it overrides the selected correction version.

correction_generation_flag_name: Name of flag. If set, this gives the correction generation string that's embedded in tags written to the database. This string should be changed for each write to the database.

correction_generation_default: Default value for the generation string, if the job property isn't set.

versions: The table of all known correction versions. Should be a dictionary; the keys are correction version names, and the values are correction lists. A correction list is a list of individual corrections:

[[CORR], [CORR], ...]

where each individual correction here is also a list:

[CORRFUNC, [VERSION,] [ORDER,] ARGS...]

CORRFUNC is a function to call to create the correction; it should have the signature:

def CORRFUNC (cells_name, suffix, version, key, source, **kw):

VERSION is a string giving the correction version. It may be omitted, and defaults to an empty string. It may also be ‘’, in which case the global version string is used instead.

ORDER is an integer, giving the order in which the tools are intended to run. Not currently used (they were used by the metatool), but retained in case we want to use this for checking.

The remainder of the list should be a set of (NAME,VALUE) tuples giving correction parameters to override. This may be (and usually should be) empty.

A key of ‘’ is used if the global correction version is tag-based (starts with ‘’).

geom_versions: The mapping between geometry versions and corrections versions. A list of lists, each of which has the form

[ GEOM-PATTERN, CORRECTION-VERSION ]

Here, GEOM-PATTERN is a string that's matched against the geometry version string. It may contain glob-style wildcards (as implemented by fnmatch). CORRECTION-VERSION is a string giving the correction version to use. The patterns are tried in order; first to match wins.

newest_version: The name of the newest version. This will be used if there's no match for the geometry string.

Definition at line 125 of file common.py.

 def split_version_spec (cspec):
     func = cspec[0]
     version = ''
     order = 0
     ii = 1
     if ii < len(cspec) and isinstance (cspec[ii], str):
         version = cspec[ii]
         ii += 1
     if ii < len(cspec) and isinstance (cspec[ii], int):
         order = cspec[ii]
         ii += 1
     extra_args = cspec[ii:]
     return (func, version, order, extra_args)
  
  
 # Given a cool tag (or GLOBAL for the currently-configured global tag),
 # return the version of the correction set to use.

◆ tag()

def common.tag ( tool )

Definition at line 1023 of file common.py.

 def tag (tool):
     return _alltools[tool.getName()][1]
  
  
 # Return the SG key for a tool.

Variable Documentation

◆ _alltools

dictionary common._alltools = {}

private

Definition at line 35 of file common.py.

◆ _folders_used

dictionary common._folders_used = {}

private

Definition at line 31 of file common.py.

◆ _poolfiles_seen

dictionary common._poolfiles_seen = {}

private

Definition at line 28 of file common.py.

Classes

Functions

Variables

Function Documentation

◆ _config_from_cool()

◆ _config_from_jo()

◆ _config_from_pool()

◆ _find_version_from_cool_tag()

◆ _is_cool_source()

◆ _is_jo_source()

◆ _is_pool_source()

◆ _longest_match()

◆ _matchlen()

◆ _mung_prefix()

◆ folder()

◆ makecorr()

◆ sgkey()

◆ split_version_spec()

◆ tag()

Variable Documentation

◆ _alltools

◆ _folders_used

◆ _poolfiles_seen