rpvsusy.RPVSUSYbranchings Class Reference

Inheritance diagram for rpvsusy.RPVSUSYbranchings:

Public Member Functions
None	__init__ (self, mass, couplings, sfmass, benchmark, bool debug=False)
list[str]	Get_Prod_Modes (self)
list[str]	Get_Dec_Modes (self)
None	AddChannelsToPythia (self, P8Gen, bool verbose=True)
def	Width_H_L (self, H, L)
def	Width_N_L (self, H, L)
def	NdecayWidth (self)
def	NprodWidth (self)
def	findDecayBranchingRatio (self, str decayString)
def	findProdBranchingRatio (self, decayString)

Public Attributes
	MN
	U
	U2
	sfmass
	bench
	decays
	prods

Detailed Description

Lifetime and total and partial decay widths of an RPV neutralino

Definition at line 178 of file rpvsusy.py.

Constructor & Destructor Documentation

__init__()

None rpvsusy.RPVSUSYbranchings.__init__	(		self,
			mass,
			couplings,
			sfmass,
			benchmark,
		bool	debug = False
	)

    Initialize with mass and couplings of the RPV neutralino

    Inputs:
    mass (GeV)
    which benchmark scenario (1,2,3,4,5)
    couplings (list of [\lambda production, \lambda decay])
    sfermion mass to normalise the couplings by (GeV)

Reimplemented in rpvsusy.RPVSUSY.

Definition at line 183 of file rpvsusy.py.

    def __init__(self, mass, couplings, sfmass, benchmark, debug: bool = False) -> None:
        r"""
        Initialize with mass and couplings of the RPV neutralino
 
        Inputs:
        mass (GeV)
        which benchmark scenario (1,2,3,4,5)
        couplings (list of [\lambda production, \lambda decay])
        sfermion mass to normalise the couplings by (GeV)
        """
        self.MN = mass * u.GeV
        self.U = couplings
        self.U2 = [ui * ui for ui in self.U]
        self.sfmass = sfmass
        self.bench = benchmark
        self.decays = {
            1: ["N -> K+ mu-", "N -> K*+ mu-", "N -> K*0 nu_mu", "N -> K_L0 nu_mu", "N -> K_S0 nu_mu"],
            2: [
                "N -> K+ mu-",
                "N -> K*+ mu-",
                "N -> K*0 nu_mu",
                "N -> K_L0 nu_mu",
                "N -> K_S0 nu_mu",
                "N -> eta nu_mu",
                "N -> eta' nu_mu",
                "N -> phi nu_mu",
            ],
            3: ["N -> K+ mu-", "N -> K*+ mu-", "N -> K*0 nu_mu", "N -> K_L0 nu_mu", "N -> K_S0 nu_mu"],
            4: ["N -> D+ mu-", "N -> D*+ mu-", "N -> K*0 nu_mu", "N -> K_L0 nu_mu", "N -> K_S0 nu_mu"],
            5: ["N -> K+ tau-", "N -> K*+ tau-", "N -> K*0 nu_tau", "N -> K_L0 nu_tau", "N -> K_S0 nu_tau"],
        }
 
        self.prods = {
            1: ["D+ -> N mu+"],
            2: ["D_s+ -> N mu+"],
            3: ["B0 -> N nu_mu"],
            4: ["B0 -> N nu_mu"],
            5: ["B0 -> N nu_tau", "B+ -> N tau+"],
        }
 
        if debug:
            print("RPVSUSYbranchings instance initialized with couplings:")
            print("\t benchmark scenario   = %d" % self.bench)
            print("\t decay coupling       = %s" % self.U[0])
            print("\t production coupling  = %s" % self.U[1])
            print("\t sfermion mass        = %s" % self.sfmass)
            print("\t total prod coupling  = %s" % (self.U[0] / self.sfmass**2))
            print("\t total decay coupling = %s" % (self.U[1] / self.sfmass**2))
            print("and mass:")
            print("\tm = %s GeV" % (self.MN))
 

Member Function Documentation

AddChannelsToPythia()

None rpvsusy.RPVSUSYbranchings.AddChannelsToPythia	(		self,
			P8Gen,
		bool	verbose = True
	)

