eicrecon Namespace Reference

-client More...

Namespaces
namespace	Tools

Classes
class	ActsToTracks
class	ActsToTracks_factory
class	ActsTrackMerger
class	ActsTrackMerger_factory
class	AmbiguitySolver
class	AmbiguitySolver_factory
struct	AmbiguitySolverConfig
class	CalorimeterClusterRecoCoG
class	CalorimeterClusterRecoCoG_factory
struct	CalorimeterClusterRecoCoGConfig
class	CalorimeterClusterShape
	Calculate cluster shapes for provided clusters. More...
class	CalorimeterClusterShape_factory
struct	CalorimeterClusterShapeConfig
class	CalorimeterHitDigi
class	CalorimeterHitDigi_factory
struct	CalorimeterHitDigiConfig
class	CalorimeterHitReco
class	CalorimeterHitReco_factory
struct	CalorimeterHitRecoConfig
class	CalorimeterHitsMerger
class	CalorimeterHitsMerger_factory
struct	CalorimeterHitsMergerConfig
class	CalorimeterIslandCluster
class	CalorimeterIslandCluster_factory
struct	CalorimeterIslandClusterConfig
class	CalorimeterParticleIDPostML
class	CalorimeterParticleIDPostML_factory
class	CalorimeterParticleIDPreML
class	CalorimeterParticleIDPreML_factory
class	CalorimeterTruthClustering
class	CalorimeterTruthClustering_factory
class	CALOROCDigitization
class	CALOROCDigitization_factory
struct	CALOROCDigitizationConfig
class	CFDROCDigitization
class	CFDROCDigitization_factory
struct	CFDROCDigitizationConfig
struct	Chain
struct	ChainInvoker
struct	ChainInvoker< FirstMemberFunctionPtr, RestMemberFunctionPtrs... >
struct	ChainInvoker< MemberFunctionPtr >
class	ChargedCandidateMaker
class	ChargedCandidateMaker_factory
class	ChargedMCParticleSelector
class	ChargedMCParticleSelector_factory
class	ChargedReconstructedParticleSelector
class	ChargedReconstructedParticleSelector_factory
class	CKFTracking
class	CKFTracking_factory
struct	CKFTrackingConfig
struct	CKFTrackingFunctionImpl
class	ClustersToParticles
class	ClustersToParticles_factory
struct	ClustersToParticlesConfig
class	CollectionCollector
class	CollectionCollector_factory
struct	CompareObjectID
class	ConvertParticleID
struct	CylinderSurfaceConfig
struct	DiscSurfaceConfig
class	EICROCDigitization
class	EICROCDigitization_factory
struct	EICROCDigitizationConfig
class	ElectronReconstruction
struct	ElectronReconstructionConfig
class	EnergyPositionClusterMerger
class	EnergyPositionClusterMerger_factory
struct	EnergyPositionClusterMergerConfig
class	EvaluatorPulse
class	EvaluatorSvc
	Provides an interface to a compiler that converts string expressions to native std::function. More...
class	FarDetectorLinearTracking
class	FarDetectorLinearTracking_factory
struct	FarDetectorLinearTrackingConfig
class	FarDetectorTrackerCluster
class	FarDetectorTrackerCluster_factory
struct	FarDetectorTrackerClusterConfig
class	FarDetectorTransportationPostML
class	FarDetectorTransportationPostML_factory
struct	FarDetectorTransportationPostMLConfig
class	FarDetectorTransportationPreML
class	FarDetectorTransportationPreML_factory
struct	FarDetectorTransportationPreMLConfig
class	FarForwardNeutralsReconstruction
class	FarForwardNeutralsReconstruction_factory
struct	FarForwardNeutralsReconstructionConfig
class	FilterMatching
class	FilterMatching_factory
class	GeometrySplit
class	HadronicFinalState
class	HadronicFinalState_factory
class	Helix
class	HEXPLIT
class	HEXPLIT_factory
struct	HEXPLITConfig
struct	HitAdapter
struct	HitAdapter< edm4hep::SimCalorimeterHit >
struct	HitAdapter< edm4hep::SimTrackerHit >
class	ImagingClusterReco
class	ImagingClusterReco_factory
struct	ImagingClusterRecoConfig
class	ImagingTopoCluster
class	ImagingTopoCluster_factory
struct	ImagingTopoClusterConfig
class	InclusiveKinematicsDA
class	InclusiveKinematicsElectron
class	InclusiveKinematicsESigma
class	InclusiveKinematicsJB
class	InclusiveKinematicsML
class	InclusiveKinematicsML_factory
struct	InclusiveKinematicsMLConfig
class	InclusiveKinematicsReconstructed_factory
class	InclusiveKinematicsSigma
class	InclusiveKinematicsTruth
class	InclusiveKinematicsTruth_factory
class	IrtCherenkovParticleID
class	IrtCherenkovParticleID_factory
class	IrtCherenkovParticleIDConfig
class	IterativeVertexFinder
class	IterativeVertexFinder_factory
struct	IterativeVertexFinderConfig
class	JetReconstruction
class	JetReconstruction_factory
struct	JetReconstructionConfig
class	LambdaReconstruction
class	LambdaReconstruction_factory
struct	LambdaReconstructionConfig
class	LandauPulse
class	LGADHitCalibration
class	LGADHitCalibration_factory
struct	LGADHitCalibrationConfig
class	LGADHitClustering
class	LGADHitClustering_factory
struct	LGADHitClusteringConfig
class	MatchClusters
class	MatchClusters_factory
class	MatchToRICHPID
class	MatchToRICHPID_factory
struct	MatchToRICHPIDConfig
struct	MatrixConfig
class	MatrixTransferStatic
class	MatrixTransferStatic_factory
struct	MatrixTransferStaticConfig
class	MC2ReconstructedParticle
class	MC2ReconstructedParticle_factory
class	MergeCherenkovParticleID_factory
class	MergeParticleID
class	MergeParticleIDConfig
class	MergeTrack_factory
class	MergeTracks
class	MPGDHitReconstruction
class	MPGDHitReconstruction_factory
struct	MPGDHitReconstructionConfig
class	MPGDTrackerDigi
class	MPGDTrackerDigi_factory
struct	MPGDTrackerDigiConfig
struct	multilambda
struct	NoConfig
class	ONNXInference
class	ONNXInference_factory
struct	ONNXInferenceConfig
struct	OrthogonalTrackSeedingConfig
class	PhotoMultiplierHitDigi
class	PhotoMultiplierHitDigi_factory
class	PhotoMultiplierHitDigiConfig
class	PIDLookup
class	PIDLookup_factory
struct	PIDLookupConfig
class	PIDLookupTable
class	PIDLookupTableSvc
struct	PolynomialMatrixConfig
class	PolynomialMatrixReconstruction
class	PolynomialMatrixReconstruction_factory
struct	PolynomialMatrixReconstructionConfig
class	PrimaryVertices
class	PrimaryVertices_factory
struct	PrimaryVerticesConfig
class	PulseCombiner
class	PulseCombiner_factory
struct	PulseCombinerConfig
class	PulseGeneration
class	PulseGeneration_factory
struct	PulseGenerationConfig
class	PulseNoise
class	PulseNoise_factory
struct	PulseNoiseConfig
class	PulseShapeFactory
struct	RadiatorConfig
class	RangeSplit
class	RangeSplit< Chain< MemberFunctionPtrs... > >
class	ReconstructedElectrons_factory
class	RichTrack_factory
class	ScatteredElectronsEMinusPz
class	ScatteredElectronsEMinusPz_factory
struct	ScatteredElectronsEMinusPzConfig
class	ScatteredElectronsTruth
class	ScatteredElectronsTruth_factory
class	SecondaryVertexFinder
class	SecondaryVertexFinder_factory
struct	SecondaryVertexFinderConfig
class	SecondaryVerticesHelix
class	SecondaryVerticesHelix_factory
struct	SecondaryVerticesHelixConfig
class	SignalPulse
class	SiliconChargeSharing
class	SiliconChargeSharing_factory
struct	SiliconChargeSharingConfig
class	SiliconPulseDiscretization
class	SiliconPulseDiscretization_factory
struct	SiliconPulseDiscretizationConfig
class	SiliconTrackerDigi
class	SiliconTrackerDigi_factory
struct	SiliconTrackerDigiConfig
class	SimCalorimeterHitProcessor
class	SimCalorimeterHitProcessor_factory
struct	SimCalorimeterHitProcessorConfig
class	SpacePoint
class	SpacePointContainerAdapter
class	SpdlogMixin
class	SpdlogPrintPolicy
	default print policy for debug messages More...
