common.CaloClusterCorrSetup Class Reference

Collaboration diagram for common.CaloClusterCorrSetup:

Public Member Functions
def	make_corrections (self, flags, corrclass, key=None, suffix='', version=None, corrlist=None, cells_name=None, source=None, **kw)
def	lookup_version (self, flags, version, corrclass)
def	geom_match (self, datasource, geom)
def	get_generation (cls, flags)
def	make_ForPool (self, flags, keys, corrclass)
	Code for writing to pool. More...
def	maybe_make_correction_for_pool (self, flags, sgkeys, tool_names, key, cspec, corrclass)
def	add_dummies (self, sgkeys, valid_keys, generation)
def	config_for_pool (self, flags, keys, corrclass)

Private Member Functions
def	_geom_match1 (self, geom)

Detailed Description

Definition at line 161 of file common.py.

Member Function Documentation

_geom_match1()

def common.CaloClusterCorrSetup._geom_match1 (   self,   geom  )

private

Definition at line 344 of file common.py.

    def _geom_match1 (self, geom):
        for (pat, v) in self.geom_versions:
            if fnmatchcase (geom, pat):
                return v
        return None

add_dummies()

def common.CaloClusterCorrSetup.add_dummies	(		self,
			sgkeys,
			valid_keys,
			generation
	)

Definition at line 464 of file common.py.

    def add_dummies (self, sgkeys, valid_keys, generation):
        CaloDummyCorrection = CompFactory.CaloDummyCorrection # CaloClusterCorrection
        toolnames = {}
        for sgkey in sgkeys.keys():
            ll = sgkey.split ('-')
            if len(ll) == 1:
                name = ll[0]
            else:
                (name, ver) = ll
            toolnames[name] = 1
        for name in toolnames.keys():
            (corrclass, basename) = name.split ('.')
            sgkey = name + '-dummy'
            tagname = "%s.%s%s-dummy" % (corrclass, generation, basename)
            folder = '/CALO/%s/%s' % (corrclass, basename)
            sgkeys[sgkey] = []
            for key in valid_keys:
                toolname = basename + key + '-dummy'
                tool = CaloDummyCorrection (toolname)
                tool.prefix = key + '.'
                sgkeys[sgkey].append (tool)
                _alltools[toolname] = (folder, tagname, sgkey)
        return
 
 

config_for_pool()

def common.CaloClusterCorrSetup.config_for_pool	(		self,
			flags,
			keys,
			corrclass
	)

Definition at line 490 of file common.py.

    def config_for_pool (self, flags, keys, corrclass):
        result = ComponentAccumulator()
 
        corr_output_list = []
        tag_list = []
 
        generation = self.get_generation (flags)
 
        (sgkeys, ca) = self.make_ForPool (flags, keys, corrclass)
        ca.popPrivateTools()
        result.merge (ca)
        self.add_dummies (sgkeys, keys, generation)
 
        for (sgkey, tools) in sgkeys.items():
            if len (tools) == 0: continue
            name = 'write_' + sgkey
            name = name.replace ('.', '_')
 
            # In CaloRec
            alg = CompFactory.CaloClusterCorrDBWriter (name,
                                                       key = sgkey,
                                                       ClusterCorrectionTools = tools)
            result.addEventAlgo (alg)
                                                       
 
            corr_output_list.append ('CaloRec::ToolConstants#' +
                                     sgkey + '#' +
                                     folder (tools[0]))
            tag_list.append (tag (tools[0]))
 
        print ("Final OutputList:")
        print (corr_output_list)
        print (tag_list)
 
        return (corr_output_list, tag_list, result)
 
 

geom_match()

def common.CaloClusterCorrSetup.geom_match	(		self,
			datasource,
			geom
	)

Definition at line 349 of file common.py.

    def geom_match (self, datasource, geom):
        if not geom: geom = ''
        vv = self._geom_match1 (datasource + '-' + geom)
        if not vv:
            vv = self._geom_match1 (geom)
        if not vv:
            vv = self.newest_version
        tryhier = True
        if vv.startswith ('NOHIER#'):
            tryhier = False
            vv = vv[7:]
        return (vv, tryhier)
 
 

get_generation()

def common.CaloClusterCorrSetup.get_generation	(		cls,
			flags
	)

