RHadronMasses Namespace Reference

Functions
	charge (c)
	get_quarks (y)
	is_baryon (x)
	anti_name (x)
	get_gluino_Rhadron_masses (input_file, mass_spectrum=1)
	update_PDG_table (input_file, pdg_table, mass_spectrum=1)
	update_particle_table (input_file, particle_table='particles.txt', mass_spectrum=1)
	get_Pythia8_commands (input_file, mass_spectrum=1)
	get_interaction_list (input_file, interaction_file='ProcessList.txt', mass_spectrum=1)
	print_masses (spectrum=-1)

Variables
int	first_mass_set = 4
dict	offset_options
dict	gb_offset = offset_options[1009113][first_mass_set+5]-offset_options[1009113][first_mass_set+1]

Detailed Description

The offset options.  Dictionary of PDG IDs with offsets.
Anti-particles by definition have the same mass as standard particles.
Columns are:
   PDG ID
   PDG ID of SUSY constituent
   Has an anti-particle (i.e. need to define a particle with an opposite-signed PDG ID)
   Name (for PDG table)
   Charge (for PDG table)

   Mass Offset in the Pythia6 simulation configuration
   8 mass options documented in the INT note of the stopped particle analysis:
   https://cds.cern.ch/record/2665511
   First 3 are the meson fits; 4th is the first specrum shifted to make the gluino R-glueball heaver
    than the lightest R-mesons, but with the same relative splitting otherwise.
   Second set of four follow the same pattern, but for the baryon fits.

The list of possible R-hadrons comes from the Pythia8 code, in src/RHadrons.cc (at the top)

Function Documentation

anti_name()

RHadronMasses.anti_name

(

x

)

 Function to turn a particle name into an anti-particle name (mostly charge issues)

Definition at line 174 of file RHadronMasses.py.

def anti_name( x ):
    """ Function to turn a particle name into an anti-particle name (mostly charge issues)
    """
    # These look a little funny to get both + and ++
    if '*+' in x: return x.replace('*','bar*').replace('+','-')
    if '*-' in x: return x.replace('*','bar*').replace('-','+')
    if '++' in x: return x.replace('++','bar--')
    if '--' in x: return x.replace('--','bar++')
    if '+' in x:  return x.replace('+','bar-')
    if '-' in x:  return x.replace('-','bar+')
    if '*0' in x: return x.replace('*0','bar*0')
    return x.replace('0','bar0')
 
 

charge()

RHadronMasses.charge

(

c

)

 Function to return a PDG table formatted charge given an integer charge
    Input is the charge either as a string or number

Definition at line 134 of file RHadronMasses.py.

def charge( c ):
    """ Function to return a PDG table formatted charge given an integer charge
        Input is the charge either as a string or number
    """
    n = int(c)
    if n==0: return ' 0'
    if n==1: return ' +'
    if n==2: return '++'
    if n==-1: return ' -'
    if n==-2: return '--'
    raise RuntimeError('Unexpected charge: '+str(n))
 
 

get_gluino_Rhadron_masses()

RHadronMasses.get_gluino_Rhadron_masses	(		input_file,
			mass_spectrum = 1 )

 Function to return a dictionary of PDG IDs and masses based on an input param/SLHA/LHE file
    First parameter: input file (string or file handle)
    Second parameter: mass spectrum (enumeration value)

Definition at line 188 of file RHadronMasses.py.

