File indexing completed on 2025-07-05 08:52:33
0001
0002
0003 #include "podio/DatamodelRegistry.h"
0004 #include "podio/SchemaEvolution.h"
0005
0006 namespace edm4hep::meta {
0007
0008
0009
0010 static constexpr auto edm4hep__JSONDefinition =
0011 R"DATAMODELDEF({"options": {"getSyntax": true, "exposePODMembers": false, "includeSubfolder": "edm4hep/"}, "schema_version": 2, "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) {}\n constexpr Vector4f(float xx, float yy, float zz, float tt) : x(xx),y(yy),z(zz),t(tt) {}\n constexpr Vector4f(const float* v) : x(v[0]),y(v[1]),z(v[2]),t(v[3]) {}\n constexpr bool operator==(const Vector4f& v) const { return (x==v.x&&y==v.y&&z==v.z&&t==v.t) ; }\n constexpr bool operator!=(const Vector4f& v) const { return !(*this == v) ; }\n constexpr 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) {}\n constexpr Vector3f(float xx, float yy, float zz) : x(xx),y(yy),z(zz) {}\n constexpr Vector3f(const float* v) : x(v[0]),y(v[1]),z(v[2]) {}\n constexpr bool operator==(const Vector3f& v) const { return (x==v.x&&y==v.y&&z==v.z) ; }\n constexpr bool operator!=(const Vector3f& v) const { return !(*this == v) ; }\n constexpr 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 "}}, "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) {}\n constexpr Vector3d(double xx, double yy, double zz) : x(xx),y(yy),z(zz) {}\n constexpr Vector3d(const double* v) : x(v[0]),y(v[1]),z(v[2]) {}\n constexpr Vector3d(const float* v) : x(v[0]),y(v[1]),z(v[2]) {}\n [[ deprecated(\"This constructor will be removed again it is mainly here for an easier transition\") ]]\n constexpr Vector3d(const Vector3f& v) : x(v.x), y(v.y), z(v.z) {}\n constexpr bool operator==(const Vector3d& v) const { return (x==v.x&&y==v.y&&z==v.z) ; }\n constexpr bool operator!=(const Vector3d& v) const { return !(*this == v) ; }\n constexpr 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::Vector2i": {"Members": ["std::int32_t a", "std::int32_t b"], "ExtraCode": {"includes": "#include <cstddef>", "declaration": " constexpr Vector2i() : a(0),b(0) {}\n constexpr Vector2i(int32_t aa, int32_t bb) : a(aa),b(bb) {}\n constexpr Vector2i( const int32_t* v) : a(v[0]), b(v[1]) {}\n constexpr bool operator==(const Vector2i& v) const { return (a==v.a&&b==v.b) ; }\n constexpr bool operator!=(const Vector2i& v) const { return !(*this == v) ; }\n constexpr int operator[](unsigned i) const {\n static_assert(\n offsetof(Vector2i,a)+sizeof(Vector2i::a) == offsetof(Vector2i,b),\n \"operator[] requires no padding\");\n return *( &a + i ) ; }\n "}}, "edm4hep::Vector2f": {"Members": ["float a", "float b"], "ExtraCode": {"includes": "#include <cstddef>", "declaration": " constexpr Vector2f() : a(0),b(0) {}\n constexpr Vector2f(float aa,float bb) : a(aa),b(bb) {}\n constexpr Vector2f(const float* v) : a(v[0]), b(v[1]) {}\n constexpr bool operator==(const Vector2f& v) const { return (a==v.a&&b==v.b) ; }\n constexpr bool operator!=(const Vector2f& v) const { return !(*this == v) ; }\n constexpr 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;\n template<typename... Vs>\n constexpr CovMatrix2f(Vs... v) : values{static_cast<float>(v)...} { static_assert(sizeof...(v) == 3, \"CovMatrix2f requires 3 values\"); }\n constexpr CovMatrix2f(const std::array<float, 3>& v) : values(v) {}\n constexpr CovMatrix2f& operator=(std::array<float, 3>& v) { values = v; return *this; }\n bool operator==(const CovMatrix2f& v) const { return v.values == values; }\n bool 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;\n constexpr CovMatrix3f(const std::array<float, 6>& v) : values(v) {}\n template<typename... Vs>\n constexpr CovMatrix3f(Vs... v) : values{static_cast<float>(v)...} { static_assert(sizeof...(v) == 6, \"CovMatrix3f requires 6 values\"); }\n constexpr CovMatrix3f& operator=(std::array<float, 6>& v) { values = v; return *this; }\n bool operator==(const CovMatrix3f& v) const { return v.values == values; }\n bool 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;\n template<typename... Vs>\n constexpr CovMatrix4f(Vs... v) : values{static_cast<float>(v)...} { static_assert(sizeof...(v) == 10, \"CovMatrix4f requires 10 values\"); }\n constexpr CovMatrix4f(const std::array<float, 10>& v) : values(v) {}\n constexpr CovMatrix4f& operator=(std::array<float, 10>& v) { values = v; return *this; }\n bool operator==(const CovMatrix4f& v) const { return v.values == values; }\n bool 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;\n template<typename... Vs>\n constexpr CovMatrix6f(Vs... v) : values{static_cast<float>(v)...} { static_assert(sizeof...(v) == 21, \"CovMatrix6f requires 21 values\"); }\n constexpr CovMatrix6f(const std::array<float, 21>& v) : values(v) {}\n constexpr CovMatrix6f& operator=(std::array<float, 21>& v) { values = v; return *this; }\n bool operator==(const CovMatrix6f& v) const { return v.values == values; }\n bool 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 // azimuthal angle", "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\n static const int AtIP = 1 ;\n static const int AtFirstHit = 2 ;\n static const int AtLastHit = 3 ;\n static const int AtCalorimeter = 4 ;\n static const int AtVertex = 5 ;\n static const int LastLocation = AtVertex ;\n\n/// Get the covariance matrix value for the two passed parameters\n constexpr 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\n constexpr void setCovMatrix(float value, edm4hep::TrackParams parI, edm4hep::TrackParams parJ) { covMatrix.setValue(value, parI, parJ); } "}}, "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::int32_t eventNumber // event number", "std::int32_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!** Event weight names should be stored using the edm4hep::EventWeights name 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 // 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", "edm4hep::Vector3f spin // spin (helicity) vector of the particle", "edm4hep::Vector2i colorFlow // color flow as defined by the generator"], "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 ) ) ; } \t\t \n void setBackscatter(bool bitval) { setSimulatorStatus( utils::setBit( getSimulatorStatus() , BITBackscatter , bitval ) ) ; } \t\t\t \n void setVertexIsNotEndpointOfParent(bool bitval) { setSimulatorStatus( utils::setBit( getSimulatorStatus() , BITVertexIsNotEndpointOfParent , bitval ) ) ; } \n void setDecayedInTracker(bool bitval) { setSimulatorStatus( utils::setBit( getSimulatorStatus() , BITDecayedInTracker , bitval ) ) ; } \t\t \n void setDecayedInCalorimeter(bool bitval) { setSimulatorStatus( utils::setBit( getSimulatorStatus() , BITDecayedInCalorimeter , bitval ) ) ; } \t\t \n void setHasLeftDetector(bool bitval) { setSimulatorStatus( utils::setBit( getSimulatorStatus() , BITLeftDetector , bitval ) ) ; } \t\t\t \n void setStopped(bool bitval) { setSimulatorStatus( utils::setBit( getSimulatorStatus() , BITStopped , bitval ) ) ; } \t\t\t\t \n void setOverlay(bool bitval) { setSimulatorStatus( utils::setBit( getSimulatorStatus() , BITOverlay , bitval ) ) ; } \n "}, "ExtraCode": {"includes": "#include <edm4hep/utils/bit_utils.h>\n", "declaration": " // define the bit positions for the simulation flag\n static const int BITCreatedInSimulation = 30;\n static const int BITBackscatter = 29 ;\n static const int BITVertexIsNotEndpointOfParent = 28 ; \n static const int BITDecayedInTracker = 27 ; \n static const int BITDecayedInCalorimeter = 26 ; \n static const int BITLeftDetector = 25 ; \n static const int BITStopped = 24 ; \n static const int BITOverlay = 23 ; \n /// return energy computed from momentum and mass \n double getEnergy() const { return 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). \n bool isCreatedInSimulation() const { return utils::checkBit(getSimulatorStatus(), BITCreatedInSimulation); } \n /// True if the particle is the result of a backscatter from a calorimeter shower. \n bool isBackscatter() const { return utils::checkBit(getSimulatorStatus(), BITBackscatter); } \n /// True if the particle's vertex is not the endpoint of the parent particle. \n bool vertexIsNotEndpointOfParent() const { return utils::checkBit(getSimulatorStatus(), BITVertexIsNotEndpointOfParent); } \n /// True if the particle has interacted in a tracking region. \n bool isDecayedInTracker() const { return utils::checkBit(getSimulatorStatus(), BITDecayedInTracker); } \n /// True if the particle has interacted in a calorimeter region. \n bool isDecayedInCalorimeter() const { return utils::checkBit(getSimulatorStatus(), BITDecayedInCalorimeter); } \n /// True if the particle has left the world volume undecayed. \n bool hasLeftDetector() const { return utils::checkBit(getSimulatorStatus(), BITLeftDetector); }\n /// True if the particle has been stopped by the simulation program. \n bool isStopped() const { return utils::checkBit(getSimulatorStatus(), BITStopped); } \n /// True if the particle has been overlayed by the simulation (or digitization) program.\n bool isOverlay() const { return utils::checkBit(getSimulatorStatus(), BITOverlay); } \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); }\n void setOverlay(bool val) { setQuality( set_bit( getQuality() , BITOverlay , val ) ) ; }\n void setProducedBySecondary(bool val) { setQuality( set_bit( getQuality() , BITProducedBySecondary , val ) ) ; }\n [[deprecated(\"use setParticle instead\")]] void setMCParticle(edm4hep::MCParticle particle) { setParticle(std::move(particle)); }\n "}, "ExtraCode": {"includes": "#include <edm4hep/MCParticle.h>\n", "declaration": " static const int BITOverlay = 31;\n static const int BITProducedBySecondary = 30;\n bool isOverlay() const { return getQuality() & (1 << BITOverlay) ; }\n bool isProducedBySecondary() const { return getQuality() & (1 << BITProducedBySecondary) ; }\n double x() const {return getPosition()[0];}\n double y() const {return getPosition()[1];}\n double z() const {return getPosition()[2];}\n double rho() const {return sqrt(x()*x() + y()*y());}\n [[deprecated(\"use getParticle instead\")]] edm4hep::MCParticle getMCParticle() const { return getParticle(); }\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[G] // energy of the this contribution", "float time[ns] // time of this contribution", "edm4hep::Vector3f stepPosition[mm] // position of this energy deposition (step)"], "OneToOneRelations": ["edm4hep::MCParticle particle // primary MCParticle that caused the shower responsible for this contribution to the hit"], "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 // covariance matrix of the position", "float iTheta // intrinsic direction of cluster at position Theta. Not to be confused with direction cluster is seen from IP", "float phi // intrinsic direction of cluster at position - Phi. Not to be confused with direction cluster is seen from IP", "edm4hep::Vector3f directionError[mm**2] // covariance matrix of the direction"], "VectorMembers": ["float shapeParameters // shape parameters. This should be accompanied by a descriptive list of names in the shapeParameterNames collection level metadata, as a vector of strings with the same ordering", "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\n float 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\n void 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 // 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\n float 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\n void 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 // measurement direction vector, u lies in the x-y plane", "edm4hep::Vector2f v // measurement direction vector, v is along z", "float du // measurement error along the direction", "float dv // measurement error along the direction", "edm4hep::Vector3d position[mm] // hit position", "edm4hep::CovMatrix3f covMatrix // 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\n float 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\n void 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::Track": {"Description": "Reconstructed track", "Author": "EDM4hep authors", "Members": ["std::int32_t type // flagword that defines the type of track", "float chi2 // Chi^2 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 // 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\n float getCovMatrix(edm4hep::Cartesian dimI, edm4hep::Cartesian dimJ) const { return getCovMatrix().getValue(dimI, dimJ); }\n // Reserved bits for the type flagword\n static constexpr int BITPrimaryVertex = 1;\n static constexpr int BITSecondaryVertex = 2;\n static constexpr int BITTertiaryVertex = 2;\n\n/// Check if this is a primary vertex\n bool isPrimary() const { return utils::checkBit(getType(), BITPrimaryVertex); }\n /// Check if this is a secondary vertex\n bool isSecondary() const { return utils::checkBit(getType(), BITSecondaryVertex); }\n /// Check if this is a tertiary vertex\n bool isTertiary() const { return utils::checkBit(getType(), BITTertiaryVertex); }\n "}, "MutableExtraCode": {"declaration": " /// Set the position covariance matrix value for the two passed dimensions\n void setCovMatrix(float value, edm4hep::Cartesian dimI, edm4hep::Cartesian dimJ) { getCovMatrix().setValue(value, dimI, dimJ); }\n\n/// Set the primary vertex flag for this vertex\n void setPrimary(bool value=true) { setType(utils::setBit(getType(), BITPrimaryVertex, value)); }\n /// Set the secondary vertex flag for this vertex\n void setSecondary(bool value=true) { setType(utils::setBit(getType(), BITSecondaryVertex, value)); }\n /// Set the tertiary vertex flag for this vertex\n void 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 // 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 // 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 [[deprecated(\"use setPDG instead\")]]\n int32_t getType() const { return getPDG(); }\n /// Get the four momentum covariance matrix value for the two passed dimensions\n float 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 [[deprecated(\"use setPDG instead\")]]\n void setType(int32_t pdg) { setPDG(pdg); }\n /// Set the four momentum covariance matrix value for the two passed dimensions\n void setCovMatrix(float value, edm4hep::FourMomCoords dimI, edm4hep::FourMomCoords dimJ) { getCovMatrix().setValue(value, dimI, dimJ); }\n "}, "VectorMembers": []}, "edm4hep::RecoMCParticleLink": {"Description": "Link between a ReconstructedParticle and the corresponding MCParticle", "Author": "EDM4hep authors", "Members": ["float weight // weight of this link"], "OneToOneRelations": ["edm4hep::ReconstructedParticle from // reference to the reconstructed particle", "edm4hep::MCParticle to // reference to the Monte-Carlo particle"], "ExtraCode": {"declaration": " [[deprecated(\"use getFrom instead\")]] edm4hep::ReconstructedParticle getRec() const;\n [[deprecated(\"use getTo instead\")]] edm4hep::MCParticle getSim() const;\n", "implementation": " edm4hep::ReconstructedParticle {name}::getRec() const { return getFrom(); }\n edm4hep::MCParticle {name}::getSim() const { return getTo(); }\n"}, "MutableExtraCode": {"declaration": " [[deprecated(\"use setFrom instead\")]]\n void setRec(const edm4hep::ReconstructedParticle& rec);\n [[deprecated(\"use setTo instead\")]]\n void setSim(const edm4hep::MCParticle& sim);\n ", "implementation": " void {name}::setSim(const edm4hep::MCParticle& sim) { setTo(sim); }\n void {name}::setRec(const edm4hep::ReconstructedParticle& rec) { setFrom(rec); }\n "}, "VectorMembers": [], "OneToManyRelations": []}, "edm4hep::CaloHitSimCaloHitLink": {"Description": "Link between a CalorimeterHit and the corresponding SimCalorimeterHit", "Author": "EDM4hep authors", "Members": ["float weight // weight of this link"], "OneToOneRelations": ["edm4hep::CalorimeterHit from // reference to the reconstructed hit", "edm4hep::SimCalorimeterHit to // reference to the simulated hit"], "ExtraCode": {"declaration": " [[deprecated(\"use getFrom instead\")]] edm4hep::CalorimeterHit getRec() const;\n [[deprecated(\"use getTo instead\")]] edm4hep::SimCalorimeterHit getSim() const;\n", "implementation": " edm4hep::CalorimeterHit {name}::getRec() const { return getFrom(); }\n edm4hep::SimCalorimeterHit {name}::getSim() const { return getTo(); }\n"}, "MutableExtraCode": {"declaration": " [[deprecated(\"use setFrom instead\")]]\n void setRec(const edm4hep::CalorimeterHit& rec);\n [[deprecated(\"use setTo instead\")]]\n void setSim(const edm4hep::SimCalorimeterHit& sim);\n ", "implementation": " void {name}::setSim(const edm4hep::SimCalorimeterHit& sim) { setTo(sim); }\n void {name}::setRec(const edm4hep::CalorimeterHit& rec) { setFrom(rec); }\n "}, "VectorMembers": [], "OneToManyRelations": []}, "edm4hep::TrackerHitSimTrackerHitLink": {"Description": "Link between a TrackerHit and the corresponding SimTrackerHit", "Author": "EDM4hep authors", "Members": ["float weight // weight of this link"], "OneToOneRelations": ["edm4hep::TrackerHit from // reference to the reconstructed hit", "edm4hep::SimTrackerHit to // reference to the simulated hit"], "ExtraCode": {"declaration": " [[deprecated(\"use getFrom instead\")]] edm4hep::TrackerHit getRec() const;\n [[deprecated(\"use getTo instead\")]] edm4hep::SimTrackerHit getSim() const;\n", "implementation": " edm4hep::TrackerHit {name}::getRec() const { return getFrom(); }\n edm4hep::SimTrackerHit {name}::getSim() const { return getTo(); }\n"}, "MutableExtraCode": {"declaration": " [[deprecated(\"use setFrom instead\")]]\n void setRec(const edm4hep::TrackerHit& rec);\n [[deprecated(\"use setTo instead\")]]\n void setSim(const edm4hep::SimTrackerHit& sim);\n ", "implementation": " void {name}::setSim(const edm4hep::SimTrackerHit& sim) { setTo(sim); }\n void {name}::setRec(const edm4hep::TrackerHit& rec) { setFrom(rec); }\n "}, "VectorMembers": [], "OneToManyRelations": []}, "edm4hep::CaloHitMCParticleLink": {"Description": "Link between a CalorimeterHit and the corresponding MCParticle", "Author": "EDM4hep authors", "Members": ["float weight // weight of this link"], "OneToOneRelations": ["edm4hep::CalorimeterHit from // reference to the reconstructed hit", "edm4hep::MCParticle to // reference to the Monte-Carlo particle"], "ExtraCode": {"declaration": " [[deprecated(\"use getFrom instead\")]] edm4hep::CalorimeterHit getRec() const;\n [[deprecated(\"use getTo instead\")]] edm4hep::MCParticle getSim() const;\n", "implementation": " edm4hep::CalorimeterHit {name}::getRec() const { return getFrom(); }\n edm4hep::MCParticle {name}::getSim() const { return getTo(); }\n"}, "MutableExtraCode": {"declaration": " [[deprecated(\"use setFrom instead\")]]\n void setRec(const edm4hep::CalorimeterHit& rec);\n [[deprecated(\"use setTo instead\")]]\n void setSim(const edm4hep::MCParticle& sim);\n ", "implementation": " void {name}::setSim(const edm4hep::MCParticle& sim) { setTo(sim); }\n void {name}::setRec(const edm4hep::CalorimeterHit& rec) { setFrom(rec); }\n "}, "VectorMembers": [], "OneToManyRelations": []}, "edm4hep::ClusterMCParticleLink": {"Description": "Link between a Cluster and the corresponding MCParticle", "Author": "EDM4hep authors", "Members": ["float weight // weight of this link"], "OneToOneRelations": ["edm4hep::Cluster from // reference to the cluster", "edm4hep::MCParticle to // reference to the Monte-Carlo particle"], "ExtraCode": {"declaration": " [[deprecated(\"use getFrom instead\")]] edm4hep::Cluster getRec() const;\n [[deprecated(\"use getTo instead\")]] edm4hep::MCParticle getSim() const;\n", "implementation": " edm4hep::Cluster {name}::getRec() const { return getFrom(); }\n edm4hep::MCParticle {name}::getSim() const { return getTo(); }\n"}, "MutableExtraCode": {"declaration": " [[deprecated(\"use setFrom instead\")]]\n void setRec(const edm4hep::Cluster& rec);\n [[deprecated(\"use setTo instead\")]]\n void setSim(const edm4hep::MCParticle& sim);\n ", "implementation": " void {name}::setSim(const edm4hep::MCParticle& sim) { setTo(sim); }\n void {name}::setRec(const edm4hep::Cluster& rec) { setFrom(rec); }\n "}, "VectorMembers": [], "OneToManyRelations": []}, "edm4hep::TrackMCParticleLink": {"Description": "Link between a Track and the corresponding MCParticle", "Author": "EDM4hep authors", "Members": ["float weight // weight of this link"], "OneToOneRelations": ["edm4hep::Track from // reference to the track", "edm4hep::MCParticle to // reference to the Monte-Carlo particle"], "ExtraCode": {"declaration": " [[deprecated(\"use getFrom instead\")]] edm4hep::Track getRec() const;\n [[deprecated(\"use getTo instead\")]] edm4hep::MCParticle getSim() const;\n", "implementation": " edm4hep::Track {name}::getRec() const { return getFrom(); }\n edm4hep::MCParticle {name}::getSim() const { return getTo(); }\n"}, "MutableExtraCode": {"declaration": " [[deprecated(\"use setFrom instead\")]]\n void setRec(const edm4hep::Track& rec);\n [[deprecated(\"use setTo instead\")]]\n void setSim(const edm4hep::MCParticle& sim);\n ", "implementation": " void {name}::setSim(const edm4hep::MCParticle& sim) { setTo(sim); }\n void {name}::setRec(const edm4hep::Track& rec) { setFrom(rec); }\n "}, "VectorMembers": [], "OneToManyRelations": []}, "edm4hep::VertexRecoParticleLink": {"Description": "Link between a Vertex and a ReconstructedParticle", "Author": "EDM4hep authors", "Members": ["float weight // weight of this link"], "OneToOneRelations": ["edm4hep::ReconstructedParticle to // reference to the reconstructed particle", "edm4hep::Vertex from // reference to the vertex"], "ExtraCode": {"declaration": " [[deprecated(\"use getTo instead\")]] edm4hep::ReconstructedParticle getRec() const;\n [[deprecated(\"use getFrom instead\")]] edm4hep::Vertex getVertex() const;\n", "implementation": " edm4hep::ReconstructedParticle {name}::getRec() const { return getTo(); }\n edm4hep::Vertex {name}::getVertex() const { return getFrom(); }\n"}, "MutableExtraCode": {"declaration": " [[deprecated(\"use setFrom instead\")]]\n void setVertex(const edm4hep::Vertex& rec);\n [[deprecated(\"use setTo instead\")]]\n void setRec(const edm4hep::ReconstructedParticle& sim);\n ", "implementation": " void {name}::setVertex(const edm4hep::Vertex& vertex) { setFrom(vertex); }\n void {name}::setRec(const edm4hep::ReconstructedParticle& rec) { setTo(rec); }\n "}, "VectorMembers": [], "OneToManyRelations": []}, "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", "Author": "EDM4hep authors", "Members": ["double eventScale // event scale", "double alphaQED // alpha_QED", "double alphaQCD // alpha_QCD", "int signalProcessId // id of signal process", "double sqrts[GeV] // sqrt(s)"], "VectorMembers": ["double crossSections[pb] // list of cross sections", "double crossSectionErrors[pb] // list of cross section errors"], "OneToManyRelations": ["edm4hep::MCParticle signalVertex // List of initial state MCParticle that are the source of the hard interaction"], "OneToOneRelations": [], "ExtraCode": {}, "MutableExtraCode": {}}, "edm4hep::GeneratorPdfInfo": {"Description": "Generator pdf information", "Author": "EDM4hep authors", "Members": ["std::array<int, 2> partonId // Parton PDG id", "std::array<int, 2> lhapdfId // LHAPDF PDF id (see https://lhapdf.hepforge.org/pdfsets.html)", "std::array<double, 2> x // Parton momentum fraction", "std::array<double, 2> xf // PDF value", "double scale[GeV] // Factorisation scale"], "VectorMembers": [], "OneToOneRelations": [], "OneToManyRelations": [], "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"], "Types": ["edm4hep::TrackerHit3D", "edm4hep::TrackerHitPlane"]}}, "links": {}})DATAMODELDEF";
0012
0013
0014
0015
0016 inline podio::RelationNameMapping edm4hep__getRelationNames() {
0017 using namespace std::string_view_literals;
0018 return {
0019 {
0020 "edm4hep::EventHeader"sv,
0021 {},
0022 {"weights"sv},
0023 },
0024 {
0025 "edm4hep::MCParticle"sv,
0026 {"parents"sv, "daughters"sv},
0027 {},
0028 },
0029 {
0030 "edm4hep::SimTrackerHit"sv,
0031 {"particle"sv},
0032 {},
0033 },
0034 {
0035 "edm4hep::CaloHitContribution"sv,
0036 {"particle"sv},
0037 {},
0038 },
0039 {
0040 "edm4hep::SimCalorimeterHit"sv,
0041 {"contributions"sv},
0042 {},
0043 },
0044 {
0045 "edm4hep::RawCalorimeterHit"sv,
0046 {},
0047 {},
0048 },
0049 {
0050 "edm4hep::CalorimeterHit"sv,
0051 {},
0052 {},
0053 },
0054 {
0055 "edm4hep::ParticleID"sv,
0056 {"particle"sv},
0057 {"parameters"sv},
0058 },
0059 {
0060 "edm4hep::Cluster"sv,
0061 {"clusters"sv, "hits"sv},
0062 {"shapeParameters"sv, "subdetectorEnergies"sv},
0063 },
0064 {
0065 "edm4hep::TrackerHit3D"sv,
0066 {},
0067 {},
0068 },
0069 {
0070 "edm4hep::TrackerHitPlane"sv,
0071 {},
0072 {},
0073 },
0074 {
0075 "edm4hep::RawTimeSeries"sv,
0076 {},
0077 {"adcCounts"sv},
0078 },
0079 {
0080 "edm4hep::Track"sv,
0081 {"trackerHits"sv, "tracks"sv},
0082 {"subdetectorHitNumbers"sv, "subdetectorHoleNumbers"sv, "trackStates"sv},
0083 },
0084 {
0085 "edm4hep::Vertex"sv,
0086 {"particles"sv},
0087 {"parameters"sv},
0088 },
0089 {
0090 "edm4hep::ReconstructedParticle"sv,
0091 {"clusters"sv, "tracks"sv, "particles"sv, "decayVertex"sv},
0092 {},
0093 },
0094 {
0095 "edm4hep::RecoMCParticleLink"sv,
0096 {"from"sv, "to"sv},
0097 {},
0098 },
0099 {
0100 "edm4hep::CaloHitSimCaloHitLink"sv,
0101 {"from"sv, "to"sv},
0102 {},
0103 },
0104 {
0105 "edm4hep::TrackerHitSimTrackerHitLink"sv,
0106 {"from"sv, "to"sv},
0107 {},
0108 },
0109 {
0110 "edm4hep::CaloHitMCParticleLink"sv,
0111 {"from"sv, "to"sv},
0112 {},
0113 },
0114 {
0115 "edm4hep::ClusterMCParticleLink"sv,
0116 {"from"sv, "to"sv},
0117 {},
0118 },
0119 {
0120 "edm4hep::TrackMCParticleLink"sv,
0121 {"from"sv, "to"sv},
0122 {},
0123 },
0124 {
0125 "edm4hep::VertexRecoParticleLink"sv,
0126 {"to"sv, "from"sv},
0127 {},
0128 },
0129 {
0130 "edm4hep::TimeSeries"sv,
0131 {},
0132 {"amplitude"sv},
0133 },
0134 {
0135 "edm4hep::RecDqdx"sv,
0136 {"track"sv},
0137 {},
0138 },
0139 {
0140 "edm4hep::GeneratorEventParameters"sv,
0141 {"signalVertex"sv},
0142 {"crossSections"sv, "crossSectionErrors"sv},
0143 },
0144 {
0145 "edm4hep::GeneratorPdfInfo"sv,
0146 {},
0147 {},
0148 },
0149 };
0150 }
0151
0152
0153
0154
0155 static constexpr podio::SchemaVersionT schemaVersion = 2;
0156
0157
0158
0159
0160
0161
0162
0163
0164 class DatamodelRegistryIndex {
0165 public:
0166 static size_t value() {
0167 static const auto relationNames = edm4hep__getRelationNames();
0168 static auto index = DatamodelRegistryIndex(podio::DatamodelRegistry::mutInstance().registerDatamodel(
0169 "edm4hep", edm4hep__JSONDefinition, relationNames, podio::version::Version{0, 99, 1}));
0170 return index.m_value;
0171 }
0172
0173 private:
0174 DatamodelRegistryIndex(size_t v) : m_value(v) {
0175 }
0176 size_t m_value{podio::DatamodelRegistry::NoDefinitionAvailable};
0177 };
0178
0179 namespace static_registration {
0180
0181
0182 inline bool ensureRegistration() {
0183 const static auto reg = []() {
0184 return edm4hep::meta::DatamodelRegistryIndex::value() != podio::DatamodelRegistry::NoDefinitionAvailable;
0185 }();
0186 return reg;
0187 }
0188
0189 const auto registrationEnsured = ensureRegistration();
0190 }
0191
0192 }