class	SubDivideCollection
class	SubDivideCollection_factory
struct	SubDivideCollectionConfig
class	TrackClusterMatch
class	TrackClusterMatch_factory
struct	TrackClusterMatchConfig
class	TrackClusterMergeSplitter
	Track-Based Cluster Merger/Splitter. More...
class	TrackClusterMergeSplitter_factory
struct	TrackClusterMergeSplitterConfig
class	TrackerHitReconstruction
class	TrackerHitReconstruction_factory
struct	TrackerHitReconstructionConfig
class	TrackerMeasurementFromHits
class	TrackerMeasurementFromHits_factory
class	TrackParamTruthInit
class	TrackParamTruthInit_factory
class	TrackProjector
class	TrackProjector_factory
class	TrackPropagation
class	TrackPropagation_factory
struct	TrackPropagationConfig
class	TrackProtoClusterMatchPromoter
class	TrackProtoClusterMatchPromoter_factory
class	TrackSeeding
class	TrackSeeding_factory
class	TracksToParticles
class	TracksToParticles_factory
class	TransformBreitFrame
class	TransformBreitFrame_factory
class	TruthEnergyPositionClusterMerger
class	TruthEnergyPositionClusterMerger_factory
class	UndoAfterBurner
struct	UndoAfterBurnerConfig
class	UndoAfterBurnerMCParticles_factory
class	ValueSplit
class	WithPodConfig

Typedefs
using	ClustersWithAssociations = std::pair< std::unique_ptr< edm4eic::ClusterCollection >, std::unique_ptr< edm4eic::MCRecoClusterParticleAssociationCollection > >
using	CalorimeterClusterRecoCoGAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::ProtoClusterCollection, std::optional< edm4eic::MCRecoCalorimeterHitLinkCollection >, std::optional< edm4eic::MCRecoCalorimeterHitAssociationCollection > >, algorithms::Output< edm4eic::ClusterCollection, std::optional< edm4eic::MCRecoClusterParticleLinkCollection >, std::optional< edm4eic::MCRecoClusterParticleAssociationCollection > > >
using	CalorimeterClusterShapeAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::ClusterCollection, std::optional< edm4eic::MCRecoClusterParticleAssociationCollection > >, algorithms::Output< edm4eic::ClusterCollection, std::optional< edm4eic::MCRecoClusterParticleLinkCollection >, std::optional< edm4eic::MCRecoClusterParticleAssociationCollection > > >
	Algorithm input/output.
