Go Back to: C++ Manual General Site

LDMX.Recon package

Submodules

LDMX.Recon.beam_electron_locator module

Configuration for beam electron locator

Attributes:

input_collectionstring

Name of the input collection, should be one that holds sim hits

input_pass_namestring

Pass name of the input collection

output_collectionstring

Name of the output collection, holding the condensed list of beam electron locations

granularity_X_mmfloat

The expected actual resolution or the bar width in mm of the TS in the X direction

granularity_Y_mmfloat

The expected actual resolution or the bar width in mm of the TS in the Y direction

min_granularity_mmfloat

The maximum distance between SimHits that are grouped together as one beam electron

verboseboolean

If set to true, more information is spit out to either Info or Debug log level

class LDMX.Recon.beam_electron_locator.BeamElectronLocator(instance_name: str = 'BeamElectronLocator', histograms: list[Histogram] = <factory>, input_collection: str = 'truthBeamElectronsTarget', input_pass_name: str = '', output_collection: str = 'BeamElectronTruthInfo', granularity_x_mm: float = 2.5, granularity_y_mm: float = 1.6666666666666667, min_granularity_mm: float = 0.1, min_x_mm: float = -10.0, max_x_mm: float = 10.0, min_y_mm: float = -40.0, max_y_mm: float = 40.0, verbose: bool = False)

Bases: Processor

The name is purely conventional to match the C++ class name for clarity

Examples

from LDMX.Recon.beamElectronLocator import BeamElectronLocator beamEleFinder= BeamElectronLocator(‘beamEleFinder’)

You can change the parameters after creating this object.

beamEleFinder.my_parameter = 50

Then you put your processor into the sequence of the process.

p.sequence.append( beamEleFinder )

class_name: str = 'recon::BeamElectronLocator'

granularity_x_mm: float = 2.5

granularity_y_mm: float = 1.6666666666666667

input_collection: str = 'truthBeamElectronsTarget'

input_pass_name: str = ''

instance_name: str = 'BeamElectronLocator'

max_x_mm: float = 10.0

max_y_mm: float = 40.0

min_granularity_mm: float = 0.1

min_x_mm: float = -10.0

min_y_mm: float = -40.0

module_name: str = 'Recon'

output_collection: str = 'BeamElectronTruthInfo'

verbose: bool = False

LDMX.Recon.dictionary module

LDMX.Recon.ecal_preselection_skimmer module

Configuration for PreselectionProcessor

Sets all the default parameters that high so it leads to no preselection.

Attributes:

use_rechits: bool

If True, use rechit-based preselection. If False, use veto-based preselection (default: False)

Rechit-based mode parameters: ecal_rec_hit_coll: string

Collection Name for ecal rechits

ecal_rec_hit_pass: string

Pass Name for ecal rechits

Veto-based mode parameters: ecal_veto_name: string

Collection Name for veto object

ecal_veto_pass: string

Pass Name for veto object

ecal_mip_name: string

Collection Name for mip result object

ecal_mip_pass: string

Pass Name for mip result object

Shared parameters (used in both modes): summed_det_max: double

Max value for summed det (veto mode) or total rechit energy sum (rechit mode, MeV)

n_readout_hits_max: int

Max value for num readout hits (veto mode) or num rechits (rechit mode)

summed_tight_iso_max: double

Max value for summed tigh iso (veto mode only)

ecal_back_energy_max: double

Max value for ecal back energy (veto mode only)

shower_rms_max: double

Max value for shower rms

shower_y_std_max: double

Max value for shower rms in Y

shower_x_std_max: double

Max value for shower rms in X

max_cell_dep_max: double

Max value for maximal cell deposition

std_layer_hit_max: int

Max value for std layer hits

n_straight_tracks_max: int

Max value for num straight tracks

bdt_disc_min: double

Min value for the BDT disc variable

fiducial_level: int

0: don’t care if it’s fiducial or not, 1: keep fiducial events only, 2: keep non-fid events only

Examples

from LDMX.Recon.ecalPreselectionSkimmer import EcalPreselectionSkimmer

# Veto-based mode (default): ecal_pres_skimmer = EcalPreselectionSkimmer() p.sequence.append( ecal_pres_skimmer )

# Rechit-based mode: ecal_pres_skimmer = EcalPreselectionSkimmer() ecal_pres_skimmer.use_rechits = True ecal_pres_skimmer.ecal_rec_hit_coll = “EcalRecHits” ecal_pres_skimmer.ecal_rec_hit_pass = “” ecal_pres_skimmer.summed_det_max = 4000.0 # MeV (total rechit energy) ecal_pres_skimmer.n_readout_hits_max = 90 # num rechits p.sequence.append( ecal_pres_skimmer )

