hepi

The HEPi package aims to automize cluster computations for parameter scans with the option to produce plots.

Subpackages

Submodules

Package Contents

Classes

Order

Computation orders.

DictData

Order

Computation orders.

Input

Input for computation and scans.

DictData

Result

General result class.

DictData

Input

Input for computation and scans.

Input

Input for computation and scans.

Order

Computation orders.

Result

General result class.

DictData

RunParam

Abstract class that is similar to a dictionary but with fixed keys.

Runner

Input

Input for computation and scans.

Functions

order_to_string(o: Order, json_style=False, no_macros=False) → str

LD2DF(ld: dict) → pandas.DataFrame

Convert a dict of list`s to a `pandas.DataFrame.

get_name(pid: int) → str

Get the latex name of a particle.

write_latex(dict_list, key, fname, scale=True, pdf=True, yscale=1.0)

Saves a dict of list`s to `filename as latex table.

write_csv(dict_list: list, filename: str)

Saves a dict of list`s to `filename as csv table.

write_json(dict_list: list, o: hepi.input.Order, parameter: str, filename: str, error_sym=False, error_asym=False)

Saves a dict of list`s to `filename as json.

get_LR_partner(pid: int) → Tuple[int, int]

Transforms a PDG id to it's left-right partner.

lhapdf_name_to_id(name: str) → int

Converts a LHAPDF name to the sets id.

get_input_dir()

Get the input directory.

get_output_dir()

Get the input directory.

get_pre()

Gets the command prefix.

set_input_dir(ind)

Sets the input directory.

set_output_dir(outd, create: bool = True)

Sets the output directory.

set_pre(ppre)

Sets the command prefix.

replace_macros(s: str) → str

order_to_string(o: Order, json_style=False, no_macros=False) → str

xsec_to_order(s: str)

is_gluino(iid: int) → bool

is_neutralino(iid: int) → bool

is_chargino(iid: int) → bool

is_weakino(iid: int) → bool

is_squark(iid: int) → bool

is_slepton(iid: int) → bool

update_slha(i: Input)

Updates dependent parameters in Input i.

scan(l: List[Input], var: str, rrange: Iterable) → List[Input]

Scans a variable var over rrange in l.

scan_multi(li: List[Input], **kwargs) → List[Input]

Magically scans the variables passed to this function.

scan_scale(l: List[Input], rrange=3, distance=2.0)

Scans scale by varying mu_f and mu_r.

scan_seven_point(l: List[Input])

Scans scale by varying mu_f and mu_r by factors of two excluding relative factors of 4.

change_where(l: List[Input], dicts: dict, **kwargs)

Applies the values of dicts if the key value pairs in kwargs agree with a member of the list l.

scan_invariant_mass(l: List[Input], diff, points, low=0.001)

Logarithmic invariant_mass scan close to the production threshold.

slha_write(newname, d)

masses_scan(l: List[Input], vars: List[int], rrange, diff_L_R=None, negate=[]) → List[Input]

Scans the PDG identified mass var over rrange in the list l.

mass_scan(l: List[Input], var: int, rrange, diff_L_R=None) → List[Input]

Scans the PDG identified mass var over rrange in the list l.

slha_scan(l: List[Input], block, var, rrange: List) → List[Input]

Scan a generic

slha_scan_rel(l: List[Input], lambdas, rrange: List) → List[Input]

Scan a generic slha variable.

scan_pdf(l: List[Input])

Scans NLO PDF sets.

pdf_error(li, dl, confidence_level=90)

Computes Parton Density Function (PDF) uncertainties through lhapdf.set.uncertainty().

scale_error(li, dl)

Computes seven-point scale uncertainties from the results where the renormalization and factorization scales are varied by factors of 2 and relative factors of four are excluded (cf. seven_point_scan()).

combine_errors(dl: dict)

Combines seven-point scale uncertainties and pdf uncertainties from the results by Pythagorean addition.

LD2DL(l: List, actual_dict=False) → dict

Convert a list of objects into a dictionary of lists.

LD2DF(ld: dict) → pandas.DataFrame

Convert a dict of list`s to a `pandas.DataFrame.

get_name(pid: int) → str

Get the latex name of a particle.

get_LR_partner(pid: int) → Tuple[int, int]

Transforms a PDG id to it's left-right partner.

namehash(n: any) → str

Creates a sha256 hash from the objects string representation.

lhapdf_name_to_id(name: str) → int

Converts a LHAPDF name to the sets id.

get_output_dir()

Get the input directory.

replace_macros(s: str) → str

get_name(pid: int) → str

Get the latex name of a particle.

title(axe, i: hepi.input.Input, scenario='', diff_L_R=None, extra='', cms_energy=True, pdf_info=True, **kwargs)

Sets the title on axis axe.

energy_plot(dict_list, y, yscale=1.0, xaxis='E [GeV]', yaxis='$\\sigma$ [pb]', label=None, **kwargs)

Plot energy on the x-axis.

mass_plot(dict_list, y, part, logy=True, yaxis='$\\sigma$ [pb]', yscale=1.0, label=None, **kwargs)

mass_vplot(dict_list, y, part, logy=True, yaxis='$\\sigma$ [pb]', yscale=1.0, label=None, mask=None, **kwargs)

get_mass(l: dict, iid: int)

Get the mass of particle with id iid out of the list in the "slha" element in the dict.

plot

index_open(var, idx)

slha_data(li, index_list)

slha_plot(li, x, y, **kwargs)

vplot(x, y, label=None, xaxis='E [GeV]', yaxis='$\\sigma$ [pb]', logy=True, yscale=1.0, interpolate=True, plot_data=True, data_color=None, mask=-1, fill=False, data_fmt='.', fmt='-', print_area=False, sort=True, **kwargs)

