added Helix

Framework/Geometry/CMakeLists.txt

 
 set (GEOMETRY_SOURCES CoordinateSystem.cc)
-set (GEOMETRY_HEADERS Vector.h Point.h Sphere.h CoordinateSystem.h)
+set (GEOMETRY_HEADERS Vector.h Point.h Sphere.h CoordinateSystem.h Helix.h)
 
 add_library (CORSIKAgeometry STATIC ${GEOMETRY_SOURCES})
 

Framework/Geometry/Helix.h

+#ifndef _include_HELIX_H_
+#define _include_HELIX_H_
+
+#include <Geometry/Vector.h>
+#include <Geometry/Point.h>
+#include <Units/PhysicalUnits.h>
+
+class Helix // TODO: inherit from to-be-implemented "Trajectory"
+{
+    using SpeedVec = Vector<phys::units::speed_d>;
+    
+    Point const r0;
+    phys::units::quantity<phys::units::frequency_d> const omegaC;
+    SpeedVec const vPar;
+    SpeedVec vPerp, uPerp;
+    
+public:
+    Helix(Point const pR0, phys::units::quantity<phys::units::frequency_d> pOmegaC,
+        SpeedVec const pvPar, SpeedVec const pvPerp) :
+        r0(pR0), omegaC(pOmegaC), vPar(pvPar), vPerp(pvPerp), uPerp(vPar.normalized().cross(vPerp))
+    {
+        
+    }
+    
+    Point getPosition(phys::units::quantity<phys::units::time_interval_d> t) const
+    {
+        return r0 + vPar * t + (vPerp * (cos(omegaC * t) - 1) + uPerp * sin(omegaC * t)) / omegaC;
+    }
+};
+
+#endif

Framework/Geometry/QuantityVector.h

@@ -70,11 +70,28 @@ public:
         }
     }
     
+    template <typename ScalarDim>
+    auto operator/(phys::units::quantity<ScalarDim, double> const p) const
+    {
+        return (*this) * (1 / p);
+    }
+    
     auto operator*(double const p) const
     {
         return QuantityVector<dim>(eVector * p);
     }
     
+    auto operator/(double const p) const
+    {
+        return QuantityVector<dim>(eVector / p);
+    }
+    
+    auto& operator/=(double const p) const
+    {
+        eVector /= p;
+        return *this;
+    }
+    
     auto& operator*=(double const p)
     {
         eVector *= p;

Framework/Geometry/Vector.h

@@ -92,23 +92,34 @@ public:
     template <typename ScalarDim>
     auto operator*(phys::units::quantity<ScalarDim, double> const p) const
     {
-        using ResQuantity = decltype(BaseVector<dim>::qVector * p);
-        if constexpr (std::is_same<ResQuantity, double>::value) // result dimensionless, not a "Quantity" anymore
+        using ProdQuantity = phys::units::detail::Product<dim, ScalarDim, double, double>;
+        
+        if constexpr (std::is_same<ProdQuantity, double>::value) // result dimensionless, not a "Quantity" anymore
         {
             return Vector<phys::units::dimensionless_d>(*BaseVector<dim>::cs, BaseVector<dim>::qVector * p);
         }
         else
         {
-            using res_dim = typename decltype(BaseVector<dim>::qVector * p)::dimension;
-            return Vector<res_dim>(*BaseVector<dim>::cs, BaseVector<dim>::qVector * p);        
+            return Vector<typename ProdQuantity::dimension_type>(*BaseVector<dim>::cs, BaseVector<dim>::qVector * p);        
         }
     }
     
+    template <typename ScalarDim>
+    auto operator/(phys::units::quantity<ScalarDim, double> const p) const
+    {
+        return (*this) * (1 / p);
+    }
+    
     auto operator*(double const p) const
     {        
         return Vector<dim>(*BaseVector<dim>::cs, BaseVector<dim>::qVector * p);
     }
     
+    auto operator/(double const p) const
+    {        
+        return Vector<dim>(*BaseVector<dim>::cs, BaseVector<dim>::qVector / p);
+    }
+    
     auto& operator+=(Vector<dim> const& pVec)
     {
         BaseVector<dim>::qVector += pVec.getComponents(*BaseVector<dim>::cs);
@@ -131,12 +142,25 @@ public:
         return (*this) * (1 / norm());
     }
     
-    //~ template <typename dim2>
-    //~ auto operator*(Vector<dim2> const& pVec)
-    //~ {
-        //~ auto constexpr resulting_dim = dimension 
-        //~ return Vector<
-    //~ }
+    template <typename dim2>
+    auto cross(Vector<dim2> pV) const
+    {
+        auto const c1 = getComponents().eVector;
+        auto const c2 = pV.getComponents(*BaseVector<dim>::cs).eVector;
+        auto const bareResult = c1.cross(c2);
+        
+        using ProdQuantity = phys::units::detail::Product<dim, dim2, double, double>;
+        
+        if constexpr (std::is_same<ProdQuantity, double>::value) // result dimensionless, not a "Quantity" anymore
+        {
+            return Vector<phys::units::dimensionless_d>(*BaseVector<dim>::cs, bareResult);
+        }
+        else
+        {
+            return Vector<typename ProdQuantity::dimension_type>(*BaseVector<dim>::cs, bareResult);        
+        }
+    }
+    
 };
 
 #endif