using	CalorimeterHitDigiAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::EventHeaderCollection, edm4hep::SimCalorimeterHitCollection >, algorithms::Output< edm4hep::RawCalorimeterHitCollection, edm4eic::MCRecoCalorimeterHitLinkCollection, edm4eic::MCRecoCalorimeterHitAssociationCollection > >
using	CalorimeterHitRecoAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::RawCalorimeterHitCollection >, algorithms::Output< edm4eic::CalorimeterHitCollection > >
using	MergeMap = std::unordered_map< uint64_t, std::vector< std::size_t > >
using	RefField = std::pair< std::string, int >
using	MapFunc = std::function< int(const edm4eic::CalorimeterHit &)>
using	CalorimeterHitsMergerAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::CalorimeterHitCollection >, algorithms::Output< edm4eic::CalorimeterHitCollection > >
using	CaloHit = edm4eic::CalorimeterHit
using	CalorimeterIslandClusterAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::CalorimeterHitCollection >, algorithms::Output< edm4eic::ProtoClusterCollection > >
using	CalorimeterTruthClusteringAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::CalorimeterHitCollection, edm4hep::SimCalorimeterHitCollection >, algorithms::Output< edm4eic::ProtoClusterCollection > >
using	EnergyPositionClusterMergerAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleAssociationCollection, edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleAssociationCollection >, algorithms::Output< edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleLinkCollection, edm4eic::MCRecoClusterParticleAssociationCollection > >
using	HEXPLITAlgorithm = algorithms::Algorithm< algorithms::Input< const edm4eic::CalorimeterHitCollection >, algorithms::Output< edm4eic::CalorimeterHitCollection > >
using	ImagingClusterRecoAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::ProtoClusterCollection, edm4eic::MCRecoCalorimeterHitLinkCollection, edm4eic::MCRecoCalorimeterHitAssociationCollection >, algorithms::Output< edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleLinkCollection, edm4eic::MCRecoClusterParticleAssociationCollection, edm4eic::ClusterCollection > >
using	ImagingTopoClusterAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::CalorimeterHitCollection >, algorithms::Output< edm4eic::ProtoClusterCollection > >
using	SimCalorimeterHitProcessorAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::SimCalorimeterHitCollection >, algorithms::Output< edm4hep::SimCalorimeterHitCollection, edm4hep::CaloHitContributionCollection > >
using	TrackClusterMergeSplitterAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::TrackClusterMatchCollection, edm4eic::ClusterCollection, edm4eic::TrackSegmentCollection >, algorithms::Output< edm4eic::ProtoClusterCollection, edm4eic::TrackProtoClusterLinkCollection > >
using	TruthEnergyPositionClusterMergerAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::MCParticleCollection, edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleAssociationCollection, edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleAssociationCollection >, algorithms::Output< edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleLinkCollection, edm4eic::MCRecoClusterParticleAssociationCollection > >
using	CALOROCDigitizationAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::SimPulseCollection >, algorithms::Output< edm4eic::RawCALOROCHitCollection > >
using	CFDROCDigitizationAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::RawTimeSeriesCollection >, algorithms::Output< edm4eic::RawTrackerHitCollection > >
using	EICROCDigitizationAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::RawTimeSeriesCollection >, algorithms::Output< edm4eic::RawTrackerHitCollection > >
using	MPGDTrackerDigiAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::EventHeaderCollection, edm4hep::SimTrackerHitCollection >, algorithms::Output< edm4eic::RawTrackerHitCollection, edm4eic::MCRecoTrackerHitLinkCollection, edm4eic::MCRecoTrackerHitAssociationCollection > >
using	PhotoMultiplierHitDigiAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::EventHeaderCollection, edm4hep::SimTrackerHitCollection >, algorithms::Output< edm4eic::RawTrackerHitCollection, edm4eic::MCRecoTrackerHitLinkCollection, edm4eic::MCRecoTrackerHitAssociationCollection > >
using	PulseType = edm4hep::TimeSeries
using	PulseCombinerAlgorithm = algorithms::Algorithm< algorithms::Input< PulseType::collection_type >, algorithms::Output< PulseType::collection_type > >
using	MutablePulseType = edm4hep::MutableTimeSeries
template<typename HitT >
using	PulseGenerationAlgorithm = algorithms::Algorithm< algorithms::Input< typename HitT::collection_type >, algorithms::Output< PulseType::collection_type > >
using	PulseNoiseAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::EventHeaderCollection, PulseType::collection_type >, algorithms::Output< PulseType::collection_type > >
using	SiliconChargeSharingAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::SimTrackerHitCollection >, algorithms::Output< edm4hep::SimTrackerHitCollection > >
using	SiliconPulseDiscretizationAlgorithm = algorithms::Algorithm< algorithms::Input< PulseType::collection_type >, algorithms::Output< edm4hep::RawTimeSeriesCollection > >
using	SiliconTrackerDigiAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::EventHeaderCollection, edm4hep::SimTrackerHitCollection >, algorithms::Output< edm4eic::RawTrackerHitCollection, edm4eic::MCRecoTrackerHitLinkCollection, edm4eic::MCRecoTrackerHitAssociationCollection > >
using	FarDetectorLinearTrackingAlgorithm = algorithms::Algorithm< algorithms::Input< std::vector< edm4eic::Measurement2DCollection >, std::optional< edm4eic::MCRecoTrackerHitLinkCollection >, std::optional< edm4eic::MCRecoTrackerHitAssociationCollection > >, algorithms::Output< edm4eic::TrackCollection, std::optional< edm4eic::MCRecoTrackParticleLinkCollection >, std::optional< edm4eic::MCRecoTrackParticleAssociationCollection > > >
using	FarDetectorTrackerClusterAlgorithm = algorithms::Algorithm< algorithms::Input< std::vector< edm4eic::TrackerHitCollection > >, algorithms::Output< std::vector< edm4eic::Measurement2DCollection > > >
using	FarDetectorTransportationPostMLAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::TensorCollection, std::optional< edm4eic::MCRecoTrackParticleAssociationCollection >, std::optional< edm4hep::MCParticleCollection > >, algorithms::Output< edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleLinkCollection, edm4eic::MCRecoParticleAssociationCollection > >
using	FarDetectorTransportationPreMLAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::TrackCollection, std::optional< edm4eic::MCRecoTrackParticleAssociationCollection >, std::optional< edm4hep::MCParticleCollection > >, algorithms::Output< edm4eic::TensorCollection, std::optional< edm4eic::TensorCollection > > >
using	MatrixTransferStaticAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::MCParticleCollection, edm4eic::TrackerHitCollection >, algorithms::Output< edm4eic::ReconstructedParticleCollection > >
using	PolynomialMatrixReconstructionAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::MCParticleCollection, edm4eic::TrackerHitCollection >, algorithms::Output< edm4eic::ReconstructedParticleCollection > >
template<class T >
using	CollectionCollectorAlgorithm = algorithms::Algorithm< typename algorithms::Input< std::vector< const T > >, typename algorithms::Output< T > >
template<class ToFilterObjectT , class FilterByObjectT >
using	FilterMatchingAlgorithm = algorithms::Algorithm< typename algorithms::Input< typename ToFilterObjectT::collection_type, typename FilterByObjectT::collection_type >, typename algorithms::Output< typename ToFilterObjectT::collection_type, typename ToFilterObjectT::collection_type > >
template<class T >
using	SubDivideCollectionAlgorithm = algorithms::Algorithm< typename algorithms::Input< const typename T::collection_type >, typename algorithms::Output< std::vector< typename T::collection_type > > >
using	CalorimeterParticleIDPostMLAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::ClusterCollection, std::optional< edm4eic::MCRecoClusterParticleAssociationCollection >, edm4eic::TensorCollection >, algorithms::Output< edm4eic::ClusterCollection, std::optional< edm4eic::MCRecoClusterParticleLinkCollection >, std::optional< edm4eic::MCRecoClusterParticleAssociationCollection >, edm4hep::ParticleIDCollection > >
using	CalorimeterParticleIDPreMLAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::ClusterCollection, std::optional< edm4eic::MCRecoClusterParticleAssociationCollection > >, algorithms::Output< edm4eic::TensorCollection, std::optional< edm4eic::TensorCollection > > >
using	InclusiveKinematicsMLAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::InclusiveKinematicsCollection, edm4eic::InclusiveKinematicsCollection >, algorithms::Output< edm4eic::InclusiveKinematicsCollection > >
using	ONNXInferenceAlgorithm = algorithms::Algorithm< algorithms::Input< std::vector< edm4eic::TensorCollection > >, algorithms::Output< std::vector< edm4eic::TensorCollection > > >
using	ChargedCandidateMakerAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::TrackClusterMatchCollection >, algorithms::Output< edm4eic::ReconstructedParticleCollection > >
using	TrackProtoClusterMatchPromoterAlgorithm = algorithms::Algorithm< typename algorithms::Input< edm4eic::TrackProtoClusterLinkCollection, edm4eic::ProtoClusterCollection, edm4eic::ClusterCollection >, typename algorithms::Output< edm4eic::TrackClusterMatchCollection > >
using	IrtCherenkovParticleIDAlgorithm = algorithms::Algorithm< algorithms::Input< const edm4eic::TrackSegmentCollection, const edm4eic::TrackSegmentCollection, const edm4eic::TrackSegmentCollection, const edm4eic::RawTrackerHitCollection, const edm4eic::MCRecoTrackerHitAssociationCollection >, algorithms::Output< edm4eic::CherenkovParticleIDCollection, edm4eic::CherenkovParticleIDCollection > >
using	MatchToRICHPIDAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleAssociationCollection, edm4eic::CherenkovParticleIDCollection >, algorithms::Output< edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleLinkCollection, edm4eic::MCRecoParticleAssociationCollection, edm4hep::ParticleIDCollection > >
using	MergeParticleIDAlgorithm = algorithms::Algorithm< algorithms::Input< std::vector< const edm4eic::CherenkovParticleIDCollection > >, algorithms::Output< edm4eic::CherenkovParticleIDCollection > >
using	MergeTracksAlgorithm = algorithms::Algorithm< algorithms::Input< std::vector< const edm4eic::TrackSegmentCollection > >, algorithms::Output< edm4eic::TrackSegmentCollection > >
using	PIDLookupAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::EventHeaderCollection, edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleAssociationCollection >, algorithms::Output< edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleLinkCollection, edm4eic::MCRecoParticleAssociationCollection, edm4hep::ParticleIDCollection > >
using	ChargedMCParticleSelectorAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::MCParticleCollection >, algorithms::Output< edm4hep::MCParticleCollection > >
using	ChargedReconstructedParticleSelectorAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::ReconstructedParticleCollection >, algorithms::Output< edm4eic::ReconstructedParticleCollection > >
using	ClustersToParticlesAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleAssociationCollection >, algorithms::Output< edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleLinkCollection, edm4eic::MCRecoParticleAssociationCollection > >
using	ElectronReconstructionAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::ReconstructedParticleCollection >, algorithms::Output< edm4eic::ReconstructedParticleCollection > >
using	FarForwardNeutralsReconstructionAlgorithm = algorithms::Algorithm< algorithms::Input< const edm4eic::ClusterCollection, const edm4eic::ClusterCollection, const edm4eic::ClusterCollection, const edm4eic::ClusterCollection >, algorithms::Output< edm4eic::ReconstructedParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::ReconstructedParticleCollection > >
using	HadronicFinalStateAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::MCParticleCollection, edm4hep::MCParticleCollection, edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleAssociationCollection >, algorithms::Output< edm4eic::HadronicFinalStateCollection > >
using	InclusiveKinematicsDAAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::MCParticleCollection, edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::HadronicFinalStateCollection >, algorithms::Output< edm4eic::InclusiveKinematicsCollection > >
using	InclusiveKinematicsElectronAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::MCParticleCollection, edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::HadronicFinalStateCollection >, algorithms::Output< edm4eic::InclusiveKinematicsCollection > >
using	InclusiveKinematicsESigmaAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::MCParticleCollection, edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::HadronicFinalStateCollection >, algorithms::Output< edm4eic::InclusiveKinematicsCollection > >
using	InclusiveKinematicsJBAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::MCParticleCollection, edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::HadronicFinalStateCollection >, algorithms::Output< edm4eic::InclusiveKinematicsCollection > >
using	InclusiveKinematicsSigmaAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::MCParticleCollection, edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::HadronicFinalStateCollection >, algorithms::Output< edm4eic::InclusiveKinematicsCollection > >
using	InclusiveKinematicsTruthAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::MCParticleCollection >, algorithms::Output< edm4eic::InclusiveKinematicsCollection > >
using	JetOutputCollection = edm4eic::JetCollection
template<typename InputT >
using	JetReconstructionAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::EventHeaderCollection, typename InputT::collection_type >, algorithms::Output< JetOutputCollection > >
using	LambdaReconstructionAlgorithm = algorithms::Algorithm< algorithms::Input< const edm4eic::ReconstructedParticleCollection, const edm4eic::ReconstructedParticleCollection, const edm4eic::ReconstructedParticleCollection, const edm4eic::ReconstructedParticleCollection >, algorithms::Output< edm4eic::ReconstructedParticleCollection, edm4eic::ReconstructedParticleCollection > >
using	LGADHitCalibrationAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::RawTrackerHitCollection >, algorithms::Output< edm4eic::TrackerHitCollection > >
using	MatchClustersAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleAssociationCollection, edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleAssociationCollection >, algorithms::Output< edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleLinkCollection, edm4eic::MCRecoParticleAssociationCollection > >
using	MC2ReconstructedParticleAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::MCParticleCollection >, algorithms::Output< edm4eic::ReconstructedParticleCollection > >
using	PrimaryVerticesAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::VertexCollection >, algorithms::Output< edm4eic::VertexCollection > >
using	ScatteredElectronsEMinusPzAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::ReconstructedParticleCollection, edm4eic::ReconstructedParticleCollection >, algorithms::Output< edm4eic::ReconstructedParticleCollection > >
using	ScatteredElectronsTruthAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleAssociationCollection >, algorithms::Output< edm4eic::ReconstructedParticleCollection > >
using	SecondaryVerticesHelixAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::VertexCollection, edm4eic::ReconstructedParticleCollection >, algorithms::Output< edm4eic::VertexCollection > >
using	TrackClusterMatchAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::TrackSegmentCollection, edm4eic::ClusterCollection >, algorithms::Output< edm4eic::TrackClusterMatchCollection > >
using	TransformBreitFrameAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::MCParticleCollection, edm4eic::InclusiveKinematicsCollection, edm4eic::ReconstructedParticleCollection >, algorithms::Output< edm4eic::ReconstructedParticleCollection > >
using	UndoAfterBurnerAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::MCParticleCollection >, algorithms::Output< edm4hep::MCParticleCollection > >
using	ActsToTracksAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::Measurement2DCollection, edm4eic::TrackSeedCollection, Acts::ConstVectorMultiTrajectory, Acts::ConstVectorTrackContainer, std::optional< edm4eic::MCRecoTrackerHitAssociationCollection > >, algorithms::Output< edm4eic::TrajectoryCollection, edm4eic::TrackParametersCollection, edm4eic::TrackCollection, std::optional< edm4eic::MCRecoTrackParticleLinkCollection >, std::optional< edm4eic::MCRecoTrackParticleAssociationCollection > > >
using	ActsTrackMergerAlgorithm = algorithms::Algorithm< algorithms::Input< Acts::ConstVectorMultiTrajectory, Acts::ConstVectorTrackContainer, Acts::ConstVectorMultiTrajectory, Acts::ConstVectorTrackContainer >, algorithms::Output< Acts::ConstVectorMultiTrajectory *, Acts::ConstVectorTrackContainer * > >
using	AmbiguitySolverAlgorithm = algorithms::Algorithm< algorithms::Input< Acts::ConstVectorMultiTrajectory, Acts::ConstVectorTrackContainer >, algorithms::Output< Acts::ConstVectorMultiTrajectory *, Acts::ConstVectorTrackContainer * > >
using	CKFTrackingAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::TrackSeedCollection, edm4eic::Measurement2DCollection >, algorithms::Output< Acts::ConstVectorMultiTrajectory *, Acts::ConstVectorTrackContainer * > >
using	Stepper = Acts::EigenStepper<>
using	Navigator = Acts::Navigator
using	Propagator = Acts::Propagator< Stepper, Navigator >
using	CKF = Acts::CombinatorialKalmanFilter< Propagator, ActsExamples::TrackContainer >
using	IterativeVertexFinderAlgorithm = algorithms::Algorithm< algorithms::Input< Acts::ConstVectorMultiTrajectory, Acts::ConstVectorTrackContainer, edm4eic::ReconstructedParticleCollection >, algorithms::Output< edm4eic::VertexCollection > >
using	LGADHitClusteringAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::TrackerHitCollection >, algorithms::Output< edm4eic::Measurement2DCollection > >
using	MPGDHitReconstructionAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::RawTrackerHitCollection >, algorithms::Output< edm4eic::TrackerHitCollection > >
using	ImpactPointEstimator = Acts::ImpactPointEstimator
using	Linearizer = Acts::HelicalTrackLinearizer
using	VertexFitter = Acts::AdaptiveMultiVertexFitter
using	VertexFinder = Acts::AdaptiveMultiVertexFinder
using	VertexFinderOptions = Acts::VertexingOptions
using	SeedFinder = Acts::AdaptiveGridDensityVertexFinder
using	SecondaryVertexFinderAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::ReconstructedParticleCollection, Acts::ConstVectorMultiTrajectory, Acts::ConstVectorTrackContainer >, algorithms::Output< edm4eic::VertexCollection > >
using	SpacePointPtr = std::unique_ptr< SpacePoint >
using	SeedContainer = std::vector< Acts::Seed< SpacePoint > >
	Container of sim seed.
