Public Member Functions
None	__init__ (self, mass, eps)

def	readPDGtable (self)

def	interpolatePDGtable (self)

float\|int	Ree_interp (self, s)

float	leptonicDecayWidth (self, str lepton)

float	leptonicBranchingRatio (self, str lepton)

float	hadronicDecayWidth (self)

float	hadronicBranchingRatio (self)

float	totalDecayWidth (self)

float	cTau (self)

float	lifetime (self)

float	findBranchingRatio (self, decayString)

dict[str, str]	allowedChannels (self)

def	scaleNEventsIncludingHadrons (self, n)

Public Attributes
	mDarkPhoton

	epsilon

	dataR

	PdgR

Detailed Description

Definition at line 22 of file darkphoton.py.

Constructor & Destructor Documentation

◆ init()

None darkphoton.DarkPhoton.__init__	(	self,
		mass,
		eps
	)

Definition at line 25 of file darkphoton.py.

    def __init__(self, mass, eps) -> None:
        self.mDarkPhoton = mass
        self.epsilon = eps
        self.dataEcm, self.dataR = self.readPDGtable()
        self.PdgR = self.interpolatePDGtable()
 

Member Function Documentation

◆ allowedChannels()

dict[str, str] darkphoton.DarkPhoton.allowedChannels ( self )

Definition at line 150 of file darkphoton.py.

    def allowedChannels(self) -> dict[str, str]:
        print("Allowed channels for dark photon mass = %3.3f" % self.mDarkPhoton)
        allowedDecays = {"A -> hadrons": "yes"}
        if self.mDarkPhoton > 2.0 * mass("e-"):
            allowedDecays.update({"A -> e- e+": "yes"})
            print("allowing decay to e")
        if self.mDarkPhoton > 2.0 * mass("mu-"):
            allowedDecays.update({"A -> mu- mu+": "yes"})
            print("allowing decay to mu")
        if self.mDarkPhoton > 2.0 * mass("tau-"):
            allowedDecays.update({"A -> tau- tau+": "yes"})
            print("allowing decay to tau")
 
        return allowedDecays
 

◆ cTau()

float darkphoton.DarkPhoton.cTau ( self )

Dark Photon lifetime in cm

Definition at line 125 of file darkphoton.py.

    def cTau(self) -> float:  # decay length in meters, dark photon mass in GeV
        """Dark Photon lifetime in cm"""
        ctau = hGeV * ccm / self.totalDecayWidth()
        # print "ctau dp.py %.3e"%(ctau)
        return ctau  # GeV/MeV conversion
 

◆ findBranchingRatio()

float darkphoton.DarkPhoton.findBranchingRatio	(	self,
		decayString
	)

Definition at line 134 of file darkphoton.py.

    def findBranchingRatio(self, decayString) -> float:
        br = 0.0
        if decayString == "A -> e- e+":
            br = self.leptonicBranchingRatio("e-")
        elif decayString == "A -> mu- mu+":
            br = self.leptonicBranchingRatio("mu-")
        elif decayString == "A -> tau- tau+":
            br = self.leptonicBranchingRatio("tau-")
        elif decayString == "A -> hadrons":
            br = self.hadronicBranchingRatio()
        else:
            print("findBranchingRatio ERROR: unknown decay %s" % decayString)
            quit()
 
        return br
 

◆ hadronicBranchingRatio()

float darkphoton.DarkPhoton.hadronicBranchingRatio ( self )

Definition at line 108 of file darkphoton.py.

    def hadronicBranchingRatio(self) -> float:
        return self.hadronicDecayWidth() / self.totalDecayWidth()
 

◆ hadronicDecayWidth()

float darkphoton.DarkPhoton.hadronicDecayWidth ( self )

Dark photon decay into hadrons

(mumu)*R

Definition at line 100 of file darkphoton.py.

    def hadronicDecayWidth(self) -> float:
        """Dark photon decay into hadrons"""
        """(mumu)*R"""
        gmumu = self.leptonicDecayWidth("mu-")
        tdw = gmumu * self.Ree_interp(self.mDarkPhoton)
        # print 'Hadronic decay width is %.3e'%(tdw)
        return tdw
 

◆ interpolatePDGtable()

def darkphoton.DarkPhoton.interpolatePDGtable ( self )

Find the best value for R for the given center-of-mass energy

Definition at line 58 of file darkphoton.py.

    def interpolatePDGtable(self):
        """Find the best value for R for the given center-of-mass energy"""
        fun = r.Math.Interpolator(len(self.dataEcm), r.Math.Interpolation.kLINEAR)
        fun.SetData(self.dataEcm, self.dataR)
        return fun
 

◆ leptonicBranchingRatio()

float darkphoton.DarkPhoton.leptonicBranchingRatio	(		self,
		str	lepton
	)

Definition at line 97 of file darkphoton.py.

    def leptonicBranchingRatio(self, lepton: str) -> float:
        return self.leptonicDecayWidth(lepton) / self.totalDecayWidth()
 

◆ leptonicDecayWidth()

float darkphoton.DarkPhoton.leptonicDecayWidth	(		self,
		str	lepton
	)

Dark photon decay width into leptons, in GeV (input short name of lepton family)

