Page MenuHomeHEPForge
Files F10881706

No OneTemporary
Actions

View Options

diff --git a/README b/README
index 76112b7..5701ce2 100644
--- a/README
+++ b/README
@@ -1,409 +1,414 @@
################################################################################
Rosetta: A Higgs Effective Field Theory basis translator
Benjamin Fuks, Fabio Maltoni, Kentarou Mawatari, Ken Mimasu, Veronica Sanz
Version 0, March 2015
################################################################################
Rosetta is a translation tool to aid in the Monte Carlo generation of events for
Higgs Effective Field Theory. The idea is to provide a simple way to map
different parametrisations of the deviations of Higgs couplings from SM
expectations to a single 'basis' of Wilson coefficients corresponding to
operators up to dimension 6.
Given an LHA style input parameter card in the users basis of choice, Rosetta
has the capability to read in the parameters, calculate any dependent
parameters, perform a number of consistency checks with respect to required and
derived inputs and finally write out a new parameter card in the target basis
which can be used as input to the associated UFO model in e.g.
MadGraph5_aMC@NLO.
The tool consists of a Python package containing implementations of
Higgs Effective Theory bases and a command line tool 'translate' that performs
the task of mapping a given basis to a target output basis. The core of the
package is based on the contents of the LHCHiggs Cross Section Working Group
(HXSWG) draft. The slides at
https://indico.cern.ch/event/375176/contribution/5/material/slides/0.pdf
provide a more detailed description of the tool as well as some examples of
usage and the code structure (see backup slides).
################################################################################
README Contents
################################################################################
1) Contact
2) Prerequisites
3) Usage
4) Input cards
5) Implementing your own basis
6) eHDECAY interface
################################################################################
1) Contact
################################################################################
Feel free to contact the authors with requests for features, bugs
etc.through k.mimasu@sussex.ac.uk.
################################################################################
2) Prerequisites
################################################################################
Python 2.7 or above
################################################################################
3) Package Contents
################################################################################
Rosetta/ # Python package containing implementation of the basis
# translation machinery.
__init__.py # Stores a dictionary of fermion PIDs and a few
# default values for SM input parameters and particle
# masses in case they are undefined by the user.
Basis.py # Base basis class implementing internal methods
# such as reading/writing param cards and checking
# for required/calculated inputs. All basis classes
# are derived from this one.
--> MassBasis.py # Basis class corresponding to the target basis
# for output parameter cards, corresponds to the
# redundant set of operators defined in
# HiggsBasis.py without imposing any dependency
- # conditions. There are 169 coefficients.
+ # conditions. There are 183 coefficients.
--> HiggsBasis.py # Basis class corresponding to the Higgs Basis as
# defined in the HXSWG draft. Using this basis as
# input calculates the dependent coefficients.
- # There are 95 independent coefficients and 74
+ # There are 99 independent coefficients and 84
# dependent coefficients.
--> WarsawBasis.py # Basis class corresponding to the Warsaw Basis
# defined arXiv:1008.4884. Using this basis
# input calculates the Mass Basis coefficients
# as per the formulae in the HXSWG draft. There are
- # 95 independent coefficients.
+ # 99 independent coefficients.
--> TemplateBasis.py # Template for a user-defined Basis class
# implemented in the Rosetta package. Toy versions
# of the calculate_dependent() and translate()
# methods are implemented.
implemeted.py # A file defining a dictionary that logs the set of
# implemented bases for the translate tool.
eHDECAY.py # Interface with eHDECAY program (arXiv:1403.3381),
# discussed later.
query.py # Yes/no query function borrowed from
# http://code.activestate.com/recipes/577058/
Cards/ # Sample MG5-style parameter cards to be used as input.
param_card_HiggsBasis.dat # Sample HiggsBasis input parameter card
param_card_MassBasis.dat # Sample MassBasis parameter card, needn't
# be used as input
param_card_TemplateBasis.dat # Sample TemplateBasis input parameter card
param_card_WarsawBasis.dat # Sample WarsawBasis input parameter card
translate # Command line tool to perform basis translation based on the
# implementations in Rosetta.py
################################################################################
3) Usage
################################################################################
-The translate command line tool takes an LHA-style param card (see sample
+The translate command line tool takes an SLHA-style param card (see sample
cards provided in Cards/ directory) in a particular basis and outputs a new
card in the specified basis (default is Mass Basis). So far, only the Mass
-Basis can be takes as the target basis.
+Basis can be taken as the target basis.
-The options BLOCKIN and BLOCKOUT allow the user to specify the name of the LHA
+The options BLOCKIN and BLOCKOUT allow the user to specify the name of the SLHA
block that contains the new couplings. The names of these couplings, specified
as the first non-whitespace characters following a hash ("#") character after
the numerical value of the parameter, should match those defined in the
-'independent' list of the specified input basis.
+'independent' list of the specified input basis implementation.
Command line documentation:
>> ./translate --help
>>
>> usage: translate [-h] [-o OUTPUT] [-b BLOCKIN] [-B BLOCKOUT]
>> [-t TARGETBASIS] [-w] [-e]
>> PARAMCARD BASIS
>>
>> Read in an LHA format parameter card in a particular basis and write a
>> new param card in the mass basis.
>>
>> positional arguments:
>> PARAMCARD Input parameter card.
>> BASIS Basis of coefficients in parameter card (one of:
>> higgs, mass, template, warsaw).
>>
>> optional arguments:
>> -h, --help show this help message and exit
>> -o OUTPUT, --output OUTPUT
>> Output file name. Default: [PARAMCARD]_new
>> -b BLOCKIN, --blockin BLOCKIN
>> New coupling block to be read in. Default:
>> newcoup
>> -B BLOCKOUT, --blockout BLOCKOUT
>> New coupling block to be written out. Default:
>> newcoup
>> -t TARGETBASIS, --target TARGETBASIS
>> Basis into which to translate (one of: higgs,
>> mass, template, warsaw). Default: mass
>> -w, --overwrite Overwrite any pre-existing output file.
>> -e, --ehdecay Interface with eHDECAY
################################################################################
4) Input cards
################################################################################
Rosetta is designed to read input cards in a format similar to the SUSY Les
Houches Accord (SLHA) detailed in http://arxiv.org/abs/hep-ph/0311123. It
coincides with the input format read in by Madgraph5_aMC@NLO. Sample cards can
be found in the Cards/ directory.
The reader looks for block structures in a case insensitive way i.e.
>>BLOCK MYBLOCK
Specifically it will search for blocks MASS, SMINPUTS and BASIS. For the
Higgs Effective Theory couplings, it will also search for a block 'newcoup' or
any other string BLOCKIN specified by the '-b BLOCKIN' option of translate.
The main difference between the input format of Rosetta and SLHA is that names
of parameters are required as this is what the translator uses to identify them
in applying the translation formulae. This was deemed to be clearer than the
usual numerical ordering that would be more suitable for automatically
generated input cards. Therefore each parameter in blocks SMINPUTS and BLOCKIN
should be accompanied by a name following a '#' character (usually reserved for
comments describing the parameter).
>>BLOCK MYBLOCK
>> 0 3.14159E+00 # pi
>> 1 1.97327E-01 # hbarc_GeVfm
>> Block sminputs
>> 1 1.325070e+02 # aEWM1 (white space doesn't matter)
ETC.
The reader reads all lines until the next occurrence of 'BLOCK' or 'DECAY',
ignoring leading and trailing white space and all lines beginning with a '#' as
well as lines that do not match the expected pattern detailed above. For blocks
BLOCKIN and SMINPUTS, the reader stores a name:value pair in the ordered
dictionaries self.par_dict and self.input respectively. For block MASS, a
PID:mass pair is stored in self.mass
>> block mass
>> 5 4.700000e+00 # MB
>> 6 1.730000e+02 # MT
>> 15 1.730000e+02 # MTAU
>> 23 9.118800e+01 # MZ
>> 25 1.250000e+02 # MH
Block basis should have one element and is simply a label for the users input
basis, it is not essential but is used when writing out the new to remind the
user from which basis they translated.
>> block BASIS
>> 0 MyBasis # name of basis
If the reader can't find block basis, it will print a warning and ask to
continue with the default value which is the input basis class name.
################################################################################
5) Implementing your own basis
################################################################################
Users who wish to implement their own basis should have a minimal understanding
of implementing formulae and assigning variables in python dictionaries. The
TemplateBasis.py class illustrates a toy implementation of a basis containing
the main ingredients necessary.
The base class Basis.py implements a number of reading and writing functions
designed to remain 'under the hood'.These include reading and writing parameter
cards, cross checking inputs read in against required inputs, storing the old
parameter card and writing out a new one with the coefficients of the target
basis. In general, the only variables needed in a derived class will be the
following useful data members:
self.independent # A list of coefficients required to be defined
# in the input parameter card.
self.dependent # A list of dependent coefficients to be assigned
# by the calculate_dependent() function. These
# should not be declared in the input parameter
# card.
self.required_inputs # A set of required input parameters in block
# SMINPUTS
self.required_masses # A set of required article masses in block MASS
self.par_dict # dictionary with keys defined by self.independent
# and self.dependent. The parameters in
# self.independent will be read in from the
# input parameter card while those in self.dependent
# should be calculated and assigned by the user in
# calculate_dependent().
self.input # dictionary with names and values of parameters
+ # defined in block SMINPUTS.
+
+ self.SHLA_sminputs # dictionary with SLHA IDs and values of parameters
# defined in block SMINPUTS. Cross checked with
# self.required_inputs
self.mass # dictionary with PIDs and particle masses defined
# in block MASS. Cross checked with elements of
# self.required_masses
self.newpar # dictionary of coefficients to be filled in
# translate() function. The contents of this
# dictionary are written out to the output parameter
# card in place of the old basis coefficients of the
- # input parameter card.
+ # input parameter card.
- self.newmass # dictionary of parameters to be filled in
+ self.newmass # dictionary of modified masses to be filled in
+ # translate() function
+ self.newinput # dictionary of modified SM inputs to be filled in
# translate() function
The basic steps are as follows:
1) Create a new file MyBasis.py declaring a class MyBasis inheriting from the
Basis class (these names need not coincide). The target basis class can
also be imported in order to initialise an empty container to fill in the
translate function.
>>from Basis import Basis # base class
>>from MassBasis import MassBasis # target basis
>>
>>class TemplateBasis(Basis):
2) Minimally, a list of strings called 'independent' should be declared
containing the names of the coefficients to be read in the input parameter
card and used to calculate the coefficients in the target basis.
Additionally, a list named 'dependent' can also optionally be defined
containing the names of coefficients to calculate internally before
translating to the target basis.
The set, 'transalte_to' can also be declared to list the existing bases to
which the implementation provides a translation. The default is {'mass'},
assuming that the translation is implemented to the mass basis.
For more consistency, the sets 'required_inputs' and 'required_masses'
can also be declared. These tell the basis class to check that the masses
of particles with certain PIDs and certain SM input parameters are defined
in the blocks MASS and SMINPUTS respectively. If default values exist for
these parameters in __init__.py, the user is asked if they wish to continue
using those when calling ./translate.
>>class MyBasis(Basis):
>> independent = ['a','b','c',...] # list of required parameters
>> dependent = ['d','e','f',...] # list of derived parameters
>> required_masses = {1,2,3,4,5,6,...} # PIDs of required particle masses
>> required_inputs = {'aEWM1','MZ',...} # required SMINPUT parameters
>> translate_to = {'mass','my_other_basis'} # available translations
3) At least the function translate() should be defined that applies the map
from the input coefficients to those in the output basis. This can be done
by creating and instance of the target basis class and filling its par_dict
data member. The function should ultimately assign the dictionary to
self.newpar. self.newname can also be assigned.
The function calculate_dependent() can also be defined which to calculate
values of the coefficients declared in 'dependent' and assign them in
self.par_dict.The dictionary self.newmass can also be modified at any
stage if modifications to particle masses occur. This should be a
dictionary of PID:mass pairs that will replace the entries in self.mass.
>> def calculate_dependent(self):
>> '''
>> Calculate dependent parameters here by assigning values
>> to self.par_dict corresponding to the keys in self.dependent.
>> '''
>> p = self.par_dict
>> p['d'] = p['a']+ p['b']*p['c'] # set a value for 'd' coefficient
>>
>> def translate(self):
>> '''
>> Translate to the mass basis by creating an empty MassBasis
>> and modifying its par_dict or coeffs._asdict().
>> Set self.newpar with resulting dictionary
>> '''
>> A = self.coeffs._asdict()
>> # initialise empty par_dict of the target basis instance
>> B = MassBasis().coeffs._asdict()
>> # set all values of coeffs according to nonsense formula:
>> # C = coeff_d * m_top / a_EW
>> for k in B.keys():
>> B[k]=A['d']*self.mass[6]/self.input['aEWM1']
>> self.newpar = B
>> self.newname = 'Mass'
4) Once the translate() function has been defined, the implementation is
complete and can be tested with the translate tool. The new basis should be
added to the dictionary 'bases' in implemented.py in order to make the tool
aware of its existence. This is done by importing the new module and
appending it to the dictionary.
In implemented.py:
>> import WarsawBasis, HiggsBasis, MassBasis, TemplateBasis
>> import MyBasis
>> bases['mybasis'] = MyBasis.MyBasis
The options for ./translate -h should now include "mybasis" as a possible
BASIS argument.
################################################################################
6) eHDECAY interface
################################################################################
A useful program based on HDECAY (arXiv:hep-ph/9704448) for calculating the
Higgs total width was developed in 2014 and is described in arXiv:1403.3381.
The program takes as input a number of parameters in the SILH basis to calculate
the width and branching ratios to SM particles optionally including Electroweak
corrections. In order to have this working correctly the user must:
1) Modify the variable eHDECAY_dir in __init__.py to have it pointing to the
location of your installation of eHDECAY
In __init__.py:
>> eHDECAY_dir = '/PATH/TO/eHDECAY'
2) Define the member function eHDECAY_inputs() in their basis implementation.
In MyBasis.py:
>> def eHDECAY_inputs(self):
>> inputs = dict() # populate with values for inputs defined below
>> ..
>> ..
>> return inputs
Currently, the translations to and from SILH basis have not yet been implemented
and so the user will be required to provide the necessary inputs via the
definition of the eHDECAY_inputs() function. The required SM and SILH basis
inputs are listed in eHDECAY.py and are as follows:
SM inputs: # ALL masses must be nonzero for eHDECAY to give a finite result
'MC', 'MB', 'MT', 'MMU', 'MTAU, # SM fermion masses
'MH', 'MZ', 'MW', 'aEWM1' 'Gf', # EW input masses, (alpha_EW)^-1, G_Fermi
'aSMZ' # alpha_S(MZ)
SILH coefficients:
'CHbar' , 'CTbar' , 'Ctaubar', 'Cmubar', 'Ctbar',
'Cbbar' , 'Ccbar' , 'Csbar' , 'CWbar' , 'CBbar',
'CHWbar', 'CHBbar', 'Cgambar', 'Cgbar'
eHDECAY option:
'IELW' # Electroweak corrections switch (1:on, 0:off)
An example of a toy implementation is given in TemplateBasis.py which uses the
default values for the SM inputs and sets the SILH coefficients.
eHDECAY_inputs() should return a dictionary of name:value pairs for the
parameters listed above.
Rosetta will take the inputs and run eHDECAY in a temporary directory and read
the relevant branching ratios, updating or creating the DECAY block in the
output card.
################################################################################
Rosetta: A Higgs Effective Field Theory basis translator
################################################################################
diff --git a/Rosetta/WarsawBasis.py b/Rosetta/WarsawBasis.py
index f19085e..90ec9fa 100644
--- a/Rosetta/WarsawBasis.py
+++ b/Rosetta/WarsawBasis.py
@@ -1,140 +1,140 @@
from Basis import Basis
from MassBasis import MassBasis
import math
from itertools import combinations_with_replacement as comb
from itertools import product
from Rosetta import PID
####################################################################################################
-# Warsaw basis class
+# Warsaw basis class
class WarsawBasis(Basis):
independent = ['cH','cT','cGG','cWW','cBB','cWB','c3W','c3G',
'ctGG','ctWW','ctBB','ctWB','ct3W','ct3G','cpll',
'cHl11','cHl12','cHl13','cHl22','cHl23','cHl33',
'cpHl11','cpHl12','cpHl13','cpHl22','cpHl23','cpHl33',
'cHe11','cHe12','cHe13','cHe22','cHe23','cHe33',
'cHq11','cHq12','cHq13','cHq22','cHq23','cHq33',
'cpHq11','cpHq12','cpHq13','cpHq22','cpHq23','cpHq33',
'cHu11','cHu12','cHu13','cHu22','cHu23','cHu33',
'cHd11','cHd12','cHd13','cHd22','cHd23','cHd33',
'cHud11','cHud12','cHud13','cHud22','cHud23','cHud33',
'cu11Re','cu12Re','cu13Re','cu22Re','cu23Re','cu33Re',
'cu11Im','cu12Im','cu13Im','cu22Im','cu23Im','cu33Im',
'cd11Re','cd12Re','cd13Re','cd22Re','cd23Re','cd33Re',
'cd11Im','cd12Im','cd13Im','cd22Im','cd23Im','cd33Im',
'ce11Re','ce12Re','ce13Re','ce22Re','ce23Re','ce33Re',
'ce11Im','ce12Im','ce13Im','ce22Im','ce23Im','ce33Im']
required_masses = set([y for x in PID.values() for y in x.values()])
required_inputs = {1, 2, 4, 8} # aEWM1, Gf, MZ, MH
translate_to={'mass'}
def calculate_inputs(self): # calculate a few required EW params from aEWM1, Gf, MZ
self.input['ee2'] = 4.*math.pi/self.input['aEWM1'] # EM coupling squared
self.input['s2w'] = (1.- math.sqrt(1. - self.input['ee2']/(math.sqrt(2.)*self.input['Gf']*self.input['MZ']**2)))/2. #sin^2(theta_W)
self.input['gw2'] = self.input['ee2']/self.input['s2w'] # SU(2) coupling squared
self.input['gp2'] = self.input['gw2']*self.input['s2w']/(1.-self.input['s2w']) # Hypercharge coupling squared
self.input['vev'] = 2.*self.input['MZ']*math.sqrt(1-self.input['s2w'])/math.sqrt(self.input['gw2'])
def translate(self):
if self.target_basis=='mass':
self.translate_to_mass()
else:
raise NotImplementedError
def translate_to_mass(self):
self.newname='Mass'
self.calculate_inputs()
s2w, ee2, gw2, gp2 = tuple([self.input[x] for x in ('s2w', 'ee2', 'gw2', 'gp2')]) # get EW params
A = self.coeffs._asdict()
B = MassBasis().coeffs._asdict()
def f(T3,Q,i,j): # [eqn (4.11)]
if i==j:
return -Q*A['cWB']*gw2*gp2/(gw2-gp2) + (A['cT']-dv)*(T3 + Q*gp2/(gw2-gp2))
else:
return 0.
def dy_sf(X,Y): # solution for dy,sin(phi) of [eqn (4.12)]
R = math.sqrt(X**2+Y**2)
sf = -Y/R # solution is +-Y/R
dy = ( X*abs(X)+Y*abs(Y) )/R
return dy,sf
# Higgs vev shift [eqn (4.8)]
dv = (A['cpHl11']+A['cpHl22'])/2.-A['cpll']
# W mass shift [eqn (4.9)]
B['dM'] = 1./(gw2-gp2)*(gw2*A['cT']-gp2*gw2*A['cWB']-gp2*dv)
# W/Z chiral coupling deviations
for i,j in comb((1,2,3),2):
B['dGLwl{}{}'.format(i,j)] = A['cpHl{}{}'.format(i,j)] + f(1./2.,0.,i,j) - f(-1./2.,-1.,i,j) # [eqn (4.10)]
B['dGLzv{}{}'.format(i,j)] = 1./2.*A['cpHl{}{}'.format(i,j)] - 1./2.*A['cHl{}{}'.format(i,j)] + f(1./2.,0.,i,j)
B['dGLze{}{}'.format(i,j)] = -1./2.*A['cpHl{}{}'.format(i,j)] - 1./2.*A['cHl{}{}'.format(i,j)] + f(-1./2.,-1.,i,j)
B['dGRze{}{}'.format(i,j)] = - 1./2.*A['cHe{}{}'.format(i,j)] + f(0.,-1.,i,j)
B['dGLwq{}{}'.format(i,j)] = A['cpHq{}{}'.format(i,j)] + f(1./2.,2./3.,i,j) - f(-1./2.,-1./3.,i,j) # [eqn (4.12)]
B['dGRwq{}{}'.format(i,j)] = -1./2.*A['cHud{}{}'.format(i,j)]
B['dGLzu{}{}'.format(i,j)] = 1./2.*A['cpHq{}{}'.format(i,j)] - 1./2.*A['cHq{}{}'.format(i,j)] + f(1./2.,2./3.,i,j)
B['dGLzd{}{}'.format(i,j)] = -1./2.*A['cpHq{}{}'.format(i,j)] - 1./2.*A['cHq{}{}'.format(i,j)] + f(-1./2.,-1./3.,i,j)
B['dGRzu{}{}'.format(i,j)] = - 1./2.*A['cHu{}{}'.format(i,j)] + f(0.,2./3.,i,j)
B['dGRzd{}{}'.format(i,j)] = - 1./2.*A['cHd{}{}'.format(i,j)] + f(0.,-1./3.,i,j)
for i,j in comb((1,2,3),2): # hVff 4-point coeffs [eqn (4.13)]
for f,chi in product(('u','d','e','v'),('L','R')):
if f=='v' and chi=='R': continue
cvff = 'C{}z{}{}{}'.format(chi,f,i,j)
B[cvff] = B['dG{}z{}{}{}'.format(chi,f,i,j)]
for f,chi in (('q','L'),('q','R'),('l','L')):
cvff = 'C{}w{}{}{}'.format(chi,f,i,j)
B[cvff] = B['dG{}w{}{}{}'.format(chi,f,i,j)]
# Higgs couplings to W/Z [eqn (4.14)]
B['dCw'] = (-A['cH']*(gw2-gp2) - A['cWB']*4.*gw2*gp2 + A['cT']*4.*gw2 - dv*(3.*gw2+gp2))/(gw2-gp2)
B['dCz'] = -A['cH'] - 3.*dv
# Two derivative field strength interactions [eqn (4.15)]
B['Cgg'] = A['cGG']
B['Caa'] = A['cWW'] + A['cBB'] - 4.*A['cWB']
B['Czz'] = (gw2**2*A['cWW'] + gp2**2*A['cBB'] + 4.*gw2*gp2*A['cWB'])/(gw2+gp2)**2
B['Czbx'] = -(2./gw2)*(A['cT'] - dv)
B['Cza'] = (gw2*A['cWW'] - gp2*A['cBB'] - 2.*(gw2-gp2)*A['cWB'])/(gw2+gp2)
B['Cabx'] = 2./(gw2-gp2)*((gw2+gp2)*A['cWB'] - 2.*A['cT'] + 2.*dv)
B['Cww'] = A['cWW']
B['Cwbx'] = 2./(gw2-gp2)*(gp2*A['cWB'] - A['cT'] + dv)
B['CTgg'] = A['ctGG']
B['CTaa'] = A['ctWW'] + A['ctBB'] - 4.*A['ctWB']
B['CTzz'] = (gw2**2*A['ctWW'] + gp2**2*A['ctBB'] + 4.*gw2*gp2*A['ctWB'])/(gw2+gp2)**2
B['CTza'] = (gw2*A['ctWW'] - gp2*A['ctBB'] - 2.*(gw2-gp2)*A['ctWB'])/(gw2+gp2)
B['CTww'] = A['ctWW']
# Yukawa type interaction coefficients [eqn. (4.16)]
for i,j in comb((1,2,3),2):
for f in ('u','d','e'):
mi, mj = self.mass[ PID[f][i] ],self.mass[ PID[f][j] ]
if mi and mj:
dy_cosphi = self.input['vev']*(A['c{}{}{}Re'.format(f,i,j)])
dy_sinphi = self.input['vev']*(A['c{}{}{}Im'.format(f,i,j)])
if i==j: dy_cosphi -= mi*(dv+A['cH'])
Rdysf = math.sqrt( dy_sinphi**2 + dy_cosphi**2)
B['S{}{}{}'.format(f,i,j)], B['dY{}{}{}'.format(f,i,j)] = dy_sf( dy_cosphi, dy_sinphi )
# Triple gauge couplings [eqn. (4.20)]
B['dG1z'] = (gw2+gp2)/(gw2-gp2)*( -A['cWB']*gp2 + A['cT'] - dv )
B['dKa'] = A['cWB']*gw2
B['dKz'] = ( -A['cWB']*2.*gw2*gp2 + (gw2+gp2)*(A['cT'] - dv ) )/(gw2-gp2)
B['La'] = -A['c3W']*3./2.*gw2**2
B['Lz'] = B['La']
B['KTa'] = A['ctWB']*gw2
B['KTz'] = -A['ctWB']*gp2
B['LTa'] = -A['ct3W']*3./2.*gw2**2
B['LTz'] = B['LTa']
self.newpar = B
self.newmass[24] = self.mass[24]+self.newpar['dM'] # W mass shift
####################################################################################################
\ No newline at end of file

File Metadata

Mime Type
text/x-diff
Expires
Sat, May 3, 6:43 AM (1 d, 4 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
4983120
Default Alt Text
(28 KB)

Event Timeline