Definition at line 240 of file rpvsusy.py.

    def AddChannelsToPythia(self, P8Gen, verbose: bool = True) -> None:
        decays_tmp = self.decays[self.bench]
        for decay in decays_tmp:
            decay_cpy = decay
            decay_cpy = decay_cpy.replace("N -> ", "")
            particles = decay_cpy.split()
            codes = [PDGcode(p) for p in particles]
            print(decay)
            bf = self.findDecayBranchingRatio(decay)
            if (
                any("K+" in s for s in particles)
                or any("K-" in s for s in particles)
                or any("K*+" in s for s in particles)
                or any("K*-" in s for s in particles)
                or any("K*0" in s for s in particles)
                or any("K*0_bar" in s for s in particles)
            ):
                bf = bf / 2.0
                P8Gen.SetParameters(
                    "9900015:addChannel = 1 {:.12} 0 {}".format(bf, " ".join(str(code) for code in codes))
                )
                P8Gen.SetParameters(
                    "9900015:addChannel = 1 {:.12} 0 {}".format(bf, " ".join(str(-code) for code in codes))
                )
            else:
                P8Gen.SetParameters(
                    "9900015:addChannel = 1 {:.12} 0 {}".format(bf, " ".join(str(code) for code in codes))
                )
            if verbose:
                print("debug readdecay table", particles, codes, bf)
 

findDecayBranchingRatio()

def rpvsusy.RPVSUSYbranchings.findDecayBranchingRatio	(		self,
		str	decayString
	)

Returns the branching ratio of the selected SUSY RPV neutralino decay channel

Inputs:
- decayString is a string describing the decay, in the form 'N -> stuff1 ... stuffN'

Definition at line 417 of file rpvsusy.py.

    def findDecayBranchingRatio(self, decayString: str):
        """
        Returns the branching ratio of the selected SUSY RPV neutralino decay channel
 
        Inputs:
        - decayString is a string describing the decay, in the form 'N -> stuff1 ... stuffN'
        """
        had = re.search(r"->\ (.+?)\ ", decayString).group(1)
        decaysplit = decayString.split(" ")
        for split in decaysplit:
            if split.find("mu") > -1 or split.find("e") > -1 or split.find("tau") > -1:
                lep = split
        if had == "pi+" or had == "pi-" or had == "pi0":
            print(
                "findBranchingRatio() ERROR: Pions in final "
                "state have not been implemented, please choose "
                "a different decay mode of out...\n"
            )
            print(self.decays)
            return -999
 
        corrdecstring = f"N -> {had} {lep}"
        listdecs = self.decays[self.bench]
        gooddec = False
        print("findBranchingRation() INFO: You have chosen the decay: '", corrdecstring)
        for dec in listdecs:
            if corrdecstring in dec:
                gooddec = True
        if gooddec is False:
            print("findBranchingRation() ERROR: Badly formulated decay string, please choose one of the following\n")
            print(self.decays)
            return -999
 
        br = 0.0
        totalwidth = self.NdecayWidth()
        if totalwidth > 0.0:
            br = self.Width_H_L(had, lep) / totalwidth
        return br
 

findProdBranchingRatio()

def rpvsusy.RPVSUSYbranchings.findProdBranchingRatio	(		self,
			decayString
	)

Returns the branching ratio of the selected SUSY RPV neutralino product channel

Inputs:
- decayString is a string describing the decay, in the form 'H -> N ... stuffN'

Definition at line 456 of file rpvsusy.py.

    def findProdBranchingRatio(self, decayString):
        """
        Returns the branching ratio of the selected SUSY RPV neutralino product channel
 
        Inputs:
        - decayString is a string describing the decay, in the form 'H -> N ... stuffN'
        """
        had = re.search(r"(.+?)\ ->", decayString).group(1)
        decaysplit = decayString.split(" ")
        for split in decaysplit:
            if split.find("mu") > -1 or split.find("e") > -1 or split.find("tau") > -1:
                lep = split
        if had == "pi+" or had == "pi-" or had == "pi0":
            print(
                "findProdBranchingRatio() ERROR: Pions in final "
                "state have not been implemented, please choose "
                "a different decay mode of out...\n"
            )
            print(self.decays)
            return -999
 
        corrdecstring = f"{had} -> N {lep}"
        listdecs = self.prods[self.bench]
        gooddec = False
        print("findProdBranchingRation() INFO: You have chosen the decay: '", corrdecstring)
        for dec in listdecs:
            if corrdecstring in dec:
                gooddec = True
        if gooddec is False:
            print(
                "findProdBranchingRation() ERROR: Badly formulated decay string, please choose one of the following\n"
            )
            print(self.decays)
            return -999
 
        br = self.Width_N_L(had, lep) / (self.Width_N_L(had, lep) + c.hGeV / lifetime(had))
        return br
 
 

