common Namespace Reference

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 949 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 861 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 921 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 141 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 856 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 842 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 851 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 996 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 991 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 1006 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 1017 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 644 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 1027 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 124 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 1022 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 34 of file common.py.

_folders_used

dictionary common._folders_used = {}

private

Definition at line 30 of file common.py.

_poolfiles_seen

dictionary common._poolfiles_seen = {}

private

Definition at line 27 of file common.py.