using	TrackerHitReconstructionAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::RawTrackerHitCollection >, algorithms::Output< edm4eic::TrackerHitCollection > >
using	TrackerMeasurementFromHitsAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::TrackerHitCollection >, algorithms::Output< edm4eic::Measurement2DCollection > >
using	TrackParamTruthInitAlgorithm = algorithms::Algorithm< algorithms::Input< edm4hep::EventHeaderCollection, edm4hep::MCParticleCollection >, algorithms::Output< edm4eic::TrackSeedCollection, edm4eic::TrackParametersCollection > >
using	TrackProjectorAlgorithm = algorithms::Algorithm< algorithms::Input< Acts::ConstVectorMultiTrajectory, Acts::ConstVectorTrackContainer, edm4eic::TrackCollection >, algorithms::Output< edm4eic::TrackSegmentCollection > >
using	ActsTrackPropagationResult = Acts::Result< std::unique_ptr< const Acts::BoundTrackParameters > >
using	TrackPropagationAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::TrackCollection, Acts::ConstVectorMultiTrajectory, Acts::ConstVectorTrackContainer >, algorithms::Output< edm4eic::TrackSegmentCollection > >
using	SurfaceConfig = std::variant< CylinderSurfaceConfig, DiscSurfaceConfig >
using	TrackSeedingAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::TrackerHitCollection >, algorithms::Output< edm4eic::TrackSeedCollection, edm4eic::TrackParametersCollection > >
using	TracksToParticlesAlgorithm = algorithms::Algorithm< algorithms::Input< edm4eic::TrackCollection, std::optional< edm4eic::MCRecoTrackParticleAssociationCollection > >, algorithms::Output< edm4eic::ReconstructedParticleCollection, std::optional< edm4eic::MCRecoParticleLinkCollection >, std::optional< edm4eic::MCRecoParticleAssociationCollection > > >
using	SpdlogToActsLevel_t = boost::bimap< spdlog::level::level_enum, Acts::Logging::Level >

Functions
std::istream &	operator>> (std::istream &in, ImagingTopoClusterConfig::ELayerMode &layerMode)
std::ostream &	operator<< (std::ostream &out, const ImagingTopoClusterConfig::ELayerMode &layerMode)
void	getLocalPosMom (const edm4hep::SimTrackerHit &sim_hit, const TGeoHMatrix &toModule, double *lpos, double *lmom)
bool	cExtrapolate (const double *lpos, const double *lmom, double rT, double *lext)
double	getRef2Cur (DetElement refVol, DetElement curVol)
bool	bExtrapolate (const double *lpos, const double *lmom, double zT, double *lext)
std::string	inconsistency (const edm4hep::EventHeader &event, unsigned int status, CellID cID, const double *lpos, const double *lmom)
std::string	oddity (const edm4hep::EventHeader &event, unsigned int status, double dist, CellID cID, const double *lpos, const double *lmom, CellID cJD, const double *lpoj, const double *lmoj)
double	outInDistance (int shape, int orientation, double lintos[][3], double louts[][3], double *lmom, double *lmoj)
void	flagUnexpected (const edm4hep::EventHeader &event, int shape, double expected, const edm4hep::SimTrackerHit &sim_hit, double *lpini, double *lpend, double *lpos, double *lmom)
std::ostream &	operator<< (std::ostream &os, const PhotoMultiplierHitDigiConfig &cfg)
std::istream &	operator>> (std::istream &in, SiliconChargeSharingConfig::ESigmaMode &sigmaMode)
std::ostream &	operator<< (std::ostream &out, const SiliconChargeSharingConfig::ESigmaMode &sigmaMode)
template<typename T >
Ort::Value	vec_to_tensor (std::vector< T > &data, const std::vector< std::int64_t > &shape)
template<class T >
auto	find_first_with_pdg (const T *parts, const std::set< int32_t > &pdg)
template<class T >
auto	find_first_with_status_pdg (const T *parts, const std::set< int32_t > &status, const std::set< int32_t > &pdg)
auto	find_first_beam_electron (const edm4hep::MCParticleCollection *mcparts)
auto	find_first_beam_hadron (const edm4hep::MCParticleCollection *mcparts)
auto	find_first_scattered_electron (const edm4hep::MCParticleCollection *mcparts)
auto	find_first_scattered_electron (const edm4eic::ReconstructedParticleCollection *rcparts)
template<typename Vector3 >
PxPyPzEVector	round_beam_four_momentum (const Vector3 &p_in, const float mass, const std::vector< float > &pz_set, const float crossing_angle=0.0)
LorentzRotation	determine_boost (PxPyPzEVector ei, PxPyPzEVector pi)
PxPyPzEVector	apply_boost (const LorentzRotation &tf, const PxPyPzEVector &part)
Acts::GreedyAmbiguityResolution::Config	transformConfig (const eicrecon::AmbiguitySolverConfig &cfg)
bool	operator== (SpacePoint a, SpacePoint b)
spdlog::level::level_enum	ParseLogLevel (const std::string &input)
std::string	LogLevelToString (spdlog::level::level_enum input)
Acts::Logging::Level	SpdlogToActsLevel (spdlog::level::level_enum input)
spdlog::level::level_enum	ActsToSpdlogLevel (Acts::Logging::Level input)
std::unique_ptr< const Acts::Logger >	getSpdlogLogger (const std::string &name, std::shared_ptr< spdlog::logger > log)