class LDMX.Recon.ecal_preselection_skimmer.EcalPreselectionSkimmer(instance_name: str = 'EcalPreselectionSkimmer', histograms: list[Histogram] = <factory>, use_rechits: bool = True, ecal_rec_hit_coll: str = 'EcalRecHits', ecal_rec_hit_pass: str = '', ecal_veto_name: str = 'EcalVeto', ecal_veto_pass: str = '', ecal_mip_name: str = 'EcalMipInfo', ecal_mip_pass: str = '', summed_det_max: float = 4000.0, summed_tight_iso_max: float = 9999.0, ecal_back_energy_max: float = 9999.0, n_readout_hits_max: int = 90, shower_rms_max: float = 9999.0, shower_y_std_max: float = 9999.0, shower_x_std_max: float = 9999.0, max_cell_dep_max: float = 9999.0, std_layer_hit_max: int = 9999, n_straight_tracks_max: int = 9999, bdt_disc_min: float = 0.0, fiducial_level: int = 0)

Bases: Processor

Configuration for an ECAL-based pre-selection skimmer

bdt_disc_min: float = 0.0

class_name: str = 'recon::EcalPreselectionSkimmer'

ecal_back_energy_max: float = 9999.0

ecal_mip_name: str = 'EcalMipInfo'

ecal_mip_pass: str = ''

ecal_rec_hit_coll: str = 'EcalRecHits'

ecal_rec_hit_pass: str = ''

ecal_veto_name: str = 'EcalVeto'

ecal_veto_pass: str = ''

fiducial_level: int = 0

instance_name: str = 'EcalPreselectionSkimmer'

max_cell_dep_max: float = 9999.0

module_name: str = 'Recon'

n_readout_hits_max: int = 90

n_straight_tracks_max: int = 9999

shower_rms_max: float = 9999.0

shower_x_std_max: float = 9999.0

shower_y_std_max: float = 9999.0

std_layer_hit_max: int = 9999

summed_det_max: float = 4000.0

summed_tight_iso_max: float = 9999.0

use_rechits: bool = True

LDMX.Recon.electron_counter module

Configuration for ElectronCounter

Sets all parameters to reasonable defaults.

Examples

from LDMX.Recon.electron_counter import electron_counter p.sequence.append( electron_counter )

class LDMX.Recon.electron_counter.ElectronCounter(instance_name: str = 'ElectronCounter', histograms: list[Histogram] = <factory>, simulated_electron_number: int = 1, input_collection: str = 'TriggerPadTracksY', input_pass_name: str = 'truth', output_collection: str = 'BeamElectronCount', use_simulated_electron_number: bool = False)

Bases: Processor

Configuration for the event beam electron counter

class_name: str = 'recon::ElectronCounter'

input_collection: str = 'TriggerPadTracksY'

input_pass_name: str = 'truth'

instance_name: str = 'ElectronCounter'

module_name: str = 'Recon'

output_collection: str = 'BeamElectronCount'

simulated_electron_number: int = 1

use_simulated_electron_number: bool = False

LDMX.Recon.fiducial_flag module

class LDMX.Recon.fiducial_flag.RecoilFiducialityProcessor(instance_name: str = 'RecoilFiducialityProcessor', histograms: list[LDMX.Framework._histogram.Histogram] = <factory>, min_p_mag: float = 50.0, min_tracker_hits: int = 5, input_pass_name: str = '', ecal_collection: str = 'EcalSimHits', hcal_collection: str = 'HcalSimHits', recoil_collection: str = 'RecoilSimHits', output_collection: str = 'RecoilTruthFiducialFlags', inverse_skim: bool = False)

Bases: Processor

class_name: str = 'recon::RecoilFiducialityProcessor'

ecal_collection: str = 'EcalSimHits'

hcal_collection: str = 'HcalSimHits'

input_pass_name: str = ''

instance_name: str = 'RecoilFiducialityProcessor'

inverse_skim: bool = False

min_p_mag: float = 50.0

min_tracker_hits: int = 5

module_name: str = 'Recon'

output_collection: str = 'RecoilTruthFiducialFlags'

recoil_collection: str = 'RecoilSimHits'

LDMX.Recon.my_processor module

Example configuration object for a processor