Definition at line 81 of file darkphoton.py.

    def leptonicDecayWidth(self, lepton: str) -> float:  # mDarkPhoton in GeV
        """Dark photon decay width into leptons, in GeV (input short name of lepton family)"""
        ml = mass(lepton)
        # print 'lepton %s mass %.3e'%(lepton,ml)
 
        constant = (1.0 / 3.0) * alphaQED * self.mDarkPhoton * pow(self.epsilon, 2.0)
        if 2.0 * ml < self.mDarkPhoton:
            rad = math.sqrt(1.0 - (4.0 * ml * ml) / (self.mDarkPhoton * self.mDarkPhoton))
        else:
            rad = 0.0
 
        par = 1.0 + (2.0 * ml * ml) / (self.mDarkPhoton * self.mDarkPhoton)
        tdw = math.fabs(constant * rad * par)
        # print 'Leptonic decay width to %s is %.3e'%(lepton,tdw)
        return tdw
 

◆ lifetime()

float darkphoton.DarkPhoton.lifetime ( self )

Definition at line 131 of file darkphoton.py.

    def lifetime(self) -> float:
        return self.cTau() / ccm
 

◆ readPDGtable()

def darkphoton.DarkPhoton.readPDGtable ( self )

Returns R data from PDG in a easy to use format

Definition at line 31 of file darkphoton.py.

    def readPDGtable(self):
        """Returns R data from PDG in a easy to use format"""
        ecm = r.vector("double")()
        ratio = r.vector("double")()
        """ecm,ratio = [],[]"""
        with open(os.path.expandvars("$FAIRSHIP/input/rpp2012-hadronicrpp_page1001.dat")) as f:
            for line in f:
                line = line.split()
                try:
                    numEcm = float(line[0])
                    numR = float(line[3])
                    strType = line[7]
                    strBis = line[8]
                    # if numEcm<2:
                    #   print numEcm,numR,strType
                    if ("EXCLSUM" in strType) or ("EDWARDS" in strType) or ("BLINOV" in strType):
                        ecm.push_back(numEcm)
                        ratio.push_back(numR)
                        # print numEcm,numR,strType
                    if "BAI" in strType and "01" in strBis:
                        ecm.push_back(numEcm)
                        ratio.push_back(numR)
                        # print numEcm,numR,strType
                except Exception:
                    continue
        return ecm, ratio
 

◆ Ree_interp()

float \| int darkphoton.DarkPhoton.Ree_interp	(	self,
		s
	)

Using PDG values for sigma(e+e- -> hadrons) / sigma(e+e- -> mu+mu-)

Definition at line 64 of file darkphoton.py.

    def Ree_interp(self, s) -> float | int:  # s in GeV
        """Using PDG values for sigma(e+e- -> hadrons) / sigma(e+e- -> mu+mu-)"""
        # Da http://pdg.lbl.gov/2012/hadronic-xsections/hadron.html#miscplots
        # ecm = math.sqrt(s)
        ecm = s
        if ecm >= 10.29:
            print(
                "Warning! Asking for interpolation beyond 10.29 GeV: not implemented, needs extending! Taking value at 10.29 GeV"
            )
            result = float(self.PdgR.Eval(10.29))
        elif ecm >= self.dataEcm[0]:
            result = float(self.PdgR.Eval(ecm))
        else:
            result = 0
        # print 'Ree_interp for mass %3.3f is %.3e'%(s,result)
        return result
 

◆ scaleNEventsIncludingHadrons()

def darkphoton.DarkPhoton.scaleNEventsIncludingHadrons	(	self,
		n
	)

Very simple patch to take into account A' -> hadrons

Definition at line 165 of file darkphoton.py.

    def scaleNEventsIncludingHadrons(self, n):
        """Very simple patch to take into account A' -> hadrons"""
        brh = self.hadronicBranchingRatio()
        # print brh
        # if M > m(c cbar):
        if self.mDarkPhoton > 2.0 * mass("c"):
            visible_frac = 1.0
        else:
            visible_frac = 2.0 / 3.0
 
        increase = brh * visible_frac
        # print increase
        return n * (1.0 + increase)

◆ totalDecayWidth()

float darkphoton.DarkPhoton.totalDecayWidth ( self )

Total decay width in GeV

Definition at line 111 of file darkphoton.py.

    def totalDecayWidth(self) -> float:  # mDarkPhoton in GeV
        """Total decay width in GeV"""
        # return hGeV*c / cTau(mDarkPhoton, epsilon)
        tdw = (
            self.leptonicDecayWidth("e-")
            + self.leptonicDecayWidth("mu-")
            + self.leptonicDecayWidth("tau-")
            + self.hadronicDecayWidth()
        )
 
        # print 'Total decay width %e'%(tdw)
 
        return tdw
 

Member Data Documentation

◆ dataR

darkphoton.DarkPhoton.dataR

Definition at line 28 of file darkphoton.py.

◆ epsilon

darkphoton.DarkPhoton.epsilon

Definition at line 27 of file darkphoton.py.

◆ mDarkPhoton

darkphoton.DarkPhoton.mDarkPhoton

Definition at line 26 of file darkphoton.py.

◆ PdgR

darkphoton.DarkPhoton.PdgR

Definition at line 29 of file darkphoton.py.

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

python/darkphoton.py

Public Member Functions

Public Attributes