-- SilkeMobius1 - 2019-10-15

Harmonising and handling default MC parameters

Central repository for default MC parameters in generator interfaces/base fragments

A central repository was created with the file 'athena/Generators/EvgenProdTools/python/physics_parameters.py'. This script calls the newest PDG API and downloads it.

Using this file, a dictionary called 'p_dict' is created that stores the mass, width, name and the PID of the particles. In the dictionary 'p_dict', the key is 'PID' and the value is another dictionary with 'mass', 'width' and 'name' as keys.

The EW parameters, such as sin2thetaW or CKM matrix elements, are stored in a hard-coded dictionary called 'EW_dict'. The values for this dictionary are mainly taken from the formerly used Powheg file 'atlas_common.py' which stored the masses and widths of particles and the EW parameters, such as branching ratios, CKM matrix elements and coupling constants in classes. Only the second value for the variation of sin2thetaW (sin2thetaWbar) is taken from Pythia8.

Both dictionaries, 'p_dict' and 'EW_dict', are combined in the dictionary 'parameters'. The keys to the separate dictionaries are 'particles' and 'EW_parameters'. This dictionary 'parameters' is exported to the python file 'offline_dict.py' in the same folder and this is also what should be included in the job options code when parameters need to be loaded by calling:

from EvgenProdTools.offline_dict import parameters

The file physics_parameters.py:

#-----------------------------------------------------------------------------
#       
#       Script to build dictionary with physics parameters from PDG API:
#       Dictionary is exported to file (offline_dict.py).
#       Once a new PDG API is availabe, this file needs to be updated with
#       the right year and run again with python physics_parameters.py 
#       to update the file offline_dict.py.
#       All other times, the dictionary created by this file can simply be 
#       integrated in the generator interfaces with 
#       from EvgenProdTools.offline_dict import parameters.
#
#-----------------------------------------------------------------------------
import os

# Check if file with PDG values already exists:
# The name of the file needs to be altered once a new PDG API is available
if os.path.isfile('./mass_width_2019.mcd'):
    # Open the existing file (
    f = open('mass_width_2019.mcd', "r")
    print 'File mass_width_2019.mcd already exists.'
else: 
    # Load the particle data from the PDG API:
    # The name of the file needs to be altered once a new PDG API is available
    import urllib2
    url = 'http://pdg.lbl.gov/2019/mcdata/mass_width_2019.mcd'
    response = urllib2.urlopen(url)
    html = response.read()

    # Write the data in a file 
    file_name = url.split('/')[-1]
    f = open(file_name, 'wb')
    f.write(html)
    f = open(file_name, "r")
    print 'Particle data was fetched from PDG API and put into %s.' % file_name

# Method to extract nonblank lines
def nonblank_lines(f):
    for l in f:
        line = l.rstrip()
        if line:
            yield line

# Loop over lines and strip to extract the parameters in a list
stripped_list = []

for line in nonblank_lines(f):
    stripped_line = line.strip()
    if not stripped_line.startswith('*'):
        split_line = line.strip().split(" ")
        if len(split_line) > 1 :
            for i in split_line:
                if i != "":
                    stripped_list.append(i)

# Function to detect integer
def isint(value):
    try:
        int(value)
        if (int(value) != 12 and int(value) != 14 and int(value) != 16):
            return value
    except ValueError:
        return False

# Function to detect float
def isfloat(value):
    try:
        float(value)
        return value
    except ValueError:
        return False

# Write particle dictionary from PDG API:
# differenciate between particles with widths and without

p_dict = dict([])