class LDMX.Recon.my_processor.MyProcessor(instance_name: str = 'MyProcessor', histograms: list[Histogram] = <factory>, my_parameter: int = 20, ecal_rechits_passname: str = '', ecal_rec_hits_event_passname: str = '')

Bases: Processor

The name is purely conventional to match the C++ class name for clarity

The @processor decorator and Processor base class handle the registration with the framework. You need to give the actual C++ class name with namespace(s) as the first argument, and the name of the module the C++ class is in as the second argument.

Any class-level attributes define parameters that are accessible in the C++ configure method. For example, the attribute

my_parameter: int = 20

defines an integer parameter for this class which can be accessed in the configure method with

int my_parameter = parameters.get<int>(“my_parameter”);

Examples

Creating the configuration object gives the parameters set in the class definition.

myProc = MyProcessor( instance_name=’myProc’)

You can also change the parameters after creating this object.

myProc.my_parameter = 50

Then you put your processor into the sequence of the process.

p.sequence.append( myProc )

class_name: str = 'recon::MyProcessor'

ecal_rec_hits_event_passname: str = ''

ecal_rechits_passname: str = ''

instance_name: str = 'MyProcessor'

module_name: str = 'Recon'

my_parameter: int = 20

LDMX.Recon.overlay module

Configuration for overlay

param overlay_filename:

The name of the file containing the pileup events to overlay on the sim event

type overlay_filename:

string

param Attributes:

param ————-:

param sim_passname:

Pass name of the sim events

type sim_passname:

string

param overlay_passname:

Pass name of the pileup events

type overlay_passname:

string

param calo_collections:

List of SimCalorimeterHit collections to pull from the sim and pileup events and combine

type calo_collections:

string

param tracker_collections:

List of SimTrackerHit collections to pull from the sim and pileup events and combine

type tracker_collections:

string

param particle_collections:

List of SimParticles collections to pull from the sim and pileup events and combine.

type particle_collections:

list[str]

param contrib_collections:

List of SimCalorimeterHit collections which need contribs added separately.

type contrib_collections:

list[str]

param poisson_mu:

The total number of interactions combined (including the sim event)

type poisson_mu:

int

param do_poisson_in_time:

Specifies whether to sample a Poisson(totalNumberOfInteractions)

to obtain the number of events to combine in-time

with the sim event (doPoissonIntime=true), or deterministically set nOverlay=totalNumberOfInteractions-1

(doPoissonIntime = false)

type do_poisson_in_time:

bool

param do_poisson_out_of_time:

Specifies whether to sample a Poisson(totalNumberOfInteractions) to obtain the number of events to put in bunches that are out-of-time with the sim event (doPoissonOutoftime=true), or deterministically set nOverlay=totalNumberOfInteractions-1

(doPoissonOutoftime = false)

type do_poisson_out_of_time:

bool

param time_sigma:

The width of a single bunch in time (expressed in sigma) [ns]

type time_sigma:

float

param time_mean:

The average time, relative to the sim time, of the pileup events [ns]. Note that this should generally be 0. A non-zero number combined with a 0 spread is useful for debugging.

type time_mean:

float

param n_earlier:

The number of preceding bunches sampled for out-of-time pileup. Furthermore, pileup will be uniformly distributed among this number of bunches m = -N_earlier, -N_earlier+1, …, N_later while the sim event is always in bunch m = 0.

type n_earlier:

int

param n_later:

The number of following bunches sampled for out-of-time pileup. Furthermore, pileup will be uniformly distributed among this number of bunches m = -N_earlier, -N_earlier+1, …, N_later while the sim event is always in bunch m = 0.

type n_later:

int

param bunch_spacing:

The spacing in time between bunches [ns]

type bunch_spacing:

float

param start_event_min:

The minimum event number to start overlaying pileup events.

type start_event_min:

int

param start_event_max:

The max event number to start overlaying pileup events.

type start_event_max:

int

param track_id_encoding:

The version number for the track ID bitwise encoding schema. Possible values range over [0, 15]. The version number is stored in bits 27-31 in the C++ int type.

type track_id_encoding:

int

class LDMX.Recon.overlay.OverlayProducer(instance_name: str = 'OverlayProducer', histograms: list[Histogram] = <factory>, overlay_filename: str = '', sim_passname: str = 'sim', overlay_passname: str = 'sim', calo_collections: list[str] = <factory>, tracker_collections: list[str] = <factory>, particle_collections: list[str] = <factory>, contrib_collections: list[str] = <factory>, out_coll_postfix: str = 'Overlay', poisson_mu: float = 2.0, do_poisson_in_time: bool = False, do_poisson_out_of_time: bool = False, time_sigma: float = 0.0, time_mean: float = 0.0, n_earlier: int = 0, n_later: int = 0, bunch_spacing: float = 26.9, tree_name: str = 'LDMX_Events', start_event_min: int = 1, start_event_max: int = 10000, track_id_encoding: int = 1)

