chore: Make use of algebra shorthands (#3998)

<!-- This is an auto-generated comment: release notes by coderabbit.ai -->
## Summary by CodeRabbit

- **New Features**
	- Enhanced type consistency across various classes and methods, particularly for matrix representations.
	- Added new test cases for the `Gx2Fitter` and `ImpactPointEstimator` to improve coverage and robustness.

- **Bug Fixes**
	- Adjusted variable types in tests to align with updated matrix types, ensuring accurate calculations and validations.

- **Documentation**
	- Updated comments and documentation to reflect changes in type definitions and method signatures.

- **Chores**
	- Refactored code to replace `ActsMatrix` with `SquareMatrix` types for better clarity and maintainability across the codebase.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Core/include/Acts/Definitions/Algebra.hpp

@@ -77,8 +77,8 @@ using Translation2 = Eigen::Translation<double, 2>;
 using Translation3 = Eigen::Translation<double, 3>;
 
 // linear (rotation) matrices
-using RotationMatrix2 = ActsMatrix<2, 2>;
-using RotationMatrix3 = ActsMatrix<3, 3>;
+using RotationMatrix2 = SquareMatrix2;
+using RotationMatrix3 = SquareMatrix3;
 
 // pure rotation defined by a rotation angle around a rotation axis
 using AngleAxis3 = Eigen::AngleAxis<double>;

Core/include/Acts/EventData/GenericBoundTrackParameters.hpp

@@ -123,10 +123,10 @@ class GenericBoundTrackParameters {
   /// Parameters vector.
   const ParametersVector& parameters() const { return m_params; }
   /// Vector of spatial impact parameters (i.e., d0 and z0)
-  ActsVector<2> spatialImpactParameters() const { return m_params.head<2>(); }
+  Vector2 spatialImpactParameters() const { return m_params.head<2>(); }
   /// Vector of spatial and temporal impact parameters (i.e., d0, z0, and t)
-  ActsVector<3> impactParameters() const {
-    ActsVector<3> ip;
+  Vector3 impactParameters() const {
+    Vector3 ip;
     ip.template head<2>() = m_params.template head<2>();
     ip(2) = m_params(eBoundTime);
     return ip;

Core/include/Acts/EventData/MultiTrajectoryBackendConcept.hpp

@@ -56,7 +56,7 @@ concept CommonMultiTrajectoryBackend =
 
       {
         cv.template calibrated_impl<2>(istate)
-      } -> std::same_as<Eigen::Map<const ActsVector<2>>>;
+      } -> std::same_as<Eigen::Map<const Vector2>>;
 
       {
         cv.template calibratedCovariance_impl<2>(istate)
@@ -86,7 +86,7 @@ concept ConstMultiTrajectoryBackend =
 
       {
         v.template calibrated_impl<2>(istate)
-      } -> std::same_as<Eigen::Map<const ActsVector<2>>>;
+      } -> std::same_as<Eigen::Map<const Vector2>>;
 
       {
         v.template calibratedCovariance_impl<2>(istate)
@@ -107,7 +107,7 @@ concept MutableMultiTrajectoryBackend =
 
       {
         v.template calibrated_impl<2>(istate)
-      } -> std::same_as<Eigen::Map<ActsVector<2>>>;
+      } -> std::same_as<Eigen::Map<Vector2>>;
 
       {
         v.template calibratedCovariance_impl<2>(istate)

Core/include/Acts/EventData/TrackStateProxyConcept.hpp

@@ -28,10 +28,10 @@ using Covariance = Eigen::Map<BoundMatrix>;
 using ConstParameters = Eigen::Map<const BoundVector>;
 using ConstCovariance = Eigen::Map<const BoundMatrix>;
 
-using Measurement = Eigen::Map<ActsVector<2>>;
+using Measurement = Eigen::Map<Vector2>;
 using MeasurementCovariance = Eigen::Map<ActsSquareMatrix<2>>;
 
-using ConstMeasurement = Eigen::Map<const ActsVector<2>>;
+using ConstMeasurement = Eigen::Map<const Vector2>;
 using ConstMeasurementCovariance = Eigen::Map<const ActsSquareMatrix<2>>;
 
 using DynamicMeasurement =

Core/include/Acts/EventData/detail/MultiTrajectoryTestsCommon.hpp

@@ -1235,7 +1235,7 @@ class MultiTrajectoryTestsCommon {
     auto [par2, cov2] = generateBoundParametersCovariance(rng, {});
 
     ts.allocateCalibrated(3);
-    BOOST_CHECK_EQUAL(ts.template calibrated<3>(), ActsVector<3>::Zero());
+    BOOST_CHECK_EQUAL(ts.template calibrated<3>(), Vector3::Zero());
     BOOST_CHECK_EQUAL(ts.template calibratedCovariance<3>(),
                       ActsSquareMatrix<3>::Zero());
 

Core/include/Acts/EventData/detail/TestSourceLink.hpp

@@ -41,7 +41,7 @@ struct TestSourceLink final {
   std::size_t sourceId = 0u;
   // use eBoundSize to indicate unused indices
   std::array<BoundIndices, 2> indices = {eBoundSize, eBoundSize};
-  Acts::ActsVector<2> parameters;
+  Acts::Vector2 parameters;
   Acts::ActsSquareMatrix<2> covariance;
 
   /// Construct a source link for a 1d measurement.
@@ -52,10 +52,10 @@ struct TestSourceLink final {
         sourceId(sid),
         indices{idx, eBoundSize},
         parameters(val, 0),
-        covariance(Acts::ActsVector<2>(var, 0).asDiagonal()) {}
+        covariance(Acts::Vector2(var, 0).asDiagonal()) {}
   /// Construct a source link for a 2d measurement.
   TestSourceLink(BoundIndices idx0, BoundIndices idx1,
-                 const Acts::ActsVector<2>& params,
+                 const Acts::Vector2& params,
                  const Acts::ActsSquareMatrix<2>& cov,
                  GeometryIdentifier gid = GeometryIdentifier(),
                  std::size_t sid = 0u)

Core/include/Acts/MagneticField/ConstantBField.hpp

@@ -45,14 +45,14 @@ class ConstantBField final : public MagneticFieldProvider {
     return Result<Vector3>::success(m_BField);
   }
 
-  /// @copydoc MagneticFieldProvider::getFieldGradient(const Vector3&,ActsMatrix<3,3>&,MagneticFieldProvider::Cache&) const
+  /// @copydoc MagneticFieldProvider::getFieldGradient(const Vector3&,SquareMatrix3&,MagneticFieldProvider::Cache&) const
   ///
   /// @note The @p position is ignored and only kept as argument to provide
   ///       a consistent interface with other magnetic field services.
   /// @note currently the derivative is not calculated
   /// @todo return derivative
   Result<Vector3> getFieldGradient(
-      const Vector3& position, ActsMatrix<3, 3>& derivative,
+      const Vector3& position, SquareMatrix3& derivative,
       MagneticFieldProvider::Cache& cache) const override {
     (void)position;
     (void)derivative;

Core/include/Acts/MagneticField/InterpolatedBFieldMap.hpp

@@ -308,13 +308,13 @@ class InterpolatedBFieldMap : public InterpolatedMagneticField {
     return Result<Vector3>::success((*lcache.fieldCell).getField(gridPosition));
   }
 
-  /// @copydoc MagneticFieldProvider::getFieldGradient(const Vector3&,ActsMatrix<3,3>&,MagneticFieldProvider::Cache&) const
+  /// @copydoc MagneticFieldProvider::getFieldGradient(const Vector3&,SquareMatrix3&,MagneticFieldProvider::Cache&) const
   ///
   /// @note currently the derivative is not calculated
   /// @note Cache is not used currently
   /// @todo return derivative
   Result<Vector3> getFieldGradient(
-      const Vector3& position, ActsMatrix<3, 3>& derivative,
+      const Vector3& position, SquareMatrix3& derivative,
       MagneticFieldProvider::Cache& cache) const final {
     (void)derivative;
     return getField(position, cache);

Core/include/Acts/MagneticField/MagneticFieldProvider.hpp

@@ -50,7 +50,7 @@ class MagneticFieldProvider {
   /// @param [in,out] cache Field provider specific cache object
   /// @return magnetic field vector
   virtual Result<Vector3> getFieldGradient(const Vector3& position,
-                                           ActsMatrix<3, 3>& derivative,
+                                           SquareMatrix3& derivative,
                                            Cache& cache) const = 0;
 
   virtual ~MagneticFieldProvider();

Core/include/Acts/MagneticField/MultiRangeBField.hpp

@@ -62,7 +62,7 @@ class MultiRangeBField final : public MagneticFieldProvider {
   ///
   /// @warning This is not currently implemented.
   Result<Vector3> getFieldGradient(
-      const Vector3& position, ActsMatrix<3, 3>& /*unused*/,
+      const Vector3& position, SquareMatrix3& /*unused*/,
       MagneticFieldProvider::Cache& cache) const override;
 };
 }  // namespace Acts

Core/include/Acts/MagneticField/NullBField.hpp

@@ -37,14 +37,14 @@ class NullBField final : public MagneticFieldProvider {
     return Result<Vector3>::success(m_BField);
   }
 
-  /// @copydoc MagneticFieldProvider::getFieldGradient(const Vector3&,ActsMatrix<3,3>&,MagneticFieldProvider::Cache&) const
+  /// @copydoc MagneticFieldProvider::getFieldGradient(const Vector3&,SquareMatrix3&,MagneticFieldProvider::Cache&) const
   ///
   /// @note The @p position is ignored and only kept as argument to provide
   ///       a consistent interface with other magnetic field services.
   /// @note currently the derivative is not calculated
   /// @todo return derivative
   Result<Vector3> getFieldGradient(
-      const Vector3& position, ActsMatrix<3, 3>& derivative,
+      const Vector3& position, SquareMatrix3& derivative,
       MagneticFieldProvider::Cache& cache) const override {
     (void)position;
     (void)derivative;

Core/include/Acts/MagneticField/SolenoidBField.hpp

@@ -111,12 +111,12 @@ class SolenoidBField final : public MagneticFieldProvider {
   Result<Vector3> getField(const Vector3& position,
                            MagneticFieldProvider::Cache& cache) const override;
 
-  /// @copydoc MagneticFieldProvider::getFieldGradient(const Vector3&,ActsMatrix<3,3>&,MagneticFieldProvider::Cache&) const
+  /// @copydoc MagneticFieldProvider::getFieldGradient(const Vector3&,SquareMatrix3&,MagneticFieldProvider::Cache&) const
   ///
   /// @note currently the derivative is not calculated
   /// @todo return derivative
   Result<Vector3> getFieldGradient(
-      const Vector3& position, ActsMatrix<3, 3>& derivative,
+      const Vector3& position, SquareMatrix3& derivative,
       MagneticFieldProvider::Cache& cache) const override;
 
  private:

Core/include/Acts/Propagator/EigenStepperDefaultExtension.hpp

@@ -175,10 +175,10 @@ struct EigenStepperDefaultExtension {
     auto dGdT = D.block<3, 3>(4, 4);
     auto dGdL = D.block<3, 1>(4, 7);
 
-    ActsMatrix<3, 3> dk1dT = ActsMatrix<3, 3>::Zero();
-    ActsMatrix<3, 3> dk2dT = ActsMatrix<3, 3>::Identity();
-    ActsMatrix<3, 3> dk3dT = ActsMatrix<3, 3>::Identity();
-    ActsMatrix<3, 3> dk4dT = ActsMatrix<3, 3>::Identity();
+    SquareMatrix3 dk1dT = SquareMatrix3::Zero();
+    SquareMatrix3 dk2dT = SquareMatrix3::Identity();
+    SquareMatrix3 dk3dT = SquareMatrix3::Identity();
+    SquareMatrix3 dk4dT = SquareMatrix3::Identity();
 
     Vector3 dk1dL = Vector3::Zero();
     Vector3 dk2dL = Vector3::Zero();

Core/include/Acts/Propagator/EigenStepperDenseExtension.hpp

@@ -263,10 +263,10 @@ struct EigenStepperDenseExtension {
     auto dGdT = D.block<3, 3>(4, 4);
     auto dGdL = D.block<3, 1>(4, 7);
 
-    ActsMatrix<3, 3> dk1dT = ActsMatrix<3, 3>::Zero();
-    ActsMatrix<3, 3> dk2dT = ActsMatrix<3, 3>::Identity();
-    ActsMatrix<3, 3> dk3dT = ActsMatrix<3, 3>::Identity();
-    ActsMatrix<3, 3> dk4dT = ActsMatrix<3, 3>::Identity();
+    SquareMatrix3 dk1dT = SquareMatrix3::Zero();
+    SquareMatrix3 dk2dT = SquareMatrix3::Identity();
+    SquareMatrix3 dk3dT = SquareMatrix3::Identity();
+    SquareMatrix3 dk4dT = SquareMatrix3::Identity();
 
     Vector3 dk1dL = Vector3::Zero();
     Vector3 dk2dL = Vector3::Zero();

Core/include/Acts/Surfaces/CylinderBounds.hpp

@@ -145,7 +145,7 @@ class CylinderBounds : public SurfaceBounds {
   Vector2 shifted(const Vector2& lposition) const;
 
   /// Return the jacobian into the polar coordinate
-  ActsMatrix<2, 2> jacobian() const;
+  SquareMatrix2 jacobian() const;
 };
 
 inline std::vector<double> CylinderBounds::values() const {

Core/include/Acts/Surfaces/DiscTrapezoidBounds.hpp

@@ -151,7 +151,7 @@ class DiscTrapezoidBounds : public DiscBounds {
   /// into its Cartesian representation
   ///
   /// @param lposition The local position in polar coordinates
-  ActsMatrix<2, 2> jacobianToLocalCartesian(const Vector2& lposition) const;
+  SquareMatrix2 jacobianToLocalCartesian(const Vector2& lposition) const;
 };
 
 inline double DiscTrapezoidBounds::rMin() const {

Core/include/Acts/Utilities/VectorHelpers.hpp

@@ -178,8 +178,8 @@ inline double cast(const Vector3& position, BinningValue bval) {
 /// @param [in] m Matrix that will be used for cross products
 /// @param [in] v Vector for cross products
 /// @return Constructed matrix
-inline ActsMatrix<3, 3> cross(const ActsMatrix<3, 3>& m, const Vector3& v) {
-  ActsMatrix<3, 3> r;
+inline SquareMatrix3 cross(const SquareMatrix3& m, const Vector3& v) {
+  SquareMatrix3 r;
   r.col(0) = m.col(0).cross(v);
   r.col(1) = m.col(1).cross(v);
   r.col(2) = m.col(2).cross(v);

Core/src/MagneticField/MultiRangeBField.cpp

@@ -71,7 +71,7 @@ Result<Vector3> MultiRangeBField::getField(
 }
 
 Result<Vector3> MultiRangeBField::getFieldGradient(
-    const Vector3& position, ActsMatrix<3, 3>& /*unused*/,
+    const Vector3& position, SquareMatrix3& /*unused*/,
     MagneticFieldProvider::Cache& cache) const {
   return getField(position, cache);
 }

Core/src/MagneticField/SolenoidBField.cpp

@@ -58,7 +58,7 @@ Acts::Vector2 Acts::SolenoidBField::getField(const Vector2& position) const {
 }
 
 Acts::Result<Acts::Vector3> Acts::SolenoidBField::getFieldGradient(
-    const Vector3& position, ActsMatrix<3, 3>& /*derivative*/,
+    const Vector3& position, SquareMatrix3& /*derivative*/,
     MagneticFieldProvider::Cache& /*cache*/) const {
   return Result<Vector3>::success(getField(position));
 }

Core/src/Surfaces/AnnulusBounds.cpp

@@ -278,7 +278,7 @@ bool Acts::AnnulusBounds::inside(
 
   double B = cosDPhiPhiStrip;
   double C = -sinDPhiPhiStrip;
-  ActsMatrix<2, 2> jacobianStripPCToModulePC;
+  SquareMatrix2 jacobianStripPCToModulePC;
   jacobianStripPCToModulePC(0, 0) = (B * O_x + C * O_y + r_strip) / sqrtA;
   jacobianStripPCToModulePC(0, 1) =
       r_strip * (B * O_y + O_x * sinDPhiPhiStrip) / sqrtA;

Core/src/Surfaces/CylinderBounds.cpp

@@ -35,8 +35,8 @@ Acts::Vector2 Acts::CylinderBounds::shifted(
           lposition[Acts::eBoundLoc1]};
 }
 
-Acts::ActsMatrix<2, 2> Acts::CylinderBounds::jacobian() const {
-  ActsMatrix<2, 2> j;
+Acts::SquareMatrix2 Acts::CylinderBounds::jacobian() const {
+  SquareMatrix2 j;
   j(0, eBoundLoc0) = 1 / get(eR);
   j(0, eBoundLoc1) = 0;
   j(1, eBoundLoc0) = 0;

Core/src/Surfaces/DiscTrapezoidBounds.cpp

@@ -39,9 +39,9 @@ Acts::Vector2 Acts::DiscTrapezoidBounds::toLocalCartesian(
               std::cos(lposition[eBoundLoc1] - get(eAveragePhi))};
 }
 
-Acts::ActsMatrix<2, 2> Acts::DiscTrapezoidBounds::jacobianToLocalCartesian(
+Acts::SquareMatrix2 Acts::DiscTrapezoidBounds::jacobianToLocalCartesian(
     const Acts::Vector2& lposition) const {
-  ActsMatrix<2, 2> jacobian;
+  SquareMatrix2 jacobian;
   jacobian(0, eBoundLoc0) = std::sin(lposition[eBoundLoc1] - get(eAveragePhi));
   jacobian(1, eBoundLoc0) = std::cos(lposition[eBoundLoc1] - get(eAveragePhi));
   jacobian(0, eBoundLoc1) =

Core/src/Utilities/SpacePointUtility.cpp

@@ -82,10 +82,9 @@ SpacePointUtility::globalCoords(
   jacXyzToRhoZ(0, ePos1) = scale * y;
   jacXyzToRhoZ(1, ePos2) = 1;
   // compute Jacobian from local coordinates to rho/z
-  ActsMatrix<2, 2> jac =
-      jacXyzToRhoZ * rotLocalToGlobal.block<3, 2>(ePos0, ePos0);
+  SquareMatrix2 jac = jacXyzToRhoZ * rotLocalToGlobal.block<3, 2>(ePos0, ePos0);
   // compute rho/z variance
-  ActsVector<2> var = (jac * localCov * jac.transpose()).diagonal();
+  Vector2 var = (jac * localCov * jac.transpose()).diagonal();
 
   auto gcov = Vector2(var[0], var[1]);
 
@@ -145,10 +144,9 @@ Vector2 SpacePointUtility::rhoZCovariance(const GeometryContext& gctx,
   jacXyzToRhoZ(0, ePos1) = scale * y;
   jacXyzToRhoZ(1, ePos2) = 1;
   // compute Jacobian from local coordinates to rho/z
-  ActsMatrix<2, 2> jac =
-      jacXyzToRhoZ * rotLocalToGlobal.block<3, 2>(ePos0, ePos0);
+  SquareMatrix2 jac = jacXyzToRhoZ * rotLocalToGlobal.block<3, 2>(ePos0, ePos0);
   // compute rho/z variance
-  ActsVector<2> var = (jac * localCov * jac.transpose()).diagonal();
+  Vector2 var = (jac * localCov * jac.transpose()).diagonal();
 
   auto gcov = Vector2(var[0], var[1]);
 

Core/src/Vertexing/AdaptiveGridTrackDensity.cpp

@@ -181,7 +181,7 @@ AdaptiveGridTrackDensity::getMaxZTPositionAndWidth(
 
 AdaptiveGridTrackDensity::DensityMap AdaptiveGridTrackDensity::addTrack(
     const BoundTrackParameters& trk, DensityMap& mainDensityMap) const {
-  ActsVector<3> impactParams = trk.impactParameters();
+  Vector3 impactParams = trk.impactParameters();
   ActsSquareMatrix<3> cov = trk.impactParameterCovariance().value();
 
   std::uint32_t spatialTrkGridSize =

Core/src/Vertexing/AdaptiveMultiVertexFitter.cpp

@@ -44,8 +44,8 @@ Acts::Result<void> Acts::AdaptiveMultiVertexFitter::fit(
       // and the linearization point of the tracks. If it is too large,
       // we relinearize the tracks and recalculate their 3D impact
       // parameters.
-      ActsVector<2> xyDiff = vtxInfo.oldPosition.template head<2>() -
-                             vtxInfo.linPoint.template head<2>();
+      Vector2 xyDiff = vtxInfo.oldPosition.template head<2>() -
+                       vtxInfo.linPoint.template head<2>();
       if (xyDiff.norm() > m_cfg.maxDistToLinPoint) {
         // Set flag for relinearization
         vtxInfo.relinearize = true;

Examples/Detectors/MagneticField/include/ActsExamples/MagneticField/ScalableBField.hpp

@@ -72,7 +72,7 @@ class ScalableBField final : public Acts::MagneticFieldProvider {
   /// @note currently the derivative is not calculated
   /// @todo return derivative
   Acts::Result<Acts::Vector3> getFieldGradient(
-      const Acts::Vector3& /*position*/, Acts::ActsMatrix<3, 3>& /*derivative*/,
+      const Acts::Vector3& /*position*/, Acts::SquareMatrix3& /*derivative*/,
       MagneticFieldProvider::Cache& gCache) const override {
     Cache& cache = gCache.as<Cache>();
     return Acts::Result<Acts::Vector3>::success(m_BField * cache.scalor);

Examples/Io/Root/src/VertexNTupleWriter.cpp

@@ -836,7 +836,7 @@ ProcessCode VertexNTupleWriter::writeT(
       if (paramsAtVtx.has_value()) {
         Acts::Vector3 recoMom =
             paramsAtVtx->parameters().segment(Acts::eBoundPhi, 3);
-        const Acts::ActsMatrix<3, 3>& momCov =
+        const Acts::SquareMatrix3& momCov =
             paramsAtVtx->covariance()->template block<3, 3>(Acts::eBoundPhi,
                                                             Acts::eBoundPhi);
         innerRecoPhi.push_back(recoMom[0]);
@@ -889,7 +889,7 @@ ProcessCode VertexNTupleWriter::writeT(
       if (paramsAtVtxFitted.has_value()) {
         Acts::Vector3 recoMomFitted =
             paramsAtVtxFitted->parameters().segment(Acts::eBoundPhi, 3);
-        const Acts::ActsMatrix<3, 3>& momCovFitted =
+        const Acts::SquareMatrix3& momCovFitted =
             paramsAtVtxFitted->covariance()->block<3, 3>(Acts::eBoundPhi,
                                                          Acts::eBoundPhi);
         innerRecoPhiFitted.push_back(recoMomFitted[0]);

Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepFieldAdapter.hpp

@@ -31,7 +31,7 @@ class DD4hepFieldAdapter : public Acts::MagneticFieldProvider {
                            MagneticFieldProvider::Cache& cache) const override;
 
   Result<Vector3> getFieldGradient(
-      const Vector3& position, ActsMatrix<3, 3>& derivative,
+      const Vector3& position, SquareMatrix3& derivative,
       MagneticFieldProvider::Cache& cache) const override;
 
  private:

Plugins/DD4hep/src/DD4hepFieldAdapter.cpp

@@ -51,7 +51,7 @@ Result<Vector3> DD4hepFieldAdapter::getField(
 }
 
 Result<Vector3> DD4hepFieldAdapter::getFieldGradient(
-    const Vector3& /*position*/, ActsMatrix<3, 3>& /*derivative*/,
+    const Vector3& /*position*/, SquareMatrix3& /*derivative*/,
     MagneticFieldProvider::Cache& /*cache*/) const {
   return Result<Vector3>::failure(MagneticFieldError::NotImplemented);
 }

Tests/Benchmarks/AnnulusBoundsBenchmark.cpp

@@ -52,7 +52,7 @@ int main(int /*argc*/, char** /*argv[]*/) {
   auto random_point = [&]() -> Vector2 { return {xDist(rng), yDist(rng)}; };
 
   // for covariance based check, set up one;
-  ActsMatrix<2, 2> cov;
+  SquareMatrix2 cov;
   cov << 1.0, 0, 0, 0.05;
 
   BoundaryTolerance bcAbs = BoundaryTolerance::None();

Tests/UnitTests/Core/Geometry/VolumeTests.cpp

@@ -31,7 +31,7 @@ BOOST_AUTO_TEST_CASE(VolumeTest) {
   Vector3 translation{1_mm, 2_mm, 3_mm};
 
   // Build a translation
-  ActsMatrix<3, 3> rotation = RotationMatrix3::Identity();
+  SquareMatrix3 rotation = RotationMatrix3::Identity();
   double rotationAngle = 60_degree;
   Vector3 xPos(cos(rotationAngle), 0., sin(rotationAngle));
   Vector3 yPos(0., 1., 0.);