for i in range(0,len(stripped_list)):
    if (isint(stripped_list[i]) and stripped_list[i] != '0'):
            # Particle with 4 PIDs      
        if (isint(stripped_list[i]) and isint(stripped_list[i+1]) and isint(stripped_list[i+2]) and isint(stripped_list[i+3])):
            p_dict[stripped_list[i]]=dict([('name',stripped_list[i+10]),('mass',stripped_list[i+4]),('width',stripped_list[i+7])])
            # Particle with 3 PIDs
        elif (isint(stripped_list[i]) and isint(stripped_list[i+1]) and isint(stripped_list[i+2])):
            p_dict[stripped_list[i]]=dict([('name',stripped_list[i+9]),('mass',stripped_list[i+3]),('width',stripped_list[i+6])])
            # Particle with 2 PIDS and width
        elif (isint(stripped_list[i]) and isint(stripped_list[i+1]) and isfloat(stripped_list[i+5])):
            p_dict[stripped_list[i]]=dict([('name',stripped_list[i+8]),('mass',stripped_list[i+2]),('width',stripped_list[i+5])])
            # Particle with 2 PIDS and no width
        elif (isint(stripped_list[i]) and isint(stripped_list[i+1]) and not isfloat(stripped_list[i+5])):
            p_dict[stripped_list[i]]=dict([('name',stripped_list[i+5]),('mass',stripped_list[i+2]),('width','0.E+00')])
            # Particle with 1 PID and no width
        elif (isint(stripped_list[i]) and not isfloat(stripped_list[i+4])):
            p_dict[stripped_list[i]]=dict([('name',stripped_list[i+4]),('mass',stripped_list[i+1]),('width','0.E+00')])
            # Particle with 1 PID and width
        else:  
            p_dict[stripped_list[i]]=dict([('name',stripped_list[i+7]),('mass',stripped_list[i+1]),('width',stripped_list[i+4])])
        
# Write EW parameter dictionary 

EW_dict = dict([])

EW_dict[('SIN2THETAW','sin2thetaW','Sin2ThetaW')]='0.23113'
EW_dict[('SIN2THETAWbar','sin2thetaWbar','Sin2ThetaWbar')]='0.23146'

EW_dict[('SIN2THETAWbar','sin2thetaWbar','Sin2ThetaWbar')]='0.23146'

# All the following values are taken from and moved here from the file 'atlas_common.py' from Powheg
# Branching ratios

EW_dict['W_to_enu'] = 0.1082
EW_dict['W_to_leptons'] = 3*EW_dict['W_to_enu']
EW_dict['W_to_hadrons'] = 1.0 - EW_dict['W_to_leptons']
EW_dict['t_to_Wb'] = 1.0
EW_dict['t_to_Ws'] = 0.0
EW_dict['t_to_Wd'] = 0.0

# CKM matrix
EW_dict['Vud'] = 0.97428
EW_dict['Vus'] = 0.2253
EW_dict['Vub'] = 0.00347
EW_dict['Vcd'] = 0.2252
EW_dict['Vcs'] = 0.97345
EW_dict['Vcb'] = 0.041
EW_dict['Vtd'] = 0.00862
EW_dict['Vts'] = 0.0403
EW_dict['Vtb'] = 0.999152
   
# Coupling constants
# EM coupling
EW_dict['alphaem_0'] = 0.00729735252  # 1/137.036
# EM coupling
EW_dict['alphaem'] = 0.00781653039  # 1/127.934
# Strong coupling
EW_dict['alphaqcd'] = 0.1185
# Fermi constant
EW_dict['G_F'] = 0.00001166397
# sin(theta_Cabibbo) ^ 2
EW_dict['sin2cabibbo'] = 0.051 

# Write combined dictionary

parameters = dict([])
parameters['particles']=p_dict
parameters['EW_parameters']=EW_dict


# Write dictionary in file 'offline_dict.py' 
with open("offline_dict.py", 'wb') as file:
    file.write("parameters = { \n")
    for k in sorted (parameters.keys()):
        #if k == 'particles':
        file.write("'%s':{ \n" % k)
        for key in sorted (parameters[k].keys()):
            lastkey = sorted (parameters[k].keys())[-1]
            secondtolastkey = sorted (parameters[k].keys())[-2]
            if key == lastkey:
                if k == 'EW_parameters':
                    file.write("%s:%s}, \n" % (key, parameters[k][key]))
                else:
                    file.write("'%s':%s} \n" % (key, parameters[k][key]))
            elif key == secondtolastkey:
                if k == 'EW_parameters':
                    file.write("%s:%s, \n" % (key, parameters[k][key]))
            else:
                file.write("'%s':%s, \n" % (key, parameters[k][key]))
    file.write("}")