Bases: Processor

Configuration for pileup overlay

Sets all parameters to reasonable defaults.

Examples

from LDMX.Recon.overlay import OverlayProducer p.sequence.append( OverlayProducer(

overlay_filename=’myPileupFileName.root’ )

)

bunch_spacing: float = 26.9

calo_collections: list[str]

class_name: str = 'recon::OverlayProducer'

contrib_collections: list[str]

do_poisson_in_time: bool = False

do_poisson_out_of_time: bool = False

instance_name: str = 'OverlayProducer'

module_name: str = 'Recon'

n_earlier: int = 0

n_later: int = 0

out_coll_postfix: str = 'Overlay'

overlay_filename: str = ''

overlay_passname: str = 'sim'

particle_collections: list[str]

poisson_mu: float = 2.0

sim_passname: str = 'sim'

start_event_max: int = 10000

start_event_min: int = 1

time_mean: float = 0.0

time_sigma: float = 0.0

track_id_encoding: int = 1

tracker_collections: list[str]

tree_name: str = 'LDMX_Events'

LDMX.Recon.pf_reco module

Configuration for pfReco producers

Sets all parameters to reasonable defaults.

Examples

from LDMX.Recon.pf_reco import PFEcalClusterProducer p.sequence.append( PFEcalClusterProducer )

class LDMX.Recon.pf_reco.PFEcalClusterProducer(instance_name: str = 'PFEcalClusterProducer', histograms: list[Histogram] = <factory>, hit_coll_name: str = 'EcalRecHits', hit_pass_name: str = '', cluster_coll_name: str = 'PFEcalClusters', do_single_cluster: bool = False, log_energy_weight: bool = True, min_cluster_hit_mult: int = 2, cluster_hit_dist: float = 50.0, min_hit_energy: float = 1.0)

Bases: Processor

Configuration for Ecal cluster builder for particle reco

class_name: str = 'recon::PFEcalClusterProducer'

cluster_coll_name: str = 'PFEcalClusters'

cluster_hit_dist: float = 50.0

do_single_cluster: bool = False

hit_coll_name: str = 'EcalRecHits'

hit_pass_name: str = ''

instance_name: str = 'PFEcalClusterProducer'

log_energy_weight: bool = True

min_cluster_hit_mult: int = 2

min_hit_energy: float = 1.0

module_name: str = 'Recon'

class LDMX.Recon.pf_reco.PFHcalClusterProducer(instance_name: str = 'PFHcalClusterProducer', histograms: list[Histogram] = <factory>, hit_coll_name: str = 'HcalRecHits', hit_pass_name: str = '', cluster_coll_name: str = 'PFHcalClusters', do_single_cluster: bool = False, log_energy_weight: bool = True, min_cluster_hit_mult: int = 2, cluster_hit_dist: float = 100.0, min_hit_energy: float = 0.1)

Bases: Processor

Configuration for Hcal cluster builder for particle reco

class_name: str = 'recon::PFHcalClusterProducer'

cluster_coll_name: str = 'PFHcalClusters'

cluster_hit_dist: float = 100.0

do_single_cluster: bool = False

hit_coll_name: str = 'HcalRecHits'

hit_pass_name: str = ''

instance_name: str = 'PFHcalClusterProducer'

log_energy_weight: bool = True

min_cluster_hit_mult: int = 2

min_hit_energy: float = 0.1

module_name: str = 'Recon'

class LDMX.Recon.pf_reco.PFProducer(instance_name: str = 'ParticleFlow', histograms: list[Histogram] = <factory>, input_ecal_coll_name: str = 'PFEcalClusters', input_hcal_coll_name: str = 'PFHcalClusters', input_track_coll_name: str = 'PFTracks', use_existing_ecal_clusters: bool = False, output_coll_name: str = 'PFCandidates', single_particle: bool = False, input_ecal_passname: str = '', input_hcal_passname: str = '', input_tracks_passname: str = '')

Bases: Processor

Configuration for particle reco

class_name: str = 'recon::ParticleFlow'

input_ecal_coll_name: str = 'PFEcalClusters'

