API

Hits

class liquidreco.hit.Hit(position=(None, None, None), time=None, weight=None, direction=(None, None, None), is_peak=(False, False, False))

Very generic detector hit, probably shouldn’t use directly, should instead use one of the derived classes

dir_x

x position of the hit

dir_y

y position of the hit

dir_z

z position of the hit

is_peak(direction: str | None = None) → bool

Checks if this hit is considered

Can specify a direction to check if it is a peak in a particular direction i.e. more position info than just the fiber position

Parameters:

direction (str) – Check if the hit is a peak in a specific direction, defaults to None

Returns:

True if this hit is a peak hit

Return type:

bool

is_x_peak

is a peak in x direction

is_y_peak

is a peak in the y direction

pos

position of the hit

set_direction(new_dir: Tuple[Any] | List[Any] | Dict[str, Any]) → None

Set a new direction for this hit

This will normalise the direction before setting the variables

Parameters:

new_dir (Tuple[float]) – New direction (must have length 3)

set_is_peak(new_is_peak: Tuple[Any] | List[Any] | Dict[str, Any]) → None

Set info about peakness of the hit

Parameters:

new_is_peak (Tuple[bool]) – New position (must have length 3)

set_position(new_pos: Tuple[Any] | List[Any] | Dict[str, Any]) → None

Set a new position for this hit

Parameters:

new_pos (Tuple[float]) – New position (must have length 3)

time

time of the hit

weight

the β€œweight” of this hit. Typically the charge/light collected

x

x position of the hit

y

y position of the hit

z

z position of the hit

class liquidreco.hit.Hit2D(pos=(None, None, None), fiber_pos=(None, None, None), time=None, weight=None, secondary_hits=None)

Describes a 2D WLS fiber hit

static copy(old_hit: Hit2D) → Hit2D

Create a copy of an existing 2D hit

Parameters:

old_hit (Hit2D) – the hit to copy

Returns:

copied hit

Return type:

Hit2D

static get_mean_pos(hits: List[Hit2D], direction: str) → float

Get the mean position of a list of 2D hits in a particular dimension

Parameters:

  • hits (List[Hit2D]) – The hits to take the average of

  • direction (str) – the dimension to take the average in. e.g. β€˜x’ to get the mean x position β€˜y’ for mean y…

Returns:

the weighted mean position

Return type:

float

set_fiber_position(new_fiber_pos: Tuple[Any] | List[Any] | Dict[str, Any]) → None

Set a new fiber position for this hit

Parameters:

new_fiber_pos – New fiber direction (must have length 3)

class liquidreco.hit.Hit3D(position=(None, None, None), voxel_x=None, voxel_y=None, voxel_z=None, time=None, weight=None, x_fiber_hit=None, y_fiber_hit=None, z_fiber_hit=None)

Describes a 3D hit constructed from two or three WLS fibers

static from_fiber_hits(x_fiber_hit: Hit2D | None = None, y_fiber_hit: Hit2D | None = None, z_fiber_hit: Hit2D | None = None, n_required_peaks: int | None = None) → Hit3D

Create a Hit3D from some 2D fiber hits

Parameters:

  • x_fiber_hit (Hit2D) – The x fiber

  • y_fiber_hit (Hit2D) – The y fiber

  • z_fiber_hit (Hit2D, optional) – The (optional) z fiber, defaults to None

  • n_required_peaks (int) – require this number of peak hits to be present in each direction to successfuly create a hit. e.g. if n_required_peaks = 1 and 0 of the provided fibers are classified as z peaks, the hit will not be valid. defaults to None

Returns:

The constructed 3D hit, None if the n_required_peaks condition is not satisfied in any direction

Return type:

Hit3D

liquidreco.hit.local_normalisation(event_hits, window_size, x_bins, y_bins, z_bins)

do a local normalisation of the hits so that lokal peaks have β€œcharge” of 1 and hits in the neighbourhood have their charges normalised by this value

liquidreco.hit.tuple_from_maybe_dict(vec: Tuple[Any] | List[Any] | Dict[str, Any]) → Tuple[Any]

Geta tuple representing a 3 vector from input that could be iterable or could be dict of form {β€œx”: *, β€œy”: *, β€œz”: *}

Parameters:

vec (Tuple[Any] | List[Any] | Dict[str, Any]) – The variable to extract 3 vector from

Returns:

3-tuple representing 3 vector

Return type:

Tuple[Any]