f.close()

Restructuring of the generator interfaces to make use of the central parameters

As a start, the generator interfaces of Powheg, aMCMG5, Sherpa, Pythia8 and Herwig7 were restructured:

  • Sherpa: The base fragment 'athena/Generators/Sherpa_i/share/common/2.2.8_Base_Fragment.py' was altered to read in the dictionary 'parameters' and set the top mass, the lepton masses, the boson masses and sin2thetaW via the dictionary, replacing the hard-coded values.
Changes in the file '2.2.8_Base_Fragment.py':

## Old version of input for particle masses/widths
#genSeq.Sherpa_i.Parameters += [
#    "MASS[6]=172.5",
#    "WIDTH[6]=1.32",
#    "MASS[15]=1.777",
#    "WIDTH[15]=2.26735e-12",
#    "MASS[23]=91.1876",
#    "WIDTH[23]=2.4952",
#    "MASS[24]=80.399",
#    "WIDTH[24]=2.085",
#    ]

## Load parameters from parameter dictionary located in EvgenProdTools/python/offline_dict.py
from EvgenProdTools.offline_dict import parameters
for k,v in parameters.items():
    if k == 'particles':
        for key,value in v.items():
            if int(key) in range(6,26):
# This includes now the top quark, the leptons and the bosons
                genSeq.Sherpa_i.Parameters += [ 
                    'MASS['+key+']='+ value['mass'],
                    'WIDTH['+key+']='+ value['width'],
                ]

## Switch to EW_SCHEME=0 to be able to set PDG value of thetaW
genSeq.Sherpa_i.Parameters += [
    "EW_SCHEME=0",
#    "SIN2THETAW=0.23113",
    ]

## Set EW parameters also via dictionary
for k,v in parameters.items():
    if k == 'EW_parameters':
        for key,value in v.items():
            if key[0] == 'SIN2THETAW':
                genSeq.Sherpa_i.Parameters += [
                    str(key[0])+'='+str(value),
                ]
  • Pythia8: The base fragment 'athena/Generators/Pythia8_i/share/common/Pythia8_Base_Fragment.py' was altered to read in the dictionary 'parameters' and set the top mass, the lepton masses, the boson masses and the two sin2thetaW values via the dictionary, replacing the hard-coded values.
Changes in the file 'Pythia8_Base_Fragment.py':

## Old version of loading parameters
genSeq.Pythia8.Commands += [
    "Main:timesAllowErrors = 500",
#    "6:m0 = 172.5",
#    "23:m0 = 91.1876",
#    "23:mWidth = 2.4952",
#    "24:m0 = 80.399",
#    "24:mWidth = 2.085",
#    "StandardModel:sin2thetaW = 0.23113",
#    "StandardModel:sin2thetaWbar = 0.23146",
    "ParticleDecays:limitTau0 = on",
    "ParticleDecays:tau0Max = 10.0"]

## New version to load parameters by including parameter dictionary 'parameters' in 'offline_dict'
from EvgenProdTools.offline_dict import parameters
for k,v in parameters.items():
    if k == 'particles':
        for key,value in v.items():
# Only the top quark, the leptons and the bosons are included
            if (int(key) in range(6,26)):
                genSeq.Pythia8.Commands += [
                    str(key)+':m0 = '+str(value['mass']),
                    str(key)+':mWidth = '+str(value['width']),
                ]
# Only the parameters sin2thetaW and sin2thetaWbar are included
    if k == 'EW_parameters':
        for key,value in v.items():
            if key[1] == 'sin2thetaW' or key[1] == 'sin2thetaWbar':
                genSeq.Pythia8.Commands += [
                    'StandardModel:'+str(key[1])+' = '+str(value),
                ]
  • Herwig7: The dictionary 'parameters' is read into the file 'athena/Generators/Herwig7_i/python/Herwig7Config.py' and the values for the top quark, the Z and the W boson and sin2thetaW are set via the dictionary, replacing the hard-coded values.
