pxd.background_generator Namespace Reference

basf2 (Belle II Analysis Software Framework) # Author: The Belle II Collaboration # # See git log for contributors and copyright holders. More...

Namespaces
namespace	models
	basf2 (Belle II Analysis Software Framework) # Author: The Belle II Collaboration # # See git log for contributors and copyright holders.

Classes
class	PXDBackgroundGenerator
	Class for the PXD background generator module. More...

Functions
str	_verify_model (str model)
	Function to verify that model:
str	_verify_checkpoint (Union[None, str, pathlib.Path] checkpoint)
	Function to verify that checkpoint:
Union[None, int]	_verify_seed (Union[None, int] seed)
	Function to verify that seed:
int	_verify_nintra (int nintra)
	Function to verify that nintra:
int	_verify_ninter (int ninter)
	Function to verify that ninter:
str	_verify_globaltag (str globaltag)
	Function to verify that globaltag:
Callable	inject_simulation (Union[None, basf2.Module] module=None)
	Helper function to incorporate a module instance into add_simulation after BGOverlayInput.

Variables
tuple	VXDID_ARGS
	Sequence of forty tuples (layer, ladder, sensor) used to instantiate VxdID specifier objects for distinct PXD modules.

Detailed Description

basf2 (Belle II Analysis Software Framework) # Author: The Belle II Collaboration # # See git log for contributors and copyright holders.

# This file is licensed under LGPL-3.0, see LICENSE.md. #

Generate PXD background samples for background overlay on the fly.

Function Documentation

_verify_checkpoint()

str _verify_checkpoint ( Union[None, str, pathlib.Path]  checkpoint )

protected

Function to verify that checkpoint:

• is either None, a string, or a pathlib.Path object,
• is a valid path to an existing file - if not None.

The value of checkpoint is returned if the conditions are met. An exception is raised otherwise.

Definition at line 66 of file __init__.py.

def _verify_checkpoint(checkpoint: Union[None, str, pathlib.Path]) -> str:
    if not isinstance(checkpoint, (type(None), str, pathlib.Path)):
        raise TypeError("expecting None or type str `checkpoint`")
    if checkpoint is None:
        return checkpoint
    checkpoint = os.path.expandvars(str(checkpoint))
    if not (os.path.exists(checkpoint) and os.path.isfile(checkpoint)):
        raise ValueError(f"invalid `checkpoint`: {checkpoint!r}")
    return checkpoint
 
 

_verify_globaltag()

str _verify_globaltag ( str  globaltag )

protected

Function to verify that globaltag:

• is a string.

The value of globaltag is returned if the condition is met. An exception is raised otherwise.

Definition at line 130 of file __init__.py.

def _verify_globaltag(globaltag: str) -> str:
    if not isinstance(globaltag, str):
        raise TypeError("expecting type str `globaltag`")
    return globaltag
 
 

_verify_model()

str _verify_model ( str  model )

protected

Function to verify that model:

• is a string,
• is a valid name for a model that is available for selection.

The value of model is returned if the conditions are met. An exception is raised otherwise.

Definition at line 50 of file __init__.py.

def _verify_model(model: str) -> str:
    if not isinstance(model, str):
        raise TypeError("expecting type str `model`")
    elif model not in MODELS:
        options = ", ".join(map(repr, MODELS))
        raise ValueError(f"invalid `model`: {model!r} (options: {options}")
    return model
 
 

_verify_ninter()

int _verify_ninter ( int  ninter )

protected

Function to verify that ninter:

• is an integer,
• is larger than zero.

The value of ninter is returned if the conditions are met. An exception is raised otherwise.

Definition at line 116 of file __init__.py.

def _verify_ninter(ninter: int) -> int:
    if not isinstance(ninter, int):
        raise TypeError("expecting type int `ninter`")
    elif not ninter > 0:
        raise ValueError(f"expecting `ninter` > 0 (got: {ninter}")
    return ninter
 
 

_verify_nintra()

int _verify_nintra ( int  nintra )

protected

Function to verify that nintra:

• is an integer,
• is larger than zero.

The value of nintra is returned if the conditions are met. An exception is raised otherwise.

Definition at line 101 of file __init__.py.

def _verify_nintra(nintra: int) -> int:
    if not isinstance(nintra, int):
        raise TypeError("expecting type int `nintra`")
    elif not nintra > 0:
        raise ValueError(f"expecting `nintra` > 0 (got: {nintra}")
    return nintra
 
 

_verify_seed()

Union[None, int] _verify_seed ( Union[None, int]  seed )

protected

Function to verify that seed:

• is either None or an integer,
• is in the interval - if not None.

The value of seed is returned if the conditions are met. An exception is raised otherwise.

Definition at line 84 of file __init__.py.

def _verify_seed(seed: Union[None, int]) -> Union[None, int]:
    if not isinstance(seed, (type(None), int)):
        raise TypeError("expecting None or type int `seed`")
    if seed is None:
        return seed
    if not -(2 ** 63) <= seed < 2 ** 63:
        raise ValueError(f"expecting -2^63 <= `seed` < 2^63 (got: {seed})")
    return seed
 
 

inject_simulation()

Callable inject_simulation

(

Union[None, basf2.Module]

module = None

)

Helper function to incorporate a module instance into add_simulation after BGOverlayInput.

Parameters

module

Module instance to be incorporated, defaults to None - return unmodified function

Returns

Drop-in replacement function for add_simulation

Incorporate a module instance
into :py:func:`.add_simulation` after `!BGOverlayInput`.

:param module: Module instance to be incorporated,
    defaults to None - return unmodified function
:type module: :py:class:`basf2.Module`, optional

:returns: Drop-in replacement function for :py:func:`.add_simulation`

Definition at line 365 of file __init__.py.

def inject_simulation(module: Union[None, basf2.Module] = None) -> Callable:
    """Incorporate a module instance
    into :py:func:`.add_simulation` after `!BGOverlayInput`.
 
    :param module: Module instance to be incorporated,
        defaults to None - return unmodified function
    :type module: :py:class:`basf2.Module`, optional
 
    :returns: Drop-in replacement function for :py:func:`.add_simulation`
    """
    from simulation import add_simulation
 
    if module is None:
        # no modifications necessary
        return add_simulation
    elif not isinstance(module, basf2.Module):
        raise TypeError("expecting None or type basf2.Module `module`")
 
    @functools.wraps(add_simulation)
    def injected_simulation(path, *args, **kwargs):
        # create a separate path with simulation modules
        simulation_path = basf2.Path()
        add_simulation(simulation_path, *args, **kwargs)
 
        # manually add the simulation modules to the given path
        for simulation_module in simulation_path.modules():
            # append the next module from the simulation path
            path.add_module(simulation_module)
 
            if simulation_module.name() == "BGOverlayInput":
                # incorporate the given module
                path.add_module(module)
 
    return injected_simulation

Variable Documentation

VXDID_ARGS

tuple VXDID_ARGS

Initial value:

=  tuple(
    tuple(product([1], [ladder + 1 for ladder in range(8)], [1, 2]))
    + tuple(product([2], [ladder + 1 for ladder in range(12)], [1, 2]))
)

Sequence of forty tuples (layer, ladder, sensor) used to instantiate VxdID specifier objects for distinct PXD modules.

It is assumed that the indices of tuples in the sequence match indices along the first axis of tensors with shape (40, 250, 768) that are produced by the generator.

Definition at line 37 of file __init__.py.