Variables
const std::vector< float >	electron_beam_pz_set {-5.0, -9.0, -10.0, -18.0}
const std::vector< float >	hadron_beam_pz_set {41.0, 100.0, 130.0, 250.0, 275.0}

Detailed Description

-client

Simple client for EICrecon managed PODIO processor.
Submits a file processing request and listens for a response.

Typedef Documentation

ActsToTracksAlgorithm

using eicrecon::ActsToTracksAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4eic::Measurement2DCollection, edm4eic::TrackSeedCollection, Acts::ConstVectorMultiTrajectory, Acts::ConstVectorTrackContainer, std::optional<edm4eic::MCRecoTrackerHitAssociationCollection> >, algorithms::Output<edm4eic::TrajectoryCollection, edm4eic::TrackParametersCollection, edm4eic::TrackCollection, std::optional<edm4eic::MCRecoTrackParticleLinkCollection>, std::optional<edm4eic::MCRecoTrackParticleAssociationCollection> >>

ActsTrackMergerAlgorithm

using eicrecon::ActsTrackMergerAlgorithm = typedef algorithms::Algorithm< algorithms::Input<Acts::ConstVectorMultiTrajectory, Acts::ConstVectorTrackContainer, Acts::ConstVectorMultiTrajectory, Acts::ConstVectorTrackContainer>, algorithms::Output<Acts::ConstVectorMultiTrajectory*, Acts::ConstVectorTrackContainer*> >

ActsTrackPropagationResult

using eicrecon::ActsTrackPropagationResult = typedef Acts::Result<std::unique_ptr<const Acts::BoundTrackParameters> >

AmbiguitySolverAlgorithm

using eicrecon::AmbiguitySolverAlgorithm = typedef algorithms::Algorithm< algorithms::Input<Acts::ConstVectorMultiTrajectory, Acts::ConstVectorTrackContainer>, algorithms::Output<Acts::ConstVectorMultiTrajectory*, Acts::ConstVectorTrackContainer*> >

CaloHit

using eicrecon::CaloHit = typedef edm4eic::CalorimeterHit

CalorimeterClusterRecoCoGAlgorithm

using eicrecon::CalorimeterClusterRecoCoGAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4eic::ProtoClusterCollection, std::optional<edm4eic::MCRecoCalorimeterHitLinkCollection>, std::optional<edm4eic::MCRecoCalorimeterHitAssociationCollection> >, algorithms::Output<edm4eic::ClusterCollection, std::optional<edm4eic::MCRecoClusterParticleLinkCollection>, std::optional<edm4eic::MCRecoClusterParticleAssociationCollection> >>

CalorimeterClusterShapeAlgorithm

using eicrecon::CalorimeterClusterShapeAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4eic::ClusterCollection, std::optional<edm4eic::MCRecoClusterParticleAssociationCollection> >, algorithms::Output<edm4eic::ClusterCollection, std::optional<edm4eic::MCRecoClusterParticleLinkCollection>, std::optional<edm4eic::MCRecoClusterParticleAssociationCollection> >>

Algorithm input/output.

CalorimeterHitDigiAlgorithm

using eicrecon::CalorimeterHitDigiAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::EventHeaderCollection, edm4hep::SimCalorimeterHitCollection>, algorithms::Output<edm4hep::RawCalorimeterHitCollection, edm4eic::MCRecoCalorimeterHitLinkCollection, edm4eic::MCRecoCalorimeterHitAssociationCollection> >

CalorimeterHitRecoAlgorithm

using eicrecon::CalorimeterHitRecoAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4hep::RawCalorimeterHitCollection>, algorithms::Output<edm4eic::CalorimeterHitCollection> >

CalorimeterHitsMergerAlgorithm

using eicrecon::CalorimeterHitsMergerAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::CalorimeterHitCollection>, algorithms::Output<edm4eic::CalorimeterHitCollection> >

CalorimeterIslandClusterAlgorithm

using eicrecon::CalorimeterIslandClusterAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::CalorimeterHitCollection>, algorithms::Output<edm4eic::ProtoClusterCollection> >

CalorimeterParticleIDPostMLAlgorithm

using eicrecon::CalorimeterParticleIDPostMLAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4eic::ClusterCollection, std::optional<edm4eic::MCRecoClusterParticleAssociationCollection>, edm4eic::TensorCollection>, algorithms::Output<edm4eic::ClusterCollection, std::optional<edm4eic::MCRecoClusterParticleLinkCollection>, std::optional<edm4eic::MCRecoClusterParticleAssociationCollection>, edm4hep::ParticleIDCollection> >

CalorimeterParticleIDPreMLAlgorithm

using eicrecon::CalorimeterParticleIDPreMLAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4eic::ClusterCollection, std::optional<edm4eic::MCRecoClusterParticleAssociationCollection> >, algorithms::Output<edm4eic::TensorCollection, std::optional<edm4eic::TensorCollection> >>

CalorimeterTruthClusteringAlgorithm

using eicrecon::CalorimeterTruthClusteringAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4eic::CalorimeterHitCollection, edm4hep::SimCalorimeterHitCollection>, algorithms::Output<edm4eic::ProtoClusterCollection> >

CALOROCDigitizationAlgorithm

using eicrecon::CALOROCDigitizationAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::SimPulseCollection>, algorithms::Output<edm4eic::RawCALOROCHitCollection> >

CFDROCDigitizationAlgorithm

using eicrecon::CFDROCDigitizationAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4hep::RawTimeSeriesCollection>, algorithms::Output<edm4eic::RawTrackerHitCollection> >

ChargedCandidateMakerAlgorithm

using eicrecon::ChargedCandidateMakerAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::TrackClusterMatchCollection>, algorithms::Output<edm4eic::ReconstructedParticleCollection> >

ChargedMCParticleSelectorAlgorithm

using eicrecon::ChargedMCParticleSelectorAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4hep::MCParticleCollection>, algorithms::Output<edm4hep::MCParticleCollection> >

ChargedReconstructedParticleSelectorAlgorithm

using eicrecon::ChargedReconstructedParticleSelectorAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::ReconstructedParticleCollection>, algorithms::Output<edm4eic::ReconstructedParticleCollection> >

CKF

using eicrecon::CKF = typedef Acts::CombinatorialKalmanFilter<Propagator, ActsExamples::TrackContainer>

CKFTrackingAlgorithm

using eicrecon::CKFTrackingAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4eic::TrackSeedCollection, edm4eic::Measurement2DCollection>, algorithms::Output<Acts::ConstVectorMultiTrajectory*, Acts::ConstVectorTrackContainer*> >

ClustersToParticlesAlgorithm

using eicrecon::ClustersToParticlesAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleAssociationCollection>, algorithms::Output<edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleLinkCollection, edm4eic::MCRecoParticleAssociationCollection> >

ClustersWithAssociations

using eicrecon::ClustersWithAssociations = typedef std::pair<std::unique_ptr<edm4eic::ClusterCollection>, std::unique_ptr<edm4eic::MCRecoClusterParticleAssociationCollection> >

CollectionCollectorAlgorithm

template<class T >

using eicrecon::CollectionCollectorAlgorithm = typedef algorithms::Algorithm<typename algorithms::Input<std::vector<const T> >, typename algorithms::Output<T> >

EICROCDigitizationAlgorithm

using eicrecon::EICROCDigitizationAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4hep::RawTimeSeriesCollection>, algorithms::Output<edm4eic::RawTrackerHitCollection> >

ElectronReconstructionAlgorithm

using eicrecon::ElectronReconstructionAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::ReconstructedParticleCollection>, algorithms::Output<edm4eic::ReconstructedParticleCollection> >

EnergyPositionClusterMergerAlgorithm

using eicrecon::EnergyPositionClusterMergerAlgorithm = typedef algorithms::Algorithm< algorithms::Input< edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleAssociationCollection, edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleAssociationCollection>, algorithms::Output<edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleLinkCollection, edm4eic::MCRecoClusterParticleAssociationCollection> >

