EIC code displayed by LXR master/​include/​edm4hep/​DatamodelDefinition.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-12-16 10:12:58

 // AUTOMATICALLY GENERATED FILE - DO NOT EDIT
 
 #ifndef edm4hepDATAMODEL_DEFINITION_H
 #define edm4hepDATAMODEL_DEFINITION_H
 
 #include "podio/DatamodelRegistry.h"
 #include "podio/SchemaEvolution.h"
 
 namespace edm4hep::meta {
 /**
  * The complete definition of the datamodel at generation time in JSON format.
  */
 static constexpr auto edm4hep__JSONDefinition =
     R"DATAMODELDEF({"options": {"getSyntax": true, "exposePODMembers": false, "includeSubfolder": "edm4hep/"}, "schema_version": 5, "components": {"edm4hep::Vector4f": {"Description": "Generic vector for storing classical 4D coordinates in memory. Four momentum helper functions are in edm4hep::utils", "Members": ["float x", "float y", "float z", "float t"], "ExtraCode": {"includes": "#include <cstddef>", "declaration": "constexpr Vector4f() : x(0),y(0),z(0),t(0) {}\nconstexpr Vector4f(float xx, float yy, float zz, float tt) : x(xx),y(yy),z(zz),t(tt) {}\nconstexpr Vector4f(const float* v) : x(v[0]),y(v[1]),z(v[2]),t(v[3]) {}\nconstexpr bool operator==(const Vector4f& v) const { return (x==v.x&&y==v.y&&z==v.z&&t==v.t) ; }\nconstexpr bool operator!=(const Vector4f& v) const { return !(*this == v) ; }\nconstexpr float operator[](unsigned i) const {\n  static_assert(\n    (offsetof(Vector4f,x)+sizeof(Vector4f::x) == offsetof(Vector4f,y)) &&\n    (offsetof(Vector4f,y)+sizeof(Vector4f::y) == offsetof(Vector4f,z)) &&\n    (offsetof(Vector4f,z)+sizeof(Vector4f::z) == offsetof(Vector4f,t)),\n    \"operator[] requires no padding\");\n  return *( &x + i ) ; }\n"}}, "edm4hep::Vector3f": {"Members": ["float x", "float y", "float z"], "ExtraCode": {"includes": "#include <cstddef>", "declaration": "constexpr Vector3f() : x(0),y(0),z(0) {}\nconstexpr Vector3f(float xx, float yy, float zz) : x(xx),y(yy),z(zz) {}\nconstexpr Vector3f(const float* v) : x(v[0]),y(v[1]),z(v[2]) {}\nconstexpr bool operator==(const Vector3f& v) const { return (x==v.x&&y==v.y&&z==v.z) ; }\nconstexpr bool operator!=(const Vector3f& v) const { return !(*this == v) ; }\nconstexpr float operator[](unsigned i) const {\n  static_assert(\n    (offsetof(Vector3f,x)+sizeof(Vector3f::x) == offsetof(Vector3f,y)) &&\n    (offsetof(Vector3f,y)+sizeof(Vector3f::y) == offsetof(Vector3f,z)),\n    \"operator[] requires no padding\");\n  return *( &x + i ) ;\n}\n"}}, "edm4hep::Vector3d": {"Members": ["double x", "double y", "double z"], "ExtraCode": {"includes": "#include <edm4hep/Vector3f.h>\n#include <cstddef>\n", "declaration": "constexpr Vector3d() : x(0),y(0),z(0) {}\nconstexpr Vector3d(double xx, double yy, double zz) : x(xx),y(yy),z(zz) {}\nconstexpr Vector3d(const double* v) : x(v[0]),y(v[1]),z(v[2]) {}\nconstexpr Vector3d(const float* v) : x(v[0]),y(v[1]),z(v[2]) {}\nconstexpr bool operator==(const Vector3d& v) const { return (x==v.x&&y==v.y&&z==v.z) ; }\nconstexpr bool operator!=(const Vector3d& v) const { return !(*this == v) ; }\nconstexpr double operator[](unsigned i) const {\n  static_assert(\n    (offsetof(Vector3d,x)+sizeof(Vector3d::x) == offsetof(Vector3d,y)) &&\n    (offsetof(Vector3d,y)+sizeof(Vector3d::y) == offsetof(Vector3d,z)),\n    \"operator[] requires no padding\");\n  return *( &x + i ) ; }\n"}}, "edm4hep::Vector2f": {"Members": ["float a", "float b"], "ExtraCode": {"includes": "#include <cstddef>", "declaration": "constexpr Vector2f() : a(0),b(0) {}\nconstexpr Vector2f(float aa,float bb) : a(aa),b(bb) {}\nconstexpr Vector2f(const float* v) : a(v[0]), b(v[1]) {}\nconstexpr bool operator==(const Vector2f& v) const { return (a==v.a&&b==v.b) ; }\nconstexpr bool operator!=(const Vector2f& v) const { return !(*this == v) ; }\nconstexpr float operator[](unsigned i) const {\n  static_assert(\n    offsetof(Vector2f,a)+sizeof(Vector2f::a) == offsetof(Vector2f,b),\n    \"operator[] requires no padding\");\n  return *( &a + i ) ; }\n"}}, "edm4hep::CovMatrix2f": {"Description": "A generic 2 dimensional covariance matrix with values stored in lower triangular form", "Members": ["std::array<float, 3> values // the covariance matrix values"], "ExtraCode": {"includes": "#include <edm4hep/utils/cov_matrix_utils.h>", "declaration": "constexpr CovMatrix2f() = default;\ntemplate<typename... Vs>\nconstexpr CovMatrix2f(Vs... v) : values{static_cast<float>(v)...} {\n  static_assert(sizeof...(v) == 3, \"CovMatrix2f requires 3 values\");\n}\nconstexpr CovMatrix2f(const std::array<float, 3>& v) : values(v) {}\nconstexpr CovMatrix2f& operator=(const std::array<float, 3>& v) { values = v; return *this; }\nbool operator==(const CovMatrix2f& v) const { return v.values == values; }\nbool operator!=(const CovMatrix2f& v) const { return v.values != values; }\n\n// This file is meant to be included via the ExtraCode declarationFile directive\n// for the CovMatrixNx components. They live in this file because they\n// can be written very generically and reduce the clutter and code repetition in\n// the edm4hep.yaml file\n//\n// NOTE: All of these functions are intended to be member functions, and the\n// only member of a CovMatrixNx component is an appropriately sized std::array\n// named values.\n//\n// NOTE: It is also assumed that the edm4hep/utils/cov_matrix_utils.h header is\n// included via the corresponding ExtraCode: include directive\n\n/// Get the i-th element of the underlying storage\n///\n/// \\note The values are stored in a flat array assuming a lower\n/// triangular matrix representation\nconstexpr float operator[](unsigned i) const {\n  return values[i];\n}\n\n/// Get the i-th element of the underlying storage\n///\n/// \\note The values are stored in a flat array assuming a lower\n/// triangular matrix representation\nconstexpr float& operator[](unsigned i) {\n  return values[i];\n}\n\n/// Get the begin iterator to the underlying storage\nconstexpr auto begin() const {\n  return values.begin();\n}\n\n/// Get the begin iterator to the underlying storage\nconstexpr auto begin() {\n  return values.begin();\n}\n\n/// Get the end iterator to the underlying storage\nconstexpr auto end() const {\n  return values.end();\n}\n\n/// Get the end iterator to the underlying storage\nconstexpr auto end() {\n  return values.end();\n}\n\n/// Get a pointer to the underlying storage data\nauto* data() {\n  return values.data();\n}\n\n/// Get a pointer to the underlying storage data\nconst auto* data() const {\n  return values.data();\n}\n\n/// Get the value of the covariance matrix for the passed dimensions\n///\n/// @tparam DimEnum The enum (class) type that describes the dimensions of this\n///                 covariance matrix. This will be deduced from the passed\n///                 arguments!\n///\n/// @param dimI The first dimension for which the covariance matrix value should\n///             be obtained\n/// @param dimJ The second dimension for which the covariance matrix value\n///             should be obtained\n///\n/// @returns The value of the covariance matrix for dimension dimI and dimJ\ntemplate <typename DimEnum>\nconstexpr float getValue(DimEnum dimI, DimEnum dimJ) const {\n  return edm4hep::utils::get_cov_value(values, dimI, dimJ);\n}\n\n/// Set the value of the covariance matrix for the passed dimensions\n///\n/// @tparam DimEnum The enum (class) type that describes the dimensions of this\n///                 covariance matrix. This will be deduced from the passed\n///                 arguments!\n///\n/// @param value The value to be set\n/// @param dimI  The first dimension for which the covariance matrix value\n///              should be obtained\n/// @param dimJ  The second dimension for which the covariance matrix value\n///              should be obtained\ntemplate <typename DimEnum>\nconstexpr void setValue(float value, DimEnum dimI, DimEnum dimJ) {\n  utils::set_cov_value(value, values, dimI, dimJ);\n}\n"}}, "edm4hep::CovMatrix3f": {"Description": "A generic 3 dimensional covariance matrix with values stored in lower triangular form", "Members": ["std::array<float, 6> values // the covariance matrix values"], "ExtraCode": {"includes": "#include <edm4hep/utils/cov_matrix_utils.h>", "declaration": "constexpr CovMatrix3f() = default;\nconstexpr CovMatrix3f(const std::array<float, 6>& v) : values(v) {}\ntemplate<typename... Vs>\nconstexpr CovMatrix3f(Vs... v) : values{static_cast<float>(v)...} {\n  static_assert(sizeof...(v) == 6, \"CovMatrix3f requires 6 values\");\n}\nconstexpr CovMatrix3f& operator=(const std::array<float, 6>& v) { values = v; return *this; }\nbool operator==(const CovMatrix3f& v) const { return v.values == values; }\nbool operator!=(const CovMatrix3f& v) const { return v.values != values; }\n\n// This file is meant to be included via the ExtraCode declarationFile directive\n// for the CovMatrixNx components. They live in this file because they\n// can be written very generically and reduce the clutter and code repetition in\n// the edm4hep.yaml file\n//\n// NOTE: All of these functions are intended to be member functions, and the\n// only member of a CovMatrixNx component is an appropriately sized std::array\n// named values.\n//\n// NOTE: It is also assumed that the edm4hep/utils/cov_matrix_utils.h header is\n// included via the corresponding ExtraCode: include directive\n\n/// Get the i-th element of the underlying storage\n///\n/// \\note The values are stored in a flat array assuming a lower\n/// triangular matrix representation\nconstexpr float operator[](unsigned i) const {\n  return values[i];\n}\n\n/// Get the i-th element of the underlying storage\n///\n/// \\note The values are stored in a flat array assuming a lower\n/// triangular matrix representation\nconstexpr float& operator[](unsigned i) {\n  return values[i];\n}\n\n/// Get the begin iterator to the underlying storage\nconstexpr auto begin() const {\n  return values.begin();\n}\n\n/// Get the begin iterator to the underlying storage\nconstexpr auto begin() {\n  return values.begin();\n}\n\n/// Get the end iterator to the underlying storage\nconstexpr auto end() const {\n  return values.end();\n}\n\n/// Get the end iterator to the underlying storage\nconstexpr auto end() {\n  return values.end();\n}\n\n/// Get a pointer to the underlying storage data\nauto* data() {\n  return values.data();\n}\n\n/// Get a pointer to the underlying storage data\nconst auto* data() const {\n  return values.data();\n}\n\n/// Get the value of the covariance matrix for the passed dimensions\n///\n/// @tparam DimEnum The enum (class) type that describes the dimensions of this\n///                 covariance matrix. This will be deduced from the passed\n///                 arguments!\n///\n/// @param dimI The first dimension for which the covariance matrix value should\n///             be obtained\n/// @param dimJ The second dimension for which the covariance matrix value\n///             should be obtained\n///\n/// @returns The value of the covariance matrix for dimension dimI and dimJ\ntemplate <typename DimEnum>\nconstexpr float getValue(DimEnum dimI, DimEnum dimJ) const {\n  return edm4hep::utils::get_cov_value(values, dimI, dimJ);\n}\n\n/// Set the value of the covariance matrix for the passed dimensions\n///\n/// @tparam DimEnum The enum (class) type that describes the dimensions of this\n///                 covariance matrix. This will be deduced from the passed\n///                 arguments!\n///\n/// @param value The value to be set\n/// @param dimI  The first dimension for which the covariance matrix value\n///              should be obtained\n/// @param dimJ  The second dimension for which the covariance matrix value\n///              should be obtained\ntemplate <typename DimEnum>\nconstexpr void setValue(float value, DimEnum dimI, DimEnum dimJ) {\n  utils::set_cov_value(value, values, dimI, dimJ);\n}\n"}}, "edm4hep::CovMatrix4f": {"Description": "A generic 4 dimensional covariance matrix with values stored in lower triangular form", "Members": ["std::array<float, 10> values // the covariance matrix values"], "ExtraCode": {"includes": "#include <edm4hep/utils/cov_matrix_utils.h>", "declaration": "constexpr CovMatrix4f() = default;\ntemplate<typename... Vs>\nconstexpr CovMatrix4f(Vs... v) : values{static_cast<float>(v)...} {\n  static_assert(sizeof...(v) == 10, \"CovMatrix4f requires 10 values\");\n}\nconstexpr CovMatrix4f(const std::array<float, 10>& v) : values(v) {}\nconstexpr CovMatrix4f& operator=(const std::array<float, 10>& v) { values = v; return *this; }\nbool operator==(const CovMatrix4f& v) const { return v.values == values; }\nbool operator!=(const CovMatrix4f& v) const { return v.values != values; }\n\n// This file is meant to be included via the ExtraCode declarationFile directive\n// for the CovMatrixNx components. They live in this file because they\n// can be written very generically and reduce the clutter and code repetition in\n// the edm4hep.yaml file\n//\n// NOTE: All of these functions are intended to be member functions, and the\n// only member of a CovMatrixNx component is an appropriately sized std::array\n// named values.\n//\n// NOTE: It is also assumed that the edm4hep/utils/cov_matrix_utils.h header is\n// included via the corresponding ExtraCode: include directive\n\n/// Get the i-th element of the underlying storage\n///\n/// \\note The values are stored in a flat array assuming a lower\n/// triangular matrix representation\nconstexpr float operator[](unsigned i) const {\n  return values[i];\n}\n\n/// Get the i-th element of the underlying storage\n///\n/// \\note The values are stored in a flat array assuming a lower\n/// triangular matrix representation\nconstexpr float& operator[](unsigned i) {\n  return values[i];\n}\n\n/// Get the begin iterator to the underlying storage\nconstexpr auto begin() const {\n  return values.begin();\n}\n\n/// Get the begin iterator to the underlying storage\nconstexpr auto begin() {\n  return values.begin();\n}\n\n/// Get the end iterator to the underlying storage\nconstexpr auto end() const {\n  return values.end();\n}\n\n/// Get the end iterator to the underlying storage\nconstexpr auto end() {\n  return values.end();\n}\n\n/// Get a pointer to the underlying storage data\nauto* data() {\n  return values.data();\n}\n\n/// Get a pointer to the underlying storage data\nconst auto* data() const {\n  return values.data();\n}\n\n/// Get the value of the covariance matrix for the passed dimensions\n///\n/// @tparam DimEnum The enum (class) type that describes the dimensions of this\n///                 covariance matrix. This will be deduced from the passed\n///                 arguments!\n///\n/// @param dimI The first dimension for which the covariance matrix value should\n///             be obtained\n/// @param dimJ The second dimension for which the covariance matrix value\n///             should be obtained\n///\n/// @returns The value of the covariance matrix for dimension dimI and dimJ\ntemplate <typename DimEnum>\nconstexpr float getValue(DimEnum dimI, DimEnum dimJ) const {\n  return edm4hep::utils::get_cov_value(values, dimI, dimJ);\n}\n\n/// Set the value of the covariance matrix for the passed dimensions\n///\n/// @tparam DimEnum The enum (class) type that describes the dimensions of this\n///                 covariance matrix. This will be deduced from the passed\n///                 arguments!\n///\n/// @param value The value to be set\n/// @param dimI  The first dimension for which the covariance matrix value\n///              should be obtained\n/// @param dimJ  The second dimension for which the covariance matrix value\n///              should be obtained\ntemplate <typename DimEnum>\nconstexpr void setValue(float value, DimEnum dimI, DimEnum dimJ) {\n  utils::set_cov_value(value, values, dimI, dimJ);\n}\n"}}, "edm4hep::CovMatrix6f": {"Description": "A generic 6 dimensional covariance matrix with values stored in lower triangular form", "Members": ["std::array<float, 21> values // the covariance matrix values"], "ExtraCode": {"includes": "#include <edm4hep/utils/cov_matrix_utils.h>", "declaration": "constexpr CovMatrix6f() = default;\ntemplate<typename... Vs>\nconstexpr CovMatrix6f(Vs... v) : values{static_cast<float>(v)...} {\n  static_assert(sizeof...(v) == 21, \"CovMatrix6f requires 21 values\");\n}\nconstexpr CovMatrix6f(const std::array<float, 21>& v) : values(v) {}\nconstexpr CovMatrix6f& operator=(const std::array<float, 21>& v) { values = v; return *this; }\nbool operator==(const CovMatrix6f& v) const { return v.values == values; }\nbool operator!=(const CovMatrix6f& v) const { return v.values != values; }\n\n// This file is meant to be included via the ExtraCode declarationFile directive\n// for the CovMatrixNx components. They live in this file because they\n// can be written very generically and reduce the clutter and code repetition in\n// the edm4hep.yaml file\n//\n// NOTE: All of these functions are intended to be member functions, and the\n// only member of a CovMatrixNx component is an appropriately sized std::array\n// named values.\n//\n// NOTE: It is also assumed that the edm4hep/utils/cov_matrix_utils.h header is\n// included via the corresponding ExtraCode: include directive\n\n/// Get the i-th element of the underlying storage\n///\n/// \\note The values are stored in a flat array assuming a lower\n/// triangular matrix representation\nconstexpr float operator[](unsigned i) const {\n  return values[i];\n}\n\n/// Get the i-th element of the underlying storage\n///\n/// \\note The values are stored in a flat array assuming a lower\n/// triangular matrix representation\nconstexpr float& operator[](unsigned i) {\n  return values[i];\n}\n\n/// Get the begin iterator to the underlying storage\nconstexpr auto begin() const {\n  return values.begin();\n}\n\n/// Get the begin iterator to the underlying storage\nconstexpr auto begin() {\n  return values.begin();\n}\n\n/// Get the end iterator to the underlying storage\nconstexpr auto end() const {\n  return values.end();\n}\n\n/// Get the end iterator to the underlying storage\nconstexpr auto end() {\n  return values.end();\n}\n\n/// Get a pointer to the underlying storage data\nauto* data() {\n  return values.data();\n}\n\n/// Get a pointer to the underlying storage data\nconst auto* data() const {\n  return values.data();\n}\n\n/// Get the value of the covariance matrix for the passed dimensions\n///\n/// @tparam DimEnum The enum (class) type that describes the dimensions of this\n///                 covariance matrix. This will be deduced from the passed\n///                 arguments!\n///\n/// @param dimI The first dimension for which the covariance matrix value should\n///             be obtained\n/// @param dimJ The second dimension for which the covariance matrix value\n///             should be obtained\n///\n/// @returns The value of the covariance matrix for dimension dimI and dimJ\ntemplate <typename DimEnum>\nconstexpr float getValue(DimEnum dimI, DimEnum dimJ) const {\n  return edm4hep::utils::get_cov_value(values, dimI, dimJ);\n}\n\n/// Set the value of the covariance matrix for the passed dimensions\n///\n/// @tparam DimEnum The enum (class) type that describes the dimensions of this\n///                 covariance matrix. This will be deduced from the passed\n///                 arguments!\n///\n/// @param value The value to be set\n/// @param dimI  The first dimension for which the covariance matrix value\n///              should be obtained\n/// @param dimJ  The second dimension for which the covariance matrix value\n///              should be obtained\ntemplate <typename DimEnum>\nconstexpr void setValue(float value, DimEnum dimI, DimEnum dimJ) {\n  utils::set_cov_value(value, values, dimI, dimJ);\n}\n"}}, "edm4hep::TrackState": {"Description": "Parametrized description of a particle track", "Members": ["std::int32_t location // for use with At{Other|IP|FirstHit|LastHit|Calorimeter|Vertex}|LastLocation", "float D0 // transverse impact parameter", "float phi[rad] // azimuthal angle of the track at this location (i.e. not phi0)", "float omega", "float Z0 // longitudinal impact parameter", "float tanLambda // lambda is the dip angle of the track in r-z", "float time[ns] // time of the track at this trackstate", "edm4hep::Vector3f referencePoint[mm] // Reference point of the track parameters, e.g. the origin at the IP, or the position  of the first/last hits or the entry point into the calorimeter", "edm4hep::CovMatrix6f covMatrix // covariance matrix of the track parameters."], "ExtraCode": {"includes": "#include <edm4hep/Constants.h>", "declaration": "static const int AtOther = 0 ; // any location other than the ones defined below\nstatic const int AtIP = 1 ;\nstatic const int AtFirstHit = 2 ;\nstatic const int AtLastHit = 3 ;\nstatic const int AtCalorimeter = 4 ;\nstatic const int AtVertex = 5 ;\nstatic const int LastLocation = AtVertex  ;\n\n/// Get the covariance matrix value for the two passed parameters\nconstexpr float getCovMatrix(edm4hep::TrackParams parI, edm4hep::TrackParams parJ) const { return covMatrix.getValue(parI, parJ); }\n/// Set the covariance matrix value for the two passed parameters\nconstexpr void setCovMatrix(float value, edm4hep::TrackParams parI, edm4hep::TrackParams parJ) { covMatrix.setValue(value, parI, parJ); }\n"}}, "edm4hep::Quantity": {"Members": ["std::int16_t type // flag identifying how to interpret the quantity", "float value // value of the quantity", "float error // error on the value of the quantity"]}}, "datatypes": {"edm4hep::EventHeader": {"Description": "Event Header. Additional parameters are assumed to go into the metadata tree.", "Author": "EDM4hep authors", "Members": ["std::uint64_t eventNumber // event number", "std::uint32_t runNumber // run number", "std::uint64_t timeStamp // time stamp", "double weight // event weight"], "VectorMembers": ["double weights // event weights in case there are multiple. **NOTE that weights[0] might not be the same as weight!** The corresponding names of the event weights should be stored in the collection named by edm4hep::labels::EventWeightsNames in the file-level metadata."], "OneToOneRelations": [], "OneToManyRelations": [], "ExtraCode": {}, "MutableExtraCode": {}}, "edm4hep::MCParticle": {"Description": "The Monte Carlo particle - based on the lcio::MCParticle.", "Author": "EDM4hep authors", "Members": ["std::int32_t PDG // PDG code of the particle", "std::int32_t generatorStatus // status of the particle as defined by the generator", "std::int32_t simulatorStatus // status of the particle from the simulation program - use BIT constants below", "float charge[e] // particle charge", "float time[ns] // creation time of the particle in wrt. the event, e.g. for preassigned decays or decays in flight from the simulator", "double mass[GeV] // mass of the particle", "edm4hep::Vector3d vertex[mm] // production vertex of the particle", "edm4hep::Vector3d endpoint[mm] // endpoint of the particle", "edm4hep::Vector3d momentum[GeV] // particle 3-momentum at the production vertex", "edm4hep::Vector3d momentumAtEndpoint[GeV] // particle 3-momentum at the endpoint", "std::int32_t helicity{9} // particle helicity (9 if unset)"], "OneToManyRelations": ["edm4hep::MCParticle parents // The parents of this particle", "edm4hep::MCParticle daughters // The daughters this particle"], "MutableExtraCode": {"includes": "#include <cmath>", "declaration": "void setCreatedInSimulation(bool bitval) { setSimulatorStatus( utils::setBit( getSimulatorStatus() , BITCreatedInSimulation , bitval ) ) ;  }\nvoid setBackscatter(bool bitval) { setSimulatorStatus( utils::setBit( getSimulatorStatus() , BITBackscatter , bitval ) ) ;   }\nvoid setVertexIsNotEndpointOfParent(bool bitval) { setSimulatorStatus( utils::setBit( getSimulatorStatus() , BITVertexIsNotEndpointOfParent , bitval ) ) ; }\nvoid setDecayedInTracker(bool bitval) { setSimulatorStatus( utils::setBit( getSimulatorStatus() , BITDecayedInTracker , bitval ) ) ;   }\nvoid setDecayedInCalorimeter(bool bitval) { setSimulatorStatus( utils::setBit( getSimulatorStatus() , BITDecayedInCalorimeter , bitval ) ) ;   }\nvoid setHasLeftDetector(bool bitval) { setSimulatorStatus( utils::setBit( getSimulatorStatus() , BITLeftDetector , bitval ) ) ;   }\nvoid setStopped(bool bitval) { setSimulatorStatus( utils::setBit( getSimulatorStatus() , BITStopped , bitval ) ) ;   }\nvoid setOverlay(bool bitval) { setSimulatorStatus( utils::setBit( getSimulatorStatus() , BITOverlay , bitval ) ) ;   }\n"}, "ExtraCode": {"includes": "#include <edm4hep/utils/bit_utils.h>\n#include <edm4hep/FeatureFlags.h>\n", "declaration": "// define the bit positions for the simulation flag\nstatic const int BITCreatedInSimulation = 30;\nstatic const int BITBackscatter = 29 ;\nstatic const int BITVertexIsNotEndpointOfParent = 28 ;\nstatic const int BITDecayedInTracker = 27 ;\nstatic const int BITDecayedInCalorimeter = 26 ;\nstatic const int BITLeftDetector = 25 ;\nstatic const int BITStopped = 24 ;\nstatic const int BITOverlay = 23 ;\n/// return energy computed from momentum and mass\ndouble getEnergy() const { return std::sqrt( getMomentum()[0]*getMomentum()[0]+getMomentum()[1]*getMomentum()[1]+\n                                  getMomentum()[2]*getMomentum()[2] + getMass()*getMass()  )  ;}\n\n/// True if the particle has been created by the simulation program (rather than the generator).\nbool isCreatedInSimulation() const { return utils::checkBit(getSimulatorStatus(), BITCreatedInSimulation); }\n/// True if the particle is the result of a backscatter from a calorimeter shower.\nbool isBackscatter() const { return utils::checkBit(getSimulatorStatus(), BITBackscatter); }\n/// True if the particle's vertex is not the endpoint of the  parent particle.\nbool vertexIsNotEndpointOfParent() const { return utils::checkBit(getSimulatorStatus(), BITVertexIsNotEndpointOfParent); }\n/// True if the particle has interacted in a tracking region.\nbool isDecayedInTracker() const { return utils::checkBit(getSimulatorStatus(), BITDecayedInTracker); }\n/// True if the particle has interacted in a calorimeter region.\nbool isDecayedInCalorimeter() const { return utils::checkBit(getSimulatorStatus(), BITDecayedInCalorimeter); }\n/// True if the particle has left the world volume undecayed.\nbool hasLeftDetector() const { return utils::checkBit(getSimulatorStatus(), BITLeftDetector); }\n/// True if the particle has been stopped by the simulation program.\nbool isStopped() const { return utils::checkBit(getSimulatorStatus(), BITStopped); }\n/// True if the particle has been overlaid by the simulation (or digitization)  program.\nbool isOverlay() const { return utils::checkBit(getSimulatorStatus(), BITOverlay); }\n/// Check if this particle has a set helicity\nbool hasHelicity() const noexcept { return getHelicity() != 9; }\n"}, "VectorMembers": [], "OneToOneRelations": []}, "edm4hep::SimTrackerHit": {"Description": "Simulated tracker hit", "Author": "EDM4hep authors", "Members": ["std::uint64_t cellID // ID of the sensor that created this hit", "float eDep[GeV] // energy deposited in the hit", "float time[ns] // proper time of the hit in the lab frame", "float pathLength // path length of the particle in the sensitive material that resulted in this hit", "std::int32_t quality // quality bit flag", "edm4hep::Vector3d position[mm] // the hit position", "edm4hep::Vector3f momentum[GeV] // the 3-momentum of the particle at the hits position"], "OneToOneRelations": ["edm4hep::MCParticle particle // MCParticle that caused the hit"], "MutableExtraCode": {"includes": "#include <cmath>\n#include <edm4hep/MCParticle.h>\n", "declaration": "int32_t  set_bit(int32_t val, int num, bool bitval){ return (val & ~(1<<num)) | (bitval << num); }\nvoid setOverlay(bool val) { setQuality( set_bit( getQuality() , BITOverlay , val ) ) ;   }\nvoid setProducedBySecondary(bool val) { setQuality( set_bit( getQuality() , BITProducedBySecondary , val ) ) ;   }\n"}, "ExtraCode": {"includes": "#include <edm4hep/MCParticle.h>", "declaration": "static const int  BITOverlay = 31;\nstatic const int  BITProducedBySecondary = 30;\nbool isOverlay() const { return getQuality() & (1 << BITOverlay) ; }\nbool isProducedBySecondary() const { return getQuality() & (1 << BITProducedBySecondary) ; }\ndouble x() const {return getPosition()[0];}\ndouble y() const {return getPosition()[1];}\ndouble z() const {return getPosition()[2];}\ndouble rho() const {return std::hypot(x(), y());}\n"}, "VectorMembers": [], "OneToManyRelations": []}, "edm4hep::CaloHitContribution": {"Description": "Monte Carlo contribution to SimCalorimeterHit", "Author": "EDM4hep authors", "Members": ["std::int32_t PDG // PDG code of the shower particle that caused this contribution", "float energy[GeV] // energy of this contribution", "float time[ns] // time of this contribution", "edm4hep::Vector3f stepPosition[mm] // position of this energy deposition (step)", "float stepLength[mm] // Geant4 step length for this contribution"], "OneToOneRelations": ["edm4hep::MCParticle particle // MCParticle responsible for this contribution to the hit. Only particles that are kept in the MCParticle record will appear here. Hence, this will point to the first mother appearing in the record."], "VectorMembers": [], "OneToManyRelations": [], "ExtraCode": {}, "MutableExtraCode": {}}, "edm4hep::SimCalorimeterHit": {"Description": "Simulated calorimeter hit", "Author": "EDM4hep authors", "Members": ["std::uint64_t cellID // ID of the sensor that created this hit", "float energy[GeV] // energy of the hit", "edm4hep::Vector3f position[mm] // position of the hit in world coordinates"], "OneToManyRelations": ["edm4hep::CaloHitContribution contributions // Monte Carlo step contributions"], "VectorMembers": [], "OneToOneRelations": [], "ExtraCode": {}, "MutableExtraCode": {}}, "edm4hep::RawCalorimeterHit": {"Description": "Raw calorimeter hit", "Author": "EDM4hep authors", "Members": ["std::uint64_t cellID // detector specific (geometrical) cell id", "std::int32_t amplitude // amplitude of the hit in ADC counts", "std::int32_t timeStamp // time stamp for the hit"], "VectorMembers": [], "OneToOneRelations": [], "OneToManyRelations": [], "ExtraCode": {}, "MutableExtraCode": {}}, "edm4hep::CalorimeterHit": {"Description": "Calorimeter hit", "Author": "EDM4hep authors", "Members": ["std::uint64_t cellID // detector specific (geometrical) cell id", "float energy[GeV] // energy of the hit", "float energyError[GeV] // error of the hit energy", "float time[ns] // time of the hit", "edm4hep::Vector3f position[mm] // position of the hit in world coordinates", "std::int32_t type // type of hit"], "VectorMembers": [], "OneToOneRelations": [], "OneToManyRelations": [], "ExtraCode": {}, "MutableExtraCode": {}}, "edm4hep::ParticleID": {"Description": "ParticleID", "Author": "EDM4hep authors", "Members": ["std::int32_t type // userdefined type", "std::int32_t PDG // PDG code of this id - ( 999999 ) if unknown", "std::int32_t algorithmType // type of the algorithm/module that created this hypothesis", "float likelihood // likelihood of this hypothesis - in a user defined normalization"], "VectorMembers": ["float parameters // parameters associated with this hypothesis"], "OneToOneRelations": ["edm4hep::ReconstructedParticle particle // the particle from which this PID has been computed"], "OneToManyRelations": [], "ExtraCode": {}, "MutableExtraCode": {}}, "edm4hep::Cluster": {"Description": "Calorimeter Hit Cluster", "Author": "EDM4hep authors", "Members": ["std::int32_t type // flagword that defines the type of cluster", "float energy[GeV] // energy of the cluster", "float energyError[GeV] // error on the energy", "edm4hep::Vector3f position[mm] // position of the cluster", "edm4hep::CovMatrix3f positionError[mm^2] // covariance matrix of the position", "float iTheta[rad] // Polar angle of the cluster's intrinsic direction (used e.g. for vertexing). Not to be confused with the cluster position seen from IP", "float phi[rad] // Azimuthal angle of the cluster's intrinsic direction (used e.g. for vertexing). Not to be confused with the cluster position seen from IP", "edm4hep::Vector3f directionError[mm^2] // covariance matrix of the direction"], "VectorMembers": ["float shapeParameters // shape parameters. The corresponding names of the shape parameters should be stored in the collection named by edm4hep::labels::ShapeParameterNames in the file-level metadata, as a vector of strings in the same order as the parameters.", "float subdetectorEnergies // energy observed in a particular subdetector"], "OneToManyRelations": ["edm4hep::Cluster clusters // clusters that have been combined to this cluster", "edm4hep::CalorimeterHit hits // hits that have been combined to this cluster"], "ExtraCode": {"includes": "#include <edm4hep/Constants.h>", "declaration": "/// Get the position error value for the two passed dimensions\nfloat getPositionError(edm4hep::Cartesian dimI, edm4hep::Cartesian dimJ) const { return getPositionError().getValue(dimI, dimJ); }\n"}, "MutableExtraCode": {"includes": "#include <edm4hep/Constants.h>", "declaration": "/// Set the position error value for the two passed dimensions\nvoid setPositionError(float value, edm4hep::Cartesian dimI, edm4hep::Cartesian dimJ) { return getPositionError().setValue(value, dimI, dimJ); }\n"}, "OneToOneRelations": []}, "edm4hep::TrackerHit3D": {"Description": "Tracker hit", "Author": "EDM4hep authors", "Members": ["std::uint64_t cellID // ID of the sensor that created this hit", "std::int32_t type // type of raw data hit", "std::int32_t quality // quality bit flag of the hit", "float time[ns] // time of the hit", "float eDep[GeV] // energy deposited on the hit", "float eDepError[GeV] // error measured on eDep", "edm4hep::Vector3d position[mm] // hit position", "edm4hep::CovMatrix3f covMatrix[mm^2] // covariance matrix of the position (x,y,z)"], "ExtraCode": {"includes": "#include <edm4hep/Constants.h>", "declaration": "/// Get the position covariance matrix value for the two passed dimensions\nfloat getCovMatrix(edm4hep::Cartesian dimI, edm4hep::Cartesian dimJ) const { return getCovMatrix().getValue(dimI, dimJ); }\n"}, "MutableExtraCode": {"includes": "#include <edm4hep/Constants.h>", "declaration": "/// Set the position covariance matrix value for the two passed dimensions\nvoid setCovMatrix(float value, edm4hep::Cartesian dimI, edm4hep::Cartesian dimJ) { getCovMatrix().setValue(value, dimI, dimJ); }\n"}, "VectorMembers": [], "OneToOneRelations": [], "OneToManyRelations": []}, "edm4hep::TrackerHitPlane": {"Description": "Tracker hit plane", "Author": "EDM4hep authors", "Members": ["std::uint64_t cellID // ID of the sensor that created this hit", "std::int32_t type // type of raw data hit", "std::int32_t quality // quality bit flag of the hit", "float time[ns] // time of the hit", "float eDep[GeV] // energy deposited on the hit", "float eDepError[GeV] // error measured on eDep", "edm4hep::Vector2f u[rad] // direction of the first measurement given as (theta, phi) in spherical coordinates", "edm4hep::Vector2f v[rad] // direction of the second measurement given as (theta, phi) in spherical coordinates", "float du[mm] // measurement error along the direction", "float dv[mm] // measurement error along the direction", "edm4hep::Vector3d position[mm] // hit position", "edm4hep::CovMatrix3f covMatrix[mm^2] // covariance of the position (x,y,z)"], "ExtraCode": {"includes": "#include <edm4hep/Constants.h>", "declaration": "/// Get the position covariance matrix value for the two passed dimensions\nfloat getCovMatrix(edm4hep::Cartesian dimI, edm4hep::Cartesian dimJ) const { return getCovMatrix().getValue(dimI, dimJ); }\n"}, "MutableExtraCode": {"includes": "#include <edm4hep/Constants.h>", "declaration": "/// Set the position covariance matrix value for the two passed dimensions\nvoid setCovMatrix(float value, edm4hep::Cartesian dimI, edm4hep::Cartesian dimJ) { getCovMatrix().setValue(value, dimI, dimJ); }\n"}, "VectorMembers": [], "OneToOneRelations": [], "OneToManyRelations": []}, "edm4hep::RawTimeSeries": {"Description": "Raw data of a detector readout", "Author": "EDM4hep authors", "Members": ["std::uint64_t cellID // detector specific cell id", "std::int32_t quality // quality flag for the hit", "float time[ns] // time of the hit", "float charge[fC] // integrated charge of the hit", "float interval[ns] // interval of each sampling"], "VectorMembers": ["std::int32_t adcCounts // raw data (32-bit) word at i"], "OneToOneRelations": [], "OneToManyRelations": [], "ExtraCode": {}, "MutableExtraCode": {}}, "edm4hep::SenseWireHit": {"Description": "Sense wire hit, knowing only the distance to the wire. The circle representing possible positions is parametrized with its center, radius and normal vector (given by the wire direction).", "Author": "EDM4hep authors", "Members": ["std::uint64_t cellID // ID of the sensor that created this hit", "std::int32_t type // type of the raw data hit", "std::int32_t quality // quality bit flag of the hit", "float time[ns] // time of the hit", "float eDep[GeV] // energy deposited by the hit", "float eDepError[GeV] // error on eDep", "float wireStereoAngle // angle between the sense wire axis and the drift chamber axis (usually the z-axis) - use it together with wireAzimuthalAngle to get the wire direction", "float wireAzimuthalAngle // azimuthal angle at the middle of the sense wire - use it together with wireStereoAngle to get the wire direction", "edm4hep::Vector3d position[mm] // point on the sense wire which is closest to the hit (center of the circle)", "double positionAlongWireError[mm] // error on the hit position along the wire direction", "float distanceToWire[mm] // distance between the hit and the wire (radius of the circle)", "float distanceToWireError[mm] // error on distanceToWire"], "VectorMembers": ["std::uint16_t nElectrons // number of electrons for each cluster (number of clusters = vector size)"], "ExtraCode": {"declaration": "/// Return the number of clusters associated to the hit\nauto getNClusters() const { return getNElectrons().size(); }\n"}, "OneToOneRelations": [], "OneToManyRelations": [], "MutableExtraCode": {}}, "edm4hep::Track": {"Description": "Reconstructed track", "Author": "EDM4hep authors", "Members": ["std::int32_t type // flagword that defines the type of track", "float chi2 // chi-squared of the track fit", "std::int32_t ndf // number of degrees of freedom of the track fit", "std::int32_t Nholes // number of holes on track"], "VectorMembers": ["std::int32_t subdetectorHitNumbers // number of hits in particular subdetectors", "std::int32_t subdetectorHoleNumbers // number of holes in particular subdetectors", "edm4hep::TrackState trackStates // track states"], "OneToManyRelations": ["edm4hep::TrackerHit trackerHits // hits that have been used to create this track", "edm4hep::Track tracks // tracks (segments) that have been combined to create this track"], "OneToOneRelations": [], "ExtraCode": {}, "MutableExtraCode": {}}, "edm4hep::Vertex": {"Description": "Vertex", "Author": "EDM4hep authors", "Members": ["std::uint32_t type // flagword that defines the type of the vertex, see reserved bits for more information", "float chi2 // chi-squared of the vertex fit", "std::int32_t ndf // number of degrees of freedom of the vertex fit", "edm4hep::Vector3f position[mm] // position of the vertex", "edm4hep::CovMatrix3f covMatrix[mm^2] // covariance matrix of the position", "std::int32_t algorithmType // type code for the algorithm that has been used to create the vertex"], "VectorMembers": ["float parameters // additional parameters related to this vertex"], "OneToManyRelations": ["edm4hep::ReconstructedParticle particles // particles that have been used to form this vertex, aka the decay particles emerging from this vertex"], "ExtraCode": {"includes": "#include <edm4hep/Constants.h>\n#include <edm4hep/utils/bit_utils.h>\n", "declaration": "/// Get the position covariance matrix value for the two passed dimensions\nfloat getCovMatrix(edm4hep::Cartesian dimI, edm4hep::Cartesian dimJ) const { return getCovMatrix().getValue(dimI, dimJ); }\n// Reserved bits for the type flagword\nstatic constexpr int BITPrimaryVertex = 1;\nstatic constexpr int BITSecondaryVertex = 2;\nstatic constexpr int BITTertiaryVertex = 3;\n\n/// Check if this is a primary vertex\nbool isPrimary() const { return utils::checkBit(getType(), BITPrimaryVertex); }\n/// Check if this is a secondary vertex\nbool isSecondary() const { return utils::checkBit(getType(), BITSecondaryVertex); }\n/// Check if this is a tertiary vertex\nbool isTertiary() const { return utils::checkBit(getType(), BITTertiaryVertex); }\n"}, "MutableExtraCode": {"declaration": "/// Set the position covariance matrix value for the two passed dimensions\nvoid setCovMatrix(float value, edm4hep::Cartesian dimI, edm4hep::Cartesian dimJ) { getCovMatrix().setValue(value, dimI, dimJ); }\n\n/// Set the primary vertex flag for this vertex\nvoid setPrimary(bool value=true) { setType(utils::setBit(getType(), BITPrimaryVertex, value)); }\n/// Set the secondary vertex flag for this vertex\nvoid setSecondary(bool value=true) { setType(utils::setBit(getType(), BITSecondaryVertex, value)); }\n/// Set the tertiary vertex flag for this vertex\nvoid setTertiary(bool value=true) { setType(utils::setBit(getType(), BITTertiaryVertex, value)); }\n"}, "OneToOneRelations": []}, "edm4hep::ReconstructedParticle": {"Description": "Reconstructed Particle", "Author": "EDM4hep authors", "Members": ["std::int32_t PDG // PDG of the reconstructed particle.", "float energy[GeV] // energy of the reconstructed particle. Four momentum state is not kept consistent internally", "edm4hep::Vector3f momentum[GeV] // particle momentum. Four momentum state is not kept consistent internally", "edm4hep::Vector3f referencePoint[mm] // reference, i.e. where the particle has been measured", "float charge[e] // charge of the reconstructed particle", "float mass[GeV] // mass of the reconstructed particle, set independently from four vector. Four momentum state is not kept consistent internally", "float goodnessOfPID // overall goodness of the PID on a scale of [0;1]", "edm4hep::CovMatrix4f covMatrix[GeV^2] // covariance matrix of the reconstructed particle 4vector"], "OneToOneRelations": ["edm4hep::Vertex decayVertex // decay vertex for the particle (if it is a composite particle)"], "OneToManyRelations": ["edm4hep::Cluster clusters // clusters that have been used for this particle", "edm4hep::Track tracks // tracks that have been used for this particle", "edm4hep::ReconstructedParticle particles // reconstructed particles that have been combined to this particle"], "ExtraCode": {"includes": "#include <edm4hep/Constants.h>", "declaration": "bool isCompound() const { return particles_size() > 0 ;}\n/// Get the four momentum covariance matrix value for the two passed dimensions\nfloat getCovMatrix(edm4hep::FourMomCoords dimI, edm4hep::FourMomCoords dimJ) const { return getCovMatrix().getValue(dimI, dimJ); }\n"}, "MutableExtraCode": {"includes": "#include <edm4hep/Constants.h>", "declaration": "//vertex where the particle decays. This method actually returns the start vertex from the first daughter particle found.\n//TODO: edm4hep::Vertex  getEndVertex() { return  edm4hep::Vertex(  (getParticles(0).isAvailable() ? getParticles(0).getStartVertex() :  edm4hep::Vertex(0,0) ) ) ; }\n/// Set the four momentum covariance matrix value for the two passed dimensions\nvoid setCovMatrix(float value, edm4hep::FourMomCoords dimI, edm4hep::FourMomCoords dimJ) { getCovMatrix().setValue(value, dimI, dimJ); }\n"}, "VectorMembers": []}, "edm4hep::TimeSeries": {"Description": "Calibrated Detector Data", "Author": "EDM4hep authors", "Members": ["std::uint64_t cellID // cell id", "float time[ns] // begin time", "float interval[ns] // interval of each sampling"], "VectorMembers": ["float amplitude // calibrated detector data"], "OneToOneRelations": [], "OneToManyRelations": [], "ExtraCode": {}, "MutableExtraCode": {}}, "edm4hep::RecDqdx": {"Description": "dN/dx or dE/dx info of a Track", "Author": "EDM4hep authors", "Members": ["edm4hep::Quantity dQdx // the reconstructed dEdx or dNdx and its error"], "OneToOneRelations": ["edm4hep::Track track // the corresponding track"], "VectorMembers": [], "OneToManyRelations": [], "ExtraCode": {}, "MutableExtraCode": {}}, "edm4hep::GeneratorEventParameters": {"Description": "Generator Event Parameters and information", "Author": "EDM4hep authors", "Members": ["double sqrts[GeV] // sqrt(s) - The nominal beam center of mass energy", "std::array<double, 2> beamsPz[GeV] // nominal z-momentum of the two incoming particle (beams)", "std::array<int, 2> partonIds // PDG id of the partons undergoing the hard scatter", "std::array<float, 2> beamPolarizations // Polarization of the incoming beam particles"], "VectorMembers": ["double crossSections[pb] // List of cross sections", "double crossSectionErrors[pb] // List of cross section errors", "double weights // event weights. The corresponding names are stored using the edm4hep::labels::GeneratorWeightNames in the file level metadata."], "OneToManyRelations": ["edm4hep::MCParticle signalVertexParticles // List of initial state MCParticles that are the source of the hard interaction"], "OneToOneRelations": [], "ExtraCode": {}, "MutableExtraCode": {}}}, "interfaces": {"edm4hep::TrackerHit": {"Description": "Tracker hit interface class", "Author": "Thomas Madlener, DESY", "Members": ["std::uint64_t cellID // ID of the sensor that created this hit", "std::int32_t type // type of the raw data hit", "std::int32_t quality // quality bit flag of the hit", "float time[ns] // time of the hit", "float eDep[GeV] // energy deposited on the hit", "float eDepError[GeV] // error measured on eDep", "edm4hep::Vector3d position[mm] // hit position as recorded by the sensor. The exact interpretation will depend on the currently held type of the interface"], "Types": ["edm4hep::TrackerHit3D", "edm4hep::TrackerHitPlane", "edm4hep::SenseWireHit"]}}, "links": {"edm4hep::RecoMCParticleLink": {"Description": "Link between a ReconstructedParticle and an MCParticle", "Author": "EDM4hep authors", "From": "edm4hep::ReconstructedParticle", "To": "edm4hep::MCParticle"}, "edm4hep::CaloHitMCParticleLink": {"Description": "Link between a CalorimeterHit and an MCParticle", "Author": "EDM4hep authors", "From": "edm4hep::CalorimeterHit", "To": "edm4hep::MCParticle"}, "edm4hep::ClusterMCParticleLink": {"Description": "Link between a Cluster and an MCParticle", "Author": "EDM4hep authors", "From": "edm4hep::Cluster", "To": "edm4hep::MCParticle"}, "edm4hep::TrackMCParticleLink": {"Description": "Link between a Track and an MCParticle", "Author": "EDM4hep authors", "From": "edm4hep::Track", "To": "edm4hep::MCParticle"}, "edm4hep::CaloHitSimCaloHitLink": {"Description": "Link between a CalorimeterHit and a SimCalorimeterHit", "Author": "EDM4hep authors", "From": "edm4hep::CalorimeterHit", "To": "edm4hep::SimCalorimeterHit"}, "edm4hep::TrackerHitSimTrackerHitLink": {"Description": "Link between a TrackerHit and a SimTrackerHit", "Author": "EDM4hep authors", "From": "edm4hep::TrackerHit", "To": "edm4hep::SimTrackerHit"}, "edm4hep::VertexRecoParticleLink": {"Description": "Link between a Vertex and a ReconstructedParticle", "Author": "EDM4hep authors", "From": "edm4hep::Vertex", "To": "edm4hep::ReconstructedParticle"}}})DATAMODELDEF";
 
 /**
  * The names of all relations and vector members for all datatypes
  */
 inline podio::RelationNameMapping edm4hep__getRelationNames() {
   using namespace std::string_view_literals;
   return {
       {
           "edm4hep::EventHeader"sv,
           {},
           {"weights"sv},
       },
       {
           "edm4hep::MCParticle"sv,
           {"parents"sv, "daughters"sv},
           {},
       },
       {
           "edm4hep::SimTrackerHit"sv,
           {"particle"sv},
           {},
       },
       {
           "edm4hep::CaloHitContribution"sv,
           {"particle"sv},
           {},
       },
       {
           "edm4hep::SimCalorimeterHit"sv,
           {"contributions"sv},
           {},
       },
       {
           "edm4hep::RawCalorimeterHit"sv,
           {},
           {},
       },
       {
           "edm4hep::CalorimeterHit"sv,
           {},
           {},
       },
       {
           "edm4hep::ParticleID"sv,
           {"particle"sv},
           {"parameters"sv},
       },
       {
           "edm4hep::Cluster"sv,
           {"clusters"sv, "hits"sv},
           {"shapeParameters"sv, "subdetectorEnergies"sv},
       },
       {
           "edm4hep::TrackerHit3D"sv,
           {},
           {},
       },
       {
           "edm4hep::TrackerHitPlane"sv,
           {},
           {},
       },
       {
           "edm4hep::RawTimeSeries"sv,
           {},
           {"adcCounts"sv},
       },
       {
           "edm4hep::SenseWireHit"sv,
           {},
           {"nElectrons"sv},
       },
       {
           "edm4hep::Track"sv,
           {"trackerHits"sv, "tracks"sv},
           {"subdetectorHitNumbers"sv, "subdetectorHoleNumbers"sv, "trackStates"sv},
       },
       {
           "edm4hep::Vertex"sv,
           {"particles"sv},
           {"parameters"sv},
       },
       {
           "edm4hep::ReconstructedParticle"sv,
           {"clusters"sv, "tracks"sv, "particles"sv, "decayVertex"sv},
           {},
       },
       {
           "edm4hep::TimeSeries"sv,
           {},
           {"amplitude"sv},
       },
       {
           "edm4hep::RecDqdx"sv,
           {"track"sv},
           {},
       },
       {
           "edm4hep::GeneratorEventParameters"sv,
           {"signalVertexParticles"sv},
           {"crossSections"sv, "crossSectionErrors"sv, "weights"sv},
       },
   };
 }
 
 /**
  * The schema version at generation time
  */
 static constexpr podio::SchemaVersionT schemaVersion = 5;
 
 /**
  * The helper class that takes care of registering the datamodel definition to
  * the DatamodelRegistry and to provide the index in that registry.
  *
  * Implemented as a singleton mainly to ensure only a single registration of
  * each datamodel, during the constructor
  */
 class DatamodelRegistryIndex {
 public:
   static size_t value() {
     static const auto relationNames = edm4hep__getRelationNames();
     static auto index = DatamodelRegistryIndex(podio::DatamodelRegistry::mutInstance().registerDatamodel(
         "edm4hep", edm4hep__JSONDefinition, relationNames, podio::version::Version{0, 99, 4}));
     return index.m_value;
   }
 
 private:
   DatamodelRegistryIndex(size_t v) : m_value(v) {}
   size_t m_value{podio::DatamodelRegistry::NoDefinitionAvailable};
 };
 
 namespace static_registration {
   // The usual trick via an IIFE and a const variable that we assign to, to
   // ensure that we populate this before everything starts
   inline bool ensureRegistration() {
     const static auto reg = []() {
       return edm4hep::meta::DatamodelRegistryIndex::value() != podio::DatamodelRegistry::NoDefinitionAvailable;
     }();
     return reg;
   }
 
   const auto registrationEnsured = ensureRegistration();
 } // namespace static_registration
 
 } // namespace edm4hep::meta
 
 #endif

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