def get_gluino_Rhadron_masses(input_file, mass_spectrum=1):
    """ Function to return a dictionary of PDG IDs and masses based on an input param/SLHA/LHE file
        First parameter: input file (string or file handle)
        Second parameter: mass spectrum (enumeration value)
    """
    # Expect a string file name or file handle
    if isinstance(input_file, str):
        in_file = open(input_file,'r')
    else:
        in_file = input_file
 
    # Expect SLHA file format.  Read for mass block, then look for relevant masses, then exit
    masses = {}
    mass_block = False
    for l in in_file.readlines():
        # Are we entering the mass block?
        if 'BLOCK' in l.upper().split('#')[0].split() and 'MASS' in l.upper().split('#')[0].split():
            mass_block = True
            continue
        # Otherwise, if we've not yet entered the mass block, keep reading
        elif not mass_block: continue
        # If we're past the mass block, then stop reading
        if 'BLOCK' in l.upper().split('#')[0].split(): break
        # Skip empty lines, comments, etc
        if len(l.split('#')[0].split())<2: continue
        pdg_id = int(l.split('#')[0].split()[0])
        # Set the input masses
        if pdg_id in offset_options:
            mass = float(l.split('#')[0].split()[1])
            # If we have decoupled the thing, don't include it!
            if mass > 7e3: continue
            # Otherwise, it goes in the list
            masses[pdg_id] = mass
        # Not an ID we care about otherwise!  Skip!
    # Done reading file; close if it's our responsibility
    if isinstance(input_file, str):
        in_file.close()
 
    # Set the remainder of the masses
    had_rhadron=False
    for pid in offset_options:
        # Skip fundamental particles - they should be read from the input file!
        if offset_options[pid][0] == 0: continue
        # Check if the constituent is in there (e.g. skip stop R-hadrons for gluino production)
        if offset_options[pid][0] not in masses: continue
        # Check if the mass spectrum is available
        if mass_spectrum<0 or first_mass_set+mass_spectrum>len(offset_options[pid]):
            raise RuntimeError("Unknown mass set requested: "+str(mass_spectrum)+" > number of options ("+str(len(offset_options[pid])-first_mass_set+1)+") for PID "+str(pid))
        # Add 'normal' R-hadron
        masses[pid] = masses[ offset_options[pid][0] ] + offset_options[pid][first_mass_set+mass_spectrum]
        # If needed, add anti-R-hadron
        if offset_options[pid][1]:
            masses[-pid] = masses[ offset_options[pid][0] ] + offset_options[pid][first_mass_set+mass_spectrum]
        had_rhadron = True
 
    # Make sure we generated some R-hadrons
    if not had_rhadron:
        raise RuntimeError('No R-hadrons generated!')
 
    # Return the dictionary
    return masses
 
 

get_interaction_list()

RHadronMasses.get_interaction_list	(		input_file,
			interaction_file = 'ProcessList.txt',
			mass_spectrum = 1 )

 Function to write all possible interactiosn that we need
    First input parameter: input file (string or file handle)
    Second input parameter: output PDG table (string or file handle)
    Third input parameter: mass spectrum (enumeration value)
    Gets R-hadron masses based on get_gluino_Rhadron_masses()

Definition at line 365 of file RHadronMasses.py.