Changes in the file 'Herwig7Config.py':

    ## Before there were used the ATLAS MC15 default parameters for particle masses and widths and Weinberg angle
    ##
    ## As specified in https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/McProductionCommonParametersMC15
    ## Now the PDG API is used to set the parameters via the python file Generators/EvgenProdTools/python/physics_parameters.py that generates the dictionary offline_dict.py with the parameters

  def physics_parameter_commands(self):
    paramlist = []
    self.physics_parameter_commands = True
    
    paramlist.append("## Masses and widths: PDG 2019 values")
    
    ## Load the dictionary and extract the values of the variables that were defined here before (top quark, W and Z boson)
    from EvgenProdTools.offline_dict import parameters
    for k,v in parameters.items():
      if k == 'particles':
        for key,value in v.items():
          if int(key) == 24:
            paramlist.append("set /Herwig/Particles/"+value['name']+"+:NominalMass "+value['mass'])
            paramlist.append("set /Herwig/Particles/"+value['name']+"+:Width "+value['width'])
            paramlist.append("set /Herwig/Particles/"+value['name']+"-:NominalMass "+value['mass'])
            paramlist.append("set /Herwig/Particles/"+value['name']+"-:Width "+value['width'])
          if int(key) == 23:
            paramlist.append("set /Herwig/Particles/"+value['name']+"0:NominalMass "+value['mass'])
            paramlist.append("set /Herwig/Particles/"+value['name']+"0:Width "+value['width'])
          if int(key) == 6:
            paramlist.append("set /Herwig/Particles/"+value['name']+"bar:NominalMass "+value['mass'])
            paramlist.append("set /Herwig/Particles/"+value['name']+"bar:Width "+value['width'])         
            paramlist.append("set /Herwig/Particles/"+value['name']+":NominalMass "+value['mass'])
            paramlist.append("set /Herwig/Particles/"+value['name']+":Width "+value['width'])
    ## Something like this could be used to integrate the other parameters if wanted
         # if (int(key) in range(1,6) or int(key) in range(7,23)):
          #  paramlist.append("set /Herwig/Particles/"+value['name']+":NominalMass "+value['mass'])
           # paramlist.append("set /Herwig/Particles/"+value['name']+":Width "+value['width'])
      
# Take the value of sin2thetaW from the EW_parameters dictionary      
      if k == 'EW_parameters':
        for key,value in v.items():
          if key[2] == "Sin2ThetaW":
            paramlist.append("set /Herwig/Model:EW/"+str(key[2])+" "+str(value))
    paramstring = '\n'.join(paramlist)
    return(paramstring)
    
    ## Old method to implement the parameters    
    #    return("""
    ## Masses and widths: PDG 2010 values (except TOP mass; kept at PDG2007)
    #set /Herwig/Particles/t:NominalMass 172.5*GeV
    #set /Herwig/Particles/tbar:NominalMass 172.5*GeV
    #set /Herwig/Particles/W+:NominalMass 80.399*GeV
    #set /Herwig/Particles/W-:NominalMass 80.399*GeV
    #set /Herwig/Particles/Z0:NominalMass 91.1876*GeV
    #set /Herwig/Particles/W+:Width 2.085*GeV
    #set /Herwig/Particles/W-:Width 2.085*GeV
    #set /Herwig/Particles/Z0:Width 2.4952*GeV
    
    ## Weinberg angle
    #set /Herwig/Model:EW/Sin2ThetaW 0.23113
    #""")
    
  • Powheg: In the file 'athena/Generators/PowhegControl/python/parameters/registry.py' all calls of the classes 'mass', 'width', etc. in the until now used file 'atlas_common.py' are replaced by calls of the dictionary 'parameters'. All calls are hard-coded with the respective keys. As the file 'atlas_common.py' was also loaded to some of the files in 'athena/Generators/PowhegControl/python/processes/powheg', these files were also modified to load the values from the dictionary 'parameters'.
First lines with changes in the file 'registry.py':

import collections