FarDetectorLinearTrackingAlgorithm

using eicrecon::FarDetectorLinearTrackingAlgorithm = typedef algorithms::Algorithm< algorithms::Input<std::vector<edm4eic::Measurement2DCollection>, std::optional<edm4eic::MCRecoTrackerHitLinkCollection>, std::optional<edm4eic::MCRecoTrackerHitAssociationCollection> >, algorithms::Output<edm4eic::TrackCollection, std::optional<edm4eic::MCRecoTrackParticleLinkCollection>, std::optional<edm4eic::MCRecoTrackParticleAssociationCollection> >>

FarDetectorTrackerClusterAlgorithm

using eicrecon::FarDetectorTrackerClusterAlgorithm = typedef algorithms::Algorithm<algorithms::Input<std::vector<edm4eic::TrackerHitCollection> >, algorithms::Output<std::vector<edm4eic::Measurement2DCollection> >>

FarDetectorTransportationPostMLAlgorithm

using eicrecon::FarDetectorTransportationPostMLAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4eic::TensorCollection, std::optional<edm4eic::MCRecoTrackParticleAssociationCollection>, std::optional<edm4hep::MCParticleCollection> >, algorithms::Output<edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleLinkCollection, edm4eic::MCRecoParticleAssociationCollection> >

FarDetectorTransportationPreMLAlgorithm

using eicrecon::FarDetectorTransportationPreMLAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4eic::TrackCollection, std::optional<edm4eic::MCRecoTrackParticleAssociationCollection>, std::optional<edm4hep::MCParticleCollection> >, algorithms::Output<edm4eic::TensorCollection, std::optional<edm4eic::TensorCollection> >>

FarForwardNeutralsReconstructionAlgorithm

using eicrecon::FarForwardNeutralsReconstructionAlgorithm = typedef algorithms::Algorithm< algorithms::Input<const edm4eic::ClusterCollection, const edm4eic::ClusterCollection, const edm4eic::ClusterCollection, const edm4eic::ClusterCollection>, algorithms::Output< edm4eic::ReconstructedParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::ReconstructedParticleCollection> >

FilterMatchingAlgorithm

template<class ToFilterObjectT , class FilterByObjectT >

using eicrecon::FilterMatchingAlgorithm = typedef algorithms::Algorithm<typename algorithms::Input<typename ToFilterObjectT::collection_type, typename FilterByObjectT::collection_type>, typename algorithms::Output<typename ToFilterObjectT::collection_type, typename ToFilterObjectT::collection_type> >

HadronicFinalStateAlgorithm

using eicrecon::HadronicFinalStateAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::MCParticleCollection, edm4hep::MCParticleCollection, edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleAssociationCollection>, algorithms::Output<edm4eic::HadronicFinalStateCollection> >

HEXPLITAlgorithm

using eicrecon::HEXPLITAlgorithm = typedef algorithms::Algorithm<algorithms::Input<const edm4eic::CalorimeterHitCollection>, algorithms::Output<edm4eic::CalorimeterHitCollection> >

ImagingClusterRecoAlgorithm

using eicrecon::ImagingClusterRecoAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::ProtoClusterCollection, edm4eic::MCRecoCalorimeterHitLinkCollection, edm4eic::MCRecoCalorimeterHitAssociationCollection>, algorithms::Output<edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleLinkCollection, edm4eic::MCRecoClusterParticleAssociationCollection, edm4eic::ClusterCollection> >

ImagingTopoClusterAlgorithm

using eicrecon::ImagingTopoClusterAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::CalorimeterHitCollection>, algorithms::Output<edm4eic::ProtoClusterCollection> >

ImpactPointEstimator

using eicrecon::ImpactPointEstimator = typedef Acts::ImpactPointEstimator

InclusiveKinematicsDAAlgorithm

using eicrecon::InclusiveKinematicsDAAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::MCParticleCollection, edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::HadronicFinalStateCollection>, algorithms::Output<edm4eic::InclusiveKinematicsCollection> >

InclusiveKinematicsElectronAlgorithm

using eicrecon::InclusiveKinematicsElectronAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::MCParticleCollection, edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::HadronicFinalStateCollection>, algorithms::Output<edm4eic::InclusiveKinematicsCollection> >

InclusiveKinematicsESigmaAlgorithm

using eicrecon::InclusiveKinematicsESigmaAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::MCParticleCollection, edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::HadronicFinalStateCollection>, algorithms::Output<edm4eic::InclusiveKinematicsCollection> >

InclusiveKinematicsJBAlgorithm

using eicrecon::InclusiveKinematicsJBAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::MCParticleCollection, edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::HadronicFinalStateCollection>, algorithms::Output<edm4eic::InclusiveKinematicsCollection> >

InclusiveKinematicsMLAlgorithm

using eicrecon::InclusiveKinematicsMLAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::InclusiveKinematicsCollection, edm4eic::InclusiveKinematicsCollection>, algorithms::Output<edm4eic::InclusiveKinematicsCollection> >

InclusiveKinematicsSigmaAlgorithm

using eicrecon::InclusiveKinematicsSigmaAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::MCParticleCollection, edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::HadronicFinalStateCollection>, algorithms::Output<edm4eic::InclusiveKinematicsCollection> >

InclusiveKinematicsTruthAlgorithm

using eicrecon::InclusiveKinematicsTruthAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4hep::MCParticleCollection>, algorithms::Output<edm4eic::InclusiveKinematicsCollection> >

IrtCherenkovParticleIDAlgorithm

using eicrecon::IrtCherenkovParticleIDAlgorithm = typedef algorithms::Algorithm< algorithms::Input<const edm4eic::TrackSegmentCollection, const edm4eic::TrackSegmentCollection, const edm4eic::TrackSegmentCollection, const edm4eic::RawTrackerHitCollection, const edm4eic::MCRecoTrackerHitAssociationCollection>, algorithms::Output<edm4eic::CherenkovParticleIDCollection, edm4eic::CherenkovParticleIDCollection> >

IterativeVertexFinderAlgorithm

using eicrecon::IterativeVertexFinderAlgorithm = typedef algorithms::Algorithm< algorithms::Input<Acts::ConstVectorMultiTrajectory, Acts::ConstVectorTrackContainer, edm4eic::ReconstructedParticleCollection>, algorithms::Output<edm4eic::VertexCollection> >

JetOutputCollection

using eicrecon::JetOutputCollection = typedef edm4eic::JetCollection

JetReconstructionAlgorithm

template<typename InputT >

using eicrecon::JetReconstructionAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::EventHeaderCollection, typename InputT::collection_type>, algorithms::Output<JetOutputCollection> >

LambdaReconstructionAlgorithm

using eicrecon::LambdaReconstructionAlgorithm = typedef algorithms::Algorithm< algorithms::Input<const edm4eic::ReconstructedParticleCollection, const edm4eic::ReconstructedParticleCollection, const edm4eic::ReconstructedParticleCollection, const edm4eic::ReconstructedParticleCollection>, algorithms::Output<edm4eic::ReconstructedParticleCollection, edm4eic::ReconstructedParticleCollection> >

LGADHitCalibrationAlgorithm

using eicrecon::LGADHitCalibrationAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::RawTrackerHitCollection>, algorithms::Output<edm4eic::TrackerHitCollection> >

LGADHitClusteringAlgorithm

using eicrecon::LGADHitClusteringAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::TrackerHitCollection>, algorithms::Output<edm4eic::Measurement2DCollection> >

Linearizer

using eicrecon::Linearizer = typedef Acts::HelicalTrackLinearizer

MapFunc

using eicrecon::MapFunc = typedef std::function<int(const edm4eic::CalorimeterHit&)>

MatchClustersAlgorithm

using eicrecon::MatchClustersAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleAssociationCollection, edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleAssociationCollection>, algorithms::Output<edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleLinkCollection, edm4eic::MCRecoParticleAssociationCollection> >

MatchToRICHPIDAlgorithm

using eicrecon::MatchToRICHPIDAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleAssociationCollection, edm4eic::CherenkovParticleIDCollection>, algorithms::Output<edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleLinkCollection, edm4eic::MCRecoParticleAssociationCollection, edm4hep::ParticleIDCollection> >

MatrixTransferStaticAlgorithm

using eicrecon::MatrixTransferStaticAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::MCParticleCollection, edm4eic::TrackerHitCollection>, algorithms::Output<edm4eic::ReconstructedParticleCollection> >