def get_interaction_list(input_file, interaction_file='ProcessList.txt', mass_spectrum=1):
    """ Function to write all possible interactiosn that we need
        First input parameter: input file (string or file handle)
        Second input parameter: output PDG table (string or file handle)
        Third input parameter: mass spectrum (enumeration value)
        Gets R-hadron masses based on get_gluino_Rhadron_masses()
    """
    # Get the masses that we need. Note that we don't really need masses, just PDG IDs
    masses = get_gluino_Rhadron_masses(input_file,mass_spectrum)
    # Get the output file ready
    # Open for appending (assume that's what was done if given a file handle)
    if isinstance (interaction_file, str):
        out_file = open(interaction_file,'a')
    else:
        out_file = interaction_file
 
    # Helpful lists to move us along
    sm_particles = {
      # Name  :  Charge , Baryon # , Strangeness
        'pi0' : [  0 , 0 ,  0 ],
        'pi+' : [  1 , 0 ,  0 ],
        'pi-' : [ -1 , 0 ,  0 ],
    'neutron' : [  0 , 1 ,  0 ],
     'proton' : [  1 , 1 ,  0 ],
      'kaon0' : [  0 , 0 ,  1 ],
 'anti_kaon0' : [  0 , 0 , -1 ],
      'kaon+' : [  1 , 0 ,  1 ],
      'kaon-' : [ -1 , 0 , -1 ]
                   }
    targets = [ 'proton' , 'neutron' ]
 
    incoming_rhadrons = {}
    outgoing_rhadrons = {}
    for pid in masses:
        # Only for bound states
        if offset_options[abs(pid)][0]==0: continue
        # All of them are on the list of incoming RHadrons
        # Deal with strangeness
        # Approximation! Bottom number -> -Charm number -> Strangeness
        # Approximation needed because outgoing SM charms are not treated in G4 at the moment
        s_number = 0
        my_q = get_quarks(pid)
        if '3' in my_q or '4' in my_q or '5' in my_q:
            if len(my_q)>2:
                # Gluino R-baryons
                s_number = -(my_q.count('3')-my_q.count('4')+my_q.count('5')) if pid>0 else my_q.count('3')-my_q.count('4')+my_q.count('5')
            elif len(my_q)>1 and '9' in str(pid):
                # Gluino R-mesons
                if my_q in ['33','44','55','35']: s_number=0 # 33, 44, 55, 35 - one is anti-quark, so they cancel
                # By convention both 43 and 53 have charge +1, which means c-sbar or c-bbar
                elif my_q in ['43','53']: s_number = 2 if pid>0 else -2
                # Only one of bottom / charm / strange. Deal with neutral convention first
                elif offset_options[abs(pid)][3]==0 and ('3' in my_q or '5' in my_q): s_number=1 if pid>0 else -1
                elif offset_options[abs(pid)][3]==0 and '4' in my_q: s_number=1 if pid<0 else -1
                # Now charged convention
                elif '3' in my_q or '5' in my_q: s_number=offset_options[abs(pid)][3]
                elif '4' in my_q: s_number=-offset_options[abs(pid)][3]
            elif len(my_q)>1:
                # Squark R-baryons
                s_number = -(my_q.count('3')-my_q.count('4')+my_q.count('5')) if pid>0 else my_q.count('3')-my_q.count('4')+my_q.count('5')
            else:
                # Squark R-mesons
                s_number = my_q.count('3') - my_q.count('4') + my_q.count('5')
                s_number = s_number if pid>0 else -s_number
        else: s_number=0
        # Build the dictionary
        pid_name = offset_options[pid][2].strip() if pid>0 else anti_name(offset_options[abs(pid)][2]).strip()
        charge = offset_options[abs(pid)][3] if pid>0 else -offset_options[abs(pid)][3]
        incoming_rhadrons[pid_name] = [ charge , is_baryon(pid) , s_number ]
        # Smaller list of outgoing rhadrons.
        # No charm or bottom
        if '4' in my_q or '5' in my_q: continue
        outgoing_rhadrons[pid_name] = [ charge , is_baryon(pid) , s_number ]
 
    # Add all our R-hadrons to the table
    for proj in incoming_rhadrons:
        # Loop over targets
        for t in targets:
            # Loop over possible outgoing R-hadrons
            for orhad in outgoing_rhadrons:
                # Possible 2>2 reactions
                for osm1 in sm_particles:
                    # Check for charge conservation
                    total_charge = incoming_rhadrons[proj][0]+sm_particles[t][0]-outgoing_rhadrons[orhad][0]-sm_particles[osm1][0]
                    # Check for baryon number conservation
                    total_bnumber = incoming_rhadrons[proj][1]+sm_particles[t][1]-outgoing_rhadrons[orhad][1]-sm_particles[osm1][1]
                    # Check for strangeness conservation
                    total_snumber = incoming_rhadrons[proj][2]+sm_particles[t][2]-outgoing_rhadrons[orhad][2]-sm_particles[osm1][2]
                    # Check if it's an allowed reaction
                    if total_charge==0 and total_bnumber==0 and total_snumber==0:
                        out_file.write( ' # '.join([str(proj),str(t),str(orhad),str(osm1)])+'\n' )
                    # Now loop over possible 2>3 reactions
                    for osm2 in sm_particles:
                        # Check for charge conservation
                        total_charge = incoming_rhadrons[proj][0]+sm_particles[t][0]-outgoing_rhadrons[orhad][0]-sm_particles[osm1][0]-sm_particles[osm2][0]
                        # Check for baryon number conservation
                        total_bnumber = incoming_rhadrons[proj][1]+sm_particles[t][1]-outgoing_rhadrons[orhad][1]-sm_particles[osm1][1]-sm_particles[osm2][1]
                        # Check for strangeness conservation
                        total_snumber = incoming_rhadrons[proj][2]+sm_particles[t][2]-outgoing_rhadrons[orhad][2]-sm_particles[osm1][2]-sm_particles[osm2][2]
                        # Check if it's an allowed reaction
                        if total_charge==0 and total_bnumber==0 and total_snumber==0:
                            out_file.write( ' # '.join([str(proj),str(t),str(orhad),str(osm1),str(osm2)])+'\n' )
                        # Wrote out the reaction
                    # Loop over 2>3
                # Loop over 2>2
            # Loop over outgoing RHadrons
        # Loop over targets
    # Loop over projectiles
 
    # Done writing all the lines!  Clean up if necessary
    if isinstance(interaction_file, str):
        out_file.close()
 
    # Nothing to return
 
 

get_Pythia8_commands()

RHadronMasses.get_Pythia8_commands	(		input_file,
			mass_spectrum = 1 )

 Function to return a list of Pythia8 commands to set up an R-hadron mass spectrum.
    First input parameter: input file (string or file handle)
    Second input parameter: mass spectrum (enumeration value)

Definition at line 344 of file RHadronMasses.py.