## Import python dictionary with particle parameters and EW parameters. Particle parameters in there are extracted from PDG API.
## The new lepton masses are a bit more precise compared to the old ones, the new quark masses are very different from the old ones, 
## the W and H mass are also different, same holds for the width of the top quark and the H boson. All old values are marked at the end of the line if they differ from the new ones. from EvgenProdTools.offline_dict import parameters from ..decorators import Singleton class Registry(object): """! Class to store information about Powheg parameters. @author James Robinson <james.robinson@cern.ch> """ __metaclass__ = Singleton __register = {} def __init__(self): """! Constructor: initialise the registry.""" self.add_default("allrad", 0, description="turns on multiple shower scheme. Keeps hardest radiation from production and all resonances. [1:enabled]") self.add_default("alpha", -1, description="[-1:use Powheg default]") self.add_default("alphaem_inv", 1.0 / float(parameters['EW_parameters']['alphaem']), description="EM coupling reciprocal") self.add_default("alphaem_z", parameters['EW_parameters']['alphaem'], description="EM coupling at the Z-boson mass") self.add_default("alphaem", parameters['EW_parameters']['alphaem'], description="EM coupling") self.add_default("alphaem0", parameters['EW_parameters']['alphaem_0'], description="EM coupling at 0") self.add_default("alphaqcd", parameters['EW_parameters']['alphaqcd'], description="strong coupling") self.add_default("alphas_from_lhapdf", -1, description="get strong coupling from LHAPDF") self.add_default("alphaspdf", parameters['EW_parameters']['alphaqcd'], description="strong coupling") self.add_default("altmap", 0, description="mapping that preserves the relative kinematics of the emitter where possible. [1:enabled]") self.add_default("always_quad", 1, description="compute always using quadruple precision [1:enabled]") self.add_default("arXiv:1207.5018", -1, frozen=True, description="compare to arXiv:1207.5018. [>0:enabled]") self.add_default("atlas_scale", -1, description="[-1:use Powheg default]") self.add_default("bcut", -1, description="[-1:use Powheg default]") self.add_default("bmass_in_minlo", 0, description="use non-zero b-mass in MiNLO. [0:disabled; 1:enabled]") self.add_default("bmass_lhe", parameters['particles']['5']['mass'], name="mass_b", description="b-quark mass in GeV (for momentum reshuffling)") # Old value: 4.95 self.add_default("Bmass", parameters['particles']['5']['mass'], name="mass_b", description="b-quark mass in GeV") # Old value: 4.95
  • MadGraph: MadGraph uses parameter cards that can be updated. In order to change values in the default parameter card 'param_card.dat' that is created during the run, a dictionary in a specific format is required. Hence, a new dictionary 'newparamdict' is built from the dictionary 'parameters' in the file 'athena/Generators/MadGraphControl/python/MadGraphUtils.py' in a new function called 'get_newparamdict'. This is then used to update the parameter card in the function 'new_process'. The new dictionary 'newparamdict' is created from 'parameters' only with the help of a "translation" dictionary 'namedict', that helps to translate the keys. The old 'param_card.dat' is moved to 'param_card.dat.backup' and the new 'param_card.dat' is created with the function 'build_param_card' and the dictionary 'newparamdict'. In the function 'generate' it is tested if 'param_card.dat' was updated correctly to feature the values that are in the dictionary 'newparamdict'.
Changes in the file 'MadGraphUtils.py':

In the function 'new_process':

 # Param_card should be located at thedir+'/Cards/param_card.dat'.
    # Move it to thedir+'/Cards/param_card.dat.backup'  
    param_card_loc=thedir+'/Cards/param_card.dat'
    if os.access(param_card_loc,os.R_OK):
        mglog.info('Moving default param_card.dat from '+str(param_card_loc)+'to'+str(param_card_loc)+'.backup')
        shutil.move(param_card_loc,thedir+'/Cards/param_card.dat.backup')
    else:
        param_card_loc=thedir+'/Cards/param_card_default.dat'
        mglog.info('Fetching default param_card.dat from '+str(param_card_loc))
        if os.access(param_card_loc,os.R_OK):
            shutil.move(param_card_loc,thedir+'/Cards/param_card.dat.backup')
        else:
            raise RuntimeError('Cannot find default param_card.dat or param_card_default.dat! I was looking here: %s'%param_card_loc)

    newparamdict = get_newparamdict(thedir)

    # Update the parameter card
    build_param_card(param_card_old=thedir+'/Cards/param_card.dat.backup',param_card_new=thedir+'/Cards/param_card.dat',params=newparamdict)
    mglog.info('Param_card.dat was created with PDG values.')

    return thedir