input_ecal_passname: str = ''

input_hcal_coll_name: str = 'PFHcalClusters'

input_hcal_passname: str = ''

input_track_coll_name: str = 'PFTracks'

input_tracks_passname: str = ''

instance_name: str = 'ParticleFlow'

module_name: str = 'Recon'

output_coll_name: str = 'PFCandidates'

single_particle: bool = False

use_existing_ecal_clusters: bool = False

class LDMX.Recon.pf_reco.PFTrackProducer(instance_name: str = 'PFTrackProducer', histograms: list[Histogram] = <factory>, input_track_coll_name: str = 'EcalScoringPlaneHits', input_pass_name: str = '', output_track_coll_name: str = 'PFTracks', do_electron_tracking: bool = False, min_electron_momentum_z: float = 2500.0, max_electron_track_id: int = 30)

Bases: Processor

Configuration for track selector for particle reco

class_name: str = 'recon::PFTrackProducer'

do_electron_tracking: bool = False

input_pass_name: str = ''

input_track_coll_name: str = 'EcalScoringPlaneHits'

instance_name: str = 'PFTrackProducer'

max_electron_track_id: int = 30

min_electron_momentum_z: float = 2500.0

module_name: str = 'Recon'

output_track_coll_name: str = 'PFTracks'

class LDMX.Recon.pf_reco.PFTruthProducer(instance_name: str = 'PFTruthProducer', histograms: list[Histogram] = <factory>, output_primary_coll_name: str = 'PFTruth', output_target_coll_name: str = 'PFTruthTarget', output_ecal_coll_name: str = 'PFTruthEcal', output_hcal_coll_name: str = 'PFTruthHcal', target_sp_coll_name: str = 'TargetScoringPlaneHits', target_sp_passname: str = '', ecal_sp_coll_name: str = 'EcalScoringPlaneHits', ecal_sp_passname: str = '', sim_particles_coll_name: str = 'SimParticles', sim_particles_passname: str = '', sim_particles_event_passname: str = '', ecal_sp_hits_event_passname: str = '', target_sp_hits_event_passname: str = '')

Bases: Processor

Configuration for track selector for particle reco

class_name: str = 'recon::PFTruthProducer'

ecal_sp_coll_name: str = 'EcalScoringPlaneHits'

ecal_sp_hits_event_passname: str = ''

ecal_sp_passname: str = ''

instance_name: str = 'PFTruthProducer'

module_name: str = 'Recon'

output_ecal_coll_name: str = 'PFTruthEcal'

output_hcal_coll_name: str = 'PFTruthHcal'

output_primary_coll_name: str = 'PFTruth'

output_target_coll_name: str = 'PFTruthTarget'

sim_particles_coll_name: str = 'SimParticles'

sim_particles_event_passname: str = ''

sim_particles_passname: str = ''

target_sp_coll_name: str = 'TargetScoringPlaneHits'

target_sp_hits_event_passname: str = ''

target_sp_passname: str = ''

LDMX.Recon.pileup_finder module

Configuration for pfReco producers

Sets all parameters to reasonable defaults.

Examples

from LDMX.Recon import pileup_finder p.sequence.append( PileupFinder )

class LDMX.Recon.pileup_finder.PileupFinder(instance_name: str = 'PileupFinder', histograms: list[Histogram] = <factory>, rec_hit_coll_name: str = 'EcalRecHits', rec_hit_pass_name: str = '', cluster_coll_name: str = 'PFEcalClusters', cluster_pass_name: str = '', pf_cand_coll_name: str = 'PFCandidates', pf_cand_pass_name: str = '', output_rec_hit_coll_name: str = 'EcalRecHitsNoPileup', min_momentum: float = 4000.0)

Bases: Processor

Configuration for pileup finding from particle flow objects

class_name: str = 'recon::PileupFinder'

cluster_coll_name: str = 'PFEcalClusters'

cluster_pass_name: str = ''

instance_name: str = 'PileupFinder'

min_momentum: float = 4000.0

module_name: str = 'Recon'

output_rec_hit_coll_name: str = 'EcalRecHitsNoPileup'

pf_cand_coll_name: str = 'PFCandidates'

pf_cand_pass_name: str = ''

rec_hit_coll_name: str = 'EcalRecHits'

rec_hit_pass_name: str = ''

LDMX.Recon.simple_seq_trigger module

Configuration for TriggerProcessor

Sets all parameters to reasonable defaults.

Attributes:

trigger_list

the collection of each trigger we perform sequential skimming with.

