EIC code displayed by LXR master/​include/​EICrecon/​services/​io/​podio/​datamodel_glue.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:55:45

 
 // This file automatically generated by the make_datamodel.py script
 #pragma once
 
 #include <stdexcept>
 #include <podio/podioVersion.h>
 #include <podio/CollectionBase.h>
 
 
 template <typename T> struct PodioTypeMap {
 #if podio_VERSION >= PODIO_VERSION(0, 17, 0)
     using collection_t = typename T::collection_type;
     using mutable_t = typename T::mutable_type;
 #endif
 };
 
 namespace edm4hep {
     class TrackerHitPlane;
     class TrackerHitPlaneCollection;
     class MutableTrackerHitPlane;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::TrackerHitPlane> {
     using collection_t = edm4hep::TrackerHitPlaneCollection;
     using mutable_t = edm4hep::MutableTrackerHitPlane;
 };
 #endif
 namespace edm4hep {
     class MCRecoTrackerHitPlaneAssociation;
     class MCRecoTrackerHitPlaneAssociationCollection;
     class MutableMCRecoTrackerHitPlaneAssociation;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::MCRecoTrackerHitPlaneAssociation> {
     using collection_t = edm4hep::MCRecoTrackerHitPlaneAssociationCollection;
     using mutable_t = edm4hep::MutableMCRecoTrackerHitPlaneAssociation;
 };
 #endif
 namespace edm4hep {
     class CaloHitContribution;
     class CaloHitContributionCollection;
     class MutableCaloHitContribution;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::CaloHitContribution> {
     using collection_t = edm4hep::CaloHitContributionCollection;
     using mutable_t = edm4hep::MutableCaloHitContribution;
 };
 #endif
 namespace edm4hep {
     class RecoParticleVertexAssociation;
     class RecoParticleVertexAssociationCollection;
     class MutableRecoParticleVertexAssociation;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::RecoParticleVertexAssociation> {
     using collection_t = edm4hep::RecoParticleVertexAssociationCollection;
     using mutable_t = edm4hep::MutableRecoParticleVertexAssociation;
 };
 #endif
 namespace edm4hep {
     class MCRecoCaloAssociation;
     class MCRecoCaloAssociationCollection;
     class MutableMCRecoCaloAssociation;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::MCRecoCaloAssociation> {
     using collection_t = edm4hep::MCRecoCaloAssociationCollection;
     using mutable_t = edm4hep::MutableMCRecoCaloAssociation;
 };
 #endif
 namespace edm4hep {
     class Cluster;
     class ClusterCollection;
     class MutableCluster;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::Cluster> {
     using collection_t = edm4hep::ClusterCollection;
     using mutable_t = edm4hep::MutableCluster;
 };
 #endif
 namespace edm4hep {
     class SimCalorimeterHit;
     class SimCalorimeterHitCollection;
     class MutableSimCalorimeterHit;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::SimCalorimeterHit> {
     using collection_t = edm4hep::SimCalorimeterHitCollection;
     using mutable_t = edm4hep::MutableSimCalorimeterHit;
 };
 #endif
 namespace edm4hep {
     class MCRecoTrackerAssociation;
     class MCRecoTrackerAssociationCollection;
     class MutableMCRecoTrackerAssociation;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::MCRecoTrackerAssociation> {
     using collection_t = edm4hep::MCRecoTrackerAssociationCollection;
     using mutable_t = edm4hep::MutableMCRecoTrackerAssociation;
 };
 #endif
 namespace edm4hep {
     class ParticleID;
     class ParticleIDCollection;
     class MutableParticleID;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::ParticleID> {
     using collection_t = edm4hep::ParticleIDCollection;
     using mutable_t = edm4hep::MutableParticleID;
 };
 #endif
 namespace edm4hep {
     class Vertex;
     class VertexCollection;
     class MutableVertex;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::Vertex> {
     using collection_t = edm4hep::VertexCollection;
     using mutable_t = edm4hep::MutableVertex;
 };
 #endif
 namespace edm4hep {
     class RecDqdx;
     class RecDqdxCollection;
     class MutableRecDqdx;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::RecDqdx> {
     using collection_t = edm4hep::RecDqdxCollection;
     using mutable_t = edm4hep::MutableRecDqdx;
 };
 #endif
 namespace edm4hep {
     class SimPrimaryIonizationCluster;
     class SimPrimaryIonizationClusterCollection;
     class MutableSimPrimaryIonizationCluster;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::SimPrimaryIonizationCluster> {
     using collection_t = edm4hep::SimPrimaryIonizationClusterCollection;
     using mutable_t = edm4hep::MutableSimPrimaryIonizationCluster;
 };
 #endif
 namespace edm4hep {
     class RawTimeSeries;
     class RawTimeSeriesCollection;
     class MutableRawTimeSeries;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::RawTimeSeries> {
     using collection_t = edm4hep::RawTimeSeriesCollection;
     using mutable_t = edm4hep::MutableRawTimeSeries;
 };
 #endif
 namespace edm4hep {
     class MCRecoTrackParticleAssociation;
     class MCRecoTrackParticleAssociationCollection;
     class MutableMCRecoTrackParticleAssociation;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::MCRecoTrackParticleAssociation> {
     using collection_t = edm4hep::MCRecoTrackParticleAssociationCollection;
     using mutable_t = edm4hep::MutableMCRecoTrackParticleAssociation;
 };
 #endif
 namespace edm4hep {
     class RecIonizationCluster;
     class RecIonizationClusterCollection;
     class MutableRecIonizationCluster;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::RecIonizationCluster> {
     using collection_t = edm4hep::RecIonizationClusterCollection;
     using mutable_t = edm4hep::MutableRecIonizationCluster;
 };
 #endif
 namespace edm4hep {
     class RawCalorimeterHit;
     class RawCalorimeterHitCollection;
     class MutableRawCalorimeterHit;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::RawCalorimeterHit> {
     using collection_t = edm4hep::RawCalorimeterHitCollection;
     using mutable_t = edm4hep::MutableRawCalorimeterHit;
 };
 #endif
 namespace edm4hep {
     class CalorimeterHit;
     class CalorimeterHitCollection;
     class MutableCalorimeterHit;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::CalorimeterHit> {
     using collection_t = edm4hep::CalorimeterHitCollection;
     using mutable_t = edm4hep::MutableCalorimeterHit;
 };
 #endif
 namespace edm4hep {
     class Track;
     class TrackCollection;
     class MutableTrack;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::Track> {
     using collection_t = edm4hep::TrackCollection;
     using mutable_t = edm4hep::MutableTrack;
 };
 #endif
 namespace edm4hep {
     class EventHeader;
     class EventHeaderCollection;
     class MutableEventHeader;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::EventHeader> {
     using collection_t = edm4hep::EventHeaderCollection;
     using mutable_t = edm4hep::MutableEventHeader;
 };
 #endif
 namespace edm4hep {
     class MCParticle;
     class MCParticleCollection;
     class MutableMCParticle;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::MCParticle> {
     using collection_t = edm4hep::MCParticleCollection;
     using mutable_t = edm4hep::MutableMCParticle;
 };
 #endif
 namespace edm4hep {
     class ReconstructedParticle;
     class ReconstructedParticleCollection;
     class MutableReconstructedParticle;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::ReconstructedParticle> {
     using collection_t = edm4hep::ReconstructedParticleCollection;
     using mutable_t = edm4hep::MutableReconstructedParticle;
 };
 #endif
 namespace edm4hep {
     class MCRecoParticleAssociation;
     class MCRecoParticleAssociationCollection;
     class MutableMCRecoParticleAssociation;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::MCRecoParticleAssociation> {
     using collection_t = edm4hep::MCRecoParticleAssociationCollection;
     using mutable_t = edm4hep::MutableMCRecoParticleAssociation;
 };
 #endif
 namespace edm4hep {
     class MCRecoClusterParticleAssociation;
     class MCRecoClusterParticleAssociationCollection;
     class MutableMCRecoClusterParticleAssociation;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::MCRecoClusterParticleAssociation> {
     using collection_t = edm4hep::MCRecoClusterParticleAssociationCollection;
     using mutable_t = edm4hep::MutableMCRecoClusterParticleAssociation;
 };
 #endif
 namespace edm4hep {
     class SimTrackerHit;
     class SimTrackerHitCollection;
     class MutableSimTrackerHit;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::SimTrackerHit> {
     using collection_t = edm4hep::SimTrackerHitCollection;
     using mutable_t = edm4hep::MutableSimTrackerHit;
 };
 #endif
 namespace edm4hep {
     class TrackerPulse;
     class TrackerPulseCollection;
     class MutableTrackerPulse;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::TrackerPulse> {
     using collection_t = edm4hep::TrackerPulseCollection;
     using mutable_t = edm4hep::MutableTrackerPulse;
 };
 #endif
 namespace edm4hep {
     class TimeSeries;
     class TimeSeriesCollection;
     class MutableTimeSeries;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::TimeSeries> {
     using collection_t = edm4hep::TimeSeriesCollection;
     using mutable_t = edm4hep::MutableTimeSeries;
 };
 #endif
 namespace edm4hep {
     class MCRecoCaloParticleAssociation;
     class MCRecoCaloParticleAssociationCollection;
     class MutableMCRecoCaloParticleAssociation;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::MCRecoCaloParticleAssociation> {
     using collection_t = edm4hep::MCRecoCaloParticleAssociationCollection;
     using mutable_t = edm4hep::MutableMCRecoCaloParticleAssociation;
 };
 #endif
 namespace edm4hep {
     class TrackerHit;
     class TrackerHitCollection;
     class MutableTrackerHit;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4hep::TrackerHit> {
     using collection_t = edm4hep::TrackerHitCollection;
     using mutable_t = edm4hep::MutableTrackerHit;
 };
 #endif
 namespace edm4eic {
     class CherenkovParticleID;
     class CherenkovParticleIDCollection;
     class MutableCherenkovParticleID;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::CherenkovParticleID> {
     using collection_t = edm4eic::CherenkovParticleIDCollection;
     using mutable_t = edm4eic::MutableCherenkovParticleID;
 };
 #endif
 namespace edm4eic {
     class Tensor;
     class TensorCollection;
     class MutableTensor;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::Tensor> {
     using collection_t = edm4eic::TensorCollection;
     using mutable_t = edm4eic::MutableTensor;
 };
 #endif
 namespace edm4eic {
     class MCRecoVertexParticleAssociation;
     class MCRecoVertexParticleAssociationCollection;
     class MutableMCRecoVertexParticleAssociation;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::MCRecoVertexParticleAssociation> {
     using collection_t = edm4eic::MCRecoVertexParticleAssociationCollection;
     using mutable_t = edm4eic::MutableMCRecoVertexParticleAssociation;
 };
 #endif
 namespace edm4eic {
     class ProtoCluster;
     class ProtoClusterCollection;
     class MutableProtoCluster;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::ProtoCluster> {
     using collection_t = edm4eic::ProtoClusterCollection;
     using mutable_t = edm4eic::MutableProtoCluster;
 };
 #endif
 namespace edm4eic {
     class TrackSegment;
     class TrackSegmentCollection;
     class MutableTrackSegment;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::TrackSegment> {
     using collection_t = edm4eic::TrackSegmentCollection;
     using mutable_t = edm4eic::MutableTrackSegment;
 };
 #endif
 namespace edm4eic {
     class Cluster;
     class ClusterCollection;
     class MutableCluster;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::Cluster> {
     using collection_t = edm4eic::ClusterCollection;
     using mutable_t = edm4eic::MutableCluster;
 };
 #endif
 namespace edm4eic {
     class Measurement2D;
     class Measurement2DCollection;
     class MutableMeasurement2D;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::Measurement2D> {
     using collection_t = edm4eic::Measurement2DCollection;
     using mutable_t = edm4eic::MutableMeasurement2D;
 };
 #endif
 namespace edm4eic {
     class Vertex;
     class VertexCollection;
     class MutableVertex;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::Vertex> {
     using collection_t = edm4eic::VertexCollection;
     using mutable_t = edm4eic::MutableVertex;
 };
 #endif
 namespace edm4eic {
     class MCRecoTrackParticleAssociation;
     class MCRecoTrackParticleAssociationCollection;
     class MutableMCRecoTrackParticleAssociation;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::MCRecoTrackParticleAssociation> {
     using collection_t = edm4eic::MCRecoTrackParticleAssociationCollection;
     using mutable_t = edm4eic::MutableMCRecoTrackParticleAssociation;
 };
 #endif
 namespace edm4eic {
     class RawTrackerHit;
     class RawTrackerHitCollection;
     class MutableRawTrackerHit;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::RawTrackerHit> {
     using collection_t = edm4eic::RawTrackerHitCollection;
     using mutable_t = edm4eic::MutableRawTrackerHit;
 };
 #endif
 namespace edm4eic {
     class TrackParameters;
     class TrackParametersCollection;
     class MutableTrackParameters;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::TrackParameters> {
     using collection_t = edm4eic::TrackParametersCollection;
     using mutable_t = edm4eic::MutableTrackParameters;
 };
 #endif
 namespace edm4eic {
     class Trajectory;
     class TrajectoryCollection;
     class MutableTrajectory;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::Trajectory> {
     using collection_t = edm4eic::TrajectoryCollection;
     using mutable_t = edm4eic::MutableTrajectory;
 };
 #endif
 namespace edm4eic {
     class MCRecoCalorimeterHitAssociation;
     class MCRecoCalorimeterHitAssociationCollection;
     class MutableMCRecoCalorimeterHitAssociation;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::MCRecoCalorimeterHitAssociation> {
     using collection_t = edm4eic::MCRecoCalorimeterHitAssociationCollection;
     using mutable_t = edm4eic::MutableMCRecoCalorimeterHitAssociation;
 };
 #endif
 namespace edm4eic {
     class PMTHit;
     class PMTHitCollection;
     class MutablePMTHit;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::PMTHit> {
     using collection_t = edm4eic::PMTHitCollection;
     using mutable_t = edm4eic::MutablePMTHit;
 };
 #endif
 namespace edm4eic {
     class CalorimeterHit;
     class CalorimeterHitCollection;
     class MutableCalorimeterHit;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::CalorimeterHit> {
     using collection_t = edm4eic::CalorimeterHitCollection;
     using mutable_t = edm4eic::MutableCalorimeterHit;
 };
 #endif
 namespace edm4eic {
     class Track;
     class TrackCollection;
     class MutableTrack;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::Track> {
     using collection_t = edm4eic::TrackCollection;
     using mutable_t = edm4eic::MutableTrack;
 };
 #endif
 namespace edm4eic {
     class ReconstructedParticle;
     class ReconstructedParticleCollection;
     class MutableReconstructedParticle;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::ReconstructedParticle> {
     using collection_t = edm4eic::ReconstructedParticleCollection;
     using mutable_t = edm4eic::MutableReconstructedParticle;
 };
 #endif
 namespace edm4eic {
     class MCRecoTrackerHitAssociation;
     class MCRecoTrackerHitAssociationCollection;
     class MutableMCRecoTrackerHitAssociation;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::MCRecoTrackerHitAssociation> {
     using collection_t = edm4eic::MCRecoTrackerHitAssociationCollection;
     using mutable_t = edm4eic::MutableMCRecoTrackerHitAssociation;
 };
 #endif
 namespace edm4eic {
     class HadronicFinalState;
     class HadronicFinalStateCollection;
     class MutableHadronicFinalState;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::HadronicFinalState> {
     using collection_t = edm4eic::HadronicFinalStateCollection;
     using mutable_t = edm4eic::MutableHadronicFinalState;
 };
 #endif
 namespace edm4eic {
     class TrackClusterMatch;
     class TrackClusterMatchCollection;
     class MutableTrackClusterMatch;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::TrackClusterMatch> {
     using collection_t = edm4eic::TrackClusterMatchCollection;
     using mutable_t = edm4eic::MutableTrackClusterMatch;
 };
 #endif
 namespace edm4eic {
     class MCRecoParticleAssociation;
     class MCRecoParticleAssociationCollection;
     class MutableMCRecoParticleAssociation;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::MCRecoParticleAssociation> {
     using collection_t = edm4eic::MCRecoParticleAssociationCollection;
     using mutable_t = edm4eic::MutableMCRecoParticleAssociation;
 };
 #endif
 namespace edm4eic {
     class MCRecoClusterParticleAssociation;
     class MCRecoClusterParticleAssociationCollection;
     class MutableMCRecoClusterParticleAssociation;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::MCRecoClusterParticleAssociation> {
     using collection_t = edm4eic::MCRecoClusterParticleAssociationCollection;
     using mutable_t = edm4eic::MutableMCRecoClusterParticleAssociation;
 };
 #endif
 namespace edm4eic {
     class RingImage;
     class RingImageCollection;
     class MutableRingImage;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::RingImage> {
     using collection_t = edm4eic::RingImageCollection;
     using mutable_t = edm4eic::MutableRingImage;
 };
 #endif
 namespace edm4eic {
     class InclusiveKinematics;
     class InclusiveKinematicsCollection;
     class MutableInclusiveKinematics;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::InclusiveKinematics> {
     using collection_t = edm4eic::InclusiveKinematicsCollection;
     using mutable_t = edm4eic::MutableInclusiveKinematics;
 };
 #endif
 namespace edm4eic {
     class TrackSeed;
     class TrackSeedCollection;
     class MutableTrackSeed;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::TrackSeed> {
     using collection_t = edm4eic::TrackSeedCollection;
     using mutable_t = edm4eic::MutableTrackSeed;
 };
 #endif
 namespace edm4eic {
     class TrackerHit;
     class TrackerHitCollection;
     class MutableTrackerHit;
 };
 #if podio_VERSION < PODIO_VERSION(0, 17, 0)
 template <> struct PodioTypeMap<edm4eic::TrackerHit> {
     using collection_t = edm4eic::TrackerHitCollection;
     using mutable_t = edm4eic::MutableTrackerHit;
 };
 #endif
 
 template <typename Visitor> struct VisitPodioCollection {
     void operator()(Visitor& visitor, const podio::CollectionBase& collection) {
         auto podio_typename = collection.getTypeName();
         if (podio_typename == "edm4hep::TrackerHitPlaneCollection") {
             return visitor(*reinterpret_cast<const edm4hep::TrackerHitPlaneCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::MCRecoTrackerHitPlaneAssociationCollection") {
             return visitor(*reinterpret_cast<const edm4hep::MCRecoTrackerHitPlaneAssociationCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::CaloHitContributionCollection") {
             return visitor(*reinterpret_cast<const edm4hep::CaloHitContributionCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::RecoParticleVertexAssociationCollection") {
             return visitor(*reinterpret_cast<const edm4hep::RecoParticleVertexAssociationCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::MCRecoCaloAssociationCollection") {
             return visitor(*reinterpret_cast<const edm4hep::MCRecoCaloAssociationCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::ClusterCollection") {
             return visitor(*reinterpret_cast<const edm4hep::ClusterCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::SimCalorimeterHitCollection") {
             return visitor(*reinterpret_cast<const edm4hep::SimCalorimeterHitCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::MCRecoTrackerAssociationCollection") {
             return visitor(*reinterpret_cast<const edm4hep::MCRecoTrackerAssociationCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::ParticleIDCollection") {
             return visitor(*reinterpret_cast<const edm4hep::ParticleIDCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::VertexCollection") {
             return visitor(*reinterpret_cast<const edm4hep::VertexCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::RecDqdxCollection") {
             return visitor(*reinterpret_cast<const edm4hep::RecDqdxCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::SimPrimaryIonizationClusterCollection") {
             return visitor(*reinterpret_cast<const edm4hep::SimPrimaryIonizationClusterCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::RawTimeSeriesCollection") {
             return visitor(*reinterpret_cast<const edm4hep::RawTimeSeriesCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::MCRecoTrackParticleAssociationCollection") {
             return visitor(*reinterpret_cast<const edm4hep::MCRecoTrackParticleAssociationCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::RecIonizationClusterCollection") {
             return visitor(*reinterpret_cast<const edm4hep::RecIonizationClusterCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::RawCalorimeterHitCollection") {
             return visitor(*reinterpret_cast<const edm4hep::RawCalorimeterHitCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::CalorimeterHitCollection") {
             return visitor(*reinterpret_cast<const edm4hep::CalorimeterHitCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::TrackCollection") {
             return visitor(*reinterpret_cast<const edm4hep::TrackCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::EventHeaderCollection") {
             return visitor(*reinterpret_cast<const edm4hep::EventHeaderCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::MCParticleCollection") {
             return visitor(*reinterpret_cast<const edm4hep::MCParticleCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::ReconstructedParticleCollection") {
             return visitor(*reinterpret_cast<const edm4hep::ReconstructedParticleCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::MCRecoParticleAssociationCollection") {
             return visitor(*reinterpret_cast<const edm4hep::MCRecoParticleAssociationCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::MCRecoClusterParticleAssociationCollection") {
             return visitor(*reinterpret_cast<const edm4hep::MCRecoClusterParticleAssociationCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::SimTrackerHitCollection") {
             return visitor(*reinterpret_cast<const edm4hep::SimTrackerHitCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::TrackerPulseCollection") {
             return visitor(*reinterpret_cast<const edm4hep::TrackerPulseCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::TimeSeriesCollection") {
             return visitor(*reinterpret_cast<const edm4hep::TimeSeriesCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::MCRecoCaloParticleAssociationCollection") {
             return visitor(*reinterpret_cast<const edm4hep::MCRecoCaloParticleAssociationCollection*>(&collection));
         }
         if (podio_typename == "edm4hep::TrackerHitCollection") {
             return visitor(*reinterpret_cast<const edm4hep::TrackerHitCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::CherenkovParticleIDCollection") {
             return visitor(*reinterpret_cast<const edm4eic::CherenkovParticleIDCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::TensorCollection") {
             return visitor(*reinterpret_cast<const edm4eic::TensorCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::MCRecoVertexParticleAssociationCollection") {
             return visitor(*reinterpret_cast<const edm4eic::MCRecoVertexParticleAssociationCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::ProtoClusterCollection") {
             return visitor(*reinterpret_cast<const edm4eic::ProtoClusterCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::TrackSegmentCollection") {
             return visitor(*reinterpret_cast<const edm4eic::TrackSegmentCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::ClusterCollection") {
             return visitor(*reinterpret_cast<const edm4eic::ClusterCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::Measurement2DCollection") {
             return visitor(*reinterpret_cast<const edm4eic::Measurement2DCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::VertexCollection") {
             return visitor(*reinterpret_cast<const edm4eic::VertexCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::MCRecoTrackParticleAssociationCollection") {
             return visitor(*reinterpret_cast<const edm4eic::MCRecoTrackParticleAssociationCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::RawTrackerHitCollection") {
             return visitor(*reinterpret_cast<const edm4eic::RawTrackerHitCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::TrackParametersCollection") {
             return visitor(*reinterpret_cast<const edm4eic::TrackParametersCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::TrajectoryCollection") {
             return visitor(*reinterpret_cast<const edm4eic::TrajectoryCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::MCRecoCalorimeterHitAssociationCollection") {
             return visitor(*reinterpret_cast<const edm4eic::MCRecoCalorimeterHitAssociationCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::PMTHitCollection") {
             return visitor(*reinterpret_cast<const edm4eic::PMTHitCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::CalorimeterHitCollection") {
             return visitor(*reinterpret_cast<const edm4eic::CalorimeterHitCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::TrackCollection") {
             return visitor(*reinterpret_cast<const edm4eic::TrackCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::ReconstructedParticleCollection") {
             return visitor(*reinterpret_cast<const edm4eic::ReconstructedParticleCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::MCRecoTrackerHitAssociationCollection") {
             return visitor(*reinterpret_cast<const edm4eic::MCRecoTrackerHitAssociationCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::HadronicFinalStateCollection") {
             return visitor(*reinterpret_cast<const edm4eic::HadronicFinalStateCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::TrackClusterMatchCollection") {
             return visitor(*reinterpret_cast<const edm4eic::TrackClusterMatchCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::MCRecoParticleAssociationCollection") {
             return visitor(*reinterpret_cast<const edm4eic::MCRecoParticleAssociationCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::MCRecoClusterParticleAssociationCollection") {
             return visitor(*reinterpret_cast<const edm4eic::MCRecoClusterParticleAssociationCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::RingImageCollection") {
             return visitor(*reinterpret_cast<const edm4eic::RingImageCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::InclusiveKinematicsCollection") {
             return visitor(*reinterpret_cast<const edm4eic::InclusiveKinematicsCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::TrackSeedCollection") {
             return visitor(*reinterpret_cast<const edm4eic::TrackSeedCollection*>(&collection));
         }
         if (podio_typename == "edm4eic::TrackerHitCollection") {
             return visitor(*reinterpret_cast<const edm4eic::TrackerHitCollection*>(&collection));
         }
         throw std::runtime_error("Unrecognized podio typename!");
     }
 };

This page was automatically generated by the 2.3.7 LXR engine. The LXR team