Definition at line 365 of file common.py.

    def get_generation (cls, flags):
        generation = cls.correction_generation_default
        gen2 = getattr (flags.Calo.ClusterCorrection, cls.correction_generation_flag_name)
        if gen2:
            generation = gen2
        if generation != '':
            generation = generation + '-'
        return generation
 
 

lookup_version()

def common.CaloClusterCorrSetup.lookup_version	(		self,
			flags,
			version,
			corrclass
	)

Definition at line 330 of file common.py.

    def lookup_version (self, flags, version, corrclass):
        vcorrlist = self.versions.get (version)
        if vcorrlist is None and version.startswith ('@'):
            findvers = _find_version_from_cool_tag (flags, version[1:], corrclass)
            vcorrlist = self.versions.get (findvers)
            if vcorrlist is None:
                vcorrlist = self.versions.get ('@')
        if vcorrlist is None:
            raise CaloCorrectionConfigError\
                  ("Can't find global correction version %s." % version)
        return (vcorrlist, version)
 
 

make_corrections()

def common.CaloClusterCorrSetup.make_corrections	(		self,
			flags,
			corrclass,
			key = None,
			suffix = '',
			version = None,
			corrlist = None,
			cells_name = None,
			source = None,
		**	kw
	)

Definition at line 190 of file common.py.

    def make_corrections (self,
                          flags,
                          corrclass,
                          key = None,
                          suffix = '',
                          version = None,
                          corrlist = None,
                          cells_name = None,
                          source = None,
                          **kw):
 
        # Make a logger.
        log = logging.getLogger ('CaloClusterCorrection')
 
        tryhier = False
 
        # First, find the appropriate overall version string to use,
        # if it wasn't specified explicitly.
        if version is None:
            # First see if the flag was set to override the version.
            # at the top-level.
            v = getattr (flags.Calo.ClusterCorrection, self.version_override_flag_name)
            if v:
                version = v
 
        if version is None:
            # No explicitly specified version.
            # Try to guess it from the data source + geometry string.
            # Otherwise, use the latest version.
            geom = flags.GeoModel.AtlasVersion
            datasource = 'geant4' if flags.Input.isMC else 'data'
            (version, tryhier) = self.geom_match (datasource, geom)
 
        # Get the correction generation.
        generation = self.get_generation(flags)
 
        # Use the default source if one wasn't specified.
        if source is None:
            source = flags.Calo.ClusterCorrection.defaultSource
 
        if not isinstance (source, list):
            source = [source]
        if CALOCORR_COOL not in source:
            tryhier = False
 
        if tryhier and version[0] != '@':
            cl = corrclass
            if flags.Input.isMC:
                cl = cl[0:4] + 'Ofl' + cl[4:]
            version = "@%s-%s%s" % (cl, generation, version)
 
        # Only use COOL if we're actually trying to resolve a COOL tag.
        # Otherwise we can run into problems: it looks like `ununsed'
        # COOL tags are removed in DB replicas.
        if version[0] != '@' and len(source) > 0:
            if CALOCORR_COOL in source:
                source.remove (CALOCORR_COOL)
 
        (vcorrlist, version) = self.lookup_version (flags, version, corrclass)
 
        # Default to the standard list if no explicit correction list.
        if corrlist is None:
            corrlist = vcorrlist
 
        log.debug ("%s corrections for %s (%s) using version %s" %
                  (self.name, key, suffix, version))
 
        # Now, walk through the list of corrections.
        out = ComponentAccumulator()
        tools = []
        for cspec in corrlist:
            (func, this_version, this_order, extra_args) = \
                   split_version_spec (cspec)
 
            # If the version or extra args isn't specified here,
            # look in the internal corrlist to see if we find it there.
            if this_version == '' or extra_args == []:
                for vcspec in vcorrlist:
                    if vcspec[0] == func:
                        (vfunc, vversion, vorder, vextra_args) = \
                                split_version_spec (vcspec)
                        if this_version == '':
                            this_version = vversion
                        if extra_args == []:
                            extra_args = vextra_args
                        if this_order == 0:
                            this_order = vorder
                        break
 
            elif version[0] == '@' and not corrlist:
                this_version = version #pragma: NO COVER
 
            if this_version == '@':
                this_version = version
 
            # Start building the other variables to use in the call.
            this_args = dict (extra_args)
            this_key = key
            this_suffix = suffix
            this_cells_name = cells_name
            this_source = source
 
            corrname = func.__name__
 
            # Look for any overriders in our keyword list.
            for (k, v) in kw.items():
                if k == corrname + '_suffix':
                    this_suffix = v
                elif k == corrname + '_key':
                    this_key = v
                elif k == corrname + '_cells_name':
                    this_cells_name = v
                elif k == corrname + '_source':
                    this_source = v
                elif k == corrname + '_version':
                    this_version = v
                elif k == corrname + '_order':
                    this_order = v
                elif k.startswith (corrname + '_'):
                    this_args[k[len(corrname)+1:]] = v
 
            # Make the tool.
            ca = func (flags,
                       this_cells_name,
                       this_suffix,
                       this_version,
                       this_key,
                       this_source,
                       generation = generation,
                       order = this_order,
                       **this_args)
            tools.append (out.popToolsAndMerge (ca))
 
        out.setPrivateTools (tools)
        return out
 
 