Events

class liquidreco.event.Event

Holds event data, is read from and written to by the various modules

add_data(key: str, data: Any) → None

Add some information about the event to the internal data table.

Can be whatever you want, hit positions, total energy deposited, a nickname for the event, go crazy!

Parameters:

  • key (str) – A key for the data being added, used by modules to access the data

  • data (Any) – The actual data

get_keys() → List[str]

Get all the data containers that are currently available in this event

Returns:

List of all the keys in the internal data table

Return type:

List[str]

Modules

Accessing Modules

Base Modules

class liquidreco.modules.module_base.ModuleBase

Base class of modules that can be run over events.

Any requirements should be given by name in the requirements member variable. Any outputs should be given by name in the outputs member variable.

To be overrridden

  • _process() - REQUIRED

  • _initialise() - OPTIONAL

  • _finalise() - OPTIONAL

  • _setup_cli_options() - OPTIONAL

  • _help() - OPTIONAL

_check_outputs(event: Event) → None

Checks that the event has all the specified outputs

Parameters:

event (Event) – the event to check

Raises:

ValueError – if the event doesn’t have the promised outputs

_check_requirements(event: Event) → None

Checks that the event has all the required inputs for this module

Parameters:

event (Event) – the event to check

Raises:

ValueError – if the event doesn’t have the required inputs

_finalise() → None

Add anything here that is neaded to tear down the object e.g. closing any files, freeing resources etc.

_help() → str

Should return a help string that will be printed to the command line for this module

Default behaviour is to use the class docstring of the module

Returns:

helpful message about your module

Return type:

str

_initialise() → None

Set up anything here that needs to be initialised

This gets called AFTER argument parsing is done so anything that depends on command line inputs needs to go in here and NOT in the __init__() method

abstract _process(event: Event) → None

This method should be implemented by any modules you write. Should process a single event and add any results to the event object.

Parameters:

event (Event) – event to be processed

Raises:

NotImplementedError – if not implemented

_setup_cli_options(parser: ArgumentParser) → None

Override this to set up any command line options for this module

The parser passed to this will be a subparser associated with this module. you can call any number of commands defined by argparse which will then be available inside of your module via self.args.

Parameters:

parser (ArgumentParser) – The subparser for this module

finalise() → None

Tear down the module

help() → str

Get help message for cmd line for this module

Returns:

help string

Return type:

str

initialise() → None

Set up the module

parse_args(args: List[str]) → None

Parse arguments for this module passed in from the command line

This sets the internally used args variable which lets user code access config arguments, so this should be called before the module is called on any events.

Parameters:

args (List[str]) – List of arguments as strings

Raises:

ValueError – if the arg parser has not yet been set up for this module

parse_object(cfg_object: Dict[str, Any]) → None

Parse arguments for this module passed in as a dict

Use for parsing objects specified via json config. This sets the internally used args variable which lets user code access config arguments, so this should be called before the module is called on any events.

Parameters:

cfg_object (Dict[str, Any]) – Dict containing arguments

Raises:

ValueError – if the arg parser has not yet been set up for this module

process(event: Event) → None

Process a single event

Parameters:

event (Event) – event to be processed

Raises:

ValueError – if the given event does not contain the specified pre-requisite inputs to at the start, or the promised outputs at the end

setup_parser(parser: ArgumentParser) → None

Setup argument parser for this module

Parameters:

parser (ArgumentParser) – The parser to be set up

Hit Building

class liquidreco.modules.hit_building.HitBuilder2D

Absolute base level module to build 2D hits from raw hit information

The starting point for any good reconstruction chain. Takes in raw hit info and turns it into more structiured hits.

_initialise()

Set up anything here that needs to be initialised

This gets called AFTER argument parsing is done so anything that depends on command line inputs needs to go in here and NOT in the __init__() method

_process(event: Event) → None

This method should be implemented by any modules you write. Should process a single event and add any results to the event object.

Parameters:

event (Event) – event to be processed

Raises:

NotImplementedError – if not implemented

_setup_cli_options(parser)

Override this to set up any command line options for this module

The parser passed to this will be a subparser associated with this module. you can call any number of commands defined by argparse which will then be available inside of your module via self.args.

Parameters:

parser (ArgumentParser) – The subparser for this module

class liquidreco.modules.hit_building.HitBuilder3D

Makes 3D hits from 2d fiber hits

_initialise()

Set up anything here that needs to be initialised