Creates a plot based on the values in x`and `y.

mass_mapplot(dict_list, part1, part2, z, logz=True, zaxis='$\\sigma$ [pb]', zscale=1.0, label=None)

mapplot(dict_list, x, y, z, xaxis=None, yaxis=None, zaxis=None, **kwargs)

Examples

map_vplot(vx, vy, vz, xaxis=None, yaxis=None, zaxis=None, logz=True, sort=True, fill_missing=True, zscale=1.0)

err_plt(axes, x, y, label=None, error=False)

scale_plot(dict_list, vl, seven_point_band=False, cont=False, error=True, li=None, plehn_color=False, yscale=1.0, unit='pb', yaxis=None, **kwargs)

Creates a scale variance plot with 5 panels (xline).

central_scale_plot(dict_list, vl, cont=False, error=True, yscale=1.0, unit='pb', yaxis=None)

Creates a scale variance plot with 3 panels (ystacked).

init_double_plot(figsize=(6, 8), sharex=True, sharey=False, gridspec_kw={'height_ratios': [3, 1]})

Initialze subplot for Ratio/K plots with another figure below.

get_input_dir()

Get the input directory.

get_output_dir()

Get the input directory.

get_pre()

Gets the command prefix.

LD2DL(l: List, actual_dict=False) → dict

Convert a list of objects into a dictionary of lists.

namehash(n: any) → str

Creates a sha256 hash from the objects string representation.

order_to_string(o: Order, json_style=False, no_macros=False) → str

xsec_to_order(s: str)

LD2DL(l: List, actual_dict=False) → dict

Convert a list of objects into a dictionary of lists.

load

Attributes

splot

tex_table

in_dir

Input directory.

out_dir

Output directory.

pre

Prefix for run commands.

multi_scan

scale_scan

seven_point_scan

pdf_scan

required_numerical_uncertainty_factor

If the numerical uncertainty is required_numerical_uncertainty_factor times higher than the scale or pdf uncertainty a warning is shown.

fig

axs

lines

labels

package

version

__version__

class hepi.Order

Bases: enum.IntEnum

Computation orders.

Initialize self. See help(type(self)) for accurate signature.

LO = 0

Leading Order

NLO = 1

Next-to-Leading Order

NLO_PLUS_NLL = 2

Next-to-Leading Order plus Next-to-Leading Logarithms

aNNLO_PLUS_NNLL = 3

Approximate Next-to-next-to-Leading Order plus Next-to-next-to-Leading Logarithms

hepi.order_to_string(o: Order, json_style=False, no_macros=False) → str
hepi.LD2DF(ld: dict) → pandas.DataFrame

Convert a dict of list`s to a `pandas.DataFrame.

hepi.get_name(pid: int) → str

Get the latex name of a particle.

Parameters

pid (int) – PDG Monte Carlo identifier for the particle.

Returns

Latex name.

Return type

str

Examples

>>> get_name(21)
'g'
>>> get_name(1000022)
'\\tilde{\\chi}_{1}^{0}'
hepi.splot[source]
hepi.write_latex(dict_list, key, fname, scale=True, pdf=True, yscale=1.0)[source]

Saves a dict of list`s to `filename as latex table.

hepi.tex_table[source]
hepi.write_csv(dict_list: list, filename: str)[source]

Saves a dict of list`s to `filename as csv table.

hepi.write_json(dict_list: list, o: hepi.input.Order, parameter: str, filename: str, error_sym=False, error_asym=False)[source]

Saves a dict of list`s to `filename as json.

Cf. https://github.com/fuenfundachtzig/xsec

class hepi.DictData
__str__(self)

Returns attributes as dict as string

hepi.get_LR_partner(pid: int) → Tuple[int, int]

Transforms a PDG id to it’s left-right partner.

Parameters

pid (int) – PDG Monte Carlo identifier for the particle.

Returns

First int is -1 for Left and 1 for Right. Second int is the PDG id.

Return type

tuple

Examples

>>> get_LR_partner(1000002)
(-1, 2000002)
hepi.lhapdf_name_to_id(name: str) → int

Converts a LHAPDF name to the sets id.

Parameters

name (str) – LHAPDF set name.

Returns

id of the LHAPDF set.

Return type

int

Examples

>>> lhapdf_name_to_id("CT14lo")
13200
hepi.in_dir = ./input/[source]

Input directory.

hepi.out_dir = ./output/[source]

Output directory.

hepi.pre = nice -n 5[source]

Prefix for run commands.

hepi.get_input_dir()[source]

Get the input directory.

Returns

in_dir

Return type

str

hepi.get_output_dir()[source]

Get the input directory.

Returns

out_dir

Return type

str

hepi.get_pre()[source]

Gets the command prefix.

Returns

pre

Return type

str

hepi.set_input_dir(ind)[source]

Sets the input directory.

Parameters

ind (str) – new input directory.

hepi.set_output_dir(outd, create: bool = True)[source]

Sets the output directory.

Parameters

outd (str) – new output directory. create (bool): create directory if not existing

hepi.set_pre(ppre)[source]

Sets the command prefix.

Parameters

ppre (str) – new command prefix.

class hepi.Order

Bases: enum.IntEnum

Computation orders.

Initialize self. See help(type(self)) for accurate signature.

LO = 0

Leading Order

NLO = 1

Next-to-Leading Order

NLO_PLUS_NLL = 2

Next-to-Leading Order plus Next-to-Leading Logarithms

aNNLO_PLUS_NNLL = 3

Approximate Next-to-next-to-Leading Order plus Next-to-next-to-Leading Logarithms

