`hepi.run`

Submodules

hepi.run.run

Package Contents

Classes

`Input`	Input for computation and scans.
`Order`	Computation orders.
`Result`	General result class. All uncertainties are of numerical origin.
`DictData`
`RunParam`	Abstract class that is similar to a dictionary but with fixed keys.
`Runner`

Functions

`get_input_dir`()	Get the input directory.
`get_output_dir`()	Get the output directory.
`get_pre`()	Gets the command prefix.
`DL2DF`(ld)	Convert a dict of list`s to a `pandas.DataFrame.
`LD2DL`(l[, actual_dict])	Convert a list of objects into a dictionary of lists.
`namehash`(n)	Creates a sha256 hash from the objects string representation.

class hepi.run.Input(order, energy, particle1, particle2, slha, pdf_lo, pdf_nlo, mu_f=1.0, mu_r=1.0, pdfset_lo=0, pdfset_nlo=0, precision=0.001, 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.

Parameters:

order (hepi.order.Order) –
energy (float) –
particle1 (int) –
particle2 (int) –
slha (str) –
pdf_lo (str) –
pdf_nlo (str) –

has_gluino()[source]

Return type:: bool

has_neutralino()[source]

Return type:: bool

has_charginos()[source]

Return type:: bool

has_weakino()[source]

Return type:: bool

has_squark()[source]

Return type:: bool

has_slepton()[source]

Return type:: bool

class hepi.run.Order[source]

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.run.get_input_dir()[source]

Get the input directory.

Returns:: in_dir
Return type:: str

hepi.run.get_output_dir()[source]

Get the output directory.

Returns:: out_dir
Return type:: str

hepi.run.get_pre()[source]

Gets the command prefix.

Returns:: pre
Return type:: str

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

Bases: hepi.util.DictData

General result class. All uncertainties are of numerical origin.

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.run.DL2DF(ld)[source]

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

Parameters:: ld (dict) –
Return type:: pandas.DataFrame

hepi.run.LD2DL(l, actual_dict=False)[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.run.DictData[source]

__str__()[source]: Returns attributes as dict as string

hepi.run.namehash(n)[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.run.RunParam(skip=False, in_file=None, out_file=None, execute=None, name=None)[source]

Bases: hepi.util.DictData

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

Parameters:

skip (bool) –
in_file (str) –
out_file (str) –
execute (str) –
name (str) –

class hepi.run.Runner(path, in_dir=None, out_dir=None, pre=None)[source]

Parameters:

path (str) –
in_dir (str) –
out_dir (str) –

orders()[source]

List of supported Orders in this runner.

Return type:: List[hepi.input.Order]

get_name()[source]

Returns the name of the runner.

Return type:: str

get_version()[source]

Return type:: str

_sub_run(coms)[source]

Parameters:: coms (List[str]) –
Return type:: str

_check_path()[source]

Checks if the passed path is valid.

Return type:: bool

_prepare(p, skip=False, assume_valid=False, **kwargs)[source]

Parameters:: p (hepi.input.Input) –
Return type:: RunParam

_check_input(param, **kwargs)[source]

Parameters:: param (hepi.input.Input) –
Return type:: bool

_prepare_all(params, skip=True, n_jobs=None, **kwargs)[source]

Prepares all parameters for execution.

Parameters:

params (List[hepi.Input]) – List of input parameters.
skip (bool, optional) – If True, the runner will check if the output file already exists and skip the execution if it does. Defaults to True.
n_jobs (int) – Number of parallel jobs. If None, use all available cores.

Return type:

List[RunParam]

run(params, skip=True, parse=True, parallel=True, sleep=0, run=True, ignore_error=False, n_jobs=None, **kwargs)[source]

Run the passed list of parameters.

Parameters:

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.
ignore_error (bool) – Continue instead of raising Exceptions. Also ignores hash collisions.
n_jobs (int) – Number of parallel jobs. If None, use all available cores.

Returns:

combined dataframe of results and parameters. The dataframe is empty if parse is set to False.

Return type:

pd.DataFrame

_run(rps, wait=True, parallel=True, sleep=0, n_jobs=None, **kwargs)[source]

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.
n_jobs (int) – Number of parallel jobs. If None, use all available cores.

Returns:

return codes from jobs if no_parse is False.

Return type:

list of int

_is_valid(file, p, d, **kwargs)[source]

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(outputs, n_jobs=None)[source]

Parses Resummino output files and returns List of Results.

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

n_jobs (int): Number of parallel jobs. If None, use all available cores.

Returns:
list of hepi.resummino.result.ResumminoResult

Parameters:: outputs (List[str]) –
Return type:: List[hepi.results.Result]

_parse_file(file)[source]

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()[source]

Get the Runner path.

Returns:: current Runner path.
Return type:: str

get_input_dir()[source]

Get the input directory.

Returns:: in_dir
Return type:: str

get_output_dir()[source]

Get the input directory.

Returns:: out_dir
Return type:: str

get_pre()[source]

Gets the command prefix.

Returns:: pre
Return type:: str

set_path(p)[source]

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

Parameters:: p (str) – new path.

set_input_dir(indir)[source]

Sets the input directory.

Parameters:: indir (str) – new input directory.

set_output_dir(outdir, create=True)[source]

Sets the output directory.

Parameters:

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

set_pre(ppre)[source]

Sets the command prefix.

Parameters:: ppre (str) – new command prefix.

hepi.run

Subpackages

Submodules

Package Contents

Classes

Functions

`hepi.run`