Get_Dec_Modes()

list[str] rpvsusy.RPVSUSYbranchings.Get_Dec_Modes

(

self

)

Definition at line 237 of file rpvsusy.py.

    def Get_Dec_Modes(self) -> list[str]:
        return self.decays[self.bench]
 

Get_Prod_Modes()

list[str] rpvsusy.RPVSUSYbranchings.Get_Prod_Modes

(

self

)

Definition at line 234 of file rpvsusy.py.

    def Get_Prod_Modes(self) -> list[str]:
        return self.prods[self.bench]
 

NdecayWidth()

def rpvsusy.RPVSUSYbranchings.NdecayWidth

(

self

)

Returns the total SUSYRPV neutralino decay width

Definition at line 396 of file rpvsusy.py.

    def NdecayWidth(self):
        """
        Returns the total SUSYRPV neutralino decay width
        """
        declist = self.decays[self.bench]
        hadlist = [re.search(r"->\ (.+?)\ ", dec).group(1) for dec in declist]
        leplist = [dlist[1].strip() for dlist in [re.findall(r"\ \w+", dec) for dec in declist]]
        print(leplist, hadlist)
        totalwidth = sum([self.Width_H_L(hadlist[i], leplist[i]) for i in range(0, len(hadlist))])
        return totalwidth
 

NprodWidth()

def rpvsusy.RPVSUSYbranchings.NprodWidth

(

self

)

Returns the total SUSYRPV neutralino production width

Definition at line 407 of file rpvsusy.py.

    def NprodWidth(self):
        """
        Returns the total SUSYRPV neutralino production width
        """
        declist = self.prods[self.bench]
        hadlist = [re.search(r"(.+?)\ ->", dec).group(1) for dec in declist]
        leplist = [dlist[1].strip() for dlist in [re.findall(r"\ \w+", dec) for dec in declist]]
        totalwidth = sum([self.Width_N_L(hadlist[i], leplist[i]) for i in range(0, len(hadlist))])
        return totalwidth
 

Width_H_L()

def rpvsusy.RPVSUSYbranchings.Width_H_L	(		self,
			H,
			L
	)

Returns the RPV neutralino decay width into neutral meson and lepton

Inputs:
- H is a string (name of the meson)
- L is a string (name of the lepton)

Definition at line 271 of file rpvsusy.py.

    def Width_H_L(self, H, L):
        """
        Returns the RPV neutralino decay width into neutral meson and lepton
 
        Inputs:
        - H is a string (name of the meson)
        - L is a string (name of the lepton)
        """
        if (mass(H) + mass(L)) > self.MN:
            return 0.0
 
        phsp = math.sqrt(
            self.MN**4
            + mass(H) ** 4
            + mass(L) ** 4
            - 2 * self.MN**2 * mass(H) ** 2
            - 2 * self.MN**2 * mass(L) ** 2
            - 2 * mass(H) ** 2 * mass(L) ** 2
        )
        tmp_width = 0
        if "nu_mu" in L or "nu_e" in L or "nu_tau" in L:
            tmp_width = (
                phsp
                / (self.sfmass**4 * 128 * u.pi * self.MN**3)
                * c.GST2["sneutrino"]
                * c.decayConstant[H] ** 2
                * (self.MN**2 + mass(L) ** 2 - mass(H) ** 2)
            )
        else:
            tmp_width = (
                phsp
                / (self.sfmass**4 * 128 * u.pi * self.MN**3)
                * c.GST2["slepton"]
                * c.decayConstant[H] ** 2
                * (self.MN**2 + mass(L) ** 2 - mass(H) ** 2)
            )
 
        if "K*" in H or "D*" in H or "phi" in H:
            if "nu_mu" in L or "nu_e" in L or "nu_tau" in L:
                tmp_width = (
                    phsp
                    / (self.sfmass**4 * 2 * u.pi * self.MN**3)
                    * c.GST2["tneutrino"]
                    * c.decayConstant[H] ** 2
                    * (2 * (self.MN**2 - mass(L) ** 2) ** 2 - mass(H) ** 2 * (mass(H) ** 2 + self.MN**2 + mass(L) ** 2))
                )
            else:
                tmp_width = (
                    phsp
                    / (self.sfmass**4 * 2 * u.pi * self.MN**3)
                    * c.GST2["tlepton"]
                    * c.decayConstant[H] ** 2
                    * (2 * (self.MN**2 - mass(L) ** 2) ** 2 - mass(H) ** 2 * (mass(H) ** 2 + self.MN**2 + mass(L) ** 2))
                )
        width = self.U2[1] * tmp_width
        # contributions both from decay and production couplings
        if self.bench == 1 and ("K_" in H or "K*" in H):
            width = (self.U2[0] + self.U2[1]) * tmp_width
        # contributions only from production coupling
        if self.bench == 2 and ("eta" in H or "phi" in H):
            width = self.U2[0] * tmp_width
 
        # Majorana case (charge conjugate channels)
        width = 2.0 * width
        return width
 