MC2ReconstructedParticleAlgorithm

using eicrecon::MC2ReconstructedParticleAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4hep::MCParticleCollection>, algorithms::Output<edm4eic::ReconstructedParticleCollection> >

MergeMap

using eicrecon::MergeMap = typedef std::unordered_map<uint64_t, std::vector<std::size_t> >

MergeParticleIDAlgorithm

using eicrecon::MergeParticleIDAlgorithm = typedef algorithms::Algorithm< algorithms::Input<std::vector<const edm4eic::CherenkovParticleIDCollection> >, algorithms::Output<edm4eic::CherenkovParticleIDCollection> >

MergeTracksAlgorithm

using eicrecon::MergeTracksAlgorithm = typedef algorithms::Algorithm<algorithms::Input<std::vector<const edm4eic::TrackSegmentCollection> >, algorithms::Output<edm4eic::TrackSegmentCollection> >

MPGDHitReconstructionAlgorithm

using eicrecon::MPGDHitReconstructionAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::RawTrackerHitCollection>, algorithms::Output<edm4eic::TrackerHitCollection> >

MPGDTrackerDigiAlgorithm

using eicrecon::MPGDTrackerDigiAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::EventHeaderCollection, edm4hep::SimTrackerHitCollection>, algorithms::Output<edm4eic::RawTrackerHitCollection, edm4eic::MCRecoTrackerHitLinkCollection, edm4eic::MCRecoTrackerHitAssociationCollection> >

MutablePulseType

using eicrecon::MutablePulseType = typedef edm4hep::MutableTimeSeries

Navigator

using eicrecon::Navigator = typedef Acts::Navigator

ONNXInferenceAlgorithm

using eicrecon::ONNXInferenceAlgorithm = typedef algorithms::Algorithm<algorithms::Input<std::vector<edm4eic::TensorCollection> >, algorithms::Output<std::vector<edm4eic::TensorCollection> >>

PhotoMultiplierHitDigiAlgorithm

using eicrecon::PhotoMultiplierHitDigiAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::EventHeaderCollection, edm4hep::SimTrackerHitCollection>, algorithms::Output<edm4eic::RawTrackerHitCollection, edm4eic::MCRecoTrackerHitLinkCollection, edm4eic::MCRecoTrackerHitAssociationCollection> >

PIDLookupAlgorithm

using eicrecon::PIDLookupAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::EventHeaderCollection, edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleAssociationCollection>, algorithms::Output<edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleLinkCollection, edm4eic::MCRecoParticleAssociationCollection, edm4hep::ParticleIDCollection> >

PolynomialMatrixReconstructionAlgorithm

using eicrecon::PolynomialMatrixReconstructionAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::MCParticleCollection, edm4eic::TrackerHitCollection>, algorithms::Output<edm4eic::ReconstructedParticleCollection> >

PrimaryVerticesAlgorithm

using eicrecon::PrimaryVerticesAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::VertexCollection>, algorithms::Output<edm4eic::VertexCollection> >

Propagator

using eicrecon::Propagator = typedef Acts::Propagator<Stepper, Navigator>

PulseCombinerAlgorithm

using eicrecon::PulseCombinerAlgorithm = typedef algorithms::Algorithm<algorithms::Input<PulseType::collection_type>, algorithms::Output<PulseType::collection_type> >

PulseGenerationAlgorithm

template<typename HitT >

using eicrecon::PulseGenerationAlgorithm = typedef algorithms::Algorithm<algorithms::Input<typename HitT::collection_type>, algorithms::Output<PulseType::collection_type> >

PulseNoiseAlgorithm

using eicrecon::PulseNoiseAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::EventHeaderCollection, PulseType::collection_type>, algorithms::Output<PulseType::collection_type> >

PulseType

typedef edm4hep::TimeSeries eicrecon::PulseType

RefField

using eicrecon::RefField = typedef std::pair<std::string, int>

ScatteredElectronsEMinusPzAlgorithm

using eicrecon::ScatteredElectronsEMinusPzAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::ReconstructedParticleCollection, edm4eic::ReconstructedParticleCollection>, algorithms::Output<edm4eic::ReconstructedParticleCollection> >

ScatteredElectronsTruthAlgorithm

using eicrecon::ScatteredElectronsTruthAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::MCParticleCollection, edm4eic::ReconstructedParticleCollection, edm4eic::MCRecoParticleAssociationCollection>, algorithms::Output<edm4eic::ReconstructedParticleCollection> >

SecondaryVertexFinderAlgorithm

using eicrecon::SecondaryVertexFinderAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4eic::ReconstructedParticleCollection, Acts::ConstVectorMultiTrajectory, Acts::ConstVectorTrackContainer>, algorithms::Output<edm4eic::VertexCollection> >

SecondaryVerticesHelixAlgorithm

using eicrecon::SecondaryVerticesHelixAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4eic::VertexCollection, edm4eic::ReconstructedParticleCollection>, algorithms::Output<edm4eic::VertexCollection> >

SeedContainer

using eicrecon::SeedContainer = typedef std::vector<Acts::Seed<SpacePoint> >

Container of sim seed.

SeedFinder

using eicrecon::SeedFinder = typedef Acts::AdaptiveGridDensityVertexFinder

SiliconChargeSharingAlgorithm

using eicrecon::SiliconChargeSharingAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4hep::SimTrackerHitCollection>, algorithms::Output<edm4hep::SimTrackerHitCollection> >

SiliconPulseDiscretizationAlgorithm

using eicrecon::SiliconPulseDiscretizationAlgorithm = typedef algorithms::Algorithm<algorithms::Input<PulseType::collection_type>, algorithms::Output<edm4hep::RawTimeSeriesCollection> >

SiliconTrackerDigiAlgorithm

using eicrecon::SiliconTrackerDigiAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::EventHeaderCollection, edm4hep::SimTrackerHitCollection>, algorithms::Output<edm4eic::RawTrackerHitCollection, edm4eic::MCRecoTrackerHitLinkCollection, edm4eic::MCRecoTrackerHitAssociationCollection> >

SimCalorimeterHitProcessorAlgorithm

using eicrecon::SimCalorimeterHitProcessorAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4hep::SimCalorimeterHitCollection>, algorithms::Output<edm4hep::SimCalorimeterHitCollection, edm4hep::CaloHitContributionCollection> >

SpacePointPtr

using eicrecon::SpacePointPtr = typedef std::unique_ptr<SpacePoint>

SpdlogToActsLevel_t

using eicrecon::SpdlogToActsLevel_t = typedef boost::bimap<spdlog::level::level_enum, Acts::Logging::Level>

Stepper

using eicrecon::Stepper = typedef Acts::EigenStepper<>

SubDivideCollectionAlgorithm

template<class T >

using eicrecon::SubDivideCollectionAlgorithm = typedef algorithms::Algorithm<typename algorithms::Input<const typename T::collection_type>, typename algorithms::Output<std::vector<typename T::collection_type> >>

SurfaceConfig

using eicrecon::SurfaceConfig = typedef std::variant<CylinderSurfaceConfig, DiscSurfaceConfig>

TrackClusterMatchAlgorithm

using eicrecon::TrackClusterMatchAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4eic::TrackSegmentCollection, edm4eic::ClusterCollection>, algorithms::Output<edm4eic::TrackClusterMatchCollection> >

TrackClusterMergeSplitterAlgorithm

using eicrecon::TrackClusterMergeSplitterAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4eic::TrackClusterMatchCollection, edm4eic::ClusterCollection, edm4eic::TrackSegmentCollection>, algorithms::Output<edm4eic::ProtoClusterCollection, edm4eic::TrackProtoClusterLinkCollection> >

TrackerHitReconstructionAlgorithm

using eicrecon::TrackerHitReconstructionAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::RawTrackerHitCollection>, algorithms::Output<edm4eic::TrackerHitCollection> >

TrackerMeasurementFromHitsAlgorithm

using eicrecon::TrackerMeasurementFromHitsAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4eic::TrackerHitCollection>, algorithms::Output<edm4eic::Measurement2DCollection> >

TrackParamTruthInitAlgorithm

using eicrecon::TrackParamTruthInitAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::EventHeaderCollection, edm4hep::MCParticleCollection>, algorithms::Output<edm4eic::TrackSeedCollection, edm4eic::TrackParametersCollection> >

TrackProjectorAlgorithm

