feat: use the UPSTREAM_EDM cmake option (NEEDS podio > 0.14.3)

This will allow eicd to use the upstream edm4hep instead of reimplementing it.

This will maintain the associations with explicit indices for now, since they are easier to use outside of ROOT-based environments.

• revert a906e3cd

utils/include/eicd/vector_utils_legacy.h

@@ -10,8 +10,6 @@
 
 #include <edm4hep/Vector2f.h>
 #include <edm4hep/Vector3f.h>
-#include <eicd/Vector2f.h>
-#include <eicd/Vector3f.h>
 
 namespace eicd {
 
@@ -28,15 +26,6 @@ template <class V> auto vector_y(const V& v) { return v.y; }
 template <class V> auto vector_z(const V& v) { return v.z; }
 // Vector2f uses a,b instead of x,y
 template <>
-inline auto vector_x<eicd::Vector2f>(const eicd::Vector2f& v) {
-  return v.a;
-}
-template <>
-inline auto vector_y<eicd::Vector2f>(const eicd::Vector2f& v) {
-  return v.b;
-}
-// Vector2f uses a,b instead of x,y
-template <>
 inline auto vector_x<edm4hep::Vector2f>(const edm4hep::Vector2f& v) {
   return v.a;
 }
@@ -46,10 +35,6 @@ inline auto vector_y<edm4hep::Vector2f>(const edm4hep::Vector2f& v) {
 }
 // no z-component for 2D vectors
 template <>
-inline auto vector_z<eicd::Vector2f>(const eicd::Vector2f& v) {
-  return 0;
-}
-template <>
 inline auto vector_z<edm4hep::Vector2f>(const edm4hep::Vector2f& v) {
   return 0;
 }
@@ -120,61 +105,61 @@ template <class V> double projection(const V& v, const V& v1) {
 
 } // namespace eicd
 
-inline eicd::Vector2f operator+(const eicd::Vector2f& v1,
-                                const eicd::Vector2f& v2) {
-  using ValueType = decltype(eicd::vector_x(eicd::Vector2f()));
+inline edm4hep::Vector2f operator+(const edm4hep::Vector2f& v1,
+                                   const edm4hep::Vector2f& v2) {
+  using ValueType = decltype(eicd::vector_x(edm4hep::Vector2f()));
   const ValueType x = eicd::vector_x(v1) + eicd::vector_x(v2);
   const ValueType y = eicd::vector_y(v1) + eicd::vector_y(v2);
   return {x, y};
 }
-inline eicd::Vector3f operator+(const eicd::Vector3f& v1,
-                                const eicd::Vector3f& v2) {
-  using ValueType = decltype(eicd::vector_x(eicd::Vector3f()));
+inline edm4hep::Vector3f operator+(const edm4hep::Vector3f& v1,
+                                   const edm4hep::Vector3f& v2) {
+  using ValueType = decltype(eicd::vector_x(edm4hep::Vector3f()));
   const ValueType x = eicd::vector_x(v1) + eicd::vector_x(v2);
   const ValueType y = eicd::vector_y(v1) + eicd::vector_y(v2);
   const ValueType z = eicd::vector_z(v1) + eicd::vector_z(v2);
   return {x, y, z};
 }
-inline double operator*(const eicd::Vector2f& v1, const eicd::Vector2f& v2) {
+inline double operator*(const edm4hep::Vector2f& v1, const edm4hep::Vector2f& v2) {
   return eicd::vector_x(v1) * eicd::vector_x(v2) +
          eicd::vector_y(v1) * eicd::vector_y(v2);
 }
-inline double operator*(const eicd::Vector3f& v1, const eicd::Vector3f& v2) {
+inline double operator*(const edm4hep::Vector3f& v1, const edm4hep::Vector3f& v2) {
   return eicd::vector_x(v1) * eicd::vector_x(v2) +
          eicd::vector_y(v1) * eicd::vector_y(v2) +
          eicd::vector_z(v1) * eicd::vector_z(v2);
 }
-inline eicd::Vector2f operator*(const double d, const eicd::Vector2f& v) {
-  using ValueType = decltype(eicd::vector_x(eicd::Vector2f()));
+inline edm4hep::Vector2f operator*(const double d, const edm4hep::Vector2f& v) {
+  using ValueType = decltype(eicd::vector_x(edm4hep::Vector2f()));
   const ValueType x = d * eicd::vector_x(v);
   const ValueType y = d * eicd::vector_y(v);
   return {x, y};
 }
-inline eicd::Vector3f operator*(const double d, const eicd::Vector3f& v) {
-  using ValueType = decltype(eicd::vector_x(eicd::Vector3f()));
+inline edm4hep::Vector3f operator*(const double d, const edm4hep::Vector3f& v) {
+  using ValueType = decltype(eicd::vector_x(edm4hep::Vector3f()));
   const ValueType x = d * eicd::vector_x(v);
   const ValueType y = d * eicd::vector_y(v);
   const ValueType z = d * eicd::vector_z(v);
   return {x, y, z};
 }
-inline eicd::Vector2f operator*(const eicd::Vector2f& v, const double d) {
+inline edm4hep::Vector2f operator*(const edm4hep::Vector2f& v, const double d) {
   return d * v;
 }
-inline eicd::Vector3f operator*(const eicd::Vector3f& v, const double d) {
+inline edm4hep::Vector3f operator*(const edm4hep::Vector3f& v, const double d) {
   return d * v;
 }
-inline eicd::Vector2f operator-(const eicd::Vector2f& v1,
-                                const eicd::Vector2f& v2) {
+inline edm4hep::Vector2f operator-(const edm4hep::Vector2f& v1,
+                                   const edm4hep::Vector2f& v2) {
   return v1 + (-1. * v2);
 }
-inline eicd::Vector3f operator-(const eicd::Vector3f& v1,
-                                const eicd::Vector3f& v2) {
+inline edm4hep::Vector3f operator-(const edm4hep::Vector3f& v1,
+                                   const edm4hep::Vector3f& v2) {
   return v1 + (-1. * v2);
 }
-inline eicd::Vector2f operator/(const eicd::Vector2f& v, const double d) {
+inline edm4hep::Vector2f operator/(const edm4hep::Vector2f& v, const double d) {
   return (1. / d) * v;
 }
-inline eicd::Vector3f operator/(const eicd::Vector3f& v, const double d) {
+inline edm4hep::Vector3f operator/(const edm4hep::Vector3f& v, const double d) {
   return (1. / d) * v;
 }
 #endif