Width_N_L()

def rpvsusy.RPVSUSYbranchings.Width_N_L	(		self,
			H,
			L
	)

Returns the Meson decay width to RPV neutralino and lepton
Inputs:
- H is a string (name of the meson)
- L is a string (name of the lepton)

Definition at line 337 of file rpvsusy.py.

    def Width_N_L(self, H, L):
        """
        Returns the Meson decay width to RPV neutralino and lepton
        Inputs:
        - H is a string (name of the meson)
        - L is a string (name of the lepton)
        """
 
        if mass(H) < (self.MN + mass(L)):
            return 0.0
        phsp = math.sqrt(
            self.MN**4
            + mass(H) ** 4
            + mass(L) ** 4
            - 2 * self.MN**2 * mass(H) ** 2
            - 2 * self.MN**2 * mass(L) ** 2
            - 2 * mass(H) ** 2 * mass(L) ** 2
        )
 
        tmp_width = 0
        if "nu_mu" in L or "nu_e" in L or "nu_tau" in L:
            tmp_width = (
                phsp
                / (self.sfmass**4 * 64 * u.pi * mass(H) ** 3)
                * c.GST2["sneutrino"]
                * c.decayConstant[H] ** 2
                * (mass(H) ** 2 - self.MN**2 - mass(L) ** 2)
            )
        else:
            tmp_width = (
                phsp
                / (self.sfmass**4 * 64 * u.pi * mass(H) ** 3)
                * c.GST2["slepton"]
                * c.decayConstant[H] ** 2
                * (mass(H) ** 2 - self.MN**2 - mass(L) ** 2)
            )
 
        if "K*" in H or "D*" in H or "phi" in H:
            if "nu_mu" in L or "nu_e" in L or "nu_tau" in L:
                tmp_width = (
                    phsp
                    / (self.sfmass**4 * 3 * u.pi * mass(H) ** 3)
                    * c.GST2["tneutrino"]
                    * c.decayConstant[H] ** 2
                    * (mass(H) ** 2 * (mass(H) ** 2 + self.MN**2 + mass(L) ** 2 - 2 * (self.MN**2 - mass(L) ** 2) ** 2))
                )
            else:
                tmp_width = (
                    phsp
                    / (self.sfmass**4 * 3 * u.pi * mass(H) ** 3)
                    * c.GST2["tlepton"]
                    * c.decayConstant[H] ** 2
                    * (mass(H) ** 2 * (mass(H) ** 2 + self.MN**2 + mass(L) ** 2 - 2 * (self.MN**2 - mass(L) ** 2) ** 2))
                )
 
        width = self.U2[0] * tmp_width
 
        return width
 

Member Data Documentation

bench

rpvsusy.RPVSUSYbranchings.bench

Definition at line 197 of file rpvsusy.py.

decays

rpvsusy.RPVSUSYbranchings.decays

Definition at line 198 of file rpvsusy.py.

MN

rpvsusy.RPVSUSYbranchings.MN

Definition at line 193 of file rpvsusy.py.

prods

rpvsusy.RPVSUSYbranchings.prods

Definition at line 215 of file rpvsusy.py.

sfmass

rpvsusy.RPVSUSYbranchings.sfmass

Definition at line 196 of file rpvsusy.py.

U

rpvsusy.RPVSUSYbranchings.U

Definition at line 194 of file rpvsusy.py.

U2

rpvsusy.RPVSUSYbranchings.U2

Definition at line 195 of file rpvsusy.py.

---

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

• python/rpvsusy.py