hepi.replace_macros(s: str) → str[source]
hepi.order_to_string(o: Order, json_style=False, no_macros=False) → str
hepi.xsec_to_order(s: str)[source]
class hepi.Input(order: Order, energy: float, particle1: int, particle2: int, slha: str, pdf_lo: str, pdf_nlo: str, mu_f=1.0, mu_r=1.0, pdfset_lo=0, pdfset_nlo=0, precision=0.01, max_iters=50, invariant_mass='auto', result='total', pt='auto', id='', model='', update=True)[source]

Bases: hepi.util.DictData

Input for computation and scans.

Variables

  • order (Order) – LO, NLO or NLO+NLL computation.

  • energy (int) – CMS energy in GeV.

  • energyhalf (int) – Halfed energy.

  • particle1 (int) – PDG identifier of the first final state particle.

  • particle2 (int) – PDG identifier of the second final state particle.

  • slha (str) – File path of for the base slha. Modified slha files will be used if a scan requires a change of the input.

  • pdf_lo (str) – LO PDF name.

  • pdf_nlo (str) – NLO PDF name.

  • pdfset_lo (int) – LO PDF member/set id.

  • pdfset_nlo (int) – NLO PDF member/set id.

  • pdf_lo_id (int) – LO PDF first member/set id.

  • pdf_nlo_id (int) – NLO PDF first member/set id.

  • mu (double) – central scale factor.

  • mu_f (double) – Factorization scale factor.

  • mu_r (double) – Renormalization scale factor.

  • precision (double) – Desired numerical relative precision.

  • max_iters (int) – Upper limit on integration iterations.

  • invariant_mass (str) – Invariant mass mode ‘auto = sqrt((p1+p2)^2)’ else value.

  • pt (str) – Transverse Momentum mode ‘auto’ or value.

  • result (str) – Result type ‘total’/’pt’/’ptj’/’m’.

  • id (str) – Set an id of this run.

  • model (str) – Path for MadGraph model.

  • update (bool) – Update dependent mu else set to zero.

has_gluino(self) → bool
has_neutralino(self) → bool
has_charginos(self) → bool
has_weakino(self) → bool
has_squark(self) → bool
has_slepton(self) → bool
hepi.is_gluino(iid: int) → bool[source]
hepi.is_neutralino(iid: int) → bool[source]
hepi.is_chargino(iid: int) → bool[source]
hepi.is_weakino(iid: int) → bool[source]
hepi.is_squark(iid: int) → bool[source]
hepi.is_slepton(iid: int) → bool[source]
hepi.update_slha(i: Input)[source]

Updates dependent parameters in Input i.

Mainly concerns the mu value used by madgraph.

hepi.scan(l: List[Input], var: str, rrange: Iterable) → List[Input][source]

Scans a variable var over rrange in l.

Note

This function does not ensure that dependent vairables are updated (see energyhalf in Examples).

Parameters

  • l (list of Input) – Input parameters that get scanned each.

  • var (str) – Scan variable name.

  • rrange (Iterable) – Range of var to be scanned.

Returns

Modified list with scan runs added.

Return type

list of Input

Examples

