MonitoringBranchingFractions Class Reference

Public Member Functions
	__init__ (self)
	getExclusive (self, particle)
	getInclusive (self, particle)
	getBranchingFraction (self, particle, branching_fractions)
	loadExclusiveBranchingFractions (self, filename)
	loadInclusiveBranchingFractions (self, exclusive_branching_fractions)

Public Attributes
	exclusive_branching_fractions = self.loadExclusiveBranchingFractions(decay_file)
	exclusive branching fractions
	inclusive_branching_fractions = self.loadInclusiveBranchingFractions(self.exclusive_branching_fractions)
	inclusive branching fractions

Static Protected Attributes
	_shared = None
	is the monitoring shared

Detailed Description

 Class extracts the branching fractions of a decay channel from the DECAY.DEC file. 

Definition at line 484 of file monitoring.py.

Constructor & Destructor Documentation

__init__()

__init__

(

self

)

Create a new MonitoringBranchingFraction object.
The extracted branching fractions are cached, hence creating more than one object does not do anything.

Definition at line 489 of file monitoring.py.

    def __init__(self):
        """
        Create a new MonitoringBranchingFraction object.
        The extracted branching fractions are cached, hence creating more than one object does not do anything.
        """
        if MonitoringBranchingFractions._shared is None:
            decay_file = get_default_decayfile()
            
            self.exclusive_branching_fractions = self.loadExclusiveBranchingFractions(decay_file)
            
            self.inclusive_branching_fractions = self.loadInclusiveBranchingFractions(self.exclusive_branching_fractions)
            MonitoringBranchingFractions._shared = (self.exclusive_branching_fractions, self.inclusive_branching_fractions)
        else:
            self.exclusive_branching_fractions, self.inclusive_branching_fractions = MonitoringBranchingFractions._shared
 

Member Function Documentation

getBranchingFraction()

getBranchingFraction	(		self,
			particle,
			branching_fractions )

 Returns the branching fraction of a particle given a branching_fraction table. 

Definition at line 512 of file monitoring.py.

    def getBranchingFraction(self, particle, branching_fractions):
        """ Returns the branching fraction of a particle given a branching_fraction table. """
        result = {c.label: 0.0 for c in particle.channels}
        name = particle.name
        channels = [tuple(sorted(d.split(':')[0] for d in channel.daughters)) for channel in particle.channels]
        if name not in branching_fractions:
            name = pdg.conjugate(name)
            channels = [tuple(pdg.conjugate(d) for d in channel) for channel in channels]
            if name not in branching_fractions:
                return result
        for c, key in zip(particle.channels, channels):
            if key in branching_fractions[name]:
                result[c.label] = branching_fractions[name][key]
        return result
 

getExclusive()

getExclusive	(		self,
			particle )

 Returns the exclusive (i.e. without the branching fractions of the daughters) branching fraction of a particle. 

Definition at line 504 of file monitoring.py.

    def getExclusive(self, particle):
        """ Returns the exclusive (i.e. without the branching fractions of the daughters) branching fraction of a particle. """
        return self.getBranchingFraction(particle, self.exclusive_branching_fractions)
 

getInclusive()

getInclusive	(		self,
			particle )

 Returns the inclusive (i.e. including all branching fractions of the daughters) branching fraction of a particle. 

Definition at line 508 of file monitoring.py.

    def getInclusive(self, particle):
        """ Returns the inclusive (i.e. including all branching fractions of the daughters) branching fraction of a particle. """
        return self.getBranchingFraction(particle, self.inclusive_branching_fractions)
 

loadExclusiveBranchingFractions()

loadExclusiveBranchingFractions	(		self,
			filename )

Load branching fraction from MC decay-file.

Definition at line 527 of file monitoring.py.

    def loadExclusiveBranchingFractions(self, filename):
        """
        Load branching fraction from MC decay-file.
        """
 
        def isFloat(element):
            """ Checks if element is a convertible to float"""
            try:
                float(element)
                return True
            except ValueError:
                return False
 
        def isValidParticle(element):
            """ Checks if element is a valid pdg name for a particle"""
            try:
                pdg.from_name(element)
                return True
            except LookupError:
                return False
 
        branching_fractions = {'UNKOWN': {}}
 
        mother = 'UNKOWN'
        with open(filename) as f:
            for line in f:
                fields = line.split(' ')
                fields = [x for x in fields if x != '']
                if len(fields) < 2 or fields[0][0] == '#':
                    continue
                if fields[0] == 'Decay':
                    mother = fields[1].strip()
                    if not isValidParticle(mother):
                        mother = 'UNKOWN'
                    continue
                if fields[0] == 'Enddecay':
                    mother = 'UNKOWN'
                    continue
                if mother == 'UNKOWN':
                    continue
                fields = fields[:-1]
                if len(fields) < 1 or not isFloat(fields[0]):
                    continue
                while len(fields) > 1:
                    if isValidParticle(fields[-1]):
                        break
                    fields = fields[:-1]
                if len(fields) < 1 or not all(isValidParticle(p) for p in fields[1:]):
                    continue
                neutrinoTag_list = ['nu_e', 'nu_mu', 'nu_tau', 'anti-nu_e', 'anti-nu_mu', 'anti-nu_tau']
                daughters = tuple(sorted(p for p in fields[1:] if p not in neutrinoTag_list))
                if mother not in branching_fractions:
                    branching_fractions[mother] = {}
                if daughters not in branching_fractions[mother]:
                    branching_fractions[mother][daughters] = 0.0
                branching_fractions[mother][daughters] += float(fields[0])
 
        del branching_fractions['UNKOWN']
        return branching_fractions
 

loadInclusiveBranchingFractions()

loadInclusiveBranchingFractions	(		self,
			exclusive_branching_fractions )

Get covered branching fraction of a particle using a recursive algorithm
and the given exclusive branching_fractions (given as Hashable List)
@param particle identifier of the particle
@param branching_fractions

Definition at line 587 of file monitoring.py.

    def loadInclusiveBranchingFractions(self, exclusive_branching_fractions):
        """
        Get covered branching fraction of a particle using a recursive algorithm
        and the given exclusive branching_fractions (given as Hashable List)
        @param particle identifier of the particle
        @param branching_fractions
        """
        particles = set(exclusive_branching_fractions.keys())
        particles.update({pdg.conjugate(p) for p in particles if p != pdg.conjugate(p)})
        particles = sorted(particles, key=lambda x: pdg.get(x).Mass())
        inclusive_branching_fractions = copy.deepcopy(exclusive_branching_fractions)
 
        for p in particles:
            if p in inclusive_branching_fractions:
                br = sum(inclusive_branching_fractions[p].values())
            else:
                br = sum(inclusive_branching_fractions[pdg.conjugate(p)].values())
            for p_br in inclusive_branching_fractions.values():
                for c in p_br:
                    for i in range(c.count(p)):
                        p_br[c] *= br
        return inclusive_branching_fractions
 
 

Member Data Documentation

_shared

_shared = None

staticprotected

is the monitoring shared

Definition at line 487 of file monitoring.py.

exclusive_branching_fractions

exclusive_branching_fractions = self.loadExclusiveBranchingFractions(decay_file)

exclusive branching fractions

Definition at line 497 of file monitoring.py.

inclusive_branching_fractions

inclusive_branching_fractions = self.loadInclusiveBranchingFractions(self.exclusive_branching_fractions)

inclusive branching fractions

Definition at line 499 of file monitoring.py.

---

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

• analysis/scripts/fei/monitoring.py