This gets called AFTER argument parsing is done so anything that depends on command line inputs needs to go in here and NOT in the __init__() method

_process(event: Event) → None

This method should be implemented by any modules you write. Should process a single event and add any results to the event object.

Parameters:

event (Event) – event to be processed

Raises:

NotImplementedError – if not implemented

_setup_cli_options(parser)

Override this to set up any command line options for this module

The parser passed to this will be a subparser associated with this module. you can call any number of commands defined by argparse which will then be available inside of your module via self.args.

Parameters:

parser (ArgumentParser) – The subparser for this module

Peak Finding

class liquidreco.modules.peak_finding.HesseRidgeDetection2D

Performs β€œridge detection” using the Hessian of a 2D image of the detector

_compute_ridgeness(hist: array, hess_eigenvals: array) → array

Compute the β€œridgeness” score for each pixel in an input image

Parameters:

  • hist (np.array) – The 2D input image

  • hess_eigenvals (np.array) – The eigenvalues of the hessian for the image (computed using the _hess_eigen() method)

Returns:

The 2D array of ridgeness scores

Return type:

np.array

_do_make_debug_plots(hist: array, u_name: str, v_name: str)

Make detailed plots of values used in the Hesse ridge detection algorithm

Parameters:

  • hist (np.array) – The input image

  • u_name (str) – The label of the u direction (β€œx”, β€œy” or β€œz”)

  • v_name (str) – The label of the v direction (β€œx”, β€œy” or β€œz”)

_finalise()

Add anything here that is neaded to tear down the object e.g. closing any files, freeing resources etc.

_gradient(hist: array, normalise: bool = False) → Tuple[array]

Calculate the gradient of an input image using central finite difference

Parameters:

  • hist (np.array) – Histogram you want the gradient of

  • normalise (bool) – Do per-bin normalisation to the cantral value

Returns:

arrays du and dv containing derivatives wrt u and v

Return type:

Tuple[np.array]

_hess_eigen(hist: array) → Tuple[array]

Get the eigenvalues and vectors of the hessian matrix of an input image

Parameters:

hist (np.array) – The input image

Returns:

The Hessian eigenvalues and eigenvectors

Return type:

Tuple[np.array]

_hessian(hist: array, normalise: bool = False) → Tuple[array]

Calculate the hessian matrix of an input image using central finite difference

Parameters:

  • hist (np.array) – Histogram you want the hessian of

  • normalise (bool) – Do per-bin normalisation to the cantral value

Returns:

arrays huu, hvv, huv, hvu containing each of the necessary double derivatives

Return type:

Tuple[np.array]

_initialise() → None

Set up anything here that needs to be initialised

This gets called AFTER argument parsing is done so anything that depends on command line inputs needs to go in here and NOT in the __init__() method

_make_plot(ridgeness: array, hess_eigenvals: array, hess_eigenvecs: array, ax: axis) → None

Make plot of the ridgeness score of each pixel (fiber) with direction of the detected ridges overlaid

Parameters:

  • ridgeness (np.array) – The 2D array defining the ridgeness score for each pixel

  • hess_eigenvals (np.array) – The 3D array of the eigenvalues of the hessian at each pixel

  • hess_eigenvecs (np.array) – The 3D array of the eigenvectors of the hessian at each pixel

  • u_name (str) – The label of the u direction (β€œx”, β€œy” or β€œz”)

  • v_name (str) – The label of the v direction (β€œx”, β€œy” or β€œz”)

  • ax (plt.axis) – The pyplot axis object to plot to

_process(event: Event)

Perform Hough transform on an event and save the result to a given file

Parameters:

event (Event) – Object describing the hits in an event

_setup_cli_options(parser)

Override this to set up any command line options for this module

The parser passed to this will be a subparser associated with this module. you can call any number of commands defined by argparse which will then be available inside of your module via self.args.

Parameters:

parser (ArgumentParser) – The subparser for this module

class liquidreco.modules.peak_finding.HesseRidgeDetection3D

Performs β€œridge detection” using the Hessian of a 3D image of the detector

_compute_ridgeness(hist: array, hess_eigenvals: array) → array

Compute the β€œridgeness” score for each pixel in an input image

Parameters:

  • hist (np.array) – The 2D input image

  • hess_eigenvals (np.array) – The eigenvalues of the hessian for the image (computed using the _hess_eigen() method)

Returns:

The 2D array of ridgeness scores