def get_Pythia8_commands(input_file, mass_spectrum=1):
    """ Function to return a list of Pythia8 commands to set up an R-hadron mass spectrum.
        First input parameter: input file (string or file handle)
        Second input parameter: mass spectrum (enumeration value)
    """
    # Get the masses for this configuration
    masses = get_gluino_Rhadron_masses(input_file,mass_spectrum)
    # Tell Pythia8 we are going to use our own masses
    commands = ['RHadrons:setMasses = off']
    
    # Add commands to set all the masses
    for pid in masses:
        # Only set masses for particles (not anti-particles)
        if pid<0: continue
        # Actual command takes the form PDGID:m0 = somemass
        commands += [ str(pid)+':m0 = '+str(masses[pid]) ]
 
    # All done!
    return commands
 
 

get_quarks()

RHadronMasses.get_quarks

(

y

)

 Function to return a list of quarks in a hadron

Definition at line 147 of file RHadronMasses.py.

def get_quarks( y ):
    """ Function to return a list of quarks in a hadron
    """
    x = abs(y)
    # For stop/sbottom mesons, just the last quark!
    if '000' in str(x): return str(x)[5:6]
    # For mesons, just two quarks
    if '00' in str(x): return str(x)[4:6]
    # For baryons, three quarks
    return str(x)[3:6]
 
 

is_baryon()

RHadronMasses.is_baryon

(

x

)

Definition at line 159 of file RHadronMasses.py.

def is_baryon( x ):
    # 1000993, gluinoball, is also not a baryon
    b_n = 0
    if '009' in str(x): b_n=0 # gluino meson
    elif '09' in str(x): b_n=1 # gluino baryon
    elif '0006' in str(x): b_n=0 # stop meson
    elif '0005' in str(x): b_n=0 # sbottom meson
    elif '006' in str(x): b_n=1 # stop baryon
    elif '005' in str(x): b_n=1 # sbottom baryon
    else: # Otherwise, what on earth was this??
        raise RuntimeError('is_baryon   ERROR Unknown PDG ID: '+str(x))
    if int(x)<0: return -b_n
    return b_n
 
 

print_masses()

RHadronMasses.print_masses

(

spectrum = -1

)

 Print the mass spectra.
Input parameter: spectrum number.  If -1, print all spectra.

Definition at line 481 of file RHadronMasses.py.

def print_masses(spectrum=-1):
    """ Print the mass spectra.
    Input parameter: spectrum number.  If -1, print all spectra.
    """
    for i in sorted(offset_options.keys()):
        s= str(offset_options[i][2])+' '+str(i)
        if spectrum<0:
            from past.builtins import range # Temporary workaround for python3 compatibility use range in CA-based config
            for j in range(first_mass_set,len(offset_options[i])): s+=' '+str(offset_options[i][j])
        else:
            if first_mass_set+spectrum>len(offset_options[i]):
                raise RuntimeError('Spectrum #'+str(spectrum)+' not known for PID '+str(i))
            else:
                s+=' '+str(offset_options[i][spectrum+first_mass_set])
        print (s)
    # Done!

update_particle_table()

RHadronMasses.update_particle_table	(		input_file,
			particle_table = 'particles.txt',
			mass_spectrum = 1 )

 Function to update a particle table with R-hadron masses
    First input parameter: input file (string or file handle)
    Second input parameter: output particle table (string or file handle)
    Third input parameter: mass spectrum (enumeration value)
    Gets R-hadron masses based on get_gluino_Rhadron_masses()

Definition at line 289 of file RHadronMasses.py.