def get_newparamdict(thedir):

    # Load all entries of the param card in a list to be able to check which parameters were set in the param card before
    param_card_loc = thedir+'/Cards/param_card.dat'
    paramcard = open(param_card_loc+'.backup')
    paramlist = []
    for line in iter(paramcard):
        if not line.strip().startswith('#'): # line commented out
            split_line = line.strip().split(" ")
            if len(split_line) > 1 :
                for i in split_line:
                    if i != "":
                        paramlist.append(i)
                        
    # Read in parameters from dictionary
    from EvgenProdTools.offline_dict import parameters
                        
    # Create translation dictionary to be able to produce dictionary that can be read by build_param_card function (for now only the quarks, leptons and bosons are included)
    namedict = {'t':{'mass':'MT','width':'WT','yukawa':'ymt'},
                'b':{'mass':'MB','yukawa':'ymb'},
                's':{'mass':'MS','yukawa':'yms'},
                'c':{'mass':'MC','yukawa':'ymc'},
                'd':{'mass':'MD','yukawa':'ymdo'},
                'u':{'mass':'MU','yukawa':'ymup'},
                'H':{'mass':'MH','width':'WH'},
                'Z':{'mass':'MZ','width':'WZ'},
                'W':{'mass':'MW','width':'WW'},
                'e':{'mass':'Me','yukawa':'yme'},
                'mu':{'mass':'MMU','yukawa':'ymm'},
                'tau':{'mass':'MTA','width':'Wtau','yukawa':'ymtau'}}

    newparamdict = dict([])
    newparamdict['mass'] = dict([])
    newparamdict['decay'] = dict([])
    newparamdict['yukawa'] = dict([])

    # Loop through parameter dictionary and fill newparamdict, which will then be used to update the param_card
    for key, value in parameters['particles'].items():
        # key is the PID of a particle
        # value is a dictionary with mass, width and name as keys
        particle_name = value['name']
        if particle_name in namedict.keys():
            width = value['width']
            mass = value['mass']      
            if namedict[particle_name]['mass'] in paramlist:
                newparamdict['mass'][namedict[particle_name]['mass']] = mass
            if 'width' in namedict[particle_name].keys() and namedict[particle_name]['width'] in paramlist:
                newparamdict['decay'][namedict[particle_name]['width']] = width
            if 'yukawa' in namedict[particle_name].keys() and namedict[particle_name]['yukawa'] in paramlist:
                newparamdict['yukawa'][namedict[particle_name]['yukawa']] = mass

    mglog.info('The parameters that will be updated are:')
    mglog.info(newparamdict)
    
    return newparamdict

In the function 'generate':

  # Checking if the param_card still features the values that were set with the dictionary 'parameters'
    # Create a list with the values that are currently stored in the param_card.dat

    newparamdict = get_newparamdict(proc_dir)
    param_card_loc = proc_dir+'/Cards/param_card.dat'
    paramcardnew = open(param_card_loc)
    paramlistnew = []    
    for line in iter(paramcardnew):
        if not line.strip().startswith('#'): # line commented out
            split_line = line.strip().split(" ")
            if len(split_line) > 1 :
                for i in split_line:
                    if i != "":
                        paramlistnew.append(i)

    # Compare the entries in the dictionary that was used to create the card (newparamdict) with the values that are now actually in the param_card.dat by comparing the entries in the paramlistnew
    
    current_block_name = ""
    for i in range(len(paramlistnew)):
        entry = paramlistnew[i]    
        if entry == "Block":
            current_block_name = paramlistnew[i+1]
        elif entry == "DECAY":
            current_block_name = "decay"
        elif entry =="#":
            value = paramlistnew[i-1]
            name = paramlistnew[i+1]
            if current_block_name in newparamdict.keys(): 
                if name in newparamdict[current_block_name].keys():
                    if (newparamdict[current_block_name][name] == value):
                        mglog.info('Parameter %s was successfully updated.' %name)
                    else:
                        mglog.warning('The parameter %s in param_card.dat you tried to update with the parameter dictionary got changed again.' %name)
        else: 
            continue

