pinefarm package

Produce theory predictions from external sources.

Subpackages

Submodules

pinefarm.configs module

Configuration tools.

pinefarm.configs.NAME = 'pinefarm.toml': Name of the config while (wherever it is placed).

pinefarm.configs.PATHS_SECTIONS = ('paths', 'commands'): Sections containing only paths.

pinefarm.configs.basic_paths(root: Path) → dict[source]

Build all default independent paths.

Independent on anything but root.

pinefarm.configs.commands(paths: dict) → dict[source]: Set all default commands.

pinefarm.configs.configs = {}: Holds loaded configurations.

pinefarm.configs.detect(path: PathLike | None = None) → Path[source]

Detect configuration files.

Parameters:: path (os.PathLike or None) – optional explicit path to file to be used as configs (default: None)
Returns:: configuration file path
Return type:: pathlib.Path
Raises:: FileNotFoundError – in case no valid configuration file is found

pinefarm.configs.force_paths()[source]: Convert values in chosen sections to paths.

pinefarm.configs.load(path: PathLike | None = None) → dict[source]

Load configuration file.

If no path is explicitly passed, a minimal configuration is used instead (just setting root folder to the current one).

Parameters:: path (os.PathLike or None) – the path to the configuration file (default: None)
Returns:: loaded configurations
Return type:: dict

pinefarm.configs.nestupdate(base: dict, update: dict)[source]

Merge nested dictionaries.

Pay attention, base will be mutated in place. So the second one will overwrite the first.

Note

Modifying in place avoids a lot of copies. But not being performance intensive, it would be possible to obtain a non in-place alternative just adding a first line:

base = copy.deepcopy(base)

but it would be called at every recursion (the lots of copies above). A simpler alternative is just to copy before calling, if needed:

mycopy = copy.deepcopy(mydict)
nestupdate(mycopy, update)

that will make a single copy.

Note

Another option could appear to be using something like collections.ChainMap. This is a smart way to implement cascade configurations, but it is not going to support nesting:

configs = ChainMap({'a': {'b': 0}}, {'a': {'c': 1}})

in this case, even if there is no clash for configs['a']['c'], this would result in a KeyError (since once configs['a'] is executed, the result is just a normal dict, and the first one encountered). Any refinement would involve a custom __geitem__(), with even more complicate logic.

Parameters:

base (dict) – dictionary to be updated
update (dict) – dictionary containing update

pinefarm.configs.paths(paths: dict) → dict[source]: Build all default dependent paths.

pinefarm.configs.raw(original: dict) → dict[source]

Convert configs (or dict) into serializable equivalent.

Parameters:: original (dict) – original dictionary to convert
Returns:: converted dictionary
Return type:: dict

pinefarm.info module

Provide inspection tools.

class pinefarm.info.Info(color: str, external: Type[External])[source]

Bases: object

Info type.

color: str

external: Type[External]

property kind: Type of process as defined by the external interface.

pinefarm.info.label(dataset: str) → Info[source]: Generate associated Info type.

pinefarm.install module

Install tools.

pinefarm.install.LHAPDF_VERSION = 'LHAPDF-6.5.4': Version of LHAPDF to be used by default (if not already available).

pinefarm.install.PINEAPPL_REPO = 'https://github.com/N3PDF/pineappl.git': Git repo location for pineappl.

pinefarm.install.cargo()[source]

Initialize Rust and Cargo.

Returns:: path to cargo
Return type:: str

pinefarm.install.hawaiian_vrap()[source]

Install a version of vrap flavoured with pineappl from https://github.com/NNPDF/hawaiian_vrap.

Returns:: whether vrap is now installed
Return type:: bool

pinefarm.install.init_prefix()[source]: Set up paths.

pinefarm.install.is_exe(command: PathLike) → bool[source]: Check if given path exists and is executable.

pinefarm.install.lhapdf()[source]

Install LHAPDF C++ library.

This is currently needed by every tool due to postprocessing requirements.

pinefarm.install.lhapdf_conf(pdf)[source]

Initialize LHAPDF.

Parameters:: pdf (str) – LHAPDF name of the required PDF

pinefarm.install.mg5amc()[source]

Initialize MadGraph5_aMC@NLO.

Returns:: whether the main executable is now existing.
Return type:: bool

pinefarm.install.nnlojet()[source]: Installation of NNLOJET.

pinefarm.install.pineappl(capi=True, cli=False)[source]

Initialize PineAPPL.

Parameters:

capi (bool) – whether to install PineAPPl CAPI (by default True, since it’s the only thing required)
cli (bool) – whether to install even PineAPPL CLI (by default False, since it’s not required to run)

Returns:

whether pineappl and pineappl_capi are now available.

Return type:

bool

pinefarm.install.update_environ()[source]: Adjust necessary environment files.

pinefarm.install.update_lhapdf_path(path)[source]

Update LHAPDF path, both in environment and lhapdf_management.

Parameters:: path (str or pathlib.Path) – path to LHAPDF data

pinefarm.log module

Logging tools.

class pinefarm.log.ChildStream(parent)[source]

Bases: object

Inner stream.

write(data)[source]: Write to stream.

class pinefarm.log.Tee(name, stdout=True, stderr=False)[source]

Bases: object

Context manager to tee stdout to file.

Parameters:: name (str or pathlib.Path) – path to redirect stdout to

flush()[source]: Flush stream.

write(data, stream)[source]: Write to stream.

exception pinefarm.log.WhileRedirectedError(*args, file, **kwargs)[source]

Bases: RuntimeError

Error to signal a generic error, while stderr was redirected to file.

Parameters:

*args – arguments passed to RuntimeError
file (str) – path to file to which stderr is redirected
**kwargs – keyword arguments passed to RuntimeError

pinefarm.log.subprocess(*args, cwd, out)[source]

Wrap subprocess.Popen to print the output to screen and capture it.

Parameters:

args – positional arguments to pass to subprocess.Popen
cwd (path-like or str) – directory where to execute the command
out (path-like or str) – file to which (also) redirect the output

Returns:

output of the command run in the subprocess

Return type:

str

pinefarm.table module

Comparison tools.

pinefarm.table.convolute_grid(grid, pdf_name, integrated=False)[source]

Call convolute via PineAPPL CLI.

Parameters:

grid (str) – grid path
pdf_name (str) – PDF name
integrated (bool) – whether the bins have to be integrated with bins normalizations

Returns:

(essential) output splitted by line

Return type:

list(str)

pinefarm.table.print_table(pineappl_results, external_results, dest)[source]

Print comparison table to screen.

Parameters:

pineappl_results (pandas.DataFrame) – results from the generated grid
external_results (pandas.DataFrame) – results from the external program
dest (pathlib.Path) – path to output file

pinefarm.tools module

Auxilariy tools.

pinefarm.tools.common_substring(s1, s2, *sn)[source]

Return the longest common part of two iterables, starting from the begininng.

Parameters:

s1 (Sequence) – first sequence to compare
s2 (Sequence) – second sequence to compare
*sn (Sequence) – any further sequence to compare

Returns:

longest common subsequence

Return type:

Sequence

Examples

>>> common_substring("test test", "test toast")
"test t"
>>> common_substring("test test", "test test test")
"test test"
>>> common_substring("test test", "")
""
>>> common_substring("test test", "test test test", "test")
"test"
>>> common_substring("test test", "test test test", "test toast")
"test t"

pinefarm.tools.compress(path)[source]

Compress a file into lz4.

Parameters:: path (pathlib.Path) – input path
Returns:: path to compressed file
Return type:: pathlib.Path

pinefarm.tools.create_output_folder(name, theoryid)[source]

Create output folder.

Parameters:: name (str) – dataset name
Returns:: path to output folder
Return type:: pathlib.Path

pinefarm.tools.decompress(path)[source]

Decompress a file from lz4.

Parameters:: path (pathlib.Path) – path to compressed file
Returns:: path to raw file
Return type:: pathlib.Path

pinefarm.tools.git_pull(repo, remote_name='origin', branch='master')[source]

Pull a remote repository.

Parameters:

repo (pygit2.Repository) – repository
remote_name (str) – remote name
branch (str) – branch to get

pinefarm.tools.nine_points = [(0.5, 0.5, 1.0), (0.5, 1.0, 1.0), (0.5, 2.0, 1.0), (1.0, 0.5, 1.0), (1.0, 1.0, 1.0), (1.0, 2.0, 1.0), (2.0, 0.5, 1.0), (2.0, 1.0, 1.0), (2.0, 2.0, 1.0)]: Nine points prescription for scale variations (as couples, referred to (fact, ren, frag=1.0) scales).

pinefarm.tools.parse_metadata(file)[source]

Parse metadata file.

Parameters:: file (io.TextIOBase) – the file to read
Returns:: the metadata entries
Return type:: dict

pinefarm.tools.patch(patch, base_dir='.')[source]

Apply patch.

Parameters:

patch (str) – patch to apply (text content, not path)
base_dir (str or pathlib.Path) – path to dir where to apply patch (default: .)

pinefarm.tools.print_time(t0, what=None)[source]

Report completion together with timing to the user.

Parameters:

t0 (int) – start time
what (str) – subject that is completed

pinefarm.tools.set_grid_metadata(grid, entries=None, entries_from_file=None)[source]

Set metadata on a pineappl grid (in-place operation).

Parameters:

input_grid (pineappl.grid.Grid) – input grid on which to set metadata
entries (dict) – mapping of key-value to store in the grid
entries_from_file (dict) – mapping of key-value pairs, whose value are file paths of which storing the content

pinefarm.tools.three_points = [0.5, 1.0, 2.0]: Three points prescription for scale variations.

pinefarm.tools.twentyseven_points = [(0.5, 0.5, 0.5), (0.5, 0.5, 1.0), (0.5, 0.5, 2.0), (0.5, 1.0, 0.5), (0.5, 1.0, 1.0), (0.5, 1.0, 2.0), (0.5, 2.0, 0.5), (0.5, 2.0, 1.0), (0.5, 2.0, 2.0), (1.0, 0.5, 0.5), (1.0, 0.5, 1.0), (1.0, 0.5, 2.0), (1.0, 1.0, 0.5), (1.0, 1.0, 1.0), (1.0, 1.0, 2.0), (1.0, 2.0, 0.5), (1.0, 2.0, 1.0), (1.0, 2.0, 2.0), (2.0, 0.5, 0.5), (2.0, 0.5, 1.0), (2.0, 0.5, 2.0), (2.0, 1.0, 0.5), (2.0, 1.0, 1.0), (2.0, 1.0, 2.0), (2.0, 2.0, 0.5), (2.0, 2.0, 1.0), (2.0, 2.0, 2.0)]: 27 points prescription for scale variations (as couples, referred to (fact, ren, frag) scales).

pinefarm.tools.update_grid_metadata(input_file, output_file, entries=None, entries_from_file=None)[source]

Set metadata on a pineappl grid stored in a file, and save in a new one.

Parameters:

input_file (path-like) – file storing input grid
output_file (path-like) – file to store the result
entries (dict) – mapping of key-value to store in the grid
entries_from_file (dict) – mapping of key-value pairs, whose value are file paths of which storing the content