Return type:

np.array

_finalise()

Add anything here that is neaded to tear down the object e.g. closing any files, freeing resources etc.

_gradient(hist: array, normalise: bool = False) → Tuple[array]

Calculate the gradient of an input image using central finite difference

Parameters:

  • hist (np.array) – Histogram you want the gradient of

  • normalise (bool) – Do per-bin normalisation to the cantral value

Returns:

arrays du and dv containing derivatives wrt u and v

Return type:

Tuple[np.array]

_hess_eigen(hist: array) → Tuple[array]

Get the eigenvalues and vectors of the hessian matrix of an input image

Parameters:

hist (np.array) – The input image

Returns:

The Hessian eigenvalues and eigenvectors

Return type:

Tuple[np.array]

_hessian(hist: array, normalise: bool = False) → Tuple[array]

Calculate the hessian matrix of an input image using central finite difference

Parameters:

  • hist (np.array) – Histogram you want the hessian of

  • normalise (bool) – Do per-bin normalisation to the cantral value

Returns:

arrays huu, hvv, huv, hvu containing each of the necessary double derivatives

Return type:

Tuple[np.array]

_initialise() → None

Set up anything here that needs to be initialised

This gets called AFTER argument parsing is done so anything that depends on command line inputs needs to go in here and NOT in the __init__() method

_process(event: Event)

Perform Hough transform on an event and save the result to a given file

Parameters:

event (Event) – Object describing the hits in an event

_setup_cli_options(parser)

Override this to set up any command line options for this module

The parser passed to this will be a subparser associated with this module. you can call any number of commands defined by argparse which will then be available inside of your module via self.args.

Parameters:

parser (ArgumentParser) – The subparser for this module

class liquidreco.modules.peak_finding.LaplaceFitter(neighbourhood_dist: float = 45.0, peak_candidate_threshold: float = 100.0, amplitude_threshold: float = 50.0, fix_width: float | None = None, min_n_neighbours: int = 0, make_plots=False)

Performs a fit of an ensemble of laplace distributions to observed collected charges in fibers in order to try to determine which

_fit_laplace(hits: List[Hit2D], peak_candidates: List[Hit2D], u: str, v: str) → List[float]

Performs the fit of the laplace distributions

Parameters:

  • hits (List['Hit2D']) – The hits that should be considered in the fit

  • peak_candidates (List['Hit2D']) – The hits that should be considered peak candidates

  • u (str) – The u direction, should be β€œx”, β€œy” or β€œz”

  • v (str) – The v direction, should be β€œx”, β€œy” or β€œz”

Returns:

The fitted laplace amplitudes of all peak candidate fibers

Return type:

List[float]

_get_laplace_fn(fiber_positions: ndarray, fiber_charges: ndarray, neighbour_distances: array, neighbour_indices: List[array]) → Callable

Construct the ensemble of laplace functions used for fitting

Parameters:

  • fiber_positions (np.ndarray) – Positions of all of the fibers included in the fit

  • fiber_charges (np.ndarray) – Measured charges for all fibers included in the fit

  • neighbour_distances (np.array) – The distances from all fibers to the peak candidates

  • neighbour_indices (np.array) – The indices indicating which peak candidate fibers contribute to the light in each fiber

Returns:

Function that predicts charges in fibers, can then be used in fit.

Return type:

Callable

class liquidreco.modules.peak_finding.PeakFinder2D

Finds peaks in raw fiber hits and performs position corrections

_cluster_hits(fiber_hits: List[Hit2D], u: str, v: str) → List[List[Hit2D]]

Cluster hits using this PeakFinder2Ds _clusterer (default is DBSCAN but you can set it to whatever you want)

Parameters:

  • fiber_hits (List['Hit2D']) – The hits to cluster

  • u (str) – the β€œu” direction, should be β€˜x’, β€˜y’ or β€˜z’ depending on the projection

  • v (str) – the β€œv” direction, should be β€˜x’, β€˜y’ or β€˜z’ depending on the projection

Returns:

hits broken down into clusters

Return type:

List[List[β€˜Hit2D’]]

_finalise()

Tidy up and close open pdfs

_find_peak_hits(main_hit: Hit2D, line_hits: list[Hit2D], direction: str) → List[Hit2D]

Finds hits in a list whose charges are monotonically decreasing relative to some central hit

e.g. running on

↓ ____

___ / / ___/ ___/

where the arrow indicates the β€œmain hit” would give