using eicrecon::TrackProjectorAlgorithm = typedef algorithms::Algorithm< algorithms::Input<Acts::ConstVectorMultiTrajectory, Acts::ConstVectorTrackContainer, edm4eic::TrackCollection>, algorithms::Output<edm4eic::TrackSegmentCollection> >

TrackPropagationAlgorithm

using eicrecon::TrackPropagationAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4eic::TrackCollection, Acts::ConstVectorMultiTrajectory, Acts::ConstVectorTrackContainer>, algorithms::Output<edm4eic::TrackSegmentCollection> >

TrackProtoClusterMatchPromoterAlgorithm

using eicrecon::TrackProtoClusterMatchPromoterAlgorithm = typedef algorithms::Algorithm< typename algorithms::Input<edm4eic::TrackProtoClusterLinkCollection, edm4eic::ProtoClusterCollection, edm4eic::ClusterCollection>, typename algorithms::Output<edm4eic::TrackClusterMatchCollection> >

TrackSeedingAlgorithm

using eicrecon::TrackSeedingAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4eic::TrackerHitCollection>, algorithms::Output<edm4eic::TrackSeedCollection, edm4eic::TrackParametersCollection> >

TracksToParticlesAlgorithm

using eicrecon::TracksToParticlesAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4eic::TrackCollection, std::optional<edm4eic::MCRecoTrackParticleAssociationCollection> >, algorithms::Output<edm4eic::ReconstructedParticleCollection, std::optional<edm4eic::MCRecoParticleLinkCollection>, std::optional<edm4eic::MCRecoParticleAssociationCollection> >>

TransformBreitFrameAlgorithm

using eicrecon::TransformBreitFrameAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::MCParticleCollection, edm4eic::InclusiveKinematicsCollection, edm4eic::ReconstructedParticleCollection>, algorithms::Output<edm4eic::ReconstructedParticleCollection> >

TruthEnergyPositionClusterMergerAlgorithm

using eicrecon::TruthEnergyPositionClusterMergerAlgorithm = typedef algorithms::Algorithm< algorithms::Input<edm4hep::MCParticleCollection, edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleAssociationCollection, edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleAssociationCollection>, algorithms::Output<edm4eic::ClusterCollection, edm4eic::MCRecoClusterParticleLinkCollection, edm4eic::MCRecoClusterParticleAssociationCollection> >

UndoAfterBurnerAlgorithm

using eicrecon::UndoAfterBurnerAlgorithm = typedef algorithms::Algorithm<algorithms::Input<edm4hep::MCParticleCollection>, algorithms::Output<edm4hep::MCParticleCollection> >

VertexFinder

using eicrecon::VertexFinder = typedef Acts::AdaptiveMultiVertexFinder

VertexFinderOptions

using eicrecon::VertexFinderOptions = typedef Acts::VertexingOptions

VertexFitter

using eicrecon::VertexFitter = typedef Acts::AdaptiveMultiVertexFitter

Function Documentation

ActsToSpdlogLevel()

spdlog::level::level_enum eicrecon::ActsToSpdlogLevel ( Acts::Logging::Level  input )

inline

apply_boost()

PxPyPzEVector eicrecon::apply_boost ( const LorentzRotation &  tf, const PxPyPzEVector &  part  )

inline

bExtrapolate()

bool eicrecon::bExtrapolate	(	const double *	lpos,
		const double *	lmom,
		double	zT,
		double *	lext
	)

cExtrapolate()

bool eicrecon::cExtrapolate	(	const double *	lpos,
		const double *	lmom,
		double	rT,
		double *	lext
	)

determine_boost()

LorentzRotation eicrecon::determine_boost ( PxPyPzEVector  ei, PxPyPzEVector  pi  )

inline

find_first_beam_electron()

auto eicrecon::find_first_beam_electron ( const edm4hep::MCParticleCollection *  mcparts )

inline

find_first_beam_hadron()

auto eicrecon::find_first_beam_hadron ( const edm4hep::MCParticleCollection *  mcparts )

inline

find_first_scattered_electron() [1/2]

auto eicrecon::find_first_scattered_electron ( const edm4eic::ReconstructedParticleCollection *  rcparts )

inline

find_first_scattered_electron() [2/2]

auto eicrecon::find_first_scattered_electron ( const edm4hep::MCParticleCollection *  mcparts )

inline

find_first_with_pdg()

template<class T >

auto eicrecon::find_first_with_pdg	(	const T *	parts,
		const std::set< int32_t > &	pdg
	)

find_first_with_status_pdg()

template<class T >

auto eicrecon::find_first_with_status_pdg	(	const T *	parts,
		const std::set< int32_t > &	status,
		const std::set< int32_t > &	pdg
	)

flagUnexpected()

void eicrecon::flagUnexpected	(	const edm4hep::EventHeader &	event,
		int	shape,
		double	expected,
		const edm4hep::SimTrackerHit &	sim_hit,
		double *	lpini,
		double *	lpend,
		double *	lpos,
		double *	lmom
	)

getLocalPosMom()

void eicrecon::getLocalPosMom	(	const edm4hep::SimTrackerHit &	sim_hit,
		const TGeoHMatrix &	toModule,
		double *	lpos,
		double *	lmom
	)

getRef2Cur()

double eicrecon::getRef2Cur	(	DetElement	refVol,
		DetElement	curVol
	)

getSpdlogLogger()

std::unique_ptr< const Acts::Logger > eicrecon::getSpdlogLogger ( const std::string &  name, std::shared_ptr< spdlog::logger >  log  )

inline

inconsistency()

std::string eicrecon::inconsistency	(	const edm4hep::EventHeader &	event,
		unsigned int	status,
		CellID	cID,
		const double *	lpos,
		const double *	lmom
	)

LogLevelToString()

std::string eicrecon::LogLevelToString ( spdlog::level::level_enum  input )

inline

oddity()

std::string eicrecon::oddity	(	const edm4hep::EventHeader &	event,
		unsigned int	status,
		double	dist,
		CellID	cID,
		const double *	lpos,
		const double *	lmom,
		CellID	cJD,
		const double *	lpoj,
		const double *	lmoj
	)

operator<<() [1/3]

std::ostream & eicrecon::operator<<	(	std::ostream &	os,
		const PhotoMultiplierHitDigiConfig &	cfg
	)

operator<<() [2/3]

std::ostream & eicrecon::operator<<	(	std::ostream &	out,
		const ImagingTopoClusterConfig::ELayerMode &	layerMode
	)

operator<<() [3/3]

std::ostream & eicrecon::operator<<	(	std::ostream &	out,
		const SiliconChargeSharingConfig::ESigmaMode &	sigmaMode
	)

operator==()

bool eicrecon::operator== ( SpacePoint  a, SpacePoint  b  )

inline

operator>>() [1/2]

std::istream & eicrecon::operator>>	(	std::istream &	in,
		ImagingTopoClusterConfig::ELayerMode &	layerMode
	)

operator>>() [2/2]

std::istream & eicrecon::operator>>	(	std::istream &	in,
		SiliconChargeSharingConfig::ESigmaMode &	sigmaMode
	)

outInDistance()

double eicrecon::outInDistance	(	int	shape,
		int	orientation,
		double	lintos[][3],
		double	louts[][3],
		double *	lmom,
		double *	lmoj
	)

ParseLogLevel()

spdlog::level::level_enum eicrecon::ParseLogLevel ( const std::string &  input )

inline

round_beam_four_momentum()

template<typename Vector3 >

PxPyPzEVector eicrecon::round_beam_four_momentum	(	const Vector3 &	p_in,
		const float	mass,
		const std::vector< float > &	pz_set,
		const float	crossing_angle = 0.0
	)

SpdlogToActsLevel()

Acts::Logging::Level eicrecon::SpdlogToActsLevel ( spdlog::level::level_enum  input )

inline

transformConfig()

Acts::GreedyAmbiguityResolution::Config eicrecon::transformConfig

(

const eicrecon::AmbiguitySolverConfig &

cfg

)

vec_to_tensor()

template<typename T >

Ort::Value eicrecon::vec_to_tensor	(	std::vector< T > &	data,
		const std::vector< std::int64_t > &	shape
	)

Variable Documentation

electron_beam_pz_set

const std::vector<float> eicrecon::electron_beam_pz_set {-5.0, -9.0, -10.0, -18.0}

inline

hadron_beam_pz_set

const std::vector<float> eicrecon::hadron_beam_pz_set {41.0, 100.0, 130.0, 250.0, 275.0}

inline