def update_particle_table(input_file, particle_table='particles.txt', mass_spectrum=1):
    """ Function to update a particle table with R-hadron masses
        First input parameter: input file (string or file handle)
        Second input parameter: output particle table (string or file handle)
        Third input parameter: mass spectrum (enumeration value)
        Gets R-hadron masses based on get_gluino_Rhadron_masses()
    """
    # Get the masses that we need
    masses = get_gluino_Rhadron_masses(input_file,mass_spectrum)
    # Get the output file ready
    # Open for appending (assume that's what was done if given a file handle)
    if isinstance (particle_table, str):
        out_file = open(particle_table,'a')
    else:
        out_file = particle_table
    # Add all our R-hadrons to the table!
    # Note that we MUST write the primary first, followed by the compound particles
    primaries = []
    extras = []
    for pid in masses:
        if offset_options[abs(pid)][0]==0: extras += [pid]
        elif not offset_options[abs(pid)][0] in primaries: primaries += [ offset_options[abs(pid)][0] ]
 
    # Rounds per primary
    for p in primaries:
        # Note that we follow the old convention of *including* fundamental SUSY particles
        # The format is VERY specific; needs mass and width (we always set the width to 0)
        # Mass is in MeV here, rather than GeV as in the dictionary
        if p>0: out_file.write('     %i  %04.3f   # %s\n'%(p,masses[p],offset_options[abs(p)][2]))
        # For the anti-particle, also need the anti-name
        else:     out_file.write('    %i  %04.3f   # %s\n'%(p,masses[p],anti_name(offset_options[abs(p)][2])))
        # Now include the secondaries
        for pid in masses:
            if offset_options[abs(pid)][0]!=p: continue
            # Note that we follow the old convention of *including* fundamental SUSY particles
            # The format is VERY specific; needs mass and width (we always set the width to 0)
            # Mass is in MeV here, rather than GeV as in the dictionary
            if pid>0: out_file.write('     %i  %04.3f   # %s\n'%(pid,masses[pid],offset_options[abs(pid)][2]))
            # For the anti-particle, also need the anti-name
            else:     out_file.write('    %i  %04.3f   # %s\n'%(pid,masses[pid],anti_name(offset_options[abs(pid)][2])))
        # Done with secondaries for this primary
 
    for p in extras:
        if p in primaries: continue
        if p>0: out_file.write('     %i  %04.3f   # %s\n'%(p,masses[p],offset_options[abs(p)][2]))
        # For the anti-particle, also need the anti-name
        else:   out_file.write('    %i  %04.3f   # %s\n'%(p,masses[p],anti_name(offset_options[abs(p)][2])))
 
    # Done writing all the lines!  Clean up if necessary
    if isinstance(particle_table, str):
        out_file.close()
 
    # Nothing to return
 
 

update_PDG_table()

RHadronMasses.update_PDG_table	(		input_file,
			pdg_table,
			mass_spectrum = 1 )

 Function to update a PDG table with R-hadron masses
    First input parameter: input file (string or file handle)
    Second input parameter: output PDG table (string or file handle)
    Third input parameter: mass spectrum (enumeration value)
    Gets R-hadron masses based on get_gluino_Rhadron_masses()

Definition at line 251 of file RHadronMasses.py.

def update_PDG_table(input_file, pdg_table, mass_spectrum=1):
    """ Function to update a PDG table with R-hadron masses
        First input parameter: input file (string or file handle)
        Second input parameter: output PDG table (string or file handle)
        Third input parameter: mass spectrum (enumeration value)
        Gets R-hadron masses based on get_gluino_Rhadron_masses()
    """
    # Check that we had the right output file type
    # Get the masses that we need
    masses = get_gluino_Rhadron_masses(input_file,mass_spectrum)
    # Get the output file ready
    # Open for appending (assume that's what was done if given a file handle)
    lines = None
    if isinstance(pdg_table, str):
        lines = open(pdg_table).readlines()
    else:
        lines = pdg_table.readlines()
    # Add all our R-hadrons to the table!
    pdgcodes = []
    for pid in masses:
        pdgcodes += [pid]
        # For the PDG table, we only write positive-signed PDG ID particles
        if pid<0: continue
        # Note that we follow the Pythia6 convention of *including* fundamental SUSY particles
        # The format is VERY specific; needs mass and width (we always set the width to 0)
        # Mass is in MeV here, rather than GeV as in the dictionary
        lines.append('M %i                          %11.7E  +0.0E+00 -0.0E+00 %s       %s'%(pid,masses[pid]*1000.,offset_options[pid][2],charge(offset_options[pid][3])) + '\n')
        lines.append('W %i                          %11.7E  +0.0E+00 -0.0E+00 %s       %s'%(pid,0.E+00,offset_options[pid][2],charge(offset_options[pid][3])) + '\n')
 
    update = open('PDGTABLE.MeV', 'w')
    update.write(''.join(lines))
    update.close()
 
    from ExtraParticles.PDGHelpers import updateExtraParticleAcceptList
    updateExtraParticleAcceptList('G4particle_acceptlist_ExtraParticles.txt', pdgcodes)
    # Nothing to return
 
 

Variable Documentation

first_mass_set

int RHadronMasses.first_mass_set = 4

Definition at line 27 of file RHadronMasses.py.

gb_offset

dict RHadronMasses.gb_offset = offset_options[1009113][first_mass_set+5]-offset_options[1009113][first_mass_set+1]

Definition at line 123 of file RHadronMasses.py.

offset_options

dict RHadronMasses.offset_options

Definition at line 28 of file RHadronMasses.py.