>>> li = [Input(Order.LO, 13000,  1000022,1000022, "None", "CT14lo","CT14lo",update=False)]
>>> li = scan(li,"energy",range(10000,13000,1000))
>>> for e in li:
...     print(e)
{'order': <Order.LO: 0>, 'energy': 10000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 11000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 12000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
>>> for e in scan(li,"order",[Order.LO,Order.NLO,Order.NLO_PLUS_NLL]):
...     print(e)
{'order': <Order.LO: 0>, 'energy': 10000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 10000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO_PLUS_NLL: 2>, 'energy': 10000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 11000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 11000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO_PLUS_NLL: 2>, 'energy': 11000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 12000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 12000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO_PLUS_NLL: 2>, 'energy': 12000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
hepi.scan_multi(li: List[Input], **kwargs) → List[Input][source]

Magically scans the variables passed to this function.

Parameters

**kwargs –

Examples

>>> oli = [Input(Order.LO, 13000,  1000022,1000022, "None", "CT14lo","CT14lo",update=False)]
>>> li = scan_multi(oli,energy=range(10000,13000,1000))
>>> for e in li:
...     print(e)
{'order': <Order.LO: 0>, 'energy': 10000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 11000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 12000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
>>> for e in scan_multi(oli,energy=range(10000,13000,1000),order=[Order.LO,Order.NLO,Order.NLO_PLUS_NLL]):
...     print(e)
{'order': <Order.LO: 0>, 'energy': 10000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 10000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO_PLUS_NLL: 2>, 'energy': 10000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 11000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 11000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO_PLUS_NLL: 2>, 'energy': 11000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 12000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 12000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO_PLUS_NLL: 2>, 'energy': 12000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
hepi.multi_scan[source]
hepi.scan_scale(l: List[Input], rrange=3, distance=2.0)[source]

Scans scale by varying mu_f and mu_r.

They take rrange values from 1/distance to distance in lograthmic spacing. Only points with mu_f`=`mu_r or mu_r/f`=1 or `mu_r/f`=`distance or mu_r/f`=1/`distance are returned.

Examples

>>> li = [Input(Order.LO, 13000,  1000022,1000022, "None", "CT14lo","CT14lo",update=False)]
>>> for e in scan_scale(li):
...     print(e)
{'order': <Order.LO: 0>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 0.5, 'mu_r': 0.5, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 0.5, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 0.5, 'mu_r': 2.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 0.5, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 2.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 2.0, 'mu_r': 0.5, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 2.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 2.0, 'mu_r': 2.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
hepi.scale_scan[source]
hepi.scan_seven_point(l: List[Input])[source]

Scans scale by varying mu_f and mu_r by factors of two excluding relative factors of 4.

Examples

>>> li = [Input(Order.LO, 13000,  1000022,1000022, "None", "CT14lo","CT14lo",update=False)]
>>> for e in scan_seven_point(li):
...     print(e)
{'order': <Order.LO: 0>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 0.5, 'mu_r': 0.5, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 0.5, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 0.5, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 2.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 2.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 2.0, 'mu_r': 2.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
hepi.seven_point_scan[source]
hepi.change_where(l: List[Input], dicts: dict, **kwargs)[source]

Applies the values of dicts if the key value pairs in kwargs agree with a member of the list l.

The changes only applied to the matching list members.

Examples

>>> li = scan_multi([Input(Order.LO, 13000,  1000022,1000022, "None", "CT14lo","CT14lo",update=False)],energy=range(10000,13000,1000))
>>> for e in change_where(li,{'order':Order.NLO},energy=11000):
...     print(e)
{'order': <Order.LO: 0>, 'energy': 10000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 11000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 12000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
>>> li = scan_multi([Input(Order.LO, 13000,  1000022,1000022, "None", "CT14lo","CT14lo",update=False)],energy=range(10000,12000,1000),mu_f=range(1,3))
>>> for e in change_where(li,{'order':Order.NLO},energy=11000,mu_f=1):
...     print(e)
{'order': <Order.LO: 0>, 'energy': 10000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 10000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 2, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 11000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 1, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.LO: 0>, 'energy': 11000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14lo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13200, 'mu_f': 2, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
hepi.scan_invariant_mass(l: List[Input], diff, points, low=0.001)[source]

Logarithmic invariant_mass scan close to the production threshold.

hepi.slha_write(newname, d)[source]
hepi.masses_scan(l: List[Input], vars: List[int], rrange, diff_L_R=None, negate=[]) → List[Input][source]

Scans the PDG identified mass var over rrange in the list l. diff_L_R allows to set a fixed difference between masses of left- and right-handed particles.

hepi.mass_scan(l: List[Input], var: int, rrange, diff_L_R=None) → List[Input][source]

Scans the PDG identified mass var over rrange in the list l. diff_L_R allows to set a fixed difference between masses of left- and right-handed particles.

hepi.slha_scan(l: List[Input], block, var, rrange: List) → List[Input][source]

Scan a generic

hepi.slha_scan_rel(l: List[Input], lambdas, rrange: List) → List[Input][source]

Scan a generic slha variable.

hepi.scan_pdf(l: List[Input])[source]

Scans NLO PDF sets.

The PDF sets are infered from lhapdf.getPDFSet with the argument of pdfset_nlo.

Examples

>>> li = [Input(Order.NLO, 13000,  1000022,1000022, "None", "CT14lo","CT14nlo",update=False)]
>>> for e in scan_pdf(li):
...     print(e)
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 0, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 1, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 2, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 3, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 4, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 5, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 6, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 7, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 8, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 9, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 10, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 11, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 12, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 13, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 14, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 15, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 16, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 17, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 18, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 19, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 20, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 21, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 22, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 23, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 24, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 25, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 26, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 27, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 28, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 29, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 30, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 31, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 32, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 33, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 34, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 35, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 36, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 37, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 38, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 39, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 40, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 41, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 42, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 43, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 44, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 45, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 46, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 47, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 48, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 49, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 50, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 51, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 52, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 53, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 54, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 55, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
{'order': <Order.NLO: 1>, 'energy': 13000, 'energyhalf': 6500.0, 'particle1': 1000022, 'particle2': 1000022, 'slha': 'None', 'pdf_lo': 'CT14lo', 'pdfset_lo': 0, 'pdf_nlo': 'CT14nlo', 'pdfset_nlo': 56, 'pdf_lo_id': 13200, 'pdf_nlo_id': 13100, 'mu_f': 1.0, 'mu_r': 1.0, 'precision': 0.01, 'max_iters': 50, 'invariant_mass': 'auto', 'pt': 'auto', 'result': 'total', 'id': '', 'model': '', 'mu': 0.0}
hepi.pdf_scan[source]
class hepi.DictData
__str__(self)

Returns attributes as dict as string

hepi.required_numerical_uncertainty_factor = 10[source]

If the numerical uncertainty is required_numerical_uncertainty_factor times higher than the scale or pdf uncertainty a warning is shown.

class hepi.Result(lo=None, nlo=None, nlo_plus_nll=None, annlo_plus_nnll=None)[source]

Bases: hepi.util.DictData

General result class.

Variables

  • LO (double) – Leading Order result. Defaults to None.

  • NLO (double) – Next-to-Leading Order result. Defaults to None.

  • NLO_PLUS_NLL (double) – Next-to-Leading Order plus Next-to-Leading Logarithm result. Defaults to None.

  • K_LO (double) – LO divided by LO.

  • K_NLO (double) – NLO divided by LO result.

  • K_NLO_PLUS_NLL (double) – NLO+NLL divided by LO.

  • K_aNNLO_PLUS_NNLL (double) – aNNLO+NNLL divided by LO.

  • NLO_PLUS_NLL_OVER_NLO (double) – NLO+NLL divided by NLO.

  • aNNLO_PLUS_NNLL_OVER_NLO (double) – aNNLO+NNLL divided by NLO.

Sets given and computes dependent Attributes.

Parameters

  • lo (double) – corresponds to LO.

  • nlo (double) – corresponds to NLO.

  • nlo_plus_nll (double) – corresponds to NLO_PLUS_NLL.

  • annlo_plus_nnll (double) – corresponds to aNNLO_PLUS_NNLL.

hepi.pdf_error(li, dl, confidence_level=90)[source]

Computes Parton Density Function (PDF) uncertainties through lhapdf.set.uncertainty().

Parameters

  • li (list of Input) – Input list.

  • dl (dict) – Result dictionary with lists per entry.

  • confidence_level (double) – Confidence Level for PDF uncertainty

Returns

Modified dl with new LO/NLO/NLO_PLUS_NLL _ PDF/PDF_CENTRAL/PDF_ERRPLUS/PDF_ERRMINUS/PDF_ERRSYM entries.

  • LO/NLO/NLO_PLUS_NLL _ PDF contains a symmetrized uncertainties object.

Return type

dict

hepi.scale_error(li, dl)[source]

Computes seven-point scale uncertainties from the results where the renormalization and factorization scales are varied by factors of 2 and relative factors of four are excluded (cf. seven_point_scan()).

Parameters

  • li (list of Input) – Input list.

  • dl (dict) – Result dictionary with lists per entry.

Returns

Modified dl with new LO/NLO/NLO_PLUS_NLL _ SCALE/SCALE_ERRPLUS/SCALE_ERRMINUS/SCALE_ERRSYM entries.

  • LO/NLO/NLO_PLUS_NLL _ SCALE contains a symmetrized uncertainties object.

Return type

dict

hepi.combine_errors(dl: dict)[source]

Combines seven-point scale uncertainties and pdf uncertainties from the results by Pythagorean addition.

Note

Running scale_errors() and pdf_errors() before is necessary.

Parameters

dl (dict) – Result dictionary with lists per entry.

Returns

Modified dl with new LO/NLO/NLO_PLUS_NLL _ COMBINED/ERRPLUS/ERRMINUS entries.

  • LO/NLO/NLO_PLUS_NLL _ COMBINED contains a symmetrized uncertainties object.

Return type

dict

class hepi.DictData
__str__(self)

Returns attributes as dict as string

hepi.LD2DL(l: List, actual_dict=False) → dict[source]

Convert a list of objects into a dictionary of lists.

The values of each object are first converted to a dict through the __dict__ attribute.

Parameters

  • l (List) – list of objects.

  • actual_dict (bool) – objects are already dicts

Returns

dictionary of numpy arrays.

Return type

dict

Examples

>>> class Param:
...      def __init__(self,a,b,c):
...         self.a = a
...         self.b = b
...         self.c = c
>>> LD2DL([ Param(1,2,3), Param(4,5,6) , Param(7,8,9) ])
{'a': array([1, 4, 7]), 'b': array([2, 5, 8]), 'c': array([3, 6, 9])}
hepi.LD2DF(ld: dict) → pandas.DataFrame

Convert a dict of list`s to a `pandas.DataFrame.

hepi.get_name(pid: int) → str

Get the latex name of a particle.

Parameters

pid (int) – PDG Monte Carlo identifier for the particle.

Returns

Latex name.

Return type

str

Examples

>>> get_name(21)
'g'
>>> get_name(1000022)
'\\tilde{\\chi}_{1}^{0}'
hepi.get_LR_partner(pid: int) → Tuple[int, int]

Transforms a PDG id to it’s left-right partner.

Parameters

pid (int) – PDG Monte Carlo identifier for the particle.

Returns

First int is -1 for Left and 1 for Right. Second int is the PDG id.

Return type

tuple

Examples

>>> get_LR_partner(1000002)
(-1, 2000002)
hepi.namehash(n: any) → str[source]

Creates a sha256 hash from the objects string representation.

Parameters

n (any) – object.

Returns

sha256 of object.

Return type

str

Examples

>>> p = {'a':1,'b':2}
>>> str(p)
"{'a': 1, 'b': 2}"
>>> namehash(str(p))
'3dffaea891e5dbadb390da33bad65f509dd667779330e2720df8165a253462b8'
>>> namehash(p)
'3dffaea891e5dbadb390da33bad65f509dd667779330e2720df8165a253462b8'
hepi.lhapdf_name_to_id(name: str) → int

Converts a LHAPDF name to the sets id.

Parameters

name (str) – LHAPDF set name.

Returns

id of the LHAPDF set.

Return type

int

Examples

>>> lhapdf_name_to_id("CT14lo")
13200
class hepi.Input(order: Order, energy: float, particle1: int, particle2: int, slha: str, pdf_lo: str, pdf_nlo: str, mu_f=1.0, mu_r=1.0, pdfset_lo=0, pdfset_nlo=0, precision=0.01, max_iters=50, invariant_mass='auto', result='total', pt='auto', id='', model='', update=True)[source]

Bases: hepi.util.DictData

Input for computation and scans.

Variables

  • order (Order) – LO, NLO or NLO+NLL computation.

  • energy (int) – CMS energy in GeV.

  • energyhalf (int) – Halfed energy.

  • particle1 (int) – PDG identifier of the first final state particle.

  • particle2 (int) – PDG identifier of the second final state particle.

  • slha (str) – File path of for the base slha. Modified slha files will be used if a scan requires a change of the input.

  • pdf_lo (str) – LO PDF name.

  • pdf_nlo (str) – NLO PDF name.

  • pdfset_lo (int) – LO PDF member/set id.

  • pdfset_nlo (int) – NLO PDF member/set id.

  • pdf_lo_id (int) – LO PDF first member/set id.

  • pdf_nlo_id (int) – NLO PDF first member/set id.

  • mu (double) – central scale factor.

  • mu_f (double) – Factorization scale factor.

  • mu_r (double) – Renormalization scale factor.

  • precision (double) – Desired numerical relative precision.

  • max_iters (int) – Upper limit on integration iterations.

  • invariant_mass (str) – Invariant mass mode ‘auto = sqrt((p1+p2)^2)’ else value.

  • pt (str) – Transverse Momentum mode ‘auto’ or value.

  • result (str) – Result type ‘total’/’pt’/’ptj’/’m’.

  • id (str) – Set an id of this run.

  • model (str) – Path for MadGraph model.

  • update (bool) – Update dependent mu else set to zero.

has_gluino(self) → bool
has_neutralino(self) → bool
has_charginos(self) → bool
has_weakino(self) → bool
has_squark(self) → bool
has_slepton(self) → bool
hepi.get_output_dir()[source]

Get the input directory.

Returns

out_dir

Return type

str

hepi.replace_macros(s: str) → str[source]
hepi.get_name(pid: int) → str

Get the latex name of a particle.

Parameters

pid (int) – PDG Monte Carlo identifier for the particle.

Returns

Latex name.

Return type

str

Examples

>>> get_name(21)
'g'
>>> get_name(1000022)
'\\tilde{\\chi}_{1}^{0}'
hepi.title(axe, i: hepi.input.Input, scenario='', diff_L_R=None, extra='', cms_energy=True, pdf_info=True, **kwargs)[source]

Sets the title on axis axe.

hepi.energy_plot(dict_list, y, yscale=1.0, xaxis='E [GeV]', yaxis='$\\sigma$ [pb]', label=None, **kwargs)[source]

Plot energy on the x-axis.

hepi.mass_plot(dict_list, y, part, logy=True, yaxis='$\\sigma$ [pb]', yscale=1.0, label=None, **kwargs)[source]
hepi.mass_vplot(dict_list, y, part, logy=True, yaxis='$\\sigma$ [pb]', yscale=1.0, label=None, mask=None, **kwargs)[source]
hepi.get_mass(l: dict, iid: int)[source]

Get the mass of particle with id iid out of the list in the “slha” element in the dict.

Returns

list of float : masses of particles in each element of the dict list.

hepi.plot(dict_list, x, y, label=None, xaxis='E [GeV]', yaxis='$\\sigma$ [pb]', ratio=False, K=False, K_plus_1=False, logy=True, yscale=1.0, mask=None, **kwargs) → None

Creates a plot based on the entries x`and `y in dict_list.

Examples

>>> import urllib.request
>>> import hepi
>>> dl = hepi.load(urllib.request.urlopen(
... "https://raw.githubusercontent.com/fuenfundachtzig/xsec/master/json/pp13_hino_NLO%2BNLL.json"
... ))
>>> hepi.plot(dl,"N1","NLO_PLUS_NLL",xaxis="$m_{\\tilde{\\chi}_1^0}$")

(Source code, png, hires.png, pdf)

../../_images/index-1.png
hepi.index_open(var, idx)[source]
hepi.slha_data(li, index_list)[source]
hepi.slha_plot(li, x, y, **kwargs)[source]
hepi.vplot(x, y, label=None, xaxis='E [GeV]', yaxis='$\\sigma$ [pb]', logy=True, yscale=1.0, interpolate=True, plot_data=True, data_color=None, mask=- 1, fill=False, data_fmt='.', fmt='-', print_area=False, sort=True, **kwargs)[source]

Creates a plot based on the values in x`and `y.

hepi.mass_mapplot(dict_list, part1, part2, z, logz=True, zaxis='$\\sigma$ [pb]', zscale=1.0, label=None)[source]
hepi.mapplot(dict_list, x, y, z, xaxis=None, yaxis=None, zaxis=None, **kwargs)[source]

Examples

>>> import urllib.request
>>> import hepi
>>> dl = hepi.load(urllib.request.urlopen(
... "https://raw.githubusercontent.com/fuenfundachtzig/xsec/master/json/pp13_hinosplit_N2N1_NLO%2BNLL.json"
... ),dimensions=2)
>>> hepi.mapplot(dl,"N1","N2","NLO_PLUS_NLL",xaxis="$m_{\\tilde{\\chi}_1^0}$",yaxis="$m_{\\tilde{\\chi}_2^0}$" , zaxis="$\\sigma_{\\mathrm{NLO+NLL}}$")

(Source code, png, hires.png, pdf)

../../_images/index-2.png
hepi.map_vplot(vx, vy, vz, xaxis=None, yaxis=None, zaxis=None, logz=True, sort=True, fill_missing=True, zscale=1.0)[source]
hepi.fig[source]
hepi.axs[source]
hepi.lines = [][source]
hepi.labels = [][source]
hepi.err_plt(axes, x, y, label=None, error=False)[source]
hepi.scale_plot(dict_list, vl, seven_point_band=False, cont=False, error=True, li=None, plehn_color=False, yscale=1.0, unit='pb', yaxis=None, **kwargs)[source]

Creates a scale variance plot with 5 panels (xline).

hepi.central_scale_plot(dict_list, vl, cont=False, error=True, yscale=1.0, unit='pb', yaxis=None)[source]

Creates a scale variance plot with 3 panels (ystacked).

hepi.init_double_plot(figsize=(6, 8), sharex=True, sharey=False, gridspec_kw={'height_ratios': [3, 1]})[source]

Initialze subplot for Ratio/K plots with another figure below.

class hepi.Input(order: Order, energy: float, particle1: int, particle2: int, slha: str, pdf_lo: str, pdf_nlo: str, mu_f=1.0, mu_r=1.0, pdfset_lo=0, pdfset_nlo=0, precision=0.01, max_iters=50, invariant_mass='auto', result='total', pt='auto', id='', model='', update=True)[source]

Bases: hepi.util.DictData

Input for computation and scans.

Variables

  • order (Order) – LO, NLO or NLO+NLL computation.

  • energy (int) – CMS energy in GeV.

  • energyhalf (int) – Halfed energy.

  • particle1 (int) – PDG identifier of the first final state particle.

  • particle2 (int) – PDG identifier of the second final state particle.

  • slha (str) – File path of for the base slha. Modified slha files will be used if a scan requires a change of the input.

  • pdf_lo (str) – LO PDF name.

  • pdf_nlo (str) – NLO PDF name.

  • pdfset_lo (int) – LO PDF member/set id.

  • pdfset_nlo (int) – NLO PDF member/set id.

  • pdf_lo_id (int) – LO PDF first member/set id.

  • pdf_nlo_id (int) – NLO PDF first member/set id.

  • mu (double) – central scale factor.

  • mu_f (double) – Factorization scale factor.

  • mu_r (double) – Renormalization scale factor.

  • precision (double) – Desired numerical relative precision.

  • max_iters (int) – Upper limit on integration iterations.

  • invariant_mass (str) – Invariant mass mode ‘auto = sqrt((p1+p2)^2)’ else value.

  • pt (str) – Transverse Momentum mode ‘auto’ or value.

  • result (str) – Result type ‘total’/’pt’/’ptj’/’m’.

  • id (str) – Set an id of this run.

  • model (str) – Path for MadGraph model.

  • update (bool) – Update dependent mu else set to zero.

has_gluino(self) → bool
has_neutralino(self) → bool
has_charginos(self) → bool
has_weakino(self) → bool
has_squark(self) → bool
has_slepton(self) → bool
class hepi.Order

Bases: enum.IntEnum

Computation orders.

Initialize self. See help(type(self)) for accurate signature.

LO = 0

Leading Order

NLO = 1

Next-to-Leading Order

NLO_PLUS_NLL = 2

Next-to-Leading Order plus Next-to-Leading Logarithms

aNNLO_PLUS_NNLL = 3

Approximate Next-to-next-to-Leading Order plus Next-to-next-to-Leading Logarithms

hepi.get_input_dir()[source]

Get the input directory.

Returns

in_dir

Return type

str

hepi.get_output_dir()[source]

Get the input directory.

Returns

out_dir

Return type

str

hepi.get_pre()[source]

Gets the command prefix.

Returns

pre

Return type

str

class hepi.Result(lo=None, nlo=None, nlo_plus_nll=None, annlo_plus_nnll=None)[source]

Bases: hepi.util.DictData

General result class.

Variables

  • LO (double) – Leading Order result. Defaults to None.

  • NLO (double) – Next-to-Leading Order result. Defaults to None.

  • NLO_PLUS_NLL (double) – Next-to-Leading Order plus Next-to-Leading Logarithm result. Defaults to None.

  • K_LO (double) – LO divided by LO.

  • K_NLO (double) – NLO divided by LO result.

  • K_NLO_PLUS_NLL (double) – NLO+NLL divided by LO.

  • K_aNNLO_PLUS_NNLL (double) – aNNLO+NNLL divided by LO.

  • NLO_PLUS_NLL_OVER_NLO (double) – NLO+NLL divided by NLO.

  • aNNLO_PLUS_NNLL_OVER_NLO (double) – aNNLO+NNLL divided by NLO.

Sets given and computes dependent Attributes.

Parameters

  • lo (double) – corresponds to LO.

  • nlo (double) – corresponds to NLO.

  • nlo_plus_nll (double) – corresponds to NLO_PLUS_NLL.

  • annlo_plus_nnll (double) – corresponds to aNNLO_PLUS_NNLL.

hepi.LD2DL(l: List, actual_dict=False) → dict[source]

Convert a list of objects into a dictionary of lists.

The values of each object are first converted to a dict through the __dict__ attribute.

Parameters

  • l (List) – list of objects.

  • actual_dict (bool) – objects are already dicts

Returns

dictionary of numpy arrays.

Return type

dict

Examples

>>> class Param:
...      def __init__(self,a,b,c):
...         self.a = a
...         self.b = b
...         self.c = c
>>> LD2DL([ Param(1,2,3), Param(4,5,6) , Param(7,8,9) ])
{'a': array([1, 4, 7]), 'b': array([2, 5, 8]), 'c': array([3, 6, 9])}
class hepi.DictData
__str__(self)

Returns attributes as dict as string

hepi.namehash(n: any) → str[source]

Creates a sha256 hash from the objects string representation.

Parameters

n (any) – object.

Returns

sha256 of object.

Return type

str

Examples

>>> p = {'a':1,'b':2}
>>> str(p)
"{'a': 1, 'b': 2}"
>>> namehash(str(p))
'3dffaea891e5dbadb390da33bad65f509dd667779330e2720df8165a253462b8'
>>> namehash(p)
'3dffaea891e5dbadb390da33bad65f509dd667779330e2720df8165a253462b8'
class hepi.RunParam(skip: bool = False, in_file: str = None, out_file: str = None, execute: str = None, name: str = None)[source]

Bases: hepi.util.DictData

Abstract class that is similar to a dictionary but with fixed keys.

class hepi.Runner(path: str, in_dir: str = None, out_dir: str = None, pre=None)[source]
orders(self) → List[hepi.input.Order]

List of supported Orders in this runner.

get_name(self) → str

Returns the name of the runner.

_check_path(self) → bool

Checks if the passed path is valid.

_prepare(self, p: hepi.input.Input, **kwargs) → RunParam
_check_input(self, param: hepi.input.Input, **kwargs) → bool
_prepare_all(self, params: List[hepi.input.Input], skip=True, **kwargs) → List[RunParam]
run(self, params: List[hepi.input.Input], skip=True, parse=True, parallel=True, sleep=0, run=True, **kwargs)

Run the passed list of parameters.

Args:

params (list of hepi.Input): All parameters that should be executed/queued. skip (bool): True means stored runs will be skipped. Else the are overwritten. parse (bool): Parse the results.

This is not the prefered cluster/parallel mode, as there the function only queues the job.

parallel (bool): Run jobs in parallel. sleep (int): Sleep seconds after starting job.

run (bool): Actually start/queue runner.

Returns:
dictcombined dictionary of results and parameters. Each member therein is a list.

The dictionary is empty if parse is set to False.

_run(self, rps: List[RunParam], wait=True, parallel=True, sleep=0, **kwargs)

Runs Runner per RunParams.

Parameters

  • rps (list of RunParams) – Extended run parameters.

  • bar (bool) – Enable info bar.

  • wait (bool) – Wait for parallel runs to finish.

  • sleep (int) – Sleep seconds after starting subprocess.

  • parallel (bool) – Run jobs in parallel.

Returns

return codes from jobs if no_parse is False.

Return type

list of int

_is_valid(self, file: str, p: hepi.input.Input, d) → bool

Verifies that a file is a complete output.

Parameters

  • file (str) – File path to be parsed.

  • p (hepi.Input) – Onput parameters.

  • d (dict) – Param dictionary.

Returns

True if file could be parsed.

Return type

bool

parse(self, outputs: List[str]) → List[hepi.results.Result]

Parses Resummino output files and returns List of Results.

Parameters

outputs (list of str) – List of the filenames to be parsed.

Returns

list of hepi.resummino.result.ResumminoResult

_parse_file(self, file: str) → hepi.results.Result

Extracts results from an output file.

Parameters

file (str) – File path to be parsed.

Returns

If a value is not found in the file None is used.

Return type

Result

get_path(self) → str

Get the Runner path.

Returns

current Runner path.

Return type

str

get_input_dir(self) → str

Get the input directory.

Returns

in_dir

Return type

str

get_output_dir(self) → str

Get the input directory.

Returns

out_dir

Return type

str

get_pre(self) → str

Gets the command prefix.

Returns

pre

Return type

str

set_path(self, p: str)

Set the path to the Runner folder containing the binary in ‘./bin’ or ‘./build/bin’.

Parameters

p (str) – new path.

set_input_dir(self, indir: str)

Sets the input directory.

Parameters

indir (str) – new input directory.

set_output_dir(self, outdir: str, create: bool = True)

Sets the output directory.

Parameters

outdir (str) – new output directory. create (bool): create directory if not existing.

set_pre(self, ppre: str)

Sets the command prefix.

Parameters

ppre (str) – new command prefix.

class hepi.Input(order: Order, energy: float, particle1: int, particle2: int, slha: str, pdf_lo: str, pdf_nlo: str, mu_f=1.0, mu_r=1.0, pdfset_lo=0, pdfset_nlo=0, precision=0.01, max_iters=50, invariant_mass='auto', result='total', pt='auto', id='', model='', update=True)[source]

Bases: hepi.util.DictData

Input for computation and scans.

Variables

  • order (Order) – LO, NLO or NLO+NLL computation.

  • energy (int) – CMS energy in GeV.

  • energyhalf (int) – Halfed energy.

  • particle1 (int) – PDG identifier of the first final state particle.

  • particle2 (int) – PDG identifier of the second final state particle.

  • slha (str) – File path of for the base slha. Modified slha files will be used if a scan requires a change of the input.

  • pdf_lo (str) – LO PDF name.

  • pdf_nlo (str) – NLO PDF name.

  • pdfset_lo (int) – LO PDF member/set id.

  • pdfset_nlo (int) – NLO PDF member/set id.

  • pdf_lo_id (int) – LO PDF first member/set id.

  • pdf_nlo_id (int) – NLO PDF first member/set id.

  • mu (double) – central scale factor.

  • mu_f (double) – Factorization scale factor.

  • mu_r (double) – Renormalization scale factor.

  • precision (double) – Desired numerical relative precision.

  • max_iters (int) – Upper limit on integration iterations.

  • invariant_mass (str) – Invariant mass mode ‘auto = sqrt((p1+p2)^2)’ else value.

  • pt (str) – Transverse Momentum mode ‘auto’ or value.

  • result (str) – Result type ‘total’/’pt’/’ptj’/’m’.

  • id (str) – Set an id of this run.

  • model (str) – Path for MadGraph model.

  • update (bool) – Update dependent mu else set to zero.

has_gluino(self) → bool
has_neutralino(self) → bool
has_charginos(self) → bool
has_weakino(self) → bool
has_squark(self) → bool
has_slepton(self) → bool
hepi.order_to_string(o: Order, json_style=False, no_macros=False) → str
hepi.xsec_to_order(s: str)[source]
hepi.LD2DL(l: List, actual_dict=False) → dict[source]

Convert a list of objects into a dictionary of lists.

The values of each object are first converted to a dict through the __dict__ attribute.

Parameters

  • l (List) – list of objects.

  • actual_dict (bool) – objects are already dicts

Returns

dictionary of numpy arrays.

Return type

dict

Examples

>>> class Param:
...      def __init__(self,a,b,c):
...         self.a = a
...         self.b = b
...         self.c = c
>>> LD2DL([ Param(1,2,3), Param(4,5,6) , Param(7,8,9) ])
{'a': array([1, 4, 7]), 'b': array([2, 5, 8]), 'c': array([3, 6, 9])}
hepi.load(f, dimensions=1)

Load xsec data from json in to something that works within hepi’s plotting.

Parameters

  • f – readable object, e.g. open(filepath:str).

  • dimensions (int) – 1 or 2 currently supported.

hepi.package = hepi[source]
hepi.version[source]
hepi.__version__[source]