What do I need to do when I want to use this?

Keeping the dictionary up-to-date

The newest PDG API was used to create the dictionary 'p_dict' in the dictionary 'parameters' in the file 'athena/Generators/EvgenProdTools/python/physics_parameters.py'. For 2019, this is the file http://pdg.lbl.gov/2019/mcdata/mass_width_2019.mcd.

The dictionary is created in the following way: It is checked whether the file from the PDG API is already existent. If this is the case, the dictionary is created from this file with 'physics_parameters.py' and stored in the file 'athena/Generators/EvgenProdTools/python/offline_dict.py'. If not, the file is downloaded and the values are extracted.

This also means that once a new PDG API is available, the file 'athena/Generators/EvgenProdTools/python/physics_parameters.py' needs to be altered to search for the new file. This should simply be done by modifying the year in the expression of the file.

Using the new parameters when running a job option

Sherpa: When you want to use the new parameters, you should load in your job option the file '2.2.8_NNPDF30NNLO.py'. This will then automatically call the '2.2.8_Base_Fragment.py' which loads the dictionary and implements these values for the top quark, the leptons, the bosons and sin2thetaW. If you want more or less particle parameters and other EW parameters to be loaded from the dictionary, you can simply adjust the base fragment '2.2.8_Base_Fragment.py' accordingly. Also, you need to make sure to load 'Generators/EvgenProdTools/python' in your local athena version to use the file 'Generators/EvgenProdTools/python/physics_parameters.py'.

Pythia8: The base fragment 'Pythia8_Base_Fragment.py' which loads the dictionary and implements these values for the top quark, the leptons, the bosons and sin2thetaW is per default included in the job options you are using. If you want more or less particle parameters and other EW parameters to be loaded from the dictionary, you can simply adjust the base fragment 'Pythia8_Base_Fragment.py' accordingly. Also, you need to make sure to load 'Generators/EvgenProdTools/python' in your local athena version to use the file 'Generators/EvgenProdTools/python/physics_parameters.py'.

Herwig7: The file 'Herwig7Config.py' contains the class that is the base class for all Herwig runs. Hence, it is included in the job options you will be using. If you want more parameters to be loaded from the dictionary 'parameters', you can adjuste the file 'Herwig7Config.py' to fit your needs. Also, you need to make sure to load 'Generators/EvgenProdTools/python' in your local athena version to use the file 'Generators/EvgenProdTools/python/physics_parameters.py'.

Powheg: The file 'registry.py' is automatically called when you run a Powheg job option. If you encounter problems in the physics you obtain with your runs, you can try exchanging the parameters from the dictionary with the initial values. These are written in parentheses behind the lines where the value was changed. Also, you need to make sure to load 'Generators/EvgenProdTools/python' in your local athena version to use the file 'Generators/EvgenProdTools/python/physics_parameters.py'.

MadGraph: The file 'MadGraphUtils.py' is automatically called when you run a MadGraph job option. The parameter card that is updated with the parameters from the dictionary 'parameters' can again be changed to your needs, if you are for example using a different physics model. To properly update the parameter card you only need to make sure to load 'Generators/EvgenProdTools/python' in your local athena version to use the file 'Generators/EvgenProdTools/python/physics_parameters.py'.

Edit | Attach | Watch | Print version | History: r6 < r5 < r4 < r3 < r2 | Backlinks | Raw View | WYSIWYG | More topic actions
Topic revision: r6 - 2019-10-18 - SilkeMobius1
 
    • Cern Search Icon Cern Search
    • TWiki Search Icon TWiki Search
    • Google Search Icon Google Search

    Sandbox All webs login

This site is powered by the TWiki collaboration platform Powered by PerlCopyright & 2008-2020 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
or Ideas, requests, problems regarding TWiki? use Discourse or Send feedback