trigger_pass_names

our input pass names for the multiple trigger.

doORbool

skimmer checks if one trigger is true

doANDbool

skimmer checks if all triggers are true

doVALbool

skimmer produces an output collection for the purpose of validation

class LDMX.Recon.simple_seq_trigger.SequentialTrigger(instance_name: str = 'SequentialTrigger', histograms: list[Histogram] = <factory>, trigger_list: list[str] = <factory>, trigger_pass_names: list[str] = <factory>, do_or: bool = False, do_and: bool = True, do_val: bool = True)

Bases: Processor

Configuration for the sequential trigger (skimmer) on the ECal reco hits

class_name: str = 'recon::SequentialTrigger'

do_and: bool = True

do_or: bool = False

do_val: bool = True

instance_name: str = 'SequentialTrigger'

module_name: str = 'Recon'

trigger_list: list[str]

trigger_pass_names: list[str]

LDMX.Recon.simple_trigger module

Configuration for TriggerProcessor

Sets all parameters to reasonable defaults.

Attributes:

beam_energyfloat

The beam energy in MeV

thresholdslist of floats

The upper limit on Ecal reconstructed hit energy sum (in MeV) allowed for the event to pass the trigger. Calculated as a sum over the specified number of layers. The processor assumes that the first element in the list is for 1e, 2nd is for 2e, etc: [ my_cut_for_1e, my_cut_for_2e, … ] If the electron count exceeds the number of elements, the 1e threshold and a simple formula subtracting a multiple of the beam energy is used.

modeint

Legacy parameter for which energy calculation mode to use. Defaults to 0 (layer sums). mode = 1 is for tower sums, currently not implemented.

start_layerint

First layer used in the Ecal energy sum over layers.

end_layerint

First layer not used in the Ecal energy sum over layers. So, the last used layer is end_layer-1.

input_collectionstring

Name of the Ecal hit collection used as input

trigger_collectionstring

Name of the output collection containing the trigger result

Examples

from LDMX.Recon.simple_trigger import simple_trigger p.sequence.append( simple_trigger )

class LDMX.Recon.simple_trigger.TriggerProcessor(instance_name: str = 'TriggerProcessor', histograms: list[Histogram] = <factory>, beam_energy: float = 8000.0, thresholds: list[float] = <factory>, mode: int = 0, start_layer: int = 0, end_layer: int = 20, input_collection: str = 'EcalRecHits', input_pass: str = '', trigger_collection: str = 'Trigger')

Bases: Processor

Configuration for the (multi-electron aware but simple) trigger on the ECal reco hits

beam_energy: float = 8000.0

class_name: str = 'recon::TriggerProcessor'

end_layer: int = 20

input_collection: str = 'EcalRecHits'

input_pass: str = ''

instance_name: str = 'TriggerProcessor'

mode: int = 0

module_name: str = 'Recon'

start_layer: int = 0

thresholds: list[float]

trigger_collection: str = 'Trigger'

LDMX.Recon.track_dedx_mass_estimator module

Configuration for TrackDeDxMassEstimator

The tracker dE/dx vs momentum 2d distribution profile histogram can be fitted using an approximated Bethe-Bloch parametrization at low relativistic regime:

dE/dx = K * m^2 / p^2 + C,

where m is the particle mass, p is the particle momentum, K and C are fit parameters. Using the fitted result of the parameters, the mass of the particle can be calculated from its dE/dx and momentum.

Attributes:

track_collectionstring

Name of the track collection used as input

fit_res_cfloat

The fitted result of the constant term C (unit: MeV/mm)

fit_res_kfloat

The fitted result of the factor K of the quadratic term (dimentionless)

Examples

from LDMX.Recon.track_dedx_mass_estimator import recoil_track_mass_estimator p.sequence.append( recoil_track_mass_estimator )

class LDMX.Recon.track_dedx_mass_estimator.TrackDeDxMassEstimator(instance_name: str = 'TrackDeDxMassEstimator', histograms: list[Histogram] = <factory>, track_collection: str = 'RecoilTruthTracks', fit_res_c: float = 3.094, fit_res_k: float = 1.862)

Bases: Processor

Configuration for the mass estimator from tracker dEdx

class_name: str = 'recon::TrackDeDxMassEstimator'

fit_res_c: float = 3.094

fit_res_k: float = 1.862

instance_name: str = 'TrackDeDxMassEstimator'

module_name: str = 'Recon'

track_collection: str = 'RecoilTruthTracks'

Module contents