___

/ __

___/

Parameters:

  • main_hit (Hit2D) – The central hit that defines the summit of the peak

  • line_hits (list['Hit2D']) – The hits to be searched (should include the main hit)

  • direction (str) – The direction along the β€œline” of hits, should be β€œx”, β€œy” or β€œz”

Returns:

list of hits that belong to the same peak as the main hit

Return type:

List[β€˜Hit2D’]

_get_diagonal_neighbours(hit: Hit2D, neighbourhood: List[Hit2D], u: str, v: str, u_pitch: float, v_pitch: float, diagonal_sign=1) → List[Hit2D]

Gets neighbours of a hit along a diagonal line

Parameters:

  • hit (Hit2D) – The main hit

  • neighbourhood (List['Hit2D']) – The hits to search for diagonal neighbours in

  • u (str) – the u direction, should be either β€œx”, β€œy” or β€œz”

  • v (str) – the v direction, should be either β€œx”, β€œy” or β€œz”

  • u_pitch (float) – fiber pitch in the u direction

  • v_pitch (float) – fiber pitch in the v direction

  • diagonal_sign (int, optional) – The gradient of the diagonal, defaults to +1

Returns:

Hits from the neighbourhood that lie along the specified diagonal

Return type:

List[β€˜Hit2D’]

_help() → str

Should return a help string that will be printed to the command line for this module

Default behaviour is to use the class docstring of the module

Returns:

helpful message about your module

Return type:

str

_initialise()

Set up anything here that needs to be initialised

This gets called AFTER argument parsing is done so anything that depends on command line inputs needs to go in here and NOT in the __init__() method

_process(event: Event) → None

Perform the peak finding

Returns:

peak hits in each projection

Return type:

Tuple[List[β€˜Hit2D’]]

_setup_cli_options(parser)

Override this to set up any command line options for this module

The parser passed to this will be a subparser associated with this module. you can call any number of commands defined by argparse which will then be available inside of your module via self.args.

Parameters:

parser (ArgumentParser) – The subparser for this module

Reconstruction

Module to be used to reconstruct tracks from hits.

class liquidreco.modules.reconstruction.HoughTransform

Performs simple Hough line transform

_finalise()

Add anything here that is neaded to tear down the object e.g. closing any files, freeing resources etc.

_initialise() → None

Set up anything here that needs to be initialised

This gets called AFTER argument parsing is done so anything that depends on command line inputs needs to go in here and NOT in the __init__() method

_process(event: Event)

Perform Hough transform on an event and save the result to a given file

Parameters:

event (Event) – Object describing the hits in an event

_setup_cli_options(parser)

Override this to set up any command line options for this module

The parser passed to this will be a subparser associated with this module. you can call any number of commands defined by argparse which will then be available inside of your module via self.args.

Parameters:

parser (ArgumentParser) – The subparser for this module

class liquidreco.modules.reconstruction.LocalMeanDBSCAN(mean_ball_radius=25.0, mean_iterations=1, dbscan_eps=9.0, min_charge_thresh=0.0)
_finalise()

Add anything here that is neaded to tear down the object e.g. closing any files, freeing resources etc.

_process(event: Event)

This method should be implemented by any modules you write. Should process a single event and add any results to the event object.

Parameters:

event (Event) – event to be processed

Raises:

NotImplementedError – if not implemented

class liquidreco.modules.reconstruction.MinimumSpanningTree2D
_finalise()

Add anything here that is neaded to tear down the object e.g. closing any files, freeing resources etc.

_initialise()

Set up anything here that needs to be initialised

This gets called AFTER argument parsing is done so anything that depends on command line inputs needs to go in here and NOT in the __init__() method

_process(event)

This method should be implemented by any modules you write. Should process a single event and add any results to the event object.

Parameters:

event (Event) – event to be processed

Raises:

NotImplementedError – if not implemented

_setup_cli_options(parser)

Override this to set up any command line options for this module

The parser passed to this will be a subparser associated with this module. you can call any number of commands defined by argparse which will then be available inside of your module via self.args.

Parameters:

parser (ArgumentParser) – The subparser for this module

Utility

class liquidreco.modules.utility.WeightScaling
_help()

Should return a help string that will be printed to the command line for this module

Default behaviour is to use the class docstring of the module

Returns:

helpful message about your module

Return type:

str

_initialise()

Set up anything here that needs to be initialised

