JetGrooming.py

Go to the documentation of this file.

# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
"""
JetGrooming: A module for classes encoding definitions of objects    
for configuring jet grooming
Author: TJ Khoo. P-A Delsart                                         
"""
 
__all__ =  ["GroomingDefinition","JetTrimming","JetSoftDrop"]
 
from AthenaCommon import Logging
from .Utilities import make_lproperty, onlyAttributesAreProperties, clonable, ldict
from copy import deepcopy
jetlog = Logging.logging.getLogger('JetGrooming')
 
@clonable
@onlyAttributesAreProperties
class GroomingDefinition(object):
    """ Base class to define grooming procedure. 
    Concrete classes will have to define the tooltype & groomalg class members
    and aslo a groomSpecAsStr() function.
 
    """
    _allowedattributes = ['_cflags','_contextDic'] # onlyAttributesAreProperties will add all properties to this list.
    tooltype = None
    groomalg = None
    def __init__(self, 
                 ungroomeddef,  # Ungroomed JetDefinition
                 modifiers=[],  # JetModifiers to run after grooming
                 suffix = '',   # allows to tune the full JetContainer name
                 lock=False,    # lock the properties of this instance to avoid accidental overwrite after __init__
                 context = None, # describe a context for which this definition will be used. See StandardJetContext
                 **properties   # any other argument is expected a grooming tool property
                 ): 
 
        self._ungroomeddef = ungroomeddef.clone() # clone to avoid messing with external jetdef
        self.inputdef = self._ungroomeddef.inputdef
        if lock: properties = ldict(properties) # ldict to freeze the properties
        self.properties = properties
 
        context = context if context is not None else ungroomeddef.context
        self._context = context
        self.suffix = suffix
        self._defineName()
 
        self.modifiers = modifiers 
        
        
        # used internally to resolve dependencies
        self._prereqDic = {}
        self._prereqOrder = [] 
        self._locked = lock
        self._cflags = None # pointer to AthenaConfiguration.ConfigFlags. Mainly to allow to invoke building of input dependencies which are outside Jet domain during std reco
        self._contextDic = None # pointer to the context dictionnary. Convenient shortcut used to configure input or modifier dependencies 
 
 
    def __hash__(self):
        return hash("")
 
    def __eq__(self,rhs):
        return self.__hash__() == rhs.__hash__()
 
    def __ne__(self,rhs):
        return (not self.__eq__(rhs))
 
    def lock(self):
        if not self._locked:
            self._locked = True
 
    # After dependency solving, we hold a reference to the AthConfigFlags,
    # which if unmodified is meant to function as a singleton throughout the
    # configuration. A full deep copy of this is expensive, and slows down
    # the HLT menu generation a lot due to copies in caches.
    # So we explicitly avoid the deepcopy of the flags here, and further
    # check that the flags are locked, to prevent accidental unlocking
    def __deepcopy__(self, memo):
        cls = self.__class__
        result = cls.__new__(cls)
        memo[id(self)] = result
        set_without_deepcopy = ['_cflags']
        for k, v in self.__dict__.items():
            if k in set_without_deepcopy:
                if v:
                    assert(v.locked())
                setattr(result, k, v)
            else:
                setattr(result, k, deepcopy(v, memo))
        return result
 
    # Define core attributes as properties, with
    # custom setter/getter such that if changed, these
    # force resetting of the jet name
    @make_lproperty
    def ungroomeddef(self): pass
    @ungroomeddef.lsetter
    def ungroomeddef(self,ungroomeddef):
        self._ungroomeddef = ungroomeddef.clone()
        self._defineName()
 
 
    @make_lproperty
    def properties(self): pass
    @make_lproperty
    def modifiers(self): pass
    @make_lproperty
    def suffix(self): pass
 
    @make_lproperty
    def context(self): pass
    
    # To be overriden in derived classes
    def groomSpecAsStr(self):
        raise Exception("Can not use a GroomingDefinition instance : use a derived class")
 
    def fullname(self):
        return self.ungroomeddef.prefix+self.basename+"Jets"+self.suffix
    
        
 
 
    def _defineName(self):
        # chop the label off so we can insert the trimming spec
        groomedName = self.ungroomeddef.basename + self.groomSpecAsStr()
        self.basename = groomedName
 
    # Define a string conversion for printing
    def __str__(self):
        return "JetGrooming({0})".format(self.basename)
    # Need to override __repr__ for printing in lists etc
    __repr__ = __str__
 
 
class JetTrimming(GroomingDefinition):
    groomalg = "Trim"
    tooltype = "JetGrooming::JetTrimming"
 
    def groomSpecAsStr(self):
        ptfrac = int( self.properties["PtFrac"] *100 ) # Not usually smaller than %
        from .JetDefinition import formatRvalue
        smallR = formatRvalue(self.properties["RClus"]*10)
        
        groomstr = "TrimmedPtFrac{}SmallR{}".format(ptfrac,smallR)
        return groomstr
    
 
class JetSoftDrop(GroomingDefinition):
    groomalg = "SoftDrop"
    tooltype = "JetGrooming::SoftDrop"
 
    def groomSpecAsStr(self):
        beta     = int( self.properties["Beta"] *100)
        zcut     = int( self.properties["ZCut"] *100)
        groomstr = "SoftDropBeta{}Zcut{}".format(beta,zcut)
        return groomstr