make_ForPool()

def common.CaloClusterCorrSetup.make_ForPool	(		self,
			flags,
			keys,
			corrclass
	)

Code for writing to pool.

Make a set of corrections for writing to pool.

Definition at line 379 of file common.py.

    def make_ForPool (self, flags, keys, corrclass):
        # Map from SG key to a list of tool instances.
        sgkeys = {}
 
        # Names of all tools made so far
        tool_names = set()
 
        # Map from (func, version) to (order, globversion).
        # For consistency checking.
        ordermap = {}
 
        result = ComponentAccumulator()
        tools = []
 
        # Go through each version, and make corrections.
        for (v,l) in self.versions.items():
            if v.startswith ('@'): continue
            last_order = 0
            last_funcname = '(none)'
            for c in l:
                # Consistency check: tool lists should be sorted in order.
                (func, version, order, extra_args) = split_version_spec (c)
                if order <= last_order:
                    raise CaloCorrectionConfigError\
                          ("Tools for global version %s are not in order!"
                           " %d(%s) < %d(%s)" % (v, order, func.__name__,
                                                 last_order, last_funcname))
                last_order = order
                last_funcname = func.__name__
 
                # Consistency check: a given tool func/version should
                # always have the same order setting.
                okey = (func, version)
                if okey not in ordermap:
                    ordermap[okey] = (order, v)
                elif ordermap[okey][0] != order:
                    raise CaloCorrectionConfigError\
                          ("Tool %s has order %d in %s but order %d in %s!" %
                           (func.__name__, order, v,
                            ordermap[okey][0], ordermap[okey][1]))
 
                # Find the list of valid keys for this tool.
                valid_keys = func (flags,
                                   None,
                                   version = version,
                                   key = '@VALID_KEYS')
                if valid_keys is None:
                    valid_keys = keys
                for key in valid_keys:
                    ca = self.maybe_make_correction_for_pool (flags,
                                                              sgkeys,
                                                              tool_names,
                                                              key, c,
                                                              corrclass)
                    if ca:
                        tools.append (ca.popPrivateTools())
                        result.merge (ca)
 
        result.setPrivateTools (tools)
 
        return (sgkeys, result)
 
 

maybe_make_correction_for_pool()

def common.CaloClusterCorrSetup.maybe_make_correction_for_pool	(		self,
			flags,
			sgkeys,
			tool_names,
			key,
			cspec,
			corrclass
	)

Definition at line 442 of file common.py.

    def maybe_make_correction_for_pool (self, flags,
                                        sgkeys, tool_names, key, cspec,
                                        corrclass):
        (func, version, order, extra_args) = split_version_spec (cspec)
        name = func.__name__ + '_' + version + '_' + key
        if name in tool_names:
            return None
        ca = func (flags,
                   None, '', version, key, CALOCORR_TOPOOL,
                   generation = self.get_generation (flags),
                   order = order)
        if ca is None:
            return None
        tool = ca.popPrivateTools()
        if tool is not None and folder(tool).find ('/' + corrclass + '/') >= 0:
            tool_names.add (name)
            sgkeys.setdefault (sgkey(tool), []).append (tool)
        ca.setPrivateTools (tool)
        return ca
 
 

---

The documentation for this class was generated from the following file:

• common.py