This gets called AFTER argument parsing is done so anything that depends on command line inputs needs to go in here and NOT in the __init__() method

_process(event: Event) → None

This method should be implemented by any modules you write. Should process a single event and add any results to the event object.

Parameters:

event (Event) – event to be processed

Raises:

NotImplementedError – if not implemented

_setup_cli_options(parser: ArgumentParser)

Override this to set up any command line options for this module

The parser passed to this will be a subparser associated with this module. you can call any number of commands defined by argparse which will then be available inside of your module via self.args.

Parameters:

parser (ArgumentParser) – The subparser for this module

Plotting

class liquidreco.modules.hit_building.HitBuilder2D

Absolute base level module to build 2D hits from raw hit information

The starting point for any good reconstruction chain. Takes in raw hit info and turns it into more structiured hits.

_initialise()

Set up anything here that needs to be initialised

This gets called AFTER argument parsing is done so anything that depends on command line inputs needs to go in here and NOT in the __init__() method

_process(event: Event) → None

This method should be implemented by any modules you write. Should process a single event and add any results to the event object.

Parameters:

event (Event) – event to be processed

Raises:

NotImplementedError – if not implemented

_setup_cli_options(parser)

Override this to set up any command line options for this module

The parser passed to this will be a subparser associated with this module. you can call any number of commands defined by argparse which will then be available inside of your module via self.args.

Parameters:

parser (ArgumentParser) – The subparser for this module

class liquidreco.modules.hit_building.HitBuilder3D

Makes 3D hits from 2d fiber hits

_initialise()

Set up anything here that needs to be initialised

This gets called AFTER argument parsing is done so anything that depends on command line inputs needs to go in here and NOT in the __init__() method

_process(event: Event) → None

This method should be implemented by any modules you write. Should process a single event and add any results to the event object.

Parameters:

event (Event) – event to be processed

Raises:

NotImplementedError – if not implemented

_setup_cli_options(parser)

Override this to set up any command line options for this module

The parser passed to this will be a subparser associated with this module. you can call any number of commands defined by argparse which will then be available inside of your module via self.args.

Parameters:

parser (ArgumentParser) – The subparser for this module

Configuration

class liquidreco.configuration.Configuration

Class responsible for parsing user configuration

The parse_args() method is used to parse command line arguments like parse_args(sys.argv[1:]). Then specified modules are available in the modules attribute and base config arguments like input file, output file etc. are available in the base_args attribute.

_add_module_subparsers(parser: ArgumentParser)

add subparsers for each registered module

these won’t actually be used when parsing but allow printing nice unified help message with all available modules listed

Parameters:

parser (ArgumentParser) – The parser to add modules to

_parse_cl_args(args: List[str]) → None

Parse command line arguments

Parameters:

args (List[str]) – List of strings from command line (should use sys.argv[1:])

Raises:

ValueError – If a module you are asking for is not recognised

_parse_json_config(config_file: str) → None

Parse a json config file

This will overwrite the args member variable, effectively ignoring any previously specified module settings

Parameters:

config_file (str) – The file to read the config from

_setup_fit_parser() → None

Set up the parser that deals with arguments for the β€œfit” command

Will set the _fit_parser member variable

_setup_make_config_parser() → None

Set up the parser that deals with arguments for the β€œmake-config” command

Will set the _make_config_parser member variable

_setup_parser() → None

Set up the base argument parser - the one that deals with everything that isn’t some module specific parameter

parse_args(args: List[str]) → None

Parse list of arguments

You probably want to pass in sys.argv[1:] - this will get you the command line arguments specified by a user

Parameters:

args (List[str]) – The list of arguments to be parsed

to_json() → Dict[str, Dict[str, Any]]

Dump the module configuration to a json string

Returns:

JSON formatted string containing configuration for all specified modules

Return type:

str

Event Processor

class liquidreco.event_processor.EventProcessor(file_name: str, tree_name: str, modules: List[ModuleBase], max_n_events: int | None = None)

Main application loop for liquidreco

This is responsible for loading up events from the input file and looping over them, applying fit modules specified by the user.

_read_hit_info() → None

load up the input root file and read event info from it

event_loop() → None

Does the loop over all events, applying each specified module to them

Plotting

Apps

liquidreco

LiquidReco main app.

Takes a root file that contains 2D fiber hits, creates an EventProcessor based on the provided arguments, and processes the fiber hits using this.

raises ValueError:

if input args are not valid