From bcf07796a5de7e401c652e66a127a0388a64ba15 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Mon, 17 Feb 2020 13:24:48 +0100
Subject: [PATCH 01/60] initial AMVFinder commit

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   | 204 ++++++++++++++++++
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   |   7 +
 2 files changed, 211 insertions(+)
 create mode 100644 Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
 create mode 100644 Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
new file mode 100644
index 000000000..d049a77e9
--- /dev/null
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -0,0 +1,204 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2020 CERN for the benefit of the Acts project
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#pragma once
+
+#include "Acts/EventData/TrackParameters.hpp"
+#include "Acts/Utilities/Definitions.hpp"
+#include "Acts/Utilities/Result.hpp"
+#include "Acts/Utilities/Units.hpp"
+#include "Acts/Vertexing/TrackToVertexIPEstimator.hpp"
+
+namespace Acts{
+
+/// @class AdaptiveMultiVertexFinder
+///
+/// @brief Implements an iterative vertex finder
+///
+////////////////////////////////////////////////////////////
+///
+/// Brief description of the algorithm implemented:
+/// TODO
+///
+////////////////////////////////////////////////////////////
+///
+/// @tparam vfitter_t Vertex fitter type
+/// @tparam sfinder_t Seed finder type
+template <typename vfitter_t, typename sfinder_t>
+class AdaptiveMultiVertexFinder {
+
+	using Propagator_t = typename vfitter_t::Propagator_t;
+	using InputTrack_t = typename vfitter_t::InputTrack_t;
+
+	using namespace Acts::UnitLiterals;
+
+public:
+
+	/// @struct Config Configuration struct
+  struct Config {
+    /// @brief Config constructor
+    ///
+    /// @param fitter The vertex fitter
+    /// @param sfinder The seed finder
+    /// @param ipEst TrackToVertexIPEstimator
+  	Config (vfitter_t fitter, sfinder_t sfinder, 
+  		TrackToVertexIPEstimator<InputTrack_t, Propagator_t> ipEst)
+  	: vertexFitter(std::move(fitter)),
+          seedFinder(std::move(sfinder)),
+          ipEstimator(std::move(ipEst)) {}
+
+	// Vertex fitter
+    vfitter_t vertexFitter;
+
+    /// Vertex seed finder
+    sfinder_t seedFinder;
+
+	// TrackToVertexIPEstimator
+    TrackToVertexIPEstimator<InputTrack_t, Propagator_t> ipEstimator;
+
+
+    /// TODO: Update descriptions!
+    /** Define a beam constraint for the fit */
+    bool useBeamConstraint = true;
+    
+    /**
+     * When adding a new vertex to the multi vertex fit,
+     * only the tracks whose Z at PCA is closer 
+     * to the seeded by more than this TracksMaxZinterval 
+     * value are added to this new vertex.
+     *
+     * Default is 4 mm. If you cut too hard, you cut out 
+     * the good cases where the seed finder is not 
+     * reliable, but the fit would be still able to converge 
+     * towards the right vertex. If you cut too soft, you 
+     * consider a lot of tracks which just slow down the fit.
+     */
+
+    double TracksMaxZinterval = 4_mm;
+
+    /**
+     * After having added one vertex to the fit and having 
+     * performed the MultiVertex fit again, all the tracks 
+     * which are compatible to the new vertex by more than 
+     * this maxVertexChi2 (in units of chi2) value are eliminated from the 
+     * tracks from which still to seed the next vertex.
+     *
+     */
+
+    double maxVertexChi2 = 18.42;
+
+    /**
+     * As a default the realMultiVertex should stay to false (because this is very well tested).
+     *
+     * If switched to true, all the tracks are considered to be added to the new vertex 
+     * after this new one is seeded, and not only the ones which are considered as outliers 
+     * of previous fitted vertices.
+     *
+     * The presence of a core of tracks the previous vertices are as attached to stabilizes 
+     * the fit quite drastically. In case of luminosities higher than the low lumi scenario,
+     * one should probably to try to switch this on, or, if this doesn't work, decrease the 
+     * maxVertexChi2 and the cleaningZinterval to lower values.
+     */
+    
+    bool realMultiVertex = false;
+
+
+    /*
+     * Decides if you want to use the vtxCompatibility() of the track (set to true) or 
+     * the chi2() (set to false) as an estimate for a track being an outlier or not.
+     * The vtxCompatibility() is the default. In case the track refitting 
+     * is switched on in the AdaptiveMultiVertex fitter, you may want to 
+     * use the refitted chi2().
+     *
+     */
+
+    bool useFastCompatibility = true;
+
+ 
+    /*
+     * Maximum significance on the distance between two vertices 
+     * to allow merging of two vertices.
+     *
+     */
+
+    double cutVertexDependence = 3.;
+    
+
+    /*
+     * Has to be setup equal to the minimum weight set in the fitter.
+     *
+     * In the fitting, when a track has a weight lower than this value,
+     * the track is not updated during that iteration.
+     */
+
+    double minweight = 0.0001;
+
+
+    /*
+     * Maximum amount of iterations allowed for vertex finding.
+     * 
+     * The more vertices you have in the event, the more iterations you have to 
+     * allow (safe factor: number of expected vertices * 10)
+     *
+     */
+
+    int maxIterations = 1000;
+
+   /*
+    * Fit also single track vertices
+    * (could be usefull for example for H-> gamma gamma)\
+    *
+    */
+
+   bool addSingleTrackVertices = false;
+
+   bool do3dSplitting = false;
+
+   double maximumVertexContamination = 0.5;
+
+    /*
+    * Maximum allowed significance of track position to vertex seed
+    */
+    double tracksMaxSignificance = 5.;
+
+    /*
+    * Toggle vertex seed constraint on/off
+    */
+    bool useSeedConstraint = true;
+
+    }; // Config struct
+
+
+
+    struct State
+    {
+    	// This is the state
+    };
+
+
+  /// @brief Function that performs the adaptive
+  /// multi-vertex finding
+  ///
+  /// @param allTracks Input track collection
+  /// @param vFinderOptions Vertex finder options
+  ///
+  /// @return Vector of all reconstructed vertices
+  Result<std::vector<Vertex<InputTrack_t>>> find(
+      const std::vector<InputTrack_t>& allTracks,
+      const VertexFinderOptions<InputTrack_t>& vFinderOptions) const;
+
+private:
+	Config m_cfg;
+
+
+
+};
+
+} // namespace Acts
+
+#include "Acts/Vertexing/AdaptiveMultiVertexFinder.ipp"
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
new file mode 100644
index 000000000..d6a797e64
--- /dev/null
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -0,0 +1,7 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2020 CERN for the benefit of the Acts project
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
\ No newline at end of file
-- 
GitLab


From 1ceafc9d6585e4d223924218d03df23c4d92b15e Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Tue, 18 Feb 2020 12:57:18 +0100
Subject: [PATCH 02/60] add empty AMVFinder unit test

---
 .../AdaptiveMultiVertexFinderTests.cpp          | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp

diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
new file mode 100644
index 000000000..1116ed7e7
--- /dev/null
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
@@ -0,0 +1,17 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2019 CERN for the benefit of the Acts project
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include <boost/test/data/test_case.hpp>
+#include <boost/test/tools/output_test_stream.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include "Acts/Vertexing/AdaptiveMultiVertexFinder.hpp"
+
+namespace Acts {
+namespace Test {}  // namespace Test
+}  // namespace Acts
-- 
GitLab


From bbdbda1be52be7f2dd47a41bf66d2d2fa80bbcc3 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Tue, 18 Feb 2020 14:04:02 +0100
Subject: [PATCH 03/60] set z width in GaussianSeedFinder always when a
 constraint is given

---
 Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp | 2 --
 Core/include/Acts/Vertexing/TrackDensityVertexFinder.ipp | 3 ++-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp b/Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp
index 690c18ae0..32fc45715 100644
--- a/Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp
@@ -44,8 +44,6 @@ class TrackDensityVertexFinder {
   struct Config {
     // The track density estimator
     track_density_t trackDensityEstimator;
-    // Run the vertex finder with width information
-    bool findWithWidth = false;
   };
 
   /// @brief Function that finds single vertex candidate
diff --git a/Core/include/Acts/Vertexing/TrackDensityVertexFinder.ipp b/Core/include/Acts/Vertexing/TrackDensityVertexFinder.ipp
index 5f99e3539..cf0f02b5f 100644
--- a/Core/include/Acts/Vertexing/TrackDensityVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/TrackDensityVertexFinder.ipp
@@ -36,7 +36,8 @@ auto Acts::TrackDensityVertexFinder<vfitter_t, track_density_t>::find(
 
   ActsSymMatrixD<3> seedCov = vFinderOptions.vertexConstraint.covariance();
 
-  if (m_cfg.findWithWidth && std::isnormal(zAndWidth.second)) {
+  // Check if a constraint is provided and set the new z position constraint
+  if (seedCov != ActsSymMatrixD<3>::Zero() && std::isnormal(zAndWidth.second)) {
     seedCov(eZ, eZ) = zAndWidth.second * zAndWidth.second;
   }
 
-- 
GitLab


From 23ccb146da20e92177bc07204876c73ff91b8953 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Tue, 18 Feb 2020 15:04:50 +0100
Subject: [PATCH 04/60] default TrackDensitySeedFinder with
 GaussianTrackDensity, remove VertexFitterConcept assertion for now, common
 interface for multivertex fit needed

---
 Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp b/Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp
index 32fc45715..12ecfe0c6 100644
--- a/Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp
@@ -14,6 +14,7 @@
 #include "Acts/Vertexing/Vertex.hpp"
 #include "Acts/Vertexing/VertexFinderOptions.hpp"
 #include "Acts/Vertexing/VertexFitterConcept.hpp"
+#include "Acts/Vertexing/GaussianTrackDensity.hpp"
 
 namespace Acts {
 
@@ -30,12 +31,13 @@ namespace Acts {
 ///
 /// @tparam vfitter_t The vertex fitter type (needed to fulfill concept)
 /// @tparam track_density_t The track density type
-template <typename vfitter_t, typename track_density_t>
+template <typename vfitter_t, typename track_density_t = GaussianTrackDensity>
 class TrackDensityVertexFinder {
   // Provided vertex fitter type should comply with the VertexFitterConcept
   // to ensure providing an input track type InputTrack_t
-  static_assert(VertexFitterConcept<vfitter_t>,
-                "Vertex fitter does not fulfill vertex fitter concept.");
+  
+  //static_assert(VertexFitterConcept<vfitter_t>,
+  //              "Vertex fitter does not fulfill vertex fitter concept.");
 
   using InputTrack_t = typename vfitter_t::InputTrack_t;
 
-- 
GitLab


From fdb622430f08925f8400aa9d30b2f49ebc876404 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Tue, 18 Feb 2020 15:06:57 +0100
Subject: [PATCH 05/60] add constructor and (not fully working) version of
 doSeeding method to AMVFinder

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   | 176 +++++++++++-------
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   |  60 +++++-
 2 files changed, 165 insertions(+), 71 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index d049a77e9..0d2705974 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -10,11 +10,15 @@
 
 #include "Acts/EventData/TrackParameters.hpp"
 #include "Acts/Utilities/Definitions.hpp"
+#include "Acts/Utilities/Logger.hpp"
 #include "Acts/Utilities/Result.hpp"
 #include "Acts/Utilities/Units.hpp"
 #include "Acts/Vertexing/TrackToVertexIPEstimator.hpp"
+#include "Acts/Vertexing/VertexFinderOptions.hpp"
 
-namespace Acts{
+namespace Acts {
+
+using namespace Acts::UnitLiterals;
 
 /// @class AdaptiveMultiVertexFinder
 ///
@@ -31,61 +35,56 @@ namespace Acts{
 /// @tparam sfinder_t Seed finder type
 template <typename vfitter_t, typename sfinder_t>
 class AdaptiveMultiVertexFinder {
+  using Propagator_t = typename vfitter_t::Propagator_t;
+  using InputTrack_t = typename vfitter_t::InputTrack_t;
 
-	using Propagator_t = typename vfitter_t::Propagator_t;
-	using InputTrack_t = typename vfitter_t::InputTrack_t;
-
-	using namespace Acts::UnitLiterals;
-
-public:
-
-	/// @struct Config Configuration struct
+ public:
+  /// @struct Config Configuration struct
   struct Config {
     /// @brief Config constructor
     ///
     /// @param fitter The vertex fitter
     /// @param sfinder The seed finder
     /// @param ipEst TrackToVertexIPEstimator
-  	Config (vfitter_t fitter, sfinder_t sfinder, 
-  		TrackToVertexIPEstimator<InputTrack_t, Propagator_t> ipEst)
-  	: vertexFitter(std::move(fitter)),
+    Config(vfitter_t fitter, sfinder_t sfinder,
+           TrackToVertexIPEstimator<InputTrack_t, Propagator_t> ipEst)
+        : vertexFitter(std::move(fitter)),
           seedFinder(std::move(sfinder)),
           ipEstimator(std::move(ipEst)) {}
 
-	// Vertex fitter
+    // Vertex fitter
     vfitter_t vertexFitter;
 
     /// Vertex seed finder
     sfinder_t seedFinder;
 
-	// TrackToVertexIPEstimator
+    // TrackToVertexIPEstimator
     TrackToVertexIPEstimator<InputTrack_t, Propagator_t> ipEstimator;
 
-
     /// TODO: Update descriptions!
     /** Define a beam constraint for the fit */
-    bool useBeamConstraint = true;
-    
+    bool useBeamSpotConstraint = true;
+
     /**
      * When adding a new vertex to the multi vertex fit,
-     * only the tracks whose Z at PCA is closer 
-     * to the seeded by more than this TracksMaxZinterval 
+     * only the tracks whose Z at PCA is closer
+     * to the seeded by more than this TracksMaxZinterval
      * value are added to this new vertex.
      *
-     * Default is 4 mm. If you cut too hard, you cut out 
-     * the good cases where the seed finder is not 
-     * reliable, but the fit would be still able to converge 
-     * towards the right vertex. If you cut too soft, you 
+     * Default is 4 mm. If you cut too hard, you cut out
+     * the good cases where the seed finder is not
+     * reliable, but the fit would be still able to converge
+     * towards the right vertex. If you cut too soft, you
      * consider a lot of tracks which just slow down the fit.
      */
 
     double TracksMaxZinterval = 4_mm;
 
     /**
-     * After having added one vertex to the fit and having 
-     * performed the MultiVertex fit again, all the tracks 
-     * which are compatible to the new vertex by more than 
-     * this maxVertexChi2 (in units of chi2) value are eliminated from the 
+     * After having added one vertex to the fit and having
+     * performed the MultiVertex fit again, all the tracks
+     * which are compatible to the new vertex by more than
+     * this maxVertexChi2 (in units of chi2) value are eliminated from the
      * tracks from which still to seed the next vertex.
      *
      */
@@ -93,41 +92,40 @@ public:
     double maxVertexChi2 = 18.42;
 
     /**
-     * As a default the realMultiVertex should stay to false (because this is very well tested).
+     * As a default the realMultiVertex should stay to false (because this is
+     * very well tested).
      *
-     * If switched to true, all the tracks are considered to be added to the new vertex 
-     * after this new one is seeded, and not only the ones which are considered as outliers 
-     * of previous fitted vertices.
+     * If switched to true, all the tracks are considered to be added to the new
+     * vertex after this new one is seeded, and not only the ones which are
+     * considered as outliers of previous fitted vertices.
      *
-     * The presence of a core of tracks the previous vertices are as attached to stabilizes 
-     * the fit quite drastically. In case of luminosities higher than the low lumi scenario,
-     * one should probably to try to switch this on, or, if this doesn't work, decrease the 
-     * maxVertexChi2 and the cleaningZinterval to lower values.
+     * The presence of a core of tracks the previous vertices are as attached to
+     * stabilizes the fit quite drastically. In case of luminosities higher than
+     * the low lumi scenario, one should probably to try to switch this on, or,
+     * if this doesn't work, decrease the maxVertexChi2 and the
+     * cleaningZinterval to lower values.
      */
-    
-    bool realMultiVertex = false;
 
+    bool realMultiVertex = false;
 
     /*
-     * Decides if you want to use the vtxCompatibility() of the track (set to true) or 
-     * the chi2() (set to false) as an estimate for a track being an outlier or not.
-     * The vtxCompatibility() is the default. In case the track refitting 
-     * is switched on in the AdaptiveMultiVertex fitter, you may want to 
-     * use the refitted chi2().
+     * Decides if you want to use the vtxCompatibility() of the track (set to
+     * true) or the chi2() (set to false) as an estimate for a track being an
+     * outlier or not. The vtxCompatibility() is the default. In case the track
+     * refitting is switched on in the AdaptiveMultiVertex fitter, you may want
+     * to use the refitted chi2().
      *
      */
 
     bool useFastCompatibility = true;
 
- 
     /*
-     * Maximum significance on the distance between two vertices 
+     * Maximum significance on the distance between two vertices
      * to allow merging of two vertices.
      *
      */
 
     double cutVertexDependence = 3.;
-    
 
     /*
      * Has to be setup equal to the minimum weight set in the fitter.
@@ -138,48 +136,71 @@ public:
 
     double minweight = 0.0001;
 
-
     /*
      * Maximum amount of iterations allowed for vertex finding.
-     * 
-     * The more vertices you have in the event, the more iterations you have to 
+     *
+     * The more vertices you have in the event, the more iterations you have to
      * allow (safe factor: number of expected vertices * 10)
      *
      */
 
     int maxIterations = 1000;
 
-   /*
-    * Fit also single track vertices
-    * (could be usefull for example for H-> gamma gamma)\
-    *
-    */
+    /*
+     * Fit also single track vertices
+     * (could be usefull for example for H-> gamma gamma)\
+     *
+     */
 
-   bool addSingleTrackVertices = false;
+    bool addSingleTrackVertices = false;
 
-   bool do3dSplitting = false;
+    bool do3dSplitting = false;
 
-   double maximumVertexContamination = 0.5;
+    double maximumVertexContamination = 0.5;
 
     /*
-    * Maximum allowed significance of track position to vertex seed
-    */
+     * Maximum allowed significance of track position to vertex seed
+     */
     double tracksMaxSignificance = 5.;
 
     /*
-    * Toggle vertex seed constraint on/off
-    */
+     * Toggle vertex seed constraint on/off
+     */
     bool useSeedConstraint = true;
 
-    }; // Config struct
-
+  };  // Config struct
 
+  struct State {
+    // This is the state
+  };
 
-    struct State
-    {
-    	// This is the state
-    };
-
+  /// @brief Constructor used if InputTrack_t type == BoundParameters
+  ///
+  /// @param cfg Configuration object
+  /// @param logger The logging instance
+  template <typename T = InputTrack_t,
+            std::enable_if_t<std::is_same<T, BoundParameters>::value, int> = 0>
+  AdaptiveMultiVertexFinder(Config& cfg,
+                            std::unique_ptr<const Logger> logger =
+                                getDefaultLogger("AdaptiveMultiVertexFinder",
+                                                 Logging::INFO))
+      : m_cfg(std::move(cfg)),
+        m_extractParameters([](T params) { return params; }),
+        m_logger(std::move(logger)) {}
+
+  /// @brief Constructor for user-defined InputTrack_t type != BoundParameters
+  ///
+  /// @param cfg Configuration object
+  /// @param func Function extracting BoundParameters from InputTrack_t object
+  /// @param logger The logging instance
+  AdaptiveMultiVertexFinder(Config& cfg,
+                            std::function<BoundParameters(InputTrack_t)> func,
+                            std::unique_ptr<const Logger> logger =
+                                getDefaultLogger("AdaptiveMultiVertexFinder",
+                                                 Logging::INFO))
+      : m_cfg(std::move(cfg)),
+        m_extractParameters(func),
+        m_logger(std::move(logger)) {}
 
   /// @brief Function that performs the adaptive
   /// multi-vertex finding
@@ -192,13 +213,28 @@ public:
       const std::vector<InputTrack_t>& allTracks,
       const VertexFinderOptions<InputTrack_t>& vFinderOptions) const;
 
-private:
-	Config m_cfg;
+ private:
+  /// Configuration object
+  Config m_cfg;
+
+  /// @brief Function to extract track parameters,
+  /// InputTrack_t objects are BoundParameters by default, function to be
+  /// overwritten to return BoundParameters for other InputTrack_t objects.
+  ///
+  /// @param InputTrack_t object to extract track parameters from
+  const std::function<BoundParameters(InputTrack_t)> m_extractParameters;
 
+  /// Logging instance
+  std::unique_ptr<const Logger> m_logger;
 
+  /// Private access to logging instance
+  const Logger& logger() const { return *m_logger; }
 
+  Result<Vertex<InputTrack_t>> doSeeding(
+      const std::vector<InputTrack_t>& trackVector,
+      VertexFinderOptions<InputTrack_t>& vFinderOptions) const;
 };
 
-} // namespace Acts
+}  // namespace Acts
 
 #include "Acts/Vertexing/AdaptiveMultiVertexFinder.ipp"
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index d6a797e64..7b9f42774 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -4,4 +4,62 @@
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
\ No newline at end of file
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include "Acts/Vertexing/VertexFitterOptions.hpp"
+#include "Acts/Vertexing/VertexingError.hpp"
+
+template <typename vfitter_t, typename sfinder_t>
+auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
+    const std::vector<InputTrack_t>& allTracks,
+    const VertexFinderOptions<InputTrack_t>& vFinderOptions) const
+    -> Result<std::vector<Vertex<InputTrack_t>>> {
+  if (allTracks.empty()) {
+    return VertexingError::EmptyInput;
+  }
+
+  // Original tracks
+  const std::vector<InputTrack_t>& origTracks = allTracks;
+  // Tracks for seeding
+  // Note: Remains to be investigated if another container (e.g. std::list)
+  // or also std::vector<InputTrack_t*> is a faster option since erasures
+  // of tracks is quite expensive with std::vector.
+  // std::vector<InputTrack_t*> would however also come with an overhead
+  // since m_cfg.vertexFitter.fit and m_cfg.seedFinder.find take
+  // vector<InputTrack_t> and hence a lot of copying would be required.
+  // Maybe use std::vector<InputTrack_t*> and adapt fit accordingly to
+  // also take pointers to tracks instead of the track object.
+  std::vector<InputTrack_t> seedTracks = allTracks;
+
+  // Construct the vertex fitter options from vertex finder options
+  VertexFitterOptions<InputTrack_t> vFitterOptions(
+      vFinderOptions.geoContext, vFinderOptions.magFieldContext,
+      vFinderOptions.vertexConstraint);
+
+  int iteration = 0;
+  while (((m_cfg.addSingleTrackVertices && seedTracks.size() > 0) ||
+          ((!m_cfg.addSingleTrackVertices) && seedTracks.size() > 1)) &&
+         iteration < m_cfg.maxIterations) {
+    auto seedRes = doSeeding(seedTracks, vFinderOptions);
+    if (!seedRes.ok()) {
+      return seedRes.error();
+    }
+    Vertex<InputTrack_t> vtxCandidate = *seedRes;
+  }
+
+  // debug
+  return {};
+}
+
+template <typename vfitter_t, typename sfinder_t>
+auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::doSeeding(
+    const std::vector<InputTrack_t>& trackVector,
+    VertexFinderOptions<InputTrack_t>& vFinderOptions) const
+    -> Result<Vertex<InputTrack_t>> {
+  Vertex<InputTrack_t> seedVertex =
+      m_cfg.seedFinder.find(trackVector, vFinderOptions).back();
+
+  if (m_cfg.useBeamSpotConstraint) {
+    vFinderOptions.vertexConstraint = seedVertex;
+  }
+}
-- 
GitLab


From 5e180e0411796f1729b06d0b8812e9706b4395cc Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Tue, 18 Feb 2020 15:08:20 +0100
Subject: [PATCH 06/60] expose InputTrack_t and Linearizer_t in AMVFitter

---
 .../Acts/Vertexing/AdaptiveMultiVertexFitter.hpp     | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
index 1d469a871..3834d9a05 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
@@ -39,8 +39,12 @@ class AdaptiveMultiVertexFitter {
   static_assert(LinearizerConcept<linearizer_t>,
                 "Linearizer does not fulfill linearizer concept.");
 
+ public:
   using InputTrack_t = input_track_t;
   using Propagator_t = typename linearizer_t::Propagator_t;
+  using Linearizer_t = linearizer_t;
+
+ private:
   using ImpactPointEstimator =
       ImpactPoint3dEstimator<InputTrack_t, Propagator_t>;
 
@@ -188,7 +192,7 @@ class AdaptiveMultiVertexFitter {
   /// @return Result<void> object
   Result<void> fit(
       State& state, const std::vector<Vertex<input_track_t>*>& verticesToFit,
-      const linearizer_t& linearizer,
+      const Linearizer_t& linearizer,
       const VertexFitterOptions<input_track_t>& vFitterOptions) const;
 
   /// @brief Adds new vertex to an existing multi-vertex fit
@@ -216,7 +220,7 @@ class AdaptiveMultiVertexFitter {
   /// @return Result<void> object
   Result<void> addVtxToFit(
       State& state, Vertex<InputTrack_t>& newVertex,
-      const linearizer_t& linearizer,
+      const Linearizer_t& linearizer,
       const VertexFitterOptions<InputTrack_t>& vFitterOptions) const;
 
  private:
@@ -245,7 +249,7 @@ class AdaptiveMultiVertexFitter {
   ///
   /// @return Result<void> object
   Result<void> fitImpl(
-      State& state, const linearizer_t& linearizer,
+      State& state, const Linearizer_t& linearizer,
       const VertexFitterOptions<InputTrack_t>& vFitterOptions) const;
 
   /// @brief Tests if vertex is already in list of vertices or not
@@ -286,7 +290,7 @@ class AdaptiveMultiVertexFitter {
   /// @param state The state object
   /// @param linearizer The track linearizer
   Result<void> setWeightsAndUpdate(State& state,
-                                   const linearizer_t& linearizer) const;
+                                   const Linearizer_t& linearizer) const;
 
   /// @brief Collects all compatibility values of the track `trk`
   /// at all vertices it is currently attached to and outputs
-- 
GitLab


From 03b4567310e5d63c6dfa30b5f4a0b46f3d0266a4 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Tue, 18 Feb 2020 17:11:27 +0100
Subject: [PATCH 07/60] add seeding to AMVFinder and start unit test

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   | 11 ++-
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 46 +++++++--
 .../Vertexing/TrackDensityVertexFinder.hpp    |  6 +-
 .../AdaptiveMultiVertexFinderTests.cpp        | 93 ++++++++++++++++++-
 4 files changed, 141 insertions(+), 15 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index 0d2705974..2dd89a774 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -168,11 +168,16 @@ class AdaptiveMultiVertexFinder {
      */
     bool useSeedConstraint = true;
 
+    // Diagonal constraint covariance entries in case
+    // no beamspot constraint is provided
+    double looseConstrValue = 1e+8;
+    // Default fitQuality for constraint vertex in case no beamspot
+    // constraint is provided
+    std::pair<double, double> defaultConstrFitQuality{0., -3.};
+
   };  // Config struct
 
-  struct State {
-    // This is the state
-  };
+  struct State {};
 
   /// @brief Constructor used if InputTrack_t type == BoundParameters
   ///
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index 7b9f42774..c79666fe0 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -18,6 +18,10 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     return VertexingError::EmptyInput;
   }
 
+  // Create copy of finder options, will be modified after seeding
+  // to set the correct vertex constraint
+  VertexFinderOptions<InputTrack_t> finderOptions = vFinderOptions;
+
   // Original tracks
   const std::vector<InputTrack_t>& origTracks = allTracks;
   // Tracks for seeding
@@ -33,22 +37,29 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
 
   // Construct the vertex fitter options from vertex finder options
   VertexFitterOptions<InputTrack_t> vFitterOptions(
-      vFinderOptions.geoContext, vFinderOptions.magFieldContext,
-      vFinderOptions.vertexConstraint);
+      finderOptions.geoContext, finderOptions.magFieldContext,
+      finderOptions.vertexConstraint);
+
+  std::vector<Vertex<InputTrack_t>> allVertices;
 
   int iteration = 0;
   while (((m_cfg.addSingleTrackVertices && seedTracks.size() > 0) ||
           ((!m_cfg.addSingleTrackVertices) && seedTracks.size() > 1)) &&
          iteration < m_cfg.maxIterations) {
-    auto seedRes = doSeeding(seedTracks, vFinderOptions);
+    // Retrieve seed vertex from all remaining seedTracks
+    auto seedRes = doSeeding(seedTracks, finderOptions);
     if (!seedRes.ok()) {
       return seedRes.error();
     }
     Vertex<InputTrack_t> vtxCandidate = *seedRes;
+
+    if (vtxCandidate.position().z() == 0.) {
+      // No seed found anymore, break and stop primary vertex finding
+      break;
+    }
   }
 
-  // debug
-  return {};
+  return allVertices;
 }
 
 template <typename vfitter_t, typename sfinder_t>
@@ -56,10 +67,29 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::doSeeding(
     const std::vector<InputTrack_t>& trackVector,
     VertexFinderOptions<InputTrack_t>& vFinderOptions) const
     -> Result<Vertex<InputTrack_t>> {
-  Vertex<InputTrack_t> seedVertex =
-      m_cfg.seedFinder.find(trackVector, vFinderOptions).back();
+  // Run seed finder
+  auto seedRes = m_cfg.seedFinder.find(trackVector, vFinderOptions);
+
+  if (!seedRes.ok()) {
+    return seedRes.error();
+  }
+
+  Vertex<InputTrack_t> seedVertex = (*seedRes).back();
 
   if (m_cfg.useBeamSpotConstraint) {
-    vFinderOptions.vertexConstraint = seedVertex;
+    if (m_cfg.useSeedConstraint) {
+      vFinderOptions.vertexConstraint.setFullPosition(
+          seedVertex.fullPosition());
+      vFinderOptions.vertexConstraint.setFullCovariance(
+          seedVertex.fullCovariance());
+    }
+  } else {
+    vFinderOptions.vertexConstraint.setFullPosition(seedVertex.fullPosition());
+    vFinderOptions.vertexConstraint.setFullCovariance(
+        SpacePointSymMatrix::Identity() * m_cfg.looseConstrValue);
+    vFinderOptions.vertexConstraint.setFitQuality(
+        m_cfg.defaultConstrFitQuality);
   }
+
+  return seedVertex;
 }
diff --git a/Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp b/Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp
index 12ecfe0c6..a5379e7c8 100644
--- a/Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp
@@ -11,10 +11,10 @@
 #include "Acts/EventData/TrackParameters.hpp"
 #include "Acts/Utilities/Definitions.hpp"
 #include "Acts/Utilities/Result.hpp"
+#include "Acts/Vertexing/GaussianTrackDensity.hpp"
 #include "Acts/Vertexing/Vertex.hpp"
 #include "Acts/Vertexing/VertexFinderOptions.hpp"
 #include "Acts/Vertexing/VertexFitterConcept.hpp"
-#include "Acts/Vertexing/GaussianTrackDensity.hpp"
 
 namespace Acts {
 
@@ -35,8 +35,8 @@ template <typename vfitter_t, typename track_density_t = GaussianTrackDensity>
 class TrackDensityVertexFinder {
   // Provided vertex fitter type should comply with the VertexFitterConcept
   // to ensure providing an input track type InputTrack_t
-  
-  //static_assert(VertexFitterConcept<vfitter_t>,
+
+  // static_assert(VertexFitterConcept<vfitter_t>,
   //              "Vertex fitter does not fulfill vertex fitter concept.");
 
   using InputTrack_t = typename vfitter_t::InputTrack_t;
diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
index 1116ed7e7..d881f49df 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
@@ -12,6 +12,97 @@
 
 #include "Acts/Vertexing/AdaptiveMultiVertexFinder.hpp"
 
+#include "Acts/MagneticField/ConstantBField.hpp"
+#include "Acts/Propagator/EigenStepper.hpp"
+#include "Acts/Propagator/Propagator.hpp"
+#include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
+#include "Acts/Utilities/Definitions.hpp"
+#include "Acts/Utilities/Units.hpp"
+#include "Acts/Vertexing/AdaptiveMultiVertexFitter.hpp"
+#include "Acts/Vertexing/HelicalTrackLinearizer.hpp"
+#include "Acts/Vertexing/TrackDensityVertexFinder.hpp"
+#include "Acts/Vertexing/Vertex.hpp"
+
 namespace Acts {
-namespace Test {}  // namespace Test
+namespace Test {
+
+using namespace Acts::UnitLiterals;
+
+using Covariance = BoundSymMatrix;
+using Propagator = Propagator<EigenStepper<ConstantBField>>;
+using Linearizer = HelicalTrackLinearizer<Propagator>;
+
+// Create a test context
+GeometryContext tgContext = GeometryContext();
+MagneticFieldContext mfContext = MagneticFieldContext();
+
+BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
+  // Set debug mode
+  bool debugMode = false;
+  // Set up constant B-Field
+  ConstantBField bField(Vector3D(0., 0., 2_T));
+
+  // Set up EigenStepper
+  // EigenStepper<ConstantBField> stepper(bField);
+  EigenStepper<ConstantBField> stepper(bField);
+
+  // Set up propagator with void navigator
+  auto propagator = std::make_shared<Propagator>(stepper);
+  PropagatorOptions<> pOptions(tgContext, mfContext);
+
+  VertexFitterOptions<BoundParameters> fitterOptions(tgContext, mfContext);
+
+  // IP 3D Estimator
+  using IPEstimator = ImpactPoint3dEstimator<BoundParameters, Propagator>;
+
+  IPEstimator::Config ip3dEstCfg(bField, propagator, pOptions, false);
+  IPEstimator ip3dEst(ip3dEstCfg);
+
+  std::vector<double> temperatures(1, 3.);
+  AnnealingUtility::Config annealingConfig(temperatures);
+  AnnealingUtility annealingUtility(annealingConfig);
+
+  using Fitter = AdaptiveMultiVertexFitter<BoundParameters, Linearizer>;
+
+  Fitter::Config fitterCfg(ip3dEst);
+
+  fitterCfg.annealingTool = annealingUtility;
+
+  // Linearizer for BoundParameters type test
+  Linearizer::Config ltConfig(bField, propagator, pOptions);
+  Linearizer linearizer(ltConfig);
+
+  // Test smoothing
+  // fitterCfg.doSmoothing = true;
+
+  Fitter fitter(fitterCfg);
+
+  using SeedFinder = TrackDensityVertexFinder<Fitter, GaussianTrackDensity>;
+
+  SeedFinder seedFinder;
+
+  using IPEstimater = TrackToVertexIPEstimator<BoundParameters, Propagator>;
+
+  IPEstimater::Config ipEstCfg(propagator, pOptions);
+
+  // Create TrackToVertexIPEstimator
+  IPEstimater ipEst(ipEstCfg);
+
+  using Finder = AdaptiveMultiVertexFinder<Fitter, SeedFinder>;
+
+  Finder::Config finderConfig(std::move(fitter), std::move(seedFinder),
+                              std::move(ipEst));
+
+  Finder finder(finderConfig);
+
+  std::vector<BoundParameters> tracks;
+
+  VertexFinderOptions<BoundParameters> finderOptions(tgContext, mfContext);
+
+  std::cout << &finderOptions << std::endl;
+
+  auto bla = finder.find(tracks, finderOptions);
+}
+
+}  // namespace Test
 }  // namespace Acts
-- 
GitLab


From 8f769331842bad8e9acfc6421ffed770562dbe57 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Tue, 18 Feb 2020 17:26:28 +0100
Subject: [PATCH 08/60] move VertexInfo and TrackAtVertexInfo to AMVFInfo file
 to be used by different tools

---
 Core/include/Acts/Vertexing/AMVFInfo.hpp      | 46 +++++++++++++++++++
 .../Vertexing/AdaptiveMultiVertexFitter.hpp   | 33 ++-----------
 .../Vertexing/AdaptiveMultiVertexFitter.ipp   |  4 +-
 .../AdaptiveMultiVertexFitterTests.cpp        |  4 +-
 4 files changed, 53 insertions(+), 34 deletions(-)
 create mode 100644 Core/include/Acts/Vertexing/AMVFInfo.hpp

diff --git a/Core/include/Acts/Vertexing/AMVFInfo.hpp b/Core/include/Acts/Vertexing/AMVFInfo.hpp
new file mode 100644
index 000000000..92844fe49
--- /dev/null
+++ b/Core/include/Acts/Vertexing/AMVFInfo.hpp
@@ -0,0 +1,46 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2019 CERN for the benefit of the Acts project
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#pragma once
+
+#include "Acts/Utilities/Definitions.hpp"
+#include "Acts/EventData/TrackParameters.hpp"
+#include "Acts/Vertexing/Vertex.hpp"
+
+namespace Acts {
+
+/// @brief Helper struct for storing vertex related information
+  template<typename input_track_t>
+  struct VertexInfo {
+    // The linearization point
+    Acts::SpacePointVector linPoint{Acts::SpacePointVector::Zero()};
+
+    // The constraint vertex
+    Acts::Vertex<input_track_t> constraintVertex;
+
+    // Old position from last iteration
+    Acts::SpacePointVector oldPosition;
+
+    Acts::SpacePointVector seedPosition;
+
+    // Needs relinearization bool
+    bool relinearize;
+  };
+
+  /// @brief Helper struct for storing TrackAtVertex related
+  template<typename input_track_t>
+  struct TrackAtVertexInfo {
+    // Links to vertices currently using the TrackAtVertex object
+    std::vector<Vertex<input_track_t>*> linksToVertices;
+
+    // Track parameters at point of closest approach in 3d as
+    // retrieved by ImpactPoint3dEstimator::getParamsAtClosestApproach
+    std::unique_ptr<const BoundParameters> ip3dParams;
+  };
+
+} // Acts namespace
\ No newline at end of file
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
index 3834d9a05..55370ba5b 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
@@ -18,6 +18,7 @@
 #include "Acts/Vertexing/TrackAtVertex.hpp"
 #include "Acts/Vertexing/Vertex.hpp"
 #include "Acts/Vertexing/VertexFitterOptions.hpp"
+#include "Acts/Vertexing/AMVFInfo.hpp"
 
 #include <functional>
 
@@ -49,34 +50,6 @@ class AdaptiveMultiVertexFitter {
       ImpactPoint3dEstimator<InputTrack_t, Propagator_t>;
 
  public:
-  /// @brief Helper struct for storing vertex related information
-  struct VertexInfo {
-    // The linearization point
-    Acts::SpacePointVector linPoint{Acts::SpacePointVector::Zero()};
-
-    // The constraint vertex
-    Acts::Vertex<input_track_t> constraintVertex;
-
-    // Old position from last iteration
-    Acts::SpacePointVector oldPosition{Acts::SpacePointVector::Zero()};
-
-    // Seed position
-    Acts::SpacePointVector seedPosition{Acts::SpacePointVector::Zero()};
-
-    // Needs relinearization bool
-    bool relinearize;
-  };
-
-  /// @brief Helper struct for storing TrackAtVertex related
-  struct TrackAtVertexInfo {
-    // Links to vertices currently using the TrackAtVertex object
-    std::vector<Vertex<input_track_t>*> linksToVertices;
-
-    // Track parameters at point of closest approach in 3d as
-    // retrieved by ImpactPoint3dEstimator::getParamsAtClosestApproach
-    std::unique_ptr<const BoundParameters> ip3dParams;
-  };
-
   /// @brief The fitter state
   struct State {
     // Vertex collection to be fitted
@@ -86,10 +59,10 @@ class AdaptiveMultiVertexFitter {
     AnnealingUtility::State annealingState;
 
     // Map to store vertices information
-    std::map<Vertex<InputTrack_t>*, VertexInfo> vtxInfoMap;
+    std::map<Vertex<InputTrack_t>*, VertexInfo<InputTrack_t>> vtxInfoMap;
 
     // Map to store tracks information
-    std::map<unsigned long, TrackAtVertexInfo> trkInfoMap;
+    std::map<unsigned long, TrackAtVertexInfo<InputTrack_t>> trkInfoMap;
 
     /// @brief Default State constructor
     State() = default;
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
index dcfff2315..6f8b9172b 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
@@ -55,7 +55,7 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::fitImpl(
          (!state.annealingState.equilibriumReached || !isSmallShift)) {
     // Initial loop over all vertices in state.vertexCollection
     for (auto currentVtx : state.vertexCollection) {
-      VertexInfo& currentVtxInfo = state.vtxInfoMap[currentVtx];
+      VertexInfo<input_track_t>& currentVtxInfo = state.vtxInfoMap[currentVtx];
       currentVtxInfo.relinearize = false;
       // Store old position of vertex, i.e. seed position
       // in case of first iteration or position determined
@@ -232,7 +232,7 @@ Acts::Result<void>
 Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::
     setAllVertexCompatibilities(State& state, const GeometryContext& geoContext,
                                 Vertex<input_track_t>* currentVtx) const {
-  VertexInfo& currentVtxInfo = state.vtxInfoMap[currentVtx];
+  VertexInfo<input_track_t>& currentVtxInfo = state.vtxInfoMap[currentVtx];
   // Create empty list of new TrackAtVertex objects
   // to be filled below. Needed due to constness of
   // tracksAtVertex list at vertex
diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
index 11eb09e5d..589fb8c2b 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
@@ -393,7 +393,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test_athena) {
   vtx1Constr.setFitQuality(0, -3);
 
   // Prepare vtx info for fitter
-  AdaptiveMultiVertexFitter<BoundParameters, Linearizer>::VertexInfo vtxInfo1;
+  VertexInfo<BoundParameters> vtxInfo1;
   vtxInfo1.linPoint.setZero();
   vtxInfo1.linPoint.head<3>() = vtxPos1;
   vtxInfo1.constraintVertex = vtx1Constr;
@@ -414,7 +414,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test_athena) {
   vtx2Constr.setFitQuality(0, -3);
 
   // Prepare vtx info for fitter
-  AdaptiveMultiVertexFitter<BoundParameters, Linearizer>::VertexInfo vtxInfo2;
+  VertexInfo<BoundParameters> vtxInfo2;
   vtxInfo2.linPoint.setZero();
   vtxInfo2.linPoint.head<3>() = vtxPos2;
   vtxInfo2.constraintVertex = vtx2Constr;
-- 
GitLab


From e22159c3bfc3df53f3e529900b81eadc9432e723 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Tue, 18 Feb 2020 17:41:09 +0100
Subject: [PATCH 09/60] introduce constructor for VertexInfo

---
 Core/include/Acts/Vertexing/AMVFInfo.hpp      | 55 +++++++++++--------
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   |  1 +
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   |  3 +
 .../Vertexing/AdaptiveMultiVertexFitter.hpp   |  2 +-
 4 files changed, 37 insertions(+), 24 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AMVFInfo.hpp b/Core/include/Acts/Vertexing/AMVFInfo.hpp
index 92844fe49..a244400c0 100644
--- a/Core/include/Acts/Vertexing/AMVFInfo.hpp
+++ b/Core/include/Acts/Vertexing/AMVFInfo.hpp
@@ -8,39 +8,48 @@
 
 #pragma once
 
-#include "Acts/Utilities/Definitions.hpp"
 #include "Acts/EventData/TrackParameters.hpp"
+#include "Acts/Utilities/Definitions.hpp"
 #include "Acts/Vertexing/Vertex.hpp"
 
 namespace Acts {
 
 /// @brief Helper struct for storing vertex related information
-  template<typename input_track_t>
-  struct VertexInfo {
-    // The linearization point
-    Acts::SpacePointVector linPoint{Acts::SpacePointVector::Zero()};
+template <typename input_track_t>
+struct VertexInfo {
+  VertexInfo() = default;
+
+  VertexInfo(const Acts::Vertex<input_track_t>& vtx,
+             const Acts::SpacePointVector& pos)
+      : constraintVertex(vtx),
+        linPoint(pos),
+        oldPosition(pos),
+        seedPosition(pos) {}
+
+  // The constraint vertex
+  Acts::Vertex<input_track_t> constraintVertex;
 
-    // The constraint vertex
-    Acts::Vertex<input_track_t> constraintVertex;
+  // The linearization point
+  Acts::SpacePointVector linPoint{Acts::SpacePointVector::Zero()};
 
-    // Old position from last iteration
-    Acts::SpacePointVector oldPosition;
+  // Old position from last iteration
+  Acts::SpacePointVector oldPosition{Acts::SpacePointVector::Zero()};
 
-    Acts::SpacePointVector seedPosition;
+  Acts::SpacePointVector seedPosition{Acts::SpacePointVector::Zero()};
 
-    // Needs relinearization bool
-    bool relinearize;
-  };
+  // Needs relinearization bool
+  bool relinearize;
+};
 
-  /// @brief Helper struct for storing TrackAtVertex related
-  template<typename input_track_t>
-  struct TrackAtVertexInfo {
-    // Links to vertices currently using the TrackAtVertex object
-    std::vector<Vertex<input_track_t>*> linksToVertices;
+/// @brief Helper struct for storing TrackAtVertex related
+template <typename input_track_t>
+struct TrackAtVertexInfo {
+  // Links to vertices currently using the TrackAtVertex object
+  std::vector<Vertex<input_track_t>*> linksToVertices;
 
-    // Track parameters at point of closest approach in 3d as
-    // retrieved by ImpactPoint3dEstimator::getParamsAtClosestApproach
-    std::unique_ptr<const BoundParameters> ip3dParams;
-  };
+  // Track parameters at point of closest approach in 3d as
+  // retrieved by ImpactPoint3dEstimator::getParamsAtClosestApproach
+  std::unique_ptr<const BoundParameters> ip3dParams;
+};
 
-} // Acts namespace
\ No newline at end of file
+}  // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index 2dd89a774..71fc39463 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -13,6 +13,7 @@
 #include "Acts/Utilities/Logger.hpp"
 #include "Acts/Utilities/Result.hpp"
 #include "Acts/Utilities/Units.hpp"
+#include "Acts/Vertexing/AMVFInfo.hpp"
 #include "Acts/Vertexing/TrackToVertexIPEstimator.hpp"
 #include "Acts/Vertexing/VertexFinderOptions.hpp"
 
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index c79666fe0..fa9c5f9de 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -57,6 +57,9 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
       // No seed found anymore, break and stop primary vertex finding
       break;
     }
+
+    VertexInfo<InputTrack_t> vtxCandidateInfo(finderOptions.vertexConstraint,
+                                              vtxCandidate.fullPosition());
   }
 
   return allVertices;
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
index 55370ba5b..c62fdffa4 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
@@ -13,12 +13,12 @@
 #include "Acts/Utilities/Definitions.hpp"
 #include "Acts/Utilities/Logger.hpp"
 #include "Acts/Utilities/Result.hpp"
+#include "Acts/Vertexing/AMVFInfo.hpp"
 #include "Acts/Vertexing/ImpactPoint3dEstimator.hpp"
 #include "Acts/Vertexing/LinearizerConcept.hpp"
 #include "Acts/Vertexing/TrackAtVertex.hpp"
 #include "Acts/Vertexing/Vertex.hpp"
 #include "Acts/Vertexing/VertexFitterOptions.hpp"
-#include "Acts/Vertexing/AMVFInfo.hpp"
 
 #include <functional>
 
-- 
GitLab


From 7ffa16d5d2d6288b41bbfb65d1e0b009ca86b55f Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Tue, 18 Feb 2020 17:54:02 +0100
Subject: [PATCH 10/60] update vertexing unittest cmake list

---
 Tests/UnitTests/Core/Vertexing/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Tests/UnitTests/Core/Vertexing/CMakeLists.txt b/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
index ae5492d59..829ef494c 100644
--- a/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
+++ b/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
@@ -5,6 +5,7 @@ add_unittest(KalmanVertexTrackUpdaterTests KalmanVertexTrackUpdaterTests.cpp)
 add_unittest(KalmanVertexUpdaterTests KalmanVertexUpdaterTests.cpp)
 add_unittest(LinearizedTrackFactoryTests LinearizedTrackFactoryTests.cpp)
 add_unittest(AdaptiveMultiVertexFitterTests AdaptiveMultiVertexFitterTests.cpp)
+add_unittest(AdaptiveMultiVertexFinderTests AdaptiveMultiVertexFinderTests.cpp)
 add_unittest(TrackToVertexIPEstimatorTests TrackToVertexIPEstimatorTests.cpp)
 add_unittest(VertexSmootherTests VertexSmootherTests.cpp)
 add_unittest(ZScanVertexFinderTests ZScanVertexFinderTests.cpp)
-- 
GitLab


From 8d69e21d6d2128c001b75c6012c248f93fe6097e Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Wed, 19 Feb 2020 16:23:47 +0100
Subject: [PATCH 11/60] add getIPSignificance and estimateDeltaZ methods

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   | 27 ++++++++++-
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 46 +++++++++++++++++++
 2 files changed, 72 insertions(+), 1 deletion(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index 71fc39463..893325efe 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -135,7 +135,7 @@ class AdaptiveMultiVertexFinder {
      * the track is not updated during that iteration.
      */
 
-    double minweight = 0.0001;
+    double minWeight = 0.0001;
 
     /*
      * Maximum amount of iterations allowed for vertex finding.
@@ -236,9 +236,34 @@ class AdaptiveMultiVertexFinder {
   /// Private access to logging instance
   const Logger& logger() const { return *m_logger; }
 
+  /// @brief Calls the seed finder and sets constraints on the found seed
+  /// vertex if desired
+  ///
+  /// @param trackVector All tracks to be used for seeding
+  /// @param vFinderOptions Vertex finder options
+  ///
+  /// @return The seed vertex
   Result<Vertex<InputTrack_t>> doSeeding(
       const std::vector<InputTrack_t>& trackVector,
       VertexFinderOptions<InputTrack_t>& vFinderOptions) const;
+
+  /// @brief Estimates delta Z between a track and a vertex position
+  ///
+  /// @param track The track
+  /// @param vtxPos The vertex position
+  ///
+  /// @return The delta Z estimate
+  double estimateDeltaZ(const BoundParameters& track,
+                        const Vector3D& vtxPos) const;
+
+  /// @brief Calculates the IP significance of a track to a given vertex
+  ///
+  /// @param track The track
+  /// @param vtx The vertex
+  ///
+  /// @return The IP significance
+  Result<double> getIPSignificance(const BoundParameters& track,
+                                   const Vertex<InputTrack_t>& vtx) const;
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index fa9c5f9de..9bd7ffc77 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -96,3 +96,49 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::doSeeding(
 
   return seedVertex;
 }
+
+template <typename vfitter_t, typename sfinder_t>
+auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::estimateDeltaZ(
+    const BoundParameters& track, const Vector3D& vtxPos) const -> double {
+  Vector3D trackPos = track.position();
+
+  double phi = track.parameters()[ParID_t::ePHI];
+  double th = track.parameters()[ParID_t::eTHETA];
+
+  double X = trackPos[eX] - vtxPos.x();
+  double Y = trackPos[eY] - vtxPos.y();
+
+  double deltaZ = trackPos[eZ] - vtxPos.z() -
+                  1. / std::tan(th) * (X * std::cos(phi) + Y * std::sin(phi));
+
+  return deltaZ;
+}
+
+template <typename vfitter_t, typename sfinder_t>
+auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::getIPSignificance(
+    const BoundParameters& track, const Vertex<InputTrack_t>& vtx) const
+    -> Result<double> {
+  // TODO: In original implementation the covariance of the given vertex is set
+  // to zero. I did the same here now, but consider removing this and just
+  // passing the vtx object to the estimator without changing its covariance.
+  // After all, the vertex seed does have a non-zero convariance in general and
+  // it probably should be used.
+  Vertex<InputTrack_t> newVtx = vtx;
+  newVtx.setFullCovariance(SpacePointSymMatrix::Zero());
+
+  double significance = 0.;
+
+  auto estRes = m_cfg.ipEstimator.estimate(track, newVtx);
+  if (!estRes.ok()) {
+    return estRes.error();
+  }
+
+  auto ipas = std::move(*estRes);
+
+  if (ipas->sigmad0 > 0 && ipas->sigmaz0 > 0) {
+    significance = std::sqrt(std::pow(ipas->IPd0 / ipas->sigmad0, 2) +
+                             std::pow(ipas->IPz0 / ipas->sigmaz0, 2));
+  }
+
+  return significance;
+}
-- 
GitLab


From 622246d5a8d5ba511e7157a88facf79f6010231a Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Wed, 19 Feb 2020 19:52:53 +0100
Subject: [PATCH 12/60] add functionality to prepare vertex for fit

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   |  44 +++++-
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 134 +++++++++++++++++-
 .../Vertexing/AdaptiveMultiVertexFitter.hpp   |  10 +-
 Core/include/Acts/Vertexing/TrackAtVertex.hpp |  22 ++-
 4 files changed, 203 insertions(+), 7 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index 893325efe..ac34a0eec 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -38,6 +38,8 @@ template <typename vfitter_t, typename sfinder_t>
 class AdaptiveMultiVertexFinder {
   using Propagator_t = typename vfitter_t::Propagator_t;
   using InputTrack_t = typename vfitter_t::InputTrack_t;
+  using Linearizer_t = typename vfitter_t::Linearizer_t;
+  using FitterState_t = typename vfitter_t::State;
 
  public:
   /// @struct Config Configuration struct
@@ -79,7 +81,7 @@ class AdaptiveMultiVertexFinder {
      * consider a lot of tracks which just slow down the fit.
      */
 
-    double TracksMaxZinterval = 4_mm;
+    double tracksMaxZinterval = 4_mm;
 
     /**
      * After having added one vertex to the fit and having
@@ -264,6 +266,46 @@ class AdaptiveMultiVertexFinder {
   /// @return The IP significance
   Result<double> getIPSignificance(const BoundParameters& track,
                                    const Vertex<InputTrack_t>& vtx) const;
+
+  /// @brief Adds compatible track to vertex candidate
+  ///
+  /// @param tracks The tracks
+  /// @param[out] vtx The vertex candidate
+  Result<void> addCompatibleTracksToVertex(
+      const std::vector<InputTrack_t>& tracks, Vertex<InputTrack_t>& vtx) const;
+
+  /// @brief Method that tries to recover from cases where no tracks
+  /// where added to the vertex candidate after seeding
+  ///
+  /// @param myTracks The tracks to be considered (either origTrack or
+  /// seedTracks)
+  /// @param seedTracks The seed tracks
+  /// @param[out] vtx The vertex candidate
+  /// @param vFinderOptions Vertex finder options
+  /// @param[out] fitterState The vertex fitter state
+  ///
+  /// return True if recovery was successful, false otherwise
+  Result<bool> canRecoverFromNoCompatibleTracks(
+      const std::vector<InputTrack_t>& myTracks,
+      const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>& vtx,
+      const VertexFinderOptions<InputTrack_t>& vFinderOptions,
+      FitterState_t& fitterState) const;
+
+  /// @brief Method that tries to prepare the vertex for the fit
+  ///
+  /// @param myTracks The tracks to be considered (either origTrack or
+  /// seedTracks)
+  /// @param seedTracks The seed tracks
+  /// @param[out] vtx The vertex candidate
+  /// @param vFinderOptions Vertex finder options
+  /// @param[out] fitterState The vertex fitter state
+  ///
+  /// @return True if preparation was successful, false otherwise
+  Result<bool> canPrepareVertexForFit(
+      const std::vector<InputTrack_t>& myTracks,
+      const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>& vtx,
+      const VertexFinderOptions<InputTrack_t>& vFinderOptions,
+      FitterState_t& fitterState) const;
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index 9bd7ffc77..153a3203f 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -40,12 +40,24 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
       finderOptions.geoContext, finderOptions.magFieldContext,
       finderOptions.vertexConstraint);
 
+  FitterState_t fitterState;
+
   std::vector<Vertex<InputTrack_t>> allVertices;
 
   int iteration = 0;
   while (((m_cfg.addSingleTrackVertices && seedTracks.size() > 0) ||
           ((!m_cfg.addSingleTrackVertices) && seedTracks.size() > 1)) &&
          iteration < m_cfg.maxIterations) {
+    // Tracks that are used for searching compatible tracks
+    // near a vertex candidate
+    // TODO: This involves a lot of copying. Change the way of accessing tracks
+    std::vector<InputTrack_t> myTracks;
+    if (m_cfg.realMultiVertex == true) {
+      myTracks = origTracks;
+    } else {
+      myTracks = seedTracks;
+    }
+
     // Retrieve seed vertex from all remaining seedTracks
     auto seedRes = doSeeding(seedTracks, finderOptions);
     if (!seedRes.ok()) {
@@ -54,12 +66,22 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     Vertex<InputTrack_t> vtxCandidate = *seedRes;
 
     if (vtxCandidate.position().z() == 0.) {
-      // No seed found anymore, break and stop primary vertex finding
+      ACTS_DEBUG(
+          "No seed found anymore. Break and stop primary vertex finding.");
       break;
     }
 
-    VertexInfo<InputTrack_t> vtxCandidateInfo(finderOptions.vertexConstraint,
-                                              vtxCandidate.fullPosition());
+    auto resPrep = canPrepareVertexForFit(myTracks, seedTracks, vtxCandidate,
+                                          finderOptions, fitterState);
+    if (!resPrep.ok()) {
+      return resPrep.error();
+    }
+    if (!(*resPrep)) {
+      // Could not prepare the vertex for the fit anymore, break.
+      break;
+    }
+
+    // state.vtxInfoMap[&vtxCandidate] = vtxInfo1;
   }
 
   return allVertices;
@@ -142,3 +164,109 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::getIPSignificance(
 
   return significance;
 }
+
+template <typename vfitter_t, typename sfinder_t>
+auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
+    addCompatibleTracksToVertex(const std::vector<InputTrack_t>& tracks,
+                                Vertex<InputTrack_t>& vtx) const
+    -> Result<void> {
+  std::vector<TrackAtVertex<InputTrack_t>> tracksAtVtx;
+
+  for (const auto& trk : tracks) {
+    BoundParameters params = m_extractParameters(trk);
+    auto sigRes = getIPSignificance(params, vtx);
+    if (!sigRes.ok()) {
+      return sigRes.error();
+    }
+    double ipSig = *sigRes;
+    if ((std::abs(estimateDeltaZ(params, vtx.position())) <
+         m_cfg.tracksMaxZinterval) &&
+        (ipSig < m_cfg.tracksMaxSignificance)) {
+      tracksAtVtx.push_back(TrackAtVertex(params, trk));
+    }
+  }
+
+  vtx.setTracksAtVertex(tracksAtVtx);
+
+  return {};
+}
+
+template <typename vfitter_t, typename sfinder_t>
+auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
+    canRecoverFromNoCompatibleTracks(
+        const std::vector<InputTrack_t>& myTracks,
+        const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>& vtx,
+        const VertexFinderOptions<InputTrack_t>& vFinderOptions,
+        FitterState_t& fitterState) const -> Result<bool> {
+  // Recover from cases where no compatible tracks to vertex
+  // candidate were found
+  // TODO: This is for now how it's done in athena... this look a bit
+  // nasty to me
+  if (vtx.tracks().empty()) {
+    double smallestDeltaZ = std::numeric_limits<double>::max();
+    double newZ = 0;
+    bool nearTrackFound = false;
+    for (const auto& trk : seedTracks) {
+      double zDistance = std::abs(m_extractParameters(trk).position()[eZ] -
+                                  vtx.position()[eZ]);
+      if (zDistance < smallestDeltaZ) {
+        smallestDeltaZ = zDistance;
+        nearTrackFound = true;
+        newZ = m_extractParameters(trk).position()[eZ];
+      }
+    }
+    if (nearTrackFound) {
+      // TODO: check athena actualcandidate position here (has not changed?)
+      // TODO: so do I want to change the vtx position here?
+      vtx.setFullPosition(SpacePointVector(0., 0., newZ, 0.));
+
+      // TODO: do sth with fitterstate here
+      // vtxInfo = VertexInfo<InputTrack_t>(vFinderOptions.vertexConstraint,
+      //                                   vtx.fullPosition());
+
+      // Try to add compatible track with adapted vertex position
+      auto res = addCompatibleTracksToVertex(myTracks, vtx);
+      if (!res.ok()) {
+        return Result<bool>::failure(res.error());
+      }
+
+      if (vtx.tracks().empty()) {
+        ACTS_DEBUG(
+            "No tracks near seed were found, while at least one was "
+            "expected. Break.");
+        return Result<bool>::success(false);
+      }
+
+    } else {
+      ACTS_DEBUG("No nearest track to seed found. Break.");
+      return Result<bool>::success(false);
+    }
+  }
+
+  return Result<bool>::success(true);
+}
+
+template <typename vfitter_t, typename sfinder_t>
+auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
+    canPrepareVertexForFit(
+        const std::vector<InputTrack_t>& myTracks,
+        const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>& vtx,
+        const VertexFinderOptions<InputTrack_t>& vFinderOptions,
+        FitterState_t& fitterState) const -> Result<bool> {
+  // TODO: do something with state here
+  VertexInfo<InputTrack_t> vtxCandidateInfo(vFinderOptions.vertexConstraint,
+                                            vtx.fullPosition());
+
+  auto resComp = addCompatibleTracksToVertex(myTracks, vtx);
+  if (!resComp.ok()) {
+    return Result<bool>::failure(resComp.error());
+  }
+
+  auto resRec = canRecoverFromNoCompatibleTracks(myTracks, seedTracks, vtx,
+                                                 vFinderOptions, fitterState);
+  if (!resRec.ok()) {
+    return Result<bool>::failure(resRec.error());
+  }
+
+  return Result<bool>::success(*resRec);
+}
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
index c62fdffa4..c3d63f8d9 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
@@ -71,6 +71,14 @@ class AdaptiveMultiVertexFitter {
     ///
     /// @param vtxList List of all vertices with trackAtVertex information
     State(std::vector<Vertex<input_track_t>>& vtxList) {
+      updateVertexList(vtxList);
+    }
+
+    State(std::vector<Vertex<input_track_t>*>& vtxList) {
+      updateVertexList(vtxList);
+    }
+
+    void updateVertexList(std::vector<Vertex<input_track_t>>& vtxList) {
       for (auto& vtx : vtxList) {
         // Add vertex link to each track
         for (auto& trkAtVtx : vtx.tracks()) {
@@ -79,7 +87,7 @@ class AdaptiveMultiVertexFitter {
       }
     }
 
-    State(std::vector<Vertex<input_track_t>*>& vtxList) {
+    void updateVertexList(std::vector<Vertex<input_track_t>*>& vtxList) {
       for (auto& vtx : vtxList) {
         // Add vertex link to each track
         for (auto& trkAtVtx : vtx->tracks()) {
diff --git a/Core/include/Acts/Vertexing/TrackAtVertex.hpp b/Core/include/Acts/Vertexing/TrackAtVertex.hpp
index d3bf98943..3dcd2b791 100644
--- a/Core/include/Acts/Vertexing/TrackAtVertex.hpp
+++ b/Core/include/Acts/Vertexing/TrackAtVertex.hpp
@@ -32,11 +32,29 @@ struct TrackAtVertex {
   /// @param chi2perTrack Chi2 of track
   /// @param paramsAtVertex Fitted perigee parameter
   /// @param originalParams Original perigee parameter
-
   TrackAtVertex(double chi2perTrack, const BoundParameters& paramsAtVertex,
                 const input_track_t& originalParams)
       : chi2Track(chi2perTrack),
-        ndf(0),
+        ndf(0.),
+        fittedParams(paramsAtVertex),
+        originalTrack(originalParams),
+        trackWeight(1.),
+        vertexCompatibility(0.) {
+    // Create unique ID for this object
+    boost::hash_combine(id, this);
+    boost::hash_combine(id, paramsAtVertex.parameters()[0]);
+    boost::hash_combine(id, paramsAtVertex.parameters()[1]);
+  }
+
+  /// @brief Constructor with default chi2
+  ///
+  /// @param chi2perTrack Chi2 of track
+  /// @param paramsAtVertex Fitted perigee parameter
+  /// @param originalParams Original perigee parameter
+  TrackAtVertex(const BoundParameters& paramsAtVertex,
+                const input_track_t& originalParams)
+      : chi2Track(0.),
+        ndf(0.),
         fittedParams(paramsAtVertex),
         originalTrack(originalParams),
         trackWeight(1.),
-- 
GitLab


From 016c4bdec74b018d5157b49100586b4ca7a06ab1 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Wed, 19 Feb 2020 23:23:13 +0100
Subject: [PATCH 13/60] use fitter to fit vertices in AMVFinder

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   | 20 +++---
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 61 +++++++++++--------
 .../AdaptiveMultiVertexFinderTests.cpp        | 12 +++-
 3 files changed, 61 insertions(+), 32 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index ac34a0eec..42b6c7771 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -49,21 +49,27 @@ class AdaptiveMultiVertexFinder {
     /// @param fitter The vertex fitter
     /// @param sfinder The seed finder
     /// @param ipEst TrackToVertexIPEstimator
+    /// @param lin Track linearizer
     Config(vfitter_t fitter, sfinder_t sfinder,
-           TrackToVertexIPEstimator<InputTrack_t, Propagator_t> ipEst)
+           TrackToVertexIPEstimator<InputTrack_t, Propagator_t> ipEst,
+           Linearizer_t lin)
         : vertexFitter(std::move(fitter)),
           seedFinder(std::move(sfinder)),
-          ipEstimator(std::move(ipEst)) {}
+          ipEstimator(std::move(ipEst)),
+          linearizer(std::move(lin)) {}
 
     // Vertex fitter
     vfitter_t vertexFitter;
 
-    /// Vertex seed finder
+    // Vertex seed finder
     sfinder_t seedFinder;
 
     // TrackToVertexIPEstimator
     TrackToVertexIPEstimator<InputTrack_t, Propagator_t> ipEstimator;
 
+    // Track linearizer
+    Linearizer_t linearizer;
+
     /// TODO: Update descriptions!
     /** Define a beam constraint for the fit */
     bool useBeamSpotConstraint = true;
@@ -265,14 +271,14 @@ class AdaptiveMultiVertexFinder {
   ///
   /// @return The IP significance
   Result<double> getIPSignificance(const BoundParameters& track,
-                                   const Vertex<InputTrack_t>& vtx) const;
+                                   const Vertex<InputTrack_t>* vtx) const;
 
   /// @brief Adds compatible track to vertex candidate
   ///
   /// @param tracks The tracks
   /// @param[out] vtx The vertex candidate
   Result<void> addCompatibleTracksToVertex(
-      const std::vector<InputTrack_t>& tracks, Vertex<InputTrack_t>& vtx) const;
+      const std::vector<InputTrack_t>& tracks, Vertex<InputTrack_t>* vtx) const;
 
   /// @brief Method that tries to recover from cases where no tracks
   /// where added to the vertex candidate after seeding
@@ -287,7 +293,7 @@ class AdaptiveMultiVertexFinder {
   /// return True if recovery was successful, false otherwise
   Result<bool> canRecoverFromNoCompatibleTracks(
       const std::vector<InputTrack_t>& myTracks,
-      const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>& vtx,
+      const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>* vtx,
       const VertexFinderOptions<InputTrack_t>& vFinderOptions,
       FitterState_t& fitterState) const;
 
@@ -303,7 +309,7 @@ class AdaptiveMultiVertexFinder {
   /// @return True if preparation was successful, false otherwise
   Result<bool> canPrepareVertexForFit(
       const std::vector<InputTrack_t>& myTracks,
-      const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>& vtx,
+      const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>* vtx,
       const VertexFinderOptions<InputTrack_t>& vFinderOptions,
       FitterState_t& fitterState) const;
 };
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index 153a3203f..ce9c5e346 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -63,9 +63,12 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     if (!seedRes.ok()) {
       return seedRes.error();
     }
-    Vertex<InputTrack_t> vtxCandidate = *seedRes;
 
-    if (vtxCandidate.position().z() == 0.) {
+    allVertices.push_back(*seedRes);
+
+    Vertex<InputTrack_t>* vtxCandidate = &(allVertices.back());
+
+    if (vtxCandidate->position().z() == 0.) {
       ACTS_DEBUG(
           "No seed found anymore. Break and stop primary vertex finding.");
       break;
@@ -77,11 +80,19 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
       return resPrep.error();
     }
     if (!(*resPrep)) {
-      // Could not prepare the vertex for the fit anymore, break.
+      ACTS_DEBUG("Could not prepare for fit anymore. Break.");
       break;
     }
-
-    // state.vtxInfoMap[&vtxCandidate] = vtxInfo1;
+    // Update fitter state with all vertices
+    fitterState.updateVertexList(allVertices);
+    // Perform the fit
+    auto fitResult = m_cfg.vertexFitter.addVtxToFit(
+        fitterState, *vtxCandidate, m_cfg.linearizer, vFitterOptions);
+    if (!fitResult.ok()) {
+      return fitResult.error();
+    }
+    ACTS_DEBUG("New position of current vertex after fit: "
+               << vtxCandidate->fullPosition());
   }
 
   return allVertices;
@@ -100,7 +111,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::doSeeding(
   }
 
   Vertex<InputTrack_t> seedVertex = (*seedRes).back();
-
+  // Update constraints according to seed vertex
   if (m_cfg.useBeamSpotConstraint) {
     if (m_cfg.useSeedConstraint) {
       vFinderOptions.vertexConstraint.setFullPosition(
@@ -138,14 +149,14 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::estimateDeltaZ(
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::getIPSignificance(
-    const BoundParameters& track, const Vertex<InputTrack_t>& vtx) const
+    const BoundParameters& track, const Vertex<InputTrack_t>* vtx) const
     -> Result<double> {
   // TODO: In original implementation the covariance of the given vertex is set
   // to zero. I did the same here now, but consider removing this and just
   // passing the vtx object to the estimator without changing its covariance.
   // After all, the vertex seed does have a non-zero convariance in general and
   // it probably should be used.
-  Vertex<InputTrack_t> newVtx = vtx;
+  Vertex<InputTrack_t> newVtx = *vtx;
   newVtx.setFullCovariance(SpacePointSymMatrix::Zero());
 
   double significance = 0.;
@@ -168,7 +179,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::getIPSignificance(
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     addCompatibleTracksToVertex(const std::vector<InputTrack_t>& tracks,
-                                Vertex<InputTrack_t>& vtx) const
+                                Vertex<InputTrack_t>* vtx) const
     -> Result<void> {
   std::vector<TrackAtVertex<InputTrack_t>> tracksAtVtx;
 
@@ -179,14 +190,14 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
       return sigRes.error();
     }
     double ipSig = *sigRes;
-    if ((std::abs(estimateDeltaZ(params, vtx.position())) <
+    if ((std::abs(estimateDeltaZ(params, vtx->position())) <
          m_cfg.tracksMaxZinterval) &&
         (ipSig < m_cfg.tracksMaxSignificance)) {
       tracksAtVtx.push_back(TrackAtVertex(params, trk));
     }
   }
 
-  vtx.setTracksAtVertex(tracksAtVtx);
+  vtx->setTracksAtVertex(tracksAtVtx);
 
   return {};
 }
@@ -195,20 +206,21 @@ template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     canRecoverFromNoCompatibleTracks(
         const std::vector<InputTrack_t>& myTracks,
-        const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>& vtx,
+        const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>* vtx,
         const VertexFinderOptions<InputTrack_t>& vFinderOptions,
         FitterState_t& fitterState) const -> Result<bool> {
   // Recover from cases where no compatible tracks to vertex
   // candidate were found
   // TODO: This is for now how it's done in athena... this look a bit
   // nasty to me
-  if (vtx.tracks().empty()) {
+  if (vtx->tracks().empty()) {
+    // Find nearest track to vertex candidate
     double smallestDeltaZ = std::numeric_limits<double>::max();
     double newZ = 0;
     bool nearTrackFound = false;
     for (const auto& trk : seedTracks) {
       double zDistance = std::abs(m_extractParameters(trk).position()[eZ] -
-                                  vtx.position()[eZ]);
+                                  vtx->position()[eZ]);
       if (zDistance < smallestDeltaZ) {
         smallestDeltaZ = zDistance;
         nearTrackFound = true;
@@ -218,11 +230,11 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     if (nearTrackFound) {
       // TODO: check athena actualcandidate position here (has not changed?)
       // TODO: so do I want to change the vtx position here?
-      vtx.setFullPosition(SpacePointVector(0., 0., newZ, 0.));
+      vtx->setFullPosition(SpacePointVector(0., 0., newZ, 0.));
 
-      // TODO: do sth with fitterstate here
-      // vtxInfo = VertexInfo<InputTrack_t>(vFinderOptions.vertexConstraint,
-      //                                   vtx.fullPosition());
+      // Update vertex info for current vertex
+      fitterState.vtxInfoMap[vtx] = VertexInfo<InputTrack_t>(
+          vFinderOptions.vertexConstraint, vtx->fullPosition());
 
       // Try to add compatible track with adapted vertex position
       auto res = addCompatibleTracksToVertex(myTracks, vtx);
@@ -230,7 +242,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
         return Result<bool>::failure(res.error());
       }
 
-      if (vtx.tracks().empty()) {
+      if (vtx->tracks().empty()) {
         ACTS_DEBUG(
             "No tracks near seed were found, while at least one was "
             "expected. Break.");
@@ -250,18 +262,19 @@ template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     canPrepareVertexForFit(
         const std::vector<InputTrack_t>& myTracks,
-        const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>& vtx,
+        const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>* vtx,
         const VertexFinderOptions<InputTrack_t>& vFinderOptions,
         FitterState_t& fitterState) const -> Result<bool> {
-  // TODO: do something with state here
-  VertexInfo<InputTrack_t> vtxCandidateInfo(vFinderOptions.vertexConstraint,
-                                            vtx.fullPosition());
+  // Add vertex info to fitter state
+  fitterState.vtxInfoMap[vtx] = VertexInfo<InputTrack_t>(
+      vFinderOptions.vertexConstraint, vtx->fullPosition());
 
+  // Add all compatible tracks to vertex
   auto resComp = addCompatibleTracksToVertex(myTracks, vtx);
   if (!resComp.ok()) {
     return Result<bool>::failure(resComp.error());
   }
-
+  // Try to recover from cases where adding compatible track was not possible
   auto resRec = canRecoverFromNoCompatibleTracks(myTracks, seedTracks, vtx,
                                                  vFinderOptions, fitterState);
   if (!resRec.ok()) {
diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
index d881f49df..c5016b39d 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
@@ -91,7 +91,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
   using Finder = AdaptiveMultiVertexFinder<Fitter, SeedFinder>;
 
   Finder::Config finderConfig(std::move(fitter), std::move(seedFinder),
-                              std::move(ipEst));
+                              std::move(ipEst), std::move(linearizer));
 
   Finder finder(finderConfig);
 
@@ -101,6 +101,16 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
 
   std::cout << &finderOptions << std::endl;
 
+  Transform3D transform;
+  ActsSymMatrixD<3> rotMat;
+  rotMat << -0.780869, 0.624695, 3.79565e-17, 0.455842, 0.569803, 0.683763,
+      0.427144, 0.53393, -0.729704;
+  transform.rotate(rotMat);
+  transform.translation() = Vector3D(1, 2, 3);
+
+  std::cout << "translation: " << transform.translation() << std::endl;
+  std::cout << "rot: " << transform.rotation() << std::endl;
+
   auto bla = finder.find(tracks, finderOptions);
 }
 
-- 
GitLab


From 5e07493318898db0b5ee5a2178f6fba662a6a4e7 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Thu, 20 Feb 2020 01:03:36 +0100
Subject: [PATCH 14/60] checkVertexAndCompatibleTracks added

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   |  5 +++
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 44 ++++++++++++++++++-
 2 files changed, 48 insertions(+), 1 deletion(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index 42b6c7771..fe6fbb94b 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -312,6 +312,11 @@ class AdaptiveMultiVertexFinder {
       const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>* vtx,
       const VertexFinderOptions<InputTrack_t>& vFinderOptions,
       FitterState_t& fitterState) const;
+
+  void checkVertexAndCompatibleTracks(
+      const Vertex<InputTrack_t>* vtx,
+      const std::vector<InputTrack_t>& seedTracks, int& nCompatibleTracks,
+      bool& isGoodVertex) const;
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index ce9c5e346..c8068f067 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -67,6 +67,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     allVertices.push_back(*seedRes);
 
     Vertex<InputTrack_t>* vtxCandidate = &(allVertices.back());
+    ACTS_DEBUG("Position of current vertex candidate after seeding: "
+               << vtxCandidate->fullPosition());
 
     if (vtxCandidate->position().z() == 0.) {
       ACTS_DEBUG(
@@ -91,8 +93,15 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     if (!fitResult.ok()) {
       return fitResult.error();
     }
-    ACTS_DEBUG("New position of current vertex after fit: "
+    ACTS_DEBUG("New position of current vertex candidate after fit: "
                << vtxCandidate->fullPosition());
+
+    // Check if vertex is good vertex
+    bool isGoodVertex = false;
+    int nCompatibleTracks = 0;
+    checkVertexAndCompatibleTracks(vtxCandidate, seedTracks, nCompatibleTracks,
+                                   isGoodVertex);
+    ACTS_DEBUG("Vertex is good vertex: " << isGoodVertex);
   }
 
   return allVertices;
@@ -283,3 +292,36 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 
   return Result<bool>::success(*resRec);
 }
+
+template <typename vfitter_t, typename sfinder_t>
+auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
+    checkVertexAndCompatibleTracks(const Vertex<InputTrack_t>* vtx,
+                                   const std::vector<InputTrack_t>& seedTracks,
+                                   int& nCompatibleTracks,
+                                   bool& isGoodVertex) const -> void {
+  for (const auto& trk : vtx->tracks()) {
+    if ((trk.vertexCompatibility() < m_cfg.maxVertexChi2 &&
+         m_cfg.useFastCompatibility) ||
+        (trk.trackWeight() > m_cfg.minweight &&
+         trk.chi2Track() < m_cfg.maxVertexChi2 &&
+         !m_cfg.useFastCompatibility)) {
+      auto foundIter = std::find_if(
+          seedTracks.begin(), seedTracks.end(), [&trk, this](auto seedTrk) {
+            return trk == m_extractParameters(seedTrk);
+          });
+      if (foundIter != seedTracks.end()) {
+        nCompatibleTracks++;
+        ACTS_DEBUG("Compatible track found.");
+
+        if (m_cfg.addSingleTrackVertices && m_cfg.useBeamConstraint) {
+          isGoodVertex = true;
+          break;
+        }
+        if (nCompatibleTracks > 1) {
+          isGoodVertex = true;
+          break;
+        }
+      }
+    }
+  }  // end loop over all tracks at vertex
+}
-- 
GitLab


From 9ed08b24a4346a9f63f92aefd84917d3aadf5192 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Thu, 20 Feb 2020 17:21:09 +0100
Subject: [PATCH 15/60] save new vertex to vertexList if isGoodVertex, first
 complete version of AMVFinder, not validated yet

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   |  50 ++++
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 219 ++++++++++++++++--
 .../Vertexing/AdaptiveMultiVertexFitter.hpp   |   2 +
 3 files changed, 252 insertions(+), 19 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index fe6fbb94b..d194f4697 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -313,10 +313,60 @@ class AdaptiveMultiVertexFinder {
       const VertexFinderOptions<InputTrack_t>& vFinderOptions,
       FitterState_t& fitterState) const;
 
+  /// @brief Method that checks if vertex is a good vertex and if
+  /// compatible tracks are available
+  ///
+  /// @param vtx The vertex candidate
+  /// @param seedTracks The seed tracks
+  /// @param[out] nCompatibleTracks Number of compatible tracks
+  /// @param[out] isGoodVertex Vertex is good vertex
   void checkVertexAndCompatibleTracks(
       const Vertex<InputTrack_t>* vtx,
       const std::vector<InputTrack_t>& seedTracks, int& nCompatibleTracks,
       bool& isGoodVertex) const;
+
+  /// @brief Method that removes all tracks that are compatible with
+  /// current vertex from seedTracks
+  ///
+  /// @param vtx The vertex candidate
+  /// @param[out] seedTracks The seed tracks
+  void removeCompatibleTracksFromSeedTracks(
+      const Vertex<InputTrack_t>* vtx,
+      std::vector<InputTrack_t>& seedTracks) const;
+
+  /// @brief Method that tries to remove a non-compatible track
+  /// from seed tracks after removing a compatible track failed.
+  ///
+  /// @param vtx The vertex candidate
+  /// @param[out] seedTracks The seed tracks
+  ///
+  /// @return Non-compatible track was removed
+  bool canRemoveNonCompatibleTrackFromSeedTracks(
+      const Vertex<InputTrack_t>* vtx,
+      std::vector<InputTrack_t>& seedTracks) const;
+
+  /// @brief Method that evaluates if the new vertex candidate should
+  /// be kept, i.e. saved, or not
+  ///
+  /// @param vtx The vertex candidate
+  /// @param allVertices All so far found vertices
+  /// @param isGoodVertex Vertex is good vertex
+  ///
+  /// @return Keep new vertex
+  bool keepNewVertex(const Vertex<InputTrack_t>* vtx,
+                     const std::vector<Vertex<InputTrack_t>>& allVertices,
+                     bool isGoodVertex) const;
+
+  /// @brief Method that evaluates if the new vertex candidate is
+  /// merged with one of the previously found vertices
+  ///
+  /// @param vtx The vertex candidate
+  /// @param allVertices All so far found vertices
+  ///
+  /// @return Vertex is merged
+  bool isMergedVertex(
+      const Vertex<InputTrack_t>* vtx,
+      const std::vector<Vertex<InputTrack_t>>& allVertices) const;
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index c8068f067..9adcb6ec9 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -59,12 +59,12 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     }
 
     // Retrieve seed vertex from all remaining seedTracks
-    auto seedRes = doSeeding(seedTracks, finderOptions);
-    if (!seedRes.ok()) {
-      return seedRes.error();
+    auto seedResult = doSeeding(seedTracks, finderOptions);
+    if (!seedResult.ok()) {
+      return seedResult.error();
     }
 
-    allVertices.push_back(*seedRes);
+    allVertices.push_back(*seedResult);
 
     Vertex<InputTrack_t>* vtxCandidate = &(allVertices.back());
     ACTS_DEBUG("Position of current vertex candidate after seeding: "
@@ -76,12 +76,12 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
       break;
     }
 
-    auto resPrep = canPrepareVertexForFit(myTracks, seedTracks, vtxCandidate,
-                                          finderOptions, fitterState);
-    if (!resPrep.ok()) {
-      return resPrep.error();
+    auto prepResult = canPrepareVertexForFit(myTracks, seedTracks, vtxCandidate,
+                                             finderOptions, fitterState);
+    if (!prepResult.ok()) {
+      return prepResult.error();
     }
-    if (!(*resPrep)) {
+    if (!(*prepResult)) {
       ACTS_DEBUG("Could not prepare for fit anymore. Break.");
       break;
     }
@@ -102,6 +102,40 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     checkVertexAndCompatibleTracks(vtxCandidate, seedTracks, nCompatibleTracks,
                                    isGoodVertex);
     ACTS_DEBUG("Vertex is good vertex: " << isGoodVertex);
+
+    if (nCompatibleTracks > 0) {
+      removeCompatibleTracksFromSeedTracks(vtxCandidate, seedTracks);
+    } else {
+      bool removedNonCompatibleTrack =
+          canRemoveNonCompatibleTrackFromSeedTracks(vtxCandidate, seedTracks);
+
+      if (!removedNonCompatibleTrack) {
+        ACTS_DEBUG(
+            "Could not remove any further track from seed tracks. Break.");
+        break;
+      }
+    }
+
+    bool keepVertex = keepNewVertex(vtxCandidate, allVertices, isGoodVertex);
+    ACTS_DEBUG("New vertex will be saved: " << keepVertex);
+
+    // Delete vertex from allVertices list again if it's not kept
+    if (not keepVertex) {
+      allVertices.pop_back();
+      // Update fitter state with removed vertex candidate
+      fitterState.updateVertexList(allVertices);
+      // Prepare for final fit
+      std::vector<Vertex<InputTrack_t>*> vtxPtrVec;
+      for (auto& vtx : allVertices) {
+        vtxPtrVec.push_back(&vtx);
+      }
+      // Do the fit with removed vertex
+      auto fitResult = m_cfg.vertexFitter.fit(fitterState, vtxPtrVec,
+                                              m_cfg.linearizer, vFitterOptions);
+      if (!fitResult.ok()) {
+        return fitResult.error();
+      }
+    }
   }
 
   return allVertices;
@@ -113,13 +147,13 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::doSeeding(
     VertexFinderOptions<InputTrack_t>& vFinderOptions) const
     -> Result<Vertex<InputTrack_t>> {
   // Run seed finder
-  auto seedRes = m_cfg.seedFinder.find(trackVector, vFinderOptions);
+  auto seedResult = m_cfg.seedFinder.find(trackVector, vFinderOptions);
 
-  if (!seedRes.ok()) {
-    return seedRes.error();
+  if (!seedResult.ok()) {
+    return seedResult.error();
   }
 
-  Vertex<InputTrack_t> seedVertex = (*seedRes).back();
+  Vertex<InputTrack_t> seedVertex = (*seedResult).back();
   // Update constraints according to seed vertex
   if (m_cfg.useBeamSpotConstraint) {
     if (m_cfg.useSeedConstraint) {
@@ -300,20 +334,20 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
                                    int& nCompatibleTracks,
                                    bool& isGoodVertex) const -> void {
   for (const auto& trk : vtx->tracks()) {
-    if ((trk.vertexCompatibility() < m_cfg.maxVertexChi2 &&
+    if ((trk.vertexCompatibility < m_cfg.maxVertexChi2 &&
          m_cfg.useFastCompatibility) ||
-        (trk.trackWeight() > m_cfg.minweight &&
-         trk.chi2Track() < m_cfg.maxVertexChi2 &&
-         !m_cfg.useFastCompatibility)) {
+        (trk.trackWeight > m_cfg.minWeight &&
+         trk.chi2Track < m_cfg.maxVertexChi2 && !m_cfg.useFastCompatibility)) {
       auto foundIter = std::find_if(
           seedTracks.begin(), seedTracks.end(), [&trk, this](auto seedTrk) {
-            return trk == m_extractParameters(seedTrk);
+            return m_extractParameters(trk.originalTrack) ==
+                   m_extractParameters(seedTrk);
           });
       if (foundIter != seedTracks.end()) {
         nCompatibleTracks++;
         ACTS_DEBUG("Compatible track found.");
 
-        if (m_cfg.addSingleTrackVertices && m_cfg.useBeamConstraint) {
+        if (m_cfg.addSingleTrackVertices && m_cfg.useBeamSpotConstraint) {
           isGoodVertex = true;
           break;
         }
@@ -325,3 +359,150 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     }
   }  // end loop over all tracks at vertex
 }
+
+template <typename vfitter_t, typename sfinder_t>
+auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
+    removeCompatibleTracksFromSeedTracks(
+        const Vertex<InputTrack_t>* vtx,
+        std::vector<InputTrack_t>& seedTracks) const -> void {
+  for (const auto& trk : vtx->tracks()) {
+    if ((trk.vertexCompatibility < m_cfg.maxVertexChi2 &&
+         m_cfg.useFastCompatibility) ||
+        (trk.trackWeight > m_cfg.minWeight &&
+         trk.chi2Track < m_cfg.maxVertexChi2 && !m_cfg.useFastCompatibility)) {
+      // Find and remove track from seedTracks
+      auto foundSeedIter = std::find_if(
+          seedTracks.begin(), seedTracks.end(), [&trk, this](auto seedTrk) {
+            return m_extractParameters(trk.originalTrack) ==
+                   m_extractParameters(seedTrk);
+          });
+      if (foundSeedIter != seedTracks.end()) {
+        seedTracks.erase(foundSeedIter);
+      } else {
+        ACTS_DEBUG("Track not found in seedTracks!");
+      }
+    }
+  }
+}
+
+template <typename vfitter_t, typename sfinder_t>
+auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
+    canRemoveNonCompatibleTrackFromSeedTracks(
+        const Vertex<InputTrack_t>* vtx,
+        std::vector<InputTrack_t>& seedTracks) const -> bool {
+  // Try to find the track with highest compatibility
+  double maxCompatibility = 0;
+  typename std::vector<InputTrack_t>::iterator maxCompSeedIt;
+  for (const auto& trk : vtx->tracks()) {
+    double compatibility = trk.vertexCompatibility;
+    if (compatibility > maxCompatibility) {
+      // Try to find track in seed tracks
+      auto foundSeedIter = std::find_if(
+          seedTracks.begin(), seedTracks.end(), [&trk, this](auto seedTrk) {
+            return m_extractParameters(trk.originalTrack) ==
+                   m_extractParameters(seedTrk);
+          });
+      if (foundSeedIter != seedTracks.end()) {
+        maxCompatibility = compatibility;
+        maxCompSeedIt = foundSeedIter;
+      }
+    }
+  }
+  if (maxCompSeedIt != seedTracks.end()) {
+    // Remove track with highest compatibility from seed tracks
+    seedTracks.erase(maxCompSeedIt);
+  } else {
+    // Could not find any seed with compatibility > 0, use alternative
+    // method to remove a track from seed tracks: Closest track in z to
+    // vtx candidate
+    double smallestDeltaZ = std::numeric_limits<double>::max();
+    auto smallestDzSeedIter = std::find_if(
+        seedTracks.begin(), seedTracks.end(),
+        [&vtx, &smallestDeltaZ, this](auto trk) {
+          double zDistance = std::abs(m_extractParameters(trk).position()[eZ] -
+                                      vtx->position()[eZ]);
+          if (zDistance < smallestDeltaZ) {
+            smallestDeltaZ = zDistance;
+            return true;
+          }
+          return false;
+        });
+    if (smallestDzSeedIter != seedTracks.end()) {
+      seedTracks.erase(smallestDzSeedIter);
+    } else {
+      ACTS_DEBUG("No track found to remove. Stop vertex finding now.");
+      return false;
+    }
+  }
+  return true;
+}
+
+template <typename vfitter_t, typename sfinder_t>
+auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::keepNewVertex(
+    const Vertex<InputTrack_t>* vtx,
+    const std::vector<Vertex<InputTrack_t>>& allVertices,
+    bool isGoodVertex) const -> bool {
+  if (not isGoodVertex) {
+    return false;
+  }
+
+  double contamination = 0.;
+  double contaminationNum = 0;
+  double contaminationDeNom = 0;
+  for (const auto& trk : vtx->tracks()) {
+    double trackWeight = trk.trackWeight;
+    contaminationNum += trackWeight * (1. - trackWeight);
+    contaminationDeNom += trackWeight * trackWeight;
+  }
+  if (contaminationDeNom != 0) {
+    contamination = contaminationNum / contaminationDeNom;
+  }
+  if (contamination > m_cfg.maximumVertexContamination) {
+    return false;
+  }
+
+  if (isMergedVertex(vtx, allVertices)) {
+    return false;
+  }
+
+  return true;
+}
+
+template <typename vfitter_t, typename sfinder_t>
+auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::isMergedVertex(
+    const Vertex<InputTrack_t>* vtx,
+    const std::vector<Vertex<InputTrack_t>>& allVertices) const -> bool {
+  const SpacePointVector& candidatePos = vtx->fullPosition();
+  const SpacePointSymMatrix& candidateCov = vtx->fullCovariance();
+  const double candidateZPos = candidatePos[eZ];
+  const double candidateZCov = candidateCov(eZ, eZ);
+  for (const auto& otherVtx : allVertices) {
+    const SpacePointVector& otherPos = otherVtx.fullPosition();
+    const SpacePointSymMatrix& otherCov = otherVtx.fullCovariance();
+    const double otherZPos = otherPos[eZ];
+    const double otherZCov = otherCov(eZ, eZ);
+
+    const auto deltaPos = otherPos - candidatePos;
+    const auto deltaZPos = otherZPos - candidateZPos;
+    const auto sumCovZ = otherZCov + candidateZCov;
+
+    double significance;
+    if (not m_cfg.do3dSplitting) {
+      // Use only z significance
+      if (sumCovZ > 0.) {
+        significance = std::abs(deltaZPos) / std::sqrt(sumCovZ);
+      } else {
+        return true;
+      }
+    } else {
+      // Use full 3d information for significance
+      auto sumCov = candidateCov + otherCov;
+      significance =
+          std::sqrt(deltaPos.dot((sumCov.inverse().eval()) * deltaPos));
+    }
+    if (significance < m_cfg.cutVertexDependence) {
+      return true;
+    }
+  }
+  return false;
+}
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
index c3d63f8d9..84c4582b1 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
@@ -79,6 +79,7 @@ class AdaptiveMultiVertexFitter {
     }
 
     void updateVertexList(std::vector<Vertex<input_track_t>>& vtxList) {
+      trkInfoMap.clear();
       for (auto& vtx : vtxList) {
         // Add vertex link to each track
         for (auto& trkAtVtx : vtx.tracks()) {
@@ -88,6 +89,7 @@ class AdaptiveMultiVertexFitter {
     }
 
     void updateVertexList(std::vector<Vertex<input_track_t>*>& vtxList) {
+      trkInfoMap.clear();
       for (auto& vtx : vtxList) {
         // Add vertex link to each track
         for (auto& trkAtVtx : vtx->tracks()) {
-- 
GitLab


From be5bed6449a459762d3dcc62481616796600bdf5 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Thu, 20 Feb 2020 17:30:55 +0100
Subject: [PATCH 16/60] use unused variable in AMVFinder unit test

---
 .../Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp          | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
index c5016b39d..983b7a375 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
@@ -108,6 +108,9 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
   transform.rotate(rotMat);
   transform.translation() = Vector3D(1, 2, 3);
 
+  if (debugMode) {
+    std::cout << "Debug mode." << std::endl;
+  }
   std::cout << "translation: " << transform.translation() << std::endl;
   std::cout << "rot: " << transform.rotation() << std::endl;
 
-- 
GitLab


From b084b0d879fbf747bd296d32e1a485917635bc82 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Fri, 21 Feb 2020 14:09:22 +0100
Subject: [PATCH 17/60] update config docs in AMVFinder

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   | 133 ++++++------------
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   |   2 +-
 2 files changed, 46 insertions(+), 89 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index d194f4697..a09533858 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -18,9 +18,6 @@
 #include "Acts/Vertexing/VertexFinderOptions.hpp"
 
 namespace Acts {
-
-using namespace Acts::UnitLiterals;
-
 /// @class AdaptiveMultiVertexFinder
 ///
 /// @brief Implements an iterative vertex finder
@@ -70,116 +67,76 @@ class AdaptiveMultiVertexFinder {
     // Track linearizer
     Linearizer_t linearizer;
 
-    /// TODO: Update descriptions!
-    /** Define a beam constraint for the fit */
+    // Use a beam spot constraint, vertexConstraint in VertexFinderOptions
+    // has to be set in this case
     bool useBeamSpotConstraint = true;
 
-    /**
-     * When adding a new vertex to the multi vertex fit,
-     * only the tracks whose Z at PCA is closer
-     * to the seeded by more than this TracksMaxZinterval
-     * value are added to this new vertex.
-     *
-     * Default is 4 mm. If you cut too hard, you cut out
-     * the good cases where the seed finder is not
-     * reliable, but the fit would be still able to converge
-     * towards the right vertex. If you cut too soft, you
-     * consider a lot of tracks which just slow down the fit.
-     */
-
-    double tracksMaxZinterval = 4_mm;
-
-    /**
-     * After having added one vertex to the fit and having
-     * performed the MultiVertex fit again, all the tracks
-     * which are compatible to the new vertex by more than
-     * this maxVertexChi2 (in units of chi2) value are eliminated from the
-     * tracks from which still to seed the next vertex.
-     *
-     */
+    // Max z interval used for adding tracks to fit:
+    // When adding a new vertex to the multi vertex fit,
+    // only the tracks whose z at PCA is closer
+    // to the seeded vertex than tracksMaxZinterval
+    // are added to this new vertex.
+    //
+    // Note: Default is 4 mm. If you cut too hard, you cut out
+    // the good cases where the seed finder is not
+    // reliable, but the fit would be still able to converge
+    // towards the right vertex. If you cut too soft, you
+    // consider a lot of tracks which just slow down the fit.
+    double tracksMaxZinterval = 4. * Acts::UnitConstants::mm;
+
+    // Maximum allowed significance of track position to vertex seed
+    // to consider track as compatible track for vertex fit
+    double tracksMaxSignificance = 5.;
 
+    // Max chi2 value for which tracks are considered compatible with
+    // the fitted vertex. These tracks are removed from the seedTracks
+    // after the fit has been performed.
     double maxVertexChi2 = 18.42;
 
-    /**
-     * As a default the realMultiVertex should stay to false (because this is
-     * very well tested).
-     *
-     * If switched to true, all the tracks are considered to be added to the new
-     * vertex after this new one is seeded, and not only the ones which are
-     * considered as outliers of previous fitted vertices.
-     *
-     * The presence of a core of tracks the previous vertices are as attached to
-     * stabilizes the fit quite drastically. In case of luminosities higher than
-     * the low lumi scenario, one should probably to try to switch this on, or,
-     * if this doesn't work, decrease the maxVertexChi2 and the
-     * cleaningZinterval to lower values.
-     */
-
+    // Perform a 'real' multi-vertex fit as intended by the algorithm.
+    // If switched to true, always all (!) tracks are considered to be
+    // added to the new vertex candidate after seeding. If switched to
+    // false, only the seedTracks, i.e. all tracks that are considered
+    // as outliers of previously fitted vertices, are used.
     bool realMultiVertex = false;
 
-    /*
-     * Decides if you want to use the vtxCompatibility() of the track (set to
-     * true) or the chi2() (set to false) as an estimate for a track being an
-     * outlier or not. The vtxCompatibility() is the default. In case the track
-     * refitting is switched on in the AdaptiveMultiVertex fitter, you may want
-     * to use the refitted chi2().
-     *
-     */
-
+    // Decides if you want to use the ```vertexCompatibility``` of the
+    //  track (set to true) or the ```chi2Track``` (set to false) as an
+    // estimate for a track being an outlier or not.
+    // In case the track refitting is switched on in the AMVFitter, you
+    // may want to use the refitted ```chi2Track```.
     bool useFastCompatibility = true;
 
-    /*
-     * Maximum significance on the distance between two vertices
-     * to allow merging of two vertices.
-     *
-     */
-
-    double cutVertexDependence = 3.;
-
-    /*
-     * Has to be setup equal to the minimum weight set in the fitter.
-     *
-     * In the fitting, when a track has a weight lower than this value,
-     * the track is not updated during that iteration.
-     */
+    // Maximum significance on the distance between two vertices
+    // to allow merging of two vertices.
+    double maxMergeVertexSignificance = 3.;
 
+    // Minimum weight a track has to have to be considered a compatible
+    // track with a vertex candidate.
+    //
+    // Note: This value has to be the same as the one in the AMVFitter.
     double minWeight = 0.0001;
 
-    /*
-     * Maximum amount of iterations allowed for vertex finding.
-     *
-     * The more vertices you have in the event, the more iterations you have to
-     * allow (safe factor: number of expected vertices * 10)
-     *
-     */
-
+    // Maximal number of iterations in the finding procedure
     int maxIterations = 1000;
 
-    /*
-     * Fit also single track vertices
-     * (could be usefull for example for H-> gamma gamma)\
-     *
-     */
-
+    // Include also single track vertices
     bool addSingleTrackVertices = false;
 
+    // Use 3d information fo evaluating the vertex distance significance
+    // for vertex merging/splitting
     bool do3dSplitting = false;
 
+    // Maximum vertex contamination value
     double maximumVertexContamination = 0.5;
 
-    /*
-     * Maximum allowed significance of track position to vertex seed
-     */
-    double tracksMaxSignificance = 5.;
-
-    /*
-     * Toggle vertex seed constraint on/off
-     */
+    // Use seed vertex as a constraint for the fit
     bool useSeedConstraint = true;
 
     // Diagonal constraint covariance entries in case
     // no beamspot constraint is provided
     double looseConstrValue = 1e+8;
+
     // Default fitQuality for constraint vertex in case no beamspot
     // constraint is provided
     std::pair<double, double> defaultConstrFitQuality{0., -3.};
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index 9adcb6ec9..2d098b011 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -500,7 +500,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::isMergedVertex(
       significance =
           std::sqrt(deltaPos.dot((sumCov.inverse().eval()) * deltaPos));
     }
-    if (significance < m_cfg.cutVertexDependence) {
+    if (significance < m_cfg.maxMergeVertexSignificance) {
       return true;
     }
   }
-- 
GitLab


From f972110dd09379669dfb87585c95e5d603d8b45a Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Mon, 24 Feb 2020 12:46:52 +0100
Subject: [PATCH 18/60] TrackToVertexIPEstimator bug fix: use correct indices

---
 Core/include/Acts/Vertexing/TrackToVertexIPEstimator.ipp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Core/include/Acts/Vertexing/TrackToVertexIPEstimator.ipp b/Core/include/Acts/Vertexing/TrackToVertexIPEstimator.ipp
index f3766518b..6722ae6a2 100644
--- a/Core/include/Acts/Vertexing/TrackToVertexIPEstimator.ipp
+++ b/Core/include/Acts/Vertexing/TrackToVertexIPEstimator.ipp
@@ -21,7 +21,7 @@ Acts::TrackToVertexIPEstimator<
   // trajectory anymore
 
   const Vector3D& lp = vtx.position();
-
+  
   const std::shared_ptr<PerigeeSurface> perigeeSurface =
       Surface::makeShared<PerigeeSurface>(lp);
 
@@ -80,7 +80,7 @@ Acts::TrackToVertexIPEstimator<
     newIPandSigma->PVsigmaz0SinTheta =
         std::sqrt(std::sin(theta) * vtxZZCov * std::sin(theta));
     newIPandSigma->IPz0 = z0;
-    newIPandSigma->sigmaz0 = std::sqrt(vtxZZCov + perigeeCov(eZ, eZ));
+    newIPandSigma->sigmaz0 = std::sqrt(vtxZZCov + perigeeCov(ParID_t::eLOC_Z0, ParID_t::eLOC_Z0));
     newIPandSigma->PVsigmaz0 = std::sqrt(vtxZZCov);
   } else {
     ACTS_WARNING(
@@ -93,7 +93,7 @@ Acts::TrackToVertexIPEstimator<
     newIPandSigma->PVsigmaz0SinTheta = 0;
 
     newIPandSigma->IPz0 = z0;
-    newIPandSigma->sigmaz0 = std::sqrt(perigeeCov(eZ, eZ));
+    newIPandSigma->sigmaz0 = std::sqrt(perigeeCov(ParID_t::eLOC_Z0, ParID_t::eLOC_Z0));
     newIPandSigma->PVsigmaz0 = 0;
   }
 
-- 
GitLab


From f8a93f8c00f6d03ce14ee6416efef8daa849c85b Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Wed, 26 Feb 2020 17:07:18 +0100
Subject: [PATCH 19/60] use original track parameters in TrackLinearizer only
 if det()=0

---
 Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp b/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp
index 5363cbf71..afd5a1ec0 100644
--- a/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp
+++ b/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp
@@ -37,7 +37,7 @@ Acts::Result<Acts::LinearizedTrack> Acts::
   VectorHelpers::position(positionAtPCA) = endParams->position();
   BoundSymMatrix parCovarianceAtPCA = *(endParams->covariance());
 
-  if (endParams->covariance()->determinant() <= 0) {
+  if (endParams->covariance()->determinant() == 0) {
     // Use the original parameters
     paramsAtPCA = params->parameters();
     VectorHelpers::position(positionAtPCA) = params->position();
-- 
GitLab


From 94f5549f5028ffbaee45ca3497b4ce7fe8fa2d69 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Wed, 26 Feb 2020 17:10:52 +0100
Subject: [PATCH 20/60] make KalmanVertexTrackUpdater consistent with non
 available timing information

---
 .../Vertexing/KalmanVertexTrackUpdater.ipp    | 67 +++++++++++--------
 1 file changed, 40 insertions(+), 27 deletions(-)

diff --git a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
index 9955eb38a..f2829f40d 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
+++ b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
@@ -19,7 +19,7 @@ Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
     return VertexingError::EmptyInput;
   }
 
-  const SpacePointVector& vtxPos = vtx->fullPosition();
+  const auto& vtxPos = vtx->fullPosition().template head<3>();
 
   // Get the linearized track
   const LinearizedTrack& linTrack = track.linearizedState;
@@ -31,16 +31,16 @@ Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
   }
 
   // Retrieve linTrack information
-  const SpacePointToBoundMatrix& posJac = linTrack.positionJacobian;
-  const ActsMatrixD<BoundParsDim, 3>& momJac = linTrack.momentumJacobian;
-  const BoundVector& trkParams = linTrack.parametersAtPCA;
-  const BoundSymMatrix& trkParamWeight = linTrack.covarianceAtPCA.inverse();
+  const auto& posJac = linTrack.positionJacobian.block<5, 3>(0, 0);
+  const auto& momJac = linTrack.momentumJacobian.block<5, 3>(0, 0);
+  const auto& trkParams = linTrack.parametersAtPCA.head<5>();
+  const auto& trkParamWeight = (linTrack.covarianceAtPCA.block<5, 5>(0, 0)).inverse();
 
   // Calculate S matrix
   ActsSymMatrixD<3> sMat =
       (momJac.transpose() * (trkParamWeight * momJac)).inverse();
 
-  const BoundVector& residual = linTrack.constantTerm;
+  const auto& residual = linTrack.constantTerm.head<5>();;
 
   // Refit track momentum
   Vector3D newTrkMomentum = sMat * momJac.transpose() * trkParamWeight *
@@ -58,15 +58,14 @@ Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
   newTrkParams(ParID_t::eQOP) = newTrkMomentum(2);           // qOverP
 
   // Vertex covariance and weight matrices
-  const SpacePointSymMatrix& vtxCov = vtx->fullCovariance();
-  const SpacePointSymMatrix vtxWeight = vtxCov.inverse();
+  const auto& vtxCov = vtx->fullCovariance().template block<3, 3>(0, 0);
+  const auto vtxWeight = vtxCov.inverse();
 
   // New track covariance matrix
-  ActsMatrixD<SpacePointDim, 3> newTrkCov =
+  auto newTrkCov =
       -vtxCov * posJac.transpose() * trkParamWeight * momJac * sMat;
 
   // Now determine the smoothed chi2 of the track in the following
-  // get updated position, this removes track from vtx
   auto res = KalmanVertexUpdater::updatePosition<input_track_t>(
       vtx, linTrack, track.trackWeight, -1);
 
@@ -77,26 +76,38 @@ Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
   Vertex<input_track_t> reducedVtx = *res;
 
   // Corresponding weight matrix
-  const SpacePointSymMatrix reducedVtxWeight =
-      reducedVtx.fullCovariance().inverse();
+  const auto reducedVtxWeight =
+      (reducedVtx.fullCovariance().template block<3, 3>(0, 0)).inverse();
 
   // Difference in positions
-  SpacePointVector posDiff = vtx->fullPosition() - reducedVtx.fullPosition();
+  auto posDiff = (vtx->fullPosition() - reducedVtx.fullPosition()).template head<3>();
 
   // Get smoothed params
-  BoundVector smParams = trkParams - (residual + posJac * vtx->fullPosition() +
+  auto smParams = trkParams - (residual + posJac * vtx->fullPosition().template head<3>() +
                                       momJac * newTrkMomentum);
 
   // New chi2 to be set later
   double chi2 = posDiff.dot(reducedVtxWeight * posDiff) +
                 smParams.dot(trkParamWeight * smParams);
 
-  const BoundMatrix& fullPerTrackCov = detail::createFullTrackCovariance(
-      sMat, newTrkCov, vtxWeight, vtxCov, newTrkParams);
+
+  // Not yet 4d ready. This can be removed together will all head<> statements,
+  // once time is consistently introduced to vertexing
+  ActsMatrixD<SpacePointDim, 3> newFullTrkCov(ActsMatrixD<SpacePointDim, 3>::Zero());
+  newFullTrkCov.block<3,3>(0,0) = newTrkCov;
+
+  SpacePointSymMatrix vtxFullWeight(SpacePointSymMatrix::Zero());
+  vtxFullWeight.block<3,3>(0,0) = vtxWeight;
+
+  SpacePointSymMatrix vtxFullCov(SpacePointSymMatrix::Zero());
+  vtxFullCov.block<3,3>(0,0) = vtxCov;
+
+  const auto& fullPerTrackCov = detail::createFullTrackCovariance(
+      sMat, newFullTrkCov, vtxFullWeight, vtxFullCov, newTrkParams);
 
   // Create new refitted parameters
   std::shared_ptr<PerigeeSurface> perigeeSurface =
-      Surface::makeShared<PerigeeSurface>(VectorHelpers::position(vtxPos));
+      Surface::makeShared<PerigeeSurface>(VectorHelpers::position(vtx->fullPosition()));
 
   BoundParameters refittedPerigee = BoundParameters(
       gctx, std::move(fullPerTrackCov), newTrkParams, perigeeSurface);
@@ -117,18 +128,19 @@ Acts::KalmanVertexTrackUpdater::detail::createFullTrackCovariance(
     const BoundVector& newTrkParams) {
   // Now new momentum covariance
   ActsSymMatrixD<3> momCov =
-      sMat + newTrkCov.transpose() * (vtxWeight * newTrkCov);
+      sMat + (newTrkCov.block<3,3>(0,0)).transpose() * (vtxWeight.block<3,3>(0,0) * newTrkCov.block<3,3>(0,0));
 
-  // Full (x,y,z,phi, theta, q/p, t) covariance matrix
-  ActsSymMatrixD<7> fullTrkCov(ActsSymMatrixD<7>::Zero());
+  // Full (x,y,z,phi, theta, q/p) covariance matrix
+  // To be made 7d again after switching to (x,y,z,phi, theta, q/p, t)
+  ActsSymMatrixD<6> fullTrkCov(ActsSymMatrixD<6>::Zero());
 
-  fullTrkCov.block<4, 4>(0, 0) = vtxCov;
-  fullTrkCov.block<4, 3>(0, 4) = newTrkCov;
-  fullTrkCov.block<3, 4>(4, 0) = newTrkCov.transpose();
-  fullTrkCov.block<3, 3>(4, 4) = momCov;
+  fullTrkCov.block<3, 3>(0, 0) = vtxCov.block<3,3>(0,0);
+  fullTrkCov.block<3, 3>(0, 3) = newTrkCov.block<3,3>(0,0);
+  fullTrkCov.block<3, 3>(3, 0) = (newTrkCov.block<3,3>(0,0)).transpose();
+  fullTrkCov.block<3, 3>(3, 3) = momCov;
 
   // Combined track jacobian
-  ActsMatrixD<BoundParsDim, 7> trkJac(ActsMatrixD<BoundParsDim, 7>::Zero());
+  ActsMatrixD<5, 6> trkJac(ActsMatrixD<5, 6>::Zero());
 
   // First row
   trkJac(0, 0) = -std::sin(newTrkParams[2]);
@@ -140,10 +152,11 @@ Acts::KalmanVertexTrackUpdater::detail::createFullTrackCovariance(
   trkJac(1, 0) = -trkJac(0, 1) / tanTheta;
   trkJac(1, 1) = trkJac(0, 0) / tanTheta;
 
-  trkJac.block<5, 5>(1, 2) = ActsSymMatrixD<5>::Identity();
+  trkJac.block<4, 4>(1, 2) = ActsSymMatrixD<4>::Identity();
 
   // Full perigee track covariance
-  BoundMatrix fullPerTrackCov(trkJac * (fullTrkCov * trkJac.transpose()));
+  BoundMatrix fullPerTrackCov(BoundMatrix::Identity());
+  fullPerTrackCov.block<5,5>(0,0) = (trkJac * (fullTrkCov * trkJac.transpose()));
 
   return fullPerTrackCov;
 }
-- 
GitLab


From 1686eb9c61a3db0bf65546c43bc56bb17b14fbf6 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Wed, 26 Feb 2020 17:15:05 +0100
Subject: [PATCH 21/60] bug fix: use perp componenent for distance measure
 instead of norm in AdaptiveMultiVertexFitter

---
 .../Acts/Vertexing/AdaptiveMultiVertexFitter.ipp      | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
index 6f8b9172b..c36778e46 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
@@ -62,8 +62,10 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::fitImpl(
       // in previous iteration afterwards
       currentVtxInfo.oldPosition = currentVtx->fullPosition();
 
+      auto dist = currentVtxInfo.oldPosition - currentVtxInfo.linPoint;
+      double perpDist = std::sqrt(dist[0] * dist[0] + dist[1] * dist[1]);
       // Determine if relinearization is needed
-      if ((currentVtxInfo.oldPosition - currentVtxInfo.linPoint).norm() >
+      if (perpDist >
           m_cfg.maxDistToLinPoint) {
         // Relinearization needed, distance too big
         currentVtxInfo.relinearize = true;
@@ -89,6 +91,7 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::fitImpl(
       auto weight =
           1. / m_cfg.annealingTool.getWeight(state.annealingState, 1.);
 
+
       auto covAnn = currentVtx->fullCovariance() * weight;
       currentVtx->setCovariance(covAnn.template block<3, 3>(0, 0));
 
@@ -101,7 +104,6 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::fitImpl(
     // all vertices, run again over all vertices to set track weights
     // and update the vertex
     setWeightsAndUpdate(state, linearizer);
-
     if (!state.annealingState.equilibriumReached) {
       m_cfg.annealingTool.anneal(state.annealingState);
     }
@@ -270,7 +272,6 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::
     if (!compRes.ok()) {
       return compRes.error();
     }
-
     double comp = *compRes;
     newTrkPtr->vertexCompatibility = *compRes;
   }
@@ -292,7 +293,6 @@ Acts::Result<void> Acts::AdaptiveMultiVertexFitter<
     newTracks.reserve(vtx->tracks().size());
 
     auto oldTracks = vtx->tracks();
-
     for (const auto& trkAtVtx : oldTracks) {
       // Create copy of current trackAtVertex in order
       // to modify it below
@@ -304,8 +304,9 @@ Acts::Result<void> Acts::AdaptiveMultiVertexFitter<
         return collectRes.error();
       }
       // Set trackWeight for current track
-      newTrkPtr->trackWeight = m_cfg.annealingTool.getWeight(
+      double currentTrkWeight = m_cfg.annealingTool.getWeight(
           state.annealingState, trkAtVtx.vertexCompatibility, *collectRes);
+      newTrkPtr->trackWeight = currentTrkWeight;
 
       if (newTrkPtr->trackWeight > m_cfg.minWeight) {
         // Check if linearization state exists or need to be relinearized
-- 
GitLab


From 07f090c1f04d995322c52c0cb02cfe19e3608cb8 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Wed, 26 Feb 2020 17:16:21 +0100
Subject: [PATCH 22/60] update some docs and default values in
 AdaptiveMultiVertexFinder

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   | 22 ++++++++++---------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index a09533858..1acbc7a77 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -82,7 +82,7 @@ class AdaptiveMultiVertexFinder {
     // reliable, but the fit would be still able to converge
     // towards the right vertex. If you cut too soft, you
     // consider a lot of tracks which just slow down the fit.
-    double tracksMaxZinterval = 4. * Acts::UnitConstants::mm;
+    double tracksMaxZinterval = 3. * Acts::UnitConstants::mm;
 
     // Maximum allowed significance of track position to vertex seed
     // to consider track as compatible track for vertex fit
@@ -98,7 +98,7 @@ class AdaptiveMultiVertexFinder {
     // added to the new vertex candidate after seeding. If switched to
     // false, only the seedTracks, i.e. all tracks that are considered
     // as outliers of previously fitted vertices, are used.
-    bool realMultiVertex = false;
+    bool realMultiVertex = true;
 
     // Decides if you want to use the ```vertexCompatibility``` of the
     //  track (set to true) or the ```chi2Track``` (set to false) as an
@@ -118,7 +118,7 @@ class AdaptiveMultiVertexFinder {
     double minWeight = 0.0001;
 
     // Maximal number of iterations in the finding procedure
-    int maxIterations = 1000;
+    int maxIterations = 100;
 
     // Include also single track vertices
     bool addSingleTrackVertices = false;
@@ -205,12 +205,14 @@ class AdaptiveMultiVertexFinder {
   /// vertex if desired
   ///
   /// @param trackVector All tracks to be used for seeding
+  /// @param currentConstraint Vertex constraint
   /// @param vFinderOptions Vertex finder options
   ///
   /// @return The seed vertex
   Result<Vertex<InputTrack_t>> doSeeding(
       const std::vector<InputTrack_t>& trackVector,
-      VertexFinderOptions<InputTrack_t>& vFinderOptions) const;
+      Vertex<InputTrack_t>& currentConstraint,
+      const VertexFinderOptions<InputTrack_t>& vFinderOptions) const;
 
   /// @brief Estimates delta Z between a track and a vertex position
   ///
@@ -244,14 +246,14 @@ class AdaptiveMultiVertexFinder {
   /// seedTracks)
   /// @param seedTracks The seed tracks
   /// @param[out] vtx The vertex candidate
-  /// @param vFinderOptions Vertex finder options
+  /// @param currentConstraint Vertex constraint
   /// @param[out] fitterState The vertex fitter state
   ///
   /// return True if recovery was successful, false otherwise
   Result<bool> canRecoverFromNoCompatibleTracks(
       const std::vector<InputTrack_t>& myTracks,
       const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>* vtx,
-      const VertexFinderOptions<InputTrack_t>& vFinderOptions,
+      const Vertex<InputTrack_t>& currentConstraint,
       FitterState_t& fitterState) const;
 
   /// @brief Method that tries to prepare the vertex for the fit
@@ -260,14 +262,14 @@ class AdaptiveMultiVertexFinder {
   /// seedTracks)
   /// @param seedTracks The seed tracks
   /// @param[out] vtx The vertex candidate
-  /// @param vFinderOptions Vertex finder options
+  /// @param currentConstraint Vertex constraint
   /// @param[out] fitterState The vertex fitter state
   ///
   /// @return True if preparation was successful, false otherwise
   Result<bool> canPrepareVertexForFit(
       const std::vector<InputTrack_t>& myTracks,
       const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>* vtx,
-      const VertexFinderOptions<InputTrack_t>& vFinderOptions,
+      const Vertex<InputTrack_t>& currentConstraint,
       FitterState_t& fitterState) const;
 
   /// @brief Method that checks if vertex is a good vertex and if
@@ -311,7 +313,7 @@ class AdaptiveMultiVertexFinder {
   ///
   /// @return Keep new vertex
   bool keepNewVertex(const Vertex<InputTrack_t>* vtx,
-                     const std::vector<Vertex<InputTrack_t>>& allVertices,
+                     const std::vector<Vertex<InputTrack_t>*>& allVertices,
                      bool isGoodVertex) const;
 
   /// @brief Method that evaluates if the new vertex candidate is
@@ -323,7 +325,7 @@ class AdaptiveMultiVertexFinder {
   /// @return Vertex is merged
   bool isMergedVertex(
       const Vertex<InputTrack_t>* vtx,
-      const std::vector<Vertex<InputTrack_t>>& allVertices) const;
+      const std::vector<Vertex<InputTrack_t>*>& allVertices) const;
 };
 
 }  // namespace Acts
-- 
GitLab


From 8203b11103830339b9c3b8516e29bfd344f7b5e6 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Wed, 26 Feb 2020 17:20:42 +0100
Subject: [PATCH 23/60] bug fixes: hold vector of unique_ptr of vertices to
 ensure correct memory addresses, create separate vertex constraint object
 from finder options

---
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 122 ++++++++++--------
 1 file changed, 68 insertions(+), 54 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index 2d098b011..cf24f4f87 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -18,10 +18,6 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     return VertexingError::EmptyInput;
   }
 
-  // Create copy of finder options, will be modified after seeding
-  // to set the correct vertex constraint
-  VertexFinderOptions<InputTrack_t> finderOptions = vFinderOptions;
-
   // Original tracks
   const std::vector<InputTrack_t>& origTracks = allTracks;
   // Tracks for seeding
@@ -37,17 +33,20 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
 
   // Construct the vertex fitter options from vertex finder options
   VertexFitterOptions<InputTrack_t> vFitterOptions(
-      finderOptions.geoContext, finderOptions.magFieldContext,
-      finderOptions.vertexConstraint);
+      vFinderOptions.geoContext, vFinderOptions.magFieldContext,
+      vFinderOptions.vertexConstraint);
 
   FitterState_t fitterState;
 
-  std::vector<Vertex<InputTrack_t>> allVertices;
+  std::vector<std::unique_ptr<Vertex<InputTrack_t>>> allVertices;
+
+  std::vector<Vertex<InputTrack_t>*> allVerticesPtr;
 
   int iteration = 0;
   while (((m_cfg.addSingleTrackVertices && seedTracks.size() > 0) ||
           ((!m_cfg.addSingleTrackVertices) && seedTracks.size() > 1)) &&
          iteration < m_cfg.maxIterations) {
+  	
     // Tracks that are used for searching compatible tracks
     // near a vertex candidate
     // TODO: This involves a lot of copying. Change the way of accessing tracks
@@ -57,42 +56,42 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     } else {
       myTracks = seedTracks;
     }
-
+    Vertex<InputTrack_t> currentConstraint = vFinderOptions.vertexConstraint;
     // Retrieve seed vertex from all remaining seedTracks
-    auto seedResult = doSeeding(seedTracks, finderOptions);
-    if (!seedResult.ok()) {
+    auto seedResult = doSeeding(seedTracks, currentConstraint, vFinderOptions);
+    if (!seedResult.ok()) {    	
       return seedResult.error();
-    }
+    }    
+    allVertices.push_back(std::make_unique<Vertex<InputTrack_t>>(*seedResult));
 
-    allVertices.push_back(*seedResult);
+    Vertex<InputTrack_t>* vtxCandidate = (allVertices.back()).get();
+    allVerticesPtr.push_back(vtxCandidate);
 
-    Vertex<InputTrack_t>* vtxCandidate = &(allVertices.back());
     ACTS_DEBUG("Position of current vertex candidate after seeding: "
                << vtxCandidate->fullPosition());
-
-    if (vtxCandidate->position().z() == 0.) {
+    if (vtxCandidate->position().z() == 0.) {    	
       ACTS_DEBUG(
           "No seed found anymore. Break and stop primary vertex finding.");
       break;
     }
-
     auto prepResult = canPrepareVertexForFit(myTracks, seedTracks, vtxCandidate,
-                                             finderOptions, fitterState);
-    if (!prepResult.ok()) {
+                                             currentConstraint, fitterState);
+
+    if (!prepResult.ok()) {    	
       return prepResult.error();
     }
-    if (!(*prepResult)) {
+    if (!(*prepResult)) {    	
       ACTS_DEBUG("Could not prepare for fit anymore. Break.");
       break;
     }
     // Update fitter state with all vertices
-    fitterState.updateVertexList(allVertices);
+    fitterState.updateVertexList(allVerticesPtr);    
     // Perform the fit
     auto fitResult = m_cfg.vertexFitter.addVtxToFit(
         fitterState, *vtxCandidate, m_cfg.linearizer, vFitterOptions);
-    if (!fitResult.ok()) {
+    if (!fitResult.ok()) {    	
       return fitResult.error();
-    }
+    }    
     ACTS_DEBUG("New position of current vertex candidate after fit: "
                << vtxCandidate->fullPosition());
 
@@ -101,8 +100,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     int nCompatibleTracks = 0;
     checkVertexAndCompatibleTracks(vtxCandidate, seedTracks, nCompatibleTracks,
                                    isGoodVertex);
-    ACTS_DEBUG("Vertex is good vertex: " << isGoodVertex);
 
+    ACTS_DEBUG("Vertex is good vertex: " << isGoodVertex);    
     if (nCompatibleTracks > 0) {
       removeCompatibleTracksFromSeedTracks(vtxCandidate, seedTracks);
     } else {
@@ -114,40 +113,47 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
             "Could not remove any further track from seed tracks. Break.");
         break;
       }
-    }
-
-    bool keepVertex = keepNewVertex(vtxCandidate, allVertices, isGoodVertex);
+    }    
+    bool keepVertex = keepNewVertex(vtxCandidate, allVerticesPtr, isGoodVertex);
     ACTS_DEBUG("New vertex will be saved: " << keepVertex);
 
     // Delete vertex from allVertices list again if it's not kept
     if (not keepVertex) {
       allVertices.pop_back();
+      allVerticesPtr.pop_back();
       // Update fitter state with removed vertex candidate
-      fitterState.updateVertexList(allVertices);
-      // Prepare for final fit
-      std::vector<Vertex<InputTrack_t>*> vtxPtrVec;
-      for (auto& vtx : allVertices) {
-        vtxPtrVec.push_back(&vtx);
-      }
+      fitterState.updateVertexList(allVerticesPtr);
+    
       // Do the fit with removed vertex
-      auto fitResult = m_cfg.vertexFitter.fit(fitterState, vtxPtrVec,
+      auto fitResult = m_cfg.vertexFitter.fit(fitterState, allVerticesPtr,
                                               m_cfg.linearizer, vFitterOptions);
-      if (!fitResult.ok()) {
+      if (!fitResult.ok()) {      	
         return fitResult.error();
-      }
-    }
+      }      
+    }  
+    iteration++;  
+  } // end while loop
+
+  std::vector<Vertex<InputTrack_t>> outputVec;
+
+  for(auto vtx : allVerticesPtr){
+    outputVec.push_back(*vtx);
   }
 
-  return allVertices;
+  return outputVec;
 }
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::doSeeding(
     const std::vector<InputTrack_t>& trackVector,
-    VertexFinderOptions<InputTrack_t>& vFinderOptions) const
+    Vertex<InputTrack_t>& currentConstraint,
+    const VertexFinderOptions<InputTrack_t>& vFinderOptions) const
     -> Result<Vertex<InputTrack_t>> {
+
+  VertexFinderOptions<InputTrack_t> seedOptions = vFinderOptions;
+  seedOptions.vertexConstraint = currentConstraint;
   // Run seed finder
-  auto seedResult = m_cfg.seedFinder.find(trackVector, vFinderOptions);
+  auto seedResult = m_cfg.seedFinder.find(trackVector, seedOptions);
 
   if (!seedResult.ok()) {
     return seedResult.error();
@@ -156,17 +162,20 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::doSeeding(
   Vertex<InputTrack_t> seedVertex = (*seedResult).back();
   // Update constraints according to seed vertex
   if (m_cfg.useBeamSpotConstraint) {
+  	if (currentConstraint.fullCovariance() == SpacePointSymMatrix::Zero()){
+  		ACTS_WARNING("No constraint provided, but useBeamSpotConstraint set to true.");
+  	}
     if (m_cfg.useSeedConstraint) {
-      vFinderOptions.vertexConstraint.setFullPosition(
+      currentConstraint.setFullPosition(
           seedVertex.fullPosition());
-      vFinderOptions.vertexConstraint.setFullCovariance(
+      currentConstraint.setFullCovariance(
           seedVertex.fullCovariance());
     }
   } else {
-    vFinderOptions.vertexConstraint.setFullPosition(seedVertex.fullPosition());
-    vFinderOptions.vertexConstraint.setFullCovariance(
+    currentConstraint.setFullPosition(seedVertex.fullPosition());
+    currentConstraint.setFullCovariance(
         SpacePointSymMatrix::Identity() * m_cfg.looseConstrValue);
-    vFinderOptions.vertexConstraint.setFitQuality(
+    currentConstraint.setFitQuality(
         m_cfg.defaultConstrFitQuality);
   }
 
@@ -250,7 +259,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     canRecoverFromNoCompatibleTracks(
         const std::vector<InputTrack_t>& myTracks,
         const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>* vtx,
-        const VertexFinderOptions<InputTrack_t>& vFinderOptions,
+        const Vertex<InputTrack_t>& currentConstraint,
         FitterState_t& fitterState) const -> Result<bool> {
   // Recover from cases where no compatible tracks to vertex
   // candidate were found
@@ -267,6 +276,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
       if (zDistance < smallestDeltaZ) {
         smallestDeltaZ = zDistance;
         nearTrackFound = true;
+
         newZ = m_extractParameters(trk).position()[eZ];
       }
     }
@@ -277,7 +287,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 
       // Update vertex info for current vertex
       fitterState.vtxInfoMap[vtx] = VertexInfo<InputTrack_t>(
-          vFinderOptions.vertexConstraint, vtx->fullPosition());
+          currentConstraint, vtx->fullPosition());
 
       // Try to add compatible track with adapted vertex position
       auto res = addCompatibleTracksToVertex(myTracks, vtx);
@@ -306,11 +316,11 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     canPrepareVertexForFit(
         const std::vector<InputTrack_t>& myTracks,
         const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>* vtx,
-        const VertexFinderOptions<InputTrack_t>& vFinderOptions,
+        const Vertex<InputTrack_t>& currentConstraint,
         FitterState_t& fitterState) const -> Result<bool> {
   // Add vertex info to fitter state
   fitterState.vtxInfoMap[vtx] = VertexInfo<InputTrack_t>(
-      vFinderOptions.vertexConstraint, vtx->fullPosition());
+      currentConstraint, vtx->fullPosition());
 
   // Add all compatible tracks to vertex
   auto resComp = addCompatibleTracksToVertex(myTracks, vtx);
@@ -319,7 +329,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
   }
   // Try to recover from cases where adding compatible track was not possible
   auto resRec = canRecoverFromNoCompatibleTracks(myTracks, seedTracks, vtx,
-                                                 vFinderOptions, fitterState);
+                                                 currentConstraint, fitterState);
   if (!resRec.ok()) {
     return Result<bool>::failure(resRec.error());
   }
@@ -440,7 +450,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::keepNewVertex(
     const Vertex<InputTrack_t>* vtx,
-    const std::vector<Vertex<InputTrack_t>>& allVertices,
+    const std::vector<Vertex<InputTrack_t>*>& allVertices,
     bool isGoodVertex) const -> bool {
   if (not isGoodVertex) {
     return false;
@@ -471,14 +481,18 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::keepNewVertex(
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::isMergedVertex(
     const Vertex<InputTrack_t>* vtx,
-    const std::vector<Vertex<InputTrack_t>>& allVertices) const -> bool {
+    const std::vector<Vertex<InputTrack_t>*>& allVertices) const -> bool {
   const SpacePointVector& candidatePos = vtx->fullPosition();
   const SpacePointSymMatrix& candidateCov = vtx->fullCovariance();
   const double candidateZPos = candidatePos[eZ];
   const double candidateZCov = candidateCov(eZ, eZ);
-  for (const auto& otherVtx : allVertices) {
-    const SpacePointVector& otherPos = otherVtx.fullPosition();
-    const SpacePointSymMatrix& otherCov = otherVtx.fullCovariance();
+
+  for (const auto otherVtx : allVertices) {
+    if(vtx == otherVtx){
+      continue;
+    }
+    const SpacePointVector& otherPos = otherVtx->fullPosition();
+    const SpacePointSymMatrix& otherCov = otherVtx->fullCovariance();
     const double otherZPos = otherPos[eZ];
     const double otherZCov = otherCov(eZ, eZ);
 
-- 
GitLab


From a3808697508759eba9d9ec01c58e51ed94aee6ee Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Wed, 26 Feb 2020 17:22:06 +0100
Subject: [PATCH 24/60] change default minWeight in AdaptiveMultiVertexFitter

---
 Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
index 84c4582b1..dc35201cb 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
@@ -91,7 +91,7 @@ class AdaptiveMultiVertexFitter {
     void updateVertexList(std::vector<Vertex<input_track_t>*>& vtxList) {
       trkInfoMap.clear();
       for (auto& vtx : vtxList) {
-        // Add vertex link to each track
+        // Add vertex link to each track  
         for (auto& trkAtVtx : vtx->tracks()) {
           trkInfoMap[trkAtVtx.id].linksToVertices.push_back(vtx);
         }
@@ -127,7 +127,7 @@ class AdaptiveMultiVertexFitter {
     double maxDistToLinPoint{0.5};
 
     // Minimum track weight needed for track to be considered
-    double minWeight{0.001};
+    double minWeight{0.0001};
 
     // Max relative shift of vertex during one iteration
     double maxRelativeShift{0.01};
-- 
GitLab


From 7379814ae5234dd35b6243be56faab4b83075373 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Wed, 26 Feb 2020 17:23:07 +0100
Subject: [PATCH 25/60] use athena event track parameters in acts unittest

---
 .../AdaptiveMultiVertexFinderTests.cpp        | 2064 ++++++++++++++++-
 1 file changed, 2048 insertions(+), 16 deletions(-)

diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
index 983b7a375..218d8a729 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
@@ -32,13 +32,15 @@ using Covariance = BoundSymMatrix;
 using Propagator = Propagator<EigenStepper<ConstantBField>>;
 using Linearizer = HelicalTrackLinearizer<Propagator>;
 
+std::vector<BoundParameters> getAthenaTracks();
+
 // Create a test context
 GeometryContext tgContext = GeometryContext();
 MagneticFieldContext mfContext = MagneticFieldContext();
 
 BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
   // Set debug mode
-  bool debugMode = false;
+  bool debugMode = true;
   // Set up constant B-Field
   ConstantBField bField(Vector3D(0., 0., 2_T));
 
@@ -49,6 +51,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
   // Set up propagator with void navigator
   auto propagator = std::make_shared<Propagator>(stepper);
   PropagatorOptions<> pOptions(tgContext, mfContext);
+  pOptions.direction=backward;
 
   VertexFitterOptions<BoundParameters> fitterOptions(tgContext, mfContext);
 
@@ -58,7 +61,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
   IPEstimator::Config ip3dEstCfg(bField, propagator, pOptions, false);
   IPEstimator ip3dEst(ip3dEstCfg);
 
-  std::vector<double> temperatures(1, 3.);
+  std::vector<double> temperatures{8.0, 4.0, 2.0, 1.4142136, 1.2247449, 1.0};
   AnnealingUtility::Config annealingConfig(temperatures);
   AnnealingUtility annealingUtility(annealingConfig);
 
@@ -73,7 +76,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
   Linearizer linearizer(ltConfig);
 
   // Test smoothing
-  // fitterCfg.doSmoothing = true;
+  fitterCfg.doSmoothing = false;
 
   Fitter fitter(fitterCfg);
 
@@ -93,29 +96,2058 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
   Finder::Config finderConfig(std::move(fitter), std::move(seedFinder),
                               std::move(ipEst), std::move(linearizer));
 
+  // TODO: test this as well!
+  //finderConfig.useBeamSpotConstraint = false;
+
   Finder finder(finderConfig);
 
-  std::vector<BoundParameters> tracks;
+  std::vector<BoundParameters> tracks = getAthenaTracks();
+
+  if(debugMode){
+  	std::cout << "Number of tracks in event: " << tracks.size() << std::endl;
+  	int maxCout = 10;
+  	int count = 0;
+  	for(const auto& trk : tracks){
+  		std::cout << count << ". track: " << std::endl;
+  		std::cout << "params: " << trk << std::endl;
+  		count++;
+  		if(count == maxCout){
+  			break;
+  		}
+  	}
+  }
 
   VertexFinderOptions<BoundParameters> finderOptions(tgContext, mfContext);
 
-  std::cout << &finderOptions << std::endl;
+  Vector3D constraintPos{-0.5_mm, -0.5_mm, 0_mm};
+  ActsSymMatrixD<3> constraintCov;
+  constraintCov <<  0.0001,      0,      0,
+					0,  		0.0001,   0,
+					0,      	0,   1764;
+
+  Vertex<BoundParameters> constraintVtx;
+  constraintVtx.setPosition(constraintPos);
+  constraintVtx.setCovariance(constraintCov);
+
+  finderOptions.vertexConstraint = constraintVtx;
+
+  auto findResult = finder.find(tracks, finderOptions);
+
+  if (!findResult.ok()) {
+      std::cout << findResult.error().message() << std::endl;
+    }
+
 
-  Transform3D transform;
-  ActsSymMatrixD<3> rotMat;
-  rotMat << -0.780869, 0.624695, 3.79565e-17, 0.455842, 0.569803, 0.683763,
-      0.427144, 0.53393, -0.729704;
-  transform.rotate(rotMat);
-  transform.translation() = Vector3D(1, 2, 3);
+  BOOST_CHECK(findResult.ok());
 
-  if (debugMode) {
-    std::cout << "Debug mode." << std::endl;
+  std::vector<Vertex<BoundParameters>> allVertices = *findResult;
+
+  if(debugMode){
+  	std::cout << "Number of vertices reconstructed: " << allVertices.size() << std::endl;
+
+  	int count = 0;
+  	for(const auto& vtx : allVertices){
+  		count++;
+  		std::cout << count << ". Vertex at position: " 
+  		<< vtx.position()[0] << ", "<< vtx.position()[1] << ", "<< vtx.position()[2] << std::endl;
+  	}
   }
-  std::cout << "translation: " << transform.translation() << std::endl;
-  std::cout << "rot: " << transform.rotation() << std::endl;
 
-  auto bla = finder.find(tracks, finderOptions);
 }
 
+// Return all tracks of one single event as reconstructed in athena.
+std::vector<BoundParameters> getAthenaTracks(){
+
+std::vector<BoundParameters> tracks;
+
+ // track 0 :
+ BoundVector params0;
+ params0 << -0.0189610905945301056, 19.2891330718994141, -1.72937667369842529, 0.245648413896560669, 0.000139094627229496837*1./(1_MeV), 0;
+ Covariance covMat0;
+ covMat0 << 0.0234750192612409592, -0.00781442524684276309, -0.000530674182045025289, -8.29588870144685228e-06, -9.34183350654419714e-08*1./(1_MeV), 0, -0.00781442524684276309, 0.406355828046798706, 0.000142553526286719813, 0.000532610276843647709, 2.47911983155666744e-08*1./(1_MeV), 0, -0.000530674182045025289, 0.000142553526286719813, 1.25120022858027369e-05, 1.45461672177318258e-07, 3.16496658346130268e-09*1./(1_MeV), 0, -8.29588870144685228e-06, 0.000532610276843647709, 1.45461672177318258e-07, 7.28171983155334601e-07, 2.62386697279164045e-11*1./(1_MeV), 0, -9.34183350654419714e-08*1./(1_MeV), 2.47911983155666744e-08*1./(1_MeV), 3.16496658346130268e-09*1./(1_MeV), 2.62386697279164045e-11*1./(1_MeV), 2.09531125089368331e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform0;
+ ActsSymMatrixD<3> rotMat0;
+ rotMat0 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform0.rotate(rotMat0);
+ transform0.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans0 = std::make_shared<const Transform3D>(transform0);
+ std::shared_ptr<PerigeeSurface> perigeeSurface0 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams0 = BoundParameters(tgContext, std::move(covMat0), params0, perigeeSurface0);
+ tracks.push_back(boundParams0);
+
+
+ // track 1 :
+ BoundVector params1;
+ params1 << 0.237322136759757996, 18.9474124908447266, 2.77435874938964844, 0.221098631620407104, 0.000243303977185860276*1./(1_MeV), 0;
+ Covariance covMat1;
+ covMat1 << 0.0224881023168563843, -0.00123628927370857643, -0.000682571853275380021, -5.08470990346168592e-07, -1.65987991328505037e-07*1./(1_MeV), 0, -0.00123628927370857643, 0.486606210470199585, -1.26428790915631958e-05, 0.000691189647290967285, 8.49211598605589898e-10*1./(1_MeV), 0, -0.000682571853275380021, -1.26428790915631958e-05, 2.10596499528037384e-05, -4.86598776586506401e-08, 8.07036236689827024e-09*1./(1_MeV), 0, -5.08470990346168592e-07, 0.000691189647290967285, -4.86598776586506401e-08, 9.96780613604641985e-07, 2.84880592793454068e-12*1./(1_MeV), 0, -1.65987991328505037e-07*1./(1_MeV), 8.49211598605589898e-10*1./(1_MeV), 8.07036236689827024e-09*1./(1_MeV), 2.84880592793454068e-12*1./(1_MeV), 6.98227170525811403e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform1;
+ ActsSymMatrixD<3> rotMat1;
+ rotMat1 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform1.rotate(rotMat1);
+ transform1.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans1 = std::make_shared<const Transform3D>(transform1);
+ std::shared_ptr<PerigeeSurface> perigeeSurface1 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams1 = BoundParameters(tgContext, std::move(covMat1), params1, perigeeSurface1);
+ tracks.push_back(boundParams1);
+
+
+ // track 2 :
+ BoundVector params2;
+ params2 << -0.274762749671936035, 19.3189582824707031, 2.51834297180175781, 0.247050970792770386, -0.000262395391473546624*1./(1_MeV), 0;
+ Covariance covMat2;
+ covMat2 << 0.0190738625824451447, -0.0017057542844459892, -0.000571975485803314851, -2.82570644125376289e-06, -1.61839967616137892e-07*1./(1_MeV), 0, -0.0017057542844459892, 0.321801245212554932, 6.65458853740041401e-05, 0.000567742814929668329, 5.31432764738237606e-09*1./(1_MeV), 0, -0.000571975485803314851, 6.65458853740041401e-05, 1.75108507391996682e-05, 1.16541064423600983e-07, 8.10714233373920505e-09*1./(1_MeV), 0, -2.82570644125376289e-06, 0.000567742814929668329, 1.16541064423600983e-07, 1.01647879091615323e-06, 1.7840055165615784e-12*1./(1_MeV), 0, -1.61839967616137892e-07*1./(1_MeV), 5.31432764738237606e-09*1./(1_MeV), 8.10714233373920505e-09*1./(1_MeV), 1.7840055165615784e-12*1./(1_MeV), 7.92840237906489165e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform2;
+ ActsSymMatrixD<3> rotMat2;
+ rotMat2 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform2.rotate(rotMat2);
+ transform2.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans2 = std::make_shared<const Transform3D>(transform2);
+ std::shared_ptr<PerigeeSurface> perigeeSurface2 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams2 = BoundParameters(tgContext, std::move(covMat2), params2, perigeeSurface2);
+ tracks.push_back(boundParams2);
+
+
+ // track 3 :
+ BoundVector params3;
+ params3 << 0.0235438384115695953, 19.7655830383300781, -0.159107863903045654, 2.30990958213806152, -0.000119360782264266163*1./(1_MeV), 0;
+ Covariance covMat3;
+ covMat3 << 0.000361772050382569432, 2.72739909974600519e-05, -8.21723450836043464e-06, 1.34126350783550678e-07, -5.88422825741122636e-09*1./(1_MeV), 0, 2.72739909974600519e-05, 0.00511974841356277466, -6.21331210701952311e-07, 3.10034413370417763e-05, -6.86043367956819384e-09*1./(1_MeV), 0, -8.21723450836043464e-06, -6.21331210701952311e-07, 2.07281985353802156e-07, -3.88590354998360268e-09, 2.03791573108340031e-10*1./(1_MeV), 0, 1.34126350783550678e-07, 3.10034413370417763e-05, -3.88590354998360268e-09, 3.01585174611318507e-07, -5.64498122454143072e-11*1./(1_MeV), 0, -5.88422825741122636e-09*1./(1_MeV), -6.86043367956819384e-09*1./(1_MeV), 2.03791573108340031e-10*1./(1_MeV), -5.64498122454143072e-11*1./(1_MeV), 4.42898885968934231e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform3;
+ ActsSymMatrixD<3> rotMat3;
+ rotMat3 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform3.rotate(rotMat3);
+ transform3.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans3 = std::make_shared<const Transform3D>(transform3);
+ std::shared_ptr<PerigeeSurface> perigeeSurface3 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams3 = BoundParameters(tgContext, std::move(covMat3), params3, perigeeSurface3);
+ tracks.push_back(boundParams3);
+
+
+ // track 4 :
+ BoundVector params4;
+ params4 << -0.00997916609048843384, 19.6140289306640625, -1.86583328247070312, 1.16398906707763672, 4.13092784583568573e-05*1./(1_MeV), 0;
+ Covariance covMat4;
+ covMat4 << 0.000111233675852417946, 6.24019899783590426e-06, -1.51042179240653054e-06, -1.66343778016681362e-09, -1.90252013322187688e-09*1./(1_MeV), 0, 6.24019899783590426e-06, 0.00304781622253358364, -1.53697680009238848e-08, 2.11791743062638145e-05, 9.71456470695990042e-10*1./(1_MeV), 0, -1.51042179240653054e-06, -1.53697680009238848e-08, 2.65749235950352158e-08, -5.72349441699598989e-10, 3.41166238038356917e-11*1./(1_MeV), 0, -1.66343778016681362e-09, 2.11791743062638145e-05, -5.72349441699598989e-10, 2.91562628262909129e-07, 1.44429681183542297e-11*1./(1_MeV), 0, -1.90252013322187688e-09*1./(1_MeV), 9.71456470695990042e-10*1./(1_MeV), 3.41166238038356917e-11*1./(1_MeV), 1.44429681183542297e-11*1./(1_MeV), 4.11648986382504023e-13*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform4;
+ ActsSymMatrixD<3> rotMat4;
+ rotMat4 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform4.rotate(rotMat4);
+ transform4.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans4 = std::make_shared<const Transform3D>(transform4);
+ std::shared_ptr<PerigeeSurface> perigeeSurface4 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams4 = BoundParameters(tgContext, std::move(covMat4), params4, perigeeSurface4);
+ tracks.push_back(boundParams4);
+
+
+ // track 5 :
+ BoundVector params5;
+ params5 << 0.0375059135258197784, 19.6366806030273438, 2.80398750305175781, 1.33918941020965576, -0.00119000650011003017*1./(1_MeV), 0;
+ Covariance covMat5;
+ covMat5 << 0.00557367224246263504, -3.50923298762731976e-05, -0.00016505602825201958, -5.83055075084957149e-07, -8.15374160823663551e-08*1./(1_MeV), 0, -3.50923298762731976e-05, 0.0162126719951629639, 1.9925351112667154e-06, 0.000363090538840017685, 1.10231246314290943e-09*1./(1_MeV), 0, -0.00016505602825201958, 1.9925351112667154e-06, 4.97896826345822774e-06, 4.42649583494026453e-08, 3.8207024978280266e-09*1./(1_MeV), 0, -5.83055075084957149e-07, 0.000363090538840017685, 4.42649583494026453e-08, 9.3684120656689629e-06, 4.81602467249185851e-11*1./(1_MeV), 0, -8.15374160823663551e-08*1./(1_MeV), 1.10231246314290943e-09*1./(1_MeV), 3.8207024978280266e-09*1./(1_MeV), 4.81602467249185851e-11*1./(1_MeV), 1.40874742426966293e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform5;
+ ActsSymMatrixD<3> rotMat5;
+ rotMat5 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform5.rotate(rotMat5);
+ transform5.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans5 = std::make_shared<const Transform3D>(transform5);
+ std::shared_ptr<PerigeeSurface> perigeeSurface5 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams5 = BoundParameters(tgContext, std::move(covMat5), params5, perigeeSurface5);
+ tracks.push_back(boundParams5);
+
+
+ // track 6 :
+ BoundVector params6;
+ params6 << 0.00140287447720766068, 19.7186660766601562, -2.14539408683776855, 1.24577629566192627, 0.000378551892936229706*1./(1_MeV), 0;
+ Covariance covMat6;
+ covMat6 << 0.00101993023417890072, -2.6994413372851214e-05, -2.65953182649328157e-05, 5.98774142459201546e-08, -1.51924922955507223e-08*1./(1_MeV), 0, -2.6994413372851214e-05, 0.00769689213484525681, 6.13944837413955775e-07, 9.60181177584976564e-05, 1.16782762059655835e-09*1./(1_MeV), 0, -2.65953182649328157e-05, 6.13944837413955775e-07, 7.35107732907636091e-07, -4.80302055565397552e-09, 6.05462078703657079e-10*1./(1_MeV), 0, 5.98774142459201546e-08, 9.60181177584976564e-05, -4.80302055565397552e-09, 1.77096819697908359e-06, -3.67492839080036729e-12*1./(1_MeV), 0, -1.51924922955507223e-08*1./(1_MeV), 1.16782762059655835e-09*1./(1_MeV), 6.05462078703657079e-10*1./(1_MeV), -3.67492839080036729e-12*1./(1_MeV), 1.91318193926148794e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform6;
+ ActsSymMatrixD<3> rotMat6;
+ rotMat6 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform6.rotate(rotMat6);
+ transform6.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans6 = std::make_shared<const Transform3D>(transform6);
+ std::shared_ptr<PerigeeSurface> perigeeSurface6 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams6 = BoundParameters(tgContext, std::move(covMat6), params6, perigeeSurface6);
+ tracks.push_back(boundParams6);
+
+
+ // track 7 :
+ BoundVector params7;
+ params7 << -0.00329869543202221394, 19.6041259765625, -1.90649104118347168, 1.12304854393005371, 0.00014407877461053431*1./(1_MeV), 0;
+ Covariance covMat7;
+ covMat7 << 0.00036740759969688952, 3.01680354122382919e-07, -7.51521596509247467e-06, 1.21665930278402614e-07, -5.43771801128259869e-09*1./(1_MeV), 0, 3.01680354122382919e-07, 0.00500722508877515793, 1.33332939824832304e-07, 3.60641268279091357e-05, -4.27847531573843138e-10*1./(1_MeV), 0, -7.51521596509247467e-06, 1.33332939824832304e-07, 1.78475985990189656e-07, -3.2621585490043233e-09, 1.59847268857147475e-10*1./(1_MeV), 0, 1.21665930278402614e-07, 3.60641268279091357e-05, -3.2621585490043233e-09, 5.36430661668418907e-07, -1.24518107354747404e-11*1./(1_MeV), 0, -5.43771801128259869e-09*1./(1_MeV), -4.27847531573843138e-10*1./(1_MeV), 1.59847268857147475e-10*1./(1_MeV), -1.24518107354747404e-11*1./(1_MeV), 3.62822619170977134e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform7;
+ ActsSymMatrixD<3> rotMat7;
+ rotMat7 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform7.rotate(rotMat7);
+ transform7.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans7 = std::make_shared<const Transform3D>(transform7);
+ std::shared_ptr<PerigeeSurface> perigeeSurface7 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams7 = BoundParameters(tgContext, std::move(covMat7), params7, perigeeSurface7);
+ tracks.push_back(boundParams7);
+
+
+ // track 8 :
+ BoundVector params8;
+ params8 << -0.00482689496129751205, 19.7954654693603516, -0.0502131059765815735, 2.31073951721191406, 4.92803592351265252e-05*1./(1_MeV), 0;
+ Covariance covMat8;
+ covMat8 << 0.0001803018240025267, 2.28634426988047736e-05, -2.72005896920448914e-06, 9.76369038665024842e-08, -3.00839639507890418e-09*1./(1_MeV), 0, 2.28634426988047736e-05, 0.00448299339041113853, -1.94291028533954824e-07, 2.32848414810477441e-05, -1.34362151935947653e-09*1./(1_MeV), 0, -2.72005896920448914e-06, -1.94291028533954824e-07, 5.47910268267060019e-08, -7.01181814072448539e-10, 6.19209989023759561e-11*1./(1_MeV), 0, 9.76369038665024842e-08, 2.32848414810477441e-05, -7.01181814072448539e-10, 1.64913686262480041e-07, -8.97362883139383566e-12*1./(1_MeV), 0, -3.00839639507890418e-09*1./(1_MeV), -1.34362151935947653e-09*1./(1_MeV), 6.19209989023759561e-11*1./(1_MeV), -8.97362883139383566e-12*1./(1_MeV), 9.50577724173617966e-13*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform8;
+ ActsSymMatrixD<3> rotMat8;
+ rotMat8 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform8.rotate(rotMat8);
+ transform8.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans8 = std::make_shared<const Transform3D>(transform8);
+ std::shared_ptr<PerigeeSurface> perigeeSurface8 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams8 = BoundParameters(tgContext, std::move(covMat8), params8, perigeeSurface8);
+ tracks.push_back(boundParams8);
+
+
+ // track 9 :
+ BoundVector params9;
+ params9 << -0.117531783878803253, 19.82318115234375, -1.45641529560089111, 2.29713797569274902, -0.00107527442742139101*1./(1_MeV), 0;
+ Covariance covMat9;
+ covMat9 << 0.0109546398743987083, 0.000422247521285191226, -0.000319963736434306643, 6.84778945643811993e-06, -1.94063777029596808e-07*1./(1_MeV), 0, 0.000422247521285191226, 0.038861934095621109, -1.73899586261722636e-05, 0.000539627280113898428, -1.08021534013767774e-09*1./(1_MeV), 0, -0.000319963736434306643, -1.73899586261722636e-05, 9.59809040068648756e-06, -2.82678258192879005e-07, 9.40666777698761478e-09*1./(1_MeV), 0, 6.84778945643811993e-06, 0.000539627280113898428, -2.82678258192879005e-07, 7.96383665147004649e-06, -2.67210172465569124e-11*1./(1_MeV), 0, -1.94063777029596808e-07*1./(1_MeV), -1.08021534013767774e-09*1./(1_MeV), 9.40666777698761478e-09*1./(1_MeV), -2.67210172465569124e-11*1./(1_MeV), 2.76092482209833179e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform9;
+ ActsSymMatrixD<3> rotMat9;
+ rotMat9 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform9.rotate(rotMat9);
+ transform9.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans9 = std::make_shared<const Transform3D>(transform9);
+ std::shared_ptr<PerigeeSurface> perigeeSurface9 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams9 = BoundParameters(tgContext, std::move(covMat9), params9, perigeeSurface9);
+ tracks.push_back(boundParams9);
+
+
+ // track 10 :
+ BoundVector params10;
+ params10 << -0.316214293241500854, 19.9858303070068359, 2.23136758804321289, 0.716844320297241211, 0.000286014255834743381*1./(1_MeV), 0;
+ Covariance covMat10;
+ covMat10 << 0.00162444496527314186, -9.06142655681587962e-05, -4.44249197781623932e-05, -1.8536710338487062e-07, -2.67329728219464978e-08*1./(1_MeV), 0, -9.06142655681587962e-05, 0.0111282505095005035, 1.36896327277162384e-06, 9.00038816992519377e-05, 1.26432483562719022e-09*1./(1_MeV), 0, -4.44249197781623932e-05, 1.36896327277162384e-06, 1.26552151868963847e-06, -3.4175627468367298e-09, 1.15430331899061749e-09*1./(1_MeV), 0, -1.8536710338487062e-07, 9.00038816992519377e-05, -3.4175627468367298e-09, 8.96049414222943597e-07, -1.35745946999861844e-11*1./(1_MeV), 0, -2.67329728219464978e-08*1./(1_MeV), 1.26432483562719022e-09*1./(1_MeV), 1.15430331899061749e-09*1./(1_MeV), -1.35745946999861844e-11*1./(1_MeV), 2.60673704843839005e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform10;
+ ActsSymMatrixD<3> rotMat10;
+ rotMat10 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform10.rotate(rotMat10);
+ transform10.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans10 = std::make_shared<const Transform3D>(transform10);
+ std::shared_ptr<PerigeeSurface> perigeeSurface10 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams10 = BoundParameters(tgContext, std::move(covMat10), params10, perigeeSurface10);
+ tracks.push_back(boundParams10);
+
+
+ // track 11 :
+ BoundVector params11;
+ params11 << -0.026949150487780571, 19.7217216491699219, -1.88010013103485107, 1.17576122283935547, -5.31275982211809605e-05*1./(1_MeV), 0;
+ Covariance covMat11;
+ covMat11 << 0.000139126204885542393, 7.52935130834812487e-06, -2.04280921055376971e-06, 4.12883664132396972e-08, -2.21097786141294125e-09*1./(1_MeV), 0, 7.52935130834812487e-06, 0.00334829371422529221, -4.54681154865933769e-08, 2.39657209827402611e-05, -7.07961483497201632e-10*1./(1_MeV), 0, -2.04280921055376971e-06, -4.54681154865933769e-08, 3.81113594016824209e-08, -5.67025045849674143e-10, 4.41613819941043693e-11*1./(1_MeV), 0, 4.12883664132396972e-08, 2.39657209827402611e-05, -5.67025045849674143e-10, 2.3924027914290491e-07, -7.29088756930822923e-12*1./(1_MeV), 0, -2.21097786141294125e-09*1./(1_MeV), -7.07961483497201632e-10*1./(1_MeV), 4.41613819941043693e-11*1./(1_MeV), -7.29088756930822923e-12*1./(1_MeV), 6.49562489300065105e-13*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform11;
+ ActsSymMatrixD<3> rotMat11;
+ rotMat11 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform11.rotate(rotMat11);
+ transform11.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans11 = std::make_shared<const Transform3D>(transform11);
+ std::shared_ptr<PerigeeSurface> perigeeSurface11 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams11 = BoundParameters(tgContext, std::move(covMat11), params11, perigeeSurface11);
+ tracks.push_back(boundParams11);
+
+
+ // track 12 :
+ BoundVector params12;
+ params12 << -0.0259521752595901489, 19.9042549133300781, 2.12977123260498047, 0.713346481323242188, 0.000183195850695483387*1./(1_MeV), 0;
+ Covariance covMat12;
+ covMat12 << 0.000819464214146137238, -2.93160457001729501e-05, -2.12643063322425127e-05, -1.06460388794225743e-07, -1.83180521921403142e-08*1./(1_MeV), 0, -2.93160457001729501e-05, 0.00743293715640902519, 3.1618179870268056e-07, 5.44865137200824102e-05, 1.28616095797583938e-09*1./(1_MeV), 0, -2.12643063322425127e-05, 3.1618179870268056e-07, 5.87186036682396661e-07, -3.96810184286856466e-10, 7.64845470534257536e-10*1./(1_MeV), 0, -1.06460388794225743e-07, 5.44865137200824102e-05, -3.96810184286856466e-10, 4.86239514430053532e-07, 2.28968063167242651e-12*1./(1_MeV), 0, -1.83180521921403142e-08*1./(1_MeV), 1.28616095797583938e-09*1./(1_MeV), 7.64845470534257536e-10*1./(1_MeV), 2.28968063167242651e-12*1./(1_MeV), 1.68847297254970385e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform12;
+ ActsSymMatrixD<3> rotMat12;
+ rotMat12 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform12.rotate(rotMat12);
+ transform12.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans12 = std::make_shared<const Transform3D>(transform12);
+ std::shared_ptr<PerigeeSurface> perigeeSurface12 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams12 = BoundParameters(tgContext, std::move(covMat12), params12, perigeeSurface12);
+ tracks.push_back(boundParams12);
+
+
+ // track 13 :
+ BoundVector params13;
+ params13 << -0.108195297420024872, 19.4963741302490234, -1.54784798622131348, 2.76453542709350586, 0.000255180755630135536*1./(1_MeV), 0;
+ Covariance covMat13;
+ covMat13 << 0.00656767562031745911, 0.000444740943016129486, -0.000189528672096109756, 7.43444913558239102e-07, -7.72608213653531881e-08*1./(1_MeV), 0, 0.000444740943016129486, 0.0576510205864906311, -6.36114600490174744e-06, 0.000213140984352768603, -5.47938491391429549e-09*1./(1_MeV), 0, -0.000189528672096109756, -6.36114600490174744e-06, 5.65102391192340292e-06, -1.16009327799978898e-09, 3.63038358649066484e-09*1./(1_MeV), 0, 7.43444913558239102e-07, 0.000213140984352768603, -1.16009327799978898e-09, 8.20147363356227288e-07, -1.16151818981247784e-11*1./(1_MeV), 0, -7.72608213653531881e-08*1./(1_MeV), -5.47938491391429549e-09*1./(1_MeV), 3.63038358649066484e-09*1./(1_MeV), -1.16151818981247784e-11*1./(1_MeV), 5.03207892021961811e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform13;
+ ActsSymMatrixD<3> rotMat13;
+ rotMat13 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform13.rotate(rotMat13);
+ transform13.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans13 = std::make_shared<const Transform3D>(transform13);
+ std::shared_ptr<PerigeeSurface> perigeeSurface13 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams13 = BoundParameters(tgContext, std::move(covMat13), params13, perigeeSurface13);
+ tracks.push_back(boundParams13);
+
+
+ // track 14 :
+ BoundVector params14;
+ params14 << 0.00369392801076173782, 19.7586956024169922, -1.87617933750152588, 1.1225888729095459, -0.000320049060974270105*1./(1_MeV), 0;
+ Covariance covMat14;
+ covMat14 << 0.000884613138623535633, -3.82952276847713579e-05, -2.2559200610146105e-05, -2.935347589307322e-07, -1.23401086351248597e-08*1./(1_MeV), 0, -3.82952276847713579e-05, 0.00863977242261171341, 1.31139582148740249e-06, 8.32184382843871649e-05, -2.57691337601532055e-09*1./(1_MeV), 0, -2.2559200610146105e-05, 1.31139582148740249e-06, 6.16463069036399247e-07, 1.02756832396022202e-08, 4.91883875434775907e-10*1./(1_MeV), 0, -2.935347589307322e-07, 8.32184382843871649e-05, 1.02756832396022202e-08, 1.14064482659159694e-06, -1.29782130095271682e-11*1./(1_MeV), 0, -1.23401086351248597e-08*1./(1_MeV), -2.57691337601532055e-09*1./(1_MeV), 4.91883875434775907e-10*1./(1_MeV), -1.29782130095271682e-11*1./(1_MeV), 1.47767145741717343e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform14;
+ ActsSymMatrixD<3> rotMat14;
+ rotMat14 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform14.rotate(rotMat14);
+ transform14.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans14 = std::make_shared<const Transform3D>(transform14);
+ std::shared_ptr<PerigeeSurface> perigeeSurface14 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams14 = BoundParameters(tgContext, std::move(covMat14), params14, perigeeSurface14);
+ tracks.push_back(boundParams14);
+
+
+ // track 15 :
+ BoundVector params15;
+ params15 << -0.0310039687901735306, 19.3887290954589844, -0.00343075022101402283, 2.74638152122497559, -0.000532752485014498234*1./(1_MeV), 0;
+ Covariance covMat15;
+ covMat15 << 0.0210070386528968811, 0.00081324441594192757, -0.000627920381522417519, 5.48433427524947839e-06, -4.65033942443220242e-07*1./(1_MeV), 0, 0.00081324441594192757, 0.163831159472465515, -4.16699183438430112e-05, 0.000680023693129414735, 4.78762996341304375e-09*1./(1_MeV), 0, -0.000627920381522417519, -4.16699183438430112e-05, 1.914421227411367e-05, -2.43960230438290961e-07, 2.22620707063765654e-08*1./(1_MeV), 0, 5.48433427524947839e-06, 0.000680023693129414735, -2.43960230438290961e-07, 2.88798310066340491e-06, -1.98088984995358787e-11*1./(1_MeV), 0, -4.65033942443220242e-07*1./(1_MeV), 4.78762996341304375e-09*1./(1_MeV), 2.22620707063765654e-08*1./(1_MeV), -1.98088984995358787e-11*1./(1_MeV), 3.28982507902253474e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform15;
+ ActsSymMatrixD<3> rotMat15;
+ rotMat15 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform15.rotate(rotMat15);
+ transform15.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans15 = std::make_shared<const Transform3D>(transform15);
+ std::shared_ptr<PerigeeSurface> perigeeSurface15 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams15 = BoundParameters(tgContext, std::move(covMat15), params15, perigeeSurface15);
+ tracks.push_back(boundParams15);
+
+
+ // track 16 :
+ BoundVector params16;
+ params16 << -0.0615801773965358734, 19.7117156982421875, -1.35818147659301758, 1.24108779430389404, 0.000683536636643111706*1./(1_MeV), 0;
+ Covariance covMat16;
+ covMat16 << 0.00367696909233927727, -6.93357704233026409e-05, -9.18706572871465986e-05, 6.07456121632656689e-08, -5.20653615571341965e-08*1./(1_MeV), 0, -6.93357704233026409e-05, 0.0121181188151240349, 8.53747299804855816e-07, 0.000199079474268702445, -6.01983132635719627e-10*1./(1_MeV), 0, -9.18706572871465986e-05, 8.53747299804855816e-07, 2.43243312070262618e-06, -1.96703166322206024e-08, 2.02041678483988925e-09*1./(1_MeV), 0, 6.07456121632656689e-08, 0.000199079474268702445, -1.96703166322206024e-08, 4.24742711402359419e-06, -5.3578874964861769e-11*1./(1_MeV), 0, -5.20653615571341965e-08*1./(1_MeV), -6.01983132635719627e-10*1./(1_MeV), 2.02041678483988925e-09*1./(1_MeV), -5.3578874964861769e-11*1./(1_MeV), 6.21097825947991566e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform16;
+ ActsSymMatrixD<3> rotMat16;
+ rotMat16 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform16.rotate(rotMat16);
+ transform16.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans16 = std::make_shared<const Transform3D>(transform16);
+ std::shared_ptr<PerigeeSurface> perigeeSurface16 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams16 = BoundParameters(tgContext, std::move(covMat16), params16, perigeeSurface16);
+ tracks.push_back(boundParams16);
+
+
+ // track 17 :
+ BoundVector params17;
+ params17 << 0.0127343572676181793, 19.6999797821044922, 1.36659955978393555, 2.38492679595947266, -1.37666047521634027e-05*1./(1_MeV), 0;
+ Covariance covMat17;
+ covMat17 << 7.14391426299698651e-05, 1.0805756954054268e-05, -8.57142054744985697e-07, 3.6976454665569372e-08, -1.42849189612088987e-09*1./(1_MeV), 0, 1.0805756954054268e-05, 0.00291397958062589169, -1.43522930069826317e-07, 1.16636632835631987e-05, -6.34703011704137292e-10*1./(1_MeV), 0, -8.57142054744985697e-07, -1.43522930069826317e-07, 1.44155682946234265e-08, -6.52670147341345277e-10, 2.26980129134178516e-11*1./(1_MeV), 0, 3.6976454665569372e-08, 1.16636632835631987e-05, -6.52670147341345277e-10, 6.37399537595229049e-08, -3.38191913541128504e-12*1./(1_MeV), 0, -1.42849189612088987e-09*1./(1_MeV), -6.34703011704137292e-10*1./(1_MeV), 2.26980129134178516e-11*1./(1_MeV), -3.38191913541128504e-12*1./(1_MeV), 1.40677413836866327e-13*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform17;
+ ActsSymMatrixD<3> rotMat17;
+ rotMat17 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform17.rotate(rotMat17);
+ transform17.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans17 = std::make_shared<const Transform3D>(transform17);
+ std::shared_ptr<PerigeeSurface> perigeeSurface17 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams17 = BoundParameters(tgContext, std::move(covMat17), params17, perigeeSurface17);
+ tracks.push_back(boundParams17);
+
+
+ // track 18 :
+ BoundVector params18;
+ params18 << -0.0384683907032012939, 19.7426490783691406, -1.80467498302459717, 1.19412243366241455, -0.000574302859604358673*1./(1_MeV), 0;
+ Covariance covMat18;
+ covMat18 << 0.00202423892915248871, -7.8687140869615615e-05, -5.63647103701870963e-05, -6.49649805133107235e-07, -3.34683099080895321e-08*1./(1_MeV), 0, -7.8687140869615615e-05, 0.0185887850821018219, 2.64877126417112638e-06, 0.000217824332446111879, -1.12870927770216557e-08*1./(1_MeV), 0, -5.63647103701870963e-05, 2.64877126417112638e-06, 1.6361793768737698e-06, 2.55884812519548554e-08, 1.44678702068679967e-09*1./(1_MeV), 0, -6.49649805133107235e-07, 0.000217824332446111879, 2.55884812519548554e-08, 3.64099946636997629e-06, -1.23298436708217984e-10*1./(1_MeV), 0, -3.34683099080895321e-08*1./(1_MeV), -1.12870927770216557e-08*1./(1_MeV), 1.44678702068679967e-09*1./(1_MeV), -1.23298436708217984e-10*1./(1_MeV), 4.65322051723671137e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform18;
+ ActsSymMatrixD<3> rotMat18;
+ rotMat18 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform18.rotate(rotMat18);
+ transform18.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans18 = std::make_shared<const Transform3D>(transform18);
+ std::shared_ptr<PerigeeSurface> perigeeSurface18 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams18 = BoundParameters(tgContext, std::move(covMat18), params18, perigeeSurface18);
+ tracks.push_back(boundParams18);
+
+
+ // track 19 :
+ BoundVector params19;
+ params19 << -0.00301715848036110401, 19.8266525268554688, -2.67224979400634766, 0.715977728366851807, -0.000728958519175648689*1./(1_MeV), 0;
+ Covariance covMat19;
+ covMat19 << 0.00722755817696452141, -0.000255548940999269852, -0.000217406702398603241, -3.1716960065804312e-06, -1.22003670918761397e-07*1./(1_MeV), 0, -0.000255548940999269852, 0.0352888740599155426, 1.12056165324810929e-05, 0.000387397513496410965, 1.44034486642105852e-09*1./(1_MeV), 0, -0.000217406702398603241, 1.12056165324810929e-05, 6.66530741000315174e-06, 1.44476099359170098e-07, 5.84575834646360909e-09*1./(1_MeV), 0, -3.1716960065804312e-06, 0.000387397513496410965, 1.44476099359170098e-07, 4.60058254247996956e-06, 2.70756521335290287e-11*1./(1_MeV), 0, -1.22003670918761397e-07*1./(1_MeV), 1.44034486642105852e-09*1./(1_MeV), 5.84575834646360909e-09*1./(1_MeV), 2.70756521335290287e-11*1./(1_MeV), 1.47919038129273872e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform19;
+ ActsSymMatrixD<3> rotMat19;
+ rotMat19 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform19.rotate(rotMat19);
+ transform19.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans19 = std::make_shared<const Transform3D>(transform19);
+ std::shared_ptr<PerigeeSurface> perigeeSurface19 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams19 = BoundParameters(tgContext, std::move(covMat19), params19, perigeeSurface19);
+ tracks.push_back(boundParams19);
+
+
+ // track 20 :
+ BoundVector params20;
+ params20 << -0.050889924168586731, 19.6028633117675781, 0.112749122083187103, 2.38145637512207031, -0.000236698266235180199*1./(1_MeV), 0;
+ Covariance covMat20;
+ covMat20 << 0.00143691536504775286, 0.000164076889054642412, -3.58648437617112441e-05, 9.51572596730293739e-07, -2.06847797524276209e-08*1./(1_MeV), 0, 0.000164076889054642412, 0.0106960544362664223, -3.61365524801671333e-06, 9.12128019022396863e-05, 1.63349320460262432e-09*1./(1_MeV), 0, -3.58648437617112441e-05, -3.61365524801671333e-06, 9.44514340517343953e-07, -2.26900632828089059e-08, 8.985070684429297e-10*1./(1_MeV), 0, 9.51572596730293739e-07, 9.12128019022396863e-05, -2.26900632828089059e-08, 9.40663255732943071e-07, -7.29312017504296212e-12*1./(1_MeV), 0, -2.06847797524276209e-08*1./(1_MeV), 1.63349320460262432e-09*1./(1_MeV), 8.985070684429297e-10*1./(1_MeV), -7.29312017504296212e-12*1./(1_MeV), 2.3087929137965979e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform20;
+ ActsSymMatrixD<3> rotMat20;
+ rotMat20 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform20.rotate(rotMat20);
+ transform20.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans20 = std::make_shared<const Transform3D>(transform20);
+ std::shared_ptr<PerigeeSurface> perigeeSurface20 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams20 = BoundParameters(tgContext, std::move(covMat20), params20, perigeeSurface20);
+ tracks.push_back(boundParams20);
+
+
+ // track 21 :
+ BoundVector params21;
+ params21 << 0.340526312589645386, 19.5222663879394531, 1.98806488513946533, 0.645573973655700684, -0.000210438229260034859*1./(1_MeV), 0;
+ Covariance covMat21;
+ covMat21 << 0.00187653978355228901, -4.61886315977834042e-05, -4.50543377001786315e-05, -4.23803726213808519e-07, -2.27506680726447051e-08*1./(1_MeV), 0, -4.61886315977834042e-05, 0.00947334989905357361, 1.12025168001414582e-06, 6.5792105051481426e-05, -1.06230443637615531e-09*1./(1_MeV), 0, -4.50543377001786315e-05, 1.12025168001414582e-06, 1.15167620151623851e-06, 1.18795575818832697e-08, 8.43143312452009429e-10*1./(1_MeV), 0, -4.23803726213808519e-07, 6.5792105051481426e-05, 1.18795575818832697e-08, 5.50924369235872291e-07, 5.88708293652256259e-12*1./(1_MeV), 0, -2.27506680726447051e-08*1./(1_MeV), -1.06230443637615531e-09*1./(1_MeV), 8.43143312452009429e-10*1./(1_MeV), 5.88708293652256259e-12*1./(1_MeV), 1.54570852645141699e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform21;
+ ActsSymMatrixD<3> rotMat21;
+ rotMat21 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform21.rotate(rotMat21);
+ transform21.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans21 = std::make_shared<const Transform3D>(transform21);
+ std::shared_ptr<PerigeeSurface> perigeeSurface21 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams21 = BoundParameters(tgContext, std::move(covMat21), params21, perigeeSurface21);
+ tracks.push_back(boundParams21);
+
+
+ // track 22 :
+ BoundVector params22;
+ params22 << 0.0327057354152202606, 19.7024917602539062, -2.13715505599975586, 2.80726861953735352, 0.000263765512499958277*1./(1_MeV), 0;
+ Covariance covMat22;
+ covMat22 << 0.00759664503857493401, 0.000905364247503756396, -0.000227879179537351814, 1.47085121825187884e-06, -1.05708472073745111e-07*1./(1_MeV), 0, 0.000905364247503756396, 0.0961576402187347412, -1.17275682104315631e-05, 0.00028353976847481278, -9.08595344434235293e-09*1./(1_MeV), 0, -0.000227879179537351814, -1.17275682104315631e-05, 7.0192058956308756e-06, -5.73812881555304563e-09, 5.16319886110993577e-09*1./(1_MeV), 0, 1.47085121825187884e-06, 0.00028353976847481278, -5.73812881555304563e-09, 8.68534641540463781e-07, -1.7137080433623932e-11*1./(1_MeV), 0, -1.05708472073745111e-07*1./(1_MeV), -9.08595344434235293e-09*1./(1_MeV), 5.16319886110993577e-09*1./(1_MeV), -1.7137080433623932e-11*1./(1_MeV), 6.82771200688492286e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform22;
+ ActsSymMatrixD<3> rotMat22;
+ rotMat22 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform22.rotate(rotMat22);
+ transform22.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans22 = std::make_shared<const Transform3D>(transform22);
+ std::shared_ptr<PerigeeSurface> perigeeSurface22 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams22 = BoundParameters(tgContext, std::move(covMat22), params22, perigeeSurface22);
+ tracks.push_back(boundParams22);
+
+
+ // track 23 :
+ BoundVector params23;
+ params23 << -0.313747167587280273, 19.8418807983398438, 2.22803497314453125, 0.69142603874206543, 0.000169251798070035875*1./(1_MeV), 0;
+ Covariance covMat23;
+ covMat23 << 0.000822073488961905241, -4.22023511849360173e-05, -2.11682852032007045e-05, -1.39809980877076557e-07, -1.13325862651714777e-08*1./(1_MeV), 0, -4.22023511849360173e-05, 0.00642389757558703423, 4.73854987704379056e-07, 4.62124676517580748e-05, 7.96633147731774745e-10*1./(1_MeV), 0, -2.11682852032007045e-05, 4.73854987704379056e-07, 5.80069183797604637e-07, 3.15912432766058085e-11, 4.56396742731161166e-10*1./(1_MeV), 0, -1.39809980877076557e-07, 4.62124676517580748e-05, 3.15912432766058085e-11, 3.99615089463623008e-07, 2.27545298907622666e-12*1./(1_MeV), 0, -1.13325862651714777e-08*1./(1_MeV), 7.96633147731774745e-10*1./(1_MeV), 4.56396742731161166e-10*1./(1_MeV), 2.27545298907622666e-12*1./(1_MeV), 9.23549778319987524e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform23;
+ ActsSymMatrixD<3> rotMat23;
+ rotMat23 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform23.rotate(rotMat23);
+ transform23.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans23 = std::make_shared<const Transform3D>(transform23);
+ std::shared_ptr<PerigeeSurface> perigeeSurface23 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams23 = BoundParameters(tgContext, std::move(covMat23), params23, perigeeSurface23);
+ tracks.push_back(boundParams23);
+
+
+ // track 24 :
+ BoundVector params24;
+ params24 << 0.0601691603660583496, 19.4889583587646484, 1.45675015449523926, 1.56046152114868164, -0.000939691497478634119*1./(1_MeV), 0;
+ Covariance covMat24;
+ covMat24 << 0.00347459153272211552, 2.61288253282652421e-08, -0.000100485766757895184, -1.57776073352115993e-08, -5.9865669012875978e-08*1./(1_MeV), 0, 2.61288253282652421e-08, 0.0155909880995750427, 4.31090469568027334e-09, 0.00030456631727040519, -2.26566988417194164e-09*1./(1_MeV), 0, -0.000100485766757895184, 4.31090469568027334e-09, 2.96180473924323451e-06, 7.78080017868743252e-10, 2.82122625662053921e-09*1./(1_MeV), 0, -1.57776073352115993e-08, 0.00030456631727040519, 7.78080017868743252e-10, 7.35272124074981548e-06, -3.83106395644490913e-11*1./(1_MeV), 0, -5.9865669012875978e-08*1./(1_MeV), -2.26566988417194164e-09*1./(1_MeV), 2.82122625662053921e-09*1./(1_MeV), -3.83106395644490913e-11*1./(1_MeV), 1.06380099174074871e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform24;
+ ActsSymMatrixD<3> rotMat24;
+ rotMat24 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform24.rotate(rotMat24);
+ transform24.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans24 = std::make_shared<const Transform3D>(transform24);
+ std::shared_ptr<PerigeeSurface> perigeeSurface24 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams24 = BoundParameters(tgContext, std::move(covMat24), params24, perigeeSurface24);
+ tracks.push_back(boundParams24);
+
+
+ // track 25 :
+ BoundVector params25;
+ params25 << 0.305262893438339233, 19.6428985595703125, 2.0014500617980957, 0.674862563610076904, -0.000269854936050251126*1./(1_MeV), 0;
+ Covariance covMat25;
+ covMat25 << 0.00167414336465299129, -1.78847304832933408e-05, -4.55389135089741097e-05, -3.82403117295285017e-07, -2.12364403958921256e-08*1./(1_MeV), 0, -1.78847304832933408e-05, 0.0104135861620306969, 6.75815994310390194e-07, 8.49609773572517027e-05, -1.92504072395493255e-10*1./(1_MeV), 0, -4.55389135089741097e-05, 6.75815994310390194e-07, 1.29258842207491398e-06, 1.38985937523038846e-08, 9.37637080501081717e-10*1./(1_MeV), 0, -3.82403117295285017e-07, 8.49609773572517027e-05, 1.38985937523038846e-08, 7.91449053849646589e-07, 7.1066766939193851e-12*1./(1_MeV), 0, -2.12364403958921256e-08*1./(1_MeV), -1.92504072395493255e-10*1./(1_MeV), 9.37637080501081717e-10*1./(1_MeV), 7.1066766939193851e-12*1./(1_MeV), 2.08066983781174386e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform25;
+ ActsSymMatrixD<3> rotMat25;
+ rotMat25 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform25.rotate(rotMat25);
+ transform25.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans25 = std::make_shared<const Transform3D>(transform25);
+ std::shared_ptr<PerigeeSurface> perigeeSurface25 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams25 = BoundParameters(tgContext, std::move(covMat25), params25, perigeeSurface25);
+ tracks.push_back(boundParams25);
+
+
+ // track 26 :
+ BoundVector params26;
+ params26 << -0.0716414377093315125, 19.4469375610351562, -1.31057024002075195, 2.37900662422180176, -0.000480518414406105876*1./(1_MeV), 0;
+ Covariance covMat26;
+ covMat26 << 0.00311773899011313915, 0.000216807668024049122, -8.85980764209346383e-05, 2.33675139737157217e-06, -5.69352023227364653e-08*1./(1_MeV), 0, 0.000216807668024049122, 0.0251653064042329788, -6.874046489217475e-06, 0.000259795929953506673, 1.0275478076867433e-09*1./(1_MeV), 0, -8.85980764209346383e-05, -6.874046489217475e-06, 2.60891670222918037e-06, -7.84173992006491199e-08, 2.8010804631721876e-09*1./(1_MeV), 0, 2.33675139737157217e-06, 0.000259795929953506673, -7.84173992006491199e-08, 2.90308980765985325e-06, -2.89203496927991014e-12*1./(1_MeV), 0, -5.69352023227364653e-08*1./(1_MeV), 1.0275478076867433e-09*1./(1_MeV), 2.8010804631721876e-09*1./(1_MeV), -2.89203496927991014e-12*1./(1_MeV), 7.90091464475395355e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform26;
+ ActsSymMatrixD<3> rotMat26;
+ rotMat26 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform26.rotate(rotMat26);
+ transform26.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans26 = std::make_shared<const Transform3D>(transform26);
+ std::shared_ptr<PerigeeSurface> perigeeSurface26 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams26 = BoundParameters(tgContext, std::move(covMat26), params26, perigeeSurface26);
+ tracks.push_back(boundParams26);
+
+
+ // track 27 :
+ BoundVector params27;
+ params27 << 0.0340305417776107788, 19.7064609527587891, 1.96402919292449951, 0.62500452995300293, 0.000157972215674817562*1./(1_MeV), 0;
+ Covariance covMat27;
+ covMat27 << 0.00115194241516292095, -1.75935599558400332e-05, -2.72476171609115263e-05, -3.19554349594589653e-08, -1.21725335271778638e-08*1./(1_MeV), 0, -1.75935599558400332e-05, 0.00663218600675463676, -1.47069503149528377e-08, 4.24403084279258386e-05, -1.17670450049324461e-11*1./(1_MeV), 0, -2.72476171609115263e-05, -1.47069503149528377e-08, 6.9136649472056888e-07, -1.3832287263184986e-09, 4.45969786691428052e-10*1./(1_MeV), 0, -3.19554349594589653e-08, 4.24403084279258386e-05, -1.3832287263184986e-09, 3.26797248817456421e-07, -3.37620811397436092e-13*1./(1_MeV), 0, -1.21725335271778638e-08*1./(1_MeV), -1.17670450049324461e-11*1./(1_MeV), 4.45969786691428052e-10*1./(1_MeV), -3.37620811397436092e-13*1./(1_MeV), 7.86358218124449948e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform27;
+ ActsSymMatrixD<3> rotMat27;
+ rotMat27 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform27.rotate(rotMat27);
+ transform27.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans27 = std::make_shared<const Transform3D>(transform27);
+ std::shared_ptr<PerigeeSurface> perigeeSurface27 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams27 = BoundParameters(tgContext, std::move(covMat27), params27, perigeeSurface27);
+ tracks.push_back(boundParams27);
+
+
+ // track 28 :
+ BoundVector params28;
+ params28 << -0.0371651053428649902, 19.7891578674316406, -0.659238219261169434, 0.274633139371871948, -3.11207440972793847e-05*1./(1_MeV), 0;
+ Covariance covMat28;
+ covMat28 << 0.00094830815214663744, -0.00019487656314514027, -2.12130854277417798e-05, -2.34663925361313877e-07, -3.03861064262990213e-09*1./(1_MeV), 0, -0.00019487656314514027, 0.0170497521758079529, 3.70571285096039324e-06, 2.64888644523930275e-05, 2.42556496747356217e-10*1./(1_MeV), 0, -2.12130854277417798e-05, 3.70571285096039324e-06, 5.07914478475868236e-07, 4.96919950915106563e-09, 1.14830219767461788e-10*1./(1_MeV), 0, -2.34663925361313877e-07, 2.64888644523930275e-05, 4.96919950915106563e-09, 4.59249491768787266e-08, 2.84459713659211857e-13*1./(1_MeV), 0, -3.03861064262990213e-09*1./(1_MeV), 2.42556496747356217e-10*1./(1_MeV), 1.14830219767461788e-10*1./(1_MeV), 2.84459713659211857e-13*1./(1_MeV), 9.65581672777993116e-13*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform28;
+ ActsSymMatrixD<3> rotMat28;
+ rotMat28 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform28.rotate(rotMat28);
+ transform28.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans28 = std::make_shared<const Transform3D>(transform28);
+ std::shared_ptr<PerigeeSurface> perigeeSurface28 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams28 = BoundParameters(tgContext, std::move(covMat28), params28, perigeeSurface28);
+ tracks.push_back(boundParams28);
+
+
+ // track 29 :
+ BoundVector params29;
+ params29 << 0.0113061871379613876, 19.7758064270019531, -0.565121948719024658, 1.11297404766082764, -0.000380097364541143179*1./(1_MeV), 0;
+ Covariance covMat29;
+ covMat29 << 0.00155933154746890068, -4.97482623935557549e-05, -3.73456424926352755e-05, -4.55759156051640272e-07, -2.07172213465749658e-08*1./(1_MeV), 0, -4.97482623935557549e-05, 0.00686531048268079758, 1.31561141444726331e-06, 8.97714266550412308e-05, -1.19474789182683184e-09*1./(1_MeV), 0, -3.73456424926352755e-05, 1.31561141444726331e-06, 9.55697146309830714e-07, 1.30428805682263728e-08, 7.75026676835572029e-10*1./(1_MeV), 0, -4.55759156051640272e-07, 8.97714266550412308e-05, 1.30428805682263728e-08, 1.62136052495043259e-06, -3.68485465951844148e-12*1./(1_MeV), 0, -2.07172213465749658e-08*1./(1_MeV), -1.19474789182683184e-09*1./(1_MeV), 7.75026676835572029e-10*1./(1_MeV), -3.68485465951844148e-12*1./(1_MeV), 2.15952047910583644e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform29;
+ ActsSymMatrixD<3> rotMat29;
+ rotMat29 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform29.rotate(rotMat29);
+ transform29.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans29 = std::make_shared<const Transform3D>(transform29);
+ std::shared_ptr<PerigeeSurface> perigeeSurface29 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams29 = BoundParameters(tgContext, std::move(covMat29), params29, perigeeSurface29);
+ tracks.push_back(boundParams29);
+
+
+ // track 30 :
+ BoundVector params30;
+ params30 << -0.000764124910347163677, 19.7925205230712891, -1.60565555095672607, 2.11691427230834961, 0.00109597900882363319*1./(1_MeV), 0;
+ Covariance covMat30;
+ covMat30 << 0.00818897411227226257, -7.88637168572715077e-05, -0.000237841176207310301, -2.86874654680000338e-06, -1.07533611185096677e-07*1./(1_MeV), 0, -7.88637168572715077e-05, 0.0303833372890949249, 6.69007874662318617e-06, 0.000503271982246975501, 1.40492310581731278e-09*1./(1_MeV), 0, -0.000237841176207310301, 6.69007874662318617e-06, 7.098253263393417e-06, 1.64058162507511388e-07, 5.23793435502016417e-09*1./(1_MeV), 0, -2.86874654680000338e-06, 0.000503271982246975501, 1.64058162507511388e-07, 9.68445510807214305e-06, 4.84013097877190455e-11*1./(1_MeV), 0, -1.07533611185096677e-07*1./(1_MeV), 1.40492310581731278e-09*1./(1_MeV), 5.23793435502016417e-09*1./(1_MeV), 4.84013097877190455e-11*1./(1_MeV), 1.75064601704022493e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform30;
+ ActsSymMatrixD<3> rotMat30;
+ rotMat30 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform30.rotate(rotMat30);
+ transform30.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans30 = std::make_shared<const Transform3D>(transform30);
+ std::shared_ptr<PerigeeSurface> perigeeSurface30 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams30 = BoundParameters(tgContext, std::move(covMat30), params30, perigeeSurface30);
+ tracks.push_back(boundParams30);
+
+
+ // track 31 :
+ BoundVector params31;
+ params31 << 0.0434660129249095917, 19.9743804931640625, -1.92152023315429688, 1.10322427749633789, -0.00135057768784463406*1./(1_MeV), 0;
+ Covariance covMat31;
+ covMat31 << 0.00949090253561735153, -0.000162514116123452891, -0.000277450606342210756, -3.41726209466831981e-06, -1.35977257290003362e-07*1./(1_MeV), 0, -0.000162514116123452891, 0.0241005755960941315, 7.44390386227167547e-06, 0.000482722310593120495, -5.01533653096054345e-09*1./(1_MeV), 0, -0.000277450606342210756, 7.44390386227167547e-06, 8.34032562124775723e-06, 1.70338602887570872e-07, 6.59502382970017033e-09*1./(1_MeV), 0, -3.41726209466831981e-06, 0.000482722310593120495, 1.70338602887570872e-07, 1.08669210021616891e-05, -1.30623540733939145e-10*1./(1_MeV), 0, -1.35977257290003362e-07*1./(1_MeV), -5.01533653096054345e-09*1./(1_MeV), 6.59502382970017033e-09*1./(1_MeV), -1.30623540733939145e-10*1./(1_MeV), 2.33806835003846913e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform31;
+ ActsSymMatrixD<3> rotMat31;
+ rotMat31 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform31.rotate(rotMat31);
+ transform31.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans31 = std::make_shared<const Transform3D>(transform31);
+ std::shared_ptr<PerigeeSurface> perigeeSurface31 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams31 = BoundParameters(tgContext, std::move(covMat31), params31, perigeeSurface31);
+ tracks.push_back(boundParams31);
+
+
+ // track 32 :
+ BoundVector params32;
+ params32 << -0.323653548955917358, 23.0863323211669922, -2.04575490951538086, 1.19155371189117432, -0.00135404628235846758*1./(1_MeV), 0;
+ Covariance covMat32;
+ covMat32 << 0.00942049268633127213, -0.000156100331056732402, -0.000267428691337353848, -2.84213758688659959e-06, -1.3715343361864345e-07*1./(1_MeV), 0, -0.000156100331056732402, 0.0234745144844055176, 6.9330452366765478e-06, 0.000468627570852257769, 4.42012838944869237e-10*1./(1_MeV), 0, -0.000267428691337353848, 6.9330452366765478e-06, 7.8662105806870386e-06, 1.40317764457691491e-07, 6.38338658586116389e-09*1./(1_MeV), 0, -2.84213758688659959e-06, 0.000468627570852257769, 1.40317764457691491e-07, 1.09587390397791751e-05, 1.69050142770342731e-12*1./(1_MeV), 0, -1.3715343361864345e-07*1./(1_MeV), 4.42012838944869237e-10*1./(1_MeV), 6.38338658586116389e-09*1./(1_MeV), 1.69050142770342731e-12*1./(1_MeV), 2.24243526525391701e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform32;
+ ActsSymMatrixD<3> rotMat32;
+ rotMat32 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform32.rotate(rotMat32);
+ transform32.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans32 = std::make_shared<const Transform3D>(transform32);
+ std::shared_ptr<PerigeeSurface> perigeeSurface32 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams32 = BoundParameters(tgContext, std::move(covMat32), params32, perigeeSurface32);
+ tracks.push_back(boundParams32);
+
+
+ // track 33 :
+ BoundVector params33;
+ params33 << 0.0502348393201828003, 19.8225479125976562, 1.2200552225112915, 1.19947576522827148, 0.00065168103901669383*1./(1_MeV), 0;
+ Covariance covMat33;
+ covMat33 << 0.00330946571193635464, -3.03961755070003361e-05, -8.23355349674717059e-05, 3.61557925205989208e-07, -4.81647993693705346e-08*1./(1_MeV), 0, -3.03961755070003361e-05, 0.0121201490983366966, -3.44926830210965382e-08, 0.0001832216673901092, -8.289858737864768e-09*1./(1_MeV), 0, -8.23355349674717059e-05, -3.44926830210965382e-08, 2.16286139220756013e-06, -2.50835114436962174e-08, 1.88343068671924282e-09*1./(1_MeV), 0, 3.61557925205989208e-07, 0.0001832216673901092, -2.50835114436962174e-08, 3.61402794624154922e-06, -1.38343005917598103e-10*1./(1_MeV), 0, -4.81647993693705346e-08*1./(1_MeV), -8.289858737864768e-09*1./(1_MeV), 1.88343068671924282e-09*1./(1_MeV), -1.38343005917598103e-10*1./(1_MeV), 5.75411177039519828e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform33;
+ ActsSymMatrixD<3> rotMat33;
+ rotMat33 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform33.rotate(rotMat33);
+ transform33.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans33 = std::make_shared<const Transform3D>(transform33);
+ std::shared_ptr<PerigeeSurface> perigeeSurface33 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams33 = BoundParameters(tgContext, std::move(covMat33), params33, perigeeSurface33);
+ tracks.push_back(boundParams33);
+
+
+ // track 34 :
+ BoundVector params34;
+ params34 << -0.00679738679900765419, 19.7787380218505859, 0.64978182315826416, 1.718436598777771, 0.000399400596506893635*1./(1_MeV), 0;
+ Covariance covMat34;
+ covMat34 << 0.0016832397086545825, 3.08902871283228804e-08, -3.9761794373880207e-05, -5.36301231604843024e-08, -1.25551948300567075e-08*1./(1_MeV), 0, 3.08902871283228804e-08, 0.0122804483398795128, 1.50321795312578277e-07, 0.000155226454439672071, -3.69637596757974278e-09*1./(1_MeV), 0, -3.9761794373880207e-05, 1.50321795312578277e-07, 1.01230580185074359e-06, 3.57209146154241154e-09, 5.08893136683866958e-10*1./(1_MeV), 0, -5.36301231604843024e-08, 0.000155226454439672071, 3.57209146154241154e-09, 2.92897698273009155e-06, -4.64295001076053898e-11*1./(1_MeV), 0, -1.25551948300567075e-08*1./(1_MeV), -3.69637596757974278e-09*1./(1_MeV), 5.08893136683866958e-10*1./(1_MeV), -4.64295001076053898e-11*1./(1_MeV), 1.79039612996367836e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform34;
+ ActsSymMatrixD<3> rotMat34;
+ rotMat34 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform34.rotate(rotMat34);
+ transform34.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans34 = std::make_shared<const Transform3D>(transform34);
+ std::shared_ptr<PerigeeSurface> perigeeSurface34 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams34 = BoundParameters(tgContext, std::move(covMat34), params34, perigeeSurface34);
+ tracks.push_back(boundParams34);
+
+
+ // track 35 :
+ BoundVector params35;
+ params35 << 0.0805509239435195923, 19.8107032775878906, -0.580723822116851807, 1.39042818546295166, -0.000723547651432454586*1./(1_MeV), 0;
+ Covariance covMat35;
+ covMat35 << 0.00366608682088553905, -3.07736450112954378e-05, -9.36432680714786278e-05, -4.32691756908737401e-07, -4.03209869361722161e-08*1./(1_MeV), 0, -3.07736450112954378e-05, 0.0121293710544705391, 8.84241894101609937e-07, 0.000208273787997539348, -4.72119222103642781e-09*1./(1_MeV), 0, -9.36432680714786278e-05, 8.84241894101609937e-07, 2.51136862061684951e-06, 1.65541645067806758e-08, 1.643748206415159e-09*1./(1_MeV), 0, -4.32691756908737401e-07, 0.000208273787997539348, 1.65541645067806758e-08, 4.73576938020414673e-06, -5.8294474111660837e-11*1./(1_MeV), 0, -4.03209869361722161e-08*1./(1_MeV), -4.72119222103642781e-09*1./(1_MeV), 1.643748206415159e-09*1./(1_MeV), -5.8294474111660837e-11*1./(1_MeV), 5.46871367634871319e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform35;
+ ActsSymMatrixD<3> rotMat35;
+ rotMat35 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform35.rotate(rotMat35);
+ transform35.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans35 = std::make_shared<const Transform3D>(transform35);
+ std::shared_ptr<PerigeeSurface> perigeeSurface35 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams35 = BoundParameters(tgContext, std::move(covMat35), params35, perigeeSurface35);
+ tracks.push_back(boundParams35);
+
+
+ // track 36 :
+ BoundVector params36;
+ params36 << 0.0170946419239044189, 19.5798168182373047, 2.3832242488861084, 1.84145426750183105, -0.0016136891208589077*1./(1_MeV), 0;
+ Covariance covMat36;
+ covMat36 << 0.0110465008765459061, 0.000132400605777621878, -0.000322046919185156361, 3.95346550436209276e-06, -1.74628381920564644e-07*1./(1_MeV), 0, 0.000132400605777621878, 0.0441923066973686218, -7.93550960128202309e-06, 0.000857220862319744157, -3.078313337372045e-09*1./(1_MeV), 0, -0.000322046919185156361, -7.93550960128202309e-06, 9.60366560320835561e-06, -2.05361008506430899e-07, 8.74873834892499733e-09*1./(1_MeV), 0, 3.95346550436209276e-06, 0.000857220862319744157, -2.05361008506430899e-07, 1.90070531971286982e-05, -2.62406175067672348e-11*1./(1_MeV), 0, -1.74628381920564644e-07*1./(1_MeV), -3.078313337372045e-09*1./(1_MeV), 8.74873834892499733e-09*1./(1_MeV), -2.62406175067672348e-11*1./(1_MeV), 3.43723355333835912e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform36;
+ ActsSymMatrixD<3> rotMat36;
+ rotMat36 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform36.rotate(rotMat36);
+ transform36.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans36 = std::make_shared<const Transform3D>(transform36);
+ std::shared_ptr<PerigeeSurface> perigeeSurface36 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams36 = BoundParameters(tgContext, std::move(covMat36), params36, perigeeSurface36);
+ tracks.push_back(boundParams36);
+
+
+ // track 37 :
+ BoundVector params37;
+ params37 << 0.0422709546983242035, 19.8179073333740234, -0.292277246713638306, 1.55503785610198975, 0.00102485006209462881*1./(1_MeV), 0;
+ Covariance covMat37;
+ covMat37 << 0.0048865852877497673, 1.04378577009161224e-06, -0.000137165974802729929, 5.94294471798817227e-08, -7.83582361279693423e-08*1./(1_MeV), 0, 1.04378577009161224e-06, 0.0150463152676820755, -1.19789705332920958e-07, 0.000332276925926711661, -1.66883965671842617e-09*1./(1_MeV), 0, -0.000137165974802729929, -1.19789705332920958e-07, 3.95677625419921242e-06, -3.54401466185166792e-09, 3.6142052743200193e-09*1./(1_MeV), 0, 5.94294471798817227e-08, 0.000332276925926711661, -3.54401466185166792e-09, 8.53642995934933424e-06, -2.50276756413508482e-11*1./(1_MeV), 0, -7.83582361279693423e-08*1./(1_MeV), -1.66883965671842617e-09*1./(1_MeV), 3.6142052743200193e-09*1./(1_MeV), -2.50276756413508482e-11*1./(1_MeV), 1.35456687533341835e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform37;
+ ActsSymMatrixD<3> rotMat37;
+ rotMat37 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform37.rotate(rotMat37);
+ transform37.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans37 = std::make_shared<const Transform3D>(transform37);
+ std::shared_ptr<PerigeeSurface> perigeeSurface37 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams37 = BoundParameters(tgContext, std::move(covMat37), params37, perigeeSurface37);
+ tracks.push_back(boundParams37);
+
+
+ // track 38 :
+ BoundVector params38;
+ params38 << 0.0177954975515604019, 19.6020870208740234, 2.58446574211120605, 2.14368629455566406, 0.00039697738247923553*1./(1_MeV), 0;
+ Covariance covMat38;
+ covMat38 << 0.00228728121146559715, -6.6835355739982095e-07, -5.56660017110235266e-05, -2.3660648892322657e-07, -2.44971223220455001e-08*1./(1_MeV), 0, -6.6835355739982095e-07, 0.0207388382405042648, 9.95559061054844415e-07, 0.000196521767889107021, -9.37926118817295971e-09*1./(1_MeV), 0, -5.56660017110235266e-05, 9.95559061054844415e-07, 1.44270552482339554e-06, 1.62772969664253208e-08, 9.58725521674916825e-10*1./(1_MeV), 0, -2.3660648892322657e-07, 0.000196521767889107021, 1.62772969664253208e-08, 2.3284674171009101e-06, -3.82657738677909124e-11*1./(1_MeV), 0, -2.44971223220455001e-08*1./(1_MeV), -9.37926118817295971e-09*1./(1_MeV), 9.58725521674916825e-10*1./(1_MeV), -3.82657738677909124e-11*1./(1_MeV), 2.58620104498508141e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform38;
+ ActsSymMatrixD<3> rotMat38;
+ rotMat38 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform38.rotate(rotMat38);
+ transform38.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans38 = std::make_shared<const Transform3D>(transform38);
+ std::shared_ptr<PerigeeSurface> perigeeSurface38 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams38 = BoundParameters(tgContext, std::move(covMat38), params38, perigeeSurface38);
+ tracks.push_back(boundParams38);
+
+
+ // track 39 :
+ BoundVector params39;
+ params39 << 0.0385684818029403687, 19.5943107604980469, 2.10506224632263184, 0.815114736557006836, -0.000444010045612230897*1./(1_MeV), 0;
+ Covariance covMat39;
+ covMat39 << 0.00257171900011599064, -8.38966740548737503e-05, -6.9521214623902581e-05, -1.04908792338842471e-06, -4.18962156374891846e-08*1./(1_MeV), 0, -8.38966740548737503e-05, 0.012954135425388813, 2.69320887977152083e-06, 0.000145498663861290411, 4.42965387319607159e-10*1./(1_MeV), 0, -6.9521214623902581e-05, 2.69320887977152083e-06, 1.96165024135552812e-06, 3.61876337782125774e-08, 1.88426409286430859e-09*1./(1_MeV), 0, -1.04908792338842471e-06, 0.000145498663861290411, 3.61876337782125774e-08, 1.82780070190347033e-06, 1.36738002410268621e-11*1./(1_MeV), 0, -4.18962156374891846e-08*1./(1_MeV), 4.42965387319607159e-10*1./(1_MeV), 1.88426409286430859e-09*1./(1_MeV), 1.36738002410268621e-11*1./(1_MeV), 5.138850109331905e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform39;
+ ActsSymMatrixD<3> rotMat39;
+ rotMat39 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform39.rotate(rotMat39);
+ transform39.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans39 = std::make_shared<const Transform3D>(transform39);
+ std::shared_ptr<PerigeeSurface> perigeeSurface39 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams39 = BoundParameters(tgContext, std::move(covMat39), params39, perigeeSurface39);
+ tracks.push_back(boundParams39);
+
+
+ // track 40 :
+ BoundVector params40;
+ params40 << -0.00192465144209563732, 19.6035480499267578, 1.34771013259887695, 1.37635326385498047, 0.000349941314198076725*1./(1_MeV), 0;
+ Covariance covMat40;
+ covMat40 << 0.00092626502737402916, -4.70278465200604772e-06, -2.37325601967636777e-05, 2.6469781945744914e-08, -1.04657823685612316e-08*1./(1_MeV), 0, -4.70278465200604772e-06, 0.00892938859760761261, -2.32025646493256662e-08, 9.67470782924100583e-05, -1.28292191621348689e-09*1./(1_MeV), 0, -2.37325601967636777e-05, -2.32025646493256662e-08, 6.42108432202803669e-07, -2.41607947044108425e-09, 4.13063041753621467e-10*1./(1_MeV), 0, 2.6469781945744914e-08, 9.67470782924100583e-05, -2.41607947044108425e-09, 1.45360513670311775e-06, -1.4243170245924231e-11*1./(1_MeV), 0, -1.04657823685612316e-08*1./(1_MeV), -1.28292191621348689e-09*1./(1_MeV), 4.13063041753621467e-10*1./(1_MeV), -1.4243170245924231e-11*1./(1_MeV), 1.31918035523037602e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform40;
+ ActsSymMatrixD<3> rotMat40;
+ rotMat40 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform40.rotate(rotMat40);
+ transform40.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans40 = std::make_shared<const Transform3D>(transform40);
+ std::shared_ptr<PerigeeSurface> perigeeSurface40 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams40 = BoundParameters(tgContext, std::move(covMat40), params40, perigeeSurface40);
+ tracks.push_back(boundParams40);
+
+
+ // track 41 :
+ BoundVector params41;
+ params41 << -0.0107631208375096321, 19.6368961334228516, 2.11897373199462891, 0.68950730562210083, 0.000500780763104557991*1./(1_MeV), 0;
+ Covariance covMat41;
+ covMat41 << 0.0046280999667942524, -8.50248504624665413e-05, -0.000130293248442505169, 3.81786496695030795e-07, -6.22341861031614923e-08*1./(1_MeV), 0, -8.50248504624665413e-05, 0.0234155002981424332, -1.02870605123693907e-06, 0.000220617921810967285, 1.23912522027359707e-09*1./(1_MeV), 0, -0.000130293248442505169, -1.02870605123693907e-06, 3.78699451175634749e-06, -4.14661454981517284e-08, 2.90208625768643512e-09*1./(1_MeV), 0, 3.81786496695030795e-07, 0.000220617921810967285, -4.14661454981517284e-08, 2.34398885368136689e-06, -4.89427060442843687e-12*1./(1_MeV), 0, -6.22341861031614923e-08*1./(1_MeV), 1.23912522027359707e-09*1./(1_MeV), 2.90208625768643512e-09*1./(1_MeV), -4.89427060442843687e-12*1./(1_MeV), 7.00765001582226432e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform41;
+ ActsSymMatrixD<3> rotMat41;
+ rotMat41 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform41.rotate(rotMat41);
+ transform41.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans41 = std::make_shared<const Transform3D>(transform41);
+ std::shared_ptr<PerigeeSurface> perigeeSurface41 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams41 = BoundParameters(tgContext, std::move(covMat41), params41, perigeeSurface41);
+ tracks.push_back(boundParams41);
+
+
+ // track 42 :
+ BoundVector params42;
+ params42 << 0.205963864922523499, 19.6864852905273438, 0.214674949645996094, 1.62375175952911377, 0.00149375631008297205*1./(1_MeV), 0;
+ Covariance covMat42;
+ covMat42 << 0.00880367588251829147, -1.80866668959131395e-05, -0.000256995153030317573, -5.65481784766486379e-07, -1.21863871949890772e-07*1./(1_MeV), 0, -1.80866668959131395e-05, 0.0290389824658632278, 1.0786176979882171e-06, 0.000633662510089911938, 1.54534038892845022e-09*1./(1_MeV), 0, -0.000256995153030317573, 1.0786176979882171e-06, 7.61563569540157914e-06, 3.04492679504856067e-08, 5.93032819545449155e-09*1./(1_MeV), 0, -5.65481784766486379e-07, 0.000633662510089911938, 3.04492679504856067e-08, 1.61353309522382915e-05, 6.0506063998423997e-11*1./(1_MeV), 0, -1.21863871949890772e-07*1./(1_MeV), 1.54534038892845022e-09*1./(1_MeV), 5.93032819545449155e-09*1./(1_MeV), 6.0506063998423997e-11*1./(1_MeV), 2.29128466200378966e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform42;
+ ActsSymMatrixD<3> rotMat42;
+ rotMat42 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform42.rotate(rotMat42);
+ transform42.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans42 = std::make_shared<const Transform3D>(transform42);
+ std::shared_ptr<PerigeeSurface> perigeeSurface42 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams42 = BoundParameters(tgContext, std::move(covMat42), params42, perigeeSurface42);
+ tracks.push_back(boundParams42);
+
+
+ // track 43 :
+ BoundVector params43;
+ params43 << 0.147156372666358948, 18.0601425170898438, -1.20425975322723389, 2.95313668251037598, 4.38562346971593797e-05*1./(1_MeV), 0;
+ Covariance covMat43;
+ covMat43 << 0.00227970955893397331, 0.00210539922327512233, -6.23386652157084843e-05, 1.62139833390343564e-06, -2.4710662537678873e-08*1./(1_MeV), 0, 0.00210539922327512233, 0.0987421199679374695, -4.43239956360880696e-05, 8.53623578378920762e-05, -2.894438650939545e-09*1./(1_MeV), 0, -6.23386652157084843e-05, -4.43239956360880696e-05, 1.78687150764744729e-06, -3.5153983375057298e-08, 1.14365278859331536e-09*1./(1_MeV), 0, 1.62139833390343564e-06, 8.53623578378920762e-05, -3.5153983375057298e-08, 7.69686039348016493e-08, -2.40912278559178251e-12*1./(1_MeV), 0, -2.4710662537678873e-08*1./(1_MeV), -2.894438650939545e-09*1./(1_MeV), 1.14365278859331536e-09*1./(1_MeV), -2.40912278559178251e-12*1./(1_MeV), 8.10338168094615341e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform43;
+ ActsSymMatrixD<3> rotMat43;
+ rotMat43 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform43.rotate(rotMat43);
+ transform43.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans43 = std::make_shared<const Transform3D>(transform43);
+ std::shared_ptr<PerigeeSurface> perigeeSurface43 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams43 = BoundParameters(tgContext, std::move(covMat43), params43, perigeeSurface43);
+ tracks.push_back(boundParams43);
+
+
+ // track 44 :
+ BoundVector params44;
+ params44 << -0.0293732546269893646, 19.8860263824462891, 1.95824682712554932, 0.870327293872833252, 0.000651221722364425659*1./(1_MeV), 0;
+ Covariance covMat44;
+ covMat44 << 0.00386394886299967766, 6.41084427899122564e-05, -0.000111475937760659882, 1.88781955782771875e-06, -8.13503642219718733e-08*1./(1_MeV), 0, 6.41084427899122564e-05, 0.0216643344610929489, -4.27457576030063133e-06, 0.000299667220913072709, 1.00583188544233463e-10*1./(1_MeV), 0, -0.000111475937760659882, -4.27457576030063133e-06, 3.30510965795838274e-06, -9.27711560515876557e-08, 4.0446540731261482e-09*1./(1_MeV), 0, 1.88781955782771875e-06, 0.000299667220913072709, -9.27711560515876557e-08, 4.72439432996907271e-06, -4.51255450632084092e-11*1./(1_MeV), 0, -8.13503642219718733e-08*1./(1_MeV), 1.00583188544233463e-10*1./(1_MeV), 4.0446540731261482e-09*1./(1_MeV), -4.51255450632084092e-11*1./(1_MeV), 1.23205209923149539e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform44;
+ ActsSymMatrixD<3> rotMat44;
+ rotMat44 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform44.rotate(rotMat44);
+ transform44.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans44 = std::make_shared<const Transform3D>(transform44);
+ std::shared_ptr<PerigeeSurface> perigeeSurface44 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams44 = BoundParameters(tgContext, std::move(covMat44), params44, perigeeSurface44);
+ tracks.push_back(boundParams44);
+
+
+ // track 45 :
+ BoundVector params45;
+ params45 << -0.00822580046951770782, 19.7521209716796875, -1.34217584133148193, 1.31352841854095459, -0.00102247926406562328*1./(1_MeV), 0;
+ Covariance covMat45;
+ covMat45 << 0.00437659770250320435, -7.97783766085815948e-05, -0.00012776433189490825, -9.58273275448513196e-07, -5.94526727131795577e-08*1./(1_MeV), 0, -7.97783766085815948e-05, 0.0161803290247917175, 2.97524849199130738e-06, 0.000292265113374019965, 2.18355646012064316e-10*1./(1_MeV), 0, -0.00012776433189490825, 2.97524849199130738e-06, 3.82176176572102122e-06, 4.43621833298063989e-08, 2.82001283990720967e-09*1./(1_MeV), 0, -9.58273275448513196e-07, 0.000292265113374019965, 4.43621833298063989e-08, 6.61718468109029345e-06, 2.39856062071632866e-11*1./(1_MeV), 0, -5.94526727131795577e-08*1./(1_MeV), 2.18355646012064316e-10*1./(1_MeV), 2.82001283990720967e-09*1./(1_MeV), 2.39856062071632866e-11*1./(1_MeV), 1.06083510031940165e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform45;
+ ActsSymMatrixD<3> rotMat45;
+ rotMat45 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform45.rotate(rotMat45);
+ transform45.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans45 = std::make_shared<const Transform3D>(transform45);
+ std::shared_ptr<PerigeeSurface> perigeeSurface45 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams45 = BoundParameters(tgContext, std::move(covMat45), params45, perigeeSurface45);
+ tracks.push_back(boundParams45);
+
+
+ // track 46 :
+ BoundVector params46;
+ params46 << -0.00361508713103830814, 19.4546413421630859, -1.30042552947998047, 1.05093002319335938, -0.00133425544481724501*1./(1_MeV), 0;
+ Covariance covMat46;
+ covMat46 << 0.00941458996385335922, -0.000284834152470895207, -0.000280442622898071389, -5.80468009022971626e-06, -1.41275786371003149e-07*1./(1_MeV), 0, -0.000284834152470895207, 0.0502648279070854187, 1.53948871197303823e-05, 0.000823507242403401945, -2.66165681844982257e-09*1./(1_MeV), 0, -0.000280442622898071389, 1.53948871197303823e-05, 8.5132569438428618e-06, 2.95341827559094638e-07, 6.98672628255231531e-09*1./(1_MeV), 0, -5.80468009022971626e-06, 0.000823507242403401945, 2.95341827559094638e-07, 1.44839359563775361e-05, -4.21371554939487073e-11*1./(1_MeV), 0, -1.41275786371003149e-07*1./(1_MeV), -2.66165681844982257e-09*1./(1_MeV), 6.98672628255231531e-09*1./(1_MeV), -4.21371554939487073e-11*1./(1_MeV), 2.45891834671496667e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform46;
+ ActsSymMatrixD<3> rotMat46;
+ rotMat46 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform46.rotate(rotMat46);
+ transform46.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans46 = std::make_shared<const Transform3D>(transform46);
+ std::shared_ptr<PerigeeSurface> perigeeSurface46 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams46 = BoundParameters(tgContext, std::move(covMat46), params46, perigeeSurface46);
+ tracks.push_back(boundParams46);
+
+
+ // track 47 :
+ BoundVector params47;
+ params47 << -0.0598590485751628876, 19.6531963348388672, 2.72643232345581055, 1.30785942077636719, -0.000780149712227284908*1./(1_MeV), 0;
+ Covariance covMat47;
+ covMat47 << 0.0032495234627276659, -4.04264250143772372e-05, -9.30744349600882211e-05, -5.0226893263358181e-07, -1.01375149269318418e-07*1./(1_MeV), 0, -4.04264250143772372e-05, 0.0112805059179663658, 1.30282082485754631e-06, 0.000209029656597159029, -7.2365790516280225e-09*1./(1_MeV), 0, -9.30744349600882211e-05, 1.30282082485754631e-06, 2.75341517408378422e-06, 2.1800386214469216e-08, 4.40769477853404022e-09*1./(1_MeV), 0, -5.0226893263358181e-07, 0.000209029656597159029, 2.1800386214469216e-08, 4.8472306843905244e-06, -9.06260666641051782e-11*1./(1_MeV), 0, -1.01375149269318418e-07*1./(1_MeV), -7.2365790516280225e-09*1./(1_MeV), 4.40769477853404022e-09*1./(1_MeV), -9.06260666641051782e-11*1./(1_MeV), 1.457364923185267e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform47;
+ ActsSymMatrixD<3> rotMat47;
+ rotMat47 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform47.rotate(rotMat47);
+ transform47.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans47 = std::make_shared<const Transform3D>(transform47);
+ std::shared_ptr<PerigeeSurface> perigeeSurface47 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams47 = BoundParameters(tgContext, std::move(covMat47), params47, perigeeSurface47);
+ tracks.push_back(boundParams47);
+
+
+ // track 48 :
+ BoundVector params48;
+ params48 << 0.0583043769001960754, 19.7832298278808594, -3.05185866355895996, 2.35133123397827148, 0.000652144546620547771*1./(1_MeV), 0;
+ Covariance covMat48;
+ covMat48 << 0.00455570640042424202, 2.27770645100975327e-05, -0.000134378354520968727, -9.98581163169078598e-07, -9.40610633214604794e-08*1./(1_MeV), 0, 2.27770645100975327e-05, 0.0258676018565893173, 3.21967957682574985e-06, 0.000300520679336246791, -1.35927009544720559e-09*1./(1_MeV), 0, -0.000134378354520968727, 3.21967957682574985e-06, 4.06873823521891609e-06, 7.29906365483080491e-08, 4.4846939744143286e-09*1./(1_MeV), 0, -9.98581163169078598e-07, 0.000300520679336246791, 7.29906365483080491e-08, 3.90696686736191623e-06, 4.80210416302676692e-12*1./(1_MeV), 0, -9.40610633214604794e-08*1./(1_MeV), -1.35927009544720559e-09*1./(1_MeV), 4.4846939744143286e-09*1./(1_MeV), 4.80210416302676692e-12*1./(1_MeV), 1.25072396883751935e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform48;
+ ActsSymMatrixD<3> rotMat48;
+ rotMat48 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform48.rotate(rotMat48);
+ transform48.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans48 = std::make_shared<const Transform3D>(transform48);
+ std::shared_ptr<PerigeeSurface> perigeeSurface48 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams48 = BoundParameters(tgContext, std::move(covMat48), params48, perigeeSurface48);
+ tracks.push_back(boundParams48);
+
+
+ // track 49 :
+ BoundVector params49;
+ params49 << 0.0794872790575027466, 19.6530551910400391, -0.165329158306121826, 0.773633182048797607, 0.000477823166875168681*1./(1_MeV), 0;
+ Covariance covMat49;
+ covMat49 << 0.00381630496121942997, -8.74287441500089918e-05, -0.000100106500619540973, -8.38715409757558135e-08, -6.2290859493643327e-08*1./(1_MeV), 0, -8.74287441500089918e-05, 0.0162235908210277557, 2.22223959083791618e-08, 0.000172105791708528197, 1.96493926730074329e-10*1./(1_MeV), 0, -0.000100106500619540973, 2.22223959083791618e-08, 2.75529328064294532e-06, -2.06184740167500454e-08, 2.69172215410859302e-09*1./(1_MeV), 0, -8.38715409757558135e-08, 0.000172105791708528197, -2.06184740167500454e-08, 2.09498148251441307e-06, 8.40879734889098381e-12*1./(1_MeV), 0, -6.2290859493643327e-08*1./(1_MeV), 1.96493926730074329e-10*1./(1_MeV), 2.69172215410859302e-09*1./(1_MeV), 8.40879734889098381e-12*1./(1_MeV), 6.77461420295344396e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform49;
+ ActsSymMatrixD<3> rotMat49;
+ rotMat49 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform49.rotate(rotMat49);
+ transform49.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans49 = std::make_shared<const Transform3D>(transform49);
+ std::shared_ptr<PerigeeSurface> perigeeSurface49 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams49 = BoundParameters(tgContext, std::move(covMat49), params49, perigeeSurface49);
+ tracks.push_back(boundParams49);
+
+
+ // track 50 :
+ BoundVector params50;
+ params50 << 0.00257234717719256878, 19.729034423828125, -2.48443388938903809, 2.36831569671630859, 0.000639270059764385223*1./(1_MeV), 0;
+ Covariance covMat50;
+ covMat50 << 0.00514977378770709038, 1.5274217220811411e-06, -0.000146212466763405544, -7.3820246046654258e-07, -9.37751309006686478e-08*1./(1_MeV), 0, 1.5274217220811411e-06, 0.0244287420064210892, 3.30349992626133354e-06, 0.000276546223727476613, -7.14985035003895647e-10*1./(1_MeV), 0, -0.000146212466763405544, 3.30349992626133354e-06, 4.3204604480706621e-06, 5.8973252791929605e-08, 4.5218636718828268e-09*1./(1_MeV), 0, -7.3820246046654258e-07, 0.000276546223727476613, 5.8973252791929605e-08, 3.42068551617558114e-06, -2.22231801612401744e-12*1./(1_MeV), 0, -9.37751309006686478e-08*1./(1_MeV), -7.14985035003895647e-10*1./(1_MeV), 4.5218636718828268e-09*1./(1_MeV), -2.22231801612401744e-12*1./(1_MeV), 1.24709936821787437e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform50;
+ ActsSymMatrixD<3> rotMat50;
+ rotMat50 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform50.rotate(rotMat50);
+ transform50.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans50 = std::make_shared<const Transform3D>(transform50);
+ std::shared_ptr<PerigeeSurface> perigeeSurface50 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams50 = BoundParameters(tgContext, std::move(covMat50), params50, perigeeSurface50);
+ tracks.push_back(boundParams50);
+
+
+ // track 51 :
+ BoundVector params51;
+ params51 << 0.00432245805859565735, 19.7588119506835938, 2.78170585632324219, 1.317923903465271, 0.000862165645230561495*1./(1_MeV), 0;
+ Covariance covMat51;
+ covMat51 << 0.00373272784054279327, -3.13153124378761361e-05, -0.000104918640992595442, 7.88207645809147621e-08, -5.3073184749102294e-08*1./(1_MeV), 0, -3.13153124378761361e-05, 0.014620266854763031, 4.37770160231162941e-09, 0.000248047817836983295, -1.07342837668986752e-09*1./(1_MeV), 0, -0.000104918640992595442, 4.37770160231162941e-09, 3.04561854136409238e-06, -1.80148965656686955e-08, 2.31705476916370874e-09*1./(1_MeV), 0, 7.88207645809147621e-08, 0.000248047817836983295, -1.80148965656686955e-08, 5.14808971274760552e-06, -2.17782802728119955e-11*1./(1_MeV), 0, -5.3073184749102294e-08*1./(1_MeV), -1.07342837668986752e-09*1./(1_MeV), 2.31705476916370874e-09*1./(1_MeV), -2.17782802728119955e-11*1./(1_MeV), 7.92517093617384205e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform51;
+ ActsSymMatrixD<3> rotMat51;
+ rotMat51 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform51.rotate(rotMat51);
+ transform51.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans51 = std::make_shared<const Transform3D>(transform51);
+ std::shared_ptr<PerigeeSurface> perigeeSurface51 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams51 = BoundParameters(tgContext, std::move(covMat51), params51, perigeeSurface51);
+ tracks.push_back(boundParams51);
+
+
+ // track 52 :
+ BoundVector params52;
+ params52 << -0.0435933880507946014, 19.7911624908447266, 3.11164975166320801, 2.34090805053710938, -0.000378097058273851871*1./(1_MeV), 0;
+ Covariance covMat52;
+ covMat52 << 0.00186390290036797523, 8.51901326696253696e-05, -5.26206213063089263e-05, 7.5721243893402984e-07, -3.6471728778736459e-08*1./(1_MeV), 0, 8.51901326696253696e-05, 0.0111065087839961052, -2.43677190069158359e-06, 0.00011281071944759972, -1.62019250256225185e-09*1./(1_MeV), 0, -5.26206213063089263e-05, -2.43677190069158359e-06, 1.54202029989392031e-06, -2.53458777355814022e-08, 1.63474855631190684e-09*1./(1_MeV), 0, 7.5721243893402984e-07, 0.00011281071944759972, -2.53458777355814022e-08, 1.39124506404186832e-06, -1.08965746715162531e-11*1./(1_MeV), 0, -3.6471728778736459e-08*1./(1_MeV), -1.62019250256225185e-09*1./(1_MeV), 1.63474855631190684e-09*1./(1_MeV), -1.08965746715162531e-11*1./(1_MeV), 4.23658642889623849e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform52;
+ ActsSymMatrixD<3> rotMat52;
+ rotMat52 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform52.rotate(rotMat52);
+ transform52.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans52 = std::make_shared<const Transform3D>(transform52);
+ std::shared_ptr<PerigeeSurface> perigeeSurface52 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams52 = BoundParameters(tgContext, std::move(covMat52), params52, perigeeSurface52);
+ tracks.push_back(boundParams52);
+
+
+ // track 53 :
+ BoundVector params53;
+ params53 << -0.0815948843955993652, 19.7372093200683594, -1.84946024417877197, 1.14923441410064697, 0.000601470586843788624*1./(1_MeV), 0;
+ Covariance covMat53;
+ covMat53 << 0.00196050899103283882, -1.67352628138899218e-05, -5.56634758072358207e-05, 3.7875159202534098e-07, -3.03494187297867561e-08*1./(1_MeV), 0, -1.67352628138899218e-05, 0.0112847397103905678, -1.93632011387631403e-07, 0.000171461400770045192, -2.16268131821945559e-09*1./(1_MeV), 0, -5.56634758072358207e-05, -1.93632011387631403e-07, 1.63677134423778625e-06, -2.31373868535455102e-08, 1.4041644457469446e-09*1./(1_MeV), 0, 3.7875159202534098e-07, 0.000171461400770045192, -2.31373868535455102e-08, 3.31649607687722892e-06, -5.16496243030849994e-11*1./(1_MeV), 0, -3.03494187297867561e-08*1./(1_MeV), -2.16268131821945559e-09*1./(1_MeV), 1.4041644457469446e-09*1./(1_MeV), -5.16496243030849994e-11*1./(1_MeV), 4.88036555612580969e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform53;
+ ActsSymMatrixD<3> rotMat53;
+ rotMat53 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform53.rotate(rotMat53);
+ transform53.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans53 = std::make_shared<const Transform3D>(transform53);
+ std::shared_ptr<PerigeeSurface> perigeeSurface53 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams53 = BoundParameters(tgContext, std::move(covMat53), params53, perigeeSurface53);
+ tracks.push_back(boundParams53);
+
+
+ // track 54 :
+ BoundVector params54;
+ params54 << -0.177310273051261902, 19.6348361968994141, -1.05560946464538574, 2.24611258506774902, -0.000753726519178599119*1./(1_MeV), 0;
+ Covariance covMat54;
+ covMat54 << 0.00495443679392337799, 0.000157203730621089283, -0.000141684325914573155, 2.30922207144066844e-06, -7.94592181976909059e-08*1./(1_MeV), 0, 0.000157203730621089283, 0.0229040328413248062, -6.34654599119513331e-06, 0.000306214725126755156, -1.2839975429398817e-09*1./(1_MeV), 0, -0.000141684325914573155, -6.34654599119513331e-06, 4.18058425566414371e-06, -9.91975383724877058e-08, 3.78214495931995838e-09*1./(1_MeV), 0, 2.30922207144066844e-06, 0.000306214725126755156, -9.91975383724877058e-08, 4.69660699309315532e-06, -2.63341946589812984e-11*1./(1_MeV), 0, -7.94592181976909059e-08*1./(1_MeV), -1.2839975429398817e-09*1./(1_MeV), 3.78214495931995838e-09*1./(1_MeV), -2.63341946589812984e-11*1./(1_MeV), 1.1374100272742993e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform54;
+ ActsSymMatrixD<3> rotMat54;
+ rotMat54 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform54.rotate(rotMat54);
+ transform54.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans54 = std::make_shared<const Transform3D>(transform54);
+ std::shared_ptr<PerigeeSurface> perigeeSurface54 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams54 = BoundParameters(tgContext, std::move(covMat54), params54, perigeeSurface54);
+ tracks.push_back(boundParams54);
+
+
+ // track 55 :
+ BoundVector params55;
+ params55 << 0.0785293355584144592, 19.6328811645507812, 2.59513092041015625, 2.38374710083007812, -0.000732663145754486322*1./(1_MeV), 0;
+ Covariance covMat55;
+ covMat55 << 0.00641396967694163322, 0.000246878889801438277, -0.000189181604721914515, 3.34410570581822042e-06, -2.14548746767764377e-07*1./(1_MeV), 0, 0.000246878889801438277, 0.0336174145340919495, -1.03550476761815197e-05, 0.000399278313453293142, -2.56304746534435936e-09*1./(1_MeV), 0, -0.000189181604721914515, -1.03550476761815197e-05, 5.75400417801574804e-06, -1.44846765580733777e-07, 1.06792194541960512e-08*1./(1_MeV), 0, 3.34410570581822042e-06, 0.000399278313453293142, -1.44846765580733777e-07, 5.08104403706965968e-06, -7.68042699731362161e-11*1./(1_MeV), 0, -2.14548746767764377e-07*1./(1_MeV), -2.56304746534435936e-09*1./(1_MeV), 1.06792194541960512e-08*1./(1_MeV), -7.68042699731362161e-11*1./(1_MeV), 2.95886121159938398e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform55;
+ ActsSymMatrixD<3> rotMat55;
+ rotMat55 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform55.rotate(rotMat55);
+ transform55.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans55 = std::make_shared<const Transform3D>(transform55);
+ std::shared_ptr<PerigeeSurface> perigeeSurface55 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams55 = BoundParameters(tgContext, std::move(covMat55), params55, perigeeSurface55);
+ tracks.push_back(boundParams55);
+
+
+ // track 56 :
+ BoundVector params56;
+ params56 << 0.0173604916781187057, 19.5246124267578125, -2.51582574844360352, 0.414047539234161377, -0.00071090972051024437*1./(1_MeV), 0;
+ Covariance covMat56;
+ covMat56 << 0.0283498577773571014, -0.000298887250477381634, -0.000882125049864636171, -6.77869111648309038e-06, -5.9098209889401522e-07*1./(1_MeV), 0, -0.000298887250477381634, 0.192199692130088806, 4.3839556454493579e-05, 0.000923672206091380129, -1.8091079261186684e-08*1./(1_MeV), 0, -0.000882125049864636171, 4.3839556454493579e-05, 2.79919677268480882e-05, 3.80641892247414598e-07, 3.08266368106537475e-08*1./(1_MeV), 0, -6.77869111648309038e-06, 0.000923672206091380129, 3.80641892247414598e-07, 4.52563699582242407e-06, 3.57023520457822254e-12*1./(1_MeV), 0, -5.9098209889401522e-07*1./(1_MeV), -1.8091079261186684e-08*1./(1_MeV), 3.08266368106537475e-08*1./(1_MeV), 3.57023520457822254e-12*1./(1_MeV), 5.16008458184558094e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform56;
+ ActsSymMatrixD<3> rotMat56;
+ rotMat56 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform56.rotate(rotMat56);
+ transform56.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans56 = std::make_shared<const Transform3D>(transform56);
+ std::shared_ptr<PerigeeSurface> perigeeSurface56 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams56 = BoundParameters(tgContext, std::move(covMat56), params56, perigeeSurface56);
+ tracks.push_back(boundParams56);
+
+
+ // track 57 :
+ BoundVector params57;
+ params57 << -0.112078636884689331, 19.7138767242431641, -1.84679484367370605, 0.794435799121856689, -0.00114586413837969303*1./(1_MeV), 0;
+ Covariance covMat57;
+ covMat57 << 0.0125628607347607613, -0.00042401806910040711, -0.000382159145328276348, -7.02945588660621349e-06, -2.92791162690266574e-07*1./(1_MeV), 0, -0.00042401806910040711, 0.0519770048558712006, 2.22396418071489764e-05, 0.000696764565518564701, 2.67979975211747671e-10*1./(1_MeV), 0, -0.000382159145328276348, 2.22396418071489764e-05, 1.18492389447055757e-05, 3.53736964679786492e-07, 1.47490199626806416e-08*1./(1_MeV), 0, -7.02945588660621349e-06, 0.000696764565518564701, 3.53736964679786492e-07, 9.91684009932214394e-06, 3.12549388487418662e-11*1./(1_MeV), 0, -2.92791162690266574e-07*1./(1_MeV), 2.67979975211747671e-10*1./(1_MeV), 1.47490199626806416e-08*1./(1_MeV), 3.12549388487418662e-11*1./(1_MeV), 4.27830326721334586e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform57;
+ ActsSymMatrixD<3> rotMat57;
+ rotMat57 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform57.rotate(rotMat57);
+ transform57.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans57 = std::make_shared<const Transform3D>(transform57);
+ std::shared_ptr<PerigeeSurface> perigeeSurface57 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams57 = BoundParameters(tgContext, std::move(covMat57), params57, perigeeSurface57);
+ tracks.push_back(boundParams57);
+
+
+ // track 58 :
+ BoundVector params58;
+ params58 << -0.0965623259544372559, 19.6627426147460938, -1.23312962055206299, 0.805159807205200195, -0.000906686065718531609*1./(1_MeV), 0;
+ Covariance covMat58;
+ covMat58 << 0.00830374658107757568, -0.000373302939962240744, -0.000247266029281000856, -5.00495608162803572e-06, -2.0945470573896415e-07*1./(1_MeV), 0, -0.000373302939962240744, 0.0380906462669372559, 1.53532999294112871e-05, 0.000496518269343126733, 5.03471984032882939e-09*1./(1_MeV), 0, -0.000247266029281000856, 1.53532999294112871e-05, 7.52212054067058489e-06, 2.17835177699819493e-07, 9.95587606736010666e-09*1./(1_MeV), 0, -5.00495608162803572e-06, 0.000496518269343126733, 2.17835177699819493e-07, 6.91647301209741272e-06, 8.81431839589435575e-11*1./(1_MeV), 0, -2.0945470573896415e-07*1./(1_MeV), 5.03471984032882939e-09*1./(1_MeV), 9.95587606736010666e-09*1./(1_MeV), 8.81431839589435575e-11*1./(1_MeV), 2.77544126570106187e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform58;
+ ActsSymMatrixD<3> rotMat58;
+ rotMat58 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform58.rotate(rotMat58);
+ transform58.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans58 = std::make_shared<const Transform3D>(transform58);
+ std::shared_ptr<PerigeeSurface> perigeeSurface58 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams58 = BoundParameters(tgContext, std::move(covMat58), params58, perigeeSurface58);
+ tracks.push_back(boundParams58);
+
+
+ // track 59 :
+ BoundVector params59;
+ params59 << -0.0626908987760543823, 19.7716445922851562, -2.40555191040039062, 2.8678133487701416, -0.000198848822037689388*1./(1_MeV), 0;
+ Covariance covMat59;
+ covMat59 << 0.00839335378259420395, 0.000910603415829014081, -0.00025100860818204118, 1.87096007159414942e-06, -9.31870020461924718e-08*1./(1_MeV), 0, 0.000910603415829014081, 0.129513055086135864, -2.86761617086296627e-05, 0.000273189216280241291, -4.74956078553265506e-09*1./(1_MeV), 0, -0.00025100860818204118, -2.86761617086296627e-05, 7.71244413044769317e-06, -6.31332272284558137e-08, 4.62778036643537694e-09*1./(1_MeV), 0, 1.87096007159414942e-06, 0.000273189216280241291, -6.31332272284558137e-08, 5.91468733546207659e-07, -9.64516546051573345e-12*1./(1_MeV), 0, -9.31870020461924718e-08*1./(1_MeV), -4.74956078553265506e-09*1./(1_MeV), 4.62778036643537694e-09*1./(1_MeV), -9.64516546051573345e-12*1./(1_MeV), 5.01616283232753091e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform59;
+ ActsSymMatrixD<3> rotMat59;
+ rotMat59 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform59.rotate(rotMat59);
+ transform59.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans59 = std::make_shared<const Transform3D>(transform59);
+ std::shared_ptr<PerigeeSurface> perigeeSurface59 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams59 = BoundParameters(tgContext, std::move(covMat59), params59, perigeeSurface59);
+ tracks.push_back(boundParams59);
+
+
+ // track 60 :
+ BoundVector params60;
+ params60 << -0.0142064439132809639, 19.7910060882568359, 0.168578088283538818, 0.479709357023239136, -0.000404727092245593667*1./(1_MeV), 0;
+ Covariance covMat60;
+ covMat60 << 0.00775946257635951042, -0.000358691551729211646, -0.000217197427685534829, -2.56510932869304508e-06, -7.90923951223065759e-08*1./(1_MeV), 0, -0.000358691551729211646, 0.052836686372756958, 1.3965907239243096e-05, 0.000293662591417361029, 3.13017533889238816e-10*1./(1_MeV), 0, -0.000217197427685534829, 1.3965907239243096e-05, 6.26508744971943088e-06, 9.72321745154080499e-08, 3.84228193539540777e-09*1./(1_MeV), 0, -2.56510932869304508e-06, 0.000293662591417361029, 9.72321745154080499e-08, 1.70067016824759776e-06, 6.77559228363657895e-12*1./(1_MeV), 0, -7.90923951223065759e-08*1./(1_MeV), 3.13017533889238816e-10*1./(1_MeV), 3.84228193539540777e-09*1./(1_MeV), 6.77559228363657895e-12*1./(1_MeV), 6.94686808078159856e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform60;
+ ActsSymMatrixD<3> rotMat60;
+ rotMat60 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform60.rotate(rotMat60);
+ transform60.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans60 = std::make_shared<const Transform3D>(transform60);
+ std::shared_ptr<PerigeeSurface> perigeeSurface60 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams60 = BoundParameters(tgContext, std::move(covMat60), params60, perigeeSurface60);
+ tracks.push_back(boundParams60);
+
+
+ // track 61 :
+ BoundVector params61;
+ params61 << -0.219206094741821289, 20.4783496856689453, -0.292800366878509521, 2.68957734107971191, -0.000572857388760894537*1./(1_MeV), 0;
+ Covariance covMat61;
+ covMat61 << 0.0146720772609114647, 0.000633603948713714737, -0.000435564556254993611, 4.1380172183317663e-06, -1.65861978224238241e-07*1./(1_MeV), 0, 0.000633603948713714737, 0.0937191098928451538, -3.01445904596889702e-05, 0.000503828587046026917, 9.92026904049769552e-10*1./(1_MeV), 0, -0.000435564556254993611, -3.01445904596889702e-05, 1.31324359244899824e-05, -1.88451279319618993e-07, 8.03478199107072473e-09*1./(1_MeV), 0, 4.1380172183317663e-06, 0.000503828587046026917, -1.88451279319618993e-07, 2.77083131550170947e-06, 3.79284582712100777e-12*1./(1_MeV), 0, -1.65861978224238241e-07*1./(1_MeV), 9.92026904049769552e-10*1./(1_MeV), 8.03478199107072473e-09*1./(1_MeV), 3.79284582712100777e-12*1./(1_MeV), 1.37340042116740335e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform61;
+ ActsSymMatrixD<3> rotMat61;
+ rotMat61 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform61.rotate(rotMat61);
+ transform61.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans61 = std::make_shared<const Transform3D>(transform61);
+ std::shared_ptr<PerigeeSurface> perigeeSurface61 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams61 = BoundParameters(tgContext, std::move(covMat61), params61, perigeeSurface61);
+ tracks.push_back(boundParams61);
+
+
+ // track 62 :
+ BoundVector params62;
+ params62 << 0.0636809840798377991, 19.6062507629394531, 0.571447312831878662, 0.867952585220336914, 0.00121437374036759138*1./(1_MeV), 0;
+ Covariance covMat62;
+ covMat62 << 0.0128781227394938469, 0.000273969979431750051, -0.000375215863743342181, 8.19368995942778944e-06, -3.39195297106111847e-07*1./(1_MeV), 0, 0.000273969979431750051, 0.0600576512515544891, -2.2149498630265022e-05, 0.000888745641943021122, -2.03770348687604627e-09*1./(1_MeV), 0, -0.000375215863743342181, -2.2149498630265022e-05, 1.11544741230318323e-05, -4.44362300871132803e-07, 1.59093394709295358e-08*1./(1_MeV), 0, 8.19368995942778944e-06, 0.000888745641943021122, -4.44362300871132803e-07, 1.38034411065746099e-05, -1.03151432469073304e-10*1./(1_MeV), 0, -3.39195297106111847e-07*1./(1_MeV), -2.03770348687604627e-09*1./(1_MeV), 1.59093394709295358e-08*1./(1_MeV), -1.03151432469073304e-10*1./(1_MeV), 4.62565652448176934e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform62;
+ ActsSymMatrixD<3> rotMat62;
+ rotMat62 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform62.rotate(rotMat62);
+ transform62.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans62 = std::make_shared<const Transform3D>(transform62);
+ std::shared_ptr<PerigeeSurface> perigeeSurface62 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams62 = BoundParameters(tgContext, std::move(covMat62), params62, perigeeSurface62);
+ tracks.push_back(boundParams62);
+
+
+ // track 63 :
+ BoundVector params63;
+ params63 << 0.256703495979309082, 20.4742660522460938, 2.0388495922088623, 0.835670650005340576, -0.00106730952393263578*1./(1_MeV), 0;
+ Covariance covMat63;
+ covMat63 << 0.00996344629675149918, -0.000111380282247894335, -0.000297672988748523071, -4.10640820399169642e-06, -2.92419518098666387e-07*1./(1_MeV), 0, -0.000111380282247894335, 0.0370076149702072144, 9.57343920283051857e-06, 0.000522519448946792003, -7.68861322556322209e-09*1./(1_MeV), 0, -0.000297672988748523071, 9.57343920283051857e-06, 9.07736284716520458e-06, 2.19650252980074214e-07, 1.46923783244468664e-08*1./(1_MeV), 0, -4.10640820399169642e-06, 0.000522519448946792003, 2.19650252980074214e-07, 7.87897715781582519e-06, -2.63692280030132723e-11*1./(1_MeV), 0, -2.92419518098666387e-07*1./(1_MeV), -7.68861322556322209e-09*1./(1_MeV), 1.46923783244468664e-08*1./(1_MeV), -2.63692280030132723e-11*1./(1_MeV), 4.39882824609938439e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform63;
+ ActsSymMatrixD<3> rotMat63;
+ rotMat63 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform63.rotate(rotMat63);
+ transform63.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans63 = std::make_shared<const Transform3D>(transform63);
+ std::shared_ptr<PerigeeSurface> perigeeSurface63 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams63 = BoundParameters(tgContext, std::move(covMat63), params63, perigeeSurface63);
+ tracks.push_back(boundParams63);
+
+
+ // track 64 :
+ BoundVector params64;
+ params64 << 0.120990529656410217, 19.6643028259277344, 2.09903669357299805, 0.376666009426116943, 0.000600203988142311573*1./(1_MeV), 0;
+ Covariance covMat64;
+ covMat64 << 0.0291396286338567734, 5.39021723134598197e-05, -0.000882721168274605778, 4.14864371809709873e-06, -5.5001142494950611e-07*1./(1_MeV), 0, 5.39021723134598197e-05, 0.234371468424797058, -4.16871244043210621e-05, 0.000918528875032399673, 1.39816410013920925e-08*1./(1_MeV), 0, -0.000882721168274605778, -4.16871244043210621e-05, 2.72563647740753368e-05, -2.79753257845384789e-07, 2.7634673800087543e-08*1./(1_MeV), 0, 4.14864371809709873e-06, 0.000918528875032399673, -2.79753257845384789e-07, 3.6635033211496193e-06, 1.58046165958546609e-11*1./(1_MeV), 0, -5.5001142494950611e-07*1./(1_MeV), 1.39816410013920925e-08*1./(1_MeV), 2.7634673800087543e-08*1./(1_MeV), 1.58046165958546609e-11*1./(1_MeV), 4.08823086495146981e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform64;
+ ActsSymMatrixD<3> rotMat64;
+ rotMat64 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform64.rotate(rotMat64);
+ transform64.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans64 = std::make_shared<const Transform3D>(transform64);
+ std::shared_ptr<PerigeeSurface> perigeeSurface64 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams64 = BoundParameters(tgContext, std::move(covMat64), params64, perigeeSurface64);
+ tracks.push_back(boundParams64);
+
+
+ // track 65 :
+ BoundVector params65;
+ params65 << 0.0062864348292350769, 19.6056728363037109, 1.96336662769317627, 1.67587447166442871, -0.00098716001957654953*1./(1_MeV), 0;
+ Covariance covMat65;
+ covMat65 << 0.00639463262632489204, 2.92739463404503888e-05, -0.000162262223266041843, 7.35056423966357298e-07, -6.22851560331579401e-08*1./(1_MeV), 0, 2.92739463404503888e-05, 0.0197239704430103302, -1.20671194756186941e-06, 0.000422495468900870442, -7.46651628897230336e-10*1./(1_MeV), 0, -0.000162262223266041843, -1.20671194756186941e-06, 4.31130820288672112e-06, -3.10329014828531918e-08, 2.84192773413970349e-09*1./(1_MeV), 0, 7.35056423966357298e-07, 0.000422495468900870442, -3.10329014828531918e-08, 1.06411953311180696e-05, -4.82012337741633492e-13*1./(1_MeV), 0, -6.22851560331579401e-08*1./(1_MeV), -7.46651628897230336e-10*1./(1_MeV), 2.84192773413970349e-09*1./(1_MeV), -4.82012337741633492e-13*1./(1_MeV), 1.05485536971983151e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform65;
+ ActsSymMatrixD<3> rotMat65;
+ rotMat65 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform65.rotate(rotMat65);
+ transform65.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans65 = std::make_shared<const Transform3D>(transform65);
+ std::shared_ptr<PerigeeSurface> perigeeSurface65 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams65 = BoundParameters(tgContext, std::move(covMat65), params65, perigeeSurface65);
+ tracks.push_back(boundParams65);
+
+
+ // track 66 :
+ BoundVector params66;
+ params66 << 0.0955945327877998352, 20.2347850799560547, -0.327246248722076416, 2.98204421997070312, 2.21292903006542474e-05*1./(1_MeV), 0;
+ Covariance covMat66;
+ covMat66 << 0.00150146521627902985, 0.0023395733708214345, -3.76246492337360715e-05, 1.20517570859588883e-06, -1.54414914830204655e-08*1./(1_MeV), 0, 0.0023395733708214345, 0.0877117365598678589, -4.71741381729428471e-05, 5.21609361100870518e-05, 3.25177228611905034e-10*1./(1_MeV), 0, -3.76246492337360715e-05, -4.71741381729428471e-05, 1.0044809641840402e-06, -2.48049212962453205e-08, 6.86903087291782125e-10*1./(1_MeV), 0, 1.20517570859588883e-06, 5.21609361100870518e-05, -2.48049212962453205e-08, 3.23552171721530613e-08, 2.29084759303353043e-13*1./(1_MeV), 0, -1.54414914830204655e-08*1./(1_MeV), 3.25177228611905034e-10*1./(1_MeV), 6.86903087291782125e-10*1./(1_MeV), 2.29084759303353043e-13*1./(1_MeV), 3.96015121736925657e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform66;
+ ActsSymMatrixD<3> rotMat66;
+ rotMat66 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform66.rotate(rotMat66);
+ transform66.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans66 = std::make_shared<const Transform3D>(transform66);
+ std::shared_ptr<PerigeeSurface> perigeeSurface66 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams66 = BoundParameters(tgContext, std::move(covMat66), params66, perigeeSurface66);
+ tracks.push_back(boundParams66);
+
+
+ // track 67 :
+ BoundVector params67;
+ params67 << 0.382039725780487061, 20.0302467346191406, 1.78882849216461182, 2.7296445369720459, 0.000560962012968957424*1./(1_MeV), 0;
+ Covariance covMat67;
+ covMat67 << 0.0185648687183856964, -0.000512420938441797555, -0.000564488122844988122, -3.46646347767409226e-06, -6.9752293121264101e-07*1./(1_MeV), 0, -0.000512420938441797555, 0.158824682235717773, 4.20228128232319107e-05, 0.000710107550351205766, 5.56717392340507163e-09*1./(1_MeV), 0, -0.000564488122844988122, 4.20228128232319107e-05, 1.76464527612552047e-05, 2.17145732577765049e-07, 3.41404923239805513e-08*1./(1_MeV), 0, -3.46646347767409226e-06, 0.000710107550351205766, 2.17145732577765049e-07, 3.26669078276609071e-06, -1.08290629522060115e-11*1./(1_MeV), 0, -6.9752293121264101e-07*1./(1_MeV), 5.56717392340507163e-09*1./(1_MeV), 3.41404923239805513e-08*1./(1_MeV), -1.08290629522060115e-11*1./(1_MeV), 5.43119271778635948e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform67;
+ ActsSymMatrixD<3> rotMat67;
+ rotMat67 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform67.rotate(rotMat67);
+ transform67.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans67 = std::make_shared<const Transform3D>(transform67);
+ std::shared_ptr<PerigeeSurface> perigeeSurface67 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams67 = BoundParameters(tgContext, std::move(covMat67), params67, perigeeSurface67);
+ tracks.push_back(boundParams67);
+
+
+ // track 68 :
+ BoundVector params68;
+ params68 << -0.179121747612953186, 20.2514362335205078, -0.862554371356964111, 2.68916535377502441, -0.000457327318144962192*1./(1_MeV), 0;
+ Covariance covMat68;
+ covMat68 << 0.0108809741213917732, 0.00193338631898851772, -0.000310007020929202329, 8.43655106315042699e-06, -1.10126677038094219e-07*1./(1_MeV), 0, 0.00193338631898851772, 0.0997641086578369141, -5.31462636732746974e-05, 0.000479126202409259187, -3.00325838913588194e-09*1./(1_MeV), 0, -0.000310007020929202329, -5.31462636732746974e-05, 9.10317794478032738e-06, -2.45896355006014845e-07, 5.3026650853642868e-09*1./(1_MeV), 0, 8.43655106315042699e-06, 0.000479126202409259187, -2.45896355006014845e-07, 2.40905660575663205e-06, -1.12621932829046352e-11*1./(1_MeV), 0, -1.10126677038094219e-07*1./(1_MeV), -3.00325838913588194e-09*1./(1_MeV), 5.3026650853642868e-09*1./(1_MeV), -1.12621932829046352e-11*1./(1_MeV), 9.04395031087190659e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform68;
+ ActsSymMatrixD<3> rotMat68;
+ rotMat68 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform68.rotate(rotMat68);
+ transform68.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans68 = std::make_shared<const Transform3D>(transform68);
+ std::shared_ptr<PerigeeSurface> perigeeSurface68 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams68 = BoundParameters(tgContext, std::move(covMat68), params68, perigeeSurface68);
+ tracks.push_back(boundParams68);
+
+
+ // track 69 :
+ BoundVector params69;
+ params69 << -0.138331592082977295, 19.3751182556152344, -1.35278940200805664, 0.381486982107162476, -0.000426069716922938824*1./(1_MeV), 0;
+ Covariance covMat69;
+ covMat69 << 0.0138281593099236488, -0.000802064074892135472, -0.000420553068714103143, -3.62152568304627602e-06, -1.71446784106220126e-07*1./(1_MeV), 0, -0.000802064074892135472, 0.124462626874446869, 3.35644323921618966e-05, 0.000489752797097319013, 1.53338361947342647e-09*1./(1_MeV), 0, -0.000420553068714103143, 3.35644323921618966e-05, 1.3009085705562029e-05, 1.52739817453807061e-07, 8.51389247727636405e-09*1./(1_MeV), 0, -3.62152568304627602e-06, 0.000489752797097319013, 1.52739817453807061e-07, 1.98223324332502671e-06, 7.74913828351229925e-12*1./(1_MeV), 0, -1.71446784106220126e-07*1./(1_MeV), 1.53338361947342647e-09*1./(1_MeV), 8.51389247727636405e-09*1./(1_MeV), 7.74913828351229925e-12*1./(1_MeV), 1.26564134173001719e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform69;
+ ActsSymMatrixD<3> rotMat69;
+ rotMat69 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform69.rotate(rotMat69);
+ transform69.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans69 = std::make_shared<const Transform3D>(transform69);
+ std::shared_ptr<PerigeeSurface> perigeeSurface69 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams69 = BoundParameters(tgContext, std::move(covMat69), params69, perigeeSurface69);
+ tracks.push_back(boundParams69);
+
+
+ // track 70 :
+ BoundVector params70;
+ params70 << -0.0937596634030342102, 19.4900455474853516, -0.352513551712036133, 2.89332342147827148, -0.000186513439984992146*1./(1_MeV), 0;
+ Covariance covMat70;
+ covMat70 << 0.0097403964027762413, 0.00166471584749119505, -0.000287947885317068881, 2.55751055140476181e-06, -7.81118139203814757e-08*1./(1_MeV), 0, 0.00166471584749119505, 0.204256042838096619, -4.79791071918836e-05, 0.000340033153539362216, -1.95895871236344388e-09*1./(1_MeV), 0, -0.000287947885317068881, -4.79791071918836e-05, 8.6775098679936491e-06, -7.89068829617864185e-08, 3.73986494276367498e-09*1./(1_MeV), 0, 2.55751055140476181e-06, 0.000340033153539362216, -7.89068829617864185e-08, 5.8173242223347188e-07, -3.34422452468073519e-12*1./(1_MeV), 0, -7.81118139203814757e-08*1./(1_MeV), -1.95895871236344388e-09*1./(1_MeV), 3.73986494276367498e-09*1./(1_MeV), -3.34422452468073519e-12*1./(1_MeV), 3.56935557499493683e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform70;
+ ActsSymMatrixD<3> rotMat70;
+ rotMat70 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform70.rotate(rotMat70);
+ transform70.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans70 = std::make_shared<const Transform3D>(transform70);
+ std::shared_ptr<PerigeeSurface> perigeeSurface70 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams70 = BoundParameters(tgContext, std::move(covMat70), params70, perigeeSurface70);
+ tracks.push_back(boundParams70);
+
+
+ // track 71 :
+ BoundVector params71;
+ params71 << -0.031271662563085556, 19.7582015991210938, -0.544847011566162109, 2.35719013214111328, -0.00060985935851931572*1./(1_MeV), 0;
+ Covariance covMat71;
+ covMat71 << 0.00421266257762908936, 0.000139259250319359563, -0.000121986267999964622, 1.59459282051017784e-06, -9.93183532021228265e-08*1./(1_MeV), 0, 0.000139259250319359563, 0.0205928590148687363, -5.36726063219632336e-06, 0.000232703689853152397, -3.11346553982713454e-10*1./(1_MeV), 0, -0.000121986267999964622, -5.36726063219632336e-06, 3.63290769200830255e-06, -6.68725223656711701e-08, 4.73213336870042294e-09*1./(1_MeV), 0, 1.59459282051017784e-06, 0.000232703689853152397, -6.68725223656711701e-08, 2.95713130071817432e-06, -1.25499234028196558e-11*1./(1_MeV), 0, -9.93183532021228265e-08*1./(1_MeV), -3.11346553982713454e-10*1./(1_MeV), 4.73213336870042294e-09*1./(1_MeV), -1.25499234028196558e-11*1./(1_MeV), 1.28399915699795031e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform71;
+ ActsSymMatrixD<3> rotMat71;
+ rotMat71 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform71.rotate(rotMat71);
+ transform71.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans71 = std::make_shared<const Transform3D>(transform71);
+ std::shared_ptr<PerigeeSurface> perigeeSurface71 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams71 = BoundParameters(tgContext, std::move(covMat71), params71, perigeeSurface71);
+ tracks.push_back(boundParams71);
+
+
+ // track 72 :
+ BoundVector params72;
+ params72 << -0.00558616593480110168, 19.7915973663330078, -1.90661561489105225, 2.65805935859680176, -0.000252252968493849039*1./(1_MeV), 0;
+ Covariance covMat72;
+ covMat72 << 0.00278375041671097279, 0.000178787135861017661, -8.12352454224075254e-05, 9.80445612301050583e-07, -3.12103239377841498e-08*1./(1_MeV), 0, 0.000178787135861017661, 0.0250813495367765427, -5.34047004847387823e-06, 0.000133613120646069154, -5.47170798097926544e-10*1./(1_MeV), 0, -8.12352454224075254e-05, -5.34047004847387823e-06, 2.44281318373396061e-06, -3.22686132104606899e-08, 1.51340031297866715e-09*1./(1_MeV), 0, 9.80445612301050583e-07, 0.000133613120646069154, -3.22686132104606899e-08, 7.69510791087668622e-07, -3.66374332111759326e-12*1./(1_MeV), 0, -3.12103239377841498e-08*1./(1_MeV), -5.47170798097926544e-10*1./(1_MeV), 1.51340031297866715e-09*1./(1_MeV), -3.66374332111759326e-12*1./(1_MeV), 2.74491956941957937e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform72;
+ ActsSymMatrixD<3> rotMat72;
+ rotMat72 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform72.rotate(rotMat72);
+ transform72.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans72 = std::make_shared<const Transform3D>(transform72);
+ std::shared_ptr<PerigeeSurface> perigeeSurface72 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams72 = BoundParameters(tgContext, std::move(covMat72), params72, perigeeSurface72);
+ tracks.push_back(boundParams72);
+
+
+ // track 73 :
+ BoundVector params73;
+ params73 << -0.442154228687286377, 17.9542407989501953, 2.09526467323303223, 2.94595146179199219, -0.000162040654686279595*1./(1_MeV), 0;
+ Covariance covMat73;
+ covMat73 << 0.0148460650816559792, 0.00184244940568953006, -0.000449961931621142613, 1.29765535410889532e-06, -2.30827454176528137e-07*1./(1_MeV), 0, 0.00184244940568953006, 0.471974313259124756, -6.98775671258470389e-05, 0.000523674191842157626, -2.19369371696834795e-08*1./(1_MeV), 0, -0.000449961931621142613, -6.98775671258470389e-05, 1.40490355988731608e-05, -5.73058129070942768e-08, 1.17830493253825561e-08*1./(1_MeV), 0, 1.29765535410889532e-06, 0.000523674191842157626, -5.73058129070942768e-08, 5.89256046623631846e-07, -2.53371790794750309e-12*1./(1_MeV), 0, -2.30827454176528137e-07*1./(1_MeV), -2.19369371696834795e-08*1./(1_MeV), 1.17830493253825561e-08*1./(1_MeV), -2.53371790794750309e-12*1./(1_MeV), 9.43526715091458357e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform73;
+ ActsSymMatrixD<3> rotMat73;
+ rotMat73 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform73.rotate(rotMat73);
+ transform73.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans73 = std::make_shared<const Transform3D>(transform73);
+ std::shared_ptr<PerigeeSurface> perigeeSurface73 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams73 = BoundParameters(tgContext, std::move(covMat73), params73, perigeeSurface73);
+ tracks.push_back(boundParams73);
+
+
+ // track 74 :
+ BoundVector params74;
+ params74 << 0.11471288651227951, 19.0564899444580078, -0.177579745650291443, 2.49515652656555176, 0.000924068794120103121*1./(1_MeV), 0;
+ Covariance covMat74;
+ covMat74 << 0.0152982324361801147, 4.68616789410272773e-05, -0.000446912018709990798, -2.64518724116447377e-06, -3.35403806382200683e-07*1./(1_MeV), 0, 4.68616789410272773e-05, 0.057605259120464325, 1.24210046721730033e-05, 0.00055778648850193823, -7.16971922823788445e-09*1./(1_MeV), 0, -0.000446912018709990798, 1.24210046721730033e-05, 1.33806315716356039e-05, 2.06818269256773686e-07, 1.64730542670120641e-08*1./(1_MeV), 0, -2.64518724116447377e-06, 0.00055778648850193823, 2.06818269256773686e-07, 5.62562490813434124e-06, -2.99011952126558051e-11*1./(1_MeV), 0, -3.35403806382200683e-07*1./(1_MeV), -7.16971922823788445e-09*1./(1_MeV), 1.64730542670120641e-08*1./(1_MeV), -2.99011952126558051e-11*1./(1_MeV), 3.94437649209322672e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform74;
+ ActsSymMatrixD<3> rotMat74;
+ rotMat74 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform74.rotate(rotMat74);
+ transform74.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans74 = std::make_shared<const Transform3D>(transform74);
+ std::shared_ptr<PerigeeSurface> perigeeSurface74 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams74 = BoundParameters(tgContext, std::move(covMat74), params74, perigeeSurface74);
+ tracks.push_back(boundParams74);
+
+
+ // track 75 :
+ BoundVector params75;
+ params75 << -0.00944441463798284531, 19.5482063293457031, 1.26532316207885742, 1.51080191135406494, 0.00125105178449302912*1./(1_MeV), 0;
+ Covariance covMat75;
+ covMat75 << 0.00673942035064101219, 1.09700537457738396e-05, -0.000191837249175310959, 3.98609880544513471e-07, -1.16410980841974866e-07*1./(1_MeV), 0, 1.09700537457738396e-05, 0.030988229438662529, -8.21095175946172576e-07, 0.000558048897263842877, -1.58105556275077154e-09*1./(1_MeV), 0, -0.000191837249175310959, -8.21095175946172576e-07, 5.58653619009419344e-06, -2.21237754371518524e-08, 5.54159050773939158e-09*1./(1_MeV), 0, 3.98609880544513471e-07, 0.000558048897263842877, -2.21237754371518524e-08, 1.262055775441695e-05, -2.73377636711205828e-11*1./(1_MeV), 0, -1.16410980841974866e-07*1./(1_MeV), -1.58105556275077154e-09*1./(1_MeV), 5.54159050773939158e-09*1./(1_MeV), -2.73377636711205828e-11*1./(1_MeV), 2.14180881363823516e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform75;
+ ActsSymMatrixD<3> rotMat75;
+ rotMat75 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform75.rotate(rotMat75);
+ transform75.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans75 = std::make_shared<const Transform3D>(transform75);
+ std::shared_ptr<PerigeeSurface> perigeeSurface75 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams75 = BoundParameters(tgContext, std::move(covMat75), params75, perigeeSurface75);
+ tracks.push_back(boundParams75);
+
+
+ // track 76 :
+ BoundVector params76;
+ params76 << 0.00483211036771535873, 19.769775390625, -0.868091702461242676, 2.3166813850402832, 0.000847792427521198988*1./(1_MeV), 0;
+ Covariance covMat76;
+ covMat76 << 0.00812008138746023178, 0.000241684869612282343, -0.000229342880415569957, 1.22350455006491968e-07, -1.51766456677205247e-07*1./(1_MeV), 0, 0.000241684869612282343, 0.0279842410236597061, -1.67820530316218224e-08, 0.000371614228093685849, -3.38119498984475317e-09*1./(1_MeV), 0, -0.000229342880415569957, -1.67820530316218224e-08, 6.68844677420565858e-06, 7.68954602593033632e-08, 6.98338608547542169e-09*1./(1_MeV), 0, 1.22350455006491968e-07, 0.000371614228093685849, 7.68954602593033632e-08, 5.40870951226679608e-06, 3.18987477267544148e-12*1./(1_MeV), 0, -1.51766456677205247e-07*1./(1_MeV), -3.38119498984475317e-09*1./(1_MeV), 6.98338608547542169e-09*1./(1_MeV), 3.18987477267544148e-12*1./(1_MeV), 1.92937235632406612e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform76;
+ ActsSymMatrixD<3> rotMat76;
+ rotMat76 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform76.rotate(rotMat76);
+ transform76.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans76 = std::make_shared<const Transform3D>(transform76);
+ std::shared_ptr<PerigeeSurface> perigeeSurface76 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams76 = BoundParameters(tgContext, std::move(covMat76), params76, perigeeSurface76);
+ tracks.push_back(boundParams76);
+
+
+ // track 77 :
+ BoundVector params77;
+ params77 << -0.310725152492523193, 19.8295936584472656, -0.606030046939849854, 2.24497246742248535, 0.000661869533360004425*1./(1_MeV), 0;
+ Covariance covMat77;
+ covMat77 << 0.00436511309817433357, 6.84685072450807867e-05, -0.000120994704364630506, -4.90458514285306182e-07, -5.64318242168483114e-08*1./(1_MeV), 0, 6.84685072450807867e-05, 0.0149454157799482346, 2.04636767799999282e-07, 0.000205310692185942025, -3.61902676938797707e-10*1./(1_MeV), 0, -0.000120994704364630506, 2.04636767799999282e-07, 3.47089417118695565e-06, 4.16973363970233483e-08, 2.51792336588650841e-09*1./(1_MeV), 0, -4.90458514285306182e-07, 0.000205310692185942025, 4.16973363970233483e-08, 3.3076123600039864e-06, 1.49401026311597095e-11*1./(1_MeV), 0, -5.64318242168483114e-08*1./(1_MeV), -3.61902676938797707e-10*1./(1_MeV), 2.51792336588650841e-09*1./(1_MeV), 1.49401026311597095e-11*1./(1_MeV), 7.15068143586350402e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform77;
+ ActsSymMatrixD<3> rotMat77;
+ rotMat77 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform77.rotate(rotMat77);
+ transform77.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans77 = std::make_shared<const Transform3D>(transform77);
+ std::shared_ptr<PerigeeSurface> perigeeSurface77 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams77 = BoundParameters(tgContext, std::move(covMat77), params77, perigeeSurface77);
+ tracks.push_back(boundParams77);
+
+
+ // track 78 :
+ BoundVector params78;
+ params78 << 0.0993749722838401794, 19.6716022491455078, 2.9211122989654541, 2.08926057815551758, 0.00120215211063623428*1./(1_MeV), 0;
+ Covariance covMat78;
+ covMat78 << 0.0101556088775396347, 1.73498859834314119e-05, -0.000283271865688924712, -1.78050008267022585e-06, -1.28366707714573746e-07*1./(1_MeV), 0, 1.73498859834314119e-05, 0.023284614086151123, 4.02106375070951919e-06, 0.000434507881477119533, -1.13469407774349132e-09*1./(1_MeV), 0, -0.000283271865688924712, 4.02106375070951919e-06, 8.19536035123746842e-06, 1.330371940544055e-07, 5.98130057573423383e-09*1./(1_MeV), 0, -1.78050008267022585e-06, 0.000434507881477119533, 1.330371940544055e-07, 8.93400192580884323e-06, -2.61622173381189258e-12*1./(1_MeV), 0, -1.28366707714573746e-07*1./(1_MeV), -1.13469407774349132e-09*1./(1_MeV), 5.98130057573423383e-09*1./(1_MeV), -2.61622173381189258e-12*1./(1_MeV), 1.96618277215065973e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform78;
+ ActsSymMatrixD<3> rotMat78;
+ rotMat78 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform78.rotate(rotMat78);
+ transform78.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans78 = std::make_shared<const Transform3D>(transform78);
+ std::shared_ptr<PerigeeSurface> perigeeSurface78 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams78 = BoundParameters(tgContext, std::move(covMat78), params78, perigeeSurface78);
+ tracks.push_back(boundParams78);
+
+
+ // track 79 :
+ BoundVector params79;
+ params79 << 0.00076918123522773385, 19.5978374481201172, -0.00888663902878761292, 2.26349568367004395, -5.1679373427759856e-05*1./(1_MeV), 0;
+ Covariance covMat79;
+ covMat79 << 0.000472295709187164903, 8.06538544252120891e-05, -5.76326071222579373e-06, 5.02484334678411116e-07, -7.2162471693487795e-09*1./(1_MeV), 0, 8.06538544252120891e-05, 0.00591621501371264458, -1.05334511746836201e-06, 2.14457476054835035e-05, -1.67841364746306759e-09*1./(1_MeV), 0, -5.76326071222579373e-06, -1.05334511746836201e-06, 8.51334576168483181e-08, -5.60483430138567528e-09, 9.92946218379075931e-11*1./(1_MeV), 0, 5.02484334678411116e-07, 2.14457476054835035e-05, -5.60483430138567528e-09, 1.79219924234530481e-07, -1.48012750336918152e-11*1./(1_MeV), 0, -7.2162471693487795e-09*1./(1_MeV), -1.67841364746306759e-09*1./(1_MeV), 9.92946218379075931e-11*1./(1_MeV), -1.48012750336918152e-11*1./(1_MeV), 8.22869712906876272e-13*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform79;
+ ActsSymMatrixD<3> rotMat79;
+ rotMat79 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform79.rotate(rotMat79);
+ transform79.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans79 = std::make_shared<const Transform3D>(transform79);
+ std::shared_ptr<PerigeeSurface> perigeeSurface79 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams79 = BoundParameters(tgContext, std::move(covMat79), params79, perigeeSurface79);
+ tracks.push_back(boundParams79);
+
+
+ // track 80 :
+ BoundVector params80;
+ params80 << 0.172430276870727539, 20.0516853332519531, 0.0925022587180137634, 2.79165339469909668, 0.000355079799192026258*1./(1_MeV), 0;
+ Covariance covMat80;
+ covMat80 << 0.0123957395553588867, 0.000276004959343346566, -0.000367529600040991081, -5.44526345620848147e-07, -2.56473787837672908e-07*1./(1_MeV), 0, 0.000276004959343346566, 0.149438470602035522, 1.26945466301119017e-05, 0.000484407751120721731, -4.77601393027406713e-09*1./(1_MeV), 0, -0.000367529600040991081, 1.26945466301119017e-05, 1.11619228846393526e-05, 7.59736475896802827e-08, 1.21717089673328274e-08*1./(1_MeV), 0, -5.44526345620848147e-07, 0.000484407751120721731, 7.59736475896802827e-08, 1.61264904363633832e-06, -7.16527986733535845e-12*1./(1_MeV), 0, -2.56473787837672908e-07*1./(1_MeV), -4.77601393027406713e-09*1./(1_MeV), 1.21717089673328274e-08*1./(1_MeV), -7.16527986733535845e-12*1./(1_MeV), 1.61127389208814975e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform80;
+ ActsSymMatrixD<3> rotMat80;
+ rotMat80 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform80.rotate(rotMat80);
+ transform80.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans80 = std::make_shared<const Transform3D>(transform80);
+ std::shared_ptr<PerigeeSurface> perigeeSurface80 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams80 = BoundParameters(tgContext, std::move(covMat80), params80, perigeeSurface80);
+ tracks.push_back(boundParams80);
+
+
+ // track 81 :
+ BoundVector params81;
+ params81 << 0.0237218067049980164, 19.884124755859375, -1.31243884563446045, 1.17260158061981201, 0.00145791680552065372*1./(1_MeV), 0;
+ Covariance covMat81;
+ covMat81 << 0.00926587916910648346, 7.06487595418491801e-05, -0.000277787039323878398, 4.07603821427250781e-06, -1.58449164304071412e-07*1./(1_MeV), 0, 7.06487595418491801e-05, 0.0313730873167514801, -6.65579864375914156e-06, 0.000612313813642858889, 3.06797580601043898e-10*1./(1_MeV), 0, -0.000277787039323878398, -6.65579864375914156e-06, 8.47732735564932227e-06, -2.17222306747093869e-07, 7.82071353865796235e-09*1./(1_MeV), 0, 4.07603821427250781e-06, 0.000612313813642858889, -2.17222306747093869e-07, 1.3626353393192403e-05, 7.47614118694918694e-12*1./(1_MeV), 0, -1.58449164304071412e-07*1./(1_MeV), 3.06797580601043898e-10*1./(1_MeV), 7.82071353865796235e-09*1./(1_MeV), 7.47614118694918694e-12*1./(1_MeV), 2.8977453769840622e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform81;
+ ActsSymMatrixD<3> rotMat81;
+ rotMat81 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform81.rotate(rotMat81);
+ transform81.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans81 = std::make_shared<const Transform3D>(transform81);
+ std::shared_ptr<PerigeeSurface> perigeeSurface81 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams81 = BoundParameters(tgContext, std::move(covMat81), params81, perigeeSurface81);
+ tracks.push_back(boundParams81);
+
+
+ // track 82 :
+ BoundVector params82;
+ params82 << 0.0107990093529224396, 19.6716117858886719, 1.03559982776641846, 1.73082625865936279, -0.000879532191902399063*1./(1_MeV), 0;
+ Covariance covMat82;
+ covMat82 << 0.00402391236275434494, 3.20769174601289147e-05, -0.000111254459256007358, 8.45579221821339803e-07, -4.58324536525110618e-08*1./(1_MeV), 0, 3.20769174601289147e-05, 0.0170307178050279617, -1.43476733365515181e-06, 0.000387486496341669733, -1.98263687729926011e-09*1./(1_MeV), 0, -0.000111254459256007358, -1.43476733365515181e-06, 3.15253510052571073e-06, -3.93483906027775912e-08, 2.199583121442104e-09*1./(1_MeV), 0, 8.45579221821339803e-07, 0.000387486496341669733, -3.93483906027775912e-08, 1.00340321296243928e-05, -8.11770059300461125e-11*1./(1_MeV), 0, -4.58324536525110618e-08*1./(1_MeV), -1.98263687729926011e-09*1./(1_MeV), 2.199583121442104e-09*1./(1_MeV), -8.11770059300461125e-11*1./(1_MeV), 8.58341592246958385e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform82;
+ ActsSymMatrixD<3> rotMat82;
+ rotMat82 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform82.rotate(rotMat82);
+ transform82.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans82 = std::make_shared<const Transform3D>(transform82);
+ std::shared_ptr<PerigeeSurface> perigeeSurface82 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams82 = BoundParameters(tgContext, std::move(covMat82), params82, perigeeSurface82);
+ tracks.push_back(boundParams82);
+
+
+ // track 83 :
+ BoundVector params83;
+ params83 << -0.0155548518523573875, 19.7591342926025391, 0.363524943590164185, 1.25925362110137939, 0.000502271810546517372*1./(1_MeV), 0;
+ Covariance covMat83;
+ covMat83 << 0.00146772642619907856, -2.09037045000602479e-05, -3.96307184598860177e-05, 1.98917565341808915e-07, -2.1828224014850844e-08*1./(1_MeV), 0, -2.09037045000602479e-05, 0.0098578035831451416, 3.71240804606546409e-07, 0.000133019349065383567, 2.05370209972403466e-09*1./(1_MeV), 0, -3.96307184598860177e-05, 3.71240804606546409e-07, 1.11548615677747875e-06, -1.0700920015588702e-08, 9.39493443779476572e-10*1./(1_MeV), 0, 1.98917565341808915e-07, 0.000133019349065383567, -1.0700920015588702e-08, 2.54624114859325346e-06, 1.22768956327870663e-13*1./(1_MeV), 0, -2.1828224014850844e-08*1./(1_MeV), 2.05370209972403466e-09*1./(1_MeV), 9.39493443779476572e-10*1./(1_MeV), 1.22768956327870663e-13*1./(1_MeV), 3.11325652757599158e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform83;
+ ActsSymMatrixD<3> rotMat83;
+ rotMat83 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform83.rotate(rotMat83);
+ transform83.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans83 = std::make_shared<const Transform3D>(transform83);
+ std::shared_ptr<PerigeeSurface> perigeeSurface83 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams83 = BoundParameters(tgContext, std::move(covMat83), params83, perigeeSurface83);
+ tracks.push_back(boundParams83);
+
+
+ // track 84 :
+ BoundVector params84;
+ params84 << -0.138253405690193176, 18.5519084930419922, 1.43608295917510986, 0.270120680332183838, 0.000328816560795530677*1./(1_MeV), 0;
+ Covariance covMat84;
+ covMat84 << 0.024482090026140213, -0.00141465310858683861, -0.000727919377154882677, 7.62924836936917779e-07, -2.70713331750664401e-07*1./(1_MeV), 0, -0.00141465310858683861, 0.38681483268737793, -3.29131593924930853e-06, 0.000780935381087039492, 2.03667202249869457e-08*1./(1_MeV), 0, -0.000727919377154882677, -3.29131593924930853e-06, 2.20086349145276472e-05, -1.08805257496805159e-07, 1.28472546995040731e-08*1./(1_MeV), 0, 7.62924836936917779e-07, 0.000780935381087039492, -1.08805257496805159e-07, 1.60606941790319979e-06, 6.31240016744585034e-12*1./(1_MeV), 0, -2.70713331750664401e-07*1./(1_MeV), 2.03667202249869457e-08*1./(1_MeV), 1.28472546995040731e-08*1./(1_MeV), 6.31240016744585034e-12*1./(1_MeV), 1.31787206147926383e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform84;
+ ActsSymMatrixD<3> rotMat84;
+ rotMat84 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform84.rotate(rotMat84);
+ transform84.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans84 = std::make_shared<const Transform3D>(transform84);
+ std::shared_ptr<PerigeeSurface> perigeeSurface84 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams84 = BoundParameters(tgContext, std::move(covMat84), params84, perigeeSurface84);
+ tracks.push_back(boundParams84);
+
+
+ // track 85 :
+ BoundVector params85;
+ params85 << -0.0975429564714431763, 19.5427474975585938, 2.8031013011932373, 1.58790135383605957, 0.00166723399888724089*1./(1_MeV), 0;
+ Covariance covMat85;
+ covMat85 << 0.0113241951912641525, -9.34923139819065776e-06, -0.000335769282045279361, -2.82633621752857802e-07, -1.5729637539850742e-07*1./(1_MeV), 0, -9.34923139819065776e-06, 0.0528257228434085846, 5.71110103579136688e-07, 0.00100043855412109946, -3.03573063913276242e-10*1./(1_MeV), 0, -0.000335769282045279361, 5.71110103579136688e-07, 1.01046462077647448e-05, 1.49587275943740115e-08, 7.33039139408457665e-09*1./(1_MeV), 0, -2.82633621752857802e-07, 0.00100043855412109946, 1.49587275943740115e-08, 2.26391439355211332e-05, 1.66413138250011556e-12*1./(1_MeV), 0, -1.5729637539850742e-07*1./(1_MeV), -3.03573063913276242e-10*1./(1_MeV), 7.33039139408457665e-09*1./(1_MeV), 1.66413138250011556e-12*1./(1_MeV), 2.75241468505882381e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform85;
+ ActsSymMatrixD<3> rotMat85;
+ rotMat85 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform85.rotate(rotMat85);
+ transform85.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans85 = std::make_shared<const Transform3D>(transform85);
+ std::shared_ptr<PerigeeSurface> perigeeSurface85 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams85 = BoundParameters(tgContext, std::move(covMat85), params85, perigeeSurface85);
+ tracks.push_back(boundParams85);
+
+
+ // track 86 :
+ BoundVector params86;
+ params86 << -0.0176449194550514221, 19.7948665618896484, -2.85859298706054688, 1.93745362758636475, 0.00181531091220676899*1./(1_MeV), 0;
+ Covariance covMat86;
+ covMat86 << 0.0164455324411392212, -1.78319115876212784e-05, -0.000476391113400424576, -4.84635611442015516e-06, -2.16420755174177543e-07*1./(1_MeV), 0, -1.78319115876212784e-05, 0.0350610315799713135, 7.76663282566612816e-06, 0.00082119930622140565, -2.29522713626592166e-09*1./(1_MeV), 0, -0.000476391113400424576, 7.76663282566612816e-06, 1.41888513098820113e-05, 3.09707605227186869e-07, 1.05056686720642746e-08*1./(1_MeV), 0, -4.84635611442015516e-06, 0.00082119930622140565, 3.09707605227186869e-07, 2.0716039216495119e-05, -3.66067615445536715e-11*1./(1_MeV), 0, -2.16420755174177543e-07*1./(1_MeV), -2.29522713626592166e-09*1./(1_MeV), 1.05056686720642746e-08*1./(1_MeV), -3.66067615445536715e-11*1./(1_MeV), 3.8617198327983715e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform86;
+ ActsSymMatrixD<3> rotMat86;
+ rotMat86 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform86.rotate(rotMat86);
+ transform86.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans86 = std::make_shared<const Transform3D>(transform86);
+ std::shared_ptr<PerigeeSurface> perigeeSurface86 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams86 = BoundParameters(tgContext, std::move(covMat86), params86, perigeeSurface86);
+ tracks.push_back(boundParams86);
+
+
+ // track 87 :
+ BoundVector params87;
+ params87 << -0.166390389204025269, 19.5272064208984375, 1.93741095066070557, 2.24489212036132812, -0.000905173714272677898*1./(1_MeV), 0;
+ Covariance covMat87;
+ covMat87 << 0.00758632877841591835, 0.000139937870694665129, -0.00021374593302439404, 2.74308497049270969e-06, -1.22199307635393265e-07*1./(1_MeV), 0, 0.000139937870694665129, 0.0236409269273281097, -7.18474418831525274e-06, 0.000356769071380466532, 2.17953764438197491e-10*1./(1_MeV), 0, -0.00021374593302439404, -7.18474418831525274e-06, 6.20618220636970364e-06, -1.339422192986325e-07, 5.75423109018135768e-09*1./(1_MeV), 0, 2.74308497049270969e-06, 0.000356769071380466532, -1.339422192986325e-07, 5.97795133217005059e-06, 1.65920987870639118e-13*1./(1_MeV), 0, -1.22199307635393265e-07*1./(1_MeV), 2.17953764438197491e-10*1./(1_MeV), 5.75423109018135768e-09*1./(1_MeV), 1.65920987870639118e-13*1./(1_MeV), 1.7132852081491734e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform87;
+ ActsSymMatrixD<3> rotMat87;
+ rotMat87 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform87.rotate(rotMat87);
+ transform87.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans87 = std::make_shared<const Transform3D>(transform87);
+ std::shared_ptr<PerigeeSurface> perigeeSurface87 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams87 = BoundParameters(tgContext, std::move(covMat87), params87, perigeeSurface87);
+ tracks.push_back(boundParams87);
+
+
+ // track 88 :
+ BoundVector params88;
+ params88 << -0.0647897049784660339, 19.7515354156494141, -1.94424092769622803, 0.913331747055053711, 0.00144281168468296528*1./(1_MeV), 0;
+ Covariance covMat88;
+ covMat88 << 0.0164492577314376831, 0.000114680106948955043, -0.000493878556345173059, 7.55394948756817303e-06, -3.09421204652331308e-07*1./(1_MeV), 0, 0.000114680106948955043, 0.0497665181756019592, -1.69407417870949993e-05, 0.000847429052747156815, 4.92898530455145555e-09*1./(1_MeV), 0, -0.000493878556345173059, -1.69407417870949993e-05, 1.51399772221338935e-05, -4.57257867983653748e-07, 1.5688536216622446e-08*1./(1_MeV), 0, 7.55394948756817303e-06, 0.000847429052747156815, -4.57257867983653748e-07, 1.51720887515693903e-05, 7.05942755015551252e-12*1./(1_MeV), 0, -3.09421204652331308e-07*1./(1_MeV), 4.92898530455145555e-09*1./(1_MeV), 1.5688536216622446e-08*1./(1_MeV), 7.05942755015551252e-12*1./(1_MeV), 5.00731012209598703e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform88;
+ ActsSymMatrixD<3> rotMat88;
+ rotMat88 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform88.rotate(rotMat88);
+ transform88.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans88 = std::make_shared<const Transform3D>(transform88);
+ std::shared_ptr<PerigeeSurface> perigeeSurface88 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams88 = BoundParameters(tgContext, std::move(covMat88), params88, perigeeSurface88);
+ tracks.push_back(boundParams88);
+
+
+ // track 89 :
+ BoundVector params89;
+ params89 << -0.0218852758407592773, 19.7477836608886719, -1.84601056575775146, 1.15177929401397705, -0.000602153537329286337*1./(1_MeV), 0;
+ Covariance covMat89;
+ covMat89 << 0.00399546697735786438, -7.6231191425185513e-05, -0.000113968779238574712, -1.06749066545070016e-06, -1.49669197267399396e-07*1./(1_MeV), 0, -7.6231191425185513e-05, 0.0129444217309355736, 2.25263525428921646e-06, 0.000202868748994328374, -7.0251938262291757e-09*1./(1_MeV), 0, -0.000113968779238574712, 2.25263525428921646e-06, 3.39482835443050135e-06, 3.68428330396706466e-08, 7.19219531975148008e-09*1./(1_MeV), 0, -1.06749066545070016e-06, 0.000202868748994328374, 3.68428330396706466e-08, 3.95832057620282285e-06, -5.52575945546745665e-11*1./(1_MeV), 0, -1.49669197267399396e-07*1./(1_MeV), -7.0251938262291757e-09*1./(1_MeV), 7.19219531975148008e-09*1./(1_MeV), -5.52575945546745665e-11*1./(1_MeV), 2.65768212992512076e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform89;
+ ActsSymMatrixD<3> rotMat89;
+ rotMat89 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform89.rotate(rotMat89);
+ transform89.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans89 = std::make_shared<const Transform3D>(transform89);
+ std::shared_ptr<PerigeeSurface> perigeeSurface89 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams89 = BoundParameters(tgContext, std::move(covMat89), params89, perigeeSurface89);
+ tracks.push_back(boundParams89);
+
+
+ // track 90 :
+ BoundVector params90;
+ params90 << -0.179924234747886658, 19.2563438415527344, -1.48651039600372314, 2.36299228668212891, -0.00104924733750522137*1./(1_MeV), 0;
+ Covariance covMat90;
+ covMat90 << 0.0114581910893321037, 0.000363608408604759639, -0.000344876866124296778, 5.81780591102444491e-06, -2.6043200912918554e-07*1./(1_MeV), 0, 0.000363608408604759639, 0.0420437715947628021, -1.83725730891767065e-05, 0.000563950407188989035, -4.04684151826768466e-09*1./(1_MeV), 0, -0.000344876866124296778, -1.83725730891767065e-05, 1.06007255453732796e-05, -2.88525393038017665e-07, 1.30515590208839564e-08*1./(1_MeV), 0, 5.81780591102444491e-06, 0.000563950407188989035, -2.88525393038017665e-07, 8.05603212938876823e-06, -7.18990753436096707e-11*1./(1_MeV), 0, -2.6043200912918554e-07*1./(1_MeV), -4.04684151826768466e-09*1./(1_MeV), 1.30515590208839564e-08*1./(1_MeV), -7.18990753436096707e-11*1./(1_MeV), 3.69383551523938536e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform90;
+ ActsSymMatrixD<3> rotMat90;
+ rotMat90 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform90.rotate(rotMat90);
+ transform90.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans90 = std::make_shared<const Transform3D>(transform90);
+ std::shared_ptr<PerigeeSurface> perigeeSurface90 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams90 = BoundParameters(tgContext, std::move(covMat90), params90, perigeeSurface90);
+ tracks.push_back(boundParams90);
+
+
+ // track 91 :
+ BoundVector params91;
+ params91 << 0.0888378918170928955, 19.5743637084960938, 2.02936220169067383, 0.592313289642333984, -0.00073199498001486063*1./(1_MeV), 0;
+ Covariance covMat91;
+ covMat91 << 0.011888476088643074, -0.000364351547358354397, -0.000344164051274786493, -4.80224624851940611e-06, -1.25074865846872421e-07*1./(1_MeV), 0, -0.000364351547358354397, 0.0546070896089076996, 1.71846692226701118e-05, 0.000451481364740918725, -6.40392522058036485e-10*1./(1_MeV), 0, -0.000344164051274786493, 1.71846692226701118e-05, 1.02026851891423576e-05, 2.02827091730025172e-07, 6.16615182332136642e-09*1./(1_MeV), 0, -4.80224624851940611e-06, 0.000451481364740918725, 2.02827091730025172e-07, 3.89986053050961345e-06, 1.48987059961839454e-11*1./(1_MeV), 0, -1.25074865846872421e-07*1./(1_MeV), -6.40392522058036485e-10*1./(1_MeV), 6.16615182332136642e-09*1./(1_MeV), 1.48987059961839454e-11*1./(1_MeV), 1.37464484240013007e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform91;
+ ActsSymMatrixD<3> rotMat91;
+ rotMat91 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform91.rotate(rotMat91);
+ transform91.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans91 = std::make_shared<const Transform3D>(transform91);
+ std::shared_ptr<PerigeeSurface> perigeeSurface91 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams91 = BoundParameters(tgContext, std::move(covMat91), params91, perigeeSurface91);
+ tracks.push_back(boundParams91);
+
+
+ // track 92 :
+ BoundVector params92;
+ params92 << 1.12502670288085938, 20.2727298736572266, 2.00401997566223145, 0.626365065574645996, -0.00111448660027235746*1./(1_MeV), 0;
+ Covariance covMat92;
+ covMat92 << 0.0225118305534124374, 0.000584212031156044944, -0.000666452626493573485, -9.45983147595499108e-06, -3.13759589393168411e-07*1./(1_MeV), 0, 0.000584212031156044944, 0.0864472761750221252, 1.9655656094501285e-06, 0.000822762632728434311, -2.92388874702865178e-08*1./(1_MeV), 0, -0.000666452626493573485, 1.9655656094501285e-06, 2.00926533580059186e-05, 4.80605470309639927e-07, 1.5495058835982803e-08*1./(1_MeV), 0, -9.45983147595499108e-06, 0.000822762632728434311, 4.80605470309639927e-07, 8.10808978712884709e-06, 1.17184088836066811e-11*1./(1_MeV), 0, -3.13759589393168411e-07*1./(1_MeV), -2.92388874702865178e-08*1./(1_MeV), 1.5495058835982803e-08*1./(1_MeV), 1.17184088836066811e-11*1./(1_MeV), 3.60202312421620263e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform92;
+ ActsSymMatrixD<3> rotMat92;
+ rotMat92 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform92.rotate(rotMat92);
+ transform92.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans92 = std::make_shared<const Transform3D>(transform92);
+ std::shared_ptr<PerigeeSurface> perigeeSurface92 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams92 = BoundParameters(tgContext, std::move(covMat92), params92, perigeeSurface92);
+ tracks.push_back(boundParams92);
+
+
+ // track 93 :
+ BoundVector params93;
+ params93 << 0.0424742512404918671, 18.9486141204833984, 1.86956024169921875, 2.96004772186279297, 4.37863855040632188e-05*1./(1_MeV), 0;
+ Covariance covMat93;
+ covMat93 << 0.00272560492157936096, 0.00211849758168023089, -7.31526879372190519e-05, 1.47161851529462088e-06, -2.24706881796614946e-08*1./(1_MeV), 0, 0.00211849758168023089, 0.109402194619178772, -4.40777842273042759e-05, 8.76258363739740542e-05, -7.98382954847600904e-09*1./(1_MeV), 0, -7.31526879372190519e-05, -4.40777842273042759e-05, 2.04982438845036086e-06, -3.14008128887106979e-08, 9.90149855492210942e-10*1./(1_MeV), 0, 1.47161851529462088e-06, 8.76258363739740542e-05, -3.14008128887106979e-08, 7.31033722445317835e-08, -5.93207648040451609e-12*1./(1_MeV), 0, -2.24706881796614946e-08*1./(1_MeV), -7.98382954847600904e-09*1./(1_MeV), 9.90149855492210942e-10*1./(1_MeV), -5.93207648040451609e-12*1./(1_MeV), 6.39852146960828705e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform93;
+ ActsSymMatrixD<3> rotMat93;
+ rotMat93 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform93.rotate(rotMat93);
+ transform93.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans93 = std::make_shared<const Transform3D>(transform93);
+ std::shared_ptr<PerigeeSurface> perigeeSurface93 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams93 = BoundParameters(tgContext, std::move(covMat93), params93, perigeeSurface93);
+ tracks.push_back(boundParams93);
+
+
+ // track 94 :
+ BoundVector params94;
+ params94 << 0.0741926580667495728, 19.3120975494384766, -0.158996760845184326, 0.275065630674362183, 0.000188159960089251399*1./(1_MeV), 0;
+ Covariance covMat94;
+ covMat94 << 0.00854411255568265915, -0.000856847673562337298, -0.000243449563025652623, -9.85362587786612014e-07, -5.40653541002901188e-08*1./(1_MeV), 0, -0.000856847673562337298, 0.125519141554832458, 1.11678697417946741e-05, 0.000258925752451969187, 1.7425143865914771e-09*1./(1_MeV), 0, -0.000243449563025652623, 1.11678697417946741e-05, 7.13488225301261991e-06, 5.42206306027033232e-09, 2.68913182114241505e-09*1./(1_MeV), 0, -9.85362587786612014e-07, 0.000258925752451969187, 5.42206306027033232e-09, 5.48016146240115631e-07, 2.1763511830840563e-12*1./(1_MeV), 0, -5.40653541002901188e-08*1./(1_MeV), 1.7425143865914771e-09*1./(1_MeV), 2.68913182114241505e-09*1./(1_MeV), 2.1763511830840563e-12*1./(1_MeV), 2.93287685804166642e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform94;
+ ActsSymMatrixD<3> rotMat94;
+ rotMat94 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform94.rotate(rotMat94);
+ transform94.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans94 = std::make_shared<const Transform3D>(transform94);
+ std::shared_ptr<PerigeeSurface> perigeeSurface94 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams94 = BoundParameters(tgContext, std::move(covMat94), params94, perigeeSurface94);
+ tracks.push_back(boundParams94);
+
+
+ // track 95 :
+ BoundVector params95;
+ params95 << 0.00871588941663503647, 19.6997394561767578, -1.8126060962677002, 2.65224313735961914, 0.000173616441315971315*1./(1_MeV), 0;
+ Covariance covMat95;
+ covMat95 << 0.0016872126143425703, 0.000139207692137839037, -4.67932554158379929e-05, 4.13046758309523893e-07, -2.15022847730470487e-08*1./(1_MeV), 0, 0.000139207692137839037, 0.0162848997861146927, -2.02254704724682222e-06, 8.19432265737622998e-05, -3.67683233513065563e-10*1./(1_MeV), 0, -4.67932554158379929e-05, -2.02254704724682222e-06, 1.35188520289375447e-06, -3.99719230681514876e-09, 9.61695510131444949e-10*1./(1_MeV), 0, 4.13046758309523893e-07, 8.19432265737622998e-05, -3.99719230681514876e-09, 4.59278368225568556e-07, 1.08766285673392314e-12*1./(1_MeV), 0, -2.15022847730470487e-08*1./(1_MeV), -3.67683233513065563e-10*1./(1_MeV), 9.61695510131444949e-10*1./(1_MeV), 1.08766285673392314e-12*1./(1_MeV), 1.62394785119257534e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform95;
+ ActsSymMatrixD<3> rotMat95;
+ rotMat95 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform95.rotate(rotMat95);
+ transform95.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans95 = std::make_shared<const Transform3D>(transform95);
+ std::shared_ptr<PerigeeSurface> perigeeSurface95 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams95 = BoundParameters(tgContext, std::move(covMat95), params95, perigeeSurface95);
+ tracks.push_back(boundParams95);
+
+
+ // track 96 :
+ BoundVector params96;
+ params96 << -0.479792565107345581, 19.5514030456542969, 1.30992162227630615, 2.87463688850402832, -0.000373176822904497385*1./(1_MeV), 0;
+ Covariance covMat96;
+ covMat96 << 0.0304757114499807358, 0.00262038861845952575, -0.000909104372409295556, 4.81420582026805876e-06, -3.00973750980190046e-07*1./(1_MeV), 0, 0.00262038861845952575, 0.461684495210647583, -0.000119908842389617728, 0.000928506582398690205, -1.58063875508688272e-08*1./(1_MeV), 0, -0.000909104372409295556, -0.000119908842389617728, 2.75514212262351066e-05, -2.30932526667593089e-07, 1.47073159868963048e-08*1./(1_MeV), 0, 4.81420582026805876e-06, 0.000928506582398690205, -2.30932526667593089e-07, 1.89259435501298867e-06, -3.4275779025213788e-12*1./(1_MeV), 0, -3.00973750980190046e-07*1./(1_MeV), -1.58063875508688272e-08*1./(1_MeV), 1.47073159868963048e-08*1./(1_MeV), -3.4275779025213788e-12*1./(1_MeV), 1.52582876888907037e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform96;
+ ActsSymMatrixD<3> rotMat96;
+ rotMat96 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform96.rotate(rotMat96);
+ transform96.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans96 = std::make_shared<const Transform3D>(transform96);
+ std::shared_ptr<PerigeeSurface> perigeeSurface96 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams96 = BoundParameters(tgContext, std::move(covMat96), params96, perigeeSurface96);
+ tracks.push_back(boundParams96);
+
+
+ // track 97 :
+ BoundVector params97;
+ params97 << 0.0435044243931770325, 19.5490474700927734, -1.34004080295562744, 0.636775732040405273, 0.00095876265550032258*1./(1_MeV), 0;
+ Covariance covMat97;
+ covMat97 << 0.0165304504334926605, 8.29496702915483077e-06, -0.000500555157842997754, 3.90666040743467471e-06, -2.32492797224773581e-07*1./(1_MeV), 0, 8.29496702915483077e-06, 0.0697377473115921021, -1.69183732968702351e-05, 0.000672615077218085113, 4.78769181746032668e-09*1./(1_MeV), 0, -0.000500555157842997754, -1.69183732968702351e-05, 1.53797700477298349e-05, -2.76896198762005315e-07, 1.14306313433277435e-08*1./(1_MeV), 0, 3.90666040743467471e-06, 0.000672615077218085113, -2.76896198762005315e-07, 6.75487535772845149e-06, 5.33336934367208442e-12*1./(1_MeV), 0, -2.32492797224773581e-07*1./(1_MeV), 4.78769181746032668e-09*1./(1_MeV), 1.14306313433277435e-08*1./(1_MeV), 5.33336934367208442e-12*1./(1_MeV), 2.67363853279078967e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform97;
+ ActsSymMatrixD<3> rotMat97;
+ rotMat97 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform97.rotate(rotMat97);
+ transform97.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans97 = std::make_shared<const Transform3D>(transform97);
+ std::shared_ptr<PerigeeSurface> perigeeSurface97 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams97 = BoundParameters(tgContext, std::move(covMat97), params97, perigeeSurface97);
+ tracks.push_back(boundParams97);
+
+
+ // track 98 :
+ BoundVector params98;
+ params98 << 0.294112950563430786, 20.2545261383056641, -0.614140152931213379, 2.8818819522857666, 0.000281037588138133287*1./(1_MeV), 0;
+ Covariance covMat98;
+ covMat98 << 0.0236709490418434143, 0.00249554031068035566, -0.000662619697167173742, 2.34743469108013516e-06, -2.19122332602494014e-07*1./(1_MeV), 0, 0.00249554031068035566, 0.38017040491104126, -1.42274220258879397e-05, 0.000682984089483805218, -1.15543562394303679e-08*1./(1_MeV), 0, -0.000662619697167173742, -1.42274220258879397e-05, 1.92686129594221711e-05, 2.05189135697031987e-08, 1.0358702081816697e-08*1./(1_MeV), 0, 2.34743469108013516e-06, 0.000682984089483805218, 2.05189135697031987e-08, 1.2688219612755347e-06, -2.0944363933578172e-11*1./(1_MeV), 0, -2.19122332602494014e-07*1./(1_MeV), -1.15543562394303679e-08*1./(1_MeV), 1.0358702081816697e-08*1./(1_MeV), -2.0944363933578172e-11*1./(1_MeV), 1.02260803991338634e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform98;
+ ActsSymMatrixD<3> rotMat98;
+ rotMat98 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform98.rotate(rotMat98);
+ transform98.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans98 = std::make_shared<const Transform3D>(transform98);
+ std::shared_ptr<PerigeeSurface> perigeeSurface98 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams98 = BoundParameters(tgContext, std::move(covMat98), params98, perigeeSurface98);
+ tracks.push_back(boundParams98);
+
+
+ // track 99 :
+ BoundVector params99;
+ params99 << -0.13228142261505127, 19.8440647125244141, -1.97596120834350586, 0.307230293750762939, -0.000209428049856796861*1./(1_MeV), 0;
+ Covariance covMat99;
+ covMat99 << 0.0064656953327357769, -0.000491542212342820388, -0.00019640849669221811, -1.26200648361190619e-06, -7.51057490837922185e-08*1./(1_MeV), 0, -0.000491542212342820388, 0.0971855819225311279, 1.78855920005378135e-05, 0.000244668503969933625, 2.01135045525568458e-09*1./(1_MeV), 0, -0.00019640849669221811, 1.78855920005378135e-05, 6.10315464655286632e-06, 4.79157334954937018e-08, 3.80545329493034294e-09*1./(1_MeV), 0, -1.26200648361190619e-06, 0.000244668503969933625, 4.79157334954937018e-08, 6.40511075289396103e-07, 3.52133532247833157e-12*1./(1_MeV), 0, -7.51057490837922185e-08*1./(1_MeV), 2.01135045525568458e-09*1./(1_MeV), 3.80545329493034294e-09*1./(1_MeV), 3.52133532247833157e-12*1./(1_MeV), 4.62756812036335674e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform99;
+ ActsSymMatrixD<3> rotMat99;
+ rotMat99 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform99.rotate(rotMat99);
+ transform99.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans99 = std::make_shared<const Transform3D>(transform99);
+ std::shared_ptr<PerigeeSurface> perigeeSurface99 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams99 = BoundParameters(tgContext, std::move(covMat99), params99, perigeeSurface99);
+ tracks.push_back(boundParams99);
+
+
+ // track 100 :
+ BoundVector params100;
+ params100 << 0.0397286675870418549, 19.8980617523193359, -1.5870441198348999, 1.06085562705993652, -0.00154436775483191013*1./(1_MeV), 0;
+ Covariance covMat100;
+ covMat100 << 0.0146848792210221291, -0.00024056679482515193, -0.000422761250825204478, -6.59419504288689593e-06, -2.0883759621313093e-07*1./(1_MeV), 0, -0.00024056679482515193, 0.0353117473423480988, 1.29517733327191238e-05, 0.000689977822807362863, -2.65977040646537884e-09*1./(1_MeV), 0, -0.000422761250825204478, 1.29517733327191238e-05, 1.25361730169970542e-05, 3.29509919866834633e-07, 9.87015185549509611e-09*1./(1_MeV), 0, -6.59419504288689593e-06, 0.000689977822807362863, 3.29509919866834633e-07, 1.49626648635603487e-05, -5.44243124057383386e-11*1./(1_MeV), 0, -2.0883759621313093e-07*1./(1_MeV), -2.65977040646537884e-09*1./(1_MeV), 9.87015185549509611e-09*1./(1_MeV), -5.44243124057383386e-11*1./(1_MeV), 3.28629123913515286e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform100;
+ ActsSymMatrixD<3> rotMat100;
+ rotMat100 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform100.rotate(rotMat100);
+ transform100.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans100 = std::make_shared<const Transform3D>(transform100);
+ std::shared_ptr<PerigeeSurface> perigeeSurface100 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams100 = BoundParameters(tgContext, std::move(covMat100), params100, perigeeSurface100);
+ tracks.push_back(boundParams100);
+
+
+ // track 101 :
+ BoundVector params101;
+ params101 << -0.0403421521186828613, 20.0219764709472656, 2.98151826858520508, 0.283174663782119751, -0.000182216783287003636*1./(1_MeV), 0;
+ Covariance covMat101;
+ covMat101 << 0.0106812380254268646, -0.0024943587506664794, -0.00027858873873760296, -4.44244638850068472e-06, -5.26653512387191812e-08*1./(1_MeV), 0, -0.0024943587506664794, 0.194047778844833374, 6.18626595670502936e-05, 0.000369563883583051613, 5.07052744885661252e-09*1./(1_MeV), 0, -0.00027858873873760296, 6.18626595670502936e-05, 7.62251374908373691e-06, 1.15742939569733442e-07, 2.35948978506657342e-09*1./(1_MeV), 0, -4.44244638850068472e-06, 0.000369563883583051613, 1.15742939569733442e-07, 7.40628024686884601e-07, 9.57926490773258748e-12*1./(1_MeV), 0, -5.26653512387191812e-08*1./(1_MeV), 5.07052744885661252e-09*1./(1_MeV), 2.35948978506657342e-09*1./(1_MeV), 9.57926490773258748e-12*1./(1_MeV), 2.45328583836634806e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform101;
+ ActsSymMatrixD<3> rotMat101;
+ rotMat101 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform101.rotate(rotMat101);
+ transform101.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans101 = std::make_shared<const Transform3D>(transform101);
+ std::shared_ptr<PerigeeSurface> perigeeSurface101 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams101 = BoundParameters(tgContext, std::move(covMat101), params101, perigeeSurface101);
+ tracks.push_back(boundParams101);
+
+
+ // track 102 :
+ BoundVector params102;
+ params102 << 0.102368071675300598, 19.5361366271972656, 0.766166448593139648, 2.5110175609588623, -0.000775155378505587578*1./(1_MeV), 0;
+ Covariance covMat102;
+ covMat102 << 0.011576404795050621, 0.000312717534921375974, -0.000335520083970844722, 4.71286322771853713e-06, -1.4290716638334455e-07*1./(1_MeV), 0, 0.000312717534921375974, 0.0526967272162437439, -1.61243873360913762e-05, 0.000481644572307707124, 2.09254387760536983e-09*1./(1_MeV), 0, -0.000335520083970844722, -1.61243873360913762e-05, 9.90374064713250846e-06, -2.10436751795918073e-07, 6.86918188030268416e-09*1./(1_MeV), 0, 4.71286322771853713e-06, 0.000481644572307707124, -2.10436751795918073e-07, 4.60942783320206217e-06, -5.63914956480814653e-12*1./(1_MeV), 0, -1.4290716638334455e-07*1./(1_MeV), 2.09254387760536983e-09*1./(1_MeV), 6.86918188030268416e-09*1./(1_MeV), -5.63914956480814653e-12*1./(1_MeV), 1.56449936339342344e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform102;
+ ActsSymMatrixD<3> rotMat102;
+ rotMat102 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform102.rotate(rotMat102);
+ transform102.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans102 = std::make_shared<const Transform3D>(transform102);
+ std::shared_ptr<PerigeeSurface> perigeeSurface102 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams102 = BoundParameters(tgContext, std::move(covMat102), params102, perigeeSurface102);
+ tracks.push_back(boundParams102);
+
+
+ // track 103 :
+ BoundVector params103;
+ params103 << 0.00269113038666546345, 19.7512493133544922, 0.950928092002868652, 1.69274437427520752, -0.000290958356345072389*1./(1_MeV), 0;
+ Covariance covMat103;
+ covMat103 << 0.000890406954567879438, 9.06876283418256436e-06, -2.11295340822724774e-05, 9.41784250991205146e-08, -5.2726015222058164e-09*1./(1_MeV), 0, 9.06876283418256436e-06, 0.00811147503554821014, -2.45248004436948366e-07, 0.000101593272660637559, -2.7419352860978785e-09*1./(1_MeV), 0, -2.11295340822724774e-05, -2.45248004436948366e-07, 5.30661907305329805e-07, -3.58145452722120584e-09, 2.49822767665423193e-10*1./(1_MeV), 0, 9.41784250991205146e-08, 0.000101593272660637559, -3.58145452722120584e-09, 2.08752635444398038e-06, -5.68853159346797837e-11*1./(1_MeV), 0, -5.2726015222058164e-09*1./(1_MeV), -2.7419352860978785e-09*1./(1_MeV), 2.49822767665423193e-10*1./(1_MeV), -5.68853159346797837e-11*1./(1_MeV), 9.96157063087865779e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform103;
+ ActsSymMatrixD<3> rotMat103;
+ rotMat103 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform103.rotate(rotMat103);
+ transform103.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans103 = std::make_shared<const Transform3D>(transform103);
+ std::shared_ptr<PerigeeSurface> perigeeSurface103 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams103 = BoundParameters(tgContext, std::move(covMat103), params103, perigeeSurface103);
+ tracks.push_back(boundParams103);
+
+
+ // track 104 :
+ BoundVector params104;
+ params104 << -0.245851978659629822, 20.1682567596435547, 1.23872554302215576, 0.248893141746520996, 0.000325477973092347383*1./(1_MeV), 0;
+ Covariance covMat104;
+ covMat104 << 0.0286086816340684891, -0.001356925375741017, -0.000851797951539738228, 1.97126922666860932e-06, -2.43581517567970172e-07*1./(1_MeV), 0, -0.001356925375741017, 0.490286678075790405, -8.99033667088915713e-06, 0.000865735597139924494, 2.32921530889448322e-08*1./(1_MeV), 0, -0.000851797951539738228, -8.99033667088915713e-06, 2.57704250543611124e-05, -1.44063558527249657e-07, 1.22322871879510032e-08*1./(1_MeV), 0, 1.97126922666860932e-06, 0.000865735597139924494, -1.44063558527249657e-07, 1.54735130308836233e-06, 2.09896768832773089e-12*1./(1_MeV), 0, -2.43581517567970172e-07*1./(1_MeV), 2.32921530889448322e-08*1./(1_MeV), 1.22322871879510032e-08*1./(1_MeV), 2.09896768832773089e-12*1./(1_MeV), 1.2200331023226596e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform104;
+ ActsSymMatrixD<3> rotMat104;
+ rotMat104 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform104.rotate(rotMat104);
+ transform104.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans104 = std::make_shared<const Transform3D>(transform104);
+ std::shared_ptr<PerigeeSurface> perigeeSurface104 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams104 = BoundParameters(tgContext, std::move(covMat104), params104, perigeeSurface104);
+ tracks.push_back(boundParams104);
+
+
+ // track 105 :
+ BoundVector params105;
+ params105 << -0.0600807033479213715, 19.7313117980957031, 2.31984329223632812, 1.3616642951965332, 0.000664964492898434401*1./(1_MeV), 0;
+ Covariance covMat105;
+ covMat105 << 0.00314268073998391628, -7.7012257876423378e-06, -8.51334898014966158e-05, 5.89304597370603241e-07, -7.97505446520337312e-08*1./(1_MeV), 0, -7.7012257876423378e-06, 0.0102382330223917961, -6.32454788190619239e-07, 0.000178850129128044883, -9.30661620828337703e-09*1./(1_MeV), 0, -8.51334898014966158e-05, -6.32454788190619239e-07, 2.44164994001039304e-06, -2.83573153286948557e-08, 3.20769979461027676e-09*1./(1_MeV), 0, 5.89304597370603241e-07, 0.000178850129128044883, -2.83573153286948557e-08, 4.20260403188876808e-06, -1.84237869498140217e-10*1./(1_MeV), 0, -7.97505446520337312e-08*1./(1_MeV), -9.30661620828337703e-09*1./(1_MeV), 3.20769979461027676e-09*1./(1_MeV), -1.84237869498140217e-10*1./(1_MeV), 9.88064630114138254e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform105;
+ ActsSymMatrixD<3> rotMat105;
+ rotMat105 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform105.rotate(rotMat105);
+ transform105.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans105 = std::make_shared<const Transform3D>(transform105);
+ std::shared_ptr<PerigeeSurface> perigeeSurface105 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams105 = BoundParameters(tgContext, std::move(covMat105), params105, perigeeSurface105);
+ tracks.push_back(boundParams105);
+
+
+ // track 106 :
+ BoundVector params106;
+ params106 << -0.0632231608033180237, 19.6254329681396484, 1.89337217807769775, 0.921234846115112305, -0.000626925728283822536*1./(1_MeV), 0;
+ Covariance covMat106;
+ covMat106 << 0.00425710296258330345, -0.000219698489314023703, -0.000117615295422727911, -2.52522899438900064e-06, -5.43295757382818289e-08*1./(1_MeV), 0, -0.000219698489314023703, 0.0236179828643798828, 7.04771554651835001e-06, 0.000339162159718363429, -3.13730541114924775e-09*1./(1_MeV), 0, -0.000117615295422727911, 7.04771554651835001e-06, 3.34456171913188882e-06, 9.40031753889414598e-08, 2.52804058098014408e-09*1./(1_MeV), 0, -2.52522899438900064e-06, 0.000339162159718363429, 9.40031753889414598e-08, 5.38931180926738307e-06, -2.20941594381711364e-11*1./(1_MeV), 0, -5.43295757382818289e-08*1./(1_MeV), -3.13730541114924775e-09*1./(1_MeV), 2.52804058098014408e-09*1./(1_MeV), -2.20941594381711364e-11*1./(1_MeV), 7.74676017778475057e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform106;
+ ActsSymMatrixD<3> rotMat106;
+ rotMat106 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform106.rotate(rotMat106);
+ transform106.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans106 = std::make_shared<const Transform3D>(transform106);
+ std::shared_ptr<PerigeeSurface> perigeeSurface106 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams106 = BoundParameters(tgContext, std::move(covMat106), params106, perigeeSurface106);
+ tracks.push_back(boundParams106);
+
+
+ // track 107 :
+ BoundVector params107;
+ params107 << 0.360552132129669189, 18.9798069000244141, 2.17705512046813965, 2.95739436149597168, 0.000170226237969473004*1./(1_MeV), 0;
+ Covariance covMat107;
+ covMat107 << 0.0202916935086250305, 0.000201601632849784387, -0.000616325805420407701, 1.09389603440618418e-07, -2.32012673409599967e-07*1./(1_MeV), 0, 0.000201601632849784387, 0.596419632434844971, 3.27955063214520708e-05, 0.00059099745368901811, 1.02858367938844465e-08*1./(1_MeV), 0, -0.000616325805420407701, 3.27955063214520708e-05, 1.91301714949076995e-05, 3.16951153463901935e-08, 1.15949223809287544e-08*1./(1_MeV), 0, 1.09389603440618418e-07, 0.00059099745368901811, 3.16951153463901935e-08, 5.92274261634884169e-07, -2.37559850171720801e-12*1./(1_MeV), 0, -2.32012673409599967e-07*1./(1_MeV), 1.02858367938844465e-08*1./(1_MeV), 1.15949223809287544e-08*1./(1_MeV), -2.37559850171720801e-12*1./(1_MeV), 8.54574952469100424e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform107;
+ ActsSymMatrixD<3> rotMat107;
+ rotMat107 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform107.rotate(rotMat107);
+ transform107.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans107 = std::make_shared<const Transform3D>(transform107);
+ std::shared_ptr<PerigeeSurface> perigeeSurface107 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams107 = BoundParameters(tgContext, std::move(covMat107), params107, perigeeSurface107);
+ tracks.push_back(boundParams107);
+
+
+ // track 108 :
+ BoundVector params108;
+ params108 << -0.0385420434176921844, 19.8494167327880859, -2.91224813461303711, 0.434279114007949829, 0.000344612402841448784*1./(1_MeV), 0;
+ Covariance covMat108;
+ covMat108 << 0.00708283483982086182, -0.000290315453926490662, -0.000208821270084330699, -4.36274591953509495e-07, -2.0634328653756119e-07*1./(1_MeV), 0, -0.000290315453926490662, 0.0554034896194934845, 1.79575900534169211e-06, 0.000262110253474558965, 1.13649321255499376e-08*1./(1_MeV), 0, -0.000208821270084330699, 1.79575900534169211e-06, 6.40597681922372431e-06, -1.62866970452031225e-08, 9.99126779944540941e-09*1./(1_MeV), 0, -4.36274591953509495e-07, 0.000262110253474558965, -1.62866970452031225e-08, 1.29895113332167966e-06, 3.16671471384196928e-11*1./(1_MeV), 0, -2.0634328653756119e-07*1./(1_MeV), 1.13649321255499376e-08*1./(1_MeV), 9.99126779944540941e-09*1./(1_MeV), 3.16671471384196928e-11*1./(1_MeV), 1.64341207309348647e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform108;
+ ActsSymMatrixD<3> rotMat108;
+ rotMat108 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform108.rotate(rotMat108);
+ transform108.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans108 = std::make_shared<const Transform3D>(transform108);
+ std::shared_ptr<PerigeeSurface> perigeeSurface108 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams108 = BoundParameters(tgContext, std::move(covMat108), params108, perigeeSurface108);
+ tracks.push_back(boundParams108);
+
+
+ // track 109 :
+ BoundVector params109;
+ params109 << -0.0989816188812255859, 19.6172981262207031, -2.41140604019165039, 0.801270425319671631, -0.000793451210483908653*1./(1_MeV), 0;
+ Covariance covMat109;
+ covMat109 << 0.00786646455526351929, -0.000344219331520010437, -0.000221645718673196959, -4.14245788496836856e-06, -1.37193307846517797e-07*1./(1_MeV), 0, -0.000344219331520010437, 0.0273069571703672409, 1.18374970750359077e-05, 0.000350145532022221365, 2.43323438271879911e-09*1./(1_MeV), 0, -0.000221645718673196959, 1.18374970750359077e-05, 6.48815375825506635e-06, 1.56811599604059021e-07, 6.52184431015660127e-09*1./(1_MeV), 0, -4.14245788496836856e-06, 0.000350145532022221365, 1.56811599604059021e-07, 4.93106381327379495e-06, 2.39307717698818543e-11*1./(1_MeV), 0, -1.37193307846517797e-07*1./(1_MeV), 2.43323438271879911e-09*1./(1_MeV), 6.52184431015660127e-09*1./(1_MeV), 2.39307717698818543e-11*1./(1_MeV), 1.82697898476469334e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform109;
+ ActsSymMatrixD<3> rotMat109;
+ rotMat109 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform109.rotate(rotMat109);
+ transform109.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans109 = std::make_shared<const Transform3D>(transform109);
+ std::shared_ptr<PerigeeSurface> perigeeSurface109 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams109 = BoundParameters(tgContext, std::move(covMat109), params109, perigeeSurface109);
+ tracks.push_back(boundParams109);
+
+
+ // track 110 :
+ BoundVector params110;
+ params110 << -0.248047471046447754, 19.6557636260986328, 2.29302573204040527, 0.649587929248809814, -0.00110239081550389528*1./(1_MeV), 0;
+ Covariance covMat110;
+ covMat110 << 0.0216166544705629349, -0.00082482405910012024, -0.000652860285832565414, -1.02919032841101398e-05, -6.52212657639859215e-07*1./(1_MeV), 0, -0.00082482405910012024, 0.0853162780404090881, 4.15812377535581474e-05, 0.000839477999853416139, 1.85719368884111095e-11*1./(1_MeV), 0, -0.000652860285832565414, 4.15812377535581474e-05, 2.00744616449810565e-05, 4.89128117113744387e-07, 3.10100339064501893e-08*1./(1_MeV), 0, -1.02919032841101398e-05, 0.000839477999853416139, 4.89128117113744387e-07, 8.57177292346023023e-06, 1.97141912126868163e-11*1./(1_MeV), 0, -6.52212657639859215e-07*1./(1_MeV), 1.85719368884111095e-11*1./(1_MeV), 3.10100339064501893e-08*1./(1_MeV), 1.97141912126868163e-11*1./(1_MeV), 7.19949988514656525e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform110;
+ ActsSymMatrixD<3> rotMat110;
+ rotMat110 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform110.rotate(rotMat110);
+ transform110.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans110 = std::make_shared<const Transform3D>(transform110);
+ std::shared_ptr<PerigeeSurface> perigeeSurface110 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams110 = BoundParameters(tgContext, std::move(covMat110), params110, perigeeSurface110);
+ tracks.push_back(boundParams110);
+
+
+ // track 111 :
+ BoundVector params111;
+ params111 << 0.0262720081955194473, 19.8286037445068359, 2.18146443367004395, 2.08324813842773438, 0.000428368948632851243*1./(1_MeV), 0;
+ Covariance covMat111;
+ covMat111 << 0.00158816727343946695, 9.4853627735629324e-06, -4.36409249479155706e-05, -1.48995811754545918e-07, -2.02757518900558508e-08*1./(1_MeV), 0, 9.4853627735629324e-06, 0.0110956495627760887, 3.27586912949563326e-07, 0.000130563462425678848, -4.16497402962450788e-09*1./(1_MeV), 0, -4.36409249479155706e-05, 3.27586912949563326e-07, 1.24739369766757591e-06, 1.17262448099841417e-08, 8.7129027760781156e-10*1./(1_MeV), 0, -1.48995811754545918e-07, 0.000130563462425678848, 1.17262448099841417e-08, 2.20083074964350089e-06, -2.28033377013702109e-11*1./(1_MeV), 0, -2.02757518900558508e-08*1./(1_MeV), -4.16497402962450788e-09*1./(1_MeV), 8.7129027760781156e-10*1./(1_MeV), -2.28033377013702109e-11*1./(1_MeV), 2.59175268052524999e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform111;
+ ActsSymMatrixD<3> rotMat111;
+ rotMat111 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform111.rotate(rotMat111);
+ transform111.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans111 = std::make_shared<const Transform3D>(transform111);
+ std::shared_ptr<PerigeeSurface> perigeeSurface111 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams111 = BoundParameters(tgContext, std::move(covMat111), params111, perigeeSurface111);
+ tracks.push_back(boundParams111);
+
+
+ // track 112 :
+ BoundVector params112;
+ params112 << 0.0326793268322944641, 19.8120479583740234, 0.889699041843414307, 1.57646119594573975, -0.000467951031168922782*1./(1_MeV), 0;
+ Covariance covMat112;
+ covMat112 << 0.0013444551732391119, -1.04196358259948499e-06, -3.51593985940863599e-05, -1.51435614902372445e-08, -2.03697874567189654e-08*1./(1_MeV), 0, -1.04196358259948499e-06, 0.0113611593842506409, 2.86736734379056518e-08, 0.000153356229013592134, 1.41074638188641834e-10*1./(1_MeV), 0, -3.51593985940863599e-05, 2.86736734379056518e-08, 9.62528019954334013e-07, 3.04792415524836218e-10, 8.65383902854664365e-10*1./(1_MeV), 0, -1.51435614902372445e-08, 0.000153356229013592134, 3.04792415524836218e-10, 3.0196767966117477e-06, -4.83286461545659302e-12*1./(1_MeV), 0, -2.03697874567189654e-08*1./(1_MeV), 1.41074638188641834e-10*1./(1_MeV), 8.65383902854664365e-10*1./(1_MeV), -4.83286461545659302e-12*1./(1_MeV), 2.99355089328212642e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform112;
+ ActsSymMatrixD<3> rotMat112;
+ rotMat112 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform112.rotate(rotMat112);
+ transform112.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans112 = std::make_shared<const Transform3D>(transform112);
+ std::shared_ptr<PerigeeSurface> perigeeSurface112 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams112 = BoundParameters(tgContext, std::move(covMat112), params112, perigeeSurface112);
+ tracks.push_back(boundParams112);
+
+
+ // track 113 :
+ BoundVector params113;
+ params113 << 0.0479989089071750641, 19.5348949432373047, -1.84289538860321045, 2.54763102531433105, -0.000563078676350414753*1./(1_MeV), 0;
+ Covariance covMat113;
+ covMat113 << 0.00674024224281311035, 0.000275261902324333151, -0.000202055961074877318, 2.83455165085094845e-06, -8.66185543146518417e-08*1./(1_MeV), 0, 0.000275261902324333151, 0.0429738685488700867, -1.16714247102508588e-05, 0.000340657623151467128, -1.21201365712005428e-09*1./(1_MeV), 0, -0.000202055961074877318, -1.16714247102508588e-05, 6.1798982642358169e-06, -1.17638099338652864e-07, 4.25805894898182396e-09*1./(1_MeV), 0, 2.83455165085094845e-06, 0.000340657623151467128, -1.17638099338652864e-07, 2.85863870885805227e-06, -1.98763016529320121e-11*1./(1_MeV), 0, -8.66185543146518417e-08*1./(1_MeV), -1.21201365712005428e-09*1./(1_MeV), 4.25805894898182396e-09*1./(1_MeV), -1.98763016529320121e-11*1./(1_MeV), 9.45928058104783531e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform113;
+ ActsSymMatrixD<3> rotMat113;
+ rotMat113 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform113.rotate(rotMat113);
+ transform113.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans113 = std::make_shared<const Transform3D>(transform113);
+ std::shared_ptr<PerigeeSurface> perigeeSurface113 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams113 = BoundParameters(tgContext, std::move(covMat113), params113, perigeeSurface113);
+ tracks.push_back(boundParams113);
+
+
+ // track 114 :
+ BoundVector params114;
+ params114 << -0.166889190673828125, 19.049163818359375, 2.00572776794433594, 2.98232221603393555, -5.11993312102276832e-05*1./(1_MeV), 0;
+ Covariance covMat114;
+ covMat114 << 0.00352242938242852688, 0.000933588696445512324, -0.000101630702391713315, 5.56225575687583112e-07, -4.72569998214100291e-08*1./(1_MeV), 0, 0.000933588696445512324, 0.140665516257286072, -2.55878928890533955e-05, 9.91245475972232033e-05, -4.82721694350305098e-09*1./(1_MeV), 0, -0.000101630702391713315, -2.55878928890533955e-05, 3.07548725686501712e-06, -1.60878195926674544e-08, 2.32450177496049771e-09*1./(1_MeV), 0, 5.56225575687583112e-07, 9.91245475972232033e-05, -1.60878195926674544e-08, 7.18341084393614437e-08, -2.32272171088200988e-12*1./(1_MeV), 0, -4.72569998214100291e-08*1./(1_MeV), -4.82721694350305098e-09*1./(1_MeV), 2.32450177496049771e-09*1./(1_MeV), -2.32272171088200988e-12*1./(1_MeV), 1.44301818758019174e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform114;
+ ActsSymMatrixD<3> rotMat114;
+ rotMat114 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform114.rotate(rotMat114);
+ transform114.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans114 = std::make_shared<const Transform3D>(transform114);
+ std::shared_ptr<PerigeeSurface> perigeeSurface114 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams114 = BoundParameters(tgContext, std::move(covMat114), params114, perigeeSurface114);
+ tracks.push_back(boundParams114);
+
+
+ // track 115 :
+ BoundVector params115;
+ params115 << 0.0137746464461088181, 19.6609287261962891, 2.67169976234436035, 1.68737459182739258, -0.000312122545437887311*1./(1_MeV), 0;
+ Covariance covMat115;
+ covMat115 << 0.00205370550975203514, 2.57276641361198506e-05, -4.35124207927626197e-05, 2.05754998361759643e-07, -7.68677673940147419e-09*1./(1_MeV), 0, 2.57276641361198506e-05, 0.00751006556674838066, -5.60196307230371148e-07, 0.000104370906596587887, -2.31954884204932396e-09*1./(1_MeV), 0, -4.35124207927626197e-05, -5.60196307230371148e-07, 9.7233169071841985e-07, -5.78757716049063737e-09, 3.21560072675208627e-10*1./(1_MeV), 0, 2.05754998361759643e-07, 0.000104370906596587887, -5.78757716049063737e-09, 2.29740794566168915e-06, -4.91169097872738332e-11*1./(1_MeV), 0, -7.68677673940147419e-09*1./(1_MeV), -2.31954884204932396e-09*1./(1_MeV), 3.21560072675208627e-10*1./(1_MeV), -4.91169097872738332e-11*1./(1_MeV), 1.16981858228060176e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform115;
+ ActsSymMatrixD<3> rotMat115;
+ rotMat115 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform115.rotate(rotMat115);
+ transform115.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans115 = std::make_shared<const Transform3D>(transform115);
+ std::shared_ptr<PerigeeSurface> perigeeSurface115 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams115 = BoundParameters(tgContext, std::move(covMat115), params115, perigeeSurface115);
+ tracks.push_back(boundParams115);
+
+
+ // track 116 :
+ BoundVector params116;
+ params116 << 1.04568362236022949, 19.1366863250732422, 2.12020516395568848, 2.92311358451843262, 9.25068379729054868e-05*1./(1_MeV), 0;
+ Covariance covMat116;
+ covMat116 << 0.00488254847005009651, 0.000740361421888004493, -0.00013463378504927599, 1.2158197600630495e-06, -3.36609027457528485e-08*1./(1_MeV), 0, 0.000740361421888004493, 0.114923417568206787, -8.05991571412841247e-06, 0.000146249036050893433, 4.20761461930579654e-09*1./(1_MeV), 0, -0.00013463378504927599, -8.05991571412841247e-06, 3.85931298296782188e-06, -2.17580929998134164e-08, 1.60649110182894787e-09*1./(1_MeV), 0, 1.2158197600630495e-06, 0.000146249036050893433, -2.17580929998134164e-08, 1.92376987229181395e-07, -2.78492110134724017e-12*1./(1_MeV), 0, -3.36609027457528485e-08*1./(1_MeV), 4.20761461930579654e-09*1./(1_MeV), 1.60649110182894787e-09*1./(1_MeV), -2.78492110134724017e-12*1./(1_MeV), 1.35187555594384889e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform116;
+ ActsSymMatrixD<3> rotMat116;
+ rotMat116 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform116.rotate(rotMat116);
+ transform116.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans116 = std::make_shared<const Transform3D>(transform116);
+ std::shared_ptr<PerigeeSurface> perigeeSurface116 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams116 = BoundParameters(tgContext, std::move(covMat116), params116, perigeeSurface116);
+ tracks.push_back(boundParams116);
+
+
+ // track 117 :
+ BoundVector params117;
+ params117 << -1.20940804481506348, 19.6823959350585938, -1.81289887428283691, 0.625804603099822998, 0.000932577764615416527*1./(1_MeV), 0;
+ Covariance covMat117;
+ covMat117 << 0.0626278072595596313, -0.00168264653846623741, -0.00141945234148735475, 1.67458965126927841e-05, -7.54246802546992556e-07*1./(1_MeV), 0, -0.00168264653846623741, 0.230180084705352783, -2.73170868898178382e-06, 0.00158152202219789709, 6.02409280618631771e-08*1./(1_MeV), 0, -0.00141945234148735475, -2.73170868898178382e-06, 3.37690398737322539e-05, -7.02785129344153319e-07, 2.29061226487353007e-08*1./(1_MeV), 0, 1.67458965126927841e-05, 0.00158152202219789709, -7.02785129344153319e-07, 1.19483884191140532e-05, 4.05549492337246129e-12*1./(1_MeV), 0, -7.54246802546992556e-07*1./(1_MeV), 6.02409280618631771e-08*1./(1_MeV), 2.29061226487353007e-08*1./(1_MeV), 4.05549492337246129e-12*1./(1_MeV), 3.22085941251160079e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform117;
+ ActsSymMatrixD<3> rotMat117;
+ rotMat117 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform117.rotate(rotMat117);
+ transform117.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans117 = std::make_shared<const Transform3D>(transform117);
+ std::shared_ptr<PerigeeSurface> perigeeSurface117 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams117 = BoundParameters(tgContext, std::move(covMat117), params117, perigeeSurface117);
+ tracks.push_back(boundParams117);
+
+
+ // track 118 :
+ BoundVector params118;
+ params118 << -0.103346407413482666, 19.7446269989013672, -1.91661596298217773, 1.42171478271484375, 0.000703335157595574856*1./(1_MeV), 0;
+ Covariance covMat118;
+ covMat118 << 0.00270943623036146164, -1.17879856763720662e-06, -7.38598630680866423e-05, 3.22994399828456964e-07, -4.07104504838410184e-08*1./(1_MeV), 0, -1.17879856763720662e-06, 0.0154081536456942558, -2.72538651083495857e-07, 0.000256186705875633325, 6.87005786986738928e-09*1./(1_MeV), 0, -7.38598630680866423e-05, -2.72538651083495857e-07, 2.10873281503154431e-06, -1.4483024887950514e-08, 1.8152406999218687e-09*1./(1_MeV), 0, 3.22994399828456964e-07, 0.000256186705875633325, -1.4483024887950514e-08, 5.78958861296996474e-06, 9.80498638799178923e-11*1./(1_MeV), 0, -4.07104504838410184e-08*1./(1_MeV), 6.87005786986738928e-09*1./(1_MeV), 1.8152406999218687e-09*1./(1_MeV), 9.80498638799178923e-11*1./(1_MeV), 6.60063531610077803e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform118;
+ ActsSymMatrixD<3> rotMat118;
+ rotMat118 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform118.rotate(rotMat118);
+ transform118.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans118 = std::make_shared<const Transform3D>(transform118);
+ std::shared_ptr<PerigeeSurface> perigeeSurface118 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams118 = BoundParameters(tgContext, std::move(covMat118), params118, perigeeSurface118);
+ tracks.push_back(boundParams118);
+
+
+ // track 119 :
+ BoundVector params119;
+ params119 << 2.92615675926208496, 17.8650016784667969, -1.95857036113739014, 1.128387451171875, 0.00111896148882806301*1./(1_MeV), 0;
+ Covariance covMat119;
+ covMat119 << 0.0144027825444936752, 0.000621878947040222689, -0.0004899059955729096, 7.73510238988940677e-07, -5.53971455935470655e-06*1./(1_MeV), 0, 0.000621878947040222689, 0.025294894352555275, -2.52380243351548066e-05, 0.000523347752496337772, -2.67676038791141531e-07*1./(1_MeV), 0, -0.0004899059955729096, -2.52380243351548066e-05, 1.7668540749582462e-05, -8.13551792131595242e-08, 2.65852444971337825e-07*1./(1_MeV), 0, 7.73510238988940677e-07, 0.000523347752496337772, -8.13551792131595242e-08, 1.16607652671518736e-05, 1.44441837008855634e-09*1./(1_MeV), 0, -5.53971455935470655e-06*1./(1_MeV), -2.67676038791141531e-07*1./(1_MeV), 2.65852444971337825e-07*1./(1_MeV), 1.44441837008855634e-09*1./(1_MeV), 9.32011001708588083e-09*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform119;
+ ActsSymMatrixD<3> rotMat119;
+ rotMat119 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform119.rotate(rotMat119);
+ transform119.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans119 = std::make_shared<const Transform3D>(transform119);
+ std::shared_ptr<PerigeeSurface> perigeeSurface119 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams119 = BoundParameters(tgContext, std::move(covMat119), params119, perigeeSurface119);
+ tracks.push_back(boundParams119);
+
+
+ // track 120 :
+ BoundVector params120;
+ params120 << -0.0391223952174186707, 19.8085842132568359, -1.63484728336334229, 1.43253195285797119, 0.00101388362236320972*1./(1_MeV), 0;
+ Covariance covMat120;
+ covMat120 << 0.00591104757040739059, 2.19808179401814768e-05, -0.000175305312354405934, 9.33348192222842228e-07, -8.2119913789129893e-08*1./(1_MeV), 0, 2.19808179401814768e-05, 0.0155321685597300529, -1.19100607880362392e-06, 0.000313805117109273242, -4.29338952794729048e-09*1./(1_MeV), 0, -0.000175305312354405934, -1.19100607880362392e-06, 5.27355723534128629e-06, -3.99720907755572675e-08, 3.63588214025051008e-09*1./(1_MeV), 0, 9.33348192222842228e-07, 0.000313805117109273242, -3.99720907755572675e-08, 7.98895416664890945e-06, -7.83235112558509684e-11*1./(1_MeV), 0, -8.2119913789129893e-08*1./(1_MeV), -4.29338952794729048e-09*1./(1_MeV), 3.63588214025051008e-09*1./(1_MeV), -7.83235112558509684e-11*1./(1_MeV), 1.22159560245194143e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform120;
+ ActsSymMatrixD<3> rotMat120;
+ rotMat120 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform120.rotate(rotMat120);
+ transform120.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans120 = std::make_shared<const Transform3D>(transform120);
+ std::shared_ptr<PerigeeSurface> perigeeSurface120 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams120 = BoundParameters(tgContext, std::move(covMat120), params120, perigeeSurface120);
+ tracks.push_back(boundParams120);
+
+
+ // track 121 :
+ BoundVector params121;
+ params121 << 3.2684485912322998, -50.3953475952148438, -1.9672924280166626, 2.11276745796203613, -0.00146105431485921144*1./(1_MeV), 0;
+ Covariance covMat121;
+ covMat121 << 0.0276485588401556015, -0.00123167623434729842, -0.000845118835855476042, 1.50004803399650862e-05, -1.34122397572779639e-07*1./(1_MeV), 0, -0.00123167623434729842, 0.0636397004127502441, 2.49535016337183792e-05, 0.00133656416735393577, -2.37478957538643704e-08*1./(1_MeV), 0, -0.000845118835855476042, 2.49535016337183792e-05, 2.60623473877785727e-05, -7.59009162244489968e-07, 7.34075798768037725e-09*1./(1_MeV), 0, 1.50004803399650862e-05, 0.00133656416735393577, -7.59009162244489968e-07, 2.95604022539919242e-05, -8.85865579693641169e-10*1./(1_MeV), 0, -1.34122397572779639e-07*1./(1_MeV), -2.37478957538643704e-08*1./(1_MeV), 7.34075798768037725e-09*1./(1_MeV), -8.85865579693641169e-10*1./(1_MeV), 2.87734891468716114e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform121;
+ ActsSymMatrixD<3> rotMat121;
+ rotMat121 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform121.rotate(rotMat121);
+ transform121.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans121 = std::make_shared<const Transform3D>(transform121);
+ std::shared_ptr<PerigeeSurface> perigeeSurface121 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams121 = BoundParameters(tgContext, std::move(covMat121), params121, perigeeSurface121);
+ tracks.push_back(boundParams121);
+
+
+ // track 122 :
+ BoundVector params122;
+ params122 << 0.645450115203857422, 28.7973823547363281, 2.10054993629455566, 2.9601600170135498, -0.000159988034283742309*1./(1_MeV), 0;
+ Covariance covMat122;
+ covMat122 << 0.0836148038506507874, -0.00281942085938153468, -0.00185879864445105355, 6.07247514248449154e-06, -7.03189829531797196e-07*1./(1_MeV), 0, -0.00281942085938153468, 2.70882201194763184, -5.8760191905531437e-05, 0.00188818417948824089, -4.8300783514351801e-08*1./(1_MeV), 0, -0.00185879864445105355, -5.8760191905531437e-05, 4.32657325291074812e-05, -2.25070179677390569e-07, 2.13601337599813795e-08*1./(1_MeV), 0, 6.07247514248449154e-06, 0.00188818417948824089, -2.25070179677390569e-07, 1.36935625505429925e-06, -1.00269941249161656e-10*1./(1_MeV), 0, -7.03189829531797196e-07*1./(1_MeV), -4.8300783514351801e-08*1./(1_MeV), 2.13601337599813795e-08*1./(1_MeV), -1.00269941249161656e-10*1./(1_MeV), 9.22178722273514495e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform122;
+ ActsSymMatrixD<3> rotMat122;
+ rotMat122 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform122.rotate(rotMat122);
+ transform122.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans122 = std::make_shared<const Transform3D>(transform122);
+ std::shared_ptr<PerigeeSurface> perigeeSurface122 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams122 = BoundParameters(tgContext, std::move(covMat122), params122, perigeeSurface122);
+ tracks.push_back(boundParams122);
+
+
+ // track 123 :
+ BoundVector params123;
+ params123 << -0.260677635669708252, 19.68109130859375, -0.0893123745918273926, 2.24275779724121094, 0.000180564093170687556*1./(1_MeV), 0;
+ Covariance covMat123;
+ covMat123 << 0.00429143151268362999, -0.000282303309317850546, -5.84570627457094727e-05, -1.77592772045934701e-06, -5.25916079357569643e-08*1./(1_MeV), 0, -0.000282303309317850546, 0.0253302454948425293, 3.20487213205718757e-06, 0.00012674431483371596, 5.10278523593403899e-09*1./(1_MeV), 0, -5.84570627457094727e-05, 3.20487213205718757e-06, 9.13998974283458665e-07, 2.36155606611666679e-08, 8.36921112357011164e-10*1./(1_MeV), 0, -1.77592772045934701e-06, 0.00012674431483371596, 2.36155606611666679e-08, 9.15854911909264047e-07, 4.54410066110091468e-11*1./(1_MeV), 0, -5.25916079357569643e-08*1./(1_MeV), 5.10278523593403899e-09*1./(1_MeV), 8.36921112357011164e-10*1./(1_MeV), 4.54410066110091468e-11*1./(1_MeV), 8.13594937948414199e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
+ Transform3D transform123;
+ ActsSymMatrixD<3> rotMat123;
+ rotMat123 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+ transform123.rotate(rotMat123);
+ transform123.translation() = Vector3D(-0.5,-0.5,0);
+ auto sharedTrans123 = std::make_shared<const Transform3D>(transform123);
+ std::shared_ptr<PerigeeSurface> perigeeSurface123 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
+ auto boundParams123 = BoundParameters(tgContext, std::move(covMat123), params123, perigeeSurface123);
+ tracks.push_back(boundParams123);
+
+return tracks;
+
+}
+
+
+
 }  // namespace Test
 }  // namespace Acts
-- 
GitLab


From 3696b985c5a372becb784fb1c8ac4758983e54b3 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Wed, 26 Feb 2020 17:38:11 +0100
Subject: [PATCH 26/60] add time information to trackAtVertexs ID for debugging

---
 Core/include/Acts/Vertexing/TrackAtVertex.hpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/Core/include/Acts/Vertexing/TrackAtVertex.hpp b/Core/include/Acts/Vertexing/TrackAtVertex.hpp
index 3dcd2b791..e40d76d8c 100644
--- a/Core/include/Acts/Vertexing/TrackAtVertex.hpp
+++ b/Core/include/Acts/Vertexing/TrackAtVertex.hpp
@@ -12,6 +12,7 @@
 #include <functional>
 #include "Acts/EventData/TrackParameters.hpp"
 #include "Acts/Vertexing/LinearizedTrack.hpp"
+#include <chrono>
 
 namespace Acts {
 
@@ -41,9 +42,13 @@ struct TrackAtVertex {
         trackWeight(1.),
         vertexCompatibility(0.) {
     // Create unique ID for this object
+    unsigned long int now = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
+    
     boost::hash_combine(id, this);
     boost::hash_combine(id, paramsAtVertex.parameters()[0]);
     boost::hash_combine(id, paramsAtVertex.parameters()[1]);
+    boost::hash_combine(id, now);
+    
   }
 
   /// @brief Constructor with default chi2
@@ -60,9 +65,12 @@ struct TrackAtVertex {
         trackWeight(1.),
         vertexCompatibility(0.) {
     // Create unique ID for this object
+    unsigned long int now = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
+    
     boost::hash_combine(id, this);
     boost::hash_combine(id, paramsAtVertex.parameters()[0]);
     boost::hash_combine(id, paramsAtVertex.parameters()[1]);
+    boost::hash_combine(id, now);
   }
 
   /// Chi2 of track
-- 
GitLab


From 10e460d0bd457ac387ed26e4a118f33281df035c Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Thu, 27 Feb 2020 17:41:41 +0100
Subject: [PATCH 27/60] change vertex EDM to not store TrackAtVertex in Vertex
 anymore pt. 1

---
 Core/include/Acts/Vertexing/AMVFInfo.hpp      |   14 +-
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   |   80 +-
 .../Vertexing/AdaptiveMultiVertexFitter.hpp   |   40 +-
 .../Vertexing/AdaptiveMultiVertexFitter.ipp   |  136 +-
 .../Vertexing/KalmanVertexTrackUpdater.ipp    |   38 +-
 Core/include/Acts/Vertexing/TrackAtVertex.hpp |   25 +-
 .../Vertexing/TrackToVertexIPEstimator.ipp    |    8 +-
 Core/include/Acts/Vertexing/legacy/AMVF.cxx   | 1089 +++
 Core/include/Acts/Vertexing/legacy/AMVF.h     |  327 +
 .../AdaptiveMultiVertexFinderTests.cpp        | 5957 +++++++++++------
 .../AdaptiveMultiVertexFitterTests.cpp        |  202 +-
 Tests/UnitTests/Core/Vertexing/CMakeLists.txt |    4 +-
 .../KalmanVertexTrackUpdaterTests.cpp         |    9 +-
 13 files changed, 5647 insertions(+), 2282 deletions(-)
 create mode 100644 Core/include/Acts/Vertexing/legacy/AMVF.cxx
 create mode 100644 Core/include/Acts/Vertexing/legacy/AMVF.h

diff --git a/Core/include/Acts/Vertexing/AMVFInfo.hpp b/Core/include/Acts/Vertexing/AMVFInfo.hpp
index a244400c0..74297bdc8 100644
--- a/Core/include/Acts/Vertexing/AMVFInfo.hpp
+++ b/Core/include/Acts/Vertexing/AMVFInfo.hpp
@@ -35,21 +35,17 @@ struct VertexInfo {
   // Old position from last iteration
   Acts::SpacePointVector oldPosition{Acts::SpacePointVector::Zero()};
 
+  // The seed position
   Acts::SpacePointVector seedPosition{Acts::SpacePointVector::Zero()};
 
   // Needs relinearization bool
   bool relinearize;
-};
 
-/// @brief Helper struct for storing TrackAtVertex related
-template <typename input_track_t>
-struct TrackAtVertexInfo {
-  // Links to vertices currently using the TrackAtVertex object
-  std::vector<Vertex<input_track_t>*> linksToVertices;
+  // Vector of all track currently held by vertex
+  std::vector<const input_track_t*> trackLinks;
 
-  // Track parameters at point of closest approach in 3d as
-  // retrieved by ImpactPoint3dEstimator::getParamsAtClosestApproach
-  std::unique_ptr<const BoundParameters> ip3dParams;
+  std::map<const input_track_t*, std::unique_ptr<const BoundParameters>>
+      ip3dParams;
 };
 
 }  // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index cf24f4f87..9d883b324 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -46,7 +46,6 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
   while (((m_cfg.addSingleTrackVertices && seedTracks.size() > 0) ||
           ((!m_cfg.addSingleTrackVertices) && seedTracks.size() > 1)) &&
          iteration < m_cfg.maxIterations) {
-  	
     // Tracks that are used for searching compatible tracks
     // near a vertex candidate
     // TODO: This involves a lot of copying. Change the way of accessing tracks
@@ -59,9 +58,9 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     Vertex<InputTrack_t> currentConstraint = vFinderOptions.vertexConstraint;
     // Retrieve seed vertex from all remaining seedTracks
     auto seedResult = doSeeding(seedTracks, currentConstraint, vFinderOptions);
-    if (!seedResult.ok()) {    	
+    if (!seedResult.ok()) {
       return seedResult.error();
-    }    
+    }
     allVertices.push_back(std::make_unique<Vertex<InputTrack_t>>(*seedResult));
 
     Vertex<InputTrack_t>* vtxCandidate = (allVertices.back()).get();
@@ -69,7 +68,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
 
     ACTS_DEBUG("Position of current vertex candidate after seeding: "
                << vtxCandidate->fullPosition());
-    if (vtxCandidate->position().z() == 0.) {    	
+    if (vtxCandidate->position().z() == 0.) {
       ACTS_DEBUG(
           "No seed found anymore. Break and stop primary vertex finding.");
       break;
@@ -77,21 +76,21 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     auto prepResult = canPrepareVertexForFit(myTracks, seedTracks, vtxCandidate,
                                              currentConstraint, fitterState);
 
-    if (!prepResult.ok()) {    	
+    if (!prepResult.ok()) {
       return prepResult.error();
     }
-    if (!(*prepResult)) {    	
+    if (!(*prepResult)) {
       ACTS_DEBUG("Could not prepare for fit anymore. Break.");
       break;
     }
     // Update fitter state with all vertices
-    fitterState.updateVertexList(allVerticesPtr);    
+    fitterState.updateVertexList(allVerticesPtr);
     // Perform the fit
     auto fitResult = m_cfg.vertexFitter.addVtxToFit(
         fitterState, *vtxCandidate, m_cfg.linearizer, vFitterOptions);
-    if (!fitResult.ok()) {    	
+    if (!fitResult.ok()) {
       return fitResult.error();
-    }    
+    }
     ACTS_DEBUG("New position of current vertex candidate after fit: "
                << vtxCandidate->fullPosition());
 
@@ -101,7 +100,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     checkVertexAndCompatibleTracks(vtxCandidate, seedTracks, nCompatibleTracks,
                                    isGoodVertex);
 
-    ACTS_DEBUG("Vertex is good vertex: " << isGoodVertex);    
+    ACTS_DEBUG("Vertex is good vertex: " << isGoodVertex);
     if (nCompatibleTracks > 0) {
       removeCompatibleTracksFromSeedTracks(vtxCandidate, seedTracks);
     } else {
@@ -113,7 +112,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
             "Could not remove any further track from seed tracks. Break.");
         break;
       }
-    }    
+    }
     bool keepVertex = keepNewVertex(vtxCandidate, allVerticesPtr, isGoodVertex);
     ACTS_DEBUG("New vertex will be saved: " << keepVertex);
 
@@ -123,20 +122,20 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
       allVerticesPtr.pop_back();
       // Update fitter state with removed vertex candidate
       fitterState.updateVertexList(allVerticesPtr);
-    
+
       // Do the fit with removed vertex
       auto fitResult = m_cfg.vertexFitter.fit(fitterState, allVerticesPtr,
                                               m_cfg.linearizer, vFitterOptions);
-      if (!fitResult.ok()) {      	
+      if (!fitResult.ok()) {
         return fitResult.error();
-      }      
-    }  
-    iteration++;  
-  } // end while loop
+      }
+    }
+    iteration++;
+  }  // end while loop
 
   std::vector<Vertex<InputTrack_t>> outputVec;
 
-  for(auto vtx : allVerticesPtr){
+  for (auto vtx : allVerticesPtr) {
     outputVec.push_back(*vtx);
   }
 
@@ -149,7 +148,6 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::doSeeding(
     Vertex<InputTrack_t>& currentConstraint,
     const VertexFinderOptions<InputTrack_t>& vFinderOptions) const
     -> Result<Vertex<InputTrack_t>> {
-
   VertexFinderOptions<InputTrack_t> seedOptions = vFinderOptions;
   seedOptions.vertexConstraint = currentConstraint;
   // Run seed finder
@@ -162,21 +160,19 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::doSeeding(
   Vertex<InputTrack_t> seedVertex = (*seedResult).back();
   // Update constraints according to seed vertex
   if (m_cfg.useBeamSpotConstraint) {
-  	if (currentConstraint.fullCovariance() == SpacePointSymMatrix::Zero()){
-  		ACTS_WARNING("No constraint provided, but useBeamSpotConstraint set to true.");
-  	}
+    if (currentConstraint.fullCovariance() == SpacePointSymMatrix::Zero()) {
+      ACTS_WARNING(
+          "No constraint provided, but useBeamSpotConstraint set to true.");
+    }
     if (m_cfg.useSeedConstraint) {
-      currentConstraint.setFullPosition(
-          seedVertex.fullPosition());
-      currentConstraint.setFullCovariance(
-          seedVertex.fullCovariance());
+      currentConstraint.setFullPosition(seedVertex.fullPosition());
+      currentConstraint.setFullCovariance(seedVertex.fullCovariance());
     }
   } else {
     currentConstraint.setFullPosition(seedVertex.fullPosition());
-    currentConstraint.setFullCovariance(
-        SpacePointSymMatrix::Identity() * m_cfg.looseConstrValue);
-    currentConstraint.setFitQuality(
-        m_cfg.defaultConstrFitQuality);
+    currentConstraint.setFullCovariance(SpacePointSymMatrix::Identity() *
+                                        m_cfg.looseConstrValue);
+    currentConstraint.setFitQuality(m_cfg.defaultConstrFitQuality);
   }
 
   return seedVertex;
@@ -286,8 +282,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
       vtx->setFullPosition(SpacePointVector(0., 0., newZ, 0.));
 
       // Update vertex info for current vertex
-      fitterState.vtxInfoMap[vtx] = VertexInfo<InputTrack_t>(
-          currentConstraint, vtx->fullPosition());
+      fitterState.vtxInfoMap[vtx] =
+          VertexInfo<InputTrack_t>(currentConstraint, vtx->fullPosition());
 
       // Try to add compatible track with adapted vertex position
       auto res = addCompatibleTracksToVertex(myTracks, vtx);
@@ -313,14 +309,14 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
-    canPrepareVertexForFit(
-        const std::vector<InputTrack_t>& myTracks,
-        const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>* vtx,
-        const Vertex<InputTrack_t>& currentConstraint,
-        FitterState_t& fitterState) const -> Result<bool> {
+    canPrepareVertexForFit(const std::vector<InputTrack_t>& myTracks,
+                           const std::vector<InputTrack_t>& seedTracks,
+                           Vertex<InputTrack_t>* vtx,
+                           const Vertex<InputTrack_t>& currentConstraint,
+                           FitterState_t& fitterState) const -> Result<bool> {
   // Add vertex info to fitter state
-  fitterState.vtxInfoMap[vtx] = VertexInfo<InputTrack_t>(
-      currentConstraint, vtx->fullPosition());
+  fitterState.vtxInfoMap[vtx] =
+      VertexInfo<InputTrack_t>(currentConstraint, vtx->fullPosition());
 
   // Add all compatible tracks to vertex
   auto resComp = addCompatibleTracksToVertex(myTracks, vtx);
@@ -328,8 +324,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     return Result<bool>::failure(resComp.error());
   }
   // Try to recover from cases where adding compatible track was not possible
-  auto resRec = canRecoverFromNoCompatibleTracks(myTracks, seedTracks, vtx,
-                                                 currentConstraint, fitterState);
+  auto resRec = canRecoverFromNoCompatibleTracks(
+      myTracks, seedTracks, vtx, currentConstraint, fitterState);
   if (!resRec.ok()) {
     return Result<bool>::failure(resRec.error());
   }
@@ -488,7 +484,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::isMergedVertex(
   const double candidateZCov = candidateCov(eZ, eZ);
 
   for (const auto otherVtx : allVertices) {
-    if(vtx == otherVtx){
+    if (vtx == otherVtx) {
       continue;
     }
     const SpacePointVector& otherPos = otherVtx->fullPosition();
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
index dc35201cb..b33841262 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
@@ -61,39 +61,45 @@ class AdaptiveMultiVertexFitter {
     // Map to store vertices information
     std::map<Vertex<InputTrack_t>*, VertexInfo<InputTrack_t>> vtxInfoMap;
 
-    // Map to store tracks information
-    std::map<unsigned long, TrackAtVertexInfo<InputTrack_t>> trkInfoMap;
+    std::multimap<const InputTrack_t*, Vertex<InputTrack_t>*>
+        trackToVerticesMultiMap;
+
+    std::map<std::pair<const InputTrack_t*, Vertex<InputTrack_t>*>,
+             TrackAtVertex<InputTrack_t>>
+        tracksAtVerticesMap;
 
     /// @brief Default State constructor
     State() = default;
 
-    /// @brief State constructor to initialize trkInfoMap::linksToVertices
+    /// @brief State constructor to initialize trackToVerticesMultiMap
     ///
     /// @param vtxList List of all vertices with trackAtVertex information
     State(std::vector<Vertex<input_track_t>>& vtxList) {
-      updateVertexList(vtxList);
+      updateTrkToVerticesMultiMap(vtxList);
     }
 
     State(std::vector<Vertex<input_track_t>*>& vtxList) {
-      updateVertexList(vtxList);
+      updateTrkToVerticesMultiMap(vtxList);
     }
 
-    void updateVertexList(std::vector<Vertex<input_track_t>>& vtxList) {
-      trkInfoMap.clear();
+    void updateTrkToVerticesMultiMap(
+        std::vector<Vertex<input_track_t>>& vtxList) {
+      trackToVerticesMultiMap.clear();
       for (auto& vtx : vtxList) {
-        // Add vertex link to each track
-        for (auto& trkAtVtx : vtx.tracks()) {
-          trkInfoMap[trkAtVtx.id].linksToVertices.push_back(&vtx);
+        // Add vertex link for each track
+        for (auto& trk : vtxInfoMap[&vtx].trackLinks) {
+          trackToVerticesMultiMap.insert(std::make_pair(trk, &vtx));
         }
       }
     }
 
-    void updateVertexList(std::vector<Vertex<input_track_t>*>& vtxList) {
-      trkInfoMap.clear();
-      for (auto& vtx : vtxList) {
-        // Add vertex link to each track  
-        for (auto& trkAtVtx : vtx->tracks()) {
-          trkInfoMap[trkAtVtx.id].linksToVertices.push_back(vtx);
+    void updateTrkToVerticesMultiMap(
+        std::vector<Vertex<input_track_t>*>& vtxList) {
+      trackToVerticesMultiMap.clear();
+      for (auto vtx : vtxList) {
+        // Add vertex link for each track
+        for (auto trk : vtxInfoMap[vtx].trackLinks) {
+          trackToVerticesMultiMap.insert(std::make_pair(trk, vtx));
         }
       }
     }
@@ -284,7 +290,7 @@ class AdaptiveMultiVertexFitter {
   ///
   /// @return Vector of compatibility values
   Result<std::vector<double>> collectTrackToVertexCompatibilities(
-      State& state, const TrackAtVertex<InputTrack_t>& trk) const;
+      State& state, const InputTrack_t* trk) const;
 
   /// @brief Determines if vertex position has shifted more than
   /// m_cfg.maxRelativeShift in last iteration
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
index c36778e46..4731b0fde 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
@@ -65,8 +65,7 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::fitImpl(
       auto dist = currentVtxInfo.oldPosition - currentVtxInfo.linPoint;
       double perpDist = std::sqrt(dist[0] * dist[0] + dist[1] * dist[1]);
       // Determine if relinearization is needed
-      if (perpDist >
-          m_cfg.maxDistToLinPoint) {
+      if (perpDist > m_cfg.maxDistToLinPoint) {
         // Relinearization needed, distance too big
         currentVtxInfo.relinearize = true;
         // Prepare for fit with new vertex position
@@ -91,7 +90,6 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::fitImpl(
       auto weight =
           1. / m_cfg.annealingTool.getWeight(state.annealingState, 1.);
 
-
       auto covAnn = currentVtx->fullCovariance() * weight;
       currentVtx->setCovariance(covAnn.template block<3, 3>(0, 0));
 
@@ -107,7 +105,6 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::fitImpl(
     if (!state.annealingState.equilibriumReached) {
       m_cfg.annealingTool.anneal(state.annealingState);
     }
-
     isSmallShift = checkSmallShift(state);
 
     ++nIter;
@@ -135,7 +132,7 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::addVtxToFit(
     State& state, Vertex<input_track_t>& newVertex,
     const linearizer_t& linearizer,
     const VertexFitterOptions<input_track_t>& vFitterOptions) const {
-  if (newVertex.tracks().empty()) {
+  if (state.vtxInfoMap[&newVertex].trackLinks.empty()) {
     return VertexingError::EmptyInput;
   }
 
@@ -147,7 +144,6 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::addVtxToFit(
   if (!res.ok()) {
     return res.error();
   }
-
   // List of vertices added in last iteration
   std::vector<Vertex<input_track_t>*> lastIterAddedVertices = {&newVertex};
   // List of vertices added in current iteration
@@ -158,16 +154,17 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::addVtxToFit(
   while (!lastIterAddedVertices.empty()) {
     for (auto& lastVtxIter : lastIterAddedVertices) {
       // Loop over all track at current lastVtxIter
-      for (const TrackAtVertex<input_track_t>& trackIter :
-           lastVtxIter->tracks()) {
+      const std::vector<const input_track_t*>& trks =
+          state.vtxInfoMap[lastVtxIter].trackLinks;
+      for (const auto& trk : trks) {
         // Retrieve list of links to all vertices that currently use the current
         // track
-        std::vector<Vertex<input_track_t>*>& linksToVertices =
-            state.trkInfoMap[trackIter.id].linksToVertices;
+        auto range = state.trackToVerticesMultiMap.equal_range(trk);
 
         // Loop over all attached vertices and add those to vertex fit
         // which are not already in `verticesToFit`
-        for (auto newVtxIter : linksToVertices) {
+        for (auto vtxIter = range.first; vtxIter != range.second; ++vtxIter) {
+          auto newVtxIter = vtxIter->second;
           if (!isAlreadyInList(newVtxIter, verticesToFit)) {
             // Add newVtxIter to verticesToFit
             verticesToFit.push_back(newVtxIter);
@@ -190,7 +187,6 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::addVtxToFit(
 
   // Perform fit on all added vertices
   auto fitRes = fitImpl(state, linearizer, vFitterOptions);
-
   if (!fitRes.ok()) {
     return fitRes.error();
   }
@@ -212,19 +208,22 @@ Acts::Result<void> Acts::
     AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::prepareVertexForFit(
         State& state, Vertex<input_track_t>* vtx,
         const VertexFitterOptions<input_track_t>& vFitterOptions) const {
-  const Vector3D& seedPos =
-      state.vtxInfoMap[vtx].seedPosition.template head<3>();
+  // The current vertex info object
+  auto& currentVtxInfo = state.vtxInfoMap[vtx];
+  // The seed position
+  const Vector3D& seedPos = currentVtxInfo.seedPosition.template head<3>();
   auto& geoContext = vFitterOptions.geoContext;
 
   // Loop over all tracks at current vertex
-  for (const auto& trkAtVtx : vtx->tracks()) {
-    auto res = m_cfg.ipEst.getParamsAtClosestApproach(
-        geoContext, m_extractParameters(trkAtVtx.originalTrack), seedPos);
+  for (const auto& trk : currentVtxInfo.trackLinks) {
+    auto res =
+        m_cfg.ipEst.getParamsAtClosestApproach(geoContext, *trk, seedPos);
     if (!res.ok()) {
       return res.error();
     }
     // Set ip3dParams for current trackAtVertex
-    state.trkInfoMap[trkAtVtx.id].ip3dParams = std::move(res.value());
+    currentVtxInfo.ip3dParams.insert(
+        std::make_pair(trk, std::move(res.value())));
   }
   return {};
 }
@@ -235,48 +234,35 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::
     setAllVertexCompatibilities(State& state, const GeometryContext& geoContext,
                                 Vertex<input_track_t>* currentVtx) const {
   VertexInfo<input_track_t>& currentVtxInfo = state.vtxInfoMap[currentVtx];
-  // Create empty list of new TrackAtVertex objects
-  // to be filled below. Needed due to constness of
-  // tracksAtVertex list at vertex
-  std::vector<TrackAtVertex<input_track_t>> newTracks;
-  newTracks.reserve(currentVtx->tracks().size());
 
   // Loop over tracks at current vertex and
   // estimate compatibility with vertex
-  for (auto& trkAtVtx : currentVtx->tracks()) {
+  for (const auto& trk : currentVtxInfo.trackLinks) {
+    auto& trkAtVtx =
+        state.tracksAtVerticesMap.at(std::make_pair(trk, currentVtx));
     // Recover from cases where linearization point != 0 but
     // more tracks were added later on
-    if (!state.trkInfoMap[trkAtVtx.id].ip3dParams) {
+    if (currentVtxInfo.ip3dParams.find(trk) ==
+        currentVtxInfo.ip3dParams.end()) {
       auto res = m_cfg.ipEst.getParamsAtClosestApproach(
-          geoContext, m_extractParameters(trkAtVtx.originalTrack),
-          VectorHelpers::position(currentVtxInfo.linPoint));
+          geoContext, *trk, VectorHelpers::position(currentVtxInfo.linPoint));
       if (!res.ok()) {
         return res.error();
       }
       // Set ip3dParams for current trackAtVertex
       auto value = std::move(res.value());
 
-      state.trkInfoMap[trkAtVtx.id].ip3dParams = std::move(value);
+      currentVtxInfo.ip3dParams.insert(std::make_pair(trk, std::move(value)));
     }
-
-    // Create copy of current trackAtVertex in order
-    // to modify it below
-    newTracks.push_back(trkAtVtx);
-    TrackAtVertex<input_track_t>* newTrkPtr = &(newTracks.back());
-
     // Set compatibility with current vertex
     auto compRes = m_cfg.ipEst.getVertexCompatibility(
-        geoContext, state.trkInfoMap[trkAtVtx.id].ip3dParams.get(),
+        geoContext, currentVtxInfo.ip3dParams.at(trk).get(),
         VectorHelpers::position(currentVtxInfo.oldPosition));
-
     if (!compRes.ok()) {
       return compRes.error();
     }
-    double comp = *compRes;
-    newTrkPtr->vertexCompatibility = *compRes;
+    trkAtVtx.vertexCompatibility = *compRes;
   }
-  // Set list of updated tracks to current vertex
-  currentVtx->setTracksAtVertex(newTracks);
   return {};
 }
 
@@ -286,47 +272,38 @@ Acts::Result<void> Acts::AdaptiveMultiVertexFitter<
                                                       const linearizer_t&
                                                           linearizer) const {
   for (auto vtx : state.vertexCollection) {
-    // Create empty list of new TrackAtVertex objects
-    // to be filled below. Needed due to constness of
-    // tracksAtVertex list at vertex
-    std::vector<TrackAtVertex<input_track_t>> newTracks;
-    newTracks.reserve(vtx->tracks().size());
-
-    auto oldTracks = vtx->tracks();
-    for (const auto& trkAtVtx : oldTracks) {
-      // Create copy of current trackAtVertex in order
-      // to modify it below
-      newTracks.push_back(trkAtVtx);
-      TrackAtVertex<input_track_t>* newTrkPtr = &(newTracks.back());
+    VertexInfo<input_track_t>& currentVtxInfo = state.vtxInfoMap[vtx];
+
+    for (const auto& trk : currentVtxInfo.trackLinks) {
+      auto& trkAtVtx = state.tracksAtVerticesMap.at(std::make_pair(trk, vtx));
+
       // Get all compatibilities of track to all vertices it is attached to
-      auto collectRes = collectTrackToVertexCompatibilities(state, trkAtVtx);
+      auto collectRes = collectTrackToVertexCompatibilities(state, trk);
       if (!collectRes.ok()) {
         return collectRes.error();
       }
       // Set trackWeight for current track
       double currentTrkWeight = m_cfg.annealingTool.getWeight(
           state.annealingState, trkAtVtx.vertexCompatibility, *collectRes);
-      newTrkPtr->trackWeight = currentTrkWeight;
+      trkAtVtx.trackWeight = currentTrkWeight;
 
-      if (newTrkPtr->trackWeight > m_cfg.minWeight) {
+      if (trkAtVtx.trackWeight > m_cfg.minWeight) {
         // Check if linearization state exists or need to be relinearized
-        if (newTrkPtr->linearizedState.covarianceAtPCA ==
+        if (trkAtVtx.linearizedState.covarianceAtPCA ==
                 BoundSymMatrix::Zero() ||
             state.vtxInfoMap[vtx].relinearize) {
-          const auto& origParams =
-              m_extractParameters(newTrkPtr->originalTrack);
-          auto result = linearizer.linearizeTrack(
-              &origParams, state.vtxInfoMap[vtx].oldPosition);
+          auto result =
+              linearizer.linearizeTrack(trk, state.vtxInfoMap[vtx].oldPosition);
           if (!result.ok()) {
             return result.error();
           }
-          newTrkPtr->linearizedState = *result;
+          trkAtVtx.linearizedState = *result;
           state.vtxInfoMap[vtx].linPoint = state.vtxInfoMap[vtx].oldPosition;
         }
         // Update the vertex with the new track
         auto updateRes =
             KalmanVertexUpdater::updateVertexWithTrack<input_track_t>(
-                vtx, *newTrkPtr);
+                vtx, trkAtVtx);
         if (!updateRes.ok()) {
           return updateRes.error();
         }
@@ -335,8 +312,6 @@ Acts::Result<void> Acts::AdaptiveMultiVertexFitter<
       }
     }  // End loop over tracks at vertex
 
-    vtx->setTracksAtVertex(newTracks);
-
     ACTS_VERBOSE("New vertex position: " << vtx->fullPosition());
   }  // End loop over vertex collection
 
@@ -346,32 +321,17 @@ Acts::Result<void> Acts::AdaptiveMultiVertexFitter<
 template <typename input_track_t, typename linearizer_t>
 Acts::Result<std::vector<double>>
 Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::
-    collectTrackToVertexCompatibilities(
-        State& state, const TrackAtVertex<input_track_t>& trk) const {
-  // All vertices that currently hold the track `trk`
-  std::vector<Vertex<input_track_t>*> vertices =
-      state.trkInfoMap[trk.id].linksToVertices;
-
-  // Vector to store all compatibility values, it will have
-  // exactly the size of `vertices`(one value for each vertex
-  // the track is attached to)
+    collectTrackToVertexCompatibilities(State& state,
+                                        const input_track_t* trk) const {
   std::vector<double> trkToVtxCompatibilities;
-  trkToVtxCompatibilities.reserve(vertices.size());
-
-  for (Vertex<input_track_t>* vtxPtr : vertices) {
-    // find current track in list of tracks at vertex
-    const auto& trkIter = std::find_if(
-        vtxPtr->tracks().begin(), vtxPtr->tracks().end(),
-        [&trk, this](auto& trkAtVtx) {
-          return this->m_extractParameters(trkAtVtx.originalTrack) ==
-                 this->m_extractParameters(trk.originalTrack);
-        });
-    if (trkIter == vtxPtr->tracks().end()) {
-      return VertexingError::ElementNotFound;
-    }
-    // store vertexCompatibility of track to current vertex
-    trkToVtxCompatibilities.push_back(trkIter->vertexCompatibility);
+  auto range = state.trackToVerticesMultiMap.equal_range(trk);
+
+  for (auto vtxIter = range.first; vtxIter != range.second; ++vtxIter) {
+    trkToVtxCompatibilities.push_back(
+        state.tracksAtVerticesMap.at(std::make_pair(trk, vtxIter->second))
+            .vertexCompatibility);
   }
+
   return trkToVtxCompatibilities;
 }
 
diff --git a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
index f2829f40d..d8e60721d 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
+++ b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
@@ -34,13 +34,14 @@ Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
   const auto& posJac = linTrack.positionJacobian.block<5, 3>(0, 0);
   const auto& momJac = linTrack.momentumJacobian.block<5, 3>(0, 0);
   const auto& trkParams = linTrack.parametersAtPCA.head<5>();
-  const auto& trkParamWeight = (linTrack.covarianceAtPCA.block<5, 5>(0, 0)).inverse();
+  const auto& trkParamWeight =
+      (linTrack.covarianceAtPCA.block<5, 5>(0, 0)).inverse();
 
   // Calculate S matrix
   ActsSymMatrixD<3> sMat =
       (momJac.transpose() * (trkParamWeight * momJac)).inverse();
 
-  const auto& residual = linTrack.constantTerm.head<5>();;
+  const auto& residual = linTrack.constantTerm.head<5>();
 
   // Refit track momentum
   Vector3D newTrkMomentum = sMat * momJac.transpose() * trkParamWeight *
@@ -80,34 +81,37 @@ Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
       (reducedVtx.fullCovariance().template block<3, 3>(0, 0)).inverse();
 
   // Difference in positions
-  auto posDiff = (vtx->fullPosition() - reducedVtx.fullPosition()).template head<3>();
+  auto posDiff =
+      (vtx->fullPosition() - reducedVtx.fullPosition()).template head<3>();
 
   // Get smoothed params
-  auto smParams = trkParams - (residual + posJac * vtx->fullPosition().template head<3>() +
-                                      momJac * newTrkMomentum);
+  auto smParams =
+      trkParams - (residual + posJac * vtx->fullPosition().template head<3>() +
+                   momJac * newTrkMomentum);
 
   // New chi2 to be set later
   double chi2 = posDiff.dot(reducedVtxWeight * posDiff) +
                 smParams.dot(trkParamWeight * smParams);
 
-
   // Not yet 4d ready. This can be removed together will all head<> statements,
   // once time is consistently introduced to vertexing
-  ActsMatrixD<SpacePointDim, 3> newFullTrkCov(ActsMatrixD<SpacePointDim, 3>::Zero());
-  newFullTrkCov.block<3,3>(0,0) = newTrkCov;
+  ActsMatrixD<SpacePointDim, 3> newFullTrkCov(
+      ActsMatrixD<SpacePointDim, 3>::Zero());
+  newFullTrkCov.block<3, 3>(0, 0) = newTrkCov;
 
   SpacePointSymMatrix vtxFullWeight(SpacePointSymMatrix::Zero());
-  vtxFullWeight.block<3,3>(0,0) = vtxWeight;
+  vtxFullWeight.block<3, 3>(0, 0) = vtxWeight;
 
   SpacePointSymMatrix vtxFullCov(SpacePointSymMatrix::Zero());
-  vtxFullCov.block<3,3>(0,0) = vtxCov;
+  vtxFullCov.block<3, 3>(0, 0) = vtxCov;
 
   const auto& fullPerTrackCov = detail::createFullTrackCovariance(
       sMat, newFullTrkCov, vtxFullWeight, vtxFullCov, newTrkParams);
 
   // Create new refitted parameters
   std::shared_ptr<PerigeeSurface> perigeeSurface =
-      Surface::makeShared<PerigeeSurface>(VectorHelpers::position(vtx->fullPosition()));
+      Surface::makeShared<PerigeeSurface>(
+          VectorHelpers::position(vtx->fullPosition()));
 
   BoundParameters refittedPerigee = BoundParameters(
       gctx, std::move(fullPerTrackCov), newTrkParams, perigeeSurface);
@@ -128,15 +132,16 @@ Acts::KalmanVertexTrackUpdater::detail::createFullTrackCovariance(
     const BoundVector& newTrkParams) {
   // Now new momentum covariance
   ActsSymMatrixD<3> momCov =
-      sMat + (newTrkCov.block<3,3>(0,0)).transpose() * (vtxWeight.block<3,3>(0,0) * newTrkCov.block<3,3>(0,0));
+      sMat + (newTrkCov.block<3, 3>(0, 0)).transpose() *
+                 (vtxWeight.block<3, 3>(0, 0) * newTrkCov.block<3, 3>(0, 0));
 
   // Full (x,y,z,phi, theta, q/p) covariance matrix
   // To be made 7d again after switching to (x,y,z,phi, theta, q/p, t)
   ActsSymMatrixD<6> fullTrkCov(ActsSymMatrixD<6>::Zero());
 
-  fullTrkCov.block<3, 3>(0, 0) = vtxCov.block<3,3>(0,0);
-  fullTrkCov.block<3, 3>(0, 3) = newTrkCov.block<3,3>(0,0);
-  fullTrkCov.block<3, 3>(3, 0) = (newTrkCov.block<3,3>(0,0)).transpose();
+  fullTrkCov.block<3, 3>(0, 0) = vtxCov.block<3, 3>(0, 0);
+  fullTrkCov.block<3, 3>(0, 3) = newTrkCov.block<3, 3>(0, 0);
+  fullTrkCov.block<3, 3>(3, 0) = (newTrkCov.block<3, 3>(0, 0)).transpose();
   fullTrkCov.block<3, 3>(3, 3) = momCov;
 
   // Combined track jacobian
@@ -156,7 +161,8 @@ Acts::KalmanVertexTrackUpdater::detail::createFullTrackCovariance(
 
   // Full perigee track covariance
   BoundMatrix fullPerTrackCov(BoundMatrix::Identity());
-  fullPerTrackCov.block<5,5>(0,0) = (trkJac * (fullTrkCov * trkJac.transpose()));
+  fullPerTrackCov.block<5, 5>(0, 0) =
+      (trkJac * (fullTrkCov * trkJac.transpose()));
 
   return fullPerTrackCov;
 }
diff --git a/Core/include/Acts/Vertexing/TrackAtVertex.hpp b/Core/include/Acts/Vertexing/TrackAtVertex.hpp
index e40d76d8c..0c03d2ba4 100644
--- a/Core/include/Acts/Vertexing/TrackAtVertex.hpp
+++ b/Core/include/Acts/Vertexing/TrackAtVertex.hpp
@@ -9,10 +9,10 @@
 #pragma once
 
 #include <boost/functional/hash.hpp>
+#include <chrono>
 #include <functional>
 #include "Acts/EventData/TrackParameters.hpp"
 #include "Acts/Vertexing/LinearizedTrack.hpp"
-#include <chrono>
 
 namespace Acts {
 
@@ -42,13 +42,15 @@ struct TrackAtVertex {
         trackWeight(1.),
         vertexCompatibility(0.) {
     // Create unique ID for this object
-    unsigned long int now = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
-    
+    unsigned long int now =
+        std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::system_clock::now().time_since_epoch())
+            .count();
+
     boost::hash_combine(id, this);
     boost::hash_combine(id, paramsAtVertex.parameters()[0]);
     boost::hash_combine(id, paramsAtVertex.parameters()[1]);
     boost::hash_combine(id, now);
-    
   }
 
   /// @brief Constructor with default chi2
@@ -65,8 +67,11 @@ struct TrackAtVertex {
         trackWeight(1.),
         vertexCompatibility(0.) {
     // Create unique ID for this object
-    unsigned long int now = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
-    
+    unsigned long int now =
+        std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::system_clock::now().time_since_epoch())
+            .count();
+
     boost::hash_combine(id, this);
     boost::hash_combine(id, paramsAtVertex.parameters()[0]);
     boost::hash_combine(id, paramsAtVertex.parameters()[1]);
@@ -86,8 +91,12 @@ struct TrackAtVertex {
   BoundParameters fittedParams;
 
   /// Original input track
+  // TODO: to be fully replaced by pointer version below
   input_track_t originalTrack;
 
+  /// Original input parameters
+  input_track_t* originalTrack2;
+
   /// Weight of track in fit
   double trackWeight;
 
@@ -100,6 +109,10 @@ struct TrackAtVertex {
 
   /// Unique ID
   unsigned long id;
+
+  // Track parameters at point of closest approach in 3d as
+  // retrieved by ImpactPoint3dEstimator::getParamsAtClosestApproach
+  // std::unique_ptr<const BoundParameters> ip3dParams;
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Vertexing/TrackToVertexIPEstimator.ipp b/Core/include/Acts/Vertexing/TrackToVertexIPEstimator.ipp
index 6722ae6a2..e570e3e24 100644
--- a/Core/include/Acts/Vertexing/TrackToVertexIPEstimator.ipp
+++ b/Core/include/Acts/Vertexing/TrackToVertexIPEstimator.ipp
@@ -21,7 +21,7 @@ Acts::TrackToVertexIPEstimator<
   // trajectory anymore
 
   const Vector3D& lp = vtx.position();
-  
+
   const std::shared_ptr<PerigeeSurface> perigeeSurface =
       Surface::makeShared<PerigeeSurface>(lp);
 
@@ -80,7 +80,8 @@ Acts::TrackToVertexIPEstimator<
     newIPandSigma->PVsigmaz0SinTheta =
         std::sqrt(std::sin(theta) * vtxZZCov * std::sin(theta));
     newIPandSigma->IPz0 = z0;
-    newIPandSigma->sigmaz0 = std::sqrt(vtxZZCov + perigeeCov(ParID_t::eLOC_Z0, ParID_t::eLOC_Z0));
+    newIPandSigma->sigmaz0 =
+        std::sqrt(vtxZZCov + perigeeCov(ParID_t::eLOC_Z0, ParID_t::eLOC_Z0));
     newIPandSigma->PVsigmaz0 = std::sqrt(vtxZZCov);
   } else {
     ACTS_WARNING(
@@ -93,7 +94,8 @@ Acts::TrackToVertexIPEstimator<
     newIPandSigma->PVsigmaz0SinTheta = 0;
 
     newIPandSigma->IPz0 = z0;
-    newIPandSigma->sigmaz0 = std::sqrt(perigeeCov(ParID_t::eLOC_Z0, ParID_t::eLOC_Z0));
+    newIPandSigma->sigmaz0 =
+        std::sqrt(perigeeCov(ParID_t::eLOC_Z0, ParID_t::eLOC_Z0));
     newIPandSigma->PVsigmaz0 = 0;
   }
 
diff --git a/Core/include/Acts/Vertexing/legacy/AMVF.cxx b/Core/include/Acts/Vertexing/legacy/AMVF.cxx
new file mode 100644
index 000000000..e6b897bda
--- /dev/null
+++ b/Core/include/Acts/Vertexing/legacy/AMVF.cxx
@@ -0,0 +1,1089 @@
+/*
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+/***************************************************************************
+                         InDetAdaptivePriVxFinderTool.cxx  -  Description
+                             -------------------
+    begin   : 29-05-2006
+    authors : Giacinto Piacquadio (Freiburg Univ),
+              this is a modified version of the adaptive primary vertex finder to fit more vertexes at the same time
+    changes :
+          06/12/2006   Kirill.Prokofiev@cern.ch
+          EDM cleanup and switching to the FitQuality use
+              2007-02-15  bug fix by scott s snyder  <snyder@bnl.gov>
+              Fix memory leak.  Don't use a map for sorting.
+              2007-10-xx  Giacinto Piacquadio
+                          Many improvements (MultiVertexFinder v. 2)
+              2016-03-09  D. Casper
+                          Change default value of TracksMaxZinterval to 1 mm
+                          (trial working point for high luminosities)
+
+***************************************************************************/
+#include "VxVertex/RecVertex.h"
+#include "VxVertex/Vertex.h"
+#include "InDetPriVxFinderTool/InDetAdaptiveMultiPriVxFinderTool.h"
+#include "TrkTrack/Track.h"
+#include "TrkParameters/TrackParameters.h"
+#include <map>
+#include <vector>
+
+#include "EventPrimitives/EventPrimitives.h"
+#include "EventPrimitives/EventPrimitivesHelpers.h"
+#include "GeoPrimitives/GeoPrimitives.h"
+
+#include "NN.h"
+#include "InDetTrackSelectionTool/IInDetTrackSelectionTool.h"
+
+
+#include "VxMultiVertex/MvfFitInfo.h"
+#include "VxMultiVertex/MVFVxTrackAtVertex.h"
+#include "VxMultiVertex/TrackToVtxLink.h"
+#include "AthContainers/DataVector.h"
+#include "TrkEventPrimitives/ParamDefs.h"
+#include "TrkVertexFitters/AdaptiveMultiVertexFitter.h"
+#include "TrkVertexFitterInterfaces/IVertexAnalyticSeedFinder.h"
+#include "TrkTrack/LinkToTrack.h"
+#include "TrkParticleBase/LinkToTrackParticleBase.h"
+#include "TrkLinks/LinkToXAODTrackParticle.h"
+
+#include "xAODTracking/Vertex.h"
+#include "xAODTracking/TrackParticle.h"
+#include "xAODTracking/VertexContainer.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "xAODTracking/TrackParticleContainer.h"
+#include "xAODTracking/TrackParticleAuxContainer.h"
+
+#include <cmath>
+
+
+
+namespace InDet
+{
+  InDetAdaptiveMultiPriVxFinderTool::InDetAdaptiveMultiPriVxFinderTool(const std::string& t, const std::string& n,
+                                                                       const IInterface* p)
+    : AthAlgTool(t, n, p),
+    m_MultiVertexFitter("Trk::AdaptiveMultiVertexFitter"),
+    m_analyticSeedFinder("Trk::TrackDensitySeedFinder"),
+    m_trkFilter("InDet::InDetTrackSelection"),
+    m_useBeamConstraint(true),
+    m_TracksMaxZinterval(1.),
+    m_maxVertexChi2(18.42),
+    m_realMultiVertex(true),
+    m_useFastCompatibility(true),
+    m_selectiontype(0),
+    m_finalCutMaxVertexChi2(18.42),
+    m_cutVertexDependence(3.),
+    m_minweight(0.0001),
+    m_maxIterations(100),
+    m_testingclass(0),
+    m_addSingleTrackVertices(false),
+    m_do3dSplitting(false),
+    m_zBfieldApprox(0.60407),
+    m_maximumVertexContamination(0.5),
+    m_tracksMaxSignificance(5.),
+    m_useSeedConstraint(true)
+  {
+    declareInterface<IVertexFinder>(this);//by GP: changed from InDetMultiAdaptivePriVxFinderTool to IPriVxFinderTool
+    /* Retrieve StoreGate container and tool names from job options */
+    declareProperty("SeedFinder", m_analyticSeedFinder);
+    declareProperty("VertexFitterTool", m_MultiVertexFitter);
+    declareProperty("TrackSelector", m_trkFilter);
+
+    //finder options
+    declareProperty("TracksMaxZinterval", m_TracksMaxZinterval);
+    declareProperty("maxVertexChi2", m_maxVertexChi2);
+    declareProperty("finalCutMaxVertexChi2", m_finalCutMaxVertexChi2);
+    declareProperty("cutVertexDependence", m_cutVertexDependence);
+    declareProperty("MinWeight", m_minweight);
+    declareProperty("realMultiVertex", m_realMultiVertex);
+    declareProperty("useFastCompatibility", m_useFastCompatibility);
+    declareProperty("useBeamConstraint", m_useBeamConstraint);
+    declareProperty("addSingleTrackVertices", m_addSingleTrackVertices);
+    declareProperty("tracksMaxSignificance",m_tracksMaxSignificance);
+    declareProperty("m_useSeedConstraint",m_useSeedConstraint);
+    //********* signal vertex selection (for pile up) ****
+    declareProperty("selectiontype", m_selectiontype);
+    //==0 for sum p_t^2
+    //==1 for NN
+    //==2 for min bias compatibility estimation (in the future)
+    declareProperty("maxIterations", m_maxIterations);
+    declareProperty("do3dSplitting", m_do3dSplitting);
+    declareProperty("zBfieldApprox", m_zBfieldApprox);
+    declareProperty("maximumVertexContamination", m_maximumVertexContamination);
+    declareProperty( "IPEstimator", m_ipEstimator );
+
+  }
+
+  InDetAdaptiveMultiPriVxFinderTool::~InDetAdaptiveMultiPriVxFinderTool()
+  {}
+
+  StatusCode
+  InDetAdaptiveMultiPriVxFinderTool::initialize() {
+    /* Get the right vertex fitting tool */
+    ATH_CHECK(m_MultiVertexFitter.retrieve());
+
+    ATH_CHECK(m_analyticSeedFinder.retrieve());
+
+    ATH_CHECK(m_beamSpotKey.initialize());
+
+    ATH_CHECK(m_trkFilter.retrieve());
+
+    // since some parameters special to an inherited class this method
+    // will be overloaded by the inherited class
+    if (msgLvl(MSG::DEBUG)) printParameterSettings();
+
+    ATH_MSG_INFO("Initialization successful");
+    return StatusCode::SUCCESS;
+  }
+
+  namespace
+  {
+    struct xAODVertex_pair {
+      double first;
+      xAOD::Vertex* second;
+      xAODVertex_pair(double p1, xAOD::Vertex* p2)
+        : first(p1), second(p2) {}
+      bool
+      operator < (const xAODVertex_pair& other) const
+      {return first > other.first;}
+    };
+  } //anonymous namespace
+
+
+
+
+
+
+xAOD::Vertex::Decorator< Trk::MvfFitInfo* > MvfFitInfo("MvfFitInfo");
+    xAOD::Vertex::Decorator< bool > isInitialized("isInitialized");
+    xAOD::Vertex::Decorator< std::vector< Trk::VxTrackAtVertex* > > VTAV("VTAV");
+
+    if (m_selectiontype == 1) {//if you have to use NN, load the class
+      m_testingclass = new NN();//check later for MEMORY LEAK
+    }
+
+    //---- Start of preselection of tracks according to perigee parameters ---------------//
+    std::vector<const Trk::ITrackLink*> origTracks = trackVector;
+    std::vector<const Trk::ITrackLink*> seedTracks = trackVector;
+  
+    //now all tracks are in origTracks... std::vector<const Track*> origTracks;
+    std::vector<xAODVertex_pair> myxAODVertices;
+
+    std::vector<Trk::TrackToVtxLink*> myTrackToVtxLinks;
+
+    xAOD::VertexContainer* theVertexContainer = new xAOD::VertexContainer;
+    xAOD::VertexAuxContainer* theVertexAuxContainer = new xAOD::VertexAuxContainer;
+    theVertexContainer->setStore(theVertexAuxContainer);
+
+    Amg::Vector3D actualVertex;
+
+
+    std::map<const Trk::ITrackLink*, Trk::TrackToVtxLink*> TrackLinkOf;
+
+    //create a map between ITrackLink* and TrackToVtxLink*
+    std::vector<const Trk::ITrackLink*>::const_iterator trkbegin = origTracks.begin();
+    std::vector<const Trk::ITrackLink*>::const_iterator trkend = origTracks.end();
+
+
+    for (std::vector<const Trk::ITrackLink*>::const_iterator trkiter = trkbegin; trkiter != trkend; ++trkiter) {
+      Trk::TrackToVtxLink* newTrkToVtxLink(new Trk::TrackToVtxLink(new std::vector<xAOD::Vertex*>)); // makePrivateStore()
+                                                                                                     // is called for
+                                                                                                     // each vertex to
+                                                                                                     // add in iteration
+      TrackLinkOf[*trkiter] = newTrkToVtxLink;
+      myTrackToVtxLinks.push_back(newTrkToVtxLink);
+    }
+
+
+    //prepare iterators for tracks only necessary for seeding
+    std::vector<const Trk::ITrackLink*>::iterator seedtrkbegin = seedTracks.begin();
+    std::vector<const Trk::ITrackLink*>::iterator seedtrkend = seedTracks.end();
+    SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
+    int iteration = 0;
+
+  int nNoCompatibleTracks(0);
+  int nContamintationCut(0);
+  int nWithin3sigma(0);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    unsigned int seedtracknumber = seedTracks.size();
+    do {
+      if (seedtracknumber == 0) {
+        ATH_MSG_DEBUG("No tracks available after track selection for seeding. No finding done.");
+        break;
+      }
+      iteration += 1;
+      ATH_MSG_DEBUG("Starting iteration number " << iteration << " with " << seedtracknumber << " seed tracks.");
+      //now use all the perigee parameters you have so far
+      if (m_realMultiVertex == true) {
+        trkbegin = origTracks.begin();
+        trkend = origTracks.end();
+      } else {
+        trkbegin = seedTracks.begin();
+        trkend = seedTracks.end();
+      }
+      std::vector<const Trk::TrackParameters*> perigeeList;
+      for (std::vector<const Trk::ITrackLink*>::iterator seedtrkAtVtxIter = seedtrkbegin;
+           seedtrkAtVtxIter != seedtrkend; ++seedtrkAtVtxIter) {
+        perigeeList.push_back((*seedtrkAtVtxIter)->parameters());
+      }
+      xAOD::Vertex* constraintVertex = 0;
+
+  // SEEDING START
+      
+      if (m_useBeamConstraint) {
+        constraintVertex = new xAOD::Vertex();
+        constraintVertex->makePrivateStore();
+        constraintVertex->setPosition(beamSpotHandle->beamVtx().position());
+        constraintVertex->setCovariancePosition(beamSpotHandle->beamVtx().covariancePosition());
+        constraintVertex->setFitQuality(beamSpotHandle->beamVtx().fitQuality().chiSquared(),
+                                        beamSpotHandle->beamVtx().fitQuality().doubleNumberDoF());
+        std::pair<Amg::Vector3D,Amg::MatrixX> seedConstraintVertex = m_analyticSeedFinder->findAnalyticSeed(perigeeList, constraintVertex);
+        actualVertex = seedConstraintVertex.first;
+        if(m_useSeedConstraint){
+          constraintVertex->setPosition(seedConstraintVertex.first);
+          constraintVertex->setCovariancePosition(seedConstraintVertex.second);
+        }
+      } else {
+        actualVertex = m_analyticSeedFinder->findSeed(perigeeList);
+        Amg::MatrixX looseConstraintCovariance(3, 3);
+        looseConstraintCovariance.setIdentity();
+        looseConstraintCovariance = looseConstraintCovariance * 1e+8;
+        constraintVertex = new xAOD::Vertex();
+        constraintVertex->makePrivateStore();
+        constraintVertex->setPosition(actualVertex);
+        constraintVertex->setCovariancePosition(looseConstraintCovariance);
+        constraintVertex->setFitQuality(0., -3.);
+      }
+      // TODO: memory leak here with theconstraint when the loop breaks?
+      if (actualVertex.z() == 0.) {
+        ATH_MSG_DEBUG("No seed found: no further primary vertex finding performed on this event");
+        ATH_MSG_DEBUG(perigeeList.size() << " tracks passed to seed finder, but no seed returned.");
+        // TODO: Do I need this?
+        delete constraintVertex;
+        constraintVertex = 0;
+        break;
+      }
+
+  // SEEDING END
+
+      //new xAOD::Vertex with this
+      xAOD::Vertex* actualcandidate = new xAOD::Vertex;
+      actualcandidate->makePrivateStore();
+      actualcandidate->setVertexType(xAOD::VxType::NotSpecified); // to mimic the initialization present in the old EDM                                                          // constructor
+      // now add decorations!
+      MvfFitInfo(*actualcandidate) = new Trk::MvfFitInfo(constraintVertex,
+                                                         new Amg::Vector3D(actualVertex),
+                                                         new Amg::Vector3D(actualVertex));
+      isInitialized(*actualcandidate) = false;
+      std::vector<Trk::VxTrackAtVertex*> vector_of_tracks(0);
+      VTAV(*actualcandidate) = vector_of_tracks; // TODO: maybe needed before push_back?
+      //now iterate on all tracks and find out if they are sufficiently close to the found vertex
+
+      ATH_MSG_VERBOSE("Adding tracks to the vertex candidate now");
+
+  // ADD COMPATIBLE TRACKS TO VTX CANDIDATE START
+
+      for (std::vector<const Trk::ITrackLink*>::const_iterator trkiter = trkbegin; trkiter != trkend; ++trkiter) {
+        if (std::fabs(estimateDeltaZ(*(*trkiter)->parameters(), actualVertex)) < m_TracksMaxZinterval) {
+          const double thisTracksSignificance = ipSignificance((*trkiter)->parameters(),&actualVertex); // calculate significance
+          if ( thisTracksSignificance<m_tracksMaxSignificance)
+          {
+            //accessing corresponding link to vertices
+            Trk::TrackToVtxLink* actuallink = TrackLinkOf[*trkiter];
+            std::vector<xAOD::Vertex*>* actualvtxlink = actuallink->vertices();
+            //adding vertex to candidates of track
+            actualvtxlink->push_back(actualcandidate);
+            ATH_MSG_VERBOSE("Adding an MVFVxTrackAtVertex with tracklink " << actuallink <<
+                            " to the vertex candidate VTAV decoration");
+            VTAV(*actualcandidate).push_back(new Trk::MVFVxTrackAtVertex((*trkiter)->clone(),
+                                                                         actuallink));
+          }
+        }
+      }
+      ATH_MSG_DEBUG(VTAV(*actualcandidate).size() << " tracks added to vertex candidate for IP significance less than " << m_tracksMaxSignificance << " within " << m_TracksMaxZinterval << " mm of seed position.");
+      //now consider to recovery from the case where no tracks were added to the vertex
+      if (VTAV(*actualcandidate).empty()) {
+        //you need to define a new seed (because the old one is probably in between two ones...)
+        double zdistance = 1e8;
+        const Trk::ITrackLink* nearestTrack = 0;
+        for (std::vector<const Trk::ITrackLink*>::const_iterator seedtrkiter = seedtrkbegin;
+             seedtrkiter != seedtrkend; ++seedtrkiter) {
+          if (std::fabs((*seedtrkiter)->parameters()->position()[Trk::z] - actualVertex.z()) < zdistance) {
+            zdistance = std::fabs((*seedtrkiter)->parameters()->position()[Trk::z] - actualVertex.z());
+            nearestTrack = *seedtrkiter;
+          }
+        }
+        if (nearestTrack) {
+          double newz = (nearestTrack->parameters())->position()[Trk::z];
+          xAOD::Vertex* oldcandidate = actualcandidate; // to placehold old pointers
+
+          actualVertex = Amg::Vector3D(0., 0., newz);
+          actualcandidate = new xAOD::Vertex();
+          actualcandidate->makePrivateStore();
+          actualcandidate->setVertexType(xAOD::VxType::NotSpecified); // to mimic the initialization present in the old
+                                                                      // EDM constructor
+          // TODO: Think about where everything is deleted! Does Trk::MvfFitInfo destructor and do MVFVxTrackAtVertex
+          // destructors get called when actualcandidate gets deleted?
+          // now add decorations!
+          MvfFitInfo(*actualcandidate) = new Trk::MvfFitInfo(new xAOD::Vertex(*constraintVertex),
+                                                             new Amg::Vector3D(actualVertex),
+                                                             new Amg::Vector3D(actualVertex));
+          isInitialized(*actualcandidate) = false;
+          VTAV(*actualcandidate) = vector_of_tracks; // TODO: maybe needed before push_back?
+         
+          releaseCandidate(oldcandidate);
+
+          for (std::vector<const Trk::ITrackLink*>::const_iterator trkiter = trkbegin; trkiter != trkend; ++trkiter) {
+
+              if (std::fabs(estimateDeltaZ(*(*trkiter)->parameters(), actualVertex)) < m_TracksMaxZinterval) {
+              const double thisTracksSignificance = ipSignificance((*trkiter)->parameters(),&actualVertex); // calculate significance
+              if ( thisTracksSignificance<m_tracksMaxSignificance)
+              {
+                //accessing corresponding link to vertices
+                Trk::TrackToVtxLink* actuallink = TrackLinkOf[*trkiter];
+                std::vector<xAOD::Vertex*>* actualvtxlink = actuallink->vertices();
+                //adding vertex to candidates of track
+                actualvtxlink->push_back(actualcandidate);
+                ATH_MSG_VERBOSE("Adding an MVFVxTrackAtVertex with tracklink " << actuallink <<
+                                " to the vertex candidate VTAV decoration");
+                VTAV(*actualcandidate).push_back(new Trk::MVFVxTrackAtVertex((*trkiter)->clone(),
+                                                                             actuallink));
+              }
+            }
+          }
+
+          if (VTAV(*actualcandidate).empty()) {
+            ATH_MSG_DEBUG("No tracks found near seed, while at least one track was expected.");
+            delete actualcandidate;
+            break;
+          }
+        } else {
+          ATH_MSG_DEBUG("Nearest track to seed is missing.");
+          delete actualcandidate;
+          break;
+        }
+      }
+
+  // ADD COMPATIBLE TRACKS TO VTX CANDIDATE END
+
+  // RUN FITTER START
+
+      ATH_MSG_VERBOSE("Running addVtxTofit(); The current candidate has " << VTAV(*actualcandidate).size() <<
+                      " tracks in the vector");
+      m_MultiVertexFitter->addVtxTofit(actualcandidate);
+      ATH_MSG_DEBUG("After fit the current candidate has z: " << actualcandidate->position()[Trk::z]);
+
+  // RUN FITTER END
+
+  // CHECK TRACKS/GOOD VTX AFTER FIT START
+
+      //get link to the tracks (they are now all properly in the std::vector<Trk::VxTrackAtVertex> of the xAOD::Vertex)
+      // TODO: maybe I shouldn't be using xAOD::Vertex vector at all for VxTrackAtVertex...
+      std::vector<Trk::VxTrackAtVertex*>::iterator trkAtVtxbegin = VTAV(*actualcandidate).begin();
+      std::vector<Trk::VxTrackAtVertex*>::iterator trkAtVtxend = VTAV(*actualcandidate).end();
+      //now check that there is at least one track added to the fit
+      //(this is not always the case because only tracks above a certain compatibility threshold are considered)
+      bool atleastonecompatibletrack = false;
+      int numberOfCompatibleTracks = 0;
+      for (std::vector<Trk::VxTrackAtVertex*>::iterator trkAtVtxIter = trkAtVtxbegin;
+           trkAtVtxIter != trkAtVtxend; ++trkAtVtxIter) {
+        ATH_MSG_VERBOSE("Compatibility: " << (*trkAtVtxIter)->vtxCompatibility() <<
+                        " weight " << (*trkAtVtxIter)->weight());
+
+
+        if (((*trkAtVtxIter)->vtxCompatibility() < m_maxVertexChi2 && m_useFastCompatibility) ||
+            ((*trkAtVtxIter)->weight() > m_minweight
+             && (*trkAtVtxIter)->trackQuality().chiSquared() < m_maxVertexChi2
+             && !m_useFastCompatibility)) {
+
+                  const Trk::ITrackLink* foundTrack = 0;
+                  for (std::vector<const Trk::ITrackLink*>::const_iterator seedtrkiter =
+                         seedtrkbegin; seedtrkiter != seedtrkend;
+                       ++seedtrkiter) {
+                    if ((*seedtrkiter)->parameters() == (*trkAtVtxIter)->trackOrParticleLink()->parameters()) {
+                      foundTrack = *seedtrkiter;
+                    }
+                  }
+                  if (foundTrack != 0) {
+                    atleastonecompatibletrack = true;
+                    numberOfCompatibleTracks += 1;
+                    ATH_MSG_VERBOSE("Found compatible track");
+                    if (m_addSingleTrackVertices) {
+                      if (m_useBeamConstraint) break;
+                      if (numberOfCompatibleTracks > 1 && (!m_useBeamConstraint)) break;
+                    } else {
+                      if (numberOfCompatibleTracks > 1) break;
+                    }
+                  }
+        }
+
+
+      }
+
+      bool newVertexIsFine = false;
+      if (m_addSingleTrackVertices) {
+        if (m_useBeamConstraint) {
+          if (numberOfCompatibleTracks > 0) {
+            newVertexIsFine = true;
+          }
+        } else {
+          if (numberOfCompatibleTracks > 1) {
+            newVertexIsFine = true;
+          }
+        }
+      } 
+
+
+
+      else {
+        if (numberOfCompatibleTracks > 1) {
+          newVertexIsFine = true;
+        }
+      }
+
+
+  // CHECK TRACKS/GOOD VTX AFTER FIT END
+
+  // REMOVE COMPATIBLE TRACKS FROM SEED START
+
+      ATH_MSG_VERBOSE("newVertexIsFine = " << newVertexIsFine);
+      //this now should be so powerful to do everything by itself
+      //problem now is to delete the really compatible tracks to this fit from the tracks
+      //which still remain to be fitted
+      if (atleastonecompatibletrack) {
+        for (std::vector<Trk::VxTrackAtVertex*>::iterator trkAtVtxIter = trkAtVtxbegin;
+             trkAtVtxIter != trkAtVtxend; ++trkAtVtxIter) {
+
+
+          //for now using the compatibility at stage before end...
+          ATH_MSG_VERBOSE("The compatibility value of the track " << *trkAtVtxIter <<
+                          " is " << (*trkAtVtxIter)->vtxCompatibility());
+          if (((*trkAtVtxIter)->vtxCompatibility() < m_maxVertexChi2 && m_useFastCompatibility) ||
+              ((*trkAtVtxIter)->weight() > m_minweight
+               && (*trkAtVtxIter)->trackQuality().chiSquared() < m_maxVertexChi2
+               && !m_useFastCompatibility)) {
+            ATH_MSG_VERBOSE("Eliminating incompatible track");
+
+            std::vector<const Trk::ITrackLink*>::iterator foundTrack = seedtrkend;
+            for (std::vector<const Trk::ITrackLink*>::iterator seedtrkiter = seedtrkbegin; seedtrkiter != seedtrkend;
+                 ++seedtrkiter) {
+              if ((*seedtrkiter)->parameters() == (*trkAtVtxIter)->trackOrParticleLink()->parameters()) {
+                foundTrack = seedtrkiter;
+              }
+            }
+            ATH_MSG_VERBOSE("Trying to find track now");
+            if (foundTrack != seedtrkend) {
+              ATH_MSG_VERBOSE("Track found: eliminating it");
+              seedTracks.erase(foundTrack);
+
+              //update end and begin??? should I? yes, he can copy, regenerate, you don't know!
+              seedtrkbegin = seedTracks.begin();
+              seedtrkend = seedTracks.end();
+
+              ATH_MSG_VERBOSE("Remaining seeds: " << seedTracks.size());
+            }
+          }
+
+
+
+        } // trackatvertex loop end
+      } 
+
+  // REMOVE COMPATIBLE TRACKS FROM SEED END
+
+  // NO COMPATIBLE TRACKS FOUND START
+
+
+      else {//no compatible track found...
+        //in this case put out the highest seeding track which didn't give any good result...
+        double highestcompatibility = 0;
+        Trk::VxTrackAtVertex* trackHighestCompatibility = 0;
+
+        ATH_MSG_VERBOSE("Analyzing new vertex");
+
+        for (std::vector<Trk::VxTrackAtVertex*>::iterator trkAtVtxIter = trkAtVtxbegin;
+             trkAtVtxIter != trkAtVtxend; ++trkAtVtxIter) {
+          ATH_MSG_VERBOSE("Checking new track for compatibility");
+          const Trk::ITrackLink* foundTrack = 0;
+          for (std::vector<const Trk::ITrackLink*>::const_iterator seedtrkiter =
+                 seedtrkbegin; seedtrkiter != seedtrkend;
+               ++seedtrkiter) {
+            if ((*seedtrkiter)->parameters() == (*trkAtVtxIter)->trackOrParticleLink()->parameters()) {
+              foundTrack = *seedtrkiter;
+            }
+          }
+          if (foundTrack != 0) {
+            double compatibility = (*trkAtVtxIter)->vtxCompatibility();
+            ATH_MSG_VERBOSE("New track has compatibility: " << compatibility);
+            if (compatibility > highestcompatibility) {
+              highestcompatibility = compatibility;
+              trackHighestCompatibility = *trkAtVtxIter;
+            }
+          }
+        }
+
+        
+        ATH_MSG_VERBOSE("Highest compatibility track:" << trackHighestCompatibility <<
+                        "with compatibility: " << highestcompatibility);
+        if (trackHighestCompatibility != 0) {
+          std::vector<const Trk::ITrackLink*>::iterator foundTrack = seedtrkend;
+          for (std::vector<const Trk::ITrackLink*>::iterator seedtrkiter = seedtrkbegin; seedtrkiter != seedtrkend;
+               ++seedtrkiter) {
+            if ((*seedtrkiter)->parameters() == trackHighestCompatibility->trackOrParticleLink()->parameters()) {
+              foundTrack = seedtrkiter;
+            }
+          }
+          if (foundTrack != seedtrkend) {
+            seedTracks.erase(foundTrack);
+            seedtrkbegin = seedTracks.begin();
+            seedtrkend = seedTracks.end();
+          } else {
+            ATH_MSG_FATAL("Cannot find previously determined track ");
+            throw;
+          }
+        } else {
+          //alternative method: delete seed track nearest in z to the seed
+          double zdistance = 1e8;
+          const Trk::ITrackLink* nearestTrack = 0;
+          for (std::vector<const Trk::ITrackLink*>::const_iterator seedtrkiter = seedtrkbegin;
+               seedtrkiter != seedtrkend; ++seedtrkiter) {
+            if (std::fabs((*seedtrkiter)->parameters()->position()[Trk::z] - actualVertex.z()) < zdistance) {
+              zdistance = std::fabs((*seedtrkiter)->parameters()->position()[Trk::z] - actualVertex.z());
+              nearestTrack = *seedtrkiter;
+            }
+          }
+          if (nearestTrack != 0) {
+            std::vector<const Trk::ITrackLink*>::iterator foundTrackToDelete =
+              std::find(seedtrkbegin, seedtrkend, nearestTrack);
+            if (foundTrackToDelete != seedtrkend) {
+              seedTracks.erase(foundTrackToDelete);
+              seedtrkbegin = seedTracks.begin();
+              seedtrkend = seedTracks.end();
+            } else {
+              ATH_MSG_DEBUG("No nearest track found while it was expected.");
+              break;
+            }
+          } else {
+            ATH_MSG_DEBUG("No further seeding track was found (3 methods used) while it was expected.");
+            break;
+          }
+        }
+      }
+
+  // NO COMPATIBLE TRACKS FOUND END
+
+  // DEAL WITH BAD VERTEX 1 START
+
+
+      ///////////////
+      //now break the cycle if you didn't diminish the number of seeds...
+      ATH_MSG_DEBUG("Remaining seeds: " << seedTracks.size() << " previous round " << seedtracknumber);
+      bool deleteLastVertex = false;
+      if (!newVertexIsFine) {
+        deleteLastVertex = true;
+        nNoCompatibleTracks++;
+        ATH_MSG_DEBUG("Vertex has no compatible tracks");
+      } 
+
+  // DEAL WITH BAD VERTEX 1 END
+
+  // DEAL WITH GOOD VERTEX 1 START
+
+      else {
+        double contamination = 0.;
+        double contaminationNum = 0;
+        double contaminationDeNom = 0;
+        std::vector<Trk::VxTrackAtVertex*>::iterator TRKtrkbegin(VTAV(*actualcandidate).begin());
+        std::vector<Trk::VxTrackAtVertex*>::iterator TRKtrkend(VTAV(*actualcandidate).end());
+        for (std::vector<Trk::VxTrackAtVertex*>::iterator TRKtrkiter = TRKtrkbegin; TRKtrkiter != TRKtrkend;
+             ++TRKtrkiter) {
+          double trackWeight = (*TRKtrkiter)->weight();
+          contaminationNum += trackWeight * (1. - trackWeight);
+          contaminationDeNom += trackWeight * trackWeight;
+        }
+        if (contaminationDeNom > 0) {
+          contamination = contaminationNum / contaminationDeNom;
+        }
+        if (contamination > m_maximumVertexContamination) {
+          ATH_MSG_VERBOSE(
+            "Contamination estimator " << contamination << " fails cut of " << m_maximumVertexContamination);
+          deleteLastVertex = true;
+          nContamintationCut++;
+          ATH_MSG_DEBUG("Vertex failed contamination cut");
+        }
+        //now try to understand if the vertex was merged with another one...
+        const auto & candidatePosition = actualcandidate->position();
+        const auto & candidateZPosition = candidatePosition[Trk::z];
+        const auto & candidatePositionCovariance = actualcandidate->covariancePosition();
+        const auto & candidateZPositionCovariance = candidatePositionCovariance(Trk::z, Trk::z);
+        for (const auto & thisVertex: myxAODVertices) {
+          const auto & thisVertexPosition = (thisVertex.second)->position();
+          const auto & thisVertexZPosition = thisVertexPosition[Trk::z];
+          const auto & thisVertexPositionCovariance = thisVertex.second->covariancePosition();
+          const auto & thisVertexZPositionCovariance = thisVertexPositionCovariance(Trk::z, Trk::z);
+          const auto deltaPosition = thisVertexPosition - candidatePosition;
+          const auto deltaZPosition = thisVertexZPosition - candidateZPosition;
+          const auto sumZCovSq = thisVertexZPositionCovariance + candidateZPositionCovariance;
+          
+          ATH_MSG_VERBOSE("Estimating compatibility of z positions: " << thisVertexZPosition <<" and " << candidateZPosition);
+          //in case of no beam spot constraint you should use the full 3d significance on the distance
+          double dependence = 0;
+          if (!m_do3dSplitting) {
+            if (sumZCovSq > 0. ){
+              dependence = std::fabs(deltaZPosition) / std::sqrt(sumZCovSq);
+            } else {
+              dependence = 0.;
+            }
+          } else {
+            Amg::MatrixX sumCovariances = thisVertexPositionCovariance + candidatePositionCovariance;
+            sumCovariances = sumCovariances.inverse().eval();
+            Amg::Vector3D hepVectorPosition;
+            hepVectorPosition[0] = deltaPosition.x();
+            hepVectorPosition[1] = deltaPosition.y();
+            hepVectorPosition[2] = deltaPosition.z();
+            dependence = std::sqrt(hepVectorPosition.dot(sumCovariances * hepVectorPosition));
+          }
+          ATH_MSG_VERBOSE("Significance of vertex pair is: " << dependence << "vs. cut at " << m_cutVertexDependence);
+          if (dependence < m_cutVertexDependence) {
+            ATH_MSG_VERBOSE("Deleting last vertex since it was found to be merged with another!");
+            deleteLastVertex = true;
+            nWithin3sigma++;
+            ATH_MSG_DEBUG("Vertex failed significance (cut vertex dependence) test");
+            break;
+          }
+        }
+      }
+      ATH_MSG_VERBOSE("Decision to delete last vertex: " << deleteLastVertex);
+
+  // DEAL WITH GOOD VERTEX 1 END
+
+  // DELETE BAD VERTEX START
+
+
+      ////////////
+      //Ok all tracks in seed were deleted. You can go ahead and discover further vertices...
+      //please clean the track to vertices links before (required by real multivertexfit)
+      if (deleteLastVertex) {
+        std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkAtVtxBegin = VTAV(*actualcandidate).begin();
+        std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkAtVtxEnd = VTAV(*actualcandidate).end();
+        for (std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkIterator = MVFtrkAtVtxBegin;
+             MVFtrkIterator != MVFtrkAtVtxEnd; ++MVFtrkIterator) {
+          ATH_MSG_VERBOSE("Deleting one vertex from tracklink " <<
+                          (static_cast<Trk::MVFVxTrackAtVertex*>(*MVFtrkIterator))->linkToVertices());
+          (static_cast<Trk::MVFVxTrackAtVertex*>(*MVFtrkIterator))->linkToVertices()->vertices()->pop_back();
+        }
+        seedtracknumber = seedTracks.size();
+        ATH_MSG_VERBOSE("Redoing fit after scrapping last vertex");
+        m_MultiVertexFitter->addVtxTofit(actualcandidate); // TODO: I think this is fine still, but think about it more
+        releaseCandidate(actualcandidate);
+      } 
+
+  // DELETE BAD VERTEX START
+
+  // SAVE GOOD VERTEX START
+
+      else {
+        seedtracknumber = seedTracks.size();
+        ATH_MSG_VERBOSE("Storing new vertex with " << actualcandidate->vxTrackAtVertex().size() << " tracks");
+        myxAODVertices.push_back(xAODVertex_pair(0,actualcandidate));
+      }
+  // SAVE GOOD VERTEX END
+    } while ((
+               (m_addSingleTrackVertices && seedTracks.size() > 0) ||
+               ((!m_addSingleTrackVertices) && seedTracks.size() > 1))
+             && iteration < m_maxIterations);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    if (iteration >= m_maxIterations) {
+      ATH_MSG_WARNING("Maximum number of iterations (" << m_maxIterations <<
+                      ") reached; to reconstruct more vertices, set maxIterations to a higher value.");
+    }
+
+  ATH_MSG_DEBUG("Vertices deleted for no compatible tracks: " << nNoCompatibleTracks);
+  ATH_MSG_DEBUG("Vertices deleted for contamination cut: " << nContamintationCut);
+  ATH_MSG_DEBUG("Vertices deleted for proximity to previous: " << nWithin3sigma);
+
+    ATH_MSG_DEBUG("Primary vertex finding complete with " << iteration <<
+                  " iterations and " << myxAODVertices.size() << " vertices found.");
+
+    //correction of a bug: you can estimate the probability of being
+    //the primary interaction vertex only after the whole multivertexfit
+    //is finished!!! (the first is influenced by the fit of the second and so
+    //on...)
+    std::vector<xAODVertex_pair>::iterator vtxBegin = myxAODVertices.begin();
+    std::vector<xAODVertex_pair>::iterator vtxEnd = myxAODVertices.end();
+    // To make sure that the right tracks are in the std::vector<Trk::VxTrackAtVertex> of each vertex - up until now,
+    // they are kept in the VTAV decoration
+    for (std::vector<xAODVertex_pair>::iterator vtxIter = vtxBegin; vtxIter != vtxEnd; ++vtxIter) {
+      xAOD::Vertex* cand = vtxIter->second;
+      std::vector<Trk::VxTrackAtVertex>* tracksOfVertex = &(cand->vxTrackAtVertex());
+      tracksOfVertex->clear();
+      std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkBegin = VTAV(*cand).begin();
+      std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkEnd = VTAV(*cand).end();
+      for (std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkIter = MVFtrkBegin; MVFtrkIter != MVFtrkEnd;
+           ++MVFtrkIter) {
+        tracksOfVertex->push_back(**MVFtrkIter);
+      }
+    }
+    //before filling the container, you have to decide what is your most probable signal vertex
+    for (std::vector<xAODVertex_pair>::iterator vtxIter = vtxBegin; vtxIter != vtxEnd; ++vtxIter) {
+      (*vtxIter).first = estimateSignalCompatibility((*vtxIter).second);
+    }
+    std::sort(myxAODVertices.begin(), myxAODVertices.end());
+    if (msgLvl(MSG::VERBOSE)) {
+      ATH_MSG_VERBOSE("Vertex positions after sorting");
+      for (std::vector<xAODVertex_pair>::iterator vtxIter = vtxBegin; vtxIter != vtxEnd; ++vtxIter) {
+        ATH_MSG_VERBOSE("z position: " << (*vtxIter).second->position().z());
+      }
+    }
+    if (myxAODVertices.size() == 0) {
+      ATH_MSG_WARNING("No vertices found: returning a place-holder at the beam spot center.");
+      xAOD::Vertex* beamspotCandidate = new xAOD::Vertex;
+      beamspotCandidate->makePrivateStore();
+      beamspotCandidate->setPosition(beamSpotHandle->beamVtx().position());
+      beamspotCandidate->setCovariancePosition(beamSpotHandle->beamVtx().covariancePosition());
+      beamspotCandidate->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
+      // TODO: I don't need to set fitQuality too do I?
+      myxAODVertices.push_back(xAODVertex_pair(0, beamspotCandidate));
+    }
+    vtxBegin = myxAODVertices.begin();
+    vtxEnd = myxAODVertices.end();
+    for (std::vector<xAODVertex_pair>::const_iterator vtxIter = vtxBegin; vtxIter != vtxEnd; ++vtxIter) {
+      xAOD::Vertex* cand = vtxIter->second;
+      std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkBegin = VTAV(*cand).begin();
+      std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkEnd = VTAV(*cand).end();
+      // TODO: here, I must clean up VTAV decoration separately from vector of VxTrackAtVertex
+      for (std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkIter = MVFtrkBegin; MVFtrkIter != MVFtrkEnd;
+           ++MVFtrkIter) {
+        //setting link to TrackToVtxLink to 0 (all TrackToVtxLink will be deleted some lines later)
+        (static_cast<Trk::MVFVxTrackAtVertex*>(*MVFtrkIter))->setLinkToVertices(0);
+        delete *MVFtrkIter;
+        *MVFtrkIter = 0;
+      }
+      //delete VTAV( *cand );
+      delete MvfFitInfo(*cand);
+      std::vector<Trk::VxTrackAtVertex>::iterator trkAtVtxBegin = cand->vxTrackAtVertex().begin();
+      std::vector<Trk::VxTrackAtVertex>::iterator trkAtVtxEnd = cand->vxTrackAtVertex().end();
+      for (std::vector<Trk::VxTrackAtVertex>::iterator trkAtVtxIter = trkAtVtxBegin; trkAtVtxIter != trkAtVtxEnd; ) {//++trkAtVtxIter)                                                                                            // {
+        //cleaning up incompatible vertices
+        if (((*trkAtVtxIter).vtxCompatibility() > m_maxVertexChi2 && m_useFastCompatibility) ||
+            (((*trkAtVtxIter).weight() < m_minweight
+              || (*trkAtVtxIter).trackQuality().chiSquared() > m_maxVertexChi2)
+             && !m_useFastCompatibility)) {
+          trkAtVtxIter = cand->vxTrackAtVertex().erase(trkAtVtxIter);
+          trkAtVtxEnd = cand->vxTrackAtVertex().end();
+        } else {
+          ++trkAtVtxIter;
+        }
+      }
+      theVertexContainer->push_back(cand);
+    }
+    // If track links are to xAOD::TrackParticles, set the links directly in xAOD::Vertex with their weights
+    // Needed for weight calculator in sorting tool
+    xAOD::VertexContainer::iterator vxBegin = theVertexContainer->begin();
+    xAOD::VertexContainer::iterator vxEnd = theVertexContainer->end();
+    for (xAOD::VertexContainer::iterator vxIter = vxBegin; vxIter != vxEnd; ++vxIter) {
+      std::vector<Trk::VxTrackAtVertex>* myVxTracksAtVtx = &((*vxIter)->vxTrackAtVertex());
+      if (!myVxTracksAtVtx) continue;
+      std::vector<Trk::VxTrackAtVertex>::iterator tracksBegin = myVxTracksAtVtx->begin();
+      std::vector<Trk::VxTrackAtVertex>::iterator tracksEnd = myVxTracksAtVtx->end();
+      for (std::vector<Trk::VxTrackAtVertex>::iterator tracksIter = tracksBegin;
+           tracksIter != tracksEnd; ++tracksIter) {
+        // only set link if track link is to an xAOD::TrackParticle
+        Trk::LinkToXAODTrackParticle* linkToXAODTP =
+          dynamic_cast<Trk::LinkToXAODTrackParticle*>((*tracksIter).trackOrParticleLink());
+        if (linkToXAODTP) {
+          ATH_MSG_VERBOSE("Iterating over new vertex in fixing xAOD::TrackParticle links... ");
+          (*vxIter)->addTrackAtVertex(*linkToXAODTP, (*tracksIter).weight());
+        } // TODO: esle write in a warning? (if tracks were TrkTracks or Trk::TrackParticleBase) - sorting tool expects
+          // there to be xAOD::TrackParticleLinks!
+      }
+    }
+    if (m_selectiontype == 1 && m_testingclass != 0) delete m_testingclass;
+    std::vector<Trk::TrackToVtxLink*>::iterator begin = myTrackToVtxLinks.begin();
+    std::vector<Trk::TrackToVtxLink*>::iterator end = myTrackToVtxLinks.end();
+    //delete all TrackToVtxLink objects
+    for (std::vector<Trk::TrackToVtxLink*>::iterator iterator = begin; iterator != end; ++iterator) {
+      delete *iterator;
+    }
+    //---- add dummy vertex at the end ------------------------------------------------------//
+    //---- if one or more vertices are already there: let dummy have same position as primary vertex
+    if (theVertexContainer->size() >= 1) {
+      xAOD::Vertex* primaryVtx = theVertexContainer->front();
+      if (primaryVtx->vxTrackAtVertex().size() > 0) {
+        primaryVtx->setVertexType(xAOD::VxType::PriVtx);
+        xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
+        theVertexContainer->push_back(dummyxAODVertex); // have to add vertex to container here first so it can use its
+                                                        // aux store
+        dummyxAODVertex->setPosition(primaryVtx->position());
+        dummyxAODVertex->setCovariancePosition(primaryVtx->covariancePosition());
+        dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
+        dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
+      } else {
+        primaryVtx->setVertexType(xAOD::VxType::NoVtx);
+      }
+    }
+    //---- if no vertex is there let dummy be at beam spot
+    else if (theVertexContainer->size() == 0) {
+      xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
+      theVertexContainer->push_back(dummyxAODVertex); // have to add vertex to container here first so it can use its
+                                                      // aux store
+      dummyxAODVertex->setPosition(beamSpotHandle->beamVtx().position());
+      dummyxAODVertex->setCovariancePosition(beamSpotHandle->beamVtx().covariancePosition());
+      dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
+      dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
+    }
+    // loop over the pile up to set it as pile up (EXCLUDE first and last vertex: loop from 1 to size-1)
+    for (unsigned int i = 0; i < theVertexContainer->size() - 1; i++) {
+      if (i > 0) {
+        (*theVertexContainer)[i]->setVertexType(xAOD::VxType::PileUp);
+      }
+      ATH_MSG_VERBOSE("Vertex at z =" << (*theVertexContainer)[i]->position().z() <<
+                      " with ntracks: " << (*theVertexContainer)[i]->vxTrackAtVertex().size());
+    }
+    return std::make_pair(theVertexContainer, theVertexAuxContainer);
+  }
+
+  double
+  InDetAdaptiveMultiPriVxFinderTool::estimateSignalCompatibility(xAOD::Vertex* mycand) {
+    // TODO: put this in a better place
+    // Prepare objects holding the decoration of xAOD::Vertex with MVF auxdata
+    // For optimization of access speed
+    xAOD::Vertex::Decorator< std::vector<Trk::VxTrackAtVertex*> > VTAV("VTAV");
+
+    std::vector<Trk::VxTrackAtVertex*>::iterator begintracks = VTAV(*mycand).begin();
+    std::vector<Trk::VxTrackAtVertex*>::iterator endtracks = VTAV(*mycand).end();
+
+    if (m_selectiontype == 0) {
+      //use just sum over pt squared
+      //first get all the variables you need for to discriminate between signal and minimum bias event
+
+      double total_pt_squared = 0;
+      int total_num_tracks = 0;
+
+      for (std::vector<Trk::VxTrackAtVertex*>::iterator i = begintracks; i != endtracks; i++) {
+        ATH_MSG_VERBOSE("Compatibility is: " << (*i)->vtxCompatibility() <<
+                        " and chi^2 is: " << (*i)->trackQuality().chiSquared());
+
+        if (((*i)->vtxCompatibility() < m_finalCutMaxVertexChi2 && m_useFastCompatibility) ||
+            ((*i)->weight() > m_minweight
+             && (*i)->trackQuality().chiSquared() < m_finalCutMaxVertexChi2
+             && !m_useFastCompatibility)) {
+          const Trk::TrackParameters* perigee(0);
+          if ((*i)->perigeeAtVertex() != 0) {
+            perigee = (*i)->perigeeAtVertex();
+          } else {
+            ATH_MSG_VERBOSE("Only initialPerigee is available");
+            perigee = (*i)->initialPerigee();
+          }
+          if (perigee == 0) {
+            ATH_MSG_ERROR("Neutrals are not supported. Skipping track in pT calculation...");
+            continue;
+          }
+          total_pt_squared +=
+            std::pow(std::fabs(1. / perigee->parameters()[Trk::qOverP]) * sin(perigee->parameters()[Trk::theta]), 2);
+          total_num_tracks += 1;
+        }
+      }//finishing iterating on VxTrackAtVertex associated to **vtxIter xAOD::Vertex
+
+      return total_pt_squared * std::sqrt((double) total_num_tracks);
+    } else if (m_selectiontype == 1) {//use NN
+      double pt_track1 = 0.;
+      double pt_track2 = 0.;
+      double pt_track3 = 0.;
+      double pt_sum_linear = 0.;
+      double pt_sum_quadratic = 0.;
+
+      int total_num_tracks = 0;
+      int prognumber = 0;
+
+      for (std::vector<Trk::VxTrackAtVertex*>::iterator i = begintracks; i != endtracks; i++) {
+        if (((*i)->vtxCompatibility() < m_finalCutMaxVertexChi2 && m_useFastCompatibility) ||
+            ((*i)->weight() > m_minweight
+             && (*i)->trackQuality().chiSquared() < m_finalCutMaxVertexChi2
+             && !m_useFastCompatibility)) {
+          const Trk::TrackParameters* perigee(0);
+          if ((*i)->perigeeAtVertex() != 0) {
+            perigee = (*i)->perigeeAtVertex();
+          } else {
+            ATH_MSG_VERBOSE("Only initialPerigee is available");
+            perigee = (*i)->initialPerigee();
+          }
+          if (perigee == 0) {
+            ATH_MSG_ERROR("Neutrals not supported. Skipping track in pT calculation...");
+            continue;
+          }
+          double actualpt(std::fabs(1. / perigee->parameters()[Trk::qOverP]) * sin(perigee->parameters()[Trk::theta]));
+          pt_sum_quadratic += std::pow(actualpt, 2);
+          pt_sum_linear += actualpt;
+          if (prognumber == 0) {
+            pt_track1 = actualpt;
+            prognumber += 1;
+          } else if (prognumber == 1) {
+            pt_track2 = actualpt;
+            prognumber += 1;
+          } else if (prognumber == 2) {
+            pt_track3 = actualpt;
+            prognumber += 1;
+          }
+          total_num_tracks += 1;
+        }
+      }
+      if (total_num_tracks == 0 || pt_track2 == 0 || pt_track3 == 0) {
+        return 0.;
+      } else {
+        return m_testingclass->value(0, pt_track1, pt_track2, pt_track3,
+                                     pt_sum_linear, pt_sum_quadratic,
+                                     total_num_tracks);
+      }
+    }
+    return 0;
+  }
+
+  StatusCode
+  InDetAdaptiveMultiPriVxFinderTool::finalize() {
+    return StatusCode::SUCCESS;
+  }
+
+  void
+  InDetAdaptiveMultiPriVxFinderTool::printParameterSettings() {
+    ATH_MSG_DEBUG("Adaptive Multi-Vertex Finder: Parameter settings ");
+    ATH_MSG_DEBUG("Trackselection cuts handled by the TrackSelectorTool: " << m_trkFilter);
+    ATH_MSG_DEBUG("Finder settings: ");
+    ATH_MSG_DEBUG(
+      "Maximum distance to include track in simultaneous vertex fits: TracksMaxZinterval " << m_TracksMaxZinterval);
+    ATH_MSG_DEBUG("Seeding: minimum chi^2 for a track being an outlier:  maxVertexChi2 " << m_maxVertexChi2);
+    ATH_MSG_DEBUG("Signal identification: final cut on track chi2: finalCutMaxVertexChi2 = " <<
+    m_finalCutMaxVertexChi2);
+    ATH_MSG_DEBUG("Activate complete multi vertex fitting feature: realMultiVertex " << m_realMultiVertex);
+    ATH_MSG_DEBUG("Merging vertices: upper cut on significance to merge two vertices: cutVertexDependence = " <<
+                  m_cutVertexDependence);
+    ATH_MSG_DEBUG("Maximum number of iterations (and vertices): maxIterations = " << m_maxIterations);
+    ATH_MSG_DEBUG("Selection type (0 is sqrt(Ntr)*Sum_{tr} pT^2): selectiontype = " << m_selectiontype);
+    ATH_MSG_DEBUG("Use fast compatibility (if false use refitted chi2 instead of approximation): useFastCompatibility = " <<
+                  m_useFastCompatibility);
+    ATH_MSG_DEBUG("MinWeight (if track weight in the fit is lower, don't perform the Kalman Update) = " << m_minweight);
+    ATH_MSG_DEBUG("");
+  }
+
+  void
+  InDetAdaptiveMultiPriVxFinderTool::SGError(std::string errService) {
+    ATH_MSG_FATAL(errService << " not found. Exiting !");
+  }
+
+  double
+  InDetAdaptiveMultiPriVxFinderTool::estimateDeltaZ(const Trk::TrackParameters& myPerigee,
+                                                    const Amg::Vector3D& myTransvVertex) {
+    Amg::Vector3D lp = myTransvVertex;
+
+    Amg::Vector3D expPoint;
+    Amg::Vector3D predStatePosition = myPerigee.position();
+    expPoint[0] = predStatePosition.x();
+    expPoint[1] = predStatePosition.y();
+    expPoint[2] = predStatePosition.z();
+
+    //phi_v and functions
+    double phi_v = myPerigee.parameters()[Trk::phi];
+    double th = myPerigee.parameters()[Trk::theta];
+    double tan_th = std::tan(th);
+    double sin_phi_v = std::sin(phi_v);
+    double cos_phi_v = std::cos(phi_v);
+    double q_ov_p = myPerigee.parameters()[Trk::qOverP];
+
+    //momentum
+    Amg::Vector3D expMomentum;
+    expMomentum[0] = phi_v;
+    expMomentum[1] = th;
+    expMomentum[2] = q_ov_p;
+
+    double X = expPoint[0] - lp.x();
+    double Y = expPoint[1] - lp.y();
+
+    return expPoint[2] - lp.z() - 1. / tan_th * (X * cos_phi_v + Y * sin_phi_v);
+  }
+
+  double InDetAdaptiveMultiPriVxFinderTool::ipSignificance( const Trk::TrackParameters* params, 
+                                                 const Amg::Vector3D * vertex ) const
+  {
+    xAOD::Vertex v;
+    v.makePrivateStore();
+    v.setPosition(*vertex);
+    v.setCovariancePosition(AmgSymMatrix(3)::Zero(3,3));
+    v.setFitQuality(0., 0.);
+
+    double significance = 0.0;
+    const Trk::ImpactParametersAndSigma* ipas = m_ipEstimator->estimate( params, &v );
+    if ( ipas != nullptr )
+    {  
+      if ( ipas->sigmad0 > 0 && ipas->sigmaz0 > 0)
+      {
+  significance = std::sqrt( std::pow(ipas->IPd0/ipas->sigmad0,2) + std::pow(ipas->IPz0/ipas->sigmaz0,2) );
+      }
+      delete ipas;
+    }
+    return significance;
+  }
+
+  void
+  InDetAdaptiveMultiPriVxFinderTool::releaseCandidate(xAOD::Vertex*& candidate) {
+    if (candidate == nullptr) return;
+
+    // decorators
+    xAOD::Vertex::Decorator< Trk::MvfFitInfo* > MvfFitInfo("MvfFitInfo");
+    xAOD::Vertex::Decorator< std::vector< Trk::VxTrackAtVertex* > > VTAV("VTAV");
+
+    if (VTAV.isAvailable(*candidate)) {
+      for (auto tav : VTAV(*candidate)) {
+        if (tav == nullptr) continue;
+        (static_cast<Trk::MVFVxTrackAtVertex*>(tav))->setLinkToVertices(nullptr);
+        delete tav;
+        tav = nullptr;
+      }
+      VTAV(*candidate).clear();
+    }
+
+    if (MvfFitInfo.isAvailable(*candidate) && MvfFitInfo(*candidate) != nullptr) {
+      delete MvfFitInfo(*candidate);
+      MvfFitInfo(*candidate) = nullptr;
+    }
+
+    delete candidate;
+    candidate = nullptr;
+  }
+
diff --git a/Core/include/Acts/Vertexing/legacy/AMVF.h b/Core/include/Acts/Vertexing/legacy/AMVF.h
new file mode 100644
index 000000000..ce186b1ef
--- /dev/null
+++ b/Core/include/Acts/Vertexing/legacy/AMVF.h
@@ -0,0 +1,327 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @class InDet::InDetAdaptiveMultiPriVxFinderTool
+ *
+ * @author Giacinto Piacquadio (Freiburg University)
+ * 
+ * (giacinto.piacquadio@physik.uni-freiburg.de)
+ * 
+ * This class provides an implementation for a primary 
+ * vertex finding tool, which uses the \<i\>Adaptive MultiVertex\</i\> 
+ * Fitter to solve the problem of finding the multiple 
+ * interaction vertices and to find out the best possible 
+ * assignment of the track to the vertices.
+ *
+ * The steps done are the following:
+ * - the selection cuts are applied
+ * 
+ * then iteratively:
+ * - a new vertex is seeded with the remaining tracks
+ *    (the seed finder is used)
+ * - all the tracks whose Z at PCA is closer to the seeded 
+ *    vertex by more than TracksMaxZinterval (by JobOption), 
+ *    are added to the new vertex candidate
+ * -  the new vertex candidate is added on top of the previous fit and 
+ *    the AdaptiveMultiVertexFitter is used to fit all them 
+ *    together (more information in the \<br\>\<i\>TrkVertexFitters\</br\>\</i\>
+ *    package).
+ * -  the tracks already used are removed from the tracks 
+ *    from which the next seed would be obtained and if there 
+ *    are more than 2 left, a new iteration is started.
+ *
+ * when no more than 2 seeding tracks are left:
+ * - a vector of MVFVxCandidate is provided as result and 
+ *   according to the selection type, the order in which it is 
+ *   provided represents how high the probability of that 
+ *   particular vertex to come from the primary vertex is. 
+ *
+ * In general the first VxCandidate* in the collection is 
+ * the one with highest sqrt(N_tracks)*Sum Pt_track^2. This 
+ * is the case if the selectiontype in the jobOptions is set 
+ * to 0 (default).
+ *
+ *
+ * This finder is particularly suited for the high luminosities 
+ * scenarios which will came up at LHC.
+ *
+ * ------------------------------------------------------------
+ * Changes:
+ *
+ * David Shope <david.richard.shope@cern.ch> (2016-04-19)
+ *
+ * EDM Migration to xAOD - from Trk::VxCandidate to xAOD::Vertex, 
+ *                         from Trk::RecVertex   to xAOD::Vertex,
+ *                         from Trk::Vertex      to Amg::Vector3D
+ *
+ * Also, VxMultiVertex EDM has been migrated to the following:
+ *
+ *   Trk::MvfFitInfo  
+ *     constraintVertex     now uses xAOD::Vertex
+ *     seedVertex           now uses Amg::Vector3D
+ *     linearizationVertex  now uses Amg::Vector3D
+ *
+ *   Trk::TrackToVtxLink
+ *     Vertex objects stored using this class are now xAOD::Vertex
+ *
+ * Instead of using the MVFVxCandidate class, xAOD::Vertex is employed by decorating it
+ * with the multi-vertex information:
+ *
+ *   bool                              isInitialized
+ *   MvfFitInfo*                       MvfFitInfo
+ *   std::Vector\<VxTrackAtVertex*\>     VTAV
+ *
+ *   This last decoration is needed in order to be able to use MVFVxTrackAtVertex objects
+ *   which have the additional information of xAOD::Vertices associated to the track
+ *   and (through polymorphism) to still be able to pass them to the KalmanVertexUpdator as
+ *   VxTracksAtVertex objects.
+ */
+
+#ifndef INDETPRIVXFINDERTOOL_INDETADAPTIVEMULTIPRIVXFINDERTOOL_H
+#define INDETPRIVXFINDERTOOL_INDETADAPTIVEMULTIPRIVXFINDERTOOL_H
+
+#include "InDetRecToolInterfaces/IVertexFinder.h"
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "GaudiKernel/ServiceHandle.h"
+#include "TrkTrack/TrackCollection.h" // type def ...
+#include "TrkParticleBase/TrackParticleBaseCollection.h"
+#include "TrkParameters/TrackParameters.h"
+
+/**
+ * Forward declarations 
+ */
+#include "xAODTracking/VertexFwd.h"
+#include "xAODTracking/TrackParticleFwd.h"
+#include "xAODTracking/VertexContainerFwd.h"
+#include "xAODTracking/TrackParticleContainerFwd.h"
+#include "BeamSpotConditionsData/BeamSpotData.h"
+#include "TrkVertexFitterInterfaces/ITrackToVertexIPEstimator.h"
+class TrackToVtxLinkContainer;
+class NN;
+
+
+namespace Trk
+{
+  class IVertexAnalyticSeedFinder;
+  class AdaptiveMultiVertexFitter;
+  class Track;
+  class ITrackLink;
+  class TrkQuality;
+  class IVxCandidateXAODVertex;
+}
+
+
+namespace InDet
+{
+  class IInDetTrackSelectionTool;
+
+ class InDetAdaptiveMultiPriVxFinderTool : public AthAlgTool, virtual public IVertexFinder
+ {
+ 
+  public:
+    
+    InDetAdaptiveMultiPriVxFinderTool(const std::string& t, const std::string& n, const IInterface*  p);
+    virtual ~InDetAdaptiveMultiPriVxFinderTool();
+   
+    StatusCode initialize();
+
+    /**
+     * The MultiVertexFinding is performed.
+     *
+     * Input is the Track Collection. Output is the VertexContainer 
+     * with a list of fitted vertices, according to the probability 
+     * of being the primary interaction point.
+     * 
+     * Description of the finder is provided as doxygen info on the class.
+     *
+     */
+
+    std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*> findVertex(const TrackCollection* trackTES);
+    std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*> findVertex(const Trk::TrackParticleBaseCollection* trackTES);
+    std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*> findVertex(const xAOD::TrackParticleContainer* trackParticles);
+
+    StatusCode finalize();
+    
+  private:
+
+    std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*> findVertex(const std::vector<const Trk::ITrackLink*> & trackVector);
+  
+    void SGError(std::string errService);
+    virtual void printParameterSettings();
+
+    ToolHandle< Trk::AdaptiveMultiVertexFitter > m_MultiVertexFitter;
+    ToolHandle< Trk::IVertexAnalyticSeedFinder > m_analyticSeedFinder;
+    ToolHandle< InDet::IInDetTrackSelectionTool > m_trkFilter;
+
+    SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };
+
+    /** Define a beam constraint for the fit */
+    bool m_useBeamConstraint; //!<  Use a vertex/beam constraint
+    
+
+    /**
+     * When adding a new vertex to the multi vertex fit,
+     * only the tracks whose Z at PCA is closer 
+     * to the seeded by more than this TracksMaxZinterval 
+     * value are added to this new vertex.
+     *
+     * Default is 4 mm. If you cut too hard, you cut out 
+     * the good cases where the seed finder is not 
+     * reliable, but the fit would be still able to converge 
+     * towards the right vertex. If you cut too soft, you 
+     * consider a lot of tracks which just slow down the fit.
+     */
+
+    double m_TracksMaxZinterval;
+
+    /**
+     * After having added one vertex to the fit and having 
+     * performed the MultiVertex fit again, all the tracks 
+     * which are compatible to the new vertex by more than 
+     * this maxVertexChi2 (in units of chi2) value are eliminated from the 
+     * tracks from which still to seed the next vertex.
+     *
+     */
+
+    double m_maxVertexChi2;
+
+    /**
+     * As a default the realMultiVertex should stay to false (because this is very well tested).
+     *
+     * If switched to true, all the tracks are considered to be added to the new vertex 
+     * after this new one is seeded, and not only the ones which are considered as outliers 
+     * of previous fitted vertices.
+     *
+     * The presence of a core of tracks the previous vertices are as attached to stabilizes 
+     * the fit quite drastically. In case of luminosities higher than the low lumi scenario,
+     * one should probably to try to switch this on, or, if this doesn't work, decrease the 
+     * maxVertexChi2 and the cleaningZinterval to lower values.
+     */
+    
+    bool m_realMultiVertex;
+
+
+    /*
+     * Decides if you want to use the vtxCompatibility() of the track (set to true) or 
+     * the chi2() (set to false) as an estimate for a track being an outlier or not.
+     * The vtxCompatibility() is the default. In case the track refitting 
+     * is switched on in the AdaptiveMultiVertex fitter, you may want to 
+     * use the refutted chi2().
+     *
+     */
+
+    bool m_useFastCompatibility;
+
+    /*
+     * Selection of the most probable primary interaction vertex is done accordingly to:
+     * - selectiontype is 0:  just sqrt(N_tracks)*Sum_track p_t_track^2
+     * - selectiontype is 1:  Neural Network is used, trained on WH(120)
+     */
+
+    int m_selectiontype;
+
+    /*
+     * During the estimation of probability of vertex candidate to be the primary interaction 
+     * vertex, only all the tracks which have chi2 in the vertex fit higher than this value 
+     * are used for the sum of p_t^2 or as input for the Neural Network.
+     */
+
+    double m_finalCutMaxVertexChi2;
+
+ 
+    /*
+     * Maximum significance on the distance between two vertices 
+     * to allow merging of two vertices.
+     *
+     */
+
+    double m_cutVertexDependence;
+    
+
+    /*
+     * Has to be setup equal to the minimum weight set in the fitter.
+     *
+     * In the fitting, when a track has a weight lower than this value,
+     * the track is not updated during that iteration.
+     */
+
+    double m_minweight;
+
+
+    /*
+    * Impact parameter estimator used to calculate significance
+    */
+    ToolHandle< Trk::ITrackToVertexIPEstimator > m_ipEstimator { "Trk::TrackToVertexIPEstimator" };
+    
+    /*
+     * Maximum amount of iterations allowed for vertex finding.
+     * 
+     * The more vertices you have in the event, the more iterations you have to 
+     * allow (safe factor: number of expected vertices * 10)
+     *
+     */
+
+    double m_maxIterations;
+
+    NN* m_testingclass;
+
+   /*
+    * Fit also single track vertices
+    * (could be usefull for example for H-> gamma gamma)\
+    *
+    */
+
+   bool m_addSingleTrackVertices;
+
+   bool m_do3dSplitting;
+   
+   double m_zBfieldApprox;
+
+   double m_maximumVertexContamination;
+
+    /*
+    * Maximum allowed significance of track position to vertex seed
+    */
+    double m_tracksMaxSignificance ;
+
+    /*
+    * Toggle vertex seed constraint on/off
+    */
+    bool m_useSeedConstraint ;
+
+
+   struct CompareTheTwoVertices {
+     bool operator()( xAOD::Vertex* const & first, xAOD::Vertex* const & second);
+   };
+
+   /**												     
+    * Internal method to estimate the probability to be signal vertex of a certain vertex candidate. 
+    */												     
+
+   double estimateSignalCompatibility(xAOD::Vertex *myxAODVertex);				     
+
+   /**
+    * Estimate DeltaZ given a certain track parameters and beam spot center position
+    * ONLY TEMPORARY 15-08-2009: common tool needed to collect this method
+    */
+   
+   double estimateDeltaZ(const Trk::TrackParameters& myPerigee, const Amg::Vector3D& myTransvVertex);
+
+   /** 
+   * copying from the guassian density alg
+   */
+   double ipSignificance(const Trk::TrackParameters* params, const Amg::Vector3D * vertex) const;
+
+   /**
+    * Clean decorator data from a vertex candidate (to avoid memory leaks) and then delete it and set to zero
+    */
+   
+   void releaseCandidate(xAOD::Vertex*& candidate);
+   
+
+ };//end of class
+}//end of namespace definitions
+#endif
diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
index 218d8a729..35e95510e 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
@@ -51,7 +51,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
   // Set up propagator with void navigator
   auto propagator = std::make_shared<Propagator>(stepper);
   PropagatorOptions<> pOptions(tgContext, mfContext);
-  pOptions.direction=backward;
+  pOptions.direction = backward;
 
   VertexFitterOptions<BoundParameters> fitterOptions(tgContext, mfContext);
 
@@ -97,33 +97,31 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
                               std::move(ipEst), std::move(linearizer));
 
   // TODO: test this as well!
-  //finderConfig.useBeamSpotConstraint = false;
+  // finderConfig.useBeamSpotConstraint = false;
 
   Finder finder(finderConfig);
 
   std::vector<BoundParameters> tracks = getAthenaTracks();
 
-  if(debugMode){
-  	std::cout << "Number of tracks in event: " << tracks.size() << std::endl;
-  	int maxCout = 10;
-  	int count = 0;
-  	for(const auto& trk : tracks){
-  		std::cout << count << ". track: " << std::endl;
-  		std::cout << "params: " << trk << std::endl;
-  		count++;
-  		if(count == maxCout){
-  			break;
-  		}
-  	}
+  if (debugMode) {
+    std::cout << "Number of tracks in event: " << tracks.size() << std::endl;
+    int maxCout = 10;
+    int count = 0;
+    for (const auto& trk : tracks) {
+      std::cout << count << ". track: " << std::endl;
+      std::cout << "params: " << trk << std::endl;
+      count++;
+      if (count == maxCout) {
+        break;
+      }
+    }
   }
 
   VertexFinderOptions<BoundParameters> finderOptions(tgContext, mfContext);
 
   Vector3D constraintPos{-0.5_mm, -0.5_mm, 0_mm};
   ActsSymMatrixD<3> constraintCov;
-  constraintCov <<  0.0001,      0,      0,
-					0,  		0.0001,   0,
-					0,      	0,   1764;
+  constraintCov << 0.0001, 0, 0, 0, 0.0001, 0, 0, 0, 1764;
 
   Vertex<BoundParameters> constraintVtx;
   constraintVtx.setPosition(constraintPos);
@@ -134,2020 +132,3939 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
   auto findResult = finder.find(tracks, finderOptions);
 
   if (!findResult.ok()) {
-      std::cout << findResult.error().message() << std::endl;
-    }
-
+    std::cout << findResult.error().message() << std::endl;
+  }
 
   BOOST_CHECK(findResult.ok());
 
   std::vector<Vertex<BoundParameters>> allVertices = *findResult;
 
-  if(debugMode){
-  	std::cout << "Number of vertices reconstructed: " << allVertices.size() << std::endl;
+  if (debugMode) {
+    std::cout << "Number of vertices reconstructed: " << allVertices.size()
+              << std::endl;
 
-  	int count = 0;
-  	for(const auto& vtx : allVertices){
-  		count++;
-  		std::cout << count << ". Vertex at position: " 
-  		<< vtx.position()[0] << ", "<< vtx.position()[1] << ", "<< vtx.position()[2] << std::endl;
-  	}
+    int count = 0;
+    for (const auto& vtx : allVertices) {
+      count++;
+      std::cout << count << ". Vertex at position: " << vtx.position()[0]
+                << ", " << vtx.position()[1] << ", " << vtx.position()[2]
+                << std::endl;
+    }
   }
-
 }
 
 // Return all tracks of one single event as reconstructed in athena.
-std::vector<BoundParameters> getAthenaTracks(){
-
-std::vector<BoundParameters> tracks;
-
- // track 0 :
- BoundVector params0;
- params0 << -0.0189610905945301056, 19.2891330718994141, -1.72937667369842529, 0.245648413896560669, 0.000139094627229496837*1./(1_MeV), 0;
- Covariance covMat0;
- covMat0 << 0.0234750192612409592, -0.00781442524684276309, -0.000530674182045025289, -8.29588870144685228e-06, -9.34183350654419714e-08*1./(1_MeV), 0, -0.00781442524684276309, 0.406355828046798706, 0.000142553526286719813, 0.000532610276843647709, 2.47911983155666744e-08*1./(1_MeV), 0, -0.000530674182045025289, 0.000142553526286719813, 1.25120022858027369e-05, 1.45461672177318258e-07, 3.16496658346130268e-09*1./(1_MeV), 0, -8.29588870144685228e-06, 0.000532610276843647709, 1.45461672177318258e-07, 7.28171983155334601e-07, 2.62386697279164045e-11*1./(1_MeV), 0, -9.34183350654419714e-08*1./(1_MeV), 2.47911983155666744e-08*1./(1_MeV), 3.16496658346130268e-09*1./(1_MeV), 2.62386697279164045e-11*1./(1_MeV), 2.09531125089368331e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform0;
- ActsSymMatrixD<3> rotMat0;
- rotMat0 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform0.rotate(rotMat0);
- transform0.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans0 = std::make_shared<const Transform3D>(transform0);
- std::shared_ptr<PerigeeSurface> perigeeSurface0 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams0 = BoundParameters(tgContext, std::move(covMat0), params0, perigeeSurface0);
- tracks.push_back(boundParams0);
-
-
- // track 1 :
- BoundVector params1;
- params1 << 0.237322136759757996, 18.9474124908447266, 2.77435874938964844, 0.221098631620407104, 0.000243303977185860276*1./(1_MeV), 0;
- Covariance covMat1;
- covMat1 << 0.0224881023168563843, -0.00123628927370857643, -0.000682571853275380021, -5.08470990346168592e-07, -1.65987991328505037e-07*1./(1_MeV), 0, -0.00123628927370857643, 0.486606210470199585, -1.26428790915631958e-05, 0.000691189647290967285, 8.49211598605589898e-10*1./(1_MeV), 0, -0.000682571853275380021, -1.26428790915631958e-05, 2.10596499528037384e-05, -4.86598776586506401e-08, 8.07036236689827024e-09*1./(1_MeV), 0, -5.08470990346168592e-07, 0.000691189647290967285, -4.86598776586506401e-08, 9.96780613604641985e-07, 2.84880592793454068e-12*1./(1_MeV), 0, -1.65987991328505037e-07*1./(1_MeV), 8.49211598605589898e-10*1./(1_MeV), 8.07036236689827024e-09*1./(1_MeV), 2.84880592793454068e-12*1./(1_MeV), 6.98227170525811403e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform1;
- ActsSymMatrixD<3> rotMat1;
- rotMat1 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform1.rotate(rotMat1);
- transform1.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans1 = std::make_shared<const Transform3D>(transform1);
- std::shared_ptr<PerigeeSurface> perigeeSurface1 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams1 = BoundParameters(tgContext, std::move(covMat1), params1, perigeeSurface1);
- tracks.push_back(boundParams1);
-
-
- // track 2 :
- BoundVector params2;
- params2 << -0.274762749671936035, 19.3189582824707031, 2.51834297180175781, 0.247050970792770386, -0.000262395391473546624*1./(1_MeV), 0;
- Covariance covMat2;
- covMat2 << 0.0190738625824451447, -0.0017057542844459892, -0.000571975485803314851, -2.82570644125376289e-06, -1.61839967616137892e-07*1./(1_MeV), 0, -0.0017057542844459892, 0.321801245212554932, 6.65458853740041401e-05, 0.000567742814929668329, 5.31432764738237606e-09*1./(1_MeV), 0, -0.000571975485803314851, 6.65458853740041401e-05, 1.75108507391996682e-05, 1.16541064423600983e-07, 8.10714233373920505e-09*1./(1_MeV), 0, -2.82570644125376289e-06, 0.000567742814929668329, 1.16541064423600983e-07, 1.01647879091615323e-06, 1.7840055165615784e-12*1./(1_MeV), 0, -1.61839967616137892e-07*1./(1_MeV), 5.31432764738237606e-09*1./(1_MeV), 8.10714233373920505e-09*1./(1_MeV), 1.7840055165615784e-12*1./(1_MeV), 7.92840237906489165e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform2;
- ActsSymMatrixD<3> rotMat2;
- rotMat2 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform2.rotate(rotMat2);
- transform2.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans2 = std::make_shared<const Transform3D>(transform2);
- std::shared_ptr<PerigeeSurface> perigeeSurface2 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams2 = BoundParameters(tgContext, std::move(covMat2), params2, perigeeSurface2);
- tracks.push_back(boundParams2);
-
-
- // track 3 :
- BoundVector params3;
- params3 << 0.0235438384115695953, 19.7655830383300781, -0.159107863903045654, 2.30990958213806152, -0.000119360782264266163*1./(1_MeV), 0;
- Covariance covMat3;
- covMat3 << 0.000361772050382569432, 2.72739909974600519e-05, -8.21723450836043464e-06, 1.34126350783550678e-07, -5.88422825741122636e-09*1./(1_MeV), 0, 2.72739909974600519e-05, 0.00511974841356277466, -6.21331210701952311e-07, 3.10034413370417763e-05, -6.86043367956819384e-09*1./(1_MeV), 0, -8.21723450836043464e-06, -6.21331210701952311e-07, 2.07281985353802156e-07, -3.88590354998360268e-09, 2.03791573108340031e-10*1./(1_MeV), 0, 1.34126350783550678e-07, 3.10034413370417763e-05, -3.88590354998360268e-09, 3.01585174611318507e-07, -5.64498122454143072e-11*1./(1_MeV), 0, -5.88422825741122636e-09*1./(1_MeV), -6.86043367956819384e-09*1./(1_MeV), 2.03791573108340031e-10*1./(1_MeV), -5.64498122454143072e-11*1./(1_MeV), 4.42898885968934231e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform3;
- ActsSymMatrixD<3> rotMat3;
- rotMat3 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform3.rotate(rotMat3);
- transform3.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans3 = std::make_shared<const Transform3D>(transform3);
- std::shared_ptr<PerigeeSurface> perigeeSurface3 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams3 = BoundParameters(tgContext, std::move(covMat3), params3, perigeeSurface3);
- tracks.push_back(boundParams3);
-
-
- // track 4 :
- BoundVector params4;
- params4 << -0.00997916609048843384, 19.6140289306640625, -1.86583328247070312, 1.16398906707763672, 4.13092784583568573e-05*1./(1_MeV), 0;
- Covariance covMat4;
- covMat4 << 0.000111233675852417946, 6.24019899783590426e-06, -1.51042179240653054e-06, -1.66343778016681362e-09, -1.90252013322187688e-09*1./(1_MeV), 0, 6.24019899783590426e-06, 0.00304781622253358364, -1.53697680009238848e-08, 2.11791743062638145e-05, 9.71456470695990042e-10*1./(1_MeV), 0, -1.51042179240653054e-06, -1.53697680009238848e-08, 2.65749235950352158e-08, -5.72349441699598989e-10, 3.41166238038356917e-11*1./(1_MeV), 0, -1.66343778016681362e-09, 2.11791743062638145e-05, -5.72349441699598989e-10, 2.91562628262909129e-07, 1.44429681183542297e-11*1./(1_MeV), 0, -1.90252013322187688e-09*1./(1_MeV), 9.71456470695990042e-10*1./(1_MeV), 3.41166238038356917e-11*1./(1_MeV), 1.44429681183542297e-11*1./(1_MeV), 4.11648986382504023e-13*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform4;
- ActsSymMatrixD<3> rotMat4;
- rotMat4 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform4.rotate(rotMat4);
- transform4.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans4 = std::make_shared<const Transform3D>(transform4);
- std::shared_ptr<PerigeeSurface> perigeeSurface4 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams4 = BoundParameters(tgContext, std::move(covMat4), params4, perigeeSurface4);
- tracks.push_back(boundParams4);
-
-
- // track 5 :
- BoundVector params5;
- params5 << 0.0375059135258197784, 19.6366806030273438, 2.80398750305175781, 1.33918941020965576, -0.00119000650011003017*1./(1_MeV), 0;
- Covariance covMat5;
- covMat5 << 0.00557367224246263504, -3.50923298762731976e-05, -0.00016505602825201958, -5.83055075084957149e-07, -8.15374160823663551e-08*1./(1_MeV), 0, -3.50923298762731976e-05, 0.0162126719951629639, 1.9925351112667154e-06, 0.000363090538840017685, 1.10231246314290943e-09*1./(1_MeV), 0, -0.00016505602825201958, 1.9925351112667154e-06, 4.97896826345822774e-06, 4.42649583494026453e-08, 3.8207024978280266e-09*1./(1_MeV), 0, -5.83055075084957149e-07, 0.000363090538840017685, 4.42649583494026453e-08, 9.3684120656689629e-06, 4.81602467249185851e-11*1./(1_MeV), 0, -8.15374160823663551e-08*1./(1_MeV), 1.10231246314290943e-09*1./(1_MeV), 3.8207024978280266e-09*1./(1_MeV), 4.81602467249185851e-11*1./(1_MeV), 1.40874742426966293e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform5;
- ActsSymMatrixD<3> rotMat5;
- rotMat5 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform5.rotate(rotMat5);
- transform5.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans5 = std::make_shared<const Transform3D>(transform5);
- std::shared_ptr<PerigeeSurface> perigeeSurface5 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams5 = BoundParameters(tgContext, std::move(covMat5), params5, perigeeSurface5);
- tracks.push_back(boundParams5);
-
-
- // track 6 :
- BoundVector params6;
- params6 << 0.00140287447720766068, 19.7186660766601562, -2.14539408683776855, 1.24577629566192627, 0.000378551892936229706*1./(1_MeV), 0;
- Covariance covMat6;
- covMat6 << 0.00101993023417890072, -2.6994413372851214e-05, -2.65953182649328157e-05, 5.98774142459201546e-08, -1.51924922955507223e-08*1./(1_MeV), 0, -2.6994413372851214e-05, 0.00769689213484525681, 6.13944837413955775e-07, 9.60181177584976564e-05, 1.16782762059655835e-09*1./(1_MeV), 0, -2.65953182649328157e-05, 6.13944837413955775e-07, 7.35107732907636091e-07, -4.80302055565397552e-09, 6.05462078703657079e-10*1./(1_MeV), 0, 5.98774142459201546e-08, 9.60181177584976564e-05, -4.80302055565397552e-09, 1.77096819697908359e-06, -3.67492839080036729e-12*1./(1_MeV), 0, -1.51924922955507223e-08*1./(1_MeV), 1.16782762059655835e-09*1./(1_MeV), 6.05462078703657079e-10*1./(1_MeV), -3.67492839080036729e-12*1./(1_MeV), 1.91318193926148794e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform6;
- ActsSymMatrixD<3> rotMat6;
- rotMat6 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform6.rotate(rotMat6);
- transform6.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans6 = std::make_shared<const Transform3D>(transform6);
- std::shared_ptr<PerigeeSurface> perigeeSurface6 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams6 = BoundParameters(tgContext, std::move(covMat6), params6, perigeeSurface6);
- tracks.push_back(boundParams6);
-
-
- // track 7 :
- BoundVector params7;
- params7 << -0.00329869543202221394, 19.6041259765625, -1.90649104118347168, 1.12304854393005371, 0.00014407877461053431*1./(1_MeV), 0;
- Covariance covMat7;
- covMat7 << 0.00036740759969688952, 3.01680354122382919e-07, -7.51521596509247467e-06, 1.21665930278402614e-07, -5.43771801128259869e-09*1./(1_MeV), 0, 3.01680354122382919e-07, 0.00500722508877515793, 1.33332939824832304e-07, 3.60641268279091357e-05, -4.27847531573843138e-10*1./(1_MeV), 0, -7.51521596509247467e-06, 1.33332939824832304e-07, 1.78475985990189656e-07, -3.2621585490043233e-09, 1.59847268857147475e-10*1./(1_MeV), 0, 1.21665930278402614e-07, 3.60641268279091357e-05, -3.2621585490043233e-09, 5.36430661668418907e-07, -1.24518107354747404e-11*1./(1_MeV), 0, -5.43771801128259869e-09*1./(1_MeV), -4.27847531573843138e-10*1./(1_MeV), 1.59847268857147475e-10*1./(1_MeV), -1.24518107354747404e-11*1./(1_MeV), 3.62822619170977134e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform7;
- ActsSymMatrixD<3> rotMat7;
- rotMat7 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform7.rotate(rotMat7);
- transform7.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans7 = std::make_shared<const Transform3D>(transform7);
- std::shared_ptr<PerigeeSurface> perigeeSurface7 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams7 = BoundParameters(tgContext, std::move(covMat7), params7, perigeeSurface7);
- tracks.push_back(boundParams7);
-
-
- // track 8 :
- BoundVector params8;
- params8 << -0.00482689496129751205, 19.7954654693603516, -0.0502131059765815735, 2.31073951721191406, 4.92803592351265252e-05*1./(1_MeV), 0;
- Covariance covMat8;
- covMat8 << 0.0001803018240025267, 2.28634426988047736e-05, -2.72005896920448914e-06, 9.76369038665024842e-08, -3.00839639507890418e-09*1./(1_MeV), 0, 2.28634426988047736e-05, 0.00448299339041113853, -1.94291028533954824e-07, 2.32848414810477441e-05, -1.34362151935947653e-09*1./(1_MeV), 0, -2.72005896920448914e-06, -1.94291028533954824e-07, 5.47910268267060019e-08, -7.01181814072448539e-10, 6.19209989023759561e-11*1./(1_MeV), 0, 9.76369038665024842e-08, 2.32848414810477441e-05, -7.01181814072448539e-10, 1.64913686262480041e-07, -8.97362883139383566e-12*1./(1_MeV), 0, -3.00839639507890418e-09*1./(1_MeV), -1.34362151935947653e-09*1./(1_MeV), 6.19209989023759561e-11*1./(1_MeV), -8.97362883139383566e-12*1./(1_MeV), 9.50577724173617966e-13*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform8;
- ActsSymMatrixD<3> rotMat8;
- rotMat8 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform8.rotate(rotMat8);
- transform8.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans8 = std::make_shared<const Transform3D>(transform8);
- std::shared_ptr<PerigeeSurface> perigeeSurface8 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams8 = BoundParameters(tgContext, std::move(covMat8), params8, perigeeSurface8);
- tracks.push_back(boundParams8);
-
-
- // track 9 :
- BoundVector params9;
- params9 << -0.117531783878803253, 19.82318115234375, -1.45641529560089111, 2.29713797569274902, -0.00107527442742139101*1./(1_MeV), 0;
- Covariance covMat9;
- covMat9 << 0.0109546398743987083, 0.000422247521285191226, -0.000319963736434306643, 6.84778945643811993e-06, -1.94063777029596808e-07*1./(1_MeV), 0, 0.000422247521285191226, 0.038861934095621109, -1.73899586261722636e-05, 0.000539627280113898428, -1.08021534013767774e-09*1./(1_MeV), 0, -0.000319963736434306643, -1.73899586261722636e-05, 9.59809040068648756e-06, -2.82678258192879005e-07, 9.40666777698761478e-09*1./(1_MeV), 0, 6.84778945643811993e-06, 0.000539627280113898428, -2.82678258192879005e-07, 7.96383665147004649e-06, -2.67210172465569124e-11*1./(1_MeV), 0, -1.94063777029596808e-07*1./(1_MeV), -1.08021534013767774e-09*1./(1_MeV), 9.40666777698761478e-09*1./(1_MeV), -2.67210172465569124e-11*1./(1_MeV), 2.76092482209833179e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform9;
- ActsSymMatrixD<3> rotMat9;
- rotMat9 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform9.rotate(rotMat9);
- transform9.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans9 = std::make_shared<const Transform3D>(transform9);
- std::shared_ptr<PerigeeSurface> perigeeSurface9 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams9 = BoundParameters(tgContext, std::move(covMat9), params9, perigeeSurface9);
- tracks.push_back(boundParams9);
-
-
- // track 10 :
- BoundVector params10;
- params10 << -0.316214293241500854, 19.9858303070068359, 2.23136758804321289, 0.716844320297241211, 0.000286014255834743381*1./(1_MeV), 0;
- Covariance covMat10;
- covMat10 << 0.00162444496527314186, -9.06142655681587962e-05, -4.44249197781623932e-05, -1.8536710338487062e-07, -2.67329728219464978e-08*1./(1_MeV), 0, -9.06142655681587962e-05, 0.0111282505095005035, 1.36896327277162384e-06, 9.00038816992519377e-05, 1.26432483562719022e-09*1./(1_MeV), 0, -4.44249197781623932e-05, 1.36896327277162384e-06, 1.26552151868963847e-06, -3.4175627468367298e-09, 1.15430331899061749e-09*1./(1_MeV), 0, -1.8536710338487062e-07, 9.00038816992519377e-05, -3.4175627468367298e-09, 8.96049414222943597e-07, -1.35745946999861844e-11*1./(1_MeV), 0, -2.67329728219464978e-08*1./(1_MeV), 1.26432483562719022e-09*1./(1_MeV), 1.15430331899061749e-09*1./(1_MeV), -1.35745946999861844e-11*1./(1_MeV), 2.60673704843839005e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform10;
- ActsSymMatrixD<3> rotMat10;
- rotMat10 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform10.rotate(rotMat10);
- transform10.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans10 = std::make_shared<const Transform3D>(transform10);
- std::shared_ptr<PerigeeSurface> perigeeSurface10 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams10 = BoundParameters(tgContext, std::move(covMat10), params10, perigeeSurface10);
- tracks.push_back(boundParams10);
-
-
- // track 11 :
- BoundVector params11;
- params11 << -0.026949150487780571, 19.7217216491699219, -1.88010013103485107, 1.17576122283935547, -5.31275982211809605e-05*1./(1_MeV), 0;
- Covariance covMat11;
- covMat11 << 0.000139126204885542393, 7.52935130834812487e-06, -2.04280921055376971e-06, 4.12883664132396972e-08, -2.21097786141294125e-09*1./(1_MeV), 0, 7.52935130834812487e-06, 0.00334829371422529221, -4.54681154865933769e-08, 2.39657209827402611e-05, -7.07961483497201632e-10*1./(1_MeV), 0, -2.04280921055376971e-06, -4.54681154865933769e-08, 3.81113594016824209e-08, -5.67025045849674143e-10, 4.41613819941043693e-11*1./(1_MeV), 0, 4.12883664132396972e-08, 2.39657209827402611e-05, -5.67025045849674143e-10, 2.3924027914290491e-07, -7.29088756930822923e-12*1./(1_MeV), 0, -2.21097786141294125e-09*1./(1_MeV), -7.07961483497201632e-10*1./(1_MeV), 4.41613819941043693e-11*1./(1_MeV), -7.29088756930822923e-12*1./(1_MeV), 6.49562489300065105e-13*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform11;
- ActsSymMatrixD<3> rotMat11;
- rotMat11 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform11.rotate(rotMat11);
- transform11.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans11 = std::make_shared<const Transform3D>(transform11);
- std::shared_ptr<PerigeeSurface> perigeeSurface11 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams11 = BoundParameters(tgContext, std::move(covMat11), params11, perigeeSurface11);
- tracks.push_back(boundParams11);
-
-
- // track 12 :
- BoundVector params12;
- params12 << -0.0259521752595901489, 19.9042549133300781, 2.12977123260498047, 0.713346481323242188, 0.000183195850695483387*1./(1_MeV), 0;
- Covariance covMat12;
- covMat12 << 0.000819464214146137238, -2.93160457001729501e-05, -2.12643063322425127e-05, -1.06460388794225743e-07, -1.83180521921403142e-08*1./(1_MeV), 0, -2.93160457001729501e-05, 0.00743293715640902519, 3.1618179870268056e-07, 5.44865137200824102e-05, 1.28616095797583938e-09*1./(1_MeV), 0, -2.12643063322425127e-05, 3.1618179870268056e-07, 5.87186036682396661e-07, -3.96810184286856466e-10, 7.64845470534257536e-10*1./(1_MeV), 0, -1.06460388794225743e-07, 5.44865137200824102e-05, -3.96810184286856466e-10, 4.86239514430053532e-07, 2.28968063167242651e-12*1./(1_MeV), 0, -1.83180521921403142e-08*1./(1_MeV), 1.28616095797583938e-09*1./(1_MeV), 7.64845470534257536e-10*1./(1_MeV), 2.28968063167242651e-12*1./(1_MeV), 1.68847297254970385e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform12;
- ActsSymMatrixD<3> rotMat12;
- rotMat12 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform12.rotate(rotMat12);
- transform12.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans12 = std::make_shared<const Transform3D>(transform12);
- std::shared_ptr<PerigeeSurface> perigeeSurface12 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams12 = BoundParameters(tgContext, std::move(covMat12), params12, perigeeSurface12);
- tracks.push_back(boundParams12);
-
-
- // track 13 :
- BoundVector params13;
- params13 << -0.108195297420024872, 19.4963741302490234, -1.54784798622131348, 2.76453542709350586, 0.000255180755630135536*1./(1_MeV), 0;
- Covariance covMat13;
- covMat13 << 0.00656767562031745911, 0.000444740943016129486, -0.000189528672096109756, 7.43444913558239102e-07, -7.72608213653531881e-08*1./(1_MeV), 0, 0.000444740943016129486, 0.0576510205864906311, -6.36114600490174744e-06, 0.000213140984352768603, -5.47938491391429549e-09*1./(1_MeV), 0, -0.000189528672096109756, -6.36114600490174744e-06, 5.65102391192340292e-06, -1.16009327799978898e-09, 3.63038358649066484e-09*1./(1_MeV), 0, 7.43444913558239102e-07, 0.000213140984352768603, -1.16009327799978898e-09, 8.20147363356227288e-07, -1.16151818981247784e-11*1./(1_MeV), 0, -7.72608213653531881e-08*1./(1_MeV), -5.47938491391429549e-09*1./(1_MeV), 3.63038358649066484e-09*1./(1_MeV), -1.16151818981247784e-11*1./(1_MeV), 5.03207892021961811e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform13;
- ActsSymMatrixD<3> rotMat13;
- rotMat13 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform13.rotate(rotMat13);
- transform13.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans13 = std::make_shared<const Transform3D>(transform13);
- std::shared_ptr<PerigeeSurface> perigeeSurface13 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams13 = BoundParameters(tgContext, std::move(covMat13), params13, perigeeSurface13);
- tracks.push_back(boundParams13);
-
-
- // track 14 :
- BoundVector params14;
- params14 << 0.00369392801076173782, 19.7586956024169922, -1.87617933750152588, 1.1225888729095459, -0.000320049060974270105*1./(1_MeV), 0;
- Covariance covMat14;
- covMat14 << 0.000884613138623535633, -3.82952276847713579e-05, -2.2559200610146105e-05, -2.935347589307322e-07, -1.23401086351248597e-08*1./(1_MeV), 0, -3.82952276847713579e-05, 0.00863977242261171341, 1.31139582148740249e-06, 8.32184382843871649e-05, -2.57691337601532055e-09*1./(1_MeV), 0, -2.2559200610146105e-05, 1.31139582148740249e-06, 6.16463069036399247e-07, 1.02756832396022202e-08, 4.91883875434775907e-10*1./(1_MeV), 0, -2.935347589307322e-07, 8.32184382843871649e-05, 1.02756832396022202e-08, 1.14064482659159694e-06, -1.29782130095271682e-11*1./(1_MeV), 0, -1.23401086351248597e-08*1./(1_MeV), -2.57691337601532055e-09*1./(1_MeV), 4.91883875434775907e-10*1./(1_MeV), -1.29782130095271682e-11*1./(1_MeV), 1.47767145741717343e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform14;
- ActsSymMatrixD<3> rotMat14;
- rotMat14 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform14.rotate(rotMat14);
- transform14.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans14 = std::make_shared<const Transform3D>(transform14);
- std::shared_ptr<PerigeeSurface> perigeeSurface14 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams14 = BoundParameters(tgContext, std::move(covMat14), params14, perigeeSurface14);
- tracks.push_back(boundParams14);
-
-
- // track 15 :
- BoundVector params15;
- params15 << -0.0310039687901735306, 19.3887290954589844, -0.00343075022101402283, 2.74638152122497559, -0.000532752485014498234*1./(1_MeV), 0;
- Covariance covMat15;
- covMat15 << 0.0210070386528968811, 0.00081324441594192757, -0.000627920381522417519, 5.48433427524947839e-06, -4.65033942443220242e-07*1./(1_MeV), 0, 0.00081324441594192757, 0.163831159472465515, -4.16699183438430112e-05, 0.000680023693129414735, 4.78762996341304375e-09*1./(1_MeV), 0, -0.000627920381522417519, -4.16699183438430112e-05, 1.914421227411367e-05, -2.43960230438290961e-07, 2.22620707063765654e-08*1./(1_MeV), 0, 5.48433427524947839e-06, 0.000680023693129414735, -2.43960230438290961e-07, 2.88798310066340491e-06, -1.98088984995358787e-11*1./(1_MeV), 0, -4.65033942443220242e-07*1./(1_MeV), 4.78762996341304375e-09*1./(1_MeV), 2.22620707063765654e-08*1./(1_MeV), -1.98088984995358787e-11*1./(1_MeV), 3.28982507902253474e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform15;
- ActsSymMatrixD<3> rotMat15;
- rotMat15 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform15.rotate(rotMat15);
- transform15.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans15 = std::make_shared<const Transform3D>(transform15);
- std::shared_ptr<PerigeeSurface> perigeeSurface15 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams15 = BoundParameters(tgContext, std::move(covMat15), params15, perigeeSurface15);
- tracks.push_back(boundParams15);
-
-
- // track 16 :
- BoundVector params16;
- params16 << -0.0615801773965358734, 19.7117156982421875, -1.35818147659301758, 1.24108779430389404, 0.000683536636643111706*1./(1_MeV), 0;
- Covariance covMat16;
- covMat16 << 0.00367696909233927727, -6.93357704233026409e-05, -9.18706572871465986e-05, 6.07456121632656689e-08, -5.20653615571341965e-08*1./(1_MeV), 0, -6.93357704233026409e-05, 0.0121181188151240349, 8.53747299804855816e-07, 0.000199079474268702445, -6.01983132635719627e-10*1./(1_MeV), 0, -9.18706572871465986e-05, 8.53747299804855816e-07, 2.43243312070262618e-06, -1.96703166322206024e-08, 2.02041678483988925e-09*1./(1_MeV), 0, 6.07456121632656689e-08, 0.000199079474268702445, -1.96703166322206024e-08, 4.24742711402359419e-06, -5.3578874964861769e-11*1./(1_MeV), 0, -5.20653615571341965e-08*1./(1_MeV), -6.01983132635719627e-10*1./(1_MeV), 2.02041678483988925e-09*1./(1_MeV), -5.3578874964861769e-11*1./(1_MeV), 6.21097825947991566e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform16;
- ActsSymMatrixD<3> rotMat16;
- rotMat16 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform16.rotate(rotMat16);
- transform16.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans16 = std::make_shared<const Transform3D>(transform16);
- std::shared_ptr<PerigeeSurface> perigeeSurface16 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams16 = BoundParameters(tgContext, std::move(covMat16), params16, perigeeSurface16);
- tracks.push_back(boundParams16);
-
-
- // track 17 :
- BoundVector params17;
- params17 << 0.0127343572676181793, 19.6999797821044922, 1.36659955978393555, 2.38492679595947266, -1.37666047521634027e-05*1./(1_MeV), 0;
- Covariance covMat17;
- covMat17 << 7.14391426299698651e-05, 1.0805756954054268e-05, -8.57142054744985697e-07, 3.6976454665569372e-08, -1.42849189612088987e-09*1./(1_MeV), 0, 1.0805756954054268e-05, 0.00291397958062589169, -1.43522930069826317e-07, 1.16636632835631987e-05, -6.34703011704137292e-10*1./(1_MeV), 0, -8.57142054744985697e-07, -1.43522930069826317e-07, 1.44155682946234265e-08, -6.52670147341345277e-10, 2.26980129134178516e-11*1./(1_MeV), 0, 3.6976454665569372e-08, 1.16636632835631987e-05, -6.52670147341345277e-10, 6.37399537595229049e-08, -3.38191913541128504e-12*1./(1_MeV), 0, -1.42849189612088987e-09*1./(1_MeV), -6.34703011704137292e-10*1./(1_MeV), 2.26980129134178516e-11*1./(1_MeV), -3.38191913541128504e-12*1./(1_MeV), 1.40677413836866327e-13*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform17;
- ActsSymMatrixD<3> rotMat17;
- rotMat17 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform17.rotate(rotMat17);
- transform17.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans17 = std::make_shared<const Transform3D>(transform17);
- std::shared_ptr<PerigeeSurface> perigeeSurface17 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams17 = BoundParameters(tgContext, std::move(covMat17), params17, perigeeSurface17);
- tracks.push_back(boundParams17);
-
-
- // track 18 :
- BoundVector params18;
- params18 << -0.0384683907032012939, 19.7426490783691406, -1.80467498302459717, 1.19412243366241455, -0.000574302859604358673*1./(1_MeV), 0;
- Covariance covMat18;
- covMat18 << 0.00202423892915248871, -7.8687140869615615e-05, -5.63647103701870963e-05, -6.49649805133107235e-07, -3.34683099080895321e-08*1./(1_MeV), 0, -7.8687140869615615e-05, 0.0185887850821018219, 2.64877126417112638e-06, 0.000217824332446111879, -1.12870927770216557e-08*1./(1_MeV), 0, -5.63647103701870963e-05, 2.64877126417112638e-06, 1.6361793768737698e-06, 2.55884812519548554e-08, 1.44678702068679967e-09*1./(1_MeV), 0, -6.49649805133107235e-07, 0.000217824332446111879, 2.55884812519548554e-08, 3.64099946636997629e-06, -1.23298436708217984e-10*1./(1_MeV), 0, -3.34683099080895321e-08*1./(1_MeV), -1.12870927770216557e-08*1./(1_MeV), 1.44678702068679967e-09*1./(1_MeV), -1.23298436708217984e-10*1./(1_MeV), 4.65322051723671137e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform18;
- ActsSymMatrixD<3> rotMat18;
- rotMat18 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform18.rotate(rotMat18);
- transform18.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans18 = std::make_shared<const Transform3D>(transform18);
- std::shared_ptr<PerigeeSurface> perigeeSurface18 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams18 = BoundParameters(tgContext, std::move(covMat18), params18, perigeeSurface18);
- tracks.push_back(boundParams18);
-
-
- // track 19 :
- BoundVector params19;
- params19 << -0.00301715848036110401, 19.8266525268554688, -2.67224979400634766, 0.715977728366851807, -0.000728958519175648689*1./(1_MeV), 0;
- Covariance covMat19;
- covMat19 << 0.00722755817696452141, -0.000255548940999269852, -0.000217406702398603241, -3.1716960065804312e-06, -1.22003670918761397e-07*1./(1_MeV), 0, -0.000255548940999269852, 0.0352888740599155426, 1.12056165324810929e-05, 0.000387397513496410965, 1.44034486642105852e-09*1./(1_MeV), 0, -0.000217406702398603241, 1.12056165324810929e-05, 6.66530741000315174e-06, 1.44476099359170098e-07, 5.84575834646360909e-09*1./(1_MeV), 0, -3.1716960065804312e-06, 0.000387397513496410965, 1.44476099359170098e-07, 4.60058254247996956e-06, 2.70756521335290287e-11*1./(1_MeV), 0, -1.22003670918761397e-07*1./(1_MeV), 1.44034486642105852e-09*1./(1_MeV), 5.84575834646360909e-09*1./(1_MeV), 2.70756521335290287e-11*1./(1_MeV), 1.47919038129273872e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform19;
- ActsSymMatrixD<3> rotMat19;
- rotMat19 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform19.rotate(rotMat19);
- transform19.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans19 = std::make_shared<const Transform3D>(transform19);
- std::shared_ptr<PerigeeSurface> perigeeSurface19 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams19 = BoundParameters(tgContext, std::move(covMat19), params19, perigeeSurface19);
- tracks.push_back(boundParams19);
-
-
- // track 20 :
- BoundVector params20;
- params20 << -0.050889924168586731, 19.6028633117675781, 0.112749122083187103, 2.38145637512207031, -0.000236698266235180199*1./(1_MeV), 0;
- Covariance covMat20;
- covMat20 << 0.00143691536504775286, 0.000164076889054642412, -3.58648437617112441e-05, 9.51572596730293739e-07, -2.06847797524276209e-08*1./(1_MeV), 0, 0.000164076889054642412, 0.0106960544362664223, -3.61365524801671333e-06, 9.12128019022396863e-05, 1.63349320460262432e-09*1./(1_MeV), 0, -3.58648437617112441e-05, -3.61365524801671333e-06, 9.44514340517343953e-07, -2.26900632828089059e-08, 8.985070684429297e-10*1./(1_MeV), 0, 9.51572596730293739e-07, 9.12128019022396863e-05, -2.26900632828089059e-08, 9.40663255732943071e-07, -7.29312017504296212e-12*1./(1_MeV), 0, -2.06847797524276209e-08*1./(1_MeV), 1.63349320460262432e-09*1./(1_MeV), 8.985070684429297e-10*1./(1_MeV), -7.29312017504296212e-12*1./(1_MeV), 2.3087929137965979e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform20;
- ActsSymMatrixD<3> rotMat20;
- rotMat20 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform20.rotate(rotMat20);
- transform20.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans20 = std::make_shared<const Transform3D>(transform20);
- std::shared_ptr<PerigeeSurface> perigeeSurface20 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams20 = BoundParameters(tgContext, std::move(covMat20), params20, perigeeSurface20);
- tracks.push_back(boundParams20);
-
-
- // track 21 :
- BoundVector params21;
- params21 << 0.340526312589645386, 19.5222663879394531, 1.98806488513946533, 0.645573973655700684, -0.000210438229260034859*1./(1_MeV), 0;
- Covariance covMat21;
- covMat21 << 0.00187653978355228901, -4.61886315977834042e-05, -4.50543377001786315e-05, -4.23803726213808519e-07, -2.27506680726447051e-08*1./(1_MeV), 0, -4.61886315977834042e-05, 0.00947334989905357361, 1.12025168001414582e-06, 6.5792105051481426e-05, -1.06230443637615531e-09*1./(1_MeV), 0, -4.50543377001786315e-05, 1.12025168001414582e-06, 1.15167620151623851e-06, 1.18795575818832697e-08, 8.43143312452009429e-10*1./(1_MeV), 0, -4.23803726213808519e-07, 6.5792105051481426e-05, 1.18795575818832697e-08, 5.50924369235872291e-07, 5.88708293652256259e-12*1./(1_MeV), 0, -2.27506680726447051e-08*1./(1_MeV), -1.06230443637615531e-09*1./(1_MeV), 8.43143312452009429e-10*1./(1_MeV), 5.88708293652256259e-12*1./(1_MeV), 1.54570852645141699e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform21;
- ActsSymMatrixD<3> rotMat21;
- rotMat21 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform21.rotate(rotMat21);
- transform21.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans21 = std::make_shared<const Transform3D>(transform21);
- std::shared_ptr<PerigeeSurface> perigeeSurface21 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams21 = BoundParameters(tgContext, std::move(covMat21), params21, perigeeSurface21);
- tracks.push_back(boundParams21);
-
-
- // track 22 :
- BoundVector params22;
- params22 << 0.0327057354152202606, 19.7024917602539062, -2.13715505599975586, 2.80726861953735352, 0.000263765512499958277*1./(1_MeV), 0;
- Covariance covMat22;
- covMat22 << 0.00759664503857493401, 0.000905364247503756396, -0.000227879179537351814, 1.47085121825187884e-06, -1.05708472073745111e-07*1./(1_MeV), 0, 0.000905364247503756396, 0.0961576402187347412, -1.17275682104315631e-05, 0.00028353976847481278, -9.08595344434235293e-09*1./(1_MeV), 0, -0.000227879179537351814, -1.17275682104315631e-05, 7.0192058956308756e-06, -5.73812881555304563e-09, 5.16319886110993577e-09*1./(1_MeV), 0, 1.47085121825187884e-06, 0.00028353976847481278, -5.73812881555304563e-09, 8.68534641540463781e-07, -1.7137080433623932e-11*1./(1_MeV), 0, -1.05708472073745111e-07*1./(1_MeV), -9.08595344434235293e-09*1./(1_MeV), 5.16319886110993577e-09*1./(1_MeV), -1.7137080433623932e-11*1./(1_MeV), 6.82771200688492286e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform22;
- ActsSymMatrixD<3> rotMat22;
- rotMat22 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform22.rotate(rotMat22);
- transform22.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans22 = std::make_shared<const Transform3D>(transform22);
- std::shared_ptr<PerigeeSurface> perigeeSurface22 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams22 = BoundParameters(tgContext, std::move(covMat22), params22, perigeeSurface22);
- tracks.push_back(boundParams22);
-
-
- // track 23 :
- BoundVector params23;
- params23 << -0.313747167587280273, 19.8418807983398438, 2.22803497314453125, 0.69142603874206543, 0.000169251798070035875*1./(1_MeV), 0;
- Covariance covMat23;
- covMat23 << 0.000822073488961905241, -4.22023511849360173e-05, -2.11682852032007045e-05, -1.39809980877076557e-07, -1.13325862651714777e-08*1./(1_MeV), 0, -4.22023511849360173e-05, 0.00642389757558703423, 4.73854987704379056e-07, 4.62124676517580748e-05, 7.96633147731774745e-10*1./(1_MeV), 0, -2.11682852032007045e-05, 4.73854987704379056e-07, 5.80069183797604637e-07, 3.15912432766058085e-11, 4.56396742731161166e-10*1./(1_MeV), 0, -1.39809980877076557e-07, 4.62124676517580748e-05, 3.15912432766058085e-11, 3.99615089463623008e-07, 2.27545298907622666e-12*1./(1_MeV), 0, -1.13325862651714777e-08*1./(1_MeV), 7.96633147731774745e-10*1./(1_MeV), 4.56396742731161166e-10*1./(1_MeV), 2.27545298907622666e-12*1./(1_MeV), 9.23549778319987524e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform23;
- ActsSymMatrixD<3> rotMat23;
- rotMat23 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform23.rotate(rotMat23);
- transform23.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans23 = std::make_shared<const Transform3D>(transform23);
- std::shared_ptr<PerigeeSurface> perigeeSurface23 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams23 = BoundParameters(tgContext, std::move(covMat23), params23, perigeeSurface23);
- tracks.push_back(boundParams23);
-
-
- // track 24 :
- BoundVector params24;
- params24 << 0.0601691603660583496, 19.4889583587646484, 1.45675015449523926, 1.56046152114868164, -0.000939691497478634119*1./(1_MeV), 0;
- Covariance covMat24;
- covMat24 << 0.00347459153272211552, 2.61288253282652421e-08, -0.000100485766757895184, -1.57776073352115993e-08, -5.9865669012875978e-08*1./(1_MeV), 0, 2.61288253282652421e-08, 0.0155909880995750427, 4.31090469568027334e-09, 0.00030456631727040519, -2.26566988417194164e-09*1./(1_MeV), 0, -0.000100485766757895184, 4.31090469568027334e-09, 2.96180473924323451e-06, 7.78080017868743252e-10, 2.82122625662053921e-09*1./(1_MeV), 0, -1.57776073352115993e-08, 0.00030456631727040519, 7.78080017868743252e-10, 7.35272124074981548e-06, -3.83106395644490913e-11*1./(1_MeV), 0, -5.9865669012875978e-08*1./(1_MeV), -2.26566988417194164e-09*1./(1_MeV), 2.82122625662053921e-09*1./(1_MeV), -3.83106395644490913e-11*1./(1_MeV), 1.06380099174074871e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform24;
- ActsSymMatrixD<3> rotMat24;
- rotMat24 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform24.rotate(rotMat24);
- transform24.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans24 = std::make_shared<const Transform3D>(transform24);
- std::shared_ptr<PerigeeSurface> perigeeSurface24 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams24 = BoundParameters(tgContext, std::move(covMat24), params24, perigeeSurface24);
- tracks.push_back(boundParams24);
-
-
- // track 25 :
- BoundVector params25;
- params25 << 0.305262893438339233, 19.6428985595703125, 2.0014500617980957, 0.674862563610076904, -0.000269854936050251126*1./(1_MeV), 0;
- Covariance covMat25;
- covMat25 << 0.00167414336465299129, -1.78847304832933408e-05, -4.55389135089741097e-05, -3.82403117295285017e-07, -2.12364403958921256e-08*1./(1_MeV), 0, -1.78847304832933408e-05, 0.0104135861620306969, 6.75815994310390194e-07, 8.49609773572517027e-05, -1.92504072395493255e-10*1./(1_MeV), 0, -4.55389135089741097e-05, 6.75815994310390194e-07, 1.29258842207491398e-06, 1.38985937523038846e-08, 9.37637080501081717e-10*1./(1_MeV), 0, -3.82403117295285017e-07, 8.49609773572517027e-05, 1.38985937523038846e-08, 7.91449053849646589e-07, 7.1066766939193851e-12*1./(1_MeV), 0, -2.12364403958921256e-08*1./(1_MeV), -1.92504072395493255e-10*1./(1_MeV), 9.37637080501081717e-10*1./(1_MeV), 7.1066766939193851e-12*1./(1_MeV), 2.08066983781174386e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform25;
- ActsSymMatrixD<3> rotMat25;
- rotMat25 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform25.rotate(rotMat25);
- transform25.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans25 = std::make_shared<const Transform3D>(transform25);
- std::shared_ptr<PerigeeSurface> perigeeSurface25 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams25 = BoundParameters(tgContext, std::move(covMat25), params25, perigeeSurface25);
- tracks.push_back(boundParams25);
-
-
- // track 26 :
- BoundVector params26;
- params26 << -0.0716414377093315125, 19.4469375610351562, -1.31057024002075195, 2.37900662422180176, -0.000480518414406105876*1./(1_MeV), 0;
- Covariance covMat26;
- covMat26 << 0.00311773899011313915, 0.000216807668024049122, -8.85980764209346383e-05, 2.33675139737157217e-06, -5.69352023227364653e-08*1./(1_MeV), 0, 0.000216807668024049122, 0.0251653064042329788, -6.874046489217475e-06, 0.000259795929953506673, 1.0275478076867433e-09*1./(1_MeV), 0, -8.85980764209346383e-05, -6.874046489217475e-06, 2.60891670222918037e-06, -7.84173992006491199e-08, 2.8010804631721876e-09*1./(1_MeV), 0, 2.33675139737157217e-06, 0.000259795929953506673, -7.84173992006491199e-08, 2.90308980765985325e-06, -2.89203496927991014e-12*1./(1_MeV), 0, -5.69352023227364653e-08*1./(1_MeV), 1.0275478076867433e-09*1./(1_MeV), 2.8010804631721876e-09*1./(1_MeV), -2.89203496927991014e-12*1./(1_MeV), 7.90091464475395355e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform26;
- ActsSymMatrixD<3> rotMat26;
- rotMat26 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform26.rotate(rotMat26);
- transform26.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans26 = std::make_shared<const Transform3D>(transform26);
- std::shared_ptr<PerigeeSurface> perigeeSurface26 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams26 = BoundParameters(tgContext, std::move(covMat26), params26, perigeeSurface26);
- tracks.push_back(boundParams26);
-
-
- // track 27 :
- BoundVector params27;
- params27 << 0.0340305417776107788, 19.7064609527587891, 1.96402919292449951, 0.62500452995300293, 0.000157972215674817562*1./(1_MeV), 0;
- Covariance covMat27;
- covMat27 << 0.00115194241516292095, -1.75935599558400332e-05, -2.72476171609115263e-05, -3.19554349594589653e-08, -1.21725335271778638e-08*1./(1_MeV), 0, -1.75935599558400332e-05, 0.00663218600675463676, -1.47069503149528377e-08, 4.24403084279258386e-05, -1.17670450049324461e-11*1./(1_MeV), 0, -2.72476171609115263e-05, -1.47069503149528377e-08, 6.9136649472056888e-07, -1.3832287263184986e-09, 4.45969786691428052e-10*1./(1_MeV), 0, -3.19554349594589653e-08, 4.24403084279258386e-05, -1.3832287263184986e-09, 3.26797248817456421e-07, -3.37620811397436092e-13*1./(1_MeV), 0, -1.21725335271778638e-08*1./(1_MeV), -1.17670450049324461e-11*1./(1_MeV), 4.45969786691428052e-10*1./(1_MeV), -3.37620811397436092e-13*1./(1_MeV), 7.86358218124449948e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform27;
- ActsSymMatrixD<3> rotMat27;
- rotMat27 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform27.rotate(rotMat27);
- transform27.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans27 = std::make_shared<const Transform3D>(transform27);
- std::shared_ptr<PerigeeSurface> perigeeSurface27 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams27 = BoundParameters(tgContext, std::move(covMat27), params27, perigeeSurface27);
- tracks.push_back(boundParams27);
-
-
- // track 28 :
- BoundVector params28;
- params28 << -0.0371651053428649902, 19.7891578674316406, -0.659238219261169434, 0.274633139371871948, -3.11207440972793847e-05*1./(1_MeV), 0;
- Covariance covMat28;
- covMat28 << 0.00094830815214663744, -0.00019487656314514027, -2.12130854277417798e-05, -2.34663925361313877e-07, -3.03861064262990213e-09*1./(1_MeV), 0, -0.00019487656314514027, 0.0170497521758079529, 3.70571285096039324e-06, 2.64888644523930275e-05, 2.42556496747356217e-10*1./(1_MeV), 0, -2.12130854277417798e-05, 3.70571285096039324e-06, 5.07914478475868236e-07, 4.96919950915106563e-09, 1.14830219767461788e-10*1./(1_MeV), 0, -2.34663925361313877e-07, 2.64888644523930275e-05, 4.96919950915106563e-09, 4.59249491768787266e-08, 2.84459713659211857e-13*1./(1_MeV), 0, -3.03861064262990213e-09*1./(1_MeV), 2.42556496747356217e-10*1./(1_MeV), 1.14830219767461788e-10*1./(1_MeV), 2.84459713659211857e-13*1./(1_MeV), 9.65581672777993116e-13*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform28;
- ActsSymMatrixD<3> rotMat28;
- rotMat28 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform28.rotate(rotMat28);
- transform28.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans28 = std::make_shared<const Transform3D>(transform28);
- std::shared_ptr<PerigeeSurface> perigeeSurface28 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams28 = BoundParameters(tgContext, std::move(covMat28), params28, perigeeSurface28);
- tracks.push_back(boundParams28);
-
-
- // track 29 :
- BoundVector params29;
- params29 << 0.0113061871379613876, 19.7758064270019531, -0.565121948719024658, 1.11297404766082764, -0.000380097364541143179*1./(1_MeV), 0;
- Covariance covMat29;
- covMat29 << 0.00155933154746890068, -4.97482623935557549e-05, -3.73456424926352755e-05, -4.55759156051640272e-07, -2.07172213465749658e-08*1./(1_MeV), 0, -4.97482623935557549e-05, 0.00686531048268079758, 1.31561141444726331e-06, 8.97714266550412308e-05, -1.19474789182683184e-09*1./(1_MeV), 0, -3.73456424926352755e-05, 1.31561141444726331e-06, 9.55697146309830714e-07, 1.30428805682263728e-08, 7.75026676835572029e-10*1./(1_MeV), 0, -4.55759156051640272e-07, 8.97714266550412308e-05, 1.30428805682263728e-08, 1.62136052495043259e-06, -3.68485465951844148e-12*1./(1_MeV), 0, -2.07172213465749658e-08*1./(1_MeV), -1.19474789182683184e-09*1./(1_MeV), 7.75026676835572029e-10*1./(1_MeV), -3.68485465951844148e-12*1./(1_MeV), 2.15952047910583644e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform29;
- ActsSymMatrixD<3> rotMat29;
- rotMat29 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform29.rotate(rotMat29);
- transform29.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans29 = std::make_shared<const Transform3D>(transform29);
- std::shared_ptr<PerigeeSurface> perigeeSurface29 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams29 = BoundParameters(tgContext, std::move(covMat29), params29, perigeeSurface29);
- tracks.push_back(boundParams29);
-
-
- // track 30 :
- BoundVector params30;
- params30 << -0.000764124910347163677, 19.7925205230712891, -1.60565555095672607, 2.11691427230834961, 0.00109597900882363319*1./(1_MeV), 0;
- Covariance covMat30;
- covMat30 << 0.00818897411227226257, -7.88637168572715077e-05, -0.000237841176207310301, -2.86874654680000338e-06, -1.07533611185096677e-07*1./(1_MeV), 0, -7.88637168572715077e-05, 0.0303833372890949249, 6.69007874662318617e-06, 0.000503271982246975501, 1.40492310581731278e-09*1./(1_MeV), 0, -0.000237841176207310301, 6.69007874662318617e-06, 7.098253263393417e-06, 1.64058162507511388e-07, 5.23793435502016417e-09*1./(1_MeV), 0, -2.86874654680000338e-06, 0.000503271982246975501, 1.64058162507511388e-07, 9.68445510807214305e-06, 4.84013097877190455e-11*1./(1_MeV), 0, -1.07533611185096677e-07*1./(1_MeV), 1.40492310581731278e-09*1./(1_MeV), 5.23793435502016417e-09*1./(1_MeV), 4.84013097877190455e-11*1./(1_MeV), 1.75064601704022493e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform30;
- ActsSymMatrixD<3> rotMat30;
- rotMat30 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform30.rotate(rotMat30);
- transform30.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans30 = std::make_shared<const Transform3D>(transform30);
- std::shared_ptr<PerigeeSurface> perigeeSurface30 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams30 = BoundParameters(tgContext, std::move(covMat30), params30, perigeeSurface30);
- tracks.push_back(boundParams30);
-
-
- // track 31 :
- BoundVector params31;
- params31 << 0.0434660129249095917, 19.9743804931640625, -1.92152023315429688, 1.10322427749633789, -0.00135057768784463406*1./(1_MeV), 0;
- Covariance covMat31;
- covMat31 << 0.00949090253561735153, -0.000162514116123452891, -0.000277450606342210756, -3.41726209466831981e-06, -1.35977257290003362e-07*1./(1_MeV), 0, -0.000162514116123452891, 0.0241005755960941315, 7.44390386227167547e-06, 0.000482722310593120495, -5.01533653096054345e-09*1./(1_MeV), 0, -0.000277450606342210756, 7.44390386227167547e-06, 8.34032562124775723e-06, 1.70338602887570872e-07, 6.59502382970017033e-09*1./(1_MeV), 0, -3.41726209466831981e-06, 0.000482722310593120495, 1.70338602887570872e-07, 1.08669210021616891e-05, -1.30623540733939145e-10*1./(1_MeV), 0, -1.35977257290003362e-07*1./(1_MeV), -5.01533653096054345e-09*1./(1_MeV), 6.59502382970017033e-09*1./(1_MeV), -1.30623540733939145e-10*1./(1_MeV), 2.33806835003846913e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform31;
- ActsSymMatrixD<3> rotMat31;
- rotMat31 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform31.rotate(rotMat31);
- transform31.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans31 = std::make_shared<const Transform3D>(transform31);
- std::shared_ptr<PerigeeSurface> perigeeSurface31 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams31 = BoundParameters(tgContext, std::move(covMat31), params31, perigeeSurface31);
- tracks.push_back(boundParams31);
-
-
- // track 32 :
- BoundVector params32;
- params32 << -0.323653548955917358, 23.0863323211669922, -2.04575490951538086, 1.19155371189117432, -0.00135404628235846758*1./(1_MeV), 0;
- Covariance covMat32;
- covMat32 << 0.00942049268633127213, -0.000156100331056732402, -0.000267428691337353848, -2.84213758688659959e-06, -1.3715343361864345e-07*1./(1_MeV), 0, -0.000156100331056732402, 0.0234745144844055176, 6.9330452366765478e-06, 0.000468627570852257769, 4.42012838944869237e-10*1./(1_MeV), 0, -0.000267428691337353848, 6.9330452366765478e-06, 7.8662105806870386e-06, 1.40317764457691491e-07, 6.38338658586116389e-09*1./(1_MeV), 0, -2.84213758688659959e-06, 0.000468627570852257769, 1.40317764457691491e-07, 1.09587390397791751e-05, 1.69050142770342731e-12*1./(1_MeV), 0, -1.3715343361864345e-07*1./(1_MeV), 4.42012838944869237e-10*1./(1_MeV), 6.38338658586116389e-09*1./(1_MeV), 1.69050142770342731e-12*1./(1_MeV), 2.24243526525391701e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform32;
- ActsSymMatrixD<3> rotMat32;
- rotMat32 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform32.rotate(rotMat32);
- transform32.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans32 = std::make_shared<const Transform3D>(transform32);
- std::shared_ptr<PerigeeSurface> perigeeSurface32 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams32 = BoundParameters(tgContext, std::move(covMat32), params32, perigeeSurface32);
- tracks.push_back(boundParams32);
-
-
- // track 33 :
- BoundVector params33;
- params33 << 0.0502348393201828003, 19.8225479125976562, 1.2200552225112915, 1.19947576522827148, 0.00065168103901669383*1./(1_MeV), 0;
- Covariance covMat33;
- covMat33 << 0.00330946571193635464, -3.03961755070003361e-05, -8.23355349674717059e-05, 3.61557925205989208e-07, -4.81647993693705346e-08*1./(1_MeV), 0, -3.03961755070003361e-05, 0.0121201490983366966, -3.44926830210965382e-08, 0.0001832216673901092, -8.289858737864768e-09*1./(1_MeV), 0, -8.23355349674717059e-05, -3.44926830210965382e-08, 2.16286139220756013e-06, -2.50835114436962174e-08, 1.88343068671924282e-09*1./(1_MeV), 0, 3.61557925205989208e-07, 0.0001832216673901092, -2.50835114436962174e-08, 3.61402794624154922e-06, -1.38343005917598103e-10*1./(1_MeV), 0, -4.81647993693705346e-08*1./(1_MeV), -8.289858737864768e-09*1./(1_MeV), 1.88343068671924282e-09*1./(1_MeV), -1.38343005917598103e-10*1./(1_MeV), 5.75411177039519828e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform33;
- ActsSymMatrixD<3> rotMat33;
- rotMat33 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform33.rotate(rotMat33);
- transform33.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans33 = std::make_shared<const Transform3D>(transform33);
- std::shared_ptr<PerigeeSurface> perigeeSurface33 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams33 = BoundParameters(tgContext, std::move(covMat33), params33, perigeeSurface33);
- tracks.push_back(boundParams33);
-
-
- // track 34 :
- BoundVector params34;
- params34 << -0.00679738679900765419, 19.7787380218505859, 0.64978182315826416, 1.718436598777771, 0.000399400596506893635*1./(1_MeV), 0;
- Covariance covMat34;
- covMat34 << 0.0016832397086545825, 3.08902871283228804e-08, -3.9761794373880207e-05, -5.36301231604843024e-08, -1.25551948300567075e-08*1./(1_MeV), 0, 3.08902871283228804e-08, 0.0122804483398795128, 1.50321795312578277e-07, 0.000155226454439672071, -3.69637596757974278e-09*1./(1_MeV), 0, -3.9761794373880207e-05, 1.50321795312578277e-07, 1.01230580185074359e-06, 3.57209146154241154e-09, 5.08893136683866958e-10*1./(1_MeV), 0, -5.36301231604843024e-08, 0.000155226454439672071, 3.57209146154241154e-09, 2.92897698273009155e-06, -4.64295001076053898e-11*1./(1_MeV), 0, -1.25551948300567075e-08*1./(1_MeV), -3.69637596757974278e-09*1./(1_MeV), 5.08893136683866958e-10*1./(1_MeV), -4.64295001076053898e-11*1./(1_MeV), 1.79039612996367836e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform34;
- ActsSymMatrixD<3> rotMat34;
- rotMat34 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform34.rotate(rotMat34);
- transform34.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans34 = std::make_shared<const Transform3D>(transform34);
- std::shared_ptr<PerigeeSurface> perigeeSurface34 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams34 = BoundParameters(tgContext, std::move(covMat34), params34, perigeeSurface34);
- tracks.push_back(boundParams34);
-
-
- // track 35 :
- BoundVector params35;
- params35 << 0.0805509239435195923, 19.8107032775878906, -0.580723822116851807, 1.39042818546295166, -0.000723547651432454586*1./(1_MeV), 0;
- Covariance covMat35;
- covMat35 << 0.00366608682088553905, -3.07736450112954378e-05, -9.36432680714786278e-05, -4.32691756908737401e-07, -4.03209869361722161e-08*1./(1_MeV), 0, -3.07736450112954378e-05, 0.0121293710544705391, 8.84241894101609937e-07, 0.000208273787997539348, -4.72119222103642781e-09*1./(1_MeV), 0, -9.36432680714786278e-05, 8.84241894101609937e-07, 2.51136862061684951e-06, 1.65541645067806758e-08, 1.643748206415159e-09*1./(1_MeV), 0, -4.32691756908737401e-07, 0.000208273787997539348, 1.65541645067806758e-08, 4.73576938020414673e-06, -5.8294474111660837e-11*1./(1_MeV), 0, -4.03209869361722161e-08*1./(1_MeV), -4.72119222103642781e-09*1./(1_MeV), 1.643748206415159e-09*1./(1_MeV), -5.8294474111660837e-11*1./(1_MeV), 5.46871367634871319e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform35;
- ActsSymMatrixD<3> rotMat35;
- rotMat35 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform35.rotate(rotMat35);
- transform35.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans35 = std::make_shared<const Transform3D>(transform35);
- std::shared_ptr<PerigeeSurface> perigeeSurface35 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams35 = BoundParameters(tgContext, std::move(covMat35), params35, perigeeSurface35);
- tracks.push_back(boundParams35);
-
-
- // track 36 :
- BoundVector params36;
- params36 << 0.0170946419239044189, 19.5798168182373047, 2.3832242488861084, 1.84145426750183105, -0.0016136891208589077*1./(1_MeV), 0;
- Covariance covMat36;
- covMat36 << 0.0110465008765459061, 0.000132400605777621878, -0.000322046919185156361, 3.95346550436209276e-06, -1.74628381920564644e-07*1./(1_MeV), 0, 0.000132400605777621878, 0.0441923066973686218, -7.93550960128202309e-06, 0.000857220862319744157, -3.078313337372045e-09*1./(1_MeV), 0, -0.000322046919185156361, -7.93550960128202309e-06, 9.60366560320835561e-06, -2.05361008506430899e-07, 8.74873834892499733e-09*1./(1_MeV), 0, 3.95346550436209276e-06, 0.000857220862319744157, -2.05361008506430899e-07, 1.90070531971286982e-05, -2.62406175067672348e-11*1./(1_MeV), 0, -1.74628381920564644e-07*1./(1_MeV), -3.078313337372045e-09*1./(1_MeV), 8.74873834892499733e-09*1./(1_MeV), -2.62406175067672348e-11*1./(1_MeV), 3.43723355333835912e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform36;
- ActsSymMatrixD<3> rotMat36;
- rotMat36 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform36.rotate(rotMat36);
- transform36.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans36 = std::make_shared<const Transform3D>(transform36);
- std::shared_ptr<PerigeeSurface> perigeeSurface36 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams36 = BoundParameters(tgContext, std::move(covMat36), params36, perigeeSurface36);
- tracks.push_back(boundParams36);
-
-
- // track 37 :
- BoundVector params37;
- params37 << 0.0422709546983242035, 19.8179073333740234, -0.292277246713638306, 1.55503785610198975, 0.00102485006209462881*1./(1_MeV), 0;
- Covariance covMat37;
- covMat37 << 0.0048865852877497673, 1.04378577009161224e-06, -0.000137165974802729929, 5.94294471798817227e-08, -7.83582361279693423e-08*1./(1_MeV), 0, 1.04378577009161224e-06, 0.0150463152676820755, -1.19789705332920958e-07, 0.000332276925926711661, -1.66883965671842617e-09*1./(1_MeV), 0, -0.000137165974802729929, -1.19789705332920958e-07, 3.95677625419921242e-06, -3.54401466185166792e-09, 3.6142052743200193e-09*1./(1_MeV), 0, 5.94294471798817227e-08, 0.000332276925926711661, -3.54401466185166792e-09, 8.53642995934933424e-06, -2.50276756413508482e-11*1./(1_MeV), 0, -7.83582361279693423e-08*1./(1_MeV), -1.66883965671842617e-09*1./(1_MeV), 3.6142052743200193e-09*1./(1_MeV), -2.50276756413508482e-11*1./(1_MeV), 1.35456687533341835e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform37;
- ActsSymMatrixD<3> rotMat37;
- rotMat37 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform37.rotate(rotMat37);
- transform37.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans37 = std::make_shared<const Transform3D>(transform37);
- std::shared_ptr<PerigeeSurface> perigeeSurface37 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams37 = BoundParameters(tgContext, std::move(covMat37), params37, perigeeSurface37);
- tracks.push_back(boundParams37);
-
-
- // track 38 :
- BoundVector params38;
- params38 << 0.0177954975515604019, 19.6020870208740234, 2.58446574211120605, 2.14368629455566406, 0.00039697738247923553*1./(1_MeV), 0;
- Covariance covMat38;
- covMat38 << 0.00228728121146559715, -6.6835355739982095e-07, -5.56660017110235266e-05, -2.3660648892322657e-07, -2.44971223220455001e-08*1./(1_MeV), 0, -6.6835355739982095e-07, 0.0207388382405042648, 9.95559061054844415e-07, 0.000196521767889107021, -9.37926118817295971e-09*1./(1_MeV), 0, -5.56660017110235266e-05, 9.95559061054844415e-07, 1.44270552482339554e-06, 1.62772969664253208e-08, 9.58725521674916825e-10*1./(1_MeV), 0, -2.3660648892322657e-07, 0.000196521767889107021, 1.62772969664253208e-08, 2.3284674171009101e-06, -3.82657738677909124e-11*1./(1_MeV), 0, -2.44971223220455001e-08*1./(1_MeV), -9.37926118817295971e-09*1./(1_MeV), 9.58725521674916825e-10*1./(1_MeV), -3.82657738677909124e-11*1./(1_MeV), 2.58620104498508141e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform38;
- ActsSymMatrixD<3> rotMat38;
- rotMat38 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform38.rotate(rotMat38);
- transform38.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans38 = std::make_shared<const Transform3D>(transform38);
- std::shared_ptr<PerigeeSurface> perigeeSurface38 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams38 = BoundParameters(tgContext, std::move(covMat38), params38, perigeeSurface38);
- tracks.push_back(boundParams38);
-
-
- // track 39 :
- BoundVector params39;
- params39 << 0.0385684818029403687, 19.5943107604980469, 2.10506224632263184, 0.815114736557006836, -0.000444010045612230897*1./(1_MeV), 0;
- Covariance covMat39;
- covMat39 << 0.00257171900011599064, -8.38966740548737503e-05, -6.9521214623902581e-05, -1.04908792338842471e-06, -4.18962156374891846e-08*1./(1_MeV), 0, -8.38966740548737503e-05, 0.012954135425388813, 2.69320887977152083e-06, 0.000145498663861290411, 4.42965387319607159e-10*1./(1_MeV), 0, -6.9521214623902581e-05, 2.69320887977152083e-06, 1.96165024135552812e-06, 3.61876337782125774e-08, 1.88426409286430859e-09*1./(1_MeV), 0, -1.04908792338842471e-06, 0.000145498663861290411, 3.61876337782125774e-08, 1.82780070190347033e-06, 1.36738002410268621e-11*1./(1_MeV), 0, -4.18962156374891846e-08*1./(1_MeV), 4.42965387319607159e-10*1./(1_MeV), 1.88426409286430859e-09*1./(1_MeV), 1.36738002410268621e-11*1./(1_MeV), 5.138850109331905e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform39;
- ActsSymMatrixD<3> rotMat39;
- rotMat39 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform39.rotate(rotMat39);
- transform39.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans39 = std::make_shared<const Transform3D>(transform39);
- std::shared_ptr<PerigeeSurface> perigeeSurface39 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams39 = BoundParameters(tgContext, std::move(covMat39), params39, perigeeSurface39);
- tracks.push_back(boundParams39);
-
-
- // track 40 :
- BoundVector params40;
- params40 << -0.00192465144209563732, 19.6035480499267578, 1.34771013259887695, 1.37635326385498047, 0.000349941314198076725*1./(1_MeV), 0;
- Covariance covMat40;
- covMat40 << 0.00092626502737402916, -4.70278465200604772e-06, -2.37325601967636777e-05, 2.6469781945744914e-08, -1.04657823685612316e-08*1./(1_MeV), 0, -4.70278465200604772e-06, 0.00892938859760761261, -2.32025646493256662e-08, 9.67470782924100583e-05, -1.28292191621348689e-09*1./(1_MeV), 0, -2.37325601967636777e-05, -2.32025646493256662e-08, 6.42108432202803669e-07, -2.41607947044108425e-09, 4.13063041753621467e-10*1./(1_MeV), 0, 2.6469781945744914e-08, 9.67470782924100583e-05, -2.41607947044108425e-09, 1.45360513670311775e-06, -1.4243170245924231e-11*1./(1_MeV), 0, -1.04657823685612316e-08*1./(1_MeV), -1.28292191621348689e-09*1./(1_MeV), 4.13063041753621467e-10*1./(1_MeV), -1.4243170245924231e-11*1./(1_MeV), 1.31918035523037602e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform40;
- ActsSymMatrixD<3> rotMat40;
- rotMat40 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform40.rotate(rotMat40);
- transform40.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans40 = std::make_shared<const Transform3D>(transform40);
- std::shared_ptr<PerigeeSurface> perigeeSurface40 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams40 = BoundParameters(tgContext, std::move(covMat40), params40, perigeeSurface40);
- tracks.push_back(boundParams40);
-
-
- // track 41 :
- BoundVector params41;
- params41 << -0.0107631208375096321, 19.6368961334228516, 2.11897373199462891, 0.68950730562210083, 0.000500780763104557991*1./(1_MeV), 0;
- Covariance covMat41;
- covMat41 << 0.0046280999667942524, -8.50248504624665413e-05, -0.000130293248442505169, 3.81786496695030795e-07, -6.22341861031614923e-08*1./(1_MeV), 0, -8.50248504624665413e-05, 0.0234155002981424332, -1.02870605123693907e-06, 0.000220617921810967285, 1.23912522027359707e-09*1./(1_MeV), 0, -0.000130293248442505169, -1.02870605123693907e-06, 3.78699451175634749e-06, -4.14661454981517284e-08, 2.90208625768643512e-09*1./(1_MeV), 0, 3.81786496695030795e-07, 0.000220617921810967285, -4.14661454981517284e-08, 2.34398885368136689e-06, -4.89427060442843687e-12*1./(1_MeV), 0, -6.22341861031614923e-08*1./(1_MeV), 1.23912522027359707e-09*1./(1_MeV), 2.90208625768643512e-09*1./(1_MeV), -4.89427060442843687e-12*1./(1_MeV), 7.00765001582226432e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform41;
- ActsSymMatrixD<3> rotMat41;
- rotMat41 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform41.rotate(rotMat41);
- transform41.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans41 = std::make_shared<const Transform3D>(transform41);
- std::shared_ptr<PerigeeSurface> perigeeSurface41 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams41 = BoundParameters(tgContext, std::move(covMat41), params41, perigeeSurface41);
- tracks.push_back(boundParams41);
-
-
- // track 42 :
- BoundVector params42;
- params42 << 0.205963864922523499, 19.6864852905273438, 0.214674949645996094, 1.62375175952911377, 0.00149375631008297205*1./(1_MeV), 0;
- Covariance covMat42;
- covMat42 << 0.00880367588251829147, -1.80866668959131395e-05, -0.000256995153030317573, -5.65481784766486379e-07, -1.21863871949890772e-07*1./(1_MeV), 0, -1.80866668959131395e-05, 0.0290389824658632278, 1.0786176979882171e-06, 0.000633662510089911938, 1.54534038892845022e-09*1./(1_MeV), 0, -0.000256995153030317573, 1.0786176979882171e-06, 7.61563569540157914e-06, 3.04492679504856067e-08, 5.93032819545449155e-09*1./(1_MeV), 0, -5.65481784766486379e-07, 0.000633662510089911938, 3.04492679504856067e-08, 1.61353309522382915e-05, 6.0506063998423997e-11*1./(1_MeV), 0, -1.21863871949890772e-07*1./(1_MeV), 1.54534038892845022e-09*1./(1_MeV), 5.93032819545449155e-09*1./(1_MeV), 6.0506063998423997e-11*1./(1_MeV), 2.29128466200378966e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform42;
- ActsSymMatrixD<3> rotMat42;
- rotMat42 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform42.rotate(rotMat42);
- transform42.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans42 = std::make_shared<const Transform3D>(transform42);
- std::shared_ptr<PerigeeSurface> perigeeSurface42 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams42 = BoundParameters(tgContext, std::move(covMat42), params42, perigeeSurface42);
- tracks.push_back(boundParams42);
-
-
- // track 43 :
- BoundVector params43;
- params43 << 0.147156372666358948, 18.0601425170898438, -1.20425975322723389, 2.95313668251037598, 4.38562346971593797e-05*1./(1_MeV), 0;
- Covariance covMat43;
- covMat43 << 0.00227970955893397331, 0.00210539922327512233, -6.23386652157084843e-05, 1.62139833390343564e-06, -2.4710662537678873e-08*1./(1_MeV), 0, 0.00210539922327512233, 0.0987421199679374695, -4.43239956360880696e-05, 8.53623578378920762e-05, -2.894438650939545e-09*1./(1_MeV), 0, -6.23386652157084843e-05, -4.43239956360880696e-05, 1.78687150764744729e-06, -3.5153983375057298e-08, 1.14365278859331536e-09*1./(1_MeV), 0, 1.62139833390343564e-06, 8.53623578378920762e-05, -3.5153983375057298e-08, 7.69686039348016493e-08, -2.40912278559178251e-12*1./(1_MeV), 0, -2.4710662537678873e-08*1./(1_MeV), -2.894438650939545e-09*1./(1_MeV), 1.14365278859331536e-09*1./(1_MeV), -2.40912278559178251e-12*1./(1_MeV), 8.10338168094615341e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform43;
- ActsSymMatrixD<3> rotMat43;
- rotMat43 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform43.rotate(rotMat43);
- transform43.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans43 = std::make_shared<const Transform3D>(transform43);
- std::shared_ptr<PerigeeSurface> perigeeSurface43 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams43 = BoundParameters(tgContext, std::move(covMat43), params43, perigeeSurface43);
- tracks.push_back(boundParams43);
-
-
- // track 44 :
- BoundVector params44;
- params44 << -0.0293732546269893646, 19.8860263824462891, 1.95824682712554932, 0.870327293872833252, 0.000651221722364425659*1./(1_MeV), 0;
- Covariance covMat44;
- covMat44 << 0.00386394886299967766, 6.41084427899122564e-05, -0.000111475937760659882, 1.88781955782771875e-06, -8.13503642219718733e-08*1./(1_MeV), 0, 6.41084427899122564e-05, 0.0216643344610929489, -4.27457576030063133e-06, 0.000299667220913072709, 1.00583188544233463e-10*1./(1_MeV), 0, -0.000111475937760659882, -4.27457576030063133e-06, 3.30510965795838274e-06, -9.27711560515876557e-08, 4.0446540731261482e-09*1./(1_MeV), 0, 1.88781955782771875e-06, 0.000299667220913072709, -9.27711560515876557e-08, 4.72439432996907271e-06, -4.51255450632084092e-11*1./(1_MeV), 0, -8.13503642219718733e-08*1./(1_MeV), 1.00583188544233463e-10*1./(1_MeV), 4.0446540731261482e-09*1./(1_MeV), -4.51255450632084092e-11*1./(1_MeV), 1.23205209923149539e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform44;
- ActsSymMatrixD<3> rotMat44;
- rotMat44 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform44.rotate(rotMat44);
- transform44.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans44 = std::make_shared<const Transform3D>(transform44);
- std::shared_ptr<PerigeeSurface> perigeeSurface44 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams44 = BoundParameters(tgContext, std::move(covMat44), params44, perigeeSurface44);
- tracks.push_back(boundParams44);
-
-
- // track 45 :
- BoundVector params45;
- params45 << -0.00822580046951770782, 19.7521209716796875, -1.34217584133148193, 1.31352841854095459, -0.00102247926406562328*1./(1_MeV), 0;
- Covariance covMat45;
- covMat45 << 0.00437659770250320435, -7.97783766085815948e-05, -0.00012776433189490825, -9.58273275448513196e-07, -5.94526727131795577e-08*1./(1_MeV), 0, -7.97783766085815948e-05, 0.0161803290247917175, 2.97524849199130738e-06, 0.000292265113374019965, 2.18355646012064316e-10*1./(1_MeV), 0, -0.00012776433189490825, 2.97524849199130738e-06, 3.82176176572102122e-06, 4.43621833298063989e-08, 2.82001283990720967e-09*1./(1_MeV), 0, -9.58273275448513196e-07, 0.000292265113374019965, 4.43621833298063989e-08, 6.61718468109029345e-06, 2.39856062071632866e-11*1./(1_MeV), 0, -5.94526727131795577e-08*1./(1_MeV), 2.18355646012064316e-10*1./(1_MeV), 2.82001283990720967e-09*1./(1_MeV), 2.39856062071632866e-11*1./(1_MeV), 1.06083510031940165e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform45;
- ActsSymMatrixD<3> rotMat45;
- rotMat45 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform45.rotate(rotMat45);
- transform45.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans45 = std::make_shared<const Transform3D>(transform45);
- std::shared_ptr<PerigeeSurface> perigeeSurface45 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams45 = BoundParameters(tgContext, std::move(covMat45), params45, perigeeSurface45);
- tracks.push_back(boundParams45);
-
-
- // track 46 :
- BoundVector params46;
- params46 << -0.00361508713103830814, 19.4546413421630859, -1.30042552947998047, 1.05093002319335938, -0.00133425544481724501*1./(1_MeV), 0;
- Covariance covMat46;
- covMat46 << 0.00941458996385335922, -0.000284834152470895207, -0.000280442622898071389, -5.80468009022971626e-06, -1.41275786371003149e-07*1./(1_MeV), 0, -0.000284834152470895207, 0.0502648279070854187, 1.53948871197303823e-05, 0.000823507242403401945, -2.66165681844982257e-09*1./(1_MeV), 0, -0.000280442622898071389, 1.53948871197303823e-05, 8.5132569438428618e-06, 2.95341827559094638e-07, 6.98672628255231531e-09*1./(1_MeV), 0, -5.80468009022971626e-06, 0.000823507242403401945, 2.95341827559094638e-07, 1.44839359563775361e-05, -4.21371554939487073e-11*1./(1_MeV), 0, -1.41275786371003149e-07*1./(1_MeV), -2.66165681844982257e-09*1./(1_MeV), 6.98672628255231531e-09*1./(1_MeV), -4.21371554939487073e-11*1./(1_MeV), 2.45891834671496667e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform46;
- ActsSymMatrixD<3> rotMat46;
- rotMat46 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform46.rotate(rotMat46);
- transform46.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans46 = std::make_shared<const Transform3D>(transform46);
- std::shared_ptr<PerigeeSurface> perigeeSurface46 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams46 = BoundParameters(tgContext, std::move(covMat46), params46, perigeeSurface46);
- tracks.push_back(boundParams46);
-
-
- // track 47 :
- BoundVector params47;
- params47 << -0.0598590485751628876, 19.6531963348388672, 2.72643232345581055, 1.30785942077636719, -0.000780149712227284908*1./(1_MeV), 0;
- Covariance covMat47;
- covMat47 << 0.0032495234627276659, -4.04264250143772372e-05, -9.30744349600882211e-05, -5.0226893263358181e-07, -1.01375149269318418e-07*1./(1_MeV), 0, -4.04264250143772372e-05, 0.0112805059179663658, 1.30282082485754631e-06, 0.000209029656597159029, -7.2365790516280225e-09*1./(1_MeV), 0, -9.30744349600882211e-05, 1.30282082485754631e-06, 2.75341517408378422e-06, 2.1800386214469216e-08, 4.40769477853404022e-09*1./(1_MeV), 0, -5.0226893263358181e-07, 0.000209029656597159029, 2.1800386214469216e-08, 4.8472306843905244e-06, -9.06260666641051782e-11*1./(1_MeV), 0, -1.01375149269318418e-07*1./(1_MeV), -7.2365790516280225e-09*1./(1_MeV), 4.40769477853404022e-09*1./(1_MeV), -9.06260666641051782e-11*1./(1_MeV), 1.457364923185267e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform47;
- ActsSymMatrixD<3> rotMat47;
- rotMat47 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform47.rotate(rotMat47);
- transform47.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans47 = std::make_shared<const Transform3D>(transform47);
- std::shared_ptr<PerigeeSurface> perigeeSurface47 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams47 = BoundParameters(tgContext, std::move(covMat47), params47, perigeeSurface47);
- tracks.push_back(boundParams47);
-
-
- // track 48 :
- BoundVector params48;
- params48 << 0.0583043769001960754, 19.7832298278808594, -3.05185866355895996, 2.35133123397827148, 0.000652144546620547771*1./(1_MeV), 0;
- Covariance covMat48;
- covMat48 << 0.00455570640042424202, 2.27770645100975327e-05, -0.000134378354520968727, -9.98581163169078598e-07, -9.40610633214604794e-08*1./(1_MeV), 0, 2.27770645100975327e-05, 0.0258676018565893173, 3.21967957682574985e-06, 0.000300520679336246791, -1.35927009544720559e-09*1./(1_MeV), 0, -0.000134378354520968727, 3.21967957682574985e-06, 4.06873823521891609e-06, 7.29906365483080491e-08, 4.4846939744143286e-09*1./(1_MeV), 0, -9.98581163169078598e-07, 0.000300520679336246791, 7.29906365483080491e-08, 3.90696686736191623e-06, 4.80210416302676692e-12*1./(1_MeV), 0, -9.40610633214604794e-08*1./(1_MeV), -1.35927009544720559e-09*1./(1_MeV), 4.4846939744143286e-09*1./(1_MeV), 4.80210416302676692e-12*1./(1_MeV), 1.25072396883751935e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform48;
- ActsSymMatrixD<3> rotMat48;
- rotMat48 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform48.rotate(rotMat48);
- transform48.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans48 = std::make_shared<const Transform3D>(transform48);
- std::shared_ptr<PerigeeSurface> perigeeSurface48 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams48 = BoundParameters(tgContext, std::move(covMat48), params48, perigeeSurface48);
- tracks.push_back(boundParams48);
-
-
- // track 49 :
- BoundVector params49;
- params49 << 0.0794872790575027466, 19.6530551910400391, -0.165329158306121826, 0.773633182048797607, 0.000477823166875168681*1./(1_MeV), 0;
- Covariance covMat49;
- covMat49 << 0.00381630496121942997, -8.74287441500089918e-05, -0.000100106500619540973, -8.38715409757558135e-08, -6.2290859493643327e-08*1./(1_MeV), 0, -8.74287441500089918e-05, 0.0162235908210277557, 2.22223959083791618e-08, 0.000172105791708528197, 1.96493926730074329e-10*1./(1_MeV), 0, -0.000100106500619540973, 2.22223959083791618e-08, 2.75529328064294532e-06, -2.06184740167500454e-08, 2.69172215410859302e-09*1./(1_MeV), 0, -8.38715409757558135e-08, 0.000172105791708528197, -2.06184740167500454e-08, 2.09498148251441307e-06, 8.40879734889098381e-12*1./(1_MeV), 0, -6.2290859493643327e-08*1./(1_MeV), 1.96493926730074329e-10*1./(1_MeV), 2.69172215410859302e-09*1./(1_MeV), 8.40879734889098381e-12*1./(1_MeV), 6.77461420295344396e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform49;
- ActsSymMatrixD<3> rotMat49;
- rotMat49 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform49.rotate(rotMat49);
- transform49.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans49 = std::make_shared<const Transform3D>(transform49);
- std::shared_ptr<PerigeeSurface> perigeeSurface49 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams49 = BoundParameters(tgContext, std::move(covMat49), params49, perigeeSurface49);
- tracks.push_back(boundParams49);
-
-
- // track 50 :
- BoundVector params50;
- params50 << 0.00257234717719256878, 19.729034423828125, -2.48443388938903809, 2.36831569671630859, 0.000639270059764385223*1./(1_MeV), 0;
- Covariance covMat50;
- covMat50 << 0.00514977378770709038, 1.5274217220811411e-06, -0.000146212466763405544, -7.3820246046654258e-07, -9.37751309006686478e-08*1./(1_MeV), 0, 1.5274217220811411e-06, 0.0244287420064210892, 3.30349992626133354e-06, 0.000276546223727476613, -7.14985035003895647e-10*1./(1_MeV), 0, -0.000146212466763405544, 3.30349992626133354e-06, 4.3204604480706621e-06, 5.8973252791929605e-08, 4.5218636718828268e-09*1./(1_MeV), 0, -7.3820246046654258e-07, 0.000276546223727476613, 5.8973252791929605e-08, 3.42068551617558114e-06, -2.22231801612401744e-12*1./(1_MeV), 0, -9.37751309006686478e-08*1./(1_MeV), -7.14985035003895647e-10*1./(1_MeV), 4.5218636718828268e-09*1./(1_MeV), -2.22231801612401744e-12*1./(1_MeV), 1.24709936821787437e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform50;
- ActsSymMatrixD<3> rotMat50;
- rotMat50 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform50.rotate(rotMat50);
- transform50.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans50 = std::make_shared<const Transform3D>(transform50);
- std::shared_ptr<PerigeeSurface> perigeeSurface50 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams50 = BoundParameters(tgContext, std::move(covMat50), params50, perigeeSurface50);
- tracks.push_back(boundParams50);
-
-
- // track 51 :
- BoundVector params51;
- params51 << 0.00432245805859565735, 19.7588119506835938, 2.78170585632324219, 1.317923903465271, 0.000862165645230561495*1./(1_MeV), 0;
- Covariance covMat51;
- covMat51 << 0.00373272784054279327, -3.13153124378761361e-05, -0.000104918640992595442, 7.88207645809147621e-08, -5.3073184749102294e-08*1./(1_MeV), 0, -3.13153124378761361e-05, 0.014620266854763031, 4.37770160231162941e-09, 0.000248047817836983295, -1.07342837668986752e-09*1./(1_MeV), 0, -0.000104918640992595442, 4.37770160231162941e-09, 3.04561854136409238e-06, -1.80148965656686955e-08, 2.31705476916370874e-09*1./(1_MeV), 0, 7.88207645809147621e-08, 0.000248047817836983295, -1.80148965656686955e-08, 5.14808971274760552e-06, -2.17782802728119955e-11*1./(1_MeV), 0, -5.3073184749102294e-08*1./(1_MeV), -1.07342837668986752e-09*1./(1_MeV), 2.31705476916370874e-09*1./(1_MeV), -2.17782802728119955e-11*1./(1_MeV), 7.92517093617384205e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform51;
- ActsSymMatrixD<3> rotMat51;
- rotMat51 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform51.rotate(rotMat51);
- transform51.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans51 = std::make_shared<const Transform3D>(transform51);
- std::shared_ptr<PerigeeSurface> perigeeSurface51 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams51 = BoundParameters(tgContext, std::move(covMat51), params51, perigeeSurface51);
- tracks.push_back(boundParams51);
-
-
- // track 52 :
- BoundVector params52;
- params52 << -0.0435933880507946014, 19.7911624908447266, 3.11164975166320801, 2.34090805053710938, -0.000378097058273851871*1./(1_MeV), 0;
- Covariance covMat52;
- covMat52 << 0.00186390290036797523, 8.51901326696253696e-05, -5.26206213063089263e-05, 7.5721243893402984e-07, -3.6471728778736459e-08*1./(1_MeV), 0, 8.51901326696253696e-05, 0.0111065087839961052, -2.43677190069158359e-06, 0.00011281071944759972, -1.62019250256225185e-09*1./(1_MeV), 0, -5.26206213063089263e-05, -2.43677190069158359e-06, 1.54202029989392031e-06, -2.53458777355814022e-08, 1.63474855631190684e-09*1./(1_MeV), 0, 7.5721243893402984e-07, 0.00011281071944759972, -2.53458777355814022e-08, 1.39124506404186832e-06, -1.08965746715162531e-11*1./(1_MeV), 0, -3.6471728778736459e-08*1./(1_MeV), -1.62019250256225185e-09*1./(1_MeV), 1.63474855631190684e-09*1./(1_MeV), -1.08965746715162531e-11*1./(1_MeV), 4.23658642889623849e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform52;
- ActsSymMatrixD<3> rotMat52;
- rotMat52 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform52.rotate(rotMat52);
- transform52.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans52 = std::make_shared<const Transform3D>(transform52);
- std::shared_ptr<PerigeeSurface> perigeeSurface52 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams52 = BoundParameters(tgContext, std::move(covMat52), params52, perigeeSurface52);
- tracks.push_back(boundParams52);
-
-
- // track 53 :
- BoundVector params53;
- params53 << -0.0815948843955993652, 19.7372093200683594, -1.84946024417877197, 1.14923441410064697, 0.000601470586843788624*1./(1_MeV), 0;
- Covariance covMat53;
- covMat53 << 0.00196050899103283882, -1.67352628138899218e-05, -5.56634758072358207e-05, 3.7875159202534098e-07, -3.03494187297867561e-08*1./(1_MeV), 0, -1.67352628138899218e-05, 0.0112847397103905678, -1.93632011387631403e-07, 0.000171461400770045192, -2.16268131821945559e-09*1./(1_MeV), 0, -5.56634758072358207e-05, -1.93632011387631403e-07, 1.63677134423778625e-06, -2.31373868535455102e-08, 1.4041644457469446e-09*1./(1_MeV), 0, 3.7875159202534098e-07, 0.000171461400770045192, -2.31373868535455102e-08, 3.31649607687722892e-06, -5.16496243030849994e-11*1./(1_MeV), 0, -3.03494187297867561e-08*1./(1_MeV), -2.16268131821945559e-09*1./(1_MeV), 1.4041644457469446e-09*1./(1_MeV), -5.16496243030849994e-11*1./(1_MeV), 4.88036555612580969e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform53;
- ActsSymMatrixD<3> rotMat53;
- rotMat53 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform53.rotate(rotMat53);
- transform53.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans53 = std::make_shared<const Transform3D>(transform53);
- std::shared_ptr<PerigeeSurface> perigeeSurface53 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams53 = BoundParameters(tgContext, std::move(covMat53), params53, perigeeSurface53);
- tracks.push_back(boundParams53);
-
-
- // track 54 :
- BoundVector params54;
- params54 << -0.177310273051261902, 19.6348361968994141, -1.05560946464538574, 2.24611258506774902, -0.000753726519178599119*1./(1_MeV), 0;
- Covariance covMat54;
- covMat54 << 0.00495443679392337799, 0.000157203730621089283, -0.000141684325914573155, 2.30922207144066844e-06, -7.94592181976909059e-08*1./(1_MeV), 0, 0.000157203730621089283, 0.0229040328413248062, -6.34654599119513331e-06, 0.000306214725126755156, -1.2839975429398817e-09*1./(1_MeV), 0, -0.000141684325914573155, -6.34654599119513331e-06, 4.18058425566414371e-06, -9.91975383724877058e-08, 3.78214495931995838e-09*1./(1_MeV), 0, 2.30922207144066844e-06, 0.000306214725126755156, -9.91975383724877058e-08, 4.69660699309315532e-06, -2.63341946589812984e-11*1./(1_MeV), 0, -7.94592181976909059e-08*1./(1_MeV), -1.2839975429398817e-09*1./(1_MeV), 3.78214495931995838e-09*1./(1_MeV), -2.63341946589812984e-11*1./(1_MeV), 1.1374100272742993e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform54;
- ActsSymMatrixD<3> rotMat54;
- rotMat54 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform54.rotate(rotMat54);
- transform54.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans54 = std::make_shared<const Transform3D>(transform54);
- std::shared_ptr<PerigeeSurface> perigeeSurface54 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams54 = BoundParameters(tgContext, std::move(covMat54), params54, perigeeSurface54);
- tracks.push_back(boundParams54);
-
-
- // track 55 :
- BoundVector params55;
- params55 << 0.0785293355584144592, 19.6328811645507812, 2.59513092041015625, 2.38374710083007812, -0.000732663145754486322*1./(1_MeV), 0;
- Covariance covMat55;
- covMat55 << 0.00641396967694163322, 0.000246878889801438277, -0.000189181604721914515, 3.34410570581822042e-06, -2.14548746767764377e-07*1./(1_MeV), 0, 0.000246878889801438277, 0.0336174145340919495, -1.03550476761815197e-05, 0.000399278313453293142, -2.56304746534435936e-09*1./(1_MeV), 0, -0.000189181604721914515, -1.03550476761815197e-05, 5.75400417801574804e-06, -1.44846765580733777e-07, 1.06792194541960512e-08*1./(1_MeV), 0, 3.34410570581822042e-06, 0.000399278313453293142, -1.44846765580733777e-07, 5.08104403706965968e-06, -7.68042699731362161e-11*1./(1_MeV), 0, -2.14548746767764377e-07*1./(1_MeV), -2.56304746534435936e-09*1./(1_MeV), 1.06792194541960512e-08*1./(1_MeV), -7.68042699731362161e-11*1./(1_MeV), 2.95886121159938398e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform55;
- ActsSymMatrixD<3> rotMat55;
- rotMat55 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform55.rotate(rotMat55);
- transform55.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans55 = std::make_shared<const Transform3D>(transform55);
- std::shared_ptr<PerigeeSurface> perigeeSurface55 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams55 = BoundParameters(tgContext, std::move(covMat55), params55, perigeeSurface55);
- tracks.push_back(boundParams55);
-
-
- // track 56 :
- BoundVector params56;
- params56 << 0.0173604916781187057, 19.5246124267578125, -2.51582574844360352, 0.414047539234161377, -0.00071090972051024437*1./(1_MeV), 0;
- Covariance covMat56;
- covMat56 << 0.0283498577773571014, -0.000298887250477381634, -0.000882125049864636171, -6.77869111648309038e-06, -5.9098209889401522e-07*1./(1_MeV), 0, -0.000298887250477381634, 0.192199692130088806, 4.3839556454493579e-05, 0.000923672206091380129, -1.8091079261186684e-08*1./(1_MeV), 0, -0.000882125049864636171, 4.3839556454493579e-05, 2.79919677268480882e-05, 3.80641892247414598e-07, 3.08266368106537475e-08*1./(1_MeV), 0, -6.77869111648309038e-06, 0.000923672206091380129, 3.80641892247414598e-07, 4.52563699582242407e-06, 3.57023520457822254e-12*1./(1_MeV), 0, -5.9098209889401522e-07*1./(1_MeV), -1.8091079261186684e-08*1./(1_MeV), 3.08266368106537475e-08*1./(1_MeV), 3.57023520457822254e-12*1./(1_MeV), 5.16008458184558094e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform56;
- ActsSymMatrixD<3> rotMat56;
- rotMat56 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform56.rotate(rotMat56);
- transform56.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans56 = std::make_shared<const Transform3D>(transform56);
- std::shared_ptr<PerigeeSurface> perigeeSurface56 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams56 = BoundParameters(tgContext, std::move(covMat56), params56, perigeeSurface56);
- tracks.push_back(boundParams56);
-
-
- // track 57 :
- BoundVector params57;
- params57 << -0.112078636884689331, 19.7138767242431641, -1.84679484367370605, 0.794435799121856689, -0.00114586413837969303*1./(1_MeV), 0;
- Covariance covMat57;
- covMat57 << 0.0125628607347607613, -0.00042401806910040711, -0.000382159145328276348, -7.02945588660621349e-06, -2.92791162690266574e-07*1./(1_MeV), 0, -0.00042401806910040711, 0.0519770048558712006, 2.22396418071489764e-05, 0.000696764565518564701, 2.67979975211747671e-10*1./(1_MeV), 0, -0.000382159145328276348, 2.22396418071489764e-05, 1.18492389447055757e-05, 3.53736964679786492e-07, 1.47490199626806416e-08*1./(1_MeV), 0, -7.02945588660621349e-06, 0.000696764565518564701, 3.53736964679786492e-07, 9.91684009932214394e-06, 3.12549388487418662e-11*1./(1_MeV), 0, -2.92791162690266574e-07*1./(1_MeV), 2.67979975211747671e-10*1./(1_MeV), 1.47490199626806416e-08*1./(1_MeV), 3.12549388487418662e-11*1./(1_MeV), 4.27830326721334586e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform57;
- ActsSymMatrixD<3> rotMat57;
- rotMat57 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform57.rotate(rotMat57);
- transform57.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans57 = std::make_shared<const Transform3D>(transform57);
- std::shared_ptr<PerigeeSurface> perigeeSurface57 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams57 = BoundParameters(tgContext, std::move(covMat57), params57, perigeeSurface57);
- tracks.push_back(boundParams57);
-
-
- // track 58 :
- BoundVector params58;
- params58 << -0.0965623259544372559, 19.6627426147460938, -1.23312962055206299, 0.805159807205200195, -0.000906686065718531609*1./(1_MeV), 0;
- Covariance covMat58;
- covMat58 << 0.00830374658107757568, -0.000373302939962240744, -0.000247266029281000856, -5.00495608162803572e-06, -2.0945470573896415e-07*1./(1_MeV), 0, -0.000373302939962240744, 0.0380906462669372559, 1.53532999294112871e-05, 0.000496518269343126733, 5.03471984032882939e-09*1./(1_MeV), 0, -0.000247266029281000856, 1.53532999294112871e-05, 7.52212054067058489e-06, 2.17835177699819493e-07, 9.95587606736010666e-09*1./(1_MeV), 0, -5.00495608162803572e-06, 0.000496518269343126733, 2.17835177699819493e-07, 6.91647301209741272e-06, 8.81431839589435575e-11*1./(1_MeV), 0, -2.0945470573896415e-07*1./(1_MeV), 5.03471984032882939e-09*1./(1_MeV), 9.95587606736010666e-09*1./(1_MeV), 8.81431839589435575e-11*1./(1_MeV), 2.77544126570106187e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform58;
- ActsSymMatrixD<3> rotMat58;
- rotMat58 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform58.rotate(rotMat58);
- transform58.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans58 = std::make_shared<const Transform3D>(transform58);
- std::shared_ptr<PerigeeSurface> perigeeSurface58 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams58 = BoundParameters(tgContext, std::move(covMat58), params58, perigeeSurface58);
- tracks.push_back(boundParams58);
-
-
- // track 59 :
- BoundVector params59;
- params59 << -0.0626908987760543823, 19.7716445922851562, -2.40555191040039062, 2.8678133487701416, -0.000198848822037689388*1./(1_MeV), 0;
- Covariance covMat59;
- covMat59 << 0.00839335378259420395, 0.000910603415829014081, -0.00025100860818204118, 1.87096007159414942e-06, -9.31870020461924718e-08*1./(1_MeV), 0, 0.000910603415829014081, 0.129513055086135864, -2.86761617086296627e-05, 0.000273189216280241291, -4.74956078553265506e-09*1./(1_MeV), 0, -0.00025100860818204118, -2.86761617086296627e-05, 7.71244413044769317e-06, -6.31332272284558137e-08, 4.62778036643537694e-09*1./(1_MeV), 0, 1.87096007159414942e-06, 0.000273189216280241291, -6.31332272284558137e-08, 5.91468733546207659e-07, -9.64516546051573345e-12*1./(1_MeV), 0, -9.31870020461924718e-08*1./(1_MeV), -4.74956078553265506e-09*1./(1_MeV), 4.62778036643537694e-09*1./(1_MeV), -9.64516546051573345e-12*1./(1_MeV), 5.01616283232753091e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform59;
- ActsSymMatrixD<3> rotMat59;
- rotMat59 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform59.rotate(rotMat59);
- transform59.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans59 = std::make_shared<const Transform3D>(transform59);
- std::shared_ptr<PerigeeSurface> perigeeSurface59 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams59 = BoundParameters(tgContext, std::move(covMat59), params59, perigeeSurface59);
- tracks.push_back(boundParams59);
-
-
- // track 60 :
- BoundVector params60;
- params60 << -0.0142064439132809639, 19.7910060882568359, 0.168578088283538818, 0.479709357023239136, -0.000404727092245593667*1./(1_MeV), 0;
- Covariance covMat60;
- covMat60 << 0.00775946257635951042, -0.000358691551729211646, -0.000217197427685534829, -2.56510932869304508e-06, -7.90923951223065759e-08*1./(1_MeV), 0, -0.000358691551729211646, 0.052836686372756958, 1.3965907239243096e-05, 0.000293662591417361029, 3.13017533889238816e-10*1./(1_MeV), 0, -0.000217197427685534829, 1.3965907239243096e-05, 6.26508744971943088e-06, 9.72321745154080499e-08, 3.84228193539540777e-09*1./(1_MeV), 0, -2.56510932869304508e-06, 0.000293662591417361029, 9.72321745154080499e-08, 1.70067016824759776e-06, 6.77559228363657895e-12*1./(1_MeV), 0, -7.90923951223065759e-08*1./(1_MeV), 3.13017533889238816e-10*1./(1_MeV), 3.84228193539540777e-09*1./(1_MeV), 6.77559228363657895e-12*1./(1_MeV), 6.94686808078159856e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform60;
- ActsSymMatrixD<3> rotMat60;
- rotMat60 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform60.rotate(rotMat60);
- transform60.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans60 = std::make_shared<const Transform3D>(transform60);
- std::shared_ptr<PerigeeSurface> perigeeSurface60 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams60 = BoundParameters(tgContext, std::move(covMat60), params60, perigeeSurface60);
- tracks.push_back(boundParams60);
-
-
- // track 61 :
- BoundVector params61;
- params61 << -0.219206094741821289, 20.4783496856689453, -0.292800366878509521, 2.68957734107971191, -0.000572857388760894537*1./(1_MeV), 0;
- Covariance covMat61;
- covMat61 << 0.0146720772609114647, 0.000633603948713714737, -0.000435564556254993611, 4.1380172183317663e-06, -1.65861978224238241e-07*1./(1_MeV), 0, 0.000633603948713714737, 0.0937191098928451538, -3.01445904596889702e-05, 0.000503828587046026917, 9.92026904049769552e-10*1./(1_MeV), 0, -0.000435564556254993611, -3.01445904596889702e-05, 1.31324359244899824e-05, -1.88451279319618993e-07, 8.03478199107072473e-09*1./(1_MeV), 0, 4.1380172183317663e-06, 0.000503828587046026917, -1.88451279319618993e-07, 2.77083131550170947e-06, 3.79284582712100777e-12*1./(1_MeV), 0, -1.65861978224238241e-07*1./(1_MeV), 9.92026904049769552e-10*1./(1_MeV), 8.03478199107072473e-09*1./(1_MeV), 3.79284582712100777e-12*1./(1_MeV), 1.37340042116740335e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform61;
- ActsSymMatrixD<3> rotMat61;
- rotMat61 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform61.rotate(rotMat61);
- transform61.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans61 = std::make_shared<const Transform3D>(transform61);
- std::shared_ptr<PerigeeSurface> perigeeSurface61 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams61 = BoundParameters(tgContext, std::move(covMat61), params61, perigeeSurface61);
- tracks.push_back(boundParams61);
-
-
- // track 62 :
- BoundVector params62;
- params62 << 0.0636809840798377991, 19.6062507629394531, 0.571447312831878662, 0.867952585220336914, 0.00121437374036759138*1./(1_MeV), 0;
- Covariance covMat62;
- covMat62 << 0.0128781227394938469, 0.000273969979431750051, -0.000375215863743342181, 8.19368995942778944e-06, -3.39195297106111847e-07*1./(1_MeV), 0, 0.000273969979431750051, 0.0600576512515544891, -2.2149498630265022e-05, 0.000888745641943021122, -2.03770348687604627e-09*1./(1_MeV), 0, -0.000375215863743342181, -2.2149498630265022e-05, 1.11544741230318323e-05, -4.44362300871132803e-07, 1.59093394709295358e-08*1./(1_MeV), 0, 8.19368995942778944e-06, 0.000888745641943021122, -4.44362300871132803e-07, 1.38034411065746099e-05, -1.03151432469073304e-10*1./(1_MeV), 0, -3.39195297106111847e-07*1./(1_MeV), -2.03770348687604627e-09*1./(1_MeV), 1.59093394709295358e-08*1./(1_MeV), -1.03151432469073304e-10*1./(1_MeV), 4.62565652448176934e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform62;
- ActsSymMatrixD<3> rotMat62;
- rotMat62 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform62.rotate(rotMat62);
- transform62.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans62 = std::make_shared<const Transform3D>(transform62);
- std::shared_ptr<PerigeeSurface> perigeeSurface62 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams62 = BoundParameters(tgContext, std::move(covMat62), params62, perigeeSurface62);
- tracks.push_back(boundParams62);
-
-
- // track 63 :
- BoundVector params63;
- params63 << 0.256703495979309082, 20.4742660522460938, 2.0388495922088623, 0.835670650005340576, -0.00106730952393263578*1./(1_MeV), 0;
- Covariance covMat63;
- covMat63 << 0.00996344629675149918, -0.000111380282247894335, -0.000297672988748523071, -4.10640820399169642e-06, -2.92419518098666387e-07*1./(1_MeV), 0, -0.000111380282247894335, 0.0370076149702072144, 9.57343920283051857e-06, 0.000522519448946792003, -7.68861322556322209e-09*1./(1_MeV), 0, -0.000297672988748523071, 9.57343920283051857e-06, 9.07736284716520458e-06, 2.19650252980074214e-07, 1.46923783244468664e-08*1./(1_MeV), 0, -4.10640820399169642e-06, 0.000522519448946792003, 2.19650252980074214e-07, 7.87897715781582519e-06, -2.63692280030132723e-11*1./(1_MeV), 0, -2.92419518098666387e-07*1./(1_MeV), -7.68861322556322209e-09*1./(1_MeV), 1.46923783244468664e-08*1./(1_MeV), -2.63692280030132723e-11*1./(1_MeV), 4.39882824609938439e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform63;
- ActsSymMatrixD<3> rotMat63;
- rotMat63 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform63.rotate(rotMat63);
- transform63.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans63 = std::make_shared<const Transform3D>(transform63);
- std::shared_ptr<PerigeeSurface> perigeeSurface63 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams63 = BoundParameters(tgContext, std::move(covMat63), params63, perigeeSurface63);
- tracks.push_back(boundParams63);
-
-
- // track 64 :
- BoundVector params64;
- params64 << 0.120990529656410217, 19.6643028259277344, 2.09903669357299805, 0.376666009426116943, 0.000600203988142311573*1./(1_MeV), 0;
- Covariance covMat64;
- covMat64 << 0.0291396286338567734, 5.39021723134598197e-05, -0.000882721168274605778, 4.14864371809709873e-06, -5.5001142494950611e-07*1./(1_MeV), 0, 5.39021723134598197e-05, 0.234371468424797058, -4.16871244043210621e-05, 0.000918528875032399673, 1.39816410013920925e-08*1./(1_MeV), 0, -0.000882721168274605778, -4.16871244043210621e-05, 2.72563647740753368e-05, -2.79753257845384789e-07, 2.7634673800087543e-08*1./(1_MeV), 0, 4.14864371809709873e-06, 0.000918528875032399673, -2.79753257845384789e-07, 3.6635033211496193e-06, 1.58046165958546609e-11*1./(1_MeV), 0, -5.5001142494950611e-07*1./(1_MeV), 1.39816410013920925e-08*1./(1_MeV), 2.7634673800087543e-08*1./(1_MeV), 1.58046165958546609e-11*1./(1_MeV), 4.08823086495146981e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform64;
- ActsSymMatrixD<3> rotMat64;
- rotMat64 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform64.rotate(rotMat64);
- transform64.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans64 = std::make_shared<const Transform3D>(transform64);
- std::shared_ptr<PerigeeSurface> perigeeSurface64 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams64 = BoundParameters(tgContext, std::move(covMat64), params64, perigeeSurface64);
- tracks.push_back(boundParams64);
-
-
- // track 65 :
- BoundVector params65;
- params65 << 0.0062864348292350769, 19.6056728363037109, 1.96336662769317627, 1.67587447166442871, -0.00098716001957654953*1./(1_MeV), 0;
- Covariance covMat65;
- covMat65 << 0.00639463262632489204, 2.92739463404503888e-05, -0.000162262223266041843, 7.35056423966357298e-07, -6.22851560331579401e-08*1./(1_MeV), 0, 2.92739463404503888e-05, 0.0197239704430103302, -1.20671194756186941e-06, 0.000422495468900870442, -7.46651628897230336e-10*1./(1_MeV), 0, -0.000162262223266041843, -1.20671194756186941e-06, 4.31130820288672112e-06, -3.10329014828531918e-08, 2.84192773413970349e-09*1./(1_MeV), 0, 7.35056423966357298e-07, 0.000422495468900870442, -3.10329014828531918e-08, 1.06411953311180696e-05, -4.82012337741633492e-13*1./(1_MeV), 0, -6.22851560331579401e-08*1./(1_MeV), -7.46651628897230336e-10*1./(1_MeV), 2.84192773413970349e-09*1./(1_MeV), -4.82012337741633492e-13*1./(1_MeV), 1.05485536971983151e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform65;
- ActsSymMatrixD<3> rotMat65;
- rotMat65 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform65.rotate(rotMat65);
- transform65.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans65 = std::make_shared<const Transform3D>(transform65);
- std::shared_ptr<PerigeeSurface> perigeeSurface65 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams65 = BoundParameters(tgContext, std::move(covMat65), params65, perigeeSurface65);
- tracks.push_back(boundParams65);
-
-
- // track 66 :
- BoundVector params66;
- params66 << 0.0955945327877998352, 20.2347850799560547, -0.327246248722076416, 2.98204421997070312, 2.21292903006542474e-05*1./(1_MeV), 0;
- Covariance covMat66;
- covMat66 << 0.00150146521627902985, 0.0023395733708214345, -3.76246492337360715e-05, 1.20517570859588883e-06, -1.54414914830204655e-08*1./(1_MeV), 0, 0.0023395733708214345, 0.0877117365598678589, -4.71741381729428471e-05, 5.21609361100870518e-05, 3.25177228611905034e-10*1./(1_MeV), 0, -3.76246492337360715e-05, -4.71741381729428471e-05, 1.0044809641840402e-06, -2.48049212962453205e-08, 6.86903087291782125e-10*1./(1_MeV), 0, 1.20517570859588883e-06, 5.21609361100870518e-05, -2.48049212962453205e-08, 3.23552171721530613e-08, 2.29084759303353043e-13*1./(1_MeV), 0, -1.54414914830204655e-08*1./(1_MeV), 3.25177228611905034e-10*1./(1_MeV), 6.86903087291782125e-10*1./(1_MeV), 2.29084759303353043e-13*1./(1_MeV), 3.96015121736925657e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform66;
- ActsSymMatrixD<3> rotMat66;
- rotMat66 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform66.rotate(rotMat66);
- transform66.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans66 = std::make_shared<const Transform3D>(transform66);
- std::shared_ptr<PerigeeSurface> perigeeSurface66 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams66 = BoundParameters(tgContext, std::move(covMat66), params66, perigeeSurface66);
- tracks.push_back(boundParams66);
-
-
- // track 67 :
- BoundVector params67;
- params67 << 0.382039725780487061, 20.0302467346191406, 1.78882849216461182, 2.7296445369720459, 0.000560962012968957424*1./(1_MeV), 0;
- Covariance covMat67;
- covMat67 << 0.0185648687183856964, -0.000512420938441797555, -0.000564488122844988122, -3.46646347767409226e-06, -6.9752293121264101e-07*1./(1_MeV), 0, -0.000512420938441797555, 0.158824682235717773, 4.20228128232319107e-05, 0.000710107550351205766, 5.56717392340507163e-09*1./(1_MeV), 0, -0.000564488122844988122, 4.20228128232319107e-05, 1.76464527612552047e-05, 2.17145732577765049e-07, 3.41404923239805513e-08*1./(1_MeV), 0, -3.46646347767409226e-06, 0.000710107550351205766, 2.17145732577765049e-07, 3.26669078276609071e-06, -1.08290629522060115e-11*1./(1_MeV), 0, -6.9752293121264101e-07*1./(1_MeV), 5.56717392340507163e-09*1./(1_MeV), 3.41404923239805513e-08*1./(1_MeV), -1.08290629522060115e-11*1./(1_MeV), 5.43119271778635948e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform67;
- ActsSymMatrixD<3> rotMat67;
- rotMat67 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform67.rotate(rotMat67);
- transform67.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans67 = std::make_shared<const Transform3D>(transform67);
- std::shared_ptr<PerigeeSurface> perigeeSurface67 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams67 = BoundParameters(tgContext, std::move(covMat67), params67, perigeeSurface67);
- tracks.push_back(boundParams67);
-
-
- // track 68 :
- BoundVector params68;
- params68 << -0.179121747612953186, 20.2514362335205078, -0.862554371356964111, 2.68916535377502441, -0.000457327318144962192*1./(1_MeV), 0;
- Covariance covMat68;
- covMat68 << 0.0108809741213917732, 0.00193338631898851772, -0.000310007020929202329, 8.43655106315042699e-06, -1.10126677038094219e-07*1./(1_MeV), 0, 0.00193338631898851772, 0.0997641086578369141, -5.31462636732746974e-05, 0.000479126202409259187, -3.00325838913588194e-09*1./(1_MeV), 0, -0.000310007020929202329, -5.31462636732746974e-05, 9.10317794478032738e-06, -2.45896355006014845e-07, 5.3026650853642868e-09*1./(1_MeV), 0, 8.43655106315042699e-06, 0.000479126202409259187, -2.45896355006014845e-07, 2.40905660575663205e-06, -1.12621932829046352e-11*1./(1_MeV), 0, -1.10126677038094219e-07*1./(1_MeV), -3.00325838913588194e-09*1./(1_MeV), 5.3026650853642868e-09*1./(1_MeV), -1.12621932829046352e-11*1./(1_MeV), 9.04395031087190659e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform68;
- ActsSymMatrixD<3> rotMat68;
- rotMat68 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform68.rotate(rotMat68);
- transform68.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans68 = std::make_shared<const Transform3D>(transform68);
- std::shared_ptr<PerigeeSurface> perigeeSurface68 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams68 = BoundParameters(tgContext, std::move(covMat68), params68, perigeeSurface68);
- tracks.push_back(boundParams68);
-
-
- // track 69 :
- BoundVector params69;
- params69 << -0.138331592082977295, 19.3751182556152344, -1.35278940200805664, 0.381486982107162476, -0.000426069716922938824*1./(1_MeV), 0;
- Covariance covMat69;
- covMat69 << 0.0138281593099236488, -0.000802064074892135472, -0.000420553068714103143, -3.62152568304627602e-06, -1.71446784106220126e-07*1./(1_MeV), 0, -0.000802064074892135472, 0.124462626874446869, 3.35644323921618966e-05, 0.000489752797097319013, 1.53338361947342647e-09*1./(1_MeV), 0, -0.000420553068714103143, 3.35644323921618966e-05, 1.3009085705562029e-05, 1.52739817453807061e-07, 8.51389247727636405e-09*1./(1_MeV), 0, -3.62152568304627602e-06, 0.000489752797097319013, 1.52739817453807061e-07, 1.98223324332502671e-06, 7.74913828351229925e-12*1./(1_MeV), 0, -1.71446784106220126e-07*1./(1_MeV), 1.53338361947342647e-09*1./(1_MeV), 8.51389247727636405e-09*1./(1_MeV), 7.74913828351229925e-12*1./(1_MeV), 1.26564134173001719e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform69;
- ActsSymMatrixD<3> rotMat69;
- rotMat69 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform69.rotate(rotMat69);
- transform69.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans69 = std::make_shared<const Transform3D>(transform69);
- std::shared_ptr<PerigeeSurface> perigeeSurface69 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams69 = BoundParameters(tgContext, std::move(covMat69), params69, perigeeSurface69);
- tracks.push_back(boundParams69);
-
-
- // track 70 :
- BoundVector params70;
- params70 << -0.0937596634030342102, 19.4900455474853516, -0.352513551712036133, 2.89332342147827148, -0.000186513439984992146*1./(1_MeV), 0;
- Covariance covMat70;
- covMat70 << 0.0097403964027762413, 0.00166471584749119505, -0.000287947885317068881, 2.55751055140476181e-06, -7.81118139203814757e-08*1./(1_MeV), 0, 0.00166471584749119505, 0.204256042838096619, -4.79791071918836e-05, 0.000340033153539362216, -1.95895871236344388e-09*1./(1_MeV), 0, -0.000287947885317068881, -4.79791071918836e-05, 8.6775098679936491e-06, -7.89068829617864185e-08, 3.73986494276367498e-09*1./(1_MeV), 0, 2.55751055140476181e-06, 0.000340033153539362216, -7.89068829617864185e-08, 5.8173242223347188e-07, -3.34422452468073519e-12*1./(1_MeV), 0, -7.81118139203814757e-08*1./(1_MeV), -1.95895871236344388e-09*1./(1_MeV), 3.73986494276367498e-09*1./(1_MeV), -3.34422452468073519e-12*1./(1_MeV), 3.56935557499493683e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform70;
- ActsSymMatrixD<3> rotMat70;
- rotMat70 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform70.rotate(rotMat70);
- transform70.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans70 = std::make_shared<const Transform3D>(transform70);
- std::shared_ptr<PerigeeSurface> perigeeSurface70 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams70 = BoundParameters(tgContext, std::move(covMat70), params70, perigeeSurface70);
- tracks.push_back(boundParams70);
-
-
- // track 71 :
- BoundVector params71;
- params71 << -0.031271662563085556, 19.7582015991210938, -0.544847011566162109, 2.35719013214111328, -0.00060985935851931572*1./(1_MeV), 0;
- Covariance covMat71;
- covMat71 << 0.00421266257762908936, 0.000139259250319359563, -0.000121986267999964622, 1.59459282051017784e-06, -9.93183532021228265e-08*1./(1_MeV), 0, 0.000139259250319359563, 0.0205928590148687363, -5.36726063219632336e-06, 0.000232703689853152397, -3.11346553982713454e-10*1./(1_MeV), 0, -0.000121986267999964622, -5.36726063219632336e-06, 3.63290769200830255e-06, -6.68725223656711701e-08, 4.73213336870042294e-09*1./(1_MeV), 0, 1.59459282051017784e-06, 0.000232703689853152397, -6.68725223656711701e-08, 2.95713130071817432e-06, -1.25499234028196558e-11*1./(1_MeV), 0, -9.93183532021228265e-08*1./(1_MeV), -3.11346553982713454e-10*1./(1_MeV), 4.73213336870042294e-09*1./(1_MeV), -1.25499234028196558e-11*1./(1_MeV), 1.28399915699795031e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform71;
- ActsSymMatrixD<3> rotMat71;
- rotMat71 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform71.rotate(rotMat71);
- transform71.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans71 = std::make_shared<const Transform3D>(transform71);
- std::shared_ptr<PerigeeSurface> perigeeSurface71 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams71 = BoundParameters(tgContext, std::move(covMat71), params71, perigeeSurface71);
- tracks.push_back(boundParams71);
-
-
- // track 72 :
- BoundVector params72;
- params72 << -0.00558616593480110168, 19.7915973663330078, -1.90661561489105225, 2.65805935859680176, -0.000252252968493849039*1./(1_MeV), 0;
- Covariance covMat72;
- covMat72 << 0.00278375041671097279, 0.000178787135861017661, -8.12352454224075254e-05, 9.80445612301050583e-07, -3.12103239377841498e-08*1./(1_MeV), 0, 0.000178787135861017661, 0.0250813495367765427, -5.34047004847387823e-06, 0.000133613120646069154, -5.47170798097926544e-10*1./(1_MeV), 0, -8.12352454224075254e-05, -5.34047004847387823e-06, 2.44281318373396061e-06, -3.22686132104606899e-08, 1.51340031297866715e-09*1./(1_MeV), 0, 9.80445612301050583e-07, 0.000133613120646069154, -3.22686132104606899e-08, 7.69510791087668622e-07, -3.66374332111759326e-12*1./(1_MeV), 0, -3.12103239377841498e-08*1./(1_MeV), -5.47170798097926544e-10*1./(1_MeV), 1.51340031297866715e-09*1./(1_MeV), -3.66374332111759326e-12*1./(1_MeV), 2.74491956941957937e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform72;
- ActsSymMatrixD<3> rotMat72;
- rotMat72 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform72.rotate(rotMat72);
- transform72.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans72 = std::make_shared<const Transform3D>(transform72);
- std::shared_ptr<PerigeeSurface> perigeeSurface72 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams72 = BoundParameters(tgContext, std::move(covMat72), params72, perigeeSurface72);
- tracks.push_back(boundParams72);
-
-
- // track 73 :
- BoundVector params73;
- params73 << -0.442154228687286377, 17.9542407989501953, 2.09526467323303223, 2.94595146179199219, -0.000162040654686279595*1./(1_MeV), 0;
- Covariance covMat73;
- covMat73 << 0.0148460650816559792, 0.00184244940568953006, -0.000449961931621142613, 1.29765535410889532e-06, -2.30827454176528137e-07*1./(1_MeV), 0, 0.00184244940568953006, 0.471974313259124756, -6.98775671258470389e-05, 0.000523674191842157626, -2.19369371696834795e-08*1./(1_MeV), 0, -0.000449961931621142613, -6.98775671258470389e-05, 1.40490355988731608e-05, -5.73058129070942768e-08, 1.17830493253825561e-08*1./(1_MeV), 0, 1.29765535410889532e-06, 0.000523674191842157626, -5.73058129070942768e-08, 5.89256046623631846e-07, -2.53371790794750309e-12*1./(1_MeV), 0, -2.30827454176528137e-07*1./(1_MeV), -2.19369371696834795e-08*1./(1_MeV), 1.17830493253825561e-08*1./(1_MeV), -2.53371790794750309e-12*1./(1_MeV), 9.43526715091458357e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform73;
- ActsSymMatrixD<3> rotMat73;
- rotMat73 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform73.rotate(rotMat73);
- transform73.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans73 = std::make_shared<const Transform3D>(transform73);
- std::shared_ptr<PerigeeSurface> perigeeSurface73 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams73 = BoundParameters(tgContext, std::move(covMat73), params73, perigeeSurface73);
- tracks.push_back(boundParams73);
-
-
- // track 74 :
- BoundVector params74;
- params74 << 0.11471288651227951, 19.0564899444580078, -0.177579745650291443, 2.49515652656555176, 0.000924068794120103121*1./(1_MeV), 0;
- Covariance covMat74;
- covMat74 << 0.0152982324361801147, 4.68616789410272773e-05, -0.000446912018709990798, -2.64518724116447377e-06, -3.35403806382200683e-07*1./(1_MeV), 0, 4.68616789410272773e-05, 0.057605259120464325, 1.24210046721730033e-05, 0.00055778648850193823, -7.16971922823788445e-09*1./(1_MeV), 0, -0.000446912018709990798, 1.24210046721730033e-05, 1.33806315716356039e-05, 2.06818269256773686e-07, 1.64730542670120641e-08*1./(1_MeV), 0, -2.64518724116447377e-06, 0.00055778648850193823, 2.06818269256773686e-07, 5.62562490813434124e-06, -2.99011952126558051e-11*1./(1_MeV), 0, -3.35403806382200683e-07*1./(1_MeV), -7.16971922823788445e-09*1./(1_MeV), 1.64730542670120641e-08*1./(1_MeV), -2.99011952126558051e-11*1./(1_MeV), 3.94437649209322672e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform74;
- ActsSymMatrixD<3> rotMat74;
- rotMat74 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform74.rotate(rotMat74);
- transform74.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans74 = std::make_shared<const Transform3D>(transform74);
- std::shared_ptr<PerigeeSurface> perigeeSurface74 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams74 = BoundParameters(tgContext, std::move(covMat74), params74, perigeeSurface74);
- tracks.push_back(boundParams74);
-
-
- // track 75 :
- BoundVector params75;
- params75 << -0.00944441463798284531, 19.5482063293457031, 1.26532316207885742, 1.51080191135406494, 0.00125105178449302912*1./(1_MeV), 0;
- Covariance covMat75;
- covMat75 << 0.00673942035064101219, 1.09700537457738396e-05, -0.000191837249175310959, 3.98609880544513471e-07, -1.16410980841974866e-07*1./(1_MeV), 0, 1.09700537457738396e-05, 0.030988229438662529, -8.21095175946172576e-07, 0.000558048897263842877, -1.58105556275077154e-09*1./(1_MeV), 0, -0.000191837249175310959, -8.21095175946172576e-07, 5.58653619009419344e-06, -2.21237754371518524e-08, 5.54159050773939158e-09*1./(1_MeV), 0, 3.98609880544513471e-07, 0.000558048897263842877, -2.21237754371518524e-08, 1.262055775441695e-05, -2.73377636711205828e-11*1./(1_MeV), 0, -1.16410980841974866e-07*1./(1_MeV), -1.58105556275077154e-09*1./(1_MeV), 5.54159050773939158e-09*1./(1_MeV), -2.73377636711205828e-11*1./(1_MeV), 2.14180881363823516e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform75;
- ActsSymMatrixD<3> rotMat75;
- rotMat75 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform75.rotate(rotMat75);
- transform75.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans75 = std::make_shared<const Transform3D>(transform75);
- std::shared_ptr<PerigeeSurface> perigeeSurface75 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams75 = BoundParameters(tgContext, std::move(covMat75), params75, perigeeSurface75);
- tracks.push_back(boundParams75);
-
-
- // track 76 :
- BoundVector params76;
- params76 << 0.00483211036771535873, 19.769775390625, -0.868091702461242676, 2.3166813850402832, 0.000847792427521198988*1./(1_MeV), 0;
- Covariance covMat76;
- covMat76 << 0.00812008138746023178, 0.000241684869612282343, -0.000229342880415569957, 1.22350455006491968e-07, -1.51766456677205247e-07*1./(1_MeV), 0, 0.000241684869612282343, 0.0279842410236597061, -1.67820530316218224e-08, 0.000371614228093685849, -3.38119498984475317e-09*1./(1_MeV), 0, -0.000229342880415569957, -1.67820530316218224e-08, 6.68844677420565858e-06, 7.68954602593033632e-08, 6.98338608547542169e-09*1./(1_MeV), 0, 1.22350455006491968e-07, 0.000371614228093685849, 7.68954602593033632e-08, 5.40870951226679608e-06, 3.18987477267544148e-12*1./(1_MeV), 0, -1.51766456677205247e-07*1./(1_MeV), -3.38119498984475317e-09*1./(1_MeV), 6.98338608547542169e-09*1./(1_MeV), 3.18987477267544148e-12*1./(1_MeV), 1.92937235632406612e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform76;
- ActsSymMatrixD<3> rotMat76;
- rotMat76 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform76.rotate(rotMat76);
- transform76.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans76 = std::make_shared<const Transform3D>(transform76);
- std::shared_ptr<PerigeeSurface> perigeeSurface76 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams76 = BoundParameters(tgContext, std::move(covMat76), params76, perigeeSurface76);
- tracks.push_back(boundParams76);
-
-
- // track 77 :
- BoundVector params77;
- params77 << -0.310725152492523193, 19.8295936584472656, -0.606030046939849854, 2.24497246742248535, 0.000661869533360004425*1./(1_MeV), 0;
- Covariance covMat77;
- covMat77 << 0.00436511309817433357, 6.84685072450807867e-05, -0.000120994704364630506, -4.90458514285306182e-07, -5.64318242168483114e-08*1./(1_MeV), 0, 6.84685072450807867e-05, 0.0149454157799482346, 2.04636767799999282e-07, 0.000205310692185942025, -3.61902676938797707e-10*1./(1_MeV), 0, -0.000120994704364630506, 2.04636767799999282e-07, 3.47089417118695565e-06, 4.16973363970233483e-08, 2.51792336588650841e-09*1./(1_MeV), 0, -4.90458514285306182e-07, 0.000205310692185942025, 4.16973363970233483e-08, 3.3076123600039864e-06, 1.49401026311597095e-11*1./(1_MeV), 0, -5.64318242168483114e-08*1./(1_MeV), -3.61902676938797707e-10*1./(1_MeV), 2.51792336588650841e-09*1./(1_MeV), 1.49401026311597095e-11*1./(1_MeV), 7.15068143586350402e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform77;
- ActsSymMatrixD<3> rotMat77;
- rotMat77 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform77.rotate(rotMat77);
- transform77.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans77 = std::make_shared<const Transform3D>(transform77);
- std::shared_ptr<PerigeeSurface> perigeeSurface77 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams77 = BoundParameters(tgContext, std::move(covMat77), params77, perigeeSurface77);
- tracks.push_back(boundParams77);
-
-
- // track 78 :
- BoundVector params78;
- params78 << 0.0993749722838401794, 19.6716022491455078, 2.9211122989654541, 2.08926057815551758, 0.00120215211063623428*1./(1_MeV), 0;
- Covariance covMat78;
- covMat78 << 0.0101556088775396347, 1.73498859834314119e-05, -0.000283271865688924712, -1.78050008267022585e-06, -1.28366707714573746e-07*1./(1_MeV), 0, 1.73498859834314119e-05, 0.023284614086151123, 4.02106375070951919e-06, 0.000434507881477119533, -1.13469407774349132e-09*1./(1_MeV), 0, -0.000283271865688924712, 4.02106375070951919e-06, 8.19536035123746842e-06, 1.330371940544055e-07, 5.98130057573423383e-09*1./(1_MeV), 0, -1.78050008267022585e-06, 0.000434507881477119533, 1.330371940544055e-07, 8.93400192580884323e-06, -2.61622173381189258e-12*1./(1_MeV), 0, -1.28366707714573746e-07*1./(1_MeV), -1.13469407774349132e-09*1./(1_MeV), 5.98130057573423383e-09*1./(1_MeV), -2.61622173381189258e-12*1./(1_MeV), 1.96618277215065973e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform78;
- ActsSymMatrixD<3> rotMat78;
- rotMat78 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform78.rotate(rotMat78);
- transform78.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans78 = std::make_shared<const Transform3D>(transform78);
- std::shared_ptr<PerigeeSurface> perigeeSurface78 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams78 = BoundParameters(tgContext, std::move(covMat78), params78, perigeeSurface78);
- tracks.push_back(boundParams78);
-
-
- // track 79 :
- BoundVector params79;
- params79 << 0.00076918123522773385, 19.5978374481201172, -0.00888663902878761292, 2.26349568367004395, -5.1679373427759856e-05*1./(1_MeV), 0;
- Covariance covMat79;
- covMat79 << 0.000472295709187164903, 8.06538544252120891e-05, -5.76326071222579373e-06, 5.02484334678411116e-07, -7.2162471693487795e-09*1./(1_MeV), 0, 8.06538544252120891e-05, 0.00591621501371264458, -1.05334511746836201e-06, 2.14457476054835035e-05, -1.67841364746306759e-09*1./(1_MeV), 0, -5.76326071222579373e-06, -1.05334511746836201e-06, 8.51334576168483181e-08, -5.60483430138567528e-09, 9.92946218379075931e-11*1./(1_MeV), 0, 5.02484334678411116e-07, 2.14457476054835035e-05, -5.60483430138567528e-09, 1.79219924234530481e-07, -1.48012750336918152e-11*1./(1_MeV), 0, -7.2162471693487795e-09*1./(1_MeV), -1.67841364746306759e-09*1./(1_MeV), 9.92946218379075931e-11*1./(1_MeV), -1.48012750336918152e-11*1./(1_MeV), 8.22869712906876272e-13*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform79;
- ActsSymMatrixD<3> rotMat79;
- rotMat79 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform79.rotate(rotMat79);
- transform79.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans79 = std::make_shared<const Transform3D>(transform79);
- std::shared_ptr<PerigeeSurface> perigeeSurface79 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams79 = BoundParameters(tgContext, std::move(covMat79), params79, perigeeSurface79);
- tracks.push_back(boundParams79);
-
-
- // track 80 :
- BoundVector params80;
- params80 << 0.172430276870727539, 20.0516853332519531, 0.0925022587180137634, 2.79165339469909668, 0.000355079799192026258*1./(1_MeV), 0;
- Covariance covMat80;
- covMat80 << 0.0123957395553588867, 0.000276004959343346566, -0.000367529600040991081, -5.44526345620848147e-07, -2.56473787837672908e-07*1./(1_MeV), 0, 0.000276004959343346566, 0.149438470602035522, 1.26945466301119017e-05, 0.000484407751120721731, -4.77601393027406713e-09*1./(1_MeV), 0, -0.000367529600040991081, 1.26945466301119017e-05, 1.11619228846393526e-05, 7.59736475896802827e-08, 1.21717089673328274e-08*1./(1_MeV), 0, -5.44526345620848147e-07, 0.000484407751120721731, 7.59736475896802827e-08, 1.61264904363633832e-06, -7.16527986733535845e-12*1./(1_MeV), 0, -2.56473787837672908e-07*1./(1_MeV), -4.77601393027406713e-09*1./(1_MeV), 1.21717089673328274e-08*1./(1_MeV), -7.16527986733535845e-12*1./(1_MeV), 1.61127389208814975e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform80;
- ActsSymMatrixD<3> rotMat80;
- rotMat80 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform80.rotate(rotMat80);
- transform80.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans80 = std::make_shared<const Transform3D>(transform80);
- std::shared_ptr<PerigeeSurface> perigeeSurface80 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams80 = BoundParameters(tgContext, std::move(covMat80), params80, perigeeSurface80);
- tracks.push_back(boundParams80);
-
-
- // track 81 :
- BoundVector params81;
- params81 << 0.0237218067049980164, 19.884124755859375, -1.31243884563446045, 1.17260158061981201, 0.00145791680552065372*1./(1_MeV), 0;
- Covariance covMat81;
- covMat81 << 0.00926587916910648346, 7.06487595418491801e-05, -0.000277787039323878398, 4.07603821427250781e-06, -1.58449164304071412e-07*1./(1_MeV), 0, 7.06487595418491801e-05, 0.0313730873167514801, -6.65579864375914156e-06, 0.000612313813642858889, 3.06797580601043898e-10*1./(1_MeV), 0, -0.000277787039323878398, -6.65579864375914156e-06, 8.47732735564932227e-06, -2.17222306747093869e-07, 7.82071353865796235e-09*1./(1_MeV), 0, 4.07603821427250781e-06, 0.000612313813642858889, -2.17222306747093869e-07, 1.3626353393192403e-05, 7.47614118694918694e-12*1./(1_MeV), 0, -1.58449164304071412e-07*1./(1_MeV), 3.06797580601043898e-10*1./(1_MeV), 7.82071353865796235e-09*1./(1_MeV), 7.47614118694918694e-12*1./(1_MeV), 2.8977453769840622e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform81;
- ActsSymMatrixD<3> rotMat81;
- rotMat81 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform81.rotate(rotMat81);
- transform81.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans81 = std::make_shared<const Transform3D>(transform81);
- std::shared_ptr<PerigeeSurface> perigeeSurface81 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams81 = BoundParameters(tgContext, std::move(covMat81), params81, perigeeSurface81);
- tracks.push_back(boundParams81);
-
-
- // track 82 :
- BoundVector params82;
- params82 << 0.0107990093529224396, 19.6716117858886719, 1.03559982776641846, 1.73082625865936279, -0.000879532191902399063*1./(1_MeV), 0;
- Covariance covMat82;
- covMat82 << 0.00402391236275434494, 3.20769174601289147e-05, -0.000111254459256007358, 8.45579221821339803e-07, -4.58324536525110618e-08*1./(1_MeV), 0, 3.20769174601289147e-05, 0.0170307178050279617, -1.43476733365515181e-06, 0.000387486496341669733, -1.98263687729926011e-09*1./(1_MeV), 0, -0.000111254459256007358, -1.43476733365515181e-06, 3.15253510052571073e-06, -3.93483906027775912e-08, 2.199583121442104e-09*1./(1_MeV), 0, 8.45579221821339803e-07, 0.000387486496341669733, -3.93483906027775912e-08, 1.00340321296243928e-05, -8.11770059300461125e-11*1./(1_MeV), 0, -4.58324536525110618e-08*1./(1_MeV), -1.98263687729926011e-09*1./(1_MeV), 2.199583121442104e-09*1./(1_MeV), -8.11770059300461125e-11*1./(1_MeV), 8.58341592246958385e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform82;
- ActsSymMatrixD<3> rotMat82;
- rotMat82 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform82.rotate(rotMat82);
- transform82.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans82 = std::make_shared<const Transform3D>(transform82);
- std::shared_ptr<PerigeeSurface> perigeeSurface82 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams82 = BoundParameters(tgContext, std::move(covMat82), params82, perigeeSurface82);
- tracks.push_back(boundParams82);
-
-
- // track 83 :
- BoundVector params83;
- params83 << -0.0155548518523573875, 19.7591342926025391, 0.363524943590164185, 1.25925362110137939, 0.000502271810546517372*1./(1_MeV), 0;
- Covariance covMat83;
- covMat83 << 0.00146772642619907856, -2.09037045000602479e-05, -3.96307184598860177e-05, 1.98917565341808915e-07, -2.1828224014850844e-08*1./(1_MeV), 0, -2.09037045000602479e-05, 0.0098578035831451416, 3.71240804606546409e-07, 0.000133019349065383567, 2.05370209972403466e-09*1./(1_MeV), 0, -3.96307184598860177e-05, 3.71240804606546409e-07, 1.11548615677747875e-06, -1.0700920015588702e-08, 9.39493443779476572e-10*1./(1_MeV), 0, 1.98917565341808915e-07, 0.000133019349065383567, -1.0700920015588702e-08, 2.54624114859325346e-06, 1.22768956327870663e-13*1./(1_MeV), 0, -2.1828224014850844e-08*1./(1_MeV), 2.05370209972403466e-09*1./(1_MeV), 9.39493443779476572e-10*1./(1_MeV), 1.22768956327870663e-13*1./(1_MeV), 3.11325652757599158e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform83;
- ActsSymMatrixD<3> rotMat83;
- rotMat83 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform83.rotate(rotMat83);
- transform83.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans83 = std::make_shared<const Transform3D>(transform83);
- std::shared_ptr<PerigeeSurface> perigeeSurface83 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams83 = BoundParameters(tgContext, std::move(covMat83), params83, perigeeSurface83);
- tracks.push_back(boundParams83);
-
-
- // track 84 :
- BoundVector params84;
- params84 << -0.138253405690193176, 18.5519084930419922, 1.43608295917510986, 0.270120680332183838, 0.000328816560795530677*1./(1_MeV), 0;
- Covariance covMat84;
- covMat84 << 0.024482090026140213, -0.00141465310858683861, -0.000727919377154882677, 7.62924836936917779e-07, -2.70713331750664401e-07*1./(1_MeV), 0, -0.00141465310858683861, 0.38681483268737793, -3.29131593924930853e-06, 0.000780935381087039492, 2.03667202249869457e-08*1./(1_MeV), 0, -0.000727919377154882677, -3.29131593924930853e-06, 2.20086349145276472e-05, -1.08805257496805159e-07, 1.28472546995040731e-08*1./(1_MeV), 0, 7.62924836936917779e-07, 0.000780935381087039492, -1.08805257496805159e-07, 1.60606941790319979e-06, 6.31240016744585034e-12*1./(1_MeV), 0, -2.70713331750664401e-07*1./(1_MeV), 2.03667202249869457e-08*1./(1_MeV), 1.28472546995040731e-08*1./(1_MeV), 6.31240016744585034e-12*1./(1_MeV), 1.31787206147926383e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform84;
- ActsSymMatrixD<3> rotMat84;
- rotMat84 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform84.rotate(rotMat84);
- transform84.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans84 = std::make_shared<const Transform3D>(transform84);
- std::shared_ptr<PerigeeSurface> perigeeSurface84 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams84 = BoundParameters(tgContext, std::move(covMat84), params84, perigeeSurface84);
- tracks.push_back(boundParams84);
-
-
- // track 85 :
- BoundVector params85;
- params85 << -0.0975429564714431763, 19.5427474975585938, 2.8031013011932373, 1.58790135383605957, 0.00166723399888724089*1./(1_MeV), 0;
- Covariance covMat85;
- covMat85 << 0.0113241951912641525, -9.34923139819065776e-06, -0.000335769282045279361, -2.82633621752857802e-07, -1.5729637539850742e-07*1./(1_MeV), 0, -9.34923139819065776e-06, 0.0528257228434085846, 5.71110103579136688e-07, 0.00100043855412109946, -3.03573063913276242e-10*1./(1_MeV), 0, -0.000335769282045279361, 5.71110103579136688e-07, 1.01046462077647448e-05, 1.49587275943740115e-08, 7.33039139408457665e-09*1./(1_MeV), 0, -2.82633621752857802e-07, 0.00100043855412109946, 1.49587275943740115e-08, 2.26391439355211332e-05, 1.66413138250011556e-12*1./(1_MeV), 0, -1.5729637539850742e-07*1./(1_MeV), -3.03573063913276242e-10*1./(1_MeV), 7.33039139408457665e-09*1./(1_MeV), 1.66413138250011556e-12*1./(1_MeV), 2.75241468505882381e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform85;
- ActsSymMatrixD<3> rotMat85;
- rotMat85 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform85.rotate(rotMat85);
- transform85.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans85 = std::make_shared<const Transform3D>(transform85);
- std::shared_ptr<PerigeeSurface> perigeeSurface85 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams85 = BoundParameters(tgContext, std::move(covMat85), params85, perigeeSurface85);
- tracks.push_back(boundParams85);
-
-
- // track 86 :
- BoundVector params86;
- params86 << -0.0176449194550514221, 19.7948665618896484, -2.85859298706054688, 1.93745362758636475, 0.00181531091220676899*1./(1_MeV), 0;
- Covariance covMat86;
- covMat86 << 0.0164455324411392212, -1.78319115876212784e-05, -0.000476391113400424576, -4.84635611442015516e-06, -2.16420755174177543e-07*1./(1_MeV), 0, -1.78319115876212784e-05, 0.0350610315799713135, 7.76663282566612816e-06, 0.00082119930622140565, -2.29522713626592166e-09*1./(1_MeV), 0, -0.000476391113400424576, 7.76663282566612816e-06, 1.41888513098820113e-05, 3.09707605227186869e-07, 1.05056686720642746e-08*1./(1_MeV), 0, -4.84635611442015516e-06, 0.00082119930622140565, 3.09707605227186869e-07, 2.0716039216495119e-05, -3.66067615445536715e-11*1./(1_MeV), 0, -2.16420755174177543e-07*1./(1_MeV), -2.29522713626592166e-09*1./(1_MeV), 1.05056686720642746e-08*1./(1_MeV), -3.66067615445536715e-11*1./(1_MeV), 3.8617198327983715e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform86;
- ActsSymMatrixD<3> rotMat86;
- rotMat86 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform86.rotate(rotMat86);
- transform86.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans86 = std::make_shared<const Transform3D>(transform86);
- std::shared_ptr<PerigeeSurface> perigeeSurface86 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams86 = BoundParameters(tgContext, std::move(covMat86), params86, perigeeSurface86);
- tracks.push_back(boundParams86);
-
-
- // track 87 :
- BoundVector params87;
- params87 << -0.166390389204025269, 19.5272064208984375, 1.93741095066070557, 2.24489212036132812, -0.000905173714272677898*1./(1_MeV), 0;
- Covariance covMat87;
- covMat87 << 0.00758632877841591835, 0.000139937870694665129, -0.00021374593302439404, 2.74308497049270969e-06, -1.22199307635393265e-07*1./(1_MeV), 0, 0.000139937870694665129, 0.0236409269273281097, -7.18474418831525274e-06, 0.000356769071380466532, 2.17953764438197491e-10*1./(1_MeV), 0, -0.00021374593302439404, -7.18474418831525274e-06, 6.20618220636970364e-06, -1.339422192986325e-07, 5.75423109018135768e-09*1./(1_MeV), 0, 2.74308497049270969e-06, 0.000356769071380466532, -1.339422192986325e-07, 5.97795133217005059e-06, 1.65920987870639118e-13*1./(1_MeV), 0, -1.22199307635393265e-07*1./(1_MeV), 2.17953764438197491e-10*1./(1_MeV), 5.75423109018135768e-09*1./(1_MeV), 1.65920987870639118e-13*1./(1_MeV), 1.7132852081491734e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform87;
- ActsSymMatrixD<3> rotMat87;
- rotMat87 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform87.rotate(rotMat87);
- transform87.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans87 = std::make_shared<const Transform3D>(transform87);
- std::shared_ptr<PerigeeSurface> perigeeSurface87 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams87 = BoundParameters(tgContext, std::move(covMat87), params87, perigeeSurface87);
- tracks.push_back(boundParams87);
-
-
- // track 88 :
- BoundVector params88;
- params88 << -0.0647897049784660339, 19.7515354156494141, -1.94424092769622803, 0.913331747055053711, 0.00144281168468296528*1./(1_MeV), 0;
- Covariance covMat88;
- covMat88 << 0.0164492577314376831, 0.000114680106948955043, -0.000493878556345173059, 7.55394948756817303e-06, -3.09421204652331308e-07*1./(1_MeV), 0, 0.000114680106948955043, 0.0497665181756019592, -1.69407417870949993e-05, 0.000847429052747156815, 4.92898530455145555e-09*1./(1_MeV), 0, -0.000493878556345173059, -1.69407417870949993e-05, 1.51399772221338935e-05, -4.57257867983653748e-07, 1.5688536216622446e-08*1./(1_MeV), 0, 7.55394948756817303e-06, 0.000847429052747156815, -4.57257867983653748e-07, 1.51720887515693903e-05, 7.05942755015551252e-12*1./(1_MeV), 0, -3.09421204652331308e-07*1./(1_MeV), 4.92898530455145555e-09*1./(1_MeV), 1.5688536216622446e-08*1./(1_MeV), 7.05942755015551252e-12*1./(1_MeV), 5.00731012209598703e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform88;
- ActsSymMatrixD<3> rotMat88;
- rotMat88 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform88.rotate(rotMat88);
- transform88.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans88 = std::make_shared<const Transform3D>(transform88);
- std::shared_ptr<PerigeeSurface> perigeeSurface88 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams88 = BoundParameters(tgContext, std::move(covMat88), params88, perigeeSurface88);
- tracks.push_back(boundParams88);
-
-
- // track 89 :
- BoundVector params89;
- params89 << -0.0218852758407592773, 19.7477836608886719, -1.84601056575775146, 1.15177929401397705, -0.000602153537329286337*1./(1_MeV), 0;
- Covariance covMat89;
- covMat89 << 0.00399546697735786438, -7.6231191425185513e-05, -0.000113968779238574712, -1.06749066545070016e-06, -1.49669197267399396e-07*1./(1_MeV), 0, -7.6231191425185513e-05, 0.0129444217309355736, 2.25263525428921646e-06, 0.000202868748994328374, -7.0251938262291757e-09*1./(1_MeV), 0, -0.000113968779238574712, 2.25263525428921646e-06, 3.39482835443050135e-06, 3.68428330396706466e-08, 7.19219531975148008e-09*1./(1_MeV), 0, -1.06749066545070016e-06, 0.000202868748994328374, 3.68428330396706466e-08, 3.95832057620282285e-06, -5.52575945546745665e-11*1./(1_MeV), 0, -1.49669197267399396e-07*1./(1_MeV), -7.0251938262291757e-09*1./(1_MeV), 7.19219531975148008e-09*1./(1_MeV), -5.52575945546745665e-11*1./(1_MeV), 2.65768212992512076e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform89;
- ActsSymMatrixD<3> rotMat89;
- rotMat89 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform89.rotate(rotMat89);
- transform89.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans89 = std::make_shared<const Transform3D>(transform89);
- std::shared_ptr<PerigeeSurface> perigeeSurface89 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams89 = BoundParameters(tgContext, std::move(covMat89), params89, perigeeSurface89);
- tracks.push_back(boundParams89);
-
-
- // track 90 :
- BoundVector params90;
- params90 << -0.179924234747886658, 19.2563438415527344, -1.48651039600372314, 2.36299228668212891, -0.00104924733750522137*1./(1_MeV), 0;
- Covariance covMat90;
- covMat90 << 0.0114581910893321037, 0.000363608408604759639, -0.000344876866124296778, 5.81780591102444491e-06, -2.6043200912918554e-07*1./(1_MeV), 0, 0.000363608408604759639, 0.0420437715947628021, -1.83725730891767065e-05, 0.000563950407188989035, -4.04684151826768466e-09*1./(1_MeV), 0, -0.000344876866124296778, -1.83725730891767065e-05, 1.06007255453732796e-05, -2.88525393038017665e-07, 1.30515590208839564e-08*1./(1_MeV), 0, 5.81780591102444491e-06, 0.000563950407188989035, -2.88525393038017665e-07, 8.05603212938876823e-06, -7.18990753436096707e-11*1./(1_MeV), 0, -2.6043200912918554e-07*1./(1_MeV), -4.04684151826768466e-09*1./(1_MeV), 1.30515590208839564e-08*1./(1_MeV), -7.18990753436096707e-11*1./(1_MeV), 3.69383551523938536e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform90;
- ActsSymMatrixD<3> rotMat90;
- rotMat90 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform90.rotate(rotMat90);
- transform90.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans90 = std::make_shared<const Transform3D>(transform90);
- std::shared_ptr<PerigeeSurface> perigeeSurface90 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams90 = BoundParameters(tgContext, std::move(covMat90), params90, perigeeSurface90);
- tracks.push_back(boundParams90);
-
-
- // track 91 :
- BoundVector params91;
- params91 << 0.0888378918170928955, 19.5743637084960938, 2.02936220169067383, 0.592313289642333984, -0.00073199498001486063*1./(1_MeV), 0;
- Covariance covMat91;
- covMat91 << 0.011888476088643074, -0.000364351547358354397, -0.000344164051274786493, -4.80224624851940611e-06, -1.25074865846872421e-07*1./(1_MeV), 0, -0.000364351547358354397, 0.0546070896089076996, 1.71846692226701118e-05, 0.000451481364740918725, -6.40392522058036485e-10*1./(1_MeV), 0, -0.000344164051274786493, 1.71846692226701118e-05, 1.02026851891423576e-05, 2.02827091730025172e-07, 6.16615182332136642e-09*1./(1_MeV), 0, -4.80224624851940611e-06, 0.000451481364740918725, 2.02827091730025172e-07, 3.89986053050961345e-06, 1.48987059961839454e-11*1./(1_MeV), 0, -1.25074865846872421e-07*1./(1_MeV), -6.40392522058036485e-10*1./(1_MeV), 6.16615182332136642e-09*1./(1_MeV), 1.48987059961839454e-11*1./(1_MeV), 1.37464484240013007e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform91;
- ActsSymMatrixD<3> rotMat91;
- rotMat91 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform91.rotate(rotMat91);
- transform91.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans91 = std::make_shared<const Transform3D>(transform91);
- std::shared_ptr<PerigeeSurface> perigeeSurface91 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams91 = BoundParameters(tgContext, std::move(covMat91), params91, perigeeSurface91);
- tracks.push_back(boundParams91);
-
-
- // track 92 :
- BoundVector params92;
- params92 << 1.12502670288085938, 20.2727298736572266, 2.00401997566223145, 0.626365065574645996, -0.00111448660027235746*1./(1_MeV), 0;
- Covariance covMat92;
- covMat92 << 0.0225118305534124374, 0.000584212031156044944, -0.000666452626493573485, -9.45983147595499108e-06, -3.13759589393168411e-07*1./(1_MeV), 0, 0.000584212031156044944, 0.0864472761750221252, 1.9655656094501285e-06, 0.000822762632728434311, -2.92388874702865178e-08*1./(1_MeV), 0, -0.000666452626493573485, 1.9655656094501285e-06, 2.00926533580059186e-05, 4.80605470309639927e-07, 1.5495058835982803e-08*1./(1_MeV), 0, -9.45983147595499108e-06, 0.000822762632728434311, 4.80605470309639927e-07, 8.10808978712884709e-06, 1.17184088836066811e-11*1./(1_MeV), 0, -3.13759589393168411e-07*1./(1_MeV), -2.92388874702865178e-08*1./(1_MeV), 1.5495058835982803e-08*1./(1_MeV), 1.17184088836066811e-11*1./(1_MeV), 3.60202312421620263e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform92;
- ActsSymMatrixD<3> rotMat92;
- rotMat92 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform92.rotate(rotMat92);
- transform92.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans92 = std::make_shared<const Transform3D>(transform92);
- std::shared_ptr<PerigeeSurface> perigeeSurface92 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams92 = BoundParameters(tgContext, std::move(covMat92), params92, perigeeSurface92);
- tracks.push_back(boundParams92);
-
-
- // track 93 :
- BoundVector params93;
- params93 << 0.0424742512404918671, 18.9486141204833984, 1.86956024169921875, 2.96004772186279297, 4.37863855040632188e-05*1./(1_MeV), 0;
- Covariance covMat93;
- covMat93 << 0.00272560492157936096, 0.00211849758168023089, -7.31526879372190519e-05, 1.47161851529462088e-06, -2.24706881796614946e-08*1./(1_MeV), 0, 0.00211849758168023089, 0.109402194619178772, -4.40777842273042759e-05, 8.76258363739740542e-05, -7.98382954847600904e-09*1./(1_MeV), 0, -7.31526879372190519e-05, -4.40777842273042759e-05, 2.04982438845036086e-06, -3.14008128887106979e-08, 9.90149855492210942e-10*1./(1_MeV), 0, 1.47161851529462088e-06, 8.76258363739740542e-05, -3.14008128887106979e-08, 7.31033722445317835e-08, -5.93207648040451609e-12*1./(1_MeV), 0, -2.24706881796614946e-08*1./(1_MeV), -7.98382954847600904e-09*1./(1_MeV), 9.90149855492210942e-10*1./(1_MeV), -5.93207648040451609e-12*1./(1_MeV), 6.39852146960828705e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform93;
- ActsSymMatrixD<3> rotMat93;
- rotMat93 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform93.rotate(rotMat93);
- transform93.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans93 = std::make_shared<const Transform3D>(transform93);
- std::shared_ptr<PerigeeSurface> perigeeSurface93 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams93 = BoundParameters(tgContext, std::move(covMat93), params93, perigeeSurface93);
- tracks.push_back(boundParams93);
-
-
- // track 94 :
- BoundVector params94;
- params94 << 0.0741926580667495728, 19.3120975494384766, -0.158996760845184326, 0.275065630674362183, 0.000188159960089251399*1./(1_MeV), 0;
- Covariance covMat94;
- covMat94 << 0.00854411255568265915, -0.000856847673562337298, -0.000243449563025652623, -9.85362587786612014e-07, -5.40653541002901188e-08*1./(1_MeV), 0, -0.000856847673562337298, 0.125519141554832458, 1.11678697417946741e-05, 0.000258925752451969187, 1.7425143865914771e-09*1./(1_MeV), 0, -0.000243449563025652623, 1.11678697417946741e-05, 7.13488225301261991e-06, 5.42206306027033232e-09, 2.68913182114241505e-09*1./(1_MeV), 0, -9.85362587786612014e-07, 0.000258925752451969187, 5.42206306027033232e-09, 5.48016146240115631e-07, 2.1763511830840563e-12*1./(1_MeV), 0, -5.40653541002901188e-08*1./(1_MeV), 1.7425143865914771e-09*1./(1_MeV), 2.68913182114241505e-09*1./(1_MeV), 2.1763511830840563e-12*1./(1_MeV), 2.93287685804166642e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform94;
- ActsSymMatrixD<3> rotMat94;
- rotMat94 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform94.rotate(rotMat94);
- transform94.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans94 = std::make_shared<const Transform3D>(transform94);
- std::shared_ptr<PerigeeSurface> perigeeSurface94 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams94 = BoundParameters(tgContext, std::move(covMat94), params94, perigeeSurface94);
- tracks.push_back(boundParams94);
-
-
- // track 95 :
- BoundVector params95;
- params95 << 0.00871588941663503647, 19.6997394561767578, -1.8126060962677002, 2.65224313735961914, 0.000173616441315971315*1./(1_MeV), 0;
- Covariance covMat95;
- covMat95 << 0.0016872126143425703, 0.000139207692137839037, -4.67932554158379929e-05, 4.13046758309523893e-07, -2.15022847730470487e-08*1./(1_MeV), 0, 0.000139207692137839037, 0.0162848997861146927, -2.02254704724682222e-06, 8.19432265737622998e-05, -3.67683233513065563e-10*1./(1_MeV), 0, -4.67932554158379929e-05, -2.02254704724682222e-06, 1.35188520289375447e-06, -3.99719230681514876e-09, 9.61695510131444949e-10*1./(1_MeV), 0, 4.13046758309523893e-07, 8.19432265737622998e-05, -3.99719230681514876e-09, 4.59278368225568556e-07, 1.08766285673392314e-12*1./(1_MeV), 0, -2.15022847730470487e-08*1./(1_MeV), -3.67683233513065563e-10*1./(1_MeV), 9.61695510131444949e-10*1./(1_MeV), 1.08766285673392314e-12*1./(1_MeV), 1.62394785119257534e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform95;
- ActsSymMatrixD<3> rotMat95;
- rotMat95 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform95.rotate(rotMat95);
- transform95.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans95 = std::make_shared<const Transform3D>(transform95);
- std::shared_ptr<PerigeeSurface> perigeeSurface95 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams95 = BoundParameters(tgContext, std::move(covMat95), params95, perigeeSurface95);
- tracks.push_back(boundParams95);
-
-
- // track 96 :
- BoundVector params96;
- params96 << -0.479792565107345581, 19.5514030456542969, 1.30992162227630615, 2.87463688850402832, -0.000373176822904497385*1./(1_MeV), 0;
- Covariance covMat96;
- covMat96 << 0.0304757114499807358, 0.00262038861845952575, -0.000909104372409295556, 4.81420582026805876e-06, -3.00973750980190046e-07*1./(1_MeV), 0, 0.00262038861845952575, 0.461684495210647583, -0.000119908842389617728, 0.000928506582398690205, -1.58063875508688272e-08*1./(1_MeV), 0, -0.000909104372409295556, -0.000119908842389617728, 2.75514212262351066e-05, -2.30932526667593089e-07, 1.47073159868963048e-08*1./(1_MeV), 0, 4.81420582026805876e-06, 0.000928506582398690205, -2.30932526667593089e-07, 1.89259435501298867e-06, -3.4275779025213788e-12*1./(1_MeV), 0, -3.00973750980190046e-07*1./(1_MeV), -1.58063875508688272e-08*1./(1_MeV), 1.47073159868963048e-08*1./(1_MeV), -3.4275779025213788e-12*1./(1_MeV), 1.52582876888907037e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform96;
- ActsSymMatrixD<3> rotMat96;
- rotMat96 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform96.rotate(rotMat96);
- transform96.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans96 = std::make_shared<const Transform3D>(transform96);
- std::shared_ptr<PerigeeSurface> perigeeSurface96 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams96 = BoundParameters(tgContext, std::move(covMat96), params96, perigeeSurface96);
- tracks.push_back(boundParams96);
-
-
- // track 97 :
- BoundVector params97;
- params97 << 0.0435044243931770325, 19.5490474700927734, -1.34004080295562744, 0.636775732040405273, 0.00095876265550032258*1./(1_MeV), 0;
- Covariance covMat97;
- covMat97 << 0.0165304504334926605, 8.29496702915483077e-06, -0.000500555157842997754, 3.90666040743467471e-06, -2.32492797224773581e-07*1./(1_MeV), 0, 8.29496702915483077e-06, 0.0697377473115921021, -1.69183732968702351e-05, 0.000672615077218085113, 4.78769181746032668e-09*1./(1_MeV), 0, -0.000500555157842997754, -1.69183732968702351e-05, 1.53797700477298349e-05, -2.76896198762005315e-07, 1.14306313433277435e-08*1./(1_MeV), 0, 3.90666040743467471e-06, 0.000672615077218085113, -2.76896198762005315e-07, 6.75487535772845149e-06, 5.33336934367208442e-12*1./(1_MeV), 0, -2.32492797224773581e-07*1./(1_MeV), 4.78769181746032668e-09*1./(1_MeV), 1.14306313433277435e-08*1./(1_MeV), 5.33336934367208442e-12*1./(1_MeV), 2.67363853279078967e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform97;
- ActsSymMatrixD<3> rotMat97;
- rotMat97 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform97.rotate(rotMat97);
- transform97.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans97 = std::make_shared<const Transform3D>(transform97);
- std::shared_ptr<PerigeeSurface> perigeeSurface97 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams97 = BoundParameters(tgContext, std::move(covMat97), params97, perigeeSurface97);
- tracks.push_back(boundParams97);
-
-
- // track 98 :
- BoundVector params98;
- params98 << 0.294112950563430786, 20.2545261383056641, -0.614140152931213379, 2.8818819522857666, 0.000281037588138133287*1./(1_MeV), 0;
- Covariance covMat98;
- covMat98 << 0.0236709490418434143, 0.00249554031068035566, -0.000662619697167173742, 2.34743469108013516e-06, -2.19122332602494014e-07*1./(1_MeV), 0, 0.00249554031068035566, 0.38017040491104126, -1.42274220258879397e-05, 0.000682984089483805218, -1.15543562394303679e-08*1./(1_MeV), 0, -0.000662619697167173742, -1.42274220258879397e-05, 1.92686129594221711e-05, 2.05189135697031987e-08, 1.0358702081816697e-08*1./(1_MeV), 0, 2.34743469108013516e-06, 0.000682984089483805218, 2.05189135697031987e-08, 1.2688219612755347e-06, -2.0944363933578172e-11*1./(1_MeV), 0, -2.19122332602494014e-07*1./(1_MeV), -1.15543562394303679e-08*1./(1_MeV), 1.0358702081816697e-08*1./(1_MeV), -2.0944363933578172e-11*1./(1_MeV), 1.02260803991338634e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform98;
- ActsSymMatrixD<3> rotMat98;
- rotMat98 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform98.rotate(rotMat98);
- transform98.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans98 = std::make_shared<const Transform3D>(transform98);
- std::shared_ptr<PerigeeSurface> perigeeSurface98 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams98 = BoundParameters(tgContext, std::move(covMat98), params98, perigeeSurface98);
- tracks.push_back(boundParams98);
-
-
- // track 99 :
- BoundVector params99;
- params99 << -0.13228142261505127, 19.8440647125244141, -1.97596120834350586, 0.307230293750762939, -0.000209428049856796861*1./(1_MeV), 0;
- Covariance covMat99;
- covMat99 << 0.0064656953327357769, -0.000491542212342820388, -0.00019640849669221811, -1.26200648361190619e-06, -7.51057490837922185e-08*1./(1_MeV), 0, -0.000491542212342820388, 0.0971855819225311279, 1.78855920005378135e-05, 0.000244668503969933625, 2.01135045525568458e-09*1./(1_MeV), 0, -0.00019640849669221811, 1.78855920005378135e-05, 6.10315464655286632e-06, 4.79157334954937018e-08, 3.80545329493034294e-09*1./(1_MeV), 0, -1.26200648361190619e-06, 0.000244668503969933625, 4.79157334954937018e-08, 6.40511075289396103e-07, 3.52133532247833157e-12*1./(1_MeV), 0, -7.51057490837922185e-08*1./(1_MeV), 2.01135045525568458e-09*1./(1_MeV), 3.80545329493034294e-09*1./(1_MeV), 3.52133532247833157e-12*1./(1_MeV), 4.62756812036335674e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform99;
- ActsSymMatrixD<3> rotMat99;
- rotMat99 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform99.rotate(rotMat99);
- transform99.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans99 = std::make_shared<const Transform3D>(transform99);
- std::shared_ptr<PerigeeSurface> perigeeSurface99 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams99 = BoundParameters(tgContext, std::move(covMat99), params99, perigeeSurface99);
- tracks.push_back(boundParams99);
-
-
- // track 100 :
- BoundVector params100;
- params100 << 0.0397286675870418549, 19.8980617523193359, -1.5870441198348999, 1.06085562705993652, -0.00154436775483191013*1./(1_MeV), 0;
- Covariance covMat100;
- covMat100 << 0.0146848792210221291, -0.00024056679482515193, -0.000422761250825204478, -6.59419504288689593e-06, -2.0883759621313093e-07*1./(1_MeV), 0, -0.00024056679482515193, 0.0353117473423480988, 1.29517733327191238e-05, 0.000689977822807362863, -2.65977040646537884e-09*1./(1_MeV), 0, -0.000422761250825204478, 1.29517733327191238e-05, 1.25361730169970542e-05, 3.29509919866834633e-07, 9.87015185549509611e-09*1./(1_MeV), 0, -6.59419504288689593e-06, 0.000689977822807362863, 3.29509919866834633e-07, 1.49626648635603487e-05, -5.44243124057383386e-11*1./(1_MeV), 0, -2.0883759621313093e-07*1./(1_MeV), -2.65977040646537884e-09*1./(1_MeV), 9.87015185549509611e-09*1./(1_MeV), -5.44243124057383386e-11*1./(1_MeV), 3.28629123913515286e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform100;
- ActsSymMatrixD<3> rotMat100;
- rotMat100 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform100.rotate(rotMat100);
- transform100.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans100 = std::make_shared<const Transform3D>(transform100);
- std::shared_ptr<PerigeeSurface> perigeeSurface100 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams100 = BoundParameters(tgContext, std::move(covMat100), params100, perigeeSurface100);
- tracks.push_back(boundParams100);
-
-
- // track 101 :
- BoundVector params101;
- params101 << -0.0403421521186828613, 20.0219764709472656, 2.98151826858520508, 0.283174663782119751, -0.000182216783287003636*1./(1_MeV), 0;
- Covariance covMat101;
- covMat101 << 0.0106812380254268646, -0.0024943587506664794, -0.00027858873873760296, -4.44244638850068472e-06, -5.26653512387191812e-08*1./(1_MeV), 0, -0.0024943587506664794, 0.194047778844833374, 6.18626595670502936e-05, 0.000369563883583051613, 5.07052744885661252e-09*1./(1_MeV), 0, -0.00027858873873760296, 6.18626595670502936e-05, 7.62251374908373691e-06, 1.15742939569733442e-07, 2.35948978506657342e-09*1./(1_MeV), 0, -4.44244638850068472e-06, 0.000369563883583051613, 1.15742939569733442e-07, 7.40628024686884601e-07, 9.57926490773258748e-12*1./(1_MeV), 0, -5.26653512387191812e-08*1./(1_MeV), 5.07052744885661252e-09*1./(1_MeV), 2.35948978506657342e-09*1./(1_MeV), 9.57926490773258748e-12*1./(1_MeV), 2.45328583836634806e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform101;
- ActsSymMatrixD<3> rotMat101;
- rotMat101 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform101.rotate(rotMat101);
- transform101.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans101 = std::make_shared<const Transform3D>(transform101);
- std::shared_ptr<PerigeeSurface> perigeeSurface101 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams101 = BoundParameters(tgContext, std::move(covMat101), params101, perigeeSurface101);
- tracks.push_back(boundParams101);
-
-
- // track 102 :
- BoundVector params102;
- params102 << 0.102368071675300598, 19.5361366271972656, 0.766166448593139648, 2.5110175609588623, -0.000775155378505587578*1./(1_MeV), 0;
- Covariance covMat102;
- covMat102 << 0.011576404795050621, 0.000312717534921375974, -0.000335520083970844722, 4.71286322771853713e-06, -1.4290716638334455e-07*1./(1_MeV), 0, 0.000312717534921375974, 0.0526967272162437439, -1.61243873360913762e-05, 0.000481644572307707124, 2.09254387760536983e-09*1./(1_MeV), 0, -0.000335520083970844722, -1.61243873360913762e-05, 9.90374064713250846e-06, -2.10436751795918073e-07, 6.86918188030268416e-09*1./(1_MeV), 0, 4.71286322771853713e-06, 0.000481644572307707124, -2.10436751795918073e-07, 4.60942783320206217e-06, -5.63914956480814653e-12*1./(1_MeV), 0, -1.4290716638334455e-07*1./(1_MeV), 2.09254387760536983e-09*1./(1_MeV), 6.86918188030268416e-09*1./(1_MeV), -5.63914956480814653e-12*1./(1_MeV), 1.56449936339342344e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform102;
- ActsSymMatrixD<3> rotMat102;
- rotMat102 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform102.rotate(rotMat102);
- transform102.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans102 = std::make_shared<const Transform3D>(transform102);
- std::shared_ptr<PerigeeSurface> perigeeSurface102 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams102 = BoundParameters(tgContext, std::move(covMat102), params102, perigeeSurface102);
- tracks.push_back(boundParams102);
-
-
- // track 103 :
- BoundVector params103;
- params103 << 0.00269113038666546345, 19.7512493133544922, 0.950928092002868652, 1.69274437427520752, -0.000290958356345072389*1./(1_MeV), 0;
- Covariance covMat103;
- covMat103 << 0.000890406954567879438, 9.06876283418256436e-06, -2.11295340822724774e-05, 9.41784250991205146e-08, -5.2726015222058164e-09*1./(1_MeV), 0, 9.06876283418256436e-06, 0.00811147503554821014, -2.45248004436948366e-07, 0.000101593272660637559, -2.7419352860978785e-09*1./(1_MeV), 0, -2.11295340822724774e-05, -2.45248004436948366e-07, 5.30661907305329805e-07, -3.58145452722120584e-09, 2.49822767665423193e-10*1./(1_MeV), 0, 9.41784250991205146e-08, 0.000101593272660637559, -3.58145452722120584e-09, 2.08752635444398038e-06, -5.68853159346797837e-11*1./(1_MeV), 0, -5.2726015222058164e-09*1./(1_MeV), -2.7419352860978785e-09*1./(1_MeV), 2.49822767665423193e-10*1./(1_MeV), -5.68853159346797837e-11*1./(1_MeV), 9.96157063087865779e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform103;
- ActsSymMatrixD<3> rotMat103;
- rotMat103 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform103.rotate(rotMat103);
- transform103.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans103 = std::make_shared<const Transform3D>(transform103);
- std::shared_ptr<PerigeeSurface> perigeeSurface103 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams103 = BoundParameters(tgContext, std::move(covMat103), params103, perigeeSurface103);
- tracks.push_back(boundParams103);
-
-
- // track 104 :
- BoundVector params104;
- params104 << -0.245851978659629822, 20.1682567596435547, 1.23872554302215576, 0.248893141746520996, 0.000325477973092347383*1./(1_MeV), 0;
- Covariance covMat104;
- covMat104 << 0.0286086816340684891, -0.001356925375741017, -0.000851797951539738228, 1.97126922666860932e-06, -2.43581517567970172e-07*1./(1_MeV), 0, -0.001356925375741017, 0.490286678075790405, -8.99033667088915713e-06, 0.000865735597139924494, 2.32921530889448322e-08*1./(1_MeV), 0, -0.000851797951539738228, -8.99033667088915713e-06, 2.57704250543611124e-05, -1.44063558527249657e-07, 1.22322871879510032e-08*1./(1_MeV), 0, 1.97126922666860932e-06, 0.000865735597139924494, -1.44063558527249657e-07, 1.54735130308836233e-06, 2.09896768832773089e-12*1./(1_MeV), 0, -2.43581517567970172e-07*1./(1_MeV), 2.32921530889448322e-08*1./(1_MeV), 1.22322871879510032e-08*1./(1_MeV), 2.09896768832773089e-12*1./(1_MeV), 1.2200331023226596e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform104;
- ActsSymMatrixD<3> rotMat104;
- rotMat104 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform104.rotate(rotMat104);
- transform104.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans104 = std::make_shared<const Transform3D>(transform104);
- std::shared_ptr<PerigeeSurface> perigeeSurface104 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams104 = BoundParameters(tgContext, std::move(covMat104), params104, perigeeSurface104);
- tracks.push_back(boundParams104);
-
-
- // track 105 :
- BoundVector params105;
- params105 << -0.0600807033479213715, 19.7313117980957031, 2.31984329223632812, 1.3616642951965332, 0.000664964492898434401*1./(1_MeV), 0;
- Covariance covMat105;
- covMat105 << 0.00314268073998391628, -7.7012257876423378e-06, -8.51334898014966158e-05, 5.89304597370603241e-07, -7.97505446520337312e-08*1./(1_MeV), 0, -7.7012257876423378e-06, 0.0102382330223917961, -6.32454788190619239e-07, 0.000178850129128044883, -9.30661620828337703e-09*1./(1_MeV), 0, -8.51334898014966158e-05, -6.32454788190619239e-07, 2.44164994001039304e-06, -2.83573153286948557e-08, 3.20769979461027676e-09*1./(1_MeV), 0, 5.89304597370603241e-07, 0.000178850129128044883, -2.83573153286948557e-08, 4.20260403188876808e-06, -1.84237869498140217e-10*1./(1_MeV), 0, -7.97505446520337312e-08*1./(1_MeV), -9.30661620828337703e-09*1./(1_MeV), 3.20769979461027676e-09*1./(1_MeV), -1.84237869498140217e-10*1./(1_MeV), 9.88064630114138254e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform105;
- ActsSymMatrixD<3> rotMat105;
- rotMat105 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform105.rotate(rotMat105);
- transform105.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans105 = std::make_shared<const Transform3D>(transform105);
- std::shared_ptr<PerigeeSurface> perigeeSurface105 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams105 = BoundParameters(tgContext, std::move(covMat105), params105, perigeeSurface105);
- tracks.push_back(boundParams105);
-
-
- // track 106 :
- BoundVector params106;
- params106 << -0.0632231608033180237, 19.6254329681396484, 1.89337217807769775, 0.921234846115112305, -0.000626925728283822536*1./(1_MeV), 0;
- Covariance covMat106;
- covMat106 << 0.00425710296258330345, -0.000219698489314023703, -0.000117615295422727911, -2.52522899438900064e-06, -5.43295757382818289e-08*1./(1_MeV), 0, -0.000219698489314023703, 0.0236179828643798828, 7.04771554651835001e-06, 0.000339162159718363429, -3.13730541114924775e-09*1./(1_MeV), 0, -0.000117615295422727911, 7.04771554651835001e-06, 3.34456171913188882e-06, 9.40031753889414598e-08, 2.52804058098014408e-09*1./(1_MeV), 0, -2.52522899438900064e-06, 0.000339162159718363429, 9.40031753889414598e-08, 5.38931180926738307e-06, -2.20941594381711364e-11*1./(1_MeV), 0, -5.43295757382818289e-08*1./(1_MeV), -3.13730541114924775e-09*1./(1_MeV), 2.52804058098014408e-09*1./(1_MeV), -2.20941594381711364e-11*1./(1_MeV), 7.74676017778475057e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform106;
- ActsSymMatrixD<3> rotMat106;
- rotMat106 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform106.rotate(rotMat106);
- transform106.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans106 = std::make_shared<const Transform3D>(transform106);
- std::shared_ptr<PerigeeSurface> perigeeSurface106 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams106 = BoundParameters(tgContext, std::move(covMat106), params106, perigeeSurface106);
- tracks.push_back(boundParams106);
-
-
- // track 107 :
- BoundVector params107;
- params107 << 0.360552132129669189, 18.9798069000244141, 2.17705512046813965, 2.95739436149597168, 0.000170226237969473004*1./(1_MeV), 0;
- Covariance covMat107;
- covMat107 << 0.0202916935086250305, 0.000201601632849784387, -0.000616325805420407701, 1.09389603440618418e-07, -2.32012673409599967e-07*1./(1_MeV), 0, 0.000201601632849784387, 0.596419632434844971, 3.27955063214520708e-05, 0.00059099745368901811, 1.02858367938844465e-08*1./(1_MeV), 0, -0.000616325805420407701, 3.27955063214520708e-05, 1.91301714949076995e-05, 3.16951153463901935e-08, 1.15949223809287544e-08*1./(1_MeV), 0, 1.09389603440618418e-07, 0.00059099745368901811, 3.16951153463901935e-08, 5.92274261634884169e-07, -2.37559850171720801e-12*1./(1_MeV), 0, -2.32012673409599967e-07*1./(1_MeV), 1.02858367938844465e-08*1./(1_MeV), 1.15949223809287544e-08*1./(1_MeV), -2.37559850171720801e-12*1./(1_MeV), 8.54574952469100424e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform107;
- ActsSymMatrixD<3> rotMat107;
- rotMat107 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform107.rotate(rotMat107);
- transform107.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans107 = std::make_shared<const Transform3D>(transform107);
- std::shared_ptr<PerigeeSurface> perigeeSurface107 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams107 = BoundParameters(tgContext, std::move(covMat107), params107, perigeeSurface107);
- tracks.push_back(boundParams107);
-
-
- // track 108 :
- BoundVector params108;
- params108 << -0.0385420434176921844, 19.8494167327880859, -2.91224813461303711, 0.434279114007949829, 0.000344612402841448784*1./(1_MeV), 0;
- Covariance covMat108;
- covMat108 << 0.00708283483982086182, -0.000290315453926490662, -0.000208821270084330699, -4.36274591953509495e-07, -2.0634328653756119e-07*1./(1_MeV), 0, -0.000290315453926490662, 0.0554034896194934845, 1.79575900534169211e-06, 0.000262110253474558965, 1.13649321255499376e-08*1./(1_MeV), 0, -0.000208821270084330699, 1.79575900534169211e-06, 6.40597681922372431e-06, -1.62866970452031225e-08, 9.99126779944540941e-09*1./(1_MeV), 0, -4.36274591953509495e-07, 0.000262110253474558965, -1.62866970452031225e-08, 1.29895113332167966e-06, 3.16671471384196928e-11*1./(1_MeV), 0, -2.0634328653756119e-07*1./(1_MeV), 1.13649321255499376e-08*1./(1_MeV), 9.99126779944540941e-09*1./(1_MeV), 3.16671471384196928e-11*1./(1_MeV), 1.64341207309348647e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform108;
- ActsSymMatrixD<3> rotMat108;
- rotMat108 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform108.rotate(rotMat108);
- transform108.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans108 = std::make_shared<const Transform3D>(transform108);
- std::shared_ptr<PerigeeSurface> perigeeSurface108 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams108 = BoundParameters(tgContext, std::move(covMat108), params108, perigeeSurface108);
- tracks.push_back(boundParams108);
-
-
- // track 109 :
- BoundVector params109;
- params109 << -0.0989816188812255859, 19.6172981262207031, -2.41140604019165039, 0.801270425319671631, -0.000793451210483908653*1./(1_MeV), 0;
- Covariance covMat109;
- covMat109 << 0.00786646455526351929, -0.000344219331520010437, -0.000221645718673196959, -4.14245788496836856e-06, -1.37193307846517797e-07*1./(1_MeV), 0, -0.000344219331520010437, 0.0273069571703672409, 1.18374970750359077e-05, 0.000350145532022221365, 2.43323438271879911e-09*1./(1_MeV), 0, -0.000221645718673196959, 1.18374970750359077e-05, 6.48815375825506635e-06, 1.56811599604059021e-07, 6.52184431015660127e-09*1./(1_MeV), 0, -4.14245788496836856e-06, 0.000350145532022221365, 1.56811599604059021e-07, 4.93106381327379495e-06, 2.39307717698818543e-11*1./(1_MeV), 0, -1.37193307846517797e-07*1./(1_MeV), 2.43323438271879911e-09*1./(1_MeV), 6.52184431015660127e-09*1./(1_MeV), 2.39307717698818543e-11*1./(1_MeV), 1.82697898476469334e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform109;
- ActsSymMatrixD<3> rotMat109;
- rotMat109 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform109.rotate(rotMat109);
- transform109.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans109 = std::make_shared<const Transform3D>(transform109);
- std::shared_ptr<PerigeeSurface> perigeeSurface109 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams109 = BoundParameters(tgContext, std::move(covMat109), params109, perigeeSurface109);
- tracks.push_back(boundParams109);
-
-
- // track 110 :
- BoundVector params110;
- params110 << -0.248047471046447754, 19.6557636260986328, 2.29302573204040527, 0.649587929248809814, -0.00110239081550389528*1./(1_MeV), 0;
- Covariance covMat110;
- covMat110 << 0.0216166544705629349, -0.00082482405910012024, -0.000652860285832565414, -1.02919032841101398e-05, -6.52212657639859215e-07*1./(1_MeV), 0, -0.00082482405910012024, 0.0853162780404090881, 4.15812377535581474e-05, 0.000839477999853416139, 1.85719368884111095e-11*1./(1_MeV), 0, -0.000652860285832565414, 4.15812377535581474e-05, 2.00744616449810565e-05, 4.89128117113744387e-07, 3.10100339064501893e-08*1./(1_MeV), 0, -1.02919032841101398e-05, 0.000839477999853416139, 4.89128117113744387e-07, 8.57177292346023023e-06, 1.97141912126868163e-11*1./(1_MeV), 0, -6.52212657639859215e-07*1./(1_MeV), 1.85719368884111095e-11*1./(1_MeV), 3.10100339064501893e-08*1./(1_MeV), 1.97141912126868163e-11*1./(1_MeV), 7.19949988514656525e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform110;
- ActsSymMatrixD<3> rotMat110;
- rotMat110 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform110.rotate(rotMat110);
- transform110.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans110 = std::make_shared<const Transform3D>(transform110);
- std::shared_ptr<PerigeeSurface> perigeeSurface110 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams110 = BoundParameters(tgContext, std::move(covMat110), params110, perigeeSurface110);
- tracks.push_back(boundParams110);
-
-
- // track 111 :
- BoundVector params111;
- params111 << 0.0262720081955194473, 19.8286037445068359, 2.18146443367004395, 2.08324813842773438, 0.000428368948632851243*1./(1_MeV), 0;
- Covariance covMat111;
- covMat111 << 0.00158816727343946695, 9.4853627735629324e-06, -4.36409249479155706e-05, -1.48995811754545918e-07, -2.02757518900558508e-08*1./(1_MeV), 0, 9.4853627735629324e-06, 0.0110956495627760887, 3.27586912949563326e-07, 0.000130563462425678848, -4.16497402962450788e-09*1./(1_MeV), 0, -4.36409249479155706e-05, 3.27586912949563326e-07, 1.24739369766757591e-06, 1.17262448099841417e-08, 8.7129027760781156e-10*1./(1_MeV), 0, -1.48995811754545918e-07, 0.000130563462425678848, 1.17262448099841417e-08, 2.20083074964350089e-06, -2.28033377013702109e-11*1./(1_MeV), 0, -2.02757518900558508e-08*1./(1_MeV), -4.16497402962450788e-09*1./(1_MeV), 8.7129027760781156e-10*1./(1_MeV), -2.28033377013702109e-11*1./(1_MeV), 2.59175268052524999e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform111;
- ActsSymMatrixD<3> rotMat111;
- rotMat111 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform111.rotate(rotMat111);
- transform111.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans111 = std::make_shared<const Transform3D>(transform111);
- std::shared_ptr<PerigeeSurface> perigeeSurface111 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams111 = BoundParameters(tgContext, std::move(covMat111), params111, perigeeSurface111);
- tracks.push_back(boundParams111);
-
-
- // track 112 :
- BoundVector params112;
- params112 << 0.0326793268322944641, 19.8120479583740234, 0.889699041843414307, 1.57646119594573975, -0.000467951031168922782*1./(1_MeV), 0;
- Covariance covMat112;
- covMat112 << 0.0013444551732391119, -1.04196358259948499e-06, -3.51593985940863599e-05, -1.51435614902372445e-08, -2.03697874567189654e-08*1./(1_MeV), 0, -1.04196358259948499e-06, 0.0113611593842506409, 2.86736734379056518e-08, 0.000153356229013592134, 1.41074638188641834e-10*1./(1_MeV), 0, -3.51593985940863599e-05, 2.86736734379056518e-08, 9.62528019954334013e-07, 3.04792415524836218e-10, 8.65383902854664365e-10*1./(1_MeV), 0, -1.51435614902372445e-08, 0.000153356229013592134, 3.04792415524836218e-10, 3.0196767966117477e-06, -4.83286461545659302e-12*1./(1_MeV), 0, -2.03697874567189654e-08*1./(1_MeV), 1.41074638188641834e-10*1./(1_MeV), 8.65383902854664365e-10*1./(1_MeV), -4.83286461545659302e-12*1./(1_MeV), 2.99355089328212642e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform112;
- ActsSymMatrixD<3> rotMat112;
- rotMat112 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform112.rotate(rotMat112);
- transform112.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans112 = std::make_shared<const Transform3D>(transform112);
- std::shared_ptr<PerigeeSurface> perigeeSurface112 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams112 = BoundParameters(tgContext, std::move(covMat112), params112, perigeeSurface112);
- tracks.push_back(boundParams112);
-
-
- // track 113 :
- BoundVector params113;
- params113 << 0.0479989089071750641, 19.5348949432373047, -1.84289538860321045, 2.54763102531433105, -0.000563078676350414753*1./(1_MeV), 0;
- Covariance covMat113;
- covMat113 << 0.00674024224281311035, 0.000275261902324333151, -0.000202055961074877318, 2.83455165085094845e-06, -8.66185543146518417e-08*1./(1_MeV), 0, 0.000275261902324333151, 0.0429738685488700867, -1.16714247102508588e-05, 0.000340657623151467128, -1.21201365712005428e-09*1./(1_MeV), 0, -0.000202055961074877318, -1.16714247102508588e-05, 6.1798982642358169e-06, -1.17638099338652864e-07, 4.25805894898182396e-09*1./(1_MeV), 0, 2.83455165085094845e-06, 0.000340657623151467128, -1.17638099338652864e-07, 2.85863870885805227e-06, -1.98763016529320121e-11*1./(1_MeV), 0, -8.66185543146518417e-08*1./(1_MeV), -1.21201365712005428e-09*1./(1_MeV), 4.25805894898182396e-09*1./(1_MeV), -1.98763016529320121e-11*1./(1_MeV), 9.45928058104783531e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform113;
- ActsSymMatrixD<3> rotMat113;
- rotMat113 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform113.rotate(rotMat113);
- transform113.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans113 = std::make_shared<const Transform3D>(transform113);
- std::shared_ptr<PerigeeSurface> perigeeSurface113 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams113 = BoundParameters(tgContext, std::move(covMat113), params113, perigeeSurface113);
- tracks.push_back(boundParams113);
-
-
- // track 114 :
- BoundVector params114;
- params114 << -0.166889190673828125, 19.049163818359375, 2.00572776794433594, 2.98232221603393555, -5.11993312102276832e-05*1./(1_MeV), 0;
- Covariance covMat114;
- covMat114 << 0.00352242938242852688, 0.000933588696445512324, -0.000101630702391713315, 5.56225575687583112e-07, -4.72569998214100291e-08*1./(1_MeV), 0, 0.000933588696445512324, 0.140665516257286072, -2.55878928890533955e-05, 9.91245475972232033e-05, -4.82721694350305098e-09*1./(1_MeV), 0, -0.000101630702391713315, -2.55878928890533955e-05, 3.07548725686501712e-06, -1.60878195926674544e-08, 2.32450177496049771e-09*1./(1_MeV), 0, 5.56225575687583112e-07, 9.91245475972232033e-05, -1.60878195926674544e-08, 7.18341084393614437e-08, -2.32272171088200988e-12*1./(1_MeV), 0, -4.72569998214100291e-08*1./(1_MeV), -4.82721694350305098e-09*1./(1_MeV), 2.32450177496049771e-09*1./(1_MeV), -2.32272171088200988e-12*1./(1_MeV), 1.44301818758019174e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform114;
- ActsSymMatrixD<3> rotMat114;
- rotMat114 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform114.rotate(rotMat114);
- transform114.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans114 = std::make_shared<const Transform3D>(transform114);
- std::shared_ptr<PerigeeSurface> perigeeSurface114 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams114 = BoundParameters(tgContext, std::move(covMat114), params114, perigeeSurface114);
- tracks.push_back(boundParams114);
-
-
- // track 115 :
- BoundVector params115;
- params115 << 0.0137746464461088181, 19.6609287261962891, 2.67169976234436035, 1.68737459182739258, -0.000312122545437887311*1./(1_MeV), 0;
- Covariance covMat115;
- covMat115 << 0.00205370550975203514, 2.57276641361198506e-05, -4.35124207927626197e-05, 2.05754998361759643e-07, -7.68677673940147419e-09*1./(1_MeV), 0, 2.57276641361198506e-05, 0.00751006556674838066, -5.60196307230371148e-07, 0.000104370906596587887, -2.31954884204932396e-09*1./(1_MeV), 0, -4.35124207927626197e-05, -5.60196307230371148e-07, 9.7233169071841985e-07, -5.78757716049063737e-09, 3.21560072675208627e-10*1./(1_MeV), 0, 2.05754998361759643e-07, 0.000104370906596587887, -5.78757716049063737e-09, 2.29740794566168915e-06, -4.91169097872738332e-11*1./(1_MeV), 0, -7.68677673940147419e-09*1./(1_MeV), -2.31954884204932396e-09*1./(1_MeV), 3.21560072675208627e-10*1./(1_MeV), -4.91169097872738332e-11*1./(1_MeV), 1.16981858228060176e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform115;
- ActsSymMatrixD<3> rotMat115;
- rotMat115 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform115.rotate(rotMat115);
- transform115.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans115 = std::make_shared<const Transform3D>(transform115);
- std::shared_ptr<PerigeeSurface> perigeeSurface115 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams115 = BoundParameters(tgContext, std::move(covMat115), params115, perigeeSurface115);
- tracks.push_back(boundParams115);
-
-
- // track 116 :
- BoundVector params116;
- params116 << 1.04568362236022949, 19.1366863250732422, 2.12020516395568848, 2.92311358451843262, 9.25068379729054868e-05*1./(1_MeV), 0;
- Covariance covMat116;
- covMat116 << 0.00488254847005009651, 0.000740361421888004493, -0.00013463378504927599, 1.2158197600630495e-06, -3.36609027457528485e-08*1./(1_MeV), 0, 0.000740361421888004493, 0.114923417568206787, -8.05991571412841247e-06, 0.000146249036050893433, 4.20761461930579654e-09*1./(1_MeV), 0, -0.00013463378504927599, -8.05991571412841247e-06, 3.85931298296782188e-06, -2.17580929998134164e-08, 1.60649110182894787e-09*1./(1_MeV), 0, 1.2158197600630495e-06, 0.000146249036050893433, -2.17580929998134164e-08, 1.92376987229181395e-07, -2.78492110134724017e-12*1./(1_MeV), 0, -3.36609027457528485e-08*1./(1_MeV), 4.20761461930579654e-09*1./(1_MeV), 1.60649110182894787e-09*1./(1_MeV), -2.78492110134724017e-12*1./(1_MeV), 1.35187555594384889e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform116;
- ActsSymMatrixD<3> rotMat116;
- rotMat116 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform116.rotate(rotMat116);
- transform116.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans116 = std::make_shared<const Transform3D>(transform116);
- std::shared_ptr<PerigeeSurface> perigeeSurface116 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams116 = BoundParameters(tgContext, std::move(covMat116), params116, perigeeSurface116);
- tracks.push_back(boundParams116);
-
-
- // track 117 :
- BoundVector params117;
- params117 << -1.20940804481506348, 19.6823959350585938, -1.81289887428283691, 0.625804603099822998, 0.000932577764615416527*1./(1_MeV), 0;
- Covariance covMat117;
- covMat117 << 0.0626278072595596313, -0.00168264653846623741, -0.00141945234148735475, 1.67458965126927841e-05, -7.54246802546992556e-07*1./(1_MeV), 0, -0.00168264653846623741, 0.230180084705352783, -2.73170868898178382e-06, 0.00158152202219789709, 6.02409280618631771e-08*1./(1_MeV), 0, -0.00141945234148735475, -2.73170868898178382e-06, 3.37690398737322539e-05, -7.02785129344153319e-07, 2.29061226487353007e-08*1./(1_MeV), 0, 1.67458965126927841e-05, 0.00158152202219789709, -7.02785129344153319e-07, 1.19483884191140532e-05, 4.05549492337246129e-12*1./(1_MeV), 0, -7.54246802546992556e-07*1./(1_MeV), 6.02409280618631771e-08*1./(1_MeV), 2.29061226487353007e-08*1./(1_MeV), 4.05549492337246129e-12*1./(1_MeV), 3.22085941251160079e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform117;
- ActsSymMatrixD<3> rotMat117;
- rotMat117 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform117.rotate(rotMat117);
- transform117.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans117 = std::make_shared<const Transform3D>(transform117);
- std::shared_ptr<PerigeeSurface> perigeeSurface117 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams117 = BoundParameters(tgContext, std::move(covMat117), params117, perigeeSurface117);
- tracks.push_back(boundParams117);
-
-
- // track 118 :
- BoundVector params118;
- params118 << -0.103346407413482666, 19.7446269989013672, -1.91661596298217773, 1.42171478271484375, 0.000703335157595574856*1./(1_MeV), 0;
- Covariance covMat118;
- covMat118 << 0.00270943623036146164, -1.17879856763720662e-06, -7.38598630680866423e-05, 3.22994399828456964e-07, -4.07104504838410184e-08*1./(1_MeV), 0, -1.17879856763720662e-06, 0.0154081536456942558, -2.72538651083495857e-07, 0.000256186705875633325, 6.87005786986738928e-09*1./(1_MeV), 0, -7.38598630680866423e-05, -2.72538651083495857e-07, 2.10873281503154431e-06, -1.4483024887950514e-08, 1.8152406999218687e-09*1./(1_MeV), 0, 3.22994399828456964e-07, 0.000256186705875633325, -1.4483024887950514e-08, 5.78958861296996474e-06, 9.80498638799178923e-11*1./(1_MeV), 0, -4.07104504838410184e-08*1./(1_MeV), 6.87005786986738928e-09*1./(1_MeV), 1.8152406999218687e-09*1./(1_MeV), 9.80498638799178923e-11*1./(1_MeV), 6.60063531610077803e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform118;
- ActsSymMatrixD<3> rotMat118;
- rotMat118 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform118.rotate(rotMat118);
- transform118.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans118 = std::make_shared<const Transform3D>(transform118);
- std::shared_ptr<PerigeeSurface> perigeeSurface118 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams118 = BoundParameters(tgContext, std::move(covMat118), params118, perigeeSurface118);
- tracks.push_back(boundParams118);
-
-
- // track 119 :
- BoundVector params119;
- params119 << 2.92615675926208496, 17.8650016784667969, -1.95857036113739014, 1.128387451171875, 0.00111896148882806301*1./(1_MeV), 0;
- Covariance covMat119;
- covMat119 << 0.0144027825444936752, 0.000621878947040222689, -0.0004899059955729096, 7.73510238988940677e-07, -5.53971455935470655e-06*1./(1_MeV), 0, 0.000621878947040222689, 0.025294894352555275, -2.52380243351548066e-05, 0.000523347752496337772, -2.67676038791141531e-07*1./(1_MeV), 0, -0.0004899059955729096, -2.52380243351548066e-05, 1.7668540749582462e-05, -8.13551792131595242e-08, 2.65852444971337825e-07*1./(1_MeV), 0, 7.73510238988940677e-07, 0.000523347752496337772, -8.13551792131595242e-08, 1.16607652671518736e-05, 1.44441837008855634e-09*1./(1_MeV), 0, -5.53971455935470655e-06*1./(1_MeV), -2.67676038791141531e-07*1./(1_MeV), 2.65852444971337825e-07*1./(1_MeV), 1.44441837008855634e-09*1./(1_MeV), 9.32011001708588083e-09*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform119;
- ActsSymMatrixD<3> rotMat119;
- rotMat119 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform119.rotate(rotMat119);
- transform119.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans119 = std::make_shared<const Transform3D>(transform119);
- std::shared_ptr<PerigeeSurface> perigeeSurface119 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams119 = BoundParameters(tgContext, std::move(covMat119), params119, perigeeSurface119);
- tracks.push_back(boundParams119);
-
-
- // track 120 :
- BoundVector params120;
- params120 << -0.0391223952174186707, 19.8085842132568359, -1.63484728336334229, 1.43253195285797119, 0.00101388362236320972*1./(1_MeV), 0;
- Covariance covMat120;
- covMat120 << 0.00591104757040739059, 2.19808179401814768e-05, -0.000175305312354405934, 9.33348192222842228e-07, -8.2119913789129893e-08*1./(1_MeV), 0, 2.19808179401814768e-05, 0.0155321685597300529, -1.19100607880362392e-06, 0.000313805117109273242, -4.29338952794729048e-09*1./(1_MeV), 0, -0.000175305312354405934, -1.19100607880362392e-06, 5.27355723534128629e-06, -3.99720907755572675e-08, 3.63588214025051008e-09*1./(1_MeV), 0, 9.33348192222842228e-07, 0.000313805117109273242, -3.99720907755572675e-08, 7.98895416664890945e-06, -7.83235112558509684e-11*1./(1_MeV), 0, -8.2119913789129893e-08*1./(1_MeV), -4.29338952794729048e-09*1./(1_MeV), 3.63588214025051008e-09*1./(1_MeV), -7.83235112558509684e-11*1./(1_MeV), 1.22159560245194143e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform120;
- ActsSymMatrixD<3> rotMat120;
- rotMat120 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform120.rotate(rotMat120);
- transform120.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans120 = std::make_shared<const Transform3D>(transform120);
- std::shared_ptr<PerigeeSurface> perigeeSurface120 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams120 = BoundParameters(tgContext, std::move(covMat120), params120, perigeeSurface120);
- tracks.push_back(boundParams120);
-
-
- // track 121 :
- BoundVector params121;
- params121 << 3.2684485912322998, -50.3953475952148438, -1.9672924280166626, 2.11276745796203613, -0.00146105431485921144*1./(1_MeV), 0;
- Covariance covMat121;
- covMat121 << 0.0276485588401556015, -0.00123167623434729842, -0.000845118835855476042, 1.50004803399650862e-05, -1.34122397572779639e-07*1./(1_MeV), 0, -0.00123167623434729842, 0.0636397004127502441, 2.49535016337183792e-05, 0.00133656416735393577, -2.37478957538643704e-08*1./(1_MeV), 0, -0.000845118835855476042, 2.49535016337183792e-05, 2.60623473877785727e-05, -7.59009162244489968e-07, 7.34075798768037725e-09*1./(1_MeV), 0, 1.50004803399650862e-05, 0.00133656416735393577, -7.59009162244489968e-07, 2.95604022539919242e-05, -8.85865579693641169e-10*1./(1_MeV), 0, -1.34122397572779639e-07*1./(1_MeV), -2.37478957538643704e-08*1./(1_MeV), 7.34075798768037725e-09*1./(1_MeV), -8.85865579693641169e-10*1./(1_MeV), 2.87734891468716114e-10*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform121;
- ActsSymMatrixD<3> rotMat121;
- rotMat121 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform121.rotate(rotMat121);
- transform121.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans121 = std::make_shared<const Transform3D>(transform121);
- std::shared_ptr<PerigeeSurface> perigeeSurface121 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams121 = BoundParameters(tgContext, std::move(covMat121), params121, perigeeSurface121);
- tracks.push_back(boundParams121);
-
-
- // track 122 :
- BoundVector params122;
- params122 << 0.645450115203857422, 28.7973823547363281, 2.10054993629455566, 2.9601600170135498, -0.000159988034283742309*1./(1_MeV), 0;
- Covariance covMat122;
- covMat122 << 0.0836148038506507874, -0.00281942085938153468, -0.00185879864445105355, 6.07247514248449154e-06, -7.03189829531797196e-07*1./(1_MeV), 0, -0.00281942085938153468, 2.70882201194763184, -5.8760191905531437e-05, 0.00188818417948824089, -4.8300783514351801e-08*1./(1_MeV), 0, -0.00185879864445105355, -5.8760191905531437e-05, 4.32657325291074812e-05, -2.25070179677390569e-07, 2.13601337599813795e-08*1./(1_MeV), 0, 6.07247514248449154e-06, 0.00188818417948824089, -2.25070179677390569e-07, 1.36935625505429925e-06, -1.00269941249161656e-10*1./(1_MeV), 0, -7.03189829531797196e-07*1./(1_MeV), -4.8300783514351801e-08*1./(1_MeV), 2.13601337599813795e-08*1./(1_MeV), -1.00269941249161656e-10*1./(1_MeV), 9.22178722273514495e-11*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform122;
- ActsSymMatrixD<3> rotMat122;
- rotMat122 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform122.rotate(rotMat122);
- transform122.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans122 = std::make_shared<const Transform3D>(transform122);
- std::shared_ptr<PerigeeSurface> perigeeSurface122 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams122 = BoundParameters(tgContext, std::move(covMat122), params122, perigeeSurface122);
- tracks.push_back(boundParams122);
-
-
- // track 123 :
- BoundVector params123;
- params123 << -0.260677635669708252, 19.68109130859375, -0.0893123745918273926, 2.24275779724121094, 0.000180564093170687556*1./(1_MeV), 0;
- Covariance covMat123;
- covMat123 << 0.00429143151268362999, -0.000282303309317850546, -5.84570627457094727e-05, -1.77592772045934701e-06, -5.25916079357569643e-08*1./(1_MeV), 0, -0.000282303309317850546, 0.0253302454948425293, 3.20487213205718757e-06, 0.00012674431483371596, 5.10278523593403899e-09*1./(1_MeV), 0, -5.84570627457094727e-05, 3.20487213205718757e-06, 9.13998974283458665e-07, 2.36155606611666679e-08, 8.36921112357011164e-10*1./(1_MeV), 0, -1.77592772045934701e-06, 0.00012674431483371596, 2.36155606611666679e-08, 9.15854911909264047e-07, 4.54410066110091468e-11*1./(1_MeV), 0, -5.25916079357569643e-08*1./(1_MeV), 5.10278523593403899e-09*1./(1_MeV), 8.36921112357011164e-10*1./(1_MeV), 4.54410066110091468e-11*1./(1_MeV), 8.13594937948414199e-12*1./(1_MeV), 0, 0, 0, 0, 0, 0, 1;
- Transform3D transform123;
- ActsSymMatrixD<3> rotMat123;
- rotMat123 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
- transform123.rotate(rotMat123);
- transform123.translation() = Vector3D(-0.5,-0.5,0);
- auto sharedTrans123 = std::make_shared<const Transform3D>(transform123);
- std::shared_ptr<PerigeeSurface> perigeeSurface123 = Surface::makeShared<PerigeeSurface>(Vector3D(-0.5,-0.5,0));
- auto boundParams123 = BoundParameters(tgContext, std::move(covMat123), params123, perigeeSurface123);
- tracks.push_back(boundParams123);
-
-return tracks;
-
+std::vector<BoundParameters> getAthenaTracks() {
+  std::vector<BoundParameters> tracks;
+
+  // track 0 :
+  BoundVector params0;
+  params0 << -0.0189610905945301056, 19.2891330718994141, -1.72937667369842529,
+      0.245648413896560669, 0.000139094627229496837 * 1. / (1_MeV), 0;
+  Covariance covMat0;
+  covMat0 << 0.0234750192612409592, -0.00781442524684276309,
+      -0.000530674182045025289, -8.29588870144685228e-06,
+      -9.34183350654419714e-08 * 1. / (1_MeV), 0, -0.00781442524684276309,
+      0.406355828046798706, 0.000142553526286719813, 0.000532610276843647709,
+      2.47911983155666744e-08 * 1. / (1_MeV), 0, -0.000530674182045025289,
+      0.000142553526286719813, 1.25120022858027369e-05, 1.45461672177318258e-07,
+      3.16496658346130268e-09 * 1. / (1_MeV), 0, -8.29588870144685228e-06,
+      0.000532610276843647709, 1.45461672177318258e-07, 7.28171983155334601e-07,
+      2.62386697279164045e-11 * 1. / (1_MeV), 0,
+      -9.34183350654419714e-08 * 1. / (1_MeV),
+      2.47911983155666744e-08 * 1. / (1_MeV),
+      3.16496658346130268e-09 * 1. / (1_MeV),
+      2.62386697279164045e-11 * 1. / (1_MeV),
+      2.09531125089368331e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform0;
+  ActsSymMatrixD<3> rotMat0;
+  rotMat0 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform0.rotate(rotMat0);
+  transform0.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans0 = std::make_shared<const Transform3D>(transform0);
+  std::shared_ptr<PerigeeSurface> perigeeSurface0 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams0 =
+      BoundParameters(tgContext, std::move(covMat0), params0, perigeeSurface0);
+  tracks.push_back(boundParams0);
+
+  // track 1 :
+  BoundVector params1;
+  params1 << 0.237322136759757996, 18.9474124908447266, 2.77435874938964844,
+      0.221098631620407104, 0.000243303977185860276 * 1. / (1_MeV), 0;
+  Covariance covMat1;
+  covMat1 << 0.0224881023168563843, -0.00123628927370857643,
+      -0.000682571853275380021, -5.08470990346168592e-07,
+      -1.65987991328505037e-07 * 1. / (1_MeV), 0, -0.00123628927370857643,
+      0.486606210470199585, -1.26428790915631958e-05, 0.000691189647290967285,
+      8.49211598605589898e-10 * 1. / (1_MeV), 0, -0.000682571853275380021,
+      -1.26428790915631958e-05, 2.10596499528037384e-05,
+      -4.86598776586506401e-08, 8.07036236689827024e-09 * 1. / (1_MeV), 0,
+      -5.08470990346168592e-07, 0.000691189647290967285,
+      -4.86598776586506401e-08, 9.96780613604641985e-07,
+      2.84880592793454068e-12 * 1. / (1_MeV), 0,
+      -1.65987991328505037e-07 * 1. / (1_MeV),
+      8.49211598605589898e-10 * 1. / (1_MeV),
+      8.07036236689827024e-09 * 1. / (1_MeV),
+      2.84880592793454068e-12 * 1. / (1_MeV),
+      6.98227170525811403e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform1;
+  ActsSymMatrixD<3> rotMat1;
+  rotMat1 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform1.rotate(rotMat1);
+  transform1.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans1 = std::make_shared<const Transform3D>(transform1);
+  std::shared_ptr<PerigeeSurface> perigeeSurface1 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams1 =
+      BoundParameters(tgContext, std::move(covMat1), params1, perigeeSurface1);
+  tracks.push_back(boundParams1);
+
+  // track 2 :
+  BoundVector params2;
+  params2 << -0.274762749671936035, 19.3189582824707031, 2.51834297180175781,
+      0.247050970792770386, -0.000262395391473546624 * 1. / (1_MeV), 0;
+  Covariance covMat2;
+  covMat2 << 0.0190738625824451447, -0.0017057542844459892,
+      -0.000571975485803314851, -2.82570644125376289e-06,
+      -1.61839967616137892e-07 * 1. / (1_MeV), 0, -0.0017057542844459892,
+      0.321801245212554932, 6.65458853740041401e-05, 0.000567742814929668329,
+      5.31432764738237606e-09 * 1. / (1_MeV), 0, -0.000571975485803314851,
+      6.65458853740041401e-05, 1.75108507391996682e-05, 1.16541064423600983e-07,
+      8.10714233373920505e-09 * 1. / (1_MeV), 0, -2.82570644125376289e-06,
+      0.000567742814929668329, 1.16541064423600983e-07, 1.01647879091615323e-06,
+      1.7840055165615784e-12 * 1. / (1_MeV), 0,
+      -1.61839967616137892e-07 * 1. / (1_MeV),
+      5.31432764738237606e-09 * 1. / (1_MeV),
+      8.10714233373920505e-09 * 1. / (1_MeV),
+      1.7840055165615784e-12 * 1. / (1_MeV),
+      7.92840237906489165e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform2;
+  ActsSymMatrixD<3> rotMat2;
+  rotMat2 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform2.rotate(rotMat2);
+  transform2.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans2 = std::make_shared<const Transform3D>(transform2);
+  std::shared_ptr<PerigeeSurface> perigeeSurface2 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams2 =
+      BoundParameters(tgContext, std::move(covMat2), params2, perigeeSurface2);
+  tracks.push_back(boundParams2);
+
+  // track 3 :
+  BoundVector params3;
+  params3 << 0.0235438384115695953, 19.7655830383300781, -0.159107863903045654,
+      2.30990958213806152, -0.000119360782264266163 * 1. / (1_MeV), 0;
+  Covariance covMat3;
+  covMat3 << 0.000361772050382569432, 2.72739909974600519e-05,
+      -8.21723450836043464e-06, 1.34126350783550678e-07,
+      -5.88422825741122636e-09 * 1. / (1_MeV), 0, 2.72739909974600519e-05,
+      0.00511974841356277466, -6.21331210701952311e-07, 3.10034413370417763e-05,
+      -6.86043367956819384e-09 * 1. / (1_MeV), 0, -8.21723450836043464e-06,
+      -6.21331210701952311e-07, 2.07281985353802156e-07,
+      -3.88590354998360268e-09, 2.03791573108340031e-10 * 1. / (1_MeV), 0,
+      1.34126350783550678e-07, 3.10034413370417763e-05,
+      -3.88590354998360268e-09, 3.01585174611318507e-07,
+      -5.64498122454143072e-11 * 1. / (1_MeV), 0,
+      -5.88422825741122636e-09 * 1. / (1_MeV),
+      -6.86043367956819384e-09 * 1. / (1_MeV),
+      2.03791573108340031e-10 * 1. / (1_MeV),
+      -5.64498122454143072e-11 * 1. / (1_MeV),
+      4.42898885968934231e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform3;
+  ActsSymMatrixD<3> rotMat3;
+  rotMat3 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform3.rotate(rotMat3);
+  transform3.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans3 = std::make_shared<const Transform3D>(transform3);
+  std::shared_ptr<PerigeeSurface> perigeeSurface3 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams3 =
+      BoundParameters(tgContext, std::move(covMat3), params3, perigeeSurface3);
+  tracks.push_back(boundParams3);
+
+  // track 4 :
+  BoundVector params4;
+  params4 << -0.00997916609048843384, 19.6140289306640625, -1.86583328247070312,
+      1.16398906707763672, 4.13092784583568573e-05 * 1. / (1_MeV), 0;
+  Covariance covMat4;
+  covMat4 << 0.000111233675852417946, 6.24019899783590426e-06,
+      -1.51042179240653054e-06, -1.66343778016681362e-09,
+      -1.90252013322187688e-09 * 1. / (1_MeV), 0, 6.24019899783590426e-06,
+      0.00304781622253358364, -1.53697680009238848e-08, 2.11791743062638145e-05,
+      9.71456470695990042e-10 * 1. / (1_MeV), 0, -1.51042179240653054e-06,
+      -1.53697680009238848e-08, 2.65749235950352158e-08,
+      -5.72349441699598989e-10, 3.41166238038356917e-11 * 1. / (1_MeV), 0,
+      -1.66343778016681362e-09, 2.11791743062638145e-05,
+      -5.72349441699598989e-10, 2.91562628262909129e-07,
+      1.44429681183542297e-11 * 1. / (1_MeV), 0,
+      -1.90252013322187688e-09 * 1. / (1_MeV),
+      9.71456470695990042e-10 * 1. / (1_MeV),
+      3.41166238038356917e-11 * 1. / (1_MeV),
+      1.44429681183542297e-11 * 1. / (1_MeV),
+      4.11648986382504023e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform4;
+  ActsSymMatrixD<3> rotMat4;
+  rotMat4 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform4.rotate(rotMat4);
+  transform4.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans4 = std::make_shared<const Transform3D>(transform4);
+  std::shared_ptr<PerigeeSurface> perigeeSurface4 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams4 =
+      BoundParameters(tgContext, std::move(covMat4), params4, perigeeSurface4);
+  tracks.push_back(boundParams4);
+
+  // track 5 :
+  BoundVector params5;
+  params5 << 0.0375059135258197784, 19.6366806030273438, 2.80398750305175781,
+      1.33918941020965576, -0.00119000650011003017 * 1. / (1_MeV), 0;
+  Covariance covMat5;
+  covMat5 << 0.00557367224246263504, -3.50923298762731976e-05,
+      -0.00016505602825201958, -5.83055075084957149e-07,
+      -8.15374160823663551e-08 * 1. / (1_MeV), 0, -3.50923298762731976e-05,
+      0.0162126719951629639, 1.9925351112667154e-06, 0.000363090538840017685,
+      1.10231246314290943e-09 * 1. / (1_MeV), 0, -0.00016505602825201958,
+      1.9925351112667154e-06, 4.97896826345822774e-06, 4.42649583494026453e-08,
+      3.8207024978280266e-09 * 1. / (1_MeV), 0, -5.83055075084957149e-07,
+      0.000363090538840017685, 4.42649583494026453e-08, 9.3684120656689629e-06,
+      4.81602467249185851e-11 * 1. / (1_MeV), 0,
+      -8.15374160823663551e-08 * 1. / (1_MeV),
+      1.10231246314290943e-09 * 1. / (1_MeV),
+      3.8207024978280266e-09 * 1. / (1_MeV),
+      4.81602467249185851e-11 * 1. / (1_MeV),
+      1.40874742426966293e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform5;
+  ActsSymMatrixD<3> rotMat5;
+  rotMat5 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform5.rotate(rotMat5);
+  transform5.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans5 = std::make_shared<const Transform3D>(transform5);
+  std::shared_ptr<PerigeeSurface> perigeeSurface5 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams5 =
+      BoundParameters(tgContext, std::move(covMat5), params5, perigeeSurface5);
+  tracks.push_back(boundParams5);
+
+  // track 6 :
+  BoundVector params6;
+  params6 << 0.00140287447720766068, 19.7186660766601562, -2.14539408683776855,
+      1.24577629566192627, 0.000378551892936229706 * 1. / (1_MeV), 0;
+  Covariance covMat6;
+  covMat6 << 0.00101993023417890072, -2.6994413372851214e-05,
+      -2.65953182649328157e-05, 5.98774142459201546e-08,
+      -1.51924922955507223e-08 * 1. / (1_MeV), 0, -2.6994413372851214e-05,
+      0.00769689213484525681, 6.13944837413955775e-07, 9.60181177584976564e-05,
+      1.16782762059655835e-09 * 1. / (1_MeV), 0, -2.65953182649328157e-05,
+      6.13944837413955775e-07, 7.35107732907636091e-07,
+      -4.80302055565397552e-09, 6.05462078703657079e-10 * 1. / (1_MeV), 0,
+      5.98774142459201546e-08, 9.60181177584976564e-05,
+      -4.80302055565397552e-09, 1.77096819697908359e-06,
+      -3.67492839080036729e-12 * 1. / (1_MeV), 0,
+      -1.51924922955507223e-08 * 1. / (1_MeV),
+      1.16782762059655835e-09 * 1. / (1_MeV),
+      6.05462078703657079e-10 * 1. / (1_MeV),
+      -3.67492839080036729e-12 * 1. / (1_MeV),
+      1.91318193926148794e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform6;
+  ActsSymMatrixD<3> rotMat6;
+  rotMat6 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform6.rotate(rotMat6);
+  transform6.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans6 = std::make_shared<const Transform3D>(transform6);
+  std::shared_ptr<PerigeeSurface> perigeeSurface6 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams6 =
+      BoundParameters(tgContext, std::move(covMat6), params6, perigeeSurface6);
+  tracks.push_back(boundParams6);
+
+  // track 7 :
+  BoundVector params7;
+  params7 << -0.00329869543202221394, 19.6041259765625, -1.90649104118347168,
+      1.12304854393005371, 0.00014407877461053431 * 1. / (1_MeV), 0;
+  Covariance covMat7;
+  covMat7 << 0.00036740759969688952, 3.01680354122382919e-07,
+      -7.51521596509247467e-06, 1.21665930278402614e-07,
+      -5.43771801128259869e-09 * 1. / (1_MeV), 0, 3.01680354122382919e-07,
+      0.00500722508877515793, 1.33332939824832304e-07, 3.60641268279091357e-05,
+      -4.27847531573843138e-10 * 1. / (1_MeV), 0, -7.51521596509247467e-06,
+      1.33332939824832304e-07, 1.78475985990189656e-07, -3.2621585490043233e-09,
+      1.59847268857147475e-10 * 1. / (1_MeV), 0, 1.21665930278402614e-07,
+      3.60641268279091357e-05, -3.2621585490043233e-09, 5.36430661668418907e-07,
+      -1.24518107354747404e-11 * 1. / (1_MeV), 0,
+      -5.43771801128259869e-09 * 1. / (1_MeV),
+      -4.27847531573843138e-10 * 1. / (1_MeV),
+      1.59847268857147475e-10 * 1. / (1_MeV),
+      -1.24518107354747404e-11 * 1. / (1_MeV),
+      3.62822619170977134e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform7;
+  ActsSymMatrixD<3> rotMat7;
+  rotMat7 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform7.rotate(rotMat7);
+  transform7.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans7 = std::make_shared<const Transform3D>(transform7);
+  std::shared_ptr<PerigeeSurface> perigeeSurface7 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams7 =
+      BoundParameters(tgContext, std::move(covMat7), params7, perigeeSurface7);
+  tracks.push_back(boundParams7);
+
+  // track 8 :
+  BoundVector params8;
+  params8 << -0.00482689496129751205, 19.7954654693603516,
+      -0.0502131059765815735, 2.31073951721191406,
+      4.92803592351265252e-05 * 1. / (1_MeV), 0;
+  Covariance covMat8;
+  covMat8 << 0.0001803018240025267, 2.28634426988047736e-05,
+      -2.72005896920448914e-06, 9.76369038665024842e-08,
+      -3.00839639507890418e-09 * 1. / (1_MeV), 0, 2.28634426988047736e-05,
+      0.00448299339041113853, -1.94291028533954824e-07, 2.32848414810477441e-05,
+      -1.34362151935947653e-09 * 1. / (1_MeV), 0, -2.72005896920448914e-06,
+      -1.94291028533954824e-07, 5.47910268267060019e-08,
+      -7.01181814072448539e-10, 6.19209989023759561e-11 * 1. / (1_MeV), 0,
+      9.76369038665024842e-08, 2.32848414810477441e-05,
+      -7.01181814072448539e-10, 1.64913686262480041e-07,
+      -8.97362883139383566e-12 * 1. / (1_MeV), 0,
+      -3.00839639507890418e-09 * 1. / (1_MeV),
+      -1.34362151935947653e-09 * 1. / (1_MeV),
+      6.19209989023759561e-11 * 1. / (1_MeV),
+      -8.97362883139383566e-12 * 1. / (1_MeV),
+      9.50577724173617966e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform8;
+  ActsSymMatrixD<3> rotMat8;
+  rotMat8 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform8.rotate(rotMat8);
+  transform8.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans8 = std::make_shared<const Transform3D>(transform8);
+  std::shared_ptr<PerigeeSurface> perigeeSurface8 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams8 =
+      BoundParameters(tgContext, std::move(covMat8), params8, perigeeSurface8);
+  tracks.push_back(boundParams8);
+
+  // track 9 :
+  BoundVector params9;
+  params9 << -0.117531783878803253, 19.82318115234375, -1.45641529560089111,
+      2.29713797569274902, -0.00107527442742139101 * 1. / (1_MeV), 0;
+  Covariance covMat9;
+  covMat9 << 0.0109546398743987083, 0.000422247521285191226,
+      -0.000319963736434306643, 6.84778945643811993e-06,
+      -1.94063777029596808e-07 * 1. / (1_MeV), 0, 0.000422247521285191226,
+      0.038861934095621109, -1.73899586261722636e-05, 0.000539627280113898428,
+      -1.08021534013767774e-09 * 1. / (1_MeV), 0, -0.000319963736434306643,
+      -1.73899586261722636e-05, 9.59809040068648756e-06,
+      -2.82678258192879005e-07, 9.40666777698761478e-09 * 1. / (1_MeV), 0,
+      6.84778945643811993e-06, 0.000539627280113898428,
+      -2.82678258192879005e-07, 7.96383665147004649e-06,
+      -2.67210172465569124e-11 * 1. / (1_MeV), 0,
+      -1.94063777029596808e-07 * 1. / (1_MeV),
+      -1.08021534013767774e-09 * 1. / (1_MeV),
+      9.40666777698761478e-09 * 1. / (1_MeV),
+      -2.67210172465569124e-11 * 1. / (1_MeV),
+      2.76092482209833179e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform9;
+  ActsSymMatrixD<3> rotMat9;
+  rotMat9 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform9.rotate(rotMat9);
+  transform9.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans9 = std::make_shared<const Transform3D>(transform9);
+  std::shared_ptr<PerigeeSurface> perigeeSurface9 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams9 =
+      BoundParameters(tgContext, std::move(covMat9), params9, perigeeSurface9);
+  tracks.push_back(boundParams9);
+
+  // track 10 :
+  BoundVector params10;
+  params10 << -0.316214293241500854, 19.9858303070068359, 2.23136758804321289,
+      0.716844320297241211, 0.000286014255834743381 * 1. / (1_MeV), 0;
+  Covariance covMat10;
+  covMat10 << 0.00162444496527314186, -9.06142655681587962e-05,
+      -4.44249197781623932e-05, -1.8536710338487062e-07,
+      -2.67329728219464978e-08 * 1. / (1_MeV), 0, -9.06142655681587962e-05,
+      0.0111282505095005035, 1.36896327277162384e-06, 9.00038816992519377e-05,
+      1.26432483562719022e-09 * 1. / (1_MeV), 0, -4.44249197781623932e-05,
+      1.36896327277162384e-06, 1.26552151868963847e-06, -3.4175627468367298e-09,
+      1.15430331899061749e-09 * 1. / (1_MeV), 0, -1.8536710338487062e-07,
+      9.00038816992519377e-05, -3.4175627468367298e-09, 8.96049414222943597e-07,
+      -1.35745946999861844e-11 * 1. / (1_MeV), 0,
+      -2.67329728219464978e-08 * 1. / (1_MeV),
+      1.26432483562719022e-09 * 1. / (1_MeV),
+      1.15430331899061749e-09 * 1. / (1_MeV),
+      -1.35745946999861844e-11 * 1. / (1_MeV),
+      2.60673704843839005e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform10;
+  ActsSymMatrixD<3> rotMat10;
+  rotMat10 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform10.rotate(rotMat10);
+  transform10.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans10 = std::make_shared<const Transform3D>(transform10);
+  std::shared_ptr<PerigeeSurface> perigeeSurface10 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams10 = BoundParameters(tgContext, std::move(covMat10), params10,
+                                       perigeeSurface10);
+  tracks.push_back(boundParams10);
+
+  // track 11 :
+  BoundVector params11;
+  params11 << -0.026949150487780571, 19.7217216491699219, -1.88010013103485107,
+      1.17576122283935547, -5.31275982211809605e-05 * 1. / (1_MeV), 0;
+  Covariance covMat11;
+  covMat11 << 0.000139126204885542393, 7.52935130834812487e-06,
+      -2.04280921055376971e-06, 4.12883664132396972e-08,
+      -2.21097786141294125e-09 * 1. / (1_MeV), 0, 7.52935130834812487e-06,
+      0.00334829371422529221, -4.54681154865933769e-08, 2.39657209827402611e-05,
+      -7.07961483497201632e-10 * 1. / (1_MeV), 0, -2.04280921055376971e-06,
+      -4.54681154865933769e-08, 3.81113594016824209e-08,
+      -5.67025045849674143e-10, 4.41613819941043693e-11 * 1. / (1_MeV), 0,
+      4.12883664132396972e-08, 2.39657209827402611e-05,
+      -5.67025045849674143e-10, 2.3924027914290491e-07,
+      -7.29088756930822923e-12 * 1. / (1_MeV), 0,
+      -2.21097786141294125e-09 * 1. / (1_MeV),
+      -7.07961483497201632e-10 * 1. / (1_MeV),
+      4.41613819941043693e-11 * 1. / (1_MeV),
+      -7.29088756930822923e-12 * 1. / (1_MeV),
+      6.49562489300065105e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform11;
+  ActsSymMatrixD<3> rotMat11;
+  rotMat11 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform11.rotate(rotMat11);
+  transform11.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans11 = std::make_shared<const Transform3D>(transform11);
+  std::shared_ptr<PerigeeSurface> perigeeSurface11 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams11 = BoundParameters(tgContext, std::move(covMat11), params11,
+                                       perigeeSurface11);
+  tracks.push_back(boundParams11);
+
+  // track 12 :
+  BoundVector params12;
+  params12 << -0.0259521752595901489, 19.9042549133300781, 2.12977123260498047,
+      0.713346481323242188, 0.000183195850695483387 * 1. / (1_MeV), 0;
+  Covariance covMat12;
+  covMat12 << 0.000819464214146137238, -2.93160457001729501e-05,
+      -2.12643063322425127e-05, -1.06460388794225743e-07,
+      -1.83180521921403142e-08 * 1. / (1_MeV), 0, -2.93160457001729501e-05,
+      0.00743293715640902519, 3.1618179870268056e-07, 5.44865137200824102e-05,
+      1.28616095797583938e-09 * 1. / (1_MeV), 0, -2.12643063322425127e-05,
+      3.1618179870268056e-07, 5.87186036682396661e-07, -3.96810184286856466e-10,
+      7.64845470534257536e-10 * 1. / (1_MeV), 0, -1.06460388794225743e-07,
+      5.44865137200824102e-05, -3.96810184286856466e-10,
+      4.86239514430053532e-07, 2.28968063167242651e-12 * 1. / (1_MeV), 0,
+      -1.83180521921403142e-08 * 1. / (1_MeV),
+      1.28616095797583938e-09 * 1. / (1_MeV),
+      7.64845470534257536e-10 * 1. / (1_MeV),
+      2.28968063167242651e-12 * 1. / (1_MeV),
+      1.68847297254970385e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform12;
+  ActsSymMatrixD<3> rotMat12;
+  rotMat12 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform12.rotate(rotMat12);
+  transform12.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans12 = std::make_shared<const Transform3D>(transform12);
+  std::shared_ptr<PerigeeSurface> perigeeSurface12 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams12 = BoundParameters(tgContext, std::move(covMat12), params12,
+                                       perigeeSurface12);
+  tracks.push_back(boundParams12);
+
+  // track 13 :
+  BoundVector params13;
+  params13 << -0.108195297420024872, 19.4963741302490234, -1.54784798622131348,
+      2.76453542709350586, 0.000255180755630135536 * 1. / (1_MeV), 0;
+  Covariance covMat13;
+  covMat13 << 0.00656767562031745911, 0.000444740943016129486,
+      -0.000189528672096109756, 7.43444913558239102e-07,
+      -7.72608213653531881e-08 * 1. / (1_MeV), 0, 0.000444740943016129486,
+      0.0576510205864906311, -6.36114600490174744e-06, 0.000213140984352768603,
+      -5.47938491391429549e-09 * 1. / (1_MeV), 0, -0.000189528672096109756,
+      -6.36114600490174744e-06, 5.65102391192340292e-06,
+      -1.16009327799978898e-09, 3.63038358649066484e-09 * 1. / (1_MeV), 0,
+      7.43444913558239102e-07, 0.000213140984352768603,
+      -1.16009327799978898e-09, 8.20147363356227288e-07,
+      -1.16151818981247784e-11 * 1. / (1_MeV), 0,
+      -7.72608213653531881e-08 * 1. / (1_MeV),
+      -5.47938491391429549e-09 * 1. / (1_MeV),
+      3.63038358649066484e-09 * 1. / (1_MeV),
+      -1.16151818981247784e-11 * 1. / (1_MeV),
+      5.03207892021961811e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform13;
+  ActsSymMatrixD<3> rotMat13;
+  rotMat13 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform13.rotate(rotMat13);
+  transform13.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans13 = std::make_shared<const Transform3D>(transform13);
+  std::shared_ptr<PerigeeSurface> perigeeSurface13 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams13 = BoundParameters(tgContext, std::move(covMat13), params13,
+                                       perigeeSurface13);
+  tracks.push_back(boundParams13);
+
+  // track 14 :
+  BoundVector params14;
+  params14 << 0.00369392801076173782, 19.7586956024169922, -1.87617933750152588,
+      1.1225888729095459, -0.000320049060974270105 * 1. / (1_MeV), 0;
+  Covariance covMat14;
+  covMat14 << 0.000884613138623535633, -3.82952276847713579e-05,
+      -2.2559200610146105e-05, -2.935347589307322e-07,
+      -1.23401086351248597e-08 * 1. / (1_MeV), 0, -3.82952276847713579e-05,
+      0.00863977242261171341, 1.31139582148740249e-06, 8.32184382843871649e-05,
+      -2.57691337601532055e-09 * 1. / (1_MeV), 0, -2.2559200610146105e-05,
+      1.31139582148740249e-06, 6.16463069036399247e-07, 1.02756832396022202e-08,
+      4.91883875434775907e-10 * 1. / (1_MeV), 0, -2.935347589307322e-07,
+      8.32184382843871649e-05, 1.02756832396022202e-08, 1.14064482659159694e-06,
+      -1.29782130095271682e-11 * 1. / (1_MeV), 0,
+      -1.23401086351248597e-08 * 1. / (1_MeV),
+      -2.57691337601532055e-09 * 1. / (1_MeV),
+      4.91883875434775907e-10 * 1. / (1_MeV),
+      -1.29782130095271682e-11 * 1. / (1_MeV),
+      1.47767145741717343e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform14;
+  ActsSymMatrixD<3> rotMat14;
+  rotMat14 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform14.rotate(rotMat14);
+  transform14.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans14 = std::make_shared<const Transform3D>(transform14);
+  std::shared_ptr<PerigeeSurface> perigeeSurface14 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams14 = BoundParameters(tgContext, std::move(covMat14), params14,
+                                       perigeeSurface14);
+  tracks.push_back(boundParams14);
+
+  // track 15 :
+  BoundVector params15;
+  params15 << -0.0310039687901735306, 19.3887290954589844,
+      -0.00343075022101402283, 2.74638152122497559,
+      -0.000532752485014498234 * 1. / (1_MeV), 0;
+  Covariance covMat15;
+  covMat15 << 0.0210070386528968811, 0.00081324441594192757,
+      -0.000627920381522417519, 5.48433427524947839e-06,
+      -4.65033942443220242e-07 * 1. / (1_MeV), 0, 0.00081324441594192757,
+      0.163831159472465515, -4.16699183438430112e-05, 0.000680023693129414735,
+      4.78762996341304375e-09 * 1. / (1_MeV), 0, -0.000627920381522417519,
+      -4.16699183438430112e-05, 1.914421227411367e-05, -2.43960230438290961e-07,
+      2.22620707063765654e-08 * 1. / (1_MeV), 0, 5.48433427524947839e-06,
+      0.000680023693129414735, -2.43960230438290961e-07,
+      2.88798310066340491e-06, -1.98088984995358787e-11 * 1. / (1_MeV), 0,
+      -4.65033942443220242e-07 * 1. / (1_MeV),
+      4.78762996341304375e-09 * 1. / (1_MeV),
+      2.22620707063765654e-08 * 1. / (1_MeV),
+      -1.98088984995358787e-11 * 1. / (1_MeV),
+      3.28982507902253474e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform15;
+  ActsSymMatrixD<3> rotMat15;
+  rotMat15 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform15.rotate(rotMat15);
+  transform15.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans15 = std::make_shared<const Transform3D>(transform15);
+  std::shared_ptr<PerigeeSurface> perigeeSurface15 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams15 = BoundParameters(tgContext, std::move(covMat15), params15,
+                                       perigeeSurface15);
+  tracks.push_back(boundParams15);
+
+  // track 16 :
+  BoundVector params16;
+  params16 << -0.0615801773965358734, 19.7117156982421875, -1.35818147659301758,
+      1.24108779430389404, 0.000683536636643111706 * 1. / (1_MeV), 0;
+  Covariance covMat16;
+  covMat16 << 0.00367696909233927727, -6.93357704233026409e-05,
+      -9.18706572871465986e-05, 6.07456121632656689e-08,
+      -5.20653615571341965e-08 * 1. / (1_MeV), 0, -6.93357704233026409e-05,
+      0.0121181188151240349, 8.53747299804855816e-07, 0.000199079474268702445,
+      -6.01983132635719627e-10 * 1. / (1_MeV), 0, -9.18706572871465986e-05,
+      8.53747299804855816e-07, 2.43243312070262618e-06,
+      -1.96703166322206024e-08, 2.02041678483988925e-09 * 1. / (1_MeV), 0,
+      6.07456121632656689e-08, 0.000199079474268702445,
+      -1.96703166322206024e-08, 4.24742711402359419e-06,
+      -5.3578874964861769e-11 * 1. / (1_MeV), 0,
+      -5.20653615571341965e-08 * 1. / (1_MeV),
+      -6.01983132635719627e-10 * 1. / (1_MeV),
+      2.02041678483988925e-09 * 1. / (1_MeV),
+      -5.3578874964861769e-11 * 1. / (1_MeV),
+      6.21097825947991566e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform16;
+  ActsSymMatrixD<3> rotMat16;
+  rotMat16 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform16.rotate(rotMat16);
+  transform16.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans16 = std::make_shared<const Transform3D>(transform16);
+  std::shared_ptr<PerigeeSurface> perigeeSurface16 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams16 = BoundParameters(tgContext, std::move(covMat16), params16,
+                                       perigeeSurface16);
+  tracks.push_back(boundParams16);
+
+  // track 17 :
+  BoundVector params17;
+  params17 << 0.0127343572676181793, 19.6999797821044922, 1.36659955978393555,
+      2.38492679595947266, -1.37666047521634027e-05 * 1. / (1_MeV), 0;
+  Covariance covMat17;
+  covMat17 << 7.14391426299698651e-05, 1.0805756954054268e-05,
+      -8.57142054744985697e-07, 3.6976454665569372e-08,
+      -1.42849189612088987e-09 * 1. / (1_MeV), 0, 1.0805756954054268e-05,
+      0.00291397958062589169, -1.43522930069826317e-07, 1.16636632835631987e-05,
+      -6.34703011704137292e-10 * 1. / (1_MeV), 0, -8.57142054744985697e-07,
+      -1.43522930069826317e-07, 1.44155682946234265e-08,
+      -6.52670147341345277e-10, 2.26980129134178516e-11 * 1. / (1_MeV), 0,
+      3.6976454665569372e-08, 1.16636632835631987e-05, -6.52670147341345277e-10,
+      6.37399537595229049e-08, -3.38191913541128504e-12 * 1. / (1_MeV), 0,
+      -1.42849189612088987e-09 * 1. / (1_MeV),
+      -6.34703011704137292e-10 * 1. / (1_MeV),
+      2.26980129134178516e-11 * 1. / (1_MeV),
+      -3.38191913541128504e-12 * 1. / (1_MeV),
+      1.40677413836866327e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform17;
+  ActsSymMatrixD<3> rotMat17;
+  rotMat17 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform17.rotate(rotMat17);
+  transform17.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans17 = std::make_shared<const Transform3D>(transform17);
+  std::shared_ptr<PerigeeSurface> perigeeSurface17 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams17 = BoundParameters(tgContext, std::move(covMat17), params17,
+                                       perigeeSurface17);
+  tracks.push_back(boundParams17);
+
+  // track 18 :
+  BoundVector params18;
+  params18 << -0.0384683907032012939, 19.7426490783691406, -1.80467498302459717,
+      1.19412243366241455, -0.000574302859604358673 * 1. / (1_MeV), 0;
+  Covariance covMat18;
+  covMat18 << 0.00202423892915248871, -7.8687140869615615e-05,
+      -5.63647103701870963e-05, -6.49649805133107235e-07,
+      -3.34683099080895321e-08 * 1. / (1_MeV), 0, -7.8687140869615615e-05,
+      0.0185887850821018219, 2.64877126417112638e-06, 0.000217824332446111879,
+      -1.12870927770216557e-08 * 1. / (1_MeV), 0, -5.63647103701870963e-05,
+      2.64877126417112638e-06, 1.6361793768737698e-06, 2.55884812519548554e-08,
+      1.44678702068679967e-09 * 1. / (1_MeV), 0, -6.49649805133107235e-07,
+      0.000217824332446111879, 2.55884812519548554e-08, 3.64099946636997629e-06,
+      -1.23298436708217984e-10 * 1. / (1_MeV), 0,
+      -3.34683099080895321e-08 * 1. / (1_MeV),
+      -1.12870927770216557e-08 * 1. / (1_MeV),
+      1.44678702068679967e-09 * 1. / (1_MeV),
+      -1.23298436708217984e-10 * 1. / (1_MeV),
+      4.65322051723671137e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform18;
+  ActsSymMatrixD<3> rotMat18;
+  rotMat18 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform18.rotate(rotMat18);
+  transform18.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans18 = std::make_shared<const Transform3D>(transform18);
+  std::shared_ptr<PerigeeSurface> perigeeSurface18 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams18 = BoundParameters(tgContext, std::move(covMat18), params18,
+                                       perigeeSurface18);
+  tracks.push_back(boundParams18);
+
+  // track 19 :
+  BoundVector params19;
+  params19 << -0.00301715848036110401, 19.8266525268554688,
+      -2.67224979400634766, 0.715977728366851807,
+      -0.000728958519175648689 * 1. / (1_MeV), 0;
+  Covariance covMat19;
+  covMat19 << 0.00722755817696452141, -0.000255548940999269852,
+      -0.000217406702398603241, -3.1716960065804312e-06,
+      -1.22003670918761397e-07 * 1. / (1_MeV), 0, -0.000255548940999269852,
+      0.0352888740599155426, 1.12056165324810929e-05, 0.000387397513496410965,
+      1.44034486642105852e-09 * 1. / (1_MeV), 0, -0.000217406702398603241,
+      1.12056165324810929e-05, 6.66530741000315174e-06, 1.44476099359170098e-07,
+      5.84575834646360909e-09 * 1. / (1_MeV), 0, -3.1716960065804312e-06,
+      0.000387397513496410965, 1.44476099359170098e-07, 4.60058254247996956e-06,
+      2.70756521335290287e-11 * 1. / (1_MeV), 0,
+      -1.22003670918761397e-07 * 1. / (1_MeV),
+      1.44034486642105852e-09 * 1. / (1_MeV),
+      5.84575834646360909e-09 * 1. / (1_MeV),
+      2.70756521335290287e-11 * 1. / (1_MeV),
+      1.47919038129273872e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform19;
+  ActsSymMatrixD<3> rotMat19;
+  rotMat19 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform19.rotate(rotMat19);
+  transform19.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans19 = std::make_shared<const Transform3D>(transform19);
+  std::shared_ptr<PerigeeSurface> perigeeSurface19 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams19 = BoundParameters(tgContext, std::move(covMat19), params19,
+                                       perigeeSurface19);
+  tracks.push_back(boundParams19);
+
+  // track 20 :
+  BoundVector params20;
+  params20 << -0.050889924168586731, 19.6028633117675781, 0.112749122083187103,
+      2.38145637512207031, -0.000236698266235180199 * 1. / (1_MeV), 0;
+  Covariance covMat20;
+  covMat20 << 0.00143691536504775286, 0.000164076889054642412,
+      -3.58648437617112441e-05, 9.51572596730293739e-07,
+      -2.06847797524276209e-08 * 1. / (1_MeV), 0, 0.000164076889054642412,
+      0.0106960544362664223, -3.61365524801671333e-06, 9.12128019022396863e-05,
+      1.63349320460262432e-09 * 1. / (1_MeV), 0, -3.58648437617112441e-05,
+      -3.61365524801671333e-06, 9.44514340517343953e-07,
+      -2.26900632828089059e-08, 8.985070684429297e-10 * 1. / (1_MeV), 0,
+      9.51572596730293739e-07, 9.12128019022396863e-05,
+      -2.26900632828089059e-08, 9.40663255732943071e-07,
+      -7.29312017504296212e-12 * 1. / (1_MeV), 0,
+      -2.06847797524276209e-08 * 1. / (1_MeV),
+      1.63349320460262432e-09 * 1. / (1_MeV),
+      8.985070684429297e-10 * 1. / (1_MeV),
+      -7.29312017504296212e-12 * 1. / (1_MeV),
+      2.3087929137965979e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform20;
+  ActsSymMatrixD<3> rotMat20;
+  rotMat20 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform20.rotate(rotMat20);
+  transform20.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans20 = std::make_shared<const Transform3D>(transform20);
+  std::shared_ptr<PerigeeSurface> perigeeSurface20 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams20 = BoundParameters(tgContext, std::move(covMat20), params20,
+                                       perigeeSurface20);
+  tracks.push_back(boundParams20);
+
+  // track 21 :
+  BoundVector params21;
+  params21 << 0.340526312589645386, 19.5222663879394531, 1.98806488513946533,
+      0.645573973655700684, -0.000210438229260034859 * 1. / (1_MeV), 0;
+  Covariance covMat21;
+  covMat21 << 0.00187653978355228901, -4.61886315977834042e-05,
+      -4.50543377001786315e-05, -4.23803726213808519e-07,
+      -2.27506680726447051e-08 * 1. / (1_MeV), 0, -4.61886315977834042e-05,
+      0.00947334989905357361, 1.12025168001414582e-06, 6.5792105051481426e-05,
+      -1.06230443637615531e-09 * 1. / (1_MeV), 0, -4.50543377001786315e-05,
+      1.12025168001414582e-06, 1.15167620151623851e-06, 1.18795575818832697e-08,
+      8.43143312452009429e-10 * 1. / (1_MeV), 0, -4.23803726213808519e-07,
+      6.5792105051481426e-05, 1.18795575818832697e-08, 5.50924369235872291e-07,
+      5.88708293652256259e-12 * 1. / (1_MeV), 0,
+      -2.27506680726447051e-08 * 1. / (1_MeV),
+      -1.06230443637615531e-09 * 1. / (1_MeV),
+      8.43143312452009429e-10 * 1. / (1_MeV),
+      5.88708293652256259e-12 * 1. / (1_MeV),
+      1.54570852645141699e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform21;
+  ActsSymMatrixD<3> rotMat21;
+  rotMat21 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform21.rotate(rotMat21);
+  transform21.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans21 = std::make_shared<const Transform3D>(transform21);
+  std::shared_ptr<PerigeeSurface> perigeeSurface21 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams21 = BoundParameters(tgContext, std::move(covMat21), params21,
+                                       perigeeSurface21);
+  tracks.push_back(boundParams21);
+
+  // track 22 :
+  BoundVector params22;
+  params22 << 0.0327057354152202606, 19.7024917602539062, -2.13715505599975586,
+      2.80726861953735352, 0.000263765512499958277 * 1. / (1_MeV), 0;
+  Covariance covMat22;
+  covMat22 << 0.00759664503857493401, 0.000905364247503756396,
+      -0.000227879179537351814, 1.47085121825187884e-06,
+      -1.05708472073745111e-07 * 1. / (1_MeV), 0, 0.000905364247503756396,
+      0.0961576402187347412, -1.17275682104315631e-05, 0.00028353976847481278,
+      -9.08595344434235293e-09 * 1. / (1_MeV), 0, -0.000227879179537351814,
+      -1.17275682104315631e-05, 7.0192058956308756e-06,
+      -5.73812881555304563e-09, 5.16319886110993577e-09 * 1. / (1_MeV), 0,
+      1.47085121825187884e-06, 0.00028353976847481278, -5.73812881555304563e-09,
+      8.68534641540463781e-07, -1.7137080433623932e-11 * 1. / (1_MeV), 0,
+      -1.05708472073745111e-07 * 1. / (1_MeV),
+      -9.08595344434235293e-09 * 1. / (1_MeV),
+      5.16319886110993577e-09 * 1. / (1_MeV),
+      -1.7137080433623932e-11 * 1. / (1_MeV),
+      6.82771200688492286e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform22;
+  ActsSymMatrixD<3> rotMat22;
+  rotMat22 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform22.rotate(rotMat22);
+  transform22.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans22 = std::make_shared<const Transform3D>(transform22);
+  std::shared_ptr<PerigeeSurface> perigeeSurface22 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams22 = BoundParameters(tgContext, std::move(covMat22), params22,
+                                       perigeeSurface22);
+  tracks.push_back(boundParams22);
+
+  // track 23 :
+  BoundVector params23;
+  params23 << -0.313747167587280273, 19.8418807983398438, 2.22803497314453125,
+      0.69142603874206543, 0.000169251798070035875 * 1. / (1_MeV), 0;
+  Covariance covMat23;
+  covMat23 << 0.000822073488961905241, -4.22023511849360173e-05,
+      -2.11682852032007045e-05, -1.39809980877076557e-07,
+      -1.13325862651714777e-08 * 1. / (1_MeV), 0, -4.22023511849360173e-05,
+      0.00642389757558703423, 4.73854987704379056e-07, 4.62124676517580748e-05,
+      7.96633147731774745e-10 * 1. / (1_MeV), 0, -2.11682852032007045e-05,
+      4.73854987704379056e-07, 5.80069183797604637e-07, 3.15912432766058085e-11,
+      4.56396742731161166e-10 * 1. / (1_MeV), 0, -1.39809980877076557e-07,
+      4.62124676517580748e-05, 3.15912432766058085e-11, 3.99615089463623008e-07,
+      2.27545298907622666e-12 * 1. / (1_MeV), 0,
+      -1.13325862651714777e-08 * 1. / (1_MeV),
+      7.96633147731774745e-10 * 1. / (1_MeV),
+      4.56396742731161166e-10 * 1. / (1_MeV),
+      2.27545298907622666e-12 * 1. / (1_MeV),
+      9.23549778319987524e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform23;
+  ActsSymMatrixD<3> rotMat23;
+  rotMat23 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform23.rotate(rotMat23);
+  transform23.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans23 = std::make_shared<const Transform3D>(transform23);
+  std::shared_ptr<PerigeeSurface> perigeeSurface23 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams23 = BoundParameters(tgContext, std::move(covMat23), params23,
+                                       perigeeSurface23);
+  tracks.push_back(boundParams23);
+
+  // track 24 :
+  BoundVector params24;
+  params24 << 0.0601691603660583496, 19.4889583587646484, 1.45675015449523926,
+      1.56046152114868164, -0.000939691497478634119 * 1. / (1_MeV), 0;
+  Covariance covMat24;
+  covMat24 << 0.00347459153272211552, 2.61288253282652421e-08,
+      -0.000100485766757895184, -1.57776073352115993e-08,
+      -5.9865669012875978e-08 * 1. / (1_MeV), 0, 2.61288253282652421e-08,
+      0.0155909880995750427, 4.31090469568027334e-09, 0.00030456631727040519,
+      -2.26566988417194164e-09 * 1. / (1_MeV), 0, -0.000100485766757895184,
+      4.31090469568027334e-09, 2.96180473924323451e-06, 7.78080017868743252e-10,
+      2.82122625662053921e-09 * 1. / (1_MeV), 0, -1.57776073352115993e-08,
+      0.00030456631727040519, 7.78080017868743252e-10, 7.35272124074981548e-06,
+      -3.83106395644490913e-11 * 1. / (1_MeV), 0,
+      -5.9865669012875978e-08 * 1. / (1_MeV),
+      -2.26566988417194164e-09 * 1. / (1_MeV),
+      2.82122625662053921e-09 * 1. / (1_MeV),
+      -3.83106395644490913e-11 * 1. / (1_MeV),
+      1.06380099174074871e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform24;
+  ActsSymMatrixD<3> rotMat24;
+  rotMat24 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform24.rotate(rotMat24);
+  transform24.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans24 = std::make_shared<const Transform3D>(transform24);
+  std::shared_ptr<PerigeeSurface> perigeeSurface24 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams24 = BoundParameters(tgContext, std::move(covMat24), params24,
+                                       perigeeSurface24);
+  tracks.push_back(boundParams24);
+
+  // track 25 :
+  BoundVector params25;
+  params25 << 0.305262893438339233, 19.6428985595703125, 2.0014500617980957,
+      0.674862563610076904, -0.000269854936050251126 * 1. / (1_MeV), 0;
+  Covariance covMat25;
+  covMat25 << 0.00167414336465299129, -1.78847304832933408e-05,
+      -4.55389135089741097e-05, -3.82403117295285017e-07,
+      -2.12364403958921256e-08 * 1. / (1_MeV), 0, -1.78847304832933408e-05,
+      0.0104135861620306969, 6.75815994310390194e-07, 8.49609773572517027e-05,
+      -1.92504072395493255e-10 * 1. / (1_MeV), 0, -4.55389135089741097e-05,
+      6.75815994310390194e-07, 1.29258842207491398e-06, 1.38985937523038846e-08,
+      9.37637080501081717e-10 * 1. / (1_MeV), 0, -3.82403117295285017e-07,
+      8.49609773572517027e-05, 1.38985937523038846e-08, 7.91449053849646589e-07,
+      7.1066766939193851e-12 * 1. / (1_MeV), 0,
+      -2.12364403958921256e-08 * 1. / (1_MeV),
+      -1.92504072395493255e-10 * 1. / (1_MeV),
+      9.37637080501081717e-10 * 1. / (1_MeV),
+      7.1066766939193851e-12 * 1. / (1_MeV),
+      2.08066983781174386e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform25;
+  ActsSymMatrixD<3> rotMat25;
+  rotMat25 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform25.rotate(rotMat25);
+  transform25.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans25 = std::make_shared<const Transform3D>(transform25);
+  std::shared_ptr<PerigeeSurface> perigeeSurface25 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams25 = BoundParameters(tgContext, std::move(covMat25), params25,
+                                       perigeeSurface25);
+  tracks.push_back(boundParams25);
+
+  // track 26 :
+  BoundVector params26;
+  params26 << -0.0716414377093315125, 19.4469375610351562, -1.31057024002075195,
+      2.37900662422180176, -0.000480518414406105876 * 1. / (1_MeV), 0;
+  Covariance covMat26;
+  covMat26 << 0.00311773899011313915, 0.000216807668024049122,
+      -8.85980764209346383e-05, 2.33675139737157217e-06,
+      -5.69352023227364653e-08 * 1. / (1_MeV), 0, 0.000216807668024049122,
+      0.0251653064042329788, -6.874046489217475e-06, 0.000259795929953506673,
+      1.0275478076867433e-09 * 1. / (1_MeV), 0, -8.85980764209346383e-05,
+      -6.874046489217475e-06, 2.60891670222918037e-06, -7.84173992006491199e-08,
+      2.8010804631721876e-09 * 1. / (1_MeV), 0, 2.33675139737157217e-06,
+      0.000259795929953506673, -7.84173992006491199e-08,
+      2.90308980765985325e-06, -2.89203496927991014e-12 * 1. / (1_MeV), 0,
+      -5.69352023227364653e-08 * 1. / (1_MeV),
+      1.0275478076867433e-09 * 1. / (1_MeV),
+      2.8010804631721876e-09 * 1. / (1_MeV),
+      -2.89203496927991014e-12 * 1. / (1_MeV),
+      7.90091464475395355e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform26;
+  ActsSymMatrixD<3> rotMat26;
+  rotMat26 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform26.rotate(rotMat26);
+  transform26.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans26 = std::make_shared<const Transform3D>(transform26);
+  std::shared_ptr<PerigeeSurface> perigeeSurface26 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams26 = BoundParameters(tgContext, std::move(covMat26), params26,
+                                       perigeeSurface26);
+  tracks.push_back(boundParams26);
+
+  // track 27 :
+  BoundVector params27;
+  params27 << 0.0340305417776107788, 19.7064609527587891, 1.96402919292449951,
+      0.62500452995300293, 0.000157972215674817562 * 1. / (1_MeV), 0;
+  Covariance covMat27;
+  covMat27 << 0.00115194241516292095, -1.75935599558400332e-05,
+      -2.72476171609115263e-05, -3.19554349594589653e-08,
+      -1.21725335271778638e-08 * 1. / (1_MeV), 0, -1.75935599558400332e-05,
+      0.00663218600675463676, -1.47069503149528377e-08, 4.24403084279258386e-05,
+      -1.17670450049324461e-11 * 1. / (1_MeV), 0, -2.72476171609115263e-05,
+      -1.47069503149528377e-08, 6.9136649472056888e-07, -1.3832287263184986e-09,
+      4.45969786691428052e-10 * 1. / (1_MeV), 0, -3.19554349594589653e-08,
+      4.24403084279258386e-05, -1.3832287263184986e-09, 3.26797248817456421e-07,
+      -3.37620811397436092e-13 * 1. / (1_MeV), 0,
+      -1.21725335271778638e-08 * 1. / (1_MeV),
+      -1.17670450049324461e-11 * 1. / (1_MeV),
+      4.45969786691428052e-10 * 1. / (1_MeV),
+      -3.37620811397436092e-13 * 1. / (1_MeV),
+      7.86358218124449948e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform27;
+  ActsSymMatrixD<3> rotMat27;
+  rotMat27 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform27.rotate(rotMat27);
+  transform27.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans27 = std::make_shared<const Transform3D>(transform27);
+  std::shared_ptr<PerigeeSurface> perigeeSurface27 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams27 = BoundParameters(tgContext, std::move(covMat27), params27,
+                                       perigeeSurface27);
+  tracks.push_back(boundParams27);
+
+  // track 28 :
+  BoundVector params28;
+  params28 << -0.0371651053428649902, 19.7891578674316406,
+      -0.659238219261169434, 0.274633139371871948,
+      -3.11207440972793847e-05 * 1. / (1_MeV), 0;
+  Covariance covMat28;
+  covMat28 << 0.00094830815214663744, -0.00019487656314514027,
+      -2.12130854277417798e-05, -2.34663925361313877e-07,
+      -3.03861064262990213e-09 * 1. / (1_MeV), 0, -0.00019487656314514027,
+      0.0170497521758079529, 3.70571285096039324e-06, 2.64888644523930275e-05,
+      2.42556496747356217e-10 * 1. / (1_MeV), 0, -2.12130854277417798e-05,
+      3.70571285096039324e-06, 5.07914478475868236e-07, 4.96919950915106563e-09,
+      1.14830219767461788e-10 * 1. / (1_MeV), 0, -2.34663925361313877e-07,
+      2.64888644523930275e-05, 4.96919950915106563e-09, 4.59249491768787266e-08,
+      2.84459713659211857e-13 * 1. / (1_MeV), 0,
+      -3.03861064262990213e-09 * 1. / (1_MeV),
+      2.42556496747356217e-10 * 1. / (1_MeV),
+      1.14830219767461788e-10 * 1. / (1_MeV),
+      2.84459713659211857e-13 * 1. / (1_MeV),
+      9.65581672777993116e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform28;
+  ActsSymMatrixD<3> rotMat28;
+  rotMat28 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform28.rotate(rotMat28);
+  transform28.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans28 = std::make_shared<const Transform3D>(transform28);
+  std::shared_ptr<PerigeeSurface> perigeeSurface28 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams28 = BoundParameters(tgContext, std::move(covMat28), params28,
+                                       perigeeSurface28);
+  tracks.push_back(boundParams28);
+
+  // track 29 :
+  BoundVector params29;
+  params29 << 0.0113061871379613876, 19.7758064270019531, -0.565121948719024658,
+      1.11297404766082764, -0.000380097364541143179 * 1. / (1_MeV), 0;
+  Covariance covMat29;
+  covMat29 << 0.00155933154746890068, -4.97482623935557549e-05,
+      -3.73456424926352755e-05, -4.55759156051640272e-07,
+      -2.07172213465749658e-08 * 1. / (1_MeV), 0, -4.97482623935557549e-05,
+      0.00686531048268079758, 1.31561141444726331e-06, 8.97714266550412308e-05,
+      -1.19474789182683184e-09 * 1. / (1_MeV), 0, -3.73456424926352755e-05,
+      1.31561141444726331e-06, 9.55697146309830714e-07, 1.30428805682263728e-08,
+      7.75026676835572029e-10 * 1. / (1_MeV), 0, -4.55759156051640272e-07,
+      8.97714266550412308e-05, 1.30428805682263728e-08, 1.62136052495043259e-06,
+      -3.68485465951844148e-12 * 1. / (1_MeV), 0,
+      -2.07172213465749658e-08 * 1. / (1_MeV),
+      -1.19474789182683184e-09 * 1. / (1_MeV),
+      7.75026676835572029e-10 * 1. / (1_MeV),
+      -3.68485465951844148e-12 * 1. / (1_MeV),
+      2.15952047910583644e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform29;
+  ActsSymMatrixD<3> rotMat29;
+  rotMat29 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform29.rotate(rotMat29);
+  transform29.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans29 = std::make_shared<const Transform3D>(transform29);
+  std::shared_ptr<PerigeeSurface> perigeeSurface29 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams29 = BoundParameters(tgContext, std::move(covMat29), params29,
+                                       perigeeSurface29);
+  tracks.push_back(boundParams29);
+
+  // track 30 :
+  BoundVector params30;
+  params30 << -0.000764124910347163677, 19.7925205230712891,
+      -1.60565555095672607, 2.11691427230834961,
+      0.00109597900882363319 * 1. / (1_MeV), 0;
+  Covariance covMat30;
+  covMat30 << 0.00818897411227226257, -7.88637168572715077e-05,
+      -0.000237841176207310301, -2.86874654680000338e-06,
+      -1.07533611185096677e-07 * 1. / (1_MeV), 0, -7.88637168572715077e-05,
+      0.0303833372890949249, 6.69007874662318617e-06, 0.000503271982246975501,
+      1.40492310581731278e-09 * 1. / (1_MeV), 0, -0.000237841176207310301,
+      6.69007874662318617e-06, 7.098253263393417e-06, 1.64058162507511388e-07,
+      5.23793435502016417e-09 * 1. / (1_MeV), 0, -2.86874654680000338e-06,
+      0.000503271982246975501, 1.64058162507511388e-07, 9.68445510807214305e-06,
+      4.84013097877190455e-11 * 1. / (1_MeV), 0,
+      -1.07533611185096677e-07 * 1. / (1_MeV),
+      1.40492310581731278e-09 * 1. / (1_MeV),
+      5.23793435502016417e-09 * 1. / (1_MeV),
+      4.84013097877190455e-11 * 1. / (1_MeV),
+      1.75064601704022493e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform30;
+  ActsSymMatrixD<3> rotMat30;
+  rotMat30 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform30.rotate(rotMat30);
+  transform30.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans30 = std::make_shared<const Transform3D>(transform30);
+  std::shared_ptr<PerigeeSurface> perigeeSurface30 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams30 = BoundParameters(tgContext, std::move(covMat30), params30,
+                                       perigeeSurface30);
+  tracks.push_back(boundParams30);
+
+  // track 31 :
+  BoundVector params31;
+  params31 << 0.0434660129249095917, 19.9743804931640625, -1.92152023315429688,
+      1.10322427749633789, -0.00135057768784463406 * 1. / (1_MeV), 0;
+  Covariance covMat31;
+  covMat31 << 0.00949090253561735153, -0.000162514116123452891,
+      -0.000277450606342210756, -3.41726209466831981e-06,
+      -1.35977257290003362e-07 * 1. / (1_MeV), 0, -0.000162514116123452891,
+      0.0241005755960941315, 7.44390386227167547e-06, 0.000482722310593120495,
+      -5.01533653096054345e-09 * 1. / (1_MeV), 0, -0.000277450606342210756,
+      7.44390386227167547e-06, 8.34032562124775723e-06, 1.70338602887570872e-07,
+      6.59502382970017033e-09 * 1. / (1_MeV), 0, -3.41726209466831981e-06,
+      0.000482722310593120495, 1.70338602887570872e-07, 1.08669210021616891e-05,
+      -1.30623540733939145e-10 * 1. / (1_MeV), 0,
+      -1.35977257290003362e-07 * 1. / (1_MeV),
+      -5.01533653096054345e-09 * 1. / (1_MeV),
+      6.59502382970017033e-09 * 1. / (1_MeV),
+      -1.30623540733939145e-10 * 1. / (1_MeV),
+      2.33806835003846913e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform31;
+  ActsSymMatrixD<3> rotMat31;
+  rotMat31 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform31.rotate(rotMat31);
+  transform31.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans31 = std::make_shared<const Transform3D>(transform31);
+  std::shared_ptr<PerigeeSurface> perigeeSurface31 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams31 = BoundParameters(tgContext, std::move(covMat31), params31,
+                                       perigeeSurface31);
+  tracks.push_back(boundParams31);
+
+  // track 32 :
+  BoundVector params32;
+  params32 << -0.323653548955917358, 23.0863323211669922, -2.04575490951538086,
+      1.19155371189117432, -0.00135404628235846758 * 1. / (1_MeV), 0;
+  Covariance covMat32;
+  covMat32 << 0.00942049268633127213, -0.000156100331056732402,
+      -0.000267428691337353848, -2.84213758688659959e-06,
+      -1.3715343361864345e-07 * 1. / (1_MeV), 0, -0.000156100331056732402,
+      0.0234745144844055176, 6.9330452366765478e-06, 0.000468627570852257769,
+      4.42012838944869237e-10 * 1. / (1_MeV), 0, -0.000267428691337353848,
+      6.9330452366765478e-06, 7.8662105806870386e-06, 1.40317764457691491e-07,
+      6.38338658586116389e-09 * 1. / (1_MeV), 0, -2.84213758688659959e-06,
+      0.000468627570852257769, 1.40317764457691491e-07, 1.09587390397791751e-05,
+      1.69050142770342731e-12 * 1. / (1_MeV), 0,
+      -1.3715343361864345e-07 * 1. / (1_MeV),
+      4.42012838944869237e-10 * 1. / (1_MeV),
+      6.38338658586116389e-09 * 1. / (1_MeV),
+      1.69050142770342731e-12 * 1. / (1_MeV),
+      2.24243526525391701e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform32;
+  ActsSymMatrixD<3> rotMat32;
+  rotMat32 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform32.rotate(rotMat32);
+  transform32.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans32 = std::make_shared<const Transform3D>(transform32);
+  std::shared_ptr<PerigeeSurface> perigeeSurface32 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams32 = BoundParameters(tgContext, std::move(covMat32), params32,
+                                       perigeeSurface32);
+  tracks.push_back(boundParams32);
+
+  // track 33 :
+  BoundVector params33;
+  params33 << 0.0502348393201828003, 19.8225479125976562, 1.2200552225112915,
+      1.19947576522827148, 0.00065168103901669383 * 1. / (1_MeV), 0;
+  Covariance covMat33;
+  covMat33 << 0.00330946571193635464, -3.03961755070003361e-05,
+      -8.23355349674717059e-05, 3.61557925205989208e-07,
+      -4.81647993693705346e-08 * 1. / (1_MeV), 0, -3.03961755070003361e-05,
+      0.0121201490983366966, -3.44926830210965382e-08, 0.0001832216673901092,
+      -8.289858737864768e-09 * 1. / (1_MeV), 0, -8.23355349674717059e-05,
+      -3.44926830210965382e-08, 2.16286139220756013e-06,
+      -2.50835114436962174e-08, 1.88343068671924282e-09 * 1. / (1_MeV), 0,
+      3.61557925205989208e-07, 0.0001832216673901092, -2.50835114436962174e-08,
+      3.61402794624154922e-06, -1.38343005917598103e-10 * 1. / (1_MeV), 0,
+      -4.81647993693705346e-08 * 1. / (1_MeV),
+      -8.289858737864768e-09 * 1. / (1_MeV),
+      1.88343068671924282e-09 * 1. / (1_MeV),
+      -1.38343005917598103e-10 * 1. / (1_MeV),
+      5.75411177039519828e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform33;
+  ActsSymMatrixD<3> rotMat33;
+  rotMat33 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform33.rotate(rotMat33);
+  transform33.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans33 = std::make_shared<const Transform3D>(transform33);
+  std::shared_ptr<PerigeeSurface> perigeeSurface33 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams33 = BoundParameters(tgContext, std::move(covMat33), params33,
+                                       perigeeSurface33);
+  tracks.push_back(boundParams33);
+
+  // track 34 :
+  BoundVector params34;
+  params34 << -0.00679738679900765419, 19.7787380218505859, 0.64978182315826416,
+      1.718436598777771, 0.000399400596506893635 * 1. / (1_MeV), 0;
+  Covariance covMat34;
+  covMat34 << 0.0016832397086545825, 3.08902871283228804e-08,
+      -3.9761794373880207e-05, -5.36301231604843024e-08,
+      -1.25551948300567075e-08 * 1. / (1_MeV), 0, 3.08902871283228804e-08,
+      0.0122804483398795128, 1.50321795312578277e-07, 0.000155226454439672071,
+      -3.69637596757974278e-09 * 1. / (1_MeV), 0, -3.9761794373880207e-05,
+      1.50321795312578277e-07, 1.01230580185074359e-06, 3.57209146154241154e-09,
+      5.08893136683866958e-10 * 1. / (1_MeV), 0, -5.36301231604843024e-08,
+      0.000155226454439672071, 3.57209146154241154e-09, 2.92897698273009155e-06,
+      -4.64295001076053898e-11 * 1. / (1_MeV), 0,
+      -1.25551948300567075e-08 * 1. / (1_MeV),
+      -3.69637596757974278e-09 * 1. / (1_MeV),
+      5.08893136683866958e-10 * 1. / (1_MeV),
+      -4.64295001076053898e-11 * 1. / (1_MeV),
+      1.79039612996367836e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform34;
+  ActsSymMatrixD<3> rotMat34;
+  rotMat34 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform34.rotate(rotMat34);
+  transform34.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans34 = std::make_shared<const Transform3D>(transform34);
+  std::shared_ptr<PerigeeSurface> perigeeSurface34 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams34 = BoundParameters(tgContext, std::move(covMat34), params34,
+                                       perigeeSurface34);
+  tracks.push_back(boundParams34);
+
+  // track 35 :
+  BoundVector params35;
+  params35 << 0.0805509239435195923, 19.8107032775878906, -0.580723822116851807,
+      1.39042818546295166, -0.000723547651432454586 * 1. / (1_MeV), 0;
+  Covariance covMat35;
+  covMat35 << 0.00366608682088553905, -3.07736450112954378e-05,
+      -9.36432680714786278e-05, -4.32691756908737401e-07,
+      -4.03209869361722161e-08 * 1. / (1_MeV), 0, -3.07736450112954378e-05,
+      0.0121293710544705391, 8.84241894101609937e-07, 0.000208273787997539348,
+      -4.72119222103642781e-09 * 1. / (1_MeV), 0, -9.36432680714786278e-05,
+      8.84241894101609937e-07, 2.51136862061684951e-06, 1.65541645067806758e-08,
+      1.643748206415159e-09 * 1. / (1_MeV), 0, -4.32691756908737401e-07,
+      0.000208273787997539348, 1.65541645067806758e-08, 4.73576938020414673e-06,
+      -5.8294474111660837e-11 * 1. / (1_MeV), 0,
+      -4.03209869361722161e-08 * 1. / (1_MeV),
+      -4.72119222103642781e-09 * 1. / (1_MeV),
+      1.643748206415159e-09 * 1. / (1_MeV),
+      -5.8294474111660837e-11 * 1. / (1_MeV),
+      5.46871367634871319e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform35;
+  ActsSymMatrixD<3> rotMat35;
+  rotMat35 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform35.rotate(rotMat35);
+  transform35.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans35 = std::make_shared<const Transform3D>(transform35);
+  std::shared_ptr<PerigeeSurface> perigeeSurface35 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams35 = BoundParameters(tgContext, std::move(covMat35), params35,
+                                       perigeeSurface35);
+  tracks.push_back(boundParams35);
+
+  // track 36 :
+  BoundVector params36;
+  params36 << 0.0170946419239044189, 19.5798168182373047, 2.3832242488861084,
+      1.84145426750183105, -0.0016136891208589077 * 1. / (1_MeV), 0;
+  Covariance covMat36;
+  covMat36 << 0.0110465008765459061, 0.000132400605777621878,
+      -0.000322046919185156361, 3.95346550436209276e-06,
+      -1.74628381920564644e-07 * 1. / (1_MeV), 0, 0.000132400605777621878,
+      0.0441923066973686218, -7.93550960128202309e-06, 0.000857220862319744157,
+      -3.078313337372045e-09 * 1. / (1_MeV), 0, -0.000322046919185156361,
+      -7.93550960128202309e-06, 9.60366560320835561e-06,
+      -2.05361008506430899e-07, 8.74873834892499733e-09 * 1. / (1_MeV), 0,
+      3.95346550436209276e-06, 0.000857220862319744157,
+      -2.05361008506430899e-07, 1.90070531971286982e-05,
+      -2.62406175067672348e-11 * 1. / (1_MeV), 0,
+      -1.74628381920564644e-07 * 1. / (1_MeV),
+      -3.078313337372045e-09 * 1. / (1_MeV),
+      8.74873834892499733e-09 * 1. / (1_MeV),
+      -2.62406175067672348e-11 * 1. / (1_MeV),
+      3.43723355333835912e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform36;
+  ActsSymMatrixD<3> rotMat36;
+  rotMat36 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform36.rotate(rotMat36);
+  transform36.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans36 = std::make_shared<const Transform3D>(transform36);
+  std::shared_ptr<PerigeeSurface> perigeeSurface36 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams36 = BoundParameters(tgContext, std::move(covMat36), params36,
+                                       perigeeSurface36);
+  tracks.push_back(boundParams36);
+
+  // track 37 :
+  BoundVector params37;
+  params37 << 0.0422709546983242035, 19.8179073333740234, -0.292277246713638306,
+      1.55503785610198975, 0.00102485006209462881 * 1. / (1_MeV), 0;
+  Covariance covMat37;
+  covMat37 << 0.0048865852877497673, 1.04378577009161224e-06,
+      -0.000137165974802729929, 5.94294471798817227e-08,
+      -7.83582361279693423e-08 * 1. / (1_MeV), 0, 1.04378577009161224e-06,
+      0.0150463152676820755, -1.19789705332920958e-07, 0.000332276925926711661,
+      -1.66883965671842617e-09 * 1. / (1_MeV), 0, -0.000137165974802729929,
+      -1.19789705332920958e-07, 3.95677625419921242e-06,
+      -3.54401466185166792e-09, 3.6142052743200193e-09 * 1. / (1_MeV), 0,
+      5.94294471798817227e-08, 0.000332276925926711661,
+      -3.54401466185166792e-09, 8.53642995934933424e-06,
+      -2.50276756413508482e-11 * 1. / (1_MeV), 0,
+      -7.83582361279693423e-08 * 1. / (1_MeV),
+      -1.66883965671842617e-09 * 1. / (1_MeV),
+      3.6142052743200193e-09 * 1. / (1_MeV),
+      -2.50276756413508482e-11 * 1. / (1_MeV),
+      1.35456687533341835e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform37;
+  ActsSymMatrixD<3> rotMat37;
+  rotMat37 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform37.rotate(rotMat37);
+  transform37.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans37 = std::make_shared<const Transform3D>(transform37);
+  std::shared_ptr<PerigeeSurface> perigeeSurface37 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams37 = BoundParameters(tgContext, std::move(covMat37), params37,
+                                       perigeeSurface37);
+  tracks.push_back(boundParams37);
+
+  // track 38 :
+  BoundVector params38;
+  params38 << 0.0177954975515604019, 19.6020870208740234, 2.58446574211120605,
+      2.14368629455566406, 0.00039697738247923553 * 1. / (1_MeV), 0;
+  Covariance covMat38;
+  covMat38 << 0.00228728121146559715, -6.6835355739982095e-07,
+      -5.56660017110235266e-05, -2.3660648892322657e-07,
+      -2.44971223220455001e-08 * 1. / (1_MeV), 0, -6.6835355739982095e-07,
+      0.0207388382405042648, 9.95559061054844415e-07, 0.000196521767889107021,
+      -9.37926118817295971e-09 * 1. / (1_MeV), 0, -5.56660017110235266e-05,
+      9.95559061054844415e-07, 1.44270552482339554e-06, 1.62772969664253208e-08,
+      9.58725521674916825e-10 * 1. / (1_MeV), 0, -2.3660648892322657e-07,
+      0.000196521767889107021, 1.62772969664253208e-08, 2.3284674171009101e-06,
+      -3.82657738677909124e-11 * 1. / (1_MeV), 0,
+      -2.44971223220455001e-08 * 1. / (1_MeV),
+      -9.37926118817295971e-09 * 1. / (1_MeV),
+      9.58725521674916825e-10 * 1. / (1_MeV),
+      -3.82657738677909124e-11 * 1. / (1_MeV),
+      2.58620104498508141e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform38;
+  ActsSymMatrixD<3> rotMat38;
+  rotMat38 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform38.rotate(rotMat38);
+  transform38.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans38 = std::make_shared<const Transform3D>(transform38);
+  std::shared_ptr<PerigeeSurface> perigeeSurface38 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams38 = BoundParameters(tgContext, std::move(covMat38), params38,
+                                       perigeeSurface38);
+  tracks.push_back(boundParams38);
+
+  // track 39 :
+  BoundVector params39;
+  params39 << 0.0385684818029403687, 19.5943107604980469, 2.10506224632263184,
+      0.815114736557006836, -0.000444010045612230897 * 1. / (1_MeV), 0;
+  Covariance covMat39;
+  covMat39 << 0.00257171900011599064, -8.38966740548737503e-05,
+      -6.9521214623902581e-05, -1.04908792338842471e-06,
+      -4.18962156374891846e-08 * 1. / (1_MeV), 0, -8.38966740548737503e-05,
+      0.012954135425388813, 2.69320887977152083e-06, 0.000145498663861290411,
+      4.42965387319607159e-10 * 1. / (1_MeV), 0, -6.9521214623902581e-05,
+      2.69320887977152083e-06, 1.96165024135552812e-06, 3.61876337782125774e-08,
+      1.88426409286430859e-09 * 1. / (1_MeV), 0, -1.04908792338842471e-06,
+      0.000145498663861290411, 3.61876337782125774e-08, 1.82780070190347033e-06,
+      1.36738002410268621e-11 * 1. / (1_MeV), 0,
+      -4.18962156374891846e-08 * 1. / (1_MeV),
+      4.42965387319607159e-10 * 1. / (1_MeV),
+      1.88426409286430859e-09 * 1. / (1_MeV),
+      1.36738002410268621e-11 * 1. / (1_MeV),
+      5.138850109331905e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform39;
+  ActsSymMatrixD<3> rotMat39;
+  rotMat39 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform39.rotate(rotMat39);
+  transform39.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans39 = std::make_shared<const Transform3D>(transform39);
+  std::shared_ptr<PerigeeSurface> perigeeSurface39 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams39 = BoundParameters(tgContext, std::move(covMat39), params39,
+                                       perigeeSurface39);
+  tracks.push_back(boundParams39);
+
+  // track 40 :
+  BoundVector params40;
+  params40 << -0.00192465144209563732, 19.6035480499267578, 1.34771013259887695,
+      1.37635326385498047, 0.000349941314198076725 * 1. / (1_MeV), 0;
+  Covariance covMat40;
+  covMat40 << 0.00092626502737402916, -4.70278465200604772e-06,
+      -2.37325601967636777e-05, 2.6469781945744914e-08,
+      -1.04657823685612316e-08 * 1. / (1_MeV), 0, -4.70278465200604772e-06,
+      0.00892938859760761261, -2.32025646493256662e-08, 9.67470782924100583e-05,
+      -1.28292191621348689e-09 * 1. / (1_MeV), 0, -2.37325601967636777e-05,
+      -2.32025646493256662e-08, 6.42108432202803669e-07,
+      -2.41607947044108425e-09, 4.13063041753621467e-10 * 1. / (1_MeV), 0,
+      2.6469781945744914e-08, 9.67470782924100583e-05, -2.41607947044108425e-09,
+      1.45360513670311775e-06, -1.4243170245924231e-11 * 1. / (1_MeV), 0,
+      -1.04657823685612316e-08 * 1. / (1_MeV),
+      -1.28292191621348689e-09 * 1. / (1_MeV),
+      4.13063041753621467e-10 * 1. / (1_MeV),
+      -1.4243170245924231e-11 * 1. / (1_MeV),
+      1.31918035523037602e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform40;
+  ActsSymMatrixD<3> rotMat40;
+  rotMat40 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform40.rotate(rotMat40);
+  transform40.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans40 = std::make_shared<const Transform3D>(transform40);
+  std::shared_ptr<PerigeeSurface> perigeeSurface40 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams40 = BoundParameters(tgContext, std::move(covMat40), params40,
+                                       perigeeSurface40);
+  tracks.push_back(boundParams40);
+
+  // track 41 :
+  BoundVector params41;
+  params41 << -0.0107631208375096321, 19.6368961334228516, 2.11897373199462891,
+      0.68950730562210083, 0.000500780763104557991 * 1. / (1_MeV), 0;
+  Covariance covMat41;
+  covMat41 << 0.0046280999667942524, -8.50248504624665413e-05,
+      -0.000130293248442505169, 3.81786496695030795e-07,
+      -6.22341861031614923e-08 * 1. / (1_MeV), 0, -8.50248504624665413e-05,
+      0.0234155002981424332, -1.02870605123693907e-06, 0.000220617921810967285,
+      1.23912522027359707e-09 * 1. / (1_MeV), 0, -0.000130293248442505169,
+      -1.02870605123693907e-06, 3.78699451175634749e-06,
+      -4.14661454981517284e-08, 2.90208625768643512e-09 * 1. / (1_MeV), 0,
+      3.81786496695030795e-07, 0.000220617921810967285,
+      -4.14661454981517284e-08, 2.34398885368136689e-06,
+      -4.89427060442843687e-12 * 1. / (1_MeV), 0,
+      -6.22341861031614923e-08 * 1. / (1_MeV),
+      1.23912522027359707e-09 * 1. / (1_MeV),
+      2.90208625768643512e-09 * 1. / (1_MeV),
+      -4.89427060442843687e-12 * 1. / (1_MeV),
+      7.00765001582226432e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform41;
+  ActsSymMatrixD<3> rotMat41;
+  rotMat41 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform41.rotate(rotMat41);
+  transform41.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans41 = std::make_shared<const Transform3D>(transform41);
+  std::shared_ptr<PerigeeSurface> perigeeSurface41 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams41 = BoundParameters(tgContext, std::move(covMat41), params41,
+                                       perigeeSurface41);
+  tracks.push_back(boundParams41);
+
+  // track 42 :
+  BoundVector params42;
+  params42 << 0.205963864922523499, 19.6864852905273438, 0.214674949645996094,
+      1.62375175952911377, 0.00149375631008297205 * 1. / (1_MeV), 0;
+  Covariance covMat42;
+  covMat42 << 0.00880367588251829147, -1.80866668959131395e-05,
+      -0.000256995153030317573, -5.65481784766486379e-07,
+      -1.21863871949890772e-07 * 1. / (1_MeV), 0, -1.80866668959131395e-05,
+      0.0290389824658632278, 1.0786176979882171e-06, 0.000633662510089911938,
+      1.54534038892845022e-09 * 1. / (1_MeV), 0, -0.000256995153030317573,
+      1.0786176979882171e-06, 7.61563569540157914e-06, 3.04492679504856067e-08,
+      5.93032819545449155e-09 * 1. / (1_MeV), 0, -5.65481784766486379e-07,
+      0.000633662510089911938, 3.04492679504856067e-08, 1.61353309522382915e-05,
+      6.0506063998423997e-11 * 1. / (1_MeV), 0,
+      -1.21863871949890772e-07 * 1. / (1_MeV),
+      1.54534038892845022e-09 * 1. / (1_MeV),
+      5.93032819545449155e-09 * 1. / (1_MeV),
+      6.0506063998423997e-11 * 1. / (1_MeV),
+      2.29128466200378966e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform42;
+  ActsSymMatrixD<3> rotMat42;
+  rotMat42 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform42.rotate(rotMat42);
+  transform42.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans42 = std::make_shared<const Transform3D>(transform42);
+  std::shared_ptr<PerigeeSurface> perigeeSurface42 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams42 = BoundParameters(tgContext, std::move(covMat42), params42,
+                                       perigeeSurface42);
+  tracks.push_back(boundParams42);
+
+  // track 43 :
+  BoundVector params43;
+  params43 << 0.147156372666358948, 18.0601425170898438, -1.20425975322723389,
+      2.95313668251037598, 4.38562346971593797e-05 * 1. / (1_MeV), 0;
+  Covariance covMat43;
+  covMat43 << 0.00227970955893397331, 0.00210539922327512233,
+      -6.23386652157084843e-05, 1.62139833390343564e-06,
+      -2.4710662537678873e-08 * 1. / (1_MeV), 0, 0.00210539922327512233,
+      0.0987421199679374695, -4.43239956360880696e-05, 8.53623578378920762e-05,
+      -2.894438650939545e-09 * 1. / (1_MeV), 0, -6.23386652157084843e-05,
+      -4.43239956360880696e-05, 1.78687150764744729e-06,
+      -3.5153983375057298e-08, 1.14365278859331536e-09 * 1. / (1_MeV), 0,
+      1.62139833390343564e-06, 8.53623578378920762e-05, -3.5153983375057298e-08,
+      7.69686039348016493e-08, -2.40912278559178251e-12 * 1. / (1_MeV), 0,
+      -2.4710662537678873e-08 * 1. / (1_MeV),
+      -2.894438650939545e-09 * 1. / (1_MeV),
+      1.14365278859331536e-09 * 1. / (1_MeV),
+      -2.40912278559178251e-12 * 1. / (1_MeV),
+      8.10338168094615341e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform43;
+  ActsSymMatrixD<3> rotMat43;
+  rotMat43 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform43.rotate(rotMat43);
+  transform43.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans43 = std::make_shared<const Transform3D>(transform43);
+  std::shared_ptr<PerigeeSurface> perigeeSurface43 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams43 = BoundParameters(tgContext, std::move(covMat43), params43,
+                                       perigeeSurface43);
+  tracks.push_back(boundParams43);
+
+  // track 44 :
+  BoundVector params44;
+  params44 << -0.0293732546269893646, 19.8860263824462891, 1.95824682712554932,
+      0.870327293872833252, 0.000651221722364425659 * 1. / (1_MeV), 0;
+  Covariance covMat44;
+  covMat44 << 0.00386394886299967766, 6.41084427899122564e-05,
+      -0.000111475937760659882, 1.88781955782771875e-06,
+      -8.13503642219718733e-08 * 1. / (1_MeV), 0, 6.41084427899122564e-05,
+      0.0216643344610929489, -4.27457576030063133e-06, 0.000299667220913072709,
+      1.00583188544233463e-10 * 1. / (1_MeV), 0, -0.000111475937760659882,
+      -4.27457576030063133e-06, 3.30510965795838274e-06,
+      -9.27711560515876557e-08, 4.0446540731261482e-09 * 1. / (1_MeV), 0,
+      1.88781955782771875e-06, 0.000299667220913072709,
+      -9.27711560515876557e-08, 4.72439432996907271e-06,
+      -4.51255450632084092e-11 * 1. / (1_MeV), 0,
+      -8.13503642219718733e-08 * 1. / (1_MeV),
+      1.00583188544233463e-10 * 1. / (1_MeV),
+      4.0446540731261482e-09 * 1. / (1_MeV),
+      -4.51255450632084092e-11 * 1. / (1_MeV),
+      1.23205209923149539e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform44;
+  ActsSymMatrixD<3> rotMat44;
+  rotMat44 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform44.rotate(rotMat44);
+  transform44.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans44 = std::make_shared<const Transform3D>(transform44);
+  std::shared_ptr<PerigeeSurface> perigeeSurface44 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams44 = BoundParameters(tgContext, std::move(covMat44), params44,
+                                       perigeeSurface44);
+  tracks.push_back(boundParams44);
+
+  // track 45 :
+  BoundVector params45;
+  params45 << -0.00822580046951770782, 19.7521209716796875,
+      -1.34217584133148193, 1.31352841854095459,
+      -0.00102247926406562328 * 1. / (1_MeV), 0;
+  Covariance covMat45;
+  covMat45 << 0.00437659770250320435, -7.97783766085815948e-05,
+      -0.00012776433189490825, -9.58273275448513196e-07,
+      -5.94526727131795577e-08 * 1. / (1_MeV), 0, -7.97783766085815948e-05,
+      0.0161803290247917175, 2.97524849199130738e-06, 0.000292265113374019965,
+      2.18355646012064316e-10 * 1. / (1_MeV), 0, -0.00012776433189490825,
+      2.97524849199130738e-06, 3.82176176572102122e-06, 4.43621833298063989e-08,
+      2.82001283990720967e-09 * 1. / (1_MeV), 0, -9.58273275448513196e-07,
+      0.000292265113374019965, 4.43621833298063989e-08, 6.61718468109029345e-06,
+      2.39856062071632866e-11 * 1. / (1_MeV), 0,
+      -5.94526727131795577e-08 * 1. / (1_MeV),
+      2.18355646012064316e-10 * 1. / (1_MeV),
+      2.82001283990720967e-09 * 1. / (1_MeV),
+      2.39856062071632866e-11 * 1. / (1_MeV),
+      1.06083510031940165e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform45;
+  ActsSymMatrixD<3> rotMat45;
+  rotMat45 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform45.rotate(rotMat45);
+  transform45.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans45 = std::make_shared<const Transform3D>(transform45);
+  std::shared_ptr<PerigeeSurface> perigeeSurface45 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams45 = BoundParameters(tgContext, std::move(covMat45), params45,
+                                       perigeeSurface45);
+  tracks.push_back(boundParams45);
+
+  // track 46 :
+  BoundVector params46;
+  params46 << -0.00361508713103830814, 19.4546413421630859,
+      -1.30042552947998047, 1.05093002319335938,
+      -0.00133425544481724501 * 1. / (1_MeV), 0;
+  Covariance covMat46;
+  covMat46 << 0.00941458996385335922, -0.000284834152470895207,
+      -0.000280442622898071389, -5.80468009022971626e-06,
+      -1.41275786371003149e-07 * 1. / (1_MeV), 0, -0.000284834152470895207,
+      0.0502648279070854187, 1.53948871197303823e-05, 0.000823507242403401945,
+      -2.66165681844982257e-09 * 1. / (1_MeV), 0, -0.000280442622898071389,
+      1.53948871197303823e-05, 8.5132569438428618e-06, 2.95341827559094638e-07,
+      6.98672628255231531e-09 * 1. / (1_MeV), 0, -5.80468009022971626e-06,
+      0.000823507242403401945, 2.95341827559094638e-07, 1.44839359563775361e-05,
+      -4.21371554939487073e-11 * 1. / (1_MeV), 0,
+      -1.41275786371003149e-07 * 1. / (1_MeV),
+      -2.66165681844982257e-09 * 1. / (1_MeV),
+      6.98672628255231531e-09 * 1. / (1_MeV),
+      -4.21371554939487073e-11 * 1. / (1_MeV),
+      2.45891834671496667e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform46;
+  ActsSymMatrixD<3> rotMat46;
+  rotMat46 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform46.rotate(rotMat46);
+  transform46.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans46 = std::make_shared<const Transform3D>(transform46);
+  std::shared_ptr<PerigeeSurface> perigeeSurface46 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams46 = BoundParameters(tgContext, std::move(covMat46), params46,
+                                       perigeeSurface46);
+  tracks.push_back(boundParams46);
+
+  // track 47 :
+  BoundVector params47;
+  params47 << -0.0598590485751628876, 19.6531963348388672, 2.72643232345581055,
+      1.30785942077636719, -0.000780149712227284908 * 1. / (1_MeV), 0;
+  Covariance covMat47;
+  covMat47 << 0.0032495234627276659, -4.04264250143772372e-05,
+      -9.30744349600882211e-05, -5.0226893263358181e-07,
+      -1.01375149269318418e-07 * 1. / (1_MeV), 0, -4.04264250143772372e-05,
+      0.0112805059179663658, 1.30282082485754631e-06, 0.000209029656597159029,
+      -7.2365790516280225e-09 * 1. / (1_MeV), 0, -9.30744349600882211e-05,
+      1.30282082485754631e-06, 2.75341517408378422e-06, 2.1800386214469216e-08,
+      4.40769477853404022e-09 * 1. / (1_MeV), 0, -5.0226893263358181e-07,
+      0.000209029656597159029, 2.1800386214469216e-08, 4.8472306843905244e-06,
+      -9.06260666641051782e-11 * 1. / (1_MeV), 0,
+      -1.01375149269318418e-07 * 1. / (1_MeV),
+      -7.2365790516280225e-09 * 1. / (1_MeV),
+      4.40769477853404022e-09 * 1. / (1_MeV),
+      -9.06260666641051782e-11 * 1. / (1_MeV),
+      1.457364923185267e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform47;
+  ActsSymMatrixD<3> rotMat47;
+  rotMat47 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform47.rotate(rotMat47);
+  transform47.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans47 = std::make_shared<const Transform3D>(transform47);
+  std::shared_ptr<PerigeeSurface> perigeeSurface47 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams47 = BoundParameters(tgContext, std::move(covMat47), params47,
+                                       perigeeSurface47);
+  tracks.push_back(boundParams47);
+
+  // track 48 :
+  BoundVector params48;
+  params48 << 0.0583043769001960754, 19.7832298278808594, -3.05185866355895996,
+      2.35133123397827148, 0.000652144546620547771 * 1. / (1_MeV), 0;
+  Covariance covMat48;
+  covMat48 << 0.00455570640042424202, 2.27770645100975327e-05,
+      -0.000134378354520968727, -9.98581163169078598e-07,
+      -9.40610633214604794e-08 * 1. / (1_MeV), 0, 2.27770645100975327e-05,
+      0.0258676018565893173, 3.21967957682574985e-06, 0.000300520679336246791,
+      -1.35927009544720559e-09 * 1. / (1_MeV), 0, -0.000134378354520968727,
+      3.21967957682574985e-06, 4.06873823521891609e-06, 7.29906365483080491e-08,
+      4.4846939744143286e-09 * 1. / (1_MeV), 0, -9.98581163169078598e-07,
+      0.000300520679336246791, 7.29906365483080491e-08, 3.90696686736191623e-06,
+      4.80210416302676692e-12 * 1. / (1_MeV), 0,
+      -9.40610633214604794e-08 * 1. / (1_MeV),
+      -1.35927009544720559e-09 * 1. / (1_MeV),
+      4.4846939744143286e-09 * 1. / (1_MeV),
+      4.80210416302676692e-12 * 1. / (1_MeV),
+      1.25072396883751935e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform48;
+  ActsSymMatrixD<3> rotMat48;
+  rotMat48 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform48.rotate(rotMat48);
+  transform48.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans48 = std::make_shared<const Transform3D>(transform48);
+  std::shared_ptr<PerigeeSurface> perigeeSurface48 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams48 = BoundParameters(tgContext, std::move(covMat48), params48,
+                                       perigeeSurface48);
+  tracks.push_back(boundParams48);
+
+  // track 49 :
+  BoundVector params49;
+  params49 << 0.0794872790575027466, 19.6530551910400391, -0.165329158306121826,
+      0.773633182048797607, 0.000477823166875168681 * 1. / (1_MeV), 0;
+  Covariance covMat49;
+  covMat49 << 0.00381630496121942997, -8.74287441500089918e-05,
+      -0.000100106500619540973, -8.38715409757558135e-08,
+      -6.2290859493643327e-08 * 1. / (1_MeV), 0, -8.74287441500089918e-05,
+      0.0162235908210277557, 2.22223959083791618e-08, 0.000172105791708528197,
+      1.96493926730074329e-10 * 1. / (1_MeV), 0, -0.000100106500619540973,
+      2.22223959083791618e-08, 2.75529328064294532e-06,
+      -2.06184740167500454e-08, 2.69172215410859302e-09 * 1. / (1_MeV), 0,
+      -8.38715409757558135e-08, 0.000172105791708528197,
+      -2.06184740167500454e-08, 2.09498148251441307e-06,
+      8.40879734889098381e-12 * 1. / (1_MeV), 0,
+      -6.2290859493643327e-08 * 1. / (1_MeV),
+      1.96493926730074329e-10 * 1. / (1_MeV),
+      2.69172215410859302e-09 * 1. / (1_MeV),
+      8.40879734889098381e-12 * 1. / (1_MeV),
+      6.77461420295344396e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform49;
+  ActsSymMatrixD<3> rotMat49;
+  rotMat49 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform49.rotate(rotMat49);
+  transform49.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans49 = std::make_shared<const Transform3D>(transform49);
+  std::shared_ptr<PerigeeSurface> perigeeSurface49 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams49 = BoundParameters(tgContext, std::move(covMat49), params49,
+                                       perigeeSurface49);
+  tracks.push_back(boundParams49);
+
+  // track 50 :
+  BoundVector params50;
+  params50 << 0.00257234717719256878, 19.729034423828125, -2.48443388938903809,
+      2.36831569671630859, 0.000639270059764385223 * 1. / (1_MeV), 0;
+  Covariance covMat50;
+  covMat50 << 0.00514977378770709038, 1.5274217220811411e-06,
+      -0.000146212466763405544, -7.3820246046654258e-07,
+      -9.37751309006686478e-08 * 1. / (1_MeV), 0, 1.5274217220811411e-06,
+      0.0244287420064210892, 3.30349992626133354e-06, 0.000276546223727476613,
+      -7.14985035003895647e-10 * 1. / (1_MeV), 0, -0.000146212466763405544,
+      3.30349992626133354e-06, 4.3204604480706621e-06, 5.8973252791929605e-08,
+      4.5218636718828268e-09 * 1. / (1_MeV), 0, -7.3820246046654258e-07,
+      0.000276546223727476613, 5.8973252791929605e-08, 3.42068551617558114e-06,
+      -2.22231801612401744e-12 * 1. / (1_MeV), 0,
+      -9.37751309006686478e-08 * 1. / (1_MeV),
+      -7.14985035003895647e-10 * 1. / (1_MeV),
+      4.5218636718828268e-09 * 1. / (1_MeV),
+      -2.22231801612401744e-12 * 1. / (1_MeV),
+      1.24709936821787437e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform50;
+  ActsSymMatrixD<3> rotMat50;
+  rotMat50 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform50.rotate(rotMat50);
+  transform50.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans50 = std::make_shared<const Transform3D>(transform50);
+  std::shared_ptr<PerigeeSurface> perigeeSurface50 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams50 = BoundParameters(tgContext, std::move(covMat50), params50,
+                                       perigeeSurface50);
+  tracks.push_back(boundParams50);
+
+  // track 51 :
+  BoundVector params51;
+  params51 << 0.00432245805859565735, 19.7588119506835938, 2.78170585632324219,
+      1.317923903465271, 0.000862165645230561495 * 1. / (1_MeV), 0;
+  Covariance covMat51;
+  covMat51 << 0.00373272784054279327, -3.13153124378761361e-05,
+      -0.000104918640992595442, 7.88207645809147621e-08,
+      -5.3073184749102294e-08 * 1. / (1_MeV), 0, -3.13153124378761361e-05,
+      0.014620266854763031, 4.37770160231162941e-09, 0.000248047817836983295,
+      -1.07342837668986752e-09 * 1. / (1_MeV), 0, -0.000104918640992595442,
+      4.37770160231162941e-09, 3.04561854136409238e-06,
+      -1.80148965656686955e-08, 2.31705476916370874e-09 * 1. / (1_MeV), 0,
+      7.88207645809147621e-08, 0.000248047817836983295,
+      -1.80148965656686955e-08, 5.14808971274760552e-06,
+      -2.17782802728119955e-11 * 1. / (1_MeV), 0,
+      -5.3073184749102294e-08 * 1. / (1_MeV),
+      -1.07342837668986752e-09 * 1. / (1_MeV),
+      2.31705476916370874e-09 * 1. / (1_MeV),
+      -2.17782802728119955e-11 * 1. / (1_MeV),
+      7.92517093617384205e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform51;
+  ActsSymMatrixD<3> rotMat51;
+  rotMat51 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform51.rotate(rotMat51);
+  transform51.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans51 = std::make_shared<const Transform3D>(transform51);
+  std::shared_ptr<PerigeeSurface> perigeeSurface51 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams51 = BoundParameters(tgContext, std::move(covMat51), params51,
+                                       perigeeSurface51);
+  tracks.push_back(boundParams51);
+
+  // track 52 :
+  BoundVector params52;
+  params52 << -0.0435933880507946014, 19.7911624908447266, 3.11164975166320801,
+      2.34090805053710938, -0.000378097058273851871 * 1. / (1_MeV), 0;
+  Covariance covMat52;
+  covMat52 << 0.00186390290036797523, 8.51901326696253696e-05,
+      -5.26206213063089263e-05, 7.5721243893402984e-07,
+      -3.6471728778736459e-08 * 1. / (1_MeV), 0, 8.51901326696253696e-05,
+      0.0111065087839961052, -2.43677190069158359e-06, 0.00011281071944759972,
+      -1.62019250256225185e-09 * 1. / (1_MeV), 0, -5.26206213063089263e-05,
+      -2.43677190069158359e-06, 1.54202029989392031e-06,
+      -2.53458777355814022e-08, 1.63474855631190684e-09 * 1. / (1_MeV), 0,
+      7.5721243893402984e-07, 0.00011281071944759972, -2.53458777355814022e-08,
+      1.39124506404186832e-06, -1.08965746715162531e-11 * 1. / (1_MeV), 0,
+      -3.6471728778736459e-08 * 1. / (1_MeV),
+      -1.62019250256225185e-09 * 1. / (1_MeV),
+      1.63474855631190684e-09 * 1. / (1_MeV),
+      -1.08965746715162531e-11 * 1. / (1_MeV),
+      4.23658642889623849e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform52;
+  ActsSymMatrixD<3> rotMat52;
+  rotMat52 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform52.rotate(rotMat52);
+  transform52.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans52 = std::make_shared<const Transform3D>(transform52);
+  std::shared_ptr<PerigeeSurface> perigeeSurface52 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams52 = BoundParameters(tgContext, std::move(covMat52), params52,
+                                       perigeeSurface52);
+  tracks.push_back(boundParams52);
+
+  // track 53 :
+  BoundVector params53;
+  params53 << -0.0815948843955993652, 19.7372093200683594, -1.84946024417877197,
+      1.14923441410064697, 0.000601470586843788624 * 1. / (1_MeV), 0;
+  Covariance covMat53;
+  covMat53 << 0.00196050899103283882, -1.67352628138899218e-05,
+      -5.56634758072358207e-05, 3.7875159202534098e-07,
+      -3.03494187297867561e-08 * 1. / (1_MeV), 0, -1.67352628138899218e-05,
+      0.0112847397103905678, -1.93632011387631403e-07, 0.000171461400770045192,
+      -2.16268131821945559e-09 * 1. / (1_MeV), 0, -5.56634758072358207e-05,
+      -1.93632011387631403e-07, 1.63677134423778625e-06,
+      -2.31373868535455102e-08, 1.4041644457469446e-09 * 1. / (1_MeV), 0,
+      3.7875159202534098e-07, 0.000171461400770045192, -2.31373868535455102e-08,
+      3.31649607687722892e-06, -5.16496243030849994e-11 * 1. / (1_MeV), 0,
+      -3.03494187297867561e-08 * 1. / (1_MeV),
+      -2.16268131821945559e-09 * 1. / (1_MeV),
+      1.4041644457469446e-09 * 1. / (1_MeV),
+      -5.16496243030849994e-11 * 1. / (1_MeV),
+      4.88036555612580969e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform53;
+  ActsSymMatrixD<3> rotMat53;
+  rotMat53 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform53.rotate(rotMat53);
+  transform53.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans53 = std::make_shared<const Transform3D>(transform53);
+  std::shared_ptr<PerigeeSurface> perigeeSurface53 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams53 = BoundParameters(tgContext, std::move(covMat53), params53,
+                                       perigeeSurface53);
+  tracks.push_back(boundParams53);
+
+  // track 54 :
+  BoundVector params54;
+  params54 << -0.177310273051261902, 19.6348361968994141, -1.05560946464538574,
+      2.24611258506774902, -0.000753726519178599119 * 1. / (1_MeV), 0;
+  Covariance covMat54;
+  covMat54 << 0.00495443679392337799, 0.000157203730621089283,
+      -0.000141684325914573155, 2.30922207144066844e-06,
+      -7.94592181976909059e-08 * 1. / (1_MeV), 0, 0.000157203730621089283,
+      0.0229040328413248062, -6.34654599119513331e-06, 0.000306214725126755156,
+      -1.2839975429398817e-09 * 1. / (1_MeV), 0, -0.000141684325914573155,
+      -6.34654599119513331e-06, 4.18058425566414371e-06,
+      -9.91975383724877058e-08, 3.78214495931995838e-09 * 1. / (1_MeV), 0,
+      2.30922207144066844e-06, 0.000306214725126755156,
+      -9.91975383724877058e-08, 4.69660699309315532e-06,
+      -2.63341946589812984e-11 * 1. / (1_MeV), 0,
+      -7.94592181976909059e-08 * 1. / (1_MeV),
+      -1.2839975429398817e-09 * 1. / (1_MeV),
+      3.78214495931995838e-09 * 1. / (1_MeV),
+      -2.63341946589812984e-11 * 1. / (1_MeV),
+      1.1374100272742993e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform54;
+  ActsSymMatrixD<3> rotMat54;
+  rotMat54 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform54.rotate(rotMat54);
+  transform54.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans54 = std::make_shared<const Transform3D>(transform54);
+  std::shared_ptr<PerigeeSurface> perigeeSurface54 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams54 = BoundParameters(tgContext, std::move(covMat54), params54,
+                                       perigeeSurface54);
+  tracks.push_back(boundParams54);
+
+  // track 55 :
+  BoundVector params55;
+  params55 << 0.0785293355584144592, 19.6328811645507812, 2.59513092041015625,
+      2.38374710083007812, -0.000732663145754486322 * 1. / (1_MeV), 0;
+  Covariance covMat55;
+  covMat55 << 0.00641396967694163322, 0.000246878889801438277,
+      -0.000189181604721914515, 3.34410570581822042e-06,
+      -2.14548746767764377e-07 * 1. / (1_MeV), 0, 0.000246878889801438277,
+      0.0336174145340919495, -1.03550476761815197e-05, 0.000399278313453293142,
+      -2.56304746534435936e-09 * 1. / (1_MeV), 0, -0.000189181604721914515,
+      -1.03550476761815197e-05, 5.75400417801574804e-06,
+      -1.44846765580733777e-07, 1.06792194541960512e-08 * 1. / (1_MeV), 0,
+      3.34410570581822042e-06, 0.000399278313453293142,
+      -1.44846765580733777e-07, 5.08104403706965968e-06,
+      -7.68042699731362161e-11 * 1. / (1_MeV), 0,
+      -2.14548746767764377e-07 * 1. / (1_MeV),
+      -2.56304746534435936e-09 * 1. / (1_MeV),
+      1.06792194541960512e-08 * 1. / (1_MeV),
+      -7.68042699731362161e-11 * 1. / (1_MeV),
+      2.95886121159938398e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform55;
+  ActsSymMatrixD<3> rotMat55;
+  rotMat55 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform55.rotate(rotMat55);
+  transform55.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans55 = std::make_shared<const Transform3D>(transform55);
+  std::shared_ptr<PerigeeSurface> perigeeSurface55 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams55 = BoundParameters(tgContext, std::move(covMat55), params55,
+                                       perigeeSurface55);
+  tracks.push_back(boundParams55);
+
+  // track 56 :
+  BoundVector params56;
+  params56 << 0.0173604916781187057, 19.5246124267578125, -2.51582574844360352,
+      0.414047539234161377, -0.00071090972051024437 * 1. / (1_MeV), 0;
+  Covariance covMat56;
+  covMat56 << 0.0283498577773571014, -0.000298887250477381634,
+      -0.000882125049864636171, -6.77869111648309038e-06,
+      -5.9098209889401522e-07 * 1. / (1_MeV), 0, -0.000298887250477381634,
+      0.192199692130088806, 4.3839556454493579e-05, 0.000923672206091380129,
+      -1.8091079261186684e-08 * 1. / (1_MeV), 0, -0.000882125049864636171,
+      4.3839556454493579e-05, 2.79919677268480882e-05, 3.80641892247414598e-07,
+      3.08266368106537475e-08 * 1. / (1_MeV), 0, -6.77869111648309038e-06,
+      0.000923672206091380129, 3.80641892247414598e-07, 4.52563699582242407e-06,
+      3.57023520457822254e-12 * 1. / (1_MeV), 0,
+      -5.9098209889401522e-07 * 1. / (1_MeV),
+      -1.8091079261186684e-08 * 1. / (1_MeV),
+      3.08266368106537475e-08 * 1. / (1_MeV),
+      3.57023520457822254e-12 * 1. / (1_MeV),
+      5.16008458184558094e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform56;
+  ActsSymMatrixD<3> rotMat56;
+  rotMat56 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform56.rotate(rotMat56);
+  transform56.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans56 = std::make_shared<const Transform3D>(transform56);
+  std::shared_ptr<PerigeeSurface> perigeeSurface56 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams56 = BoundParameters(tgContext, std::move(covMat56), params56,
+                                       perigeeSurface56);
+  tracks.push_back(boundParams56);
+
+  // track 57 :
+  BoundVector params57;
+  params57 << -0.112078636884689331, 19.7138767242431641, -1.84679484367370605,
+      0.794435799121856689, -0.00114586413837969303 * 1. / (1_MeV), 0;
+  Covariance covMat57;
+  covMat57 << 0.0125628607347607613, -0.00042401806910040711,
+      -0.000382159145328276348, -7.02945588660621349e-06,
+      -2.92791162690266574e-07 * 1. / (1_MeV), 0, -0.00042401806910040711,
+      0.0519770048558712006, 2.22396418071489764e-05, 0.000696764565518564701,
+      2.67979975211747671e-10 * 1. / (1_MeV), 0, -0.000382159145328276348,
+      2.22396418071489764e-05, 1.18492389447055757e-05, 3.53736964679786492e-07,
+      1.47490199626806416e-08 * 1. / (1_MeV), 0, -7.02945588660621349e-06,
+      0.000696764565518564701, 3.53736964679786492e-07, 9.91684009932214394e-06,
+      3.12549388487418662e-11 * 1. / (1_MeV), 0,
+      -2.92791162690266574e-07 * 1. / (1_MeV),
+      2.67979975211747671e-10 * 1. / (1_MeV),
+      1.47490199626806416e-08 * 1. / (1_MeV),
+      3.12549388487418662e-11 * 1. / (1_MeV),
+      4.27830326721334586e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform57;
+  ActsSymMatrixD<3> rotMat57;
+  rotMat57 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform57.rotate(rotMat57);
+  transform57.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans57 = std::make_shared<const Transform3D>(transform57);
+  std::shared_ptr<PerigeeSurface> perigeeSurface57 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams57 = BoundParameters(tgContext, std::move(covMat57), params57,
+                                       perigeeSurface57);
+  tracks.push_back(boundParams57);
+
+  // track 58 :
+  BoundVector params58;
+  params58 << -0.0965623259544372559, 19.6627426147460938, -1.23312962055206299,
+      0.805159807205200195, -0.000906686065718531609 * 1. / (1_MeV), 0;
+  Covariance covMat58;
+  covMat58 << 0.00830374658107757568, -0.000373302939962240744,
+      -0.000247266029281000856, -5.00495608162803572e-06,
+      -2.0945470573896415e-07 * 1. / (1_MeV), 0, -0.000373302939962240744,
+      0.0380906462669372559, 1.53532999294112871e-05, 0.000496518269343126733,
+      5.03471984032882939e-09 * 1. / (1_MeV), 0, -0.000247266029281000856,
+      1.53532999294112871e-05, 7.52212054067058489e-06, 2.17835177699819493e-07,
+      9.95587606736010666e-09 * 1. / (1_MeV), 0, -5.00495608162803572e-06,
+      0.000496518269343126733, 2.17835177699819493e-07, 6.91647301209741272e-06,
+      8.81431839589435575e-11 * 1. / (1_MeV), 0,
+      -2.0945470573896415e-07 * 1. / (1_MeV),
+      5.03471984032882939e-09 * 1. / (1_MeV),
+      9.95587606736010666e-09 * 1. / (1_MeV),
+      8.81431839589435575e-11 * 1. / (1_MeV),
+      2.77544126570106187e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform58;
+  ActsSymMatrixD<3> rotMat58;
+  rotMat58 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform58.rotate(rotMat58);
+  transform58.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans58 = std::make_shared<const Transform3D>(transform58);
+  std::shared_ptr<PerigeeSurface> perigeeSurface58 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams58 = BoundParameters(tgContext, std::move(covMat58), params58,
+                                       perigeeSurface58);
+  tracks.push_back(boundParams58);
+
+  // track 59 :
+  BoundVector params59;
+  params59 << -0.0626908987760543823, 19.7716445922851562, -2.40555191040039062,
+      2.8678133487701416, -0.000198848822037689388 * 1. / (1_MeV), 0;
+  Covariance covMat59;
+  covMat59 << 0.00839335378259420395, 0.000910603415829014081,
+      -0.00025100860818204118, 1.87096007159414942e-06,
+      -9.31870020461924718e-08 * 1. / (1_MeV), 0, 0.000910603415829014081,
+      0.129513055086135864, -2.86761617086296627e-05, 0.000273189216280241291,
+      -4.74956078553265506e-09 * 1. / (1_MeV), 0, -0.00025100860818204118,
+      -2.86761617086296627e-05, 7.71244413044769317e-06,
+      -6.31332272284558137e-08, 4.62778036643537694e-09 * 1. / (1_MeV), 0,
+      1.87096007159414942e-06, 0.000273189216280241291,
+      -6.31332272284558137e-08, 5.91468733546207659e-07,
+      -9.64516546051573345e-12 * 1. / (1_MeV), 0,
+      -9.31870020461924718e-08 * 1. / (1_MeV),
+      -4.74956078553265506e-09 * 1. / (1_MeV),
+      4.62778036643537694e-09 * 1. / (1_MeV),
+      -9.64516546051573345e-12 * 1. / (1_MeV),
+      5.01616283232753091e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform59;
+  ActsSymMatrixD<3> rotMat59;
+  rotMat59 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform59.rotate(rotMat59);
+  transform59.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans59 = std::make_shared<const Transform3D>(transform59);
+  std::shared_ptr<PerigeeSurface> perigeeSurface59 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams59 = BoundParameters(tgContext, std::move(covMat59), params59,
+                                       perigeeSurface59);
+  tracks.push_back(boundParams59);
+
+  // track 60 :
+  BoundVector params60;
+  params60 << -0.0142064439132809639, 19.7910060882568359, 0.168578088283538818,
+      0.479709357023239136, -0.000404727092245593667 * 1. / (1_MeV), 0;
+  Covariance covMat60;
+  covMat60 << 0.00775946257635951042, -0.000358691551729211646,
+      -0.000217197427685534829, -2.56510932869304508e-06,
+      -7.90923951223065759e-08 * 1. / (1_MeV), 0, -0.000358691551729211646,
+      0.052836686372756958, 1.3965907239243096e-05, 0.000293662591417361029,
+      3.13017533889238816e-10 * 1. / (1_MeV), 0, -0.000217197427685534829,
+      1.3965907239243096e-05, 6.26508744971943088e-06, 9.72321745154080499e-08,
+      3.84228193539540777e-09 * 1. / (1_MeV), 0, -2.56510932869304508e-06,
+      0.000293662591417361029, 9.72321745154080499e-08, 1.70067016824759776e-06,
+      6.77559228363657895e-12 * 1. / (1_MeV), 0,
+      -7.90923951223065759e-08 * 1. / (1_MeV),
+      3.13017533889238816e-10 * 1. / (1_MeV),
+      3.84228193539540777e-09 * 1. / (1_MeV),
+      6.77559228363657895e-12 * 1. / (1_MeV),
+      6.94686808078159856e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform60;
+  ActsSymMatrixD<3> rotMat60;
+  rotMat60 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform60.rotate(rotMat60);
+  transform60.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans60 = std::make_shared<const Transform3D>(transform60);
+  std::shared_ptr<PerigeeSurface> perigeeSurface60 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams60 = BoundParameters(tgContext, std::move(covMat60), params60,
+                                       perigeeSurface60);
+  tracks.push_back(boundParams60);
+
+  // track 61 :
+  BoundVector params61;
+  params61 << -0.219206094741821289, 20.4783496856689453, -0.292800366878509521,
+      2.68957734107971191, -0.000572857388760894537 * 1. / (1_MeV), 0;
+  Covariance covMat61;
+  covMat61 << 0.0146720772609114647, 0.000633603948713714737,
+      -0.000435564556254993611, 4.1380172183317663e-06,
+      -1.65861978224238241e-07 * 1. / (1_MeV), 0, 0.000633603948713714737,
+      0.0937191098928451538, -3.01445904596889702e-05, 0.000503828587046026917,
+      9.92026904049769552e-10 * 1. / (1_MeV), 0, -0.000435564556254993611,
+      -3.01445904596889702e-05, 1.31324359244899824e-05,
+      -1.88451279319618993e-07, 8.03478199107072473e-09 * 1. / (1_MeV), 0,
+      4.1380172183317663e-06, 0.000503828587046026917, -1.88451279319618993e-07,
+      2.77083131550170947e-06, 3.79284582712100777e-12 * 1. / (1_MeV), 0,
+      -1.65861978224238241e-07 * 1. / (1_MeV),
+      9.92026904049769552e-10 * 1. / (1_MeV),
+      8.03478199107072473e-09 * 1. / (1_MeV),
+      3.79284582712100777e-12 * 1. / (1_MeV),
+      1.37340042116740335e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform61;
+  ActsSymMatrixD<3> rotMat61;
+  rotMat61 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform61.rotate(rotMat61);
+  transform61.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans61 = std::make_shared<const Transform3D>(transform61);
+  std::shared_ptr<PerigeeSurface> perigeeSurface61 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams61 = BoundParameters(tgContext, std::move(covMat61), params61,
+                                       perigeeSurface61);
+  tracks.push_back(boundParams61);
+
+  // track 62 :
+  BoundVector params62;
+  params62 << 0.0636809840798377991, 19.6062507629394531, 0.571447312831878662,
+      0.867952585220336914, 0.00121437374036759138 * 1. / (1_MeV), 0;
+  Covariance covMat62;
+  covMat62 << 0.0128781227394938469, 0.000273969979431750051,
+      -0.000375215863743342181, 8.19368995942778944e-06,
+      -3.39195297106111847e-07 * 1. / (1_MeV), 0, 0.000273969979431750051,
+      0.0600576512515544891, -2.2149498630265022e-05, 0.000888745641943021122,
+      -2.03770348687604627e-09 * 1. / (1_MeV), 0, -0.000375215863743342181,
+      -2.2149498630265022e-05, 1.11544741230318323e-05,
+      -4.44362300871132803e-07, 1.59093394709295358e-08 * 1. / (1_MeV), 0,
+      8.19368995942778944e-06, 0.000888745641943021122,
+      -4.44362300871132803e-07, 1.38034411065746099e-05,
+      -1.03151432469073304e-10 * 1. / (1_MeV), 0,
+      -3.39195297106111847e-07 * 1. / (1_MeV),
+      -2.03770348687604627e-09 * 1. / (1_MeV),
+      1.59093394709295358e-08 * 1. / (1_MeV),
+      -1.03151432469073304e-10 * 1. / (1_MeV),
+      4.62565652448176934e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform62;
+  ActsSymMatrixD<3> rotMat62;
+  rotMat62 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform62.rotate(rotMat62);
+  transform62.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans62 = std::make_shared<const Transform3D>(transform62);
+  std::shared_ptr<PerigeeSurface> perigeeSurface62 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams62 = BoundParameters(tgContext, std::move(covMat62), params62,
+                                       perigeeSurface62);
+  tracks.push_back(boundParams62);
+
+  // track 63 :
+  BoundVector params63;
+  params63 << 0.256703495979309082, 20.4742660522460938, 2.0388495922088623,
+      0.835670650005340576, -0.00106730952393263578 * 1. / (1_MeV), 0;
+  Covariance covMat63;
+  covMat63 << 0.00996344629675149918, -0.000111380282247894335,
+      -0.000297672988748523071, -4.10640820399169642e-06,
+      -2.92419518098666387e-07 * 1. / (1_MeV), 0, -0.000111380282247894335,
+      0.0370076149702072144, 9.57343920283051857e-06, 0.000522519448946792003,
+      -7.68861322556322209e-09 * 1. / (1_MeV), 0, -0.000297672988748523071,
+      9.57343920283051857e-06, 9.07736284716520458e-06, 2.19650252980074214e-07,
+      1.46923783244468664e-08 * 1. / (1_MeV), 0, -4.10640820399169642e-06,
+      0.000522519448946792003, 2.19650252980074214e-07, 7.87897715781582519e-06,
+      -2.63692280030132723e-11 * 1. / (1_MeV), 0,
+      -2.92419518098666387e-07 * 1. / (1_MeV),
+      -7.68861322556322209e-09 * 1. / (1_MeV),
+      1.46923783244468664e-08 * 1. / (1_MeV),
+      -2.63692280030132723e-11 * 1. / (1_MeV),
+      4.39882824609938439e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform63;
+  ActsSymMatrixD<3> rotMat63;
+  rotMat63 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform63.rotate(rotMat63);
+  transform63.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans63 = std::make_shared<const Transform3D>(transform63);
+  std::shared_ptr<PerigeeSurface> perigeeSurface63 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams63 = BoundParameters(tgContext, std::move(covMat63), params63,
+                                       perigeeSurface63);
+  tracks.push_back(boundParams63);
+
+  // track 64 :
+  BoundVector params64;
+  params64 << 0.120990529656410217, 19.6643028259277344, 2.09903669357299805,
+      0.376666009426116943, 0.000600203988142311573 * 1. / (1_MeV), 0;
+  Covariance covMat64;
+  covMat64 << 0.0291396286338567734, 5.39021723134598197e-05,
+      -0.000882721168274605778, 4.14864371809709873e-06,
+      -5.5001142494950611e-07 * 1. / (1_MeV), 0, 5.39021723134598197e-05,
+      0.234371468424797058, -4.16871244043210621e-05, 0.000918528875032399673,
+      1.39816410013920925e-08 * 1. / (1_MeV), 0, -0.000882721168274605778,
+      -4.16871244043210621e-05, 2.72563647740753368e-05,
+      -2.79753257845384789e-07, 2.7634673800087543e-08 * 1. / (1_MeV), 0,
+      4.14864371809709873e-06, 0.000918528875032399673,
+      -2.79753257845384789e-07, 3.6635033211496193e-06,
+      1.58046165958546609e-11 * 1. / (1_MeV), 0,
+      -5.5001142494950611e-07 * 1. / (1_MeV),
+      1.39816410013920925e-08 * 1. / (1_MeV),
+      2.7634673800087543e-08 * 1. / (1_MeV),
+      1.58046165958546609e-11 * 1. / (1_MeV),
+      4.08823086495146981e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform64;
+  ActsSymMatrixD<3> rotMat64;
+  rotMat64 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform64.rotate(rotMat64);
+  transform64.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans64 = std::make_shared<const Transform3D>(transform64);
+  std::shared_ptr<PerigeeSurface> perigeeSurface64 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams64 = BoundParameters(tgContext, std::move(covMat64), params64,
+                                       perigeeSurface64);
+  tracks.push_back(boundParams64);
+
+  // track 65 :
+  BoundVector params65;
+  params65 << 0.0062864348292350769, 19.6056728363037109, 1.96336662769317627,
+      1.67587447166442871, -0.00098716001957654953 * 1. / (1_MeV), 0;
+  Covariance covMat65;
+  covMat65 << 0.00639463262632489204, 2.92739463404503888e-05,
+      -0.000162262223266041843, 7.35056423966357298e-07,
+      -6.22851560331579401e-08 * 1. / (1_MeV), 0, 2.92739463404503888e-05,
+      0.0197239704430103302, -1.20671194756186941e-06, 0.000422495468900870442,
+      -7.46651628897230336e-10 * 1. / (1_MeV), 0, -0.000162262223266041843,
+      -1.20671194756186941e-06, 4.31130820288672112e-06,
+      -3.10329014828531918e-08, 2.84192773413970349e-09 * 1. / (1_MeV), 0,
+      7.35056423966357298e-07, 0.000422495468900870442,
+      -3.10329014828531918e-08, 1.06411953311180696e-05,
+      -4.82012337741633492e-13 * 1. / (1_MeV), 0,
+      -6.22851560331579401e-08 * 1. / (1_MeV),
+      -7.46651628897230336e-10 * 1. / (1_MeV),
+      2.84192773413970349e-09 * 1. / (1_MeV),
+      -4.82012337741633492e-13 * 1. / (1_MeV),
+      1.05485536971983151e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform65;
+  ActsSymMatrixD<3> rotMat65;
+  rotMat65 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform65.rotate(rotMat65);
+  transform65.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans65 = std::make_shared<const Transform3D>(transform65);
+  std::shared_ptr<PerigeeSurface> perigeeSurface65 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams65 = BoundParameters(tgContext, std::move(covMat65), params65,
+                                       perigeeSurface65);
+  tracks.push_back(boundParams65);
+
+  // track 66 :
+  BoundVector params66;
+  params66 << 0.0955945327877998352, 20.2347850799560547, -0.327246248722076416,
+      2.98204421997070312, 2.21292903006542474e-05 * 1. / (1_MeV), 0;
+  Covariance covMat66;
+  covMat66 << 0.00150146521627902985, 0.0023395733708214345,
+      -3.76246492337360715e-05, 1.20517570859588883e-06,
+      -1.54414914830204655e-08 * 1. / (1_MeV), 0, 0.0023395733708214345,
+      0.0877117365598678589, -4.71741381729428471e-05, 5.21609361100870518e-05,
+      3.25177228611905034e-10 * 1. / (1_MeV), 0, -3.76246492337360715e-05,
+      -4.71741381729428471e-05, 1.0044809641840402e-06,
+      -2.48049212962453205e-08, 6.86903087291782125e-10 * 1. / (1_MeV), 0,
+      1.20517570859588883e-06, 5.21609361100870518e-05,
+      -2.48049212962453205e-08, 3.23552171721530613e-08,
+      2.29084759303353043e-13 * 1. / (1_MeV), 0,
+      -1.54414914830204655e-08 * 1. / (1_MeV),
+      3.25177228611905034e-10 * 1. / (1_MeV),
+      6.86903087291782125e-10 * 1. / (1_MeV),
+      2.29084759303353043e-13 * 1. / (1_MeV),
+      3.96015121736925657e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform66;
+  ActsSymMatrixD<3> rotMat66;
+  rotMat66 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform66.rotate(rotMat66);
+  transform66.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans66 = std::make_shared<const Transform3D>(transform66);
+  std::shared_ptr<PerigeeSurface> perigeeSurface66 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams66 = BoundParameters(tgContext, std::move(covMat66), params66,
+                                       perigeeSurface66);
+  tracks.push_back(boundParams66);
+
+  // track 67 :
+  BoundVector params67;
+  params67 << 0.382039725780487061, 20.0302467346191406, 1.78882849216461182,
+      2.7296445369720459, 0.000560962012968957424 * 1. / (1_MeV), 0;
+  Covariance covMat67;
+  covMat67 << 0.0185648687183856964, -0.000512420938441797555,
+      -0.000564488122844988122, -3.46646347767409226e-06,
+      -6.9752293121264101e-07 * 1. / (1_MeV), 0, -0.000512420938441797555,
+      0.158824682235717773, 4.20228128232319107e-05, 0.000710107550351205766,
+      5.56717392340507163e-09 * 1. / (1_MeV), 0, -0.000564488122844988122,
+      4.20228128232319107e-05, 1.76464527612552047e-05, 2.17145732577765049e-07,
+      3.41404923239805513e-08 * 1. / (1_MeV), 0, -3.46646347767409226e-06,
+      0.000710107550351205766, 2.17145732577765049e-07, 3.26669078276609071e-06,
+      -1.08290629522060115e-11 * 1. / (1_MeV), 0,
+      -6.9752293121264101e-07 * 1. / (1_MeV),
+      5.56717392340507163e-09 * 1. / (1_MeV),
+      3.41404923239805513e-08 * 1. / (1_MeV),
+      -1.08290629522060115e-11 * 1. / (1_MeV),
+      5.43119271778635948e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform67;
+  ActsSymMatrixD<3> rotMat67;
+  rotMat67 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform67.rotate(rotMat67);
+  transform67.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans67 = std::make_shared<const Transform3D>(transform67);
+  std::shared_ptr<PerigeeSurface> perigeeSurface67 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams67 = BoundParameters(tgContext, std::move(covMat67), params67,
+                                       perigeeSurface67);
+  tracks.push_back(boundParams67);
+
+  // track 68 :
+  BoundVector params68;
+  params68 << -0.179121747612953186, 20.2514362335205078, -0.862554371356964111,
+      2.68916535377502441, -0.000457327318144962192 * 1. / (1_MeV), 0;
+  Covariance covMat68;
+  covMat68 << 0.0108809741213917732, 0.00193338631898851772,
+      -0.000310007020929202329, 8.43655106315042699e-06,
+      -1.10126677038094219e-07 * 1. / (1_MeV), 0, 0.00193338631898851772,
+      0.0997641086578369141, -5.31462636732746974e-05, 0.000479126202409259187,
+      -3.00325838913588194e-09 * 1. / (1_MeV), 0, -0.000310007020929202329,
+      -5.31462636732746974e-05, 9.10317794478032738e-06,
+      -2.45896355006014845e-07, 5.3026650853642868e-09 * 1. / (1_MeV), 0,
+      8.43655106315042699e-06, 0.000479126202409259187,
+      -2.45896355006014845e-07, 2.40905660575663205e-06,
+      -1.12621932829046352e-11 * 1. / (1_MeV), 0,
+      -1.10126677038094219e-07 * 1. / (1_MeV),
+      -3.00325838913588194e-09 * 1. / (1_MeV),
+      5.3026650853642868e-09 * 1. / (1_MeV),
+      -1.12621932829046352e-11 * 1. / (1_MeV),
+      9.04395031087190659e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform68;
+  ActsSymMatrixD<3> rotMat68;
+  rotMat68 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform68.rotate(rotMat68);
+  transform68.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans68 = std::make_shared<const Transform3D>(transform68);
+  std::shared_ptr<PerigeeSurface> perigeeSurface68 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams68 = BoundParameters(tgContext, std::move(covMat68), params68,
+                                       perigeeSurface68);
+  tracks.push_back(boundParams68);
+
+  // track 69 :
+  BoundVector params69;
+  params69 << -0.138331592082977295, 19.3751182556152344, -1.35278940200805664,
+      0.381486982107162476, -0.000426069716922938824 * 1. / (1_MeV), 0;
+  Covariance covMat69;
+  covMat69 << 0.0138281593099236488, -0.000802064074892135472,
+      -0.000420553068714103143, -3.62152568304627602e-06,
+      -1.71446784106220126e-07 * 1. / (1_MeV), 0, -0.000802064074892135472,
+      0.124462626874446869, 3.35644323921618966e-05, 0.000489752797097319013,
+      1.53338361947342647e-09 * 1. / (1_MeV), 0, -0.000420553068714103143,
+      3.35644323921618966e-05, 1.3009085705562029e-05, 1.52739817453807061e-07,
+      8.51389247727636405e-09 * 1. / (1_MeV), 0, -3.62152568304627602e-06,
+      0.000489752797097319013, 1.52739817453807061e-07, 1.98223324332502671e-06,
+      7.74913828351229925e-12 * 1. / (1_MeV), 0,
+      -1.71446784106220126e-07 * 1. / (1_MeV),
+      1.53338361947342647e-09 * 1. / (1_MeV),
+      8.51389247727636405e-09 * 1. / (1_MeV),
+      7.74913828351229925e-12 * 1. / (1_MeV),
+      1.26564134173001719e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform69;
+  ActsSymMatrixD<3> rotMat69;
+  rotMat69 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform69.rotate(rotMat69);
+  transform69.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans69 = std::make_shared<const Transform3D>(transform69);
+  std::shared_ptr<PerigeeSurface> perigeeSurface69 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams69 = BoundParameters(tgContext, std::move(covMat69), params69,
+                                       perigeeSurface69);
+  tracks.push_back(boundParams69);
+
+  // track 70 :
+  BoundVector params70;
+  params70 << -0.0937596634030342102, 19.4900455474853516,
+      -0.352513551712036133, 2.89332342147827148,
+      -0.000186513439984992146 * 1. / (1_MeV), 0;
+  Covariance covMat70;
+  covMat70 << 0.0097403964027762413, 0.00166471584749119505,
+      -0.000287947885317068881, 2.55751055140476181e-06,
+      -7.81118139203814757e-08 * 1. / (1_MeV), 0, 0.00166471584749119505,
+      0.204256042838096619, -4.79791071918836e-05, 0.000340033153539362216,
+      -1.95895871236344388e-09 * 1. / (1_MeV), 0, -0.000287947885317068881,
+      -4.79791071918836e-05, 8.6775098679936491e-06, -7.89068829617864185e-08,
+      3.73986494276367498e-09 * 1. / (1_MeV), 0, 2.55751055140476181e-06,
+      0.000340033153539362216, -7.89068829617864185e-08, 5.8173242223347188e-07,
+      -3.34422452468073519e-12 * 1. / (1_MeV), 0,
+      -7.81118139203814757e-08 * 1. / (1_MeV),
+      -1.95895871236344388e-09 * 1. / (1_MeV),
+      3.73986494276367498e-09 * 1. / (1_MeV),
+      -3.34422452468073519e-12 * 1. / (1_MeV),
+      3.56935557499493683e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform70;
+  ActsSymMatrixD<3> rotMat70;
+  rotMat70 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform70.rotate(rotMat70);
+  transform70.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans70 = std::make_shared<const Transform3D>(transform70);
+  std::shared_ptr<PerigeeSurface> perigeeSurface70 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams70 = BoundParameters(tgContext, std::move(covMat70), params70,
+                                       perigeeSurface70);
+  tracks.push_back(boundParams70);
+
+  // track 71 :
+  BoundVector params71;
+  params71 << -0.031271662563085556, 19.7582015991210938, -0.544847011566162109,
+      2.35719013214111328, -0.00060985935851931572 * 1. / (1_MeV), 0;
+  Covariance covMat71;
+  covMat71 << 0.00421266257762908936, 0.000139259250319359563,
+      -0.000121986267999964622, 1.59459282051017784e-06,
+      -9.93183532021228265e-08 * 1. / (1_MeV), 0, 0.000139259250319359563,
+      0.0205928590148687363, -5.36726063219632336e-06, 0.000232703689853152397,
+      -3.11346553982713454e-10 * 1. / (1_MeV), 0, -0.000121986267999964622,
+      -5.36726063219632336e-06, 3.63290769200830255e-06,
+      -6.68725223656711701e-08, 4.73213336870042294e-09 * 1. / (1_MeV), 0,
+      1.59459282051017784e-06, 0.000232703689853152397,
+      -6.68725223656711701e-08, 2.95713130071817432e-06,
+      -1.25499234028196558e-11 * 1. / (1_MeV), 0,
+      -9.93183532021228265e-08 * 1. / (1_MeV),
+      -3.11346553982713454e-10 * 1. / (1_MeV),
+      4.73213336870042294e-09 * 1. / (1_MeV),
+      -1.25499234028196558e-11 * 1. / (1_MeV),
+      1.28399915699795031e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform71;
+  ActsSymMatrixD<3> rotMat71;
+  rotMat71 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform71.rotate(rotMat71);
+  transform71.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans71 = std::make_shared<const Transform3D>(transform71);
+  std::shared_ptr<PerigeeSurface> perigeeSurface71 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams71 = BoundParameters(tgContext, std::move(covMat71), params71,
+                                       perigeeSurface71);
+  tracks.push_back(boundParams71);
+
+  // track 72 :
+  BoundVector params72;
+  params72 << -0.00558616593480110168, 19.7915973663330078,
+      -1.90661561489105225, 2.65805935859680176,
+      -0.000252252968493849039 * 1. / (1_MeV), 0;
+  Covariance covMat72;
+  covMat72 << 0.00278375041671097279, 0.000178787135861017661,
+      -8.12352454224075254e-05, 9.80445612301050583e-07,
+      -3.12103239377841498e-08 * 1. / (1_MeV), 0, 0.000178787135861017661,
+      0.0250813495367765427, -5.34047004847387823e-06, 0.000133613120646069154,
+      -5.47170798097926544e-10 * 1. / (1_MeV), 0, -8.12352454224075254e-05,
+      -5.34047004847387823e-06, 2.44281318373396061e-06,
+      -3.22686132104606899e-08, 1.51340031297866715e-09 * 1. / (1_MeV), 0,
+      9.80445612301050583e-07, 0.000133613120646069154,
+      -3.22686132104606899e-08, 7.69510791087668622e-07,
+      -3.66374332111759326e-12 * 1. / (1_MeV), 0,
+      -3.12103239377841498e-08 * 1. / (1_MeV),
+      -5.47170798097926544e-10 * 1. / (1_MeV),
+      1.51340031297866715e-09 * 1. / (1_MeV),
+      -3.66374332111759326e-12 * 1. / (1_MeV),
+      2.74491956941957937e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform72;
+  ActsSymMatrixD<3> rotMat72;
+  rotMat72 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform72.rotate(rotMat72);
+  transform72.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans72 = std::make_shared<const Transform3D>(transform72);
+  std::shared_ptr<PerigeeSurface> perigeeSurface72 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams72 = BoundParameters(tgContext, std::move(covMat72), params72,
+                                       perigeeSurface72);
+  tracks.push_back(boundParams72);
+
+  // track 73 :
+  BoundVector params73;
+  params73 << -0.442154228687286377, 17.9542407989501953, 2.09526467323303223,
+      2.94595146179199219, -0.000162040654686279595 * 1. / (1_MeV), 0;
+  Covariance covMat73;
+  covMat73 << 0.0148460650816559792, 0.00184244940568953006,
+      -0.000449961931621142613, 1.29765535410889532e-06,
+      -2.30827454176528137e-07 * 1. / (1_MeV), 0, 0.00184244940568953006,
+      0.471974313259124756, -6.98775671258470389e-05, 0.000523674191842157626,
+      -2.19369371696834795e-08 * 1. / (1_MeV), 0, -0.000449961931621142613,
+      -6.98775671258470389e-05, 1.40490355988731608e-05,
+      -5.73058129070942768e-08, 1.17830493253825561e-08 * 1. / (1_MeV), 0,
+      1.29765535410889532e-06, 0.000523674191842157626,
+      -5.73058129070942768e-08, 5.89256046623631846e-07,
+      -2.53371790794750309e-12 * 1. / (1_MeV), 0,
+      -2.30827454176528137e-07 * 1. / (1_MeV),
+      -2.19369371696834795e-08 * 1. / (1_MeV),
+      1.17830493253825561e-08 * 1. / (1_MeV),
+      -2.53371790794750309e-12 * 1. / (1_MeV),
+      9.43526715091458357e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform73;
+  ActsSymMatrixD<3> rotMat73;
+  rotMat73 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform73.rotate(rotMat73);
+  transform73.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans73 = std::make_shared<const Transform3D>(transform73);
+  std::shared_ptr<PerigeeSurface> perigeeSurface73 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams73 = BoundParameters(tgContext, std::move(covMat73), params73,
+                                       perigeeSurface73);
+  tracks.push_back(boundParams73);
+
+  // track 74 :
+  BoundVector params74;
+  params74 << 0.11471288651227951, 19.0564899444580078, -0.177579745650291443,
+      2.49515652656555176, 0.000924068794120103121 * 1. / (1_MeV), 0;
+  Covariance covMat74;
+  covMat74 << 0.0152982324361801147, 4.68616789410272773e-05,
+      -0.000446912018709990798, -2.64518724116447377e-06,
+      -3.35403806382200683e-07 * 1. / (1_MeV), 0, 4.68616789410272773e-05,
+      0.057605259120464325, 1.24210046721730033e-05, 0.00055778648850193823,
+      -7.16971922823788445e-09 * 1. / (1_MeV), 0, -0.000446912018709990798,
+      1.24210046721730033e-05, 1.33806315716356039e-05, 2.06818269256773686e-07,
+      1.64730542670120641e-08 * 1. / (1_MeV), 0, -2.64518724116447377e-06,
+      0.00055778648850193823, 2.06818269256773686e-07, 5.62562490813434124e-06,
+      -2.99011952126558051e-11 * 1. / (1_MeV), 0,
+      -3.35403806382200683e-07 * 1. / (1_MeV),
+      -7.16971922823788445e-09 * 1. / (1_MeV),
+      1.64730542670120641e-08 * 1. / (1_MeV),
+      -2.99011952126558051e-11 * 1. / (1_MeV),
+      3.94437649209322672e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform74;
+  ActsSymMatrixD<3> rotMat74;
+  rotMat74 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform74.rotate(rotMat74);
+  transform74.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans74 = std::make_shared<const Transform3D>(transform74);
+  std::shared_ptr<PerigeeSurface> perigeeSurface74 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams74 = BoundParameters(tgContext, std::move(covMat74), params74,
+                                       perigeeSurface74);
+  tracks.push_back(boundParams74);
+
+  // track 75 :
+  BoundVector params75;
+  params75 << -0.00944441463798284531, 19.5482063293457031, 1.26532316207885742,
+      1.51080191135406494, 0.00125105178449302912 * 1. / (1_MeV), 0;
+  Covariance covMat75;
+  covMat75 << 0.00673942035064101219, 1.09700537457738396e-05,
+      -0.000191837249175310959, 3.98609880544513471e-07,
+      -1.16410980841974866e-07 * 1. / (1_MeV), 0, 1.09700537457738396e-05,
+      0.030988229438662529, -8.21095175946172576e-07, 0.000558048897263842877,
+      -1.58105556275077154e-09 * 1. / (1_MeV), 0, -0.000191837249175310959,
+      -8.21095175946172576e-07, 5.58653619009419344e-06,
+      -2.21237754371518524e-08, 5.54159050773939158e-09 * 1. / (1_MeV), 0,
+      3.98609880544513471e-07, 0.000558048897263842877,
+      -2.21237754371518524e-08, 1.262055775441695e-05,
+      -2.73377636711205828e-11 * 1. / (1_MeV), 0,
+      -1.16410980841974866e-07 * 1. / (1_MeV),
+      -1.58105556275077154e-09 * 1. / (1_MeV),
+      5.54159050773939158e-09 * 1. / (1_MeV),
+      -2.73377636711205828e-11 * 1. / (1_MeV),
+      2.14180881363823516e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform75;
+  ActsSymMatrixD<3> rotMat75;
+  rotMat75 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform75.rotate(rotMat75);
+  transform75.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans75 = std::make_shared<const Transform3D>(transform75);
+  std::shared_ptr<PerigeeSurface> perigeeSurface75 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams75 = BoundParameters(tgContext, std::move(covMat75), params75,
+                                       perigeeSurface75);
+  tracks.push_back(boundParams75);
+
+  // track 76 :
+  BoundVector params76;
+  params76 << 0.00483211036771535873, 19.769775390625, -0.868091702461242676,
+      2.3166813850402832, 0.000847792427521198988 * 1. / (1_MeV), 0;
+  Covariance covMat76;
+  covMat76 << 0.00812008138746023178, 0.000241684869612282343,
+      -0.000229342880415569957, 1.22350455006491968e-07,
+      -1.51766456677205247e-07 * 1. / (1_MeV), 0, 0.000241684869612282343,
+      0.0279842410236597061, -1.67820530316218224e-08, 0.000371614228093685849,
+      -3.38119498984475317e-09 * 1. / (1_MeV), 0, -0.000229342880415569957,
+      -1.67820530316218224e-08, 6.68844677420565858e-06,
+      7.68954602593033632e-08, 6.98338608547542169e-09 * 1. / (1_MeV), 0,
+      1.22350455006491968e-07, 0.000371614228093685849, 7.68954602593033632e-08,
+      5.40870951226679608e-06, 3.18987477267544148e-12 * 1. / (1_MeV), 0,
+      -1.51766456677205247e-07 * 1. / (1_MeV),
+      -3.38119498984475317e-09 * 1. / (1_MeV),
+      6.98338608547542169e-09 * 1. / (1_MeV),
+      3.18987477267544148e-12 * 1. / (1_MeV),
+      1.92937235632406612e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform76;
+  ActsSymMatrixD<3> rotMat76;
+  rotMat76 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform76.rotate(rotMat76);
+  transform76.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans76 = std::make_shared<const Transform3D>(transform76);
+  std::shared_ptr<PerigeeSurface> perigeeSurface76 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams76 = BoundParameters(tgContext, std::move(covMat76), params76,
+                                       perigeeSurface76);
+  tracks.push_back(boundParams76);
+
+  // track 77 :
+  BoundVector params77;
+  params77 << -0.310725152492523193, 19.8295936584472656, -0.606030046939849854,
+      2.24497246742248535, 0.000661869533360004425 * 1. / (1_MeV), 0;
+  Covariance covMat77;
+  covMat77 << 0.00436511309817433357, 6.84685072450807867e-05,
+      -0.000120994704364630506, -4.90458514285306182e-07,
+      -5.64318242168483114e-08 * 1. / (1_MeV), 0, 6.84685072450807867e-05,
+      0.0149454157799482346, 2.04636767799999282e-07, 0.000205310692185942025,
+      -3.61902676938797707e-10 * 1. / (1_MeV), 0, -0.000120994704364630506,
+      2.04636767799999282e-07, 3.47089417118695565e-06, 4.16973363970233483e-08,
+      2.51792336588650841e-09 * 1. / (1_MeV), 0, -4.90458514285306182e-07,
+      0.000205310692185942025, 4.16973363970233483e-08, 3.3076123600039864e-06,
+      1.49401026311597095e-11 * 1. / (1_MeV), 0,
+      -5.64318242168483114e-08 * 1. / (1_MeV),
+      -3.61902676938797707e-10 * 1. / (1_MeV),
+      2.51792336588650841e-09 * 1. / (1_MeV),
+      1.49401026311597095e-11 * 1. / (1_MeV),
+      7.15068143586350402e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform77;
+  ActsSymMatrixD<3> rotMat77;
+  rotMat77 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform77.rotate(rotMat77);
+  transform77.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans77 = std::make_shared<const Transform3D>(transform77);
+  std::shared_ptr<PerigeeSurface> perigeeSurface77 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams77 = BoundParameters(tgContext, std::move(covMat77), params77,
+                                       perigeeSurface77);
+  tracks.push_back(boundParams77);
+
+  // track 78 :
+  BoundVector params78;
+  params78 << 0.0993749722838401794, 19.6716022491455078, 2.9211122989654541,
+      2.08926057815551758, 0.00120215211063623428 * 1. / (1_MeV), 0;
+  Covariance covMat78;
+  covMat78 << 0.0101556088775396347, 1.73498859834314119e-05,
+      -0.000283271865688924712, -1.78050008267022585e-06,
+      -1.28366707714573746e-07 * 1. / (1_MeV), 0, 1.73498859834314119e-05,
+      0.023284614086151123, 4.02106375070951919e-06, 0.000434507881477119533,
+      -1.13469407774349132e-09 * 1. / (1_MeV), 0, -0.000283271865688924712,
+      4.02106375070951919e-06, 8.19536035123746842e-06, 1.330371940544055e-07,
+      5.98130057573423383e-09 * 1. / (1_MeV), 0, -1.78050008267022585e-06,
+      0.000434507881477119533, 1.330371940544055e-07, 8.93400192580884323e-06,
+      -2.61622173381189258e-12 * 1. / (1_MeV), 0,
+      -1.28366707714573746e-07 * 1. / (1_MeV),
+      -1.13469407774349132e-09 * 1. / (1_MeV),
+      5.98130057573423383e-09 * 1. / (1_MeV),
+      -2.61622173381189258e-12 * 1. / (1_MeV),
+      1.96618277215065973e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform78;
+  ActsSymMatrixD<3> rotMat78;
+  rotMat78 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform78.rotate(rotMat78);
+  transform78.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans78 = std::make_shared<const Transform3D>(transform78);
+  std::shared_ptr<PerigeeSurface> perigeeSurface78 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams78 = BoundParameters(tgContext, std::move(covMat78), params78,
+                                       perigeeSurface78);
+  tracks.push_back(boundParams78);
+
+  // track 79 :
+  BoundVector params79;
+  params79 << 0.00076918123522773385, 19.5978374481201172,
+      -0.00888663902878761292, 2.26349568367004395,
+      -5.1679373427759856e-05 * 1. / (1_MeV), 0;
+  Covariance covMat79;
+  covMat79 << 0.000472295709187164903, 8.06538544252120891e-05,
+      -5.76326071222579373e-06, 5.02484334678411116e-07,
+      -7.2162471693487795e-09 * 1. / (1_MeV), 0, 8.06538544252120891e-05,
+      0.00591621501371264458, -1.05334511746836201e-06, 2.14457476054835035e-05,
+      -1.67841364746306759e-09 * 1. / (1_MeV), 0, -5.76326071222579373e-06,
+      -1.05334511746836201e-06, 8.51334576168483181e-08,
+      -5.60483430138567528e-09, 9.92946218379075931e-11 * 1. / (1_MeV), 0,
+      5.02484334678411116e-07, 2.14457476054835035e-05,
+      -5.60483430138567528e-09, 1.79219924234530481e-07,
+      -1.48012750336918152e-11 * 1. / (1_MeV), 0,
+      -7.2162471693487795e-09 * 1. / (1_MeV),
+      -1.67841364746306759e-09 * 1. / (1_MeV),
+      9.92946218379075931e-11 * 1. / (1_MeV),
+      -1.48012750336918152e-11 * 1. / (1_MeV),
+      8.22869712906876272e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform79;
+  ActsSymMatrixD<3> rotMat79;
+  rotMat79 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform79.rotate(rotMat79);
+  transform79.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans79 = std::make_shared<const Transform3D>(transform79);
+  std::shared_ptr<PerigeeSurface> perigeeSurface79 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams79 = BoundParameters(tgContext, std::move(covMat79), params79,
+                                       perigeeSurface79);
+  tracks.push_back(boundParams79);
+
+  // track 80 :
+  BoundVector params80;
+  params80 << 0.172430276870727539, 20.0516853332519531, 0.0925022587180137634,
+      2.79165339469909668, 0.000355079799192026258 * 1. / (1_MeV), 0;
+  Covariance covMat80;
+  covMat80 << 0.0123957395553588867, 0.000276004959343346566,
+      -0.000367529600040991081, -5.44526345620848147e-07,
+      -2.56473787837672908e-07 * 1. / (1_MeV), 0, 0.000276004959343346566,
+      0.149438470602035522, 1.26945466301119017e-05, 0.000484407751120721731,
+      -4.77601393027406713e-09 * 1. / (1_MeV), 0, -0.000367529600040991081,
+      1.26945466301119017e-05, 1.11619228846393526e-05, 7.59736475896802827e-08,
+      1.21717089673328274e-08 * 1. / (1_MeV), 0, -5.44526345620848147e-07,
+      0.000484407751120721731, 7.59736475896802827e-08, 1.61264904363633832e-06,
+      -7.16527986733535845e-12 * 1. / (1_MeV), 0,
+      -2.56473787837672908e-07 * 1. / (1_MeV),
+      -4.77601393027406713e-09 * 1. / (1_MeV),
+      1.21717089673328274e-08 * 1. / (1_MeV),
+      -7.16527986733535845e-12 * 1. / (1_MeV),
+      1.61127389208814975e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform80;
+  ActsSymMatrixD<3> rotMat80;
+  rotMat80 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform80.rotate(rotMat80);
+  transform80.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans80 = std::make_shared<const Transform3D>(transform80);
+  std::shared_ptr<PerigeeSurface> perigeeSurface80 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams80 = BoundParameters(tgContext, std::move(covMat80), params80,
+                                       perigeeSurface80);
+  tracks.push_back(boundParams80);
+
+  // track 81 :
+  BoundVector params81;
+  params81 << 0.0237218067049980164, 19.884124755859375, -1.31243884563446045,
+      1.17260158061981201, 0.00145791680552065372 * 1. / (1_MeV), 0;
+  Covariance covMat81;
+  covMat81 << 0.00926587916910648346, 7.06487595418491801e-05,
+      -0.000277787039323878398, 4.07603821427250781e-06,
+      -1.58449164304071412e-07 * 1. / (1_MeV), 0, 7.06487595418491801e-05,
+      0.0313730873167514801, -6.65579864375914156e-06, 0.000612313813642858889,
+      3.06797580601043898e-10 * 1. / (1_MeV), 0, -0.000277787039323878398,
+      -6.65579864375914156e-06, 8.47732735564932227e-06,
+      -2.17222306747093869e-07, 7.82071353865796235e-09 * 1. / (1_MeV), 0,
+      4.07603821427250781e-06, 0.000612313813642858889,
+      -2.17222306747093869e-07, 1.3626353393192403e-05,
+      7.47614118694918694e-12 * 1. / (1_MeV), 0,
+      -1.58449164304071412e-07 * 1. / (1_MeV),
+      3.06797580601043898e-10 * 1. / (1_MeV),
+      7.82071353865796235e-09 * 1. / (1_MeV),
+      7.47614118694918694e-12 * 1. / (1_MeV),
+      2.8977453769840622e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform81;
+  ActsSymMatrixD<3> rotMat81;
+  rotMat81 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform81.rotate(rotMat81);
+  transform81.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans81 = std::make_shared<const Transform3D>(transform81);
+  std::shared_ptr<PerigeeSurface> perigeeSurface81 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams81 = BoundParameters(tgContext, std::move(covMat81), params81,
+                                       perigeeSurface81);
+  tracks.push_back(boundParams81);
+
+  // track 82 :
+  BoundVector params82;
+  params82 << 0.0107990093529224396, 19.6716117858886719, 1.03559982776641846,
+      1.73082625865936279, -0.000879532191902399063 * 1. / (1_MeV), 0;
+  Covariance covMat82;
+  covMat82 << 0.00402391236275434494, 3.20769174601289147e-05,
+      -0.000111254459256007358, 8.45579221821339803e-07,
+      -4.58324536525110618e-08 * 1. / (1_MeV), 0, 3.20769174601289147e-05,
+      0.0170307178050279617, -1.43476733365515181e-06, 0.000387486496341669733,
+      -1.98263687729926011e-09 * 1. / (1_MeV), 0, -0.000111254459256007358,
+      -1.43476733365515181e-06, 3.15253510052571073e-06,
+      -3.93483906027775912e-08, 2.199583121442104e-09 * 1. / (1_MeV), 0,
+      8.45579221821339803e-07, 0.000387486496341669733,
+      -3.93483906027775912e-08, 1.00340321296243928e-05,
+      -8.11770059300461125e-11 * 1. / (1_MeV), 0,
+      -4.58324536525110618e-08 * 1. / (1_MeV),
+      -1.98263687729926011e-09 * 1. / (1_MeV),
+      2.199583121442104e-09 * 1. / (1_MeV),
+      -8.11770059300461125e-11 * 1. / (1_MeV),
+      8.58341592246958385e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform82;
+  ActsSymMatrixD<3> rotMat82;
+  rotMat82 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform82.rotate(rotMat82);
+  transform82.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans82 = std::make_shared<const Transform3D>(transform82);
+  std::shared_ptr<PerigeeSurface> perigeeSurface82 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams82 = BoundParameters(tgContext, std::move(covMat82), params82,
+                                       perigeeSurface82);
+  tracks.push_back(boundParams82);
+
+  // track 83 :
+  BoundVector params83;
+  params83 << -0.0155548518523573875, 19.7591342926025391, 0.363524943590164185,
+      1.25925362110137939, 0.000502271810546517372 * 1. / (1_MeV), 0;
+  Covariance covMat83;
+  covMat83 << 0.00146772642619907856, -2.09037045000602479e-05,
+      -3.96307184598860177e-05, 1.98917565341808915e-07,
+      -2.1828224014850844e-08 * 1. / (1_MeV), 0, -2.09037045000602479e-05,
+      0.0098578035831451416, 3.71240804606546409e-07, 0.000133019349065383567,
+      2.05370209972403466e-09 * 1. / (1_MeV), 0, -3.96307184598860177e-05,
+      3.71240804606546409e-07, 1.11548615677747875e-06, -1.0700920015588702e-08,
+      9.39493443779476572e-10 * 1. / (1_MeV), 0, 1.98917565341808915e-07,
+      0.000133019349065383567, -1.0700920015588702e-08, 2.54624114859325346e-06,
+      1.22768956327870663e-13 * 1. / (1_MeV), 0,
+      -2.1828224014850844e-08 * 1. / (1_MeV),
+      2.05370209972403466e-09 * 1. / (1_MeV),
+      9.39493443779476572e-10 * 1. / (1_MeV),
+      1.22768956327870663e-13 * 1. / (1_MeV),
+      3.11325652757599158e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform83;
+  ActsSymMatrixD<3> rotMat83;
+  rotMat83 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform83.rotate(rotMat83);
+  transform83.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans83 = std::make_shared<const Transform3D>(transform83);
+  std::shared_ptr<PerigeeSurface> perigeeSurface83 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams83 = BoundParameters(tgContext, std::move(covMat83), params83,
+                                       perigeeSurface83);
+  tracks.push_back(boundParams83);
+
+  // track 84 :
+  BoundVector params84;
+  params84 << -0.138253405690193176, 18.5519084930419922, 1.43608295917510986,
+      0.270120680332183838, 0.000328816560795530677 * 1. / (1_MeV), 0;
+  Covariance covMat84;
+  covMat84 << 0.024482090026140213, -0.00141465310858683861,
+      -0.000727919377154882677, 7.62924836936917779e-07,
+      -2.70713331750664401e-07 * 1. / (1_MeV), 0, -0.00141465310858683861,
+      0.38681483268737793, -3.29131593924930853e-06, 0.000780935381087039492,
+      2.03667202249869457e-08 * 1. / (1_MeV), 0, -0.000727919377154882677,
+      -3.29131593924930853e-06, 2.20086349145276472e-05,
+      -1.08805257496805159e-07, 1.28472546995040731e-08 * 1. / (1_MeV), 0,
+      7.62924836936917779e-07, 0.000780935381087039492,
+      -1.08805257496805159e-07, 1.60606941790319979e-06,
+      6.31240016744585034e-12 * 1. / (1_MeV), 0,
+      -2.70713331750664401e-07 * 1. / (1_MeV),
+      2.03667202249869457e-08 * 1. / (1_MeV),
+      1.28472546995040731e-08 * 1. / (1_MeV),
+      6.31240016744585034e-12 * 1. / (1_MeV),
+      1.31787206147926383e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform84;
+  ActsSymMatrixD<3> rotMat84;
+  rotMat84 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform84.rotate(rotMat84);
+  transform84.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans84 = std::make_shared<const Transform3D>(transform84);
+  std::shared_ptr<PerigeeSurface> perigeeSurface84 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams84 = BoundParameters(tgContext, std::move(covMat84), params84,
+                                       perigeeSurface84);
+  tracks.push_back(boundParams84);
+
+  // track 85 :
+  BoundVector params85;
+  params85 << -0.0975429564714431763, 19.5427474975585938, 2.8031013011932373,
+      1.58790135383605957, 0.00166723399888724089 * 1. / (1_MeV), 0;
+  Covariance covMat85;
+  covMat85 << 0.0113241951912641525, -9.34923139819065776e-06,
+      -0.000335769282045279361, -2.82633621752857802e-07,
+      -1.5729637539850742e-07 * 1. / (1_MeV), 0, -9.34923139819065776e-06,
+      0.0528257228434085846, 5.71110103579136688e-07, 0.00100043855412109946,
+      -3.03573063913276242e-10 * 1. / (1_MeV), 0, -0.000335769282045279361,
+      5.71110103579136688e-07, 1.01046462077647448e-05, 1.49587275943740115e-08,
+      7.33039139408457665e-09 * 1. / (1_MeV), 0, -2.82633621752857802e-07,
+      0.00100043855412109946, 1.49587275943740115e-08, 2.26391439355211332e-05,
+      1.66413138250011556e-12 * 1. / (1_MeV), 0,
+      -1.5729637539850742e-07 * 1. / (1_MeV),
+      -3.03573063913276242e-10 * 1. / (1_MeV),
+      7.33039139408457665e-09 * 1. / (1_MeV),
+      1.66413138250011556e-12 * 1. / (1_MeV),
+      2.75241468505882381e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform85;
+  ActsSymMatrixD<3> rotMat85;
+  rotMat85 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform85.rotate(rotMat85);
+  transform85.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans85 = std::make_shared<const Transform3D>(transform85);
+  std::shared_ptr<PerigeeSurface> perigeeSurface85 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams85 = BoundParameters(tgContext, std::move(covMat85), params85,
+                                       perigeeSurface85);
+  tracks.push_back(boundParams85);
+
+  // track 86 :
+  BoundVector params86;
+  params86 << -0.0176449194550514221, 19.7948665618896484, -2.85859298706054688,
+      1.93745362758636475, 0.00181531091220676899 * 1. / (1_MeV), 0;
+  Covariance covMat86;
+  covMat86 << 0.0164455324411392212, -1.78319115876212784e-05,
+      -0.000476391113400424576, -4.84635611442015516e-06,
+      -2.16420755174177543e-07 * 1. / (1_MeV), 0, -1.78319115876212784e-05,
+      0.0350610315799713135, 7.76663282566612816e-06, 0.00082119930622140565,
+      -2.29522713626592166e-09 * 1. / (1_MeV), 0, -0.000476391113400424576,
+      7.76663282566612816e-06, 1.41888513098820113e-05, 3.09707605227186869e-07,
+      1.05056686720642746e-08 * 1. / (1_MeV), 0, -4.84635611442015516e-06,
+      0.00082119930622140565, 3.09707605227186869e-07, 2.0716039216495119e-05,
+      -3.66067615445536715e-11 * 1. / (1_MeV), 0,
+      -2.16420755174177543e-07 * 1. / (1_MeV),
+      -2.29522713626592166e-09 * 1. / (1_MeV),
+      1.05056686720642746e-08 * 1. / (1_MeV),
+      -3.66067615445536715e-11 * 1. / (1_MeV),
+      3.8617198327983715e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform86;
+  ActsSymMatrixD<3> rotMat86;
+  rotMat86 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform86.rotate(rotMat86);
+  transform86.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans86 = std::make_shared<const Transform3D>(transform86);
+  std::shared_ptr<PerigeeSurface> perigeeSurface86 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams86 = BoundParameters(tgContext, std::move(covMat86), params86,
+                                       perigeeSurface86);
+  tracks.push_back(boundParams86);
+
+  // track 87 :
+  BoundVector params87;
+  params87 << -0.166390389204025269, 19.5272064208984375, 1.93741095066070557,
+      2.24489212036132812, -0.000905173714272677898 * 1. / (1_MeV), 0;
+  Covariance covMat87;
+  covMat87 << 0.00758632877841591835, 0.000139937870694665129,
+      -0.00021374593302439404, 2.74308497049270969e-06,
+      -1.22199307635393265e-07 * 1. / (1_MeV), 0, 0.000139937870694665129,
+      0.0236409269273281097, -7.18474418831525274e-06, 0.000356769071380466532,
+      2.17953764438197491e-10 * 1. / (1_MeV), 0, -0.00021374593302439404,
+      -7.18474418831525274e-06, 6.20618220636970364e-06, -1.339422192986325e-07,
+      5.75423109018135768e-09 * 1. / (1_MeV), 0, 2.74308497049270969e-06,
+      0.000356769071380466532, -1.339422192986325e-07, 5.97795133217005059e-06,
+      1.65920987870639118e-13 * 1. / (1_MeV), 0,
+      -1.22199307635393265e-07 * 1. / (1_MeV),
+      2.17953764438197491e-10 * 1. / (1_MeV),
+      5.75423109018135768e-09 * 1. / (1_MeV),
+      1.65920987870639118e-13 * 1. / (1_MeV),
+      1.7132852081491734e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform87;
+  ActsSymMatrixD<3> rotMat87;
+  rotMat87 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform87.rotate(rotMat87);
+  transform87.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans87 = std::make_shared<const Transform3D>(transform87);
+  std::shared_ptr<PerigeeSurface> perigeeSurface87 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams87 = BoundParameters(tgContext, std::move(covMat87), params87,
+                                       perigeeSurface87);
+  tracks.push_back(boundParams87);
+
+  // track 88 :
+  BoundVector params88;
+  params88 << -0.0647897049784660339, 19.7515354156494141, -1.94424092769622803,
+      0.913331747055053711, 0.00144281168468296528 * 1. / (1_MeV), 0;
+  Covariance covMat88;
+  covMat88 << 0.0164492577314376831, 0.000114680106948955043,
+      -0.000493878556345173059, 7.55394948756817303e-06,
+      -3.09421204652331308e-07 * 1. / (1_MeV), 0, 0.000114680106948955043,
+      0.0497665181756019592, -1.69407417870949993e-05, 0.000847429052747156815,
+      4.92898530455145555e-09 * 1. / (1_MeV), 0, -0.000493878556345173059,
+      -1.69407417870949993e-05, 1.51399772221338935e-05,
+      -4.57257867983653748e-07, 1.5688536216622446e-08 * 1. / (1_MeV), 0,
+      7.55394948756817303e-06, 0.000847429052747156815,
+      -4.57257867983653748e-07, 1.51720887515693903e-05,
+      7.05942755015551252e-12 * 1. / (1_MeV), 0,
+      -3.09421204652331308e-07 * 1. / (1_MeV),
+      4.92898530455145555e-09 * 1. / (1_MeV),
+      1.5688536216622446e-08 * 1. / (1_MeV),
+      7.05942755015551252e-12 * 1. / (1_MeV),
+      5.00731012209598703e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform88;
+  ActsSymMatrixD<3> rotMat88;
+  rotMat88 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform88.rotate(rotMat88);
+  transform88.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans88 = std::make_shared<const Transform3D>(transform88);
+  std::shared_ptr<PerigeeSurface> perigeeSurface88 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams88 = BoundParameters(tgContext, std::move(covMat88), params88,
+                                       perigeeSurface88);
+  tracks.push_back(boundParams88);
+
+  // track 89 :
+  BoundVector params89;
+  params89 << -0.0218852758407592773, 19.7477836608886719, -1.84601056575775146,
+      1.15177929401397705, -0.000602153537329286337 * 1. / (1_MeV), 0;
+  Covariance covMat89;
+  covMat89 << 0.00399546697735786438, -7.6231191425185513e-05,
+      -0.000113968779238574712, -1.06749066545070016e-06,
+      -1.49669197267399396e-07 * 1. / (1_MeV), 0, -7.6231191425185513e-05,
+      0.0129444217309355736, 2.25263525428921646e-06, 0.000202868748994328374,
+      -7.0251938262291757e-09 * 1. / (1_MeV), 0, -0.000113968779238574712,
+      2.25263525428921646e-06, 3.39482835443050135e-06, 3.68428330396706466e-08,
+      7.19219531975148008e-09 * 1. / (1_MeV), 0, -1.06749066545070016e-06,
+      0.000202868748994328374, 3.68428330396706466e-08, 3.95832057620282285e-06,
+      -5.52575945546745665e-11 * 1. / (1_MeV), 0,
+      -1.49669197267399396e-07 * 1. / (1_MeV),
+      -7.0251938262291757e-09 * 1. / (1_MeV),
+      7.19219531975148008e-09 * 1. / (1_MeV),
+      -5.52575945546745665e-11 * 1. / (1_MeV),
+      2.65768212992512076e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform89;
+  ActsSymMatrixD<3> rotMat89;
+  rotMat89 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform89.rotate(rotMat89);
+  transform89.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans89 = std::make_shared<const Transform3D>(transform89);
+  std::shared_ptr<PerigeeSurface> perigeeSurface89 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams89 = BoundParameters(tgContext, std::move(covMat89), params89,
+                                       perigeeSurface89);
+  tracks.push_back(boundParams89);
+
+  // track 90 :
+  BoundVector params90;
+  params90 << -0.179924234747886658, 19.2563438415527344, -1.48651039600372314,
+      2.36299228668212891, -0.00104924733750522137 * 1. / (1_MeV), 0;
+  Covariance covMat90;
+  covMat90 << 0.0114581910893321037, 0.000363608408604759639,
+      -0.000344876866124296778, 5.81780591102444491e-06,
+      -2.6043200912918554e-07 * 1. / (1_MeV), 0, 0.000363608408604759639,
+      0.0420437715947628021, -1.83725730891767065e-05, 0.000563950407188989035,
+      -4.04684151826768466e-09 * 1. / (1_MeV), 0, -0.000344876866124296778,
+      -1.83725730891767065e-05, 1.06007255453732796e-05,
+      -2.88525393038017665e-07, 1.30515590208839564e-08 * 1. / (1_MeV), 0,
+      5.81780591102444491e-06, 0.000563950407188989035,
+      -2.88525393038017665e-07, 8.05603212938876823e-06,
+      -7.18990753436096707e-11 * 1. / (1_MeV), 0,
+      -2.6043200912918554e-07 * 1. / (1_MeV),
+      -4.04684151826768466e-09 * 1. / (1_MeV),
+      1.30515590208839564e-08 * 1. / (1_MeV),
+      -7.18990753436096707e-11 * 1. / (1_MeV),
+      3.69383551523938536e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform90;
+  ActsSymMatrixD<3> rotMat90;
+  rotMat90 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform90.rotate(rotMat90);
+  transform90.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans90 = std::make_shared<const Transform3D>(transform90);
+  std::shared_ptr<PerigeeSurface> perigeeSurface90 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams90 = BoundParameters(tgContext, std::move(covMat90), params90,
+                                       perigeeSurface90);
+  tracks.push_back(boundParams90);
+
+  // track 91 :
+  BoundVector params91;
+  params91 << 0.0888378918170928955, 19.5743637084960938, 2.02936220169067383,
+      0.592313289642333984, -0.00073199498001486063 * 1. / (1_MeV), 0;
+  Covariance covMat91;
+  covMat91 << 0.011888476088643074, -0.000364351547358354397,
+      -0.000344164051274786493, -4.80224624851940611e-06,
+      -1.25074865846872421e-07 * 1. / (1_MeV), 0, -0.000364351547358354397,
+      0.0546070896089076996, 1.71846692226701118e-05, 0.000451481364740918725,
+      -6.40392522058036485e-10 * 1. / (1_MeV), 0, -0.000344164051274786493,
+      1.71846692226701118e-05, 1.02026851891423576e-05, 2.02827091730025172e-07,
+      6.16615182332136642e-09 * 1. / (1_MeV), 0, -4.80224624851940611e-06,
+      0.000451481364740918725, 2.02827091730025172e-07, 3.89986053050961345e-06,
+      1.48987059961839454e-11 * 1. / (1_MeV), 0,
+      -1.25074865846872421e-07 * 1. / (1_MeV),
+      -6.40392522058036485e-10 * 1. / (1_MeV),
+      6.16615182332136642e-09 * 1. / (1_MeV),
+      1.48987059961839454e-11 * 1. / (1_MeV),
+      1.37464484240013007e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform91;
+  ActsSymMatrixD<3> rotMat91;
+  rotMat91 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform91.rotate(rotMat91);
+  transform91.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans91 = std::make_shared<const Transform3D>(transform91);
+  std::shared_ptr<PerigeeSurface> perigeeSurface91 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams91 = BoundParameters(tgContext, std::move(covMat91), params91,
+                                       perigeeSurface91);
+  tracks.push_back(boundParams91);
+
+  // track 92 :
+  BoundVector params92;
+  params92 << 1.12502670288085938, 20.2727298736572266, 2.00401997566223145,
+      0.626365065574645996, -0.00111448660027235746 * 1. / (1_MeV), 0;
+  Covariance covMat92;
+  covMat92 << 0.0225118305534124374, 0.000584212031156044944,
+      -0.000666452626493573485, -9.45983147595499108e-06,
+      -3.13759589393168411e-07 * 1. / (1_MeV), 0, 0.000584212031156044944,
+      0.0864472761750221252, 1.9655656094501285e-06, 0.000822762632728434311,
+      -2.92388874702865178e-08 * 1. / (1_MeV), 0, -0.000666452626493573485,
+      1.9655656094501285e-06, 2.00926533580059186e-05, 4.80605470309639927e-07,
+      1.5495058835982803e-08 * 1. / (1_MeV), 0, -9.45983147595499108e-06,
+      0.000822762632728434311, 4.80605470309639927e-07, 8.10808978712884709e-06,
+      1.17184088836066811e-11 * 1. / (1_MeV), 0,
+      -3.13759589393168411e-07 * 1. / (1_MeV),
+      -2.92388874702865178e-08 * 1. / (1_MeV),
+      1.5495058835982803e-08 * 1. / (1_MeV),
+      1.17184088836066811e-11 * 1. / (1_MeV),
+      3.60202312421620263e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform92;
+  ActsSymMatrixD<3> rotMat92;
+  rotMat92 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform92.rotate(rotMat92);
+  transform92.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans92 = std::make_shared<const Transform3D>(transform92);
+  std::shared_ptr<PerigeeSurface> perigeeSurface92 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams92 = BoundParameters(tgContext, std::move(covMat92), params92,
+                                       perigeeSurface92);
+  tracks.push_back(boundParams92);
+
+  // track 93 :
+  BoundVector params93;
+  params93 << 0.0424742512404918671, 18.9486141204833984, 1.86956024169921875,
+      2.96004772186279297, 4.37863855040632188e-05 * 1. / (1_MeV), 0;
+  Covariance covMat93;
+  covMat93 << 0.00272560492157936096, 0.00211849758168023089,
+      -7.31526879372190519e-05, 1.47161851529462088e-06,
+      -2.24706881796614946e-08 * 1. / (1_MeV), 0, 0.00211849758168023089,
+      0.109402194619178772, -4.40777842273042759e-05, 8.76258363739740542e-05,
+      -7.98382954847600904e-09 * 1. / (1_MeV), 0, -7.31526879372190519e-05,
+      -4.40777842273042759e-05, 2.04982438845036086e-06,
+      -3.14008128887106979e-08, 9.90149855492210942e-10 * 1. / (1_MeV), 0,
+      1.47161851529462088e-06, 8.76258363739740542e-05,
+      -3.14008128887106979e-08, 7.31033722445317835e-08,
+      -5.93207648040451609e-12 * 1. / (1_MeV), 0,
+      -2.24706881796614946e-08 * 1. / (1_MeV),
+      -7.98382954847600904e-09 * 1. / (1_MeV),
+      9.90149855492210942e-10 * 1. / (1_MeV),
+      -5.93207648040451609e-12 * 1. / (1_MeV),
+      6.39852146960828705e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform93;
+  ActsSymMatrixD<3> rotMat93;
+  rotMat93 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform93.rotate(rotMat93);
+  transform93.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans93 = std::make_shared<const Transform3D>(transform93);
+  std::shared_ptr<PerigeeSurface> perigeeSurface93 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams93 = BoundParameters(tgContext, std::move(covMat93), params93,
+                                       perigeeSurface93);
+  tracks.push_back(boundParams93);
+
+  // track 94 :
+  BoundVector params94;
+  params94 << 0.0741926580667495728, 19.3120975494384766, -0.158996760845184326,
+      0.275065630674362183, 0.000188159960089251399 * 1. / (1_MeV), 0;
+  Covariance covMat94;
+  covMat94 << 0.00854411255568265915, -0.000856847673562337298,
+      -0.000243449563025652623, -9.85362587786612014e-07,
+      -5.40653541002901188e-08 * 1. / (1_MeV), 0, -0.000856847673562337298,
+      0.125519141554832458, 1.11678697417946741e-05, 0.000258925752451969187,
+      1.7425143865914771e-09 * 1. / (1_MeV), 0, -0.000243449563025652623,
+      1.11678697417946741e-05, 7.13488225301261991e-06, 5.42206306027033232e-09,
+      2.68913182114241505e-09 * 1. / (1_MeV), 0, -9.85362587786612014e-07,
+      0.000258925752451969187, 5.42206306027033232e-09, 5.48016146240115631e-07,
+      2.1763511830840563e-12 * 1. / (1_MeV), 0,
+      -5.40653541002901188e-08 * 1. / (1_MeV),
+      1.7425143865914771e-09 * 1. / (1_MeV),
+      2.68913182114241505e-09 * 1. / (1_MeV),
+      2.1763511830840563e-12 * 1. / (1_MeV),
+      2.93287685804166642e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform94;
+  ActsSymMatrixD<3> rotMat94;
+  rotMat94 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform94.rotate(rotMat94);
+  transform94.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans94 = std::make_shared<const Transform3D>(transform94);
+  std::shared_ptr<PerigeeSurface> perigeeSurface94 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams94 = BoundParameters(tgContext, std::move(covMat94), params94,
+                                       perigeeSurface94);
+  tracks.push_back(boundParams94);
+
+  // track 95 :
+  BoundVector params95;
+  params95 << 0.00871588941663503647, 19.6997394561767578, -1.8126060962677002,
+      2.65224313735961914, 0.000173616441315971315 * 1. / (1_MeV), 0;
+  Covariance covMat95;
+  covMat95 << 0.0016872126143425703, 0.000139207692137839037,
+      -4.67932554158379929e-05, 4.13046758309523893e-07,
+      -2.15022847730470487e-08 * 1. / (1_MeV), 0, 0.000139207692137839037,
+      0.0162848997861146927, -2.02254704724682222e-06, 8.19432265737622998e-05,
+      -3.67683233513065563e-10 * 1. / (1_MeV), 0, -4.67932554158379929e-05,
+      -2.02254704724682222e-06, 1.35188520289375447e-06,
+      -3.99719230681514876e-09, 9.61695510131444949e-10 * 1. / (1_MeV), 0,
+      4.13046758309523893e-07, 8.19432265737622998e-05,
+      -3.99719230681514876e-09, 4.59278368225568556e-07,
+      1.08766285673392314e-12 * 1. / (1_MeV), 0,
+      -2.15022847730470487e-08 * 1. / (1_MeV),
+      -3.67683233513065563e-10 * 1. / (1_MeV),
+      9.61695510131444949e-10 * 1. / (1_MeV),
+      1.08766285673392314e-12 * 1. / (1_MeV),
+      1.62394785119257534e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform95;
+  ActsSymMatrixD<3> rotMat95;
+  rotMat95 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform95.rotate(rotMat95);
+  transform95.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans95 = std::make_shared<const Transform3D>(transform95);
+  std::shared_ptr<PerigeeSurface> perigeeSurface95 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams95 = BoundParameters(tgContext, std::move(covMat95), params95,
+                                       perigeeSurface95);
+  tracks.push_back(boundParams95);
+
+  // track 96 :
+  BoundVector params96;
+  params96 << -0.479792565107345581, 19.5514030456542969, 1.30992162227630615,
+      2.87463688850402832, -0.000373176822904497385 * 1. / (1_MeV), 0;
+  Covariance covMat96;
+  covMat96 << 0.0304757114499807358, 0.00262038861845952575,
+      -0.000909104372409295556, 4.81420582026805876e-06,
+      -3.00973750980190046e-07 * 1. / (1_MeV), 0, 0.00262038861845952575,
+      0.461684495210647583, -0.000119908842389617728, 0.000928506582398690205,
+      -1.58063875508688272e-08 * 1. / (1_MeV), 0, -0.000909104372409295556,
+      -0.000119908842389617728, 2.75514212262351066e-05,
+      -2.30932526667593089e-07, 1.47073159868963048e-08 * 1. / (1_MeV), 0,
+      4.81420582026805876e-06, 0.000928506582398690205,
+      -2.30932526667593089e-07, 1.89259435501298867e-06,
+      -3.4275779025213788e-12 * 1. / (1_MeV), 0,
+      -3.00973750980190046e-07 * 1. / (1_MeV),
+      -1.58063875508688272e-08 * 1. / (1_MeV),
+      1.47073159868963048e-08 * 1. / (1_MeV),
+      -3.4275779025213788e-12 * 1. / (1_MeV),
+      1.52582876888907037e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform96;
+  ActsSymMatrixD<3> rotMat96;
+  rotMat96 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform96.rotate(rotMat96);
+  transform96.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans96 = std::make_shared<const Transform3D>(transform96);
+  std::shared_ptr<PerigeeSurface> perigeeSurface96 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams96 = BoundParameters(tgContext, std::move(covMat96), params96,
+                                       perigeeSurface96);
+  tracks.push_back(boundParams96);
+
+  // track 97 :
+  BoundVector params97;
+  params97 << 0.0435044243931770325, 19.5490474700927734, -1.34004080295562744,
+      0.636775732040405273, 0.00095876265550032258 * 1. / (1_MeV), 0;
+  Covariance covMat97;
+  covMat97 << 0.0165304504334926605, 8.29496702915483077e-06,
+      -0.000500555157842997754, 3.90666040743467471e-06,
+      -2.32492797224773581e-07 * 1. / (1_MeV), 0, 8.29496702915483077e-06,
+      0.0697377473115921021, -1.69183732968702351e-05, 0.000672615077218085113,
+      4.78769181746032668e-09 * 1. / (1_MeV), 0, -0.000500555157842997754,
+      -1.69183732968702351e-05, 1.53797700477298349e-05,
+      -2.76896198762005315e-07, 1.14306313433277435e-08 * 1. / (1_MeV), 0,
+      3.90666040743467471e-06, 0.000672615077218085113,
+      -2.76896198762005315e-07, 6.75487535772845149e-06,
+      5.33336934367208442e-12 * 1. / (1_MeV), 0,
+      -2.32492797224773581e-07 * 1. / (1_MeV),
+      4.78769181746032668e-09 * 1. / (1_MeV),
+      1.14306313433277435e-08 * 1. / (1_MeV),
+      5.33336934367208442e-12 * 1. / (1_MeV),
+      2.67363853279078967e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform97;
+  ActsSymMatrixD<3> rotMat97;
+  rotMat97 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform97.rotate(rotMat97);
+  transform97.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans97 = std::make_shared<const Transform3D>(transform97);
+  std::shared_ptr<PerigeeSurface> perigeeSurface97 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams97 = BoundParameters(tgContext, std::move(covMat97), params97,
+                                       perigeeSurface97);
+  tracks.push_back(boundParams97);
+
+  // track 98 :
+  BoundVector params98;
+  params98 << 0.294112950563430786, 20.2545261383056641, -0.614140152931213379,
+      2.8818819522857666, 0.000281037588138133287 * 1. / (1_MeV), 0;
+  Covariance covMat98;
+  covMat98 << 0.0236709490418434143, 0.00249554031068035566,
+      -0.000662619697167173742, 2.34743469108013516e-06,
+      -2.19122332602494014e-07 * 1. / (1_MeV), 0, 0.00249554031068035566,
+      0.38017040491104126, -1.42274220258879397e-05, 0.000682984089483805218,
+      -1.15543562394303679e-08 * 1. / (1_MeV), 0, -0.000662619697167173742,
+      -1.42274220258879397e-05, 1.92686129594221711e-05,
+      2.05189135697031987e-08, 1.0358702081816697e-08 * 1. / (1_MeV), 0,
+      2.34743469108013516e-06, 0.000682984089483805218, 2.05189135697031987e-08,
+      1.2688219612755347e-06, -2.0944363933578172e-11 * 1. / (1_MeV), 0,
+      -2.19122332602494014e-07 * 1. / (1_MeV),
+      -1.15543562394303679e-08 * 1. / (1_MeV),
+      1.0358702081816697e-08 * 1. / (1_MeV),
+      -2.0944363933578172e-11 * 1. / (1_MeV),
+      1.02260803991338634e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform98;
+  ActsSymMatrixD<3> rotMat98;
+  rotMat98 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform98.rotate(rotMat98);
+  transform98.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans98 = std::make_shared<const Transform3D>(transform98);
+  std::shared_ptr<PerigeeSurface> perigeeSurface98 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams98 = BoundParameters(tgContext, std::move(covMat98), params98,
+                                       perigeeSurface98);
+  tracks.push_back(boundParams98);
+
+  // track 99 :
+  BoundVector params99;
+  params99 << -0.13228142261505127, 19.8440647125244141, -1.97596120834350586,
+      0.307230293750762939, -0.000209428049856796861 * 1. / (1_MeV), 0;
+  Covariance covMat99;
+  covMat99 << 0.0064656953327357769, -0.000491542212342820388,
+      -0.00019640849669221811, -1.26200648361190619e-06,
+      -7.51057490837922185e-08 * 1. / (1_MeV), 0, -0.000491542212342820388,
+      0.0971855819225311279, 1.78855920005378135e-05, 0.000244668503969933625,
+      2.01135045525568458e-09 * 1. / (1_MeV), 0, -0.00019640849669221811,
+      1.78855920005378135e-05, 6.10315464655286632e-06, 4.79157334954937018e-08,
+      3.80545329493034294e-09 * 1. / (1_MeV), 0, -1.26200648361190619e-06,
+      0.000244668503969933625, 4.79157334954937018e-08, 6.40511075289396103e-07,
+      3.52133532247833157e-12 * 1. / (1_MeV), 0,
+      -7.51057490837922185e-08 * 1. / (1_MeV),
+      2.01135045525568458e-09 * 1. / (1_MeV),
+      3.80545329493034294e-09 * 1. / (1_MeV),
+      3.52133532247833157e-12 * 1. / (1_MeV),
+      4.62756812036335674e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform99;
+  ActsSymMatrixD<3> rotMat99;
+  rotMat99 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform99.rotate(rotMat99);
+  transform99.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans99 = std::make_shared<const Transform3D>(transform99);
+  std::shared_ptr<PerigeeSurface> perigeeSurface99 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams99 = BoundParameters(tgContext, std::move(covMat99), params99,
+                                       perigeeSurface99);
+  tracks.push_back(boundParams99);
+
+  // track 100 :
+  BoundVector params100;
+  params100 << 0.0397286675870418549, 19.8980617523193359, -1.5870441198348999,
+      1.06085562705993652, -0.00154436775483191013 * 1. / (1_MeV), 0;
+  Covariance covMat100;
+  covMat100 << 0.0146848792210221291, -0.00024056679482515193,
+      -0.000422761250825204478, -6.59419504288689593e-06,
+      -2.0883759621313093e-07 * 1. / (1_MeV), 0, -0.00024056679482515193,
+      0.0353117473423480988, 1.29517733327191238e-05, 0.000689977822807362863,
+      -2.65977040646537884e-09 * 1. / (1_MeV), 0, -0.000422761250825204478,
+      1.29517733327191238e-05, 1.25361730169970542e-05, 3.29509919866834633e-07,
+      9.87015185549509611e-09 * 1. / (1_MeV), 0, -6.59419504288689593e-06,
+      0.000689977822807362863, 3.29509919866834633e-07, 1.49626648635603487e-05,
+      -5.44243124057383386e-11 * 1. / (1_MeV), 0,
+      -2.0883759621313093e-07 * 1. / (1_MeV),
+      -2.65977040646537884e-09 * 1. / (1_MeV),
+      9.87015185549509611e-09 * 1. / (1_MeV),
+      -5.44243124057383386e-11 * 1. / (1_MeV),
+      3.28629123913515286e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform100;
+  ActsSymMatrixD<3> rotMat100;
+  rotMat100 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform100.rotate(rotMat100);
+  transform100.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans100 = std::make_shared<const Transform3D>(transform100);
+  std::shared_ptr<PerigeeSurface> perigeeSurface100 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams100 = BoundParameters(tgContext, std::move(covMat100),
+                                        params100, perigeeSurface100);
+  tracks.push_back(boundParams100);
+
+  // track 101 :
+  BoundVector params101;
+  params101 << -0.0403421521186828613, 20.0219764709472656, 2.98151826858520508,
+      0.283174663782119751, -0.000182216783287003636 * 1. / (1_MeV), 0;
+  Covariance covMat101;
+  covMat101 << 0.0106812380254268646, -0.0024943587506664794,
+      -0.00027858873873760296, -4.44244638850068472e-06,
+      -5.26653512387191812e-08 * 1. / (1_MeV), 0, -0.0024943587506664794,
+      0.194047778844833374, 6.18626595670502936e-05, 0.000369563883583051613,
+      5.07052744885661252e-09 * 1. / (1_MeV), 0, -0.00027858873873760296,
+      6.18626595670502936e-05, 7.62251374908373691e-06, 1.15742939569733442e-07,
+      2.35948978506657342e-09 * 1. / (1_MeV), 0, -4.44244638850068472e-06,
+      0.000369563883583051613, 1.15742939569733442e-07, 7.40628024686884601e-07,
+      9.57926490773258748e-12 * 1. / (1_MeV), 0,
+      -5.26653512387191812e-08 * 1. / (1_MeV),
+      5.07052744885661252e-09 * 1. / (1_MeV),
+      2.35948978506657342e-09 * 1. / (1_MeV),
+      9.57926490773258748e-12 * 1. / (1_MeV),
+      2.45328583836634806e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform101;
+  ActsSymMatrixD<3> rotMat101;
+  rotMat101 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform101.rotate(rotMat101);
+  transform101.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans101 = std::make_shared<const Transform3D>(transform101);
+  std::shared_ptr<PerigeeSurface> perigeeSurface101 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams101 = BoundParameters(tgContext, std::move(covMat101),
+                                        params101, perigeeSurface101);
+  tracks.push_back(boundParams101);
+
+  // track 102 :
+  BoundVector params102;
+  params102 << 0.102368071675300598, 19.5361366271972656, 0.766166448593139648,
+      2.5110175609588623, -0.000775155378505587578 * 1. / (1_MeV), 0;
+  Covariance covMat102;
+  covMat102 << 0.011576404795050621, 0.000312717534921375974,
+      -0.000335520083970844722, 4.71286322771853713e-06,
+      -1.4290716638334455e-07 * 1. / (1_MeV), 0, 0.000312717534921375974,
+      0.0526967272162437439, -1.61243873360913762e-05, 0.000481644572307707124,
+      2.09254387760536983e-09 * 1. / (1_MeV), 0, -0.000335520083970844722,
+      -1.61243873360913762e-05, 9.90374064713250846e-06,
+      -2.10436751795918073e-07, 6.86918188030268416e-09 * 1. / (1_MeV), 0,
+      4.71286322771853713e-06, 0.000481644572307707124,
+      -2.10436751795918073e-07, 4.60942783320206217e-06,
+      -5.63914956480814653e-12 * 1. / (1_MeV), 0,
+      -1.4290716638334455e-07 * 1. / (1_MeV),
+      2.09254387760536983e-09 * 1. / (1_MeV),
+      6.86918188030268416e-09 * 1. / (1_MeV),
+      -5.63914956480814653e-12 * 1. / (1_MeV),
+      1.56449936339342344e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform102;
+  ActsSymMatrixD<3> rotMat102;
+  rotMat102 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform102.rotate(rotMat102);
+  transform102.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans102 = std::make_shared<const Transform3D>(transform102);
+  std::shared_ptr<PerigeeSurface> perigeeSurface102 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams102 = BoundParameters(tgContext, std::move(covMat102),
+                                        params102, perigeeSurface102);
+  tracks.push_back(boundParams102);
+
+  // track 103 :
+  BoundVector params103;
+  params103 << 0.00269113038666546345, 19.7512493133544922,
+      0.950928092002868652, 1.69274437427520752,
+      -0.000290958356345072389 * 1. / (1_MeV), 0;
+  Covariance covMat103;
+  covMat103 << 0.000890406954567879438, 9.06876283418256436e-06,
+      -2.11295340822724774e-05, 9.41784250991205146e-08,
+      -5.2726015222058164e-09 * 1. / (1_MeV), 0, 9.06876283418256436e-06,
+      0.00811147503554821014, -2.45248004436948366e-07, 0.000101593272660637559,
+      -2.7419352860978785e-09 * 1. / (1_MeV), 0, -2.11295340822724774e-05,
+      -2.45248004436948366e-07, 5.30661907305329805e-07,
+      -3.58145452722120584e-09, 2.49822767665423193e-10 * 1. / (1_MeV), 0,
+      9.41784250991205146e-08, 0.000101593272660637559,
+      -3.58145452722120584e-09, 2.08752635444398038e-06,
+      -5.68853159346797837e-11 * 1. / (1_MeV), 0,
+      -5.2726015222058164e-09 * 1. / (1_MeV),
+      -2.7419352860978785e-09 * 1. / (1_MeV),
+      2.49822767665423193e-10 * 1. / (1_MeV),
+      -5.68853159346797837e-11 * 1. / (1_MeV),
+      9.96157063087865779e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform103;
+  ActsSymMatrixD<3> rotMat103;
+  rotMat103 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform103.rotate(rotMat103);
+  transform103.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans103 = std::make_shared<const Transform3D>(transform103);
+  std::shared_ptr<PerigeeSurface> perigeeSurface103 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams103 = BoundParameters(tgContext, std::move(covMat103),
+                                        params103, perigeeSurface103);
+  tracks.push_back(boundParams103);
+
+  // track 104 :
+  BoundVector params104;
+  params104 << -0.245851978659629822, 20.1682567596435547, 1.23872554302215576,
+      0.248893141746520996, 0.000325477973092347383 * 1. / (1_MeV), 0;
+  Covariance covMat104;
+  covMat104 << 0.0286086816340684891, -0.001356925375741017,
+      -0.000851797951539738228, 1.97126922666860932e-06,
+      -2.43581517567970172e-07 * 1. / (1_MeV), 0, -0.001356925375741017,
+      0.490286678075790405, -8.99033667088915713e-06, 0.000865735597139924494,
+      2.32921530889448322e-08 * 1. / (1_MeV), 0, -0.000851797951539738228,
+      -8.99033667088915713e-06, 2.57704250543611124e-05,
+      -1.44063558527249657e-07, 1.22322871879510032e-08 * 1. / (1_MeV), 0,
+      1.97126922666860932e-06, 0.000865735597139924494,
+      -1.44063558527249657e-07, 1.54735130308836233e-06,
+      2.09896768832773089e-12 * 1. / (1_MeV), 0,
+      -2.43581517567970172e-07 * 1. / (1_MeV),
+      2.32921530889448322e-08 * 1. / (1_MeV),
+      1.22322871879510032e-08 * 1. / (1_MeV),
+      2.09896768832773089e-12 * 1. / (1_MeV),
+      1.2200331023226596e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform104;
+  ActsSymMatrixD<3> rotMat104;
+  rotMat104 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform104.rotate(rotMat104);
+  transform104.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans104 = std::make_shared<const Transform3D>(transform104);
+  std::shared_ptr<PerigeeSurface> perigeeSurface104 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams104 = BoundParameters(tgContext, std::move(covMat104),
+                                        params104, perigeeSurface104);
+  tracks.push_back(boundParams104);
+
+  // track 105 :
+  BoundVector params105;
+  params105 << -0.0600807033479213715, 19.7313117980957031, 2.31984329223632812,
+      1.3616642951965332, 0.000664964492898434401 * 1. / (1_MeV), 0;
+  Covariance covMat105;
+  covMat105 << 0.00314268073998391628, -7.7012257876423378e-06,
+      -8.51334898014966158e-05, 5.89304597370603241e-07,
+      -7.97505446520337312e-08 * 1. / (1_MeV), 0, -7.7012257876423378e-06,
+      0.0102382330223917961, -6.32454788190619239e-07, 0.000178850129128044883,
+      -9.30661620828337703e-09 * 1. / (1_MeV), 0, -8.51334898014966158e-05,
+      -6.32454788190619239e-07, 2.44164994001039304e-06,
+      -2.83573153286948557e-08, 3.20769979461027676e-09 * 1. / (1_MeV), 0,
+      5.89304597370603241e-07, 0.000178850129128044883,
+      -2.83573153286948557e-08, 4.20260403188876808e-06,
+      -1.84237869498140217e-10 * 1. / (1_MeV), 0,
+      -7.97505446520337312e-08 * 1. / (1_MeV),
+      -9.30661620828337703e-09 * 1. / (1_MeV),
+      3.20769979461027676e-09 * 1. / (1_MeV),
+      -1.84237869498140217e-10 * 1. / (1_MeV),
+      9.88064630114138254e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform105;
+  ActsSymMatrixD<3> rotMat105;
+  rotMat105 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform105.rotate(rotMat105);
+  transform105.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans105 = std::make_shared<const Transform3D>(transform105);
+  std::shared_ptr<PerigeeSurface> perigeeSurface105 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams105 = BoundParameters(tgContext, std::move(covMat105),
+                                        params105, perigeeSurface105);
+  tracks.push_back(boundParams105);
+
+  // track 106 :
+  BoundVector params106;
+  params106 << -0.0632231608033180237, 19.6254329681396484, 1.89337217807769775,
+      0.921234846115112305, -0.000626925728283822536 * 1. / (1_MeV), 0;
+  Covariance covMat106;
+  covMat106 << 0.00425710296258330345, -0.000219698489314023703,
+      -0.000117615295422727911, -2.52522899438900064e-06,
+      -5.43295757382818289e-08 * 1. / (1_MeV), 0, -0.000219698489314023703,
+      0.0236179828643798828, 7.04771554651835001e-06, 0.000339162159718363429,
+      -3.13730541114924775e-09 * 1. / (1_MeV), 0, -0.000117615295422727911,
+      7.04771554651835001e-06, 3.34456171913188882e-06, 9.40031753889414598e-08,
+      2.52804058098014408e-09 * 1. / (1_MeV), 0, -2.52522899438900064e-06,
+      0.000339162159718363429, 9.40031753889414598e-08, 5.38931180926738307e-06,
+      -2.20941594381711364e-11 * 1. / (1_MeV), 0,
+      -5.43295757382818289e-08 * 1. / (1_MeV),
+      -3.13730541114924775e-09 * 1. / (1_MeV),
+      2.52804058098014408e-09 * 1. / (1_MeV),
+      -2.20941594381711364e-11 * 1. / (1_MeV),
+      7.74676017778475057e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform106;
+  ActsSymMatrixD<3> rotMat106;
+  rotMat106 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform106.rotate(rotMat106);
+  transform106.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans106 = std::make_shared<const Transform3D>(transform106);
+  std::shared_ptr<PerigeeSurface> perigeeSurface106 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams106 = BoundParameters(tgContext, std::move(covMat106),
+                                        params106, perigeeSurface106);
+  tracks.push_back(boundParams106);
+
+  // track 107 :
+  BoundVector params107;
+  params107 << 0.360552132129669189, 18.9798069000244141, 2.17705512046813965,
+      2.95739436149597168, 0.000170226237969473004 * 1. / (1_MeV), 0;
+  Covariance covMat107;
+  covMat107 << 0.0202916935086250305, 0.000201601632849784387,
+      -0.000616325805420407701, 1.09389603440618418e-07,
+      -2.32012673409599967e-07 * 1. / (1_MeV), 0, 0.000201601632849784387,
+      0.596419632434844971, 3.27955063214520708e-05, 0.00059099745368901811,
+      1.02858367938844465e-08 * 1. / (1_MeV), 0, -0.000616325805420407701,
+      3.27955063214520708e-05, 1.91301714949076995e-05, 3.16951153463901935e-08,
+      1.15949223809287544e-08 * 1. / (1_MeV), 0, 1.09389603440618418e-07,
+      0.00059099745368901811, 3.16951153463901935e-08, 5.92274261634884169e-07,
+      -2.37559850171720801e-12 * 1. / (1_MeV), 0,
+      -2.32012673409599967e-07 * 1. / (1_MeV),
+      1.02858367938844465e-08 * 1. / (1_MeV),
+      1.15949223809287544e-08 * 1. / (1_MeV),
+      -2.37559850171720801e-12 * 1. / (1_MeV),
+      8.54574952469100424e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform107;
+  ActsSymMatrixD<3> rotMat107;
+  rotMat107 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform107.rotate(rotMat107);
+  transform107.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans107 = std::make_shared<const Transform3D>(transform107);
+  std::shared_ptr<PerigeeSurface> perigeeSurface107 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams107 = BoundParameters(tgContext, std::move(covMat107),
+                                        params107, perigeeSurface107);
+  tracks.push_back(boundParams107);
+
+  // track 108 :
+  BoundVector params108;
+  params108 << -0.0385420434176921844, 19.8494167327880859,
+      -2.91224813461303711, 0.434279114007949829,
+      0.000344612402841448784 * 1. / (1_MeV), 0;
+  Covariance covMat108;
+  covMat108 << 0.00708283483982086182, -0.000290315453926490662,
+      -0.000208821270084330699, -4.36274591953509495e-07,
+      -2.0634328653756119e-07 * 1. / (1_MeV), 0, -0.000290315453926490662,
+      0.0554034896194934845, 1.79575900534169211e-06, 0.000262110253474558965,
+      1.13649321255499376e-08 * 1. / (1_MeV), 0, -0.000208821270084330699,
+      1.79575900534169211e-06, 6.40597681922372431e-06,
+      -1.62866970452031225e-08, 9.99126779944540941e-09 * 1. / (1_MeV), 0,
+      -4.36274591953509495e-07, 0.000262110253474558965,
+      -1.62866970452031225e-08, 1.29895113332167966e-06,
+      3.16671471384196928e-11 * 1. / (1_MeV), 0,
+      -2.0634328653756119e-07 * 1. / (1_MeV),
+      1.13649321255499376e-08 * 1. / (1_MeV),
+      9.99126779944540941e-09 * 1. / (1_MeV),
+      3.16671471384196928e-11 * 1. / (1_MeV),
+      1.64341207309348647e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform108;
+  ActsSymMatrixD<3> rotMat108;
+  rotMat108 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform108.rotate(rotMat108);
+  transform108.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans108 = std::make_shared<const Transform3D>(transform108);
+  std::shared_ptr<PerigeeSurface> perigeeSurface108 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams108 = BoundParameters(tgContext, std::move(covMat108),
+                                        params108, perigeeSurface108);
+  tracks.push_back(boundParams108);
+
+  // track 109 :
+  BoundVector params109;
+  params109 << -0.0989816188812255859, 19.6172981262207031,
+      -2.41140604019165039, 0.801270425319671631,
+      -0.000793451210483908653 * 1. / (1_MeV), 0;
+  Covariance covMat109;
+  covMat109 << 0.00786646455526351929, -0.000344219331520010437,
+      -0.000221645718673196959, -4.14245788496836856e-06,
+      -1.37193307846517797e-07 * 1. / (1_MeV), 0, -0.000344219331520010437,
+      0.0273069571703672409, 1.18374970750359077e-05, 0.000350145532022221365,
+      2.43323438271879911e-09 * 1. / (1_MeV), 0, -0.000221645718673196959,
+      1.18374970750359077e-05, 6.48815375825506635e-06, 1.56811599604059021e-07,
+      6.52184431015660127e-09 * 1. / (1_MeV), 0, -4.14245788496836856e-06,
+      0.000350145532022221365, 1.56811599604059021e-07, 4.93106381327379495e-06,
+      2.39307717698818543e-11 * 1. / (1_MeV), 0,
+      -1.37193307846517797e-07 * 1. / (1_MeV),
+      2.43323438271879911e-09 * 1. / (1_MeV),
+      6.52184431015660127e-09 * 1. / (1_MeV),
+      2.39307717698818543e-11 * 1. / (1_MeV),
+      1.82697898476469334e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform109;
+  ActsSymMatrixD<3> rotMat109;
+  rotMat109 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform109.rotate(rotMat109);
+  transform109.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans109 = std::make_shared<const Transform3D>(transform109);
+  std::shared_ptr<PerigeeSurface> perigeeSurface109 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams109 = BoundParameters(tgContext, std::move(covMat109),
+                                        params109, perigeeSurface109);
+  tracks.push_back(boundParams109);
+
+  // track 110 :
+  BoundVector params110;
+  params110 << -0.248047471046447754, 19.6557636260986328, 2.29302573204040527,
+      0.649587929248809814, -0.00110239081550389528 * 1. / (1_MeV), 0;
+  Covariance covMat110;
+  covMat110 << 0.0216166544705629349, -0.00082482405910012024,
+      -0.000652860285832565414, -1.02919032841101398e-05,
+      -6.52212657639859215e-07 * 1. / (1_MeV), 0, -0.00082482405910012024,
+      0.0853162780404090881, 4.15812377535581474e-05, 0.000839477999853416139,
+      1.85719368884111095e-11 * 1. / (1_MeV), 0, -0.000652860285832565414,
+      4.15812377535581474e-05, 2.00744616449810565e-05, 4.89128117113744387e-07,
+      3.10100339064501893e-08 * 1. / (1_MeV), 0, -1.02919032841101398e-05,
+      0.000839477999853416139, 4.89128117113744387e-07, 8.57177292346023023e-06,
+      1.97141912126868163e-11 * 1. / (1_MeV), 0,
+      -6.52212657639859215e-07 * 1. / (1_MeV),
+      1.85719368884111095e-11 * 1. / (1_MeV),
+      3.10100339064501893e-08 * 1. / (1_MeV),
+      1.97141912126868163e-11 * 1. / (1_MeV),
+      7.19949988514656525e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform110;
+  ActsSymMatrixD<3> rotMat110;
+  rotMat110 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform110.rotate(rotMat110);
+  transform110.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans110 = std::make_shared<const Transform3D>(transform110);
+  std::shared_ptr<PerigeeSurface> perigeeSurface110 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams110 = BoundParameters(tgContext, std::move(covMat110),
+                                        params110, perigeeSurface110);
+  tracks.push_back(boundParams110);
+
+  // track 111 :
+  BoundVector params111;
+  params111 << 0.0262720081955194473, 19.8286037445068359, 2.18146443367004395,
+      2.08324813842773438, 0.000428368948632851243 * 1. / (1_MeV), 0;
+  Covariance covMat111;
+  covMat111 << 0.00158816727343946695, 9.4853627735629324e-06,
+      -4.36409249479155706e-05, -1.48995811754545918e-07,
+      -2.02757518900558508e-08 * 1. / (1_MeV), 0, 9.4853627735629324e-06,
+      0.0110956495627760887, 3.27586912949563326e-07, 0.000130563462425678848,
+      -4.16497402962450788e-09 * 1. / (1_MeV), 0, -4.36409249479155706e-05,
+      3.27586912949563326e-07, 1.24739369766757591e-06, 1.17262448099841417e-08,
+      8.7129027760781156e-10 * 1. / (1_MeV), 0, -1.48995811754545918e-07,
+      0.000130563462425678848, 1.17262448099841417e-08, 2.20083074964350089e-06,
+      -2.28033377013702109e-11 * 1. / (1_MeV), 0,
+      -2.02757518900558508e-08 * 1. / (1_MeV),
+      -4.16497402962450788e-09 * 1. / (1_MeV),
+      8.7129027760781156e-10 * 1. / (1_MeV),
+      -2.28033377013702109e-11 * 1. / (1_MeV),
+      2.59175268052524999e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform111;
+  ActsSymMatrixD<3> rotMat111;
+  rotMat111 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform111.rotate(rotMat111);
+  transform111.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans111 = std::make_shared<const Transform3D>(transform111);
+  std::shared_ptr<PerigeeSurface> perigeeSurface111 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams111 = BoundParameters(tgContext, std::move(covMat111),
+                                        params111, perigeeSurface111);
+  tracks.push_back(boundParams111);
+
+  // track 112 :
+  BoundVector params112;
+  params112 << 0.0326793268322944641, 19.8120479583740234, 0.889699041843414307,
+      1.57646119594573975, -0.000467951031168922782 * 1. / (1_MeV), 0;
+  Covariance covMat112;
+  covMat112 << 0.0013444551732391119, -1.04196358259948499e-06,
+      -3.51593985940863599e-05, -1.51435614902372445e-08,
+      -2.03697874567189654e-08 * 1. / (1_MeV), 0, -1.04196358259948499e-06,
+      0.0113611593842506409, 2.86736734379056518e-08, 0.000153356229013592134,
+      1.41074638188641834e-10 * 1. / (1_MeV), 0, -3.51593985940863599e-05,
+      2.86736734379056518e-08, 9.62528019954334013e-07, 3.04792415524836218e-10,
+      8.65383902854664365e-10 * 1. / (1_MeV), 0, -1.51435614902372445e-08,
+      0.000153356229013592134, 3.04792415524836218e-10, 3.0196767966117477e-06,
+      -4.83286461545659302e-12 * 1. / (1_MeV), 0,
+      -2.03697874567189654e-08 * 1. / (1_MeV),
+      1.41074638188641834e-10 * 1. / (1_MeV),
+      8.65383902854664365e-10 * 1. / (1_MeV),
+      -4.83286461545659302e-12 * 1. / (1_MeV),
+      2.99355089328212642e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform112;
+  ActsSymMatrixD<3> rotMat112;
+  rotMat112 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform112.rotate(rotMat112);
+  transform112.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans112 = std::make_shared<const Transform3D>(transform112);
+  std::shared_ptr<PerigeeSurface> perigeeSurface112 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams112 = BoundParameters(tgContext, std::move(covMat112),
+                                        params112, perigeeSurface112);
+  tracks.push_back(boundParams112);
+
+  // track 113 :
+  BoundVector params113;
+  params113 << 0.0479989089071750641, 19.5348949432373047, -1.84289538860321045,
+      2.54763102531433105, -0.000563078676350414753 * 1. / (1_MeV), 0;
+  Covariance covMat113;
+  covMat113 << 0.00674024224281311035, 0.000275261902324333151,
+      -0.000202055961074877318, 2.83455165085094845e-06,
+      -8.66185543146518417e-08 * 1. / (1_MeV), 0, 0.000275261902324333151,
+      0.0429738685488700867, -1.16714247102508588e-05, 0.000340657623151467128,
+      -1.21201365712005428e-09 * 1. / (1_MeV), 0, -0.000202055961074877318,
+      -1.16714247102508588e-05, 6.1798982642358169e-06,
+      -1.17638099338652864e-07, 4.25805894898182396e-09 * 1. / (1_MeV), 0,
+      2.83455165085094845e-06, 0.000340657623151467128,
+      -1.17638099338652864e-07, 2.85863870885805227e-06,
+      -1.98763016529320121e-11 * 1. / (1_MeV), 0,
+      -8.66185543146518417e-08 * 1. / (1_MeV),
+      -1.21201365712005428e-09 * 1. / (1_MeV),
+      4.25805894898182396e-09 * 1. / (1_MeV),
+      -1.98763016529320121e-11 * 1. / (1_MeV),
+      9.45928058104783531e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform113;
+  ActsSymMatrixD<3> rotMat113;
+  rotMat113 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform113.rotate(rotMat113);
+  transform113.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans113 = std::make_shared<const Transform3D>(transform113);
+  std::shared_ptr<PerigeeSurface> perigeeSurface113 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams113 = BoundParameters(tgContext, std::move(covMat113),
+                                        params113, perigeeSurface113);
+  tracks.push_back(boundParams113);
+
+  // track 114 :
+  BoundVector params114;
+  params114 << -0.166889190673828125, 19.049163818359375, 2.00572776794433594,
+      2.98232221603393555, -5.11993312102276832e-05 * 1. / (1_MeV), 0;
+  Covariance covMat114;
+  covMat114 << 0.00352242938242852688, 0.000933588696445512324,
+      -0.000101630702391713315, 5.56225575687583112e-07,
+      -4.72569998214100291e-08 * 1. / (1_MeV), 0, 0.000933588696445512324,
+      0.140665516257286072, -2.55878928890533955e-05, 9.91245475972232033e-05,
+      -4.82721694350305098e-09 * 1. / (1_MeV), 0, -0.000101630702391713315,
+      -2.55878928890533955e-05, 3.07548725686501712e-06,
+      -1.60878195926674544e-08, 2.32450177496049771e-09 * 1. / (1_MeV), 0,
+      5.56225575687583112e-07, 9.91245475972232033e-05,
+      -1.60878195926674544e-08, 7.18341084393614437e-08,
+      -2.32272171088200988e-12 * 1. / (1_MeV), 0,
+      -4.72569998214100291e-08 * 1. / (1_MeV),
+      -4.82721694350305098e-09 * 1. / (1_MeV),
+      2.32450177496049771e-09 * 1. / (1_MeV),
+      -2.32272171088200988e-12 * 1. / (1_MeV),
+      1.44301818758019174e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform114;
+  ActsSymMatrixD<3> rotMat114;
+  rotMat114 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform114.rotate(rotMat114);
+  transform114.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans114 = std::make_shared<const Transform3D>(transform114);
+  std::shared_ptr<PerigeeSurface> perigeeSurface114 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams114 = BoundParameters(tgContext, std::move(covMat114),
+                                        params114, perigeeSurface114);
+  tracks.push_back(boundParams114);
+
+  // track 115 :
+  BoundVector params115;
+  params115 << 0.0137746464461088181, 19.6609287261962891, 2.67169976234436035,
+      1.68737459182739258, -0.000312122545437887311 * 1. / (1_MeV), 0;
+  Covariance covMat115;
+  covMat115 << 0.00205370550975203514, 2.57276641361198506e-05,
+      -4.35124207927626197e-05, 2.05754998361759643e-07,
+      -7.68677673940147419e-09 * 1. / (1_MeV), 0, 2.57276641361198506e-05,
+      0.00751006556674838066, -5.60196307230371148e-07, 0.000104370906596587887,
+      -2.31954884204932396e-09 * 1. / (1_MeV), 0, -4.35124207927626197e-05,
+      -5.60196307230371148e-07, 9.7233169071841985e-07,
+      -5.78757716049063737e-09, 3.21560072675208627e-10 * 1. / (1_MeV), 0,
+      2.05754998361759643e-07, 0.000104370906596587887,
+      -5.78757716049063737e-09, 2.29740794566168915e-06,
+      -4.91169097872738332e-11 * 1. / (1_MeV), 0,
+      -7.68677673940147419e-09 * 1. / (1_MeV),
+      -2.31954884204932396e-09 * 1. / (1_MeV),
+      3.21560072675208627e-10 * 1. / (1_MeV),
+      -4.91169097872738332e-11 * 1. / (1_MeV),
+      1.16981858228060176e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform115;
+  ActsSymMatrixD<3> rotMat115;
+  rotMat115 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform115.rotate(rotMat115);
+  transform115.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans115 = std::make_shared<const Transform3D>(transform115);
+  std::shared_ptr<PerigeeSurface> perigeeSurface115 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams115 = BoundParameters(tgContext, std::move(covMat115),
+                                        params115, perigeeSurface115);
+  tracks.push_back(boundParams115);
+
+  // track 116 :
+  BoundVector params116;
+  params116 << 1.04568362236022949, 19.1366863250732422, 2.12020516395568848,
+      2.92311358451843262, 9.25068379729054868e-05 * 1. / (1_MeV), 0;
+  Covariance covMat116;
+  covMat116 << 0.00488254847005009651, 0.000740361421888004493,
+      -0.00013463378504927599, 1.2158197600630495e-06,
+      -3.36609027457528485e-08 * 1. / (1_MeV), 0, 0.000740361421888004493,
+      0.114923417568206787, -8.05991571412841247e-06, 0.000146249036050893433,
+      4.20761461930579654e-09 * 1. / (1_MeV), 0, -0.00013463378504927599,
+      -8.05991571412841247e-06, 3.85931298296782188e-06,
+      -2.17580929998134164e-08, 1.60649110182894787e-09 * 1. / (1_MeV), 0,
+      1.2158197600630495e-06, 0.000146249036050893433, -2.17580929998134164e-08,
+      1.92376987229181395e-07, -2.78492110134724017e-12 * 1. / (1_MeV), 0,
+      -3.36609027457528485e-08 * 1. / (1_MeV),
+      4.20761461930579654e-09 * 1. / (1_MeV),
+      1.60649110182894787e-09 * 1. / (1_MeV),
+      -2.78492110134724017e-12 * 1. / (1_MeV),
+      1.35187555594384889e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform116;
+  ActsSymMatrixD<3> rotMat116;
+  rotMat116 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform116.rotate(rotMat116);
+  transform116.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans116 = std::make_shared<const Transform3D>(transform116);
+  std::shared_ptr<PerigeeSurface> perigeeSurface116 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams116 = BoundParameters(tgContext, std::move(covMat116),
+                                        params116, perigeeSurface116);
+  tracks.push_back(boundParams116);
+
+  // track 117 :
+  BoundVector params117;
+  params117 << -1.20940804481506348, 19.6823959350585938, -1.81289887428283691,
+      0.625804603099822998, 0.000932577764615416527 * 1. / (1_MeV), 0;
+  Covariance covMat117;
+  covMat117 << 0.0626278072595596313, -0.00168264653846623741,
+      -0.00141945234148735475, 1.67458965126927841e-05,
+      -7.54246802546992556e-07 * 1. / (1_MeV), 0, -0.00168264653846623741,
+      0.230180084705352783, -2.73170868898178382e-06, 0.00158152202219789709,
+      6.02409280618631771e-08 * 1. / (1_MeV), 0, -0.00141945234148735475,
+      -2.73170868898178382e-06, 3.37690398737322539e-05,
+      -7.02785129344153319e-07, 2.29061226487353007e-08 * 1. / (1_MeV), 0,
+      1.67458965126927841e-05, 0.00158152202219789709, -7.02785129344153319e-07,
+      1.19483884191140532e-05, 4.05549492337246129e-12 * 1. / (1_MeV), 0,
+      -7.54246802546992556e-07 * 1. / (1_MeV),
+      6.02409280618631771e-08 * 1. / (1_MeV),
+      2.29061226487353007e-08 * 1. / (1_MeV),
+      4.05549492337246129e-12 * 1. / (1_MeV),
+      3.22085941251160079e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform117;
+  ActsSymMatrixD<3> rotMat117;
+  rotMat117 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform117.rotate(rotMat117);
+  transform117.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans117 = std::make_shared<const Transform3D>(transform117);
+  std::shared_ptr<PerigeeSurface> perigeeSurface117 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams117 = BoundParameters(tgContext, std::move(covMat117),
+                                        params117, perigeeSurface117);
+  tracks.push_back(boundParams117);
+
+  // track 118 :
+  BoundVector params118;
+  params118 << -0.103346407413482666, 19.7446269989013672, -1.91661596298217773,
+      1.42171478271484375, 0.000703335157595574856 * 1. / (1_MeV), 0;
+  Covariance covMat118;
+  covMat118 << 0.00270943623036146164, -1.17879856763720662e-06,
+      -7.38598630680866423e-05, 3.22994399828456964e-07,
+      -4.07104504838410184e-08 * 1. / (1_MeV), 0, -1.17879856763720662e-06,
+      0.0154081536456942558, -2.72538651083495857e-07, 0.000256186705875633325,
+      6.87005786986738928e-09 * 1. / (1_MeV), 0, -7.38598630680866423e-05,
+      -2.72538651083495857e-07, 2.10873281503154431e-06,
+      -1.4483024887950514e-08, 1.8152406999218687e-09 * 1. / (1_MeV), 0,
+      3.22994399828456964e-07, 0.000256186705875633325, -1.4483024887950514e-08,
+      5.78958861296996474e-06, 9.80498638799178923e-11 * 1. / (1_MeV), 0,
+      -4.07104504838410184e-08 * 1. / (1_MeV),
+      6.87005786986738928e-09 * 1. / (1_MeV),
+      1.8152406999218687e-09 * 1. / (1_MeV),
+      9.80498638799178923e-11 * 1. / (1_MeV),
+      6.60063531610077803e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform118;
+  ActsSymMatrixD<3> rotMat118;
+  rotMat118 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform118.rotate(rotMat118);
+  transform118.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans118 = std::make_shared<const Transform3D>(transform118);
+  std::shared_ptr<PerigeeSurface> perigeeSurface118 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams118 = BoundParameters(tgContext, std::move(covMat118),
+                                        params118, perigeeSurface118);
+  tracks.push_back(boundParams118);
+
+  // track 119 :
+  BoundVector params119;
+  params119 << 2.92615675926208496, 17.8650016784667969, -1.95857036113739014,
+      1.128387451171875, 0.00111896148882806301 * 1. / (1_MeV), 0;
+  Covariance covMat119;
+  covMat119 << 0.0144027825444936752, 0.000621878947040222689,
+      -0.0004899059955729096, 7.73510238988940677e-07,
+      -5.53971455935470655e-06 * 1. / (1_MeV), 0, 0.000621878947040222689,
+      0.025294894352555275, -2.52380243351548066e-05, 0.000523347752496337772,
+      -2.67676038791141531e-07 * 1. / (1_MeV), 0, -0.0004899059955729096,
+      -2.52380243351548066e-05, 1.7668540749582462e-05,
+      -8.13551792131595242e-08, 2.65852444971337825e-07 * 1. / (1_MeV), 0,
+      7.73510238988940677e-07, 0.000523347752496337772,
+      -8.13551792131595242e-08, 1.16607652671518736e-05,
+      1.44441837008855634e-09 * 1. / (1_MeV), 0,
+      -5.53971455935470655e-06 * 1. / (1_MeV),
+      -2.67676038791141531e-07 * 1. / (1_MeV),
+      2.65852444971337825e-07 * 1. / (1_MeV),
+      1.44441837008855634e-09 * 1. / (1_MeV),
+      9.32011001708588083e-09 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform119;
+  ActsSymMatrixD<3> rotMat119;
+  rotMat119 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform119.rotate(rotMat119);
+  transform119.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans119 = std::make_shared<const Transform3D>(transform119);
+  std::shared_ptr<PerigeeSurface> perigeeSurface119 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams119 = BoundParameters(tgContext, std::move(covMat119),
+                                        params119, perigeeSurface119);
+  tracks.push_back(boundParams119);
+
+  // track 120 :
+  BoundVector params120;
+  params120 << -0.0391223952174186707, 19.8085842132568359,
+      -1.63484728336334229, 1.43253195285797119,
+      0.00101388362236320972 * 1. / (1_MeV), 0;
+  Covariance covMat120;
+  covMat120 << 0.00591104757040739059, 2.19808179401814768e-05,
+      -0.000175305312354405934, 9.33348192222842228e-07,
+      -8.2119913789129893e-08 * 1. / (1_MeV), 0, 2.19808179401814768e-05,
+      0.0155321685597300529, -1.19100607880362392e-06, 0.000313805117109273242,
+      -4.29338952794729048e-09 * 1. / (1_MeV), 0, -0.000175305312354405934,
+      -1.19100607880362392e-06, 5.27355723534128629e-06,
+      -3.99720907755572675e-08, 3.63588214025051008e-09 * 1. / (1_MeV), 0,
+      9.33348192222842228e-07, 0.000313805117109273242,
+      -3.99720907755572675e-08, 7.98895416664890945e-06,
+      -7.83235112558509684e-11 * 1. / (1_MeV), 0,
+      -8.2119913789129893e-08 * 1. / (1_MeV),
+      -4.29338952794729048e-09 * 1. / (1_MeV),
+      3.63588214025051008e-09 * 1. / (1_MeV),
+      -7.83235112558509684e-11 * 1. / (1_MeV),
+      1.22159560245194143e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform120;
+  ActsSymMatrixD<3> rotMat120;
+  rotMat120 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform120.rotate(rotMat120);
+  transform120.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans120 = std::make_shared<const Transform3D>(transform120);
+  std::shared_ptr<PerigeeSurface> perigeeSurface120 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams120 = BoundParameters(tgContext, std::move(covMat120),
+                                        params120, perigeeSurface120);
+  tracks.push_back(boundParams120);
+
+  // track 121 :
+  BoundVector params121;
+  params121 << 3.2684485912322998, -50.3953475952148438, -1.9672924280166626,
+      2.11276745796203613, -0.00146105431485921144 * 1. / (1_MeV), 0;
+  Covariance covMat121;
+  covMat121 << 0.0276485588401556015, -0.00123167623434729842,
+      -0.000845118835855476042, 1.50004803399650862e-05,
+      -1.34122397572779639e-07 * 1. / (1_MeV), 0, -0.00123167623434729842,
+      0.0636397004127502441, 2.49535016337183792e-05, 0.00133656416735393577,
+      -2.37478957538643704e-08 * 1. / (1_MeV), 0, -0.000845118835855476042,
+      2.49535016337183792e-05, 2.60623473877785727e-05,
+      -7.59009162244489968e-07, 7.34075798768037725e-09 * 1. / (1_MeV), 0,
+      1.50004803399650862e-05, 0.00133656416735393577, -7.59009162244489968e-07,
+      2.95604022539919242e-05, -8.85865579693641169e-10 * 1. / (1_MeV), 0,
+      -1.34122397572779639e-07 * 1. / (1_MeV),
+      -2.37478957538643704e-08 * 1. / (1_MeV),
+      7.34075798768037725e-09 * 1. / (1_MeV),
+      -8.85865579693641169e-10 * 1. / (1_MeV),
+      2.87734891468716114e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform121;
+  ActsSymMatrixD<3> rotMat121;
+  rotMat121 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform121.rotate(rotMat121);
+  transform121.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans121 = std::make_shared<const Transform3D>(transform121);
+  std::shared_ptr<PerigeeSurface> perigeeSurface121 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams121 = BoundParameters(tgContext, std::move(covMat121),
+                                        params121, perigeeSurface121);
+  tracks.push_back(boundParams121);
+
+  // track 122 :
+  BoundVector params122;
+  params122 << 0.645450115203857422, 28.7973823547363281, 2.10054993629455566,
+      2.9601600170135498, -0.000159988034283742309 * 1. / (1_MeV), 0;
+  Covariance covMat122;
+  covMat122 << 0.0836148038506507874, -0.00281942085938153468,
+      -0.00185879864445105355, 6.07247514248449154e-06,
+      -7.03189829531797196e-07 * 1. / (1_MeV), 0, -0.00281942085938153468,
+      2.70882201194763184, -5.8760191905531437e-05, 0.00188818417948824089,
+      -4.8300783514351801e-08 * 1. / (1_MeV), 0, -0.00185879864445105355,
+      -5.8760191905531437e-05, 4.32657325291074812e-05,
+      -2.25070179677390569e-07, 2.13601337599813795e-08 * 1. / (1_MeV), 0,
+      6.07247514248449154e-06, 0.00188818417948824089, -2.25070179677390569e-07,
+      1.36935625505429925e-06, -1.00269941249161656e-10 * 1. / (1_MeV), 0,
+      -7.03189829531797196e-07 * 1. / (1_MeV),
+      -4.8300783514351801e-08 * 1. / (1_MeV),
+      2.13601337599813795e-08 * 1. / (1_MeV),
+      -1.00269941249161656e-10 * 1. / (1_MeV),
+      9.22178722273514495e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform122;
+  ActsSymMatrixD<3> rotMat122;
+  rotMat122 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform122.rotate(rotMat122);
+  transform122.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans122 = std::make_shared<const Transform3D>(transform122);
+  std::shared_ptr<PerigeeSurface> perigeeSurface122 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams122 = BoundParameters(tgContext, std::move(covMat122),
+                                        params122, perigeeSurface122);
+  tracks.push_back(boundParams122);
+
+  // track 123 :
+  BoundVector params123;
+  params123 << -0.260677635669708252, 19.68109130859375, -0.0893123745918273926,
+      2.24275779724121094, 0.000180564093170687556 * 1. / (1_MeV), 0;
+  Covariance covMat123;
+  covMat123 << 0.00429143151268362999, -0.000282303309317850546,
+      -5.84570627457094727e-05, -1.77592772045934701e-06,
+      -5.25916079357569643e-08 * 1. / (1_MeV), 0, -0.000282303309317850546,
+      0.0253302454948425293, 3.20487213205718757e-06, 0.00012674431483371596,
+      5.10278523593403899e-09 * 1. / (1_MeV), 0, -5.84570627457094727e-05,
+      3.20487213205718757e-06, 9.13998974283458665e-07, 2.36155606611666679e-08,
+      8.36921112357011164e-10 * 1. / (1_MeV), 0, -1.77592772045934701e-06,
+      0.00012674431483371596, 2.36155606611666679e-08, 9.15854911909264047e-07,
+      4.54410066110091468e-11 * 1. / (1_MeV), 0,
+      -5.25916079357569643e-08 * 1. / (1_MeV),
+      5.10278523593403899e-09 * 1. / (1_MeV),
+      8.36921112357011164e-10 * 1. / (1_MeV),
+      4.54410066110091468e-11 * 1. / (1_MeV),
+      8.13594937948414199e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  Transform3D transform123;
+  ActsSymMatrixD<3> rotMat123;
+  rotMat123 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
+  transform123.rotate(rotMat123);
+  transform123.translation() = Vector3D(-0.5, -0.5, 0);
+  auto sharedTrans123 = std::make_shared<const Transform3D>(transform123);
+  std::shared_ptr<PerigeeSurface> perigeeSurface123 =
+      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  auto boundParams123 = BoundParameters(tgContext, std::move(covMat123),
+                                        params123, perigeeSurface123);
+  tracks.push_back(boundParams123);
+
+  return tracks;
 }
 
-
-
 }  // namespace Test
 }  // namespace Acts
diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
index 589fb8c2b..bdff6e69d 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
@@ -61,7 +61,7 @@ std::uniform_int_distribution<> nTracksDist(3, 10);
 /// @brief Unit test for AdaptiveMultiVertexFitter
 ///
 BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test) {
-  bool debugMode = false;
+  bool debugMode = true;
 
   // Set up RNG
   int mySeed = 31415;
@@ -103,14 +103,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test) {
   Vector3D vtxPos2(-0.1_mm, -0.15_mm, -3._mm);
   Vector3D vtxPos3(0.2_mm, 0.2_mm, 10._mm);
 
-  std::vector<Vector3D> vtxVec{vtxPos1, vtxPos2, vtxPos3};
-
-  // Vector to store vectors of Tracks at vertex for every vertex
-  std::vector<std::vector<TrackAtVertex<BoundParameters>>> trackVtxVec(
-      vtxVec.size());
-
-  // only for debugging
-  std::vector<TrackAtVertex<BoundParameters>> allTracks;
+  std::vector<Vector3D> vtxPosVec{vtxPos1, vtxPos2, vtxPos3};
 
   // Resolutions, use the same for all tracks
   double resD0 = resIPDist(gen);
@@ -119,10 +112,35 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test) {
   double resTh = resAngDist(gen);
   double resQp = resQoPDist(gen);
 
+  std::vector<Vertex<BoundParameters>> vtxList;
+  for (auto& vtxPos : vtxPosVec) {
+    Vertex<BoundParameters> vtx(vtxPos);
+    // Set some vertex covariance
+    SpacePointSymMatrix posCovariance(SpacePointSymMatrix::Identity());
+    vtx.setFullCovariance(posCovariance);
+    // Add to vertex list
+    vtxList.push_back(vtx);
+  }
+
+  std::vector<Vertex<BoundParameters>*> vtxPtrList;
+  int cv = 0;
+  if (debugMode) {
+    std::cout << "All vertices in test case: " << std::endl;
+  }
+  for (auto& vtx : vtxList) {
+    if (debugMode) {
+      cv++;
+      std::cout << "\t" << cv << ". vertex ptr: " << &vtx << std::endl;
+    }
+    vtxPtrList.push_back(&vtx);
+  }
+
+  std::vector<const BoundParameters> allTracks;
+
   unsigned int nTracksPerVtx = 4;
   // Construct nTracksPerVtx * 3 (3 vertices) random track emerging
   // from vicinity of vertex positions
-  for (unsigned int iTrack = 0; iTrack < nTracksPerVtx * vtxVec.size();
+  for (unsigned int iTrack = 0; iTrack < nTracksPerVtx * vtxPosVec.size();
        iTrack++) {
     // Construct positive or negative charge randomly
     double q = qDist(gen) < 0 ? -1. : 1.;
@@ -143,60 +161,66 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test) {
         q / pTDist(gen), 0.;
 
     std::shared_ptr<PerigeeSurface> perigeeSurface =
-        Surface::makeShared<PerigeeSurface>(vtxVec[vtxIdx]);
-
-    auto trk =
-        BoundParameters(tgContext, std::move(covMat), paramVec, perigeeSurface);
+        Surface::makeShared<PerigeeSurface>(vtxPosVec[vtxIdx]);
 
-    TrackAtVertex<BoundParameters> trkAtVtx(1., trk, trk);
+    allTracks.push_back(BoundParameters(tgContext, std::move(covMat), paramVec,
+                                        perigeeSurface));
+  }
 
-    if (debugMode) {
-      std::cout << "Adding track " << iTrack << " for vertex " << vtxIdx
-                << "\n\twith ID: " << trkAtVtx.id
-                << "\n\tparams:  " << trk.parameters() << std::endl;
-      allTracks.push_back(trkAtVtx);
+  if (debugMode) {
+    int ct = 0;
+    std::cout << "All tracks in test case: " << std::endl;
+    for (auto& trk : allTracks) {
+      ct++;
+      std::cout << "\t" << ct << ". track ptr: " << &trk << std::endl;
     }
+  }
 
-    trackVtxVec[vtxIdx].push_back(trkAtVtx);
+  AdaptiveMultiVertexFitter<BoundParameters, Linearizer>::State state;
+
+  for (unsigned int iTrack = 0; iTrack < nTracksPerVtx * vtxPosVec.size();
+       iTrack++) {
+    // Index of current vertex
+    int vtxIdx = (int)(iTrack / nTracksPerVtx);
+    state.vtxInfoMap[&vtxList[vtxIdx]].trackLinks.push_back(&allTracks[iTrack]);
+    state.tracksAtVerticesMap.insert(
+        std::make_pair(std::make_pair(&allTracks[iTrack], &vtxList[vtxIdx]),
+                       TrackAtVertex<BoundParameters>(1., allTracks[iTrack],
+                                                      allTracks[iTrack])));
 
     // Use first track also for second vertex to let vtx1 and vtx2
     // share this track
     if (iTrack == 0) {
-      trackVtxVec[1].push_back(trkAtVtx);
+      state.vtxInfoMap[&vtxList[1]].trackLinks.push_back(&allTracks[iTrack]);
+      state.tracksAtVerticesMap.insert(
+          std::make_pair(std::make_pair(&allTracks[iTrack], &vtxList[1]),
+                         TrackAtVertex<BoundParameters>(1., allTracks[iTrack],
+                                                        allTracks[iTrack])));
     }
   }
 
-  std::vector<Vertex<BoundParameters>> vtxList;
-
-  int idx = 0;
-  for (auto& vtxPos : vtxVec) {
-    Vertex<BoundParameters> vtx(vtxPos);
-    // Set track for current vertex
-    vtx.setTracksAtVertex(trackVtxVec[idx]);
-    // Set some vertex covariance
-    SpacePointSymMatrix posCovariance(SpacePointSymMatrix::Identity());
-    vtx.setFullCovariance(posCovariance);
-    // Add to vertex list
-    vtxList.push_back(vtx);
-    idx++;
-  }
-
   if (debugMode) {
-    int count = 0;
-    for (auto& vtx : vtxList) {
-      count++;
-      std::cout << count << ". vertex: " << &vtx << std::endl;
+    std::cout << "Tracks linked to each vertex: " << std::endl;
+    int c = 0;
+    for (auto& vtx : vtxPtrList) {
+      c++;
+      std::cout << c << ". vertex, with ptr: " << vtx << std::endl;
+      for (auto& trk : state.vtxInfoMap[vtx].trackLinks) {
+        std::cout << "\t track ptr: " << trk << std::endl;
+      }
     }
   }
 
-  AdaptiveMultiVertexFitter<BoundParameters, Linearizer>::State state(vtxList);
+  state.updateTrkToVerticesMultiMap(vtxPtrList);
 
   if (debugMode) {
-    for (auto& trkAtVtx : allTracks) {
-      auto links = state.trkInfoMap[trkAtVtx.id].linksToVertices;
-      for (auto vtxLink : links) {
-        std::cout << "Track with ID: " << trkAtVtx.id << " used by vertex "
-                  << vtxLink << std::endl;
+    std::cout << "Checking all vertices linked to a single track: "
+              << std::endl;
+    for (auto& trk : allTracks) {
+      std::cout << "Track with ptr: " << &trk << std::endl;
+      auto range = state.trackToVerticesMultiMap.equal_range(&trk);
+      for (auto vtxIter = range.first; vtxIter != range.second; ++vtxIter) {
+        std::cout << "\t used by vertex: " << vtxIter->second << std::endl;
       }
     }
   }
@@ -205,8 +229,33 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test) {
   // list in order to be able to compare later
   std::vector<Vertex<BoundParameters>> seedListCopy = vtxList;
 
+  std::cout << "HERE 0" << std::endl;
   auto res1 = fitter.addVtxToFit(state, vtxList[0], linearizer, fitterOptions);
 
+  if (debugMode) {
+    std::cout << "Tracks linked to each vertex AFTER fit: " << std::endl;
+    int c = 0;
+    for (auto& vtx : vtxPtrList) {
+      c++;
+      std::cout << c << ". vertex, with ptr: " << vtx << std::endl;
+      for (auto& trk : state.vtxInfoMap[vtx].trackLinks) {
+        std::cout << "\t track ptr: " << trk << std::endl;
+      }
+    }
+  }
+
+  if (debugMode) {
+    std::cout << "Checking all vertices linked to a single track AFTER fit: "
+              << std::endl;
+    for (auto& trk : allTracks) {
+      std::cout << "Track with ptr: " << &trk << std::endl;
+      auto range = state.trackToVerticesMultiMap.equal_range(&trk);
+      for (auto vtxIter = range.first; vtxIter != range.second; ++vtxIter) {
+        std::cout << "\t used by vertex: " << vtxIter->second << std::endl;
+      }
+    }
+  }
+
   BOOST_CHECK(res1.ok());
 
   if (debugMode) {
@@ -261,7 +310,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test) {
 /// test values are used here
 BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test_athena) {
   // Set debug mode
-  bool debugMode = false;
+  bool debugMode = true;
   // Set up constant B-Field
   ConstantBField bField(Vector3D(0., 0., 2_T));
 
@@ -363,17 +412,10 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test_athena) {
       BoundParameters(tgContext, covMat2, pos2c, mom2c, -1, 0,
                       Surface::makeShared<PerigeeSurface>(pos2c)));
 
-  std::vector<TrackAtVertex<BoundParameters>> tracksAtVtx1;
-  for (const auto& trk : params1) {
-    tracksAtVtx1.push_back(TrackAtVertex<BoundParameters>(1.5, trk, trk));
-  }
-  std::vector<TrackAtVertex<BoundParameters>> tracksAtVtx2;
-  for (const auto& trk : params2) {
-    tracksAtVtx2.push_back(TrackAtVertex<BoundParameters>(1.5, trk, trk));
-  }
-
   std::vector<Vertex<BoundParameters>*> vtxList;
 
+  AdaptiveMultiVertexFitter<BoundParameters, Linearizer>::State state;
+
   // The constraint vertex position covariance
   SpacePointSymMatrix covConstr(SpacePointSymMatrix::Identity());
   covConstr = covConstr * 1e+8;
@@ -382,8 +424,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test_athena) {
   // Prepare first vertex
   Vector3D vtxPos1(0.15_mm, 0.15_mm, 2.9_mm);
   Vertex<BoundParameters> vtx1(vtxPos1);
-  // Set track for current vertex
-  vtx1.setTracksAtVertex(tracksAtVtx1);
+
   // Add to vertex list
   vtxList.push_back(&vtx1);
 
@@ -400,11 +441,17 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test_athena) {
   vtxInfo1.oldPosition = vtxInfo1.linPoint;
   vtxInfo1.seedPosition = vtxInfo1.linPoint;
 
+  for (const auto& trk : params1) {
+    vtxInfo1.trackLinks.push_back(&trk);
+    state.tracksAtVerticesMap.insert(
+        std::make_pair(std::make_pair(&trk, &vtx1),
+                       TrackAtVertex<BoundParameters>(1.5, trk, trk)));
+  }
+
   // Prepare second vertex
   Vector3D vtxPos2(0.3_mm, -0.2_mm, -4.8_mm);
   Vertex<BoundParameters> vtx2(vtxPos2);
-  // Set track for current vertex
-  vtx2.setTracksAtVertex(tracksAtVtx2);
+
   // Add to vertex list
   vtxList.push_back(&vtx2);
 
@@ -421,40 +468,47 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test_athena) {
   vtxInfo2.oldPosition = vtxInfo2.linPoint;
   vtxInfo2.seedPosition = vtxInfo2.linPoint;
 
-  AdaptiveMultiVertexFitter<BoundParameters, Linearizer>::State state(vtxList);
+  for (const auto& trk : params2) {
+    vtxInfo2.trackLinks.push_back(&trk);
+    state.tracksAtVerticesMap.insert(
+        std::make_pair(std::make_pair(&trk, &vtx2),
+                       TrackAtVertex<BoundParameters>(1.5, trk, trk)));
+  }
+
+  state.vtxInfoMap[&vtx1] = std::move(vtxInfo1);
+  state.vtxInfoMap[&vtx2] = std::move(vtxInfo2);
 
-  state.vtxInfoMap[&vtx1] = vtxInfo1;
-  state.vtxInfoMap[&vtx2] = vtxInfo2;
+  state.updateTrkToVerticesMultiMap(vtxList);
 
   // Fit vertices
   fitter.fit(state, vtxList, linearizer, fitterOptions);
 
   auto vtx1Pos = state.vertexCollection[0]->position();
   auto vtx1Cov = state.vertexCollection[0]->covariance();
-  auto vtx1Trks = state.vertexCollection[0]->tracks();
+  // auto vtx1Trks = state.vertexCollection[0]->tracks();
   auto vtx1FQ = state.vertexCollection[0]->fitQuality();
 
   auto vtx2Pos = state.vertexCollection[1]->position();
   auto vtx2Cov = state.vertexCollection[1]->covariance();
-  auto vtx2Trks = state.vertexCollection[1]->tracks();
+  // auto vtx2Trks = state.vertexCollection[1]->tracks();
   auto vtx2FQ = state.vertexCollection[1]->fitQuality();
 
   if (debugMode) {
     // Vertex 1
     std::cout << "Vertex 1, position: " << vtx1Pos << std::endl;
     std::cout << "Vertex 1, covariance: " << vtx1Cov << std::endl;
-    for (auto t : vtx1Trks) {
-      std::cout << "\tTrackWeight:" << t.trackWeight << std::endl;
-    }
+    // for (auto t : vtx1Trks) {
+    //   std::cout << "\tTrackWeight:" << t.trackWeight << std::endl;
+    // }
     std::cout << "Vertex 1, chi2: " << vtx1FQ.first << std::endl;
     std::cout << "Vertex 1, ndf: " << vtx1FQ.second << std::endl;
 
     // Vertex 2
     std::cout << "Vertex 2, position: " << vtx2Pos << std::endl;
     std::cout << "Vertex 2, covariance: " << vtx2Cov << std::endl;
-    for (auto t : vtx2Trks) {
-      std::cout << "\tTrackWeight:" << t.trackWeight << std::endl;
-    }
+    // for (auto t : vtx2Trks) {
+    //   std::cout << "\tTrackWeight:" << t.trackWeight << std::endl;
+    // }
     std::cout << "Vertex 2, chi2: " << vtx2FQ.first << std::endl;
     std::cout << "Vertex 2, ndf: " << vtx2FQ.second << std::endl;
   }
@@ -487,7 +541,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test_athena) {
   CHECK_CLOSE_ABS(vtx1Pos, expVtx1Pos, 0.001_mm);
   CHECK_CLOSE_ABS(vtx1Cov, expVtx1Cov, 0.001_mm);
   for (int i = 0; i < expVtx1TrkWeights.size(); i++) {
-    CHECK_CLOSE_ABS(vtx1Trks[i].trackWeight, expVtx1TrkWeights[i], 0.001);
+    // CHECK_CLOSE_ABS(vtx1Trks[i].trackWeight, expVtx1TrkWeights[i], 0.001);
   }
   CHECK_CLOSE_ABS(vtx1FQ.first, expVtx1chi2, 0.001);
   CHECK_CLOSE_ABS(vtx1FQ.second, expVtx1ndf, 0.001);
@@ -496,7 +550,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test_athena) {
   CHECK_CLOSE_ABS(vtx2Pos, expVtx2Pos, 0.001_mm);
   CHECK_CLOSE_ABS(vtx2Cov, expVtx2Cov, 0.001_mm);
   for (int i = 0; i < expVtx2TrkWeights.size(); i++) {
-    CHECK_CLOSE_ABS(vtx2Trks[i].trackWeight, expVtx2TrkWeights[i], 0.001);
+    // CHECK_CLOSE_ABS(vtx2Trks[i].trackWeight, expVtx2TrkWeights[i], 0.001);
   }
   CHECK_CLOSE_ABS(vtx2FQ.first, expVtx2chi2, 0.001);
   CHECK_CLOSE_ABS(vtx2FQ.second, expVtx2ndf, 0.001);
diff --git a/Tests/UnitTests/Core/Vertexing/CMakeLists.txt b/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
index 829ef494c..37c700abd 100644
--- a/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
+++ b/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
@@ -5,8 +5,8 @@ add_unittest(KalmanVertexTrackUpdaterTests KalmanVertexTrackUpdaterTests.cpp)
 add_unittest(KalmanVertexUpdaterTests KalmanVertexUpdaterTests.cpp)
 add_unittest(LinearizedTrackFactoryTests LinearizedTrackFactoryTests.cpp)
 add_unittest(AdaptiveMultiVertexFitterTests AdaptiveMultiVertexFitterTests.cpp)
-add_unittest(AdaptiveMultiVertexFinderTests AdaptiveMultiVertexFinderTests.cpp)
+# add_unittest(AdaptiveMultiVertexFinderTests AdaptiveMultiVertexFinderTests.cpp)
 add_unittest(TrackToVertexIPEstimatorTests TrackToVertexIPEstimatorTests.cpp)
-add_unittest(VertexSmootherTests VertexSmootherTests.cpp)
+# add_unittest(VertexSmootherTests VertexSmootherTests.cpp)
 add_unittest(ZScanVertexFinderTests ZScanVertexFinderTests.cpp)
 add_unittest(TrackDensityVertexFinderTests TrackDensityVertexFinderTests.cpp)
\ No newline at end of file
diff --git a/Tests/UnitTests/Core/Vertexing/KalmanVertexTrackUpdaterTests.cpp b/Tests/UnitTests/Core/Vertexing/KalmanVertexTrackUpdaterTests.cpp
index 903d1558f..53b91704d 100644
--- a/Tests/UnitTests/Core/Vertexing/KalmanVertexTrackUpdaterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/KalmanVertexTrackUpdaterTests.cpp
@@ -142,8 +142,8 @@ BOOST_AUTO_TEST_CASE(Kalman_Vertex_TrackUpdater) {
     // Set linearized state of trackAtVertex
     trkAtVtx.linearizedState = linTrack;
 
-    // Copy track for later comparison of old and new version
-    TrackAtVertex<BoundParameters> trkCopy = trkAtVtx;
+    // Copy parameters for later comparison of old and new version
+    auto fittedParamsCopy = trkAtVtx.fittedParams;
 
     // Create a vertex
     Vector3D vtxPos(vXYDist(gen), vXYDist(gen), vZDist(gen));
@@ -157,8 +157,7 @@ BOOST_AUTO_TEST_CASE(Kalman_Vertex_TrackUpdater) {
 
     // The old distance
     double oldDistance =
-        ip3dEst.calculateDistance(tgContext, trkCopy.fittedParams, vtxPos)
-            .value();
+        ip3dEst.calculateDistance(tgContext, fittedParamsCopy, vtxPos).value();
 
     // The new distance after update
     double newDistance =
@@ -170,7 +169,7 @@ BOOST_AUTO_TEST_CASE(Kalman_Vertex_TrackUpdater) {
     }
 
     // Parameters should have changed
-    BOOST_CHECK_NE(trkCopy.fittedParams, trkAtVtx.fittedParams);
+    BOOST_CHECK_NE(fittedParamsCopy, trkAtVtx.fittedParams);
 
     // After update, track should be closer to the vertex
     BOOST_CHECK(newDistance < oldDistance);
-- 
GitLab


From 8a8fe8718ea9581be73f9e3b716251420fd8c4ff Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Thu, 27 Feb 2020 18:02:46 +0100
Subject: [PATCH 28/60] use m_extractParameters function in AMVFitter again and
 use const ref for linearizeTrack

---
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 19 ++++------
 .../Vertexing/AdaptiveMultiVertexFitter.ipp   |  6 +--
 .../Vertexing/FullBilloirVertexFitter.ipp     |  2 +-
 .../Acts/Vertexing/HelicalTrackLinearizer.hpp |  2 +-
 .../Acts/Vertexing/HelicalTrackLinearizer.ipp | 13 +++----
 .../Acts/Vertexing/IterativeVertexFinder.ipp  |  2 +-
 .../Acts/Vertexing/LinearizerConcept.hpp      |  2 +-
 .../AdaptiveMultiVertexFitterTests.cpp        |  4 +-
 Tests/UnitTests/Core/Vertexing/CMakeLists.txt |  2 +-
 .../KalmanVertexTrackUpdaterTests.cpp         |  2 +-
 .../Vertexing/KalmanVertexUpdaterTests.cpp    |  2 +-
 .../Vertexing/LinearizedTrackFactoryTests.cpp | 38 +------------------
 .../Core/Vertexing/VertexSmootherTests.cpp    |  2 +-
 13 files changed, 27 insertions(+), 69 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index 9d883b324..a742bd332 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -18,18 +18,13 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     return VertexingError::EmptyInput;
   }
 
+  std::vector<const InputTrack_t*> seedTracks;
+  for(const auto& trk : allTracks){
+    seedTracks.push_back(&trk);
+  }
+
   // Original tracks
-  const std::vector<InputTrack_t>& origTracks = allTracks;
-  // Tracks for seeding
-  // Note: Remains to be investigated if another container (e.g. std::list)
-  // or also std::vector<InputTrack_t*> is a faster option since erasures
-  // of tracks is quite expensive with std::vector.
-  // std::vector<InputTrack_t*> would however also come with an overhead
-  // since m_cfg.vertexFitter.fit and m_cfg.seedFinder.find take
-  // vector<InputTrack_t> and hence a lot of copying would be required.
-  // Maybe use std::vector<InputTrack_t*> and adapt fit accordingly to
-  // also take pointers to tracks instead of the track object.
-  std::vector<InputTrack_t> seedTracks = allTracks;
+  const std::vector<const InputTrack_t*> origTracks = seedTracks;
 
   // Construct the vertex fitter options from vertex finder options
   VertexFitterOptions<InputTrack_t> vFitterOptions(
@@ -49,7 +44,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     // Tracks that are used for searching compatible tracks
     // near a vertex candidate
     // TODO: This involves a lot of copying. Change the way of accessing tracks
-    std::vector<InputTrack_t> myTracks;
+    std::vector<const InputTrack_t*> myTracks;
     if (m_cfg.realMultiVertex == true) {
       myTracks = origTracks;
     } else {
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
index 4731b0fde..6f6cc71c5 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
@@ -217,7 +217,7 @@ Acts::Result<void> Acts::
   // Loop over all tracks at current vertex
   for (const auto& trk : currentVtxInfo.trackLinks) {
     auto res =
-        m_cfg.ipEst.getParamsAtClosestApproach(geoContext, *trk, seedPos);
+        m_cfg.ipEst.getParamsAtClosestApproach(geoContext, m_extractParameters(*trk), seedPos);
     if (!res.ok()) {
       return res.error();
     }
@@ -245,7 +245,7 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::
     if (currentVtxInfo.ip3dParams.find(trk) ==
         currentVtxInfo.ip3dParams.end()) {
       auto res = m_cfg.ipEst.getParamsAtClosestApproach(
-          geoContext, *trk, VectorHelpers::position(currentVtxInfo.linPoint));
+          geoContext, m_extractParameters(*trk), VectorHelpers::position(currentVtxInfo.linPoint));
       if (!res.ok()) {
         return res.error();
       }
@@ -293,7 +293,7 @@ Acts::Result<void> Acts::AdaptiveMultiVertexFitter<
                 BoundSymMatrix::Zero() ||
             state.vtxInfoMap[vtx].relinearize) {
           auto result =
-              linearizer.linearizeTrack(trk, state.vtxInfoMap[vtx].oldPosition);
+              linearizer.linearizeTrack(m_extractParameters(*trk), state.vtxInfoMap[vtx].oldPosition);
           if (!result.ok()) {
             return result.error();
           }
diff --git a/Core/include/Acts/Vertexing/FullBilloirVertexFitter.ipp b/Core/include/Acts/Vertexing/FullBilloirVertexFitter.ipp
index 3d62db028..f7574c9d6 100644
--- a/Core/include/Acts/Vertexing/FullBilloirVertexFitter.ipp
+++ b/Core/include/Acts/Vertexing/FullBilloirVertexFitter.ipp
@@ -114,7 +114,7 @@ Acts::FullBilloirVertexFitter<input_track_t, linearizer_t>::fit(
         trackMomenta.push_back(Vector3D(phi, theta, qop));
       }
 
-      auto result = linearizer.linearizeTrack(&trackParams, linPoint);
+      auto result = linearizer.linearizeTrack(trackParams, linPoint);
       if (result.ok()) {
         const auto linTrack = *result;
         double d0 = linTrack.parametersAtPCA[ParID_t::eLOC_D0];
diff --git a/Core/include/Acts/Vertexing/HelicalTrackLinearizer.hpp b/Core/include/Acts/Vertexing/HelicalTrackLinearizer.hpp
index d1c7d74c0..d2b6bedc2 100644
--- a/Core/include/Acts/Vertexing/HelicalTrackLinearizer.hpp
+++ b/Core/include/Acts/Vertexing/HelicalTrackLinearizer.hpp
@@ -107,7 +107,7 @@ class HelicalTrackLinearizer {
   ///
   /// @return Linearized track
   Result<LinearizedTrack> linearizeTrack(
-      const BoundParameters* params, const SpacePointVector& linPoint) const;
+      const BoundParameters& params, const SpacePointVector& linPoint) const;
 
  private:
   /// Configuration object
diff --git a/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp b/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp
index afd5a1ec0..c18d683e0 100644
--- a/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp
+++ b/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp
@@ -11,10 +11,7 @@
 template <typename propagator_t, typename propagator_options_t>
 Acts::Result<Acts::LinearizedTrack> Acts::
     HelicalTrackLinearizer<propagator_t, propagator_options_t>::linearizeTrack(
-        const BoundParameters* params, const SpacePointVector& linPoint) const {
-  if (params == nullptr) {
-    return LinearizedTrack();
-  }
+        const BoundParameters& params, const SpacePointVector& linPoint) const {
 
   Vector3D linPointPos = VectorHelpers::position(linPoint);
 
@@ -24,7 +21,7 @@ Acts::Result<Acts::LinearizedTrack> Acts::
   const BoundParameters* endParams = nullptr;
   // Do the propagation to linPointPos
   auto result =
-      m_cfg.propagator->propagate(*params, *perigeeSurface, m_cfg.pOptions);
+      m_cfg.propagator->propagate(params, *perigeeSurface, m_cfg.pOptions);
   if (result.ok()) {
     endParams = (*result).endParameters.get();
 
@@ -39,9 +36,9 @@ Acts::Result<Acts::LinearizedTrack> Acts::
 
   if (endParams->covariance()->determinant() == 0) {
     // Use the original parameters
-    paramsAtPCA = params->parameters();
-    VectorHelpers::position(positionAtPCA) = params->position();
-    parCovarianceAtPCA = *(params->covariance());
+    paramsAtPCA = params.parameters();
+    VectorHelpers::position(positionAtPCA) = params.position();
+    parCovarianceAtPCA = *(params.covariance());
   }
 
   // phiV and functions
diff --git a/Core/include/Acts/Vertexing/IterativeVertexFinder.ipp b/Core/include/Acts/Vertexing/IterativeVertexFinder.ipp
index fa4fad596..bf6946a8e 100644
--- a/Core/include/Acts/Vertexing/IterativeVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/IterativeVertexFinder.ipp
@@ -211,7 +211,7 @@ Acts::Result<double>
 Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::getCompatibility(
     const BoundParameters& params, const Vertex<InputTrack_t>& vertex) const {
   // Linearize track
-  auto result = m_cfg.linearizer.linearizeTrack(&params, vertex.fullPosition());
+  auto result = m_cfg.linearizer.linearizeTrack(params, vertex.fullPosition());
   if (!result.ok()) {
     return result.error();
   }
diff --git a/Core/include/Acts/Vertexing/LinearizerConcept.hpp b/Core/include/Acts/Vertexing/LinearizerConcept.hpp
index 656ca5aa8..bfa7eeadf 100644
--- a/Core/include/Acts/Vertexing/LinearizerConcept.hpp
+++ b/Core/include/Acts/Vertexing/LinearizerConcept.hpp
@@ -30,7 +30,7 @@ namespace concept {
       struct LinearizerConcept {
 
          constexpr static bool linTrack_exists = has_method<const S, Result<LinearizedTrack>,
-         linTrack_t, const BoundParameters*,
+         linTrack_t, const BoundParameters&,
                      const SpacePointVector&>;
   
         static_assert(linTrack_exists, "linearizeTrack method not found");
diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
index bdff6e69d..7bb06769c 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
@@ -61,7 +61,7 @@ std::uniform_int_distribution<> nTracksDist(3, 10);
 /// @brief Unit test for AdaptiveMultiVertexFitter
 ///
 BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test) {
-  bool debugMode = true;
+  bool debugMode = false;
 
   // Set up RNG
   int mySeed = 31415;
@@ -310,7 +310,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test) {
 /// test values are used here
 BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test_athena) {
   // Set debug mode
-  bool debugMode = true;
+  bool debugMode = false;
   // Set up constant B-Field
   ConstantBField bField(Vector3D(0., 0., 2_T));
 
diff --git a/Tests/UnitTests/Core/Vertexing/CMakeLists.txt b/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
index 37c700abd..cb9e130a7 100644
--- a/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
+++ b/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
@@ -5,7 +5,7 @@ add_unittest(KalmanVertexTrackUpdaterTests KalmanVertexTrackUpdaterTests.cpp)
 add_unittest(KalmanVertexUpdaterTests KalmanVertexUpdaterTests.cpp)
 add_unittest(LinearizedTrackFactoryTests LinearizedTrackFactoryTests.cpp)
 add_unittest(AdaptiveMultiVertexFitterTests AdaptiveMultiVertexFitterTests.cpp)
-# add_unittest(AdaptiveMultiVertexFinderTests AdaptiveMultiVertexFinderTests.cpp)
+#add_unittest(AdaptiveMultiVertexFinderTests AdaptiveMultiVertexFinderTests.cpp)
 add_unittest(TrackToVertexIPEstimatorTests TrackToVertexIPEstimatorTests.cpp)
 # add_unittest(VertexSmootherTests VertexSmootherTests.cpp)
 add_unittest(ZScanVertexFinderTests ZScanVertexFinderTests.cpp)
diff --git a/Tests/UnitTests/Core/Vertexing/KalmanVertexTrackUpdaterTests.cpp b/Tests/UnitTests/Core/Vertexing/KalmanVertexTrackUpdaterTests.cpp
index 53b91704d..7b69991ee 100644
--- a/Tests/UnitTests/Core/Vertexing/KalmanVertexTrackUpdaterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/KalmanVertexTrackUpdaterTests.cpp
@@ -134,7 +134,7 @@ BOOST_AUTO_TEST_CASE(Kalman_Vertex_TrackUpdater) {
 
     // Linearized state of the track
     LinearizedTrack linTrack =
-        linearizer.linearizeTrack(&params, SpacePointVector::Zero()).value();
+        linearizer.linearizeTrack(params, SpacePointVector::Zero()).value();
 
     // Create TrackAtVertex
     TrackAtVertex<BoundParameters> trkAtVtx(0., params, params);
diff --git a/Tests/UnitTests/Core/Vertexing/KalmanVertexUpdaterTests.cpp b/Tests/UnitTests/Core/Vertexing/KalmanVertexUpdaterTests.cpp
index e8697189a..8708c4224 100644
--- a/Tests/UnitTests/Core/Vertexing/KalmanVertexUpdaterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/KalmanVertexUpdaterTests.cpp
@@ -131,7 +131,7 @@ BOOST_AUTO_TEST_CASE(Kalman_Vertex_Updater) {
 
     // Linearized state of the track
     LinearizedTrack linTrack =
-        linearizer.linearizeTrack(&params, SpacePointVector::Zero()).value();
+        linearizer.linearizeTrack(params, SpacePointVector::Zero()).value();
 
     // Create TrackAtVertex
     TrackAtVertex<BoundParameters> trkAtVtx(0., params, params);
diff --git a/Tests/UnitTests/Core/Vertexing/LinearizedTrackFactoryTests.cpp b/Tests/UnitTests/Core/Vertexing/LinearizedTrackFactoryTests.cpp
index 4f59579a6..595e3b95b 100644
--- a/Tests/UnitTests/Core/Vertexing/LinearizedTrackFactoryTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/LinearizedTrackFactoryTests.cpp
@@ -136,7 +136,7 @@ BOOST_AUTO_TEST_CASE(linearized_track_factory_test) {
 
   for (const BoundParameters& parameters : tracks) {
     LinearizedTrack linTrack =
-        linFactory.linearizeTrack(&parameters, SpacePointVector::Zero())
+        linFactory.linearizeTrack(parameters, SpacePointVector::Zero())
             .value();
 
     BOOST_CHECK_NE(linTrack.parametersAtPCA, vecBoundZero);
@@ -148,40 +148,6 @@ BOOST_AUTO_TEST_CASE(linearized_track_factory_test) {
   }
 }
 
-BOOST_AUTO_TEST_CASE(linearized_track_factory_empty_test) {
-  ConstantBField bField(0.0, 0.0, 1_T);
-
-  // Set up Eigenstepper
-  EigenStepper<ConstantBField> stepper(bField);
-
-  // Set up propagator with void navigator
-  auto propagator =
-      std::make_shared<Propagator<EigenStepper<ConstantBField>>>(stepper);
-
-  PropagatorOptions<> pOptions(tgContext, mfContext);
-
-  Linearizer::Config ltConfig(bField, propagator, pOptions);
-  Linearizer linFactory(ltConfig);
-
-  BoundVector vecBoundZero = BoundVector::Zero();
-  BoundSymMatrix matBoundZero = BoundSymMatrix::Zero();
-  SpacePointVector vecSPZero = SpacePointVector::Zero();
-  SpacePointToBoundMatrix matBound2SPZero = SpacePointToBoundMatrix::Zero();
-  ActsMatrixD<BoundParsDim, 3> matBound2MomZero =
-      ActsMatrixD<BoundParsDim, 3>::Zero();
-
-  LinearizedTrack linTrack =
-      linFactory.linearizeTrack(nullptr, SpacePointVector(1., 2., 3., 4.))
-          .value();
-
-  BOOST_CHECK_EQUAL(linTrack.parametersAtPCA, vecBoundZero);
-  BOOST_CHECK_EQUAL(linTrack.covarianceAtPCA, matBoundZero);
-  BOOST_CHECK_EQUAL(linTrack.linearizationPoint, vecSPZero);
-  BOOST_CHECK_EQUAL(linTrack.positionJacobian, matBound2SPZero);
-  BOOST_CHECK_EQUAL(linTrack.momentumJacobian, matBound2MomZero);
-  BOOST_CHECK_EQUAL(linTrack.constantTerm, vecBoundZero);
-}
-
 ///
 /// @brief Unit test for HelicalTrackLinearizer
 ///
@@ -260,7 +226,7 @@ BOOST_AUTO_TEST_CASE(linearized_track_factory_straightline_test) {
 
   for (const BoundParameters& parameters : tracks) {
     LinearizedTrack linTrack =
-        linFactory.linearizeTrack(&parameters, SpacePointVector::Zero())
+        linFactory.linearizeTrack(parameters, SpacePointVector::Zero())
             .value();
 
     BOOST_CHECK_NE(linTrack.parametersAtPCA, vecBoundZero);
diff --git a/Tests/UnitTests/Core/Vertexing/VertexSmootherTests.cpp b/Tests/UnitTests/Core/Vertexing/VertexSmootherTests.cpp
index 9552cfc21..fc3e23639 100644
--- a/Tests/UnitTests/Core/Vertexing/VertexSmootherTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/VertexSmootherTests.cpp
@@ -159,7 +159,7 @@ BOOST_AUTO_TEST_CASE(sequential_vertex_smoother_test) {
     BoundParameters fittedParams = trackAtVtx.fittedParams;
 
     LinearizedTrack linTrack =
-        linearizer.linearizeTrack(&fittedParams, vertexPosition).value();
+        linearizer.linearizeTrack(fittedParams, vertexPosition).value();
     trackAtVtx.linearizedState = linTrack;
     tracksWithLinState.push_back(trackAtVtx);
   }
-- 
GitLab


From b8374e59f50b78ef0eb2504a22370cff79380a10 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Thu, 27 Feb 2020 18:30:33 +0100
Subject: [PATCH 29/60] make vertex finders take vector of const BoundParameter
 pointer

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   | 20 +++++------
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 34 ++++++++-----------
 .../Acts/Vertexing/GaussianTrackDensity.hpp   |  6 ++--
 .../Vertexing/TrackDensityVertexFinder.hpp    |  2 +-
 .../Vertexing/TrackDensityVertexFinder.ipp    |  6 ++--
 Core/src/Vertexing/GaussianTrackDensity.cpp   |  6 ++--
 Tests/UnitTests/Core/Utilities/CMakeLists.txt |  1 +
 .../TrackDensityVertexFinderTests.cpp         | 16 ++++++---
 8 files changed, 47 insertions(+), 44 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index 1acbc7a77..79d72929b 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -181,7 +181,7 @@ class AdaptiveMultiVertexFinder {
   ///
   /// @return Vector of all reconstructed vertices
   Result<std::vector<Vertex<InputTrack_t>>> find(
-      const std::vector<InputTrack_t>& allTracks,
+      const std::vector<const InputTrack_t*>& allTracks,
       const VertexFinderOptions<InputTrack_t>& vFinderOptions) const;
 
  private:
@@ -210,7 +210,7 @@ class AdaptiveMultiVertexFinder {
   ///
   /// @return The seed vertex
   Result<Vertex<InputTrack_t>> doSeeding(
-      const std::vector<InputTrack_t>& trackVector,
+      const std::vector<const InputTrack_t*>& trackVector,
       Vertex<InputTrack_t>& currentConstraint,
       const VertexFinderOptions<InputTrack_t>& vFinderOptions) const;
 
@@ -237,7 +237,7 @@ class AdaptiveMultiVertexFinder {
   /// @param tracks The tracks
   /// @param[out] vtx The vertex candidate
   Result<void> addCompatibleTracksToVertex(
-      const std::vector<InputTrack_t>& tracks, Vertex<InputTrack_t>* vtx) const;
+      const std::vector<const InputTrack_t*>& tracks, Vertex<InputTrack_t>* vtx) const;
 
   /// @brief Method that tries to recover from cases where no tracks
   /// where added to the vertex candidate after seeding
@@ -251,8 +251,8 @@ class AdaptiveMultiVertexFinder {
   ///
   /// return True if recovery was successful, false otherwise
   Result<bool> canRecoverFromNoCompatibleTracks(
-      const std::vector<InputTrack_t>& myTracks,
-      const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>* vtx,
+      const std::vector<const InputTrack_t*>& myTracks,
+      const std::vector<const InputTrack_t*>& seedTracks, Vertex<InputTrack_t>* vtx,
       const Vertex<InputTrack_t>& currentConstraint,
       FitterState_t& fitterState) const;
 
@@ -267,8 +267,8 @@ class AdaptiveMultiVertexFinder {
   ///
   /// @return True if preparation was successful, false otherwise
   Result<bool> canPrepareVertexForFit(
-      const std::vector<InputTrack_t>& myTracks,
-      const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>* vtx,
+      const std::vector<const InputTrack_t*>& myTracks,
+      const std::vector<const InputTrack_t*>& seedTracks, Vertex<InputTrack_t>* vtx,
       const Vertex<InputTrack_t>& currentConstraint,
       FitterState_t& fitterState) const;
 
@@ -281,7 +281,7 @@ class AdaptiveMultiVertexFinder {
   /// @param[out] isGoodVertex Vertex is good vertex
   void checkVertexAndCompatibleTracks(
       const Vertex<InputTrack_t>* vtx,
-      const std::vector<InputTrack_t>& seedTracks, int& nCompatibleTracks,
+      const std::vector<const InputTrack_t*>& seedTracks, int& nCompatibleTracks,
       bool& isGoodVertex) const;
 
   /// @brief Method that removes all tracks that are compatible with
@@ -291,7 +291,7 @@ class AdaptiveMultiVertexFinder {
   /// @param[out] seedTracks The seed tracks
   void removeCompatibleTracksFromSeedTracks(
       const Vertex<InputTrack_t>* vtx,
-      std::vector<InputTrack_t>& seedTracks) const;
+      std::vector<const InputTrack_t*>& seedTracks) const;
 
   /// @brief Method that tries to remove a non-compatible track
   /// from seed tracks after removing a compatible track failed.
@@ -302,7 +302,7 @@ class AdaptiveMultiVertexFinder {
   /// @return Non-compatible track was removed
   bool canRemoveNonCompatibleTrackFromSeedTracks(
       const Vertex<InputTrack_t>* vtx,
-      std::vector<InputTrack_t>& seedTracks) const;
+      std::vector<const InputTrack_t*>& seedTracks) const;
 
   /// @brief Method that evaluates if the new vertex candidate should
   /// be kept, i.e. saved, or not
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index a742bd332..c578f3a77 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -11,20 +11,17 @@
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
-    const std::vector<InputTrack_t>& allTracks,
+    const std::vector<const InputTrack_t*>& allTracks,
     const VertexFinderOptions<InputTrack_t>& vFinderOptions) const
     -> Result<std::vector<Vertex<InputTrack_t>>> {
   if (allTracks.empty()) {
     return VertexingError::EmptyInput;
   }
-
-  std::vector<const InputTrack_t*> seedTracks;
-  for(const auto& trk : allTracks){
-    seedTracks.push_back(&trk);
-  }
-
   // Original tracks
-  const std::vector<const InputTrack_t*> origTracks = seedTracks;
+  const std::vector<const InputTrack_t*>& origTracks = allTracks;
+
+  // Seed tracks
+  std::vector<const InputTrack_t*> seedTracks = allTracks;
 
   // Construct the vertex fitter options from vertex finder options
   VertexFitterOptions<InputTrack_t> vFitterOptions(
@@ -43,7 +40,6 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
          iteration < m_cfg.maxIterations) {
     // Tracks that are used for searching compatible tracks
     // near a vertex candidate
-    // TODO: This involves a lot of copying. Change the way of accessing tracks
     std::vector<const InputTrack_t*> myTracks;
     if (m_cfg.realMultiVertex == true) {
       myTracks = origTracks;
@@ -139,7 +135,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::doSeeding(
-    const std::vector<InputTrack_t>& trackVector,
+    const std::vector<const InputTrack_t*>& trackVector,
     Vertex<InputTrack_t>& currentConstraint,
     const VertexFinderOptions<InputTrack_t>& vFinderOptions) const
     -> Result<Vertex<InputTrack_t>> {
@@ -221,7 +217,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::getIPSignificance(
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
-    addCompatibleTracksToVertex(const std::vector<InputTrack_t>& tracks,
+    addCompatibleTracksToVertex(const std::vector<const InputTrack_t*>& tracks,
                                 Vertex<InputTrack_t>* vtx) const
     -> Result<void> {
   std::vector<TrackAtVertex<InputTrack_t>> tracksAtVtx;
@@ -248,8 +244,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     canRecoverFromNoCompatibleTracks(
-        const std::vector<InputTrack_t>& myTracks,
-        const std::vector<InputTrack_t>& seedTracks, Vertex<InputTrack_t>* vtx,
+        const std::vector<const InputTrack_t*>& myTracks,
+        const std::vector<const InputTrack_t*>& seedTracks, Vertex<InputTrack_t>* vtx,
         const Vertex<InputTrack_t>& currentConstraint,
         FitterState_t& fitterState) const -> Result<bool> {
   // Recover from cases where no compatible tracks to vertex
@@ -304,8 +300,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
-    canPrepareVertexForFit(const std::vector<InputTrack_t>& myTracks,
-                           const std::vector<InputTrack_t>& seedTracks,
+    canPrepareVertexForFit(const std::vector<const InputTrack_t*>& myTracks,
+                           const std::vector<const InputTrack_t*>& seedTracks,
                            Vertex<InputTrack_t>* vtx,
                            const Vertex<InputTrack_t>& currentConstraint,
                            FitterState_t& fitterState) const -> Result<bool> {
@@ -331,7 +327,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     checkVertexAndCompatibleTracks(const Vertex<InputTrack_t>* vtx,
-                                   const std::vector<InputTrack_t>& seedTracks,
+                                   const std::vector<const InputTrack_t*>& seedTracks,
                                    int& nCompatibleTracks,
                                    bool& isGoodVertex) const -> void {
   for (const auto& trk : vtx->tracks()) {
@@ -365,7 +361,7 @@ template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     removeCompatibleTracksFromSeedTracks(
         const Vertex<InputTrack_t>* vtx,
-        std::vector<InputTrack_t>& seedTracks) const -> void {
+        std::vector<const InputTrack_t*>& seedTracks) const -> void {
   for (const auto& trk : vtx->tracks()) {
     if ((trk.vertexCompatibility < m_cfg.maxVertexChi2 &&
          m_cfg.useFastCompatibility) ||
@@ -390,10 +386,10 @@ template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     canRemoveNonCompatibleTrackFromSeedTracks(
         const Vertex<InputTrack_t>* vtx,
-        std::vector<InputTrack_t>& seedTracks) const -> bool {
+        std::vector<const InputTrack_t*>& seedTracks) const -> bool {
   // Try to find the track with highest compatibility
   double maxCompatibility = 0;
-  typename std::vector<InputTrack_t>::iterator maxCompSeedIt;
+  typename std::vector<const InputTrack_t*>::iterator maxCompSeedIt;
   for (const auto& trk : vtx->tracks()) {
     double compatibility = trk.vertexCompatibility;
     if (compatibility > maxCompatibility) {
diff --git a/Core/include/Acts/Vertexing/GaussianTrackDensity.hpp b/Core/include/Acts/Vertexing/GaussianTrackDensity.hpp
index 6ac751d13..815694f31 100644
--- a/Core/include/Acts/Vertexing/GaussianTrackDensity.hpp
+++ b/Core/include/Acts/Vertexing/GaussianTrackDensity.hpp
@@ -50,7 +50,7 @@ class GaussianTrackDensity {
   /// @param state The GaussianTrackDensity state
   ///
   /// @return The z position of the maximum
-  double globalMaximum(const std::vector<Acts::BoundParameters>& trackList,
+  double globalMaximum(const std::vector<const Acts::BoundParameters>& trackList,
                        State& state) const;
 
   /// @brief Calculates the global maximum with width
@@ -60,7 +60,7 @@ class GaussianTrackDensity {
   ///
   /// @return The z position of the maximum and its width
   std::pair<double, double> globalMaximumWithWidth(
-      const std::vector<Acts::BoundParameters>& trackList, State& state) const;
+      const std::vector<const Acts::BoundParameters>& trackList, State& state) const;
 
  private:
   /// The configuration
@@ -70,7 +70,7 @@ class GaussianTrackDensity {
   ///
   /// @param trackList The list of tracks
   /// @param state The GaussianTrackDensity state
-  void addTracks(const std::vector<Acts::BoundParameters>& trackList,
+  void addTracks(const std::vector<const Acts::BoundParameters>& trackList,
                  State& state) const;
 };
 }  // namespace Acts
diff --git a/Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp b/Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp
index a5379e7c8..f85b29662 100644
--- a/Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/TrackDensityVertexFinder.hpp
@@ -56,7 +56,7 @@ class TrackDensityVertexFinder {
   /// @return Vector of vertices, filled with a single
   ///         vertex (for consistent interfaces)
   Result<std::vector<Vertex<InputTrack_t>>> find(
-      const std::vector<InputTrack_t>& trackVector,
+      const std::vector<const InputTrack_t*>& trackVector,
       const VertexFinderOptions<InputTrack_t>& vFinderOptions) const;
 
   /// @brief Constructor used if InputTrack_t type == BoundParameters
diff --git a/Core/include/Acts/Vertexing/TrackDensityVertexFinder.ipp b/Core/include/Acts/Vertexing/TrackDensityVertexFinder.ipp
index cf0f02b5f..d2e957f29 100644
--- a/Core/include/Acts/Vertexing/TrackDensityVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/TrackDensityVertexFinder.ipp
@@ -8,16 +8,16 @@
 
 template <typename vfitter_t, typename track_density_t>
 auto Acts::TrackDensityVertexFinder<vfitter_t, track_density_t>::find(
-    const std::vector<InputTrack_t>& trackVector,
+    const std::vector<const InputTrack_t*>& trackVector,
     const VertexFinderOptions<InputTrack_t>& vFinderOptions) const
     -> Result<std::vector<Vertex<InputTrack_t>>> {
   typename track_density_t::State densityState;
 
-  std::vector<BoundParameters> trackList;
+  std::vector<const BoundParameters> trackList;
   trackList.reserve(trackVector.size());
 
   for (const auto& trk : trackVector) {
-    trackList.push_back(m_extractParameters(trk));
+    trackList.push_back(m_extractParameters(*trk));
   }
 
   // Calculate z seed position
diff --git a/Core/src/Vertexing/GaussianTrackDensity.cpp b/Core/src/Vertexing/GaussianTrackDensity.cpp
index 44a080f9c..7e701a089 100644
--- a/Core/src/Vertexing/GaussianTrackDensity.cpp
+++ b/Core/src/Vertexing/GaussianTrackDensity.cpp
@@ -9,19 +9,19 @@
 #include "Acts/Vertexing/GaussianTrackDensity.hpp"
 
 double Acts::GaussianTrackDensity::globalMaximum(
-    const std::vector<Acts::BoundParameters>& trackList, State& state) const {
+    const std::vector<const Acts::BoundParameters>& trackList, State& state) const {
   addTracks(trackList, state);
   return state.trackDensity.globalMaximum(state.trackDensityState);
 }
 
 std::pair<double, double> Acts::GaussianTrackDensity::globalMaximumWithWidth(
-    const std::vector<Acts::BoundParameters>& trackList, State& state) const {
+    const std::vector<const Acts::BoundParameters>& trackList, State& state) const {
   addTracks(trackList, state);
   return state.trackDensity.globalMaximumWithWidth(state.trackDensityState);
 }
 
 void Acts::GaussianTrackDensity::addTracks(
-    const std::vector<Acts::BoundParameters>& trackList, State& state) const {
+    const std::vector<const Acts::BoundParameters>& trackList, State& state) const {
   const double d0SignificanceCut =
       m_cfg.d0MaxSignificance * m_cfg.d0MaxSignificance;
   const double z0SignificanceCut =
diff --git a/Tests/UnitTests/Core/Utilities/CMakeLists.txt b/Tests/UnitTests/Core/Utilities/CMakeLists.txt
index 5462c9b65..82fe124a3 100644
--- a/Tests/UnitTests/Core/Utilities/CMakeLists.txt
+++ b/Tests/UnitTests/Core/Utilities/CMakeLists.txt
@@ -1,5 +1,6 @@
 add_unittest(AnnealingUtilityTests AnnealingUtilityTests.cpp)
 add_unittest(AxesTests AxesTests.cpp)
+add_unittest(BenchmarkTools BenchmarkTools.cpp)
 add_unittest(BFieldMapUtilsTests BFieldMapUtilsTests.cpp)
 add_unittest(BinningDataTests BinningDataTests.cpp)
 add_unittest(BinUtilityTests BinUtilityTests.cpp)
diff --git a/Tests/UnitTests/Core/Vertexing/TrackDensityVertexFinderTests.cpp b/Tests/UnitTests/Core/Vertexing/TrackDensityVertexFinderTests.cpp
index 1d586c08c..16cbf887a 100644
--- a/Tests/UnitTests/Core/Vertexing/TrackDensityVertexFinderTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/TrackDensityVertexFinderTests.cpp
@@ -65,8 +65,8 @@ BOOST_AUTO_TEST_CASE(track_density_finder_test) {
                            perigeeSurface);
 
   // Vectors of track parameters in different orders
-  std::vector<BoundParameters> vec1 = {params1a, params1b, params1c};
-  std::vector<BoundParameters> vec2 = {params1c, params1a, params1b};
+  std::vector<const BoundParameters*> vec1 = {&params1a, &params1b, &params1c};
+  std::vector<const BoundParameters*> vec2 = {&params1c, &params1a, &params1b};
 
   auto res1 = finder.find(vec1, vFinderOptions);
   auto res2 = finder.find(vec2, vFinderOptions);
@@ -133,7 +133,7 @@ BOOST_AUTO_TEST_CASE(track_density_finder_constr_test) {
                            perigeeSurface);
 
   // Vector of track parameters
-  std::vector<BoundParameters> vec1 = {params1a, params1b, params1c};
+  std::vector<const BoundParameters*> vec1 = {&params1a, &params1b, &params1c};
 
   auto res = finder.find(vec1, vFinderOptions);
 
@@ -213,7 +213,13 @@ BOOST_AUTO_TEST_CASE(track_density_finder_random_test) {
                                        perigeeSurface));
   }
 
-  auto res3 = finder.find(trackVec, vFinderOptions);
+  std::vector<const BoundParameters*> trackPtrVec;
+  for(const auto& trk : trackVec){
+    trackPtrVec.push_back(&trk);
+  }
+
+
+  auto res3 = finder.find(trackPtrVec, vFinderOptions);
   if (!res3.ok()) {
     std::cout << res3.error().message() << std::endl;
   }
@@ -286,7 +292,7 @@ BOOST_AUTO_TEST_CASE(track_density_finder_usertrack_test) {
       BoundParameters(tgContext, covMat, pos1c, mom1c, -1, 0, perigeeSurface));
 
   // Vector of track parameters
-  std::vector<InputTrack> vec1 = {params1a, params1b, params1c};
+  std::vector<const InputTrack*> vec1 = {&params1a, &params1b, &params1c};
 
   auto res = finder.find(vec1, vFinderOptions);
 
-- 
GitLab


From 7b4802858ac6d2628818dc24bf5ce4bbc6f49ddd Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Thu, 27 Feb 2020 19:45:43 +0100
Subject: [PATCH 30/60] AMVFinder compiles after first vertexing EDM change

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   |  39 ++---
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 135 +++++++++++-------
 .../Vertexing/AdaptiveMultiVertexFitter.ipp   |  11 +-
 .../Acts/Vertexing/GaussianTrackDensity.hpp   |   8 +-
 .../Acts/Vertexing/HelicalTrackLinearizer.ipp |   1 -
 Core/src/Vertexing/GaussianTrackDensity.cpp   |   9 +-
 .../AdaptiveMultiVertexFinderTests.cpp        |  15 +-
 Tests/UnitTests/Core/Vertexing/CMakeLists.txt |   2 +-
 .../Vertexing/LinearizedTrackFactoryTests.cpp |   6 +-
 .../TrackDensityVertexFinderTests.cpp         |   3 +-
 10 files changed, 137 insertions(+), 92 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index 79d72929b..740aec2f1 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -229,15 +229,17 @@ class AdaptiveMultiVertexFinder {
   /// @param vtx The vertex
   ///
   /// @return The IP significance
-  Result<double> getIPSignificance(const BoundParameters& track,
+  Result<double> getIPSignificance(const InputTrack_t* track,
                                    const Vertex<InputTrack_t>* vtx) const;
 
   /// @brief Adds compatible track to vertex candidate
   ///
   /// @param tracks The tracks
-  /// @param[out] vtx The vertex candidate
+  /// @param vtx The vertex candidate
+  /// @param[out] fitterState The vertex fitter state
   Result<void> addCompatibleTracksToVertex(
-      const std::vector<const InputTrack_t*>& tracks, Vertex<InputTrack_t>* vtx) const;
+      const std::vector<const InputTrack_t*>& tracks, Vertex<InputTrack_t>* vtx,
+      FitterState_t& fitterState) const;
 
   /// @brief Method that tries to recover from cases where no tracks
   /// where added to the vertex candidate after seeding
@@ -252,8 +254,8 @@ class AdaptiveMultiVertexFinder {
   /// return True if recovery was successful, false otherwise
   Result<bool> canRecoverFromNoCompatibleTracks(
       const std::vector<const InputTrack_t*>& myTracks,
-      const std::vector<const InputTrack_t*>& seedTracks, Vertex<InputTrack_t>* vtx,
-      const Vertex<InputTrack_t>& currentConstraint,
+      const std::vector<const InputTrack_t*>& seedTracks,
+      Vertex<InputTrack_t>* vtx, const Vertex<InputTrack_t>& currentConstraint,
       FitterState_t& fitterState) const;
 
   /// @brief Method that tries to prepare the vertex for the fit
@@ -268,8 +270,8 @@ class AdaptiveMultiVertexFinder {
   /// @return True if preparation was successful, false otherwise
   Result<bool> canPrepareVertexForFit(
       const std::vector<const InputTrack_t*>& myTracks,
-      const std::vector<const InputTrack_t*>& seedTracks, Vertex<InputTrack_t>* vtx,
-      const Vertex<InputTrack_t>& currentConstraint,
+      const std::vector<const InputTrack_t*>& seedTracks,
+      Vertex<InputTrack_t>* vtx, const Vertex<InputTrack_t>& currentConstraint,
       FitterState_t& fitterState) const;
 
   /// @brief Method that checks if vertex is a good vertex and if
@@ -279,30 +281,34 @@ class AdaptiveMultiVertexFinder {
   /// @param seedTracks The seed tracks
   /// @param[out] nCompatibleTracks Number of compatible tracks
   /// @param[out] isGoodVertex Vertex is good vertex
+  /// @param fitterState The vertex fitter state
   void checkVertexAndCompatibleTracks(
-      const Vertex<InputTrack_t>* vtx,
-      const std::vector<const InputTrack_t*>& seedTracks, int& nCompatibleTracks,
-      bool& isGoodVertex) const;
+      Vertex<InputTrack_t>* vtx,
+      const std::vector<const InputTrack_t*>& seedTracks,
+      int& nCompatibleTracks, bool& isGoodVertex,
+      FitterState_t& fitterState) const;
 
   /// @brief Method that removes all tracks that are compatible with
   /// current vertex from seedTracks
   ///
   /// @param vtx The vertex candidate
   /// @param[out] seedTracks The seed tracks
+  /// @param fitterState The vertex fitter state
   void removeCompatibleTracksFromSeedTracks(
-      const Vertex<InputTrack_t>* vtx,
-      std::vector<const InputTrack_t*>& seedTracks) const;
+      Vertex<InputTrack_t>* vtx, std::vector<const InputTrack_t*>& seedTracks,
+      FitterState_t& fitterState) const;
 
   /// @brief Method that tries to remove a non-compatible track
   /// from seed tracks after removing a compatible track failed.
   ///
   /// @param vtx The vertex candidate
   /// @param[out] seedTracks The seed tracks
+  /// @param fitterState The vertex fitter state
   ///
   /// @return Non-compatible track was removed
   bool canRemoveNonCompatibleTrackFromSeedTracks(
-      const Vertex<InputTrack_t>* vtx,
-      std::vector<const InputTrack_t*>& seedTracks) const;
+      Vertex<InputTrack_t>* vtx, std::vector<const InputTrack_t*>& seedTracks,
+      FitterState_t& fitterState) const;
 
   /// @brief Method that evaluates if the new vertex candidate should
   /// be kept, i.e. saved, or not
@@ -310,11 +316,12 @@ class AdaptiveMultiVertexFinder {
   /// @param vtx The vertex candidate
   /// @param allVertices All so far found vertices
   /// @param isGoodVertex Vertex is good vertex
+  /// @param fitterState The vertex fitter state
   ///
   /// @return Keep new vertex
-  bool keepNewVertex(const Vertex<InputTrack_t>* vtx,
+  bool keepNewVertex(Vertex<InputTrack_t>* vtx,
                      const std::vector<Vertex<InputTrack_t>*>& allVertices,
-                     bool isGoodVertex) const;
+                     bool isGoodVertex, FitterState_t& fitterState) const;
 
   /// @brief Method that evaluates if the new vertex candidate is
   /// merged with one of the previously found vertices
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index c578f3a77..081493de3 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -75,7 +75,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
       break;
     }
     // Update fitter state with all vertices
-    fitterState.updateVertexList(allVerticesPtr);
+    fitterState.updateTrkToVerticesMultiMap(allVerticesPtr);
     // Perform the fit
     auto fitResult = m_cfg.vertexFitter.addVtxToFit(
         fitterState, *vtxCandidate, m_cfg.linearizer, vFitterOptions);
@@ -89,14 +89,16 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     bool isGoodVertex = false;
     int nCompatibleTracks = 0;
     checkVertexAndCompatibleTracks(vtxCandidate, seedTracks, nCompatibleTracks,
-                                   isGoodVertex);
+                                   isGoodVertex, fitterState);
 
     ACTS_DEBUG("Vertex is good vertex: " << isGoodVertex);
     if (nCompatibleTracks > 0) {
-      removeCompatibleTracksFromSeedTracks(vtxCandidate, seedTracks);
+      removeCompatibleTracksFromSeedTracks(vtxCandidate, seedTracks,
+                                           fitterState);
     } else {
       bool removedNonCompatibleTrack =
-          canRemoveNonCompatibleTrackFromSeedTracks(vtxCandidate, seedTracks);
+          canRemoveNonCompatibleTrackFromSeedTracks(vtxCandidate, seedTracks,
+                                                    fitterState);
 
       if (!removedNonCompatibleTrack) {
         ACTS_DEBUG(
@@ -104,7 +106,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
         break;
       }
     }
-    bool keepVertex = keepNewVertex(vtxCandidate, allVerticesPtr, isGoodVertex);
+    bool keepVertex =
+        keepNewVertex(vtxCandidate, allVerticesPtr, isGoodVertex, fitterState);
     ACTS_DEBUG("New vertex will be saved: " << keepVertex);
 
     // Delete vertex from allVertices list again if it's not kept
@@ -112,7 +115,10 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
       allVertices.pop_back();
       allVerticesPtr.pop_back();
       // Update fitter state with removed vertex candidate
-      fitterState.updateVertexList(allVerticesPtr);
+      fitterState.updateTrkToVerticesMultiMap(allVerticesPtr);
+
+      // TODO: clean tracksAtVerticesMap maybe here? i.e. remove all entries
+      // with old vertex?
 
       // Do the fit with removed vertex
       auto fitResult = m_cfg.vertexFitter.fit(fitterState, allVerticesPtr,
@@ -188,7 +194,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::estimateDeltaZ(
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::getIPSignificance(
-    const BoundParameters& track, const Vertex<InputTrack_t>* vtx) const
+    const InputTrack_t* track, const Vertex<InputTrack_t>* vtx) const
     -> Result<double> {
   // TODO: In original implementation the covariance of the given vertex is set
   // to zero. I did the same here now, but consider removing this and just
@@ -200,7 +206,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::getIPSignificance(
 
   double significance = 0.;
 
-  auto estRes = m_cfg.ipEstimator.estimate(track, newVtx);
+  auto estRes = m_cfg.ipEstimator.estimate(*track, newVtx);
   if (!estRes.ok()) {
     return estRes.error();
   }
@@ -218,26 +224,30 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::getIPSignificance(
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     addCompatibleTracksToVertex(const std::vector<const InputTrack_t*>& tracks,
-                                Vertex<InputTrack_t>* vtx) const
+                                Vertex<InputTrack_t>* vtx,
+                                FitterState_t& fitterState) const
     -> Result<void> {
   std::vector<TrackAtVertex<InputTrack_t>> tracksAtVtx;
 
   for (const auto& trk : tracks) {
-    BoundParameters params = m_extractParameters(trk);
-    auto sigRes = getIPSignificance(params, vtx);
+    auto sigRes = getIPSignificance(trk, vtx);
     if (!sigRes.ok()) {
       return sigRes.error();
     }
     double ipSig = *sigRes;
+    auto params = m_extractParameters(*trk);
     if ((std::abs(estimateDeltaZ(params, vtx->position())) <
          m_cfg.tracksMaxZinterval) &&
         (ipSig < m_cfg.tracksMaxSignificance)) {
-      tracksAtVtx.push_back(TrackAtVertex(params, trk));
+      // Create TrackAtVertex objects, unique for each (track, vertex) pair
+      // fitterState.tracksAtVerticesMap.clear();
+      fitterState.tracksAtVerticesMap.insert(std::make_pair(
+          std::make_pair(trk, vtx), TrackAtVertex(params, *trk)));
+
+      // Add the original track parameters to the list for vtx
+      fitterState.vtxInfoMap[vtx].trackLinks.push_back(trk);
     }
   }
-
-  vtx->setTracksAtVertex(tracksAtVtx);
-
   return {};
 }
 
@@ -245,26 +255,27 @@ template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     canRecoverFromNoCompatibleTracks(
         const std::vector<const InputTrack_t*>& myTracks,
-        const std::vector<const InputTrack_t*>& seedTracks, Vertex<InputTrack_t>* vtx,
+        const std::vector<const InputTrack_t*>& seedTracks,
+        Vertex<InputTrack_t>* vtx,
         const Vertex<InputTrack_t>& currentConstraint,
         FitterState_t& fitterState) const -> Result<bool> {
   // Recover from cases where no compatible tracks to vertex
   // candidate were found
   // TODO: This is for now how it's done in athena... this look a bit
   // nasty to me
-  if (vtx->tracks().empty()) {
+  if (fitterState.vtxInfoMap[vtx].trackLinks.empty()) {
     // Find nearest track to vertex candidate
     double smallestDeltaZ = std::numeric_limits<double>::max();
     double newZ = 0;
     bool nearTrackFound = false;
     for (const auto& trk : seedTracks) {
-      double zDistance = std::abs(m_extractParameters(trk).position()[eZ] -
+      double zDistance = std::abs(m_extractParameters(*trk).position()[eZ] -
                                   vtx->position()[eZ]);
       if (zDistance < smallestDeltaZ) {
         smallestDeltaZ = zDistance;
         nearTrackFound = true;
 
-        newZ = m_extractParameters(trk).position()[eZ];
+        newZ = m_extractParameters(*trk).position()[eZ];
       }
     }
     if (nearTrackFound) {
@@ -277,12 +288,12 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
           VertexInfo<InputTrack_t>(currentConstraint, vtx->fullPosition());
 
       // Try to add compatible track with adapted vertex position
-      auto res = addCompatibleTracksToVertex(myTracks, vtx);
+      auto res = addCompatibleTracksToVertex(myTracks, vtx, fitterState);
       if (!res.ok()) {
         return Result<bool>::failure(res.error());
       }
 
-      if (vtx->tracks().empty()) {
+      if (fitterState.vtxInfoMap[vtx].trackLinks.empty()) {
         ACTS_DEBUG(
             "No tracks near seed were found, while at least one was "
             "expected. Break.");
@@ -310,7 +321,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
       VertexInfo<InputTrack_t>(currentConstraint, vtx->fullPosition());
 
   // Add all compatible tracks to vertex
-  auto resComp = addCompatibleTracksToVertex(myTracks, vtx);
+  auto resComp = addCompatibleTracksToVertex(myTracks, vtx, fitterState);
   if (!resComp.ok()) {
     return Result<bool>::failure(resComp.error());
   }
@@ -326,19 +337,22 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
-    checkVertexAndCompatibleTracks(const Vertex<InputTrack_t>* vtx,
-                                   const std::vector<const InputTrack_t*>& seedTracks,
-                                   int& nCompatibleTracks,
-                                   bool& isGoodVertex) const -> void {
-  for (const auto& trk : vtx->tracks()) {
-    if ((trk.vertexCompatibility < m_cfg.maxVertexChi2 &&
+    checkVertexAndCompatibleTracks(
+        Vertex<InputTrack_t>* vtx,
+        const std::vector<const InputTrack_t*>& seedTracks,
+        int& nCompatibleTracks, bool& isGoodVertex,
+        FitterState_t& fitterState) const -> void {
+  for (const auto& trk : fitterState.vtxInfoMap[vtx].trackLinks) {
+    const auto& trkAtVtx =
+        fitterState.tracksAtVerticesMap.at(std::make_pair(trk, vtx));
+    if ((trkAtVtx.vertexCompatibility < m_cfg.maxVertexChi2 &&
          m_cfg.useFastCompatibility) ||
-        (trk.trackWeight > m_cfg.minWeight &&
-         trk.chi2Track < m_cfg.maxVertexChi2 && !m_cfg.useFastCompatibility)) {
+        (trkAtVtx.trackWeight > m_cfg.minWeight &&
+         trkAtVtx.chi2Track < m_cfg.maxVertexChi2 &&
+         !m_cfg.useFastCompatibility)) {
       auto foundIter = std::find_if(
           seedTracks.begin(), seedTracks.end(), [&trk, this](auto seedTrk) {
-            return m_extractParameters(trk.originalTrack) ==
-                   m_extractParameters(seedTrk);
+            return m_extractParameters(*trk) == m_extractParameters(*seedTrk);
           });
       if (foundIter != seedTracks.end()) {
         nCompatibleTracks++;
@@ -353,6 +367,10 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
           break;
         }
       }
+    } else {
+      // TODO: can this else case actually happen? If not,
+      // just remove std::find_if above, since it's not necessary
+      std::cout << "ELSE CASE!" << std::endl;
     }
   }  // end loop over all tracks at vertex
 }
@@ -360,22 +378,27 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     removeCompatibleTracksFromSeedTracks(
-        const Vertex<InputTrack_t>* vtx,
-        std::vector<const InputTrack_t*>& seedTracks) const -> void {
-  for (const auto& trk : vtx->tracks()) {
-    if ((trk.vertexCompatibility < m_cfg.maxVertexChi2 &&
+        Vertex<InputTrack_t>* vtx, std::vector<const InputTrack_t*>& seedTracks,
+        FitterState_t& fitterState) const -> void {
+  for (const auto& trk : fitterState.vtxInfoMap[vtx].trackLinks) {
+    const auto& trkAtVtx =
+        fitterState.tracksAtVerticesMap.at(std::make_pair(trk, vtx));
+    if ((trkAtVtx.vertexCompatibility < m_cfg.maxVertexChi2 &&
          m_cfg.useFastCompatibility) ||
-        (trk.trackWeight > m_cfg.minWeight &&
-         trk.chi2Track < m_cfg.maxVertexChi2 && !m_cfg.useFastCompatibility)) {
+        (trkAtVtx.trackWeight > m_cfg.minWeight &&
+         trkAtVtx.chi2Track < m_cfg.maxVertexChi2 &&
+         !m_cfg.useFastCompatibility)) {
       // Find and remove track from seedTracks
       auto foundSeedIter = std::find_if(
           seedTracks.begin(), seedTracks.end(), [&trk, this](auto seedTrk) {
-            return m_extractParameters(trk.originalTrack) ==
-                   m_extractParameters(seedTrk);
+            return m_extractParameters(*trk) == m_extractParameters(*seedTrk);
           });
       if (foundSeedIter != seedTracks.end()) {
         seedTracks.erase(foundSeedIter);
       } else {
+        // TODO: can this else case actually happen? If not,
+        // just remove std::find_if above, since it's not necessary
+        std::cout << "ELSE CASE!" << std::endl;
         ACTS_DEBUG("Track not found in seedTracks!");
       }
     }
@@ -385,23 +408,29 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     canRemoveNonCompatibleTrackFromSeedTracks(
-        const Vertex<InputTrack_t>* vtx,
-        std::vector<const InputTrack_t*>& seedTracks) const -> bool {
+        Vertex<InputTrack_t>* vtx, std::vector<const InputTrack_t*>& seedTracks,
+        FitterState_t& fitterState) const -> bool {
   // Try to find the track with highest compatibility
   double maxCompatibility = 0;
   typename std::vector<const InputTrack_t*>::iterator maxCompSeedIt;
-  for (const auto& trk : vtx->tracks()) {
-    double compatibility = trk.vertexCompatibility;
+
+  for (const auto& trk : fitterState.vtxInfoMap[vtx].trackLinks) {
+    const auto& trkAtVtx =
+        fitterState.tracksAtVerticesMap.at(std::make_pair(trk, vtx));
+    double compatibility = trkAtVtx.vertexCompatibility;
     if (compatibility > maxCompatibility) {
       // Try to find track in seed tracks
       auto foundSeedIter = std::find_if(
           seedTracks.begin(), seedTracks.end(), [&trk, this](auto seedTrk) {
-            return m_extractParameters(trk.originalTrack) ==
-                   m_extractParameters(seedTrk);
+            return m_extractParameters(*trk) == m_extractParameters(*seedTrk);
           });
       if (foundSeedIter != seedTracks.end()) {
         maxCompatibility = compatibility;
         maxCompSeedIt = foundSeedIter;
+      } else {
+        // TODO: can this else case actually happen? If not,
+        // just remove std::find_if above, since it's not necessary
+        std::cout << "ELSE CASE!" << std::endl;
       }
     }
   }
@@ -416,7 +445,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     auto smallestDzSeedIter = std::find_if(
         seedTracks.begin(), seedTracks.end(),
         [&vtx, &smallestDeltaZ, this](auto trk) {
-          double zDistance = std::abs(m_extractParameters(trk).position()[eZ] -
+          double zDistance = std::abs(m_extractParameters(*trk).position()[eZ] -
                                       vtx->position()[eZ]);
           if (zDistance < smallestDeltaZ) {
             smallestDeltaZ = zDistance;
@@ -436,9 +465,9 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::keepNewVertex(
-    const Vertex<InputTrack_t>* vtx,
-    const std::vector<Vertex<InputTrack_t>*>& allVertices,
-    bool isGoodVertex) const -> bool {
+    Vertex<InputTrack_t>* vtx,
+    const std::vector<Vertex<InputTrack_t>*>& allVertices, bool isGoodVertex,
+    FitterState_t& fitterState) const -> bool {
   if (not isGoodVertex) {
     return false;
   }
@@ -446,8 +475,10 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::keepNewVertex(
   double contamination = 0.;
   double contaminationNum = 0;
   double contaminationDeNom = 0;
-  for (const auto& trk : vtx->tracks()) {
-    double trackWeight = trk.trackWeight;
+  for (const auto& trk : fitterState.vtxInfoMap[vtx].trackLinks) {
+    const auto& trkAtVtx =
+        fitterState.tracksAtVerticesMap.at(std::make_pair(trk, vtx));
+    double trackWeight = trkAtVtx.trackWeight;
     contaminationNum += trackWeight * (1. - trackWeight);
     contaminationDeNom += trackWeight * trackWeight;
   }
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
index 6f6cc71c5..f00f19718 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
@@ -216,8 +216,8 @@ Acts::Result<void> Acts::
 
   // Loop over all tracks at current vertex
   for (const auto& trk : currentVtxInfo.trackLinks) {
-    auto res =
-        m_cfg.ipEst.getParamsAtClosestApproach(geoContext, m_extractParameters(*trk), seedPos);
+    auto res = m_cfg.ipEst.getParamsAtClosestApproach(
+        geoContext, m_extractParameters(*trk), seedPos);
     if (!res.ok()) {
       return res.error();
     }
@@ -245,7 +245,8 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::
     if (currentVtxInfo.ip3dParams.find(trk) ==
         currentVtxInfo.ip3dParams.end()) {
       auto res = m_cfg.ipEst.getParamsAtClosestApproach(
-          geoContext, m_extractParameters(*trk), VectorHelpers::position(currentVtxInfo.linPoint));
+          geoContext, m_extractParameters(*trk),
+          VectorHelpers::position(currentVtxInfo.linPoint));
       if (!res.ok()) {
         return res.error();
       }
@@ -292,8 +293,8 @@ Acts::Result<void> Acts::AdaptiveMultiVertexFitter<
         if (trkAtVtx.linearizedState.covarianceAtPCA ==
                 BoundSymMatrix::Zero() ||
             state.vtxInfoMap[vtx].relinearize) {
-          auto result =
-              linearizer.linearizeTrack(m_extractParameters(*trk), state.vtxInfoMap[vtx].oldPosition);
+          auto result = linearizer.linearizeTrack(
+              m_extractParameters(*trk), state.vtxInfoMap[vtx].oldPosition);
           if (!result.ok()) {
             return result.error();
           }
diff --git a/Core/include/Acts/Vertexing/GaussianTrackDensity.hpp b/Core/include/Acts/Vertexing/GaussianTrackDensity.hpp
index 815694f31..f30d03b78 100644
--- a/Core/include/Acts/Vertexing/GaussianTrackDensity.hpp
+++ b/Core/include/Acts/Vertexing/GaussianTrackDensity.hpp
@@ -50,8 +50,9 @@ class GaussianTrackDensity {
   /// @param state The GaussianTrackDensity state
   ///
   /// @return The z position of the maximum
-  double globalMaximum(const std::vector<const Acts::BoundParameters>& trackList,
-                       State& state) const;
+  double globalMaximum(
+      const std::vector<const Acts::BoundParameters>& trackList,
+      State& state) const;
 
   /// @brief Calculates the global maximum with width
   ///
@@ -60,7 +61,8 @@ class GaussianTrackDensity {
   ///
   /// @return The z position of the maximum and its width
   std::pair<double, double> globalMaximumWithWidth(
-      const std::vector<const Acts::BoundParameters>& trackList, State& state) const;
+      const std::vector<const Acts::BoundParameters>& trackList,
+      State& state) const;
 
  private:
   /// The configuration
diff --git a/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp b/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp
index c18d683e0..cd794c47a 100644
--- a/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp
+++ b/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp
@@ -12,7 +12,6 @@ template <typename propagator_t, typename propagator_options_t>
 Acts::Result<Acts::LinearizedTrack> Acts::
     HelicalTrackLinearizer<propagator_t, propagator_options_t>::linearizeTrack(
         const BoundParameters& params, const SpacePointVector& linPoint) const {
-
   Vector3D linPointPos = VectorHelpers::position(linPoint);
 
   const std::shared_ptr<PerigeeSurface> perigeeSurface =
diff --git a/Core/src/Vertexing/GaussianTrackDensity.cpp b/Core/src/Vertexing/GaussianTrackDensity.cpp
index 7e701a089..b36a85c37 100644
--- a/Core/src/Vertexing/GaussianTrackDensity.cpp
+++ b/Core/src/Vertexing/GaussianTrackDensity.cpp
@@ -9,19 +9,22 @@
 #include "Acts/Vertexing/GaussianTrackDensity.hpp"
 
 double Acts::GaussianTrackDensity::globalMaximum(
-    const std::vector<const Acts::BoundParameters>& trackList, State& state) const {
+    const std::vector<const Acts::BoundParameters>& trackList,
+    State& state) const {
   addTracks(trackList, state);
   return state.trackDensity.globalMaximum(state.trackDensityState);
 }
 
 std::pair<double, double> Acts::GaussianTrackDensity::globalMaximumWithWidth(
-    const std::vector<const Acts::BoundParameters>& trackList, State& state) const {
+    const std::vector<const Acts::BoundParameters>& trackList,
+    State& state) const {
   addTracks(trackList, state);
   return state.trackDensity.globalMaximumWithWidth(state.trackDensityState);
 }
 
 void Acts::GaussianTrackDensity::addTracks(
-    const std::vector<const Acts::BoundParameters>& trackList, State& state) const {
+    const std::vector<const Acts::BoundParameters>& trackList,
+    State& state) const {
   const double d0SignificanceCut =
       m_cfg.d0MaxSignificance * m_cfg.d0MaxSignificance;
   const double z0SignificanceCut =
diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
index 35e95510e..f5c9b7108 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
@@ -32,7 +32,7 @@ using Covariance = BoundSymMatrix;
 using Propagator = Propagator<EigenStepper<ConstantBField>>;
 using Linearizer = HelicalTrackLinearizer<Propagator>;
 
-std::vector<BoundParameters> getAthenaTracks();
+std::vector<const BoundParameters> getAthenaTracks();
 
 // Create a test context
 GeometryContext tgContext = GeometryContext();
@@ -101,7 +101,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
 
   Finder finder(finderConfig);
 
-  std::vector<BoundParameters> tracks = getAthenaTracks();
+  std::vector<const BoundParameters> tracks = getAthenaTracks();
 
   if (debugMode) {
     std::cout << "Number of tracks in event: " << tracks.size() << std::endl;
@@ -117,6 +117,11 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
     }
   }
 
+  std::vector<const BoundParameters*> tracksPtr;
+  for (const auto& trk : tracks) {
+    tracksPtr.push_back(&trk);
+  }
+
   VertexFinderOptions<BoundParameters> finderOptions(tgContext, mfContext);
 
   Vector3D constraintPos{-0.5_mm, -0.5_mm, 0_mm};
@@ -129,7 +134,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
 
   finderOptions.vertexConstraint = constraintVtx;
 
-  auto findResult = finder.find(tracks, finderOptions);
+  auto findResult = finder.find(tracksPtr, finderOptions);
 
   if (!findResult.ok()) {
     std::cout << findResult.error().message() << std::endl;
@@ -154,8 +159,8 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
 }
 
 // Return all tracks of one single event as reconstructed in athena.
-std::vector<BoundParameters> getAthenaTracks() {
-  std::vector<BoundParameters> tracks;
+std::vector<const BoundParameters> getAthenaTracks() {
+  std::vector<const BoundParameters> tracks;
 
   // track 0 :
   BoundVector params0;
diff --git a/Tests/UnitTests/Core/Vertexing/CMakeLists.txt b/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
index cb9e130a7..60512520f 100644
--- a/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
+++ b/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
@@ -5,7 +5,7 @@ add_unittest(KalmanVertexTrackUpdaterTests KalmanVertexTrackUpdaterTests.cpp)
 add_unittest(KalmanVertexUpdaterTests KalmanVertexUpdaterTests.cpp)
 add_unittest(LinearizedTrackFactoryTests LinearizedTrackFactoryTests.cpp)
 add_unittest(AdaptiveMultiVertexFitterTests AdaptiveMultiVertexFitterTests.cpp)
-#add_unittest(AdaptiveMultiVertexFinderTests AdaptiveMultiVertexFinderTests.cpp)
+add_unittest(AdaptiveMultiVertexFinderTests AdaptiveMultiVertexFinderTests.cpp)
 add_unittest(TrackToVertexIPEstimatorTests TrackToVertexIPEstimatorTests.cpp)
 # add_unittest(VertexSmootherTests VertexSmootherTests.cpp)
 add_unittest(ZScanVertexFinderTests ZScanVertexFinderTests.cpp)
diff --git a/Tests/UnitTests/Core/Vertexing/LinearizedTrackFactoryTests.cpp b/Tests/UnitTests/Core/Vertexing/LinearizedTrackFactoryTests.cpp
index 595e3b95b..48a9cae8f 100644
--- a/Tests/UnitTests/Core/Vertexing/LinearizedTrackFactoryTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/LinearizedTrackFactoryTests.cpp
@@ -136,8 +136,7 @@ BOOST_AUTO_TEST_CASE(linearized_track_factory_test) {
 
   for (const BoundParameters& parameters : tracks) {
     LinearizedTrack linTrack =
-        linFactory.linearizeTrack(parameters, SpacePointVector::Zero())
-            .value();
+        linFactory.linearizeTrack(parameters, SpacePointVector::Zero()).value();
 
     BOOST_CHECK_NE(linTrack.parametersAtPCA, vecBoundZero);
     BOOST_CHECK_NE(linTrack.covarianceAtPCA, matBoundZero);
@@ -226,8 +225,7 @@ BOOST_AUTO_TEST_CASE(linearized_track_factory_straightline_test) {
 
   for (const BoundParameters& parameters : tracks) {
     LinearizedTrack linTrack =
-        linFactory.linearizeTrack(parameters, SpacePointVector::Zero())
-            .value();
+        linFactory.linearizeTrack(parameters, SpacePointVector::Zero()).value();
 
     BOOST_CHECK_NE(linTrack.parametersAtPCA, vecBoundZero);
     BOOST_CHECK_NE(linTrack.covarianceAtPCA, matBoundZero);
diff --git a/Tests/UnitTests/Core/Vertexing/TrackDensityVertexFinderTests.cpp b/Tests/UnitTests/Core/Vertexing/TrackDensityVertexFinderTests.cpp
index 16cbf887a..607b77daa 100644
--- a/Tests/UnitTests/Core/Vertexing/TrackDensityVertexFinderTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/TrackDensityVertexFinderTests.cpp
@@ -214,11 +214,10 @@ BOOST_AUTO_TEST_CASE(track_density_finder_random_test) {
   }
 
   std::vector<const BoundParameters*> trackPtrVec;
-  for(const auto& trk : trackVec){
+  for (const auto& trk : trackVec) {
     trackPtrVec.push_back(&trk);
   }
 
-
   auto res3 = finder.find(trackPtrVec, vFinderOptions);
   if (!res3.ok()) {
     std::cout << res3.error().message() << std::endl;
-- 
GitLab


From 3efbb8ee52ba070cb0492510d61c9b2b405ea6e6 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Fri, 28 Feb 2020 12:25:43 +0100
Subject: [PATCH 31/60] add some debug statements to AMVF

---
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 50 ++++++++++++++++---
 .../Vertexing/AdaptiveMultiVertexFitter.ipp   |  9 ++++
 2 files changed, 53 insertions(+), 6 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index 081493de3..ef9742e3e 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -38,6 +38,9 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
   while (((m_cfg.addSingleTrackVertices && seedTracks.size() > 0) ||
           ((!m_cfg.addSingleTrackVertices) && seedTracks.size() > 1)) &&
          iteration < m_cfg.maxIterations) {
+
+    std::cout << "iteration: " << iteration << std::endl;
+    std::cout << "number of seedtracks left: " << seedTracks.size() << std::endl;
     // Tracks that are used for searching compatible tracks
     // near a vertex candidate
     std::vector<const InputTrack_t*> myTracks;
@@ -57,6 +60,9 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     Vertex<InputTrack_t>* vtxCandidate = (allVertices.back()).get();
     allVerticesPtr.push_back(vtxCandidate);
 
+    std::cout << iteration << ". vertex, adress: " << vtxCandidate << std::endl;
+    std::cout << "\t seed z pos: " << vtxCandidate->position()[2] << std::endl;
+
     ACTS_DEBUG("Position of current vertex candidate after seeding: "
                << vtxCandidate->fullPosition());
     if (vtxCandidate->position().z() == 0.) {
@@ -67,6 +73,19 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     auto prepResult = canPrepareVertexForFit(myTracks, seedTracks, vtxCandidate,
                                              currentConstraint, fitterState);
 
+    std::cout << "\tRunning addVtxTofit(); The current candidate has " 
+    << fitterState.vtxInfoMap[vtxCandidate].trackLinks.size() <<
+                      " tracks in the vector" << std::endl;
+    //std::cout << "\t number of track at current vertex: " << fitterState.vtxInfoMap[vtxCandidate].trackLinks.size() << std::endl;
+
+    int c1 = 0;
+    for(auto& trk : fitterState.vtxInfoMap[vtxCandidate].trackLinks){
+      c1++;
+      // std::cout << "\t" << c1 << ". trkAtVtx: "
+      //    << fitterState.tracksAtVerticesMap.at(std::make_pair(trk,vtxCandidate)).fittedParams.parameters()[0] << std::endl;
+    }
+
+
     if (!prepResult.ok()) {
       return prepResult.error();
     }
@@ -76,12 +95,24 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     }
     // Update fitter state with all vertices
     fitterState.updateTrkToVerticesMultiMap(allVerticesPtr);
+
+    c1 = 0;
+    std::cout << "\t number of vertices per track: " << std::endl;
+    for(auto& trk : fitterState.vtxInfoMap[vtxCandidate].trackLinks){
+      c1++;
+      auto range = fitterState.trackToVerticesMultiMap.equal_range(trk);
+      // std::cout << "\t\t" << c1 << ". track: "
+      //   << std::distance(range.first, range.second) << std::endl;
+    }
+
+
     // Perform the fit
     auto fitResult = m_cfg.vertexFitter.addVtxToFit(
         fitterState, *vtxCandidate, m_cfg.linearizer, vFitterOptions);
     if (!fitResult.ok()) {
       return fitResult.error();
     }
+    std::cout << "\t new vtx z pos after fit: " << vtxCandidate->position()[2] << std::endl;
     ACTS_DEBUG("New position of current vertex candidate after fit: "
                << vtxCandidate->fullPosition());
 
@@ -91,6 +122,9 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     checkVertexAndCompatibleTracks(vtxCandidate, seedTracks, nCompatibleTracks,
                                    isGoodVertex, fitterState);
 
+    std::cout << "\t with nCompatibleTracks: " << nCompatibleTracks << std::endl;
+    std::cout << "\t is good vertex: " << isGoodVertex << std::endl;
+
     ACTS_DEBUG("Vertex is good vertex: " << isGoodVertex);
     if (nCompatibleTracks > 0) {
       removeCompatibleTracksFromSeedTracks(vtxCandidate, seedTracks,
@@ -325,6 +359,10 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
   if (!resComp.ok()) {
     return Result<bool>::failure(resComp.error());
   }
+
+  std::cout << "\tnumber of tracks added to vtx candidate passing IP and z cuts: " 
+  << fitterState.vtxInfoMap[vtx].trackLinks.size() << std::endl;
+      
   // Try to recover from cases where adding compatible track was not possible
   auto resRec = canRecoverFromNoCompatibleTracks(
       myTracks, seedTracks, vtx, currentConstraint, fitterState);
@@ -366,12 +404,12 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
           isGoodVertex = true;
           break;
         }
-      }
-    } else {
+      } else {
       // TODO: can this else case actually happen? If not,
       // just remove std::find_if above, since it's not necessary
-      std::cout << "ELSE CASE!" << std::endl;
-    }
+      //std::cout << "ELSE CASE!1" << std::endl;
+      }
+    } 
   }  // end loop over all tracks at vertex
 }
 
@@ -398,7 +436,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
       } else {
         // TODO: can this else case actually happen? If not,
         // just remove std::find_if above, since it's not necessary
-        std::cout << "ELSE CASE!" << std::endl;
+        //std::cout << "ELSE CASE!2" << std::endl;
         ACTS_DEBUG("Track not found in seedTracks!");
       }
     }
@@ -430,7 +468,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
       } else {
         // TODO: can this else case actually happen? If not,
         // just remove std::find_if above, since it's not necessary
-        std::cout << "ELSE CASE!" << std::endl;
+        //std::cout << "ELSE CASE!3" << std::endl;
       }
     }
   }
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
index f00f19718..e068b3775 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
@@ -54,6 +54,15 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::fitImpl(
   while (nIter < m_cfg.maxIterations &&
          (!state.annealingState.equilibriumReached || !isSmallShift)) {
     // Initial loop over all vertices in state.vertexCollection
+    std::cout << "\nfit: niter: " << nIter << std::endl;
+
+    int vc = 0;
+    for (auto currentVtx : state.vertexCollection) {
+      vc++;
+        std::cout << "\n" << vc <<". vertex, ntracks: " << state.vtxInfoMap[currentVtx].trackLinks.size() << std::endl;
+    }
+
+
     for (auto currentVtx : state.vertexCollection) {
       VertexInfo<input_track_t>& currentVtxInfo = state.vtxInfoMap[currentVtx];
       currentVtxInfo.relinearize = false;
-- 
GitLab


From e0c4e48f7a5b2055b024cbff6945507b38eda8e1 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Fri, 28 Feb 2020 12:26:09 +0100
Subject: [PATCH 32/60] remove ID from TrackAtVertex

---
 Core/include/Acts/Vertexing/TrackAtVertex.hpp | 28 -------------------
 1 file changed, 28 deletions(-)

diff --git a/Core/include/Acts/Vertexing/TrackAtVertex.hpp b/Core/include/Acts/Vertexing/TrackAtVertex.hpp
index 0c03d2ba4..e0337ebcf 100644
--- a/Core/include/Acts/Vertexing/TrackAtVertex.hpp
+++ b/Core/include/Acts/Vertexing/TrackAtVertex.hpp
@@ -8,8 +8,6 @@
 
 #pragma once
 
-#include <boost/functional/hash.hpp>
-#include <chrono>
 #include <functional>
 #include "Acts/EventData/TrackParameters.hpp"
 #include "Acts/Vertexing/LinearizedTrack.hpp"
@@ -41,16 +39,6 @@ struct TrackAtVertex {
         originalTrack(originalParams),
         trackWeight(1.),
         vertexCompatibility(0.) {
-    // Create unique ID for this object
-    unsigned long int now =
-        std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::system_clock::now().time_since_epoch())
-            .count();
-
-    boost::hash_combine(id, this);
-    boost::hash_combine(id, paramsAtVertex.parameters()[0]);
-    boost::hash_combine(id, paramsAtVertex.parameters()[1]);
-    boost::hash_combine(id, now);
   }
 
   /// @brief Constructor with default chi2
@@ -66,16 +54,6 @@ struct TrackAtVertex {
         originalTrack(originalParams),
         trackWeight(1.),
         vertexCompatibility(0.) {
-    // Create unique ID for this object
-    unsigned long int now =
-        std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::system_clock::now().time_since_epoch())
-            .count();
-
-    boost::hash_combine(id, this);
-    boost::hash_combine(id, paramsAtVertex.parameters()[0]);
-    boost::hash_combine(id, paramsAtVertex.parameters()[1]);
-    boost::hash_combine(id, now);
   }
 
   /// Chi2 of track
@@ -107,12 +85,6 @@ struct TrackAtVertex {
   /// on the estimation of the 3d distance between the track and the vertex
   double vertexCompatibility;
 
-  /// Unique ID
-  unsigned long id;
-
-  // Track parameters at point of closest approach in 3d as
-  // retrieved by ImpactPoint3dEstimator::getParamsAtClosestApproach
-  // std::unique_ptr<const BoundParameters> ip3dParams;
 };
 
 }  // namespace Acts
-- 
GitLab


From cdf471e133c662d588c91e9464b19d48bdea1921 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Fri, 28 Feb 2020 13:48:10 +0100
Subject: [PATCH 33/60] add tracks back to vertices before output of AMVF

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   |    5 +
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   |   81 +-
 .../Vertexing/AdaptiveMultiVertexFitter.ipp   |    8 -
 Core/include/Acts/Vertexing/TrackAtVertex.hpp |    7 +-
 .../AdaptiveMultiVertexFinderTests.cpp        | 7281 +++++++++--------
 5 files changed, 4056 insertions(+), 3326 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index 740aec2f1..ad5163674 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -333,6 +333,11 @@ class AdaptiveMultiVertexFinder {
   bool isMergedVertex(
       const Vertex<InputTrack_t>* vtx,
       const std::vector<Vertex<InputTrack_t>*>& allVertices) const;
+
+  // TODO
+  std::vector<Vertex<InputTrack_t>> getVertexOutputList(
+      const std::vector<Vertex<InputTrack_t>*>& allVerticesPtr,
+      FitterState_t& fitterState) const;
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index ef9742e3e..7999a7f72 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -38,9 +38,6 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
   while (((m_cfg.addSingleTrackVertices && seedTracks.size() > 0) ||
           ((!m_cfg.addSingleTrackVertices) && seedTracks.size() > 1)) &&
          iteration < m_cfg.maxIterations) {
-
-    std::cout << "iteration: " << iteration << std::endl;
-    std::cout << "number of seedtracks left: " << seedTracks.size() << std::endl;
     // Tracks that are used for searching compatible tracks
     // near a vertex candidate
     std::vector<const InputTrack_t*> myTracks;
@@ -60,9 +57,6 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     Vertex<InputTrack_t>* vtxCandidate = (allVertices.back()).get();
     allVerticesPtr.push_back(vtxCandidate);
 
-    std::cout << iteration << ". vertex, adress: " << vtxCandidate << std::endl;
-    std::cout << "\t seed z pos: " << vtxCandidate->position()[2] << std::endl;
-
     ACTS_DEBUG("Position of current vertex candidate after seeding: "
                << vtxCandidate->fullPosition());
     if (vtxCandidate->position().z() == 0.) {
@@ -73,19 +67,6 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     auto prepResult = canPrepareVertexForFit(myTracks, seedTracks, vtxCandidate,
                                              currentConstraint, fitterState);
 
-    std::cout << "\tRunning addVtxTofit(); The current candidate has " 
-    << fitterState.vtxInfoMap[vtxCandidate].trackLinks.size() <<
-                      " tracks in the vector" << std::endl;
-    //std::cout << "\t number of track at current vertex: " << fitterState.vtxInfoMap[vtxCandidate].trackLinks.size() << std::endl;
-
-    int c1 = 0;
-    for(auto& trk : fitterState.vtxInfoMap[vtxCandidate].trackLinks){
-      c1++;
-      // std::cout << "\t" << c1 << ". trkAtVtx: "
-      //    << fitterState.tracksAtVerticesMap.at(std::make_pair(trk,vtxCandidate)).fittedParams.parameters()[0] << std::endl;
-    }
-
-
     if (!prepResult.ok()) {
       return prepResult.error();
     }
@@ -96,23 +77,12 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     // Update fitter state with all vertices
     fitterState.updateTrkToVerticesMultiMap(allVerticesPtr);
 
-    c1 = 0;
-    std::cout << "\t number of vertices per track: " << std::endl;
-    for(auto& trk : fitterState.vtxInfoMap[vtxCandidate].trackLinks){
-      c1++;
-      auto range = fitterState.trackToVerticesMultiMap.equal_range(trk);
-      // std::cout << "\t\t" << c1 << ". track: "
-      //   << std::distance(range.first, range.second) << std::endl;
-    }
-
-
     // Perform the fit
     auto fitResult = m_cfg.vertexFitter.addVtxToFit(
         fitterState, *vtxCandidate, m_cfg.linearizer, vFitterOptions);
     if (!fitResult.ok()) {
       return fitResult.error();
     }
-    std::cout << "\t new vtx z pos after fit: " << vtxCandidate->position()[2] << std::endl;
     ACTS_DEBUG("New position of current vertex candidate after fit: "
                << vtxCandidate->fullPosition());
 
@@ -122,9 +92,6 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     checkVertexAndCompatibleTracks(vtxCandidate, seedTracks, nCompatibleTracks,
                                    isGoodVertex, fitterState);
 
-    std::cout << "\t with nCompatibleTracks: " << nCompatibleTracks << std::endl;
-    std::cout << "\t is good vertex: " << isGoodVertex << std::endl;
-
     ACTS_DEBUG("Vertex is good vertex: " << isGoodVertex);
     if (nCompatibleTracks > 0) {
       removeCompatibleTracksFromSeedTracks(vtxCandidate, seedTracks,
@@ -164,13 +131,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     iteration++;
   }  // end while loop
 
-  std::vector<Vertex<InputTrack_t>> outputVec;
-
-  for (auto vtx : allVerticesPtr) {
-    outputVec.push_back(*vtx);
-  }
-
-  return outputVec;
+  return getVertexOutputList(allVerticesPtr, fitterState);
 }
 
 template <typename vfitter_t, typename sfinder_t>
@@ -261,8 +222,6 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
                                 Vertex<InputTrack_t>* vtx,
                                 FitterState_t& fitterState) const
     -> Result<void> {
-  std::vector<TrackAtVertex<InputTrack_t>> tracksAtVtx;
-
   for (const auto& trk : tracks) {
     auto sigRes = getIPSignificance(trk, vtx);
     if (!sigRes.ok()) {
@@ -360,9 +319,6 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     return Result<bool>::failure(resComp.error());
   }
 
-  std::cout << "\tnumber of tracks added to vtx candidate passing IP and z cuts: " 
-  << fitterState.vtxInfoMap[vtx].trackLinks.size() << std::endl;
-      
   // Try to recover from cases where adding compatible track was not possible
   auto resRec = canRecoverFromNoCompatibleTracks(
       myTracks, seedTracks, vtx, currentConstraint, fitterState);
@@ -388,6 +344,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
         (trkAtVtx.trackWeight > m_cfg.minWeight &&
          trkAtVtx.chi2Track < m_cfg.maxVertexChi2 &&
          !m_cfg.useFastCompatibility)) {
+      // TODO: Understand why looking for compatible tracks only in seed tracks
+      // and not also in all tracks
       auto foundIter = std::find_if(
           seedTracks.begin(), seedTracks.end(), [&trk, this](auto seedTrk) {
             return m_extractParameters(*trk) == m_extractParameters(*seedTrk);
@@ -404,12 +362,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
           isGoodVertex = true;
           break;
         }
-      } else {
-      // TODO: can this else case actually happen? If not,
-      // just remove std::find_if above, since it's not necessary
-      //std::cout << "ELSE CASE!1" << std::endl;
       }
-    } 
+    }
   }  // end loop over all tracks at vertex
 }
 
@@ -433,11 +387,6 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
           });
       if (foundSeedIter != seedTracks.end()) {
         seedTracks.erase(foundSeedIter);
-      } else {
-        // TODO: can this else case actually happen? If not,
-        // just remove std::find_if above, since it's not necessary
-        //std::cout << "ELSE CASE!2" << std::endl;
-        ACTS_DEBUG("Track not found in seedTracks!");
       }
     }
   }
@@ -465,10 +414,6 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
       if (foundSeedIter != seedTracks.end()) {
         maxCompatibility = compatibility;
         maxCompSeedIt = foundSeedIter;
-      } else {
-        // TODO: can this else case actually happen? If not,
-        // just remove std::find_if above, since it's not necessary
-        //std::cout << "ELSE CASE!3" << std::endl;
       }
     }
   }
@@ -576,3 +521,21 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::isMergedVertex(
   }
   return false;
 }
+
+template <typename vfitter_t, typename sfinder_t>
+auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::getVertexOutputList(
+    const std::vector<Vertex<InputTrack_t>*>& allVerticesPtr,
+    FitterState_t& fitterState) const -> std::vector<Vertex<InputTrack_t>> {
+  std::vector<Vertex<InputTrack_t>> outputVec;
+  for (auto vtx : allVerticesPtr) {
+    auto& outVtx = *vtx;
+    std::vector<TrackAtVertex<InputTrack_t>> tracksAtVtx;
+    for (const auto& trk : fitterState.vtxInfoMap[vtx].trackLinks) {
+      tracksAtVtx.push_back(
+          fitterState.tracksAtVerticesMap.at(std::make_pair(trk, vtx)));
+    }
+    outVtx.setTracksAtVertex(tracksAtVtx);
+    outputVec.push_back(outVtx);
+  }
+  return outputVec;
+}
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
index e068b3775..819c1a9b4 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
@@ -54,14 +54,6 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::fitImpl(
   while (nIter < m_cfg.maxIterations &&
          (!state.annealingState.equilibriumReached || !isSmallShift)) {
     // Initial loop over all vertices in state.vertexCollection
-    std::cout << "\nfit: niter: " << nIter << std::endl;
-
-    int vc = 0;
-    for (auto currentVtx : state.vertexCollection) {
-      vc++;
-        std::cout << "\n" << vc <<". vertex, ntracks: " << state.vtxInfoMap[currentVtx].trackLinks.size() << std::endl;
-    }
-
 
     for (auto currentVtx : state.vertexCollection) {
       VertexInfo<input_track_t>& currentVtxInfo = state.vtxInfoMap[currentVtx];
diff --git a/Core/include/Acts/Vertexing/TrackAtVertex.hpp b/Core/include/Acts/Vertexing/TrackAtVertex.hpp
index e0337ebcf..1d63c25a8 100644
--- a/Core/include/Acts/Vertexing/TrackAtVertex.hpp
+++ b/Core/include/Acts/Vertexing/TrackAtVertex.hpp
@@ -38,8 +38,7 @@ struct TrackAtVertex {
         fittedParams(paramsAtVertex),
         originalTrack(originalParams),
         trackWeight(1.),
-        vertexCompatibility(0.) {
-  }
+        vertexCompatibility(0.) {}
 
   /// @brief Constructor with default chi2
   ///
@@ -53,8 +52,7 @@ struct TrackAtVertex {
         fittedParams(paramsAtVertex),
         originalTrack(originalParams),
         trackWeight(1.),
-        vertexCompatibility(0.) {
-  }
+        vertexCompatibility(0.) {}
 
   /// Chi2 of track
   double chi2Track;
@@ -84,7 +82,6 @@ struct TrackAtVertex {
   /// Value of the compatibility of the track to the actual vertex, based
   /// on the estimation of the 3d distance between the track and the vertex
   double vertexCompatibility;
-
 };
 
 }  // namespace Acts
diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
index f5c9b7108..223dfcf0f 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
@@ -124,9 +124,10 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
 
   VertexFinderOptions<BoundParameters> finderOptions(tgContext, mfContext);
 
-  Vector3D constraintPos{-0.5_mm, -0.5_mm, 0_mm};
+  Vector3D constraintPos{0._mm, 0._mm, 0_mm};
   ActsSymMatrixD<3> constraintCov;
-  constraintCov << 0.0001, 0, 0, 0, 0.0001, 0, 0, 0, 1764;
+  constraintCov << 0.000196000008145347238, 0, 0, 0, 0.000196000008145347238, 0,
+      0, 0, 2809;
 
   Vertex<BoundParameters> constraintVtx;
   constraintVtx.setPosition(constraintPos);
@@ -154,6 +155,9 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
       std::cout << count << ". Vertex at position: " << vtx.position()[0]
                 << ", " << vtx.position()[1] << ", " << vtx.position()[2]
                 << std::endl;
+      std::cout << count << ". Vertex with cov: " << vtx.covariance()
+                << std::endl;
+      std::cout << "\t with n tracks: " << vtx.tracks().size() << std::endl;
     }
   }
 }
@@ -162,3912 +166,4681 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
 std::vector<const BoundParameters> getAthenaTracks() {
   std::vector<const BoundParameters> tracks;
 
+  std::shared_ptr<PerigeeSurface> perigeeSurface =
+      Surface::makeShared<PerigeeSurface>(Vector3D(0, 0, 0));
+
   // track 0 :
   BoundVector params0;
-  params0 << -0.0189610905945301056, 19.2891330718994141, -1.72937667369842529,
-      0.245648413896560669, 0.000139094627229496837 * 1. / (1_MeV), 0;
+  params0 << 0.208999365568161011, -7.4357142448425293, -2.55163192749023438,
+      0.400493592023849487, 0.000171513980603776872 * 1. / (1_MeV), 0;
   Covariance covMat0;
-  covMat0 << 0.0234750192612409592, -0.00781442524684276309,
-      -0.000530674182045025289, -8.29588870144685228e-06,
-      -9.34183350654419714e-08 * 1. / (1_MeV), 0, -0.00781442524684276309,
-      0.406355828046798706, 0.000142553526286719813, 0.000532610276843647709,
-      2.47911983155666744e-08 * 1. / (1_MeV), 0, -0.000530674182045025289,
-      0.000142553526286719813, 1.25120022858027369e-05, 1.45461672177318258e-07,
-      3.16496658346130268e-09 * 1. / (1_MeV), 0, -8.29588870144685228e-06,
-      0.000532610276843647709, 1.45461672177318258e-07, 7.28171983155334601e-07,
-      2.62386697279164045e-11 * 1. / (1_MeV), 0,
-      -9.34183350654419714e-08 * 1. / (1_MeV),
-      2.47911983155666744e-08 * 1. / (1_MeV),
-      3.16496658346130268e-09 * 1. / (1_MeV),
-      2.62386697279164045e-11 * 1. / (1_MeV),
-      2.09531125089368331e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform0;
-  ActsSymMatrixD<3> rotMat0;
-  rotMat0 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform0.rotate(rotMat0);
-  transform0.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans0 = std::make_shared<const Transform3D>(transform0);
-  std::shared_ptr<PerigeeSurface> perigeeSurface0 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat0 << 0.00214068428613245487, -7.96709354183403084e-05,
+      -6.33177642943666364e-05, -3.00625320493796891e-07,
+      -4.07648672868712677e-08 * 1. / (1_MeV), 0, -7.96709354183403084e-05,
+      0.0202132239937782288, 6.98606246685060205e-07, 8.37879139489858309e-05,
+      -8.87738057299842411e-10 * 1. / (1_MeV), 0, -6.33177642943666364e-05,
+      6.98606246685060205e-07, 1.92246739061374683e-06, 3.3797454010498409e-09,
+      1.96217863793276324e-09 * 1. / (1_MeV), 0, -3.00625320493796891e-07,
+      8.37879139489858309e-05, 3.3797454010498409e-09, 3.60428089152264874e-07,
+      -2.89474607768885319e-13 * 1. / (1_MeV), 0,
+      -4.07648672868712677e-08 * 1. / (1_MeV),
+      -8.87738057299842411e-10 * 1. / (1_MeV),
+      1.96217863793276324e-09 * 1. / (1_MeV),
+      -2.89474607768885319e-13 * 1. / (1_MeV),
+      2.95636293223822122e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams0 =
-      BoundParameters(tgContext, std::move(covMat0), params0, perigeeSurface0);
+      BoundParameters(tgContext, std::move(covMat0), params0, perigeeSurface);
   tracks.push_back(boundParams0);
 
   // track 1 :
   BoundVector params1;
-  params1 << 0.237322136759757996, 18.9474124908447266, 2.77435874938964844,
-      0.221098631620407104, 0.000243303977185860276 * 1. / (1_MeV), 0;
+  params1 << -0.824735164642333984, -26.9860115051269531, -0.7550087571144104,
+      2.88085079193115234, -0.000325617991620674729 * 1. / (1_MeV), 0;
   Covariance covMat1;
-  covMat1 << 0.0224881023168563843, -0.00123628927370857643,
-      -0.000682571853275380021, -5.08470990346168592e-07,
-      -1.65987991328505037e-07 * 1. / (1_MeV), 0, -0.00123628927370857643,
-      0.486606210470199585, -1.26428790915631958e-05, 0.000691189647290967285,
-      8.49211598605589898e-10 * 1. / (1_MeV), 0, -0.000682571853275380021,
-      -1.26428790915631958e-05, 2.10596499528037384e-05,
-      -4.86598776586506401e-08, 8.07036236689827024e-09 * 1. / (1_MeV), 0,
-      -5.08470990346168592e-07, 0.000691189647290967285,
-      -4.86598776586506401e-08, 9.96780613604641985e-07,
-      2.84880592793454068e-12 * 1. / (1_MeV), 0,
-      -1.65987991328505037e-07 * 1. / (1_MeV),
-      8.49211598605589898e-10 * 1. / (1_MeV),
-      8.07036236689827024e-09 * 1. / (1_MeV),
-      2.84880592793454068e-12 * 1. / (1_MeV),
-      6.98227170525811403e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform1;
-  ActsSymMatrixD<3> rotMat1;
-  rotMat1 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform1.rotate(rotMat1);
-  transform1.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans1 = std::make_shared<const Transform3D>(transform1);
-  std::shared_ptr<PerigeeSurface> perigeeSurface1 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat1 << 0.0251417625695466995, 0.00420630678879723493,
+      -0.000765272953239746903, 6.15640108953951687e-06,
+      -2.11256706714709132e-07 * 1. / (1_MeV), 0, 0.00420630678879723493,
+      0.45946967601776123, -0.00017342003098708611, 0.000916811988348789977,
+      -4.01729661445370942e-08 * 1. / (1_MeV), 0, -0.000765272953239746903,
+      -0.00017342003098708611, 2.36324631259776652e-05,
+      -2.76756048013333578e-07, 1.12351950637584698e-08 * 1. / (1_MeV), 0,
+      6.15640108953951687e-06, 0.000916811988348789977,
+      -2.76756048013333578e-07, 1.84237103439954808e-06,
+      -2.85976888807477401e-11 * 1. / (1_MeV), 0,
+      -2.11256706714709132e-07 * 1. / (1_MeV),
+      -4.01729661445370942e-08 * 1. / (1_MeV),
+      1.12351950637584698e-08 * 1. / (1_MeV),
+      -2.85976888807477401e-11 * 1. / (1_MeV),
+      1.26268676070573349e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams1 =
-      BoundParameters(tgContext, std::move(covMat1), params1, perigeeSurface1);
+      BoundParameters(tgContext, std::move(covMat1), params1, perigeeSurface);
   tracks.push_back(boundParams1);
 
   // track 2 :
   BoundVector params2;
-  params2 << -0.274762749671936035, 19.3189582824707031, 2.51834297180175781,
-      0.247050970792770386, -0.000262395391473546624 * 1. / (1_MeV), 0;
+  params2 << 0.118518374860286713, -48.0805015563964844, -2.49598431587219238,
+      0.356813013553619385, 1.4544933037541341e-05 * 1. / (1_MeV), 0;
   Covariance covMat2;
-  covMat2 << 0.0190738625824451447, -0.0017057542844459892,
-      -0.000571975485803314851, -2.82570644125376289e-06,
-      -1.61839967616137892e-07 * 1. / (1_MeV), 0, -0.0017057542844459892,
-      0.321801245212554932, 6.65458853740041401e-05, 0.000567742814929668329,
-      5.31432764738237606e-09 * 1. / (1_MeV), 0, -0.000571975485803314851,
-      6.65458853740041401e-05, 1.75108507391996682e-05, 1.16541064423600983e-07,
-      8.10714233373920505e-09 * 1. / (1_MeV), 0, -2.82570644125376289e-06,
-      0.000567742814929668329, 1.16541064423600983e-07, 1.01647879091615323e-06,
-      1.7840055165615784e-12 * 1. / (1_MeV), 0,
-      -1.61839967616137892e-07 * 1. / (1_MeV),
-      5.31432764738237606e-09 * 1. / (1_MeV),
-      8.10714233373920505e-09 * 1. / (1_MeV),
-      1.7840055165615784e-12 * 1. / (1_MeV),
-      7.92840237906489165e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform2;
-  ActsSymMatrixD<3> rotMat2;
-  rotMat2 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform2.rotate(rotMat2);
-  transform2.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans2 = std::make_shared<const Transform3D>(transform2);
-  std::shared_ptr<PerigeeSurface> perigeeSurface2 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat2 << 0.00012035925465170294, -1.71798710526704588e-05,
+      -2.2860801492818823e-06, -2.13407107938616708e-08,
+      -8.14879249062358672e-10 * 1. / (1_MeV), 0, -1.71798710526704588e-05,
+      0.00348281394690275192, 1.23563722604002285e-07, 5.49114154040670388e-06,
+      2.65331046074031372e-11 * 1. / (1_MeV), 0, -2.2860801492818823e-06,
+      1.23563722604002285e-07, 5.03515273919674655e-08, 2.09996509522900305e-10,
+      2.36859555262461008e-11 * 1. / (1_MeV), 0, -2.13407107938616708e-08,
+      5.49114154040670388e-06, 2.09996509522900305e-10, 1.09355804411848112e-08,
+      4.89767384223879453e-14 * 1. / (1_MeV), 0,
+      -8.14879249062358672e-10 * 1. / (1_MeV),
+      2.65331046074031372e-11 * 1. / (1_MeV),
+      2.36859555262461008e-11 * 1. / (1_MeV),
+      4.89767384223879453e-14 * 1. / (1_MeV),
+      2.01368720417934022e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams2 =
-      BoundParameters(tgContext, std::move(covMat2), params2, perigeeSurface2);
+      BoundParameters(tgContext, std::move(covMat2), params2, perigeeSurface);
   tracks.push_back(boundParams2);
 
   // track 3 :
   BoundVector params3;
-  params3 << 0.0235438384115695953, 19.7655830383300781, -0.159107863903045654,
-      2.30990958213806152, -0.000119360782264266163 * 1. / (1_MeV), 0;
+  params3 << 0.368123382329940796, -20.0190258026123047, -3.06338405609130859,
+      0.214836537837982178, -7.34859349904581904e-05 * 1. / (1_MeV), 0;
   Covariance covMat3;
-  covMat3 << 0.000361772050382569432, 2.72739909974600519e-05,
-      -8.21723450836043464e-06, 1.34126350783550678e-07,
-      -5.88422825741122636e-09 * 1. / (1_MeV), 0, 2.72739909974600519e-05,
-      0.00511974841356277466, -6.21331210701952311e-07, 3.10034413370417763e-05,
-      -6.86043367956819384e-09 * 1. / (1_MeV), 0, -8.21723450836043464e-06,
-      -6.21331210701952311e-07, 2.07281985353802156e-07,
-      -3.88590354998360268e-09, 2.03791573108340031e-10 * 1. / (1_MeV), 0,
-      1.34126350783550678e-07, 3.10034413370417763e-05,
-      -3.88590354998360268e-09, 3.01585174611318507e-07,
-      -5.64498122454143072e-11 * 1. / (1_MeV), 0,
-      -5.88422825741122636e-09 * 1. / (1_MeV),
-      -6.86043367956819384e-09 * 1. / (1_MeV),
-      2.03791573108340031e-10 * 1. / (1_MeV),
-      -5.64498122454143072e-11 * 1. / (1_MeV),
-      4.42898885968934231e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform3;
-  ActsSymMatrixD<3> rotMat3;
-  rotMat3 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform3.rotate(rotMat3);
-  transform3.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans3 = std::make_shared<const Transform3D>(transform3);
-  std::shared_ptr<PerigeeSurface> perigeeSurface3 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat3 << 0.00247312174178659916, -0.000435264296712661316,
+      -7.28904508252383349e-05, -6.00209640313102993e-07,
+      -1.5146067160372626e-08 * 1. / (1_MeV), 0, -0.000435264296712661316,
+      0.0798703059554100037, 1.0091468480348509e-05, 9.74132025003542101e-05,
+      -1.07193522414496703e-09 * 1. / (1_MeV), 0, -7.28904508252383349e-05,
+      1.0091468480348509e-05, 2.19589765038108453e-06, 1.58931373903659957e-08,
+      7.46303764303131372e-10 * 1. / (1_MeV), 0, -6.00209640313102993e-07,
+      9.74132025003542101e-05, 1.58931373903659957e-08, 1.23175823318888433e-07,
+      3.22868607412569302e-13 * 1. / (1_MeV), 0,
+      -1.5146067160372626e-08 * 1. / (1_MeV),
+      -1.07193522414496703e-09 * 1. / (1_MeV),
+      7.46303764303131372e-10 * 1. / (1_MeV),
+      3.22868607412569302e-13 * 1. / (1_MeV),
+      6.43069972272591883e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams3 =
-      BoundParameters(tgContext, std::move(covMat3), params3, perigeeSurface3);
+      BoundParameters(tgContext, std::move(covMat3), params3, perigeeSurface);
   tracks.push_back(boundParams3);
 
   // track 4 :
   BoundVector params4;
-  params4 << -0.00997916609048843384, 19.6140289306640625, -1.86583328247070312,
-      1.16398906707763672, 4.13092784583568573e-05 * 1. / (1_MeV), 0;
+  params4 << 0.462106257677078247, -45.3825263977050781, 1.54434430599212646,
+      0.558617532253265381, -3.18408128805458546e-05 * 1. / (1_MeV), 0;
   Covariance covMat4;
-  covMat4 << 0.000111233675852417946, 6.24019899783590426e-06,
-      -1.51042179240653054e-06, -1.66343778016681362e-09,
-      -1.90252013322187688e-09 * 1. / (1_MeV), 0, 6.24019899783590426e-06,
-      0.00304781622253358364, -1.53697680009238848e-08, 2.11791743062638145e-05,
-      9.71456470695990042e-10 * 1. / (1_MeV), 0, -1.51042179240653054e-06,
-      -1.53697680009238848e-08, 2.65749235950352158e-08,
-      -5.72349441699598989e-10, 3.41166238038356917e-11 * 1. / (1_MeV), 0,
-      -1.66343778016681362e-09, 2.11791743062638145e-05,
-      -5.72349441699598989e-10, 2.91562628262909129e-07,
-      1.44429681183542297e-11 * 1. / (1_MeV), 0,
-      -1.90252013322187688e-09 * 1. / (1_MeV),
-      9.71456470695990042e-10 * 1. / (1_MeV),
-      3.41166238038356917e-11 * 1. / (1_MeV),
-      1.44429681183542297e-11 * 1. / (1_MeV),
-      4.11648986382504023e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform4;
-  ActsSymMatrixD<3> rotMat4;
-  rotMat4 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform4.rotate(rotMat4);
-  transform4.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans4 = std::make_shared<const Transform3D>(transform4);
-  std::shared_ptr<PerigeeSurface> perigeeSurface4 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat4 << 0.000138078830786980689, -4.74506524313709474e-06,
+      -2.59465406890078115e-06, -1.74446828994113136e-08,
+      -1.79858408809330508e-09 * 1. / (1_MeV), 0, -4.74506524313709474e-06,
+      0.00170238339342176914, 4.66287404599609629e-08, 6.20544387605423323e-06,
+      -4.15978667666583788e-10 * 1. / (1_MeV), 0, -2.59465406890078115e-06,
+      4.66287404599609629e-08, 5.59409834011148632e-08, 2.68972091189718476e-10,
+      4.44398634319667074e-11 * 1. / (1_MeV), 0, -1.74446828994113136e-08,
+      6.20544387605423323e-06, 2.68972091189718476e-10, 3.03028748760425515e-08,
+      -1.68471064059951095e-12 * 1. / (1_MeV), 0,
+      -1.79858408809330508e-09 * 1. / (1_MeV),
+      -4.15978667666583788e-10 * 1. / (1_MeV),
+      4.44398634319667074e-11 * 1. / (1_MeV),
+      -1.68471064059951095e-12 * 1. / (1_MeV),
+      5.01555231808420432e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams4 =
-      BoundParameters(tgContext, std::move(covMat4), params4, perigeeSurface4);
+      BoundParameters(tgContext, std::move(covMat4), params4, perigeeSurface);
   tracks.push_back(boundParams4);
 
   // track 5 :
   BoundVector params5;
-  params5 << 0.0375059135258197784, 19.6366806030273438, 2.80398750305175781,
-      1.33918941020965576, -0.00119000650011003017 * 1. / (1_MeV), 0;
+  params5 << -0.243943929672241211, 0.680740892887115479, 0.597834229469299316,
+      0.471394985914230347, 0.000422831799369305372 * 1. / (1_MeV), 0;
   Covariance covMat5;
-  covMat5 << 0.00557367224246263504, -3.50923298762731976e-05,
-      -0.00016505602825201958, -5.83055075084957149e-07,
-      -8.15374160823663551e-08 * 1. / (1_MeV), 0, -3.50923298762731976e-05,
-      0.0162126719951629639, 1.9925351112667154e-06, 0.000363090538840017685,
-      1.10231246314290943e-09 * 1. / (1_MeV), 0, -0.00016505602825201958,
-      1.9925351112667154e-06, 4.97896826345822774e-06, 4.42649583494026453e-08,
-      3.8207024978280266e-09 * 1. / (1_MeV), 0, -5.83055075084957149e-07,
-      0.000363090538840017685, 4.42649583494026453e-08, 9.3684120656689629e-06,
-      4.81602467249185851e-11 * 1. / (1_MeV), 0,
-      -8.15374160823663551e-08 * 1. / (1_MeV),
-      1.10231246314290943e-09 * 1. / (1_MeV),
-      3.8207024978280266e-09 * 1. / (1_MeV),
-      4.81602467249185851e-11 * 1. / (1_MeV),
-      1.40874742426966293e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform5;
-  ActsSymMatrixD<3> rotMat5;
-  rotMat5 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform5.rotate(rotMat5);
-  transform5.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans5 = std::make_shared<const Transform3D>(transform5);
-  std::shared_ptr<PerigeeSurface> perigeeSurface5 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat5 << 0.00671237893402576447, 5.08571871304874882e-05,
+      -0.000202164056117718448, 1.79538343147805643e-06,
+      -7.75962475463819757e-08 * 1. / (1_MeV), 0, 5.08571871304874882e-05,
+      0.0489778071641921997, -6.91368197228182291e-06, 0.000294139645283991724,
+      3.11541037258698699e-09 * 1. / (1_MeV), 0, -0.000202164056117718448,
+      -6.91368197228182291e-06, 6.17467458141618408e-06,
+      -8.53989223955858972e-08, 3.75976367980382885e-09 * 1. / (1_MeV), 0,
+      1.79538343147805643e-06, 0.000294139645283991724,
+      -8.53989223955858972e-08, 1.79972050773358205e-06,
+      2.80142049328043291e-12 * 1. / (1_MeV), 0,
+      -7.75962475463819757e-08 * 1. / (1_MeV),
+      3.11541037258698699e-09 * 1. / (1_MeV),
+      3.75976367980382885e-09 * 1. / (1_MeV),
+      2.80142049328043291e-12 * 1. / (1_MeV),
+      6.64618290957541547e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams5 =
-      BoundParameters(tgContext, std::move(covMat5), params5, perigeeSurface5);
+      BoundParameters(tgContext, std::move(covMat5), params5, perigeeSurface);
   tracks.push_back(boundParams5);
 
   // track 6 :
   BoundVector params6;
-  params6 << 0.00140287447720766068, 19.7186660766601562, -2.14539408683776855,
-      1.24577629566192627, 0.000378551892936229706 * 1. / (1_MeV), 0;
+  params6 << 0.475236207246780396, -0.555901706218719482, -2.99527096748352051,
+      1.8675537109375, 0.000811780162621289492 * 1. / (1_MeV), 0;
   Covariance covMat6;
-  covMat6 << 0.00101993023417890072, -2.6994413372851214e-05,
-      -2.65953182649328157e-05, 5.98774142459201546e-08,
-      -1.51924922955507223e-08 * 1. / (1_MeV), 0, -2.6994413372851214e-05,
-      0.00769689213484525681, 6.13944837413955775e-07, 9.60181177584976564e-05,
-      1.16782762059655835e-09 * 1. / (1_MeV), 0, -2.65953182649328157e-05,
-      6.13944837413955775e-07, 7.35107732907636091e-07,
-      -4.80302055565397552e-09, 6.05462078703657079e-10 * 1. / (1_MeV), 0,
-      5.98774142459201546e-08, 9.60181177584976564e-05,
-      -4.80302055565397552e-09, 1.77096819697908359e-06,
-      -3.67492839080036729e-12 * 1. / (1_MeV), 0,
-      -1.51924922955507223e-08 * 1. / (1_MeV),
-      1.16782762059655835e-09 * 1. / (1_MeV),
-      6.05462078703657079e-10 * 1. / (1_MeV),
-      -3.67492839080036729e-12 * 1. / (1_MeV),
-      1.91318193926148794e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform6;
-  ActsSymMatrixD<3> rotMat6;
-  rotMat6 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform6.rotate(rotMat6);
-  transform6.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans6 = std::make_shared<const Transform3D>(transform6);
-  std::shared_ptr<PerigeeSurface> perigeeSurface6 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat6 << 0.00304217985831201077, -2.25882172757928212e-05,
+      -8.97036319376342655e-05, -4.59106853961998723e-07,
+      -4.27624663748239102e-08 * 1. / (1_MeV), 0, -2.25882172757928212e-05,
+      0.00797311495989561081, 1.20376337146220198e-06, 0.000183945562259729228,
+      2.1216330790963481e-09 * 1. / (1_MeV), 0, -8.97036319376342655e-05,
+      1.20376337146220198e-06, 2.68421172222588211e-06, 2.66801954035878537e-08,
+      2.01812436010421032e-09 * 1. / (1_MeV), 0, -4.59106853961998723e-07,
+      0.000183945562259729228, 2.66801954035878537e-08, 4.72296460429788567e-06,
+      5.98997883150413798e-11 * 1. / (1_MeV), 0,
+      -4.27624663748239102e-08 * 1. / (1_MeV),
+      2.1216330790963481e-09 * 1. / (1_MeV),
+      2.01812436010421032e-09 * 1. / (1_MeV),
+      5.98997883150413798e-11 * 1. / (1_MeV),
+      7.336908858235347e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams6 =
-      BoundParameters(tgContext, std::move(covMat6), params6, perigeeSurface6);
+      BoundParameters(tgContext, std::move(covMat6), params6, perigeeSurface);
   tracks.push_back(boundParams6);
 
   // track 7 :
   BoundVector params7;
-  params7 << -0.00329869543202221394, 19.6041259765625, -1.90649104118347168,
-      1.12304854393005371, 0.00014407877461053431 * 1. / (1_MeV), 0;
+  params7 << 0.448179751634597778, -45.4515190124511719, 1.47425985336303711,
+      0.590856075286865234, 0.000101737932709511369 * 1. / (1_MeV), 0;
   Covariance covMat7;
-  covMat7 << 0.00036740759969688952, 3.01680354122382919e-07,
-      -7.51521596509247467e-06, 1.21665930278402614e-07,
-      -5.43771801128259869e-09 * 1. / (1_MeV), 0, 3.01680354122382919e-07,
-      0.00500722508877515793, 1.33332939824832304e-07, 3.60641268279091357e-05,
-      -4.27847531573843138e-10 * 1. / (1_MeV), 0, -7.51521596509247467e-06,
-      1.33332939824832304e-07, 1.78475985990189656e-07, -3.2621585490043233e-09,
-      1.59847268857147475e-10 * 1. / (1_MeV), 0, 1.21665930278402614e-07,
-      3.60641268279091357e-05, -3.2621585490043233e-09, 5.36430661668418907e-07,
-      -1.24518107354747404e-11 * 1. / (1_MeV), 0,
-      -5.43771801128259869e-09 * 1. / (1_MeV),
-      -4.27847531573843138e-10 * 1. / (1_MeV),
-      1.59847268857147475e-10 * 1. / (1_MeV),
-      -1.24518107354747404e-11 * 1. / (1_MeV),
-      3.62822619170977134e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform7;
-  ActsSymMatrixD<3> rotMat7;
-  rotMat7 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform7.rotate(rotMat7);
-  transform7.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans7 = std::make_shared<const Transform3D>(transform7);
-  std::shared_ptr<PerigeeSurface> perigeeSurface7 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat7 << 0.000363267812645062804, -5.84171889726608582e-06,
+      -9.84987562994702426e-06, -3.80723442526054169e-08,
+      -5.40267153936386849e-09 * 1. / (1_MeV), 0, -5.84171889726608582e-06,
+      0.00307919480837881565, -5.80046399822108589e-08, 2.00901792637231817e-05,
+      -1.06284200946168232e-10 * 1. / (1_MeV), 0, -9.84987562994702426e-06,
+      -5.80046399822108589e-08, 2.79255488067065016e-07,
+      1.31849282891976127e-10, 2.35086178574079181e-10 * 1. / (1_MeV), 0,
+      -3.80723442526054169e-08, 2.00901792637231817e-05,
+      1.31849282891976127e-10, 1.53749851961038075e-07,
+      1.15397785221538584e-12 * 1. / (1_MeV), 0,
+      -5.40267153936386849e-09 * 1. / (1_MeV),
+      -1.06284200946168232e-10 * 1. / (1_MeV),
+      2.35086178574079181e-10 * 1. / (1_MeV),
+      1.15397785221538584e-12 * 1. / (1_MeV),
+      4.62566573586342678e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams7 =
-      BoundParameters(tgContext, std::move(covMat7), params7, perigeeSurface7);
+      BoundParameters(tgContext, std::move(covMat7), params7, perigeeSurface);
   tracks.push_back(boundParams7);
 
   // track 8 :
   BoundVector params8;
-  params8 << -0.00482689496129751205, 19.7954654693603516,
-      -0.0502131059765815735, 2.31073951721191406,
-      4.92803592351265252e-05 * 1. / (1_MeV), 0;
+  params8 << -0.0999302864074707031, -28.5842227935791016, -1.68599784374237061,
+      0.212112680077552795, 0.000165652469149790704 * 1. / (1_MeV), 0;
   Covariance covMat8;
-  covMat8 << 0.0001803018240025267, 2.28634426988047736e-05,
-      -2.72005896920448914e-06, 9.76369038665024842e-08,
-      -3.00839639507890418e-09 * 1. / (1_MeV), 0, 2.28634426988047736e-05,
-      0.00448299339041113853, -1.94291028533954824e-07, 2.32848414810477441e-05,
-      -1.34362151935947653e-09 * 1. / (1_MeV), 0, -2.72005896920448914e-06,
-      -1.94291028533954824e-07, 5.47910268267060019e-08,
-      -7.01181814072448539e-10, 6.19209989023759561e-11 * 1. / (1_MeV), 0,
-      9.76369038665024842e-08, 2.32848414810477441e-05,
-      -7.01181814072448539e-10, 1.64913686262480041e-07,
-      -8.97362883139383566e-12 * 1. / (1_MeV), 0,
-      -3.00839639507890418e-09 * 1. / (1_MeV),
-      -1.34362151935947653e-09 * 1. / (1_MeV),
-      6.19209989023759561e-11 * 1. / (1_MeV),
-      -8.97362883139383566e-12 * 1. / (1_MeV),
-      9.50577724173617966e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform8;
-  ActsSymMatrixD<3> rotMat8;
-  rotMat8 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform8.rotate(rotMat8);
-  transform8.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans8 = std::make_shared<const Transform3D>(transform8);
-  std::shared_ptr<PerigeeSurface> perigeeSurface8 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat8 << 0.0116489045321941376, -0.000940270776104953194,
+      -0.000352319442915666192, -2.13370040931020126e-07,
+      -8.36209125013331952e-08 * 1. / (1_MeV), 0, -0.000940270776104953194,
+      0.291504502296447754, 8.5972731503188673e-06, 0.000378374215149366048,
+      5.11104877714145611e-09 * 1. / (1_MeV), 0, -0.000352319442915666192,
+      8.5972731503188673e-06, 1.08157237264094874e-05, -1.70526684678213333e-08,
+      4.01226430794326207e-09 * 1. / (1_MeV), 0, -2.13370040931020126e-07,
+      0.000378374215149366048, -1.70526684678213333e-08, 4.9813826308309217e-07,
+      7.61584071858783847e-13 * 1. / (1_MeV), 0,
+      -8.36209125013331952e-08 * 1. / (1_MeV),
+      5.11104877714145611e-09 * 1. / (1_MeV),
+      4.01226430794326207e-09 * 1. / (1_MeV),
+      7.61584071858783847e-13 * 1. / (1_MeV),
+      3.27873631023045675e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams8 =
-      BoundParameters(tgContext, std::move(covMat8), params8, perigeeSurface8);
+      BoundParameters(tgContext, std::move(covMat8), params8, perigeeSurface);
   tracks.push_back(boundParams8);
 
   // track 9 :
   BoundVector params9;
-  params9 << -0.117531783878803253, 19.82318115234375, -1.45641529560089111,
-      2.29713797569274902, -0.00107527442742139101 * 1. / (1_MeV), 0;
+  params9 << 0.152172759175300598, -44.9148368835449219, 1.11447858810424805,
+      0.444638043642044067, -4.85752825625240803e-05 * 1. / (1_MeV), 0;
   Covariance covMat9;
-  covMat9 << 0.0109546398743987083, 0.000422247521285191226,
-      -0.000319963736434306643, 6.84778945643811993e-06,
-      -1.94063777029596808e-07 * 1. / (1_MeV), 0, 0.000422247521285191226,
-      0.038861934095621109, -1.73899586261722636e-05, 0.000539627280113898428,
-      -1.08021534013767774e-09 * 1. / (1_MeV), 0, -0.000319963736434306643,
-      -1.73899586261722636e-05, 9.59809040068648756e-06,
-      -2.82678258192879005e-07, 9.40666777698761478e-09 * 1. / (1_MeV), 0,
-      6.84778945643811993e-06, 0.000539627280113898428,
-      -2.82678258192879005e-07, 7.96383665147004649e-06,
-      -2.67210172465569124e-11 * 1. / (1_MeV), 0,
-      -1.94063777029596808e-07 * 1. / (1_MeV),
-      -1.08021534013767774e-09 * 1. / (1_MeV),
-      9.40666777698761478e-09 * 1. / (1_MeV),
-      -2.67210172465569124e-11 * 1. / (1_MeV),
-      2.76092482209833179e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform9;
-  ActsSymMatrixD<3> rotMat9;
-  rotMat9 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform9.rotate(rotMat9);
-  transform9.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans9 = std::make_shared<const Transform3D>(transform9);
-  std::shared_ptr<PerigeeSurface> perigeeSurface9 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat9 << 0.000584102817811071873, -5.44941413560534802e-05,
+      -1.26293938525266511e-05, -1.64085737189133858e-07,
+      -2.36394827653963764e-09 * 1. / (1_MeV), 0, -5.44941413560534802e-05,
+      0.00448216451331973076, 1.03947024549991706e-06, 1.60899248222629787e-05,
+      -6.13962752714581741e-10 * 1. / (1_MeV), 0, -1.26293938525266511e-05,
+      1.03947024549991706e-06, 2.90120709678376443e-07, 3.39785893631303301e-09,
+      8.40703862829191019e-11 * 1. / (1_MeV), 0, -1.64085737189133858e-07,
+      1.60899248222629787e-05, 3.39785893631303301e-09, 6.88935983816918451e-08,
+      -1.33380435332641628e-12 * 1. / (1_MeV), 0,
+      -2.36394827653963764e-09 * 1. / (1_MeV),
+      -6.13962752714581741e-10 * 1. / (1_MeV),
+      8.40703862829191019e-11 * 1. / (1_MeV),
+      -1.33380435332641628e-12 * 1. / (1_MeV),
+      1.12903610072212501e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams9 =
-      BoundParameters(tgContext, std::move(covMat9), params9, perigeeSurface9);
+      BoundParameters(tgContext, std::move(covMat9), params9, perigeeSurface);
   tracks.push_back(boundParams9);
 
   // track 10 :
   BoundVector params10;
-  params10 << -0.316214293241500854, 19.9858303070068359, 2.23136758804321289,
-      0.716844320297241211, 0.000286014255834743381 * 1. / (1_MeV), 0;
+  params10 << -0.389045566320419312, -24.5613670349121094, -1.53248834609985352,
+      2.95340991020202637, 4.71094026579521596e-05 * 1. / (1_MeV), 0;
   Covariance covMat10;
-  covMat10 << 0.00162444496527314186, -9.06142655681587962e-05,
-      -4.44249197781623932e-05, -1.8536710338487062e-07,
-      -2.67329728219464978e-08 * 1. / (1_MeV), 0, -9.06142655681587962e-05,
-      0.0111282505095005035, 1.36896327277162384e-06, 9.00038816992519377e-05,
-      1.26432483562719022e-09 * 1. / (1_MeV), 0, -4.44249197781623932e-05,
-      1.36896327277162384e-06, 1.26552151868963847e-06, -3.4175627468367298e-09,
-      1.15430331899061749e-09 * 1. / (1_MeV), 0, -1.8536710338487062e-07,
-      9.00038816992519377e-05, -3.4175627468367298e-09, 8.96049414222943597e-07,
-      -1.35745946999861844e-11 * 1. / (1_MeV), 0,
-      -2.67329728219464978e-08 * 1. / (1_MeV),
-      1.26432483562719022e-09 * 1. / (1_MeV),
-      1.15430331899061749e-09 * 1. / (1_MeV),
-      -1.35745946999861844e-11 * 1. / (1_MeV),
-      2.60673704843839005e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform10;
-  ActsSymMatrixD<3> rotMat10;
-  rotMat10 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform10.rotate(rotMat10);
-  transform10.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans10 = std::make_shared<const Transform3D>(transform10);
-  std::shared_ptr<PerigeeSurface> perigeeSurface10 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams10 = BoundParameters(tgContext, std::move(covMat10), params10,
-                                       perigeeSurface10);
+  covMat10 << 0.00179947458673268557, 0.000515301817937796288,
+      -5.33457823139441806e-05, 3.56486698371958979e-07,
+      -1.94156960953159151e-08 * 1. / (1_MeV), 0, 0.000515301817937796288,
+      0.0590848624706268311, -1.31940455534009742e-05, 5.69552185596370288e-05,
+      -4.96614965526505315e-10 * 1. / (1_MeV), 0, -5.33457823139441806e-05,
+      -1.31940455534009742e-05, 1.63217691806494258e-06,
+      -8.93780411334805054e-09, 9.9924929691409935e-10 * 1. / (1_MeV), 0,
+      3.56486698371958979e-07, 5.69552185596370288e-05,
+      -8.93780411334805054e-09, 5.66441578087051312e-08,
+      1.78960551097981704e-12 * 1. / (1_MeV), 0,
+      -1.94156960953159151e-08 * 1. / (1_MeV),
+      -4.96614965526505315e-10 * 1. / (1_MeV),
+      9.9924929691409935e-10 * 1. / (1_MeV),
+      1.78960551097981704e-12 * 1. / (1_MeV),
+      7.76793473294956627e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams10 =
+      BoundParameters(tgContext, std::move(covMat10), params10, perigeeSurface);
   tracks.push_back(boundParams10);
 
   // track 11 :
   BoundVector params11;
-  params11 << -0.026949150487780571, 19.7217216491699219, -1.88010013103485107,
-      1.17576122283935547, -5.31275982211809605e-05 * 1. / (1_MeV), 0;
+  params11 << 0.185064643621444702, -0.313567250967025757, -2.70109248161315918,
+      1.87472164630889893, 0.00110536499414592981 * 1. / (1_MeV), 0;
   Covariance covMat11;
-  covMat11 << 0.000139126204885542393, 7.52935130834812487e-06,
-      -2.04280921055376971e-06, 4.12883664132396972e-08,
-      -2.21097786141294125e-09 * 1. / (1_MeV), 0, 7.52935130834812487e-06,
-      0.00334829371422529221, -4.54681154865933769e-08, 2.39657209827402611e-05,
-      -7.07961483497201632e-10 * 1. / (1_MeV), 0, -2.04280921055376971e-06,
-      -4.54681154865933769e-08, 3.81113594016824209e-08,
-      -5.67025045849674143e-10, 4.41613819941043693e-11 * 1. / (1_MeV), 0,
-      4.12883664132396972e-08, 2.39657209827402611e-05,
-      -5.67025045849674143e-10, 2.3924027914290491e-07,
-      -7.29088756930822923e-12 * 1. / (1_MeV), 0,
-      -2.21097786141294125e-09 * 1. / (1_MeV),
-      -7.07961483497201632e-10 * 1. / (1_MeV),
-      4.41613819941043693e-11 * 1. / (1_MeV),
-      -7.29088756930822923e-12 * 1. / (1_MeV),
-      6.49562489300065105e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform11;
-  ActsSymMatrixD<3> rotMat11;
-  rotMat11 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform11.rotate(rotMat11);
-  transform11.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans11 = std::make_shared<const Transform3D>(transform11);
-  std::shared_ptr<PerigeeSurface> perigeeSurface11 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams11 = BoundParameters(tgContext, std::move(covMat11), params11,
-                                       perigeeSurface11);
+  covMat11 << 0.00607731565833091736, 1.88963384623831746e-05,
+      -0.000169582357508678549, -6.27965247220519728e-07,
+      -8.0749598939812492e-08 * 1. / (1_MeV), 0, 1.88963384623831746e-05,
+      0.0179781261831521988, 1.49729644512497734e-06, 0.00036414153838812695,
+      2.41630691182238931e-09 * 1. / (1_MeV), 0, -0.000169582357508678549,
+      1.49729644512497734e-06, 4.88961950395605527e-06, 5.74954357912554399e-08,
+      3.74836269648672209e-09 * 1. / (1_MeV), 0, -6.27965247220519728e-07,
+      0.00036414153838812695, 5.74954357912554399e-08, 8.48198396852239966e-06,
+      7.0596004861697542e-11 * 1. / (1_MeV), 0,
+      -8.0749598939812492e-08 * 1. / (1_MeV),
+      2.41630691182238931e-09 * 1. / (1_MeV),
+      3.74836269648672209e-09 * 1. / (1_MeV),
+      7.0596004861697542e-11 * 1. / (1_MeV),
+      1.38257211235170985e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams11 =
+      BoundParameters(tgContext, std::move(covMat11), params11, perigeeSurface);
   tracks.push_back(boundParams11);
 
   // track 12 :
   BoundVector params12;
-  params12 << -0.0259521752595901489, 19.9042549133300781, 2.12977123260498047,
-      0.713346481323242188, 0.000183195850695483387 * 1. / (1_MeV), 0;
+  params12 << -0.706103920936584473, -8.715667724609375, -1.11427760124206543,
+      0.390437692403793335, -0.000532702077180147171 * 1. / (1_MeV), 0;
   Covariance covMat12;
-  covMat12 << 0.000819464214146137238, -2.93160457001729501e-05,
-      -2.12643063322425127e-05, -1.06460388794225743e-07,
-      -1.83180521921403142e-08 * 1. / (1_MeV), 0, -2.93160457001729501e-05,
-      0.00743293715640902519, 3.1618179870268056e-07, 5.44865137200824102e-05,
-      1.28616095797583938e-09 * 1. / (1_MeV), 0, -2.12643063322425127e-05,
-      3.1618179870268056e-07, 5.87186036682396661e-07, -3.96810184286856466e-10,
-      7.64845470534257536e-10 * 1. / (1_MeV), 0, -1.06460388794225743e-07,
-      5.44865137200824102e-05, -3.96810184286856466e-10,
-      4.86239514430053532e-07, 2.28968063167242651e-12 * 1. / (1_MeV), 0,
-      -1.83180521921403142e-08 * 1. / (1_MeV),
-      1.28616095797583938e-09 * 1. / (1_MeV),
-      7.64845470534257536e-10 * 1. / (1_MeV),
-      2.28968063167242651e-12 * 1. / (1_MeV),
-      1.68847297254970385e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform12;
-  ActsSymMatrixD<3> rotMat12;
-  rotMat12 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform12.rotate(rotMat12);
-  transform12.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans12 = std::make_shared<const Transform3D>(transform12);
-  std::shared_ptr<PerigeeSurface> perigeeSurface12 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams12 = BoundParameters(tgContext, std::move(covMat12), params12,
-                                       perigeeSurface12);
+  covMat12 << 0.0187691841274499893, -0.0011922780217786253,
+      -0.00057461193605452235, -3.44533681528817511e-06,
+      -4.01344704143888752e-07 * 1. / (1_MeV), 0, -0.0011922780217786253,
+      0.151490718126296997, 5.75941132180694864e-05, 0.000636005119141786097,
+      2.44353971236399676e-08 * 1. / (1_MeV), 0, -0.00057461193605452235,
+      5.75941132180694864e-05, 1.79298804141581059e-05, 1.93515522095858729e-07,
+      2.04097502268213299e-08 * 1. / (1_MeV), 0, -3.44533681528817511e-06,
+      0.000636005119141786097, 1.93515522095858729e-07, 2.72269880952080712e-06,
+      -8.79447815502355232e-13 * 1. / (1_MeV), 0,
+      -4.01344704143888752e-07 * 1. / (1_MeV),
+      2.44353971236399676e-08 * 1. / (1_MeV),
+      2.04097502268213299e-08 * 1. / (1_MeV),
+      -8.79447815502355232e-13 * 1. / (1_MeV),
+      3.13229303605666587e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams12 =
+      BoundParameters(tgContext, std::move(covMat12), params12, perigeeSurface);
   tracks.push_back(boundParams12);
 
   // track 13 :
   BoundVector params13;
-  params13 << -0.108195297420024872, 19.4963741302490234, -1.54784798622131348,
-      2.76453542709350586, 0.000255180755630135536 * 1. / (1_MeV), 0;
+  params13 << -0.154836609959602356, -20.9581050872802734, -2.51126766204833984,
+      2.93840575218200684, -0.000163531469297595322 * 1. / (1_MeV), 0;
   Covariance covMat13;
-  covMat13 << 0.00656767562031745911, 0.000444740943016129486,
-      -0.000189528672096109756, 7.43444913558239102e-07,
-      -7.72608213653531881e-08 * 1. / (1_MeV), 0, 0.000444740943016129486,
-      0.0576510205864906311, -6.36114600490174744e-06, 0.000213140984352768603,
-      -5.47938491391429549e-09 * 1. / (1_MeV), 0, -0.000189528672096109756,
-      -6.36114600490174744e-06, 5.65102391192340292e-06,
-      -1.16009327799978898e-09, 3.63038358649066484e-09 * 1. / (1_MeV), 0,
-      7.43444913558239102e-07, 0.000213140984352768603,
-      -1.16009327799978898e-09, 8.20147363356227288e-07,
-      -1.16151818981247784e-11 * 1. / (1_MeV), 0,
-      -7.72608213653531881e-08 * 1. / (1_MeV),
-      -5.47938491391429549e-09 * 1. / (1_MeV),
-      3.63038358649066484e-09 * 1. / (1_MeV),
-      -1.16151818981247784e-11 * 1. / (1_MeV),
-      5.03207892021961811e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform13;
-  ActsSymMatrixD<3> rotMat13;
-  rotMat13 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform13.rotate(rotMat13);
-  transform13.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans13 = std::make_shared<const Transform3D>(transform13);
-  std::shared_ptr<PerigeeSurface> perigeeSurface13 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams13 = BoundParameters(tgContext, std::move(covMat13), params13,
-                                       perigeeSurface13);
+  covMat13 << 0.0135372020304203033, 0.000522583301631817797,
+      -0.000414465124389575392, 8.5218793332842329e-07,
+      -1.76418161813100027e-07 * 1. / (1_MeV), 0, 0.000522583301631817797,
+      0.337794691324234009, -3.07875272696438078e-05, 0.00040703982941800882,
+      -1.5122350796412209e-09 * 1. / (1_MeV), 0, -0.000414465124389575392,
+      -3.07875272696438078e-05, 1.29683203340391628e-05,
+      -4.41435125773279206e-08, 8.99447573145401141e-09 * 1. / (1_MeV), 0,
+      8.5218793332842329e-07, 0.00040703982941800882, -4.41435125773279206e-08,
+      4.96554378059954615e-07, 1.01639646010204121e-13 * 1. / (1_MeV), 0,
+      -1.76418161813100027e-07 * 1. / (1_MeV),
+      -1.5122350796412209e-09 * 1. / (1_MeV),
+      8.99447573145401141e-09 * 1. / (1_MeV),
+      1.01639646010204121e-13 * 1. / (1_MeV),
+      7.34017638337469691e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams13 =
+      BoundParameters(tgContext, std::move(covMat13), params13, perigeeSurface);
   tracks.push_back(boundParams13);
 
   // track 14 :
   BoundVector params14;
-  params14 << 0.00369392801076173782, 19.7586956024169922, -1.87617933750152588,
-      1.1225888729095459, -0.000320049060974270105 * 1. / (1_MeV), 0;
+  params14 << 0.429115772247314453, -24.0853328704833984, -3.03889799118041992,
+      1.37072885036468506, -0.00179144914727658033 * 1. / (1_MeV), 0;
   Covariance covMat14;
-  covMat14 << 0.000884613138623535633, -3.82952276847713579e-05,
-      -2.2559200610146105e-05, -2.935347589307322e-07,
-      -1.23401086351248597e-08 * 1. / (1_MeV), 0, -3.82952276847713579e-05,
-      0.00863977242261171341, 1.31139582148740249e-06, 8.32184382843871649e-05,
-      -2.57691337601532055e-09 * 1. / (1_MeV), 0, -2.2559200610146105e-05,
-      1.31139582148740249e-06, 6.16463069036399247e-07, 1.02756832396022202e-08,
-      4.91883875434775907e-10 * 1. / (1_MeV), 0, -2.935347589307322e-07,
-      8.32184382843871649e-05, 1.02756832396022202e-08, 1.14064482659159694e-06,
-      -1.29782130095271682e-11 * 1. / (1_MeV), 0,
-      -1.23401086351248597e-08 * 1. / (1_MeV),
-      -2.57691337601532055e-09 * 1. / (1_MeV),
-      4.91883875434775907e-10 * 1. / (1_MeV),
-      -1.29782130095271682e-11 * 1. / (1_MeV),
-      1.47767145741717343e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform14;
-  ActsSymMatrixD<3> rotMat14;
-  rotMat14 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform14.rotate(rotMat14);
-  transform14.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans14 = std::make_shared<const Transform3D>(transform14);
-  std::shared_ptr<PerigeeSurface> perigeeSurface14 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams14 = BoundParameters(tgContext, std::move(covMat14), params14,
-                                       perigeeSurface14);
+  covMat14 << 0.011815081350505352, -4.35886846561170212e-05,
+      -0.000356196480791449814, -3.06510243603507525e-06,
+      -2.49215155156052749e-07 * 1. / (1_MeV), 0, -4.35886846561170212e-05,
+      0.0279703252017498016, 3.82172586877418007e-06, 0.000700707100556712979,
+      2.18971032423624985e-10 * 1. / (1_MeV), 0, -0.000356196480791449814,
+      3.82172586877418007e-06, 1.08708409243263304e-05, 1.60096981832880633e-07,
+      1.23485013066819254e-08 * 1. / (1_MeV), 0, -3.06510243603507525e-06,
+      0.000700707100556712979, 1.60096981832880633e-07, 1.87871864909538999e-05,
+      3.9118155474036915e-11 * 1. / (1_MeV), 0,
+      -2.49215155156052749e-07 * 1. / (1_MeV),
+      2.18971032423624985e-10 * 1. / (1_MeV),
+      1.23485013066819254e-08 * 1. / (1_MeV),
+      3.9118155474036915e-11 * 1. / (1_MeV),
+      4.91916063438679885e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams14 =
+      BoundParameters(tgContext, std::move(covMat14), params14, perigeeSurface);
   tracks.push_back(boundParams14);
 
   // track 15 :
   BoundVector params15;
-  params15 << -0.0310039687901735306, 19.3887290954589844,
-      -0.00343075022101402283, 2.74638152122497559,
-      -0.000532752485014498234 * 1. / (1_MeV), 0;
+  params15 << 0.0964239463210105896, -47.889434814453125, -2.51376533508300781,
+      0.37591966986656189, -7.28844097466208041e-05 * 1. / (1_MeV), 0;
   Covariance covMat15;
-  covMat15 << 0.0210070386528968811, 0.00081324441594192757,
-      -0.000627920381522417519, 5.48433427524947839e-06,
-      -4.65033942443220242e-07 * 1. / (1_MeV), 0, 0.00081324441594192757,
-      0.163831159472465515, -4.16699183438430112e-05, 0.000680023693129414735,
-      4.78762996341304375e-09 * 1. / (1_MeV), 0, -0.000627920381522417519,
-      -4.16699183438430112e-05, 1.914421227411367e-05, -2.43960230438290961e-07,
-      2.22620707063765654e-08 * 1. / (1_MeV), 0, 5.48433427524947839e-06,
-      0.000680023693129414735, -2.43960230438290961e-07,
-      2.88798310066340491e-06, -1.98088984995358787e-11 * 1. / (1_MeV), 0,
-      -4.65033942443220242e-07 * 1. / (1_MeV),
-      4.78762996341304375e-09 * 1. / (1_MeV),
-      2.22620707063765654e-08 * 1. / (1_MeV),
-      -1.98088984995358787e-11 * 1. / (1_MeV),
-      3.28982507902253474e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform15;
-  ActsSymMatrixD<3> rotMat15;
-  rotMat15 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform15.rotate(rotMat15);
-  transform15.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans15 = std::make_shared<const Transform3D>(transform15);
-  std::shared_ptr<PerigeeSurface> perigeeSurface15 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams15 = BoundParameters(tgContext, std::move(covMat15), params15,
-                                       perigeeSurface15);
+  covMat15 << 0.000915166805498301983, -5.63928610000066137e-05,
+      -2.30546935251043627e-05, -1.39514212094140237e-07,
+      -8.05606781506218595e-09 * 1. / (1_MeV), 0, -5.63928610000066137e-05,
+      0.00867577362805604935, 1.03957424061424194e-06, 2.75793322198900407e-05,
+      -3.50129287353289466e-11 * 1. / (1_MeV), 0, -2.30546935251043627e-05,
+      1.03957424061424194e-06, 6.37507866940723034e-07, 3.5300612609194207e-09,
+      3.32995301645455374e-10 * 1. / (1_MeV), 0, -1.39514212094140237e-07,
+      2.75793322198900407e-05, 3.5300612609194207e-09, 1.00911485390042799e-07,
+      -2.86168849963761193e-13 * 1. / (1_MeV), 0,
+      -8.05606781506218595e-09 * 1. / (1_MeV),
+      -3.50129287353289466e-11 * 1. / (1_MeV),
+      3.32995301645455374e-10 * 1. / (1_MeV),
+      -2.86168849963761193e-13 * 1. / (1_MeV),
+      3.81985762465397727e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams15 =
+      BoundParameters(tgContext, std::move(covMat15), params15, perigeeSurface);
   tracks.push_back(boundParams15);
 
   // track 16 :
   BoundVector params16;
-  params16 << -0.0615801773965358734, 19.7117156982421875, -1.35818147659301758,
-      1.24108779430389404, 0.000683536636643111706 * 1. / (1_MeV), 0;
+  params16 << -1.083709716796875, -0.935704529285430908, -0.732377231121063232,
+      2.61545205116271973, -0.00085982074961066246 * 1. / (1_MeV), 0;
   Covariance covMat16;
-  covMat16 << 0.00367696909233927727, -6.93357704233026409e-05,
-      -9.18706572871465986e-05, 6.07456121632656689e-08,
-      -5.20653615571341965e-08 * 1. / (1_MeV), 0, -6.93357704233026409e-05,
-      0.0121181188151240349, 8.53747299804855816e-07, 0.000199079474268702445,
-      -6.01983132635719627e-10 * 1. / (1_MeV), 0, -9.18706572871465986e-05,
-      8.53747299804855816e-07, 2.43243312070262618e-06,
-      -1.96703166322206024e-08, 2.02041678483988925e-09 * 1. / (1_MeV), 0,
-      6.07456121632656689e-08, 0.000199079474268702445,
-      -1.96703166322206024e-08, 4.24742711402359419e-06,
-      -5.3578874964861769e-11 * 1. / (1_MeV), 0,
-      -5.20653615571341965e-08 * 1. / (1_MeV),
-      -6.01983132635719627e-10 * 1. / (1_MeV),
-      2.02041678483988925e-09 * 1. / (1_MeV),
-      -5.3578874964861769e-11 * 1. / (1_MeV),
-      6.21097825947991566e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform16;
-  ActsSymMatrixD<3> rotMat16;
-  rotMat16 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform16.rotate(rotMat16);
-  transform16.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans16 = std::make_shared<const Transform3D>(transform16);
-  std::shared_ptr<PerigeeSurface> perigeeSurface16 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams16 = BoundParameters(tgContext, std::move(covMat16), params16,
-                                       perigeeSurface16);
+  covMat16 << 0.020250808447599411, 0.00134430434697943471,
+      -0.000619652083316512593, 5.49275271760961433e-06,
+      -5.75555269925167598e-07 * 1. / (1_MeV), 0, 0.00134430434697943471,
+      0.0884110480546951294, -5.99276194628552559e-05, 0.000655524024191507732,
+      -5.54305280465676383e-08 * 1. / (1_MeV), 0, -0.000619652083316512593,
+      -5.99276194628552559e-05, 1.93270625459263101e-05,
+      -3.0658624571105338e-07, 2.90396851494721417e-08 * 1. / (1_MeV), 0,
+      5.49275271760961433e-06, 0.000655524024191507732, -3.0658624571105338e-07,
+      4.93054767503053881e-06, -1.14583522129541419e-10 * 1. / (1_MeV), 0,
+      -5.75555269925167598e-07 * 1. / (1_MeV),
+      -5.54305280465676383e-08 * 1. / (1_MeV),
+      2.90396851494721417e-08 * 1. / (1_MeV),
+      -1.14583522129541419e-10 * 1. / (1_MeV),
+      6.01911798181475888e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams16 =
+      BoundParameters(tgContext, std::move(covMat16), params16, perigeeSurface);
   tracks.push_back(boundParams16);
 
   // track 17 :
   BoundVector params17;
-  params17 << 0.0127343572676181793, 19.6999797821044922, 1.36659955978393555,
-      2.38492679595947266, -1.37666047521634027e-05 * 1. / (1_MeV), 0;
+  params17 << -0.655812859535217285, -13.5116653442382812, -1.45666837692260742,
+      0.292341023683547974, -0.000473626889288425446 * 1. / (1_MeV), 0;
   Covariance covMat17;
-  covMat17 << 7.14391426299698651e-05, 1.0805756954054268e-05,
-      -8.57142054744985697e-07, 3.6976454665569372e-08,
-      -1.42849189612088987e-09 * 1. / (1_MeV), 0, 1.0805756954054268e-05,
-      0.00291397958062589169, -1.43522930069826317e-07, 1.16636632835631987e-05,
-      -6.34703011704137292e-10 * 1. / (1_MeV), 0, -8.57142054744985697e-07,
-      -1.43522930069826317e-07, 1.44155682946234265e-08,
-      -6.52670147341345277e-10, 2.26980129134178516e-11 * 1. / (1_MeV), 0,
-      3.6976454665569372e-08, 1.16636632835631987e-05, -6.52670147341345277e-10,
-      6.37399537595229049e-08, -3.38191913541128504e-12 * 1. / (1_MeV), 0,
-      -1.42849189612088987e-09 * 1. / (1_MeV),
-      -6.34703011704137292e-10 * 1. / (1_MeV),
-      2.26980129134178516e-11 * 1. / (1_MeV),
-      -3.38191913541128504e-12 * 1. / (1_MeV),
-      1.40677413836866327e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform17;
-  ActsSymMatrixD<3> rotMat17;
-  rotMat17 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform17.rotate(rotMat17);
-  transform17.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans17 = std::make_shared<const Transform3D>(transform17);
-  std::shared_ptr<PerigeeSurface> perigeeSurface17 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams17 = BoundParameters(tgContext, std::move(covMat17), params17,
-                                       perigeeSurface17);
+  covMat17 << 0.0376270599663257599, -0.00331542860473353455,
+      -0.00114237259512064548, -6.46160583865347861e-06,
+      -5.41927356748457027e-07 * 1. / (1_MeV), 0, -0.00331542860473353455,
+      0.453363090753555298, 0.000154569181769570089, 0.00111683225416074725,
+      4.13684226275355482e-08 * 1. / (1_MeV), 0, -0.00114237259512064548,
+      0.000154569181769570089, 3.53331015503499657e-05, 3.31737366693554871e-07,
+      2.71004393542162535e-08 * 1. / (1_MeV), 0, -6.46160583865347861e-06,
+      0.00111683225416074725, 3.31737366693554871e-07, 2.77932576864259318e-06,
+      8.98558886340603463e-12 * 1. / (1_MeV), 0,
+      -5.41927356748457027e-07 * 1. / (1_MeV),
+      4.13684226275355482e-08 * 1. / (1_MeV),
+      2.71004393542162535e-08 * 1. / (1_MeV),
+      8.98558886340603463e-12 * 1. / (1_MeV),
+      3.11804027042228427e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams17 =
+      BoundParameters(tgContext, std::move(covMat17), params17, perigeeSurface);
   tracks.push_back(boundParams17);
 
   // track 18 :
   BoundVector params18;
-  params18 << -0.0384683907032012939, 19.7426490783691406, -1.80467498302459717,
-      1.19412243366241455, -0.000574302859604358673 * 1. / (1_MeV), 0;
+  params18 << 0.575450718402862549, -15.9936590194702148, -2.98787665367126465,
+      0.166759386658668518, 9.08106376300565898e-05 * 1. / (1_MeV), 0;
   Covariance covMat18;
-  covMat18 << 0.00202423892915248871, -7.8687140869615615e-05,
-      -5.63647103701870963e-05, -6.49649805133107235e-07,
-      -3.34683099080895321e-08 * 1. / (1_MeV), 0, -7.8687140869615615e-05,
-      0.0185887850821018219, 2.64877126417112638e-06, 0.000217824332446111879,
-      -1.12870927770216557e-08 * 1. / (1_MeV), 0, -5.63647103701870963e-05,
-      2.64877126417112638e-06, 1.6361793768737698e-06, 2.55884812519548554e-08,
-      1.44678702068679967e-09 * 1. / (1_MeV), 0, -6.49649805133107235e-07,
-      0.000217824332446111879, 2.55884812519548554e-08, 3.64099946636997629e-06,
-      -1.23298436708217984e-10 * 1. / (1_MeV), 0,
-      -3.34683099080895321e-08 * 1. / (1_MeV),
-      -1.12870927770216557e-08 * 1. / (1_MeV),
-      1.44678702068679967e-09 * 1. / (1_MeV),
-      -1.23298436708217984e-10 * 1. / (1_MeV),
-      4.65322051723671137e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform18;
-  ActsSymMatrixD<3> rotMat18;
-  rotMat18 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform18.rotate(rotMat18);
-  transform18.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans18 = std::make_shared<const Transform3D>(transform18);
-  std::shared_ptr<PerigeeSurface> perigeeSurface18 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams18 = BoundParameters(tgContext, std::move(covMat18), params18,
-                                       perigeeSurface18);
+  covMat18 << 0.00828655995428562164, 0.000185564554592324227,
+      -0.000254140606495853623, -3.35073246108407e-07,
+      -1.308304405438276e-07 * 1. / (1_MeV), 0, 0.000185564554592324227,
+      0.291260480880737305, -1.50678458478300795e-05, 0.000236462002833863597,
+      -2.12250899201718451e-08 * 1. / (1_MeV), 0, -0.000254140606495853623,
+      -1.50678458478300795e-05, 8.0477584560867399e-06, 3.73422528117420346e-09,
+      6.7895997118531728e-09 * 1. / (1_MeV), 0, -3.35073246108407e-07,
+      0.000236462002833863597, 3.73422528117420346e-09, 1.94628071881197684e-07,
+      -1.03714183548395548e-12 * 1. / (1_MeV), 0,
+      -1.308304405438276e-07 * 1. / (1_MeV),
+      -2.12250899201718451e-08 * 1. / (1_MeV),
+      6.7895997118531728e-09 * 1. / (1_MeV),
+      -1.03714183548395548e-12 * 1. / (1_MeV),
+      4.68583748192141769e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams18 =
+      BoundParameters(tgContext, std::move(covMat18), params18, perigeeSurface);
   tracks.push_back(boundParams18);
 
   // track 19 :
   BoundVector params19;
-  params19 << -0.00301715848036110401, 19.8266525268554688,
-      -2.67224979400634766, 0.715977728366851807,
-      -0.000728958519175648689 * 1. / (1_MeV), 0;
+  params19 << 0.450536131858825684, -45.6087112426757812, 1.54512977600097656,
+      0.65365976095199585, 5.42995185242034495e-05 * 1. / (1_MeV), 0;
   Covariance covMat19;
-  covMat19 << 0.00722755817696452141, -0.000255548940999269852,
-      -0.000217406702398603241, -3.1716960065804312e-06,
-      -1.22003670918761397e-07 * 1. / (1_MeV), 0, -0.000255548940999269852,
-      0.0352888740599155426, 1.12056165324810929e-05, 0.000387397513496410965,
-      1.44034486642105852e-09 * 1. / (1_MeV), 0, -0.000217406702398603241,
-      1.12056165324810929e-05, 6.66530741000315174e-06, 1.44476099359170098e-07,
-      5.84575834646360909e-09 * 1. / (1_MeV), 0, -3.1716960065804312e-06,
-      0.000387397513496410965, 1.44476099359170098e-07, 4.60058254247996956e-06,
-      2.70756521335290287e-11 * 1. / (1_MeV), 0,
-      -1.22003670918761397e-07 * 1. / (1_MeV),
-      1.44034486642105852e-09 * 1. / (1_MeV),
-      5.84575834646360909e-09 * 1. / (1_MeV),
-      2.70756521335290287e-11 * 1. / (1_MeV),
-      1.47919038129273872e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform19;
-  ActsSymMatrixD<3> rotMat19;
-  rotMat19 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform19.rotate(rotMat19);
-  transform19.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans19 = std::make_shared<const Transform3D>(transform19);
-  std::shared_ptr<PerigeeSurface> perigeeSurface19 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams19 = BoundParameters(tgContext, std::move(covMat19), params19,
-                                       perigeeSurface19);
+  covMat19 << 0.000259126914897933602, -7.71187497722190822e-06,
+      -5.15114709723808123e-06, -2.6619027249675935e-08,
+      -2.6312704155352256e-09 * 1. / (1_MeV), 0, -7.71187497722190822e-06,
+      0.00295044109225273132, 4.46207192501835153e-08, 1.36801867739356403e-05,
+      -6.77873236221157013e-10 * 1. / (1_MeV), 0, -5.15114709723808123e-06,
+      4.46207192501835153e-08, 1.1458803328423528e-07, 1.22672567207018586e-10,
+      8.3325729033356906e-11 * 1. / (1_MeV), 0, -2.6619027249675935e-08,
+      1.36801867739356403e-05, 1.22672567207018586e-10, 8.8454470414944808e-08,
+      -4.19827894841714947e-12 * 1. / (1_MeV), 0,
+      -2.6312704155352256e-09 * 1. / (1_MeV),
+      -6.77873236221157013e-10 * 1. / (1_MeV),
+      8.3325729033356906e-11 * 1. / (1_MeV),
+      -4.19827894841714947e-12 * 1. / (1_MeV),
+      1.43134245775278224e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams19 =
+      BoundParameters(tgContext, std::move(covMat19), params19, perigeeSurface);
   tracks.push_back(boundParams19);
 
   // track 20 :
   BoundVector params20;
-  params20 << -0.050889924168586731, 19.6028633117675781, 0.112749122083187103,
-      2.38145637512207031, -0.000236698266235180199 * 1. / (1_MeV), 0;
+  params20 << 0.473463654518127441, -26.5566444396972656, 2.22220945358276367,
+      2.8751678466796875, -0.000256116356467828155 * 1. / (1_MeV), 0;
   Covariance covMat20;
-  covMat20 << 0.00143691536504775286, 0.000164076889054642412,
-      -3.58648437617112441e-05, 9.51572596730293739e-07,
-      -2.06847797524276209e-08 * 1. / (1_MeV), 0, 0.000164076889054642412,
-      0.0106960544362664223, -3.61365524801671333e-06, 9.12128019022396863e-05,
-      1.63349320460262432e-09 * 1. / (1_MeV), 0, -3.58648437617112441e-05,
-      -3.61365524801671333e-06, 9.44514340517343953e-07,
-      -2.26900632828089059e-08, 8.985070684429297e-10 * 1. / (1_MeV), 0,
-      9.51572596730293739e-07, 9.12128019022396863e-05,
-      -2.26900632828089059e-08, 9.40663255732943071e-07,
-      -7.29312017504296212e-12 * 1. / (1_MeV), 0,
-      -2.06847797524276209e-08 * 1. / (1_MeV),
-      1.63349320460262432e-09 * 1. / (1_MeV),
-      8.985070684429297e-10 * 1. / (1_MeV),
-      -7.29312017504296212e-12 * 1. / (1_MeV),
-      2.3087929137965979e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform20;
-  ActsSymMatrixD<3> rotMat20;
-  rotMat20 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform20.rotate(rotMat20);
-  transform20.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans20 = std::make_shared<const Transform3D>(transform20);
-  std::shared_ptr<PerigeeSurface> perigeeSurface20 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams20 = BoundParameters(tgContext, std::move(covMat20), params20,
-                                       perigeeSurface20);
+  covMat20 << 0.0143999364227056503, -6.2299028153707387e-05,
+      -0.000435219809783413591, 2.17336195005980567e-06,
+      -1.21769702441849882e-07 * 1. / (1_MeV), 0, -6.2299028153707387e-05,
+      0.225834131240844727, -9.51855047040289537e-06, 0.000458192287494221199,
+      1.25566461565313107e-08 * 1. / (1_MeV), 0, -0.000435219809783413591,
+      -9.51855047040289537e-06, 1.33511766762239859e-05,
+      -9.24405891210373471e-08, 6.00420036495892829e-09 * 1. / (1_MeV), 0,
+      2.17336195005980567e-06, 0.000458192287494221199,
+      -9.24405891210373471e-08, 9.43835061661957297e-07,
+      -1.98670297988379238e-12 * 1. / (1_MeV), 0,
+      -1.21769702441849882e-07 * 1. / (1_MeV),
+      1.25566461565313107e-08 * 1. / (1_MeV),
+      6.00420036495892829e-09 * 1. / (1_MeV),
+      -1.98670297988379238e-12 * 1. / (1_MeV),
+      6.28335161678705845e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams20 =
+      BoundParameters(tgContext, std::move(covMat20), params20, perigeeSurface);
   tracks.push_back(boundParams20);
 
   // track 21 :
   BoundVector params21;
-  params21 << 0.340526312589645386, 19.5222663879394531, 1.98806488513946533,
-      0.645573973655700684, -0.000210438229260034859 * 1. / (1_MeV), 0;
+  params21 << 0.474121242761611938, -45.3727645874023438, 1.55173587799072266,
+      0.574172139167785645, 5.4487241868628189e-05 * 1. / (1_MeV), 0;
   Covariance covMat21;
-  covMat21 << 0.00187653978355228901, -4.61886315977834042e-05,
-      -4.50543377001786315e-05, -4.23803726213808519e-07,
-      -2.27506680726447051e-08 * 1. / (1_MeV), 0, -4.61886315977834042e-05,
-      0.00947334989905357361, 1.12025168001414582e-06, 6.5792105051481426e-05,
-      -1.06230443637615531e-09 * 1. / (1_MeV), 0, -4.50543377001786315e-05,
-      1.12025168001414582e-06, 1.15167620151623851e-06, 1.18795575818832697e-08,
-      8.43143312452009429e-10 * 1. / (1_MeV), 0, -4.23803726213808519e-07,
-      6.5792105051481426e-05, 1.18795575818832697e-08, 5.50924369235872291e-07,
-      5.88708293652256259e-12 * 1. / (1_MeV), 0,
-      -2.27506680726447051e-08 * 1. / (1_MeV),
-      -1.06230443637615531e-09 * 1. / (1_MeV),
-      8.43143312452009429e-10 * 1. / (1_MeV),
-      5.88708293652256259e-12 * 1. / (1_MeV),
-      1.54570852645141699e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform21;
-  ActsSymMatrixD<3> rotMat21;
-  rotMat21 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform21.rotate(rotMat21);
-  transform21.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans21 = std::make_shared<const Transform3D>(transform21);
-  std::shared_ptr<PerigeeSurface> perigeeSurface21 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams21 = BoundParameters(tgContext, std::move(covMat21), params21,
-                                       perigeeSurface21);
+  covMat21 << 0.000224435978452675045, -3.34686356158648375e-08,
+      -4.87554553510472616e-06, -1.05072650608508861e-08,
+      -3.01031009155958153e-09 * 1. / (1_MeV), 0, -3.34686356158648375e-08,
+      0.00355649716220796108, -1.23797957582243194e-09, 1.29672827928777902e-05,
+      -5.29747367549304477e-10 * 1. / (1_MeV), 0, -4.87554553510472616e-06,
+      -1.23797957582243194e-09, 1.18275345073470817e-07,
+      1.10832502633235662e-10, 9.64028556852257677e-11 * 1. / (1_MeV), 0,
+      -1.05072650608508861e-08, 1.29672827928777902e-05,
+      1.10832502633235662e-10, 6.4137751110138197e-08,
+      -1.6225318684374243e-12 * 1. / (1_MeV), 0,
+      -3.01031009155958153e-09 * 1. / (1_MeV),
+      -5.29747367549304477e-10 * 1. / (1_MeV),
+      9.64028556852257677e-11 * 1. / (1_MeV),
+      -1.6225318684374243e-12 * 1. / (1_MeV),
+      1.46339776234405416e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams21 =
+      BoundParameters(tgContext, std::move(covMat21), params21, perigeeSurface);
   tracks.push_back(boundParams21);
 
   // track 22 :
   BoundVector params22;
-  params22 << 0.0327057354152202606, 19.7024917602539062, -2.13715505599975586,
-      2.80726861953735352, 0.000263765512499958277 * 1. / (1_MeV), 0;
+  params22 << -1.09075939655303955, -45.9652023315429688, -1.37540817260742188,
+      2.04655265808105469, -3.31696282955817878e-05 * 1. / (1_MeV), 0;
   Covariance covMat22;
-  covMat22 << 0.00759664503857493401, 0.000905364247503756396,
-      -0.000227879179537351814, 1.47085121825187884e-06,
-      -1.05708472073745111e-07 * 1. / (1_MeV), 0, 0.000905364247503756396,
-      0.0961576402187347412, -1.17275682104315631e-05, 0.00028353976847481278,
-      -9.08595344434235293e-09 * 1. / (1_MeV), 0, -0.000227879179537351814,
-      -1.17275682104315631e-05, 7.0192058956308756e-06,
-      -5.73812881555304563e-09, 5.16319886110993577e-09 * 1. / (1_MeV), 0,
-      1.47085121825187884e-06, 0.00028353976847481278, -5.73812881555304563e-09,
-      8.68534641540463781e-07, -1.7137080433623932e-11 * 1. / (1_MeV), 0,
-      -1.05708472073745111e-07 * 1. / (1_MeV),
-      -9.08595344434235293e-09 * 1. / (1_MeV),
-      5.16319886110993577e-09 * 1. / (1_MeV),
-      -1.7137080433623932e-11 * 1. / (1_MeV),
-      6.82771200688492286e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform22;
-  ActsSymMatrixD<3> rotMat22;
-  rotMat22 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform22.rotate(rotMat22);
-  transform22.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans22 = std::make_shared<const Transform3D>(transform22);
-  std::shared_ptr<PerigeeSurface> perigeeSurface22 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams22 = BoundParameters(tgContext, std::move(covMat22), params22,
-                                       perigeeSurface22);
+  covMat22 << 0.000312969175865873694, 0.0001463311972326757,
+      -3.44899335412854335e-06, 1.27787244910060675e-06,
+      -1.09905405688468608e-08 * 1. / (1_MeV), 0, 0.0001463311972326757,
+      0.00594136770814657211, -1.71895848646021814e-06, 4.22735853806673674e-05,
+      -1.192286442570364e-08 * 1. / (1_MeV), 0, -3.44899335412854335e-06,
+      -1.71895848646021814e-06, 4.42678249612526997e-08,
+      -1.47011582918932722e-08, 1.32897993796644671e-10 * 1. / (1_MeV), 0,
+      1.27787244910060675e-06, 4.22735853806673674e-05,
+      -1.47011582918932722e-08, 3.68511109627434053e-07,
+      -1.04379022097924494e-10 * 1. / (1_MeV), 0,
+      -1.09905405688468608e-08 * 1. / (1_MeV),
+      -1.192286442570364e-08 * 1. / (1_MeV),
+      1.32897993796644671e-10 * 1. / (1_MeV),
+      -1.04379022097924494e-10 * 1. / (1_MeV),
+      1.09507943078096526e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams22 =
+      BoundParameters(tgContext, std::move(covMat22), params22, perigeeSurface);
   tracks.push_back(boundParams22);
 
   // track 23 :
   BoundVector params23;
-  params23 << -0.313747167587280273, 19.8418807983398438, 2.22803497314453125,
-      0.69142603874206543, 0.000169251798070035875 * 1. / (1_MeV), 0;
+  params23 << -1.31657886505126953, -44.3285789489746094, -1.36793792247772217,
+      2.08678793907165527, -6.51905575068667531e-05 * 1. / (1_MeV), 0;
   Covariance covMat23;
-  covMat23 << 0.000822073488961905241, -4.22023511849360173e-05,
-      -2.11682852032007045e-05, -1.39809980877076557e-07,
-      -1.13325862651714777e-08 * 1. / (1_MeV), 0, -4.22023511849360173e-05,
-      0.00642389757558703423, 4.73854987704379056e-07, 4.62124676517580748e-05,
-      7.96633147731774745e-10 * 1. / (1_MeV), 0, -2.11682852032007045e-05,
-      4.73854987704379056e-07, 5.80069183797604637e-07, 3.15912432766058085e-11,
-      4.56396742731161166e-10 * 1. / (1_MeV), 0, -1.39809980877076557e-07,
-      4.62124676517580748e-05, 3.15912432766058085e-11, 3.99615089463623008e-07,
-      2.27545298907622666e-12 * 1. / (1_MeV), 0,
-      -1.13325862651714777e-08 * 1. / (1_MeV),
-      7.96633147731774745e-10 * 1. / (1_MeV),
-      4.56396742731161166e-10 * 1. / (1_MeV),
-      2.27545298907622666e-12 * 1. / (1_MeV),
-      9.23549778319987524e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform23;
-  ActsSymMatrixD<3> rotMat23;
-  rotMat23 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform23.rotate(rotMat23);
-  transform23.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans23 = std::make_shared<const Transform3D>(transform23);
-  std::shared_ptr<PerigeeSurface> perigeeSurface23 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams23 = BoundParameters(tgContext, std::move(covMat23), params23,
-                                       perigeeSurface23);
+  covMat23 << 0.000181945419171825051, -2.81234401866508066e-05,
+      -3.22076197235801949e-06, -7.63838237863357019e-08,
+      -3.46247467047687857e-09 * 1. / (1_MeV), 0, -2.81234401866508066e-05,
+      0.0078449668362736702, -1.27915101440830079e-07, 4.12960218865452011e-05,
+      -5.4435441037029841e-09 * 1. / (1_MeV), 0, -3.22076197235801949e-06,
+      -1.27915101440830079e-07, 6.53957670238014543e-08,
+      -1.06815947474639986e-09, 8.7867543161386892e-11 * 1. / (1_MeV), 0,
+      -7.63838237863357019e-08, 4.12960218865452011e-05,
+      -1.06815947474639986e-09, 3.63342195441873628e-07,
+      -5.37524150950671376e-11 * 1. / (1_MeV), 0,
+      -3.46247467047687857e-09 * 1. / (1_MeV),
+      -5.4435441037029841e-09 * 1. / (1_MeV),
+      8.7867543161386892e-11 * 1. / (1_MeV),
+      -5.37524150950671376e-11 * 1. / (1_MeV),
+      1.83543284737464063e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams23 =
+      BoundParameters(tgContext, std::move(covMat23), params23, perigeeSurface);
   tracks.push_back(boundParams23);
 
   // track 24 :
   BoundVector params24;
-  params24 << 0.0601691603660583496, 19.4889583587646484, 1.45675015449523926,
-      1.56046152114868164, -0.000939691497478634119 * 1. / (1_MeV), 0;
+  params24 << 0.468431740999221802, -45.6113662719726562, 1.57319939136505127,
+      0.724432468414306641, -6.46604967187158763e-05 * 1. / (1_MeV), 0;
   Covariance covMat24;
-  covMat24 << 0.00347459153272211552, 2.61288253282652421e-08,
-      -0.000100485766757895184, -1.57776073352115993e-08,
-      -5.9865669012875978e-08 * 1. / (1_MeV), 0, 2.61288253282652421e-08,
-      0.0155909880995750427, 4.31090469568027334e-09, 0.00030456631727040519,
-      -2.26566988417194164e-09 * 1. / (1_MeV), 0, -0.000100485766757895184,
-      4.31090469568027334e-09, 2.96180473924323451e-06, 7.78080017868743252e-10,
-      2.82122625662053921e-09 * 1. / (1_MeV), 0, -1.57776073352115993e-08,
-      0.00030456631727040519, 7.78080017868743252e-10, 7.35272124074981548e-06,
-      -3.83106395644490913e-11 * 1. / (1_MeV), 0,
-      -5.9865669012875978e-08 * 1. / (1_MeV),
-      -2.26566988417194164e-09 * 1. / (1_MeV),
-      2.82122625662053921e-09 * 1. / (1_MeV),
-      -3.83106395644490913e-11 * 1. / (1_MeV),
-      1.06380099174074871e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform24;
-  ActsSymMatrixD<3> rotMat24;
-  rotMat24 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform24.rotate(rotMat24);
-  transform24.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans24 = std::make_shared<const Transform3D>(transform24);
-  std::shared_ptr<PerigeeSurface> perigeeSurface24 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams24 = BoundParameters(tgContext, std::move(covMat24), params24,
-                                       perigeeSurface24);
+  covMat24 << 0.000443243887275457382, -2.3272761085957688e-05,
+      -8.05724456303655931e-06, -1.10478345604928828e-07,
+      -5.12934471198391627e-09 * 1. / (1_MeV), 0, -2.3272761085957688e-05,
+      0.00292888842523097992, 2.09734580782484699e-07, 1.69251524164295596e-05,
+      2.63255285816454836e-10 * 1. / (1_MeV), 0, -8.05724456303655931e-06,
+      2.09734580782484699e-07, 1.72984968571654463e-07, 1.6524169254854016e-09,
+      1.09902161546833325e-10 * 1. / (1_MeV), 0, -1.10478345604928828e-07,
+      1.69251524164295596e-05, 1.6524169254854016e-09, 1.26708812331344234e-07,
+      1.02436393801765789e-12 * 1. / (1_MeV), 0,
+      -5.12934471198391627e-09 * 1. / (1_MeV),
+      2.63255285816454836e-10 * 1. / (1_MeV),
+      1.09902161546833325e-10 * 1. / (1_MeV),
+      1.02436393801765789e-12 * 1. / (1_MeV),
+      1.77089365307331326e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams24 =
+      BoundParameters(tgContext, std::move(covMat24), params24, perigeeSurface);
   tracks.push_back(boundParams24);
 
   // track 25 :
   BoundVector params25;
-  params25 << 0.305262893438339233, 19.6428985595703125, 2.0014500617980957,
-      0.674862563610076904, -0.000269854936050251126 * 1. / (1_MeV), 0;
+  params25 << 0.605970263481140137, -27.2015609741210938, 2.96404910087585449,
+      0.461374938488006592, -0.000201874907361343503 * 1. / (1_MeV), 0;
   Covariance covMat25;
-  covMat25 << 0.00167414336465299129, -1.78847304832933408e-05,
-      -4.55389135089741097e-05, -3.82403117295285017e-07,
-      -2.12364403958921256e-08 * 1. / (1_MeV), 0, -1.78847304832933408e-05,
-      0.0104135861620306969, 6.75815994310390194e-07, 8.49609773572517027e-05,
-      -1.92504072395493255e-10 * 1. / (1_MeV), 0, -4.55389135089741097e-05,
-      6.75815994310390194e-07, 1.29258842207491398e-06, 1.38985937523038846e-08,
-      9.37637080501081717e-10 * 1. / (1_MeV), 0, -3.82403117295285017e-07,
-      8.49609773572517027e-05, 1.38985937523038846e-08, 7.91449053849646589e-07,
-      7.1066766939193851e-12 * 1. / (1_MeV), 0,
-      -2.12364403958921256e-08 * 1. / (1_MeV),
-      -1.92504072395493255e-10 * 1. / (1_MeV),
-      9.37637080501081717e-10 * 1. / (1_MeV),
-      7.1066766939193851e-12 * 1. / (1_MeV),
-      2.08066983781174386e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform25;
-  ActsSymMatrixD<3> rotMat25;
-  rotMat25 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform25.rotate(rotMat25);
-  transform25.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans25 = std::make_shared<const Transform3D>(transform25);
-  std::shared_ptr<PerigeeSurface> perigeeSurface25 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams25 = BoundParameters(tgContext, std::move(covMat25), params25,
-                                       perigeeSurface25);
+  covMat25 << 0.00265368912369012833, -0.000160160863867693455,
+      -7.10252410690768288e-05, -1.03680404805919409e-06,
+      -2.01188254958249733e-08 * 1. / (1_MeV), 0, -0.000160160863867693455,
+      0.0171342100948095322, 3.50132547577921485e-06, 8.76344783019533907e-05,
+      7.09798679472868797e-10 * 1. / (1_MeV), 0, -7.10252410690768288e-05,
+      3.50132547577921485e-06, 1.98413022189924959e-06, 2.72794764037440166e-08,
+      8.99215162966161182e-10 * 1. / (1_MeV), 0, -1.03680404805919409e-06,
+      8.76344783019533907e-05, 2.72794764037440166e-08, 4.75305114377988502e-07,
+      8.86034124151153122e-12 * 1. / (1_MeV), 0,
+      -2.01188254958249733e-08 * 1. / (1_MeV),
+      7.09798679472868797e-10 * 1. / (1_MeV),
+      8.99215162966161182e-10 * 1. / (1_MeV),
+      8.86034124151153122e-12 * 1. / (1_MeV),
+      1.49597105536525277e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams25 =
+      BoundParameters(tgContext, std::move(covMat25), params25, perigeeSurface);
   tracks.push_back(boundParams25);
 
   // track 26 :
   BoundVector params26;
-  params26 << -0.0716414377093315125, 19.4469375610351562, -1.31057024002075195,
-      2.37900662422180176, -0.000480518414406105876 * 1. / (1_MeV), 0;
+  params26 << 0.373259454965591431, -45.9041404724121094, -2.82848834991455078,
+      2.05866789817810059, -0.000124583908473141491 * 1. / (1_MeV), 0;
   Covariance covMat26;
-  covMat26 << 0.00311773899011313915, 0.000216807668024049122,
-      -8.85980764209346383e-05, 2.33675139737157217e-06,
-      -5.69352023227364653e-08 * 1. / (1_MeV), 0, 0.000216807668024049122,
-      0.0251653064042329788, -6.874046489217475e-06, 0.000259795929953506673,
-      1.0275478076867433e-09 * 1. / (1_MeV), 0, -8.85980764209346383e-05,
-      -6.874046489217475e-06, 2.60891670222918037e-06, -7.84173992006491199e-08,
-      2.8010804631721876e-09 * 1. / (1_MeV), 0, 2.33675139737157217e-06,
-      0.000259795929953506673, -7.84173992006491199e-08,
-      2.90308980765985325e-06, -2.89203496927991014e-12 * 1. / (1_MeV), 0,
-      -5.69352023227364653e-08 * 1. / (1_MeV),
-      1.0275478076867433e-09 * 1. / (1_MeV),
-      2.8010804631721876e-09 * 1. / (1_MeV),
-      -2.89203496927991014e-12 * 1. / (1_MeV),
-      7.90091464475395355e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform26;
-  ActsSymMatrixD<3> rotMat26;
-  rotMat26 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform26.rotate(rotMat26);
-  transform26.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans26 = std::make_shared<const Transform3D>(transform26);
-  std::shared_ptr<PerigeeSurface> perigeeSurface26 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams26 = BoundParameters(tgContext, std::move(covMat26), params26,
-                                       perigeeSurface26);
+  covMat26 << 0.000358323537511751056, 5.45377012590961527e-06,
+      -7.43998460263549215e-06, -2.04257445390517592e-08,
+      -2.8271193498608263e-09 * 1. / (1_MeV), 0, 5.45377012590961527e-06,
+      0.00235699070617556572, -1.65012257788975246e-07, 2.44201179406483771e-05,
+      -1.12260566358553804e-09 * 1. / (1_MeV), 0, -7.43998460263549215e-06,
+      -1.65012257788975246e-07, 1.71034542972847703e-07,
+      5.99568256402865656e-10, 9.80197960016773152e-11 * 1. / (1_MeV), 0,
+      -2.04257445390517592e-08, 2.44201179406483771e-05,
+      5.99568256402865656e-10, 4.42280850165843731e-07,
+      -1.97182050693094459e-11 * 1. / (1_MeV), 0,
+      -2.8271193498608263e-09 * 1. / (1_MeV),
+      -1.12260566358553804e-09 * 1. / (1_MeV),
+      9.80197960016773152e-11 * 1. / (1_MeV),
+      -1.97182050693094459e-11 * 1. / (1_MeV),
+      2.83151215148269575e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams26 =
+      BoundParameters(tgContext, std::move(covMat26), params26, perigeeSurface);
   tracks.push_back(boundParams26);
 
   // track 27 :
   BoundVector params27;
-  params27 << 0.0340305417776107788, 19.7064609527587891, 1.96402919292449951,
-      0.62500452995300293, 0.000157972215674817562 * 1. / (1_MeV), 0;
+  params27 << 0.23818458616733551, -43.9735908508300781, 1.15663206577301025,
+      0.325361251831054688, -0.000120135584438685328 * 1. / (1_MeV), 0;
   Covariance covMat27;
-  covMat27 << 0.00115194241516292095, -1.75935599558400332e-05,
-      -2.72476171609115263e-05, -3.19554349594589653e-08,
-      -1.21725335271778638e-08 * 1. / (1_MeV), 0, -1.75935599558400332e-05,
-      0.00663218600675463676, -1.47069503149528377e-08, 4.24403084279258386e-05,
-      -1.17670450049324461e-11 * 1. / (1_MeV), 0, -2.72476171609115263e-05,
-      -1.47069503149528377e-08, 6.9136649472056888e-07, -1.3832287263184986e-09,
-      4.45969786691428052e-10 * 1. / (1_MeV), 0, -3.19554349594589653e-08,
-      4.24403084279258386e-05, -1.3832287263184986e-09, 3.26797248817456421e-07,
-      -3.37620811397436092e-13 * 1. / (1_MeV), 0,
-      -1.21725335271778638e-08 * 1. / (1_MeV),
-      -1.17670450049324461e-11 * 1. / (1_MeV),
-      4.45969786691428052e-10 * 1. / (1_MeV),
-      -3.37620811397436092e-13 * 1. / (1_MeV),
-      7.86358218124449948e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform27;
-  ActsSymMatrixD<3> rotMat27;
-  rotMat27 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform27.rotate(rotMat27);
-  transform27.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans27 = std::make_shared<const Transform3D>(transform27);
-  std::shared_ptr<PerigeeSurface> perigeeSurface27 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams27 = BoundParameters(tgContext, std::move(covMat27), params27,
-                                       perigeeSurface27);
+  covMat27 << 0.00264720292761921883, -0.000279904810298890847,
+      -7.0787471462461463e-05, -6.09630619944338989e-07,
+      -2.72122881545780153e-08 * 1. / (1_MeV), 0, -0.000279904810298890847,
+      0.0381099320948123932, 6.2210670995119084e-06, 0.00010238674474765499,
+      8.91128192470317596e-11 * 1. / (1_MeV), 0, -7.0787471462461463e-05,
+      6.2210670995119084e-06, 1.99035594050656073e-06, 1.5641300493302086e-08,
+      1.26289836850190108e-09 * 1. / (1_MeV), 0, -6.09630619944338989e-07,
+      0.00010238674474765499, 1.5641300493302086e-08, 2.93358084491046611e-07,
+      2.02230046547630554e-12 * 1. / (1_MeV), 0,
+      -2.72122881545780153e-08 * 1. / (1_MeV),
+      8.91128192470317596e-11 * 1. / (1_MeV),
+      1.26289836850190108e-09 * 1. / (1_MeV),
+      2.02230046547630554e-12 * 1. / (1_MeV),
+      1.52509879725037933e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams27 =
+      BoundParameters(tgContext, std::move(covMat27), params27, perigeeSurface);
   tracks.push_back(boundParams27);
 
   // track 28 :
   BoundVector params28;
-  params28 << -0.0371651053428649902, 19.7891578674316406,
-      -0.659238219261169434, 0.274633139371871948,
-      -3.11207440972793847e-05 * 1. / (1_MeV), 0;
+  params28 << 0.379233330488204956, -45.0619316101074219, 1.36501443386077881,
+      0.467382907867431641, 7.43830823921598494e-05 * 1. / (1_MeV), 0;
   Covariance covMat28;
-  covMat28 << 0.00094830815214663744, -0.00019487656314514027,
-      -2.12130854277417798e-05, -2.34663925361313877e-07,
-      -3.03861064262990213e-09 * 1. / (1_MeV), 0, -0.00019487656314514027,
-      0.0170497521758079529, 3.70571285096039324e-06, 2.64888644523930275e-05,
-      2.42556496747356217e-10 * 1. / (1_MeV), 0, -2.12130854277417798e-05,
-      3.70571285096039324e-06, 5.07914478475868236e-07, 4.96919950915106563e-09,
-      1.14830219767461788e-10 * 1. / (1_MeV), 0, -2.34663925361313877e-07,
-      2.64888644523930275e-05, 4.96919950915106563e-09, 4.59249491768787266e-08,
-      2.84459713659211857e-13 * 1. / (1_MeV), 0,
-      -3.03861064262990213e-09 * 1. / (1_MeV),
-      2.42556496747356217e-10 * 1. / (1_MeV),
-      1.14830219767461788e-10 * 1. / (1_MeV),
-      2.84459713659211857e-13 * 1. / (1_MeV),
-      9.65581672777993116e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform28;
-  ActsSymMatrixD<3> rotMat28;
-  rotMat28 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform28.rotate(rotMat28);
-  transform28.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans28 = std::make_shared<const Transform3D>(transform28);
-  std::shared_ptr<PerigeeSurface> perigeeSurface28 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams28 = BoundParameters(tgContext, std::move(covMat28), params28,
-                                       perigeeSurface28);
+  covMat28 << 0.000463021540781483054, -3.19743694997498169e-05,
+      -1.22576460878201678e-05, -1.17553161873688474e-07,
+      -5.1874231027619962e-09 * 1. / (1_MeV), 0, -3.19743694997498169e-05,
+      0.00478032277897000313, 1.17327598364092336e-07, 1.94133319938421418e-05,
+      -2.06704265685090959e-10 * 1. / (1_MeV), 0, -1.22576460878201678e-05,
+      1.17327598364092336e-07, 3.46005350593259209e-07, 1.4500069383794639e-09,
+      2.06696790491209021e-10 * 1. / (1_MeV), 0, -1.17553161873688474e-07,
+      1.94133319938421418e-05, 1.4500069383794639e-09, 9.33096515609577182e-08,
+      1.00703744558876763e-12 * 1. / (1_MeV), 0,
+      -5.1874231027619962e-09 * 1. / (1_MeV),
+      -2.06704265685090959e-10 * 1. / (1_MeV),
+      2.06696790491209021e-10 * 1. / (1_MeV),
+      1.00703744558876763e-12 * 1. / (1_MeV),
+      2.83601007261546911e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams28 =
+      BoundParameters(tgContext, std::move(covMat28), params28, perigeeSurface);
   tracks.push_back(boundParams28);
 
   // track 29 :
   BoundVector params29;
-  params29 << 0.0113061871379613876, 19.7758064270019531, -0.565121948719024658,
-      1.11297404766082764, -0.000380097364541143179 * 1. / (1_MeV), 0;
+  params29 << 0.0437062010169029236, -6.05203485488891602, 0.845894753932952881,
+      2.40220952033996582, -0.00021497465786524117 * 1. / (1_MeV), 0;
   Covariance covMat29;
-  covMat29 << 0.00155933154746890068, -4.97482623935557549e-05,
-      -3.73456424926352755e-05, -4.55759156051640272e-07,
-      -2.07172213465749658e-08 * 1. / (1_MeV), 0, -4.97482623935557549e-05,
-      0.00686531048268079758, 1.31561141444726331e-06, 8.97714266550412308e-05,
-      -1.19474789182683184e-09 * 1. / (1_MeV), 0, -3.73456424926352755e-05,
-      1.31561141444726331e-06, 9.55697146309830714e-07, 1.30428805682263728e-08,
-      7.75026676835572029e-10 * 1. / (1_MeV), 0, -4.55759156051640272e-07,
-      8.97714266550412308e-05, 1.30428805682263728e-08, 1.62136052495043259e-06,
-      -3.68485465951844148e-12 * 1. / (1_MeV), 0,
-      -2.07172213465749658e-08 * 1. / (1_MeV),
-      -1.19474789182683184e-09 * 1. / (1_MeV),
-      7.75026676835572029e-10 * 1. / (1_MeV),
-      -3.68485465951844148e-12 * 1. / (1_MeV),
-      2.15952047910583644e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform29;
-  ActsSymMatrixD<3> rotMat29;
-  rotMat29 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform29.rotate(rotMat29);
-  transform29.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans29 = std::make_shared<const Transform3D>(transform29);
-  std::shared_ptr<PerigeeSurface> perigeeSurface29 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams29 = BoundParameters(tgContext, std::move(covMat29), params29,
-                                       perigeeSurface29);
+  covMat29 << 0.00100414641201496124, 7.52416013682256636e-05,
+      -2.59772254577332751e-05, 3.8490891938040421e-07,
+      -1.6676738431268612e-08 * 1. / (1_MeV), 0, 7.52416013682256636e-05,
+      0.00544706359505653381, -1.72766771292602573e-06, 4.92784133153511604e-05,
+      -1.22367109538203667e-09 * 1. / (1_MeV), 0, -2.59772254577332751e-05,
+      -1.72766771292602573e-06, 7.08758761902572587e-07,
+      -9.85089323790014416e-09, 6.84218014584375542e-10 * 1. / (1_MeV), 0,
+      3.8490891938040421e-07, 4.92784133153511604e-05, -9.85089323790014416e-09,
+      5.590306955127744e-07, -9.11246232266255587e-12 * 1. / (1_MeV), 0,
+      -1.6676738431268612e-08 * 1. / (1_MeV),
+      -1.22367109538203667e-09 * 1. / (1_MeV),
+      6.84218014584375542e-10 * 1. / (1_MeV),
+      -9.11246232266255587e-12 * 1. / (1_MeV),
+      1.55326706358094313e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams29 =
+      BoundParameters(tgContext, std::move(covMat29), params29, perigeeSurface);
   tracks.push_back(boundParams29);
 
   // track 30 :
   BoundVector params30;
-  params30 << -0.000764124910347163677, 19.7925205230712891,
-      -1.60565555095672607, 2.11691427230834961,
-      0.00109597900882363319 * 1. / (1_MeV), 0;
+  params30 << -0.517760396003723145, -46.0633049011230469, -1.40931129455566406,
+      1.87501537799835205, 0.000927834073081612587 * 1. / (1_MeV), 0;
   Covariance covMat30;
-  covMat30 << 0.00818897411227226257, -7.88637168572715077e-05,
-      -0.000237841176207310301, -2.86874654680000338e-06,
-      -1.07533611185096677e-07 * 1. / (1_MeV), 0, -7.88637168572715077e-05,
-      0.0303833372890949249, 6.69007874662318617e-06, 0.000503271982246975501,
-      1.40492310581731278e-09 * 1. / (1_MeV), 0, -0.000237841176207310301,
-      6.69007874662318617e-06, 7.098253263393417e-06, 1.64058162507511388e-07,
-      5.23793435502016417e-09 * 1. / (1_MeV), 0, -2.86874654680000338e-06,
-      0.000503271982246975501, 1.64058162507511388e-07, 9.68445510807214305e-06,
-      4.84013097877190455e-11 * 1. / (1_MeV), 0,
-      -1.07533611185096677e-07 * 1. / (1_MeV),
-      1.40492310581731278e-09 * 1. / (1_MeV),
-      5.23793435502016417e-09 * 1. / (1_MeV),
-      4.84013097877190455e-11 * 1. / (1_MeV),
-      1.75064601704022493e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform30;
-  ActsSymMatrixD<3> rotMat30;
-  rotMat30 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform30.rotate(rotMat30);
-  transform30.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans30 = std::make_shared<const Transform3D>(transform30);
-  std::shared_ptr<PerigeeSurface> perigeeSurface30 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams30 = BoundParameters(tgContext, std::move(covMat30), params30,
-                                       perigeeSurface30);
+  covMat30 << 0.00338696571998298168, 2.2701516820957546e-05,
+      -0.000100746524188053817, -6.39718888889637967e-07,
+      -5.16928846777282941e-08 * 1. / (1_MeV), 0, 2.2701516820957546e-05,
+      0.0142748663201928139, 1.52136563622953833e-07, 0.000252430357142510112,
+      -3.20784296654136601e-10 * 1. / (1_MeV), 0, -0.000100746524188053817,
+      1.52136563622953833e-07, 3.04392483485571574e-06, 3.67106627303256195e-08,
+      2.52688458153465702e-09 * 1. / (1_MeV), 0, -6.39718888889637967e-07,
+      0.000252430357142510112, 3.67106627303256195e-08, 5.46493629371980205e-06,
+      9.90579325614409665e-12 * 1. / (1_MeV), 0,
+      -5.16928846777282941e-08 * 1. / (1_MeV),
+      -3.20784296654136601e-10 * 1. / (1_MeV),
+      2.52688458153465702e-09 * 1. / (1_MeV),
+      9.90579325614409665e-12 * 1. / (1_MeV),
+      9.43339711900748057e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams30 =
+      BoundParameters(tgContext, std::move(covMat30), params30, perigeeSurface);
   tracks.push_back(boundParams30);
 
   // track 31 :
   BoundVector params31;
-  params31 << 0.0434660129249095917, 19.9743804931640625, -1.92152023315429688,
-      1.10322427749633789, -0.00135057768784463406 * 1. / (1_MeV), 0;
+  params31 << -0.525244832038879395, -0.217865616083145142,
+      -0.475070565938949585, 0.477265685796737671,
+      0.000297125487122684717 * 1. / (1_MeV), 0;
   Covariance covMat31;
-  covMat31 << 0.00949090253561735153, -0.000162514116123452891,
-      -0.000277450606342210756, -3.41726209466831981e-06,
-      -1.35977257290003362e-07 * 1. / (1_MeV), 0, -0.000162514116123452891,
-      0.0241005755960941315, 7.44390386227167547e-06, 0.000482722310593120495,
-      -5.01533653096054345e-09 * 1. / (1_MeV), 0, -0.000277450606342210756,
-      7.44390386227167547e-06, 8.34032562124775723e-06, 1.70338602887570872e-07,
-      6.59502382970017033e-09 * 1. / (1_MeV), 0, -3.41726209466831981e-06,
-      0.000482722310593120495, 1.70338602887570872e-07, 1.08669210021616891e-05,
-      -1.30623540733939145e-10 * 1. / (1_MeV), 0,
-      -1.35977257290003362e-07 * 1. / (1_MeV),
-      -5.01533653096054345e-09 * 1. / (1_MeV),
-      6.59502382970017033e-09 * 1. / (1_MeV),
-      -1.30623540733939145e-10 * 1. / (1_MeV),
-      2.33806835003846913e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform31;
-  ActsSymMatrixD<3> rotMat31;
-  rotMat31 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform31.rotate(rotMat31);
-  transform31.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans31 = std::make_shared<const Transform3D>(transform31);
-  std::shared_ptr<PerigeeSurface> perigeeSurface31 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams31 = BoundParameters(tgContext, std::move(covMat31), params31,
-                                       perigeeSurface31);
+  covMat31 << 0.00397888477891683578, -0.000295814951524862792,
+      -0.00011510871599225749, -1.88877208528145442e-07,
+      -3.65170360119058424e-08 * 1. / (1_MeV), 0, -0.000295814951524862792,
+      0.0287617519497871399, 4.36081614729639213e-06, 0.000165308229332130187,
+      2.86168612064016744e-09 * 1. / (1_MeV), 0, -0.00011510871599225749,
+      4.36081614729639213e-06, 3.41281020155292936e-06,
+      -1.47002165497313678e-08, 1.75686917916454533e-09 * 1. / (1_MeV), 0,
+      -1.88877208528145442e-07, 0.000165308229332130187,
+      -1.47002165497313678e-08, 9.93909566204820294e-07,
+      1.22169439162607638e-12 * 1. / (1_MeV), 0,
+      -3.65170360119058424e-08 * 1. / (1_MeV),
+      2.86168612064016744e-09 * 1. / (1_MeV),
+      1.75686917916454533e-09 * 1. / (1_MeV),
+      1.22169439162607638e-12 * 1. / (1_MeV),
+      3.16079003248592727e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams31 =
+      BoundParameters(tgContext, std::move(covMat31), params31, perigeeSurface);
   tracks.push_back(boundParams31);
 
   // track 32 :
   BoundVector params32;
-  params32 << -0.323653548955917358, 23.0863323211669922, -2.04575490951538086,
-      1.19155371189117432, -0.00135404628235846758 * 1. / (1_MeV), 0;
+  params32 << -0.164086505770683289, -37.753753662109375, -1.87344110012054443,
+      2.57577276229858398, 0.000515770167112350464 * 1. / (1_MeV), 0;
   Covariance covMat32;
-  covMat32 << 0.00942049268633127213, -0.000156100331056732402,
-      -0.000267428691337353848, -2.84213758688659959e-06,
-      -1.3715343361864345e-07 * 1. / (1_MeV), 0, -0.000156100331056732402,
-      0.0234745144844055176, 6.9330452366765478e-06, 0.000468627570852257769,
-      4.42012838944869237e-10 * 1. / (1_MeV), 0, -0.000267428691337353848,
-      6.9330452366765478e-06, 7.8662105806870386e-06, 1.40317764457691491e-07,
-      6.38338658586116389e-09 * 1. / (1_MeV), 0, -2.84213758688659959e-06,
-      0.000468627570852257769, 1.40317764457691491e-07, 1.09587390397791751e-05,
-      1.69050142770342731e-12 * 1. / (1_MeV), 0,
-      -1.3715343361864345e-07 * 1. / (1_MeV),
-      4.42012838944869237e-10 * 1. / (1_MeV),
-      6.38338658586116389e-09 * 1. / (1_MeV),
-      1.69050142770342731e-12 * 1. / (1_MeV),
-      2.24243526525391701e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform32;
-  ActsSymMatrixD<3> rotMat32;
-  rotMat32 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform32.rotate(rotMat32);
-  transform32.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans32 = std::make_shared<const Transform3D>(transform32);
-  std::shared_ptr<PerigeeSurface> perigeeSurface32 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams32 = BoundParameters(tgContext, std::move(covMat32), params32,
-                                       perigeeSurface32);
+  covMat32 << 0.00635964749380946159, 4.45514887833019807e-05,
+      -0.000193066686713004587, -9.8075773789463948e-07,
+      -1.543514422213774e-07 * 1. / (1_MeV), 0, 4.45514887833019807e-05,
+      0.0324134901165962219, 3.01616810351035857e-06, 0.000257514567093702538,
+      -4.60722406707723369e-09 * 1. / (1_MeV), 0, -0.000193066686713004587,
+      3.01616810351035857e-06, 5.97237203692202456e-06, 6.40635690248244268e-08,
+      7.82772160913690927e-09 * 1. / (1_MeV), 0, -9.8075773789463948e-07,
+      0.000257514567093702538, 6.40635690248244268e-08, 2.12554232348338701e-06,
+      -2.69885970530160845e-12 * 1. / (1_MeV), 0,
+      -1.543514422213774e-07 * 1. / (1_MeV),
+      -4.60722406707723369e-09 * 1. / (1_MeV),
+      7.82772160913690927e-09 * 1. / (1_MeV),
+      -2.69885970530160845e-12 * 1. / (1_MeV),
+      1.721506964758035e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams32 =
+      BoundParameters(tgContext, std::move(covMat32), params32, perigeeSurface);
   tracks.push_back(boundParams32);
 
   // track 33 :
   BoundVector params33;
-  params33 << 0.0502348393201828003, 19.8225479125976562, 1.2200552225112915,
-      1.19947576522827148, 0.00065168103901669383 * 1. / (1_MeV), 0;
+  params33 << -0.422558963298797607, -25.4688777923583984, -1.69958257675170898,
+      2.64382648468017578, 0.00017704063793644309 * 1. / (1_MeV), 0;
   Covariance covMat33;
-  covMat33 << 0.00330946571193635464, -3.03961755070003361e-05,
-      -8.23355349674717059e-05, 3.61557925205989208e-07,
-      -4.81647993693705346e-08 * 1. / (1_MeV), 0, -3.03961755070003361e-05,
-      0.0121201490983366966, -3.44926830210965382e-08, 0.0001832216673901092,
-      -8.289858737864768e-09 * 1. / (1_MeV), 0, -8.23355349674717059e-05,
-      -3.44926830210965382e-08, 2.16286139220756013e-06,
-      -2.50835114436962174e-08, 1.88343068671924282e-09 * 1. / (1_MeV), 0,
-      3.61557925205989208e-07, 0.0001832216673901092, -2.50835114436962174e-08,
-      3.61402794624154922e-06, -1.38343005917598103e-10 * 1. / (1_MeV), 0,
-      -4.81647993693705346e-08 * 1. / (1_MeV),
-      -8.289858737864768e-09 * 1. / (1_MeV),
-      1.88343068671924282e-09 * 1. / (1_MeV),
-      -1.38343005917598103e-10 * 1. / (1_MeV),
-      5.75411177039519828e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform33;
-  ActsSymMatrixD<3> rotMat33;
-  rotMat33 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform33.rotate(rotMat33);
-  transform33.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans33 = std::make_shared<const Transform3D>(transform33);
-  std::shared_ptr<PerigeeSurface> perigeeSurface33 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams33 = BoundParameters(tgContext, std::move(covMat33), params33,
-                                       perigeeSurface33);
+  covMat33 << 0.0013904899824410677, 0.000162016200161348015,
+      -3.89817331369023135e-05, 4.29909627029974153e-07,
+      -1.45160757016235074e-08 * 1. / (1_MeV), 0, 0.000162016200161348015,
+      0.0123065607622265816, -2.87947509703742562e-06, 6.703852723089744e-05,
+      -8.48754668083118025e-10 * 1. / (1_MeV), 0, -3.89817331369023135e-05,
+      -2.87947509703742562e-06, 1.12921497930074111e-06,
+      -4.83207911132727673e-09, 6.53490602957053302e-10 * 1. / (1_MeV), 0,
+      4.29909627029974153e-07, 6.703852723089744e-05, -4.83207911132727673e-09,
+      3.95028536104291561e-07, 5.22664500397267715e-13 * 1. / (1_MeV), 0,
+      -1.45160757016235074e-08 * 1. / (1_MeV),
+      -8.48754668083118025e-10 * 1. / (1_MeV),
+      6.53490602957053302e-10 * 1. / (1_MeV),
+      5.22664500397267715e-13 * 1. / (1_MeV),
+      1.14117890484544127e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams33 =
+      BoundParameters(tgContext, std::move(covMat33), params33, perigeeSurface);
   tracks.push_back(boundParams33);
 
   // track 34 :
   BoundVector params34;
-  params34 << -0.00679738679900765419, 19.7787380218505859, 0.64978182315826416,
-      1.718436598777771, 0.000399400596506893635 * 1. / (1_MeV), 0;
+  params34 << -0.706149637699127197, -5.55039787292480469, -1.03704202175140381,
+      2.66923093795776367, 0.000632659648545086384 * 1. / (1_MeV), 0;
   Covariance covMat34;
-  covMat34 << 0.0016832397086545825, 3.08902871283228804e-08,
-      -3.9761794373880207e-05, -5.36301231604843024e-08,
-      -1.25551948300567075e-08 * 1. / (1_MeV), 0, 3.08902871283228804e-08,
-      0.0122804483398795128, 1.50321795312578277e-07, 0.000155226454439672071,
-      -3.69637596757974278e-09 * 1. / (1_MeV), 0, -3.9761794373880207e-05,
-      1.50321795312578277e-07, 1.01230580185074359e-06, 3.57209146154241154e-09,
-      5.08893136683866958e-10 * 1. / (1_MeV), 0, -5.36301231604843024e-08,
-      0.000155226454439672071, 3.57209146154241154e-09, 2.92897698273009155e-06,
-      -4.64295001076053898e-11 * 1. / (1_MeV), 0,
-      -1.25551948300567075e-08 * 1. / (1_MeV),
-      -3.69637596757974278e-09 * 1. / (1_MeV),
-      5.08893136683866958e-10 * 1. / (1_MeV),
-      -4.64295001076053898e-11 * 1. / (1_MeV),
-      1.79039612996367836e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform34;
-  ActsSymMatrixD<3> rotMat34;
-  rotMat34 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform34.rotate(rotMat34);
-  transform34.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans34 = std::make_shared<const Transform3D>(transform34);
-  std::shared_ptr<PerigeeSurface> perigeeSurface34 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams34 = BoundParameters(tgContext, std::move(covMat34), params34,
-                                       perigeeSurface34);
+  covMat34 << 0.0149489222094416618, 0.000618369321077981275,
+      -0.000455378611332247401, -2.5954498544077396e-06,
+      -2.91043194495528445e-07 * 1. / (1_MeV), 0, 0.000618369321077981275,
+      0.0851441845297813416, -4.93271553790423069e-06, 0.0005094039417602418,
+      -2.83093285269249633e-08 * 1. / (1_MeV), 0, -0.000455378611332247401,
+      -4.93271553790423069e-06, 1.41044911288190633e-05,
+      1.63956270962265813e-07, 1.48782651378673617e-08 * 1. / (1_MeV), 0,
+      -2.5954498544077396e-06, 0.0005094039417602418, 1.63956270962265813e-07,
+      3.11431858790456317e-06, -8.52575602760203913e-12 * 1. / (1_MeV), 0,
+      -2.91043194495528445e-07 * 1. / (1_MeV),
+      -2.83093285269249633e-08 * 1. / (1_MeV),
+      1.48782651378673617e-08 * 1. / (1_MeV),
+      -8.52575602760203913e-12 * 1. / (1_MeV),
+      2.77564138340125055e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams34 =
+      BoundParameters(tgContext, std::move(covMat34), params34, perigeeSurface);
   tracks.push_back(boundParams34);
 
   // track 35 :
   BoundVector params35;
-  params35 << 0.0805509239435195923, 19.8107032775878906, -0.580723822116851807,
-      1.39042818546295166, -0.000723547651432454586 * 1. / (1_MeV), 0;
+  params35 << 0.66977304220199585, -45.2442741394042969, 1.78884363174438477,
+      0.401856839656829834, 0.000140385964186862111 * 1. / (1_MeV), 0;
   Covariance covMat35;
-  covMat35 << 0.00366608682088553905, -3.07736450112954378e-05,
-      -9.36432680714786278e-05, -4.32691756908737401e-07,
-      -4.03209869361722161e-08 * 1. / (1_MeV), 0, -3.07736450112954378e-05,
-      0.0121293710544705391, 8.84241894101609937e-07, 0.000208273787997539348,
-      -4.72119222103642781e-09 * 1. / (1_MeV), 0, -9.36432680714786278e-05,
-      8.84241894101609937e-07, 2.51136862061684951e-06, 1.65541645067806758e-08,
-      1.643748206415159e-09 * 1. / (1_MeV), 0, -4.32691756908737401e-07,
-      0.000208273787997539348, 1.65541645067806758e-08, 4.73576938020414673e-06,
-      -5.8294474111660837e-11 * 1. / (1_MeV), 0,
-      -4.03209869361722161e-08 * 1. / (1_MeV),
-      -4.72119222103642781e-09 * 1. / (1_MeV),
-      1.643748206415159e-09 * 1. / (1_MeV),
-      -5.8294474111660837e-11 * 1. / (1_MeV),
-      5.46871367634871319e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform35;
-  ActsSymMatrixD<3> rotMat35;
-  rotMat35 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform35.rotate(rotMat35);
-  transform35.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans35 = std::make_shared<const Transform3D>(transform35);
-  std::shared_ptr<PerigeeSurface> perigeeSurface35 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams35 = BoundParameters(tgContext, std::move(covMat35), params35,
-                                       perigeeSurface35);
+  covMat35 << 0.00143626355566084385, -5.35207803621203505e-05,
+      -4.22572311413643752e-05, -3.20053881947622934e-07,
+      -4.44998922265500791e-08 * 1. / (1_MeV), 0, -5.35207803621203505e-05,
+      0.0170358996838331223, -9.72014409846223381e-08, 6.54062168950196484e-05,
+      -5.2860188976227197e-10 * 1. / (1_MeV), 0, -4.22572311413643752e-05,
+      -9.72014409846223381e-08, 1.28950614453060552e-06,
+      4.58471361676392425e-09, 2.07668118549997414e-09 * 1. / (1_MeV), 0,
+      -3.20053881947622934e-07, 6.54062168950196484e-05,
+      4.58471361676392425e-09, 2.676340216112294e-07,
+      8.60400887008258369e-12 * 1. / (1_MeV), 0,
+      -4.44998922265500791e-08 * 1. / (1_MeV),
+      -5.2860188976227197e-10 * 1. / (1_MeV),
+      2.07668118549997414e-09 * 1. / (1_MeV),
+      8.60400887008258369e-12 * 1. / (1_MeV),
+      3.06659697635325301e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams35 =
+      BoundParameters(tgContext, std::move(covMat35), params35, perigeeSurface);
   tracks.push_back(boundParams35);
 
   // track 36 :
   BoundVector params36;
-  params36 << 0.0170946419239044189, 19.5798168182373047, 2.3832242488861084,
-      1.84145426750183105, -0.0016136891208589077 * 1. / (1_MeV), 0;
+  params36 << 0.413177251815795898, -44.2774276733398438, 1.65670633316040039,
+      0.282397657632827759, 0.000249879318289458752 * 1. / (1_MeV), 0;
   Covariance covMat36;
-  covMat36 << 0.0110465008765459061, 0.000132400605777621878,
-      -0.000322046919185156361, 3.95346550436209276e-06,
-      -1.74628381920564644e-07 * 1. / (1_MeV), 0, 0.000132400605777621878,
-      0.0441923066973686218, -7.93550960128202309e-06, 0.000857220862319744157,
-      -3.078313337372045e-09 * 1. / (1_MeV), 0, -0.000322046919185156361,
-      -7.93550960128202309e-06, 9.60366560320835561e-06,
-      -2.05361008506430899e-07, 8.74873834892499733e-09 * 1. / (1_MeV), 0,
-      3.95346550436209276e-06, 0.000857220862319744157,
-      -2.05361008506430899e-07, 1.90070531971286982e-05,
-      -2.62406175067672348e-11 * 1. / (1_MeV), 0,
-      -1.74628381920564644e-07 * 1. / (1_MeV),
-      -3.078313337372045e-09 * 1. / (1_MeV),
-      8.74873834892499733e-09 * 1. / (1_MeV),
-      -2.62406175067672348e-11 * 1. / (1_MeV),
-      3.43723355333835912e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform36;
-  ActsSymMatrixD<3> rotMat36;
-  rotMat36 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform36.rotate(rotMat36);
-  transform36.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans36 = std::make_shared<const Transform3D>(transform36);
-  std::shared_ptr<PerigeeSurface> perigeeSurface36 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams36 = BoundParameters(tgContext, std::move(covMat36), params36,
-                                       perigeeSurface36);
+  covMat36 << 0.0265074372291564941, -0.0048766653213794765,
+      -0.000651586934053853908, -7.10144307243836228e-06,
+      -2.56150394427947489e-07 * 1. / (1_MeV), 0, -0.0048766653213794765,
+      0.360502183437347412, 6.96873463333104177e-05, 0.000667993313991547253,
+      3.22042667667872301e-08 * 1. / (1_MeV), 0, -0.000651586934053853908,
+      6.96873463333104177e-05, 1.68455553648527712e-05, 9.1205915360878042e-08,
+      9.93307233918962727e-09 * 1. / (1_MeV), 0, -7.10144307243836228e-06,
+      0.000667993313991547253, 9.1205915360878042e-08, 1.2959271771251224e-06,
+      5.92305231785808206e-11 * 1. / (1_MeV), 0,
+      -2.56150394427947489e-07 * 1. / (1_MeV),
+      3.22042667667872301e-08 * 1. / (1_MeV),
+      9.93307233918962727e-09 * 1. / (1_MeV),
+      5.92305231785808206e-11 * 1. / (1_MeV),
+      8.93205231999871785e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams36 =
+      BoundParameters(tgContext, std::move(covMat36), params36, perigeeSurface);
   tracks.push_back(boundParams36);
 
   // track 37 :
   BoundVector params37;
-  params37 << 0.0422709546983242035, 19.8179073333740234, -0.292277246713638306,
-      1.55503785610198975, 0.00102485006209462881 * 1. / (1_MeV), 0;
+  params37 << 0.498688608407974243, -24.5804386138916016, 1.52300190925598145,
+      2.57985329627990723, -0.000602965301368385553 * 1. / (1_MeV), 0;
   Covariance covMat37;
-  covMat37 << 0.0048865852877497673, 1.04378577009161224e-06,
-      -0.000137165974802729929, 5.94294471798817227e-08,
-      -7.83582361279693423e-08 * 1. / (1_MeV), 0, 1.04378577009161224e-06,
-      0.0150463152676820755, -1.19789705332920958e-07, 0.000332276925926711661,
-      -1.66883965671842617e-09 * 1. / (1_MeV), 0, -0.000137165974802729929,
-      -1.19789705332920958e-07, 3.95677625419921242e-06,
-      -3.54401466185166792e-09, 3.6142052743200193e-09 * 1. / (1_MeV), 0,
-      5.94294471798817227e-08, 0.000332276925926711661,
-      -3.54401466185166792e-09, 8.53642995934933424e-06,
-      -2.50276756413508482e-11 * 1. / (1_MeV), 0,
-      -7.83582361279693423e-08 * 1. / (1_MeV),
-      -1.66883965671842617e-09 * 1. / (1_MeV),
-      3.6142052743200193e-09 * 1. / (1_MeV),
-      -2.50276756413508482e-11 * 1. / (1_MeV),
-      1.35456687533341835e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform37;
-  ActsSymMatrixD<3> rotMat37;
-  rotMat37 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform37.rotate(rotMat37);
-  transform37.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans37 = std::make_shared<const Transform3D>(transform37);
-  std::shared_ptr<PerigeeSurface> perigeeSurface37 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams37 = BoundParameters(tgContext, std::move(covMat37), params37,
-                                       perigeeSurface37);
+  covMat37 << 0.00829706247895956039, -9.98736632524845883e-05,
+      -0.00024923303906360778, 1.90709718139177409e-06,
+      -7.88885613202604259e-08 * 1. / (1_MeV), 0, -9.98736632524845883e-05,
+      0.0392925664782524109, -2.2279263572824716e-06, 0.000312385200119348323,
+      4.01687609353752231e-09 * 1. / (1_MeV), 0, -0.00024923303906360778,
+      -2.2279263572824716e-06, 7.59069098421605304e-06,
+      -1.01456043862080861e-07, 4.11041373461571408e-09 * 1. / (1_MeV), 0,
+      1.90709718139177409e-06, 0.000312385200119348323,
+      -1.01456043862080861e-07, 2.56480029747763183e-06,
+      -2.55342842411113774e-12 * 1. / (1_MeV), 0,
+      -7.88885613202604259e-08 * 1. / (1_MeV),
+      4.01687609353752231e-09 * 1. / (1_MeV),
+      4.11041373461571408e-09 * 1. / (1_MeV),
+      -2.55342842411113774e-12 * 1. / (1_MeV),
+      9.23438478461768852e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams37 =
+      BoundParameters(tgContext, std::move(covMat37), params37, perigeeSurface);
   tracks.push_back(boundParams37);
 
   // track 38 :
   BoundVector params38;
-  params38 << 0.0177954975515604019, 19.6020870208740234, 2.58446574211120605,
-      2.14368629455566406, 0.00039697738247923553 * 1. / (1_MeV), 0;
+  params38 << 0.136582925915718079, -4.81802463531494141, -2.5786285400390625,
+      2.42307066917419434, 0.000150643929373472929 * 1. / (1_MeV), 0;
   Covariance covMat38;
-  covMat38 << 0.00228728121146559715, -6.6835355739982095e-07,
-      -5.56660017110235266e-05, -2.3660648892322657e-07,
-      -2.44971223220455001e-08 * 1. / (1_MeV), 0, -6.6835355739982095e-07,
-      0.0207388382405042648, 9.95559061054844415e-07, 0.000196521767889107021,
-      -9.37926118817295971e-09 * 1. / (1_MeV), 0, -5.56660017110235266e-05,
-      9.95559061054844415e-07, 1.44270552482339554e-06, 1.62772969664253208e-08,
-      9.58725521674916825e-10 * 1. / (1_MeV), 0, -2.3660648892322657e-07,
-      0.000196521767889107021, 1.62772969664253208e-08, 2.3284674171009101e-06,
-      -3.82657738677909124e-11 * 1. / (1_MeV), 0,
-      -2.44971223220455001e-08 * 1. / (1_MeV),
-      -9.37926118817295971e-09 * 1. / (1_MeV),
-      9.58725521674916825e-10 * 1. / (1_MeV),
-      -3.82657738677909124e-11 * 1. / (1_MeV),
-      2.58620104498508141e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform38;
-  ActsSymMatrixD<3> rotMat38;
-  rotMat38 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform38.rotate(rotMat38);
-  transform38.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans38 = std::make_shared<const Transform3D>(transform38);
-  std::shared_ptr<PerigeeSurface> perigeeSurface38 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams38 = BoundParameters(tgContext, std::move(covMat38), params38,
-                                       perigeeSurface38);
+  covMat38 << 0.000507234770338982344, 2.1336988269281213e-05,
+      -1.35209599010707551e-05, 1.0410117459028839e-07,
+      -9.58138079071134127e-09 * 1. / (1_MeV), 0, 2.1336988269281213e-05,
+      0.00488950824365019798, -3.46387683816058679e-07, 3.650374061662458e-05,
+      -4.69743203747746844e-09 * 1. / (1_MeV), 0, -1.35209599010707551e-05,
+      -3.46387683816058679e-07, 3.77618221136799548e-07,
+      -1.29143148179678594e-09, 3.91247397541968152e-10 * 1. / (1_MeV), 0,
+      1.0410117459028839e-07, 3.650374061662458e-05, -1.29143148179678594e-09,
+      3.27887306639240705e-07, -2.82010017781291024e-11 * 1. / (1_MeV), 0,
+      -9.58138079071134127e-09 * 1. / (1_MeV),
+      -4.69743203747746844e-09 * 1. / (1_MeV),
+      3.91247397541968152e-10 * 1. / (1_MeV),
+      -2.82010017781291024e-11 * 1. / (1_MeV),
+      8.54110965980980907e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams38 =
+      BoundParameters(tgContext, std::move(covMat38), params38, perigeeSurface);
   tracks.push_back(boundParams38);
 
   // track 39 :
   BoundVector params39;
-  params39 << 0.0385684818029403687, 19.5943107604980469, 2.10506224632263184,
-      0.815114736557006836, -0.000444010045612230897 * 1. / (1_MeV), 0;
+  params39 << 0.595804989337921143, -45.6078872680664062, 1.77534663677215576,
+      0.6340065598487854, 0.000248436292167752981 * 1. / (1_MeV), 0;
   Covariance covMat39;
-  covMat39 << 0.00257171900011599064, -8.38966740548737503e-05,
-      -6.9521214623902581e-05, -1.04908792338842471e-06,
-      -4.18962156374891846e-08 * 1. / (1_MeV), 0, -8.38966740548737503e-05,
-      0.012954135425388813, 2.69320887977152083e-06, 0.000145498663861290411,
-      4.42965387319607159e-10 * 1. / (1_MeV), 0, -6.9521214623902581e-05,
-      2.69320887977152083e-06, 1.96165024135552812e-06, 3.61876337782125774e-08,
-      1.88426409286430859e-09 * 1. / (1_MeV), 0, -1.04908792338842471e-06,
-      0.000145498663861290411, 3.61876337782125774e-08, 1.82780070190347033e-06,
-      1.36738002410268621e-11 * 1. / (1_MeV), 0,
-      -4.18962156374891846e-08 * 1. / (1_MeV),
-      4.42965387319607159e-10 * 1. / (1_MeV),
-      1.88426409286430859e-09 * 1. / (1_MeV),
-      1.36738002410268621e-11 * 1. / (1_MeV),
-      5.138850109331905e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform39;
-  ActsSymMatrixD<3> rotMat39;
-  rotMat39 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform39.rotate(rotMat39);
-  transform39.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans39 = std::make_shared<const Transform3D>(transform39);
-  std::shared_ptr<PerigeeSurface> perigeeSurface39 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams39 = BoundParameters(tgContext, std::move(covMat39), params39,
-                                       perigeeSurface39);
+  covMat39 << 0.00133234611712396145, -1.25221378814500536e-05,
+      -3.7965405863780084e-05, -1.36477460859891688e-07,
+      -1.64839701014251819e-08 * 1. / (1_MeV), 0, -1.25221378814500536e-05,
+      0.00918729789555072784, -6.07022323103743485e-07, 7.3648342192368039e-05,
+      -2.81287484533099953e-10 * 1. / (1_MeV), 0, -3.7965405863780084e-05,
+      -6.07022323103743485e-07, 1.113939106289763e-06, -2.37922716438868783e-09,
+      7.63262387403224464e-10 * 1. / (1_MeV), 0, -1.36477460859891688e-07,
+      7.3648342192368039e-05, -2.37922716438868783e-09, 6.66182188524544472e-07,
+      1.08505726379481843e-12 * 1. / (1_MeV), 0,
+      -1.64839701014251819e-08 * 1. / (1_MeV),
+      -2.81287484533099953e-10 * 1. / (1_MeV),
+      7.63262387403224464e-10 * 1. / (1_MeV),
+      1.08505726379481843e-12 * 1. / (1_MeV),
+      1.69044726133771306e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams39 =
+      BoundParameters(tgContext, std::move(covMat39), params39, perigeeSurface);
   tracks.push_back(boundParams39);
 
   // track 40 :
   BoundVector params40;
-  params40 << -0.00192465144209563732, 19.6035480499267578, 1.34771013259887695,
-      1.37635326385498047, 0.000349941314198076725 * 1. / (1_MeV), 0;
+  params40 << 0.536075055599212646, -38.6850814819335938, 2.99125289916992188,
+      1.66691744327545166, -0.000342374085448682308 * 1. / (1_MeV), 0;
   Covariance covMat40;
-  covMat40 << 0.00092626502737402916, -4.70278465200604772e-06,
-      -2.37325601967636777e-05, 2.6469781945744914e-08,
-      -1.04657823685612316e-08 * 1. / (1_MeV), 0, -4.70278465200604772e-06,
-      0.00892938859760761261, -2.32025646493256662e-08, 9.67470782924100583e-05,
-      -1.28292191621348689e-09 * 1. / (1_MeV), 0, -2.37325601967636777e-05,
-      -2.32025646493256662e-08, 6.42108432202803669e-07,
-      -2.41607947044108425e-09, 4.13063041753621467e-10 * 1. / (1_MeV), 0,
-      2.6469781945744914e-08, 9.67470782924100583e-05, -2.41607947044108425e-09,
-      1.45360513670311775e-06, -1.4243170245924231e-11 * 1. / (1_MeV), 0,
-      -1.04657823685612316e-08 * 1. / (1_MeV),
-      -1.28292191621348689e-09 * 1. / (1_MeV),
-      4.13063041753621467e-10 * 1. / (1_MeV),
-      -1.4243170245924231e-11 * 1. / (1_MeV),
-      1.31918035523037602e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform40;
-  ActsSymMatrixD<3> rotMat40;
-  rotMat40 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform40.rotate(rotMat40);
-  transform40.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans40 = std::make_shared<const Transform3D>(transform40);
-  std::shared_ptr<PerigeeSurface> perigeeSurface40 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams40 = BoundParameters(tgContext, std::move(covMat40), params40,
-                                       perigeeSurface40);
+  covMat40 << 0.00137188716325908899, 4.5762325967963918e-06,
+      -2.98856022058698631e-05, -7.0850830871642625e-08,
+      -1.97128857840108858e-08 * 1. / (1_MeV), 0, 4.5762325967963918e-06,
+      0.00638887425884604454, -1.76478143227192729e-07, 8.48770224160730878e-05,
+      -1.45698149891952607e-09 * 1. / (1_MeV), 0, -2.98856022058698631e-05,
+      -1.76478143227192729e-07, 7.38780101983138593e-07,
+      1.85882878019951661e-09, 6.72217443687235182e-10 * 1. / (1_MeV), 0,
+      -7.0850830871642625e-08, 8.48770224160730878e-05, 1.85882878019951661e-09,
+      1.77700985659612343e-06, -2.50821896355620095e-11 * 1. / (1_MeV), 0,
+      -1.97128857840108858e-08 * 1. / (1_MeV),
+      -1.45698149891952607e-09 * 1. / (1_MeV),
+      6.72217443687235182e-10 * 1. / (1_MeV),
+      -2.50821896355620095e-11 * 1. / (1_MeV),
+      1.938233948339807e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams40 =
+      BoundParameters(tgContext, std::move(covMat40), params40, perigeeSurface);
   tracks.push_back(boundParams40);
 
   // track 41 :
   BoundVector params41;
-  params41 << -0.0107631208375096321, 19.6368961334228516, 2.11897373199462891,
-      0.68950730562210083, 0.000500780763104557991 * 1. / (1_MeV), 0;
+  params41 << -0.428327828645706177, -22.2199287414550781, 0.257566869258880615,
+      0.331243127584457397, -0.000147191138239577413 * 1. / (1_MeV), 0;
   Covariance covMat41;
-  covMat41 << 0.0046280999667942524, -8.50248504624665413e-05,
-      -0.000130293248442505169, 3.81786496695030795e-07,
-      -6.22341861031614923e-08 * 1. / (1_MeV), 0, -8.50248504624665413e-05,
-      0.0234155002981424332, -1.02870605123693907e-06, 0.000220617921810967285,
-      1.23912522027359707e-09 * 1. / (1_MeV), 0, -0.000130293248442505169,
-      -1.02870605123693907e-06, 3.78699451175634749e-06,
-      -4.14661454981517284e-08, 2.90208625768643512e-09 * 1. / (1_MeV), 0,
-      3.81786496695030795e-07, 0.000220617921810967285,
-      -4.14661454981517284e-08, 2.34398885368136689e-06,
-      -4.89427060442843687e-12 * 1. / (1_MeV), 0,
-      -6.22341861031614923e-08 * 1. / (1_MeV),
-      1.23912522027359707e-09 * 1. / (1_MeV),
-      2.90208625768643512e-09 * 1. / (1_MeV),
-      -4.89427060442843687e-12 * 1. / (1_MeV),
-      7.00765001582226432e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform41;
-  ActsSymMatrixD<3> rotMat41;
-  rotMat41 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform41.rotate(rotMat41);
-  transform41.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans41 = std::make_shared<const Transform3D>(transform41);
-  std::shared_ptr<PerigeeSurface> perigeeSurface41 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams41 = BoundParameters(tgContext, std::move(covMat41), params41,
-                                       perigeeSurface41);
+  covMat41 << 0.00331501034088432789, -0.000402231679056904746,
+      -9.11024456904284614e-05, -5.25031012402464848e-07,
+      -3.85090693495478952e-08 * 1. / (1_MeV), 0, -0.000402231679056904746,
+      0.0420148223638534546, 1.02748198387320961e-05, 0.000127530944468113439,
+      5.32950012849014807e-10 * 1. / (1_MeV), 0, -9.11024456904284614e-05,
+      1.02748198387320961e-05, 2.61258151112997439e-06, 1.50109511208772318e-08,
+      1.78440131718612806e-09 * 1. / (1_MeV), 0, -5.25031012402464848e-07,
+      0.000127530944468113439, 1.50109511208772318e-08, 4.0045941318567202e-07,
+      -7.30460799902715398e-12 * 1. / (1_MeV), 0,
+      -3.85090693495478952e-08 * 1. / (1_MeV),
+      5.32950012849014807e-10 * 1. / (1_MeV),
+      1.78440131718612806e-09 * 1. / (1_MeV),
+      -7.30460799902715398e-12 * 1. / (1_MeV),
+      2.19001535656238033e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams41 =
+      BoundParameters(tgContext, std::move(covMat41), params41, perigeeSurface);
   tracks.push_back(boundParams41);
 
   // track 42 :
   BoundVector params42;
-  params42 << 0.205963864922523499, 19.6864852905273438, 0.214674949645996094,
-      1.62375175952911377, 0.00149375631008297205 * 1. / (1_MeV), 0;
+  params42 << 0.653292655944824219, -26.9052543640136719, 2.44972705841064453,
+      0.300775229930877686, -0.000126484796055592597 * 1. / (1_MeV), 0;
   Covariance covMat42;
-  covMat42 << 0.00880367588251829147, -1.80866668959131395e-05,
-      -0.000256995153030317573, -5.65481784766486379e-07,
-      -1.21863871949890772e-07 * 1. / (1_MeV), 0, -1.80866668959131395e-05,
-      0.0290389824658632278, 1.0786176979882171e-06, 0.000633662510089911938,
-      1.54534038892845022e-09 * 1. / (1_MeV), 0, -0.000256995153030317573,
-      1.0786176979882171e-06, 7.61563569540157914e-06, 3.04492679504856067e-08,
-      5.93032819545449155e-09 * 1. / (1_MeV), 0, -5.65481784766486379e-07,
-      0.000633662510089911938, 3.04492679504856067e-08, 1.61353309522382915e-05,
-      6.0506063998423997e-11 * 1. / (1_MeV), 0,
-      -1.21863871949890772e-07 * 1. / (1_MeV),
-      1.54534038892845022e-09 * 1. / (1_MeV),
-      5.93032819545449155e-09 * 1. / (1_MeV),
-      6.0506063998423997e-11 * 1. / (1_MeV),
-      2.29128466200378966e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform42;
-  ActsSymMatrixD<3> rotMat42;
-  rotMat42 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform42.rotate(rotMat42);
-  transform42.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans42 = std::make_shared<const Transform3D>(transform42);
-  std::shared_ptr<PerigeeSurface> perigeeSurface42 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams42 = BoundParameters(tgContext, std::move(covMat42), params42,
-                                       perigeeSurface42);
+  covMat42 << 0.00361175555735826492, -0.000145092938087995886,
+      -0.000101172023225305413, -8.20245834004805885e-07,
+      -4.59128816485603501e-08 * 1. / (1_MeV), 0, -0.000145092938087995886,
+      0.0409743189811706543, 3.61313611193146349e-06, 0.000101264190622654121,
+      -2.39200094119792923e-09 * 1. / (1_MeV), 0, -0.000101172023225305413,
+      3.61313611193146349e-06, 2.95380596071481705e-06, 2.49031335596621612e-08,
+      2.08122633356299761e-09 * 1. / (1_MeV), 0, -8.20245834004805885e-07,
+      0.000101264190622654121, 2.49031335596621612e-08, 2.5834717121142603e-07,
+      5.02372502596273887e-12 * 1. / (1_MeV), 0,
+      -4.59128816485603501e-08 * 1. / (1_MeV),
+      -2.39200094119792923e-09 * 1. / (1_MeV),
+      2.08122633356299761e-09 * 1. / (1_MeV),
+      5.02372502596273887e-12 * 1. / (1_MeV),
+      2.24156318506807395e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams42 =
+      BoundParameters(tgContext, std::move(covMat42), params42, perigeeSurface);
   tracks.push_back(boundParams42);
 
   // track 43 :
   BoundVector params43;
-  params43 << 0.147156372666358948, 18.0601425170898438, -1.20425975322723389,
-      2.95313668251037598, 4.38562346971593797e-05 * 1. / (1_MeV), 0;
+  params43 << 0.0787500590085983276, -5.06010723114013672, -2.50320339202880859,
+      2.27719211578369141, -0.000224699513637460768 * 1. / (1_MeV), 0;
   Covariance covMat43;
-  covMat43 << 0.00227970955893397331, 0.00210539922327512233,
-      -6.23386652157084843e-05, 1.62139833390343564e-06,
-      -2.4710662537678873e-08 * 1. / (1_MeV), 0, 0.00210539922327512233,
-      0.0987421199679374695, -4.43239956360880696e-05, 8.53623578378920762e-05,
-      -2.894438650939545e-09 * 1. / (1_MeV), 0, -6.23386652157084843e-05,
-      -4.43239956360880696e-05, 1.78687150764744729e-06,
-      -3.5153983375057298e-08, 1.14365278859331536e-09 * 1. / (1_MeV), 0,
-      1.62139833390343564e-06, 8.53623578378920762e-05, -3.5153983375057298e-08,
-      7.69686039348016493e-08, -2.40912278559178251e-12 * 1. / (1_MeV), 0,
-      -2.4710662537678873e-08 * 1. / (1_MeV),
-      -2.894438650939545e-09 * 1. / (1_MeV),
-      1.14365278859331536e-09 * 1. / (1_MeV),
-      -2.40912278559178251e-12 * 1. / (1_MeV),
-      8.10338168094615341e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform43;
-  ActsSymMatrixD<3> rotMat43;
-  rotMat43 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform43.rotate(rotMat43);
-  transform43.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans43 = std::make_shared<const Transform3D>(transform43);
-  std::shared_ptr<PerigeeSurface> perigeeSurface43 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams43 = BoundParameters(tgContext, std::move(covMat43), params43,
-                                       perigeeSurface43);
+  covMat43 << 0.000872635049745440483, 2.94171319120868002e-05,
+      -2.12370270488864835e-05, 2.61547510497884302e-07,
+      -1.68371736189228777e-08 * 1. / (1_MeV), 0, 2.94171319120868002e-05,
+      0.00385157112032175064, -8.95594258975597383e-07, 3.97548389387994175e-05,
+      -6.99780771762925697e-09 * 1. / (1_MeV), 0, -2.12370270488864835e-05,
+      -8.95594258975597383e-07, 5.52114101992629003e-07,
+      -8.06623935930032111e-09, 6.36599567289482473e-10 * 1. / (1_MeV), 0,
+      2.61547510497884302e-07, 3.97548389387994175e-05,
+      -8.06623935930032111e-09, 5.23487074133299757e-07,
+      -6.36775855132313344e-11 * 1. / (1_MeV), 0,
+      -1.68371736189228777e-08 * 1. / (1_MeV),
+      -6.99780771762925697e-09 * 1. / (1_MeV),
+      6.36599567289482473e-10 * 1. / (1_MeV),
+      -6.36775855132313344e-11 * 1. / (1_MeV),
+      1.53753346859852869e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams43 =
+      BoundParameters(tgContext, std::move(covMat43), params43, perigeeSurface);
   tracks.push_back(boundParams43);
 
   // track 44 :
   BoundVector params44;
-  params44 << -0.0293732546269893646, 19.8860263824462891, 1.95824682712554932,
-      0.870327293872833252, 0.000651221722364425659 * 1. / (1_MeV), 0;
+  params44 << -0.667890667915344238, -26.4306564331054688,
+      -0.519191086292266846, 1.6297152042388916,
+      0.000324116728734225035 * 1. / (1_MeV), 0;
   Covariance covMat44;
-  covMat44 << 0.00386394886299967766, 6.41084427899122564e-05,
-      -0.000111475937760659882, 1.88781955782771875e-06,
-      -8.13503642219718733e-08 * 1. / (1_MeV), 0, 6.41084427899122564e-05,
-      0.0216643344610929489, -4.27457576030063133e-06, 0.000299667220913072709,
-      1.00583188544233463e-10 * 1. / (1_MeV), 0, -0.000111475937760659882,
-      -4.27457576030063133e-06, 3.30510965795838274e-06,
-      -9.27711560515876557e-08, 4.0446540731261482e-09 * 1. / (1_MeV), 0,
-      1.88781955782771875e-06, 0.000299667220913072709,
-      -9.27711560515876557e-08, 4.72439432996907271e-06,
-      -4.51255450632084092e-11 * 1. / (1_MeV), 0,
-      -8.13503642219718733e-08 * 1. / (1_MeV),
-      1.00583188544233463e-10 * 1. / (1_MeV),
-      4.0446540731261482e-09 * 1. / (1_MeV),
-      -4.51255450632084092e-11 * 1. / (1_MeV),
-      1.23205209923149539e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform44;
-  ActsSymMatrixD<3> rotMat44;
-  rotMat44 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform44.rotate(rotMat44);
-  transform44.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans44 = std::make_shared<const Transform3D>(transform44);
-  std::shared_ptr<PerigeeSurface> perigeeSurface44 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams44 = BoundParameters(tgContext, std::move(covMat44), params44,
-                                       perigeeSurface44);
+  covMat44 << 0.00108695926610380411, 7.82180373432526278e-06,
+      -2.48846267524919409e-05, -9.69900814831316844e-08,
+      -1.40750276354789122e-08 * 1. / (1_MeV), 0, 7.82180373432526278e-06,
+      0.00617291871458292007, -1.81813433580045645e-07, 7.85765795126072551e-05,
+      -3.23756334365082546e-09 * 1. / (1_MeV), 0, -2.48846267524919409e-05,
+      -1.81813433580045645e-07, 6.10426923230988905e-07,
+      1.84604413254372613e-09, 4.89069275340707137e-10 * 1. / (1_MeV), 0,
+      -9.69900814831316844e-08, 7.85765795126072551e-05,
+      1.84604413254372613e-09, 1.63906986472284188e-06,
+      -5.57887414635642927e-11 * 1. / (1_MeV), 0,
+      -1.40750276354789122e-08 * 1. / (1_MeV),
+      -3.23756334365082546e-09 * 1. / (1_MeV),
+      4.89069275340707137e-10 * 1. / (1_MeV),
+      -5.57887414635642927e-11 * 1. / (1_MeV),
+      1.4045833940379282e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams44 =
+      BoundParameters(tgContext, std::move(covMat44), params44, perigeeSurface);
   tracks.push_back(boundParams44);
 
   // track 45 :
   BoundVector params45;
-  params45 << -0.00822580046951770782, 19.7521209716796875,
-      -1.34217584133148193, 1.31352841854095459,
-      -0.00102247926406562328 * 1. / (1_MeV), 0;
+  params45 << -0.476996541023254395, -10.2552490234375, -1.7952648401260376,
+      2.92429637908935547, -0.000136506365379318595 * 1. / (1_MeV), 0;
   Covariance covMat45;
-  covMat45 << 0.00437659770250320435, -7.97783766085815948e-05,
-      -0.00012776433189490825, -9.58273275448513196e-07,
-      -5.94526727131795577e-08 * 1. / (1_MeV), 0, -7.97783766085815948e-05,
-      0.0161803290247917175, 2.97524849199130738e-06, 0.000292265113374019965,
-      2.18355646012064316e-10 * 1. / (1_MeV), 0, -0.00012776433189490825,
-      2.97524849199130738e-06, 3.82176176572102122e-06, 4.43621833298063989e-08,
-      2.82001283990720967e-09 * 1. / (1_MeV), 0, -9.58273275448513196e-07,
-      0.000292265113374019965, 4.43621833298063989e-08, 6.61718468109029345e-06,
-      2.39856062071632866e-11 * 1. / (1_MeV), 0,
-      -5.94526727131795577e-08 * 1. / (1_MeV),
-      2.18355646012064316e-10 * 1. / (1_MeV),
-      2.82001283990720967e-09 * 1. / (1_MeV),
-      2.39856062071632866e-11 * 1. / (1_MeV),
-      1.06083510031940165e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform45;
-  ActsSymMatrixD<3> rotMat45;
-  rotMat45 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform45.rotate(rotMat45);
-  transform45.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans45 = std::make_shared<const Transform3D>(transform45);
-  std::shared_ptr<PerigeeSurface> perigeeSurface45 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams45 = BoundParameters(tgContext, std::move(covMat45), params45,
-                                       perigeeSurface45);
+  covMat45 << 0.00768429320305585861, 0.00109988557537010995,
+      -0.000231500581337145973, 9.1348816939045401e-07,
+      -5.63601372249975442e-08 * 1. / (1_MeV), 0, 0.00109988557537010995,
+      0.189449697732925415, -3.59507566995492182e-05, 0.000252646856270792965,
+      -5.46718705987526794e-09 * 1. / (1_MeV), 0, -0.000231500581337145973,
+      -3.59507566995492182e-05, 7.09176856616977602e-06,
+      -3.28587508657521865e-08, 2.79242397856570532e-09 * 1. / (1_MeV), 0,
+      9.1348816939045401e-07, 0.000252646856270792965, -3.28587508657521865e-08,
+      3.43827053939094185e-07, -6.9029270759318352e-13 * 1. / (1_MeV), 0,
+      -5.63601372249975442e-08 * 1. / (1_MeV),
+      -5.46718705987526794e-09 * 1. / (1_MeV),
+      2.79242397856570532e-09 * 1. / (1_MeV),
+      -6.9029270759318352e-13 * 1. / (1_MeV),
+      2.4027510883706249e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams45 =
+      BoundParameters(tgContext, std::move(covMat45), params45, perigeeSurface);
   tracks.push_back(boundParams45);
 
   // track 46 :
   BoundVector params46;
-  params46 << -0.00361508713103830814, 19.4546413421630859,
-      -1.30042552947998047, 1.05093002319335938,
-      -0.00133425544481724501 * 1. / (1_MeV), 0;
+  params46 << -0.42024993896484375, -23.2919502258300781, -1.68882715702056885,
+      2.90132379531860352, 5.77600185351911932e-05 * 1. / (1_MeV), 0;
   Covariance covMat46;
-  covMat46 << 0.00941458996385335922, -0.000284834152470895207,
-      -0.000280442622898071389, -5.80468009022971626e-06,
-      -1.41275786371003149e-07 * 1. / (1_MeV), 0, -0.000284834152470895207,
-      0.0502648279070854187, 1.53948871197303823e-05, 0.000823507242403401945,
-      -2.66165681844982257e-09 * 1. / (1_MeV), 0, -0.000280442622898071389,
-      1.53948871197303823e-05, 8.5132569438428618e-06, 2.95341827559094638e-07,
-      6.98672628255231531e-09 * 1. / (1_MeV), 0, -5.80468009022971626e-06,
-      0.000823507242403401945, 2.95341827559094638e-07, 1.44839359563775361e-05,
-      -4.21371554939487073e-11 * 1. / (1_MeV), 0,
-      -1.41275786371003149e-07 * 1. / (1_MeV),
-      -2.66165681844982257e-09 * 1. / (1_MeV),
-      6.98672628255231531e-09 * 1. / (1_MeV),
-      -4.21371554939487073e-11 * 1. / (1_MeV),
-      2.45891834671496667e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform46;
-  ActsSymMatrixD<3> rotMat46;
-  rotMat46 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform46.rotate(rotMat46);
-  transform46.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans46 = std::make_shared<const Transform3D>(transform46);
-  std::shared_ptr<PerigeeSurface> perigeeSurface46 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams46 = BoundParameters(tgContext, std::move(covMat46), params46,
-                                       perigeeSurface46);
+  covMat46 << 0.00207295711152255535, 0.000908217743513093658,
+      -5.86378931102357517e-05, 1.21430336966273425e-06,
+      -1.06873090546652326e-08 * 1. / (1_MeV), 0, 0.000908217743513093658,
+      0.0524019971489906311, -2.13007825335927641e-05, 7.23961054167061288e-05,
+      -9.20706515105713893e-10 * 1. / (1_MeV), 0, -5.86378931102357517e-05,
+      -2.13007825335927641e-05, 1.70187172443547752e-06,
+      -2.99895102076280531e-08, 4.8877497815574335e-10 * 1. / (1_MeV), 0,
+      1.21430336966273425e-06, 7.23961054167061288e-05,
+      -2.99895102076280531e-08, 1.06208936756502226e-07,
+      5.48951242834580673e-13 * 1. / (1_MeV), 0,
+      -1.06873090546652326e-08 * 1. / (1_MeV),
+      -9.20706515105713893e-10 * 1. / (1_MeV),
+      4.8877497815574335e-10 * 1. / (1_MeV),
+      5.48951242834580673e-13 * 1. / (1_MeV),
+      4.31213008009190268e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams46 =
+      BoundParameters(tgContext, std::move(covMat46), params46, perigeeSurface);
   tracks.push_back(boundParams46);
 
   // track 47 :
   BoundVector params47;
-  params47 << -0.0598590485751628876, 19.6531963348388672, 2.72643232345581055,
-      1.30785942077636719, -0.000780149712227284908 * 1. / (1_MeV), 0;
+  params47 << 0.099998176097869873, -28.7298069000244141, -2.47280740737915039,
+      0.362899661064147949, 0.000242739581153728068 * 1. / (1_MeV), 0;
   Covariance covMat47;
-  covMat47 << 0.0032495234627276659, -4.04264250143772372e-05,
-      -9.30744349600882211e-05, -5.0226893263358181e-07,
-      -1.01375149269318418e-07 * 1. / (1_MeV), 0, -4.04264250143772372e-05,
-      0.0112805059179663658, 1.30282082485754631e-06, 0.000209029656597159029,
-      -7.2365790516280225e-09 * 1. / (1_MeV), 0, -9.30744349600882211e-05,
-      1.30282082485754631e-06, 2.75341517408378422e-06, 2.1800386214469216e-08,
-      4.40769477853404022e-09 * 1. / (1_MeV), 0, -5.0226893263358181e-07,
-      0.000209029656597159029, 2.1800386214469216e-08, 4.8472306843905244e-06,
-      -9.06260666641051782e-11 * 1. / (1_MeV), 0,
-      -1.01375149269318418e-07 * 1. / (1_MeV),
-      -7.2365790516280225e-09 * 1. / (1_MeV),
-      4.40769477853404022e-09 * 1. / (1_MeV),
-      -9.06260666641051782e-11 * 1. / (1_MeV),
-      1.457364923185267e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform47;
-  ActsSymMatrixD<3> rotMat47;
-  rotMat47 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform47.rotate(rotMat47);
-  transform47.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans47 = std::make_shared<const Transform3D>(transform47);
-  std::shared_ptr<PerigeeSurface> perigeeSurface47 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams47 = BoundParameters(tgContext, std::move(covMat47), params47,
-                                       perigeeSurface47);
+  covMat47 << 0.0060739489272236824, -0.000228269915109891231,
+      -0.000175137091140785308, -2.85641093745946927e-07,
+      -9.02268162913695653e-08 * 1. / (1_MeV), 0, -0.000228269915109891231,
+      0.0536332316696643829, 6.97667401826663415e-07, 0.000189819333742468862,
+      1.50668591753161066e-09 * 1. / (1_MeV), 0, -0.000175137091140785308,
+      6.97667401826663415e-07, 5.22334448760375381e-06,
+      -9.75788662698204661e-09, 4.53229459790751107e-09 * 1. / (1_MeV), 0,
+      -2.85641093745946927e-07, 0.000189819333742468862,
+      -9.75788662698204661e-09, 6.91088189341826364e-07,
+      3.54234059812463208e-12 * 1. / (1_MeV), 0,
+      -9.02268162913695653e-08 * 1. / (1_MeV),
+      1.50668591753161066e-09 * 1. / (1_MeV),
+      4.53229459790751107e-09 * 1. / (1_MeV),
+      3.54234059812463208e-12 * 1. / (1_MeV),
+      6.56103088525483713e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams47 =
+      BoundParameters(tgContext, std::move(covMat47), params47, perigeeSurface);
   tracks.push_back(boundParams47);
 
   // track 48 :
   BoundVector params48;
-  params48 << 0.0583043769001960754, 19.7832298278808594, -3.05185866355895996,
-      2.35133123397827148, 0.000652144546620547771 * 1. / (1_MeV), 0;
+  params48 << -0.638817727565765381, -46.7263984680175781,
+      -0.0762649774551391602, 2.44958138465881348,
+      0.00033917097607627511 * 1. / (1_MeV), 0;
   Covariance covMat48;
-  covMat48 << 0.00455570640042424202, 2.27770645100975327e-05,
-      -0.000134378354520968727, -9.98581163169078598e-07,
-      -9.40610633214604794e-08 * 1. / (1_MeV), 0, 2.27770645100975327e-05,
-      0.0258676018565893173, 3.21967957682574985e-06, 0.000300520679336246791,
-      -1.35927009544720559e-09 * 1. / (1_MeV), 0, -0.000134378354520968727,
-      3.21967957682574985e-06, 4.06873823521891609e-06, 7.29906365483080491e-08,
-      4.4846939744143286e-09 * 1. / (1_MeV), 0, -9.98581163169078598e-07,
-      0.000300520679336246791, 7.29906365483080491e-08, 3.90696686736191623e-06,
-      4.80210416302676692e-12 * 1. / (1_MeV), 0,
-      -9.40610633214604794e-08 * 1. / (1_MeV),
-      -1.35927009544720559e-09 * 1. / (1_MeV),
-      4.4846939744143286e-09 * 1. / (1_MeV),
-      4.80210416302676692e-12 * 1. / (1_MeV),
-      1.25072396883751935e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform48;
-  ActsSymMatrixD<3> rotMat48;
-  rotMat48 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform48.rotate(rotMat48);
-  transform48.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans48 = std::make_shared<const Transform3D>(transform48);
-  std::shared_ptr<PerigeeSurface> perigeeSurface48 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams48 = BoundParameters(tgContext, std::move(covMat48), params48,
-                                       perigeeSurface48);
+  covMat48 << 0.00275217113085091114, 0.00021318761584315771,
+      -7.17503295784262051e-05, 5.19027545172934056e-07,
+      -3.27445192482216638e-08 * 1. / (1_MeV), 0, 0.00021318761584315771,
+      0.0129677252843976021, -3.76428307295029104e-06, 0.000116100785357966014,
+      -3.04730203134838935e-09 * 1. / (1_MeV), 0, -7.17503295784262051e-05,
+      -3.76428307295029104e-06, 1.9585518202802632e-06, 1.06617289122836538e-09,
+      1.3563696615201376e-09 * 1. / (1_MeV), 0, 5.19027545172934056e-07,
+      0.000116100785357966014, 1.06617289122836538e-09, 1.19973151413432788e-06,
+      -2.78975801873471684e-12 * 1. / (1_MeV), 0,
+      -3.27445192482216638e-08 * 1. / (1_MeV),
+      -3.04730203134838935e-09 * 1. / (1_MeV),
+      1.3563696615201376e-09 * 1. / (1_MeV),
+      -2.78975801873471684e-12 * 1. / (1_MeV),
+      2.97016820860473985e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams48 =
+      BoundParameters(tgContext, std::move(covMat48), params48, perigeeSurface);
   tracks.push_back(boundParams48);
 
   // track 49 :
   BoundVector params49;
-  params49 << 0.0794872790575027466, 19.6530551910400391, -0.165329158306121826,
-      0.773633182048797607, 0.000477823166875168681 * 1. / (1_MeV), 0;
+  params49 << -0.64014434814453125, -46.3312034606933594, -1.05530393123626709,
+      1.65516412258148193, 6.55830517644062638e-05 * 1. / (1_MeV), 0;
   Covariance covMat49;
-  covMat49 << 0.00381630496121942997, -8.74287441500089918e-05,
-      -0.000100106500619540973, -8.38715409757558135e-08,
-      -6.2290859493643327e-08 * 1. / (1_MeV), 0, -8.74287441500089918e-05,
-      0.0162235908210277557, 2.22223959083791618e-08, 0.000172105791708528197,
-      1.96493926730074329e-10 * 1. / (1_MeV), 0, -0.000100106500619540973,
-      2.22223959083791618e-08, 2.75529328064294532e-06,
-      -2.06184740167500454e-08, 2.69172215410859302e-09 * 1. / (1_MeV), 0,
-      -8.38715409757558135e-08, 0.000172105791708528197,
-      -2.06184740167500454e-08, 2.09498148251441307e-06,
-      8.40879734889098381e-12 * 1. / (1_MeV), 0,
-      -6.2290859493643327e-08 * 1. / (1_MeV),
-      1.96493926730074329e-10 * 1. / (1_MeV),
-      2.69172215410859302e-09 * 1. / (1_MeV),
-      8.40879734889098381e-12 * 1. / (1_MeV),
-      6.77461420295344396e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform49;
-  ActsSymMatrixD<3> rotMat49;
-  rotMat49 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform49.rotate(rotMat49);
-  transform49.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans49 = std::make_shared<const Transform3D>(transform49);
-  std::shared_ptr<PerigeeSurface> perigeeSurface49 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams49 = BoundParameters(tgContext, std::move(covMat49), params49,
-                                       perigeeSurface49);
+  covMat49 << 0.00014873131294734776, -3.25668154925161195e-06,
+      -2.57186509895848779e-06, 1.03651221484145729e-07,
+      -4.02098191895756443e-09 * 1. / (1_MeV), 0, -3.25668154925161195e-06,
+      0.00208531459793448448, -3.00105708930370322e-08, 2.31327739872350428e-05,
+      -3.79285333931827184e-10 * 1. / (1_MeV), 0, -2.57186509895848779e-06,
+      -3.00105708930370322e-08, 5.21384144747116807e-08,
+      -1.13043687468235159e-09, 8.74314611771519845e-11 * 1. / (1_MeV), 0,
+      1.03651221484145729e-07, 2.31327739872350428e-05,
+      -1.13043687468235159e-09, 4.8820493248058483e-07,
+      -9.77849218642090565e-12 * 1. / (1_MeV), 0,
+      -4.02098191895756443e-09 * 1. / (1_MeV),
+      -3.79285333931827184e-10 * 1. / (1_MeV),
+      8.74314611771519845e-11 * 1. / (1_MeV),
+      -9.77849218642090565e-12 * 1. / (1_MeV),
+      1.17200834540837073e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams49 =
+      BoundParameters(tgContext, std::move(covMat49), params49, perigeeSurface);
   tracks.push_back(boundParams49);
 
   // track 50 :
   BoundVector params50;
-  params50 << 0.00257234717719256878, 19.729034423828125, -2.48443388938903809,
-      2.36831569671630859, 0.000639270059764385223 * 1. / (1_MeV), 0;
+  params50 << 0.679204404354095459, -23.8228569030761719, 2.55430388450622559,
+      0.620291829109191895, -0.000398631149437278509 * 1. / (1_MeV), 0;
   Covariance covMat50;
-  covMat50 << 0.00514977378770709038, 1.5274217220811411e-06,
-      -0.000146212466763405544, -7.3820246046654258e-07,
-      -9.37751309006686478e-08 * 1. / (1_MeV), 0, 1.5274217220811411e-06,
-      0.0244287420064210892, 3.30349992626133354e-06, 0.000276546223727476613,
-      -7.14985035003895647e-10 * 1. / (1_MeV), 0, -0.000146212466763405544,
-      3.30349992626133354e-06, 4.3204604480706621e-06, 5.8973252791929605e-08,
-      4.5218636718828268e-09 * 1. / (1_MeV), 0, -7.3820246046654258e-07,
-      0.000276546223727476613, 5.8973252791929605e-08, 3.42068551617558114e-06,
-      -2.22231801612401744e-12 * 1. / (1_MeV), 0,
-      -9.37751309006686478e-08 * 1. / (1_MeV),
-      -7.14985035003895647e-10 * 1. / (1_MeV),
-      4.5218636718828268e-09 * 1. / (1_MeV),
-      -2.22231801612401744e-12 * 1. / (1_MeV),
-      1.24709936821787437e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform50;
-  ActsSymMatrixD<3> rotMat50;
-  rotMat50 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform50.rotate(rotMat50);
-  transform50.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans50 = std::make_shared<const Transform3D>(transform50);
-  std::shared_ptr<PerigeeSurface> perigeeSurface50 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams50 = BoundParameters(tgContext, std::move(covMat50), params50,
-                                       perigeeSurface50);
+  covMat50 << 0.00396185368299484253, -0.000125750330223895206,
+      -0.000109741625616368232, -1.77279611732068793e-06,
+      -4.59372500797877474e-08 * 1. / (1_MeV), 0, -0.000125750330223895206,
+      0.016484508290886879, 3.18639890004686668e-06, 0.000143314523991435627,
+      -9.97977172285195535e-10 * 1. / (1_MeV), 0, -0.000109741625616368232,
+      3.18639890004686668e-06, 3.15156694341567345e-06, 5.29784994588306965e-08,
+      2.0784715645265731e-09 * 1. / (1_MeV), 0, -1.77279611732068793e-06,
+      0.000143314523991435627, 5.29784994588306965e-08, 1.32396576191240456e-06,
+      7.96588919931270625e-12 * 1. / (1_MeV), 0,
+      -4.59372500797877474e-08 * 1. / (1_MeV),
+      -9.97977172285195535e-10 * 1. / (1_MeV),
+      2.0784715645265731e-09 * 1. / (1_MeV),
+      7.96588919931270625e-12 * 1. / (1_MeV),
+      4.46022628552977807e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams50 =
+      BoundParameters(tgContext, std::move(covMat50), params50, perigeeSurface);
   tracks.push_back(boundParams50);
 
   // track 51 :
   BoundVector params51;
-  params51 << 0.00432245805859565735, 19.7588119506835938, 2.78170585632324219,
-      1.317923903465271, 0.000862165645230561495 * 1. / (1_MeV), 0;
+  params51 << 0.0953129231929779053, -6.67084884643554688, 0.758422255516052246,
+      2.50242829322814941, 0.000553281046450138092 * 1. / (1_MeV), 0;
   Covariance covMat51;
-  covMat51 << 0.00373272784054279327, -3.13153124378761361e-05,
-      -0.000104918640992595442, 7.88207645809147621e-08,
-      -5.3073184749102294e-08 * 1. / (1_MeV), 0, -3.13153124378761361e-05,
-      0.014620266854763031, 4.37770160231162941e-09, 0.000248047817836983295,
-      -1.07342837668986752e-09 * 1. / (1_MeV), 0, -0.000104918640992595442,
-      4.37770160231162941e-09, 3.04561854136409238e-06,
-      -1.80148965656686955e-08, 2.31705476916370874e-09 * 1. / (1_MeV), 0,
-      7.88207645809147621e-08, 0.000248047817836983295,
-      -1.80148965656686955e-08, 5.14808971274760552e-06,
-      -2.17782802728119955e-11 * 1. / (1_MeV), 0,
-      -5.3073184749102294e-08 * 1. / (1_MeV),
-      -1.07342837668986752e-09 * 1. / (1_MeV),
-      2.31705476916370874e-09 * 1. / (1_MeV),
-      -2.17782802728119955e-11 * 1. / (1_MeV),
-      7.92517093617384205e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform51;
-  ActsSymMatrixD<3> rotMat51;
-  rotMat51 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform51.rotate(rotMat51);
-  transform51.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans51 = std::make_shared<const Transform3D>(transform51);
-  std::shared_ptr<PerigeeSurface> perigeeSurface51 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams51 = BoundParameters(tgContext, std::move(covMat51), params51,
-                                       perigeeSurface51);
+  covMat51 << 0.00646894052624702454, 0.00018205583963275726,
+      -0.000184070642760310164, 4.01968699095653562e-07,
+      -7.26072619004993246e-08 * 1. / (1_MeV), 0, 0.00018205583963275726,
+      0.0242310706526041031, -2.67127070573839354e-07, 0.000235120330855929796,
+      -1.69241003100018407e-09 * 1. / (1_MeV), 0, -0.000184070642760310164,
+      -2.67127070573839354e-07, 5.39285929335164838e-06,
+      2.94062803351906824e-08, 3.36582393282827341e-09 * 1. / (1_MeV), 0,
+      4.01968699095653562e-07, 0.000235120330855929796, 2.94062803351906824e-08,
+      2.3894551759440219e-06, -7.96709832496419101e-12 * 1. / (1_MeV), 0,
+      -7.26072619004993246e-08 * 1. / (1_MeV),
+      -1.69241003100018407e-09 * 1. / (1_MeV),
+      3.36582393282827341e-09 * 1. / (1_MeV),
+      -7.96709832496419101e-12 * 1. / (1_MeV),
+      7.49710918346302435e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams51 =
+      BoundParameters(tgContext, std::move(covMat51), params51, perigeeSurface);
   tracks.push_back(boundParams51);
 
   // track 52 :
   BoundVector params52;
-  params52 << -0.0435933880507946014, 19.7911624908447266, 3.11164975166320801,
-      2.34090805053710938, -0.000378097058273851871 * 1. / (1_MeV), 0;
+  params52 << 0.596444904804229736, -46.791473388671875, 2.81760692596435547,
+      0.466173619031906128, -4.01311117457225919e-05 * 1. / (1_MeV), 0;
   Covariance covMat52;
-  covMat52 << 0.00186390290036797523, 8.51901326696253696e-05,
-      -5.26206213063089263e-05, 7.5721243893402984e-07,
-      -3.6471728778736459e-08 * 1. / (1_MeV), 0, 8.51901326696253696e-05,
-      0.0111065087839961052, -2.43677190069158359e-06, 0.00011281071944759972,
-      -1.62019250256225185e-09 * 1. / (1_MeV), 0, -5.26206213063089263e-05,
-      -2.43677190069158359e-06, 1.54202029989392031e-06,
-      -2.53458777355814022e-08, 1.63474855631190684e-09 * 1. / (1_MeV), 0,
-      7.5721243893402984e-07, 0.00011281071944759972, -2.53458777355814022e-08,
-      1.39124506404186832e-06, -1.08965746715162531e-11 * 1. / (1_MeV), 0,
-      -3.6471728778736459e-08 * 1. / (1_MeV),
-      -1.62019250256225185e-09 * 1. / (1_MeV),
-      1.63474855631190684e-09 * 1. / (1_MeV),
-      -1.08965746715162531e-11 * 1. / (1_MeV),
-      4.23658642889623849e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform52;
-  ActsSymMatrixD<3> rotMat52;
-  rotMat52 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform52.rotate(rotMat52);
-  transform52.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans52 = std::make_shared<const Transform3D>(transform52);
-  std::shared_ptr<PerigeeSurface> perigeeSurface52 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams52 = BoundParameters(tgContext, std::move(covMat52), params52,
-                                       perigeeSurface52);
+  covMat52 << 0.000178020185558125377, -1.20741123187898347e-05,
+      -4.47439657042341053e-06, -5.00683209793379036e-08,
+      -1.74763438138931432e-09 * 1. / (1_MeV), 0, -1.20741123187898347e-05,
+      0.00217202818021178246, 1.64534794833318549e-08, 7.73194260617184203e-06,
+      1.58039148376204822e-10 * 1. / (1_MeV), 0, -4.47439657042341053e-06,
+      1.64534794833318549e-08, 1.25094288705440704e-07, 9.26271094478818689e-10,
+      6.72005839541690491e-11 * 1. / (1_MeV), 0, -5.00683209793379036e-08,
+      7.73194260617184203e-06, 9.26271094478818689e-10, 3.52726665653335658e-08,
+      6.38826446714830372e-13 * 1. / (1_MeV), 0,
+      -1.74763438138931432e-09 * 1. / (1_MeV),
+      1.58039148376204822e-10 * 1. / (1_MeV),
+      6.72005839541690491e-11 * 1. / (1_MeV),
+      6.38826446714830372e-13 * 1. / (1_MeV),
+      8.76188607345368409e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams52 =
+      BoundParameters(tgContext, std::move(covMat52), params52, perigeeSurface);
   tracks.push_back(boundParams52);
 
   // track 53 :
   BoundVector params53;
-  params53 << -0.0815948843955993652, 19.7372093200683594, -1.84946024417877197,
-      1.14923441410064697, 0.000601470586843788624 * 1. / (1_MeV), 0;
+  params53 << -0.509457647800445557, -6.32682275772094727, -1.33872759342193604,
+      0.491079181432723999, 0.00053247174946591258 * 1. / (1_MeV), 0;
   Covariance covMat53;
-  covMat53 << 0.00196050899103283882, -1.67352628138899218e-05,
-      -5.56634758072358207e-05, 3.7875159202534098e-07,
-      -3.03494187297867561e-08 * 1. / (1_MeV), 0, -1.67352628138899218e-05,
-      0.0112847397103905678, -1.93632011387631403e-07, 0.000171461400770045192,
-      -2.16268131821945559e-09 * 1. / (1_MeV), 0, -5.56634758072358207e-05,
-      -1.93632011387631403e-07, 1.63677134423778625e-06,
-      -2.31373868535455102e-08, 1.4041644457469446e-09 * 1. / (1_MeV), 0,
-      3.7875159202534098e-07, 0.000171461400770045192, -2.31373868535455102e-08,
-      3.31649607687722892e-06, -5.16496243030849994e-11 * 1. / (1_MeV), 0,
-      -3.03494187297867561e-08 * 1. / (1_MeV),
-      -2.16268131821945559e-09 * 1. / (1_MeV),
-      1.4041644457469446e-09 * 1. / (1_MeV),
-      -5.16496243030849994e-11 * 1. / (1_MeV),
-      4.88036555612580969e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform53;
-  ActsSymMatrixD<3> rotMat53;
-  rotMat53 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform53.rotate(rotMat53);
-  transform53.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans53 = std::make_shared<const Transform3D>(transform53);
-  std::shared_ptr<PerigeeSurface> perigeeSurface53 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams53 = BoundParameters(tgContext, std::move(covMat53), params53,
-                                       perigeeSurface53);
+  covMat53 << 0.0100084031000733376, -0.000479280897979647135,
+      -0.000299479223647432344, 6.22369951852639685e-07,
+      -1.22423028040487334e-07 * 1. / (1_MeV), 0, -0.000479280897979647135,
+      0.0567438751459121704, 4.44730771047373873e-06, 0.000355637421562457208,
+      9.09945816895274824e-09 * 1. / (1_MeV), 0, -0.000299479223647432344,
+      4.44730771047373873e-06, 9.10697599465493113e-06,
+      -7.71163662653393619e-08, 5.96647706005148785e-09 * 1. / (1_MeV), 0,
+      6.22369951852639685e-07, 0.000355637421562457208,
+      -7.71163662653393619e-08, 2.29044917432474904e-06,
+      5.6513620234422192e-12 * 1. / (1_MeV), 0,
+      -1.22423028040487334e-07 * 1. / (1_MeV),
+      9.09945816895274824e-09 * 1. / (1_MeV),
+      5.96647706005148785e-09 * 1. / (1_MeV),
+      5.6513620234422192e-12 * 1. / (1_MeV),
+      1.10141243347960938e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams53 =
+      BoundParameters(tgContext, std::move(covMat53), params53, perigeeSurface);
   tracks.push_back(boundParams53);
 
   // track 54 :
   BoundVector params54;
-  params54 << -0.177310273051261902, 19.6348361968994141, -1.05560946464538574,
-      2.24611258506774902, -0.000753726519178599119 * 1. / (1_MeV), 0;
+  params54 << 0.0559646449983119965, -27.9413089752197266, -2.75167965888977051,
+      0.386726617813110352, -0.000363107450539246202 * 1. / (1_MeV), 0;
   Covariance covMat54;
-  covMat54 << 0.00495443679392337799, 0.000157203730621089283,
-      -0.000141684325914573155, 2.30922207144066844e-06,
-      -7.94592181976909059e-08 * 1. / (1_MeV), 0, 0.000157203730621089283,
-      0.0229040328413248062, -6.34654599119513331e-06, 0.000306214725126755156,
-      -1.2839975429398817e-09 * 1. / (1_MeV), 0, -0.000141684325914573155,
-      -6.34654599119513331e-06, 4.18058425566414371e-06,
-      -9.91975383724877058e-08, 3.78214495931995838e-09 * 1. / (1_MeV), 0,
-      2.30922207144066844e-06, 0.000306214725126755156,
-      -9.91975383724877058e-08, 4.69660699309315532e-06,
-      -2.63341946589812984e-11 * 1. / (1_MeV), 0,
-      -7.94592181976909059e-08 * 1. / (1_MeV),
-      -1.2839975429398817e-09 * 1. / (1_MeV),
-      3.78214495931995838e-09 * 1. / (1_MeV),
-      -2.63341946589812984e-11 * 1. / (1_MeV),
-      1.1374100272742993e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform54;
-  ActsSymMatrixD<3> rotMat54;
-  rotMat54 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform54.rotate(rotMat54);
-  transform54.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans54 = std::make_shared<const Transform3D>(transform54);
-  std::shared_ptr<PerigeeSurface> perigeeSurface54 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams54 = BoundParameters(tgContext, std::move(covMat54), params54,
-                                       perigeeSurface54);
+  covMat54 << 0.00913079828023910522, -0.000177719306007508867,
+      -0.000277420127510917254, -1.59392792391846542e-06,
+      -1.63671693721281069e-07 * 1. / (1_MeV), 0, -0.000177719306007508867,
+      0.0778327509760856628, 1.14397241749803718e-05, 0.00031574579409467628,
+      -2.24438577982619877e-09 * 1. / (1_MeV), 0, -0.000277420127510917254,
+      1.14397241749803718e-05, 8.58535440784180537e-06, 7.52518631694262801e-08,
+      8.36903947194818426e-09 * 1. / (1_MeV), 0, -1.59392792391846542e-06,
+      0.00031574579409467628, 7.52518631694262801e-08, 1.31181081997056026e-06,
+      6.22930295116186707e-12 * 1. / (1_MeV), 0,
+      -1.63671693721281069e-07 * 1. / (1_MeV),
+      -2.24438577982619877e-09 * 1. / (1_MeV),
+      8.36903947194818426e-09 * 1. / (1_MeV),
+      6.22930295116186707e-12 * 1. / (1_MeV),
+      1.3151608968531292e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams54 =
+      BoundParameters(tgContext, std::move(covMat54), params54, perigeeSurface);
   tracks.push_back(boundParams54);
 
   // track 55 :
   BoundVector params55;
-  params55 << 0.0785293355584144592, 19.6328811645507812, 2.59513092041015625,
-      2.38374710083007812, -0.000732663145754486322 * 1. / (1_MeV), 0;
+  params55 << 0.313830852508544922, -0.35525098443031311, -2.79895758628845215,
+      2.27995705604553223, 0.000609797949437052011 * 1. / (1_MeV), 0;
   Covariance covMat55;
-  covMat55 << 0.00641396967694163322, 0.000246878889801438277,
-      -0.000189181604721914515, 3.34410570581822042e-06,
-      -2.14548746767764377e-07 * 1. / (1_MeV), 0, 0.000246878889801438277,
-      0.0336174145340919495, -1.03550476761815197e-05, 0.000399278313453293142,
-      -2.56304746534435936e-09 * 1. / (1_MeV), 0, -0.000189181604721914515,
-      -1.03550476761815197e-05, 5.75400417801574804e-06,
-      -1.44846765580733777e-07, 1.06792194541960512e-08 * 1. / (1_MeV), 0,
-      3.34410570581822042e-06, 0.000399278313453293142,
-      -1.44846765580733777e-07, 5.08104403706965968e-06,
-      -7.68042699731362161e-11 * 1. / (1_MeV), 0,
-      -2.14548746767764377e-07 * 1. / (1_MeV),
-      -2.56304746534435936e-09 * 1. / (1_MeV),
-      1.06792194541960512e-08 * 1. / (1_MeV),
-      -7.68042699731362161e-11 * 1. / (1_MeV),
-      2.95886121159938398e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform55;
-  ActsSymMatrixD<3> rotMat55;
-  rotMat55 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform55.rotate(rotMat55);
-  transform55.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans55 = std::make_shared<const Transform3D>(transform55);
-  std::shared_ptr<PerigeeSurface> perigeeSurface55 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams55 = BoundParameters(tgContext, std::move(covMat55), params55,
-                                       perigeeSurface55);
+  covMat55 << 0.0030504278838634491, -3.81297205072847354e-05,
+      -9.09237206775645104e-05, -8.09544327444282553e-07,
+      -5.66159970214913546e-08 * 1. / (1_MeV), 0, -3.81297205072847354e-05,
+      0.0142782162874937057, 2.63776141900322284e-06, 0.00018603481737948765,
+      1.51670403755547486e-09 * 1. / (1_MeV), 0, -9.09237206775645104e-05,
+      2.63776141900322284e-06, 2.75821184914093465e-06, 4.54309779123903346e-08,
+      2.79668441371068291e-09 * 1. / (1_MeV), 0, -8.09544327444282553e-07,
+      0.00018603481737948765, 4.54309779123903346e-08, 2.758416712822509e-06,
+      4.93865123861046129e-11 * 1. / (1_MeV), 0,
+      -5.66159970214913546e-08 * 1. / (1_MeV),
+      1.51670403755547486e-09 * 1. / (1_MeV),
+      2.79668441371068291e-09 * 1. / (1_MeV),
+      4.93865123861046129e-11 * 1. / (1_MeV),
+      8.41345951241301293e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams55 =
+      BoundParameters(tgContext, std::move(covMat55), params55, perigeeSurface);
   tracks.push_back(boundParams55);
 
   // track 56 :
   BoundVector params56;
-  params56 << 0.0173604916781187057, 19.5246124267578125, -2.51582574844360352,
-      0.414047539234161377, -0.00071090972051024437 * 1. / (1_MeV), 0;
+  params56 << 0.155255094170570374, 5.48450565338134766, -2.57013368606567383,
+      2.0009157657623291, -0.00166504201479256153 * 1. / (1_MeV), 0;
   Covariance covMat56;
-  covMat56 << 0.0283498577773571014, -0.000298887250477381634,
-      -0.000882125049864636171, -6.77869111648309038e-06,
-      -5.9098209889401522e-07 * 1. / (1_MeV), 0, -0.000298887250477381634,
-      0.192199692130088806, 4.3839556454493579e-05, 0.000923672206091380129,
-      -1.8091079261186684e-08 * 1. / (1_MeV), 0, -0.000882125049864636171,
-      4.3839556454493579e-05, 2.79919677268480882e-05, 3.80641892247414598e-07,
-      3.08266368106537475e-08 * 1. / (1_MeV), 0, -6.77869111648309038e-06,
-      0.000923672206091380129, 3.80641892247414598e-07, 4.52563699582242407e-06,
-      3.57023520457822254e-12 * 1. / (1_MeV), 0,
-      -5.9098209889401522e-07 * 1. / (1_MeV),
-      -1.8091079261186684e-08 * 1. / (1_MeV),
-      3.08266368106537475e-08 * 1. / (1_MeV),
-      3.57023520457822254e-12 * 1. / (1_MeV),
-      5.16008458184558094e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform56;
-  ActsSymMatrixD<3> rotMat56;
-  rotMat56 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform56.rotate(rotMat56);
-  transform56.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans56 = std::make_shared<const Transform3D>(transform56);
-  std::shared_ptr<PerigeeSurface> perigeeSurface56 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams56 = BoundParameters(tgContext, std::move(covMat56), params56,
-                                       perigeeSurface56);
+  covMat56 << 0.0131199266761541367, 0.000131623878451009752,
+      -0.000394009320893070269, 6.03472828037634446e-06,
+      -2.10906706685497427e-07 * 1. / (1_MeV), 0, 0.000131623878451009752,
+      0.0316174179315567017, -9.5725861230159473e-06, 0.000710392294531094187,
+      9.45078749853857351e-09 * 1. / (1_MeV), 0, -0.000394009320893070269,
+      -9.5725861230159473e-06, 1.19737778732087463e-05,
+      -3.15962032494940612e-07, 1.01155494796444282e-08 * 1. / (1_MeV), 0,
+      6.03472828037634446e-06, 0.000710392294531094187,
+      -3.15962032494940612e-07, 1.67491944011999294e-05,
+      1.71955939069872652e-10 * 1. / (1_MeV), 0,
+      -2.10906706685497427e-07 * 1. / (1_MeV),
+      9.45078749853857351e-09 * 1. / (1_MeV),
+      1.01155494796444282e-08 * 1. / (1_MeV),
+      1.71955939069872652e-10 * 1. / (1_MeV),
+      3.56558282899044343e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams56 =
+      BoundParameters(tgContext, std::move(covMat56), params56, perigeeSurface);
   tracks.push_back(boundParams56);
 
   // track 57 :
   BoundVector params57;
-  params57 << -0.112078636884689331, 19.7138767242431641, -1.84679484367370605,
-      0.794435799121856689, -0.00114586413837969303 * 1. / (1_MeV), 0;
+  params57 << 0.246611848473548889, -26.5061550140380859, -2.83754277229309082,
+      1.51932394504547119, 0.00129061494953930378 * 1. / (1_MeV), 0;
   Covariance covMat57;
-  covMat57 << 0.0125628607347607613, -0.00042401806910040711,
-      -0.000382159145328276348, -7.02945588660621349e-06,
-      -2.92791162690266574e-07 * 1. / (1_MeV), 0, -0.00042401806910040711,
-      0.0519770048558712006, 2.22396418071489764e-05, 0.000696764565518564701,
-      2.67979975211747671e-10 * 1. / (1_MeV), 0, -0.000382159145328276348,
-      2.22396418071489764e-05, 1.18492389447055757e-05, 3.53736964679786492e-07,
-      1.47490199626806416e-08 * 1. / (1_MeV), 0, -7.02945588660621349e-06,
-      0.000696764565518564701, 3.53736964679786492e-07, 9.91684009932214394e-06,
-      3.12549388487418662e-11 * 1. / (1_MeV), 0,
-      -2.92791162690266574e-07 * 1. / (1_MeV),
-      2.67979975211747671e-10 * 1. / (1_MeV),
-      1.47490199626806416e-08 * 1. / (1_MeV),
-      3.12549388487418662e-11 * 1. / (1_MeV),
-      4.27830326721334586e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform57;
-  ActsSymMatrixD<3> rotMat57;
-  rotMat57 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform57.rotate(rotMat57);
-  transform57.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans57 = std::make_shared<const Transform3D>(transform57);
-  std::shared_ptr<PerigeeSurface> perigeeSurface57 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams57 = BoundParameters(tgContext, std::move(covMat57), params57,
-                                       perigeeSurface57);
+  covMat57 << 0.00866833329200744629, 3.01401983869387291e-06,
+      -0.000239535524096211392, 2.72296952977166461e-07,
+      -1.26333629804036578e-07 * 1. / (1_MeV), 0, 3.01401983869387291e-06,
+      0.0214755143970251083, -5.52645836342027297e-07, 0.000483994911188721929,
+      -2.39220428270368834e-09 * 1. / (1_MeV), 0, -0.000239535524096211392,
+      -5.52645836342027297e-07, 6.85501072439365089e-06,
+      -1.80955198945319287e-08, 5.68860497435955863e-09 * 1. / (1_MeV), 0,
+      2.72296952977166461e-07, 0.000483994911188721929,
+      -1.80955198945319287e-08, 1.2657999832299538e-05,
+      -4.49134917661611488e-11 * 1. / (1_MeV), 0,
+      -1.26333629804036578e-07 * 1. / (1_MeV),
+      -2.39220428270368834e-09 * 1. / (1_MeV),
+      5.68860497435955863e-09 * 1. / (1_MeV),
+      -4.49134917661611488e-11 * 1. / (1_MeV),
+      2.06098235699947452e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams57 =
+      BoundParameters(tgContext, std::move(covMat57), params57, perigeeSurface);
   tracks.push_back(boundParams57);
 
   // track 58 :
   BoundVector params58;
-  params58 << -0.0965623259544372559, 19.6627426147460938, -1.23312962055206299,
-      0.805159807205200195, -0.000906686065718531609 * 1. / (1_MeV), 0;
+  params58 << 0.753639280796051025, -6.00856494903564453, 2.30286669731140137,
+      0.268404930830001831, 0.000222592061618342996 * 1. / (1_MeV), 0;
   Covariance covMat58;
-  covMat58 << 0.00830374658107757568, -0.000373302939962240744,
-      -0.000247266029281000856, -5.00495608162803572e-06,
-      -2.0945470573896415e-07 * 1. / (1_MeV), 0, -0.000373302939962240744,
-      0.0380906462669372559, 1.53532999294112871e-05, 0.000496518269343126733,
-      5.03471984032882939e-09 * 1. / (1_MeV), 0, -0.000247266029281000856,
-      1.53532999294112871e-05, 7.52212054067058489e-06, 2.17835177699819493e-07,
-      9.95587606736010666e-09 * 1. / (1_MeV), 0, -5.00495608162803572e-06,
-      0.000496518269343126733, 2.17835177699819493e-07, 6.91647301209741272e-06,
-      8.81431839589435575e-11 * 1. / (1_MeV), 0,
-      -2.0945470573896415e-07 * 1. / (1_MeV),
-      5.03471984032882939e-09 * 1. / (1_MeV),
-      9.95587606736010666e-09 * 1. / (1_MeV),
-      8.81431839589435575e-11 * 1. / (1_MeV),
-      2.77544126570106187e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform58;
-  ActsSymMatrixD<3> rotMat58;
-  rotMat58 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform58.rotate(rotMat58);
-  transform58.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans58 = std::make_shared<const Transform3D>(transform58);
-  std::shared_ptr<PerigeeSurface> perigeeSurface58 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams58 = BoundParameters(tgContext, std::move(covMat58), params58,
-                                       perigeeSurface58);
+  covMat58 << 0.0102735972031950951, 0.000561483560818463708,
+      -0.00031188075048945189, 2.28136549511333255e-07,
+      -1.11255212859507957e-07 * 1. / (1_MeV), 0, 0.000561483560818463708,
+      0.171909451484680176, -3.10575259235835638e-05, 0.000346326413890911768,
+      -1.04190472154705827e-08 * 1. / (1_MeV), 0, -0.00031188075048945189,
+      -3.10575259235835638e-05, 9.61947171163046733e-06,
+      -3.25676596064154555e-08, 5.32616098447415082e-09 * 1. / (1_MeV), 0,
+      2.28136549511333255e-07, 0.000346326413890911768,
+      -3.25676596064154555e-08, 7.13259510121133644e-07,
+      1.99585598211435834e-12 * 1. / (1_MeV), 0,
+      -1.11255212859507957e-07 * 1. / (1_MeV),
+      -1.04190472154705827e-08 * 1. / (1_MeV),
+      5.32616098447415082e-09 * 1. / (1_MeV),
+      1.99585598211435834e-12 * 1. / (1_MeV),
+      5.44141676162013255e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams58 =
+      BoundParameters(tgContext, std::move(covMat58), params58, perigeeSurface);
   tracks.push_back(boundParams58);
 
   // track 59 :
   BoundVector params59;
-  params59 << -0.0626908987760543823, 19.7716445922851562, -2.40555191040039062,
-      2.8678133487701416, -0.000198848822037689388 * 1. / (1_MeV), 0;
+  params59 << -0.740706324577331543, -26.4523181915283203, -0.33198884129524231,
+      1.24688541889190674, 0.00112402497325092554 * 1. / (1_MeV), 0;
   Covariance covMat59;
-  covMat59 << 0.00839335378259420395, 0.000910603415829014081,
-      -0.00025100860818204118, 1.87096007159414942e-06,
-      -9.31870020461924718e-08 * 1. / (1_MeV), 0, 0.000910603415829014081,
-      0.129513055086135864, -2.86761617086296627e-05, 0.000273189216280241291,
-      -4.74956078553265506e-09 * 1. / (1_MeV), 0, -0.00025100860818204118,
-      -2.86761617086296627e-05, 7.71244413044769317e-06,
-      -6.31332272284558137e-08, 4.62778036643537694e-09 * 1. / (1_MeV), 0,
-      1.87096007159414942e-06, 0.000273189216280241291,
-      -6.31332272284558137e-08, 5.91468733546207659e-07,
-      -9.64516546051573345e-12 * 1. / (1_MeV), 0,
-      -9.31870020461924718e-08 * 1. / (1_MeV),
-      -4.74956078553265506e-09 * 1. / (1_MeV),
-      4.62778036643537694e-09 * 1. / (1_MeV),
-      -9.64516546051573345e-12 * 1. / (1_MeV),
-      5.01616283232753091e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform59;
-  ActsSymMatrixD<3> rotMat59;
-  rotMat59 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform59.rotate(rotMat59);
-  transform59.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans59 = std::make_shared<const Transform3D>(transform59);
-  std::shared_ptr<PerigeeSurface> perigeeSurface59 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams59 = BoundParameters(tgContext, std::move(covMat59), params59,
-                                       perigeeSurface59);
+  covMat59 << 0.00939919613301753998, -0.000330953811817127669,
+      -0.000243319623521406008, -1.98870275046275838e-06,
+      -1.10875607601281475e-07 * 1. / (1_MeV), 0, -0.000330953811817127669,
+      0.0170400068163871765, 5.20070220108950583e-06, 0.000343470715600280925,
+      2.37905357060564215e-09 * 1. / (1_MeV), 0, -0.000243319623521406008,
+      5.20070220108950583e-06, 6.58395856589777395e-06,
+      -4.89928191758482858e-09, 4.48106445691990887e-09 * 1. / (1_MeV), 0,
+      -1.98870275046275838e-06, 0.000343470715600280925,
+      -4.89928191758482858e-09, 7.88109264249214903e-06,
+      1.57469333177652749e-11 * 1. / (1_MeV), 0,
+      -1.10875607601281475e-07 * 1. / (1_MeV),
+      2.37905357060564215e-09 * 1. / (1_MeV),
+      4.48106445691990887e-09 * 1. / (1_MeV),
+      1.57469333177652749e-11 * 1. / (1_MeV),
+      1.41142181275810685e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams59 =
+      BoundParameters(tgContext, std::move(covMat59), params59, perigeeSurface);
   tracks.push_back(boundParams59);
 
   // track 60 :
   BoundVector params60;
-  params60 << -0.0142064439132809639, 19.7910060882568359, 0.168578088283538818,
-      0.479709357023239136, -0.000404727092245593667 * 1. / (1_MeV), 0;
+  params60 << 0.404530495405197144, -45.1964073181152344, 1.50114703178405762,
+      0.477049559354782104, 0.000178427377250045538 * 1. / (1_MeV), 0;
   Covariance covMat60;
-  covMat60 << 0.00775946257635951042, -0.000358691551729211646,
-      -0.000217197427685534829, -2.56510932869304508e-06,
-      -7.90923951223065759e-08 * 1. / (1_MeV), 0, -0.000358691551729211646,
-      0.052836686372756958, 1.3965907239243096e-05, 0.000293662591417361029,
-      3.13017533889238816e-10 * 1. / (1_MeV), 0, -0.000217197427685534829,
-      1.3965907239243096e-05, 6.26508744971943088e-06, 9.72321745154080499e-08,
-      3.84228193539540777e-09 * 1. / (1_MeV), 0, -2.56510932869304508e-06,
-      0.000293662591417361029, 9.72321745154080499e-08, 1.70067016824759776e-06,
-      6.77559228363657895e-12 * 1. / (1_MeV), 0,
-      -7.90923951223065759e-08 * 1. / (1_MeV),
-      3.13017533889238816e-10 * 1. / (1_MeV),
-      3.84228193539540777e-09 * 1. / (1_MeV),
-      6.77559228363657895e-12 * 1. / (1_MeV),
-      6.94686808078159856e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform60;
-  ActsSymMatrixD<3> rotMat60;
-  rotMat60 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform60.rotate(rotMat60);
-  transform60.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans60 = std::make_shared<const Transform3D>(transform60);
-  std::shared_ptr<PerigeeSurface> perigeeSurface60 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams60 = BoundParameters(tgContext, std::move(covMat60), params60,
-                                       perigeeSurface60);
+  covMat60 << 0.00160884018987417221, 2.48786024325549841e-05,
+      -4.55158622795351621e-05, 5.27237356570212567e-08,
+      -1.71578397922792243e-08 * 1. / (1_MeV), 0, 2.48786024325549841e-05,
+      0.0133713036775588989, -1.47535371521175571e-06, 7.02707466725490158e-05,
+      -2.00878031112618562e-10 * 1. / (1_MeV), 0, -4.55158622795351621e-05,
+      -1.47535371521175571e-06, 1.33205401198210893e-06,
+      -5.17880198705678666e-09, 8.08198329216027338e-10 * 1. / (1_MeV), 0,
+      5.27237356570212567e-08, 7.02707466725490158e-05,
+      -5.17880198705678666e-09, 4.04392295649813605e-07,
+      1.74801379954387645e-12 * 1. / (1_MeV), 0,
+      -1.71578397922792243e-08 * 1. / (1_MeV),
+      -2.00878031112618562e-10 * 1. / (1_MeV),
+      8.08198329216027338e-10 * 1. / (1_MeV),
+      1.74801379954387645e-12 * 1. / (1_MeV),
+      1.40280183302810002e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams60 =
+      BoundParameters(tgContext, std::move(covMat60), params60, perigeeSurface);
   tracks.push_back(boundParams60);
 
   // track 61 :
   BoundVector params61;
-  params61 << -0.219206094741821289, 20.4783496856689453, -0.292800366878509521,
-      2.68957734107971191, -0.000572857388760894537 * 1. / (1_MeV), 0;
+  params61 << 0.481095165014266968, -45.3241767883300781, 1.63423991203308105,
+      0.527970552444458008, -0.000266404327703639865 * 1. / (1_MeV), 0;
   Covariance covMat61;
-  covMat61 << 0.0146720772609114647, 0.000633603948713714737,
-      -0.000435564556254993611, 4.1380172183317663e-06,
-      -1.65861978224238241e-07 * 1. / (1_MeV), 0, 0.000633603948713714737,
-      0.0937191098928451538, -3.01445904596889702e-05, 0.000503828587046026917,
-      9.92026904049769552e-10 * 1. / (1_MeV), 0, -0.000435564556254993611,
-      -3.01445904596889702e-05, 1.31324359244899824e-05,
-      -1.88451279319618993e-07, 8.03478199107072473e-09 * 1. / (1_MeV), 0,
-      4.1380172183317663e-06, 0.000503828587046026917, -1.88451279319618993e-07,
-      2.77083131550170947e-06, 3.79284582712100777e-12 * 1. / (1_MeV), 0,
-      -1.65861978224238241e-07 * 1. / (1_MeV),
-      9.92026904049769552e-10 * 1. / (1_MeV),
-      8.03478199107072473e-09 * 1. / (1_MeV),
-      3.79284582712100777e-12 * 1. / (1_MeV),
-      1.37340042116740335e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform61;
-  ActsSymMatrixD<3> rotMat61;
-  rotMat61 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform61.rotate(rotMat61);
-  transform61.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans61 = std::make_shared<const Transform3D>(transform61);
-  std::shared_ptr<PerigeeSurface> perigeeSurface61 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams61 = BoundParameters(tgContext, std::move(covMat61), params61,
-                                       perigeeSurface61);
+  covMat61 << 0.00288071134127676487, -0.000155863492110799547,
+      -7.77621373783901631e-05, -1.18027593530364395e-06,
+      -2.48196096965139494e-08 * 1. / (1_MeV), 0, -0.000155863492110799547,
+      0.0149536263197660446, 3.65078035069732869e-06, 9.743912874541411e-05,
+      8.37675468431534094e-11 * 1. / (1_MeV), 0, -7.77621373783901631e-05,
+      3.65078035069732869e-06, 2.18776540350518189e-06, 3.25560801512905163e-08,
+      1.08576617849883842e-09 * 1. / (1_MeV), 0, -1.18027593530364395e-06,
+      9.743912874541411e-05, 3.25560801512905163e-08, 6.77229820666980231e-07,
+      5.47754434165355313e-12 * 1. / (1_MeV), 0,
+      -2.48196096965139494e-08 * 1. / (1_MeV),
+      8.37675468431534094e-11 * 1. / (1_MeV),
+      1.08576617849883842e-09 * 1. / (1_MeV),
+      5.47754434165355313e-12 * 1. / (1_MeV),
+      1.96000368712923034e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams61 =
+      BoundParameters(tgContext, std::move(covMat61), params61, perigeeSurface);
   tracks.push_back(boundParams61);
 
   // track 62 :
   BoundVector params62;
-  params62 << 0.0636809840798377991, 19.6062507629394531, 0.571447312831878662,
-      0.867952585220336914, 0.00121437374036759138 * 1. / (1_MeV), 0;
+  params62 << 0.46620604395866394, -39.1152420043945312, 2.9602348804473877,
+      2.54967498779296875, -0.000812723359558731318 * 1. / (1_MeV), 0;
   Covariance covMat62;
-  covMat62 << 0.0128781227394938469, 0.000273969979431750051,
-      -0.000375215863743342181, 8.19368995942778944e-06,
-      -3.39195297106111847e-07 * 1. / (1_MeV), 0, 0.000273969979431750051,
-      0.0600576512515544891, -2.2149498630265022e-05, 0.000888745641943021122,
-      -2.03770348687604627e-09 * 1. / (1_MeV), 0, -0.000375215863743342181,
-      -2.2149498630265022e-05, 1.11544741230318323e-05,
-      -4.44362300871132803e-07, 1.59093394709295358e-08 * 1. / (1_MeV), 0,
-      8.19368995942778944e-06, 0.000888745641943021122,
-      -4.44362300871132803e-07, 1.38034411065746099e-05,
-      -1.03151432469073304e-10 * 1. / (1_MeV), 0,
-      -3.39195297106111847e-07 * 1. / (1_MeV),
-      -2.03770348687604627e-09 * 1. / (1_MeV),
-      1.59093394709295358e-08 * 1. / (1_MeV),
-      -1.03151432469073304e-10 * 1. / (1_MeV),
-      4.62565652448176934e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform62;
-  ActsSymMatrixD<3> rotMat62;
-  rotMat62 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform62.rotate(rotMat62);
-  transform62.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans62 = std::make_shared<const Transform3D>(transform62);
-  std::shared_ptr<PerigeeSurface> perigeeSurface62 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams62 = BoundParameters(tgContext, std::move(covMat62), params62,
-                                       perigeeSurface62);
+  covMat62 << 0.0155730284750461578, 0.00038755317191748362,
+      -0.000450653030958149533, 7.46684313401321562e-06,
+      -1.56837822709803982e-07 * 1. / (1_MeV), 0, 0.00038755317191748362,
+      0.0830775722861289978, -2.15848125497517351e-05, 0.000657707917473032439,
+      7.52506139410446467e-09 * 1. / (1_MeV), 0, -0.000450653030958149533,
+      -2.15848125497517351e-05, 1.33805215227766894e-05,
+      -3.1197420281739802e-07, 8.02502888738918489e-09 * 1. / (1_MeV), 0,
+      7.46684313401321562e-06, 0.000657707917473032439, -3.1197420281739802e-07,
+      5.4718084356863983e-06, -5.04380269074694918e-12 * 1. / (1_MeV), 0,
+      -1.56837822709803982e-07 * 1. / (1_MeV),
+      7.52506139410446467e-09 * 1. / (1_MeV),
+      8.02502888738918489e-09 * 1. / (1_MeV),
+      -5.04380269074694918e-12 * 1. / (1_MeV),
+      1.86463025575456243e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams62 =
+      BoundParameters(tgContext, std::move(covMat62), params62, perigeeSurface);
   tracks.push_back(boundParams62);
 
   // track 63 :
   BoundVector params63;
-  params63 << 0.256703495979309082, 20.4742660522460938, 2.0388495922088623,
-      0.835670650005340576, -0.00106730952393263578 * 1. / (1_MeV), 0;
+  params63 << -0.645694375038146973, -45.9093971252441406, -1.42855286598205566,
+      2.14151239395141602, -0.000308145768940448761 * 1. / (1_MeV), 0;
   Covariance covMat63;
-  covMat63 << 0.00996344629675149918, -0.000111380282247894335,
-      -0.000297672988748523071, -4.10640820399169642e-06,
-      -2.92419518098666387e-07 * 1. / (1_MeV), 0, -0.000111380282247894335,
-      0.0370076149702072144, 9.57343920283051857e-06, 0.000522519448946792003,
-      -7.68861322556322209e-09 * 1. / (1_MeV), 0, -0.000297672988748523071,
-      9.57343920283051857e-06, 9.07736284716520458e-06, 2.19650252980074214e-07,
-      1.46923783244468664e-08 * 1. / (1_MeV), 0, -4.10640820399169642e-06,
-      0.000522519448946792003, 2.19650252980074214e-07, 7.87897715781582519e-06,
-      -2.63692280030132723e-11 * 1. / (1_MeV), 0,
-      -2.92419518098666387e-07 * 1. / (1_MeV),
-      -7.68861322556322209e-09 * 1. / (1_MeV),
-      1.46923783244468664e-08 * 1. / (1_MeV),
-      -2.63692280030132723e-11 * 1. / (1_MeV),
-      4.39882824609938439e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform63;
-  ActsSymMatrixD<3> rotMat63;
-  rotMat63 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform63.rotate(rotMat63);
-  transform63.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans63 = std::make_shared<const Transform3D>(transform63);
-  std::shared_ptr<PerigeeSurface> perigeeSurface63 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams63 = BoundParameters(tgContext, std::move(covMat63), params63,
-                                       perigeeSurface63);
+  covMat63 << 0.00141701370012015104, 8.16846515917965093e-05,
+      -3.3697989251933814e-05, 6.17724276590095669e-07,
+      -1.6156751085000028e-08 * 1. / (1_MeV), 0, 8.16846515917965093e-05,
+      0.00634454051032662392, -2.08952126392131457e-06, 7.15744916836027302e-05,
+      -1.49091147779785594e-09 * 1. / (1_MeV), 0, -3.3697989251933814e-05,
+      -2.08952126392131457e-06, 8.4832106495014159e-07,
+      -1.64115671055080147e-08, 5.9837667986473886e-10 * 1. / (1_MeV), 0,
+      6.17724276590095669e-07, 7.15744916836027302e-05,
+      -1.64115671055080147e-08, 1.0292989145455067e-06,
+      -1.46674673345839605e-11 * 1. / (1_MeV), 0,
+      -1.6156751085000028e-08 * 1. / (1_MeV),
+      -1.49091147779785594e-09 * 1. / (1_MeV),
+      5.9837667986473886e-10 * 1. / (1_MeV),
+      -1.46674673345839605e-11 * 1. / (1_MeV),
+      1.54105235516954764e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams63 =
+      BoundParameters(tgContext, std::move(covMat63), params63, perigeeSurface);
   tracks.push_back(boundParams63);
 
   // track 64 :
   BoundVector params64;
-  params64 << 0.120990529656410217, 19.6643028259277344, 2.09903669357299805,
-      0.376666009426116943, 0.000600203988142311573 * 1. / (1_MeV), 0;
+  params64 << -0.608972728252410889, -0.205871865153312683,
+      -0.337655186653137207, 0.617485642433166504,
+      0.000326765264617279172 * 1. / (1_MeV), 0;
   Covariance covMat64;
-  covMat64 << 0.0291396286338567734, 5.39021723134598197e-05,
-      -0.000882721168274605778, 4.14864371809709873e-06,
-      -5.5001142494950611e-07 * 1. / (1_MeV), 0, 5.39021723134598197e-05,
-      0.234371468424797058, -4.16871244043210621e-05, 0.000918528875032399673,
-      1.39816410013920925e-08 * 1. / (1_MeV), 0, -0.000882721168274605778,
-      -4.16871244043210621e-05, 2.72563647740753368e-05,
-      -2.79753257845384789e-07, 2.7634673800087543e-08 * 1. / (1_MeV), 0,
-      4.14864371809709873e-06, 0.000918528875032399673,
-      -2.79753257845384789e-07, 3.6635033211496193e-06,
-      1.58046165958546609e-11 * 1. / (1_MeV), 0,
-      -5.5001142494950611e-07 * 1. / (1_MeV),
-      1.39816410013920925e-08 * 1. / (1_MeV),
-      2.7634673800087543e-08 * 1. / (1_MeV),
-      1.58046165958546609e-11 * 1. / (1_MeV),
-      4.08823086495146981e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform64;
-  ActsSymMatrixD<3> rotMat64;
-  rotMat64 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform64.rotate(rotMat64);
-  transform64.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans64 = std::make_shared<const Transform3D>(transform64);
-  std::shared_ptr<PerigeeSurface> perigeeSurface64 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams64 = BoundParameters(tgContext, std::move(covMat64), params64,
-                                       perigeeSurface64);
+  covMat64 << 0.00256323744542896748, -0.000102964159443142377,
+      -7.43746711326680654e-05, 2.77199836373549426e-07,
+      -3.16870017552968717e-08 * 1. / (1_MeV), 0, -0.000102964159443142377,
+      0.0179459210485219955, 9.927183095141406e-07, 0.000150291132415494166,
+      1.84401452515339684e-09 * 1. / (1_MeV), 0, -7.43746711326680654e-05,
+      9.927183095141406e-07, 2.20178139898052905e-06, -2.23963294945635655e-08,
+      1.42819207588526508e-09 * 1. / (1_MeV), 0, 2.77199836373549426e-07,
+      0.000150291132415494166, -2.23963294945635655e-08,
+      1.36840594677778427e-06, 1.15087456059600686e-12 * 1. / (1_MeV), 0,
+      -3.16870017552968717e-08 * 1. / (1_MeV),
+      1.84401452515339684e-09 * 1. / (1_MeV),
+      1.42819207588526508e-09 * 1. / (1_MeV),
+      1.15087456059600686e-12 * 1. / (1_MeV),
+      2.95290424057181866e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams64 =
+      BoundParameters(tgContext, std::move(covMat64), params64, perigeeSurface);
   tracks.push_back(boundParams64);
 
   // track 65 :
   BoundVector params65;
-  params65 << 0.0062864348292350769, 19.6056728363037109, 1.96336662769317627,
-      1.67587447166442871, -0.00098716001957654953 * 1. / (1_MeV), 0;
+  params65 << -0.651330411434173584, -46.6501655578613281,
+      -0.162742897868156433, 2.37663960456848145,
+      0.000465616496512666345 * 1. / (1_MeV), 0;
   Covariance covMat65;
-  covMat65 << 0.00639463262632489204, 2.92739463404503888e-05,
-      -0.000162262223266041843, 7.35056423966357298e-07,
-      -6.22851560331579401e-08 * 1. / (1_MeV), 0, 2.92739463404503888e-05,
-      0.0197239704430103302, -1.20671194756186941e-06, 0.000422495468900870442,
-      -7.46651628897230336e-10 * 1. / (1_MeV), 0, -0.000162262223266041843,
-      -1.20671194756186941e-06, 4.31130820288672112e-06,
-      -3.10329014828531918e-08, 2.84192773413970349e-09 * 1. / (1_MeV), 0,
-      7.35056423966357298e-07, 0.000422495468900870442,
-      -3.10329014828531918e-08, 1.06411953311180696e-05,
-      -4.82012337741633492e-13 * 1. / (1_MeV), 0,
-      -6.22851560331579401e-08 * 1. / (1_MeV),
-      -7.46651628897230336e-10 * 1. / (1_MeV),
-      2.84192773413970349e-09 * 1. / (1_MeV),
-      -4.82012337741633492e-13 * 1. / (1_MeV),
-      1.05485536971983151e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform65;
-  ActsSymMatrixD<3> rotMat65;
-  rotMat65 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform65.rotate(rotMat65);
-  transform65.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans65 = std::make_shared<const Transform3D>(transform65);
-  std::shared_ptr<PerigeeSurface> perigeeSurface65 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams65 = BoundParameters(tgContext, std::move(covMat65), params65,
-                                       perigeeSurface65);
+  covMat65 << 0.00349642685614526272, 0.000141372948412694558,
+      -9.42089049286210813e-05, 1.58411676533929063e-07,
+      -5.51507903718466048e-08 * 1. / (1_MeV), 0, 0.000141372948412694558,
+      0.0145636545494198799, -1.8376679472879644e-06, 0.000159144530910216837,
+      -9.77799777456030559e-10 * 1. / (1_MeV), 0, -9.42089049286210813e-05,
+      -1.8376679472879644e-06, 2.6513741886446951e-06, 1.6927620638758599e-08,
+      2.44350119045523328e-09 * 1. / (1_MeV), 0, 1.58411676533929063e-07,
+      0.000159144530910216837, 1.6927620638758599e-08, 1.91570370589033701e-06,
+      2.43993447359552124e-11 * 1. / (1_MeV), 0,
+      -5.51507903718466048e-08 * 1. / (1_MeV),
+      -9.77799777456030559e-10 * 1. / (1_MeV),
+      2.44350119045523328e-09 * 1. / (1_MeV),
+      2.43993447359552124e-11 * 1. / (1_MeV),
+      6.30697091774656826e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams65 =
+      BoundParameters(tgContext, std::move(covMat65), params65, perigeeSurface);
   tracks.push_back(boundParams65);
 
   // track 66 :
   BoundVector params66;
-  params66 << 0.0955945327877998352, 20.2347850799560547, -0.327246248722076416,
-      2.98204421997070312, 2.21292903006542474e-05 * 1. / (1_MeV), 0;
+  params66 << 0.64414292573928833, -37.8168792724609375, 1.41348385810852051,
+      0.628789603710174561, -0.000711047730874270201 * 1. / (1_MeV), 0;
   Covariance covMat66;
-  covMat66 << 0.00150146521627902985, 0.0023395733708214345,
-      -3.76246492337360715e-05, 1.20517570859588883e-06,
-      -1.54414914830204655e-08 * 1. / (1_MeV), 0, 0.0023395733708214345,
-      0.0877117365598678589, -4.71741381729428471e-05, 5.21609361100870518e-05,
-      3.25177228611905034e-10 * 1. / (1_MeV), 0, -3.76246492337360715e-05,
-      -4.71741381729428471e-05, 1.0044809641840402e-06,
-      -2.48049212962453205e-08, 6.86903087291782125e-10 * 1. / (1_MeV), 0,
-      1.20517570859588883e-06, 5.21609361100870518e-05,
-      -2.48049212962453205e-08, 3.23552171721530613e-08,
-      2.29084759303353043e-13 * 1. / (1_MeV), 0,
-      -1.54414914830204655e-08 * 1. / (1_MeV),
-      3.25177228611905034e-10 * 1. / (1_MeV),
-      6.86903087291782125e-10 * 1. / (1_MeV),
-      2.29084759303353043e-13 * 1. / (1_MeV),
-      3.96015121736925657e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform66;
-  ActsSymMatrixD<3> rotMat66;
-  rotMat66 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform66.rotate(rotMat66);
-  transform66.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans66 = std::make_shared<const Transform3D>(transform66);
-  std::shared_ptr<PerigeeSurface> perigeeSurface66 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams66 = BoundParameters(tgContext, std::move(covMat66), params66,
-                                       perigeeSurface66);
+  covMat66 << 0.00865435414016246796, 4.30179014559714792e-05,
+      -0.000260259753258794142, -2.77364333528555447e-06,
+      -1.18175630051794391e-07 * 1. / (1_MeV), 0, 4.30179014559714792e-05,
+      0.0385085344314575195, 3.5186803309031585e-06, 0.000362887855399699421,
+      -6.57911033053770427e-09 * 1. / (1_MeV), 0, -0.000260259753258794142,
+      3.5186803309031585e-06, 7.93121216702274978e-06, 1.35170575721091198e-07,
+      5.61496221132519249e-09 * 1. / (1_MeV), 0, -2.77364333528555447e-06,
+      0.000362887855399699421, 1.35170575721091198e-07, 3.55381462213699706e-06,
+      -1.76572689736880453e-12 * 1. / (1_MeV), 0,
+      -1.18175630051794391e-07 * 1. / (1_MeV),
+      -6.57911033053770427e-09 * 1. / (1_MeV),
+      5.61496221132519249e-09 * 1. / (1_MeV),
+      -1.76572689736880453e-12 * 1. / (1_MeV),
+      1.27183083509230244e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams66 =
+      BoundParameters(tgContext, std::move(covMat66), params66, perigeeSurface);
   tracks.push_back(boundParams66);
 
   // track 67 :
   BoundVector params67;
-  params67 << 0.382039725780487061, 20.0302467346191406, 1.78882849216461182,
-      2.7296445369720459, 0.000560962012968957424 * 1. / (1_MeV), 0;
+  params67 << -0.332721292972564697, -22.5682830810546875, 0.226930230855941772,
+      0.439133286476135254, 0.000341838604072108865 * 1. / (1_MeV), 0;
   Covariance covMat67;
-  covMat67 << 0.0185648687183856964, -0.000512420938441797555,
-      -0.000564488122844988122, -3.46646347767409226e-06,
-      -6.9752293121264101e-07 * 1. / (1_MeV), 0, -0.000512420938441797555,
-      0.158824682235717773, 4.20228128232319107e-05, 0.000710107550351205766,
-      5.56717392340507163e-09 * 1. / (1_MeV), 0, -0.000564488122844988122,
-      4.20228128232319107e-05, 1.76464527612552047e-05, 2.17145732577765049e-07,
-      3.41404923239805513e-08 * 1. / (1_MeV), 0, -3.46646347767409226e-06,
-      0.000710107550351205766, 2.17145732577765049e-07, 3.26669078276609071e-06,
-      -1.08290629522060115e-11 * 1. / (1_MeV), 0,
-      -6.9752293121264101e-07 * 1. / (1_MeV),
-      5.56717392340507163e-09 * 1. / (1_MeV),
-      3.41404923239805513e-08 * 1. / (1_MeV),
-      -1.08290629522060115e-11 * 1. / (1_MeV),
-      5.43119271778635948e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform67;
-  ActsSymMatrixD<3> rotMat67;
-  rotMat67 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform67.rotate(rotMat67);
-  transform67.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans67 = std::make_shared<const Transform3D>(transform67);
-  std::shared_ptr<PerigeeSurface> perigeeSurface67 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams67 = BoundParameters(tgContext, std::move(covMat67), params67,
-                                       perigeeSurface67);
+  covMat67 << 0.00658620009198784828, -0.000468461936445102546,
+      -0.000190280257733648498, -8.77654618295631542e-07,
+      -7.41082017465768966e-08 * 1. / (1_MeV), 0, -0.000468461936445102546,
+      0.0421695522964000702, 8.37362681235735137e-06, 0.000212639250704076973,
+      5.59919585012054894e-09 * 1. / (1_MeV), 0, -0.000190280257733648498,
+      8.37362681235735137e-06, 5.653947482642252e-06, 2.05904961050614474e-09,
+      3.61592933955667245e-09 * 1. / (1_MeV), 0, -8.77654618295631542e-07,
+      0.000212639250704076973, 2.05904961050614474e-09, 1.10556209165224573e-06,
+      9.31555819953937805e-12 * 1. / (1_MeV), 0,
+      -7.41082017465768966e-08 * 1. / (1_MeV),
+      5.59919585012054894e-09 * 1. / (1_MeV),
+      3.61592933955667245e-09 * 1. / (1_MeV),
+      9.31555819953937805e-12 * 1. / (1_MeV),
+      6.02211544520336872e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams67 =
+      BoundParameters(tgContext, std::move(covMat67), params67, perigeeSurface);
   tracks.push_back(boundParams67);
 
   // track 68 :
   BoundVector params68;
-  params68 << -0.179121747612953186, 20.2514362335205078, -0.862554371356964111,
-      2.68916535377502441, -0.000457327318144962192 * 1. / (1_MeV), 0;
+  params68 << 0.228807628154754639, -45.5291328430175781, 1.88212299346923828,
+      0.391405045986175537, -0.000272470730124041438 * 1. / (1_MeV), 0;
   Covariance covMat68;
-  covMat68 << 0.0108809741213917732, 0.00193338631898851772,
-      -0.000310007020929202329, 8.43655106315042699e-06,
-      -1.10126677038094219e-07 * 1. / (1_MeV), 0, 0.00193338631898851772,
-      0.0997641086578369141, -5.31462636732746974e-05, 0.000479126202409259187,
-      -3.00325838913588194e-09 * 1. / (1_MeV), 0, -0.000310007020929202329,
-      -5.31462636732746974e-05, 9.10317794478032738e-06,
-      -2.45896355006014845e-07, 5.3026650853642868e-09 * 1. / (1_MeV), 0,
-      8.43655106315042699e-06, 0.000479126202409259187,
-      -2.45896355006014845e-07, 2.40905660575663205e-06,
-      -1.12621932829046352e-11 * 1. / (1_MeV), 0,
-      -1.10126677038094219e-07 * 1. / (1_MeV),
-      -3.00325838913588194e-09 * 1. / (1_MeV),
-      5.3026650853642868e-09 * 1. / (1_MeV),
-      -1.12621932829046352e-11 * 1. / (1_MeV),
-      9.04395031087190659e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform68;
-  ActsSymMatrixD<3> rotMat68;
-  rotMat68 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform68.rotate(rotMat68);
-  transform68.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans68 = std::make_shared<const Transform3D>(transform68);
-  std::shared_ptr<PerigeeSurface> perigeeSurface68 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams68 = BoundParameters(tgContext, std::move(covMat68), params68,
-                                       perigeeSurface68);
+  covMat68 << 0.00558751169592142105, -0.000526476410891340272,
+      -0.000165610234749681399, -2.61479347877094164e-06,
+      -6.61682300501314344e-08 * 1. / (1_MeV), 0, -0.000526476410891340272,
+      0.0537347830832004547, 1.60095985217531436e-05, 0.000211228233160033968,
+      -7.3861724702695647e-11 * 1. / (1_MeV), 0, -0.000165610234749681399,
+      1.60095985217531436e-05, 4.99409998155897483e-06, 8.27335653273563984e-08,
+      3.08626652913981362e-09 * 1. / (1_MeV), 0, -2.61479347877094164e-06,
+      0.000211228233160033968, 8.27335653273563984e-08, 8.58062662700831424e-07,
+      9.8161963481123767e-12 * 1. / (1_MeV), 0,
+      -6.61682300501314344e-08 * 1. / (1_MeV),
+      -7.3861724702695647e-11 * 1. / (1_MeV),
+      3.08626652913981362e-09 * 1. / (1_MeV),
+      9.8161963481123767e-12 * 1. / (1_MeV),
+      4.41570460751883331e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams68 =
+      BoundParameters(tgContext, std::move(covMat68), params68, perigeeSurface);
   tracks.push_back(boundParams68);
 
   // track 69 :
   BoundVector params69;
-  params69 << -0.138331592082977295, 19.3751182556152344, -1.35278940200805664,
-      0.381486982107162476, -0.000426069716922938824 * 1. / (1_MeV), 0;
+  params69 << -0.774779915809631348, -7.18358039855957031, -1.68472623825073242,
+      0.294571459293365479, -0.00012300643720664084 * 1. / (1_MeV), 0;
   Covariance covMat69;
-  covMat69 << 0.0138281593099236488, -0.000802064074892135472,
-      -0.000420553068714103143, -3.62152568304627602e-06,
-      -1.71446784106220126e-07 * 1. / (1_MeV), 0, -0.000802064074892135472,
-      0.124462626874446869, 3.35644323921618966e-05, 0.000489752797097319013,
-      1.53338361947342647e-09 * 1. / (1_MeV), 0, -0.000420553068714103143,
-      3.35644323921618966e-05, 1.3009085705562029e-05, 1.52739817453807061e-07,
-      8.51389247727636405e-09 * 1. / (1_MeV), 0, -3.62152568304627602e-06,
-      0.000489752797097319013, 1.52739817453807061e-07, 1.98223324332502671e-06,
-      7.74913828351229925e-12 * 1. / (1_MeV), 0,
-      -1.71446784106220126e-07 * 1. / (1_MeV),
-      1.53338361947342647e-09 * 1. / (1_MeV),
-      8.51389247727636405e-09 * 1. / (1_MeV),
-      7.74913828351229925e-12 * 1. / (1_MeV),
-      1.26564134173001719e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform69;
-  ActsSymMatrixD<3> rotMat69;
-  rotMat69 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform69.rotate(rotMat69);
-  transform69.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans69 = std::make_shared<const Transform3D>(transform69);
-  std::shared_ptr<PerigeeSurface> perigeeSurface69 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams69 = BoundParameters(tgContext, std::move(covMat69), params69,
-                                       perigeeSurface69);
+  covMat69 << 0.00796640384942293167, -0.00308066711056936707,
+      -0.000183902465217028856, -4.40322681469892384e-06,
+      -4.28751518274954345e-08 * 1. / (1_MeV), 0, -0.00308066711056936707,
+      0.256041616201400757, 7.1248927562660272e-05, 0.000440831013812017375,
+      7.95526672562874677e-09 * 1. / (1_MeV), 0, -0.000183902465217028856,
+      7.1248927562660272e-05, 4.48159107691026293e-06, 1.02520016937503953e-07,
+      1.75117724904492434e-09 * 1. / (1_MeV), 0, -4.40322681469892384e-06,
+      0.000440831013812017375, 1.02520016937503953e-07, 7.90239880643639481e-07,
+      6.37842082317695236e-12 * 1. / (1_MeV), 0,
+      -4.28751518274954345e-08 * 1. / (1_MeV),
+      7.95526672562874677e-09 * 1. / (1_MeV),
+      1.75117724904492434e-09 * 1. / (1_MeV),
+      6.37842082317695236e-12 * 1. / (1_MeV),
+      1.73160132066474404e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams69 =
+      BoundParameters(tgContext, std::move(covMat69), params69, perigeeSurface);
   tracks.push_back(boundParams69);
 
   // track 70 :
   BoundVector params70;
-  params70 << -0.0937596634030342102, 19.4900455474853516,
-      -0.352513551712036133, 2.89332342147827148,
-      -0.000186513439984992146 * 1. / (1_MeV), 0;
+  params70 << -0.799591720104217529, -4.63163089752197266, 0.405971020460128784,
+      0.378831923007965088, 0.000591743737459182739 * 1. / (1_MeV), 0;
   Covariance covMat70;
-  covMat70 << 0.0097403964027762413, 0.00166471584749119505,
-      -0.000287947885317068881, 2.55751055140476181e-06,
-      -7.81118139203814757e-08 * 1. / (1_MeV), 0, 0.00166471584749119505,
-      0.204256042838096619, -4.79791071918836e-05, 0.000340033153539362216,
-      -1.95895871236344388e-09 * 1. / (1_MeV), 0, -0.000287947885317068881,
-      -4.79791071918836e-05, 8.6775098679936491e-06, -7.89068829617864185e-08,
-      3.73986494276367498e-09 * 1. / (1_MeV), 0, 2.55751055140476181e-06,
-      0.000340033153539362216, -7.89068829617864185e-08, 5.8173242223347188e-07,
-      -3.34422452468073519e-12 * 1. / (1_MeV), 0,
-      -7.81118139203814757e-08 * 1. / (1_MeV),
-      -1.95895871236344388e-09 * 1. / (1_MeV),
-      3.73986494276367498e-09 * 1. / (1_MeV),
-      -3.34422452468073519e-12 * 1. / (1_MeV),
-      3.56935557499493683e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform70;
-  ActsSymMatrixD<3> rotMat70;
-  rotMat70 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform70.rotate(rotMat70);
-  transform70.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans70 = std::make_shared<const Transform3D>(transform70);
-  std::shared_ptr<PerigeeSurface> perigeeSurface70 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams70 = BoundParameters(tgContext, std::move(covMat70), params70,
-                                       perigeeSurface70);
+  covMat70 << 0.0266661942005157471, -0.00183957268711347835,
+      -0.000807137683582467521, 3.8442389767195023e-06,
+      -3.49680195741055849e-07 * 1. / (1_MeV), 0, -0.00183957268711347835,
+      0.211709365248680115, 1.93959104101635743e-05, 0.000855412169330214186,
+      4.91598206364535424e-08 * 1. / (1_MeV), 0, -0.000807137683582467521,
+      1.93959104101635743e-05, 2.48053565883310512e-05,
+      -2.62219580174192418e-07, 1.76141434145594417e-08 * 1. / (1_MeV), 0,
+      3.8442389767195023e-06, 0.000855412169330214186, -2.62219580174192418e-07,
+      3.50158666151401121e-06, 8.73307509198330779e-12 * 1. / (1_MeV), 0,
+      -3.49680195741055849e-07 * 1. / (1_MeV),
+      4.91598206364535424e-08 * 1. / (1_MeV),
+      1.76141434145594417e-08 * 1. / (1_MeV),
+      8.73307509198330779e-12 * 1. / (1_MeV),
+      2.64328670063207483e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams70 =
+      BoundParameters(tgContext, std::move(covMat70), params70, perigeeSurface);
   tracks.push_back(boundParams70);
 
   // track 71 :
   BoundVector params71;
-  params71 << -0.031271662563085556, 19.7582015991210938, -0.544847011566162109,
-      2.35719013214111328, -0.00060985935851931572 * 1. / (1_MeV), 0;
+  params71 << -0.600866556167602539, -46.0752182006835938, -1.38232946395874023,
+      2.03518390655517578, 0.000216916509089060128 * 1. / (1_MeV), 0;
   Covariance covMat71;
-  covMat71 << 0.00421266257762908936, 0.000139259250319359563,
-      -0.000121986267999964622, 1.59459282051017784e-06,
-      -9.93183532021228265e-08 * 1. / (1_MeV), 0, 0.000139259250319359563,
-      0.0205928590148687363, -5.36726063219632336e-06, 0.000232703689853152397,
-      -3.11346553982713454e-10 * 1. / (1_MeV), 0, -0.000121986267999964622,
-      -5.36726063219632336e-06, 3.63290769200830255e-06,
-      -6.68725223656711701e-08, 4.73213336870042294e-09 * 1. / (1_MeV), 0,
-      1.59459282051017784e-06, 0.000232703689853152397,
-      -6.68725223656711701e-08, 2.95713130071817432e-06,
-      -1.25499234028196558e-11 * 1. / (1_MeV), 0,
-      -9.93183532021228265e-08 * 1. / (1_MeV),
-      -3.11346553982713454e-10 * 1. / (1_MeV),
-      4.73213336870042294e-09 * 1. / (1_MeV),
-      -1.25499234028196558e-11 * 1. / (1_MeV),
-      1.28399915699795031e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform71;
-  ActsSymMatrixD<3> rotMat71;
-  rotMat71 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform71.rotate(rotMat71);
-  transform71.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans71 = std::make_shared<const Transform3D>(transform71);
-  std::shared_ptr<PerigeeSurface> perigeeSurface71 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams71 = BoundParameters(tgContext, std::move(covMat71), params71,
-                                       perigeeSurface71);
+  covMat71 << 0.000447078287834301591, 6.4246307431772498e-06,
+      -1.22906651502427452e-05, -1.99116263412532374e-09,
+      -1.43109528065029844e-08 * 1. / (1_MeV), 0, 6.4246307431772498e-06,
+      0.00480788340792059898, -5.87978219682613621e-08, 5.37988074894698367e-05,
+      -1.93974344917808111e-09 * 1. / (1_MeV), 0, -1.22906651502427452e-05,
+      -5.87978219682613621e-08, 3.57868174205577816e-07, 1.5805389300162696e-09,
+      6.29499582429645186e-10 * 1. / (1_MeV), 0, -1.99116263412532374e-09,
+      5.37988074894698367e-05, 1.5805389300162696e-09, 7.68185657307185465e-07,
+      -6.71150128191831827e-12 * 1. / (1_MeV), 0,
+      -1.43109528065029844e-08 * 1. / (1_MeV),
+      -1.93974344917808111e-09 * 1. / (1_MeV),
+      6.29499582429645186e-10 * 1. / (1_MeV),
+      -6.71150128191831827e-12 * 1. / (1_MeV),
+      1.96153805004373183e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams71 =
+      BoundParameters(tgContext, std::move(covMat71), params71, perigeeSurface);
   tracks.push_back(boundParams71);
 
   // track 72 :
   BoundVector params72;
-  params72 << -0.00558616593480110168, 19.7915973663330078,
-      -1.90661561489105225, 2.65805935859680176,
-      -0.000252252968493849039 * 1. / (1_MeV), 0;
+  params72 << 0.934263527393341064, -26.3208255767822266, 2.37594270706176758,
+      2.72768449783325195, 0.000554551603272557259 * 1. / (1_MeV), 0;
   Covariance covMat72;
-  covMat72 << 0.00278375041671097279, 0.000178787135861017661,
-      -8.12352454224075254e-05, 9.80445612301050583e-07,
-      -3.12103239377841498e-08 * 1. / (1_MeV), 0, 0.000178787135861017661,
-      0.0250813495367765427, -5.34047004847387823e-06, 0.000133613120646069154,
-      -5.47170798097926544e-10 * 1. / (1_MeV), 0, -8.12352454224075254e-05,
-      -5.34047004847387823e-06, 2.44281318373396061e-06,
-      -3.22686132104606899e-08, 1.51340031297866715e-09 * 1. / (1_MeV), 0,
-      9.80445612301050583e-07, 0.000133613120646069154,
-      -3.22686132104606899e-08, 7.69510791087668622e-07,
-      -3.66374332111759326e-12 * 1. / (1_MeV), 0,
-      -3.12103239377841498e-08 * 1. / (1_MeV),
-      -5.47170798097926544e-10 * 1. / (1_MeV),
-      1.51340031297866715e-09 * 1. / (1_MeV),
-      -3.66374332111759326e-12 * 1. / (1_MeV),
-      2.74491956941957937e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform72;
-  ActsSymMatrixD<3> rotMat72;
-  rotMat72 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform72.rotate(rotMat72);
-  transform72.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans72 = std::make_shared<const Transform3D>(transform72);
-  std::shared_ptr<PerigeeSurface> perigeeSurface72 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams72 = BoundParameters(tgContext, std::move(covMat72), params72,
-                                       perigeeSurface72);
+  covMat72 << 0.0188611242920160294, -0.00121691842277711322,
+      -0.000576619514959964973, -2.82991619355262503e-06,
+      -4.0010412648847567e-07 * 1. / (1_MeV), 0, -0.00121691842277711322,
+      0.123724676668643951, 5.66678562685891124e-05, 0.000592259000642492389,
+      3.76165411298313188e-08 * 1. / (1_MeV), 0, -0.000576619514959964973,
+      5.66678562685891124e-05, 1.79301478056004271e-05, 1.75725099274939068e-07,
+      1.9855251791033252e-08 * 1. / (1_MeV), 0, -2.82991619355262503e-06,
+      0.000592259000642492389, 1.75725099274939068e-07, 2.86794875137275085e-06,
+      1.52908464521253004e-11 * 1. / (1_MeV), 0,
+      -4.0010412648847567e-07 * 1. / (1_MeV),
+      3.76165411298313188e-08 * 1. / (1_MeV),
+      1.9855251791033252e-08 * 1. / (1_MeV),
+      1.52908464521253004e-11 * 1. / (1_MeV),
+      3.20209747606270412e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams72 =
+      BoundParameters(tgContext, std::move(covMat72), params72, perigeeSurface);
   tracks.push_back(boundParams72);
 
   // track 73 :
   BoundVector params73;
-  params73 << -0.442154228687286377, 17.9542407989501953, 2.09526467323303223,
-      2.94595146179199219, -0.000162040654686279595 * 1. / (1_MeV), 0;
+  params73 << 0.730206131935119629, -0.356079369783401489, 1.74193072319030762,
+      0.789627969264984131, 0.000864426896441727877 * 1. / (1_MeV), 0;
   Covariance covMat73;
-  covMat73 << 0.0148460650816559792, 0.00184244940568953006,
-      -0.000449961931621142613, 1.29765535410889532e-06,
-      -2.30827454176528137e-07 * 1. / (1_MeV), 0, 0.00184244940568953006,
-      0.471974313259124756, -6.98775671258470389e-05, 0.000523674191842157626,
-      -2.19369371696834795e-08 * 1. / (1_MeV), 0, -0.000449961931621142613,
-      -6.98775671258470389e-05, 1.40490355988731608e-05,
-      -5.73058129070942768e-08, 1.17830493253825561e-08 * 1. / (1_MeV), 0,
-      1.29765535410889532e-06, 0.000523674191842157626,
-      -5.73058129070942768e-08, 5.89256046623631846e-07,
-      -2.53371790794750309e-12 * 1. / (1_MeV), 0,
-      -2.30827454176528137e-07 * 1. / (1_MeV),
-      -2.19369371696834795e-08 * 1. / (1_MeV),
-      1.17830493253825561e-08 * 1. / (1_MeV),
-      -2.53371790794750309e-12 * 1. / (1_MeV),
-      9.43526715091458357e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform73;
-  ActsSymMatrixD<3> rotMat73;
-  rotMat73 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform73.rotate(rotMat73);
-  transform73.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans73 = std::make_shared<const Transform3D>(transform73);
-  std::shared_ptr<PerigeeSurface> perigeeSurface73 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams73 = BoundParameters(tgContext, std::move(covMat73), params73,
-                                       perigeeSurface73);
+  covMat73 << 0.00696328096091747284, 0.000192718431767054029,
+      -0.000210651783787634309, 1.79142534806142213e-06,
+      -1.60408967532742937e-07 * 1. / (1_MeV), 0, 0.000192718431767054029,
+      0.0250711347907781601, -1.01345165607011824e-05, 0.000326248033176201218,
+      -2.92212069047691244e-09 * 1. / (1_MeV), 0, -0.000210651783787634309,
+      -1.01345165607011824e-05, 6.47193519398570061e-06,
+      -1.10382166450068239e-07, 7.86957679995017337e-09 * 1. / (1_MeV), 0,
+      1.79142534806142213e-06, 0.000326248033176201218,
+      -1.10382166450068239e-07, 4.4890334720548708e-06,
+      1.43532649831609989e-11 * 1. / (1_MeV), 0,
+      -1.60408967532742937e-07 * 1. / (1_MeV),
+      -2.92212069047691244e-09 * 1. / (1_MeV),
+      7.86957679995017337e-09 * 1. / (1_MeV),
+      1.43532649831609989e-11 * 1. / (1_MeV),
+      2.18980167332460951e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams73 =
+      BoundParameters(tgContext, std::move(covMat73), params73, perigeeSurface);
   tracks.push_back(boundParams73);
 
   // track 74 :
   BoundVector params74;
-  params74 << 0.11471288651227951, 19.0564899444580078, -0.177579745650291443,
-      2.49515652656555176, 0.000924068794120103121 * 1. / (1_MeV), 0;
+  params74 << -0.697826266288757324, -23.5827674865722656,
+      -0.712247550487518311, 0.6665802001953125,
+      0.000837316561955958605 * 1. / (1_MeV), 0;
   Covariance covMat74;
-  covMat74 << 0.0152982324361801147, 4.68616789410272773e-05,
-      -0.000446912018709990798, -2.64518724116447377e-06,
-      -3.35403806382200683e-07 * 1. / (1_MeV), 0, 4.68616789410272773e-05,
-      0.057605259120464325, 1.24210046721730033e-05, 0.00055778648850193823,
-      -7.16971922823788445e-09 * 1. / (1_MeV), 0, -0.000446912018709990798,
-      1.24210046721730033e-05, 1.33806315716356039e-05, 2.06818269256773686e-07,
-      1.64730542670120641e-08 * 1. / (1_MeV), 0, -2.64518724116447377e-06,
-      0.00055778648850193823, 2.06818269256773686e-07, 5.62562490813434124e-06,
-      -2.99011952126558051e-11 * 1. / (1_MeV), 0,
-      -3.35403806382200683e-07 * 1. / (1_MeV),
-      -7.16971922823788445e-09 * 1. / (1_MeV),
-      1.64730542670120641e-08 * 1. / (1_MeV),
-      -2.99011952126558051e-11 * 1. / (1_MeV),
-      3.94437649209322672e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform74;
-  ActsSymMatrixD<3> rotMat74;
-  rotMat74 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform74.rotate(rotMat74);
-  transform74.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans74 = std::make_shared<const Transform3D>(transform74);
-  std::shared_ptr<PerigeeSurface> perigeeSurface74 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams74 = BoundParameters(tgContext, std::move(covMat74), params74,
-                                       perigeeSurface74);
+  covMat74 << 0.0102707967162132263, -0.000136778664959171002,
+      -0.000310806316136640959, 3.61658036657657105e-06,
+      -1.57486458126811822e-07 * 1. / (1_MeV), 0, -0.000136778664959171002,
+      0.0391799546778202057, -3.21871642520172128e-06, 0.000429004761143547957,
+      7.25027250869408224e-09 * 1. / (1_MeV), 0, -0.000310806316136640959,
+      -3.21871642520172128e-06, 9.52503432927187532e-06,
+      -1.91221331833284833e-07, 8.03748117560459975e-09 * 1. / (1_MeV), 0,
+      3.61658036657657105e-06, 0.000429004761143547957,
+      -1.91221331833284833e-07, 4.81143752040225081e-06,
+      -1.69302933545922802e-11 * 1. / (1_MeV), 0,
+      -1.57486458126811822e-07 * 1. / (1_MeV),
+      7.25027250869408224e-09 * 1. / (1_MeV),
+      8.03748117560459975e-09 * 1. / (1_MeV),
+      -1.69302933545922802e-11 * 1. / (1_MeV),
+      2.06939729241462089e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams74 =
+      BoundParameters(tgContext, std::move(covMat74), params74, perigeeSurface);
   tracks.push_back(boundParams74);
 
   // track 75 :
   BoundVector params75;
-  params75 << -0.00944441463798284531, 19.5482063293457031, 1.26532316207885742,
-      1.51080191135406494, 0.00125105178449302912 * 1. / (1_MeV), 0;
+  params75 << 0.0529175736010074615, -12.0598258972167969, 1.1199498176574707,
+      1.30395138263702393, 0.000916379212867468596 * 1. / (1_MeV), 0;
   Covariance covMat75;
-  covMat75 << 0.00673942035064101219, 1.09700537457738396e-05,
-      -0.000191837249175310959, 3.98609880544513471e-07,
-      -1.16410980841974866e-07 * 1. / (1_MeV), 0, 1.09700537457738396e-05,
-      0.030988229438662529, -8.21095175946172576e-07, 0.000558048897263842877,
-      -1.58105556275077154e-09 * 1. / (1_MeV), 0, -0.000191837249175310959,
-      -8.21095175946172576e-07, 5.58653619009419344e-06,
-      -2.21237754371518524e-08, 5.54159050773939158e-09 * 1. / (1_MeV), 0,
-      3.98609880544513471e-07, 0.000558048897263842877,
-      -2.21237754371518524e-08, 1.262055775441695e-05,
-      -2.73377636711205828e-11 * 1. / (1_MeV), 0,
-      -1.16410980841974866e-07 * 1. / (1_MeV),
-      -1.58105556275077154e-09 * 1. / (1_MeV),
-      5.54159050773939158e-09 * 1. / (1_MeV),
-      -2.73377636711205828e-11 * 1. / (1_MeV),
-      2.14180881363823516e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform75;
-  ActsSymMatrixD<3> rotMat75;
-  rotMat75 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform75.rotate(rotMat75);
-  transform75.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans75 = std::make_shared<const Transform3D>(transform75);
-  std::shared_ptr<PerigeeSurface> perigeeSurface75 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams75 = BoundParameters(tgContext, std::move(covMat75), params75,
-                                       perigeeSurface75);
+  covMat75 << 0.00428111432120203972, 2.62827478725743552e-05,
+      -0.000120566700934877791, 7.54315472354089557e-07,
+      -5.43323675648758046e-08 * 1. / (1_MeV), 0, 2.62827478725743552e-05,
+      0.0172699503600597382, -1.77099448321877513e-06, 0.000338392047693610422,
+      -9.53148133943496205e-10 * 1. / (1_MeV), 0, -0.000120566700934877791,
+      -1.77099448321877513e-06, 3.49290257872780785e-06,
+      -4.25857281398289675e-08, 2.55990108225490642e-09 * 1. / (1_MeV), 0,
+      7.54315472354089557e-07, 0.000338392047693610422,
+      -4.25857281398289675e-08, 7.29711200619931333e-06,
+      -2.28893257339241436e-11 * 1. / (1_MeV), 0,
+      -5.43323675648758046e-08 * 1. / (1_MeV),
+      -9.53148133943496205e-10 * 1. / (1_MeV),
+      2.55990108225490642e-09 * 1. / (1_MeV),
+      -2.28893257339241436e-11 * 1. / (1_MeV),
+      9.44539516045672656e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams75 =
+      BoundParameters(tgContext, std::move(covMat75), params75, perigeeSurface);
   tracks.push_back(boundParams75);
 
   // track 76 :
   BoundVector params76;
-  params76 << 0.00483211036771535873, 19.769775390625, -0.868091702461242676,
-      2.3166813850402832, 0.000847792427521198988 * 1. / (1_MeV), 0;
+  params76 << 0.640764772891998291, -0.930534124374389648, 2.15712094306945801,
+      2.28308653831481934, 0.000431261461926624179 * 1. / (1_MeV), 0;
   Covariance covMat76;
-  covMat76 << 0.00812008138746023178, 0.000241684869612282343,
-      -0.000229342880415569957, 1.22350455006491968e-07,
-      -1.51766456677205247e-07 * 1. / (1_MeV), 0, 0.000241684869612282343,
-      0.0279842410236597061, -1.67820530316218224e-08, 0.000371614228093685849,
-      -3.38119498984475317e-09 * 1. / (1_MeV), 0, -0.000229342880415569957,
-      -1.67820530316218224e-08, 6.68844677420565858e-06,
-      7.68954602593033632e-08, 6.98338608547542169e-09 * 1. / (1_MeV), 0,
-      1.22350455006491968e-07, 0.000371614228093685849, 7.68954602593033632e-08,
-      5.40870951226679608e-06, 3.18987477267544148e-12 * 1. / (1_MeV), 0,
-      -1.51766456677205247e-07 * 1. / (1_MeV),
-      -3.38119498984475317e-09 * 1. / (1_MeV),
-      6.98338608547542169e-09 * 1. / (1_MeV),
-      3.18987477267544148e-12 * 1. / (1_MeV),
-      1.92937235632406612e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform76;
-  ActsSymMatrixD<3> rotMat76;
-  rotMat76 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform76.rotate(rotMat76);
-  transform76.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans76 = std::make_shared<const Transform3D>(transform76);
-  std::shared_ptr<PerigeeSurface> perigeeSurface76 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams76 = BoundParameters(tgContext, std::move(covMat76), params76,
-                                       perigeeSurface76);
+  covMat76 << 0.00260529923252761364, 4.58412423896785499e-05,
+      -6.7969661726482311e-05, 1.81599714744093986e-08,
+      -4.24128181647569863e-08 * 1. / (1_MeV), 0, 4.58412423896785499e-05,
+      0.0122323241084814072, 8.04787994406084613e-08, 0.000150878291840991384,
+      -1.26706283098581222e-08 * 1. / (1_MeV), 0, -6.7969661726482311e-05,
+      8.04787994406084613e-08, 1.85573071576072834e-06, 1.38421707121045597e-08,
+      1.77332557811301974e-09 * 1. / (1_MeV), 0, 1.81599714744093986e-08,
+      0.000150878291840991384, 1.38421707121045597e-08, 2.22777407543617301e-06,
+      -1.58479619806951909e-10 * 1. / (1_MeV), 0,
+      -4.24128181647569863e-08 * 1. / (1_MeV),
+      -1.26706283098581222e-08 * 1. / (1_MeV),
+      1.77332557811301974e-09 * 1. / (1_MeV),
+      -1.58479619806951909e-10 * 1. / (1_MeV),
+      4.6452456464729508e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams76 =
+      BoundParameters(tgContext, std::move(covMat76), params76, perigeeSurface);
   tracks.push_back(boundParams76);
 
   // track 77 :
   BoundVector params77;
-  params77 << -0.310725152492523193, 19.8295936584472656, -0.606030046939849854,
-      2.24497246742248535, 0.000661869533360004425 * 1. / (1_MeV), 0;
+  params77 << 0.653912067413330078, -38.5965461730957031, 2.62386393547058105,
+      2.6188347339630127, -0.000398666656110435724 * 1. / (1_MeV), 0;
   Covariance covMat77;
-  covMat77 << 0.00436511309817433357, 6.84685072450807867e-05,
-      -0.000120994704364630506, -4.90458514285306182e-07,
-      -5.64318242168483114e-08 * 1. / (1_MeV), 0, 6.84685072450807867e-05,
-      0.0149454157799482346, 2.04636767799999282e-07, 0.000205310692185942025,
-      -3.61902676938797707e-10 * 1. / (1_MeV), 0, -0.000120994704364630506,
-      2.04636767799999282e-07, 3.47089417118695565e-06, 4.16973363970233483e-08,
-      2.51792336588650841e-09 * 1. / (1_MeV), 0, -4.90458514285306182e-07,
-      0.000205310692185942025, 4.16973363970233483e-08, 3.3076123600039864e-06,
-      1.49401026311597095e-11 * 1. / (1_MeV), 0,
-      -5.64318242168483114e-08 * 1. / (1_MeV),
-      -3.61902676938797707e-10 * 1. / (1_MeV),
-      2.51792336588650841e-09 * 1. / (1_MeV),
-      1.49401026311597095e-11 * 1. / (1_MeV),
-      7.15068143586350402e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform77;
-  ActsSymMatrixD<3> rotMat77;
-  rotMat77 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform77.rotate(rotMat77);
-  transform77.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans77 = std::make_shared<const Transform3D>(transform77);
-  std::shared_ptr<PerigeeSurface> perigeeSurface77 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams77 = BoundParameters(tgContext, std::move(covMat77), params77,
-                                       perigeeSurface77);
+  covMat77 << 0.00521424366161227226, 0.000139879184703866033,
+      -0.000151905000687639944, 1.9792889758053464e-06,
+      -7.62257896696214591e-08 * 1. / (1_MeV), 0, 0.000139879184703866033,
+      0.032011859118938446, -4.45397794194540351e-06, 0.000216144809062415678,
+      4.33223192345790811e-09 * 1. / (1_MeV), 0, -0.000151905000687639944,
+      -4.45397794194540351e-06, 4.54638166047516279e-06,
+      -6.7860751060001615e-08, 3.68501084222524602e-09 * 1. / (1_MeV), 0,
+      1.9792889758053464e-06, 0.000216144809062415678, -6.7860751060001615e-08,
+      1.52451764279248891e-06, -1.26932170430756531e-12 * 1. / (1_MeV), 0,
+      -7.62257896696214591e-08 * 1. / (1_MeV),
+      4.33223192345790811e-09 * 1. / (1_MeV),
+      3.68501084222524602e-09 * 1. / (1_MeV),
+      -1.26932170430756531e-12 * 1. / (1_MeV),
+      7.21128712299901053e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams77 =
+      BoundParameters(tgContext, std::move(covMat77), params77, perigeeSurface);
   tracks.push_back(boundParams77);
 
   // track 78 :
   BoundVector params78;
-  params78 << 0.0993749722838401794, 19.6716022491455078, 2.9211122989654541,
-      2.08926057815551758, 0.00120215211063623428 * 1. / (1_MeV), 0;
+  params78 << -0.147352397441864014, -5.29536819458007812, -2.19698119163513184,
+      2.19908237457275391, 0.000603679509367793798 * 1. / (1_MeV), 0;
   Covariance covMat78;
-  covMat78 << 0.0101556088775396347, 1.73498859834314119e-05,
-      -0.000283271865688924712, -1.78050008267022585e-06,
-      -1.28366707714573746e-07 * 1. / (1_MeV), 0, 1.73498859834314119e-05,
-      0.023284614086151123, 4.02106375070951919e-06, 0.000434507881477119533,
-      -1.13469407774349132e-09 * 1. / (1_MeV), 0, -0.000283271865688924712,
-      4.02106375070951919e-06, 8.19536035123746842e-06, 1.330371940544055e-07,
-      5.98130057573423383e-09 * 1. / (1_MeV), 0, -1.78050008267022585e-06,
-      0.000434507881477119533, 1.330371940544055e-07, 8.93400192580884323e-06,
-      -2.61622173381189258e-12 * 1. / (1_MeV), 0,
-      -1.28366707714573746e-07 * 1. / (1_MeV),
-      -1.13469407774349132e-09 * 1. / (1_MeV),
-      5.98130057573423383e-09 * 1. / (1_MeV),
-      -2.61622173381189258e-12 * 1. / (1_MeV),
-      1.96618277215065973e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform78;
-  ActsSymMatrixD<3> rotMat78;
-  rotMat78 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform78.rotate(rotMat78);
-  transform78.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans78 = std::make_shared<const Transform3D>(transform78);
-  std::shared_ptr<PerigeeSurface> perigeeSurface78 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams78 = BoundParameters(tgContext, std::move(covMat78), params78,
-                                       perigeeSurface78);
+  covMat78 << 0.0025317345280200243, 3.93469647761186486e-06,
+      -7.47220338226873746e-05, -8.47547663426674989e-07,
+      -4.10995834716985269e-08 * 1. / (1_MeV), 0, 3.93469647761186486e-06,
+      0.0137719558551907539, 1.18341805513367972e-06, 0.000192888227764741909,
+      8.4659628993769127e-11 * 1. / (1_MeV), 0, -7.47220338226873746e-05,
+      1.18341805513367972e-06, 2.24668019654927775e-06, 4.44216205306269896e-08,
+      1.9813795664012159e-09 * 1. / (1_MeV), 0, -8.47547663426674989e-07,
+      0.000192888227764741909, 4.44216205306269896e-08, 3.1759927878738381e-06,
+      2.44401588800591696e-11 * 1. / (1_MeV), 0,
+      -4.10995834716985269e-08 * 1. / (1_MeV),
+      8.4659628993769127e-11 * 1. / (1_MeV),
+      1.9813795664012159e-09 * 1. / (1_MeV),
+      2.44401588800591696e-11 * 1. / (1_MeV),
+      6.28857244056035825e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams78 =
+      BoundParameters(tgContext, std::move(covMat78), params78, perigeeSurface);
   tracks.push_back(boundParams78);
 
   // track 79 :
   BoundVector params79;
-  params79 << 0.00076918123522773385, 19.5978374481201172,
-      -0.00888663902878761292, 2.26349568367004395,
-      -5.1679373427759856e-05 * 1. / (1_MeV), 0;
+  params79 << 0.678209245204925537, -26.9999599456787109, 1.87300777435302734,
+      2.68262672424316406, 0.000182776289875619113 * 1. / (1_MeV), 0;
   Covariance covMat79;
-  covMat79 << 0.000472295709187164903, 8.06538544252120891e-05,
-      -5.76326071222579373e-06, 5.02484334678411116e-07,
-      -7.2162471693487795e-09 * 1. / (1_MeV), 0, 8.06538544252120891e-05,
-      0.00591621501371264458, -1.05334511746836201e-06, 2.14457476054835035e-05,
-      -1.67841364746306759e-09 * 1. / (1_MeV), 0, -5.76326071222579373e-06,
-      -1.05334511746836201e-06, 8.51334576168483181e-08,
-      -5.60483430138567528e-09, 9.92946218379075931e-11 * 1. / (1_MeV), 0,
-      5.02484334678411116e-07, 2.14457476054835035e-05,
-      -5.60483430138567528e-09, 1.79219924234530481e-07,
-      -1.48012750336918152e-11 * 1. / (1_MeV), 0,
-      -7.2162471693487795e-09 * 1. / (1_MeV),
-      -1.67841364746306759e-09 * 1. / (1_MeV),
-      9.92946218379075931e-11 * 1. / (1_MeV),
-      -1.48012750336918152e-11 * 1. / (1_MeV),
-      8.22869712906876272e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform79;
-  ActsSymMatrixD<3> rotMat79;
-  rotMat79 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform79.rotate(rotMat79);
-  transform79.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans79 = std::make_shared<const Transform3D>(transform79);
-  std::shared_ptr<PerigeeSurface> perigeeSurface79 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams79 = BoundParameters(tgContext, std::move(covMat79), params79,
-                                       perigeeSurface79);
+  covMat79 << 0.00191749841906130314, 0.000110412661743103727,
+      -5.49806951977405462e-05, 6.60175592356722232e-07,
+      -2.1776932514113485e-08 * 1. / (1_MeV), 0, 0.000110412661743103727,
+      0.0226654317229986191, -6.31152562384800887e-07, 0.000109733381182499073,
+      9.56806544278803705e-10 * 1. / (1_MeV), 0, -5.49806951977405462e-05,
+      -6.31152562384800887e-07, 1.61751074756466551e-06,
+      -8.57919113866550056e-09, 1.02398276394864458e-09 * 1. / (1_MeV), 0,
+      6.60175592356722232e-07, 0.000109733381182499073,
+      -8.57919113866550056e-09, 5.57945270429627271e-07,
+      -9.30864559448818034e-13 * 1. / (1_MeV), 0,
+      -2.1776932514113485e-08 * 1. / (1_MeV),
+      9.56806544278803705e-10 * 1. / (1_MeV),
+      1.02398276394864458e-09 * 1. / (1_MeV),
+      -9.30864559448818034e-13 * 1. / (1_MeV),
+      1.72951982596591947e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams79 =
+      BoundParameters(tgContext, std::move(covMat79), params79, perigeeSurface);
   tracks.push_back(boundParams79);
 
   // track 80 :
   BoundVector params80;
-  params80 << 0.172430276870727539, 20.0516853332519531, 0.0925022587180137634,
-      2.79165339469909668, 0.000355079799192026258 * 1. / (1_MeV), 0;
+  params80 << 0.64381110668182373, -6.46031522750854492, 2.02721667289733887,
+      2.68821907043457031, -0.000553313468117266893 * 1. / (1_MeV), 0;
   Covariance covMat80;
-  covMat80 << 0.0123957395553588867, 0.000276004959343346566,
-      -0.000367529600040991081, -5.44526345620848147e-07,
-      -2.56473787837672908e-07 * 1. / (1_MeV), 0, 0.000276004959343346566,
-      0.149438470602035522, 1.26945466301119017e-05, 0.000484407751120721731,
-      -4.77601393027406713e-09 * 1. / (1_MeV), 0, -0.000367529600040991081,
-      1.26945466301119017e-05, 1.11619228846393526e-05, 7.59736475896802827e-08,
-      1.21717089673328274e-08 * 1. / (1_MeV), 0, -5.44526345620848147e-07,
-      0.000484407751120721731, 7.59736475896802827e-08, 1.61264904363633832e-06,
-      -7.16527986733535845e-12 * 1. / (1_MeV), 0,
-      -2.56473787837672908e-07 * 1. / (1_MeV),
-      -4.77601393027406713e-09 * 1. / (1_MeV),
-      1.21717089673328274e-08 * 1. / (1_MeV),
-      -7.16527986733535845e-12 * 1. / (1_MeV),
-      1.61127389208814975e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform80;
-  ActsSymMatrixD<3> rotMat80;
-  rotMat80 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform80.rotate(rotMat80);
-  transform80.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans80 = std::make_shared<const Transform3D>(transform80);
-  std::shared_ptr<PerigeeSurface> perigeeSurface80 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams80 = BoundParameters(tgContext, std::move(covMat80), params80,
-                                       perigeeSurface80);
+  covMat80 << 0.0134714795276522636, -0.000148150339418309318,
+      -0.000399405999997743766, 3.50936426643331028e-06,
+      -1.66954978163253585e-07 * 1. / (1_MeV), 0, -0.000148150339418309318,
+      0.0778103619813919067, -3.53222213147371605e-06, 0.000429908786653424371,
+      1.29938534403212134e-08 * 1. / (1_MeV), 0, -0.000399405999997743766,
+      -3.53222213147371605e-06, 1.20958047773456201e-05,
+      -1.55765136847599568e-07, 8.36922640021012843e-09 * 1. / (1_MeV), 0,
+      3.50936426643331028e-06, 0.000429908786653424371,
+      -1.55765136847599568e-07, 2.42866008193232119e-06,
+      -5.38086858591292421e-12 * 1. / (1_MeV), 0,
+      -1.66954978163253585e-07 * 1. / (1_MeV),
+      1.29938534403212134e-08 * 1. / (1_MeV),
+      8.36922640021012843e-09 * 1. / (1_MeV),
+      -5.38086858591292421e-12 * 1. / (1_MeV),
+      1.47779136150383295e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams80 =
+      BoundParameters(tgContext, std::move(covMat80), params80, perigeeSurface);
   tracks.push_back(boundParams80);
 
   // track 81 :
   BoundVector params81;
-  params81 << 0.0237218067049980164, 19.884124755859375, -1.31243884563446045,
-      1.17260158061981201, 0.00145791680552065372 * 1. / (1_MeV), 0;
+  params81 << 0.13216361403465271, -5.14932060241699219, 0.880854129791259766,
+      0.992275714874267578, -0.000997516443021595478 * 1. / (1_MeV), 0;
   Covariance covMat81;
-  covMat81 << 0.00926587916910648346, 7.06487595418491801e-05,
-      -0.000277787039323878398, 4.07603821427250781e-06,
-      -1.58449164304071412e-07 * 1. / (1_MeV), 0, 7.06487595418491801e-05,
-      0.0313730873167514801, -6.65579864375914156e-06, 0.000612313813642858889,
-      3.06797580601043898e-10 * 1. / (1_MeV), 0, -0.000277787039323878398,
-      -6.65579864375914156e-06, 8.47732735564932227e-06,
-      -2.17222306747093869e-07, 7.82071353865796235e-09 * 1. / (1_MeV), 0,
-      4.07603821427250781e-06, 0.000612313813642858889,
-      -2.17222306747093869e-07, 1.3626353393192403e-05,
-      7.47614118694918694e-12 * 1. / (1_MeV), 0,
-      -1.58449164304071412e-07 * 1. / (1_MeV),
-      3.06797580601043898e-10 * 1. / (1_MeV),
-      7.82071353865796235e-09 * 1. / (1_MeV),
-      7.47614118694918694e-12 * 1. / (1_MeV),
-      2.8977453769840622e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform81;
-  ActsSymMatrixD<3> rotMat81;
-  rotMat81 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform81.rotate(rotMat81);
-  transform81.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans81 = std::make_shared<const Transform3D>(transform81);
-  std::shared_ptr<PerigeeSurface> perigeeSurface81 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams81 = BoundParameters(tgContext, std::move(covMat81), params81,
-                                       perigeeSurface81);
+  covMat81 << 0.00625587906688451767, -0.000110949013866784292,
+      -0.000185194923985265947, -2.88485291842903976e-06,
+      -9.58251834750225767e-08 * 1. / (1_MeV), 0, -0.000110949013866784292,
+      0.0189361255615949631, 5.522171408563187e-06, 0.000352685543849685001,
+      -3.54823960396222519e-11 * 1. / (1_MeV), 0, -0.000185194923985265947,
+      5.522171408563187e-06, 5.57630210096249357e-06, 1.35760624085924114e-07,
+      4.58229751365888916e-09 * 1. / (1_MeV), 0, -2.88485291842903976e-06,
+      0.000352685543849685001, 1.35760624085924114e-07, 7.01960607329965569e-06,
+      9.7695621439726223e-12 * 1. / (1_MeV), 0,
+      -9.58251834750225767e-08 * 1. / (1_MeV),
+      -3.54823960396222519e-11 * 1. / (1_MeV),
+      4.58229751365888916e-09 * 1. / (1_MeV),
+      9.7695621439726223e-12 * 1. / (1_MeV),
+      1.47325138200038452e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams81 =
+      BoundParameters(tgContext, std::move(covMat81), params81, perigeeSurface);
   tracks.push_back(boundParams81);
 
   // track 82 :
   BoundVector params82;
-  params82 << 0.0107990093529224396, 19.6716117858886719, 1.03559982776641846,
-      1.73082625865936279, -0.000879532191902399063 * 1. / (1_MeV), 0;
+  params82 << 0.227797195315361023, -48.2234649658203125, -2.77569174766540527,
+      0.305090576410293579, -0.000179648617631755769 * 1. / (1_MeV), 0;
   Covariance covMat82;
-  covMat82 << 0.00402391236275434494, 3.20769174601289147e-05,
-      -0.000111254459256007358, 8.45579221821339803e-07,
-      -4.58324536525110618e-08 * 1. / (1_MeV), 0, 3.20769174601289147e-05,
-      0.0170307178050279617, -1.43476733365515181e-06, 0.000387486496341669733,
-      -1.98263687729926011e-09 * 1. / (1_MeV), 0, -0.000111254459256007358,
-      -1.43476733365515181e-06, 3.15253510052571073e-06,
-      -3.93483906027775912e-08, 2.199583121442104e-09 * 1. / (1_MeV), 0,
-      8.45579221821339803e-07, 0.000387486496341669733,
-      -3.93483906027775912e-08, 1.00340321296243928e-05,
-      -8.11770059300461125e-11 * 1. / (1_MeV), 0,
-      -4.58324536525110618e-08 * 1. / (1_MeV),
-      -1.98263687729926011e-09 * 1. / (1_MeV),
-      2.199583121442104e-09 * 1. / (1_MeV),
-      -8.11770059300461125e-11 * 1. / (1_MeV),
-      8.58341592246958385e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform82;
-  ActsSymMatrixD<3> rotMat82;
-  rotMat82 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform82.rotate(rotMat82);
-  transform82.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans82 = std::make_shared<const Transform3D>(transform82);
-  std::shared_ptr<PerigeeSurface> perigeeSurface82 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams82 = BoundParameters(tgContext, std::move(covMat82), params82,
-                                       perigeeSurface82);
+  covMat82 << 0.00557572394609451294, -0.000663197008771320177,
+      -0.000161846338406778913, -1.69794778867290902e-06,
+      -9.04045033146821151e-08 * 1. / (1_MeV), 0, -0.000663197008771320177,
+      0.0660624504089355469, 1.59902907216536034e-05, 0.000168873299181685442,
+      2.14987267373142885e-10 * 1. / (1_MeV), 0, -0.000161846338406778913,
+      1.59902907216536034e-05, 4.86282624478917569e-06, 4.67482134719900594e-08,
+      4.44175415702797833e-09 * 1. / (1_MeV), 0, -1.69794778867290902e-06,
+      0.000168873299181685442, 4.67482134719900594e-08, 4.42445099224642036e-07,
+      8.83536325828199794e-12 * 1. / (1_MeV), 0,
+      -9.04045033146821151e-08 * 1. / (1_MeV),
+      2.14987267373142885e-10 * 1. / (1_MeV),
+      4.44175415702797833e-09 * 1. / (1_MeV),
+      8.83536325828199794e-12 * 1. / (1_MeV),
+      5.34931300644192476e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams82 =
+      BoundParameters(tgContext, std::move(covMat82), params82, perigeeSurface);
   tracks.push_back(boundParams82);
 
   // track 83 :
   BoundVector params83;
-  params83 << -0.0155548518523573875, 19.7591342926025391, 0.363524943590164185,
-      1.25925362110137939, 0.000502271810546517372 * 1. / (1_MeV), 0;
+  params83 << -0.00143859826494008303, -15.1650552749633789,
+      -2.28632807731628418, 0.256175190210342407,
+      0.000115477916551753879 * 1. / (1_MeV), 0;
   Covariance covMat83;
-  covMat83 << 0.00146772642619907856, -2.09037045000602479e-05,
-      -3.96307184598860177e-05, 1.98917565341808915e-07,
-      -2.1828224014850844e-08 * 1. / (1_MeV), 0, -2.09037045000602479e-05,
-      0.0098578035831451416, 3.71240804606546409e-07, 0.000133019349065383567,
-      2.05370209972403466e-09 * 1. / (1_MeV), 0, -3.96307184598860177e-05,
-      3.71240804606546409e-07, 1.11548615677747875e-06, -1.0700920015588702e-08,
-      9.39493443779476572e-10 * 1. / (1_MeV), 0, 1.98917565341808915e-07,
-      0.000133019349065383567, -1.0700920015588702e-08, 2.54624114859325346e-06,
-      1.22768956327870663e-13 * 1. / (1_MeV), 0,
-      -2.1828224014850844e-08 * 1. / (1_MeV),
-      2.05370209972403466e-09 * 1. / (1_MeV),
-      9.39493443779476572e-10 * 1. / (1_MeV),
-      1.22768956327870663e-13 * 1. / (1_MeV),
-      3.11325652757599158e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform83;
-  ActsSymMatrixD<3> rotMat83;
-  rotMat83 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform83.rotate(rotMat83);
-  transform83.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans83 = std::make_shared<const Transform3D>(transform83);
-  std::shared_ptr<PerigeeSurface> perigeeSurface83 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams83 = BoundParameters(tgContext, std::move(covMat83), params83,
-                                       perigeeSurface83);
+  covMat83 << 0.00375564000569283962, -0.000551671739993432088,
+      -0.00010947611885112353, -5.73661445135283778e-07,
+      -4.22778383392875813e-08 * 1. / (1_MeV), 0, -0.000551671739993432088,
+      0.0728673934936523438, 9.0784263305680404e-06, 0.000129420350572193905,
+      2.27171510114886803e-09 * 1. / (1_MeV), 0, -0.00010947611885112353,
+      9.0784263305680404e-06, 3.28997566612088121e-06, 7.07299627862913823e-09,
+      1.99936639608643397e-09 * 1. / (1_MeV), 0, -5.73661445135283778e-07,
+      0.000129420350572193905, 7.07299627862913823e-09, 2.37868235331006872e-07,
+      1.04279595331346869e-12 * 1. / (1_MeV), 0,
+      -4.22778383392875813e-08 * 1. / (1_MeV),
+      2.27171510114886803e-09 * 1. / (1_MeV),
+      1.99936639608643397e-09 * 1. / (1_MeV),
+      1.04279595331346869e-12 * 1. / (1_MeV),
+      1.92760772621536347e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams83 =
+      BoundParameters(tgContext, std::move(covMat83), params83, perigeeSurface);
   tracks.push_back(boundParams83);
 
   // track 84 :
   BoundVector params84;
-  params84 << -0.138253405690193176, 18.5519084930419922, 1.43608295917510986,
-      0.270120680332183838, 0.000328816560795530677 * 1. / (1_MeV), 0;
+  params84 << -0.78146892786026001, -23.751434326171875, -0.999060988426208496,
+      2.0324549674987793, -0.000969979155343025923 * 1. / (1_MeV), 0;
   Covariance covMat84;
-  covMat84 << 0.024482090026140213, -0.00141465310858683861,
-      -0.000727919377154882677, 7.62924836936917779e-07,
-      -2.70713331750664401e-07 * 1. / (1_MeV), 0, -0.00141465310858683861,
-      0.38681483268737793, -3.29131593924930853e-06, 0.000780935381087039492,
-      2.03667202249869457e-08 * 1. / (1_MeV), 0, -0.000727919377154882677,
-      -3.29131593924930853e-06, 2.20086349145276472e-05,
-      -1.08805257496805159e-07, 1.28472546995040731e-08 * 1. / (1_MeV), 0,
-      7.62924836936917779e-07, 0.000780935381087039492,
-      -1.08805257496805159e-07, 1.60606941790319979e-06,
-      6.31240016744585034e-12 * 1. / (1_MeV), 0,
-      -2.70713331750664401e-07 * 1. / (1_MeV),
-      2.03667202249869457e-08 * 1. / (1_MeV),
-      1.28472546995040731e-08 * 1. / (1_MeV),
-      6.31240016744585034e-12 * 1. / (1_MeV),
-      1.31787206147926383e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform84;
-  ActsSymMatrixD<3> rotMat84;
-  rotMat84 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform84.rotate(rotMat84);
-  transform84.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans84 = std::make_shared<const Transform3D>(transform84);
-  std::shared_ptr<PerigeeSurface> perigeeSurface84 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams84 = BoundParameters(tgContext, std::move(covMat84), params84,
-                                       perigeeSurface84);
+  covMat84 << 0.0048350747674703598, 0.000120963946599512005,
+      -0.000144374569500283449, 1.3788048161874064e-06,
+      -7.09094644554907288e-08 * 1. / (1_MeV), 0, 0.000120963946599512005,
+      0.0167757254093885422, -5.14354340070674043e-06, 0.000297219118512754719,
+      -1.79593641161986059e-09 * 1. / (1_MeV), 0, -0.000144374569500283449,
+      -5.14354340070674043e-06, 4.36926575275720097e-06,
+      -7.26679966160986237e-08, 3.53139150458423765e-09 * 1. / (1_MeV), 0,
+      1.3788048161874064e-06, 0.000297219118512754719, -7.26679966160986237e-08,
+      6.093463071010774e-06, 6.19247327016922366e-12 * 1. / (1_MeV), 0,
+      -7.09094644554907288e-08 * 1. / (1_MeV),
+      -1.79593641161986059e-09 * 1. / (1_MeV),
+      3.53139150458423765e-09 * 1. / (1_MeV),
+      6.19247327016922366e-12 * 1. / (1_MeV),
+      1.26404206546304465e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams84 =
+      BoundParameters(tgContext, std::move(covMat84), params84, perigeeSurface);
   tracks.push_back(boundParams84);
 
   // track 85 :
   BoundVector params85;
-  params85 << -0.0975429564714431763, 19.5427474975585938, 2.8031013011932373,
-      1.58790135383605957, 0.00166723399888724089 * 1. / (1_MeV), 0;
+  params85 << -0.419987142086029053, -23.2181625366210938, -1.72765111923217773,
+      2.3730311393737793, 0.000834245642181485891 * 1. / (1_MeV), 0;
   Covariance covMat85;
-  covMat85 << 0.0113241951912641525, -9.34923139819065776e-06,
-      -0.000335769282045279361, -2.82633621752857802e-07,
-      -1.5729637539850742e-07 * 1. / (1_MeV), 0, -9.34923139819065776e-06,
-      0.0528257228434085846, 5.71110103579136688e-07, 0.00100043855412109946,
-      -3.03573063913276242e-10 * 1. / (1_MeV), 0, -0.000335769282045279361,
-      5.71110103579136688e-07, 1.01046462077647448e-05, 1.49587275943740115e-08,
-      7.33039139408457665e-09 * 1. / (1_MeV), 0, -2.82633621752857802e-07,
-      0.00100043855412109946, 1.49587275943740115e-08, 2.26391439355211332e-05,
-      1.66413138250011556e-12 * 1. / (1_MeV), 0,
-      -1.5729637539850742e-07 * 1. / (1_MeV),
-      -3.03573063913276242e-10 * 1. / (1_MeV),
-      7.33039139408457665e-09 * 1. / (1_MeV),
-      1.66413138250011556e-12 * 1. / (1_MeV),
-      2.75241468505882381e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform85;
-  ActsSymMatrixD<3> rotMat85;
-  rotMat85 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform85.rotate(rotMat85);
-  transform85.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans85 = std::make_shared<const Transform3D>(transform85);
-  std::shared_ptr<PerigeeSurface> perigeeSurface85 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams85 = BoundParameters(tgContext, std::move(covMat85), params85,
-                                       perigeeSurface85);
+  covMat85 << 0.00711026880890130997, 2.11381997852235886e-05,
+      -0.000214070355238693376, -2.47722478700721587e-06,
+      -1.49308714645023079e-07 * 1. / (1_MeV), 0, 2.11381997852235886e-05,
+      0.0319119654595851898, 4.62741704063705679e-06, 0.000389666316763969648,
+      -4.99086836094690827e-09 * 1. / (1_MeV), 0, -0.000214070355238693376,
+      4.62741704063705679e-06, 6.5447911765659228e-06, 1.4062768144653077e-07,
+      7.23939037737933651e-09 * 1. / (1_MeV), 0, -2.47722478700721587e-06,
+      0.000389666316763969648, 1.4062768144653077e-07, 5.10100881001562811e-06,
+      4.05519853361521036e-12 * 1. / (1_MeV), 0,
+      -1.49308714645023079e-07 * 1. / (1_MeV),
+      -4.99086836094690827e-09 * 1. / (1_MeV),
+      7.23939037737933651e-09 * 1. / (1_MeV),
+      4.05519853361521036e-12 * 1. / (1_MeV),
+      1.97367219789690296e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams85 =
+      BoundParameters(tgContext, std::move(covMat85), params85, perigeeSurface);
   tracks.push_back(boundParams85);
 
   // track 86 :
   BoundVector params86;
-  params86 << -0.0176449194550514221, 19.7948665618896484, -2.85859298706054688,
-      1.93745362758636475, 0.00181531091220676899 * 1. / (1_MeV), 0;
+  params86 << 0.280342727899551392, -1.76902174949645996, 1.17941749095916748,
+      2.43773078918457031, 0.00124833709560334682 * 1. / (1_MeV), 0;
   Covariance covMat86;
-  covMat86 << 0.0164455324411392212, -1.78319115876212784e-05,
-      -0.000476391113400424576, -4.84635611442015516e-06,
-      -2.16420755174177543e-07 * 1. / (1_MeV), 0, -1.78319115876212784e-05,
-      0.0350610315799713135, 7.76663282566612816e-06, 0.00082119930622140565,
-      -2.29522713626592166e-09 * 1. / (1_MeV), 0, -0.000476391113400424576,
-      7.76663282566612816e-06, 1.41888513098820113e-05, 3.09707605227186869e-07,
-      1.05056686720642746e-08 * 1. / (1_MeV), 0, -4.84635611442015516e-06,
-      0.00082119930622140565, 3.09707605227186869e-07, 2.0716039216495119e-05,
-      -3.66067615445536715e-11 * 1. / (1_MeV), 0,
-      -2.16420755174177543e-07 * 1. / (1_MeV),
-      -2.29522713626592166e-09 * 1. / (1_MeV),
-      1.05056686720642746e-08 * 1. / (1_MeV),
-      -3.66067615445536715e-11 * 1. / (1_MeV),
-      3.8617198327983715e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform86;
-  ActsSymMatrixD<3> rotMat86;
-  rotMat86 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform86.rotate(rotMat86);
-  transform86.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans86 = std::make_shared<const Transform3D>(transform86);
-  std::shared_ptr<PerigeeSurface> perigeeSurface86 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams86 = BoundParameters(tgContext, std::move(covMat86), params86,
-                                       perigeeSurface86);
+  covMat86 << 0.0222384743392467499, -0.000469551059919313127,
+      -0.000668093464709992738, -1.03170210424629496e-05,
+      -6.31322167864463976e-07 * 1. / (1_MeV), 0, -0.000469551059919313127,
+      0.0734211504459381104, 3.64346959713435348e-05, 0.000901481115280004927,
+      7.77891238924622843e-09 * 1. / (1_MeV), 0, -0.000668093464709992738,
+      3.64346959713435348e-05, 2.04888619919074699e-05, 5.77626316243002577e-07,
+      3.13812114656612788e-08 * 1. / (1_MeV), 0, -1.03170210424629496e-05,
+      0.000901481115280004927, 5.77626316243002577e-07, 1.12906618596753106e-05,
+      1.32123927173378508e-10 * 1. / (1_MeV), 0,
+      -6.31322167864463976e-07 * 1. / (1_MeV),
+      7.77891238924622843e-09 * 1. / (1_MeV),
+      3.13812114656612788e-08 * 1. / (1_MeV),
+      1.32123927173378508e-10 * 1. / (1_MeV),
+      8.04692867895084873e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams86 =
+      BoundParameters(tgContext, std::move(covMat86), params86, perigeeSurface);
   tracks.push_back(boundParams86);
 
   // track 87 :
   BoundVector params87;
-  params87 << -0.166390389204025269, 19.5272064208984375, 1.93741095066070557,
-      2.24489212036132812, -0.000905173714272677898 * 1. / (1_MeV), 0;
+  params87 << -0.655172765254974365, -26.7765121459960938,
+      -0.736525535583496094, 2.02205944061279297,
+      0.000604338070843368769 * 1. / (1_MeV), 0;
   Covariance covMat87;
-  covMat87 << 0.00758632877841591835, 0.000139937870694665129,
-      -0.00021374593302439404, 2.74308497049270969e-06,
-      -1.22199307635393265e-07 * 1. / (1_MeV), 0, 0.000139937870694665129,
-      0.0236409269273281097, -7.18474418831525274e-06, 0.000356769071380466532,
-      2.17953764438197491e-10 * 1. / (1_MeV), 0, -0.00021374593302439404,
-      -7.18474418831525274e-06, 6.20618220636970364e-06, -1.339422192986325e-07,
-      5.75423109018135768e-09 * 1. / (1_MeV), 0, 2.74308497049270969e-06,
-      0.000356769071380466532, -1.339422192986325e-07, 5.97795133217005059e-06,
-      1.65920987870639118e-13 * 1. / (1_MeV), 0,
-      -1.22199307635393265e-07 * 1. / (1_MeV),
-      2.17953764438197491e-10 * 1. / (1_MeV),
-      5.75423109018135768e-09 * 1. / (1_MeV),
-      1.65920987870639118e-13 * 1. / (1_MeV),
-      1.7132852081491734e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform87;
-  ActsSymMatrixD<3> rotMat87;
-  rotMat87 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform87.rotate(rotMat87);
-  transform87.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans87 = std::make_shared<const Transform3D>(transform87);
-  std::shared_ptr<PerigeeSurface> perigeeSurface87 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams87 = BoundParameters(tgContext, std::move(covMat87), params87,
-                                       perigeeSurface87);
+  covMat87 << 0.00198961631394922733, 3.05661867898970239e-06,
+      -5.82364130628319071e-05, -8.33779895790357002e-07,
+      -3.03302168166956188e-08 * 1. / (1_MeV), 0, 3.05661867898970239e-06,
+      0.00704017188400030136, 3.30304839880078472e-07, 0.000134940363950436851,
+      -3.70578310628897577e-09 * 1. / (1_MeV), 0, -5.82364130628319071e-05,
+      3.30304839880078472e-07, 1.73737998920842074e-06, 3.39209195261311275e-08,
+      1.44265069638837021e-09 * 1. / (1_MeV), 0, -8.33779895790357002e-07,
+      0.000134940363950436851, 3.39209195261311275e-08, 3.01883733300201129e-06,
+      -3.51121860297362421e-11 * 1. / (1_MeV), 0,
+      -3.03302168166956188e-08 * 1. / (1_MeV),
+      -3.70578310628897577e-09 * 1. / (1_MeV),
+      1.44265069638837021e-09 * 1. / (1_MeV),
+      -3.51121860297362421e-11 * 1. / (1_MeV),
+      5.05374214698761648e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams87 =
+      BoundParameters(tgContext, std::move(covMat87), params87, perigeeSurface);
   tracks.push_back(boundParams87);
 
   // track 88 :
   BoundVector params88;
-  params88 << -0.0647897049784660339, 19.7515354156494141, -1.94424092769622803,
-      0.913331747055053711, 0.00144281168468296528 * 1. / (1_MeV), 0;
+  params88 << 0.550101339817047119, -1.01730048656463623, 1.95360791683197021,
+      1.34285402297973633, -0.00163667963352054358 * 1. / (1_MeV), 0;
   Covariance covMat88;
-  covMat88 << 0.0164492577314376831, 0.000114680106948955043,
-      -0.000493878556345173059, 7.55394948756817303e-06,
-      -3.09421204652331308e-07 * 1. / (1_MeV), 0, 0.000114680106948955043,
-      0.0497665181756019592, -1.69407417870949993e-05, 0.000847429052747156815,
-      4.92898530455145555e-09 * 1. / (1_MeV), 0, -0.000493878556345173059,
-      -1.69407417870949993e-05, 1.51399772221338935e-05,
-      -4.57257867983653748e-07, 1.5688536216622446e-08 * 1. / (1_MeV), 0,
-      7.55394948756817303e-06, 0.000847429052747156815,
-      -4.57257867983653748e-07, 1.51720887515693903e-05,
-      7.05942755015551252e-12 * 1. / (1_MeV), 0,
-      -3.09421204652331308e-07 * 1. / (1_MeV),
-      4.92898530455145555e-09 * 1. / (1_MeV),
-      1.5688536216622446e-08 * 1. / (1_MeV),
-      7.05942755015551252e-12 * 1. / (1_MeV),
-      5.00731012209598703e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform88;
-  ActsSymMatrixD<3> rotMat88;
-  rotMat88 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform88.rotate(rotMat88);
-  transform88.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans88 = std::make_shared<const Transform3D>(transform88);
-  std::shared_ptr<PerigeeSurface> perigeeSurface88 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams88 = BoundParameters(tgContext, std::move(covMat88), params88,
-                                       perigeeSurface88);
+  covMat88 << 0.0107496930286288261, -7.68611913775611998e-05,
+      -0.000315102046698671615, -3.90352989298854716e-06,
+      -1.47303449929830411e-07 * 1. / (1_MeV), 0, -7.68611913775611998e-05,
+      0.0372591577470302582, 5.62124909349075963e-06, 0.000868637235426337399,
+      -2.50207485117721545e-09 * 1. / (1_MeV), 0, -0.000315102046698671615,
+      5.62124909349075963e-06, 9.41804592002881691e-06, 2.0220920354903416e-07,
+      7.44695559286270222e-09 * 1. / (1_MeV), 0, -3.90352989298854716e-06,
+      0.000868637235426337399, 2.0220920354903416e-07, 2.23459410335635766e-05,
+      -5.58945405173847072e-11 * 1. / (1_MeV), 0,
+      -1.47303449929830411e-07 * 1. / (1_MeV),
+      -2.50207485117721545e-09 * 1. / (1_MeV),
+      7.44695559286270222e-09 * 1. / (1_MeV),
+      -5.58945405173847072e-11 * 1. / (1_MeV),
+      2.93490870495460854e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams88 =
+      BoundParameters(tgContext, std::move(covMat88), params88, perigeeSurface);
   tracks.push_back(boundParams88);
 
   // track 89 :
   BoundVector params89;
-  params89 << -0.0218852758407592773, 19.7477836608886719, -1.84601056575775146,
-      1.15177929401397705, -0.000602153537329286337 * 1. / (1_MeV), 0;
+  params89 << -0.0243351589888334274, -6.1328587532043457, -2.17217230796813965,
+      0.851706326007843018, -0.00123827718198299408 * 1. / (1_MeV), 0;
   Covariance covMat89;
-  covMat89 << 0.00399546697735786438, -7.6231191425185513e-05,
-      -0.000113968779238574712, -1.06749066545070016e-06,
-      -1.49669197267399396e-07 * 1. / (1_MeV), 0, -7.6231191425185513e-05,
-      0.0129444217309355736, 2.25263525428921646e-06, 0.000202868748994328374,
-      -7.0251938262291757e-09 * 1. / (1_MeV), 0, -0.000113968779238574712,
-      2.25263525428921646e-06, 3.39482835443050135e-06, 3.68428330396706466e-08,
-      7.19219531975148008e-09 * 1. / (1_MeV), 0, -1.06749066545070016e-06,
-      0.000202868748994328374, 3.68428330396706466e-08, 3.95832057620282285e-06,
-      -5.52575945546745665e-11 * 1. / (1_MeV), 0,
-      -1.49669197267399396e-07 * 1. / (1_MeV),
-      -7.0251938262291757e-09 * 1. / (1_MeV),
-      7.19219531975148008e-09 * 1. / (1_MeV),
-      -5.52575945546745665e-11 * 1. / (1_MeV),
-      2.65768212992512076e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform89;
-  ActsSymMatrixD<3> rotMat89;
-  rotMat89 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform89.rotate(rotMat89);
-  transform89.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans89 = std::make_shared<const Transform3D>(transform89);
-  std::shared_ptr<PerigeeSurface> perigeeSurface89 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams89 = BoundParameters(tgContext, std::move(covMat89), params89,
-                                       perigeeSurface89);
+  covMat89 << 0.013601384125649929, -0.000238490415799996243,
+      -0.000407308591532023773, -5.81321625599451904e-06,
+      -2.20563854841242778e-07 * 1. / (1_MeV), 0, -0.000238490415799996243,
+      0.0385725460946559906, 1.44713061143640791e-05, 0.000594927870114984056,
+      -4.2657516143838364e-09 * 1. / (1_MeV), 0, -0.000407308591532023773,
+      1.44713061143640791e-05, 1.23664985949289985e-05, 2.98472027659172679e-07,
+      1.09973686096897418e-08 * 1. / (1_MeV), 0, -5.81321625599451904e-06,
+      0.000594927870114984056, 2.98472027659172679e-07, 9.52084610617021099e-06,
+      -3.86199606571132037e-11 * 1. / (1_MeV), 0,
+      -2.20563854841242778e-07 * 1. / (1_MeV),
+      -4.2657516143838364e-09 * 1. / (1_MeV),
+      1.09973686096897418e-08 * 1. / (1_MeV),
+      -3.86199606571132037e-11 * 1. / (1_MeV),
+      3.39196892795712301e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams89 =
+      BoundParameters(tgContext, std::move(covMat89), params89, perigeeSurface);
   tracks.push_back(boundParams89);
 
   // track 90 :
   BoundVector params90;
-  params90 << -0.179924234747886658, 19.2563438415527344, -1.48651039600372314,
-      2.36299228668212891, -0.00104924733750522137 * 1. / (1_MeV), 0;
+  params90 << 0.723694682121276855, -26.568511962890625, 2.23595356941223145,
+      2.48232841491699219, -0.000482781761093065143 * 1. / (1_MeV), 0;
   Covariance covMat90;
-  covMat90 << 0.0114581910893321037, 0.000363608408604759639,
-      -0.000344876866124296778, 5.81780591102444491e-06,
-      -2.6043200912918554e-07 * 1. / (1_MeV), 0, 0.000363608408604759639,
-      0.0420437715947628021, -1.83725730891767065e-05, 0.000563950407188989035,
-      -4.04684151826768466e-09 * 1. / (1_MeV), 0, -0.000344876866124296778,
-      -1.83725730891767065e-05, 1.06007255453732796e-05,
-      -2.88525393038017665e-07, 1.30515590208839564e-08 * 1. / (1_MeV), 0,
-      5.81780591102444491e-06, 0.000563950407188989035,
-      -2.88525393038017665e-07, 8.05603212938876823e-06,
-      -7.18990753436096707e-11 * 1. / (1_MeV), 0,
-      -2.6043200912918554e-07 * 1. / (1_MeV),
-      -4.04684151826768466e-09 * 1. / (1_MeV),
-      1.30515590208839564e-08 * 1. / (1_MeV),
-      -7.18990753436096707e-11 * 1. / (1_MeV),
-      3.69383551523938536e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform90;
-  ActsSymMatrixD<3> rotMat90;
-  rotMat90 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform90.rotate(rotMat90);
-  transform90.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans90 = std::make_shared<const Transform3D>(transform90);
-  std::shared_ptr<PerigeeSurface> perigeeSurface90 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams90 = BoundParameters(tgContext, std::move(covMat90), params90,
-                                       perigeeSurface90);
+  covMat90 << 0.00387407466769218445, 2.81628374958135634e-05,
+      -0.000114726948246347626, 1.29467025144414135e-06,
+      -9.82718568940813015e-08 * 1. / (1_MeV), 0, 2.81628374958135634e-05,
+      0.0211086571216583252, -1.99152008947953991e-06, 0.000209110626146605873,
+      3.14540254121542699e-09 * 1. / (1_MeV), 0, -0.000114726948246347626,
+      -1.99152008947953991e-06, 3.47766376762592699e-06,
+      -5.54193827886431388e-08, 4.70571016940573361e-09 * 1. / (1_MeV), 0,
+      1.29467025144414135e-06, 0.000209110626146605873,
+      -5.54193827886431388e-08, 2.18847662836196832e-06,
+      -1.76163300018645983e-11 * 1. / (1_MeV), 0,
+      -9.82718568940813015e-08 * 1. / (1_MeV),
+      3.14540254121542699e-09 * 1. / (1_MeV),
+      4.70571016940573361e-09 * 1. / (1_MeV),
+      -1.76163300018645983e-11 * 1. / (1_MeV),
+      1.11767643751203849e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams90 =
+      BoundParameters(tgContext, std::move(covMat90), params90, perigeeSurface);
   tracks.push_back(boundParams90);
 
   // track 91 :
   BoundVector params91;
-  params91 << 0.0888378918170928955, 19.5743637084960938, 2.02936220169067383,
-      0.592313289642333984, -0.00073199498001486063 * 1. / (1_MeV), 0;
+  params91 << -0.2323446124792099, -1.08657681941986084, -2.02921128273010254,
+      1.34838950634002686, -0.000909031485207378864 * 1. / (1_MeV), 0;
   Covariance covMat91;
-  covMat91 << 0.011888476088643074, -0.000364351547358354397,
-      -0.000344164051274786493, -4.80224624851940611e-06,
-      -1.25074865846872421e-07 * 1. / (1_MeV), 0, -0.000364351547358354397,
-      0.0546070896089076996, 1.71846692226701118e-05, 0.000451481364740918725,
-      -6.40392522058036485e-10 * 1. / (1_MeV), 0, -0.000344164051274786493,
-      1.71846692226701118e-05, 1.02026851891423576e-05, 2.02827091730025172e-07,
-      6.16615182332136642e-09 * 1. / (1_MeV), 0, -4.80224624851940611e-06,
-      0.000451481364740918725, 2.02827091730025172e-07, 3.89986053050961345e-06,
-      1.48987059961839454e-11 * 1. / (1_MeV), 0,
-      -1.25074865846872421e-07 * 1. / (1_MeV),
-      -6.40392522058036485e-10 * 1. / (1_MeV),
-      6.16615182332136642e-09 * 1. / (1_MeV),
-      1.48987059961839454e-11 * 1. / (1_MeV),
-      1.37464484240013007e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform91;
-  ActsSymMatrixD<3> rotMat91;
-  rotMat91 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform91.rotate(rotMat91);
-  transform91.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans91 = std::make_shared<const Transform3D>(transform91);
-  std::shared_ptr<PerigeeSurface> perigeeSurface91 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams91 = BoundParameters(tgContext, std::move(covMat91), params91,
-                                       perigeeSurface91);
+  covMat91 << 0.0042699095793068409, -4.94646692795497152e-05,
+      -0.00011729394910827925, -1.00433771415922194e-06,
+      -4.90878501892060452e-08 * 1. / (1_MeV), 0, -4.94646692795497152e-05,
+      0.0193016305565834045, 2.10226265958507905e-06, 0.000365190230248221902,
+      7.18162424846205697e-10 * 1. / (1_MeV), 0, -0.00011729394910827925,
+      2.10226265958507905e-06, 3.3351993806718383e-06, 4.49848539144146812e-08,
+      2.39365529077948547e-09 * 1. / (1_MeV), 0, -1.00433771415922194e-06,
+      0.000365190230248221902, 4.49848539144146812e-08, 8.12437156127998605e-06,
+      1.11281704892510676e-11 * 1. / (1_MeV), 0,
+      -4.90878501892060452e-08 * 1. / (1_MeV),
+      7.18162424846205697e-10 * 1. / (1_MeV),
+      2.39365529077948547e-09 * 1. / (1_MeV),
+      1.11281704892510676e-11 * 1. / (1_MeV),
+      9.21146006693795982e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams91 =
+      BoundParameters(tgContext, std::move(covMat91), params91, perigeeSurface);
   tracks.push_back(boundParams91);
 
   // track 92 :
   BoundVector params92;
-  params92 << 1.12502670288085938, 20.2727298736572266, 2.00401997566223145,
-      0.626365065574645996, -0.00111448660027235746 * 1. / (1_MeV), 0;
+  params92 << 0.265045791864395142, -27.2973098754882812, 1.05269753932952881,
+      2.81940984725952148, -0.000315688434056937695 * 1. / (1_MeV), 0;
   Covariance covMat92;
-  covMat92 << 0.0225118305534124374, 0.000584212031156044944,
-      -0.000666452626493573485, -9.45983147595499108e-06,
-      -3.13759589393168411e-07 * 1. / (1_MeV), 0, 0.000584212031156044944,
-      0.0864472761750221252, 1.9655656094501285e-06, 0.000822762632728434311,
-      -2.92388874702865178e-08 * 1. / (1_MeV), 0, -0.000666452626493573485,
-      1.9655656094501285e-06, 2.00926533580059186e-05, 4.80605470309639927e-07,
-      1.5495058835982803e-08 * 1. / (1_MeV), 0, -9.45983147595499108e-06,
-      0.000822762632728434311, 4.80605470309639927e-07, 8.10808978712884709e-06,
-      1.17184088836066811e-11 * 1. / (1_MeV), 0,
-      -3.13759589393168411e-07 * 1. / (1_MeV),
-      -2.92388874702865178e-08 * 1. / (1_MeV),
-      1.5495058835982803e-08 * 1. / (1_MeV),
-      1.17184088836066811e-11 * 1. / (1_MeV),
-      3.60202312421620263e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform92;
-  ActsSymMatrixD<3> rotMat92;
-  rotMat92 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform92.rotate(rotMat92);
-  transform92.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans92 = std::make_shared<const Transform3D>(transform92);
-  std::shared_ptr<PerigeeSurface> perigeeSurface92 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams92 = BoundParameters(tgContext, std::move(covMat92), params92,
-                                       perigeeSurface92);
+  covMat92 << 0.0140700377523899078, 0.000593323783968879382,
+      -0.000416014263318039551, 3.4111828236548417e-06,
+      -2.73414962589024817e-07 * 1. / (1_MeV), 0, 0.000593323783968879382,
+      0.35917237401008606, -4.08578592997089967e-05, 0.000845220423224244104,
+      1.86785150218537236e-08 * 1. / (1_MeV), 0, -0.000416014263318039551,
+      -4.08578592997089967e-05, 1.27100629470078275e-05,
+      -1.59836018444417662e-07, 1.37035759118268963e-08 * 1. / (1_MeV), 0,
+      3.4111828236548417e-06, 0.000845220423224244104, -1.59836018444417662e-07,
+      2.07905191018653568e-06, 2.14949156818848357e-12 * 1. / (1_MeV), 0,
+      -2.73414962589024817e-07 * 1. / (1_MeV),
+      1.86785150218537236e-08 * 1. / (1_MeV),
+      1.37035759118268963e-08 * 1. / (1_MeV),
+      2.14949156818848357e-12 * 1. / (1_MeV),
+      1.74355599402709061e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams92 =
+      BoundParameters(tgContext, std::move(covMat92), params92, perigeeSurface);
   tracks.push_back(boundParams92);
 
   // track 93 :
   BoundVector params93;
-  params93 << 0.0424742512404918671, 18.9486141204833984, 1.86956024169921875,
-      2.96004772186279297, 4.37863855040632188e-05 * 1. / (1_MeV), 0;
+  params93 << 0.789679765701293945, -24.0303401947021484, 2.51740336418151855,
+      0.428744226694107056, 0.000271489931037649512 * 1. / (1_MeV), 0;
   Covariance covMat93;
-  covMat93 << 0.00272560492157936096, 0.00211849758168023089,
-      -7.31526879372190519e-05, 1.47161851529462088e-06,
-      -2.24706881796614946e-08 * 1. / (1_MeV), 0, 0.00211849758168023089,
-      0.109402194619178772, -4.40777842273042759e-05, 8.76258363739740542e-05,
-      -7.98382954847600904e-09 * 1. / (1_MeV), 0, -7.31526879372190519e-05,
-      -4.40777842273042759e-05, 2.04982438845036086e-06,
-      -3.14008128887106979e-08, 9.90149855492210942e-10 * 1. / (1_MeV), 0,
-      1.47161851529462088e-06, 8.76258363739740542e-05,
-      -3.14008128887106979e-08, 7.31033722445317835e-08,
-      -5.93207648040451609e-12 * 1. / (1_MeV), 0,
-      -2.24706881796614946e-08 * 1. / (1_MeV),
-      -7.98382954847600904e-09 * 1. / (1_MeV),
-      9.90149855492210942e-10 * 1. / (1_MeV),
-      -5.93207648040451609e-12 * 1. / (1_MeV),
-      6.39852146960828705e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform93;
-  ActsSymMatrixD<3> rotMat93;
-  rotMat93 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform93.rotate(rotMat93);
-  transform93.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans93 = std::make_shared<const Transform3D>(transform93);
-  std::shared_ptr<PerigeeSurface> perigeeSurface93 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams93 = BoundParameters(tgContext, std::move(covMat93), params93,
-                                       perigeeSurface93);
+  covMat93 << 0.00483581656590104103, -0.00014841558570857861,
+      -0.000137122191448320704, -1.15095639449306219e-06,
+      -5.72764878155495094e-08 * 1. / (1_MeV), 0, -0.00014841558570857861,
+      0.0322524122893810272, -4.39218594800754952e-07, 0.000152778757565279151,
+      -1.06383037100379797e-09 * 1. / (1_MeV), 0, -0.000137122191448320704,
+      -4.39218594800754952e-07, 4.02241357733146288e-06, 1.598528605493444e-08,
+      2.66714797310526465e-09 * 1. / (1_MeV), 0, -1.15095639449306219e-06,
+      0.000152778757565279151, 1.598528605493444e-08, 7.50712217723048525e-07,
+      1.22675320789893397e-11 * 1. / (1_MeV), 0,
+      -5.72764878155495094e-08 * 1. / (1_MeV),
+      -1.06383037100379797e-09 * 1. / (1_MeV),
+      2.66714797310526465e-09 * 1. / (1_MeV),
+      1.22675320789893397e-11 * 1. / (1_MeV),
+      4.13053515002648197e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams93 =
+      BoundParameters(tgContext, std::move(covMat93), params93, perigeeSurface);
   tracks.push_back(boundParams93);
 
   // track 94 :
   BoundVector params94;
-  params94 << 0.0741926580667495728, 19.3120975494384766, -0.158996760845184326,
-      0.275065630674362183, 0.000188159960089251399 * 1. / (1_MeV), 0;
+  params94 << 0.0419332981109619141, -22.403900146484375, 1.04268980026245117,
+      0.541070818901062012, -0.000843891466502100229 * 1. / (1_MeV), 0;
   Covariance covMat94;
-  covMat94 << 0.00854411255568265915, -0.000856847673562337298,
-      -0.000243449563025652623, -9.85362587786612014e-07,
-      -5.40653541002901188e-08 * 1. / (1_MeV), 0, -0.000856847673562337298,
-      0.125519141554832458, 1.11678697417946741e-05, 0.000258925752451969187,
-      1.7425143865914771e-09 * 1. / (1_MeV), 0, -0.000243449563025652623,
-      1.11678697417946741e-05, 7.13488225301261991e-06, 5.42206306027033232e-09,
-      2.68913182114241505e-09 * 1. / (1_MeV), 0, -9.85362587786612014e-07,
-      0.000258925752451969187, 5.42206306027033232e-09, 5.48016146240115631e-07,
-      2.1763511830840563e-12 * 1. / (1_MeV), 0,
-      -5.40653541002901188e-08 * 1. / (1_MeV),
-      1.7425143865914771e-09 * 1. / (1_MeV),
-      2.68913182114241505e-09 * 1. / (1_MeV),
-      2.1763511830840563e-12 * 1. / (1_MeV),
-      2.93287685804166642e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform94;
-  ActsSymMatrixD<3> rotMat94;
-  rotMat94 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform94.rotate(rotMat94);
-  transform94.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans94 = std::make_shared<const Transform3D>(transform94);
-  std::shared_ptr<PerigeeSurface> perigeeSurface94 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams94 = BoundParameters(tgContext, std::move(covMat94), params94,
-                                       perigeeSurface94);
+  covMat94 << 0.0182619895786046982, -0.000309098329579466258,
+      -0.000548046706254767617, -6.4069930181110618e-06,
+      -2.1453733001269524e-07 * 1. / (1_MeV), 0, -0.000309098329579466258,
+      0.0862535983324050903, 2.67156807455599936e-05, 0.000666602107346143339,
+      -5.16283304523887763e-09 * 1. / (1_MeV), 0, -0.000548046706254767617,
+      2.67156807455599936e-05, 1.6711990610929206e-05, 3.3081373187341857e-07,
+      1.096216345456462e-08 * 1. / (1_MeV), 0, -6.4069930181110618e-06,
+      0.000666602107346143339, 3.3081373187341857e-07, 5.25060204381588846e-06,
+      2.56585402895446448e-14 * 1. / (1_MeV), 0,
+      -2.1453733001269524e-07 * 1. / (1_MeV),
+      -5.16283304523887763e-09 * 1. / (1_MeV),
+      1.096216345456462e-08 * 1. / (1_MeV),
+      2.56585402895446448e-14 * 1. / (1_MeV),
+      2.29805854901066198e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams94 =
+      BoundParameters(tgContext, std::move(covMat94), params94, perigeeSurface);
   tracks.push_back(boundParams94);
 
   // track 95 :
   BoundVector params95;
-  params95 << 0.00871588941663503647, 19.6997394561767578, -1.8126060962677002,
-      2.65224313735961914, 0.000173616441315971315 * 1. / (1_MeV), 0;
+  params95 << 0.176779255270957947, -37.7216300964355469, -2.91102933883666992,
+      2.48529434204101562, -0.000805854273494333029 * 1. / (1_MeV), 0;
   Covariance covMat95;
-  covMat95 << 0.0016872126143425703, 0.000139207692137839037,
-      -4.67932554158379929e-05, 4.13046758309523893e-07,
-      -2.15022847730470487e-08 * 1. / (1_MeV), 0, 0.000139207692137839037,
-      0.0162848997861146927, -2.02254704724682222e-06, 8.19432265737622998e-05,
-      -3.67683233513065563e-10 * 1. / (1_MeV), 0, -4.67932554158379929e-05,
-      -2.02254704724682222e-06, 1.35188520289375447e-06,
-      -3.99719230681514876e-09, 9.61695510131444949e-10 * 1. / (1_MeV), 0,
-      4.13046758309523893e-07, 8.19432265737622998e-05,
-      -3.99719230681514876e-09, 4.59278368225568556e-07,
-      1.08766285673392314e-12 * 1. / (1_MeV), 0,
-      -2.15022847730470487e-08 * 1. / (1_MeV),
-      -3.67683233513065563e-10 * 1. / (1_MeV),
-      9.61695510131444949e-10 * 1. / (1_MeV),
-      1.08766285673392314e-12 * 1. / (1_MeV),
-      1.62394785119257534e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform95;
-  ActsSymMatrixD<3> rotMat95;
-  rotMat95 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform95.rotate(rotMat95);
-  transform95.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans95 = std::make_shared<const Transform3D>(transform95);
-  std::shared_ptr<PerigeeSurface> perigeeSurface95 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams95 = BoundParameters(tgContext, std::move(covMat95), params95,
-                                       perigeeSurface95);
+  covMat95 << 0.0118867438286542892, 0.000227795118694210991,
+      -0.000348746534646607244, 4.75699803725603849e-06,
+      -2.10260526953580937e-07 * 1. / (1_MeV), 0, 0.000227795118694210991,
+      0.0444288402795791626, -1.27103127595436328e-05, 0.00044249878890344381,
+      3.24775989820321723e-09 * 1. / (1_MeV), 0, -0.000348746534646607244,
+      -1.27103127595436328e-05, 1.04705995909171179e-05,
+      -2.08165437755266941e-07, 1.02343642189694215e-08 * 1. / (1_MeV), 0,
+      4.75699803725603849e-06, 0.00044249878890344381, -2.08165437755266941e-07,
+      4.59913690065150149e-06, -1.77698327525688441e-11 * 1. / (1_MeV), 0,
+      -2.10260526953580937e-07 * 1. / (1_MeV),
+      3.24775989820321723e-09 * 1. / (1_MeV),
+      1.02343642189694215e-08 * 1. / (1_MeV),
+      -1.77698327525688441e-11 * 1. / (1_MeV),
+      2.43435688274118434e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams95 =
+      BoundParameters(tgContext, std::move(covMat95), params95, perigeeSurface);
   tracks.push_back(boundParams95);
 
   // track 96 :
   BoundVector params96;
-  params96 << -0.479792565107345581, 19.5514030456542969, 1.30992162227630615,
-      2.87463688850402832, -0.000373176822904497385 * 1. / (1_MeV), 0;
+  params96 << 0.447810828685760498, -26.3884296417236328, 1.54339611530303955,
+      1.56189525127410889, 0.00136160221882164478 * 1. / (1_MeV), 0;
   Covariance covMat96;
-  covMat96 << 0.0304757114499807358, 0.00262038861845952575,
-      -0.000909104372409295556, 4.81420582026805876e-06,
-      -3.00973750980190046e-07 * 1. / (1_MeV), 0, 0.00262038861845952575,
-      0.461684495210647583, -0.000119908842389617728, 0.000928506582398690205,
-      -1.58063875508688272e-08 * 1. / (1_MeV), 0, -0.000909104372409295556,
-      -0.000119908842389617728, 2.75514212262351066e-05,
-      -2.30932526667593089e-07, 1.47073159868963048e-08 * 1. / (1_MeV), 0,
-      4.81420582026805876e-06, 0.000928506582398690205,
-      -2.30932526667593089e-07, 1.89259435501298867e-06,
-      -3.4275779025213788e-12 * 1. / (1_MeV), 0,
-      -3.00973750980190046e-07 * 1. / (1_MeV),
-      -1.58063875508688272e-08 * 1. / (1_MeV),
-      1.47073159868963048e-08 * 1. / (1_MeV),
-      -3.4275779025213788e-12 * 1. / (1_MeV),
-      1.52582876888907037e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform96;
-  ActsSymMatrixD<3> rotMat96;
-  rotMat96 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform96.rotate(rotMat96);
-  transform96.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans96 = std::make_shared<const Transform3D>(transform96);
-  std::shared_ptr<PerigeeSurface> perigeeSurface96 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams96 = BoundParameters(tgContext, std::move(covMat96), params96,
-                                       perigeeSurface96);
+  covMat96 << 0.00786379911005496979, 2.44020731388588477e-06,
+      -0.000226637467024543921, 6.05815686194600369e-08,
+      -9.290821859919166e-08 * 1. / (1_MeV), 0, 2.44020731388588477e-06,
+      0.0212073065340518951, -1.41751539171569177e-07, 0.000477572767546785625,
+      -6.58794985364503272e-10 * 1. / (1_MeV), 0, -0.000226637467024543921,
+      -1.41751539171569177e-07, 6.68278789817122743e-06,
+      -3.38178369258151404e-09, 4.51877708122468826e-09 * 1. / (1_MeV), 0,
+      6.05815686194600369e-08, 0.000477572767546785625,
+      -3.38178369258151404e-09, 1.25970709632383659e-05,
+      -7.18296901266119286e-13 * 1. / (1_MeV), 0,
+      -9.290821859919166e-08 * 1. / (1_MeV),
+      -6.58794985364503272e-10 * 1. / (1_MeV),
+      4.51877708122468826e-09 * 1. / (1_MeV),
+      -7.18296901266119286e-13 * 1. / (1_MeV),
+      1.78482867374540888e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams96 =
+      BoundParameters(tgContext, std::move(covMat96), params96, perigeeSurface);
   tracks.push_back(boundParams96);
 
   // track 97 :
   BoundVector params97;
-  params97 << 0.0435044243931770325, 19.5490474700927734, -1.34004080295562744,
-      0.636775732040405273, 0.00095876265550032258 * 1. / (1_MeV), 0;
+  params97 << 0.69138866662979126, -0.824633300304412842, 1.62790572643280029,
+      2.17131519317626953, -0.00157829432282596827 * 1. / (1_MeV), 0;
   Covariance covMat97;
-  covMat97 << 0.0165304504334926605, 8.29496702915483077e-06,
-      -0.000500555157842997754, 3.90666040743467471e-06,
-      -2.32492797224773581e-07 * 1. / (1_MeV), 0, 8.29496702915483077e-06,
-      0.0697377473115921021, -1.69183732968702351e-05, 0.000672615077218085113,
-      4.78769181746032668e-09 * 1. / (1_MeV), 0, -0.000500555157842997754,
-      -1.69183732968702351e-05, 1.53797700477298349e-05,
-      -2.76896198762005315e-07, 1.14306313433277435e-08 * 1. / (1_MeV), 0,
-      3.90666040743467471e-06, 0.000672615077218085113,
-      -2.76896198762005315e-07, 6.75487535772845149e-06,
-      5.33336934367208442e-12 * 1. / (1_MeV), 0,
-      -2.32492797224773581e-07 * 1. / (1_MeV),
-      4.78769181746032668e-09 * 1. / (1_MeV),
-      1.14306313433277435e-08 * 1. / (1_MeV),
-      5.33336934367208442e-12 * 1. / (1_MeV),
-      2.67363853279078967e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform97;
-  ActsSymMatrixD<3> rotMat97;
-  rotMat97 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform97.rotate(rotMat97);
-  transform97.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans97 = std::make_shared<const Transform3D>(transform97);
-  std::shared_ptr<PerigeeSurface> perigeeSurface97 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams97 = BoundParameters(tgContext, std::move(covMat97), params97,
-                                       perigeeSurface97);
+  covMat97 << 0.0180772673338651657, 6.76792935648847091e-05,
+      -0.000534082747176570683, 9.79180919063570467e-06,
+      -2.87445677290829436e-07 * 1. / (1_MeV), 0, 6.76792935648847091e-05,
+      0.0473108701407909393, -1.27657009238910182e-05, 0.000919307781488095115,
+      2.86386577268916162e-09 * 1. / (1_MeV), 0, -0.000534082747176570683,
+      -1.27657009238910182e-05, 1.60557119670556858e-05, -5.161388544210652e-07,
+      1.4339166470730082e-08 * 1. / (1_MeV), 0, 9.79180919063570467e-06,
+      0.000919307781488095115, -5.161388544210652e-07, 1.83516385732218623e-05,
+      -1.41501241215600609e-10 * 1. / (1_MeV), 0,
+      -2.87445677290829436e-07 * 1. / (1_MeV),
+      2.86386577268916162e-09 * 1. / (1_MeV),
+      1.4339166470730082e-08 * 1. / (1_MeV),
+      -1.41501241215600609e-10 * 1. / (1_MeV),
+      4.72637817772181279e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams97 =
+      BoundParameters(tgContext, std::move(covMat97), params97, perigeeSurface);
   tracks.push_back(boundParams97);
 
   // track 98 :
   BoundVector params98;
-  params98 << 0.294112950563430786, 20.2545261383056641, -0.614140152931213379,
-      2.8818819522857666, 0.000281037588138133287 * 1. / (1_MeV), 0;
+  params98 << 2.12992453575134277, -18.7516555786132812, 0.322550356388092041,
+      0.368121087551116943, 0.000346695247571915388 * 1. / (1_MeV), 0;
   Covariance covMat98;
-  covMat98 << 0.0236709490418434143, 0.00249554031068035566,
-      -0.000662619697167173742, 2.34743469108013516e-06,
-      -2.19122332602494014e-07 * 1. / (1_MeV), 0, 0.00249554031068035566,
-      0.38017040491104126, -1.42274220258879397e-05, 0.000682984089483805218,
-      -1.15543562394303679e-08 * 1. / (1_MeV), 0, -0.000662619697167173742,
-      -1.42274220258879397e-05, 1.92686129594221711e-05,
-      2.05189135697031987e-08, 1.0358702081816697e-08 * 1. / (1_MeV), 0,
-      2.34743469108013516e-06, 0.000682984089483805218, 2.05189135697031987e-08,
-      1.2688219612755347e-06, -2.0944363933578172e-11 * 1. / (1_MeV), 0,
-      -2.19122332602494014e-07 * 1. / (1_MeV),
-      -1.15543562394303679e-08 * 1. / (1_MeV),
-      1.0358702081816697e-08 * 1. / (1_MeV),
-      -2.0944363933578172e-11 * 1. / (1_MeV),
-      1.02260803991338634e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform98;
-  ActsSymMatrixD<3> rotMat98;
-  rotMat98 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform98.rotate(rotMat98);
-  transform98.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans98 = std::make_shared<const Transform3D>(transform98);
-  std::shared_ptr<PerigeeSurface> perigeeSurface98 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams98 = BoundParameters(tgContext, std::move(covMat98), params98,
-                                       perigeeSurface98);
+  covMat98 << 0.0101209962740540504, 0.0011374339858220674,
+      -0.000299095329991897287, -3.14932882056957461e-07,
+      -1.65684092374357599e-07 * 1. / (1_MeV), 0, 0.0011374339858220674,
+      0.0939061492681503296, -4.8902690159540195e-05, 0.000337479548580967448,
+      -3.9036311873074078e-08 * 1. / (1_MeV), 0, -0.000299095329991897287,
+      -4.8902690159540195e-05, 9.09368463908322155e-06,
+      -3.51741511269112836e-08, 8.19782135067778202e-09 * 1. / (1_MeV), 0,
+      -3.14932882056957461e-07, 0.000337479548580967448,
+      -3.51741511269112836e-08, 1.25376061532733729e-06,
+      7.26578444477865009e-12 * 1. / (1_MeV), 0,
+      -1.65684092374357599e-07 * 1. / (1_MeV),
+      -3.9036311873074078e-08 * 1. / (1_MeV),
+      8.19782135067778202e-09 * 1. / (1_MeV),
+      7.26578444477865009e-12 * 1. / (1_MeV),
+      1.17719708980779103e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams98 =
+      BoundParameters(tgContext, std::move(covMat98), params98, perigeeSurface);
   tracks.push_back(boundParams98);
 
   // track 99 :
   BoundVector params99;
-  params99 << -0.13228142261505127, 19.8440647125244141, -1.97596120834350586,
-      0.307230293750762939, -0.000209428049856796861 * 1. / (1_MeV), 0;
+  params99 << -0.535510718822479248, -28.7000522613525391,
+      -0.231238842010498047, 1.41121876239776611,
+      0.00161712500266730785 * 1. / (1_MeV), 0;
   Covariance covMat99;
-  covMat99 << 0.0064656953327357769, -0.000491542212342820388,
-      -0.00019640849669221811, -1.26200648361190619e-06,
-      -7.51057490837922185e-08 * 1. / (1_MeV), 0, -0.000491542212342820388,
-      0.0971855819225311279, 1.78855920005378135e-05, 0.000244668503969933625,
-      2.01135045525568458e-09 * 1. / (1_MeV), 0, -0.00019640849669221811,
-      1.78855920005378135e-05, 6.10315464655286632e-06, 4.79157334954937018e-08,
-      3.80545329493034294e-09 * 1. / (1_MeV), 0, -1.26200648361190619e-06,
-      0.000244668503969933625, 4.79157334954937018e-08, 6.40511075289396103e-07,
-      3.52133532247833157e-12 * 1. / (1_MeV), 0,
-      -7.51057490837922185e-08 * 1. / (1_MeV),
-      2.01135045525568458e-09 * 1. / (1_MeV),
-      3.80545329493034294e-09 * 1. / (1_MeV),
-      3.52133532247833157e-12 * 1. / (1_MeV),
-      4.62756812036335674e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform99;
-  ActsSymMatrixD<3> rotMat99;
-  rotMat99 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform99.rotate(rotMat99);
-  transform99.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans99 = std::make_shared<const Transform3D>(transform99);
-  std::shared_ptr<PerigeeSurface> perigeeSurface99 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
-  auto boundParams99 = BoundParameters(tgContext, std::move(covMat99), params99,
-                                       perigeeSurface99);
+  covMat99 << 0.0117115778848528862, -7.67866557470544008e-06,
+      -0.000338518527122336449, 1.34603162757949205e-06,
+      -1.72783210997185512e-07 * 1. / (1_MeV), 0, -7.67866557470544008e-06,
+      0.0252319127321243286, -1.52781402695736202e-06, 0.000597511113212106579,
+      3.90113700709114385e-10 * 1. / (1_MeV), 0, -0.000338518527122336449,
+      -1.52781402695736202e-06, 1.00057823146926239e-05,
+      -8.19645843713344724e-08, 8.35848601602763903e-09 * 1. / (1_MeV), 0,
+      1.34603162757949205e-06, 0.000597511113212106579,
+      -8.19645843713344724e-08, 1.51151134559768252e-05,
+      -1.22177379055824259e-11 * 1. / (1_MeV), 0,
+      -1.72783210997185512e-07 * 1. / (1_MeV),
+      3.90113700709114385e-10 * 1. / (1_MeV),
+      8.35848601602763903e-09 * 1. / (1_MeV),
+      -1.22177379055824259e-11 * 1. / (1_MeV),
+      3.21954796156376233e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams99 =
+      BoundParameters(tgContext, std::move(covMat99), params99, perigeeSurface);
   tracks.push_back(boundParams99);
 
   // track 100 :
   BoundVector params100;
-  params100 << 0.0397286675870418549, 19.8980617523193359, -1.5870441198348999,
-      1.06085562705993652, -0.00154436775483191013 * 1. / (1_MeV), 0;
+  params100 << -0.843921840190887451, -49.1135101318359375,
+      -0.365095585584640503, 2.96138834953308105,
+      -6.34708048892207444e-05 * 1. / (1_MeV), 0;
   Covariance covMat100;
-  covMat100 << 0.0146848792210221291, -0.00024056679482515193,
-      -0.000422761250825204478, -6.59419504288689593e-06,
-      -2.0883759621313093e-07 * 1. / (1_MeV), 0, -0.00024056679482515193,
-      0.0353117473423480988, 1.29517733327191238e-05, 0.000689977822807362863,
-      -2.65977040646537884e-09 * 1. / (1_MeV), 0, -0.000422761250825204478,
-      1.29517733327191238e-05, 1.25361730169970542e-05, 3.29509919866834633e-07,
-      9.87015185549509611e-09 * 1. / (1_MeV), 0, -6.59419504288689593e-06,
-      0.000689977822807362863, 3.29509919866834633e-07, 1.49626648635603487e-05,
-      -5.44243124057383386e-11 * 1. / (1_MeV), 0,
-      -2.0883759621313093e-07 * 1. / (1_MeV),
-      -2.65977040646537884e-09 * 1. / (1_MeV),
-      9.87015185549509611e-09 * 1. / (1_MeV),
-      -5.44243124057383386e-11 * 1. / (1_MeV),
-      3.28629123913515286e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform100;
-  ActsSymMatrixD<3> rotMat100;
-  rotMat100 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform100.rotate(rotMat100);
-  transform100.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans100 = std::make_shared<const Transform3D>(transform100);
-  std::shared_ptr<PerigeeSurface> perigeeSurface100 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat100 << 0.00338416872546076775, 0.00177216971338738029,
+      -9.9789567797386219e-05, 9.88074736457750535e-07,
+      -3.61024835134689107e-08 * 1. / (1_MeV), 0, 0.00177216971338738029,
+      0.116565637290477753, -4.51521351414238938e-05, 0.000105721181896181534,
+      -9.47131199620464829e-09 * 1. / (1_MeV), 0, -9.9789567797386219e-05,
+      -4.51521351414238938e-05, 3.03179808724962641e-06,
+      -2.47402428503374937e-08, 1.75584896641553984e-09 * 1. / (1_MeV), 0,
+      9.88074736457750535e-07, 0.000105721181896181534,
+      -2.47402428503374937e-08, 9.8112643343029049e-08,
+      -1.43857092852611679e-12 * 1. / (1_MeV), 0,
+      -3.61024835134689107e-08 * 1. / (1_MeV),
+      -9.47131199620464829e-09 * 1. / (1_MeV),
+      1.75584896641553984e-09 * 1. / (1_MeV),
+      -1.43857092852611679e-12 * 1. / (1_MeV),
+      1.24140029852948253e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams100 = BoundParameters(tgContext, std::move(covMat100),
-                                        params100, perigeeSurface100);
+                                        params100, perigeeSurface);
   tracks.push_back(boundParams100);
 
   // track 101 :
   BoundVector params101;
-  params101 << -0.0403421521186828613, 20.0219764709472656, 2.98151826858520508,
-      0.283174663782119751, -0.000182216783287003636 * 1. / (1_MeV), 0;
+  params101 << 0.641214549541473389, -26.0584869384765625, 1.89008140563964844,
+      0.860124528408050537, 0.00106167653575539589 * 1. / (1_MeV), 0;
   Covariance covMat101;
-  covMat101 << 0.0106812380254268646, -0.0024943587506664794,
-      -0.00027858873873760296, -4.44244638850068472e-06,
-      -5.26653512387191812e-08 * 1. / (1_MeV), 0, -0.0024943587506664794,
-      0.194047778844833374, 6.18626595670502936e-05, 0.000369563883583051613,
-      5.07052744885661252e-09 * 1. / (1_MeV), 0, -0.00027858873873760296,
-      6.18626595670502936e-05, 7.62251374908373691e-06, 1.15742939569733442e-07,
-      2.35948978506657342e-09 * 1. / (1_MeV), 0, -4.44244638850068472e-06,
-      0.000369563883583051613, 1.15742939569733442e-07, 7.40628024686884601e-07,
-      9.57926490773258748e-12 * 1. / (1_MeV), 0,
-      -5.26653512387191812e-08 * 1. / (1_MeV),
-      5.07052744885661252e-09 * 1. / (1_MeV),
-      2.35948978506657342e-09 * 1. / (1_MeV),
-      9.57926490773258748e-12 * 1. / (1_MeV),
-      2.45328583836634806e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform101;
-  ActsSymMatrixD<3> rotMat101;
-  rotMat101 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform101.rotate(rotMat101);
-  transform101.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans101 = std::make_shared<const Transform3D>(transform101);
-  std::shared_ptr<PerigeeSurface> perigeeSurface101 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat101 << 0.0103070121258497238, 0.000236402176595641814,
+      -0.000307985893857692168, 3.39085785889227025e-06,
+      -1.78250227329527766e-07 * 1. / (1_MeV), 0, 0.000236402176595641814,
+      0.0338090509176254272, -1.38128442497058292e-05, 0.000515236218679150171,
+      4.11640035508361721e-10 * 1. / (1_MeV), 0, -0.000307985893857692168,
+      -1.38128442497058292e-05, 9.32193688640836626e-06,
+      -2.03856681051109258e-07, 8.47974964267322053e-09 * 1. / (1_MeV), 0,
+      3.39085785889227025e-06, 0.000515236218679150171,
+      -2.03856681051109258e-07, 8.28272459330037236e-06,
+      5.47351419013377902e-11 * 1. / (1_MeV), 0,
+      -1.78250227329527766e-07 * 1. / (1_MeV),
+      4.11640035508361721e-10 * 1. / (1_MeV),
+      8.47974964267322053e-09 * 1. / (1_MeV),
+      5.47351419013377902e-11 * 1. / (1_MeV),
+      2.47352943683054605e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams101 = BoundParameters(tgContext, std::move(covMat101),
-                                        params101, perigeeSurface101);
+                                        params101, perigeeSurface);
   tracks.push_back(boundParams101);
 
   // track 102 :
   BoundVector params102;
-  params102 << 0.102368071675300598, 19.5361366271972656, 0.766166448593139648,
-      2.5110175609588623, -0.000775155378505587578 * 1. / (1_MeV), 0;
+  params102 << -0.362777590751647949, -46.8636550903320312,
+      0.170416802167892456, 2.36327528953552246,
+      -0.000455565168522298336 * 1. / (1_MeV), 0;
   Covariance covMat102;
-  covMat102 << 0.011576404795050621, 0.000312717534921375974,
-      -0.000335520083970844722, 4.71286322771853713e-06,
-      -1.4290716638334455e-07 * 1. / (1_MeV), 0, 0.000312717534921375974,
-      0.0526967272162437439, -1.61243873360913762e-05, 0.000481644572307707124,
-      2.09254387760536983e-09 * 1. / (1_MeV), 0, -0.000335520083970844722,
-      -1.61243873360913762e-05, 9.90374064713250846e-06,
-      -2.10436751795918073e-07, 6.86918188030268416e-09 * 1. / (1_MeV), 0,
-      4.71286322771853713e-06, 0.000481644572307707124,
-      -2.10436751795918073e-07, 4.60942783320206217e-06,
-      -5.63914956480814653e-12 * 1. / (1_MeV), 0,
-      -1.4290716638334455e-07 * 1. / (1_MeV),
-      2.09254387760536983e-09 * 1. / (1_MeV),
-      6.86918188030268416e-09 * 1. / (1_MeV),
-      -5.63914956480814653e-12 * 1. / (1_MeV),
-      1.56449936339342344e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform102;
-  ActsSymMatrixD<3> rotMat102;
-  rotMat102 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform102.rotate(rotMat102);
-  transform102.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans102 = std::make_shared<const Transform3D>(transform102);
-  std::shared_ptr<PerigeeSurface> perigeeSurface102 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat102 << 0.00364208268001675606, 8.14110252555974963e-05,
+      -0.000105730958373490328, 7.352639037761148e-07,
+      -1.11606862640893415e-07 * 1. / (1_MeV), 0, 8.14110252555974963e-05,
+      0.0136387618258595467, -2.96848315587999865e-06, 0.00014858030669170883,
+      -2.44465634156851802e-09 * 1. / (1_MeV), 0, -0.000105730958373490328,
+      -2.96848315587999865e-06, 3.21430798067012802e-06,
+      -3.21777938528106935e-08, 4.84297827278802643e-09 * 1. / (1_MeV), 0,
+      7.352639037761148e-07, 0.00014858030669170883, -3.21777938528106935e-08,
+      1.92027391676674597e-06, 7.89285090595557677e-12 * 1. / (1_MeV), 0,
+      -1.11606862640893415e-07 * 1. / (1_MeV),
+      -2.44465634156851802e-09 * 1. / (1_MeV),
+      4.84297827278802643e-09 * 1. / (1_MeV),
+      7.89285090595557677e-12 * 1. / (1_MeV),
+      1.05506943459676705e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams102 = BoundParameters(tgContext, std::move(covMat102),
-                                        params102, perigeeSurface102);
+                                        params102, perigeeSurface);
   tracks.push_back(boundParams102);
 
   // track 103 :
   BoundVector params103;
-  params103 << 0.00269113038666546345, 19.7512493133544922,
-      0.950928092002868652, 1.69274437427520752,
-      -0.000290958356345072389 * 1. / (1_MeV), 0;
+  params103 << -0.40931740403175354, -26.7641277313232422, 0.23282817006111145,
+      1.9218742847442627, -0.00123902841005474329 * 1. / (1_MeV), 0;
   Covariance covMat103;
-  covMat103 << 0.000890406954567879438, 9.06876283418256436e-06,
-      -2.11295340822724774e-05, 9.41784250991205146e-08,
-      -5.2726015222058164e-09 * 1. / (1_MeV), 0, 9.06876283418256436e-06,
-      0.00811147503554821014, -2.45248004436948366e-07, 0.000101593272660637559,
-      -2.7419352860978785e-09 * 1. / (1_MeV), 0, -2.11295340822724774e-05,
-      -2.45248004436948366e-07, 5.30661907305329805e-07,
-      -3.58145452722120584e-09, 2.49822767665423193e-10 * 1. / (1_MeV), 0,
-      9.41784250991205146e-08, 0.000101593272660637559,
-      -3.58145452722120584e-09, 2.08752635444398038e-06,
-      -5.68853159346797837e-11 * 1. / (1_MeV), 0,
-      -5.2726015222058164e-09 * 1. / (1_MeV),
-      -2.7419352860978785e-09 * 1. / (1_MeV),
-      2.49822767665423193e-10 * 1. / (1_MeV),
-      -5.68853159346797837e-11 * 1. / (1_MeV),
-      9.96157063087865779e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform103;
-  ActsSymMatrixD<3> rotMat103;
-  rotMat103 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform103.rotate(rotMat103);
-  transform103.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans103 = std::make_shared<const Transform3D>(transform103);
-  std::shared_ptr<PerigeeSurface> perigeeSurface103 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat103 << 0.00617217039689421654, 8.91950346564854339e-05,
+      -0.000185605375297960145, 1.82571256326137244e-06,
+      -9.99364389719838625e-08 * 1. / (1_MeV), 0, 8.91950346564854339e-05,
+      0.0202017351984977722, -4.70036532729824457e-06, 0.000417853265694033654,
+      -3.42294422890168881e-09 * 1. / (1_MeV), 0, -0.000185605375297960145,
+      -4.70036532729824457e-06, 5.65443906452856027e-06,
+      -9.94552627423270062e-08, 5.03852824195809614e-09 * 1. / (1_MeV), 0,
+      1.82571256326137244e-06, 0.000417853265694033654,
+      -9.94552627423270062e-08, 9.30496571527328342e-06,
+      -5.69843357485556815e-11 * 1. / (1_MeV), 0,
+      -9.99364389719838625e-08 * 1. / (1_MeV),
+      -3.42294422890168881e-09 * 1. / (1_MeV),
+      5.03852824195809614e-09 * 1. / (1_MeV),
+      -5.69843357485556815e-11 * 1. / (1_MeV),
+      1.89580739995420799e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams103 = BoundParameters(tgContext, std::move(covMat103),
-                                        params103, perigeeSurface103);
+                                        params103, perigeeSurface);
   tracks.push_back(boundParams103);
 
   // track 104 :
   BoundVector params104;
-  params104 << -0.245851978659629822, 20.1682567596435547, 1.23872554302215576,
-      0.248893141746520996, 0.000325477973092347383 * 1. / (1_MeV), 0;
+  params104 << -0.404072463512420654, -38.5120201110839844,
+      0.344911128282546997, 1.1619257926940918,
+      0.000986460363492369652 * 1. / (1_MeV), 0;
   Covariance covMat104;
-  covMat104 << 0.0286086816340684891, -0.001356925375741017,
-      -0.000851797951539738228, 1.97126922666860932e-06,
-      -2.43581517567970172e-07 * 1. / (1_MeV), 0, -0.001356925375741017,
-      0.490286678075790405, -8.99033667088915713e-06, 0.000865735597139924494,
-      2.32921530889448322e-08 * 1. / (1_MeV), 0, -0.000851797951539738228,
-      -8.99033667088915713e-06, 2.57704250543611124e-05,
-      -1.44063558527249657e-07, 1.22322871879510032e-08 * 1. / (1_MeV), 0,
-      1.97126922666860932e-06, 0.000865735597139924494,
-      -1.44063558527249657e-07, 1.54735130308836233e-06,
-      2.09896768832773089e-12 * 1. / (1_MeV), 0,
-      -2.43581517567970172e-07 * 1. / (1_MeV),
-      2.32921530889448322e-08 * 1. / (1_MeV),
-      1.22322871879510032e-08 * 1. / (1_MeV),
-      2.09896768832773089e-12 * 1. / (1_MeV),
-      1.2200331023226596e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform104;
-  ActsSymMatrixD<3> rotMat104;
-  rotMat104 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform104.rotate(rotMat104);
-  transform104.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans104 = std::make_shared<const Transform3D>(transform104);
-  std::shared_ptr<PerigeeSurface> perigeeSurface104 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat104 << 0.00567628862336277962, 1.63609496095437183e-05,
+      -0.000170335731137528478, 1.2532630967862434e-06,
+      -7.98636404443589343e-08 * 1. / (1_MeV), 0, 1.63609496095437183e-05,
+      0.0189783293753862381, -2.2718372282879903e-06, 0.000355776438418386749,
+      -2.11084620426846086e-09 * 1. / (1_MeV), 0, -0.000170335731137528478,
+      -2.2718372282879903e-06, 5.16884620083146729e-06,
+      -7.55285582881687735e-08, 3.807619848578843e-09 * 1. / (1_MeV), 0,
+      1.2532630967862434e-06, 0.000355776438418386749, -7.55285582881687735e-08,
+      7.77826517150970176e-06, -9.50285600530462166e-11 * 1. / (1_MeV), 0,
+      -7.98636404443589343e-08 * 1. / (1_MeV),
+      -2.11084620426846086e-09 * 1. / (1_MeV),
+      3.807619848578843e-09 * 1. / (1_MeV),
+      -9.50285600530462166e-11 * 1. / (1_MeV),
+      1.29019364636384637e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams104 = BoundParameters(tgContext, std::move(covMat104),
-                                        params104, perigeeSurface104);
+                                        params104, perigeeSurface);
   tracks.push_back(boundParams104);
 
   // track 105 :
   BoundVector params105;
-  params105 << -0.0600807033479213715, 19.7313117980957031, 2.31984329223632812,
-      1.3616642951965332, 0.000664964492898434401 * 1. / (1_MeV), 0;
+  params105 << -0.748140871524810791, -23.7969169616699219,
+      -1.03605329990386963, 2.42653083801269531,
+      -0.00107949809171259403 * 1. / (1_MeV), 0;
   Covariance covMat105;
-  covMat105 << 0.00314268073998391628, -7.7012257876423378e-06,
-      -8.51334898014966158e-05, 5.89304597370603241e-07,
-      -7.97505446520337312e-08 * 1. / (1_MeV), 0, -7.7012257876423378e-06,
-      0.0102382330223917961, -6.32454788190619239e-07, 0.000178850129128044883,
-      -9.30661620828337703e-09 * 1. / (1_MeV), 0, -8.51334898014966158e-05,
-      -6.32454788190619239e-07, 2.44164994001039304e-06,
-      -2.83573153286948557e-08, 3.20769979461027676e-09 * 1. / (1_MeV), 0,
-      5.89304597370603241e-07, 0.000178850129128044883,
-      -2.83573153286948557e-08, 4.20260403188876808e-06,
-      -1.84237869498140217e-10 * 1. / (1_MeV), 0,
-      -7.97505446520337312e-08 * 1. / (1_MeV),
-      -9.30661620828337703e-09 * 1. / (1_MeV),
-      3.20769979461027676e-09 * 1. / (1_MeV),
-      -1.84237869498140217e-10 * 1. / (1_MeV),
-      9.88064630114138254e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform105;
-  ActsSymMatrixD<3> rotMat105;
-  rotMat105 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform105.rotate(rotMat105);
-  transform105.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans105 = std::make_shared<const Transform3D>(transform105);
-  std::shared_ptr<PerigeeSurface> perigeeSurface105 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat105 << 0.0166618265211582184, 0.000828099383602299449,
+      -0.000494286373322627617, 7.81528533501132929e-06,
+      -2.37068070630336222e-07 * 1. / (1_MeV), 0, 0.000828099383602299449,
+      0.054433431476354599, -3.50962664017384553e-05, 0.000667669965196798754,
+      -8.65990164654914017e-09 * 1. / (1_MeV), 0, -0.000494286373322627617,
+      -3.50962664017384553e-05, 1.49260613397927955e-05,
+      -3.71389679468892074e-07, 1.21273109287785646e-08 * 1. / (1_MeV), 0,
+      7.81528533501132929e-06, 0.000667669965196798754,
+      -3.71389679468892074e-07, 8.39095991977956146e-06,
+      -1.74774216671551251e-11 * 1. / (1_MeV), 0,
+      -2.37068070630336222e-07 * 1. / (1_MeV),
+      -8.65990164654914017e-09 * 1. / (1_MeV),
+      1.21273109287785646e-08 * 1. / (1_MeV),
+      -1.74774216671551251e-11 * 1. / (1_MeV),
+      3.28096633195329446e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams105 = BoundParameters(tgContext, std::move(covMat105),
-                                        params105, perigeeSurface105);
+                                        params105, perigeeSurface);
   tracks.push_back(boundParams105);
 
   // track 106 :
   BoundVector params106;
-  params106 << -0.0632231608033180237, 19.6254329681396484, 1.89337217807769775,
-      0.921234846115112305, -0.000626925728283822536 * 1. / (1_MeV), 0;
+  params106 << -0.1366615891456604, -27.5638828277587891, -2.49039888381958008,
+      2.61403965950012207, -0.000799041183199733496 * 1. / (1_MeV), 0;
   Covariance covMat106;
-  covMat106 << 0.00425710296258330345, -0.000219698489314023703,
-      -0.000117615295422727911, -2.52522899438900064e-06,
-      -5.43295757382818289e-08 * 1. / (1_MeV), 0, -0.000219698489314023703,
-      0.0236179828643798828, 7.04771554651835001e-06, 0.000339162159718363429,
-      -3.13730541114924775e-09 * 1. / (1_MeV), 0, -0.000117615295422727911,
-      7.04771554651835001e-06, 3.34456171913188882e-06, 9.40031753889414598e-08,
-      2.52804058098014408e-09 * 1. / (1_MeV), 0, -2.52522899438900064e-06,
-      0.000339162159718363429, 9.40031753889414598e-08, 5.38931180926738307e-06,
-      -2.20941594381711364e-11 * 1. / (1_MeV), 0,
-      -5.43295757382818289e-08 * 1. / (1_MeV),
-      -3.13730541114924775e-09 * 1. / (1_MeV),
-      2.52804058098014408e-09 * 1. / (1_MeV),
-      -2.20941594381711364e-11 * 1. / (1_MeV),
-      7.74676017778475057e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform106;
-  ActsSymMatrixD<3> rotMat106;
-  rotMat106 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform106.rotate(rotMat106);
-  transform106.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans106 = std::make_shared<const Transform3D>(transform106);
-  std::shared_ptr<PerigeeSurface> perigeeSurface106 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat106 << 0.0195895861834287643, 0.000432913617665369582,
+      -0.000583389996389527331, 5.64615132296629398e-06,
+      -2.21743636175833062e-07 * 1. / (1_MeV), 0, 0.000432913617665369582,
+      0.0853368565440177917, -2.81463041205404891e-05, 0.00062887185835232241,
+      7.3903210045338403e-10 * 1. / (1_MeV), 0, -0.000583389996389527331,
+      -2.81463041205404891e-05, 1.76701887539820746e-05,
+      -2.86129485279660388e-07, 1.13733623250742995e-08 * 1. / (1_MeV), 0,
+      5.64615132296629398e-06, 0.00062887185835232241, -2.86129485279660388e-07,
+      4.7167955017357599e-06, -6.31956258410507594e-12 * 1. / (1_MeV), 0,
+      -2.21743636175833062e-07 * 1. / (1_MeV),
+      7.3903210045338403e-10 * 1. / (1_MeV),
+      1.13733623250742995e-08 * 1. / (1_MeV),
+      -6.31956258410507594e-12 * 1. / (1_MeV),
+      2.37201536190667639e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams106 = BoundParameters(tgContext, std::move(covMat106),
-                                        params106, perigeeSurface106);
+                                        params106, perigeeSurface);
   tracks.push_back(boundParams106);
 
   // track 107 :
   BoundVector params107;
-  params107 << 0.360552132129669189, 18.9798069000244141, 2.17705512046813965,
-      2.95739436149597168, 0.000170226237969473004 * 1. / (1_MeV), 0;
+  params107 << -0.281952261924743652, -27.2675514221191406,
+      0.283114522695541382, 2.50815463066101074,
+      0.000522553629707545042 * 1. / (1_MeV), 0;
   Covariance covMat107;
-  covMat107 << 0.0202916935086250305, 0.000201601632849784387,
-      -0.000616325805420407701, 1.09389603440618418e-07,
-      -2.32012673409599967e-07 * 1. / (1_MeV), 0, 0.000201601632849784387,
-      0.596419632434844971, 3.27955063214520708e-05, 0.00059099745368901811,
-      1.02858367938844465e-08 * 1. / (1_MeV), 0, -0.000616325805420407701,
-      3.27955063214520708e-05, 1.91301714949076995e-05, 3.16951153463901935e-08,
-      1.15949223809287544e-08 * 1. / (1_MeV), 0, 1.09389603440618418e-07,
-      0.00059099745368901811, 3.16951153463901935e-08, 5.92274261634884169e-07,
-      -2.37559850171720801e-12 * 1. / (1_MeV), 0,
-      -2.32012673409599967e-07 * 1. / (1_MeV),
-      1.02858367938844465e-08 * 1. / (1_MeV),
-      1.15949223809287544e-08 * 1. / (1_MeV),
-      -2.37559850171720801e-12 * 1. / (1_MeV),
-      8.54574952469100424e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform107;
-  ActsSymMatrixD<3> rotMat107;
-  rotMat107 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform107.rotate(rotMat107);
-  transform107.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans107 = std::make_shared<const Transform3D>(transform107);
-  std::shared_ptr<PerigeeSurface> perigeeSurface107 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat107 << 0.00573171814903616905, 0.00019089292202471595,
+      -0.00016298341980869213, -1.57774753003534747e-07,
+      -1.76578997119228594e-07 * 1. / (1_MeV), 0, 0.00019089292202471595,
+      0.0275938734412193298, -6.10260426027345211e-07, 0.000245123840061546561,
+      -1.87936821571313464e-09 * 1. / (1_MeV), 0, -0.00016298341980869213,
+      -6.10260426027345211e-07, 4.82601581097696908e-06,
+      4.47867660897611079e-08, 8.397331774157027e-09 * 1. / (1_MeV), 0,
+      -1.57774753003534747e-07, 0.000245123840061546561,
+      4.47867660897611079e-08, 2.33085211220895872e-06,
+      4.17575815132199387e-11 * 1. / (1_MeV), 0,
+      -1.76578997119228594e-07 * 1. / (1_MeV),
+      -1.87936821571313464e-09 * 1. / (1_MeV),
+      8.397331774157027e-09 * 1. / (1_MeV),
+      4.17575815132199387e-11 * 1. / (1_MeV),
+      1.90833182589500439e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams107 = BoundParameters(tgContext, std::move(covMat107),
-                                        params107, perigeeSurface107);
+                                        params107, perigeeSurface);
   tracks.push_back(boundParams107);
 
   // track 108 :
   BoundVector params108;
-  params108 << -0.0385420434176921844, 19.8494167327880859,
-      -2.91224813461303711, 0.434279114007949829,
-      0.000344612402841448784 * 1. / (1_MeV), 0;
+  params108 << -0.209811851382255554, -38.4141693115234375,
+      -2.18240070343017578, 2.00559163093566895,
+      0.000823514885269105434 * 1. / (1_MeV), 0;
   Covariance covMat108;
-  covMat108 << 0.00708283483982086182, -0.000290315453926490662,
-      -0.000208821270084330699, -4.36274591953509495e-07,
-      -2.0634328653756119e-07 * 1. / (1_MeV), 0, -0.000290315453926490662,
-      0.0554034896194934845, 1.79575900534169211e-06, 0.000262110253474558965,
-      1.13649321255499376e-08 * 1. / (1_MeV), 0, -0.000208821270084330699,
-      1.79575900534169211e-06, 6.40597681922372431e-06,
-      -1.62866970452031225e-08, 9.99126779944540941e-09 * 1. / (1_MeV), 0,
-      -4.36274591953509495e-07, 0.000262110253474558965,
-      -1.62866970452031225e-08, 1.29895113332167966e-06,
-      3.16671471384196928e-11 * 1. / (1_MeV), 0,
-      -2.0634328653756119e-07 * 1. / (1_MeV),
-      1.13649321255499376e-08 * 1. / (1_MeV),
-      9.99126779944540941e-09 * 1. / (1_MeV),
-      3.16671471384196928e-11 * 1. / (1_MeV),
-      1.64341207309348647e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform108;
-  ActsSymMatrixD<3> rotMat108;
-  rotMat108 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform108.rotate(rotMat108);
-  transform108.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans108 = std::make_shared<const Transform3D>(transform108);
-  std::shared_ptr<PerigeeSurface> perigeeSurface108 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat108 << 0.00320075475610792637, -1.04729464667693049e-05,
+      -9.46977753717566058e-05, -8.47132736283527935e-07,
+      -5.70312221165104945e-08 * 1. / (1_MeV), 0, -1.04729464667693049e-05,
+      0.014612528495490551, 1.60439917204324993e-06, 0.00026047244379319754,
+      1.66653208275732943e-09 * 1. / (1_MeV), 0, -9.46977753717566058e-05,
+      1.60439917204324993e-06, 2.8525080324470764e-06, 4.92819818644437109e-08,
+      2.74010143274654739e-09 * 1. / (1_MeV), 0, -8.47132736283527935e-07,
+      0.00026047244379319754, 4.92819818644437109e-08, 5.10619156557368115e-06,
+      4.4716062401029798e-11 * 1. / (1_MeV), 0,
+      -5.70312221165104945e-08 * 1. / (1_MeV),
+      1.66653208275732943e-09 * 1. / (1_MeV),
+      2.74010143274654739e-09 * 1. / (1_MeV),
+      4.4716062401029798e-11 * 1. / (1_MeV),
+      9.70698590951890594e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams108 = BoundParameters(tgContext, std::move(covMat108),
-                                        params108, perigeeSurface108);
+                                        params108, perigeeSurface);
   tracks.push_back(boundParams108);
 
   // track 109 :
   BoundVector params109;
-  params109 << -0.0989816188812255859, 19.6172981262207031,
-      -2.41140604019165039, 0.801270425319671631,
-      -0.000793451210483908653 * 1. / (1_MeV), 0;
+  params109 << 0.400049686431884766, 5.43777561187744141, 1.30985116958618164,
+      0.949728786945343018, 0.00125019415281713009 * 1. / (1_MeV), 0;
   Covariance covMat109;
-  covMat109 << 0.00786646455526351929, -0.000344219331520010437,
-      -0.000221645718673196959, -4.14245788496836856e-06,
-      -1.37193307846517797e-07 * 1. / (1_MeV), 0, -0.000344219331520010437,
-      0.0273069571703672409, 1.18374970750359077e-05, 0.000350145532022221365,
-      2.43323438271879911e-09 * 1. / (1_MeV), 0, -0.000221645718673196959,
-      1.18374970750359077e-05, 6.48815375825506635e-06, 1.56811599604059021e-07,
-      6.52184431015660127e-09 * 1. / (1_MeV), 0, -4.14245788496836856e-06,
-      0.000350145532022221365, 1.56811599604059021e-07, 4.93106381327379495e-06,
-      2.39307717698818543e-11 * 1. / (1_MeV), 0,
-      -1.37193307846517797e-07 * 1. / (1_MeV),
-      2.43323438271879911e-09 * 1. / (1_MeV),
-      6.52184431015660127e-09 * 1. / (1_MeV),
-      2.39307717698818543e-11 * 1. / (1_MeV),
-      1.82697898476469334e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform109;
-  ActsSymMatrixD<3> rotMat109;
-  rotMat109 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform109.rotate(rotMat109);
-  transform109.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans109 = std::make_shared<const Transform3D>(transform109);
-  std::shared_ptr<PerigeeSurface> perigeeSurface109 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat109 << 0.0109754176810383797, 8.39713551440950264e-05,
+      -0.000324492312141962081, 3.05687976180540516e-06,
+      -1.72665763951203633e-07 * 1. / (1_MeV), 0, 8.39713551440950264e-05,
+      0.0270265769213438034, -9.01515946057451831e-06, 0.000490121886147781502,
+      1.08024475744600902e-09 * 1. / (1_MeV), 0, -0.000324492312141962081,
+      -9.01515946057451831e-06, 9.76565206656232476e-06,
+      -2.03225115069697751e-07, 8.22356836237723778e-09 * 1. / (1_MeV), 0,
+      3.05687976180540516e-06, 0.000490121886147781502,
+      -2.03225115069697751e-07, 9.30580608837772161e-06,
+      3.42299696660580778e-11 * 1. / (1_MeV), 0,
+      -1.72665763951203633e-07 * 1. / (1_MeV),
+      1.08024475744600902e-09 * 1. / (1_MeV),
+      8.22356836237723778e-09 * 1. / (1_MeV),
+      3.42299696660580778e-11 * 1. / (1_MeV),
+      2.54714332958982936e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams109 = BoundParameters(tgContext, std::move(covMat109),
-                                        params109, perigeeSurface109);
+                                        params109, perigeeSurface);
   tracks.push_back(boundParams109);
 
   // track 110 :
   BoundVector params110;
-  params110 << -0.248047471046447754, 19.6557636260986328, 2.29302573204040527,
-      0.649587929248809814, -0.00110239081550389528 * 1. / (1_MeV), 0;
+  params110 << -0.539265453815460205, -1.51409578323364258,
+      -1.46416330337524414, 0.445282995700836182,
+      -0.000581343425437808037 * 1. / (1_MeV), 0;
   Covariance covMat110;
-  covMat110 << 0.0216166544705629349, -0.00082482405910012024,
-      -0.000652860285832565414, -1.02919032841101398e-05,
-      -6.52212657639859215e-07 * 1. / (1_MeV), 0, -0.00082482405910012024,
-      0.0853162780404090881, 4.15812377535581474e-05, 0.000839477999853416139,
-      1.85719368884111095e-11 * 1. / (1_MeV), 0, -0.000652860285832565414,
-      4.15812377535581474e-05, 2.00744616449810565e-05, 4.89128117113744387e-07,
-      3.10100339064501893e-08 * 1. / (1_MeV), 0, -1.02919032841101398e-05,
-      0.000839477999853416139, 4.89128117113744387e-07, 8.57177292346023023e-06,
-      1.97141912126868163e-11 * 1. / (1_MeV), 0,
-      -6.52212657639859215e-07 * 1. / (1_MeV),
-      1.85719368884111095e-11 * 1. / (1_MeV),
-      3.10100339064501893e-08 * 1. / (1_MeV),
-      1.97141912126868163e-11 * 1. / (1_MeV),
-      7.19949988514656525e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform110;
-  ActsSymMatrixD<3> rotMat110;
-  rotMat110 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform110.rotate(rotMat110);
-  transform110.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans110 = std::make_shared<const Transform3D>(transform110);
-  std::shared_ptr<PerigeeSurface> perigeeSurface110 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat110 << 0.0150984814390540123, -0.00078787709593504591,
+      -0.000463668385076406234, -3.40126069737758356e-06,
+      -4.7594001233568186e-07 * 1. / (1_MeV), 0, -0.00078787709593504591,
+      0.0981750190258026123, 3.73198782812315689e-05, 0.000517547473711687102,
+      1.71900525614601273e-08 * 1. / (1_MeV), 0, -0.000463668385076406234,
+      3.73198782812315689e-05, 1.45666390380938537e-05, 1.75249294465507646e-07,
+      2.38844165520381005e-08 * 1. / (1_MeV), 0, -3.40126069737758356e-06,
+      0.000517547473711687102, 1.75249294465507646e-07, 2.79596974905871321e-06,
+      1.81008924621221718e-12 * 1. / (1_MeV), 0,
+      -4.7594001233568186e-07 * 1. / (1_MeV),
+      1.71900525614601273e-08 * 1. / (1_MeV),
+      2.38844165520381005e-08 * 1. / (1_MeV),
+      1.81008924621221718e-12 * 1. / (1_MeV),
+      4.11227746299758223e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams110 = BoundParameters(tgContext, std::move(covMat110),
-                                        params110, perigeeSurface110);
+                                        params110, perigeeSurface);
   tracks.push_back(boundParams110);
 
   // track 111 :
   BoundVector params111;
-  params111 << 0.0262720081955194473, 19.8286037445068359, 2.18146443367004395,
-      2.08324813842773438, 0.000428368948632851243 * 1. / (1_MeV), 0;
+  params111 << 0.671114623546600342, -23.2680797576904297, 2.88971590995788574,
+      2.53794145584106445, 0.000528754433616995811 * 1. / (1_MeV), 0;
   Covariance covMat111;
-  covMat111 << 0.00158816727343946695, 9.4853627735629324e-06,
-      -4.36409249479155706e-05, -1.48995811754545918e-07,
-      -2.02757518900558508e-08 * 1. / (1_MeV), 0, 9.4853627735629324e-06,
-      0.0110956495627760887, 3.27586912949563326e-07, 0.000130563462425678848,
-      -4.16497402962450788e-09 * 1. / (1_MeV), 0, -4.36409249479155706e-05,
-      3.27586912949563326e-07, 1.24739369766757591e-06, 1.17262448099841417e-08,
-      8.7129027760781156e-10 * 1. / (1_MeV), 0, -1.48995811754545918e-07,
-      0.000130563462425678848, 1.17262448099841417e-08, 2.20083074964350089e-06,
-      -2.28033377013702109e-11 * 1. / (1_MeV), 0,
-      -2.02757518900558508e-08 * 1. / (1_MeV),
-      -4.16497402962450788e-09 * 1. / (1_MeV),
-      8.7129027760781156e-10 * 1. / (1_MeV),
-      -2.28033377013702109e-11 * 1. / (1_MeV),
-      2.59175268052524999e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform111;
-  ActsSymMatrixD<3> rotMat111;
-  rotMat111 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform111.rotate(rotMat111);
-  transform111.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans111 = std::make_shared<const Transform3D>(transform111);
-  std::shared_ptr<PerigeeSurface> perigeeSurface111 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat111 << 0.00582297053188085556, -0.000178269433632520676,
+      -0.00017064040508346805, -9.16577544786184328e-07,
+      -7.39871471870988742e-08 * 1. / (1_MeV), 0, -0.000178269433632520676,
+      0.0320282876491546631, 9.47676944871473379e-06, 0.000262375079643188658,
+      2.3446639759563834e-09 * 1. / (1_MeV), 0, -0.00017064040508346805,
+      9.47676944871473379e-06, 5.11728148921974935e-06, 6.10420777287489119e-08,
+      3.63856481310620549e-09 * 1. / (1_MeV), 0, -9.16577544786184328e-07,
+      0.000262375079643188658, 6.10420777287489119e-08, 2.29290367315115873e-06,
+      -1.73298870890743619e-12 * 1. / (1_MeV), 0,
+      -7.39871471870988742e-08 * 1. / (1_MeV),
+      2.3446639759563834e-09 * 1. / (1_MeV),
+      3.63856481310620549e-09 * 1. / (1_MeV),
+      -1.73298870890743619e-12 * 1. / (1_MeV),
+      8.13164466317850554e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams111 = BoundParameters(tgContext, std::move(covMat111),
-                                        params111, perigeeSurface111);
+                                        params111, perigeeSurface);
   tracks.push_back(boundParams111);
 
   // track 112 :
   BoundVector params112;
-  params112 << 0.0326793268322944641, 19.8120479583740234, 0.889699041843414307,
-      1.57646119594573975, -0.000467951031168922782 * 1. / (1_MeV), 0;
+  params112 << -0.567338824272155762, -39.2379379272460938,
+      -0.573527812957763672, 2.7919611930847168,
+      0.000323907297570258379 * 1. / (1_MeV), 0;
   Covariance covMat112;
-  covMat112 << 0.0013444551732391119, -1.04196358259948499e-06,
-      -3.51593985940863599e-05, -1.51435614902372445e-08,
-      -2.03697874567189654e-08 * 1. / (1_MeV), 0, -1.04196358259948499e-06,
-      0.0113611593842506409, 2.86736734379056518e-08, 0.000153356229013592134,
-      1.41074638188641834e-10 * 1. / (1_MeV), 0, -3.51593985940863599e-05,
-      2.86736734379056518e-08, 9.62528019954334013e-07, 3.04792415524836218e-10,
-      8.65383902854664365e-10 * 1. / (1_MeV), 0, -1.51435614902372445e-08,
-      0.000153356229013592134, 3.04792415524836218e-10, 3.0196767966117477e-06,
-      -4.83286461545659302e-12 * 1. / (1_MeV), 0,
-      -2.03697874567189654e-08 * 1. / (1_MeV),
-      1.41074638188641834e-10 * 1. / (1_MeV),
-      8.65383902854664365e-10 * 1. / (1_MeV),
-      -4.83286461545659302e-12 * 1. / (1_MeV),
-      2.99355089328212642e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform112;
-  ActsSymMatrixD<3> rotMat112;
-  rotMat112 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform112.rotate(rotMat112);
-  transform112.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans112 = std::make_shared<const Transform3D>(transform112);
-  std::shared_ptr<PerigeeSurface> perigeeSurface112 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat112 << 0.0145241515710949898, 0.00100893966705628622,
+      -0.000435175147220113426, -7.91300794951697705e-07,
+      -1.50984912241323336e-07 * 1. / (1_MeV), 0, 0.00100893966705628622,
+      0.162825420498847961, -1.17342322710575323e-05, 0.000570896267478980253,
+      -1.57354143788096226e-08 * 1. / (1_MeV), 0, -0.000435175147220113426,
+      -1.17342322710575323e-05, 1.32923332785139792e-05,
+      8.24493698474199101e-08, 7.3705206571867806e-09 * 1. / (1_MeV), 0,
+      -7.91300794951697705e-07, 0.000570896267478980253,
+      8.24493698474199101e-08, 2.02825663109251764e-06,
+      -1.36270420577401879e-12 * 1. / (1_MeV), 0,
+      -1.50984912241323336e-07 * 1. / (1_MeV),
+      -1.57354143788096226e-08 * 1. / (1_MeV),
+      7.3705206571867806e-09 * 1. / (1_MeV),
+      -1.36270420577401879e-12 * 1. / (1_MeV),
+      9.7393829112668584e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams112 = BoundParameters(tgContext, std::move(covMat112),
-                                        params112, perigeeSurface112);
+                                        params112, perigeeSurface);
   tracks.push_back(boundParams112);
 
   // track 113 :
   BoundVector params113;
-  params113 << 0.0479989089071750641, 19.5348949432373047, -1.84289538860321045,
-      2.54763102531433105, -0.000563078676350414753 * 1. / (1_MeV), 0;
+  params113 << -0.352110147476196289, -42.806732177734375, -1.94127309322357178,
+      0.234347626566886902, 0.000298306811600923538 * 1. / (1_MeV), 0;
   Covariance covMat113;
-  covMat113 << 0.00674024224281311035, 0.000275261902324333151,
-      -0.000202055961074877318, 2.83455165085094845e-06,
-      -8.66185543146518417e-08 * 1. / (1_MeV), 0, 0.000275261902324333151,
-      0.0429738685488700867, -1.16714247102508588e-05, 0.000340657623151467128,
-      -1.21201365712005428e-09 * 1. / (1_MeV), 0, -0.000202055961074877318,
-      -1.16714247102508588e-05, 6.1798982642358169e-06,
-      -1.17638099338652864e-07, 4.25805894898182396e-09 * 1. / (1_MeV), 0,
-      2.83455165085094845e-06, 0.000340657623151467128,
-      -1.17638099338652864e-07, 2.85863870885805227e-06,
-      -1.98763016529320121e-11 * 1. / (1_MeV), 0,
-      -8.66185543146518417e-08 * 1. / (1_MeV),
-      -1.21201365712005428e-09 * 1. / (1_MeV),
-      4.25805894898182396e-09 * 1. / (1_MeV),
-      -1.98763016529320121e-11 * 1. / (1_MeV),
-      9.45928058104783531e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform113;
-  ActsSymMatrixD<3> rotMat113;
-  rotMat113 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform113.rotate(rotMat113);
-  transform113.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans113 = std::make_shared<const Transform3D>(transform113);
-  std::shared_ptr<PerigeeSurface> perigeeSurface113 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat113 << 0.0297679267823696136, -0.000157760492633259443,
+      -0.000897409671925476033, 5.00768443241615978e-06,
+      -2.84713002525393994e-07 * 1. / (1_MeV), 0, -0.000157760492633259443,
+      0.755975544452667236, -6.81046218350048719e-05, 0.00122586976424697179,
+      3.04180315460180327e-08 * 1. / (1_MeV), 0, -0.000897409671925476033,
+      -6.81046218350048719e-05, 2.75633337878389284e-05,
+      -2.65506639049251932e-07, 1.4268675855279823e-08 * 1. / (1_MeV), 0,
+      5.00768443241615978e-06, 0.00122586976424697179, -2.65506639049251932e-07,
+      2.00353611035097856e-06, -5.77783317368770183e-12 * 1. / (1_MeV), 0,
+      -2.84713002525393994e-07 * 1. / (1_MeV),
+      3.04180315460180327e-08 * 1. / (1_MeV),
+      1.4268675855279823e-08 * 1. / (1_MeV),
+      -5.77783317368770183e-12 * 1. / (1_MeV),
+      1.32142283226777124e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams113 = BoundParameters(tgContext, std::move(covMat113),
-                                        params113, perigeeSurface113);
+                                        params113, perigeeSurface);
   tracks.push_back(boundParams113);
 
   // track 114 :
   BoundVector params114;
-  params114 << -0.166889190673828125, 19.049163818359375, 2.00572776794433594,
-      2.98232221603393555, -5.11993312102276832e-05 * 1. / (1_MeV), 0;
+  params114 << 0.70326077938079834, -23.8514003753662109, 2.19736742973327637,
+      2.66175127029418945, -0.000729386345483362675 * 1. / (1_MeV), 0;
   Covariance covMat114;
-  covMat114 << 0.00352242938242852688, 0.000933588696445512324,
-      -0.000101630702391713315, 5.56225575687583112e-07,
-      -4.72569998214100291e-08 * 1. / (1_MeV), 0, 0.000933588696445512324,
-      0.140665516257286072, -2.55878928890533955e-05, 9.91245475972232033e-05,
-      -4.82721694350305098e-09 * 1. / (1_MeV), 0, -0.000101630702391713315,
-      -2.55878928890533955e-05, 3.07548725686501712e-06,
-      -1.60878195926674544e-08, 2.32450177496049771e-09 * 1. / (1_MeV), 0,
-      5.56225575687583112e-07, 9.91245475972232033e-05,
-      -1.60878195926674544e-08, 7.18341084393614437e-08,
-      -2.32272171088200988e-12 * 1. / (1_MeV), 0,
-      -4.72569998214100291e-08 * 1. / (1_MeV),
-      -4.82721694350305098e-09 * 1. / (1_MeV),
-      2.32450177496049771e-09 * 1. / (1_MeV),
-      -2.32272171088200988e-12 * 1. / (1_MeV),
-      1.44301818758019174e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform114;
-  ActsSymMatrixD<3> rotMat114;
-  rotMat114 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform114.rotate(rotMat114);
-  transform114.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans114 = std::make_shared<const Transform3D>(transform114);
-  std::shared_ptr<PerigeeSurface> perigeeSurface114 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat114 << 0.0201517790555953979, -0.000402410594205282815,
+      -0.000615109406015380898, 6.20916466189531659e-06,
+      -5.01304650979099997e-07 * 1. / (1_MeV), 0, -0.000402410594205282815,
+      0.106326393783092499, -5.39270699210803652e-06, 0.000656929741407722974,
+      4.16003452981261856e-08 * 1. / (1_MeV), 0, -0.000615109406015380898,
+      -5.39270699210803652e-06, 1.91017334145726636e-05,
+      -3.05136297241337109e-07, 2.46257505980399243e-08 * 1. / (1_MeV), 0,
+      6.20916466189531659e-06, 0.000656929741407722974,
+      -3.05136297241337109e-07, 4.13353836847818457e-06,
+      -2.25280483073948522e-11 * 1. / (1_MeV), 0,
+      -5.01304650979099997e-07 * 1. / (1_MeV),
+      4.16003452981261856e-08 * 1. / (1_MeV),
+      2.46257505980399243e-08 * 1. / (1_MeV),
+      -2.25280483073948522e-11 * 1. / (1_MeV),
+      4.48457743162933298e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams114 = BoundParameters(tgContext, std::move(covMat114),
-                                        params114, perigeeSurface114);
+                                        params114, perigeeSurface);
   tracks.push_back(boundParams114);
 
   // track 115 :
   BoundVector params115;
-  params115 << 0.0137746464461088181, 19.6609287261962891, 2.67169976234436035,
-      1.68737459182739258, -0.000312122545437887311 * 1. / (1_MeV), 0;
+  params115 << 0.671093463897705078, -45.1692886352539062, 1.74538934230804443,
+      0.344533443450927734, -0.000281130109215155244 * 1. / (1_MeV), 0;
   Covariance covMat115;
-  covMat115 << 0.00205370550975203514, 2.57276641361198506e-05,
-      -4.35124207927626197e-05, 2.05754998361759643e-07,
-      -7.68677673940147419e-09 * 1. / (1_MeV), 0, 2.57276641361198506e-05,
-      0.00751006556674838066, -5.60196307230371148e-07, 0.000104370906596587887,
-      -2.31954884204932396e-09 * 1. / (1_MeV), 0, -4.35124207927626197e-05,
-      -5.60196307230371148e-07, 9.7233169071841985e-07,
-      -5.78757716049063737e-09, 3.21560072675208627e-10 * 1. / (1_MeV), 0,
-      2.05754998361759643e-07, 0.000104370906596587887,
-      -5.78757716049063737e-09, 2.29740794566168915e-06,
-      -4.91169097872738332e-11 * 1. / (1_MeV), 0,
-      -7.68677673940147419e-09 * 1. / (1_MeV),
-      -2.31954884204932396e-09 * 1. / (1_MeV),
-      3.21560072675208627e-10 * 1. / (1_MeV),
-      -4.91169097872738332e-11 * 1. / (1_MeV),
-      1.16981858228060176e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform115;
-  ActsSymMatrixD<3> rotMat115;
-  rotMat115 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform115.rotate(rotMat115);
-  transform115.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans115 = std::make_shared<const Transform3D>(transform115);
-  std::shared_ptr<PerigeeSurface> perigeeSurface115 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat115 << 0.00903735589236021042, -0.00019873340309471113,
+      -0.000273524033995838783, -2.89533457392990707e-06,
+      -1.61454060310120352e-07 * 1. / (1_MeV), 0, -0.00019873340309471113,
+      0.107433833181858063, 1.17062433953150529e-05, 0.000347414063588650612,
+      -5.60630576356142156e-09 * 1. / (1_MeV), 0, -0.000273524033995838783,
+      1.17062433953150529e-05, 8.43327961774775758e-06, 1.10675918622981839e-07,
+      7.60358813812795812e-09 * 1. / (1_MeV), 0, -2.89533457392990707e-06,
+      0.000347414063588650612, 1.10675918622981839e-07, 1.1579301144593046e-06,
+      3.89686466885357287e-11 * 1. / (1_MeV), 0,
+      -1.61454060310120352e-07 * 1. / (1_MeV),
+      -5.60630576356142156e-09 * 1. / (1_MeV),
+      7.60358813812795812e-09 * 1. / (1_MeV),
+      3.89686466885357287e-11 * 1. / (1_MeV),
+      9.49285094975493848e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams115 = BoundParameters(tgContext, std::move(covMat115),
-                                        params115, perigeeSurface115);
+                                        params115, perigeeSurface);
   tracks.push_back(boundParams115);
 
   // track 116 :
   BoundVector params116;
-  params116 << 1.04568362236022949, 19.1366863250732422, 2.12020516395568848,
-      2.92311358451843262, 9.25068379729054868e-05 * 1. / (1_MeV), 0;
+  params116 << -0.513536512851715088, -24.0025615692138672,
+      -1.29378879070281982, 0.68014836311340332,
+      -0.00116809376049786806 * 1. / (1_MeV), 0;
   Covariance covMat116;
-  covMat116 << 0.00488254847005009651, 0.000740361421888004493,
-      -0.00013463378504927599, 1.2158197600630495e-06,
-      -3.36609027457528485e-08 * 1. / (1_MeV), 0, 0.000740361421888004493,
-      0.114923417568206787, -8.05991571412841247e-06, 0.000146249036050893433,
-      4.20761461930579654e-09 * 1. / (1_MeV), 0, -0.00013463378504927599,
-      -8.05991571412841247e-06, 3.85931298296782188e-06,
-      -2.17580929998134164e-08, 1.60649110182894787e-09 * 1. / (1_MeV), 0,
-      1.2158197600630495e-06, 0.000146249036050893433, -2.17580929998134164e-08,
-      1.92376987229181395e-07, -2.78492110134724017e-12 * 1. / (1_MeV), 0,
-      -3.36609027457528485e-08 * 1. / (1_MeV),
-      4.20761461930579654e-09 * 1. / (1_MeV),
-      1.60649110182894787e-09 * 1. / (1_MeV),
-      -2.78492110134724017e-12 * 1. / (1_MeV),
-      1.35187555594384889e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform116;
-  ActsSymMatrixD<3> rotMat116;
-  rotMat116 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform116.rotate(rotMat116);
-  transform116.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans116 = std::make_shared<const Transform3D>(transform116);
-  std::shared_ptr<PerigeeSurface> perigeeSurface116 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat116 << 0.0196314919739961624, -0.000964473384199337471,
+      -0.000592159047274326794, -1.01560641560312488e-05,
+      -3.59403968241742458e-07 * 1. / (1_MeV), 0, -0.000964473384199337471,
+      0.0900372341275215149, 4.81210676710760611e-05, 0.000917365400873606292,
+      4.18182893772007853e-09 * 1. / (1_MeV), 0, -0.000592159047274326794,
+      4.81210676710760611e-05, 1.81187115231296048e-05, 5.11456018571083069e-07,
+      1.74822784071129361e-08 * 1. / (1_MeV), 0, -1.01560641560312488e-05,
+      0.000917365400873606292, 5.11456018571083069e-07, 9.76017781795235351e-06,
+      -2.45815925497200098e-12 * 1. / (1_MeV), 0,
+      -3.59403968241742458e-07 * 1. / (1_MeV),
+      4.18182893772007853e-09 * 1. / (1_MeV),
+      1.74822784071129361e-08 * 1. / (1_MeV),
+      -2.45815925497200098e-12 * 1. / (1_MeV),
+      4.33391877940891845e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams116 = BoundParameters(tgContext, std::move(covMat116),
-                                        params116, perigeeSurface116);
+                                        params116, perigeeSurface);
   tracks.push_back(boundParams116);
 
   // track 117 :
   BoundVector params117;
-  params117 << -1.20940804481506348, 19.6823959350585938, -1.81289887428283691,
-      0.625804603099822998, 0.000932577764615416527 * 1. / (1_MeV), 0;
+  params117 << -0.188389301300048828, -27.492034912109375, -2.0469822883605957,
+      0.402536779642105103, -0.000401498342398554087 * 1. / (1_MeV), 0;
   Covariance covMat117;
-  covMat117 << 0.0626278072595596313, -0.00168264653846623741,
-      -0.00141945234148735475, 1.67458965126927841e-05,
-      -7.54246802546992556e-07 * 1. / (1_MeV), 0, -0.00168264653846623741,
-      0.230180084705352783, -2.73170868898178382e-06, 0.00158152202219789709,
-      6.02409280618631771e-08 * 1. / (1_MeV), 0, -0.00141945234148735475,
-      -2.73170868898178382e-06, 3.37690398737322539e-05,
-      -7.02785129344153319e-07, 2.29061226487353007e-08 * 1. / (1_MeV), 0,
-      1.67458965126927841e-05, 0.00158152202219789709, -7.02785129344153319e-07,
-      1.19483884191140532e-05, 4.05549492337246129e-12 * 1. / (1_MeV), 0,
-      -7.54246802546992556e-07 * 1. / (1_MeV),
-      6.02409280618631771e-08 * 1. / (1_MeV),
-      2.29061226487353007e-08 * 1. / (1_MeV),
-      4.05549492337246129e-12 * 1. / (1_MeV),
-      3.22085941251160079e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform117;
-  ActsSymMatrixD<3> rotMat117;
-  rotMat117 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform117.rotate(rotMat117);
-  transform117.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans117 = std::make_shared<const Transform3D>(transform117);
-  std::shared_ptr<PerigeeSurface> perigeeSurface117 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat117 << 0.0106127634644508362, -0.000530327986901170411,
+      -0.000318114363953226264, -2.58171609717844701e-06,
+      -3.04161855482286476e-07 * 1. / (1_MeV), 0, -0.000530327986901170411,
+      0.0728393122553825378, 2.18031202084567084e-05, 0.000323112379856879315,
+      8.72212302001908086e-09 * 1. / (1_MeV), 0, -0.000318114363953226264,
+      2.18031202084567084e-05, 9.83124391495948657e-06, 1.0660118653808876e-07,
+      1.49552172231130049e-08 * 1. / (1_MeV), 0, -2.58171609717844701e-06,
+      0.000323112379856879315, 1.0660118653808876e-07, 1.46258253153064288e-06,
+      3.10238162026694015e-11 * 1. / (1_MeV), 0,
+      -3.04161855482286476e-07 * 1. / (1_MeV),
+      8.72212302001908086e-09 * 1. / (1_MeV),
+      1.49552172231130049e-08 * 1. / (1_MeV),
+      3.10238162026694015e-11 * 1. / (1_MeV),
+      2.30750710206173437e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams117 = BoundParameters(tgContext, std::move(covMat117),
-                                        params117, perigeeSurface117);
+                                        params117, perigeeSurface);
   tracks.push_back(boundParams117);
 
   // track 118 :
   BoundVector params118;
-  params118 << -0.103346407413482666, 19.7446269989013672, -1.91661596298217773,
-      1.42171478271484375, 0.000703335157595574856 * 1. / (1_MeV), 0;
+  params118 << -0.0811463147401809692, -27.6623687744140625,
+      0.45338207483291626, 2.77416062355041504,
+      0.000383521459298208356 * 1. / (1_MeV), 0;
   Covariance covMat118;
-  covMat118 << 0.00270943623036146164, -1.17879856763720662e-06,
-      -7.38598630680866423e-05, 3.22994399828456964e-07,
-      -4.07104504838410184e-08 * 1. / (1_MeV), 0, -1.17879856763720662e-06,
-      0.0154081536456942558, -2.72538651083495857e-07, 0.000256186705875633325,
-      6.87005786986738928e-09 * 1. / (1_MeV), 0, -7.38598630680866423e-05,
-      -2.72538651083495857e-07, 2.10873281503154431e-06,
-      -1.4483024887950514e-08, 1.8152406999218687e-09 * 1. / (1_MeV), 0,
-      3.22994399828456964e-07, 0.000256186705875633325, -1.4483024887950514e-08,
-      5.78958861296996474e-06, 9.80498638799178923e-11 * 1. / (1_MeV), 0,
-      -4.07104504838410184e-08 * 1. / (1_MeV),
-      6.87005786986738928e-09 * 1. / (1_MeV),
-      1.8152406999218687e-09 * 1. / (1_MeV),
-      9.80498638799178923e-11 * 1. / (1_MeV),
-      6.60063531610077803e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform118;
-  ActsSymMatrixD<3> rotMat118;
-  rotMat118 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform118.rotate(rotMat118);
-  transform118.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans118 = std::make_shared<const Transform3D>(transform118);
-  std::shared_ptr<PerigeeSurface> perigeeSurface118 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat118 << 0.0120377568528056145, 0.000348936630741464966,
+      -0.000367708072083872627, -4.00268806455590574e-07,
+      -2.44429806871556943e-07 * 1. / (1_MeV), 0, 0.000348936630741464966,
+      0.106920868158340454, 2.02262643355694362e-06, 0.000396612496039519481,
+      -1.29354667260461022e-08 * 1. / (1_MeV), 0, -0.000367708072083872627,
+      2.02262643355694362e-06, 1.14461399789433926e-05, 5.77674609016439322e-08,
+      1.20551713367857255e-08 * 1. / (1_MeV), 0, -4.00268806455590574e-07,
+      0.000396612496039519481, 5.77674609016439322e-08, 1.50108360230660765e-06,
+      -1.71918312121670268e-11 * 1. / (1_MeV), 0,
+      -2.44429806871556943e-07 * 1. / (1_MeV),
+      -1.29354667260461022e-08 * 1. / (1_MeV),
+      1.20551713367857255e-08 * 1. / (1_MeV),
+      -1.71918312121670268e-11 * 1. / (1_MeV),
+      1.72003744580706552e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams118 = BoundParameters(tgContext, std::move(covMat118),
-                                        params118, perigeeSurface118);
+                                        params118, perigeeSurface);
   tracks.push_back(boundParams118);
 
   // track 119 :
   BoundVector params119;
-  params119 << 2.92615675926208496, 17.8650016784667969, -1.95857036113739014,
-      1.128387451171875, 0.00111896148882806301 * 1. / (1_MeV), 0;
+  params119 << -0.669821977615356445, -0.254957705736160278,
+      -0.642573356628417969, 0.338302493095397949,
+      -0.000448048056568950415 * 1. / (1_MeV), 0;
   Covariance covMat119;
-  covMat119 << 0.0144027825444936752, 0.000621878947040222689,
-      -0.0004899059955729096, 7.73510238988940677e-07,
-      -5.53971455935470655e-06 * 1. / (1_MeV), 0, 0.000621878947040222689,
-      0.025294894352555275, -2.52380243351548066e-05, 0.000523347752496337772,
-      -2.67676038791141531e-07 * 1. / (1_MeV), 0, -0.0004899059955729096,
-      -2.52380243351548066e-05, 1.7668540749582462e-05,
-      -8.13551792131595242e-08, 2.65852444971337825e-07 * 1. / (1_MeV), 0,
-      7.73510238988940677e-07, 0.000523347752496337772,
-      -8.13551792131595242e-08, 1.16607652671518736e-05,
-      1.44441837008855634e-09 * 1. / (1_MeV), 0,
-      -5.53971455935470655e-06 * 1. / (1_MeV),
-      -2.67676038791141531e-07 * 1. / (1_MeV),
-      2.65852444971337825e-07 * 1. / (1_MeV),
-      1.44441837008855634e-09 * 1. / (1_MeV),
-      9.32011001708588083e-09 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform119;
-  ActsSymMatrixD<3> rotMat119;
-  rotMat119 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform119.rotate(rotMat119);
-  transform119.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans119 = std::make_shared<const Transform3D>(transform119);
-  std::shared_ptr<PerigeeSurface> perigeeSurface119 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat119 << 0.0216007865965366364, -0.00185881288533683146,
+      -0.000647740560197286076, -4.15704652410560125e-06,
+      -2.75570705855937687e-07 * 1. / (1_MeV), 0, -0.00185881288533683146,
+      0.205522537231445312, 7.6902207402064222e-05, 0.00067089446492805667,
+      2.13544688641597921e-08 * 1. / (1_MeV), 0, -0.000647740560197286076,
+      7.6902207402064222e-05, 1.98106827156152576e-05, 1.96993374819633446e-07,
+      1.39122962799931803e-08 * 1. / (1_MeV), 0, -4.15704652410560125e-06,
+      0.00067089446492805667, 1.96993374819633446e-07, 2.21493996832577977e-06,
+      6.08338264527575119e-12 * 1. / (1_MeV), 0,
+      -2.75570705855937687e-07 * 1. / (1_MeV),
+      2.13544688641597921e-08 * 1. / (1_MeV),
+      1.39122962799931803e-08 * 1. / (1_MeV),
+      6.08338264527575119e-12 * 1. / (1_MeV),
+      1.86805737545370221e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams119 = BoundParameters(tgContext, std::move(covMat119),
-                                        params119, perigeeSurface119);
+                                        params119, perigeeSurface);
   tracks.push_back(boundParams119);
 
   // track 120 :
   BoundVector params120;
-  params120 << -0.0391223952174186707, 19.8085842132568359,
-      -1.63484728336334229, 1.43253195285797119,
-      0.00101388362236320972 * 1. / (1_MeV), 0;
+  params120 << 0.620538651943206787, -5.9463653564453125, 2.88366031646728516,
+      0.806014358997344971, 0.000814548286143690348 * 1. / (1_MeV), 0;
   Covariance covMat120;
-  covMat120 << 0.00591104757040739059, 2.19808179401814768e-05,
-      -0.000175305312354405934, 9.33348192222842228e-07,
-      -8.2119913789129893e-08 * 1. / (1_MeV), 0, 2.19808179401814768e-05,
-      0.0155321685597300529, -1.19100607880362392e-06, 0.000313805117109273242,
-      -4.29338952794729048e-09 * 1. / (1_MeV), 0, -0.000175305312354405934,
-      -1.19100607880362392e-06, 5.27355723534128629e-06,
-      -3.99720907755572675e-08, 3.63588214025051008e-09 * 1. / (1_MeV), 0,
-      9.33348192222842228e-07, 0.000313805117109273242,
-      -3.99720907755572675e-08, 7.98895416664890945e-06,
-      -7.83235112558509684e-11 * 1. / (1_MeV), 0,
-      -8.2119913789129893e-08 * 1. / (1_MeV),
-      -4.29338952794729048e-09 * 1. / (1_MeV),
-      3.63588214025051008e-09 * 1. / (1_MeV),
-      -7.83235112558509684e-11 * 1. / (1_MeV),
-      1.22159560245194143e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform120;
-  ActsSymMatrixD<3> rotMat120;
-  rotMat120 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform120.rotate(rotMat120);
-  transform120.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans120 = std::make_shared<const Transform3D>(transform120);
-  std::shared_ptr<PerigeeSurface> perigeeSurface120 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat120 << 0.00660947803407907486, 0.000148207317841221223,
+      -0.000194191570441951892, 1.81425520658158306e-06,
+      -1.30802501722950138e-07 * 1. / (1_MeV), 0, 0.000148207317841221223,
+      0.0214615482836961746, -8.02621091024865615e-06, 0.000291939065786425093,
+      -3.37860649239220225e-09 * 1. / (1_MeV), 0, -0.000194191570441951892,
+      -8.02621091024865615e-06, 5.84407371206907555e-06,
+      -1.03748135696870454e-07, 6.35917118456449052e-09 * 1. / (1_MeV), 0,
+      1.81425520658158306e-06, 0.000291939065786425093,
+      -1.03748135696870454e-07, 4.28725343226687983e-06,
+      -2.51583629069704591e-11 * 1. / (1_MeV), 0,
+      -1.30802501722950138e-07 * 1. / (1_MeV),
+      -3.37860649239220225e-09 * 1. / (1_MeV),
+      6.35917118456449052e-09 * 1. / (1_MeV),
+      -2.51583629069704591e-11 * 1. / (1_MeV),
+      1.78077538826038051e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams120 = BoundParameters(tgContext, std::move(covMat120),
-                                        params120, perigeeSurface120);
+                                        params120, perigeeSurface);
   tracks.push_back(boundParams120);
 
   // track 121 :
   BoundVector params121;
-  params121 << 3.2684485912322998, -50.3953475952148438, -1.9672924280166626,
-      2.11276745796203613, -0.00146105431485921144 * 1. / (1_MeV), 0;
+  params121 << 0.628487765789031982, -46.8420448303222656, 2.83293843269348145,
+      0.440805107355117798, 0.00010274051601300016 * 1. / (1_MeV), 0;
   Covariance covMat121;
-  covMat121 << 0.0276485588401556015, -0.00123167623434729842,
-      -0.000845118835855476042, 1.50004803399650862e-05,
-      -1.34122397572779639e-07 * 1. / (1_MeV), 0, -0.00123167623434729842,
-      0.0636397004127502441, 2.49535016337183792e-05, 0.00133656416735393577,
-      -2.37478957538643704e-08 * 1. / (1_MeV), 0, -0.000845118835855476042,
-      2.49535016337183792e-05, 2.60623473877785727e-05,
-      -7.59009162244489968e-07, 7.34075798768037725e-09 * 1. / (1_MeV), 0,
-      1.50004803399650862e-05, 0.00133656416735393577, -7.59009162244489968e-07,
-      2.95604022539919242e-05, -8.85865579693641169e-10 * 1. / (1_MeV), 0,
-      -1.34122397572779639e-07 * 1. / (1_MeV),
-      -2.37478957538643704e-08 * 1. / (1_MeV),
-      7.34075798768037725e-09 * 1. / (1_MeV),
-      -8.85865579693641169e-10 * 1. / (1_MeV),
-      2.87734891468716114e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform121;
-  ActsSymMatrixD<3> rotMat121;
-  rotMat121 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform121.rotate(rotMat121);
-  transform121.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans121 = std::make_shared<const Transform3D>(transform121);
-  std::shared_ptr<PerigeeSurface> perigeeSurface121 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat121 << 0.000842933135572820902, -2.19657301004237121e-05,
+      -2.40593078576417954e-05, -2.61079431395439085e-07,
+      -6.29023439716158914e-09 * 1. / (1_MeV), 0, -2.19657301004237121e-05,
+      0.00974787771701812744, -2.23540359415713673e-08, 4.29750192042335346e-05,
+      -3.28310247664964105e-10 * 1. / (1_MeV), 0, -2.40593078576417954e-05,
+      -2.23540359415713673e-08, 7.04093849890341517e-07,
+      5.44971636290248205e-09, 3.05175081762309306e-10 * 1. / (1_MeV), 0,
+      -2.61079431395439085e-07, 4.29750192042335346e-05,
+      5.44971636290248205e-09, 2.0320584326327662e-07,
+      1.64157138196977762e-13 * 1. / (1_MeV), 0,
+      -6.29023439716158914e-09 * 1. / (1_MeV),
+      -3.28310247664964105e-10 * 1. / (1_MeV),
+      3.05175081762309306e-10 * 1. / (1_MeV),
+      1.64157138196977762e-13 * 1. / (1_MeV),
+      5.16425357338645696e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams121 = BoundParameters(tgContext, std::move(covMat121),
-                                        params121, perigeeSurface121);
+                                        params121, perigeeSurface);
   tracks.push_back(boundParams121);
 
   // track 122 :
   BoundVector params122;
-  params122 << 0.645450115203857422, 28.7973823547363281, 2.10054993629455566,
-      2.9601600170135498, -0.000159988034283742309 * 1. / (1_MeV), 0;
+  params122 << -0.812381505966186523, -28.9338283538818359, -1.2193833589553833,
+      1.04633200168609619, 0.00115260039456188679 * 1. / (1_MeV), 0;
   Covariance covMat122;
-  covMat122 << 0.0836148038506507874, -0.00281942085938153468,
-      -0.00185879864445105355, 6.07247514248449154e-06,
-      -7.03189829531797196e-07 * 1. / (1_MeV), 0, -0.00281942085938153468,
-      2.70882201194763184, -5.8760191905531437e-05, 0.00188818417948824089,
-      -4.8300783514351801e-08 * 1. / (1_MeV), 0, -0.00185879864445105355,
-      -5.8760191905531437e-05, 4.32657325291074812e-05,
-      -2.25070179677390569e-07, 2.13601337599813795e-08 * 1. / (1_MeV), 0,
-      6.07247514248449154e-06, 0.00188818417948824089, -2.25070179677390569e-07,
-      1.36935625505429925e-06, -1.00269941249161656e-10 * 1. / (1_MeV), 0,
-      -7.03189829531797196e-07 * 1. / (1_MeV),
-      -4.8300783514351801e-08 * 1. / (1_MeV),
-      2.13601337599813795e-08 * 1. / (1_MeV),
-      -1.00269941249161656e-10 * 1. / (1_MeV),
-      9.22178722273514495e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform122;
-  ActsSymMatrixD<3> rotMat122;
-  rotMat122 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform122.rotate(rotMat122);
-  transform122.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans122 = std::make_shared<const Transform3D>(transform122);
-  std::shared_ptr<PerigeeSurface> perigeeSurface122 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat122 << 0.00886439252644777298, -7.98301718682701986e-05,
+      -0.000261729182772038702, 2.80699128527500705e-06,
+      -1.19181091476079831e-07 * 1. / (1_MeV), 0, -7.98301718682701986e-05,
+      0.0244551245123147964, -1.85192755523473285e-06, 0.000485515751149120391,
+      2.3685986667229676e-09 * 1. / (1_MeV), 0, -0.000261729182772038702,
+      -1.85192755523473285e-06, 7.82700044510420412e-06,
+      -1.65953545175140125e-07, 5.47590882437587651e-09 * 1. / (1_MeV), 0,
+      2.80699128527500705e-06, 0.000485515751149120391,
+      -1.65953545175140125e-07, 1.0220603144261986e-05,
+      -1.07937619402598992e-11 * 1. / (1_MeV), 0,
+      -1.19181091476079831e-07 * 1. / (1_MeV),
+      2.3685986667229676e-09 * 1. / (1_MeV),
+      5.47590882437587651e-09 * 1. / (1_MeV),
+      -1.07937619402598992e-11 * 1. / (1_MeV),
+      1.73649483681259653e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams122 = BoundParameters(tgContext, std::move(covMat122),
-                                        params122, perigeeSurface122);
+                                        params122, perigeeSurface);
   tracks.push_back(boundParams122);
 
   // track 123 :
   BoundVector params123;
-  params123 << -0.260677635669708252, 19.68109130859375, -0.0893123745918273926,
-      2.24275779724121094, 0.000180564093170687556 * 1. / (1_MeV), 0;
+  params123 << 0.674202203750610352, -46.3594818115234375, 2.85884332656860352,
+      0.887206554412841797, -0.000505877542309463024 * 1. / (1_MeV), 0;
   Covariance covMat123;
-  covMat123 << 0.00429143151268362999, -0.000282303309317850546,
-      -5.84570627457094727e-05, -1.77592772045934701e-06,
-      -5.25916079357569643e-08 * 1. / (1_MeV), 0, -0.000282303309317850546,
-      0.0253302454948425293, 3.20487213205718757e-06, 0.00012674431483371596,
-      5.10278523593403899e-09 * 1. / (1_MeV), 0, -5.84570627457094727e-05,
-      3.20487213205718757e-06, 9.13998974283458665e-07, 2.36155606611666679e-08,
-      8.36921112357011164e-10 * 1. / (1_MeV), 0, -1.77592772045934701e-06,
-      0.00012674431483371596, 2.36155606611666679e-08, 9.15854911909264047e-07,
-      4.54410066110091468e-11 * 1. / (1_MeV), 0,
-      -5.25916079357569643e-08 * 1. / (1_MeV),
-      5.10278523593403899e-09 * 1. / (1_MeV),
-      8.36921112357011164e-10 * 1. / (1_MeV),
-      4.54410066110091468e-11 * 1. / (1_MeV),
-      8.13594937948414199e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  Transform3D transform123;
-  ActsSymMatrixD<3> rotMat123;
-  rotMat123 << 1, 0, 0, 0, 1, 0, 0, 0, 1;
-  transform123.rotate(rotMat123);
-  transform123.translation() = Vector3D(-0.5, -0.5, 0);
-  auto sharedTrans123 = std::make_shared<const Transform3D>(transform123);
-  std::shared_ptr<PerigeeSurface> perigeeSurface123 =
-      Surface::makeShared<PerigeeSurface>(Vector3D(-0.5, -0.5, 0));
+  covMat123 << 0.00251318048685789108, -1.66645647325415036e-06,
+      -6.98672509700519375e-05, -7.12881638668814119e-07,
+      -6.71595898982830382e-08 * 1. / (1_MeV), 0, -1.66645647325415036e-06,
+      0.00859435927122831345, 5.71233764557248797e-07, 0.000121854224792618618,
+      1.32173469014469017e-09 * 1. / (1_MeV), 0, -6.98672509700519375e-05,
+      5.71233764557248797e-07, 2.02263481696718372e-06, 3.12296641803006321e-08,
+      3.09126253015111042e-09 * 1. / (1_MeV), 0, -7.12881638668814119e-07,
+      0.000121854224792618618, 3.12296641803006321e-08, 1.98942507267929614e-06,
+      9.00985395948335217e-11 * 1. / (1_MeV), 0,
+      -6.71595898982830382e-08 * 1. / (1_MeV),
+      1.32173469014469017e-09 * 1. / (1_MeV),
+      3.09126253015111042e-09 * 1. / (1_MeV),
+      9.00985395948335217e-11 * 1. / (1_MeV),
+      8.96472895917099777e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
   auto boundParams123 = BoundParameters(tgContext, std::move(covMat123),
-                                        params123, perigeeSurface123);
+                                        params123, perigeeSurface);
   tracks.push_back(boundParams123);
 
+  // track 124 :
+  BoundVector params124;
+  params124 << -0.317187309265136719, -5.00441408157348633,
+      0.162307113409042358, 0.750772595405578613,
+      -0.000692651956342160702 * 1. / (1_MeV), 0;
+  Covariance covMat124;
+  covMat124 << 0.00589033449068665504, -0.000147228859748553363,
+      -0.000171248391294949903, -1.76774655708203412e-06,
+      -1.07121129211567312e-07 * 1. / (1_MeV), 0, -0.000147228859748553363,
+      0.0193875245749950409, 6.6144993330992646e-06, 0.000238616816721432543,
+      1.73743427737471889e-09 * 1. / (1_MeV), 0, -0.000171248391294949903,
+      6.6144993330992646e-06, 5.10799418407259509e-06, 8.27169602099734583e-08,
+      5.19150014241903916e-09 * 1. / (1_MeV), 0, -1.76774655708203412e-06,
+      0.000238616816721432543, 8.27169602099734583e-08, 3.09604706671962049e-06,
+      1.1663553056713431e-11 * 1. / (1_MeV), 0,
+      -1.07121129211567312e-07 * 1. / (1_MeV),
+      1.73743427737471889e-09 * 1. / (1_MeV),
+      5.19150014241903916e-09 * 1. / (1_MeV),
+      1.1663553056713431e-11 * 1. / (1_MeV),
+      1.38518113645957897e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams124 = BoundParameters(tgContext, std::move(covMat124),
+                                        params124, perigeeSurface);
+  tracks.push_back(boundParams124);
+
+  // track 125 :
+  BoundVector params125;
+  params125 << -0.367212682962417603, -26.4488010406494141,
+      -0.589624702930450439, 0.890817821025848389,
+      -0.00130973628256469965 * 1. / (1_MeV), 0;
+  Covariance covMat125;
+  covMat125 << 0.0136615298688411713, -0.000553210438098500888,
+      -0.000408959420512909242, -9.54127328493114892e-06,
+      -2.28585933325679961e-07 * 1. / (1_MeV), 0, -0.000553210438098500888,
+      0.0606655515730381012, 2.85290059337265401e-05, 0.000919541054049329964,
+      6.41373777463503296e-10 * 1. / (1_MeV), 0, -0.000408959420512909242,
+      2.85290059337265401e-05, 1.2425651220837608e-05, 4.81781448104062685e-07,
+      1.15319447682158026e-08 * 1. / (1_MeV), 0, -9.54127328493114892e-06,
+      0.000919541054049329964, 4.81781448104062685e-07, 1.48983235703781247e-05,
+      -4.6401369967705386e-12 * 1. / (1_MeV), 0,
+      -2.28585933325679961e-07 * 1. / (1_MeV),
+      6.41373777463503296e-10 * 1. / (1_MeV),
+      1.15319447682158026e-08 * 1. / (1_MeV),
+      -4.6401369967705386e-12 * 1. / (1_MeV),
+      3.61465746223643691e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams125 = BoundParameters(tgContext, std::move(covMat125),
+                                        params125, perigeeSurface);
+  tracks.push_back(boundParams125);
+
+  // track 126 :
+  BoundVector params126;
+  params126 << -0.819772541522979736, -15.088465690612793, -1.57550454139709473,
+      2.87169027328491211, -0.000316481309710070491 * 1. / (1_MeV), 0;
+  Covariance covMat126;
+  covMat126 << 0.020475972443819046, 0.00244909382101079955,
+      -0.000612602284994073114, 2.84735667237426659e-06,
+      -1.18856619171178898e-07 * 1. / (1_MeV), 0, 0.00244909382101079955,
+      0.285471856594085693, -9.50848052190165181e-05, 0.00060520112781335168,
+      -1.42274967363324924e-08 * 1. / (1_MeV), 0, -0.000612602284994073114,
+      -9.50848052190165181e-05, 1.86471988854464144e-05,
+      -1.33140486250698117e-07, 6.17048734091374837e-09 * 1. / (1_MeV), 0,
+      2.84735667237426659e-06, 0.00060520112781335168, -1.33140486250698117e-07,
+      1.2966377198608825e-06, 1.20738678057781713e-12 * 1. / (1_MeV), 0,
+      -1.18856619171178898e-07 * 1. / (1_MeV),
+      -1.42274967363324924e-08 * 1. / (1_MeV),
+      6.17048734091374837e-09 * 1. / (1_MeV),
+      1.20738678057781713e-12 * 1. / (1_MeV),
+      6.87515253061654619e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams126 = BoundParameters(tgContext, std::move(covMat126),
+                                        params126, perigeeSurface);
+  tracks.push_back(boundParams126);
+
+  // track 127 :
+  BoundVector params127;
+  params127 << -0.318770557641983032, -24.7678050994873047,
+      0.258936554193496704, 0.221435293555259705,
+      0.000250038632657378912 * 1. / (1_MeV), 0;
+  Covariance covMat127;
+  covMat127 << 0.0237364936619997025, -0.00216027412516154932,
+      -0.000714136299484843372, 3.91136153798043594e-07,
+      -1.92060015221202961e-07 * 1. / (1_MeV), 0, -0.00216027412516154932,
+      0.474111497402191162, 2.45504002711651886e-05, 0.000683401475519821908,
+      2.31633021184019983e-08 * 1. / (1_MeV), 0, -0.000714136299484843372,
+      2.45504002711651886e-05, 2.19113735511200503e-05,
+      -6.74041726618829811e-08, 9.78682020756434252e-09 * 1. / (1_MeV), 0,
+      3.91136153798043594e-07, 0.000683401475519821908,
+      -6.74041726618829811e-08, 9.95008008430886548e-07,
+      2.37236751652554644e-12 * 1. / (1_MeV), 0,
+      -1.92060015221202961e-07 * 1. / (1_MeV),
+      2.31633021184019983e-08 * 1. / (1_MeV),
+      9.78682020756434252e-09 * 1. / (1_MeV),
+      2.37236751652554644e-12 * 1. / (1_MeV),
+      8.74325264965669646e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams127 = BoundParameters(tgContext, std::move(covMat127),
+                                        params127, perigeeSurface);
+  tracks.push_back(boundParams127);
+
+  // track 128 :
+  BoundVector params128;
+  params128 << -0.786545097827911377, -38.7401618957519531,
+      -0.845708072185516357, 0.685007095336914062,
+      -0.00115627096965909004 * 1. / (1_MeV), 0;
+  Covariance covMat128;
+  covMat128 << 0.0192839577794075012, -0.000884148373743458998,
+      -0.000582462336183784323, -8.08110064280186493e-06,
+      -2.82867484656328478e-07 * 1. / (1_MeV), 0, -0.000884148373743458998,
+      0.0635840222239494324, 4.14378320186397384e-05, 0.000713555828392625161,
+      1.15057697948470685e-08 * 1. / (1_MeV), 0, -0.000582462336183784323,
+      4.14378320186397384e-05, 1.78008613147540018e-05, 4.15133191686953799e-07,
+      1.37170909103508374e-08 * 1. / (1_MeV), 0, -8.08110064280186493e-06,
+      0.000713555828392625161, 4.15133191686953799e-07, 8.22206584416562691e-06,
+      3.36288899333749929e-11 * 1. / (1_MeV), 0,
+      -2.82867484656328478e-07 * 1. / (1_MeV),
+      1.15057697948470685e-08 * 1. / (1_MeV),
+      1.37170909103508374e-08 * 1. / (1_MeV),
+      3.36288899333749929e-11 * 1. / (1_MeV),
+      3.38668010302356493e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams128 = BoundParameters(tgContext, std::move(covMat128),
+                                        params128, perigeeSurface);
+  tracks.push_back(boundParams128);
+
+  // track 129 :
+  BoundVector params129;
+  params129 << 0.486697107553482056, -27.5921802520751953, 1.46391701698303223,
+      2.71947717666625977, -0.000425876642111688852 * 1. / (1_MeV), 0;
+  Covariance covMat129;
+  covMat129 << 0.0104358252137899399, -0.000194071380788289307,
+      -0.000315099921452716538, 1.76392275881344802e-06,
+      -1.10626700413367959e-07 * 1. / (1_MeV), 0, -0.000194071380788289307,
+      0.0726201385259628296, -1.22225312305688994e-06, 0.000354468038776242019,
+      1.07847367917163246e-08 * 1. / (1_MeV), 0, -0.000315099921452716538,
+      -1.22225312305688994e-06, 9.63851289270678535e-06,
+      -9.06071612650389521e-08, 5.46013101705028866e-09 * 1. / (1_MeV), 0,
+      1.76392275881344802e-06, 0.000354468038776242019,
+      -9.06071612650389521e-08, 1.75927425516420044e-06,
+      8.12217710906210286e-12 * 1. / (1_MeV), 0,
+      -1.10626700413367959e-07 * 1. / (1_MeV),
+      1.07847367917163246e-08 * 1. / (1_MeV),
+      5.46013101705028866e-09 * 1. / (1_MeV),
+      8.12217710906210286e-12 * 1. / (1_MeV),
+      8.87762224843768877e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams129 = BoundParameters(tgContext, std::move(covMat129),
+                                        params129, perigeeSurface);
+  tracks.push_back(boundParams129);
+
+  // track 130 :
+  BoundVector params130;
+  params130 << -0.617856025695800781, -0.871593713760375977,
+      -0.820657730102539062, 1.98759174346923828,
+      0.00110533414408564568 * 1. / (1_MeV), 0;
+  Covariance covMat130;
+  covMat130 << 0.00552858132869005203, -6.21963191966173515e-06,
+      -0.000165318571599927403, -1.87050290953511793e-06,
+      -9.12087055682573263e-08 * 1. / (1_MeV), 0, -6.21963191966173515e-06,
+      0.0224491767585277557, 2.49900583889646317e-06, 0.000406727201832187205,
+      -1.6111436767727037e-09 * 1. / (1_MeV), 0, -0.000165318571599927403,
+      2.49900583889646317e-06, 5.011198027204955e-06, 1.03599533976687726e-07,
+      4.3871518926068891e-09 * 1. / (1_MeV), 0, -1.87050290953511793e-06,
+      0.000406727201832187205, 1.03599533976687726e-07, 8.68987262947484851e-06,
+      1.25136088613115525e-11 * 1. / (1_MeV), 0,
+      -9.12087055682573263e-08 * 1. / (1_MeV),
+      -1.6111436767727037e-09 * 1. / (1_MeV),
+      4.3871518926068891e-09 * 1. / (1_MeV),
+      1.25136088613115525e-11 * 1. / (1_MeV),
+      1.55834969928214662e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams130 = BoundParameters(tgContext, std::move(covMat130),
+                                        params130, perigeeSurface);
+  tracks.push_back(boundParams130);
+
+  // track 131 :
+  BoundVector params131;
+  params131 << -0.317273795604705811, -39.7836227416992188,
+      0.271088778972625732, 2.60198879241943359,
+      -0.000791704689618200064 * 1. / (1_MeV), 0;
+  Covariance covMat131;
+  covMat131 << 0.0173647217452526093, 0.000699109712679081823,
+      -0.000517395274305629347, 5.83878339750726826e-06,
+      -2.16819932799887328e-07 * 1. / (1_MeV), 0, 0.000699109712679081823,
+      0.0743361711502075195, -3.22919950885157238e-05, 0.000565554144244462416,
+      -2.84215790760252208e-09 * 1. / (1_MeV), 0, -0.000517395274305629347,
+      -3.22919950885157238e-05, 1.57065533130662516e-05,
+      -2.69347200961308565e-07, 1.07852728031145877e-08 * 1. / (1_MeV), 0,
+      5.83878339750726826e-06, 0.000565554144244462416,
+      -2.69347200961308565e-07, 4.39661971540772356e-06,
+      -7.1469095279936026e-12 * 1. / (1_MeV), 0,
+      -2.16819932799887328e-07 * 1. / (1_MeV),
+      -2.84215790760252208e-09 * 1. / (1_MeV),
+      1.07852728031145877e-08 * 1. / (1_MeV),
+      -7.1469095279936026e-12 * 1. / (1_MeV),
+      2.20003334994167687e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams131 = BoundParameters(tgContext, std::move(covMat131),
+                                        params131, perigeeSurface);
+  tracks.push_back(boundParams131);
+
+  // track 132 :
+  BoundVector params132;
+  params132 << -0.176747366786003113, -6.18134498596191406,
+      -2.44022130966186523, 1.06020462512969971,
+      -0.00166206969879567623 * 1. / (1_MeV), 0;
+  Covariance covMat132;
+  covMat132 << 0.0163360219448804855, -0.0003172835243235103,
+      -0.000474475361325176945, -8.23511726091334258e-06,
+      -2.30416042777669323e-07 * 1. / (1_MeV), 0, -0.0003172835243235103,
+      0.0361283980309963226, 1.62689442711704658e-05, 0.000735986183239389154,
+      -2.55052024057200266e-09 * 1. / (1_MeV), 0, -0.000474475361325176945,
+      1.62689442711704658e-05, 1.40814063342986628e-05, 4.00503665767196095e-07,
+      1.13634723345292126e-08 * 1. / (1_MeV), 0, -8.23511726091334258e-06,
+      0.000735986183239389154, 4.00503665767196095e-07, 1.59251703735208139e-05,
+      -4.93303581762030017e-11 * 1. / (1_MeV), 0,
+      -2.30416042777669323e-07 * 1. / (1_MeV),
+      -2.55052024057200266e-09 * 1. / (1_MeV),
+      1.13634723345292126e-08 * 1. / (1_MeV),
+      -4.93303581762030017e-11 * 1. / (1_MeV),
+      3.97582966549236971e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams132 = BoundParameters(tgContext, std::move(covMat132),
+                                        params132, perigeeSurface);
+  tracks.push_back(boundParams132);
+
+  // track 133 :
+  BoundVector params133;
+  params133 << 0.252984225749969482, -0.155150562524795532,
+      -2.66754698753356934, 2.31749868392944336,
+      0.000917813042178750038 * 1. / (1_MeV), 0;
+  Covariance covMat133;
+  covMat133 << 0.00944171752780675888, 0.000145823562828363914,
+      -0.000271052957960221707, -4.55321772559130365e-07,
+      -2.43926736564194306e-07 * 1. / (1_MeV), 0, 0.000145823562828363914,
+      0.0299511272460222244, 3.38575145014588503e-06, 0.000406530300163432086,
+      -3.0856143118849151e-09 * 1. / (1_MeV), 0, -0.000271052957960221707,
+      3.38575145014588503e-06, 8.01670285000000149e-06, 1.05147518352289746e-07,
+      1.1170956971681221e-08 * 1. / (1_MeV), 0, -4.55321772559130365e-07,
+      0.000406530300163432086, 1.05147518352289746e-07, 5.94885204918682575e-06,
+      -1.05152517914159529e-11 * 1. / (1_MeV), 0,
+      -2.43926736564194306e-07 * 1. / (1_MeV),
+      -3.0856143118849151e-09 * 1. / (1_MeV),
+      1.1170956971681221e-08 * 1. / (1_MeV),
+      -1.05152517914159529e-11 * 1. / (1_MeV),
+      3.04403169337774671e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams133 = BoundParameters(tgContext, std::move(covMat133),
+                                        params133, perigeeSurface);
+  tracks.push_back(boundParams133);
+
+  // track 134 :
+  BoundVector params134;
+  params134 << 0.261232942342758179, -4.98270845413208008, -2.7913355827331543,
+      2.3903357982635498, -0.000602899584919214249 * 1. / (1_MeV), 0;
+  Covariance covMat134;
+  covMat134 << 0.00512111512944102287, 0.000151096985693622513,
+      -0.000145316183125153919, 1.87182314845306937e-06,
+      -1.11018028044376921e-07 * 1. / (1_MeV), 0, 0.000151096985693622513,
+      0.0171234942972660065, -4.80042332048881649e-06, 0.000210849209555024551,
+      1.07928525134701817e-09 * 1. / (1_MeV), 0, -0.000145316183125153919,
+      -4.80042332048881649e-06, 4.26421911470242776e-06,
+      -6.99455919823715623e-08, 5.18060114302286267e-09 * 1. / (1_MeV), 0,
+      1.87182314845306937e-06, 0.000210849209555024551,
+      -6.99455919823715623e-08, 2.78515085483377334e-06,
+      2.16936360639539862e-12 * 1. / (1_MeV), 0,
+      -1.11018028044376921e-07 * 1. / (1_MeV),
+      1.07928525134701817e-09 * 1. / (1_MeV),
+      5.18060114302286267e-09 * 1. / (1_MeV),
+      2.16936360639539862e-12 * 1. / (1_MeV),
+      1.35624275698909003e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams134 = BoundParameters(tgContext, std::move(covMat134),
+                                        params134, perigeeSurface);
+  tracks.push_back(boundParams134);
+
+  // track 135 :
+  BoundVector params135;
+  params135 << 0.485514432191848755, -45.5758934020996094, 1.94401109218597412,
+      0.505930542945861816, -0.000614787102676928043 * 1. / (1_MeV), 0;
+  Covariance covMat135;
+  covMat135 << 0.0123122958466410637, 0.000103715887417680144,
+      -0.000367851729220063496, -3.31341741262174798e-06,
+      -1.40577584093730895e-07 * 1. / (1_MeV), 0, 0.000103715887417680144,
+      0.0622931979596614838, 5.81297839975361217e-06, 0.000418717043270157351,
+      -7.78615764923604825e-09 * 1. / (1_MeV), 0, -0.000367851729220063496,
+      5.81297839975361217e-06, 1.11767485577729531e-05, 1.62622397510481766e-07,
+      7.02699563203032516e-09 * 1. / (1_MeV), 0, -3.31341741262174798e-06,
+      0.000418717043270157351, 1.62622397510481766e-07, 2.88416777038946748e-06,
+      6.04537737743006593e-12 * 1. / (1_MeV), 0,
+      -1.40577584093730895e-07 * 1. / (1_MeV),
+      -7.78615764923604825e-09 * 1. / (1_MeV),
+      7.02699563203032516e-09 * 1. / (1_MeV),
+      6.04537737743006593e-12 * 1. / (1_MeV),
+      1.35220848407335836e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams135 = BoundParameters(tgContext, std::move(covMat135),
+                                        params135, perigeeSurface);
+  tracks.push_back(boundParams135);
+
+  // track 136 :
+  BoundVector params136;
+  params136 << -0.670421361923217773, -23.7245407104492188,
+      -0.64520871639251709, 1.0696331262588501,
+      -0.00114500056952238083 * 1. / (1_MeV), 0;
+  Covariance covMat136;
+  covMat136 << 0.00867419224232435226, -0.000238439934654708106,
+      -0.000247132726740291432, -3.75722689616700562e-06,
+      -9.94438198214882919e-08 * 1. / (1_MeV), 0, -0.000238439934654708106,
+      0.0179926082491874695, 8.82013517111327567e-06, 0.000362395650514492373,
+      2.75455883099119192e-09 * 1. / (1_MeV), 0, -0.000247132726740291432,
+      8.82013517111327567e-06, 7.21778906154213473e-06, 1.5386779713221143e-07,
+      4.75511246715568753e-09 * 1. / (1_MeV), 0, -3.75722689616700562e-06,
+      0.000362395650514492373, 1.5386779713221143e-07, 7.68224344938062131e-06,
+      2.56252285968062862e-11 * 1. / (1_MeV), 0,
+      -9.94438198214882919e-08 * 1. / (1_MeV),
+      2.75455883099119192e-09 * 1. / (1_MeV),
+      4.75511246715568753e-09 * 1. / (1_MeV),
+      2.56252285968062862e-11 * 1. / (1_MeV),
+      1.62369812040097372e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams136 = BoundParameters(tgContext, std::move(covMat136),
+                                        params136, perigeeSurface);
+  tracks.push_back(boundParams136);
+
+  // track 137 :
+  BoundVector params137;
+  params137 << -0.115538112819194794, 1.36448657512664795, -1.94587123394012451,
+      2.86434054374694824, 0.000385540741262957454 * 1. / (1_MeV), 0;
+  Covariance covMat137;
+  covMat137 << 0.0277297049760818481, 0.00109366535881475391,
+      -0.000837399106664793598, -1.86861717914986654e-06,
+      -3.02391750465843443e-07 * 1. / (1_MeV), 0, 0.00109366535881475391,
+      0.36750379204750061, 1.37618244604514028e-05, 0.000820460451267350272,
+      -2.09467237202718329e-08 * 1. / (1_MeV), 0, -0.000837399106664793598,
+      1.37618244604514028e-05, 2.5784886020119302e-05, 1.55912763303336569e-07,
+      1.51901283557160921e-08 * 1. / (1_MeV), 0, -1.86861717914986654e-06,
+      0.000820460451267350272, 1.55912763303336569e-07, 1.85243084160902072e-06,
+      -5.89799137780591859e-12 * 1. / (1_MeV), 0,
+      -3.02391750465843443e-07 * 1. / (1_MeV),
+      -2.09467237202718329e-08 * 1. / (1_MeV),
+      1.51901283557160921e-08 * 1. / (1_MeV),
+      -5.89799137780591859e-12 * 1. / (1_MeV),
+      1.66225588849044925e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams137 = BoundParameters(tgContext, std::move(covMat137),
+                                        params137, perigeeSurface);
+  tracks.push_back(boundParams137);
+
+  // track 138 :
+  BoundVector params138;
+  params138 << -0.437855541706085205, 0.00233042589388787746,
+      -1.61236178874969482, 2.66223287582397461,
+      -0.00048968649934977293 * 1. / (1_MeV), 0;
+  Covariance covMat138;
+  covMat138 << 0.0102480929344892502, 0.000472131789165782347,
+      -0.00030005184152762706, 2.30777092355429649e-06,
+      -8.23733339483005762e-08 * 1. / (1_MeV), 0, 0.000472131789165782347,
+      0.0548162646591663361, -1.93984184037375696e-05, 0.0003337112441505619,
+      -3.15116273492404661e-09 * 1. / (1_MeV), 0, -0.00030005184152762706,
+      -1.93984184037375696e-05, 8.96569144970271736e-06,
+      -1.04404311461369532e-07, 4.16595730488154716e-09 * 1. / (1_MeV), 0,
+      2.30777092355429649e-06, 0.0003337112441505619, -1.04404311461369532e-07,
+      2.07969515031436458e-06, -4.21540260659907555e-12 * 1. / (1_MeV), 0,
+      -8.23733339483005762e-08 * 1. / (1_MeV),
+      -3.15116273492404661e-09 * 1. / (1_MeV),
+      4.16595730488154716e-09 * 1. / (1_MeV),
+      -4.21540260659907555e-12 * 1. / (1_MeV),
+      7.92930027193605724e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams138 = BoundParameters(tgContext, std::move(covMat138),
+                                        params138, perigeeSurface);
+  tracks.push_back(boundParams138);
+
+  // track 139 :
+  BoundVector params139;
+  params139 << -0.508741080760955811, -46.586151123046875,
+      -0.155602023005485535, 2.23871588706970215,
+      0.00108059775084257126 * 1. / (1_MeV), 0;
+  Covariance covMat139;
+  covMat139 << 0.0092028668150305748, 2.68137590592830111e-06,
+      -0.000267328437856131614, -4.45051587392828996e-06,
+      -1.7870806347180625e-07 * 1. / (1_MeV), 0, 2.68137590592830111e-06,
+      0.0370477475225925446, 7.6281684549949988e-06, 0.000581077286055830654,
+      -4.87564726794623446e-09 * 1. / (1_MeV), 0, -0.000267328437856131614,
+      7.6281684549949988e-06, 7.97686789155704901e-06, 2.52891502516708447e-07,
+      8.98278177902545255e-09 * 1. / (1_MeV), 0, -4.45051587392828996e-06,
+      0.000581077286055830654, 2.52891502516708447e-07, 9.77692525339080021e-06,
+      1.52214832118640255e-11 * 1. / (1_MeV), 0,
+      -1.7870806347180625e-07 * 1. / (1_MeV),
+      -4.87564726794623446e-09 * 1. / (1_MeV),
+      8.98278177902545255e-09 * 1. / (1_MeV),
+      1.52214832118640255e-11 * 1. / (1_MeV),
+      2.85946016864713215e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams139 = BoundParameters(tgContext, std::move(covMat139),
+                                        params139, perigeeSurface);
+  tracks.push_back(boundParams139);
+
+  // track 140 :
+  BoundVector params140;
+  params140 << -0.0287109911441802979, -46.0042991638183594,
+      -2.35494875907897949, 1.89670753479003906,
+      -0.00176577572710812092 * 1. / (1_MeV), 0;
+  Covariance covMat140;
+  covMat140 << 0.0144642842933535576, 0.000202304881255863523,
+      -0.0004315195269340391, 5.3491723128578935e-06,
+      -2.30140530552361737e-07 * 1. / (1_MeV), 0, 0.000202304881255863523,
+      0.0459608733654022217, -1.13086865182124149e-05, 0.000878128453669932505,
+      -5.83245686148190731e-10 * 1. / (1_MeV), 0, -0.0004315195269340391,
+      -1.13086865182124149e-05, 1.30631951833493076e-05,
+      -2.77542364129523601e-07, 1.1015992963213548e-08 * 1. / (1_MeV), 0,
+      5.3491723128578935e-06, 0.000878128453669932505, -2.77542364129523601e-07,
+      1.93870200746459886e-05, 1.69476858439270149e-11 * 1. / (1_MeV), 0,
+      -2.30140530552361737e-07 * 1. / (1_MeV),
+      -5.83245686148190731e-10 * 1. / (1_MeV),
+      1.1015992963213548e-08 * 1. / (1_MeV),
+      1.69476858439270149e-11 * 1. / (1_MeV),
+      3.93277660437618692e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams140 = BoundParameters(tgContext, std::move(covMat140),
+                                        params140, perigeeSurface);
+  tracks.push_back(boundParams140);
+
+  // track 141 :
+  BoundVector params141;
+  params141 << -0.324331343173980713, -23.5119915008544922,
+      -1.97980344295501709, 1.80859279632568359,
+      0.00151402072515338659 * 1. / (1_MeV), 0;
+  Covariance covMat141;
+  covMat141 << 0.0087733948603272438, -9.15304093536118931e-05,
+      -0.000263482306437119978, -4.30371014091713246e-06,
+      -1.27371578273573737e-07 * 1. / (1_MeV), 0, -9.15304093536118931e-05,
+      0.0360054671764373779, 5.80982901356528686e-06, 0.00079117892231876717,
+      -1.84955003459008438e-09 * 1. / (1_MeV), 0, -0.000263482306437119978,
+      5.80982901356528686e-06, 8.00929956312756985e-06, 2.04894742385078515e-07,
+      6.42585697371379892e-09 * 1. / (1_MeV), 0, -4.30371014091713246e-06,
+      0.00079117892231876717, 2.04894742385078515e-07, 1.9523367882356979e-05,
+      -2.99674425730772401e-11 * 1. / (1_MeV), 0,
+      -1.27371578273573737e-07 * 1. / (1_MeV),
+      -1.84955003459008438e-09 * 1. / (1_MeV),
+      6.42585697371379892e-09 * 1. / (1_MeV),
+      -2.99674425730772401e-11 * 1. / (1_MeV),
+      2.4992743985485788e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams141 = BoundParameters(tgContext, std::move(covMat141),
+                                        params141, perigeeSurface);
+  tracks.push_back(boundParams141);
+
+  // track 142 :
+  BoundVector params142;
+  params142 << 0.833708107471466064, -26.5761394500732422, 2.42632651329040527,
+      0.695800244808197021, -0.00123036885634064674 * 1. / (1_MeV), 0;
+  Covariance covMat142;
+  covMat142 << 0.0211165659129619598, 0.000359701005864806447,
+      -0.000640851902958058375, -9.11472752482565601e-06,
+      -3.61128702466976842e-07 * 1. / (1_MeV), 0, 0.000359701005864806447,
+      0.0739856362342834473, 8.7222025530136249e-06, 0.000880846867037469831,
+      -2.53787934713242592e-08 * 1. / (1_MeV), 0, -0.000640851902958058375,
+      8.7222025530136249e-06, 1.96944329218240455e-05, 5.19825459711244045e-07,
+      1.80691074173165322e-08 * 1. / (1_MeV), 0, -9.11472752482565601e-06,
+      0.000880846867037469831, 5.19825459711244045e-07, 1.07980968095944263e-05,
+      -8.35165165596293098e-12 * 1. / (1_MeV), 0,
+      -3.61128702466976842e-07 * 1. / (1_MeV),
+      -2.53787934713242592e-08 * 1. / (1_MeV),
+      1.80691074173165322e-08 * 1. / (1_MeV),
+      -8.35165165596293098e-12 * 1. / (1_MeV),
+      4.57582055579663916e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams142 = BoundParameters(tgContext, std::move(covMat142),
+                                        params142, perigeeSurface);
+  tracks.push_back(boundParams142);
+
+  // track 143 :
+  BoundVector params143;
+  params143 << 0.431655138731002808, -29.9960479736328125, 3.04886436462402344,
+      0.219654783606529236, -0.000162235795869491994 * 1. / (1_MeV), 0;
+  Covariance covMat143;
+  covMat143 << 0.0106745027005672455, -8.84194609194169812e-05,
+      -0.000323117334005453873, -1.40461092014443657e-06,
+      -7.26826880107808198e-08 * 1. / (1_MeV), 0, -8.84194609194169812e-05,
+      0.237027347087860107, 1.1001073976894211e-05, 0.000332182033533801643,
+      -6.39605428797278291e-09 * 1. / (1_MeV), 0, -0.000323117334005453873,
+      1.1001073976894211e-05, 9.92172226688126102e-06, 5.57033782439724886e-08,
+      3.63950477953687594e-09 * 1. / (1_MeV), 0, -1.40461092014443657e-06,
+      0.000332182033533801643, 5.57033782439724886e-08, 4.7147932491498068e-07,
+      3.22132744873936636e-12 * 1. / (1_MeV), 0,
+      -7.26826880107808198e-08 * 1. / (1_MeV),
+      -6.39605428797278291e-09 * 1. / (1_MeV),
+      3.63950477953687594e-09 * 1. / (1_MeV),
+      3.22132744873936636e-12 * 1. / (1_MeV),
+      3.18471672644538017e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams143 = BoundParameters(tgContext, std::move(covMat143),
+                                        params143, perigeeSurface);
+  tracks.push_back(boundParams143);
+
+  // track 144 :
+  BoundVector params144;
+  params144 << 0.453293651342391968, -3.70734310150146484, 1.55869936943054199,
+      0.256132364273071289, 0.000176838657353073359 * 1. / (1_MeV), 0;
+  Covariance covMat144;
+  covMat144 << 0.00827712379395961761, 2.30498411629412509e-05,
+      -0.000244603197258337732, -1.09126589030407755e-07,
+      -1.23444322806264544e-07 * 1. / (1_MeV), 0, 2.30498411629412509e-05,
+      0.129736632108688354, -1.08938113172420931e-05, 0.00024017541022616651,
+      -4.9073936291752883e-09 * 1. / (1_MeV), 0, -0.000244603197258337732,
+      -1.08938113172420931e-05, 7.46843306842492893e-06,
+      -1.2793133595916256e-08, 6.20080490265058224e-09 * 1. / (1_MeV), 0,
+      -1.09126589030407755e-07, 0.00024017541022616651, -1.2793133595916256e-08,
+      4.53893193252952187e-07, 4.19473349424168581e-12 * 1. / (1_MeV), 0,
+      -1.23444322806264544e-07 * 1. / (1_MeV),
+      -4.9073936291752883e-09 * 1. / (1_MeV),
+      6.20080490265058224e-09 * 1. / (1_MeV),
+      4.19473349424168581e-12 * 1. / (1_MeV),
+      6.42161740449509466e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams144 = BoundParameters(tgContext, std::move(covMat144),
+                                        params144, perigeeSurface);
+  tracks.push_back(boundParams144);
+
+  // track 145 :
+  BoundVector params145;
+  params145 << -0.061490967869758606, -26.7054595947265625,
+      -2.24733877182006836, 0.956555545330047607,
+      0.00144492473918944597 * 1. / (1_MeV), 0;
+  Covariance covMat145;
+  covMat145 << 0.0162842385470867157, -0.000263099496401078266,
+      -0.00047392584055408227, 9.13166470635725779e-07,
+      -2.48568574213736665e-07 * 1. / (1_MeV), 0, -0.000263099496401078266,
+      0.0405553430318832397, -4.6234755882358841e-06, 0.000706847528783378985,
+      3.8766189110419867e-09 * 1. / (1_MeV), 0, -0.00047392584055408227,
+      -4.6234755882358841e-06, 1.40937036121613346e-05, -2.3073629352790705e-07,
+      1.21477695022017926e-08 * 1. / (1_MeV), 0, 9.13166470635725779e-07,
+      0.000706847528783378985, -2.3073629352790705e-07, 1.28429355754633434e-05,
+      8.96597163070042405e-12 * 1. / (1_MeV), 0,
+      -2.48568574213736665e-07 * 1. / (1_MeV),
+      3.8766189110419867e-09 * 1. / (1_MeV),
+      1.21477695022017926e-08 * 1. / (1_MeV),
+      8.96597163070042405e-12 * 1. / (1_MeV),
+      3.91443821801118474e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams145 = BoundParameters(tgContext, std::move(covMat145),
+                                        params145, perigeeSurface);
+  tracks.push_back(boundParams145);
+
+  // track 146 :
+  BoundVector params146;
+  params146 << 0.763872087001800537, -38.5857467651367188, 2.27715539932250977,
+      1.21252071857452393, -0.00143153721000999212 * 1. / (1_MeV), 0;
+  Covariance covMat146;
+  covMat146 << 0.00959093961864709854, -5.95333196772062091e-05,
+      -0.000286590504535243261, -3.89848736920619265e-06,
+      -1.27862245568167995e-07 * 1. / (1_MeV), 0, -5.95333196772062091e-05,
+      0.0381334424018859863, 5.54447234346008645e-06, 0.000701959475459679595,
+      -3.38021765880820443e-09 * 1. / (1_MeV), 0, -0.000286590504535243261,
+      5.54447234346008645e-06, 8.66082245920551941e-06, 1.98754844823631596e-07,
+      6.11745668929922213e-09 * 1. / (1_MeV), 0, -3.89848736920619265e-06,
+      0.000701959475459679595, 1.98754844823631596e-07, 1.4981656931922771e-05,
+      -3.86232878211289549e-11 * 1. / (1_MeV), 0,
+      -1.27862245568167995e-07 * 1. / (1_MeV),
+      -3.38021765880820443e-09 * 1. / (1_MeV),
+      6.11745668929922213e-09 * 1. / (1_MeV),
+      -3.86232878211289549e-11 * 1. / (1_MeV),
+      2.21742652017908881e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams146 = BoundParameters(tgContext, std::move(covMat146),
+                                        params146, perigeeSurface);
+  tracks.push_back(boundParams146);
+
+  // track 147 :
+  BoundVector params147;
+  params147 << 0.103607669472694397, 2.84468746185302734, -2.64531970024108887,
+      0.422175496816635132, 0.000728976272512227297 * 1. / (1_MeV), 0;
+  Covariance covMat147;
+  covMat147 << 0.0291666984558105469, -0.00028174513634597289,
+      -0.000896671963135054384, 3.65521430545857715e-06,
+      -9.28791760013186476e-07 * 1. / (1_MeV), 0, -0.00028174513634597289,
+      0.183342501521110535, -2.96247041841360439e-05, 0.000901552718064765435,
+      2.53499877322050493e-08 * 1. / (1_MeV), 0, -0.000896671963135054384,
+      -2.96247041841360439e-05, 2.81649827229557559e-05,
+      -2.96050592993603566e-07, 4.56613110250769837e-08 * 1. / (1_MeV), 0,
+      3.65521430545857715e-06, 0.000901552718064765435,
+      -2.96050592993603566e-07, 4.49623166787205264e-06,
+      2.77175608301356693e-11 * 1. / (1_MeV), 0,
+      -9.28791760013186476e-07 * 1. / (1_MeV),
+      2.53499877322050493e-08 * 1. / (1_MeV),
+      4.56613110250769837e-08 * 1. / (1_MeV),
+      2.77175608301356693e-11 * 1. / (1_MeV),
+      7.42934380681958828e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams147 = BoundParameters(tgContext, std::move(covMat147),
+                                        params147, perigeeSurface);
+  tracks.push_back(boundParams147);
+
+  // track 148 :
+  BoundVector params148;
+  params148 << 0.0596604086458683014, -22.0404262542724609,
+      -2.35440278053283691, 2.71709132194519043,
+      0.000393175549106672406 * 1. / (1_MeV), 0;
+  Covariance covMat148;
+  covMat148 << 0.00926339346915483475, 0.000528247059013484989,
+      -0.000273002338954134941, 1.18533332081702857e-06,
+      -1.0181309061738991e-07 * 1. / (1_MeV), 0, 0.000528247059013484989,
+      0.0657876729965209961, -4.89306573522013593e-06, 0.000319671212486525062,
+      -1.99118715573116921e-09 * 1. / (1_MeV), 0, -0.000273002338954134941,
+      -4.89306573522013593e-06, 8.228425940615125e-06, 1.0922913420953112e-08,
+      5.11517095198890007e-09 * 1. / (1_MeV), 0, 1.18533332081702857e-06,
+      0.000319671212486525062, 1.0922913420953112e-08, 1.58801094585214742e-06,
+      -3.45854711927653862e-12 * 1. / (1_MeV), 0,
+      -1.0181309061738991e-07 * 1. / (1_MeV),
+      -1.99118715573116921e-09 * 1. / (1_MeV),
+      5.11517095198890007e-09 * 1. / (1_MeV),
+      -3.45854711927653862e-12 * 1. / (1_MeV),
+      8.50769107940685387e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams148 = BoundParameters(tgContext, std::move(covMat148),
+                                        params148, perigeeSurface);
+  tracks.push_back(boundParams148);
+
+  // track 149 :
+  BoundVector params149;
+  params149 << -0.100074939429759979, -45.496917724609375, -2.26213359832763672,
+      2.41107773780822754, -0.00105385575443506241 * 1. / (1_MeV), 0;
+  Covariance covMat149;
+  covMat149 << 0.0151377040892839432, 0.000602634067371094167,
+      -0.000444356777866817588, 7.9758927859093853e-06,
+      -2.44218026422960964e-07 * 1. / (1_MeV), 0, 0.000602634067371094167,
+      0.0541137345135211945, -2.54764657299984998e-05, 0.000650772244522164326,
+      -2.86525491239922761e-10 * 1. / (1_MeV), 0, -0.000444356777866817588,
+      -2.54764657299984998e-05, 1.33216317408368923e-05,
+      -3.50343885338622606e-07, 1.17735415136484234e-08 * 1. / (1_MeV), 0,
+      7.9758927859093853e-06, 0.000650772244522164326, -3.50343885338622606e-07,
+      8.18384978629183024e-06, -1.33592110665984887e-11 * 1. / (1_MeV), 0,
+      -2.44218026422960964e-07 * 1. / (1_MeV),
+      -2.86525491239922761e-10 * 1. / (1_MeV),
+      1.17735415136484234e-08 * 1. / (1_MeV),
+      -1.33592110665984887e-11 * 1. / (1_MeV),
+      3.07479458561132901e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams149 = BoundParameters(tgContext, std::move(covMat149),
+                                        params149, perigeeSurface);
+  tracks.push_back(boundParams149);
+
+  // track 150 :
+  BoundVector params150;
+  params150 << -0.475683718919754028, -7.06369543075561523, 0.21792110800743103,
+      2.59036850929260254, 0.000621944374870508909 * 1. / (1_MeV), 0;
+  Covariance covMat150;
+  covMat150 << 0.0113344583660364151, 0.000305280624649602989,
+      -0.000332487044324006938, -1.63824948116055707e-06,
+      -9.71480251237366926e-08 * 1. / (1_MeV), 0, 0.000305280624649602989,
+      0.0582733377814292908, 7.6302914477251913e-07, 0.000438738226848568399,
+      -5.91422448133011881e-09 * 1. / (1_MeV), 0, -0.000332487044324006938,
+      7.6302914477251913e-07, 9.93357571132946759e-06, 1.21010113810928627e-07,
+      4.84814135648083373e-09 * 1. / (1_MeV), 0, -1.63824948116055707e-06,
+      0.000438738226848568399, 1.21010113810928627e-07, 3.42198154612560757e-06,
+      -3.26867840396934173e-12 * 1. / (1_MeV), 0,
+      -9.71480251237366926e-08 * 1. / (1_MeV),
+      -5.91422448133011881e-09 * 1. / (1_MeV),
+      4.84814135648083373e-09 * 1. / (1_MeV),
+      -3.26867840396934173e-12 * 1. / (1_MeV),
+      1.01995072110394602e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams150 = BoundParameters(tgContext, std::move(covMat150),
+                                        params150, perigeeSurface);
+  tracks.push_back(boundParams150);
+
+  // track 151 :
+  BoundVector params151;
+  params151 << 0.98848491907119751, -23.9967403411865234, 2.97214531898498535,
+      2.47884941101074219, -0.000928516499698162079 * 1. / (1_MeV), 0;
+  Covariance covMat151;
+  covMat151 << 0.0139401322230696678, -0.000109650695280206099,
+      -0.000410603766136218755, 6.34942242156624963e-06,
+      -1.91480875943633338e-07 * 1. / (1_MeV), 0, -0.000109650695280206099,
+      0.051623273640871048, -4.96380863496017579e-06, 0.000554779761149708835,
+      1.06928217588898346e-08 * 1. / (1_MeV), 0, -0.000410603766136218755,
+      -4.96380863496017579e-06, 1.23366617117426358e-05,
+      -2.8907121314848788e-07, 9.51416150401782656e-09 * 1. / (1_MeV), 0,
+      6.34942242156624963e-06, 0.000554779761149708835, -2.8907121314848788e-07,
+      6.12514031672617421e-06, -4.0379007049062301e-11 * 1. / (1_MeV), 0,
+      -1.91480875943633338e-07 * 1. / (1_MeV),
+      1.06928217588898346e-08 * 1. / (1_MeV),
+      9.51416150401782656e-09 * 1. / (1_MeV),
+      -4.0379007049062301e-11 * 1. / (1_MeV),
+      2.35979236151706573e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams151 = BoundParameters(tgContext, std::move(covMat151),
+                                        params151, perigeeSurface);
+  tracks.push_back(boundParams151);
+
+  // track 152 :
+  BoundVector params152;
+  params152 << 0.55860060453414917, -45.7249908447265625, 1.83190596103668213,
+      0.48145294189453125, 0.000721027201507240534 * 1. / (1_MeV), 0;
+  Covariance covMat152;
+  covMat152 << 0.0186744499951601028, 0.000493292771603547758,
+      -0.000565849238931288596, 3.05813720670537946e-06,
+      -2.66483594264544379e-07 * 1. / (1_MeV), 0, 0.000493292771603547758,
+      0.101673096418380737, -3.54761000333760567e-05, 0.000629179521496957923,
+      -6.15039861676908778e-09 * 1. / (1_MeV), 0, -0.000565849238931288596,
+      -3.54761000333760567e-05, 1.73863791133044288e-05,
+      -2.15955155252030693e-07, 1.3347851460192395e-08 * 1. / (1_MeV), 0,
+      3.05813720670537946e-06, 0.000629179521496957923,
+      -2.15955155252030693e-07, 3.96863515561562963e-06,
+      9.51450535762684209e-12 * 1. / (1_MeV), 0,
+      -2.66483594264544379e-07 * 1. / (1_MeV),
+      -6.15039861676908778e-09 * 1. / (1_MeV),
+      1.3347851460192395e-08 * 1. / (1_MeV),
+      9.51450535762684209e-12 * 1. / (1_MeV),
+      2.52067755557305873e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams152 = BoundParameters(tgContext, std::move(covMat152),
+                                        params152, perigeeSurface);
+  tracks.push_back(boundParams152);
+
+  // track 153 :
+  BoundVector params153;
+  params153 << -0.675277292728424072, -17.5367851257324219,
+      -1.09335136413574219, 1.29379391670227051,
+      0.00186408217996358871 * 1. / (1_MeV), 0;
+  Covariance covMat153;
+  covMat153 << 0.0150135625153779984, -5.98760396689701493e-06,
+      -0.000439278218315922013, 4.52858267312502235e-06,
+      -2.12443419817206803e-07 * 1. / (1_MeV), 0, -5.98760396689701493e-06,
+      0.0350622236728668213, -4.82582268169156601e-06, 0.000836372815788150622,
+      2.09070433346646154e-09 * 1. / (1_MeV), 0, -0.000439278218315922013,
+      -4.82582268169156601e-06, 1.31102533487137407e-05,
+      -2.59231851245594785e-07, 1.04858623295484113e-08 * 1. / (1_MeV), 0,
+      4.52858267312502235e-06, 0.000836372815788150622,
+      -2.59231851245594785e-07, 2.17701854126062244e-05,
+      -2.62710156705971042e-11 * 1. / (1_MeV), 0,
+      -2.12443419817206803e-07 * 1. / (1_MeV),
+      2.09070433346646154e-09 * 1. / (1_MeV),
+      1.04858623295484113e-08 * 1. / (1_MeV),
+      -2.62710156705971042e-11 * 1. / (1_MeV),
+      4.00474514661297576e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams153 = BoundParameters(tgContext, std::move(covMat153),
+                                        params153, perigeeSurface);
+  tracks.push_back(boundParams153);
+
+  // track 154 :
+  BoundVector params154;
+  params154 << 0.0753030404448509216, -29.1891746520996094,
+      0.738724231719970703, 2.31334257125854492,
+      0.00144911545794457197 * 1. / (1_MeV), 0;
+  Covariance covMat154;
+  covMat154 << 0.0217308551073074341, 3.24991188634454485e-05,
+      -0.000647178201020877667, -5.51537304078277638e-06,
+      -4.24940247733336709e-07 * 1. / (1_MeV), 0, 3.24991188634454485e-05,
+      0.0502317957580089569, 1.42908758929754525e-05, 0.000768853527443186789,
+      -1.11154383882071719e-08 * 1. / (1_MeV), 0, -0.000647178201020877667,
+      1.42908758929754525e-05, 1.96035034605301917e-05, 3.94051157866699596e-07,
+      2.12308161941993043e-08 * 1. / (1_MeV), 0, -5.51537304078277638e-06,
+      0.000768853527443186789, 3.94051157866699596e-07, 1.20725653687259182e-05,
+      -9.05413371576357781e-11 * 1. / (1_MeV), 0,
+      -4.24940247733336709e-07 * 1. / (1_MeV),
+      -1.11154383882071719e-08 * 1. / (1_MeV),
+      2.12308161941993043e-08 * 1. / (1_MeV),
+      -9.05413371576357781e-11 * 1. / (1_MeV),
+      6.28650798084606777e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams154 = BoundParameters(tgContext, std::move(covMat154),
+                                        params154, perigeeSurface);
+  tracks.push_back(boundParams154);
+
+  // track 155 :
+  BoundVector params155;
+  params155 << 0.261458933353424072, -2.39843320846557617, 1.05141377449035645,
+      0.232830539345741272, 0.000250596785917878151 * 1. / (1_MeV), 0;
+  Covariance covMat155;
+  covMat155 << 0.0212338902056217194, 0.000353406616331773335,
+      -0.00064520728113282098, 9.74350339390978654e-07,
+      -1.69741491338621847e-07 * 1. / (1_MeV), 0, 0.000353406616331773335,
+      0.41215890645980835, -4.22061888380635897e-05, 0.000653800381523604113,
+      -1.34245812546777072e-08 * 1. / (1_MeV), 0, -0.00064520728113282098,
+      -4.22061888380635897e-05, 1.98819634533720091e-05,
+      -7.83604692222462539e-08, 8.68476512257556142e-09 * 1. / (1_MeV), 0,
+      9.74350339390978654e-07, 0.000653800381523604113,
+      -7.83604692222462539e-08, 1.04632010788918706e-06,
+      -1.19444645168272657e-11 * 1. / (1_MeV), 0,
+      -1.69741491338621847e-07 * 1. / (1_MeV),
+      -1.34245812546777072e-08 * 1. / (1_MeV),
+      8.68476512257556142e-09 * 1. / (1_MeV),
+      -1.19444645168272657e-11 * 1. / (1_MeV),
+      8.34616611933292063e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams155 = BoundParameters(tgContext, std::move(covMat155),
+                                        params155, perigeeSurface);
+  tracks.push_back(boundParams155);
+
+  // track 156 :
+  BoundVector params156;
+  params156 << -0.105008736252784729, -4.60046195983886719,
+      -2.15087199211120605, 2.53013730049133301,
+      0.000869307026732712984 * 1. / (1_MeV), 0;
+  Covariance covMat156;
+  covMat156 << 0.0136917401105165482, 0.000115121263015629808,
+      -0.000413429347423517678, -2.62571780336553623e-06,
+      -2.07199662141073358e-07 * 1. / (1_MeV), 0, 0.000115121263015629808,
+      0.0558724924921989441, 8.99969196056981436e-06, 0.000514698386282201061,
+      -6.20886185541909694e-09 * 1. / (1_MeV), 0, -0.000413429347423517678,
+      8.99969196056981436e-06, 1.26550057757413015e-05, 1.92253160785162133e-07,
+      1.01717537862091531e-08 * 1. / (1_MeV), 0, -2.62571780336553623e-06,
+      0.000514698386282201061, 1.92253160785162133e-07, 4.87851730213151313e-06,
+      -7.31342694223202373e-12 * 1. / (1_MeV), 0,
+      -2.07199662141073358e-07 * 1. / (1_MeV),
+      -6.20886185541909694e-09 * 1. / (1_MeV),
+      1.01717537862091531e-08 * 1. / (1_MeV),
+      -7.31342694223202373e-12 * 1. / (1_MeV),
+      2.3365928636387423e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams156 = BoundParameters(tgContext, std::move(covMat156),
+                                        params156, perigeeSurface);
+  tracks.push_back(boundParams156);
+
+  // track 157 :
+  BoundVector params157;
+  params157 << 0.449398219585418701, -27.5547370910644531, -2.98990011215209961,
+      0.584414243698120117, -0.000796562700998038054 * 1. / (1_MeV), 0;
+  Covariance covMat157;
+  covMat157 << 0.0147328255698084831, 0.000102396442328031638,
+      -0.000442161702936779853, -4.51768449626899611e-06,
+      -1.75125426997186622e-07 * 1. / (1_MeV), 0, 0.000102396442328031638,
+      0.0676895305514335632, 9.61359721658456181e-06, 0.000602606334717200459,
+      -8.66739114473183283e-09 * 1. / (1_MeV), 0, -0.000442161702936779853,
+      9.61359721658456181e-06, 1.34547990455757827e-05, 2.52859101937164529e-07,
+      8.84959810661187708e-09 * 1. / (1_MeV), 0, -4.51768449626899611e-06,
+      0.000602606334717200459, 2.52859101937164529e-07, 5.48358138985349797e-06,
+      2.42683894231848255e-12 * 1. / (1_MeV), 0,
+      -1.75125426997186622e-07 * 1. / (1_MeV),
+      -8.66739114473183283e-09 * 1. / (1_MeV),
+      8.84959810661187708e-09 * 1. / (1_MeV),
+      2.42683894231848255e-12 * 1. / (1_MeV),
+      1.96425084530993388e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams157 = BoundParameters(tgContext, std::move(covMat157),
+                                        params157, perigeeSurface);
+  tracks.push_back(boundParams157);
+
+  // track 158 :
+  BoundVector params158;
+  params158 << -0.47096705436706543, -23.1657295227050781, -1.74237358570098877,
+      2.32017350196838379, 0.000883807893842458725 * 1. / (1_MeV), 0;
+  Covariance covMat158;
+  covMat158 << 0.00741111813113093376, 3.92975220400803806e-05,
+      -0.000222045332813570817, -2.88822099446990028e-06,
+      -2.12788927612163033e-07 * 1. / (1_MeV), 0, 3.92975220400803806e-05,
+      0.0265452265739440918, 3.83772358007061724e-06, 0.000388211046384209855,
+      -5.72504289628637471e-09 * 1. / (1_MeV), 0, -0.000222045332813570817,
+      3.83772358007061724e-06, 6.7778209995594807e-06, 1.57738925506559928e-07,
+      1.01751060319750463e-08 * 1. / (1_MeV), 0, -2.88822099446990028e-06,
+      0.000388211046384209855, 1.57738925506559928e-07, 5.97009920966229402e-06,
+      2.72996826709048491e-11 * 1. / (1_MeV), 0,
+      -2.12788927612163033e-07 * 1. / (1_MeV),
+      -5.72504289628637471e-09 * 1. / (1_MeV),
+      1.01751060319750463e-08 * 1. / (1_MeV),
+      2.72996826709048491e-11 * 1. / (1_MeV),
+      2.86495771550931977e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams158 = BoundParameters(tgContext, std::move(covMat158),
+                                        params158, perigeeSurface);
+  tracks.push_back(boundParams158);
+
+  // track 159 :
+  BoundVector params159;
+  params159 << -0.772880673408508301, -0.194379150867462158,
+      -0.128169164061546326, 0.661742448806762695,
+      0.00110341468825936317 * 1. / (1_MeV), 0;
+  Covariance covMat159;
+  covMat159 << 0.020627237856388092, -0.000651662753287368906,
+      -0.00061276879384480475, 5.7418960693298186e-06,
+      -2.67843352789052197e-07 * 1. / (1_MeV), 0, -0.000651662753287368906,
+      0.0692515745759010315, -2.26766543920346976e-07, 0.000746164457055286962,
+      1.87684603862415885e-08 * 1. / (1_MeV), 0, -0.00061276879384480475,
+      -2.26766543920346976e-07, 1.8517455828259699e-05,
+      -3.78605360981018502e-07, 1.36753554668844785e-08 * 1. / (1_MeV), 0,
+      5.7418960693298186e-06, 0.000746164457055286962, -3.78605360981018502e-07,
+      8.24847211333690211e-06, -3.39037168618683865e-12 * 1. / (1_MeV), 0,
+      -2.67843352789052197e-07 * 1. / (1_MeV),
+      1.87684603862415885e-08 * 1. / (1_MeV),
+      1.36753554668844785e-08 * 1. / (1_MeV),
+      -3.39037168618683865e-12 * 1. / (1_MeV),
+      3.48178236242446815e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams159 = BoundParameters(tgContext, std::move(covMat159),
+                                        params159, perigeeSurface);
+  tracks.push_back(boundParams159);
+
+  // track 160 :
+  BoundVector params160;
+  params160 << -0.347648710012435913, -45.7085342407226562,
+      0.140009865164756775, 0.641895532608032227,
+      0.00117580872029066086 * 1. / (1_MeV), 0;
+  Covariance covMat160;
+  covMat160 << 0.0375818982720375061, -0.000303276309189704169,
+      -0.00110587969340759386, 1.29061987071589049e-05,
+      -4.12294858313896687e-07 * 1. / (1_MeV), 0, -0.000303276309189704169,
+      0.125086501240730286, -2.57186227015147112e-05, 0.00124988554053600013,
+      1.69162268005727335e-08 * 1. / (1_MeV), 0, -0.00110587969340759386,
+      -2.57186227015147112e-05, 3.28488567902240902e-05,
+      -7.27553385059438972e-07, 1.83230555024144881e-08 * 1. / (1_MeV), 0,
+      1.29061987071589049e-05, 0.00124988554053600013, -7.27553385059438972e-07,
+      1.28745887195691466e-05, -1.87734052287320618e-11 * 1. / (1_MeV), 0,
+      -4.12294858313896687e-07 * 1. / (1_MeV),
+      1.69162268005727335e-08 * 1. / (1_MeV),
+      1.83230555024144881e-08 * 1. / (1_MeV),
+      -1.87734052287320618e-11 * 1. / (1_MeV),
+      3.79933057237380467e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams160 = BoundParameters(tgContext, std::move(covMat160),
+                                        params160, perigeeSurface);
+  tracks.push_back(boundParams160);
+
+  // track 161 :
+  BoundVector params161;
+  params161 << -0.2922801673412323, -0.921251356601715088,
+      0.0930548682808876038, 1.51108169555664062,
+      0.00123066513333469629 * 1. / (1_MeV), 0;
+  Covariance covMat161;
+  covMat161 << 0.00921367853879928589, 4.5284958991639089e-06,
+      -0.000270542651850571756, 4.18970364145019236e-07,
+      -1.24935012983859226e-07 * 1. / (1_MeV), 0, 4.5284958991639089e-06,
+      0.0202056393027305603, -5.18878459713167351e-07, 0.000441547249561386889,
+      -1.60400630155777733e-09 * 1. / (1_MeV), 0, -0.000270542651850571756,
+      -5.18878459713167351e-07, 8.02594786364352331e-06,
+      -2.14580558624309511e-08, 5.3323840067832493e-09 * 1. / (1_MeV), 0,
+      4.18970364145019236e-07, 0.000441547249561386889,
+      -2.14580558624309511e-08, 1.14672693598549813e-05,
+      -2.71866026406819207e-11 * 1. / (1_MeV), 0,
+      -1.24935012983859226e-07 * 1. / (1_MeV),
+      -1.60400630155777733e-09 * 1. / (1_MeV),
+      5.3323840067832493e-09 * 1. / (1_MeV),
+      -2.71866026406819207e-11 * 1. / (1_MeV),
+      1.68986658000136458e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams161 = BoundParameters(tgContext, std::move(covMat161),
+                                        params161, perigeeSurface);
+  tracks.push_back(boundParams161);
+
+  // track 162 :
+  BoundVector params162;
+  params162 << 0.4121856689453125, -23.2384719848632812, 3.07601475715637207,
+      2.50852036476135254, -0.00103297142777591944 * 1. / (1_MeV), 0;
+  Covariance covMat162;
+  covMat162 << 0.0184979140758514404, 0.000137593374859579015,
+      -0.000556487007709731548, 8.2413879715742071e-06,
+      -2.98670195072288683e-07 * 1. / (1_MeV), 0, 0.000137593374859579015,
+      0.0723279938101768494, -1.91025340155191667e-05, 0.00072751066352708994,
+      1.28089131983040278e-08 * 1. / (1_MeV), 0, -0.000556487007709731548,
+      -1.91025340155191667e-05, 1.6993884855764918e-05,
+      -4.09609317210932893e-07, 1.47520025775196756e-08 * 1. / (1_MeV), 0,
+      8.2413879715742071e-06, 0.00072751066352708994, -4.09609317210932893e-07,
+      7.47372678233659826e-06, -6.9067412337676577e-12 * 1. / (1_MeV), 0,
+      -2.98670195072288683e-07 * 1. / (1_MeV),
+      1.28089131983040278e-08 * 1. / (1_MeV),
+      1.47520025775196756e-08 * 1. / (1_MeV),
+      -6.9067412337676577e-12 * 1. / (1_MeV),
+      3.46785045124420321e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams162 = BoundParameters(tgContext, std::move(covMat162),
+                                        params162, perigeeSurface);
+  tracks.push_back(boundParams162);
+
+  // track 163 :
+  BoundVector params163;
+  params163 << -0.483950525522232056, -26.1256237030029297,
+      0.0553041622042655945, 0.949812471866607666,
+      -0.00125660584308207035 * 1. / (1_MeV), 0;
+  Covariance covMat163;
+  covMat163 << 0.0255814455449581146, -0.000497574279907850563,
+      -0.000750143259475374879, -9.48529005801767566e-06,
+      -1.80692002549941218e-07 * 1. / (1_MeV), 0, -0.000497574279907850563,
+      0.0536283813416957855, 2.52424588427675564e-05, 0.000992537455962576656,
+      -6.36132286347180259e-10 * 1. / (1_MeV), 0, -0.000750143259475374879,
+      2.52424588427675564e-05, 2.21376776607939973e-05, 4.85059345667416894e-07,
+      8.91432167580867079e-09 * 1. / (1_MeV), 0, -9.48529005801767566e-06,
+      0.000992537455962576656, 4.85059345667416894e-07, 1.88748454093001783e-05,
+      -4.62705821113891289e-11 * 1. / (1_MeV), 0,
+      -1.80692002549941218e-07 * 1. / (1_MeV),
+      -6.36132286347180259e-10 * 1. / (1_MeV),
+      8.91432167580867079e-09 * 1. / (1_MeV),
+      -4.62705821113891289e-11 * 1. / (1_MeV),
+      2.9073463081452644e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams163 = BoundParameters(tgContext, std::move(covMat163),
+                                        params163, perigeeSurface);
+  tracks.push_back(boundParams163);
+
+  // track 164 :
+  BoundVector params164;
+  params164 << 0.446096986532211304, -45.5545768737792969, 1.52503681182861328,
+      0.665921330451965332, -3.70692359865643084e-05 * 1. / (1_MeV), 0;
+  Covariance covMat164;
+  covMat164 << 0.000154954337631352246, -2.7711175651334654e-06,
+      -2.81480069777612953e-06, 5.24993610348611895e-09,
+      -1.85158695435768846e-09 * 1. / (1_MeV), 0, -2.7711175651334654e-06,
+      0.00208598608151078224, -5.19392850454352899e-09, 9.56207419135546286e-06,
+      -8.58618417511969728e-10 * 1. / (1_MeV), 0, -2.81480069777612953e-06,
+      -5.19392850454352899e-09, 5.87558872666704701e-08,
+      -2.14259485564807477e-10, 4.70134905851354349e-11 * 1. / (1_MeV), 0,
+      5.24993610348611895e-09, 9.56207419135546286e-06,
+      -2.14259485564807477e-10, 6.29812220154235547e-08,
+      -5.34156221200548834e-12 * 1. / (1_MeV), 0,
+      -1.85158695435768846e-09 * 1. / (1_MeV),
+      -8.58618417511969728e-10 * 1. / (1_MeV),
+      4.70134905851354349e-11 * 1. / (1_MeV),
+      -5.34156221200548834e-12 * 1. / (1_MeV),
+      6.18826441912273539e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams164 = BoundParameters(tgContext, std::move(covMat164),
+                                        params164, perigeeSurface);
+  tracks.push_back(boundParams164);
+
+  // track 165 :
+  BoundVector params165;
+  params165 << -0.193144664168357849, -39.8290443420410156,
+      0.404710888862609863, 2.53834176063537598,
+      0.000577296596020460129 * 1. / (1_MeV), 0;
+  Covariance covMat165;
+  covMat165 << 0.00723315775394439697, 0.000260372419450370792,
+      -0.000213528892024644653, 8.64182027576564045e-08,
+      -1.62459623796150906e-07 * 1. / (1_MeV), 0, 0.000260372419450370792,
+      0.0307485610246658325, -1.36157327480265165e-06, 0.000270086486223694014,
+      -7.61741612270504069e-09 * 1. / (1_MeV), 0, -0.000213528892024644653,
+      -1.36157327480265165e-06, 6.46902481094002724e-06,
+      4.73498669259185492e-08, 7.96054784235342818e-09 * 1. / (1_MeV), 0,
+      8.64182027576564045e-08, 0.000270086486223694014, 4.73498669259185492e-08,
+      2.46902618528110906e-06, -1.95104992239772127e-11 * 1. / (1_MeV), 0,
+      -1.62459623796150906e-07 * 1. / (1_MeV),
+      -7.61741612270504069e-09 * 1. / (1_MeV),
+      7.96054784235342818e-09 * 1. / (1_MeV),
+      -1.95104992239772127e-11 * 1. / (1_MeV),
+      1.81045026192983016e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams165 = BoundParameters(tgContext, std::move(covMat165),
+                                        params165, perigeeSurface);
+  tracks.push_back(boundParams165);
+
+  // track 166 :
+  BoundVector params166;
+  params166 << 0.799288451671600342, -27.6733474731445312, 1.79553651809692383,
+      2.62628865242004395, 0.000649376073852181435 * 1. / (1_MeV), 0;
+  Covariance covMat166;
+  covMat166 << 0.0184728335589170456, 0.000576206559643558606,
+      -0.000498748322512280475, 2.46767730379623049e-06,
+      -2.41244600997874658e-07 * 1. / (1_MeV), 0, 0.000576206559643558606,
+      0.1421927809715271, 1.81454957973484008e-05, 0.000800767644742904545,
+      -5.41325547148110521e-09 * 1. / (1_MeV), 0, -0.000498748322512280475,
+      1.81454957973484008e-05, 1.40697147799073718e-05, 1.08885275385941302e-07,
+      1.05514606536829556e-08 * 1. / (1_MeV), 0, 2.46767730379623049e-06,
+      0.000800767644742904545, 1.08885275385941302e-07, 4.79977052236790769e-06,
+      -6.6186235709197681e-11 * 1. / (1_MeV), 0,
+      -2.41244600997874658e-07 * 1. / (1_MeV),
+      -5.41325547148110521e-09 * 1. / (1_MeV),
+      1.05514606536829556e-08 * 1. / (1_MeV),
+      -6.6186235709197681e-11 * 1. / (1_MeV),
+      1.90290047608066004e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams166 = BoundParameters(tgContext, std::move(covMat166),
+                                        params166, perigeeSurface);
+  tracks.push_back(boundParams166);
+
+  // track 167 :
+  BoundVector params167;
+  params167 << -0.35574042797088623, -24.7030124664306641, -2.12256479263305664,
+      0.692609786987304688, -0.00104050105437636375 * 1. / (1_MeV), 0;
+  Covariance covMat167;
+  covMat167 << 0.015440003015100956, -0.000624176001675493886,
+      -0.000464574482277491259, -7.70109899823705722e-06,
+      -2.81178338802018056e-07 * 1. / (1_MeV), 0, -0.000624176001675493886,
+      0.0619786754250526428, 3.09368817688975256e-05, 0.000695986322192939863,
+      5.11273110436170716e-09 * 1. / (1_MeV), 0, -0.000464574482277491259,
+      3.09368817688975256e-05, 1.41627569973934442e-05, 3.76623335304221592e-07,
+      1.32070729647698356e-08 * 1. / (1_MeV), 0, -7.70109899823705722e-06,
+      0.000695986322192939863, 3.76623335304221592e-07, 8.04879437055205926e-06,
+      4.26309578361557248e-11 * 1. / (1_MeV), 0,
+      -2.81178338802018056e-07 * 1. / (1_MeV),
+      5.11273110436170716e-09 * 1. / (1_MeV),
+      1.32070729647698356e-08 * 1. / (1_MeV),
+      4.26309578361557248e-11 * 1. / (1_MeV),
+      3.20331428049769329e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams167 = BoundParameters(tgContext, std::move(covMat167),
+                                        params167, perigeeSurface);
+  tracks.push_back(boundParams167);
+
+  // track 168 :
+  BoundVector params168;
+  params168 << 0.11886557936668396, -47.7819938659667969, -2.63996195793151855,
+      0.518789112567901611, 0.000841481960378587246 * 1. / (1_MeV), 0;
+  Covariance covMat168;
+  covMat168 << 0.0208285339176654816, -0.000140944469367757928,
+      -0.000628714493802016365, 2.85093059534874148e-06,
+      -2.52877307106631281e-07 * 1. / (1_MeV), 0, -0.000140944469367757928,
+      0.0990117564797401428, -1.87049319949921501e-05, 0.000699713933447829585,
+      5.35561789668739302e-09 * 1. / (1_MeV), 0, -0.000628714493802016365,
+      -1.87049319949921501e-05, 1.92184870684286579e-05,
+      -2.45129716626087157e-07, 1.23193818731095067e-08 * 1. / (1_MeV), 0,
+      2.85093059534874148e-06, 0.000699713933447829585,
+      -2.45129716626087157e-07, 5.04362697029137053e-06,
+      1.03376886437529416e-11 * 1. / (1_MeV), 0,
+      -2.52877307106631281e-07 * 1. / (1_MeV),
+      5.35561789668739302e-09 * 1. / (1_MeV),
+      1.23193818731095067e-08 * 1. / (1_MeV),
+      1.03376886437529416e-11 * 1. / (1_MeV),
+      2.40058611877813632e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams168 = BoundParameters(tgContext, std::move(covMat168),
+                                        params168, perigeeSurface);
+  tracks.push_back(boundParams168);
+
+  // track 169 :
+  BoundVector params169;
+  params169 << -0.753641188144683838, -24.6972694396972656,
+      -1.26335954666137695, 2.93867397308349609,
+      -5.220841194386594e-05 * 1. / (1_MeV), 0;
+  Covariance covMat169;
+  covMat169 << 0.00236013904213905334, 0.00154376213001722611,
+      -6.73646577569984184e-05, 1.30328176525545106e-06,
+      -1.67714425087651653e-08 * 1. / (1_MeV), 0, 0.00154376213001722611,
+      0.0721083357930183411, -3.89344568551530906e-05, 7.66922827229373638e-05,
+      -5.41191330879136116e-09 * 1. / (1_MeV), 0, -6.73646577569984184e-05,
+      -3.89344568551530906e-05, 1.97714439309493173e-06,
+      -3.33291794511282267e-08, 7.90020084251383031e-10 * 1. / (1_MeV), 0,
+      1.30328176525545106e-06, 7.66922827229373638e-05,
+      -3.33291794511282267e-08, 8.44821670398232527e-08,
+      -2.55639621894285378e-12 * 1. / (1_MeV), 0,
+      -1.67714425087651653e-08 * 1. / (1_MeV),
+      -5.41191330879136116e-09 * 1. / (1_MeV),
+      7.90020084251383031e-10 * 1. / (1_MeV),
+      -2.55639621894285378e-12 * 1. / (1_MeV),
+      6.093434784526508e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams169 = BoundParameters(tgContext, std::move(covMat169),
+                                        params169, perigeeSurface);
+  tracks.push_back(boundParams169);
+
+  // track 170 :
+  BoundVector params170;
+  params170 << -2.15710759162902832, -45.7950439453125, 1.61371970176696777,
+      0.570733428001403809, 0.000358434394001960754 * 1. / (1_MeV), 0;
+  Covariance covMat170;
+  covMat170 << 0.00374916614964604378, -0.000480773005103489936,
+      -0.000105863497891874796, -1.61542653193409112e-07,
+      -1.17937713758139657e-07 * 1. / (1_MeV), 0, -0.000480773005103489936,
+      0.017858605831861496, 1.13532057634138872e-05, 0.000137701393792528048,
+      2.46103911881579324e-08 * 1. / (1_MeV), 0, -0.000105863497891874796,
+      1.13532057634138872e-05, 3.12180145556339994e-06, -1.2843229301556418e-08,
+      5.5197340225094278e-09 * 1. / (1_MeV), 0, -1.61542653193409112e-07,
+      0.000137701393792528048, -1.2843229301556418e-08, 1.12689849629532546e-06,
+      2.78956850716596797e-11 * 1. / (1_MeV), 0,
+      -1.17937713758139657e-07 * 1. / (1_MeV),
+      2.46103911881579324e-08 * 1. / (1_MeV),
+      5.5197340225094278e-09 * 1. / (1_MeV),
+      2.78956850716596797e-11 * 1. / (1_MeV),
+      1.16566450936161914e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams170 = BoundParameters(tgContext, std::move(covMat170),
+                                        params170, perigeeSurface);
+  tracks.push_back(boundParams170);
+
+  // track 171 :
+  BoundVector params171;
+  params171 << 0.297651320695877075, -45.3023033142089844, 1.42410826683044434,
+      0.565678238868713379, -0.000133898094645701349 * 1. / (1_MeV), 0;
+  Covariance covMat171;
+  covMat171 << 0.0027103363536298275, -0.000399266654113502575,
+      -6.23420930522729119e-05, -1.82670658152625359e-06,
+      -7.69916514339241363e-08 * 1. / (1_MeV), 0, -0.000399266654113502575,
+      0.0117103047668933868, 7.28538372498596201e-06, 6.72442964353909048e-05,
+      5.10417192350336677e-09 * 1. / (1_MeV), 0, -6.23420930522729119e-05,
+      7.28538372498596201e-06, 1.54875021962652681e-06, 3.63352506955697989e-08,
+      2.88464097247522637e-09 * 1. / (1_MeV), 0, -1.82670658152625359e-06,
+      6.72442964353909048e-05, 3.63352506955697989e-08, 4.41652872495978954e-07,
+      3.38702398090118851e-11 * 1. / (1_MeV), 0,
+      -7.69916514339241363e-08 * 1. / (1_MeV),
+      5.10417192350336677e-09 * 1. / (1_MeV),
+      2.88464097247522637e-09 * 1. / (1_MeV),
+      3.38702398090118851e-11 * 1. / (1_MeV),
+      5.12816594744336385e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams171 = BoundParameters(tgContext, std::move(covMat171),
+                                        params171, perigeeSurface);
+  tracks.push_back(boundParams171);
+
+  // track 172 :
+  BoundVector params172;
+  params172 << -0.260308802127838135, -25.6350498199462891,
+      -1.41230368614196777, 0.262120574712753296,
+      0.000281498883850872517 * 1. / (1_MeV), 0;
+  Covariance covMat172;
+  covMat172 << 0.0194595623761415482, -0.00222148450059943877,
+      -0.00058252322875270953, -1.15501756925054456e-06,
+      -1.81610552902542074e-07 * 1. / (1_MeV), 0, -0.00222148450059943877,
+      0.29862898588180542, 3.40986013403370269e-05, 0.000587010747958494408,
+      2.04544462489257834e-08 * 1. / (1_MeV), 0, -0.00058252322875270953,
+      3.40986013403370269e-05, 1.77671008714241907e-05,
+      -2.35695411054423683e-08, 8.95910636378094416e-09 * 1. / (1_MeV), 0,
+      -1.15501756925054456e-06, 0.000587010747958494408,
+      -2.35695411054423683e-08, 1.17103115826466819e-06,
+      1.04135839016089135e-11 * 1. / (1_MeV), 0,
+      -1.81610552902542074e-07 * 1. / (1_MeV),
+      2.04544462489257834e-08 * 1. / (1_MeV),
+      8.95910636378094416e-09 * 1. / (1_MeV),
+      1.04135839016089135e-11 * 1. / (1_MeV),
+      9.13651862499698098e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams172 = BoundParameters(tgContext, std::move(covMat172),
+                                        params172, perigeeSurface);
+  tracks.push_back(boundParams172);
+
+  // track 173 :
+  BoundVector params173;
+  params173 << -0.594252109527587891, -5.60402631759643555,
+      -0.336331099271774292, 1.13270664215087891,
+      0.000378493685275316238 * 1. / (1_MeV), 0;
+  Covariance covMat173;
+  covMat173 << 0.00115027138963341713, -2.19197368548817592e-05,
+      -3.13219643767075195e-05, 1.15073899304131421e-07,
+      -1.65870850823649665e-08 * 1. / (1_MeV), 0, -2.19197368548817592e-05,
+      0.00670524360612034798, 1.96229471089852108e-07, 9.39307543268990297e-05,
+      2.47498208313890995e-09 * 1. / (1_MeV), 0, -3.13219643767075195e-05,
+      1.96229471089852108e-07, 8.87292799234273843e-07,
+      -8.13976292236793086e-09, 6.99034330539053411e-10 * 1. / (1_MeV), 0,
+      1.15073899304131421e-07, 9.39307543268990297e-05,
+      -8.13976292236793086e-09, 1.76549144725868246e-06,
+      2.24057572896354012e-11 * 1. / (1_MeV), 0,
+      -1.65870850823649665e-08 * 1. / (1_MeV),
+      2.47498208313890995e-09 * 1. / (1_MeV),
+      6.99034330539053411e-10 * 1. / (1_MeV),
+      2.24057572896354012e-11 * 1. / (1_MeV),
+      2.14914561841306195e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams173 = BoundParameters(tgContext, std::move(covMat173),
+                                        params173, perigeeSurface);
+  tracks.push_back(boundParams173);
+
+  // track 174 :
+  BoundVector params174;
+  params174 << 0.52924954891204834, -45.4634666442871094, 1.54447901248931885,
+      0.575577259063720703, 0.000140380390803329647 * 1. / (1_MeV), 0;
+  Covariance covMat174;
+  covMat174 << 0.00100269797258079052, -1.87621193858972703e-05,
+      -2.4220765886711641e-05, -1.19159820826764043e-07,
+      -1.29051422917792668e-08 * 1. / (1_MeV), 0, -1.87621193858972703e-05,
+      0.00537070957943797112, -5.56254936329620509e-08, 3.29737664105863798e-05,
+      3.42796441483104706e-11 * 1. / (1_MeV), 0, -2.4220765886711641e-05,
+      -5.56254936329620509e-08, 6.28942132152587874e-07,
+      9.62406379884910632e-10, 4.7992442755515698e-10 * 1. / (1_MeV), 0,
+      -1.19159820826764043e-07, 3.29737664105863798e-05,
+      9.62406379884910632e-10, 2.3663132253659569e-07,
+      2.21547914401007548e-12 * 1. / (1_MeV), 0,
+      -1.29051422917792668e-08 * 1. / (1_MeV),
+      3.42796441483104706e-11 * 1. / (1_MeV),
+      4.7992442755515698e-10 * 1. / (1_MeV),
+      2.21547914401007548e-12 * 1. / (1_MeV),
+      8.28479385789337996e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams174 = BoundParameters(tgContext, std::move(covMat174),
+                                        params174, perigeeSurface);
+  tracks.push_back(boundParams174);
+
+  // track 175 :
+  BoundVector params175;
+  params175 << -0.450001835823059082, -24.8905086517333984, -1.6759798526763916,
+      2.58415007591247559, 0.000905881694052368402 * 1. / (1_MeV), 0;
+  Covariance covMat175;
+  covMat175 << 0.0191041901707649231, 0.000428026557284443552,
+      -0.000578871801601514016, -4.45544214020110735e-06,
+      -2.95792810909549861e-07 * 1. / (1_MeV), 0, 0.000428026557284443552,
+      0.0838873609900474548, 6.5131177683482284e-06, 0.000669239272102370875,
+      -1.83345569355485214e-08 * 1. / (1_MeV), 0, -0.000578871801601514016,
+      6.5131177683482284e-06, 1.77657839230960235e-05, 2.90084065510616385e-07,
+      1.41475994510483018e-08 * 1. / (1_MeV), 0, -4.45544214020110735e-06,
+      0.000669239272102370875, 2.90084065510616385e-07, 5.4637353059661109e-06,
+      -8.89617608490651688e-12 * 1. / (1_MeV), 0,
+      -2.95792810909549861e-07 * 1. / (1_MeV),
+      -1.83345569355485214e-08 * 1. / (1_MeV),
+      1.41475994510483018e-08 * 1. / (1_MeV),
+      -8.89617608490651688e-12 * 1. / (1_MeV),
+      2.89176599332918727e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams175 = BoundParameters(tgContext, std::move(covMat175),
+                                        params175, perigeeSurface);
+  tracks.push_back(boundParams175);
+
+  // track 176 :
+  BoundVector params176;
+  params176 << -1.09194684028625488, -51.893341064453125, -2.42328953742980957,
+      0.323457986116409302, -9.37030999921262264e-05 * 1. / (1_MeV), 0;
+  Covariance covMat176;
+  covMat176 << 0.00412589358165860176, -0.000375938547586086044,
+      -9.1347763501019072e-05, -2.06706237329043565e-07,
+      -3.10176057568745453e-08 * 1. / (1_MeV), 0, -0.000375938547586086044,
+      0.044574592262506485, 9.1346382981081699e-06, 9.46204435551554129e-05,
+      3.18549795465229701e-09 * 1. / (1_MeV), 0, -9.1347763501019072e-05,
+      9.1346382981081699e-06, 2.12798704524175264e-06, 6.25620778480259521e-09,
+      9.45920987209876617e-10 * 1. / (1_MeV), 0, -2.06706237329043565e-07,
+      9.46204435551554129e-05, 6.25620778480259521e-09, 2.1415434048321913e-07,
+      2.81623324330943026e-13 * 1. / (1_MeV), 0,
+      -3.10176057568745453e-08 * 1. / (1_MeV),
+      3.18549795465229701e-09 * 1. / (1_MeV),
+      9.45920987209876617e-10 * 1. / (1_MeV),
+      2.81623324330943026e-13 * 1. / (1_MeV),
+      7.16269968684124514e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams176 = BoundParameters(tgContext, std::move(covMat176),
+                                        params176, perigeeSurface);
+  tracks.push_back(boundParams176);
+
+  // track 177 :
+  BoundVector params177;
+  params177 << -0.625615954399108887, -46.6411361694335938,
+      -1.67621421813964844, 0.80771172046661377,
+      -0.000952719361521303654 * 1. / (1_MeV), 0;
+  Covariance covMat177;
+  covMat177 << 0.00838966574519872665, -0.000390657537966586301,
+      -0.000252564060557339894, -4.46970396215082643e-06,
+      -1.84211977604922163e-07 * 1. / (1_MeV), 0, -0.000390657537966586301,
+      0.0338415279984474182, 1.69225585373511505e-05, 0.000474475732694860702,
+      5.60214482748251599e-09 * 1. / (1_MeV), 0, -0.000252564060557339894,
+      1.69225585373511505e-05, 7.7171598604763858e-06, 2.14307467715597906e-07,
+      8.70000260399467453e-09 * 1. / (1_MeV), 0, -4.46970396215082643e-06,
+      0.000474475732694860702, 2.14307467715597906e-07, 6.95064863975858316e-06,
+      3.34801528438062845e-11 * 1. / (1_MeV), 0,
+      -1.84211977604922163e-07 * 1. / (1_MeV),
+      5.60214482748251599e-09 * 1. / (1_MeV),
+      8.70000260399467453e-09 * 1. / (1_MeV),
+      3.34801528438062845e-11 * 1. / (1_MeV),
+      2.40241548876696243e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams177 = BoundParameters(tgContext, std::move(covMat177),
+                                        params177, perigeeSurface);
+  tracks.push_back(boundParams177);
+
+  // track 178 :
+  BoundVector params178;
+  params178 << 0.249076232314109802, -45.2034416198730469, 1.10756564140319824,
+      0.49081951379776001, 0.000841880100779235363 * 1. / (1_MeV), 0;
+  Covariance covMat178;
+  covMat178 << 0.0248545967042446136, 0.000258131336002727254,
+      -0.000766693038710525494, 4.70029301471237248e-06,
+      -9.08506397185599934e-07 * 1. / (1_MeV), 0, 0.000258131336002727254,
+      0.119198836386203766, -3.3659753635808291e-05, 0.000777684091309682095,
+      1.1712654493269838e-08 * 1. / (1_MeV), 0, -0.000766693038710525494,
+      -3.3659753635808291e-05, 2.41926300077466294e-05,
+      -3.10682537473999761e-07, 4.60434144629863134e-08 * 1. / (1_MeV), 0,
+      4.70029301471237248e-06, 0.000777684091309682095,
+      -3.10682537473999761e-07, 5.14959992869989946e-06,
+      6.61054698516293509e-11 * 1. / (1_MeV), 0,
+      -9.08506397185599934e-07 * 1. / (1_MeV),
+      1.1712654493269838e-08 * 1. / (1_MeV),
+      4.60434144629863134e-08 * 1. / (1_MeV),
+      6.61054698516293509e-11 * 1. / (1_MeV),
+      8.71379024491858445e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams178 = BoundParameters(tgContext, std::move(covMat178),
+                                        params178, perigeeSurface);
+  tracks.push_back(boundParams178);
+
+  // track 179 :
+  BoundVector params179;
+  params179 << -0.351021707057952881, -22.8008213043212891,
+      -1.84860432147979736, 2.58694338798522949,
+      -0.000485390948597341776 * 1. / (1_MeV), 0;
+  Covariance covMat179;
+  covMat179 << 0.00608975626528263092, 0.000321320464682472128,
+      -0.000183190187843461718, 2.34032168014660546e-06,
+      -7.63023209733254009e-08 * 1. / (1_MeV), 0, 0.000321320464682472128,
+      0.0319467782974243164, -1.25274257766205381e-05, 0.000241198831469217781,
+      -2.23777402096878229e-09 * 1. / (1_MeV), 0, -0.000183190187843461718,
+      -1.25274257766205381e-05, 5.58611691303667612e-06,
+      -9.42901609067163353e-08, 3.72169224602511146e-09 * 1. / (1_MeV), 0,
+      2.34032168014660546e-06, 0.000241198831469217781,
+      -9.42901609067163353e-08, 1.88807791801082203e-06,
+      -8.61261950846322556e-12 * 1. / (1_MeV), 0,
+      -7.63023209733254009e-08 * 1. / (1_MeV),
+      -2.23777402096878229e-09 * 1. / (1_MeV),
+      3.72169224602511146e-09 * 1. / (1_MeV),
+      -8.61261950846322556e-12 * 1. / (1_MeV),
+      7.60389459730781425e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams179 = BoundParameters(tgContext, std::move(covMat179),
+                                        params179, perigeeSurface);
+  tracks.push_back(boundParams179);
+
+  // track 180 :
+  BoundVector params180;
+  params180 << 0.651896417140960693, -46.7836685180664062, 2.76631903648376465,
+      0.470141232013702393, 1.55008747242391109e-05 * 1. / (1_MeV), 0;
+  Covariance covMat180;
+  covMat180 << 0.000128315252368338406, -3.22642732016210971e-05,
+      -1.99036999570274823e-06, -7.04322809885584826e-08,
+      -1.0059405196984426e-09 * 1. / (1_MeV), 0, -3.22642732016210971e-05,
+      0.00309902383014559746, 3.32147694595742431e-07, 7.25987283305179582e-06,
+      4.75892992516188328e-11 * 1. / (1_MeV), 0, -1.99036999570274823e-06,
+      3.32147694595742431e-07, 3.70899009283220948e-08, 8.60572979362656713e-10,
+      2.24457480954691427e-11 * 1. / (1_MeV), 0, -7.04322809885584826e-08,
+      7.25987283305179582e-06, 8.60572979362656713e-10, 2.08767385601049682e-08,
+      3.80890047398306893e-14 * 1. / (1_MeV), 0,
+      -1.0059405196984426e-09 * 1. / (1_MeV),
+      4.75892992516188328e-11 * 1. / (1_MeV),
+      2.24457480954691427e-11 * 1. / (1_MeV),
+      3.80890047398306893e-14 * 1. / (1_MeV),
+      2.13997019432067559e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams180 = BoundParameters(tgContext, std::move(covMat180),
+                                        params180, perigeeSurface);
+  tracks.push_back(boundParams180);
+
+  // track 181 :
+  BoundVector params181;
+  params181 << 0.3097667396068573, -23.4043254852294922, -2.6382148265838623,
+      2.12934017181396484, 0.00137407251168042421 * 1. / (1_MeV), 0;
+  Covariance covMat181;
+  covMat181 << 0.0118062039837241173, -0.000109254910565050641,
+      -0.000350342450795821422, -4.40406929924205366e-06,
+      -1.69602117125455836e-07 * 1. / (1_MeV), 0, -0.000109254910565050641,
+      0.0281959716230630875, 9.69099679268529228e-06, 0.000552701234963060353,
+      -1.86788811100685945e-09 * 1. / (1_MeV), 0, -0.000350342450795821422,
+      9.69099679268529228e-06, 1.0552752428338863e-05, 2.52690458002615574e-07,
+      8.14523789406513383e-09 * 1. / (1_MeV), 0, -4.40406929924205366e-06,
+      0.000552701234963060353, 2.52690458002615574e-07, 1.13834439616766758e-05,
+      -4.34128100864560213e-11 * 1. / (1_MeV), 0,
+      -1.69602117125455836e-07 * 1. / (1_MeV),
+      -1.86788811100685945e-09 * 1. / (1_MeV),
+      8.14523789406513383e-09 * 1. / (1_MeV),
+      -4.34128100864560213e-11 * 1. / (1_MeV),
+      2.69415295628405715e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams181 = BoundParameters(tgContext, std::move(covMat181),
+                                        params181, perigeeSurface);
+  tracks.push_back(boundParams181);
+
+  // track 182 :
+  BoundVector params182;
+  params182 << 0.642095208168029785, -46.7620658874511719, 2.74535226821899414,
+      0.476923286914825439, -2.45610826823394746e-05 * 1. / (1_MeV), 0;
+  Covariance covMat182;
+  covMat182 << 0.000100913421192672104, -2.33679616572281888e-05,
+      -2.07401176069228284e-06, -4.92462068561543299e-08,
+      -7.88576461002653878e-10 * 1. / (1_MeV), 0, -2.33679616572281888e-05,
+      0.00347701110877096653, 1.02118911354786458e-07, 1.11020572919389336e-05,
+      6.8980626296848663e-10 * 1. / (1_MeV), 0, -2.07401176069228284e-06,
+      1.02118911354786458e-07, 5.15610665274834901e-08, 1.91829932276107212e-10,
+      2.57034296242806379e-11 * 1. / (1_MeV), 0, -4.92462068561543299e-08,
+      1.11020572919389336e-05, 1.91829932276107212e-10, 4.51592896411057154e-08,
+      2.18691904163845164e-12 * 1. / (1_MeV), 0,
+      -7.88576461002653878e-10 * 1. / (1_MeV),
+      6.8980626296848663e-10 * 1. / (1_MeV),
+      2.57034296242806379e-11 * 1. / (1_MeV),
+      2.18691904163845164e-12 * 1. / (1_MeV),
+      3.96474248830908094e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams182 = BoundParameters(tgContext, std::move(covMat182),
+                                        params182, perigeeSurface);
+  tracks.push_back(boundParams182);
+
+  // track 183 :
+  BoundVector params183;
+  params183 << -0.858931362628936768, -26.3201007843017578,
+      -1.06501162052154541, 2.00542879104614258,
+      -0.00147176207974553108 * 1. / (1_MeV), 0;
+  Covariance covMat183;
+  covMat183 << 0.011342288926243782, 0.000290935310731487665,
+      -0.000333001654335057632, 4.59266904966147677e-06,
+      -1.51592966891820935e-07 * 1. / (1_MeV), 0, 0.000290935310731487665,
+      0.0283716730773448944, -1.24780364597086955e-05, 0.000574239226233242469,
+      -9.53412665718049786e-09 * 1. / (1_MeV), 0, -0.000333001654335057632,
+      -1.24780364597086955e-05, 9.96404742181766778e-06,
+      -2.20760287088705507e-07, 7.55984162080033033e-09 * 1. / (1_MeV), 0,
+      4.59266904966147677e-06, 0.000574239226233242469,
+      -2.20760287088705507e-07, 1.23750987768289633e-05,
+      -1.19858856846402273e-10 * 1. / (1_MeV), 0,
+      -1.51592966891820935e-07 * 1. / (1_MeV),
+      -9.53412665718049786e-09 * 1. / (1_MeV),
+      7.55984162080033033e-09 * 1. / (1_MeV),
+      -1.19858856846402273e-10 * 1. / (1_MeV),
+      2.77350448163460328e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams183 = BoundParameters(tgContext, std::move(covMat183),
+                                        params183, perigeeSurface);
+  tracks.push_back(boundParams183);
+
+  // track 184 :
+  BoundVector params184;
+  params184 << 0.845212101936340332, -24.126739501953125, 2.38256359100341797,
+      0.824191451072692871, 0.00116483436431735754 * 1. / (1_MeV), 0;
+  Covariance covMat184;
+  covMat184 << 0.0120219700038433075, 0.000314479883882060258,
+      -0.000367754344864782703, 3.16651031569499765e-06,
+      -5.50176211668336246e-07 * 1. / (1_MeV), 0, 0.000314479883882060258,
+      0.0294524524360895157, -1.65477014501080602e-05, 0.00044716975418939163,
+      -1.85121059683026354e-08 * 1. / (1_MeV), 0, -0.000367754344864782703,
+      -1.65477014501080602e-05, 1.14791173473349772e-05,
+      -1.9939615532523593e-07, 2.734052899630625e-08 * 1. / (1_MeV), 0,
+      3.16651031569499765e-06, 0.00044716975418939163, -1.9939615532523593e-07,
+      6.98199028192902915e-06, -3.56882818335140094e-11 * 1. / (1_MeV), 0,
+      -5.50176211668336246e-07 * 1. / (1_MeV),
+      -1.85121059683026354e-08 * 1. / (1_MeV),
+      2.734052899630625e-08 * 1. / (1_MeV),
+      -3.56882818335140094e-11 * 1. / (1_MeV),
+      8.01815225326407699e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams184 = BoundParameters(tgContext, std::move(covMat184),
+                                        params184, perigeeSurface);
+  tracks.push_back(boundParams184);
+
+  // track 185 :
+  BoundVector params185;
+  params185 << -0.647501945495605469, -26.0731620788574219,
+      -0.995935499668121338, 2.34878754615783691,
+      -0.00110976793803274632 * 1. / (1_MeV), 0;
+  Covariance covMat185;
+  covMat185 << 0.0123600270599126816, 0.000410363839412986508,
+      -0.000381886789830261913, 4.94468486056877076e-06,
+      -7.64568886360537938e-07 * 1. / (1_MeV), 0, 0.000410363839412986508,
+      0.0372607558965682983, -2.04358797977256596e-05, 0.000530848800251920608,
+      -1.84281636372081495e-08 * 1. / (1_MeV), 0, -0.000381886789830261913,
+      -2.04358797977256596e-05, 1.20873473861138336e-05,
+      -2.66094668793066799e-07, 3.82825795137663461e-08 * 1. / (1_MeV), 0,
+      4.94468486056877076e-06, 0.000530848800251920608,
+      -2.66094668793066799e-07, 7.83790710556786507e-06,
+      -5.28708663533158423e-11 * 1. / (1_MeV), 0,
+      -7.64568886360537938e-07 * 1. / (1_MeV),
+      -1.84281636372081495e-08 * 1. / (1_MeV),
+      3.82825795137663461e-08 * 1. / (1_MeV),
+      -5.28708663533158423e-11 * 1. / (1_MeV),
+      1.09044751006592833e-09 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams185 = BoundParameters(tgContext, std::move(covMat185),
+                                        params185, perigeeSurface);
+  tracks.push_back(boundParams185);
+
+  // track 186 :
+  BoundVector params186;
+  params186 << 0.319027870893478394, -46.8204345703125, -2.81523966789245605,
+      0.552423059940338135, -0.000565428519621491432 * 1. / (1_MeV), 0;
+  Covariance covMat186;
+  covMat186 << 0.00984183419495820999, -0.000107861702339279294,
+      -0.000293623369079297144, -2.57141056900692002e-06,
+      -2.68841014325236236e-07 * 1. / (1_MeV), 0, -0.000107861702339279294,
+      0.0447328835725784302, 6.98001302362255524e-06, 0.000354029532888733148,
+      -7.43175254803814895e-09 * 1. / (1_MeV), 0, -0.000293623369079297144,
+      6.98001302362255524e-06, 8.98743746802210808e-06, 1.18656413477563677e-07,
+      1.2513898586729675e-08 * 1. / (1_MeV), 0, -2.57141056900692002e-06,
+      0.000354029532888733148, 1.18656413477563677e-07, 2.89464674096961971e-06,
+      9.64087163963260696e-12 * 1. / (1_MeV), 0,
+      -2.68841014325236236e-07 * 1. / (1_MeV),
+      -7.43175254803814895e-09 * 1. / (1_MeV),
+      1.2513898586729675e-08 * 1. / (1_MeV),
+      9.64087163963260696e-12 * 1. / (1_MeV),
+      2.39039704696963895e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams186 = BoundParameters(tgContext, std::move(covMat186),
+                                        params186, perigeeSurface);
+  tracks.push_back(boundParams186);
+
+  // track 187 :
+  BoundVector params187;
+  params187 << 0.200757488608360291, -26.9347019195556641, 1.57208847999572754,
+      2.04276847839355469, -0.00149231334216892719 * 1. / (1_MeV), 0;
+  Covariance covMat187;
+  covMat187 << 0.0462070293724536896, 1.90087908538328356e-05,
+      -0.00102549302847446035, 1.05894079671972913e-05,
+      -5.64029011801386039e-07 * 1. / (1_MeV), 0, 1.90087908538328356e-05,
+      0.0641310736536979675, -1.20655144555816986e-05, 0.00107456409340518297,
+      7.16318519179297501e-09 * 1. / (1_MeV), 0, -0.00102549302847446035,
+      -1.20655144555816986e-05, 2.3894455807749182e-05,
+      -4.41047372315603779e-07, 1.78538275775300426e-08 * 1. / (1_MeV), 0,
+      1.05894079671972913e-05, 0.00107456409340518297, -4.41047372315603779e-07,
+      1.92008483281824738e-05, -2.57140078054900237e-12 * 1. / (1_MeV), 0,
+      -5.64029011801386039e-07 * 1. / (1_MeV),
+      7.16318519179297501e-09 * 1. / (1_MeV),
+      1.78538275775300426e-08 * 1. / (1_MeV),
+      -2.57140078054900237e-12 * 1. / (1_MeV),
+      3.88259702166493526e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams187 = BoundParameters(tgContext, std::move(covMat187),
+                                        params187, perigeeSurface);
+  tracks.push_back(boundParams187);
+
+  // track 188 :
+  BoundVector params188;
+  params188 << 0.206104561686515808, -26.3112201690673828, 1.16691756248474121,
+      1.37588953971862793, 0.00132282346021384001 * 1. / (1_MeV), 0;
+  Covariance covMat188;
+  covMat188 << 0.00764826126396656036, 2.58893561269243087e-05,
+      -0.000224053920824634036, 1.17201917881422574e-06,
+      -6.15634478426662571e-07 * 1. / (1_MeV), 0, 2.58893561269243087e-05,
+      0.0230550467967987061, -2.20380176677741682e-06, 0.000482425977760371505,
+      5.06151582160123152e-09 * 1. / (1_MeV), 0, -0.000224053920824634036,
+      -2.20380176677741682e-06, 6.82648260408313945e-06,
+      -6.86203109211295378e-08, 2.94694781059607752e-08 * 1. / (1_MeV), 0,
+      1.17201917881422574e-06, 0.000482425977760371505,
+      -6.86203109211295378e-08, 1.19285659820889123e-05,
+      -8.07723581241271915e-12 * 1. / (1_MeV), 0,
+      -6.15634478426662571e-07 * 1. / (1_MeV),
+      5.06151582160123152e-09 * 1. / (1_MeV),
+      2.94694781059607752e-08 * 1. / (1_MeV),
+      -8.07723581241271915e-12 * 1. / (1_MeV),
+      1.11964115756535421e-09 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams188 = BoundParameters(tgContext, std::move(covMat188),
+                                        params188, perigeeSurface);
+  tracks.push_back(boundParams188);
+
+  // track 189 :
+  BoundVector params189;
+  params189 << 1.26870429515838623, -46.6835365295410156, 2.73736929893493652,
+      0.47043222188949585, -0.000411598914070054889 * 1. / (1_MeV), 0;
+  Covariance covMat189;
+  covMat189 << 0.01254259143024683, -0.00206373011378385143,
+      -0.000333126060112854414, -1.27171802273924282e-05,
+      -3.42805695619100495e-07 * 1. / (1_MeV), 0, -0.00206373011378385143,
+      0.063680604100227356, 4.27260303702722393e-05, 0.000335381549435983519,
+      6.98047989676528565e-09 * 1. / (1_MeV), 0, -0.000333126060112854414,
+      4.27260303702722393e-05, 9.29942689253948629e-06, 3.07921052012408952e-07,
+      1.3794266136933136e-08 * 1. / (1_MeV), 0, -1.27171802273924282e-05,
+      0.000335381549435983519, 3.07921052012408952e-07, 1.85226963367313147e-06,
+      1.88533015927685212e-10 * 1. / (1_MeV), 0,
+      -3.42805695619100495e-07 * 1. / (1_MeV),
+      6.98047989676528565e-09 * 1. / (1_MeV),
+      1.3794266136933136e-08 * 1. / (1_MeV),
+      1.88533015927685212e-10 * 1. / (1_MeV),
+      2.06299227700768029e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams189 = BoundParameters(tgContext, std::move(covMat189),
+                                        params189, perigeeSurface);
+  tracks.push_back(boundParams189);
+
+  // track 190 :
+  BoundVector params190;
+  params190 << 0.520144522190093994, -26.78125, 2.87916159629821777,
+      0.913090944290161133, 0.000958578370045870543 * 1. / (1_MeV), 0;
+  Covariance covMat190;
+  covMat190 << 0.0566640235483646393, 0.000619879059068139857,
+      -0.0011829013005423088, 1.13578597071357791e-05,
+      -2.92844240909480606e-07 * 1. / (1_MeV), 0, 0.000619879059068139857,
+      0.112776532769203186, -3.16848163975865004e-05, 0.00133383261677284099,
+      1.65364516509722375e-10 * 1. / (1_MeV), 0, -0.0011829013005423088,
+      -3.16848163975865004e-05, 2.54572314588585868e-05,
+      -4.61895451801213113e-07, 9.13941830794303589e-09 * 1. / (1_MeV), 0,
+      1.13578597071357791e-05, 0.00133383261677284099, -4.61895451801213113e-07,
+      1.69904978974955156e-05, 2.02537558480182913e-11 * 1. / (1_MeV), 0,
+      -2.92844240909480606e-07 * 1. / (1_MeV),
+      1.65364516509722375e-10 * 1. / (1_MeV),
+      9.13941830794303589e-09 * 1. / (1_MeV),
+      2.02537558480182913e-11 * 1. / (1_MeV),
+      1.74747369352523663e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams190 = BoundParameters(tgContext, std::move(covMat190),
+                                        params190, perigeeSurface);
+  tracks.push_back(boundParams190);
+
+  // track 191 :
+  BoundVector params191;
+  params191 << 3.12282395362854004, -65.509918212890625, -0.187527939677238464,
+      2.73361945152282715, 0.000346441811416298151 * 1. / (1_MeV), 0;
+  Covariance covMat191;
+  covMat191 << 0.0481044948101043701, -0.00734549814752950836,
+      -0.00103489854597267421, -4.2235125913880291e-06,
+      -3.96252766190557419e-07 * 1. / (1_MeV), 0, -0.00734549814752950836,
+      0.311487704515457153, 0.000193686295137312744, 0.00101870529268977775,
+      7.69202591235202105e-08 * 1. / (1_MeV), 0, -0.00103489854597267421,
+      0.000193686295137312744, 2.31200901907868683e-05, 1.875400366292023e-07,
+      1.18979733649928015e-08 * 1. / (1_MeV), 0, -4.2235125913880291e-06,
+      0.00101870529268977775, 1.875400366292023e-07, 3.4847455481212819e-06,
+      4.99503482968757551e-12 * 1. / (1_MeV), 0,
+      -3.96252766190557419e-07 * 1. / (1_MeV),
+      7.69202591235202105e-08 * 1. / (1_MeV),
+      1.18979733649928015e-08 * 1. / (1_MeV),
+      4.99503482968757551e-12 * 1. / (1_MeV),
+      1.1102829766684863e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams191 = BoundParameters(tgContext, std::move(covMat191),
+                                        params191, perigeeSurface);
+  tracks.push_back(boundParams191);
+
+  // track 192 :
+  BoundVector params192;
+  params192 << 1.94856953620910645, 32.0474395751953125, 1.59367656707763672,
+      0.301271170377731323, -0.000417216855566948652 * 1. / (1_MeV), 0;
+  Covariance covMat192;
+  covMat192 << 0.11419309675693512, 0.0161650360627660812,
+      -0.00256272073865566842, -1.33614281853937828e-05,
+      -1.05474827860620141e-06 * 1. / (1_MeV), 0, 0.0161650360627660812,
+      1.25828850269317627, -0.000234076459249502955, 0.00243207131735968243,
+      -2.73285579882235462e-07 * 1. / (1_MeV), 0, -0.00256272073865566842,
+      -0.000234076459249502955, 6.02843829256016761e-05,
+      5.83439505836653557e-07, 3.3253261709379142e-08 * 1. / (1_MeV), 0,
+      -1.33614281853937828e-05, 0.00243207131735968243, 5.83439505836653557e-07,
+      4.93446850668988191e-06, -1.22599704885134249e-11 * 1. / (1_MeV), 0,
+      -1.05474827860620141e-06 * 1. / (1_MeV),
+      -2.73285579882235462e-07 * 1. / (1_MeV),
+      3.3253261709379142e-08 * 1. / (1_MeV),
+      -1.22599704885134249e-11 * 1. / (1_MeV),
+      2.39606362528732575e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams192 = BoundParameters(tgContext, std::move(covMat192),
+                                        params192, perigeeSurface);
+  tracks.push_back(boundParams192);
+
+  // track 193 :
+  BoundVector params193;
+  params193 << 0.523398816585540771, -46.3878059387207031, 2.57148909568786621,
+      0.468454271554946899, 0.000597213569562882185 * 1. / (1_MeV), 0;
+  Covariance covMat193;
+  covMat193 << 0.0160064026713371277, 0.000101030272422620432,
+      -0.000480147175700083547, 8.08765442010045379e-07,
+      -4.30079426986170688e-07 * 1. / (1_MeV), 0, 0.000101030272422620432,
+      0.090941987931728363, -2.0664086011827537e-05, 0.000523265493974074398,
+      -1.2205651249153285e-09 * 1. / (1_MeV), 0, -0.000480147175700083547,
+      -2.0664086011827537e-05, 1.47662221934297122e-05,
+      -1.17382332277604896e-07, 2.09396062746074539e-08 * 1. / (1_MeV), 0,
+      8.08765442010045379e-07, 0.000523265493974074398,
+      -1.17382332277604896e-07, 3.09063830172817688e-06,
+      5.33983405657483665e-11 * 1. / (1_MeV), 0,
+      -4.30079426986170688e-07 * 1. / (1_MeV),
+      -1.2205651249153285e-09 * 1. / (1_MeV),
+      2.09396062746074539e-08 * 1. / (1_MeV),
+      5.33983405657483665e-11 * 1. / (1_MeV),
+      3.6832190075664073e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams193 = BoundParameters(tgContext, std::move(covMat193),
+                                        params193, perigeeSurface);
+  tracks.push_back(boundParams193);
+
+  // track 194 :
+  BoundVector params194;
+  params194 << -0.0635648146271705627, -14.7882223129272461,
+      -2.64156651496887207, 0.224920362234115601,
+      -0.000183147756615653634 * 1. / (1_MeV), 0;
+  Covariance covMat194;
+  covMat194 << 0.0120655400678515434, -0.0006910453838693592,
+      -0.000365977142399209201, -1.28533147920557146e-06,
+      -1.01339535493182776e-07 * 1. / (1_MeV), 0, -0.0006910453838693592,
+      0.273133754730224609, 3.06268979203341366e-05, 0.000393899454679768192,
+      -1.35539555434146533e-10 * 1. / (1_MeV), 0, -0.000365977142399209201,
+      3.06268979203341366e-05, 1.12705602077767253e-05, 5.48705815401846056e-08,
+      4.95433244701872377e-09 * 1. / (1_MeV), 0, -1.28533147920557146e-06,
+      0.000393899454679768192, 5.48705815401846056e-08, 5.77933633394422941e-07,
+      1.62498821676485166e-12 * 1. / (1_MeV), 0,
+      -1.01339535493182776e-07 * 1. / (1_MeV),
+      -1.35539555434146533e-10 * 1. / (1_MeV),
+      4.95433244701872377e-09 * 1. / (1_MeV),
+      1.62498821676485166e-12 * 1. / (1_MeV),
+      4.37339504888445418e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams194 = BoundParameters(tgContext, std::move(covMat194),
+                                        params194, perigeeSurface);
+  tracks.push_back(boundParams194);
+
+  // track 195 :
+  BoundVector params195;
+  params195 << -0.455407500267028809, 0.212499335408210754,
+      -2.02245116233825684, 2.88869571685791016,
+      0.000139400261105038226 * 1. / (1_MeV), 0;
+  Covariance covMat195;
+  covMat195 << 0.0228636190295219421, 0.00132628619103978239,
+      -0.000501410814590430576, -5.05350529972164141e-07,
+      -1.15052451624681027e-07 * 1. / (1_MeV), 0, 0.00132628619103978239,
+      0.374587059020996094, -1.18830711055222554e-05, 0.000496772398167388309,
+      -8.53100318867495256e-09 * 1. / (1_MeV), 0, -0.000501410814590430576,
+      -1.18830711055222554e-05, 1.15277352961129509e-05,
+      3.33864252437007874e-08, 3.65227707433702304e-09 * 1. / (1_MeV), 0,
+      -5.05350529972164141e-07, 0.000496772398167388309,
+      3.33864252437007874e-08, 6.9544324787784717e-07,
+      9.05586100425189466e-13 * 1. / (1_MeV), 0,
+      -1.15052451624681027e-07 * 1. / (1_MeV),
+      -8.53100318867495256e-09 * 1. / (1_MeV),
+      3.65227707433702304e-09 * 1. / (1_MeV),
+      9.05586100425189466e-13 * 1. / (1_MeV),
+      2.24803491793990062e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams195 = BoundParameters(tgContext, std::move(covMat195),
+                                        params195, perigeeSurface);
+  tracks.push_back(boundParams195);
+
+  // track 196 :
+  BoundVector params196;
+  params196 << 0.0801024585962295532, 22.3374137878417969, -1.32229578495025635,
+      2.88867521286010742, -0.000216519838431850076 * 1. / (1_MeV), 0;
+  Covariance covMat196;
+  covMat196 << 0.0681927874684333801, 0.00231532290305440673,
+      -0.00145939788550150835, 7.36670177096379346e-06,
+      -3.68450500773211916e-07 * 1. / (1_MeV), 0, 0.00231532290305440673,
+      1.3315422534942627, -0.000122508412210780388, 0.00171897979661990116,
+      1.76497106084476643e-08 * 1. / (1_MeV), 0, -0.00145939788550150835,
+      -0.000122508412210780388, 3.25632354361005127e-05,
+      -2.55214252507531063e-07, 1.09182558397378106e-08 * 1. / (1_MeV), 0,
+      7.36670177096379346e-06, 0.00171897979661990116, -2.55214252507531063e-07,
+      2.29971669796213973e-06, -1.84419314901396339e-12 * 1. / (1_MeV), 0,
+      -3.68450500773211916e-07 * 1. / (1_MeV),
+      1.76497106084476643e-08 * 1. / (1_MeV),
+      1.09182558397378106e-08 * 1. / (1_MeV),
+      -1.84419314901396339e-12 * 1. / (1_MeV),
+      6.27720861401392938e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams196 = BoundParameters(tgContext, std::move(covMat196),
+                                        params196, perigeeSurface);
+  tracks.push_back(boundParams196);
+
+  // track 197 :
+  BoundVector params197;
+  params197 << 0.193900123238563538, -49.2524490356445312, 1.49366855621337891,
+      0.566030263900756836, -0.000631641771178692579 * 1. / (1_MeV), 0;
+  Covariance covMat197;
+  covMat197 << 0.0389422886073589325, 9.48181031765662076e-05,
+      -0.000864193462432249256, -6.76416801720607369e-06,
+      -2.91262857280178875e-07 * 1. / (1_MeV), 0, 9.48181031765662076e-05,
+      0.157681390643119812, 2.04442639286554837e-05, 0.000927270582484305585,
+      -1.8757136234213445e-08 * 1. / (1_MeV), 0, -0.000864193462432249256,
+      2.04442639286554837e-05, 2.00722697627497837e-05, 2.89773386592212807e-07,
+      8.81223262771924531e-09 * 1. / (1_MeV), 0, -6.76416801720607369e-06,
+      0.000927270582484305585, 2.89773386592212807e-07, 5.88341436014161445e-06,
+      -3.63880446087211061e-11 * 1. / (1_MeV), 0,
+      -2.91262857280178875e-07 * 1. / (1_MeV),
+      -1.8757136234213445e-08 * 1. / (1_MeV),
+      8.81223262771924531e-09 * 1. / (1_MeV),
+      -3.63880446087211061e-11 * 1. / (1_MeV),
+      1.12412849861964759e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams197 = BoundParameters(tgContext, std::move(covMat197),
+                                        params197, perigeeSurface);
+  tracks.push_back(boundParams197);
+
   return tracks;
 }
 
-- 
GitLab


From 93bfb693765e3f444a5532d47e87243232a31e9e Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Fri, 28 Feb 2020 17:45:52 +0100
Subject: [PATCH 34/60] add missing docs

---
 Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index ad5163674..2eada8b97 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -334,7 +334,12 @@ class AdaptiveMultiVertexFinder {
       const Vertex<InputTrack_t>* vtx,
       const std::vector<Vertex<InputTrack_t>*>& allVertices) const;
 
-  // TODO
+  /// @brief Prepares the output vector of vertices
+  ///
+  /// @param allVerticesPtr Vector of pointers to vertices
+  /// @param fitterState The vertex fitter state
+  ///
+  /// @return The output vertex collection
   std::vector<Vertex<InputTrack_t>> getVertexOutputList(
       const std::vector<Vertex<InputTrack_t>*>& allVerticesPtr,
       FitterState_t& fitterState) const;
-- 
GitLab


From 0bfd4abc2af7011dd7ba066a30c2c2640457ecd1 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Fri, 28 Feb 2020 17:46:26 +0100
Subject: [PATCH 35/60] remove vertex seed from collectionbefore break in AMVF

---
 Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index 7999a7f72..313c30761 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -62,6 +62,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     if (vtxCandidate->position().z() == 0.) {
       ACTS_DEBUG(
           "No seed found anymore. Break and stop primary vertex finding.");
+      allVertices.pop_back();
+      allVerticesPtr.pop_back();
       break;
     }
     auto prepResult = canPrepareVertexForFit(myTracks, seedTracks, vtxCandidate,
@@ -72,6 +74,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     }
     if (!(*prepResult)) {
       ACTS_DEBUG("Could not prepare for fit anymore. Break.");
+      allVertices.pop_back();
+      allVerticesPtr.pop_back();
       break;
     }
     // Update fitter state with all vertices
@@ -104,6 +108,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
       if (!removedNonCompatibleTrack) {
         ACTS_DEBUG(
             "Could not remove any further track from seed tracks. Break.");
+        allVertices.pop_back();
+        allVerticesPtr.pop_back();
         break;
       }
     }
-- 
GitLab


From 03184caacef9a2d50e60f07408ba8b096dc0b59c Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Fri, 28 Feb 2020 17:47:03 +0100
Subject: [PATCH 36/60] compare AMVF results with athena outcomes in test

---
 .../UnitTests/Core/Vertexing/AMVFTestData.ipp | 4709 ++++++++++++++++
 .../AdaptiveMultiVertexFinderTests.cpp        | 4756 +----------------
 2 files changed, 4783 insertions(+), 4682 deletions(-)
 create mode 100644 Tests/UnitTests/Core/Vertexing/AMVFTestData.ipp

diff --git a/Tests/UnitTests/Core/Vertexing/AMVFTestData.ipp b/Tests/UnitTests/Core/Vertexing/AMVFTestData.ipp
new file mode 100644
index 000000000..f16726c13
--- /dev/null
+++ b/Tests/UnitTests/Core/Vertexing/AMVFTestData.ipp
@@ -0,0 +1,4709 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2020 CERN for the benefit of the Acts project
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#include "Acts/Utilities/Definitions.hpp"
+#include "Acts/Utilities/Units.hpp"
+
+///////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////
+// Test data to produce a vector of track parameters for the Adaptive
+// multi vertex finder test. These tracks are taken from an athena q440
+// reco job (master/2020-02-20T2134) input to the primary vertex finding.
+///////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////
+
+namespace Acts {
+namespace Test {
+
+using namespace Acts::UnitLiterals;
+using Covariance = Acts::BoundSymMatrix;
+
+GeometryContext gctx = GeometryContext();
+// Return all tracks of one single event as reconstructed in athena.
+std::vector<const BoundParameters> getAthenaTracks() {
+  std::vector<const BoundParameters> tracks;
+
+  std::shared_ptr<PerigeeSurface> perigeeSurface =
+      Surface::makeShared<PerigeeSurface>(Vector3D(0, 0, 0));
+
+  // track 0 :
+  BoundVector params0;
+  params0 << 0.208999365568161011, -7.4357142448425293, -2.55163192749023438,
+      0.400493592023849487, 0.000171513980603776872 * 1. / (1_MeV), 0;
+  Covariance covMat0;
+  covMat0 << 0.00214068428613245487, -7.96709354183403084e-05,
+      -6.33177642943666364e-05, -3.00625320493796891e-07,
+      -4.07648672868712677e-08 * 1. / (1_MeV), 0, -7.96709354183403084e-05,
+      0.0202132239937782288, 6.98606246685060205e-07, 8.37879139489858309e-05,
+      -8.87738057299842411e-10 * 1. / (1_MeV), 0, -6.33177642943666364e-05,
+      6.98606246685060205e-07, 1.92246739061374683e-06, 3.3797454010498409e-09,
+      1.96217863793276324e-09 * 1. / (1_MeV), 0, -3.00625320493796891e-07,
+      8.37879139489858309e-05, 3.3797454010498409e-09, 3.60428089152264874e-07,
+      -2.89474607768885319e-13 * 1. / (1_MeV), 0,
+      -4.07648672868712677e-08 * 1. / (1_MeV),
+      -8.87738057299842411e-10 * 1. / (1_MeV),
+      1.96217863793276324e-09 * 1. / (1_MeV),
+      -2.89474607768885319e-13 * 1. / (1_MeV),
+      2.95636293223822122e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams0 =
+      BoundParameters(gctx, std::move(covMat0), params0, perigeeSurface);
+  tracks.push_back(boundParams0);
+
+  // track 1 :
+  BoundVector params1;
+  params1 << -0.824735164642333984, -26.9860115051269531, -0.7550087571144104,
+      2.88085079193115234, -0.000325617991620674729 * 1. / (1_MeV), 0;
+  Covariance covMat1;
+  covMat1 << 0.0251417625695466995, 0.00420630678879723493,
+      -0.000765272953239746903, 6.15640108953951687e-06,
+      -2.11256706714709132e-07 * 1. / (1_MeV), 0, 0.00420630678879723493,
+      0.45946967601776123, -0.00017342003098708611, 0.000916811988348789977,
+      -4.01729661445370942e-08 * 1. / (1_MeV), 0, -0.000765272953239746903,
+      -0.00017342003098708611, 2.36324631259776652e-05,
+      -2.76756048013333578e-07, 1.12351950637584698e-08 * 1. / (1_MeV), 0,
+      6.15640108953951687e-06, 0.000916811988348789977,
+      -2.76756048013333578e-07, 1.84237103439954808e-06,
+      -2.85976888807477401e-11 * 1. / (1_MeV), 0,
+      -2.11256706714709132e-07 * 1. / (1_MeV),
+      -4.01729661445370942e-08 * 1. / (1_MeV),
+      1.12351950637584698e-08 * 1. / (1_MeV),
+      -2.85976888807477401e-11 * 1. / (1_MeV),
+      1.26268676070573349e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams1 =
+      BoundParameters(gctx, std::move(covMat1), params1, perigeeSurface);
+  tracks.push_back(boundParams1);
+
+  // track 2 :
+  BoundVector params2;
+  params2 << 0.118518374860286713, -48.0805015563964844, -2.49598431587219238,
+      0.356813013553619385, 1.4544933037541341e-05 * 1. / (1_MeV), 0;
+  Covariance covMat2;
+  covMat2 << 0.00012035925465170294, -1.71798710526704588e-05,
+      -2.2860801492818823e-06, -2.13407107938616708e-08,
+      -8.14879249062358672e-10 * 1. / (1_MeV), 0, -1.71798710526704588e-05,
+      0.00348281394690275192, 1.23563722604002285e-07, 5.49114154040670388e-06,
+      2.65331046074031372e-11 * 1. / (1_MeV), 0, -2.2860801492818823e-06,
+      1.23563722604002285e-07, 5.03515273919674655e-08, 2.09996509522900305e-10,
+      2.36859555262461008e-11 * 1. / (1_MeV), 0, -2.13407107938616708e-08,
+      5.49114154040670388e-06, 2.09996509522900305e-10, 1.09355804411848112e-08,
+      4.89767384223879453e-14 * 1. / (1_MeV), 0,
+      -8.14879249062358672e-10 * 1. / (1_MeV),
+      2.65331046074031372e-11 * 1. / (1_MeV),
+      2.36859555262461008e-11 * 1. / (1_MeV),
+      4.89767384223879453e-14 * 1. / (1_MeV),
+      2.01368720417934022e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams2 =
+      BoundParameters(gctx, std::move(covMat2), params2, perigeeSurface);
+  tracks.push_back(boundParams2);
+
+  // track 3 :
+  BoundVector params3;
+  params3 << 0.368123382329940796, -20.0190258026123047, -3.06338405609130859,
+      0.214836537837982178, -7.34859349904581904e-05 * 1. / (1_MeV), 0;
+  Covariance covMat3;
+  covMat3 << 0.00247312174178659916, -0.000435264296712661316,
+      -7.28904508252383349e-05, -6.00209640313102993e-07,
+      -1.5146067160372626e-08 * 1. / (1_MeV), 0, -0.000435264296712661316,
+      0.0798703059554100037, 1.0091468480348509e-05, 9.74132025003542101e-05,
+      -1.07193522414496703e-09 * 1. / (1_MeV), 0, -7.28904508252383349e-05,
+      1.0091468480348509e-05, 2.19589765038108453e-06, 1.58931373903659957e-08,
+      7.46303764303131372e-10 * 1. / (1_MeV), 0, -6.00209640313102993e-07,
+      9.74132025003542101e-05, 1.58931373903659957e-08, 1.23175823318888433e-07,
+      3.22868607412569302e-13 * 1. / (1_MeV), 0,
+      -1.5146067160372626e-08 * 1. / (1_MeV),
+      -1.07193522414496703e-09 * 1. / (1_MeV),
+      7.46303764303131372e-10 * 1. / (1_MeV),
+      3.22868607412569302e-13 * 1. / (1_MeV),
+      6.43069972272591883e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams3 =
+      BoundParameters(gctx, std::move(covMat3), params3, perigeeSurface);
+  tracks.push_back(boundParams3);
+
+  // track 4 :
+  BoundVector params4;
+  params4 << 0.462106257677078247, -45.3825263977050781, 1.54434430599212646,
+      0.558617532253265381, -3.18408128805458546e-05 * 1. / (1_MeV), 0;
+  Covariance covMat4;
+  covMat4 << 0.000138078830786980689, -4.74506524313709474e-06,
+      -2.59465406890078115e-06, -1.74446828994113136e-08,
+      -1.79858408809330508e-09 * 1. / (1_MeV), 0, -4.74506524313709474e-06,
+      0.00170238339342176914, 4.66287404599609629e-08, 6.20544387605423323e-06,
+      -4.15978667666583788e-10 * 1. / (1_MeV), 0, -2.59465406890078115e-06,
+      4.66287404599609629e-08, 5.59409834011148632e-08, 2.68972091189718476e-10,
+      4.44398634319667074e-11 * 1. / (1_MeV), 0, -1.74446828994113136e-08,
+      6.20544387605423323e-06, 2.68972091189718476e-10, 3.03028748760425515e-08,
+      -1.68471064059951095e-12 * 1. / (1_MeV), 0,
+      -1.79858408809330508e-09 * 1. / (1_MeV),
+      -4.15978667666583788e-10 * 1. / (1_MeV),
+      4.44398634319667074e-11 * 1. / (1_MeV),
+      -1.68471064059951095e-12 * 1. / (1_MeV),
+      5.01555231808420432e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams4 =
+      BoundParameters(gctx, std::move(covMat4), params4, perigeeSurface);
+  tracks.push_back(boundParams4);
+
+  // track 5 :
+  BoundVector params5;
+  params5 << -0.243943929672241211, 0.680740892887115479, 0.597834229469299316,
+      0.471394985914230347, 0.000422831799369305372 * 1. / (1_MeV), 0;
+  Covariance covMat5;
+  covMat5 << 0.00671237893402576447, 5.08571871304874882e-05,
+      -0.000202164056117718448, 1.79538343147805643e-06,
+      -7.75962475463819757e-08 * 1. / (1_MeV), 0, 5.08571871304874882e-05,
+      0.0489778071641921997, -6.91368197228182291e-06, 0.000294139645283991724,
+      3.11541037258698699e-09 * 1. / (1_MeV), 0, -0.000202164056117718448,
+      -6.91368197228182291e-06, 6.17467458141618408e-06,
+      -8.53989223955858972e-08, 3.75976367980382885e-09 * 1. / (1_MeV), 0,
+      1.79538343147805643e-06, 0.000294139645283991724,
+      -8.53989223955858972e-08, 1.79972050773358205e-06,
+      2.80142049328043291e-12 * 1. / (1_MeV), 0,
+      -7.75962475463819757e-08 * 1. / (1_MeV),
+      3.11541037258698699e-09 * 1. / (1_MeV),
+      3.75976367980382885e-09 * 1. / (1_MeV),
+      2.80142049328043291e-12 * 1. / (1_MeV),
+      6.64618290957541547e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams5 =
+      BoundParameters(gctx, std::move(covMat5), params5, perigeeSurface);
+  tracks.push_back(boundParams5);
+
+  // track 6 :
+  BoundVector params6;
+  params6 << 0.475236207246780396, -0.555901706218719482, -2.99527096748352051,
+      1.8675537109375, 0.000811780162621289492 * 1. / (1_MeV), 0;
+  Covariance covMat6;
+  covMat6 << 0.00304217985831201077, -2.25882172757928212e-05,
+      -8.97036319376342655e-05, -4.59106853961998723e-07,
+      -4.27624663748239102e-08 * 1. / (1_MeV), 0, -2.25882172757928212e-05,
+      0.00797311495989561081, 1.20376337146220198e-06, 0.000183945562259729228,
+      2.1216330790963481e-09 * 1. / (1_MeV), 0, -8.97036319376342655e-05,
+      1.20376337146220198e-06, 2.68421172222588211e-06, 2.66801954035878537e-08,
+      2.01812436010421032e-09 * 1. / (1_MeV), 0, -4.59106853961998723e-07,
+      0.000183945562259729228, 2.66801954035878537e-08, 4.72296460429788567e-06,
+      5.98997883150413798e-11 * 1. / (1_MeV), 0,
+      -4.27624663748239102e-08 * 1. / (1_MeV),
+      2.1216330790963481e-09 * 1. / (1_MeV),
+      2.01812436010421032e-09 * 1. / (1_MeV),
+      5.98997883150413798e-11 * 1. / (1_MeV),
+      7.336908858235347e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams6 =
+      BoundParameters(gctx, std::move(covMat6), params6, perigeeSurface);
+  tracks.push_back(boundParams6);
+
+  // track 7 :
+  BoundVector params7;
+  params7 << 0.448179751634597778, -45.4515190124511719, 1.47425985336303711,
+      0.590856075286865234, 0.000101737932709511369 * 1. / (1_MeV), 0;
+  Covariance covMat7;
+  covMat7 << 0.000363267812645062804, -5.84171889726608582e-06,
+      -9.84987562994702426e-06, -3.80723442526054169e-08,
+      -5.40267153936386849e-09 * 1. / (1_MeV), 0, -5.84171889726608582e-06,
+      0.00307919480837881565, -5.80046399822108589e-08, 2.00901792637231817e-05,
+      -1.06284200946168232e-10 * 1. / (1_MeV), 0, -9.84987562994702426e-06,
+      -5.80046399822108589e-08, 2.79255488067065016e-07,
+      1.31849282891976127e-10, 2.35086178574079181e-10 * 1. / (1_MeV), 0,
+      -3.80723442526054169e-08, 2.00901792637231817e-05,
+      1.31849282891976127e-10, 1.53749851961038075e-07,
+      1.15397785221538584e-12 * 1. / (1_MeV), 0,
+      -5.40267153936386849e-09 * 1. / (1_MeV),
+      -1.06284200946168232e-10 * 1. / (1_MeV),
+      2.35086178574079181e-10 * 1. / (1_MeV),
+      1.15397785221538584e-12 * 1. / (1_MeV),
+      4.62566573586342678e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams7 =
+      BoundParameters(gctx, std::move(covMat7), params7, perigeeSurface);
+  tracks.push_back(boundParams7);
+
+  // track 8 :
+  BoundVector params8;
+  params8 << -0.0999302864074707031, -28.5842227935791016, -1.68599784374237061,
+      0.212112680077552795, 0.000165652469149790704 * 1. / (1_MeV), 0;
+  Covariance covMat8;
+  covMat8 << 0.0116489045321941376, -0.000940270776104953194,
+      -0.000352319442915666192, -2.13370040931020126e-07,
+      -8.36209125013331952e-08 * 1. / (1_MeV), 0, -0.000940270776104953194,
+      0.291504502296447754, 8.5972731503188673e-06, 0.000378374215149366048,
+      5.11104877714145611e-09 * 1. / (1_MeV), 0, -0.000352319442915666192,
+      8.5972731503188673e-06, 1.08157237264094874e-05, -1.70526684678213333e-08,
+      4.01226430794326207e-09 * 1. / (1_MeV), 0, -2.13370040931020126e-07,
+      0.000378374215149366048, -1.70526684678213333e-08, 4.9813826308309217e-07,
+      7.61584071858783847e-13 * 1. / (1_MeV), 0,
+      -8.36209125013331952e-08 * 1. / (1_MeV),
+      5.11104877714145611e-09 * 1. / (1_MeV),
+      4.01226430794326207e-09 * 1. / (1_MeV),
+      7.61584071858783847e-13 * 1. / (1_MeV),
+      3.27873631023045675e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams8 =
+      BoundParameters(gctx, std::move(covMat8), params8, perigeeSurface);
+  tracks.push_back(boundParams8);
+
+  // track 9 :
+  BoundVector params9;
+  params9 << 0.152172759175300598, -44.9148368835449219, 1.11447858810424805,
+      0.444638043642044067, -4.85752825625240803e-05 * 1. / (1_MeV), 0;
+  Covariance covMat9;
+  covMat9 << 0.000584102817811071873, -5.44941413560534802e-05,
+      -1.26293938525266511e-05, -1.64085737189133858e-07,
+      -2.36394827653963764e-09 * 1. / (1_MeV), 0, -5.44941413560534802e-05,
+      0.00448216451331973076, 1.03947024549991706e-06, 1.60899248222629787e-05,
+      -6.13962752714581741e-10 * 1. / (1_MeV), 0, -1.26293938525266511e-05,
+      1.03947024549991706e-06, 2.90120709678376443e-07, 3.39785893631303301e-09,
+      8.40703862829191019e-11 * 1. / (1_MeV), 0, -1.64085737189133858e-07,
+      1.60899248222629787e-05, 3.39785893631303301e-09, 6.88935983816918451e-08,
+      -1.33380435332641628e-12 * 1. / (1_MeV), 0,
+      -2.36394827653963764e-09 * 1. / (1_MeV),
+      -6.13962752714581741e-10 * 1. / (1_MeV),
+      8.40703862829191019e-11 * 1. / (1_MeV),
+      -1.33380435332641628e-12 * 1. / (1_MeV),
+      1.12903610072212501e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams9 =
+      BoundParameters(gctx, std::move(covMat9), params9, perigeeSurface);
+  tracks.push_back(boundParams9);
+
+  // track 10 :
+  BoundVector params10;
+  params10 << -0.389045566320419312, -24.5613670349121094, -1.53248834609985352,
+      2.95340991020202637, 4.71094026579521596e-05 * 1. / (1_MeV), 0;
+  Covariance covMat10;
+  covMat10 << 0.00179947458673268557, 0.000515301817937796288,
+      -5.33457823139441806e-05, 3.56486698371958979e-07,
+      -1.94156960953159151e-08 * 1. / (1_MeV), 0, 0.000515301817937796288,
+      0.0590848624706268311, -1.31940455534009742e-05, 5.69552185596370288e-05,
+      -4.96614965526505315e-10 * 1. / (1_MeV), 0, -5.33457823139441806e-05,
+      -1.31940455534009742e-05, 1.63217691806494258e-06,
+      -8.93780411334805054e-09, 9.9924929691409935e-10 * 1. / (1_MeV), 0,
+      3.56486698371958979e-07, 5.69552185596370288e-05,
+      -8.93780411334805054e-09, 5.66441578087051312e-08,
+      1.78960551097981704e-12 * 1. / (1_MeV), 0,
+      -1.94156960953159151e-08 * 1. / (1_MeV),
+      -4.96614965526505315e-10 * 1. / (1_MeV),
+      9.9924929691409935e-10 * 1. / (1_MeV),
+      1.78960551097981704e-12 * 1. / (1_MeV),
+      7.76793473294956627e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams10 =
+      BoundParameters(gctx, std::move(covMat10), params10, perigeeSurface);
+  tracks.push_back(boundParams10);
+
+  // track 11 :
+  BoundVector params11;
+  params11 << 0.185064643621444702, -0.313567250967025757, -2.70109248161315918,
+      1.87472164630889893, 0.00110536499414592981 * 1. / (1_MeV), 0;
+  Covariance covMat11;
+  covMat11 << 0.00607731565833091736, 1.88963384623831746e-05,
+      -0.000169582357508678549, -6.27965247220519728e-07,
+      -8.0749598939812492e-08 * 1. / (1_MeV), 0, 1.88963384623831746e-05,
+      0.0179781261831521988, 1.49729644512497734e-06, 0.00036414153838812695,
+      2.41630691182238931e-09 * 1. / (1_MeV), 0, -0.000169582357508678549,
+      1.49729644512497734e-06, 4.88961950395605527e-06, 5.74954357912554399e-08,
+      3.74836269648672209e-09 * 1. / (1_MeV), 0, -6.27965247220519728e-07,
+      0.00036414153838812695, 5.74954357912554399e-08, 8.48198396852239966e-06,
+      7.0596004861697542e-11 * 1. / (1_MeV), 0,
+      -8.0749598939812492e-08 * 1. / (1_MeV),
+      2.41630691182238931e-09 * 1. / (1_MeV),
+      3.74836269648672209e-09 * 1. / (1_MeV),
+      7.0596004861697542e-11 * 1. / (1_MeV),
+      1.38257211235170985e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams11 =
+      BoundParameters(gctx, std::move(covMat11), params11, perigeeSurface);
+  tracks.push_back(boundParams11);
+
+  // track 12 :
+  BoundVector params12;
+  params12 << -0.706103920936584473, -8.715667724609375, -1.11427760124206543,
+      0.390437692403793335, -0.000532702077180147171 * 1. / (1_MeV), 0;
+  Covariance covMat12;
+  covMat12 << 0.0187691841274499893, -0.0011922780217786253,
+      -0.00057461193605452235, -3.44533681528817511e-06,
+      -4.01344704143888752e-07 * 1. / (1_MeV), 0, -0.0011922780217786253,
+      0.151490718126296997, 5.75941132180694864e-05, 0.000636005119141786097,
+      2.44353971236399676e-08 * 1. / (1_MeV), 0, -0.00057461193605452235,
+      5.75941132180694864e-05, 1.79298804141581059e-05, 1.93515522095858729e-07,
+      2.04097502268213299e-08 * 1. / (1_MeV), 0, -3.44533681528817511e-06,
+      0.000636005119141786097, 1.93515522095858729e-07, 2.72269880952080712e-06,
+      -8.79447815502355232e-13 * 1. / (1_MeV), 0,
+      -4.01344704143888752e-07 * 1. / (1_MeV),
+      2.44353971236399676e-08 * 1. / (1_MeV),
+      2.04097502268213299e-08 * 1. / (1_MeV),
+      -8.79447815502355232e-13 * 1. / (1_MeV),
+      3.13229303605666587e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams12 =
+      BoundParameters(gctx, std::move(covMat12), params12, perigeeSurface);
+  tracks.push_back(boundParams12);
+
+  // track 13 :
+  BoundVector params13;
+  params13 << -0.154836609959602356, -20.9581050872802734, -2.51126766204833984,
+      2.93840575218200684, -0.000163531469297595322 * 1. / (1_MeV), 0;
+  Covariance covMat13;
+  covMat13 << 0.0135372020304203033, 0.000522583301631817797,
+      -0.000414465124389575392, 8.5218793332842329e-07,
+      -1.76418161813100027e-07 * 1. / (1_MeV), 0, 0.000522583301631817797,
+      0.337794691324234009, -3.07875272696438078e-05, 0.00040703982941800882,
+      -1.5122350796412209e-09 * 1. / (1_MeV), 0, -0.000414465124389575392,
+      -3.07875272696438078e-05, 1.29683203340391628e-05,
+      -4.41435125773279206e-08, 8.99447573145401141e-09 * 1. / (1_MeV), 0,
+      8.5218793332842329e-07, 0.00040703982941800882, -4.41435125773279206e-08,
+      4.96554378059954615e-07, 1.01639646010204121e-13 * 1. / (1_MeV), 0,
+      -1.76418161813100027e-07 * 1. / (1_MeV),
+      -1.5122350796412209e-09 * 1. / (1_MeV),
+      8.99447573145401141e-09 * 1. / (1_MeV),
+      1.01639646010204121e-13 * 1. / (1_MeV),
+      7.34017638337469691e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams13 =
+      BoundParameters(gctx, std::move(covMat13), params13, perigeeSurface);
+  tracks.push_back(boundParams13);
+
+  // track 14 :
+  BoundVector params14;
+  params14 << 0.429115772247314453, -24.0853328704833984, -3.03889799118041992,
+      1.37072885036468506, -0.00179144914727658033 * 1. / (1_MeV), 0;
+  Covariance covMat14;
+  covMat14 << 0.011815081350505352, -4.35886846561170212e-05,
+      -0.000356196480791449814, -3.06510243603507525e-06,
+      -2.49215155156052749e-07 * 1. / (1_MeV), 0, -4.35886846561170212e-05,
+      0.0279703252017498016, 3.82172586877418007e-06, 0.000700707100556712979,
+      2.18971032423624985e-10 * 1. / (1_MeV), 0, -0.000356196480791449814,
+      3.82172586877418007e-06, 1.08708409243263304e-05, 1.60096981832880633e-07,
+      1.23485013066819254e-08 * 1. / (1_MeV), 0, -3.06510243603507525e-06,
+      0.000700707100556712979, 1.60096981832880633e-07, 1.87871864909538999e-05,
+      3.9118155474036915e-11 * 1. / (1_MeV), 0,
+      -2.49215155156052749e-07 * 1. / (1_MeV),
+      2.18971032423624985e-10 * 1. / (1_MeV),
+      1.23485013066819254e-08 * 1. / (1_MeV),
+      3.9118155474036915e-11 * 1. / (1_MeV),
+      4.91916063438679885e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams14 =
+      BoundParameters(gctx, std::move(covMat14), params14, perigeeSurface);
+  tracks.push_back(boundParams14);
+
+  // track 15 :
+  BoundVector params15;
+  params15 << 0.0964239463210105896, -47.889434814453125, -2.51376533508300781,
+      0.37591966986656189, -7.28844097466208041e-05 * 1. / (1_MeV), 0;
+  Covariance covMat15;
+  covMat15 << 0.000915166805498301983, -5.63928610000066137e-05,
+      -2.30546935251043627e-05, -1.39514212094140237e-07,
+      -8.05606781506218595e-09 * 1. / (1_MeV), 0, -5.63928610000066137e-05,
+      0.00867577362805604935, 1.03957424061424194e-06, 2.75793322198900407e-05,
+      -3.50129287353289466e-11 * 1. / (1_MeV), 0, -2.30546935251043627e-05,
+      1.03957424061424194e-06, 6.37507866940723034e-07, 3.5300612609194207e-09,
+      3.32995301645455374e-10 * 1. / (1_MeV), 0, -1.39514212094140237e-07,
+      2.75793322198900407e-05, 3.5300612609194207e-09, 1.00911485390042799e-07,
+      -2.86168849963761193e-13 * 1. / (1_MeV), 0,
+      -8.05606781506218595e-09 * 1. / (1_MeV),
+      -3.50129287353289466e-11 * 1. / (1_MeV),
+      3.32995301645455374e-10 * 1. / (1_MeV),
+      -2.86168849963761193e-13 * 1. / (1_MeV),
+      3.81985762465397727e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams15 =
+      BoundParameters(gctx, std::move(covMat15), params15, perigeeSurface);
+  tracks.push_back(boundParams15);
+
+  // track 16 :
+  BoundVector params16;
+  params16 << -1.083709716796875, -0.935704529285430908, -0.732377231121063232,
+      2.61545205116271973, -0.00085982074961066246 * 1. / (1_MeV), 0;
+  Covariance covMat16;
+  covMat16 << 0.020250808447599411, 0.00134430434697943471,
+      -0.000619652083316512593, 5.49275271760961433e-06,
+      -5.75555269925167598e-07 * 1. / (1_MeV), 0, 0.00134430434697943471,
+      0.0884110480546951294, -5.99276194628552559e-05, 0.000655524024191507732,
+      -5.54305280465676383e-08 * 1. / (1_MeV), 0, -0.000619652083316512593,
+      -5.99276194628552559e-05, 1.93270625459263101e-05,
+      -3.0658624571105338e-07, 2.90396851494721417e-08 * 1. / (1_MeV), 0,
+      5.49275271760961433e-06, 0.000655524024191507732, -3.0658624571105338e-07,
+      4.93054767503053881e-06, -1.14583522129541419e-10 * 1. / (1_MeV), 0,
+      -5.75555269925167598e-07 * 1. / (1_MeV),
+      -5.54305280465676383e-08 * 1. / (1_MeV),
+      2.90396851494721417e-08 * 1. / (1_MeV),
+      -1.14583522129541419e-10 * 1. / (1_MeV),
+      6.01911798181475888e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams16 =
+      BoundParameters(gctx, std::move(covMat16), params16, perigeeSurface);
+  tracks.push_back(boundParams16);
+
+  // track 17 :
+  BoundVector params17;
+  params17 << -0.655812859535217285, -13.5116653442382812, -1.45666837692260742,
+      0.292341023683547974, -0.000473626889288425446 * 1. / (1_MeV), 0;
+  Covariance covMat17;
+  covMat17 << 0.0376270599663257599, -0.00331542860473353455,
+      -0.00114237259512064548, -6.46160583865347861e-06,
+      -5.41927356748457027e-07 * 1. / (1_MeV), 0, -0.00331542860473353455,
+      0.453363090753555298, 0.000154569181769570089, 0.00111683225416074725,
+      4.13684226275355482e-08 * 1. / (1_MeV), 0, -0.00114237259512064548,
+      0.000154569181769570089, 3.53331015503499657e-05, 3.31737366693554871e-07,
+      2.71004393542162535e-08 * 1. / (1_MeV), 0, -6.46160583865347861e-06,
+      0.00111683225416074725, 3.31737366693554871e-07, 2.77932576864259318e-06,
+      8.98558886340603463e-12 * 1. / (1_MeV), 0,
+      -5.41927356748457027e-07 * 1. / (1_MeV),
+      4.13684226275355482e-08 * 1. / (1_MeV),
+      2.71004393542162535e-08 * 1. / (1_MeV),
+      8.98558886340603463e-12 * 1. / (1_MeV),
+      3.11804027042228427e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams17 =
+      BoundParameters(gctx, std::move(covMat17), params17, perigeeSurface);
+  tracks.push_back(boundParams17);
+
+  // track 18 :
+  BoundVector params18;
+  params18 << 0.575450718402862549, -15.9936590194702148, -2.98787665367126465,
+      0.166759386658668518, 9.08106376300565898e-05 * 1. / (1_MeV), 0;
+  Covariance covMat18;
+  covMat18 << 0.00828655995428562164, 0.000185564554592324227,
+      -0.000254140606495853623, -3.35073246108407e-07,
+      -1.308304405438276e-07 * 1. / (1_MeV), 0, 0.000185564554592324227,
+      0.291260480880737305, -1.50678458478300795e-05, 0.000236462002833863597,
+      -2.12250899201718451e-08 * 1. / (1_MeV), 0, -0.000254140606495853623,
+      -1.50678458478300795e-05, 8.0477584560867399e-06, 3.73422528117420346e-09,
+      6.7895997118531728e-09 * 1. / (1_MeV), 0, -3.35073246108407e-07,
+      0.000236462002833863597, 3.73422528117420346e-09, 1.94628071881197684e-07,
+      -1.03714183548395548e-12 * 1. / (1_MeV), 0,
+      -1.308304405438276e-07 * 1. / (1_MeV),
+      -2.12250899201718451e-08 * 1. / (1_MeV),
+      6.7895997118531728e-09 * 1. / (1_MeV),
+      -1.03714183548395548e-12 * 1. / (1_MeV),
+      4.68583748192141769e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams18 =
+      BoundParameters(gctx, std::move(covMat18), params18, perigeeSurface);
+  tracks.push_back(boundParams18);
+
+  // track 19 :
+  BoundVector params19;
+  params19 << 0.450536131858825684, -45.6087112426757812, 1.54512977600097656,
+      0.65365976095199585, 5.42995185242034495e-05 * 1. / (1_MeV), 0;
+  Covariance covMat19;
+  covMat19 << 0.000259126914897933602, -7.71187497722190822e-06,
+      -5.15114709723808123e-06, -2.6619027249675935e-08,
+      -2.6312704155352256e-09 * 1. / (1_MeV), 0, -7.71187497722190822e-06,
+      0.00295044109225273132, 4.46207192501835153e-08, 1.36801867739356403e-05,
+      -6.77873236221157013e-10 * 1. / (1_MeV), 0, -5.15114709723808123e-06,
+      4.46207192501835153e-08, 1.1458803328423528e-07, 1.22672567207018586e-10,
+      8.3325729033356906e-11 * 1. / (1_MeV), 0, -2.6619027249675935e-08,
+      1.36801867739356403e-05, 1.22672567207018586e-10, 8.8454470414944808e-08,
+      -4.19827894841714947e-12 * 1. / (1_MeV), 0,
+      -2.6312704155352256e-09 * 1. / (1_MeV),
+      -6.77873236221157013e-10 * 1. / (1_MeV),
+      8.3325729033356906e-11 * 1. / (1_MeV),
+      -4.19827894841714947e-12 * 1. / (1_MeV),
+      1.43134245775278224e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams19 =
+      BoundParameters(gctx, std::move(covMat19), params19, perigeeSurface);
+  tracks.push_back(boundParams19);
+
+  // track 20 :
+  BoundVector params20;
+  params20 << 0.473463654518127441, -26.5566444396972656, 2.22220945358276367,
+      2.8751678466796875, -0.000256116356467828155 * 1. / (1_MeV), 0;
+  Covariance covMat20;
+  covMat20 << 0.0143999364227056503, -6.2299028153707387e-05,
+      -0.000435219809783413591, 2.17336195005980567e-06,
+      -1.21769702441849882e-07 * 1. / (1_MeV), 0, -6.2299028153707387e-05,
+      0.225834131240844727, -9.51855047040289537e-06, 0.000458192287494221199,
+      1.25566461565313107e-08 * 1. / (1_MeV), 0, -0.000435219809783413591,
+      -9.51855047040289537e-06, 1.33511766762239859e-05,
+      -9.24405891210373471e-08, 6.00420036495892829e-09 * 1. / (1_MeV), 0,
+      2.17336195005980567e-06, 0.000458192287494221199,
+      -9.24405891210373471e-08, 9.43835061661957297e-07,
+      -1.98670297988379238e-12 * 1. / (1_MeV), 0,
+      -1.21769702441849882e-07 * 1. / (1_MeV),
+      1.25566461565313107e-08 * 1. / (1_MeV),
+      6.00420036495892829e-09 * 1. / (1_MeV),
+      -1.98670297988379238e-12 * 1. / (1_MeV),
+      6.28335161678705845e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams20 =
+      BoundParameters(gctx, std::move(covMat20), params20, perigeeSurface);
+  tracks.push_back(boundParams20);
+
+  // track 21 :
+  BoundVector params21;
+  params21 << 0.474121242761611938, -45.3727645874023438, 1.55173587799072266,
+      0.574172139167785645, 5.4487241868628189e-05 * 1. / (1_MeV), 0;
+  Covariance covMat21;
+  covMat21 << 0.000224435978452675045, -3.34686356158648375e-08,
+      -4.87554553510472616e-06, -1.05072650608508861e-08,
+      -3.01031009155958153e-09 * 1. / (1_MeV), 0, -3.34686356158648375e-08,
+      0.00355649716220796108, -1.23797957582243194e-09, 1.29672827928777902e-05,
+      -5.29747367549304477e-10 * 1. / (1_MeV), 0, -4.87554553510472616e-06,
+      -1.23797957582243194e-09, 1.18275345073470817e-07,
+      1.10832502633235662e-10, 9.64028556852257677e-11 * 1. / (1_MeV), 0,
+      -1.05072650608508861e-08, 1.29672827928777902e-05,
+      1.10832502633235662e-10, 6.4137751110138197e-08,
+      -1.6225318684374243e-12 * 1. / (1_MeV), 0,
+      -3.01031009155958153e-09 * 1. / (1_MeV),
+      -5.29747367549304477e-10 * 1. / (1_MeV),
+      9.64028556852257677e-11 * 1. / (1_MeV),
+      -1.6225318684374243e-12 * 1. / (1_MeV),
+      1.46339776234405416e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams21 =
+      BoundParameters(gctx, std::move(covMat21), params21, perigeeSurface);
+  tracks.push_back(boundParams21);
+
+  // track 22 :
+  BoundVector params22;
+  params22 << -1.09075939655303955, -45.9652023315429688, -1.37540817260742188,
+      2.04655265808105469, -3.31696282955817878e-05 * 1. / (1_MeV), 0;
+  Covariance covMat22;
+  covMat22 << 0.000312969175865873694, 0.0001463311972326757,
+      -3.44899335412854335e-06, 1.27787244910060675e-06,
+      -1.09905405688468608e-08 * 1. / (1_MeV), 0, 0.0001463311972326757,
+      0.00594136770814657211, -1.71895848646021814e-06, 4.22735853806673674e-05,
+      -1.192286442570364e-08 * 1. / (1_MeV), 0, -3.44899335412854335e-06,
+      -1.71895848646021814e-06, 4.42678249612526997e-08,
+      -1.47011582918932722e-08, 1.32897993796644671e-10 * 1. / (1_MeV), 0,
+      1.27787244910060675e-06, 4.22735853806673674e-05,
+      -1.47011582918932722e-08, 3.68511109627434053e-07,
+      -1.04379022097924494e-10 * 1. / (1_MeV), 0,
+      -1.09905405688468608e-08 * 1. / (1_MeV),
+      -1.192286442570364e-08 * 1. / (1_MeV),
+      1.32897993796644671e-10 * 1. / (1_MeV),
+      -1.04379022097924494e-10 * 1. / (1_MeV),
+      1.09507943078096526e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams22 =
+      BoundParameters(gctx, std::move(covMat22), params22, perigeeSurface);
+  tracks.push_back(boundParams22);
+
+  // track 23 :
+  BoundVector params23;
+  params23 << -1.31657886505126953, -44.3285789489746094, -1.36793792247772217,
+      2.08678793907165527, -6.51905575068667531e-05 * 1. / (1_MeV), 0;
+  Covariance covMat23;
+  covMat23 << 0.000181945419171825051, -2.81234401866508066e-05,
+      -3.22076197235801949e-06, -7.63838237863357019e-08,
+      -3.46247467047687857e-09 * 1. / (1_MeV), 0, -2.81234401866508066e-05,
+      0.0078449668362736702, -1.27915101440830079e-07, 4.12960218865452011e-05,
+      -5.4435441037029841e-09 * 1. / (1_MeV), 0, -3.22076197235801949e-06,
+      -1.27915101440830079e-07, 6.53957670238014543e-08,
+      -1.06815947474639986e-09, 8.7867543161386892e-11 * 1. / (1_MeV), 0,
+      -7.63838237863357019e-08, 4.12960218865452011e-05,
+      -1.06815947474639986e-09, 3.63342195441873628e-07,
+      -5.37524150950671376e-11 * 1. / (1_MeV), 0,
+      -3.46247467047687857e-09 * 1. / (1_MeV),
+      -5.4435441037029841e-09 * 1. / (1_MeV),
+      8.7867543161386892e-11 * 1. / (1_MeV),
+      -5.37524150950671376e-11 * 1. / (1_MeV),
+      1.83543284737464063e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams23 =
+      BoundParameters(gctx, std::move(covMat23), params23, perigeeSurface);
+  tracks.push_back(boundParams23);
+
+  // track 24 :
+  BoundVector params24;
+  params24 << 0.468431740999221802, -45.6113662719726562, 1.57319939136505127,
+      0.724432468414306641, -6.46604967187158763e-05 * 1. / (1_MeV), 0;
+  Covariance covMat24;
+  covMat24 << 0.000443243887275457382, -2.3272761085957688e-05,
+      -8.05724456303655931e-06, -1.10478345604928828e-07,
+      -5.12934471198391627e-09 * 1. / (1_MeV), 0, -2.3272761085957688e-05,
+      0.00292888842523097992, 2.09734580782484699e-07, 1.69251524164295596e-05,
+      2.63255285816454836e-10 * 1. / (1_MeV), 0, -8.05724456303655931e-06,
+      2.09734580782484699e-07, 1.72984968571654463e-07, 1.6524169254854016e-09,
+      1.09902161546833325e-10 * 1. / (1_MeV), 0, -1.10478345604928828e-07,
+      1.69251524164295596e-05, 1.6524169254854016e-09, 1.26708812331344234e-07,
+      1.02436393801765789e-12 * 1. / (1_MeV), 0,
+      -5.12934471198391627e-09 * 1. / (1_MeV),
+      2.63255285816454836e-10 * 1. / (1_MeV),
+      1.09902161546833325e-10 * 1. / (1_MeV),
+      1.02436393801765789e-12 * 1. / (1_MeV),
+      1.77089365307331326e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams24 =
+      BoundParameters(gctx, std::move(covMat24), params24, perigeeSurface);
+  tracks.push_back(boundParams24);
+
+  // track 25 :
+  BoundVector params25;
+  params25 << 0.605970263481140137, -27.2015609741210938, 2.96404910087585449,
+      0.461374938488006592, -0.000201874907361343503 * 1. / (1_MeV), 0;
+  Covariance covMat25;
+  covMat25 << 0.00265368912369012833, -0.000160160863867693455,
+      -7.10252410690768288e-05, -1.03680404805919409e-06,
+      -2.01188254958249733e-08 * 1. / (1_MeV), 0, -0.000160160863867693455,
+      0.0171342100948095322, 3.50132547577921485e-06, 8.76344783019533907e-05,
+      7.09798679472868797e-10 * 1. / (1_MeV), 0, -7.10252410690768288e-05,
+      3.50132547577921485e-06, 1.98413022189924959e-06, 2.72794764037440166e-08,
+      8.99215162966161182e-10 * 1. / (1_MeV), 0, -1.03680404805919409e-06,
+      8.76344783019533907e-05, 2.72794764037440166e-08, 4.75305114377988502e-07,
+      8.86034124151153122e-12 * 1. / (1_MeV), 0,
+      -2.01188254958249733e-08 * 1. / (1_MeV),
+      7.09798679472868797e-10 * 1. / (1_MeV),
+      8.99215162966161182e-10 * 1. / (1_MeV),
+      8.86034124151153122e-12 * 1. / (1_MeV),
+      1.49597105536525277e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams25 =
+      BoundParameters(gctx, std::move(covMat25), params25, perigeeSurface);
+  tracks.push_back(boundParams25);
+
+  // track 26 :
+  BoundVector params26;
+  params26 << 0.373259454965591431, -45.9041404724121094, -2.82848834991455078,
+      2.05866789817810059, -0.000124583908473141491 * 1. / (1_MeV), 0;
+  Covariance covMat26;
+  covMat26 << 0.000358323537511751056, 5.45377012590961527e-06,
+      -7.43998460263549215e-06, -2.04257445390517592e-08,
+      -2.8271193498608263e-09 * 1. / (1_MeV), 0, 5.45377012590961527e-06,
+      0.00235699070617556572, -1.65012257788975246e-07, 2.44201179406483771e-05,
+      -1.12260566358553804e-09 * 1. / (1_MeV), 0, -7.43998460263549215e-06,
+      -1.65012257788975246e-07, 1.71034542972847703e-07,
+      5.99568256402865656e-10, 9.80197960016773152e-11 * 1. / (1_MeV), 0,
+      -2.04257445390517592e-08, 2.44201179406483771e-05,
+      5.99568256402865656e-10, 4.42280850165843731e-07,
+      -1.97182050693094459e-11 * 1. / (1_MeV), 0,
+      -2.8271193498608263e-09 * 1. / (1_MeV),
+      -1.12260566358553804e-09 * 1. / (1_MeV),
+      9.80197960016773152e-11 * 1. / (1_MeV),
+      -1.97182050693094459e-11 * 1. / (1_MeV),
+      2.83151215148269575e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams26 =
+      BoundParameters(gctx, std::move(covMat26), params26, perigeeSurface);
+  tracks.push_back(boundParams26);
+
+  // track 27 :
+  BoundVector params27;
+  params27 << 0.23818458616733551, -43.9735908508300781, 1.15663206577301025,
+      0.325361251831054688, -0.000120135584438685328 * 1. / (1_MeV), 0;
+  Covariance covMat27;
+  covMat27 << 0.00264720292761921883, -0.000279904810298890847,
+      -7.0787471462461463e-05, -6.09630619944338989e-07,
+      -2.72122881545780153e-08 * 1. / (1_MeV), 0, -0.000279904810298890847,
+      0.0381099320948123932, 6.2210670995119084e-06, 0.00010238674474765499,
+      8.91128192470317596e-11 * 1. / (1_MeV), 0, -7.0787471462461463e-05,
+      6.2210670995119084e-06, 1.99035594050656073e-06, 1.5641300493302086e-08,
+      1.26289836850190108e-09 * 1. / (1_MeV), 0, -6.09630619944338989e-07,
+      0.00010238674474765499, 1.5641300493302086e-08, 2.93358084491046611e-07,
+      2.02230046547630554e-12 * 1. / (1_MeV), 0,
+      -2.72122881545780153e-08 * 1. / (1_MeV),
+      8.91128192470317596e-11 * 1. / (1_MeV),
+      1.26289836850190108e-09 * 1. / (1_MeV),
+      2.02230046547630554e-12 * 1. / (1_MeV),
+      1.52509879725037933e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams27 =
+      BoundParameters(gctx, std::move(covMat27), params27, perigeeSurface);
+  tracks.push_back(boundParams27);
+
+  // track 28 :
+  BoundVector params28;
+  params28 << 0.379233330488204956, -45.0619316101074219, 1.36501443386077881,
+      0.467382907867431641, 7.43830823921598494e-05 * 1. / (1_MeV), 0;
+  Covariance covMat28;
+  covMat28 << 0.000463021540781483054, -3.19743694997498169e-05,
+      -1.22576460878201678e-05, -1.17553161873688474e-07,
+      -5.1874231027619962e-09 * 1. / (1_MeV), 0, -3.19743694997498169e-05,
+      0.00478032277897000313, 1.17327598364092336e-07, 1.94133319938421418e-05,
+      -2.06704265685090959e-10 * 1. / (1_MeV), 0, -1.22576460878201678e-05,
+      1.17327598364092336e-07, 3.46005350593259209e-07, 1.4500069383794639e-09,
+      2.06696790491209021e-10 * 1. / (1_MeV), 0, -1.17553161873688474e-07,
+      1.94133319938421418e-05, 1.4500069383794639e-09, 9.33096515609577182e-08,
+      1.00703744558876763e-12 * 1. / (1_MeV), 0,
+      -5.1874231027619962e-09 * 1. / (1_MeV),
+      -2.06704265685090959e-10 * 1. / (1_MeV),
+      2.06696790491209021e-10 * 1. / (1_MeV),
+      1.00703744558876763e-12 * 1. / (1_MeV),
+      2.83601007261546911e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams28 =
+      BoundParameters(gctx, std::move(covMat28), params28, perigeeSurface);
+  tracks.push_back(boundParams28);
+
+  // track 29 :
+  BoundVector params29;
+  params29 << 0.0437062010169029236, -6.05203485488891602, 0.845894753932952881,
+      2.40220952033996582, -0.00021497465786524117 * 1. / (1_MeV), 0;
+  Covariance covMat29;
+  covMat29 << 0.00100414641201496124, 7.52416013682256636e-05,
+      -2.59772254577332751e-05, 3.8490891938040421e-07,
+      -1.6676738431268612e-08 * 1. / (1_MeV), 0, 7.52416013682256636e-05,
+      0.00544706359505653381, -1.72766771292602573e-06, 4.92784133153511604e-05,
+      -1.22367109538203667e-09 * 1. / (1_MeV), 0, -2.59772254577332751e-05,
+      -1.72766771292602573e-06, 7.08758761902572587e-07,
+      -9.85089323790014416e-09, 6.84218014584375542e-10 * 1. / (1_MeV), 0,
+      3.8490891938040421e-07, 4.92784133153511604e-05, -9.85089323790014416e-09,
+      5.590306955127744e-07, -9.11246232266255587e-12 * 1. / (1_MeV), 0,
+      -1.6676738431268612e-08 * 1. / (1_MeV),
+      -1.22367109538203667e-09 * 1. / (1_MeV),
+      6.84218014584375542e-10 * 1. / (1_MeV),
+      -9.11246232266255587e-12 * 1. / (1_MeV),
+      1.55326706358094313e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams29 =
+      BoundParameters(gctx, std::move(covMat29), params29, perigeeSurface);
+  tracks.push_back(boundParams29);
+
+  // track 30 :
+  BoundVector params30;
+  params30 << -0.517760396003723145, -46.0633049011230469, -1.40931129455566406,
+      1.87501537799835205, 0.000927834073081612587 * 1. / (1_MeV), 0;
+  Covariance covMat30;
+  covMat30 << 0.00338696571998298168, 2.2701516820957546e-05,
+      -0.000100746524188053817, -6.39718888889637967e-07,
+      -5.16928846777282941e-08 * 1. / (1_MeV), 0, 2.2701516820957546e-05,
+      0.0142748663201928139, 1.52136563622953833e-07, 0.000252430357142510112,
+      -3.20784296654136601e-10 * 1. / (1_MeV), 0, -0.000100746524188053817,
+      1.52136563622953833e-07, 3.04392483485571574e-06, 3.67106627303256195e-08,
+      2.52688458153465702e-09 * 1. / (1_MeV), 0, -6.39718888889637967e-07,
+      0.000252430357142510112, 3.67106627303256195e-08, 5.46493629371980205e-06,
+      9.90579325614409665e-12 * 1. / (1_MeV), 0,
+      -5.16928846777282941e-08 * 1. / (1_MeV),
+      -3.20784296654136601e-10 * 1. / (1_MeV),
+      2.52688458153465702e-09 * 1. / (1_MeV),
+      9.90579325614409665e-12 * 1. / (1_MeV),
+      9.43339711900748057e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams30 =
+      BoundParameters(gctx, std::move(covMat30), params30, perigeeSurface);
+  tracks.push_back(boundParams30);
+
+  // track 31 :
+  BoundVector params31;
+  params31 << -0.525244832038879395, -0.217865616083145142,
+      -0.475070565938949585, 0.477265685796737671,
+      0.000297125487122684717 * 1. / (1_MeV), 0;
+  Covariance covMat31;
+  covMat31 << 0.00397888477891683578, -0.000295814951524862792,
+      -0.00011510871599225749, -1.88877208528145442e-07,
+      -3.65170360119058424e-08 * 1. / (1_MeV), 0, -0.000295814951524862792,
+      0.0287617519497871399, 4.36081614729639213e-06, 0.000165308229332130187,
+      2.86168612064016744e-09 * 1. / (1_MeV), 0, -0.00011510871599225749,
+      4.36081614729639213e-06, 3.41281020155292936e-06,
+      -1.47002165497313678e-08, 1.75686917916454533e-09 * 1. / (1_MeV), 0,
+      -1.88877208528145442e-07, 0.000165308229332130187,
+      -1.47002165497313678e-08, 9.93909566204820294e-07,
+      1.22169439162607638e-12 * 1. / (1_MeV), 0,
+      -3.65170360119058424e-08 * 1. / (1_MeV),
+      2.86168612064016744e-09 * 1. / (1_MeV),
+      1.75686917916454533e-09 * 1. / (1_MeV),
+      1.22169439162607638e-12 * 1. / (1_MeV),
+      3.16079003248592727e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams31 =
+      BoundParameters(gctx, std::move(covMat31), params31, perigeeSurface);
+  tracks.push_back(boundParams31);
+
+  // track 32 :
+  BoundVector params32;
+  params32 << -0.164086505770683289, -37.753753662109375, -1.87344110012054443,
+      2.57577276229858398, 0.000515770167112350464 * 1. / (1_MeV), 0;
+  Covariance covMat32;
+  covMat32 << 0.00635964749380946159, 4.45514887833019807e-05,
+      -0.000193066686713004587, -9.8075773789463948e-07,
+      -1.543514422213774e-07 * 1. / (1_MeV), 0, 4.45514887833019807e-05,
+      0.0324134901165962219, 3.01616810351035857e-06, 0.000257514567093702538,
+      -4.60722406707723369e-09 * 1. / (1_MeV), 0, -0.000193066686713004587,
+      3.01616810351035857e-06, 5.97237203692202456e-06, 6.40635690248244268e-08,
+      7.82772160913690927e-09 * 1. / (1_MeV), 0, -9.8075773789463948e-07,
+      0.000257514567093702538, 6.40635690248244268e-08, 2.12554232348338701e-06,
+      -2.69885970530160845e-12 * 1. / (1_MeV), 0,
+      -1.543514422213774e-07 * 1. / (1_MeV),
+      -4.60722406707723369e-09 * 1. / (1_MeV),
+      7.82772160913690927e-09 * 1. / (1_MeV),
+      -2.69885970530160845e-12 * 1. / (1_MeV),
+      1.721506964758035e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams32 =
+      BoundParameters(gctx, std::move(covMat32), params32, perigeeSurface);
+  tracks.push_back(boundParams32);
+
+  // track 33 :
+  BoundVector params33;
+  params33 << -0.422558963298797607, -25.4688777923583984, -1.69958257675170898,
+      2.64382648468017578, 0.00017704063793644309 * 1. / (1_MeV), 0;
+  Covariance covMat33;
+  covMat33 << 0.0013904899824410677, 0.000162016200161348015,
+      -3.89817331369023135e-05, 4.29909627029974153e-07,
+      -1.45160757016235074e-08 * 1. / (1_MeV), 0, 0.000162016200161348015,
+      0.0123065607622265816, -2.87947509703742562e-06, 6.703852723089744e-05,
+      -8.48754668083118025e-10 * 1. / (1_MeV), 0, -3.89817331369023135e-05,
+      -2.87947509703742562e-06, 1.12921497930074111e-06,
+      -4.83207911132727673e-09, 6.53490602957053302e-10 * 1. / (1_MeV), 0,
+      4.29909627029974153e-07, 6.703852723089744e-05, -4.83207911132727673e-09,
+      3.95028536104291561e-07, 5.22664500397267715e-13 * 1. / (1_MeV), 0,
+      -1.45160757016235074e-08 * 1. / (1_MeV),
+      -8.48754668083118025e-10 * 1. / (1_MeV),
+      6.53490602957053302e-10 * 1. / (1_MeV),
+      5.22664500397267715e-13 * 1. / (1_MeV),
+      1.14117890484544127e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams33 =
+      BoundParameters(gctx, std::move(covMat33), params33, perigeeSurface);
+  tracks.push_back(boundParams33);
+
+  // track 34 :
+  BoundVector params34;
+  params34 << -0.706149637699127197, -5.55039787292480469, -1.03704202175140381,
+      2.66923093795776367, 0.000632659648545086384 * 1. / (1_MeV), 0;
+  Covariance covMat34;
+  covMat34 << 0.0149489222094416618, 0.000618369321077981275,
+      -0.000455378611332247401, -2.5954498544077396e-06,
+      -2.91043194495528445e-07 * 1. / (1_MeV), 0, 0.000618369321077981275,
+      0.0851441845297813416, -4.93271553790423069e-06, 0.0005094039417602418,
+      -2.83093285269249633e-08 * 1. / (1_MeV), 0, -0.000455378611332247401,
+      -4.93271553790423069e-06, 1.41044911288190633e-05,
+      1.63956270962265813e-07, 1.48782651378673617e-08 * 1. / (1_MeV), 0,
+      -2.5954498544077396e-06, 0.0005094039417602418, 1.63956270962265813e-07,
+      3.11431858790456317e-06, -8.52575602760203913e-12 * 1. / (1_MeV), 0,
+      -2.91043194495528445e-07 * 1. / (1_MeV),
+      -2.83093285269249633e-08 * 1. / (1_MeV),
+      1.48782651378673617e-08 * 1. / (1_MeV),
+      -8.52575602760203913e-12 * 1. / (1_MeV),
+      2.77564138340125055e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams34 =
+      BoundParameters(gctx, std::move(covMat34), params34, perigeeSurface);
+  tracks.push_back(boundParams34);
+
+  // track 35 :
+  BoundVector params35;
+  params35 << 0.66977304220199585, -45.2442741394042969, 1.78884363174438477,
+      0.401856839656829834, 0.000140385964186862111 * 1. / (1_MeV), 0;
+  Covariance covMat35;
+  covMat35 << 0.00143626355566084385, -5.35207803621203505e-05,
+      -4.22572311413643752e-05, -3.20053881947622934e-07,
+      -4.44998922265500791e-08 * 1. / (1_MeV), 0, -5.35207803621203505e-05,
+      0.0170358996838331223, -9.72014409846223381e-08, 6.54062168950196484e-05,
+      -5.2860188976227197e-10 * 1. / (1_MeV), 0, -4.22572311413643752e-05,
+      -9.72014409846223381e-08, 1.28950614453060552e-06,
+      4.58471361676392425e-09, 2.07668118549997414e-09 * 1. / (1_MeV), 0,
+      -3.20053881947622934e-07, 6.54062168950196484e-05,
+      4.58471361676392425e-09, 2.676340216112294e-07,
+      8.60400887008258369e-12 * 1. / (1_MeV), 0,
+      -4.44998922265500791e-08 * 1. / (1_MeV),
+      -5.2860188976227197e-10 * 1. / (1_MeV),
+      2.07668118549997414e-09 * 1. / (1_MeV),
+      8.60400887008258369e-12 * 1. / (1_MeV),
+      3.06659697635325301e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams35 =
+      BoundParameters(gctx, std::move(covMat35), params35, perigeeSurface);
+  tracks.push_back(boundParams35);
+
+  // track 36 :
+  BoundVector params36;
+  params36 << 0.413177251815795898, -44.2774276733398438, 1.65670633316040039,
+      0.282397657632827759, 0.000249879318289458752 * 1. / (1_MeV), 0;
+  Covariance covMat36;
+  covMat36 << 0.0265074372291564941, -0.0048766653213794765,
+      -0.000651586934053853908, -7.10144307243836228e-06,
+      -2.56150394427947489e-07 * 1. / (1_MeV), 0, -0.0048766653213794765,
+      0.360502183437347412, 6.96873463333104177e-05, 0.000667993313991547253,
+      3.22042667667872301e-08 * 1. / (1_MeV), 0, -0.000651586934053853908,
+      6.96873463333104177e-05, 1.68455553648527712e-05, 9.1205915360878042e-08,
+      9.93307233918962727e-09 * 1. / (1_MeV), 0, -7.10144307243836228e-06,
+      0.000667993313991547253, 9.1205915360878042e-08, 1.2959271771251224e-06,
+      5.92305231785808206e-11 * 1. / (1_MeV), 0,
+      -2.56150394427947489e-07 * 1. / (1_MeV),
+      3.22042667667872301e-08 * 1. / (1_MeV),
+      9.93307233918962727e-09 * 1. / (1_MeV),
+      5.92305231785808206e-11 * 1. / (1_MeV),
+      8.93205231999871785e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams36 =
+      BoundParameters(gctx, std::move(covMat36), params36, perigeeSurface);
+  tracks.push_back(boundParams36);
+
+  // track 37 :
+  BoundVector params37;
+  params37 << 0.498688608407974243, -24.5804386138916016, 1.52300190925598145,
+      2.57985329627990723, -0.000602965301368385553 * 1. / (1_MeV), 0;
+  Covariance covMat37;
+  covMat37 << 0.00829706247895956039, -9.98736632524845883e-05,
+      -0.00024923303906360778, 1.90709718139177409e-06,
+      -7.88885613202604259e-08 * 1. / (1_MeV), 0, -9.98736632524845883e-05,
+      0.0392925664782524109, -2.2279263572824716e-06, 0.000312385200119348323,
+      4.01687609353752231e-09 * 1. / (1_MeV), 0, -0.00024923303906360778,
+      -2.2279263572824716e-06, 7.59069098421605304e-06,
+      -1.01456043862080861e-07, 4.11041373461571408e-09 * 1. / (1_MeV), 0,
+      1.90709718139177409e-06, 0.000312385200119348323,
+      -1.01456043862080861e-07, 2.56480029747763183e-06,
+      -2.55342842411113774e-12 * 1. / (1_MeV), 0,
+      -7.88885613202604259e-08 * 1. / (1_MeV),
+      4.01687609353752231e-09 * 1. / (1_MeV),
+      4.11041373461571408e-09 * 1. / (1_MeV),
+      -2.55342842411113774e-12 * 1. / (1_MeV),
+      9.23438478461768852e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams37 =
+      BoundParameters(gctx, std::move(covMat37), params37, perigeeSurface);
+  tracks.push_back(boundParams37);
+
+  // track 38 :
+  BoundVector params38;
+  params38 << 0.136582925915718079, -4.81802463531494141, -2.5786285400390625,
+      2.42307066917419434, 0.000150643929373472929 * 1. / (1_MeV), 0;
+  Covariance covMat38;
+  covMat38 << 0.000507234770338982344, 2.1336988269281213e-05,
+      -1.35209599010707551e-05, 1.0410117459028839e-07,
+      -9.58138079071134127e-09 * 1. / (1_MeV), 0, 2.1336988269281213e-05,
+      0.00488950824365019798, -3.46387683816058679e-07, 3.650374061662458e-05,
+      -4.69743203747746844e-09 * 1. / (1_MeV), 0, -1.35209599010707551e-05,
+      -3.46387683816058679e-07, 3.77618221136799548e-07,
+      -1.29143148179678594e-09, 3.91247397541968152e-10 * 1. / (1_MeV), 0,
+      1.0410117459028839e-07, 3.650374061662458e-05, -1.29143148179678594e-09,
+      3.27887306639240705e-07, -2.82010017781291024e-11 * 1. / (1_MeV), 0,
+      -9.58138079071134127e-09 * 1. / (1_MeV),
+      -4.69743203747746844e-09 * 1. / (1_MeV),
+      3.91247397541968152e-10 * 1. / (1_MeV),
+      -2.82010017781291024e-11 * 1. / (1_MeV),
+      8.54110965980980907e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams38 =
+      BoundParameters(gctx, std::move(covMat38), params38, perigeeSurface);
+  tracks.push_back(boundParams38);
+
+  // track 39 :
+  BoundVector params39;
+  params39 << 0.595804989337921143, -45.6078872680664062, 1.77534663677215576,
+      0.6340065598487854, 0.000248436292167752981 * 1. / (1_MeV), 0;
+  Covariance covMat39;
+  covMat39 << 0.00133234611712396145, -1.25221378814500536e-05,
+      -3.7965405863780084e-05, -1.36477460859891688e-07,
+      -1.64839701014251819e-08 * 1. / (1_MeV), 0, -1.25221378814500536e-05,
+      0.00918729789555072784, -6.07022323103743485e-07, 7.3648342192368039e-05,
+      -2.81287484533099953e-10 * 1. / (1_MeV), 0, -3.7965405863780084e-05,
+      -6.07022323103743485e-07, 1.113939106289763e-06, -2.37922716438868783e-09,
+      7.63262387403224464e-10 * 1. / (1_MeV), 0, -1.36477460859891688e-07,
+      7.3648342192368039e-05, -2.37922716438868783e-09, 6.66182188524544472e-07,
+      1.08505726379481843e-12 * 1. / (1_MeV), 0,
+      -1.64839701014251819e-08 * 1. / (1_MeV),
+      -2.81287484533099953e-10 * 1. / (1_MeV),
+      7.63262387403224464e-10 * 1. / (1_MeV),
+      1.08505726379481843e-12 * 1. / (1_MeV),
+      1.69044726133771306e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams39 =
+      BoundParameters(gctx, std::move(covMat39), params39, perigeeSurface);
+  tracks.push_back(boundParams39);
+
+  // track 40 :
+  BoundVector params40;
+  params40 << 0.536075055599212646, -38.6850814819335938, 2.99125289916992188,
+      1.66691744327545166, -0.000342374085448682308 * 1. / (1_MeV), 0;
+  Covariance covMat40;
+  covMat40 << 0.00137188716325908899, 4.5762325967963918e-06,
+      -2.98856022058698631e-05, -7.0850830871642625e-08,
+      -1.97128857840108858e-08 * 1. / (1_MeV), 0, 4.5762325967963918e-06,
+      0.00638887425884604454, -1.76478143227192729e-07, 8.48770224160730878e-05,
+      -1.45698149891952607e-09 * 1. / (1_MeV), 0, -2.98856022058698631e-05,
+      -1.76478143227192729e-07, 7.38780101983138593e-07,
+      1.85882878019951661e-09, 6.72217443687235182e-10 * 1. / (1_MeV), 0,
+      -7.0850830871642625e-08, 8.48770224160730878e-05, 1.85882878019951661e-09,
+      1.77700985659612343e-06, -2.50821896355620095e-11 * 1. / (1_MeV), 0,
+      -1.97128857840108858e-08 * 1. / (1_MeV),
+      -1.45698149891952607e-09 * 1. / (1_MeV),
+      6.72217443687235182e-10 * 1. / (1_MeV),
+      -2.50821896355620095e-11 * 1. / (1_MeV),
+      1.938233948339807e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams40 =
+      BoundParameters(gctx, std::move(covMat40), params40, perigeeSurface);
+  tracks.push_back(boundParams40);
+
+  // track 41 :
+  BoundVector params41;
+  params41 << -0.428327828645706177, -22.2199287414550781, 0.257566869258880615,
+      0.331243127584457397, -0.000147191138239577413 * 1. / (1_MeV), 0;
+  Covariance covMat41;
+  covMat41 << 0.00331501034088432789, -0.000402231679056904746,
+      -9.11024456904284614e-05, -5.25031012402464848e-07,
+      -3.85090693495478952e-08 * 1. / (1_MeV), 0, -0.000402231679056904746,
+      0.0420148223638534546, 1.02748198387320961e-05, 0.000127530944468113439,
+      5.32950012849014807e-10 * 1. / (1_MeV), 0, -9.11024456904284614e-05,
+      1.02748198387320961e-05, 2.61258151112997439e-06, 1.50109511208772318e-08,
+      1.78440131718612806e-09 * 1. / (1_MeV), 0, -5.25031012402464848e-07,
+      0.000127530944468113439, 1.50109511208772318e-08, 4.0045941318567202e-07,
+      -7.30460799902715398e-12 * 1. / (1_MeV), 0,
+      -3.85090693495478952e-08 * 1. / (1_MeV),
+      5.32950012849014807e-10 * 1. / (1_MeV),
+      1.78440131718612806e-09 * 1. / (1_MeV),
+      -7.30460799902715398e-12 * 1. / (1_MeV),
+      2.19001535656238033e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams41 =
+      BoundParameters(gctx, std::move(covMat41), params41, perigeeSurface);
+  tracks.push_back(boundParams41);
+
+  // track 42 :
+  BoundVector params42;
+  params42 << 0.653292655944824219, -26.9052543640136719, 2.44972705841064453,
+      0.300775229930877686, -0.000126484796055592597 * 1. / (1_MeV), 0;
+  Covariance covMat42;
+  covMat42 << 0.00361175555735826492, -0.000145092938087995886,
+      -0.000101172023225305413, -8.20245834004805885e-07,
+      -4.59128816485603501e-08 * 1. / (1_MeV), 0, -0.000145092938087995886,
+      0.0409743189811706543, 3.61313611193146349e-06, 0.000101264190622654121,
+      -2.39200094119792923e-09 * 1. / (1_MeV), 0, -0.000101172023225305413,
+      3.61313611193146349e-06, 2.95380596071481705e-06, 2.49031335596621612e-08,
+      2.08122633356299761e-09 * 1. / (1_MeV), 0, -8.20245834004805885e-07,
+      0.000101264190622654121, 2.49031335596621612e-08, 2.5834717121142603e-07,
+      5.02372502596273887e-12 * 1. / (1_MeV), 0,
+      -4.59128816485603501e-08 * 1. / (1_MeV),
+      -2.39200094119792923e-09 * 1. / (1_MeV),
+      2.08122633356299761e-09 * 1. / (1_MeV),
+      5.02372502596273887e-12 * 1. / (1_MeV),
+      2.24156318506807395e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams42 =
+      BoundParameters(gctx, std::move(covMat42), params42, perigeeSurface);
+  tracks.push_back(boundParams42);
+
+  // track 43 :
+  BoundVector params43;
+  params43 << 0.0787500590085983276, -5.06010723114013672, -2.50320339202880859,
+      2.27719211578369141, -0.000224699513637460768 * 1. / (1_MeV), 0;
+  Covariance covMat43;
+  covMat43 << 0.000872635049745440483, 2.94171319120868002e-05,
+      -2.12370270488864835e-05, 2.61547510497884302e-07,
+      -1.68371736189228777e-08 * 1. / (1_MeV), 0, 2.94171319120868002e-05,
+      0.00385157112032175064, -8.95594258975597383e-07, 3.97548389387994175e-05,
+      -6.99780771762925697e-09 * 1. / (1_MeV), 0, -2.12370270488864835e-05,
+      -8.95594258975597383e-07, 5.52114101992629003e-07,
+      -8.06623935930032111e-09, 6.36599567289482473e-10 * 1. / (1_MeV), 0,
+      2.61547510497884302e-07, 3.97548389387994175e-05,
+      -8.06623935930032111e-09, 5.23487074133299757e-07,
+      -6.36775855132313344e-11 * 1. / (1_MeV), 0,
+      -1.68371736189228777e-08 * 1. / (1_MeV),
+      -6.99780771762925697e-09 * 1. / (1_MeV),
+      6.36599567289482473e-10 * 1. / (1_MeV),
+      -6.36775855132313344e-11 * 1. / (1_MeV),
+      1.53753346859852869e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams43 =
+      BoundParameters(gctx, std::move(covMat43), params43, perigeeSurface);
+  tracks.push_back(boundParams43);
+
+  // track 44 :
+  BoundVector params44;
+  params44 << -0.667890667915344238, -26.4306564331054688,
+      -0.519191086292266846, 1.6297152042388916,
+      0.000324116728734225035 * 1. / (1_MeV), 0;
+  Covariance covMat44;
+  covMat44 << 0.00108695926610380411, 7.82180373432526278e-06,
+      -2.48846267524919409e-05, -9.69900814831316844e-08,
+      -1.40750276354789122e-08 * 1. / (1_MeV), 0, 7.82180373432526278e-06,
+      0.00617291871458292007, -1.81813433580045645e-07, 7.85765795126072551e-05,
+      -3.23756334365082546e-09 * 1. / (1_MeV), 0, -2.48846267524919409e-05,
+      -1.81813433580045645e-07, 6.10426923230988905e-07,
+      1.84604413254372613e-09, 4.89069275340707137e-10 * 1. / (1_MeV), 0,
+      -9.69900814831316844e-08, 7.85765795126072551e-05,
+      1.84604413254372613e-09, 1.63906986472284188e-06,
+      -5.57887414635642927e-11 * 1. / (1_MeV), 0,
+      -1.40750276354789122e-08 * 1. / (1_MeV),
+      -3.23756334365082546e-09 * 1. / (1_MeV),
+      4.89069275340707137e-10 * 1. / (1_MeV),
+      -5.57887414635642927e-11 * 1. / (1_MeV),
+      1.4045833940379282e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams44 =
+      BoundParameters(gctx, std::move(covMat44), params44, perigeeSurface);
+  tracks.push_back(boundParams44);
+
+  // track 45 :
+  BoundVector params45;
+  params45 << -0.476996541023254395, -10.2552490234375, -1.7952648401260376,
+      2.92429637908935547, -0.000136506365379318595 * 1. / (1_MeV), 0;
+  Covariance covMat45;
+  covMat45 << 0.00768429320305585861, 0.00109988557537010995,
+      -0.000231500581337145973, 9.1348816939045401e-07,
+      -5.63601372249975442e-08 * 1. / (1_MeV), 0, 0.00109988557537010995,
+      0.189449697732925415, -3.59507566995492182e-05, 0.000252646856270792965,
+      -5.46718705987526794e-09 * 1. / (1_MeV), 0, -0.000231500581337145973,
+      -3.59507566995492182e-05, 7.09176856616977602e-06,
+      -3.28587508657521865e-08, 2.79242397856570532e-09 * 1. / (1_MeV), 0,
+      9.1348816939045401e-07, 0.000252646856270792965, -3.28587508657521865e-08,
+      3.43827053939094185e-07, -6.9029270759318352e-13 * 1. / (1_MeV), 0,
+      -5.63601372249975442e-08 * 1. / (1_MeV),
+      -5.46718705987526794e-09 * 1. / (1_MeV),
+      2.79242397856570532e-09 * 1. / (1_MeV),
+      -6.9029270759318352e-13 * 1. / (1_MeV),
+      2.4027510883706249e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams45 =
+      BoundParameters(gctx, std::move(covMat45), params45, perigeeSurface);
+  tracks.push_back(boundParams45);
+
+  // track 46 :
+  BoundVector params46;
+  params46 << -0.42024993896484375, -23.2919502258300781, -1.68882715702056885,
+      2.90132379531860352, 5.77600185351911932e-05 * 1. / (1_MeV), 0;
+  Covariance covMat46;
+  covMat46 << 0.00207295711152255535, 0.000908217743513093658,
+      -5.86378931102357517e-05, 1.21430336966273425e-06,
+      -1.06873090546652326e-08 * 1. / (1_MeV), 0, 0.000908217743513093658,
+      0.0524019971489906311, -2.13007825335927641e-05, 7.23961054167061288e-05,
+      -9.20706515105713893e-10 * 1. / (1_MeV), 0, -5.86378931102357517e-05,
+      -2.13007825335927641e-05, 1.70187172443547752e-06,
+      -2.99895102076280531e-08, 4.8877497815574335e-10 * 1. / (1_MeV), 0,
+      1.21430336966273425e-06, 7.23961054167061288e-05,
+      -2.99895102076280531e-08, 1.06208936756502226e-07,
+      5.48951242834580673e-13 * 1. / (1_MeV), 0,
+      -1.06873090546652326e-08 * 1. / (1_MeV),
+      -9.20706515105713893e-10 * 1. / (1_MeV),
+      4.8877497815574335e-10 * 1. / (1_MeV),
+      5.48951242834580673e-13 * 1. / (1_MeV),
+      4.31213008009190268e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams46 =
+      BoundParameters(gctx, std::move(covMat46), params46, perigeeSurface);
+  tracks.push_back(boundParams46);
+
+  // track 47 :
+  BoundVector params47;
+  params47 << 0.099998176097869873, -28.7298069000244141, -2.47280740737915039,
+      0.362899661064147949, 0.000242739581153728068 * 1. / (1_MeV), 0;
+  Covariance covMat47;
+  covMat47 << 0.0060739489272236824, -0.000228269915109891231,
+      -0.000175137091140785308, -2.85641093745946927e-07,
+      -9.02268162913695653e-08 * 1. / (1_MeV), 0, -0.000228269915109891231,
+      0.0536332316696643829, 6.97667401826663415e-07, 0.000189819333742468862,
+      1.50668591753161066e-09 * 1. / (1_MeV), 0, -0.000175137091140785308,
+      6.97667401826663415e-07, 5.22334448760375381e-06,
+      -9.75788662698204661e-09, 4.53229459790751107e-09 * 1. / (1_MeV), 0,
+      -2.85641093745946927e-07, 0.000189819333742468862,
+      -9.75788662698204661e-09, 6.91088189341826364e-07,
+      3.54234059812463208e-12 * 1. / (1_MeV), 0,
+      -9.02268162913695653e-08 * 1. / (1_MeV),
+      1.50668591753161066e-09 * 1. / (1_MeV),
+      4.53229459790751107e-09 * 1. / (1_MeV),
+      3.54234059812463208e-12 * 1. / (1_MeV),
+      6.56103088525483713e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams47 =
+      BoundParameters(gctx, std::move(covMat47), params47, perigeeSurface);
+  tracks.push_back(boundParams47);
+
+  // track 48 :
+  BoundVector params48;
+  params48 << -0.638817727565765381, -46.7263984680175781,
+      -0.0762649774551391602, 2.44958138465881348,
+      0.00033917097607627511 * 1. / (1_MeV), 0;
+  Covariance covMat48;
+  covMat48 << 0.00275217113085091114, 0.00021318761584315771,
+      -7.17503295784262051e-05, 5.19027545172934056e-07,
+      -3.27445192482216638e-08 * 1. / (1_MeV), 0, 0.00021318761584315771,
+      0.0129677252843976021, -3.76428307295029104e-06, 0.000116100785357966014,
+      -3.04730203134838935e-09 * 1. / (1_MeV), 0, -7.17503295784262051e-05,
+      -3.76428307295029104e-06, 1.9585518202802632e-06, 1.06617289122836538e-09,
+      1.3563696615201376e-09 * 1. / (1_MeV), 0, 5.19027545172934056e-07,
+      0.000116100785357966014, 1.06617289122836538e-09, 1.19973151413432788e-06,
+      -2.78975801873471684e-12 * 1. / (1_MeV), 0,
+      -3.27445192482216638e-08 * 1. / (1_MeV),
+      -3.04730203134838935e-09 * 1. / (1_MeV),
+      1.3563696615201376e-09 * 1. / (1_MeV),
+      -2.78975801873471684e-12 * 1. / (1_MeV),
+      2.97016820860473985e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams48 =
+      BoundParameters(gctx, std::move(covMat48), params48, perigeeSurface);
+  tracks.push_back(boundParams48);
+
+  // track 49 :
+  BoundVector params49;
+  params49 << -0.64014434814453125, -46.3312034606933594, -1.05530393123626709,
+      1.65516412258148193, 6.55830517644062638e-05 * 1. / (1_MeV), 0;
+  Covariance covMat49;
+  covMat49 << 0.00014873131294734776, -3.25668154925161195e-06,
+      -2.57186509895848779e-06, 1.03651221484145729e-07,
+      -4.02098191895756443e-09 * 1. / (1_MeV), 0, -3.25668154925161195e-06,
+      0.00208531459793448448, -3.00105708930370322e-08, 2.31327739872350428e-05,
+      -3.79285333931827184e-10 * 1. / (1_MeV), 0, -2.57186509895848779e-06,
+      -3.00105708930370322e-08, 5.21384144747116807e-08,
+      -1.13043687468235159e-09, 8.74314611771519845e-11 * 1. / (1_MeV), 0,
+      1.03651221484145729e-07, 2.31327739872350428e-05,
+      -1.13043687468235159e-09, 4.8820493248058483e-07,
+      -9.77849218642090565e-12 * 1. / (1_MeV), 0,
+      -4.02098191895756443e-09 * 1. / (1_MeV),
+      -3.79285333931827184e-10 * 1. / (1_MeV),
+      8.74314611771519845e-11 * 1. / (1_MeV),
+      -9.77849218642090565e-12 * 1. / (1_MeV),
+      1.17200834540837073e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams49 =
+      BoundParameters(gctx, std::move(covMat49), params49, perigeeSurface);
+  tracks.push_back(boundParams49);
+
+  // track 50 :
+  BoundVector params50;
+  params50 << 0.679204404354095459, -23.8228569030761719, 2.55430388450622559,
+      0.620291829109191895, -0.000398631149437278509 * 1. / (1_MeV), 0;
+  Covariance covMat50;
+  covMat50 << 0.00396185368299484253, -0.000125750330223895206,
+      -0.000109741625616368232, -1.77279611732068793e-06,
+      -4.59372500797877474e-08 * 1. / (1_MeV), 0, -0.000125750330223895206,
+      0.016484508290886879, 3.18639890004686668e-06, 0.000143314523991435627,
+      -9.97977172285195535e-10 * 1. / (1_MeV), 0, -0.000109741625616368232,
+      3.18639890004686668e-06, 3.15156694341567345e-06, 5.29784994588306965e-08,
+      2.0784715645265731e-09 * 1. / (1_MeV), 0, -1.77279611732068793e-06,
+      0.000143314523991435627, 5.29784994588306965e-08, 1.32396576191240456e-06,
+      7.96588919931270625e-12 * 1. / (1_MeV), 0,
+      -4.59372500797877474e-08 * 1. / (1_MeV),
+      -9.97977172285195535e-10 * 1. / (1_MeV),
+      2.0784715645265731e-09 * 1. / (1_MeV),
+      7.96588919931270625e-12 * 1. / (1_MeV),
+      4.46022628552977807e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams50 =
+      BoundParameters(gctx, std::move(covMat50), params50, perigeeSurface);
+  tracks.push_back(boundParams50);
+
+  // track 51 :
+  BoundVector params51;
+  params51 << 0.0953129231929779053, -6.67084884643554688, 0.758422255516052246,
+      2.50242829322814941, 0.000553281046450138092 * 1. / (1_MeV), 0;
+  Covariance covMat51;
+  covMat51 << 0.00646894052624702454, 0.00018205583963275726,
+      -0.000184070642760310164, 4.01968699095653562e-07,
+      -7.26072619004993246e-08 * 1. / (1_MeV), 0, 0.00018205583963275726,
+      0.0242310706526041031, -2.67127070573839354e-07, 0.000235120330855929796,
+      -1.69241003100018407e-09 * 1. / (1_MeV), 0, -0.000184070642760310164,
+      -2.67127070573839354e-07, 5.39285929335164838e-06,
+      2.94062803351906824e-08, 3.36582393282827341e-09 * 1. / (1_MeV), 0,
+      4.01968699095653562e-07, 0.000235120330855929796, 2.94062803351906824e-08,
+      2.3894551759440219e-06, -7.96709832496419101e-12 * 1. / (1_MeV), 0,
+      -7.26072619004993246e-08 * 1. / (1_MeV),
+      -1.69241003100018407e-09 * 1. / (1_MeV),
+      3.36582393282827341e-09 * 1. / (1_MeV),
+      -7.96709832496419101e-12 * 1. / (1_MeV),
+      7.49710918346302435e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams51 =
+      BoundParameters(gctx, std::move(covMat51), params51, perigeeSurface);
+  tracks.push_back(boundParams51);
+
+  // track 52 :
+  BoundVector params52;
+  params52 << 0.596444904804229736, -46.791473388671875, 2.81760692596435547,
+      0.466173619031906128, -4.01311117457225919e-05 * 1. / (1_MeV), 0;
+  Covariance covMat52;
+  covMat52 << 0.000178020185558125377, -1.20741123187898347e-05,
+      -4.47439657042341053e-06, -5.00683209793379036e-08,
+      -1.74763438138931432e-09 * 1. / (1_MeV), 0, -1.20741123187898347e-05,
+      0.00217202818021178246, 1.64534794833318549e-08, 7.73194260617184203e-06,
+      1.58039148376204822e-10 * 1. / (1_MeV), 0, -4.47439657042341053e-06,
+      1.64534794833318549e-08, 1.25094288705440704e-07, 9.26271094478818689e-10,
+      6.72005839541690491e-11 * 1. / (1_MeV), 0, -5.00683209793379036e-08,
+      7.73194260617184203e-06, 9.26271094478818689e-10, 3.52726665653335658e-08,
+      6.38826446714830372e-13 * 1. / (1_MeV), 0,
+      -1.74763438138931432e-09 * 1. / (1_MeV),
+      1.58039148376204822e-10 * 1. / (1_MeV),
+      6.72005839541690491e-11 * 1. / (1_MeV),
+      6.38826446714830372e-13 * 1. / (1_MeV),
+      8.76188607345368409e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams52 =
+      BoundParameters(gctx, std::move(covMat52), params52, perigeeSurface);
+  tracks.push_back(boundParams52);
+
+  // track 53 :
+  BoundVector params53;
+  params53 << -0.509457647800445557, -6.32682275772094727, -1.33872759342193604,
+      0.491079181432723999, 0.00053247174946591258 * 1. / (1_MeV), 0;
+  Covariance covMat53;
+  covMat53 << 0.0100084031000733376, -0.000479280897979647135,
+      -0.000299479223647432344, 6.22369951852639685e-07,
+      -1.22423028040487334e-07 * 1. / (1_MeV), 0, -0.000479280897979647135,
+      0.0567438751459121704, 4.44730771047373873e-06, 0.000355637421562457208,
+      9.09945816895274824e-09 * 1. / (1_MeV), 0, -0.000299479223647432344,
+      4.44730771047373873e-06, 9.10697599465493113e-06,
+      -7.71163662653393619e-08, 5.96647706005148785e-09 * 1. / (1_MeV), 0,
+      6.22369951852639685e-07, 0.000355637421562457208,
+      -7.71163662653393619e-08, 2.29044917432474904e-06,
+      5.6513620234422192e-12 * 1. / (1_MeV), 0,
+      -1.22423028040487334e-07 * 1. / (1_MeV),
+      9.09945816895274824e-09 * 1. / (1_MeV),
+      5.96647706005148785e-09 * 1. / (1_MeV),
+      5.6513620234422192e-12 * 1. / (1_MeV),
+      1.10141243347960938e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams53 =
+      BoundParameters(gctx, std::move(covMat53), params53, perigeeSurface);
+  tracks.push_back(boundParams53);
+
+  // track 54 :
+  BoundVector params54;
+  params54 << 0.0559646449983119965, -27.9413089752197266, -2.75167965888977051,
+      0.386726617813110352, -0.000363107450539246202 * 1. / (1_MeV), 0;
+  Covariance covMat54;
+  covMat54 << 0.00913079828023910522, -0.000177719306007508867,
+      -0.000277420127510917254, -1.59392792391846542e-06,
+      -1.63671693721281069e-07 * 1. / (1_MeV), 0, -0.000177719306007508867,
+      0.0778327509760856628, 1.14397241749803718e-05, 0.00031574579409467628,
+      -2.24438577982619877e-09 * 1. / (1_MeV), 0, -0.000277420127510917254,
+      1.14397241749803718e-05, 8.58535440784180537e-06, 7.52518631694262801e-08,
+      8.36903947194818426e-09 * 1. / (1_MeV), 0, -1.59392792391846542e-06,
+      0.00031574579409467628, 7.52518631694262801e-08, 1.31181081997056026e-06,
+      6.22930295116186707e-12 * 1. / (1_MeV), 0,
+      -1.63671693721281069e-07 * 1. / (1_MeV),
+      -2.24438577982619877e-09 * 1. / (1_MeV),
+      8.36903947194818426e-09 * 1. / (1_MeV),
+      6.22930295116186707e-12 * 1. / (1_MeV),
+      1.3151608968531292e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams54 =
+      BoundParameters(gctx, std::move(covMat54), params54, perigeeSurface);
+  tracks.push_back(boundParams54);
+
+  // track 55 :
+  BoundVector params55;
+  params55 << 0.313830852508544922, -0.35525098443031311, -2.79895758628845215,
+      2.27995705604553223, 0.000609797949437052011 * 1. / (1_MeV), 0;
+  Covariance covMat55;
+  covMat55 << 0.0030504278838634491, -3.81297205072847354e-05,
+      -9.09237206775645104e-05, -8.09544327444282553e-07,
+      -5.66159970214913546e-08 * 1. / (1_MeV), 0, -3.81297205072847354e-05,
+      0.0142782162874937057, 2.63776141900322284e-06, 0.00018603481737948765,
+      1.51670403755547486e-09 * 1. / (1_MeV), 0, -9.09237206775645104e-05,
+      2.63776141900322284e-06, 2.75821184914093465e-06, 4.54309779123903346e-08,
+      2.79668441371068291e-09 * 1. / (1_MeV), 0, -8.09544327444282553e-07,
+      0.00018603481737948765, 4.54309779123903346e-08, 2.758416712822509e-06,
+      4.93865123861046129e-11 * 1. / (1_MeV), 0,
+      -5.66159970214913546e-08 * 1. / (1_MeV),
+      1.51670403755547486e-09 * 1. / (1_MeV),
+      2.79668441371068291e-09 * 1. / (1_MeV),
+      4.93865123861046129e-11 * 1. / (1_MeV),
+      8.41345951241301293e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams55 =
+      BoundParameters(gctx, std::move(covMat55), params55, perigeeSurface);
+  tracks.push_back(boundParams55);
+
+  // track 56 :
+  BoundVector params56;
+  params56 << 0.155255094170570374, 5.48450565338134766, -2.57013368606567383,
+      2.0009157657623291, -0.00166504201479256153 * 1. / (1_MeV), 0;
+  Covariance covMat56;
+  covMat56 << 0.0131199266761541367, 0.000131623878451009752,
+      -0.000394009320893070269, 6.03472828037634446e-06,
+      -2.10906706685497427e-07 * 1. / (1_MeV), 0, 0.000131623878451009752,
+      0.0316174179315567017, -9.5725861230159473e-06, 0.000710392294531094187,
+      9.45078749853857351e-09 * 1. / (1_MeV), 0, -0.000394009320893070269,
+      -9.5725861230159473e-06, 1.19737778732087463e-05,
+      -3.15962032494940612e-07, 1.01155494796444282e-08 * 1. / (1_MeV), 0,
+      6.03472828037634446e-06, 0.000710392294531094187,
+      -3.15962032494940612e-07, 1.67491944011999294e-05,
+      1.71955939069872652e-10 * 1. / (1_MeV), 0,
+      -2.10906706685497427e-07 * 1. / (1_MeV),
+      9.45078749853857351e-09 * 1. / (1_MeV),
+      1.01155494796444282e-08 * 1. / (1_MeV),
+      1.71955939069872652e-10 * 1. / (1_MeV),
+      3.56558282899044343e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams56 =
+      BoundParameters(gctx, std::move(covMat56), params56, perigeeSurface);
+  tracks.push_back(boundParams56);
+
+  // track 57 :
+  BoundVector params57;
+  params57 << 0.246611848473548889, -26.5061550140380859, -2.83754277229309082,
+      1.51932394504547119, 0.00129061494953930378 * 1. / (1_MeV), 0;
+  Covariance covMat57;
+  covMat57 << 0.00866833329200744629, 3.01401983869387291e-06,
+      -0.000239535524096211392, 2.72296952977166461e-07,
+      -1.26333629804036578e-07 * 1. / (1_MeV), 0, 3.01401983869387291e-06,
+      0.0214755143970251083, -5.52645836342027297e-07, 0.000483994911188721929,
+      -2.39220428270368834e-09 * 1. / (1_MeV), 0, -0.000239535524096211392,
+      -5.52645836342027297e-07, 6.85501072439365089e-06,
+      -1.80955198945319287e-08, 5.68860497435955863e-09 * 1. / (1_MeV), 0,
+      2.72296952977166461e-07, 0.000483994911188721929,
+      -1.80955198945319287e-08, 1.2657999832299538e-05,
+      -4.49134917661611488e-11 * 1. / (1_MeV), 0,
+      -1.26333629804036578e-07 * 1. / (1_MeV),
+      -2.39220428270368834e-09 * 1. / (1_MeV),
+      5.68860497435955863e-09 * 1. / (1_MeV),
+      -4.49134917661611488e-11 * 1. / (1_MeV),
+      2.06098235699947452e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams57 =
+      BoundParameters(gctx, std::move(covMat57), params57, perigeeSurface);
+  tracks.push_back(boundParams57);
+
+  // track 58 :
+  BoundVector params58;
+  params58 << 0.753639280796051025, -6.00856494903564453, 2.30286669731140137,
+      0.268404930830001831, 0.000222592061618342996 * 1. / (1_MeV), 0;
+  Covariance covMat58;
+  covMat58 << 0.0102735972031950951, 0.000561483560818463708,
+      -0.00031188075048945189, 2.28136549511333255e-07,
+      -1.11255212859507957e-07 * 1. / (1_MeV), 0, 0.000561483560818463708,
+      0.171909451484680176, -3.10575259235835638e-05, 0.000346326413890911768,
+      -1.04190472154705827e-08 * 1. / (1_MeV), 0, -0.00031188075048945189,
+      -3.10575259235835638e-05, 9.61947171163046733e-06,
+      -3.25676596064154555e-08, 5.32616098447415082e-09 * 1. / (1_MeV), 0,
+      2.28136549511333255e-07, 0.000346326413890911768,
+      -3.25676596064154555e-08, 7.13259510121133644e-07,
+      1.99585598211435834e-12 * 1. / (1_MeV), 0,
+      -1.11255212859507957e-07 * 1. / (1_MeV),
+      -1.04190472154705827e-08 * 1. / (1_MeV),
+      5.32616098447415082e-09 * 1. / (1_MeV),
+      1.99585598211435834e-12 * 1. / (1_MeV),
+      5.44141676162013255e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams58 =
+      BoundParameters(gctx, std::move(covMat58), params58, perigeeSurface);
+  tracks.push_back(boundParams58);
+
+  // track 59 :
+  BoundVector params59;
+  params59 << -0.740706324577331543, -26.4523181915283203, -0.33198884129524231,
+      1.24688541889190674, 0.00112402497325092554 * 1. / (1_MeV), 0;
+  Covariance covMat59;
+  covMat59 << 0.00939919613301753998, -0.000330953811817127669,
+      -0.000243319623521406008, -1.98870275046275838e-06,
+      -1.10875607601281475e-07 * 1. / (1_MeV), 0, -0.000330953811817127669,
+      0.0170400068163871765, 5.20070220108950583e-06, 0.000343470715600280925,
+      2.37905357060564215e-09 * 1. / (1_MeV), 0, -0.000243319623521406008,
+      5.20070220108950583e-06, 6.58395856589777395e-06,
+      -4.89928191758482858e-09, 4.48106445691990887e-09 * 1. / (1_MeV), 0,
+      -1.98870275046275838e-06, 0.000343470715600280925,
+      -4.89928191758482858e-09, 7.88109264249214903e-06,
+      1.57469333177652749e-11 * 1. / (1_MeV), 0,
+      -1.10875607601281475e-07 * 1. / (1_MeV),
+      2.37905357060564215e-09 * 1. / (1_MeV),
+      4.48106445691990887e-09 * 1. / (1_MeV),
+      1.57469333177652749e-11 * 1. / (1_MeV),
+      1.41142181275810685e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams59 =
+      BoundParameters(gctx, std::move(covMat59), params59, perigeeSurface);
+  tracks.push_back(boundParams59);
+
+  // track 60 :
+  BoundVector params60;
+  params60 << 0.404530495405197144, -45.1964073181152344, 1.50114703178405762,
+      0.477049559354782104, 0.000178427377250045538 * 1. / (1_MeV), 0;
+  Covariance covMat60;
+  covMat60 << 0.00160884018987417221, 2.48786024325549841e-05,
+      -4.55158622795351621e-05, 5.27237356570212567e-08,
+      -1.71578397922792243e-08 * 1. / (1_MeV), 0, 2.48786024325549841e-05,
+      0.0133713036775588989, -1.47535371521175571e-06, 7.02707466725490158e-05,
+      -2.00878031112618562e-10 * 1. / (1_MeV), 0, -4.55158622795351621e-05,
+      -1.47535371521175571e-06, 1.33205401198210893e-06,
+      -5.17880198705678666e-09, 8.08198329216027338e-10 * 1. / (1_MeV), 0,
+      5.27237356570212567e-08, 7.02707466725490158e-05,
+      -5.17880198705678666e-09, 4.04392295649813605e-07,
+      1.74801379954387645e-12 * 1. / (1_MeV), 0,
+      -1.71578397922792243e-08 * 1. / (1_MeV),
+      -2.00878031112618562e-10 * 1. / (1_MeV),
+      8.08198329216027338e-10 * 1. / (1_MeV),
+      1.74801379954387645e-12 * 1. / (1_MeV),
+      1.40280183302810002e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams60 =
+      BoundParameters(gctx, std::move(covMat60), params60, perigeeSurface);
+  tracks.push_back(boundParams60);
+
+  // track 61 :
+  BoundVector params61;
+  params61 << 0.481095165014266968, -45.3241767883300781, 1.63423991203308105,
+      0.527970552444458008, -0.000266404327703639865 * 1. / (1_MeV), 0;
+  Covariance covMat61;
+  covMat61 << 0.00288071134127676487, -0.000155863492110799547,
+      -7.77621373783901631e-05, -1.18027593530364395e-06,
+      -2.48196096965139494e-08 * 1. / (1_MeV), 0, -0.000155863492110799547,
+      0.0149536263197660446, 3.65078035069732869e-06, 9.743912874541411e-05,
+      8.37675468431534094e-11 * 1. / (1_MeV), 0, -7.77621373783901631e-05,
+      3.65078035069732869e-06, 2.18776540350518189e-06, 3.25560801512905163e-08,
+      1.08576617849883842e-09 * 1. / (1_MeV), 0, -1.18027593530364395e-06,
+      9.743912874541411e-05, 3.25560801512905163e-08, 6.77229820666980231e-07,
+      5.47754434165355313e-12 * 1. / (1_MeV), 0,
+      -2.48196096965139494e-08 * 1. / (1_MeV),
+      8.37675468431534094e-11 * 1. / (1_MeV),
+      1.08576617849883842e-09 * 1. / (1_MeV),
+      5.47754434165355313e-12 * 1. / (1_MeV),
+      1.96000368712923034e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams61 =
+      BoundParameters(gctx, std::move(covMat61), params61, perigeeSurface);
+  tracks.push_back(boundParams61);
+
+  // track 62 :
+  BoundVector params62;
+  params62 << 0.46620604395866394, -39.1152420043945312, 2.9602348804473877,
+      2.54967498779296875, -0.000812723359558731318 * 1. / (1_MeV), 0;
+  Covariance covMat62;
+  covMat62 << 0.0155730284750461578, 0.00038755317191748362,
+      -0.000450653030958149533, 7.46684313401321562e-06,
+      -1.56837822709803982e-07 * 1. / (1_MeV), 0, 0.00038755317191748362,
+      0.0830775722861289978, -2.15848125497517351e-05, 0.000657707917473032439,
+      7.52506139410446467e-09 * 1. / (1_MeV), 0, -0.000450653030958149533,
+      -2.15848125497517351e-05, 1.33805215227766894e-05,
+      -3.1197420281739802e-07, 8.02502888738918489e-09 * 1. / (1_MeV), 0,
+      7.46684313401321562e-06, 0.000657707917473032439, -3.1197420281739802e-07,
+      5.4718084356863983e-06, -5.04380269074694918e-12 * 1. / (1_MeV), 0,
+      -1.56837822709803982e-07 * 1. / (1_MeV),
+      7.52506139410446467e-09 * 1. / (1_MeV),
+      8.02502888738918489e-09 * 1. / (1_MeV),
+      -5.04380269074694918e-12 * 1. / (1_MeV),
+      1.86463025575456243e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams62 =
+      BoundParameters(gctx, std::move(covMat62), params62, perigeeSurface);
+  tracks.push_back(boundParams62);
+
+  // track 63 :
+  BoundVector params63;
+  params63 << -0.645694375038146973, -45.9093971252441406, -1.42855286598205566,
+      2.14151239395141602, -0.000308145768940448761 * 1. / (1_MeV), 0;
+  Covariance covMat63;
+  covMat63 << 0.00141701370012015104, 8.16846515917965093e-05,
+      -3.3697989251933814e-05, 6.17724276590095669e-07,
+      -1.6156751085000028e-08 * 1. / (1_MeV), 0, 8.16846515917965093e-05,
+      0.00634454051032662392, -2.08952126392131457e-06, 7.15744916836027302e-05,
+      -1.49091147779785594e-09 * 1. / (1_MeV), 0, -3.3697989251933814e-05,
+      -2.08952126392131457e-06, 8.4832106495014159e-07,
+      -1.64115671055080147e-08, 5.9837667986473886e-10 * 1. / (1_MeV), 0,
+      6.17724276590095669e-07, 7.15744916836027302e-05,
+      -1.64115671055080147e-08, 1.0292989145455067e-06,
+      -1.46674673345839605e-11 * 1. / (1_MeV), 0,
+      -1.6156751085000028e-08 * 1. / (1_MeV),
+      -1.49091147779785594e-09 * 1. / (1_MeV),
+      5.9837667986473886e-10 * 1. / (1_MeV),
+      -1.46674673345839605e-11 * 1. / (1_MeV),
+      1.54105235516954764e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams63 =
+      BoundParameters(gctx, std::move(covMat63), params63, perigeeSurface);
+  tracks.push_back(boundParams63);
+
+  // track 64 :
+  BoundVector params64;
+  params64 << -0.608972728252410889, -0.205871865153312683,
+      -0.337655186653137207, 0.617485642433166504,
+      0.000326765264617279172 * 1. / (1_MeV), 0;
+  Covariance covMat64;
+  covMat64 << 0.00256323744542896748, -0.000102964159443142377,
+      -7.43746711326680654e-05, 2.77199836373549426e-07,
+      -3.16870017552968717e-08 * 1. / (1_MeV), 0, -0.000102964159443142377,
+      0.0179459210485219955, 9.927183095141406e-07, 0.000150291132415494166,
+      1.84401452515339684e-09 * 1. / (1_MeV), 0, -7.43746711326680654e-05,
+      9.927183095141406e-07, 2.20178139898052905e-06, -2.23963294945635655e-08,
+      1.42819207588526508e-09 * 1. / (1_MeV), 0, 2.77199836373549426e-07,
+      0.000150291132415494166, -2.23963294945635655e-08,
+      1.36840594677778427e-06, 1.15087456059600686e-12 * 1. / (1_MeV), 0,
+      -3.16870017552968717e-08 * 1. / (1_MeV),
+      1.84401452515339684e-09 * 1. / (1_MeV),
+      1.42819207588526508e-09 * 1. / (1_MeV),
+      1.15087456059600686e-12 * 1. / (1_MeV),
+      2.95290424057181866e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams64 =
+      BoundParameters(gctx, std::move(covMat64), params64, perigeeSurface);
+  tracks.push_back(boundParams64);
+
+  // track 65 :
+  BoundVector params65;
+  params65 << -0.651330411434173584, -46.6501655578613281,
+      -0.162742897868156433, 2.37663960456848145,
+      0.000465616496512666345 * 1. / (1_MeV), 0;
+  Covariance covMat65;
+  covMat65 << 0.00349642685614526272, 0.000141372948412694558,
+      -9.42089049286210813e-05, 1.58411676533929063e-07,
+      -5.51507903718466048e-08 * 1. / (1_MeV), 0, 0.000141372948412694558,
+      0.0145636545494198799, -1.8376679472879644e-06, 0.000159144530910216837,
+      -9.77799777456030559e-10 * 1. / (1_MeV), 0, -9.42089049286210813e-05,
+      -1.8376679472879644e-06, 2.6513741886446951e-06, 1.6927620638758599e-08,
+      2.44350119045523328e-09 * 1. / (1_MeV), 0, 1.58411676533929063e-07,
+      0.000159144530910216837, 1.6927620638758599e-08, 1.91570370589033701e-06,
+      2.43993447359552124e-11 * 1. / (1_MeV), 0,
+      -5.51507903718466048e-08 * 1. / (1_MeV),
+      -9.77799777456030559e-10 * 1. / (1_MeV),
+      2.44350119045523328e-09 * 1. / (1_MeV),
+      2.43993447359552124e-11 * 1. / (1_MeV),
+      6.30697091774656826e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams65 =
+      BoundParameters(gctx, std::move(covMat65), params65, perigeeSurface);
+  tracks.push_back(boundParams65);
+
+  // track 66 :
+  BoundVector params66;
+  params66 << 0.64414292573928833, -37.8168792724609375, 1.41348385810852051,
+      0.628789603710174561, -0.000711047730874270201 * 1. / (1_MeV), 0;
+  Covariance covMat66;
+  covMat66 << 0.00865435414016246796, 4.30179014559714792e-05,
+      -0.000260259753258794142, -2.77364333528555447e-06,
+      -1.18175630051794391e-07 * 1. / (1_MeV), 0, 4.30179014559714792e-05,
+      0.0385085344314575195, 3.5186803309031585e-06, 0.000362887855399699421,
+      -6.57911033053770427e-09 * 1. / (1_MeV), 0, -0.000260259753258794142,
+      3.5186803309031585e-06, 7.93121216702274978e-06, 1.35170575721091198e-07,
+      5.61496221132519249e-09 * 1. / (1_MeV), 0, -2.77364333528555447e-06,
+      0.000362887855399699421, 1.35170575721091198e-07, 3.55381462213699706e-06,
+      -1.76572689736880453e-12 * 1. / (1_MeV), 0,
+      -1.18175630051794391e-07 * 1. / (1_MeV),
+      -6.57911033053770427e-09 * 1. / (1_MeV),
+      5.61496221132519249e-09 * 1. / (1_MeV),
+      -1.76572689736880453e-12 * 1. / (1_MeV),
+      1.27183083509230244e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams66 =
+      BoundParameters(gctx, std::move(covMat66), params66, perigeeSurface);
+  tracks.push_back(boundParams66);
+
+  // track 67 :
+  BoundVector params67;
+  params67 << -0.332721292972564697, -22.5682830810546875, 0.226930230855941772,
+      0.439133286476135254, 0.000341838604072108865 * 1. / (1_MeV), 0;
+  Covariance covMat67;
+  covMat67 << 0.00658620009198784828, -0.000468461936445102546,
+      -0.000190280257733648498, -8.77654618295631542e-07,
+      -7.41082017465768966e-08 * 1. / (1_MeV), 0, -0.000468461936445102546,
+      0.0421695522964000702, 8.37362681235735137e-06, 0.000212639250704076973,
+      5.59919585012054894e-09 * 1. / (1_MeV), 0, -0.000190280257733648498,
+      8.37362681235735137e-06, 5.653947482642252e-06, 2.05904961050614474e-09,
+      3.61592933955667245e-09 * 1. / (1_MeV), 0, -8.77654618295631542e-07,
+      0.000212639250704076973, 2.05904961050614474e-09, 1.10556209165224573e-06,
+      9.31555819953937805e-12 * 1. / (1_MeV), 0,
+      -7.41082017465768966e-08 * 1. / (1_MeV),
+      5.59919585012054894e-09 * 1. / (1_MeV),
+      3.61592933955667245e-09 * 1. / (1_MeV),
+      9.31555819953937805e-12 * 1. / (1_MeV),
+      6.02211544520336872e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams67 =
+      BoundParameters(gctx, std::move(covMat67), params67, perigeeSurface);
+  tracks.push_back(boundParams67);
+
+  // track 68 :
+  BoundVector params68;
+  params68 << 0.228807628154754639, -45.5291328430175781, 1.88212299346923828,
+      0.391405045986175537, -0.000272470730124041438 * 1. / (1_MeV), 0;
+  Covariance covMat68;
+  covMat68 << 0.00558751169592142105, -0.000526476410891340272,
+      -0.000165610234749681399, -2.61479347877094164e-06,
+      -6.61682300501314344e-08 * 1. / (1_MeV), 0, -0.000526476410891340272,
+      0.0537347830832004547, 1.60095985217531436e-05, 0.000211228233160033968,
+      -7.3861724702695647e-11 * 1. / (1_MeV), 0, -0.000165610234749681399,
+      1.60095985217531436e-05, 4.99409998155897483e-06, 8.27335653273563984e-08,
+      3.08626652913981362e-09 * 1. / (1_MeV), 0, -2.61479347877094164e-06,
+      0.000211228233160033968, 8.27335653273563984e-08, 8.58062662700831424e-07,
+      9.8161963481123767e-12 * 1. / (1_MeV), 0,
+      -6.61682300501314344e-08 * 1. / (1_MeV),
+      -7.3861724702695647e-11 * 1. / (1_MeV),
+      3.08626652913981362e-09 * 1. / (1_MeV),
+      9.8161963481123767e-12 * 1. / (1_MeV),
+      4.41570460751883331e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams68 =
+      BoundParameters(gctx, std::move(covMat68), params68, perigeeSurface);
+  tracks.push_back(boundParams68);
+
+  // track 69 :
+  BoundVector params69;
+  params69 << -0.774779915809631348, -7.18358039855957031, -1.68472623825073242,
+      0.294571459293365479, -0.00012300643720664084 * 1. / (1_MeV), 0;
+  Covariance covMat69;
+  covMat69 << 0.00796640384942293167, -0.00308066711056936707,
+      -0.000183902465217028856, -4.40322681469892384e-06,
+      -4.28751518274954345e-08 * 1. / (1_MeV), 0, -0.00308066711056936707,
+      0.256041616201400757, 7.1248927562660272e-05, 0.000440831013812017375,
+      7.95526672562874677e-09 * 1. / (1_MeV), 0, -0.000183902465217028856,
+      7.1248927562660272e-05, 4.48159107691026293e-06, 1.02520016937503953e-07,
+      1.75117724904492434e-09 * 1. / (1_MeV), 0, -4.40322681469892384e-06,
+      0.000440831013812017375, 1.02520016937503953e-07, 7.90239880643639481e-07,
+      6.37842082317695236e-12 * 1. / (1_MeV), 0,
+      -4.28751518274954345e-08 * 1. / (1_MeV),
+      7.95526672562874677e-09 * 1. / (1_MeV),
+      1.75117724904492434e-09 * 1. / (1_MeV),
+      6.37842082317695236e-12 * 1. / (1_MeV),
+      1.73160132066474404e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams69 =
+      BoundParameters(gctx, std::move(covMat69), params69, perigeeSurface);
+  tracks.push_back(boundParams69);
+
+  // track 70 :
+  BoundVector params70;
+  params70 << -0.799591720104217529, -4.63163089752197266, 0.405971020460128784,
+      0.378831923007965088, 0.000591743737459182739 * 1. / (1_MeV), 0;
+  Covariance covMat70;
+  covMat70 << 0.0266661942005157471, -0.00183957268711347835,
+      -0.000807137683582467521, 3.8442389767195023e-06,
+      -3.49680195741055849e-07 * 1. / (1_MeV), 0, -0.00183957268711347835,
+      0.211709365248680115, 1.93959104101635743e-05, 0.000855412169330214186,
+      4.91598206364535424e-08 * 1. / (1_MeV), 0, -0.000807137683582467521,
+      1.93959104101635743e-05, 2.48053565883310512e-05,
+      -2.62219580174192418e-07, 1.76141434145594417e-08 * 1. / (1_MeV), 0,
+      3.8442389767195023e-06, 0.000855412169330214186, -2.62219580174192418e-07,
+      3.50158666151401121e-06, 8.73307509198330779e-12 * 1. / (1_MeV), 0,
+      -3.49680195741055849e-07 * 1. / (1_MeV),
+      4.91598206364535424e-08 * 1. / (1_MeV),
+      1.76141434145594417e-08 * 1. / (1_MeV),
+      8.73307509198330779e-12 * 1. / (1_MeV),
+      2.64328670063207483e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams70 =
+      BoundParameters(gctx, std::move(covMat70), params70, perigeeSurface);
+  tracks.push_back(boundParams70);
+
+  // track 71 :
+  BoundVector params71;
+  params71 << -0.600866556167602539, -46.0752182006835938, -1.38232946395874023,
+      2.03518390655517578, 0.000216916509089060128 * 1. / (1_MeV), 0;
+  Covariance covMat71;
+  covMat71 << 0.000447078287834301591, 6.4246307431772498e-06,
+      -1.22906651502427452e-05, -1.99116263412532374e-09,
+      -1.43109528065029844e-08 * 1. / (1_MeV), 0, 6.4246307431772498e-06,
+      0.00480788340792059898, -5.87978219682613621e-08, 5.37988074894698367e-05,
+      -1.93974344917808111e-09 * 1. / (1_MeV), 0, -1.22906651502427452e-05,
+      -5.87978219682613621e-08, 3.57868174205577816e-07, 1.5805389300162696e-09,
+      6.29499582429645186e-10 * 1. / (1_MeV), 0, -1.99116263412532374e-09,
+      5.37988074894698367e-05, 1.5805389300162696e-09, 7.68185657307185465e-07,
+      -6.71150128191831827e-12 * 1. / (1_MeV), 0,
+      -1.43109528065029844e-08 * 1. / (1_MeV),
+      -1.93974344917808111e-09 * 1. / (1_MeV),
+      6.29499582429645186e-10 * 1. / (1_MeV),
+      -6.71150128191831827e-12 * 1. / (1_MeV),
+      1.96153805004373183e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams71 =
+      BoundParameters(gctx, std::move(covMat71), params71, perigeeSurface);
+  tracks.push_back(boundParams71);
+
+  // track 72 :
+  BoundVector params72;
+  params72 << 0.934263527393341064, -26.3208255767822266, 2.37594270706176758,
+      2.72768449783325195, 0.000554551603272557259 * 1. / (1_MeV), 0;
+  Covariance covMat72;
+  covMat72 << 0.0188611242920160294, -0.00121691842277711322,
+      -0.000576619514959964973, -2.82991619355262503e-06,
+      -4.0010412648847567e-07 * 1. / (1_MeV), 0, -0.00121691842277711322,
+      0.123724676668643951, 5.66678562685891124e-05, 0.000592259000642492389,
+      3.76165411298313188e-08 * 1. / (1_MeV), 0, -0.000576619514959964973,
+      5.66678562685891124e-05, 1.79301478056004271e-05, 1.75725099274939068e-07,
+      1.9855251791033252e-08 * 1. / (1_MeV), 0, -2.82991619355262503e-06,
+      0.000592259000642492389, 1.75725099274939068e-07, 2.86794875137275085e-06,
+      1.52908464521253004e-11 * 1. / (1_MeV), 0,
+      -4.0010412648847567e-07 * 1. / (1_MeV),
+      3.76165411298313188e-08 * 1. / (1_MeV),
+      1.9855251791033252e-08 * 1. / (1_MeV),
+      1.52908464521253004e-11 * 1. / (1_MeV),
+      3.20209747606270412e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams72 =
+      BoundParameters(gctx, std::move(covMat72), params72, perigeeSurface);
+  tracks.push_back(boundParams72);
+
+  // track 73 :
+  BoundVector params73;
+  params73 << 0.730206131935119629, -0.356079369783401489, 1.74193072319030762,
+      0.789627969264984131, 0.000864426896441727877 * 1. / (1_MeV), 0;
+  Covariance covMat73;
+  covMat73 << 0.00696328096091747284, 0.000192718431767054029,
+      -0.000210651783787634309, 1.79142534806142213e-06,
+      -1.60408967532742937e-07 * 1. / (1_MeV), 0, 0.000192718431767054029,
+      0.0250711347907781601, -1.01345165607011824e-05, 0.000326248033176201218,
+      -2.92212069047691244e-09 * 1. / (1_MeV), 0, -0.000210651783787634309,
+      -1.01345165607011824e-05, 6.47193519398570061e-06,
+      -1.10382166450068239e-07, 7.86957679995017337e-09 * 1. / (1_MeV), 0,
+      1.79142534806142213e-06, 0.000326248033176201218,
+      -1.10382166450068239e-07, 4.4890334720548708e-06,
+      1.43532649831609989e-11 * 1. / (1_MeV), 0,
+      -1.60408967532742937e-07 * 1. / (1_MeV),
+      -2.92212069047691244e-09 * 1. / (1_MeV),
+      7.86957679995017337e-09 * 1. / (1_MeV),
+      1.43532649831609989e-11 * 1. / (1_MeV),
+      2.18980167332460951e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams73 =
+      BoundParameters(gctx, std::move(covMat73), params73, perigeeSurface);
+  tracks.push_back(boundParams73);
+
+  // track 74 :
+  BoundVector params74;
+  params74 << -0.697826266288757324, -23.5827674865722656,
+      -0.712247550487518311, 0.6665802001953125,
+      0.000837316561955958605 * 1. / (1_MeV), 0;
+  Covariance covMat74;
+  covMat74 << 0.0102707967162132263, -0.000136778664959171002,
+      -0.000310806316136640959, 3.61658036657657105e-06,
+      -1.57486458126811822e-07 * 1. / (1_MeV), 0, -0.000136778664959171002,
+      0.0391799546778202057, -3.21871642520172128e-06, 0.000429004761143547957,
+      7.25027250869408224e-09 * 1. / (1_MeV), 0, -0.000310806316136640959,
+      -3.21871642520172128e-06, 9.52503432927187532e-06,
+      -1.91221331833284833e-07, 8.03748117560459975e-09 * 1. / (1_MeV), 0,
+      3.61658036657657105e-06, 0.000429004761143547957,
+      -1.91221331833284833e-07, 4.81143752040225081e-06,
+      -1.69302933545922802e-11 * 1. / (1_MeV), 0,
+      -1.57486458126811822e-07 * 1. / (1_MeV),
+      7.25027250869408224e-09 * 1. / (1_MeV),
+      8.03748117560459975e-09 * 1. / (1_MeV),
+      -1.69302933545922802e-11 * 1. / (1_MeV),
+      2.06939729241462089e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams74 =
+      BoundParameters(gctx, std::move(covMat74), params74, perigeeSurface);
+  tracks.push_back(boundParams74);
+
+  // track 75 :
+  BoundVector params75;
+  params75 << 0.0529175736010074615, -12.0598258972167969, 1.1199498176574707,
+      1.30395138263702393, 0.000916379212867468596 * 1. / (1_MeV), 0;
+  Covariance covMat75;
+  covMat75 << 0.00428111432120203972, 2.62827478725743552e-05,
+      -0.000120566700934877791, 7.54315472354089557e-07,
+      -5.43323675648758046e-08 * 1. / (1_MeV), 0, 2.62827478725743552e-05,
+      0.0172699503600597382, -1.77099448321877513e-06, 0.000338392047693610422,
+      -9.53148133943496205e-10 * 1. / (1_MeV), 0, -0.000120566700934877791,
+      -1.77099448321877513e-06, 3.49290257872780785e-06,
+      -4.25857281398289675e-08, 2.55990108225490642e-09 * 1. / (1_MeV), 0,
+      7.54315472354089557e-07, 0.000338392047693610422,
+      -4.25857281398289675e-08, 7.29711200619931333e-06,
+      -2.28893257339241436e-11 * 1. / (1_MeV), 0,
+      -5.43323675648758046e-08 * 1. / (1_MeV),
+      -9.53148133943496205e-10 * 1. / (1_MeV),
+      2.55990108225490642e-09 * 1. / (1_MeV),
+      -2.28893257339241436e-11 * 1. / (1_MeV),
+      9.44539516045672656e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams75 =
+      BoundParameters(gctx, std::move(covMat75), params75, perigeeSurface);
+  tracks.push_back(boundParams75);
+
+  // track 76 :
+  BoundVector params76;
+  params76 << 0.640764772891998291, -0.930534124374389648, 2.15712094306945801,
+      2.28308653831481934, 0.000431261461926624179 * 1. / (1_MeV), 0;
+  Covariance covMat76;
+  covMat76 << 0.00260529923252761364, 4.58412423896785499e-05,
+      -6.7969661726482311e-05, 1.81599714744093986e-08,
+      -4.24128181647569863e-08 * 1. / (1_MeV), 0, 4.58412423896785499e-05,
+      0.0122323241084814072, 8.04787994406084613e-08, 0.000150878291840991384,
+      -1.26706283098581222e-08 * 1. / (1_MeV), 0, -6.7969661726482311e-05,
+      8.04787994406084613e-08, 1.85573071576072834e-06, 1.38421707121045597e-08,
+      1.77332557811301974e-09 * 1. / (1_MeV), 0, 1.81599714744093986e-08,
+      0.000150878291840991384, 1.38421707121045597e-08, 2.22777407543617301e-06,
+      -1.58479619806951909e-10 * 1. / (1_MeV), 0,
+      -4.24128181647569863e-08 * 1. / (1_MeV),
+      -1.26706283098581222e-08 * 1. / (1_MeV),
+      1.77332557811301974e-09 * 1. / (1_MeV),
+      -1.58479619806951909e-10 * 1. / (1_MeV),
+      4.6452456464729508e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams76 =
+      BoundParameters(gctx, std::move(covMat76), params76, perigeeSurface);
+  tracks.push_back(boundParams76);
+
+  // track 77 :
+  BoundVector params77;
+  params77 << 0.653912067413330078, -38.5965461730957031, 2.62386393547058105,
+      2.6188347339630127, -0.000398666656110435724 * 1. / (1_MeV), 0;
+  Covariance covMat77;
+  covMat77 << 0.00521424366161227226, 0.000139879184703866033,
+      -0.000151905000687639944, 1.9792889758053464e-06,
+      -7.62257896696214591e-08 * 1. / (1_MeV), 0, 0.000139879184703866033,
+      0.032011859118938446, -4.45397794194540351e-06, 0.000216144809062415678,
+      4.33223192345790811e-09 * 1. / (1_MeV), 0, -0.000151905000687639944,
+      -4.45397794194540351e-06, 4.54638166047516279e-06,
+      -6.7860751060001615e-08, 3.68501084222524602e-09 * 1. / (1_MeV), 0,
+      1.9792889758053464e-06, 0.000216144809062415678, -6.7860751060001615e-08,
+      1.52451764279248891e-06, -1.26932170430756531e-12 * 1. / (1_MeV), 0,
+      -7.62257896696214591e-08 * 1. / (1_MeV),
+      4.33223192345790811e-09 * 1. / (1_MeV),
+      3.68501084222524602e-09 * 1. / (1_MeV),
+      -1.26932170430756531e-12 * 1. / (1_MeV),
+      7.21128712299901053e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams77 =
+      BoundParameters(gctx, std::move(covMat77), params77, perigeeSurface);
+  tracks.push_back(boundParams77);
+
+  // track 78 :
+  BoundVector params78;
+  params78 << -0.147352397441864014, -5.29536819458007812, -2.19698119163513184,
+      2.19908237457275391, 0.000603679509367793798 * 1. / (1_MeV), 0;
+  Covariance covMat78;
+  covMat78 << 0.0025317345280200243, 3.93469647761186486e-06,
+      -7.47220338226873746e-05, -8.47547663426674989e-07,
+      -4.10995834716985269e-08 * 1. / (1_MeV), 0, 3.93469647761186486e-06,
+      0.0137719558551907539, 1.18341805513367972e-06, 0.000192888227764741909,
+      8.4659628993769127e-11 * 1. / (1_MeV), 0, -7.47220338226873746e-05,
+      1.18341805513367972e-06, 2.24668019654927775e-06, 4.44216205306269896e-08,
+      1.9813795664012159e-09 * 1. / (1_MeV), 0, -8.47547663426674989e-07,
+      0.000192888227764741909, 4.44216205306269896e-08, 3.1759927878738381e-06,
+      2.44401588800591696e-11 * 1. / (1_MeV), 0,
+      -4.10995834716985269e-08 * 1. / (1_MeV),
+      8.4659628993769127e-11 * 1. / (1_MeV),
+      1.9813795664012159e-09 * 1. / (1_MeV),
+      2.44401588800591696e-11 * 1. / (1_MeV),
+      6.28857244056035825e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams78 =
+      BoundParameters(gctx, std::move(covMat78), params78, perigeeSurface);
+  tracks.push_back(boundParams78);
+
+  // track 79 :
+  BoundVector params79;
+  params79 << 0.678209245204925537, -26.9999599456787109, 1.87300777435302734,
+      2.68262672424316406, 0.000182776289875619113 * 1. / (1_MeV), 0;
+  Covariance covMat79;
+  covMat79 << 0.00191749841906130314, 0.000110412661743103727,
+      -5.49806951977405462e-05, 6.60175592356722232e-07,
+      -2.1776932514113485e-08 * 1. / (1_MeV), 0, 0.000110412661743103727,
+      0.0226654317229986191, -6.31152562384800887e-07, 0.000109733381182499073,
+      9.56806544278803705e-10 * 1. / (1_MeV), 0, -5.49806951977405462e-05,
+      -6.31152562384800887e-07, 1.61751074756466551e-06,
+      -8.57919113866550056e-09, 1.02398276394864458e-09 * 1. / (1_MeV), 0,
+      6.60175592356722232e-07, 0.000109733381182499073,
+      -8.57919113866550056e-09, 5.57945270429627271e-07,
+      -9.30864559448818034e-13 * 1. / (1_MeV), 0,
+      -2.1776932514113485e-08 * 1. / (1_MeV),
+      9.56806544278803705e-10 * 1. / (1_MeV),
+      1.02398276394864458e-09 * 1. / (1_MeV),
+      -9.30864559448818034e-13 * 1. / (1_MeV),
+      1.72951982596591947e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams79 =
+      BoundParameters(gctx, std::move(covMat79), params79, perigeeSurface);
+  tracks.push_back(boundParams79);
+
+  // track 80 :
+  BoundVector params80;
+  params80 << 0.64381110668182373, -6.46031522750854492, 2.02721667289733887,
+      2.68821907043457031, -0.000553313468117266893 * 1. / (1_MeV), 0;
+  Covariance covMat80;
+  covMat80 << 0.0134714795276522636, -0.000148150339418309318,
+      -0.000399405999997743766, 3.50936426643331028e-06,
+      -1.66954978163253585e-07 * 1. / (1_MeV), 0, -0.000148150339418309318,
+      0.0778103619813919067, -3.53222213147371605e-06, 0.000429908786653424371,
+      1.29938534403212134e-08 * 1. / (1_MeV), 0, -0.000399405999997743766,
+      -3.53222213147371605e-06, 1.20958047773456201e-05,
+      -1.55765136847599568e-07, 8.36922640021012843e-09 * 1. / (1_MeV), 0,
+      3.50936426643331028e-06, 0.000429908786653424371,
+      -1.55765136847599568e-07, 2.42866008193232119e-06,
+      -5.38086858591292421e-12 * 1. / (1_MeV), 0,
+      -1.66954978163253585e-07 * 1. / (1_MeV),
+      1.29938534403212134e-08 * 1. / (1_MeV),
+      8.36922640021012843e-09 * 1. / (1_MeV),
+      -5.38086858591292421e-12 * 1. / (1_MeV),
+      1.47779136150383295e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams80 =
+      BoundParameters(gctx, std::move(covMat80), params80, perigeeSurface);
+  tracks.push_back(boundParams80);
+
+  // track 81 :
+  BoundVector params81;
+  params81 << 0.13216361403465271, -5.14932060241699219, 0.880854129791259766,
+      0.992275714874267578, -0.000997516443021595478 * 1. / (1_MeV), 0;
+  Covariance covMat81;
+  covMat81 << 0.00625587906688451767, -0.000110949013866784292,
+      -0.000185194923985265947, -2.88485291842903976e-06,
+      -9.58251834750225767e-08 * 1. / (1_MeV), 0, -0.000110949013866784292,
+      0.0189361255615949631, 5.522171408563187e-06, 0.000352685543849685001,
+      -3.54823960396222519e-11 * 1. / (1_MeV), 0, -0.000185194923985265947,
+      5.522171408563187e-06, 5.57630210096249357e-06, 1.35760624085924114e-07,
+      4.58229751365888916e-09 * 1. / (1_MeV), 0, -2.88485291842903976e-06,
+      0.000352685543849685001, 1.35760624085924114e-07, 7.01960607329965569e-06,
+      9.7695621439726223e-12 * 1. / (1_MeV), 0,
+      -9.58251834750225767e-08 * 1. / (1_MeV),
+      -3.54823960396222519e-11 * 1. / (1_MeV),
+      4.58229751365888916e-09 * 1. / (1_MeV),
+      9.7695621439726223e-12 * 1. / (1_MeV),
+      1.47325138200038452e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams81 =
+      BoundParameters(gctx, std::move(covMat81), params81, perigeeSurface);
+  tracks.push_back(boundParams81);
+
+  // track 82 :
+  BoundVector params82;
+  params82 << 0.227797195315361023, -48.2234649658203125, -2.77569174766540527,
+      0.305090576410293579, -0.000179648617631755769 * 1. / (1_MeV), 0;
+  Covariance covMat82;
+  covMat82 << 0.00557572394609451294, -0.000663197008771320177,
+      -0.000161846338406778913, -1.69794778867290902e-06,
+      -9.04045033146821151e-08 * 1. / (1_MeV), 0, -0.000663197008771320177,
+      0.0660624504089355469, 1.59902907216536034e-05, 0.000168873299181685442,
+      2.14987267373142885e-10 * 1. / (1_MeV), 0, -0.000161846338406778913,
+      1.59902907216536034e-05, 4.86282624478917569e-06, 4.67482134719900594e-08,
+      4.44175415702797833e-09 * 1. / (1_MeV), 0, -1.69794778867290902e-06,
+      0.000168873299181685442, 4.67482134719900594e-08, 4.42445099224642036e-07,
+      8.83536325828199794e-12 * 1. / (1_MeV), 0,
+      -9.04045033146821151e-08 * 1. / (1_MeV),
+      2.14987267373142885e-10 * 1. / (1_MeV),
+      4.44175415702797833e-09 * 1. / (1_MeV),
+      8.83536325828199794e-12 * 1. / (1_MeV),
+      5.34931300644192476e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams82 =
+      BoundParameters(gctx, std::move(covMat82), params82, perigeeSurface);
+  tracks.push_back(boundParams82);
+
+  // track 83 :
+  BoundVector params83;
+  params83 << -0.00143859826494008303, -15.1650552749633789,
+      -2.28632807731628418, 0.256175190210342407,
+      0.000115477916551753879 * 1. / (1_MeV), 0;
+  Covariance covMat83;
+  covMat83 << 0.00375564000569283962, -0.000551671739993432088,
+      -0.00010947611885112353, -5.73661445135283778e-07,
+      -4.22778383392875813e-08 * 1. / (1_MeV), 0, -0.000551671739993432088,
+      0.0728673934936523438, 9.0784263305680404e-06, 0.000129420350572193905,
+      2.27171510114886803e-09 * 1. / (1_MeV), 0, -0.00010947611885112353,
+      9.0784263305680404e-06, 3.28997566612088121e-06, 7.07299627862913823e-09,
+      1.99936639608643397e-09 * 1. / (1_MeV), 0, -5.73661445135283778e-07,
+      0.000129420350572193905, 7.07299627862913823e-09, 2.37868235331006872e-07,
+      1.04279595331346869e-12 * 1. / (1_MeV), 0,
+      -4.22778383392875813e-08 * 1. / (1_MeV),
+      2.27171510114886803e-09 * 1. / (1_MeV),
+      1.99936639608643397e-09 * 1. / (1_MeV),
+      1.04279595331346869e-12 * 1. / (1_MeV),
+      1.92760772621536347e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams83 =
+      BoundParameters(gctx, std::move(covMat83), params83, perigeeSurface);
+  tracks.push_back(boundParams83);
+
+  // track 84 :
+  BoundVector params84;
+  params84 << -0.78146892786026001, -23.751434326171875, -0.999060988426208496,
+      2.0324549674987793, -0.000969979155343025923 * 1. / (1_MeV), 0;
+  Covariance covMat84;
+  covMat84 << 0.0048350747674703598, 0.000120963946599512005,
+      -0.000144374569500283449, 1.3788048161874064e-06,
+      -7.09094644554907288e-08 * 1. / (1_MeV), 0, 0.000120963946599512005,
+      0.0167757254093885422, -5.14354340070674043e-06, 0.000297219118512754719,
+      -1.79593641161986059e-09 * 1. / (1_MeV), 0, -0.000144374569500283449,
+      -5.14354340070674043e-06, 4.36926575275720097e-06,
+      -7.26679966160986237e-08, 3.53139150458423765e-09 * 1. / (1_MeV), 0,
+      1.3788048161874064e-06, 0.000297219118512754719, -7.26679966160986237e-08,
+      6.093463071010774e-06, 6.19247327016922366e-12 * 1. / (1_MeV), 0,
+      -7.09094644554907288e-08 * 1. / (1_MeV),
+      -1.79593641161986059e-09 * 1. / (1_MeV),
+      3.53139150458423765e-09 * 1. / (1_MeV),
+      6.19247327016922366e-12 * 1. / (1_MeV),
+      1.26404206546304465e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams84 =
+      BoundParameters(gctx, std::move(covMat84), params84, perigeeSurface);
+  tracks.push_back(boundParams84);
+
+  // track 85 :
+  BoundVector params85;
+  params85 << -0.419987142086029053, -23.2181625366210938, -1.72765111923217773,
+      2.3730311393737793, 0.000834245642181485891 * 1. / (1_MeV), 0;
+  Covariance covMat85;
+  covMat85 << 0.00711026880890130997, 2.11381997852235886e-05,
+      -0.000214070355238693376, -2.47722478700721587e-06,
+      -1.49308714645023079e-07 * 1. / (1_MeV), 0, 2.11381997852235886e-05,
+      0.0319119654595851898, 4.62741704063705679e-06, 0.000389666316763969648,
+      -4.99086836094690827e-09 * 1. / (1_MeV), 0, -0.000214070355238693376,
+      4.62741704063705679e-06, 6.5447911765659228e-06, 1.4062768144653077e-07,
+      7.23939037737933651e-09 * 1. / (1_MeV), 0, -2.47722478700721587e-06,
+      0.000389666316763969648, 1.4062768144653077e-07, 5.10100881001562811e-06,
+      4.05519853361521036e-12 * 1. / (1_MeV), 0,
+      -1.49308714645023079e-07 * 1. / (1_MeV),
+      -4.99086836094690827e-09 * 1. / (1_MeV),
+      7.23939037737933651e-09 * 1. / (1_MeV),
+      4.05519853361521036e-12 * 1. / (1_MeV),
+      1.97367219789690296e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams85 =
+      BoundParameters(gctx, std::move(covMat85), params85, perigeeSurface);
+  tracks.push_back(boundParams85);
+
+  // track 86 :
+  BoundVector params86;
+  params86 << 0.280342727899551392, -1.76902174949645996, 1.17941749095916748,
+      2.43773078918457031, 0.00124833709560334682 * 1. / (1_MeV), 0;
+  Covariance covMat86;
+  covMat86 << 0.0222384743392467499, -0.000469551059919313127,
+      -0.000668093464709992738, -1.03170210424629496e-05,
+      -6.31322167864463976e-07 * 1. / (1_MeV), 0, -0.000469551059919313127,
+      0.0734211504459381104, 3.64346959713435348e-05, 0.000901481115280004927,
+      7.77891238924622843e-09 * 1. / (1_MeV), 0, -0.000668093464709992738,
+      3.64346959713435348e-05, 2.04888619919074699e-05, 5.77626316243002577e-07,
+      3.13812114656612788e-08 * 1. / (1_MeV), 0, -1.03170210424629496e-05,
+      0.000901481115280004927, 5.77626316243002577e-07, 1.12906618596753106e-05,
+      1.32123927173378508e-10 * 1. / (1_MeV), 0,
+      -6.31322167864463976e-07 * 1. / (1_MeV),
+      7.77891238924622843e-09 * 1. / (1_MeV),
+      3.13812114656612788e-08 * 1. / (1_MeV),
+      1.32123927173378508e-10 * 1. / (1_MeV),
+      8.04692867895084873e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams86 =
+      BoundParameters(gctx, std::move(covMat86), params86, perigeeSurface);
+  tracks.push_back(boundParams86);
+
+  // track 87 :
+  BoundVector params87;
+  params87 << -0.655172765254974365, -26.7765121459960938,
+      -0.736525535583496094, 2.02205944061279297,
+      0.000604338070843368769 * 1. / (1_MeV), 0;
+  Covariance covMat87;
+  covMat87 << 0.00198961631394922733, 3.05661867898970239e-06,
+      -5.82364130628319071e-05, -8.33779895790357002e-07,
+      -3.03302168166956188e-08 * 1. / (1_MeV), 0, 3.05661867898970239e-06,
+      0.00704017188400030136, 3.30304839880078472e-07, 0.000134940363950436851,
+      -3.70578310628897577e-09 * 1. / (1_MeV), 0, -5.82364130628319071e-05,
+      3.30304839880078472e-07, 1.73737998920842074e-06, 3.39209195261311275e-08,
+      1.44265069638837021e-09 * 1. / (1_MeV), 0, -8.33779895790357002e-07,
+      0.000134940363950436851, 3.39209195261311275e-08, 3.01883733300201129e-06,
+      -3.51121860297362421e-11 * 1. / (1_MeV), 0,
+      -3.03302168166956188e-08 * 1. / (1_MeV),
+      -3.70578310628897577e-09 * 1. / (1_MeV),
+      1.44265069638837021e-09 * 1. / (1_MeV),
+      -3.51121860297362421e-11 * 1. / (1_MeV),
+      5.05374214698761648e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams87 =
+      BoundParameters(gctx, std::move(covMat87), params87, perigeeSurface);
+  tracks.push_back(boundParams87);
+
+  // track 88 :
+  BoundVector params88;
+  params88 << 0.550101339817047119, -1.01730048656463623, 1.95360791683197021,
+      1.34285402297973633, -0.00163667963352054358 * 1. / (1_MeV), 0;
+  Covariance covMat88;
+  covMat88 << 0.0107496930286288261, -7.68611913775611998e-05,
+      -0.000315102046698671615, -3.90352989298854716e-06,
+      -1.47303449929830411e-07 * 1. / (1_MeV), 0, -7.68611913775611998e-05,
+      0.0372591577470302582, 5.62124909349075963e-06, 0.000868637235426337399,
+      -2.50207485117721545e-09 * 1. / (1_MeV), 0, -0.000315102046698671615,
+      5.62124909349075963e-06, 9.41804592002881691e-06, 2.0220920354903416e-07,
+      7.44695559286270222e-09 * 1. / (1_MeV), 0, -3.90352989298854716e-06,
+      0.000868637235426337399, 2.0220920354903416e-07, 2.23459410335635766e-05,
+      -5.58945405173847072e-11 * 1. / (1_MeV), 0,
+      -1.47303449929830411e-07 * 1. / (1_MeV),
+      -2.50207485117721545e-09 * 1. / (1_MeV),
+      7.44695559286270222e-09 * 1. / (1_MeV),
+      -5.58945405173847072e-11 * 1. / (1_MeV),
+      2.93490870495460854e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams88 =
+      BoundParameters(gctx, std::move(covMat88), params88, perigeeSurface);
+  tracks.push_back(boundParams88);
+
+  // track 89 :
+  BoundVector params89;
+  params89 << -0.0243351589888334274, -6.1328587532043457, -2.17217230796813965,
+      0.851706326007843018, -0.00123827718198299408 * 1. / (1_MeV), 0;
+  Covariance covMat89;
+  covMat89 << 0.013601384125649929, -0.000238490415799996243,
+      -0.000407308591532023773, -5.81321625599451904e-06,
+      -2.20563854841242778e-07 * 1. / (1_MeV), 0, -0.000238490415799996243,
+      0.0385725460946559906, 1.44713061143640791e-05, 0.000594927870114984056,
+      -4.2657516143838364e-09 * 1. / (1_MeV), 0, -0.000407308591532023773,
+      1.44713061143640791e-05, 1.23664985949289985e-05, 2.98472027659172679e-07,
+      1.09973686096897418e-08 * 1. / (1_MeV), 0, -5.81321625599451904e-06,
+      0.000594927870114984056, 2.98472027659172679e-07, 9.52084610617021099e-06,
+      -3.86199606571132037e-11 * 1. / (1_MeV), 0,
+      -2.20563854841242778e-07 * 1. / (1_MeV),
+      -4.2657516143838364e-09 * 1. / (1_MeV),
+      1.09973686096897418e-08 * 1. / (1_MeV),
+      -3.86199606571132037e-11 * 1. / (1_MeV),
+      3.39196892795712301e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams89 =
+      BoundParameters(gctx, std::move(covMat89), params89, perigeeSurface);
+  tracks.push_back(boundParams89);
+
+  // track 90 :
+  BoundVector params90;
+  params90 << 0.723694682121276855, -26.568511962890625, 2.23595356941223145,
+      2.48232841491699219, -0.000482781761093065143 * 1. / (1_MeV), 0;
+  Covariance covMat90;
+  covMat90 << 0.00387407466769218445, 2.81628374958135634e-05,
+      -0.000114726948246347626, 1.29467025144414135e-06,
+      -9.82718568940813015e-08 * 1. / (1_MeV), 0, 2.81628374958135634e-05,
+      0.0211086571216583252, -1.99152008947953991e-06, 0.000209110626146605873,
+      3.14540254121542699e-09 * 1. / (1_MeV), 0, -0.000114726948246347626,
+      -1.99152008947953991e-06, 3.47766376762592699e-06,
+      -5.54193827886431388e-08, 4.70571016940573361e-09 * 1. / (1_MeV), 0,
+      1.29467025144414135e-06, 0.000209110626146605873,
+      -5.54193827886431388e-08, 2.18847662836196832e-06,
+      -1.76163300018645983e-11 * 1. / (1_MeV), 0,
+      -9.82718568940813015e-08 * 1. / (1_MeV),
+      3.14540254121542699e-09 * 1. / (1_MeV),
+      4.70571016940573361e-09 * 1. / (1_MeV),
+      -1.76163300018645983e-11 * 1. / (1_MeV),
+      1.11767643751203849e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams90 =
+      BoundParameters(gctx, std::move(covMat90), params90, perigeeSurface);
+  tracks.push_back(boundParams90);
+
+  // track 91 :
+  BoundVector params91;
+  params91 << -0.2323446124792099, -1.08657681941986084, -2.02921128273010254,
+      1.34838950634002686, -0.000909031485207378864 * 1. / (1_MeV), 0;
+  Covariance covMat91;
+  covMat91 << 0.0042699095793068409, -4.94646692795497152e-05,
+      -0.00011729394910827925, -1.00433771415922194e-06,
+      -4.90878501892060452e-08 * 1. / (1_MeV), 0, -4.94646692795497152e-05,
+      0.0193016305565834045, 2.10226265958507905e-06, 0.000365190230248221902,
+      7.18162424846205697e-10 * 1. / (1_MeV), 0, -0.00011729394910827925,
+      2.10226265958507905e-06, 3.3351993806718383e-06, 4.49848539144146812e-08,
+      2.39365529077948547e-09 * 1. / (1_MeV), 0, -1.00433771415922194e-06,
+      0.000365190230248221902, 4.49848539144146812e-08, 8.12437156127998605e-06,
+      1.11281704892510676e-11 * 1. / (1_MeV), 0,
+      -4.90878501892060452e-08 * 1. / (1_MeV),
+      7.18162424846205697e-10 * 1. / (1_MeV),
+      2.39365529077948547e-09 * 1. / (1_MeV),
+      1.11281704892510676e-11 * 1. / (1_MeV),
+      9.21146006693795982e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams91 =
+      BoundParameters(gctx, std::move(covMat91), params91, perigeeSurface);
+  tracks.push_back(boundParams91);
+
+  // track 92 :
+  BoundVector params92;
+  params92 << 0.265045791864395142, -27.2973098754882812, 1.05269753932952881,
+      2.81940984725952148, -0.000315688434056937695 * 1. / (1_MeV), 0;
+  Covariance covMat92;
+  covMat92 << 0.0140700377523899078, 0.000593323783968879382,
+      -0.000416014263318039551, 3.4111828236548417e-06,
+      -2.73414962589024817e-07 * 1. / (1_MeV), 0, 0.000593323783968879382,
+      0.35917237401008606, -4.08578592997089967e-05, 0.000845220423224244104,
+      1.86785150218537236e-08 * 1. / (1_MeV), 0, -0.000416014263318039551,
+      -4.08578592997089967e-05, 1.27100629470078275e-05,
+      -1.59836018444417662e-07, 1.37035759118268963e-08 * 1. / (1_MeV), 0,
+      3.4111828236548417e-06, 0.000845220423224244104, -1.59836018444417662e-07,
+      2.07905191018653568e-06, 2.14949156818848357e-12 * 1. / (1_MeV), 0,
+      -2.73414962589024817e-07 * 1. / (1_MeV),
+      1.86785150218537236e-08 * 1. / (1_MeV),
+      1.37035759118268963e-08 * 1. / (1_MeV),
+      2.14949156818848357e-12 * 1. / (1_MeV),
+      1.74355599402709061e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams92 =
+      BoundParameters(gctx, std::move(covMat92), params92, perigeeSurface);
+  tracks.push_back(boundParams92);
+
+  // track 93 :
+  BoundVector params93;
+  params93 << 0.789679765701293945, -24.0303401947021484, 2.51740336418151855,
+      0.428744226694107056, 0.000271489931037649512 * 1. / (1_MeV), 0;
+  Covariance covMat93;
+  covMat93 << 0.00483581656590104103, -0.00014841558570857861,
+      -0.000137122191448320704, -1.15095639449306219e-06,
+      -5.72764878155495094e-08 * 1. / (1_MeV), 0, -0.00014841558570857861,
+      0.0322524122893810272, -4.39218594800754952e-07, 0.000152778757565279151,
+      -1.06383037100379797e-09 * 1. / (1_MeV), 0, -0.000137122191448320704,
+      -4.39218594800754952e-07, 4.02241357733146288e-06, 1.598528605493444e-08,
+      2.66714797310526465e-09 * 1. / (1_MeV), 0, -1.15095639449306219e-06,
+      0.000152778757565279151, 1.598528605493444e-08, 7.50712217723048525e-07,
+      1.22675320789893397e-11 * 1. / (1_MeV), 0,
+      -5.72764878155495094e-08 * 1. / (1_MeV),
+      -1.06383037100379797e-09 * 1. / (1_MeV),
+      2.66714797310526465e-09 * 1. / (1_MeV),
+      1.22675320789893397e-11 * 1. / (1_MeV),
+      4.13053515002648197e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams93 =
+      BoundParameters(gctx, std::move(covMat93), params93, perigeeSurface);
+  tracks.push_back(boundParams93);
+
+  // track 94 :
+  BoundVector params94;
+  params94 << 0.0419332981109619141, -22.403900146484375, 1.04268980026245117,
+      0.541070818901062012, -0.000843891466502100229 * 1. / (1_MeV), 0;
+  Covariance covMat94;
+  covMat94 << 0.0182619895786046982, -0.000309098329579466258,
+      -0.000548046706254767617, -6.4069930181110618e-06,
+      -2.1453733001269524e-07 * 1. / (1_MeV), 0, -0.000309098329579466258,
+      0.0862535983324050903, 2.67156807455599936e-05, 0.000666602107346143339,
+      -5.16283304523887763e-09 * 1. / (1_MeV), 0, -0.000548046706254767617,
+      2.67156807455599936e-05, 1.6711990610929206e-05, 3.3081373187341857e-07,
+      1.096216345456462e-08 * 1. / (1_MeV), 0, -6.4069930181110618e-06,
+      0.000666602107346143339, 3.3081373187341857e-07, 5.25060204381588846e-06,
+      2.56585402895446448e-14 * 1. / (1_MeV), 0,
+      -2.1453733001269524e-07 * 1. / (1_MeV),
+      -5.16283304523887763e-09 * 1. / (1_MeV),
+      1.096216345456462e-08 * 1. / (1_MeV),
+      2.56585402895446448e-14 * 1. / (1_MeV),
+      2.29805854901066198e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams94 =
+      BoundParameters(gctx, std::move(covMat94), params94, perigeeSurface);
+  tracks.push_back(boundParams94);
+
+  // track 95 :
+  BoundVector params95;
+  params95 << 0.176779255270957947, -37.7216300964355469, -2.91102933883666992,
+      2.48529434204101562, -0.000805854273494333029 * 1. / (1_MeV), 0;
+  Covariance covMat95;
+  covMat95 << 0.0118867438286542892, 0.000227795118694210991,
+      -0.000348746534646607244, 4.75699803725603849e-06,
+      -2.10260526953580937e-07 * 1. / (1_MeV), 0, 0.000227795118694210991,
+      0.0444288402795791626, -1.27103127595436328e-05, 0.00044249878890344381,
+      3.24775989820321723e-09 * 1. / (1_MeV), 0, -0.000348746534646607244,
+      -1.27103127595436328e-05, 1.04705995909171179e-05,
+      -2.08165437755266941e-07, 1.02343642189694215e-08 * 1. / (1_MeV), 0,
+      4.75699803725603849e-06, 0.00044249878890344381, -2.08165437755266941e-07,
+      4.59913690065150149e-06, -1.77698327525688441e-11 * 1. / (1_MeV), 0,
+      -2.10260526953580937e-07 * 1. / (1_MeV),
+      3.24775989820321723e-09 * 1. / (1_MeV),
+      1.02343642189694215e-08 * 1. / (1_MeV),
+      -1.77698327525688441e-11 * 1. / (1_MeV),
+      2.43435688274118434e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams95 =
+      BoundParameters(gctx, std::move(covMat95), params95, perigeeSurface);
+  tracks.push_back(boundParams95);
+
+  // track 96 :
+  BoundVector params96;
+  params96 << 0.447810828685760498, -26.3884296417236328, 1.54339611530303955,
+      1.56189525127410889, 0.00136160221882164478 * 1. / (1_MeV), 0;
+  Covariance covMat96;
+  covMat96 << 0.00786379911005496979, 2.44020731388588477e-06,
+      -0.000226637467024543921, 6.05815686194600369e-08,
+      -9.290821859919166e-08 * 1. / (1_MeV), 0, 2.44020731388588477e-06,
+      0.0212073065340518951, -1.41751539171569177e-07, 0.000477572767546785625,
+      -6.58794985364503272e-10 * 1. / (1_MeV), 0, -0.000226637467024543921,
+      -1.41751539171569177e-07, 6.68278789817122743e-06,
+      -3.38178369258151404e-09, 4.51877708122468826e-09 * 1. / (1_MeV), 0,
+      6.05815686194600369e-08, 0.000477572767546785625,
+      -3.38178369258151404e-09, 1.25970709632383659e-05,
+      -7.18296901266119286e-13 * 1. / (1_MeV), 0,
+      -9.290821859919166e-08 * 1. / (1_MeV),
+      -6.58794985364503272e-10 * 1. / (1_MeV),
+      4.51877708122468826e-09 * 1. / (1_MeV),
+      -7.18296901266119286e-13 * 1. / (1_MeV),
+      1.78482867374540888e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams96 =
+      BoundParameters(gctx, std::move(covMat96), params96, perigeeSurface);
+  tracks.push_back(boundParams96);
+
+  // track 97 :
+  BoundVector params97;
+  params97 << 0.69138866662979126, -0.824633300304412842, 1.62790572643280029,
+      2.17131519317626953, -0.00157829432282596827 * 1. / (1_MeV), 0;
+  Covariance covMat97;
+  covMat97 << 0.0180772673338651657, 6.76792935648847091e-05,
+      -0.000534082747176570683, 9.79180919063570467e-06,
+      -2.87445677290829436e-07 * 1. / (1_MeV), 0, 6.76792935648847091e-05,
+      0.0473108701407909393, -1.27657009238910182e-05, 0.000919307781488095115,
+      2.86386577268916162e-09 * 1. / (1_MeV), 0, -0.000534082747176570683,
+      -1.27657009238910182e-05, 1.60557119670556858e-05, -5.161388544210652e-07,
+      1.4339166470730082e-08 * 1. / (1_MeV), 0, 9.79180919063570467e-06,
+      0.000919307781488095115, -5.161388544210652e-07, 1.83516385732218623e-05,
+      -1.41501241215600609e-10 * 1. / (1_MeV), 0,
+      -2.87445677290829436e-07 * 1. / (1_MeV),
+      2.86386577268916162e-09 * 1. / (1_MeV),
+      1.4339166470730082e-08 * 1. / (1_MeV),
+      -1.41501241215600609e-10 * 1. / (1_MeV),
+      4.72637817772181279e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams97 =
+      BoundParameters(gctx, std::move(covMat97), params97, perigeeSurface);
+  tracks.push_back(boundParams97);
+
+  // track 98 :
+  BoundVector params98;
+  params98 << 2.12992453575134277, -18.7516555786132812, 0.322550356388092041,
+      0.368121087551116943, 0.000346695247571915388 * 1. / (1_MeV), 0;
+  Covariance covMat98;
+  covMat98 << 0.0101209962740540504, 0.0011374339858220674,
+      -0.000299095329991897287, -3.14932882056957461e-07,
+      -1.65684092374357599e-07 * 1. / (1_MeV), 0, 0.0011374339858220674,
+      0.0939061492681503296, -4.8902690159540195e-05, 0.000337479548580967448,
+      -3.9036311873074078e-08 * 1. / (1_MeV), 0, -0.000299095329991897287,
+      -4.8902690159540195e-05, 9.09368463908322155e-06,
+      -3.51741511269112836e-08, 8.19782135067778202e-09 * 1. / (1_MeV), 0,
+      -3.14932882056957461e-07, 0.000337479548580967448,
+      -3.51741511269112836e-08, 1.25376061532733729e-06,
+      7.26578444477865009e-12 * 1. / (1_MeV), 0,
+      -1.65684092374357599e-07 * 1. / (1_MeV),
+      -3.9036311873074078e-08 * 1. / (1_MeV),
+      8.19782135067778202e-09 * 1. / (1_MeV),
+      7.26578444477865009e-12 * 1. / (1_MeV),
+      1.17719708980779103e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams98 =
+      BoundParameters(gctx, std::move(covMat98), params98, perigeeSurface);
+  tracks.push_back(boundParams98);
+
+  // track 99 :
+  BoundVector params99;
+  params99 << -0.535510718822479248, -28.7000522613525391,
+      -0.231238842010498047, 1.41121876239776611,
+      0.00161712500266730785 * 1. / (1_MeV), 0;
+  Covariance covMat99;
+  covMat99 << 0.0117115778848528862, -7.67866557470544008e-06,
+      -0.000338518527122336449, 1.34603162757949205e-06,
+      -1.72783210997185512e-07 * 1. / (1_MeV), 0, -7.67866557470544008e-06,
+      0.0252319127321243286, -1.52781402695736202e-06, 0.000597511113212106579,
+      3.90113700709114385e-10 * 1. / (1_MeV), 0, -0.000338518527122336449,
+      -1.52781402695736202e-06, 1.00057823146926239e-05,
+      -8.19645843713344724e-08, 8.35848601602763903e-09 * 1. / (1_MeV), 0,
+      1.34603162757949205e-06, 0.000597511113212106579,
+      -8.19645843713344724e-08, 1.51151134559768252e-05,
+      -1.22177379055824259e-11 * 1. / (1_MeV), 0,
+      -1.72783210997185512e-07 * 1. / (1_MeV),
+      3.90113700709114385e-10 * 1. / (1_MeV),
+      8.35848601602763903e-09 * 1. / (1_MeV),
+      -1.22177379055824259e-11 * 1. / (1_MeV),
+      3.21954796156376233e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams99 =
+      BoundParameters(gctx, std::move(covMat99), params99, perigeeSurface);
+  tracks.push_back(boundParams99);
+
+  // track 100 :
+  BoundVector params100;
+  params100 << -0.843921840190887451, -49.1135101318359375,
+      -0.365095585584640503, 2.96138834953308105,
+      -6.34708048892207444e-05 * 1. / (1_MeV), 0;
+  Covariance covMat100;
+  covMat100 << 0.00338416872546076775, 0.00177216971338738029,
+      -9.9789567797386219e-05, 9.88074736457750535e-07,
+      -3.61024835134689107e-08 * 1. / (1_MeV), 0, 0.00177216971338738029,
+      0.116565637290477753, -4.51521351414238938e-05, 0.000105721181896181534,
+      -9.47131199620464829e-09 * 1. / (1_MeV), 0, -9.9789567797386219e-05,
+      -4.51521351414238938e-05, 3.03179808724962641e-06,
+      -2.47402428503374937e-08, 1.75584896641553984e-09 * 1. / (1_MeV), 0,
+      9.88074736457750535e-07, 0.000105721181896181534,
+      -2.47402428503374937e-08, 9.8112643343029049e-08,
+      -1.43857092852611679e-12 * 1. / (1_MeV), 0,
+      -3.61024835134689107e-08 * 1. / (1_MeV),
+      -9.47131199620464829e-09 * 1. / (1_MeV),
+      1.75584896641553984e-09 * 1. / (1_MeV),
+      -1.43857092852611679e-12 * 1. / (1_MeV),
+      1.24140029852948253e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams100 =
+      BoundParameters(gctx, std::move(covMat100), params100, perigeeSurface);
+  tracks.push_back(boundParams100);
+
+  // track 101 :
+  BoundVector params101;
+  params101 << 0.641214549541473389, -26.0584869384765625, 1.89008140563964844,
+      0.860124528408050537, 0.00106167653575539589 * 1. / (1_MeV), 0;
+  Covariance covMat101;
+  covMat101 << 0.0103070121258497238, 0.000236402176595641814,
+      -0.000307985893857692168, 3.39085785889227025e-06,
+      -1.78250227329527766e-07 * 1. / (1_MeV), 0, 0.000236402176595641814,
+      0.0338090509176254272, -1.38128442497058292e-05, 0.000515236218679150171,
+      4.11640035508361721e-10 * 1. / (1_MeV), 0, -0.000307985893857692168,
+      -1.38128442497058292e-05, 9.32193688640836626e-06,
+      -2.03856681051109258e-07, 8.47974964267322053e-09 * 1. / (1_MeV), 0,
+      3.39085785889227025e-06, 0.000515236218679150171,
+      -2.03856681051109258e-07, 8.28272459330037236e-06,
+      5.47351419013377902e-11 * 1. / (1_MeV), 0,
+      -1.78250227329527766e-07 * 1. / (1_MeV),
+      4.11640035508361721e-10 * 1. / (1_MeV),
+      8.47974964267322053e-09 * 1. / (1_MeV),
+      5.47351419013377902e-11 * 1. / (1_MeV),
+      2.47352943683054605e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams101 =
+      BoundParameters(gctx, std::move(covMat101), params101, perigeeSurface);
+  tracks.push_back(boundParams101);
+
+  // track 102 :
+  BoundVector params102;
+  params102 << -0.362777590751647949, -46.8636550903320312,
+      0.170416802167892456, 2.36327528953552246,
+      -0.000455565168522298336 * 1. / (1_MeV), 0;
+  Covariance covMat102;
+  covMat102 << 0.00364208268001675606, 8.14110252555974963e-05,
+      -0.000105730958373490328, 7.352639037761148e-07,
+      -1.11606862640893415e-07 * 1. / (1_MeV), 0, 8.14110252555974963e-05,
+      0.0136387618258595467, -2.96848315587999865e-06, 0.00014858030669170883,
+      -2.44465634156851802e-09 * 1. / (1_MeV), 0, -0.000105730958373490328,
+      -2.96848315587999865e-06, 3.21430798067012802e-06,
+      -3.21777938528106935e-08, 4.84297827278802643e-09 * 1. / (1_MeV), 0,
+      7.352639037761148e-07, 0.00014858030669170883, -3.21777938528106935e-08,
+      1.92027391676674597e-06, 7.89285090595557677e-12 * 1. / (1_MeV), 0,
+      -1.11606862640893415e-07 * 1. / (1_MeV),
+      -2.44465634156851802e-09 * 1. / (1_MeV),
+      4.84297827278802643e-09 * 1. / (1_MeV),
+      7.89285090595557677e-12 * 1. / (1_MeV),
+      1.05506943459676705e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams102 =
+      BoundParameters(gctx, std::move(covMat102), params102, perigeeSurface);
+  tracks.push_back(boundParams102);
+
+  // track 103 :
+  BoundVector params103;
+  params103 << -0.40931740403175354, -26.7641277313232422, 0.23282817006111145,
+      1.9218742847442627, -0.00123902841005474329 * 1. / (1_MeV), 0;
+  Covariance covMat103;
+  covMat103 << 0.00617217039689421654, 8.91950346564854339e-05,
+      -0.000185605375297960145, 1.82571256326137244e-06,
+      -9.99364389719838625e-08 * 1. / (1_MeV), 0, 8.91950346564854339e-05,
+      0.0202017351984977722, -4.70036532729824457e-06, 0.000417853265694033654,
+      -3.42294422890168881e-09 * 1. / (1_MeV), 0, -0.000185605375297960145,
+      -4.70036532729824457e-06, 5.65443906452856027e-06,
+      -9.94552627423270062e-08, 5.03852824195809614e-09 * 1. / (1_MeV), 0,
+      1.82571256326137244e-06, 0.000417853265694033654,
+      -9.94552627423270062e-08, 9.30496571527328342e-06,
+      -5.69843357485556815e-11 * 1. / (1_MeV), 0,
+      -9.99364389719838625e-08 * 1. / (1_MeV),
+      -3.42294422890168881e-09 * 1. / (1_MeV),
+      5.03852824195809614e-09 * 1. / (1_MeV),
+      -5.69843357485556815e-11 * 1. / (1_MeV),
+      1.89580739995420799e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams103 =
+      BoundParameters(gctx, std::move(covMat103), params103, perigeeSurface);
+  tracks.push_back(boundParams103);
+
+  // track 104 :
+  BoundVector params104;
+  params104 << -0.404072463512420654, -38.5120201110839844,
+      0.344911128282546997, 1.1619257926940918,
+      0.000986460363492369652 * 1. / (1_MeV), 0;
+  Covariance covMat104;
+  covMat104 << 0.00567628862336277962, 1.63609496095437183e-05,
+      -0.000170335731137528478, 1.2532630967862434e-06,
+      -7.98636404443589343e-08 * 1. / (1_MeV), 0, 1.63609496095437183e-05,
+      0.0189783293753862381, -2.2718372282879903e-06, 0.000355776438418386749,
+      -2.11084620426846086e-09 * 1. / (1_MeV), 0, -0.000170335731137528478,
+      -2.2718372282879903e-06, 5.16884620083146729e-06,
+      -7.55285582881687735e-08, 3.807619848578843e-09 * 1. / (1_MeV), 0,
+      1.2532630967862434e-06, 0.000355776438418386749, -7.55285582881687735e-08,
+      7.77826517150970176e-06, -9.50285600530462166e-11 * 1. / (1_MeV), 0,
+      -7.98636404443589343e-08 * 1. / (1_MeV),
+      -2.11084620426846086e-09 * 1. / (1_MeV),
+      3.807619848578843e-09 * 1. / (1_MeV),
+      -9.50285600530462166e-11 * 1. / (1_MeV),
+      1.29019364636384637e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams104 =
+      BoundParameters(gctx, std::move(covMat104), params104, perigeeSurface);
+  tracks.push_back(boundParams104);
+
+  // track 105 :
+  BoundVector params105;
+  params105 << -0.748140871524810791, -23.7969169616699219,
+      -1.03605329990386963, 2.42653083801269531,
+      -0.00107949809171259403 * 1. / (1_MeV), 0;
+  Covariance covMat105;
+  covMat105 << 0.0166618265211582184, 0.000828099383602299449,
+      -0.000494286373322627617, 7.81528533501132929e-06,
+      -2.37068070630336222e-07 * 1. / (1_MeV), 0, 0.000828099383602299449,
+      0.054433431476354599, -3.50962664017384553e-05, 0.000667669965196798754,
+      -8.65990164654914017e-09 * 1. / (1_MeV), 0, -0.000494286373322627617,
+      -3.50962664017384553e-05, 1.49260613397927955e-05,
+      -3.71389679468892074e-07, 1.21273109287785646e-08 * 1. / (1_MeV), 0,
+      7.81528533501132929e-06, 0.000667669965196798754,
+      -3.71389679468892074e-07, 8.39095991977956146e-06,
+      -1.74774216671551251e-11 * 1. / (1_MeV), 0,
+      -2.37068070630336222e-07 * 1. / (1_MeV),
+      -8.65990164654914017e-09 * 1. / (1_MeV),
+      1.21273109287785646e-08 * 1. / (1_MeV),
+      -1.74774216671551251e-11 * 1. / (1_MeV),
+      3.28096633195329446e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams105 =
+      BoundParameters(gctx, std::move(covMat105), params105, perigeeSurface);
+  tracks.push_back(boundParams105);
+
+  // track 106 :
+  BoundVector params106;
+  params106 << -0.1366615891456604, -27.5638828277587891, -2.49039888381958008,
+      2.61403965950012207, -0.000799041183199733496 * 1. / (1_MeV), 0;
+  Covariance covMat106;
+  covMat106 << 0.0195895861834287643, 0.000432913617665369582,
+      -0.000583389996389527331, 5.64615132296629398e-06,
+      -2.21743636175833062e-07 * 1. / (1_MeV), 0, 0.000432913617665369582,
+      0.0853368565440177917, -2.81463041205404891e-05, 0.00062887185835232241,
+      7.3903210045338403e-10 * 1. / (1_MeV), 0, -0.000583389996389527331,
+      -2.81463041205404891e-05, 1.76701887539820746e-05,
+      -2.86129485279660388e-07, 1.13733623250742995e-08 * 1. / (1_MeV), 0,
+      5.64615132296629398e-06, 0.00062887185835232241, -2.86129485279660388e-07,
+      4.7167955017357599e-06, -6.31956258410507594e-12 * 1. / (1_MeV), 0,
+      -2.21743636175833062e-07 * 1. / (1_MeV),
+      7.3903210045338403e-10 * 1. / (1_MeV),
+      1.13733623250742995e-08 * 1. / (1_MeV),
+      -6.31956258410507594e-12 * 1. / (1_MeV),
+      2.37201536190667639e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams106 =
+      BoundParameters(gctx, std::move(covMat106), params106, perigeeSurface);
+  tracks.push_back(boundParams106);
+
+  // track 107 :
+  BoundVector params107;
+  params107 << -0.281952261924743652, -27.2675514221191406,
+      0.283114522695541382, 2.50815463066101074,
+      0.000522553629707545042 * 1. / (1_MeV), 0;
+  Covariance covMat107;
+  covMat107 << 0.00573171814903616905, 0.00019089292202471595,
+      -0.00016298341980869213, -1.57774753003534747e-07,
+      -1.76578997119228594e-07 * 1. / (1_MeV), 0, 0.00019089292202471595,
+      0.0275938734412193298, -6.10260426027345211e-07, 0.000245123840061546561,
+      -1.87936821571313464e-09 * 1. / (1_MeV), 0, -0.00016298341980869213,
+      -6.10260426027345211e-07, 4.82601581097696908e-06,
+      4.47867660897611079e-08, 8.397331774157027e-09 * 1. / (1_MeV), 0,
+      -1.57774753003534747e-07, 0.000245123840061546561,
+      4.47867660897611079e-08, 2.33085211220895872e-06,
+      4.17575815132199387e-11 * 1. / (1_MeV), 0,
+      -1.76578997119228594e-07 * 1. / (1_MeV),
+      -1.87936821571313464e-09 * 1. / (1_MeV),
+      8.397331774157027e-09 * 1. / (1_MeV),
+      4.17575815132199387e-11 * 1. / (1_MeV),
+      1.90833182589500439e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams107 =
+      BoundParameters(gctx, std::move(covMat107), params107, perigeeSurface);
+  tracks.push_back(boundParams107);
+
+  // track 108 :
+  BoundVector params108;
+  params108 << -0.209811851382255554, -38.4141693115234375,
+      -2.18240070343017578, 2.00559163093566895,
+      0.000823514885269105434 * 1. / (1_MeV), 0;
+  Covariance covMat108;
+  covMat108 << 0.00320075475610792637, -1.04729464667693049e-05,
+      -9.46977753717566058e-05, -8.47132736283527935e-07,
+      -5.70312221165104945e-08 * 1. / (1_MeV), 0, -1.04729464667693049e-05,
+      0.014612528495490551, 1.60439917204324993e-06, 0.00026047244379319754,
+      1.66653208275732943e-09 * 1. / (1_MeV), 0, -9.46977753717566058e-05,
+      1.60439917204324993e-06, 2.8525080324470764e-06, 4.92819818644437109e-08,
+      2.74010143274654739e-09 * 1. / (1_MeV), 0, -8.47132736283527935e-07,
+      0.00026047244379319754, 4.92819818644437109e-08, 5.10619156557368115e-06,
+      4.4716062401029798e-11 * 1. / (1_MeV), 0,
+      -5.70312221165104945e-08 * 1. / (1_MeV),
+      1.66653208275732943e-09 * 1. / (1_MeV),
+      2.74010143274654739e-09 * 1. / (1_MeV),
+      4.4716062401029798e-11 * 1. / (1_MeV),
+      9.70698590951890594e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams108 =
+      BoundParameters(gctx, std::move(covMat108), params108, perigeeSurface);
+  tracks.push_back(boundParams108);
+
+  // track 109 :
+  BoundVector params109;
+  params109 << 0.400049686431884766, 5.43777561187744141, 1.30985116958618164,
+      0.949728786945343018, 0.00125019415281713009 * 1. / (1_MeV), 0;
+  Covariance covMat109;
+  covMat109 << 0.0109754176810383797, 8.39713551440950264e-05,
+      -0.000324492312141962081, 3.05687976180540516e-06,
+      -1.72665763951203633e-07 * 1. / (1_MeV), 0, 8.39713551440950264e-05,
+      0.0270265769213438034, -9.01515946057451831e-06, 0.000490121886147781502,
+      1.08024475744600902e-09 * 1. / (1_MeV), 0, -0.000324492312141962081,
+      -9.01515946057451831e-06, 9.76565206656232476e-06,
+      -2.03225115069697751e-07, 8.22356836237723778e-09 * 1. / (1_MeV), 0,
+      3.05687976180540516e-06, 0.000490121886147781502,
+      -2.03225115069697751e-07, 9.30580608837772161e-06,
+      3.42299696660580778e-11 * 1. / (1_MeV), 0,
+      -1.72665763951203633e-07 * 1. / (1_MeV),
+      1.08024475744600902e-09 * 1. / (1_MeV),
+      8.22356836237723778e-09 * 1. / (1_MeV),
+      3.42299696660580778e-11 * 1. / (1_MeV),
+      2.54714332958982936e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams109 =
+      BoundParameters(gctx, std::move(covMat109), params109, perigeeSurface);
+  tracks.push_back(boundParams109);
+
+  // track 110 :
+  BoundVector params110;
+  params110 << -0.539265453815460205, -1.51409578323364258,
+      -1.46416330337524414, 0.445282995700836182,
+      -0.000581343425437808037 * 1. / (1_MeV), 0;
+  Covariance covMat110;
+  covMat110 << 0.0150984814390540123, -0.00078787709593504591,
+      -0.000463668385076406234, -3.40126069737758356e-06,
+      -4.7594001233568186e-07 * 1. / (1_MeV), 0, -0.00078787709593504591,
+      0.0981750190258026123, 3.73198782812315689e-05, 0.000517547473711687102,
+      1.71900525614601273e-08 * 1. / (1_MeV), 0, -0.000463668385076406234,
+      3.73198782812315689e-05, 1.45666390380938537e-05, 1.75249294465507646e-07,
+      2.38844165520381005e-08 * 1. / (1_MeV), 0, -3.40126069737758356e-06,
+      0.000517547473711687102, 1.75249294465507646e-07, 2.79596974905871321e-06,
+      1.81008924621221718e-12 * 1. / (1_MeV), 0,
+      -4.7594001233568186e-07 * 1. / (1_MeV),
+      1.71900525614601273e-08 * 1. / (1_MeV),
+      2.38844165520381005e-08 * 1. / (1_MeV),
+      1.81008924621221718e-12 * 1. / (1_MeV),
+      4.11227746299758223e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams110 =
+      BoundParameters(gctx, std::move(covMat110), params110, perigeeSurface);
+  tracks.push_back(boundParams110);
+
+  // track 111 :
+  BoundVector params111;
+  params111 << 0.671114623546600342, -23.2680797576904297, 2.88971590995788574,
+      2.53794145584106445, 0.000528754433616995811 * 1. / (1_MeV), 0;
+  Covariance covMat111;
+  covMat111 << 0.00582297053188085556, -0.000178269433632520676,
+      -0.00017064040508346805, -9.16577544786184328e-07,
+      -7.39871471870988742e-08 * 1. / (1_MeV), 0, -0.000178269433632520676,
+      0.0320282876491546631, 9.47676944871473379e-06, 0.000262375079643188658,
+      2.3446639759563834e-09 * 1. / (1_MeV), 0, -0.00017064040508346805,
+      9.47676944871473379e-06, 5.11728148921974935e-06, 6.10420777287489119e-08,
+      3.63856481310620549e-09 * 1. / (1_MeV), 0, -9.16577544786184328e-07,
+      0.000262375079643188658, 6.10420777287489119e-08, 2.29290367315115873e-06,
+      -1.73298870890743619e-12 * 1. / (1_MeV), 0,
+      -7.39871471870988742e-08 * 1. / (1_MeV),
+      2.3446639759563834e-09 * 1. / (1_MeV),
+      3.63856481310620549e-09 * 1. / (1_MeV),
+      -1.73298870890743619e-12 * 1. / (1_MeV),
+      8.13164466317850554e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams111 =
+      BoundParameters(gctx, std::move(covMat111), params111, perigeeSurface);
+  tracks.push_back(boundParams111);
+
+  // track 112 :
+  BoundVector params112;
+  params112 << -0.567338824272155762, -39.2379379272460938,
+      -0.573527812957763672, 2.7919611930847168,
+      0.000323907297570258379 * 1. / (1_MeV), 0;
+  Covariance covMat112;
+  covMat112 << 0.0145241515710949898, 0.00100893966705628622,
+      -0.000435175147220113426, -7.91300794951697705e-07,
+      -1.50984912241323336e-07 * 1. / (1_MeV), 0, 0.00100893966705628622,
+      0.162825420498847961, -1.17342322710575323e-05, 0.000570896267478980253,
+      -1.57354143788096226e-08 * 1. / (1_MeV), 0, -0.000435175147220113426,
+      -1.17342322710575323e-05, 1.32923332785139792e-05,
+      8.24493698474199101e-08, 7.3705206571867806e-09 * 1. / (1_MeV), 0,
+      -7.91300794951697705e-07, 0.000570896267478980253,
+      8.24493698474199101e-08, 2.02825663109251764e-06,
+      -1.36270420577401879e-12 * 1. / (1_MeV), 0,
+      -1.50984912241323336e-07 * 1. / (1_MeV),
+      -1.57354143788096226e-08 * 1. / (1_MeV),
+      7.3705206571867806e-09 * 1. / (1_MeV),
+      -1.36270420577401879e-12 * 1. / (1_MeV),
+      9.7393829112668584e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams112 =
+      BoundParameters(gctx, std::move(covMat112), params112, perigeeSurface);
+  tracks.push_back(boundParams112);
+
+  // track 113 :
+  BoundVector params113;
+  params113 << -0.352110147476196289, -42.806732177734375, -1.94127309322357178,
+      0.234347626566886902, 0.000298306811600923538 * 1. / (1_MeV), 0;
+  Covariance covMat113;
+  covMat113 << 0.0297679267823696136, -0.000157760492633259443,
+      -0.000897409671925476033, 5.00768443241615978e-06,
+      -2.84713002525393994e-07 * 1. / (1_MeV), 0, -0.000157760492633259443,
+      0.755975544452667236, -6.81046218350048719e-05, 0.00122586976424697179,
+      3.04180315460180327e-08 * 1. / (1_MeV), 0, -0.000897409671925476033,
+      -6.81046218350048719e-05, 2.75633337878389284e-05,
+      -2.65506639049251932e-07, 1.4268675855279823e-08 * 1. / (1_MeV), 0,
+      5.00768443241615978e-06, 0.00122586976424697179, -2.65506639049251932e-07,
+      2.00353611035097856e-06, -5.77783317368770183e-12 * 1. / (1_MeV), 0,
+      -2.84713002525393994e-07 * 1. / (1_MeV),
+      3.04180315460180327e-08 * 1. / (1_MeV),
+      1.4268675855279823e-08 * 1. / (1_MeV),
+      -5.77783317368770183e-12 * 1. / (1_MeV),
+      1.32142283226777124e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams113 =
+      BoundParameters(gctx, std::move(covMat113), params113, perigeeSurface);
+  tracks.push_back(boundParams113);
+
+  // track 114 :
+  BoundVector params114;
+  params114 << 0.70326077938079834, -23.8514003753662109, 2.19736742973327637,
+      2.66175127029418945, -0.000729386345483362675 * 1. / (1_MeV), 0;
+  Covariance covMat114;
+  covMat114 << 0.0201517790555953979, -0.000402410594205282815,
+      -0.000615109406015380898, 6.20916466189531659e-06,
+      -5.01304650979099997e-07 * 1. / (1_MeV), 0, -0.000402410594205282815,
+      0.106326393783092499, -5.39270699210803652e-06, 0.000656929741407722974,
+      4.16003452981261856e-08 * 1. / (1_MeV), 0, -0.000615109406015380898,
+      -5.39270699210803652e-06, 1.91017334145726636e-05,
+      -3.05136297241337109e-07, 2.46257505980399243e-08 * 1. / (1_MeV), 0,
+      6.20916466189531659e-06, 0.000656929741407722974,
+      -3.05136297241337109e-07, 4.13353836847818457e-06,
+      -2.25280483073948522e-11 * 1. / (1_MeV), 0,
+      -5.01304650979099997e-07 * 1. / (1_MeV),
+      4.16003452981261856e-08 * 1. / (1_MeV),
+      2.46257505980399243e-08 * 1. / (1_MeV),
+      -2.25280483073948522e-11 * 1. / (1_MeV),
+      4.48457743162933298e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams114 =
+      BoundParameters(gctx, std::move(covMat114), params114, perigeeSurface);
+  tracks.push_back(boundParams114);
+
+  // track 115 :
+  BoundVector params115;
+  params115 << 0.671093463897705078, -45.1692886352539062, 1.74538934230804443,
+      0.344533443450927734, -0.000281130109215155244 * 1. / (1_MeV), 0;
+  Covariance covMat115;
+  covMat115 << 0.00903735589236021042, -0.00019873340309471113,
+      -0.000273524033995838783, -2.89533457392990707e-06,
+      -1.61454060310120352e-07 * 1. / (1_MeV), 0, -0.00019873340309471113,
+      0.107433833181858063, 1.17062433953150529e-05, 0.000347414063588650612,
+      -5.60630576356142156e-09 * 1. / (1_MeV), 0, -0.000273524033995838783,
+      1.17062433953150529e-05, 8.43327961774775758e-06, 1.10675918622981839e-07,
+      7.60358813812795812e-09 * 1. / (1_MeV), 0, -2.89533457392990707e-06,
+      0.000347414063588650612, 1.10675918622981839e-07, 1.1579301144593046e-06,
+      3.89686466885357287e-11 * 1. / (1_MeV), 0,
+      -1.61454060310120352e-07 * 1. / (1_MeV),
+      -5.60630576356142156e-09 * 1. / (1_MeV),
+      7.60358813812795812e-09 * 1. / (1_MeV),
+      3.89686466885357287e-11 * 1. / (1_MeV),
+      9.49285094975493848e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams115 =
+      BoundParameters(gctx, std::move(covMat115), params115, perigeeSurface);
+  tracks.push_back(boundParams115);
+
+  // track 116 :
+  BoundVector params116;
+  params116 << -0.513536512851715088, -24.0025615692138672,
+      -1.29378879070281982, 0.68014836311340332,
+      -0.00116809376049786806 * 1. / (1_MeV), 0;
+  Covariance covMat116;
+  covMat116 << 0.0196314919739961624, -0.000964473384199337471,
+      -0.000592159047274326794, -1.01560641560312488e-05,
+      -3.59403968241742458e-07 * 1. / (1_MeV), 0, -0.000964473384199337471,
+      0.0900372341275215149, 4.81210676710760611e-05, 0.000917365400873606292,
+      4.18182893772007853e-09 * 1. / (1_MeV), 0, -0.000592159047274326794,
+      4.81210676710760611e-05, 1.81187115231296048e-05, 5.11456018571083069e-07,
+      1.74822784071129361e-08 * 1. / (1_MeV), 0, -1.01560641560312488e-05,
+      0.000917365400873606292, 5.11456018571083069e-07, 9.76017781795235351e-06,
+      -2.45815925497200098e-12 * 1. / (1_MeV), 0,
+      -3.59403968241742458e-07 * 1. / (1_MeV),
+      4.18182893772007853e-09 * 1. / (1_MeV),
+      1.74822784071129361e-08 * 1. / (1_MeV),
+      -2.45815925497200098e-12 * 1. / (1_MeV),
+      4.33391877940891845e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams116 =
+      BoundParameters(gctx, std::move(covMat116), params116, perigeeSurface);
+  tracks.push_back(boundParams116);
+
+  // track 117 :
+  BoundVector params117;
+  params117 << -0.188389301300048828, -27.492034912109375, -2.0469822883605957,
+      0.402536779642105103, -0.000401498342398554087 * 1. / (1_MeV), 0;
+  Covariance covMat117;
+  covMat117 << 0.0106127634644508362, -0.000530327986901170411,
+      -0.000318114363953226264, -2.58171609717844701e-06,
+      -3.04161855482286476e-07 * 1. / (1_MeV), 0, -0.000530327986901170411,
+      0.0728393122553825378, 2.18031202084567084e-05, 0.000323112379856879315,
+      8.72212302001908086e-09 * 1. / (1_MeV), 0, -0.000318114363953226264,
+      2.18031202084567084e-05, 9.83124391495948657e-06, 1.0660118653808876e-07,
+      1.49552172231130049e-08 * 1. / (1_MeV), 0, -2.58171609717844701e-06,
+      0.000323112379856879315, 1.0660118653808876e-07, 1.46258253153064288e-06,
+      3.10238162026694015e-11 * 1. / (1_MeV), 0,
+      -3.04161855482286476e-07 * 1. / (1_MeV),
+      8.72212302001908086e-09 * 1. / (1_MeV),
+      1.49552172231130049e-08 * 1. / (1_MeV),
+      3.10238162026694015e-11 * 1. / (1_MeV),
+      2.30750710206173437e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams117 =
+      BoundParameters(gctx, std::move(covMat117), params117, perigeeSurface);
+  tracks.push_back(boundParams117);
+
+  // track 118 :
+  BoundVector params118;
+  params118 << -0.0811463147401809692, -27.6623687744140625,
+      0.45338207483291626, 2.77416062355041504,
+      0.000383521459298208356 * 1. / (1_MeV), 0;
+  Covariance covMat118;
+  covMat118 << 0.0120377568528056145, 0.000348936630741464966,
+      -0.000367708072083872627, -4.00268806455590574e-07,
+      -2.44429806871556943e-07 * 1. / (1_MeV), 0, 0.000348936630741464966,
+      0.106920868158340454, 2.02262643355694362e-06, 0.000396612496039519481,
+      -1.29354667260461022e-08 * 1. / (1_MeV), 0, -0.000367708072083872627,
+      2.02262643355694362e-06, 1.14461399789433926e-05, 5.77674609016439322e-08,
+      1.20551713367857255e-08 * 1. / (1_MeV), 0, -4.00268806455590574e-07,
+      0.000396612496039519481, 5.77674609016439322e-08, 1.50108360230660765e-06,
+      -1.71918312121670268e-11 * 1. / (1_MeV), 0,
+      -2.44429806871556943e-07 * 1. / (1_MeV),
+      -1.29354667260461022e-08 * 1. / (1_MeV),
+      1.20551713367857255e-08 * 1. / (1_MeV),
+      -1.71918312121670268e-11 * 1. / (1_MeV),
+      1.72003744580706552e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams118 =
+      BoundParameters(gctx, std::move(covMat118), params118, perigeeSurface);
+  tracks.push_back(boundParams118);
+
+  // track 119 :
+  BoundVector params119;
+  params119 << -0.669821977615356445, -0.254957705736160278,
+      -0.642573356628417969, 0.338302493095397949,
+      -0.000448048056568950415 * 1. / (1_MeV), 0;
+  Covariance covMat119;
+  covMat119 << 0.0216007865965366364, -0.00185881288533683146,
+      -0.000647740560197286076, -4.15704652410560125e-06,
+      -2.75570705855937687e-07 * 1. / (1_MeV), 0, -0.00185881288533683146,
+      0.205522537231445312, 7.6902207402064222e-05, 0.00067089446492805667,
+      2.13544688641597921e-08 * 1. / (1_MeV), 0, -0.000647740560197286076,
+      7.6902207402064222e-05, 1.98106827156152576e-05, 1.96993374819633446e-07,
+      1.39122962799931803e-08 * 1. / (1_MeV), 0, -4.15704652410560125e-06,
+      0.00067089446492805667, 1.96993374819633446e-07, 2.21493996832577977e-06,
+      6.08338264527575119e-12 * 1. / (1_MeV), 0,
+      -2.75570705855937687e-07 * 1. / (1_MeV),
+      2.13544688641597921e-08 * 1. / (1_MeV),
+      1.39122962799931803e-08 * 1. / (1_MeV),
+      6.08338264527575119e-12 * 1. / (1_MeV),
+      1.86805737545370221e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams119 =
+      BoundParameters(gctx, std::move(covMat119), params119, perigeeSurface);
+  tracks.push_back(boundParams119);
+
+  // track 120 :
+  BoundVector params120;
+  params120 << 0.620538651943206787, -5.9463653564453125, 2.88366031646728516,
+      0.806014358997344971, 0.000814548286143690348 * 1. / (1_MeV), 0;
+  Covariance covMat120;
+  covMat120 << 0.00660947803407907486, 0.000148207317841221223,
+      -0.000194191570441951892, 1.81425520658158306e-06,
+      -1.30802501722950138e-07 * 1. / (1_MeV), 0, 0.000148207317841221223,
+      0.0214615482836961746, -8.02621091024865615e-06, 0.000291939065786425093,
+      -3.37860649239220225e-09 * 1. / (1_MeV), 0, -0.000194191570441951892,
+      -8.02621091024865615e-06, 5.84407371206907555e-06,
+      -1.03748135696870454e-07, 6.35917118456449052e-09 * 1. / (1_MeV), 0,
+      1.81425520658158306e-06, 0.000291939065786425093,
+      -1.03748135696870454e-07, 4.28725343226687983e-06,
+      -2.51583629069704591e-11 * 1. / (1_MeV), 0,
+      -1.30802501722950138e-07 * 1. / (1_MeV),
+      -3.37860649239220225e-09 * 1. / (1_MeV),
+      6.35917118456449052e-09 * 1. / (1_MeV),
+      -2.51583629069704591e-11 * 1. / (1_MeV),
+      1.78077538826038051e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams120 =
+      BoundParameters(gctx, std::move(covMat120), params120, perigeeSurface);
+  tracks.push_back(boundParams120);
+
+  // track 121 :
+  BoundVector params121;
+  params121 << 0.628487765789031982, -46.8420448303222656, 2.83293843269348145,
+      0.440805107355117798, 0.00010274051601300016 * 1. / (1_MeV), 0;
+  Covariance covMat121;
+  covMat121 << 0.000842933135572820902, -2.19657301004237121e-05,
+      -2.40593078576417954e-05, -2.61079431395439085e-07,
+      -6.29023439716158914e-09 * 1. / (1_MeV), 0, -2.19657301004237121e-05,
+      0.00974787771701812744, -2.23540359415713673e-08, 4.29750192042335346e-05,
+      -3.28310247664964105e-10 * 1. / (1_MeV), 0, -2.40593078576417954e-05,
+      -2.23540359415713673e-08, 7.04093849890341517e-07,
+      5.44971636290248205e-09, 3.05175081762309306e-10 * 1. / (1_MeV), 0,
+      -2.61079431395439085e-07, 4.29750192042335346e-05,
+      5.44971636290248205e-09, 2.0320584326327662e-07,
+      1.64157138196977762e-13 * 1. / (1_MeV), 0,
+      -6.29023439716158914e-09 * 1. / (1_MeV),
+      -3.28310247664964105e-10 * 1. / (1_MeV),
+      3.05175081762309306e-10 * 1. / (1_MeV),
+      1.64157138196977762e-13 * 1. / (1_MeV),
+      5.16425357338645696e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams121 =
+      BoundParameters(gctx, std::move(covMat121), params121, perigeeSurface);
+  tracks.push_back(boundParams121);
+
+  // track 122 :
+  BoundVector params122;
+  params122 << -0.812381505966186523, -28.9338283538818359, -1.2193833589553833,
+      1.04633200168609619, 0.00115260039456188679 * 1. / (1_MeV), 0;
+  Covariance covMat122;
+  covMat122 << 0.00886439252644777298, -7.98301718682701986e-05,
+      -0.000261729182772038702, 2.80699128527500705e-06,
+      -1.19181091476079831e-07 * 1. / (1_MeV), 0, -7.98301718682701986e-05,
+      0.0244551245123147964, -1.85192755523473285e-06, 0.000485515751149120391,
+      2.3685986667229676e-09 * 1. / (1_MeV), 0, -0.000261729182772038702,
+      -1.85192755523473285e-06, 7.82700044510420412e-06,
+      -1.65953545175140125e-07, 5.47590882437587651e-09 * 1. / (1_MeV), 0,
+      2.80699128527500705e-06, 0.000485515751149120391,
+      -1.65953545175140125e-07, 1.0220603144261986e-05,
+      -1.07937619402598992e-11 * 1. / (1_MeV), 0,
+      -1.19181091476079831e-07 * 1. / (1_MeV),
+      2.3685986667229676e-09 * 1. / (1_MeV),
+      5.47590882437587651e-09 * 1. / (1_MeV),
+      -1.07937619402598992e-11 * 1. / (1_MeV),
+      1.73649483681259653e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams122 =
+      BoundParameters(gctx, std::move(covMat122), params122, perigeeSurface);
+  tracks.push_back(boundParams122);
+
+  // track 123 :
+  BoundVector params123;
+  params123 << 0.674202203750610352, -46.3594818115234375, 2.85884332656860352,
+      0.887206554412841797, -0.000505877542309463024 * 1. / (1_MeV), 0;
+  Covariance covMat123;
+  covMat123 << 0.00251318048685789108, -1.66645647325415036e-06,
+      -6.98672509700519375e-05, -7.12881638668814119e-07,
+      -6.71595898982830382e-08 * 1. / (1_MeV), 0, -1.66645647325415036e-06,
+      0.00859435927122831345, 5.71233764557248797e-07, 0.000121854224792618618,
+      1.32173469014469017e-09 * 1. / (1_MeV), 0, -6.98672509700519375e-05,
+      5.71233764557248797e-07, 2.02263481696718372e-06, 3.12296641803006321e-08,
+      3.09126253015111042e-09 * 1. / (1_MeV), 0, -7.12881638668814119e-07,
+      0.000121854224792618618, 3.12296641803006321e-08, 1.98942507267929614e-06,
+      9.00985395948335217e-11 * 1. / (1_MeV), 0,
+      -6.71595898982830382e-08 * 1. / (1_MeV),
+      1.32173469014469017e-09 * 1. / (1_MeV),
+      3.09126253015111042e-09 * 1. / (1_MeV),
+      9.00985395948335217e-11 * 1. / (1_MeV),
+      8.96472895917099777e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams123 =
+      BoundParameters(gctx, std::move(covMat123), params123, perigeeSurface);
+  tracks.push_back(boundParams123);
+
+  // track 124 :
+  BoundVector params124;
+  params124 << -0.317187309265136719, -5.00441408157348633,
+      0.162307113409042358, 0.750772595405578613,
+      -0.000692651956342160702 * 1. / (1_MeV), 0;
+  Covariance covMat124;
+  covMat124 << 0.00589033449068665504, -0.000147228859748553363,
+      -0.000171248391294949903, -1.76774655708203412e-06,
+      -1.07121129211567312e-07 * 1. / (1_MeV), 0, -0.000147228859748553363,
+      0.0193875245749950409, 6.6144993330992646e-06, 0.000238616816721432543,
+      1.73743427737471889e-09 * 1. / (1_MeV), 0, -0.000171248391294949903,
+      6.6144993330992646e-06, 5.10799418407259509e-06, 8.27169602099734583e-08,
+      5.19150014241903916e-09 * 1. / (1_MeV), 0, -1.76774655708203412e-06,
+      0.000238616816721432543, 8.27169602099734583e-08, 3.09604706671962049e-06,
+      1.1663553056713431e-11 * 1. / (1_MeV), 0,
+      -1.07121129211567312e-07 * 1. / (1_MeV),
+      1.73743427737471889e-09 * 1. / (1_MeV),
+      5.19150014241903916e-09 * 1. / (1_MeV),
+      1.1663553056713431e-11 * 1. / (1_MeV),
+      1.38518113645957897e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams124 =
+      BoundParameters(gctx, std::move(covMat124), params124, perigeeSurface);
+  tracks.push_back(boundParams124);
+
+  // track 125 :
+  BoundVector params125;
+  params125 << -0.367212682962417603, -26.4488010406494141,
+      -0.589624702930450439, 0.890817821025848389,
+      -0.00130973628256469965 * 1. / (1_MeV), 0;
+  Covariance covMat125;
+  covMat125 << 0.0136615298688411713, -0.000553210438098500888,
+      -0.000408959420512909242, -9.54127328493114892e-06,
+      -2.28585933325679961e-07 * 1. / (1_MeV), 0, -0.000553210438098500888,
+      0.0606655515730381012, 2.85290059337265401e-05, 0.000919541054049329964,
+      6.41373777463503296e-10 * 1. / (1_MeV), 0, -0.000408959420512909242,
+      2.85290059337265401e-05, 1.2425651220837608e-05, 4.81781448104062685e-07,
+      1.15319447682158026e-08 * 1. / (1_MeV), 0, -9.54127328493114892e-06,
+      0.000919541054049329964, 4.81781448104062685e-07, 1.48983235703781247e-05,
+      -4.6401369967705386e-12 * 1. / (1_MeV), 0,
+      -2.28585933325679961e-07 * 1. / (1_MeV),
+      6.41373777463503296e-10 * 1. / (1_MeV),
+      1.15319447682158026e-08 * 1. / (1_MeV),
+      -4.6401369967705386e-12 * 1. / (1_MeV),
+      3.61465746223643691e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams125 =
+      BoundParameters(gctx, std::move(covMat125), params125, perigeeSurface);
+  tracks.push_back(boundParams125);
+
+  // track 126 :
+  BoundVector params126;
+  params126 << -0.819772541522979736, -15.088465690612793, -1.57550454139709473,
+      2.87169027328491211, -0.000316481309710070491 * 1. / (1_MeV), 0;
+  Covariance covMat126;
+  covMat126 << 0.020475972443819046, 0.00244909382101079955,
+      -0.000612602284994073114, 2.84735667237426659e-06,
+      -1.18856619171178898e-07 * 1. / (1_MeV), 0, 0.00244909382101079955,
+      0.285471856594085693, -9.50848052190165181e-05, 0.00060520112781335168,
+      -1.42274967363324924e-08 * 1. / (1_MeV), 0, -0.000612602284994073114,
+      -9.50848052190165181e-05, 1.86471988854464144e-05,
+      -1.33140486250698117e-07, 6.17048734091374837e-09 * 1. / (1_MeV), 0,
+      2.84735667237426659e-06, 0.00060520112781335168, -1.33140486250698117e-07,
+      1.2966377198608825e-06, 1.20738678057781713e-12 * 1. / (1_MeV), 0,
+      -1.18856619171178898e-07 * 1. / (1_MeV),
+      -1.42274967363324924e-08 * 1. / (1_MeV),
+      6.17048734091374837e-09 * 1. / (1_MeV),
+      1.20738678057781713e-12 * 1. / (1_MeV),
+      6.87515253061654619e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams126 =
+      BoundParameters(gctx, std::move(covMat126), params126, perigeeSurface);
+  tracks.push_back(boundParams126);
+
+  // track 127 :
+  BoundVector params127;
+  params127 << -0.318770557641983032, -24.7678050994873047,
+      0.258936554193496704, 0.221435293555259705,
+      0.000250038632657378912 * 1. / (1_MeV), 0;
+  Covariance covMat127;
+  covMat127 << 0.0237364936619997025, -0.00216027412516154932,
+      -0.000714136299484843372, 3.91136153798043594e-07,
+      -1.92060015221202961e-07 * 1. / (1_MeV), 0, -0.00216027412516154932,
+      0.474111497402191162, 2.45504002711651886e-05, 0.000683401475519821908,
+      2.31633021184019983e-08 * 1. / (1_MeV), 0, -0.000714136299484843372,
+      2.45504002711651886e-05, 2.19113735511200503e-05,
+      -6.74041726618829811e-08, 9.78682020756434252e-09 * 1. / (1_MeV), 0,
+      3.91136153798043594e-07, 0.000683401475519821908,
+      -6.74041726618829811e-08, 9.95008008430886548e-07,
+      2.37236751652554644e-12 * 1. / (1_MeV), 0,
+      -1.92060015221202961e-07 * 1. / (1_MeV),
+      2.31633021184019983e-08 * 1. / (1_MeV),
+      9.78682020756434252e-09 * 1. / (1_MeV),
+      2.37236751652554644e-12 * 1. / (1_MeV),
+      8.74325264965669646e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams127 =
+      BoundParameters(gctx, std::move(covMat127), params127, perigeeSurface);
+  tracks.push_back(boundParams127);
+
+  // track 128 :
+  BoundVector params128;
+  params128 << -0.786545097827911377, -38.7401618957519531,
+      -0.845708072185516357, 0.685007095336914062,
+      -0.00115627096965909004 * 1. / (1_MeV), 0;
+  Covariance covMat128;
+  covMat128 << 0.0192839577794075012, -0.000884148373743458998,
+      -0.000582462336183784323, -8.08110064280186493e-06,
+      -2.82867484656328478e-07 * 1. / (1_MeV), 0, -0.000884148373743458998,
+      0.0635840222239494324, 4.14378320186397384e-05, 0.000713555828392625161,
+      1.15057697948470685e-08 * 1. / (1_MeV), 0, -0.000582462336183784323,
+      4.14378320186397384e-05, 1.78008613147540018e-05, 4.15133191686953799e-07,
+      1.37170909103508374e-08 * 1. / (1_MeV), 0, -8.08110064280186493e-06,
+      0.000713555828392625161, 4.15133191686953799e-07, 8.22206584416562691e-06,
+      3.36288899333749929e-11 * 1. / (1_MeV), 0,
+      -2.82867484656328478e-07 * 1. / (1_MeV),
+      1.15057697948470685e-08 * 1. / (1_MeV),
+      1.37170909103508374e-08 * 1. / (1_MeV),
+      3.36288899333749929e-11 * 1. / (1_MeV),
+      3.38668010302356493e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams128 =
+      BoundParameters(gctx, std::move(covMat128), params128, perigeeSurface);
+  tracks.push_back(boundParams128);
+
+  // track 129 :
+  BoundVector params129;
+  params129 << 0.486697107553482056, -27.5921802520751953, 1.46391701698303223,
+      2.71947717666625977, -0.000425876642111688852 * 1. / (1_MeV), 0;
+  Covariance covMat129;
+  covMat129 << 0.0104358252137899399, -0.000194071380788289307,
+      -0.000315099921452716538, 1.76392275881344802e-06,
+      -1.10626700413367959e-07 * 1. / (1_MeV), 0, -0.000194071380788289307,
+      0.0726201385259628296, -1.22225312305688994e-06, 0.000354468038776242019,
+      1.07847367917163246e-08 * 1. / (1_MeV), 0, -0.000315099921452716538,
+      -1.22225312305688994e-06, 9.63851289270678535e-06,
+      -9.06071612650389521e-08, 5.46013101705028866e-09 * 1. / (1_MeV), 0,
+      1.76392275881344802e-06, 0.000354468038776242019,
+      -9.06071612650389521e-08, 1.75927425516420044e-06,
+      8.12217710906210286e-12 * 1. / (1_MeV), 0,
+      -1.10626700413367959e-07 * 1. / (1_MeV),
+      1.07847367917163246e-08 * 1. / (1_MeV),
+      5.46013101705028866e-09 * 1. / (1_MeV),
+      8.12217710906210286e-12 * 1. / (1_MeV),
+      8.87762224843768877e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams129 =
+      BoundParameters(gctx, std::move(covMat129), params129, perigeeSurface);
+  tracks.push_back(boundParams129);
+
+  // track 130 :
+  BoundVector params130;
+  params130 << -0.617856025695800781, -0.871593713760375977,
+      -0.820657730102539062, 1.98759174346923828,
+      0.00110533414408564568 * 1. / (1_MeV), 0;
+  Covariance covMat130;
+  covMat130 << 0.00552858132869005203, -6.21963191966173515e-06,
+      -0.000165318571599927403, -1.87050290953511793e-06,
+      -9.12087055682573263e-08 * 1. / (1_MeV), 0, -6.21963191966173515e-06,
+      0.0224491767585277557, 2.49900583889646317e-06, 0.000406727201832187205,
+      -1.6111436767727037e-09 * 1. / (1_MeV), 0, -0.000165318571599927403,
+      2.49900583889646317e-06, 5.011198027204955e-06, 1.03599533976687726e-07,
+      4.3871518926068891e-09 * 1. / (1_MeV), 0, -1.87050290953511793e-06,
+      0.000406727201832187205, 1.03599533976687726e-07, 8.68987262947484851e-06,
+      1.25136088613115525e-11 * 1. / (1_MeV), 0,
+      -9.12087055682573263e-08 * 1. / (1_MeV),
+      -1.6111436767727037e-09 * 1. / (1_MeV),
+      4.3871518926068891e-09 * 1. / (1_MeV),
+      1.25136088613115525e-11 * 1. / (1_MeV),
+      1.55834969928214662e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams130 =
+      BoundParameters(gctx, std::move(covMat130), params130, perigeeSurface);
+  tracks.push_back(boundParams130);
+
+  // track 131 :
+  BoundVector params131;
+  params131 << -0.317273795604705811, -39.7836227416992188,
+      0.271088778972625732, 2.60198879241943359,
+      -0.000791704689618200064 * 1. / (1_MeV), 0;
+  Covariance covMat131;
+  covMat131 << 0.0173647217452526093, 0.000699109712679081823,
+      -0.000517395274305629347, 5.83878339750726826e-06,
+      -2.16819932799887328e-07 * 1. / (1_MeV), 0, 0.000699109712679081823,
+      0.0743361711502075195, -3.22919950885157238e-05, 0.000565554144244462416,
+      -2.84215790760252208e-09 * 1. / (1_MeV), 0, -0.000517395274305629347,
+      -3.22919950885157238e-05, 1.57065533130662516e-05,
+      -2.69347200961308565e-07, 1.07852728031145877e-08 * 1. / (1_MeV), 0,
+      5.83878339750726826e-06, 0.000565554144244462416,
+      -2.69347200961308565e-07, 4.39661971540772356e-06,
+      -7.1469095279936026e-12 * 1. / (1_MeV), 0,
+      -2.16819932799887328e-07 * 1. / (1_MeV),
+      -2.84215790760252208e-09 * 1. / (1_MeV),
+      1.07852728031145877e-08 * 1. / (1_MeV),
+      -7.1469095279936026e-12 * 1. / (1_MeV),
+      2.20003334994167687e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams131 =
+      BoundParameters(gctx, std::move(covMat131), params131, perigeeSurface);
+  tracks.push_back(boundParams131);
+
+  // track 132 :
+  BoundVector params132;
+  params132 << -0.176747366786003113, -6.18134498596191406,
+      -2.44022130966186523, 1.06020462512969971,
+      -0.00166206969879567623 * 1. / (1_MeV), 0;
+  Covariance covMat132;
+  covMat132 << 0.0163360219448804855, -0.0003172835243235103,
+      -0.000474475361325176945, -8.23511726091334258e-06,
+      -2.30416042777669323e-07 * 1. / (1_MeV), 0, -0.0003172835243235103,
+      0.0361283980309963226, 1.62689442711704658e-05, 0.000735986183239389154,
+      -2.55052024057200266e-09 * 1. / (1_MeV), 0, -0.000474475361325176945,
+      1.62689442711704658e-05, 1.40814063342986628e-05, 4.00503665767196095e-07,
+      1.13634723345292126e-08 * 1. / (1_MeV), 0, -8.23511726091334258e-06,
+      0.000735986183239389154, 4.00503665767196095e-07, 1.59251703735208139e-05,
+      -4.93303581762030017e-11 * 1. / (1_MeV), 0,
+      -2.30416042777669323e-07 * 1. / (1_MeV),
+      -2.55052024057200266e-09 * 1. / (1_MeV),
+      1.13634723345292126e-08 * 1. / (1_MeV),
+      -4.93303581762030017e-11 * 1. / (1_MeV),
+      3.97582966549236971e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams132 =
+      BoundParameters(gctx, std::move(covMat132), params132, perigeeSurface);
+  tracks.push_back(boundParams132);
+
+  // track 133 :
+  BoundVector params133;
+  params133 << 0.252984225749969482, -0.155150562524795532,
+      -2.66754698753356934, 2.31749868392944336,
+      0.000917813042178750038 * 1. / (1_MeV), 0;
+  Covariance covMat133;
+  covMat133 << 0.00944171752780675888, 0.000145823562828363914,
+      -0.000271052957960221707, -4.55321772559130365e-07,
+      -2.43926736564194306e-07 * 1. / (1_MeV), 0, 0.000145823562828363914,
+      0.0299511272460222244, 3.38575145014588503e-06, 0.000406530300163432086,
+      -3.0856143118849151e-09 * 1. / (1_MeV), 0, -0.000271052957960221707,
+      3.38575145014588503e-06, 8.01670285000000149e-06, 1.05147518352289746e-07,
+      1.1170956971681221e-08 * 1. / (1_MeV), 0, -4.55321772559130365e-07,
+      0.000406530300163432086, 1.05147518352289746e-07, 5.94885204918682575e-06,
+      -1.05152517914159529e-11 * 1. / (1_MeV), 0,
+      -2.43926736564194306e-07 * 1. / (1_MeV),
+      -3.0856143118849151e-09 * 1. / (1_MeV),
+      1.1170956971681221e-08 * 1. / (1_MeV),
+      -1.05152517914159529e-11 * 1. / (1_MeV),
+      3.04403169337774671e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams133 =
+      BoundParameters(gctx, std::move(covMat133), params133, perigeeSurface);
+  tracks.push_back(boundParams133);
+
+  // track 134 :
+  BoundVector params134;
+  params134 << 0.261232942342758179, -4.98270845413208008, -2.7913355827331543,
+      2.3903357982635498, -0.000602899584919214249 * 1. / (1_MeV), 0;
+  Covariance covMat134;
+  covMat134 << 0.00512111512944102287, 0.000151096985693622513,
+      -0.000145316183125153919, 1.87182314845306937e-06,
+      -1.11018028044376921e-07 * 1. / (1_MeV), 0, 0.000151096985693622513,
+      0.0171234942972660065, -4.80042332048881649e-06, 0.000210849209555024551,
+      1.07928525134701817e-09 * 1. / (1_MeV), 0, -0.000145316183125153919,
+      -4.80042332048881649e-06, 4.26421911470242776e-06,
+      -6.99455919823715623e-08, 5.18060114302286267e-09 * 1. / (1_MeV), 0,
+      1.87182314845306937e-06, 0.000210849209555024551,
+      -6.99455919823715623e-08, 2.78515085483377334e-06,
+      2.16936360639539862e-12 * 1. / (1_MeV), 0,
+      -1.11018028044376921e-07 * 1. / (1_MeV),
+      1.07928525134701817e-09 * 1. / (1_MeV),
+      5.18060114302286267e-09 * 1. / (1_MeV),
+      2.16936360639539862e-12 * 1. / (1_MeV),
+      1.35624275698909003e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams134 =
+      BoundParameters(gctx, std::move(covMat134), params134, perigeeSurface);
+  tracks.push_back(boundParams134);
+
+  // track 135 :
+  BoundVector params135;
+  params135 << 0.485514432191848755, -45.5758934020996094, 1.94401109218597412,
+      0.505930542945861816, -0.000614787102676928043 * 1. / (1_MeV), 0;
+  Covariance covMat135;
+  covMat135 << 0.0123122958466410637, 0.000103715887417680144,
+      -0.000367851729220063496, -3.31341741262174798e-06,
+      -1.40577584093730895e-07 * 1. / (1_MeV), 0, 0.000103715887417680144,
+      0.0622931979596614838, 5.81297839975361217e-06, 0.000418717043270157351,
+      -7.78615764923604825e-09 * 1. / (1_MeV), 0, -0.000367851729220063496,
+      5.81297839975361217e-06, 1.11767485577729531e-05, 1.62622397510481766e-07,
+      7.02699563203032516e-09 * 1. / (1_MeV), 0, -3.31341741262174798e-06,
+      0.000418717043270157351, 1.62622397510481766e-07, 2.88416777038946748e-06,
+      6.04537737743006593e-12 * 1. / (1_MeV), 0,
+      -1.40577584093730895e-07 * 1. / (1_MeV),
+      -7.78615764923604825e-09 * 1. / (1_MeV),
+      7.02699563203032516e-09 * 1. / (1_MeV),
+      6.04537737743006593e-12 * 1. / (1_MeV),
+      1.35220848407335836e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams135 =
+      BoundParameters(gctx, std::move(covMat135), params135, perigeeSurface);
+  tracks.push_back(boundParams135);
+
+  // track 136 :
+  BoundVector params136;
+  params136 << -0.670421361923217773, -23.7245407104492188,
+      -0.64520871639251709, 1.0696331262588501,
+      -0.00114500056952238083 * 1. / (1_MeV), 0;
+  Covariance covMat136;
+  covMat136 << 0.00867419224232435226, -0.000238439934654708106,
+      -0.000247132726740291432, -3.75722689616700562e-06,
+      -9.94438198214882919e-08 * 1. / (1_MeV), 0, -0.000238439934654708106,
+      0.0179926082491874695, 8.82013517111327567e-06, 0.000362395650514492373,
+      2.75455883099119192e-09 * 1. / (1_MeV), 0, -0.000247132726740291432,
+      8.82013517111327567e-06, 7.21778906154213473e-06, 1.5386779713221143e-07,
+      4.75511246715568753e-09 * 1. / (1_MeV), 0, -3.75722689616700562e-06,
+      0.000362395650514492373, 1.5386779713221143e-07, 7.68224344938062131e-06,
+      2.56252285968062862e-11 * 1. / (1_MeV), 0,
+      -9.94438198214882919e-08 * 1. / (1_MeV),
+      2.75455883099119192e-09 * 1. / (1_MeV),
+      4.75511246715568753e-09 * 1. / (1_MeV),
+      2.56252285968062862e-11 * 1. / (1_MeV),
+      1.62369812040097372e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams136 =
+      BoundParameters(gctx, std::move(covMat136), params136, perigeeSurface);
+  tracks.push_back(boundParams136);
+
+  // track 137 :
+  BoundVector params137;
+  params137 << -0.115538112819194794, 1.36448657512664795, -1.94587123394012451,
+      2.86434054374694824, 0.000385540741262957454 * 1. / (1_MeV), 0;
+  Covariance covMat137;
+  covMat137 << 0.0277297049760818481, 0.00109366535881475391,
+      -0.000837399106664793598, -1.86861717914986654e-06,
+      -3.02391750465843443e-07 * 1. / (1_MeV), 0, 0.00109366535881475391,
+      0.36750379204750061, 1.37618244604514028e-05, 0.000820460451267350272,
+      -2.09467237202718329e-08 * 1. / (1_MeV), 0, -0.000837399106664793598,
+      1.37618244604514028e-05, 2.5784886020119302e-05, 1.55912763303336569e-07,
+      1.51901283557160921e-08 * 1. / (1_MeV), 0, -1.86861717914986654e-06,
+      0.000820460451267350272, 1.55912763303336569e-07, 1.85243084160902072e-06,
+      -5.89799137780591859e-12 * 1. / (1_MeV), 0,
+      -3.02391750465843443e-07 * 1. / (1_MeV),
+      -2.09467237202718329e-08 * 1. / (1_MeV),
+      1.51901283557160921e-08 * 1. / (1_MeV),
+      -5.89799137780591859e-12 * 1. / (1_MeV),
+      1.66225588849044925e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams137 =
+      BoundParameters(gctx, std::move(covMat137), params137, perigeeSurface);
+  tracks.push_back(boundParams137);
+
+  // track 138 :
+  BoundVector params138;
+  params138 << -0.437855541706085205, 0.00233042589388787746,
+      -1.61236178874969482, 2.66223287582397461,
+      -0.00048968649934977293 * 1. / (1_MeV), 0;
+  Covariance covMat138;
+  covMat138 << 0.0102480929344892502, 0.000472131789165782347,
+      -0.00030005184152762706, 2.30777092355429649e-06,
+      -8.23733339483005762e-08 * 1. / (1_MeV), 0, 0.000472131789165782347,
+      0.0548162646591663361, -1.93984184037375696e-05, 0.0003337112441505619,
+      -3.15116273492404661e-09 * 1. / (1_MeV), 0, -0.00030005184152762706,
+      -1.93984184037375696e-05, 8.96569144970271736e-06,
+      -1.04404311461369532e-07, 4.16595730488154716e-09 * 1. / (1_MeV), 0,
+      2.30777092355429649e-06, 0.0003337112441505619, -1.04404311461369532e-07,
+      2.07969515031436458e-06, -4.21540260659907555e-12 * 1. / (1_MeV), 0,
+      -8.23733339483005762e-08 * 1. / (1_MeV),
+      -3.15116273492404661e-09 * 1. / (1_MeV),
+      4.16595730488154716e-09 * 1. / (1_MeV),
+      -4.21540260659907555e-12 * 1. / (1_MeV),
+      7.92930027193605724e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams138 =
+      BoundParameters(gctx, std::move(covMat138), params138, perigeeSurface);
+  tracks.push_back(boundParams138);
+
+  // track 139 :
+  BoundVector params139;
+  params139 << -0.508741080760955811, -46.586151123046875,
+      -0.155602023005485535, 2.23871588706970215,
+      0.00108059775084257126 * 1. / (1_MeV), 0;
+  Covariance covMat139;
+  covMat139 << 0.0092028668150305748, 2.68137590592830111e-06,
+      -0.000267328437856131614, -4.45051587392828996e-06,
+      -1.7870806347180625e-07 * 1. / (1_MeV), 0, 2.68137590592830111e-06,
+      0.0370477475225925446, 7.6281684549949988e-06, 0.000581077286055830654,
+      -4.87564726794623446e-09 * 1. / (1_MeV), 0, -0.000267328437856131614,
+      7.6281684549949988e-06, 7.97686789155704901e-06, 2.52891502516708447e-07,
+      8.98278177902545255e-09 * 1. / (1_MeV), 0, -4.45051587392828996e-06,
+      0.000581077286055830654, 2.52891502516708447e-07, 9.77692525339080021e-06,
+      1.52214832118640255e-11 * 1. / (1_MeV), 0,
+      -1.7870806347180625e-07 * 1. / (1_MeV),
+      -4.87564726794623446e-09 * 1. / (1_MeV),
+      8.98278177902545255e-09 * 1. / (1_MeV),
+      1.52214832118640255e-11 * 1. / (1_MeV),
+      2.85946016864713215e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams139 =
+      BoundParameters(gctx, std::move(covMat139), params139, perigeeSurface);
+  tracks.push_back(boundParams139);
+
+  // track 140 :
+  BoundVector params140;
+  params140 << -0.0287109911441802979, -46.0042991638183594,
+      -2.35494875907897949, 1.89670753479003906,
+      -0.00176577572710812092 * 1. / (1_MeV), 0;
+  Covariance covMat140;
+  covMat140 << 0.0144642842933535576, 0.000202304881255863523,
+      -0.0004315195269340391, 5.3491723128578935e-06,
+      -2.30140530552361737e-07 * 1. / (1_MeV), 0, 0.000202304881255863523,
+      0.0459608733654022217, -1.13086865182124149e-05, 0.000878128453669932505,
+      -5.83245686148190731e-10 * 1. / (1_MeV), 0, -0.0004315195269340391,
+      -1.13086865182124149e-05, 1.30631951833493076e-05,
+      -2.77542364129523601e-07, 1.1015992963213548e-08 * 1. / (1_MeV), 0,
+      5.3491723128578935e-06, 0.000878128453669932505, -2.77542364129523601e-07,
+      1.93870200746459886e-05, 1.69476858439270149e-11 * 1. / (1_MeV), 0,
+      -2.30140530552361737e-07 * 1. / (1_MeV),
+      -5.83245686148190731e-10 * 1. / (1_MeV),
+      1.1015992963213548e-08 * 1. / (1_MeV),
+      1.69476858439270149e-11 * 1. / (1_MeV),
+      3.93277660437618692e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams140 =
+      BoundParameters(gctx, std::move(covMat140), params140, perigeeSurface);
+  tracks.push_back(boundParams140);
+
+  // track 141 :
+  BoundVector params141;
+  params141 << -0.324331343173980713, -23.5119915008544922,
+      -1.97980344295501709, 1.80859279632568359,
+      0.00151402072515338659 * 1. / (1_MeV), 0;
+  Covariance covMat141;
+  covMat141 << 0.0087733948603272438, -9.15304093536118931e-05,
+      -0.000263482306437119978, -4.30371014091713246e-06,
+      -1.27371578273573737e-07 * 1. / (1_MeV), 0, -9.15304093536118931e-05,
+      0.0360054671764373779, 5.80982901356528686e-06, 0.00079117892231876717,
+      -1.84955003459008438e-09 * 1. / (1_MeV), 0, -0.000263482306437119978,
+      5.80982901356528686e-06, 8.00929956312756985e-06, 2.04894742385078515e-07,
+      6.42585697371379892e-09 * 1. / (1_MeV), 0, -4.30371014091713246e-06,
+      0.00079117892231876717, 2.04894742385078515e-07, 1.9523367882356979e-05,
+      -2.99674425730772401e-11 * 1. / (1_MeV), 0,
+      -1.27371578273573737e-07 * 1. / (1_MeV),
+      -1.84955003459008438e-09 * 1. / (1_MeV),
+      6.42585697371379892e-09 * 1. / (1_MeV),
+      -2.99674425730772401e-11 * 1. / (1_MeV),
+      2.4992743985485788e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams141 =
+      BoundParameters(gctx, std::move(covMat141), params141, perigeeSurface);
+  tracks.push_back(boundParams141);
+
+  // track 142 :
+  BoundVector params142;
+  params142 << 0.833708107471466064, -26.5761394500732422, 2.42632651329040527,
+      0.695800244808197021, -0.00123036885634064674 * 1. / (1_MeV), 0;
+  Covariance covMat142;
+  covMat142 << 0.0211165659129619598, 0.000359701005864806447,
+      -0.000640851902958058375, -9.11472752482565601e-06,
+      -3.61128702466976842e-07 * 1. / (1_MeV), 0, 0.000359701005864806447,
+      0.0739856362342834473, 8.7222025530136249e-06, 0.000880846867037469831,
+      -2.53787934713242592e-08 * 1. / (1_MeV), 0, -0.000640851902958058375,
+      8.7222025530136249e-06, 1.96944329218240455e-05, 5.19825459711244045e-07,
+      1.80691074173165322e-08 * 1. / (1_MeV), 0, -9.11472752482565601e-06,
+      0.000880846867037469831, 5.19825459711244045e-07, 1.07980968095944263e-05,
+      -8.35165165596293098e-12 * 1. / (1_MeV), 0,
+      -3.61128702466976842e-07 * 1. / (1_MeV),
+      -2.53787934713242592e-08 * 1. / (1_MeV),
+      1.80691074173165322e-08 * 1. / (1_MeV),
+      -8.35165165596293098e-12 * 1. / (1_MeV),
+      4.57582055579663916e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams142 =
+      BoundParameters(gctx, std::move(covMat142), params142, perigeeSurface);
+  tracks.push_back(boundParams142);
+
+  // track 143 :
+  BoundVector params143;
+  params143 << 0.431655138731002808, -29.9960479736328125, 3.04886436462402344,
+      0.219654783606529236, -0.000162235795869491994 * 1. / (1_MeV), 0;
+  Covariance covMat143;
+  covMat143 << 0.0106745027005672455, -8.84194609194169812e-05,
+      -0.000323117334005453873, -1.40461092014443657e-06,
+      -7.26826880107808198e-08 * 1. / (1_MeV), 0, -8.84194609194169812e-05,
+      0.237027347087860107, 1.1001073976894211e-05, 0.000332182033533801643,
+      -6.39605428797278291e-09 * 1. / (1_MeV), 0, -0.000323117334005453873,
+      1.1001073976894211e-05, 9.92172226688126102e-06, 5.57033782439724886e-08,
+      3.63950477953687594e-09 * 1. / (1_MeV), 0, -1.40461092014443657e-06,
+      0.000332182033533801643, 5.57033782439724886e-08, 4.7147932491498068e-07,
+      3.22132744873936636e-12 * 1. / (1_MeV), 0,
+      -7.26826880107808198e-08 * 1. / (1_MeV),
+      -6.39605428797278291e-09 * 1. / (1_MeV),
+      3.63950477953687594e-09 * 1. / (1_MeV),
+      3.22132744873936636e-12 * 1. / (1_MeV),
+      3.18471672644538017e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams143 =
+      BoundParameters(gctx, std::move(covMat143), params143, perigeeSurface);
+  tracks.push_back(boundParams143);
+
+  // track 144 :
+  BoundVector params144;
+  params144 << 0.453293651342391968, -3.70734310150146484, 1.55869936943054199,
+      0.256132364273071289, 0.000176838657353073359 * 1. / (1_MeV), 0;
+  Covariance covMat144;
+  covMat144 << 0.00827712379395961761, 2.30498411629412509e-05,
+      -0.000244603197258337732, -1.09126589030407755e-07,
+      -1.23444322806264544e-07 * 1. / (1_MeV), 0, 2.30498411629412509e-05,
+      0.129736632108688354, -1.08938113172420931e-05, 0.00024017541022616651,
+      -4.9073936291752883e-09 * 1. / (1_MeV), 0, -0.000244603197258337732,
+      -1.08938113172420931e-05, 7.46843306842492893e-06,
+      -1.2793133595916256e-08, 6.20080490265058224e-09 * 1. / (1_MeV), 0,
+      -1.09126589030407755e-07, 0.00024017541022616651, -1.2793133595916256e-08,
+      4.53893193252952187e-07, 4.19473349424168581e-12 * 1. / (1_MeV), 0,
+      -1.23444322806264544e-07 * 1. / (1_MeV),
+      -4.9073936291752883e-09 * 1. / (1_MeV),
+      6.20080490265058224e-09 * 1. / (1_MeV),
+      4.19473349424168581e-12 * 1. / (1_MeV),
+      6.42161740449509466e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams144 =
+      BoundParameters(gctx, std::move(covMat144), params144, perigeeSurface);
+  tracks.push_back(boundParams144);
+
+  // track 145 :
+  BoundVector params145;
+  params145 << -0.061490967869758606, -26.7054595947265625,
+      -2.24733877182006836, 0.956555545330047607,
+      0.00144492473918944597 * 1. / (1_MeV), 0;
+  Covariance covMat145;
+  covMat145 << 0.0162842385470867157, -0.000263099496401078266,
+      -0.00047392584055408227, 9.13166470635725779e-07,
+      -2.48568574213736665e-07 * 1. / (1_MeV), 0, -0.000263099496401078266,
+      0.0405553430318832397, -4.6234755882358841e-06, 0.000706847528783378985,
+      3.8766189110419867e-09 * 1. / (1_MeV), 0, -0.00047392584055408227,
+      -4.6234755882358841e-06, 1.40937036121613346e-05, -2.3073629352790705e-07,
+      1.21477695022017926e-08 * 1. / (1_MeV), 0, 9.13166470635725779e-07,
+      0.000706847528783378985, -2.3073629352790705e-07, 1.28429355754633434e-05,
+      8.96597163070042405e-12 * 1. / (1_MeV), 0,
+      -2.48568574213736665e-07 * 1. / (1_MeV),
+      3.8766189110419867e-09 * 1. / (1_MeV),
+      1.21477695022017926e-08 * 1. / (1_MeV),
+      8.96597163070042405e-12 * 1. / (1_MeV),
+      3.91443821801118474e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams145 =
+      BoundParameters(gctx, std::move(covMat145), params145, perigeeSurface);
+  tracks.push_back(boundParams145);
+
+  // track 146 :
+  BoundVector params146;
+  params146 << 0.763872087001800537, -38.5857467651367188, 2.27715539932250977,
+      1.21252071857452393, -0.00143153721000999212 * 1. / (1_MeV), 0;
+  Covariance covMat146;
+  covMat146 << 0.00959093961864709854, -5.95333196772062091e-05,
+      -0.000286590504535243261, -3.89848736920619265e-06,
+      -1.27862245568167995e-07 * 1. / (1_MeV), 0, -5.95333196772062091e-05,
+      0.0381334424018859863, 5.54447234346008645e-06, 0.000701959475459679595,
+      -3.38021765880820443e-09 * 1. / (1_MeV), 0, -0.000286590504535243261,
+      5.54447234346008645e-06, 8.66082245920551941e-06, 1.98754844823631596e-07,
+      6.11745668929922213e-09 * 1. / (1_MeV), 0, -3.89848736920619265e-06,
+      0.000701959475459679595, 1.98754844823631596e-07, 1.4981656931922771e-05,
+      -3.86232878211289549e-11 * 1. / (1_MeV), 0,
+      -1.27862245568167995e-07 * 1. / (1_MeV),
+      -3.38021765880820443e-09 * 1. / (1_MeV),
+      6.11745668929922213e-09 * 1. / (1_MeV),
+      -3.86232878211289549e-11 * 1. / (1_MeV),
+      2.21742652017908881e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams146 =
+      BoundParameters(gctx, std::move(covMat146), params146, perigeeSurface);
+  tracks.push_back(boundParams146);
+
+  // track 147 :
+  BoundVector params147;
+  params147 << 0.103607669472694397, 2.84468746185302734, -2.64531970024108887,
+      0.422175496816635132, 0.000728976272512227297 * 1. / (1_MeV), 0;
+  Covariance covMat147;
+  covMat147 << 0.0291666984558105469, -0.00028174513634597289,
+      -0.000896671963135054384, 3.65521430545857715e-06,
+      -9.28791760013186476e-07 * 1. / (1_MeV), 0, -0.00028174513634597289,
+      0.183342501521110535, -2.96247041841360439e-05, 0.000901552718064765435,
+      2.53499877322050493e-08 * 1. / (1_MeV), 0, -0.000896671963135054384,
+      -2.96247041841360439e-05, 2.81649827229557559e-05,
+      -2.96050592993603566e-07, 4.56613110250769837e-08 * 1. / (1_MeV), 0,
+      3.65521430545857715e-06, 0.000901552718064765435,
+      -2.96050592993603566e-07, 4.49623166787205264e-06,
+      2.77175608301356693e-11 * 1. / (1_MeV), 0,
+      -9.28791760013186476e-07 * 1. / (1_MeV),
+      2.53499877322050493e-08 * 1. / (1_MeV),
+      4.56613110250769837e-08 * 1. / (1_MeV),
+      2.77175608301356693e-11 * 1. / (1_MeV),
+      7.42934380681958828e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams147 =
+      BoundParameters(gctx, std::move(covMat147), params147, perigeeSurface);
+  tracks.push_back(boundParams147);
+
+  // track 148 :
+  BoundVector params148;
+  params148 << 0.0596604086458683014, -22.0404262542724609,
+      -2.35440278053283691, 2.71709132194519043,
+      0.000393175549106672406 * 1. / (1_MeV), 0;
+  Covariance covMat148;
+  covMat148 << 0.00926339346915483475, 0.000528247059013484989,
+      -0.000273002338954134941, 1.18533332081702857e-06,
+      -1.0181309061738991e-07 * 1. / (1_MeV), 0, 0.000528247059013484989,
+      0.0657876729965209961, -4.89306573522013593e-06, 0.000319671212486525062,
+      -1.99118715573116921e-09 * 1. / (1_MeV), 0, -0.000273002338954134941,
+      -4.89306573522013593e-06, 8.228425940615125e-06, 1.0922913420953112e-08,
+      5.11517095198890007e-09 * 1. / (1_MeV), 0, 1.18533332081702857e-06,
+      0.000319671212486525062, 1.0922913420953112e-08, 1.58801094585214742e-06,
+      -3.45854711927653862e-12 * 1. / (1_MeV), 0,
+      -1.0181309061738991e-07 * 1. / (1_MeV),
+      -1.99118715573116921e-09 * 1. / (1_MeV),
+      5.11517095198890007e-09 * 1. / (1_MeV),
+      -3.45854711927653862e-12 * 1. / (1_MeV),
+      8.50769107940685387e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams148 =
+      BoundParameters(gctx, std::move(covMat148), params148, perigeeSurface);
+  tracks.push_back(boundParams148);
+
+  // track 149 :
+  BoundVector params149;
+  params149 << -0.100074939429759979, -45.496917724609375, -2.26213359832763672,
+      2.41107773780822754, -0.00105385575443506241 * 1. / (1_MeV), 0;
+  Covariance covMat149;
+  covMat149 << 0.0151377040892839432, 0.000602634067371094167,
+      -0.000444356777866817588, 7.9758927859093853e-06,
+      -2.44218026422960964e-07 * 1. / (1_MeV), 0, 0.000602634067371094167,
+      0.0541137345135211945, -2.54764657299984998e-05, 0.000650772244522164326,
+      -2.86525491239922761e-10 * 1. / (1_MeV), 0, -0.000444356777866817588,
+      -2.54764657299984998e-05, 1.33216317408368923e-05,
+      -3.50343885338622606e-07, 1.17735415136484234e-08 * 1. / (1_MeV), 0,
+      7.9758927859093853e-06, 0.000650772244522164326, -3.50343885338622606e-07,
+      8.18384978629183024e-06, -1.33592110665984887e-11 * 1. / (1_MeV), 0,
+      -2.44218026422960964e-07 * 1. / (1_MeV),
+      -2.86525491239922761e-10 * 1. / (1_MeV),
+      1.17735415136484234e-08 * 1. / (1_MeV),
+      -1.33592110665984887e-11 * 1. / (1_MeV),
+      3.07479458561132901e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams149 =
+      BoundParameters(gctx, std::move(covMat149), params149, perigeeSurface);
+  tracks.push_back(boundParams149);
+
+  // track 150 :
+  BoundVector params150;
+  params150 << -0.475683718919754028, -7.06369543075561523, 0.21792110800743103,
+      2.59036850929260254, 0.000621944374870508909 * 1. / (1_MeV), 0;
+  Covariance covMat150;
+  covMat150 << 0.0113344583660364151, 0.000305280624649602989,
+      -0.000332487044324006938, -1.63824948116055707e-06,
+      -9.71480251237366926e-08 * 1. / (1_MeV), 0, 0.000305280624649602989,
+      0.0582733377814292908, 7.6302914477251913e-07, 0.000438738226848568399,
+      -5.91422448133011881e-09 * 1. / (1_MeV), 0, -0.000332487044324006938,
+      7.6302914477251913e-07, 9.93357571132946759e-06, 1.21010113810928627e-07,
+      4.84814135648083373e-09 * 1. / (1_MeV), 0, -1.63824948116055707e-06,
+      0.000438738226848568399, 1.21010113810928627e-07, 3.42198154612560757e-06,
+      -3.26867840396934173e-12 * 1. / (1_MeV), 0,
+      -9.71480251237366926e-08 * 1. / (1_MeV),
+      -5.91422448133011881e-09 * 1. / (1_MeV),
+      4.84814135648083373e-09 * 1. / (1_MeV),
+      -3.26867840396934173e-12 * 1. / (1_MeV),
+      1.01995072110394602e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams150 =
+      BoundParameters(gctx, std::move(covMat150), params150, perigeeSurface);
+  tracks.push_back(boundParams150);
+
+  // track 151 :
+  BoundVector params151;
+  params151 << 0.98848491907119751, -23.9967403411865234, 2.97214531898498535,
+      2.47884941101074219, -0.000928516499698162079 * 1. / (1_MeV), 0;
+  Covariance covMat151;
+  covMat151 << 0.0139401322230696678, -0.000109650695280206099,
+      -0.000410603766136218755, 6.34942242156624963e-06,
+      -1.91480875943633338e-07 * 1. / (1_MeV), 0, -0.000109650695280206099,
+      0.051623273640871048, -4.96380863496017579e-06, 0.000554779761149708835,
+      1.06928217588898346e-08 * 1. / (1_MeV), 0, -0.000410603766136218755,
+      -4.96380863496017579e-06, 1.23366617117426358e-05,
+      -2.8907121314848788e-07, 9.51416150401782656e-09 * 1. / (1_MeV), 0,
+      6.34942242156624963e-06, 0.000554779761149708835, -2.8907121314848788e-07,
+      6.12514031672617421e-06, -4.0379007049062301e-11 * 1. / (1_MeV), 0,
+      -1.91480875943633338e-07 * 1. / (1_MeV),
+      1.06928217588898346e-08 * 1. / (1_MeV),
+      9.51416150401782656e-09 * 1. / (1_MeV),
+      -4.0379007049062301e-11 * 1. / (1_MeV),
+      2.35979236151706573e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams151 =
+      BoundParameters(gctx, std::move(covMat151), params151, perigeeSurface);
+  tracks.push_back(boundParams151);
+
+  // track 152 :
+  BoundVector params152;
+  params152 << 0.55860060453414917, -45.7249908447265625, 1.83190596103668213,
+      0.48145294189453125, 0.000721027201507240534 * 1. / (1_MeV), 0;
+  Covariance covMat152;
+  covMat152 << 0.0186744499951601028, 0.000493292771603547758,
+      -0.000565849238931288596, 3.05813720670537946e-06,
+      -2.66483594264544379e-07 * 1. / (1_MeV), 0, 0.000493292771603547758,
+      0.101673096418380737, -3.54761000333760567e-05, 0.000629179521496957923,
+      -6.15039861676908778e-09 * 1. / (1_MeV), 0, -0.000565849238931288596,
+      -3.54761000333760567e-05, 1.73863791133044288e-05,
+      -2.15955155252030693e-07, 1.3347851460192395e-08 * 1. / (1_MeV), 0,
+      3.05813720670537946e-06, 0.000629179521496957923,
+      -2.15955155252030693e-07, 3.96863515561562963e-06,
+      9.51450535762684209e-12 * 1. / (1_MeV), 0,
+      -2.66483594264544379e-07 * 1. / (1_MeV),
+      -6.15039861676908778e-09 * 1. / (1_MeV),
+      1.3347851460192395e-08 * 1. / (1_MeV),
+      9.51450535762684209e-12 * 1. / (1_MeV),
+      2.52067755557305873e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams152 =
+      BoundParameters(gctx, std::move(covMat152), params152, perigeeSurface);
+  tracks.push_back(boundParams152);
+
+  // track 153 :
+  BoundVector params153;
+  params153 << -0.675277292728424072, -17.5367851257324219,
+      -1.09335136413574219, 1.29379391670227051,
+      0.00186408217996358871 * 1. / (1_MeV), 0;
+  Covariance covMat153;
+  covMat153 << 0.0150135625153779984, -5.98760396689701493e-06,
+      -0.000439278218315922013, 4.52858267312502235e-06,
+      -2.12443419817206803e-07 * 1. / (1_MeV), 0, -5.98760396689701493e-06,
+      0.0350622236728668213, -4.82582268169156601e-06, 0.000836372815788150622,
+      2.09070433346646154e-09 * 1. / (1_MeV), 0, -0.000439278218315922013,
+      -4.82582268169156601e-06, 1.31102533487137407e-05,
+      -2.59231851245594785e-07, 1.04858623295484113e-08 * 1. / (1_MeV), 0,
+      4.52858267312502235e-06, 0.000836372815788150622,
+      -2.59231851245594785e-07, 2.17701854126062244e-05,
+      -2.62710156705971042e-11 * 1. / (1_MeV), 0,
+      -2.12443419817206803e-07 * 1. / (1_MeV),
+      2.09070433346646154e-09 * 1. / (1_MeV),
+      1.04858623295484113e-08 * 1. / (1_MeV),
+      -2.62710156705971042e-11 * 1. / (1_MeV),
+      4.00474514661297576e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams153 =
+      BoundParameters(gctx, std::move(covMat153), params153, perigeeSurface);
+  tracks.push_back(boundParams153);
+
+  // track 154 :
+  BoundVector params154;
+  params154 << 0.0753030404448509216, -29.1891746520996094,
+      0.738724231719970703, 2.31334257125854492,
+      0.00144911545794457197 * 1. / (1_MeV), 0;
+  Covariance covMat154;
+  covMat154 << 0.0217308551073074341, 3.24991188634454485e-05,
+      -0.000647178201020877667, -5.51537304078277638e-06,
+      -4.24940247733336709e-07 * 1. / (1_MeV), 0, 3.24991188634454485e-05,
+      0.0502317957580089569, 1.42908758929754525e-05, 0.000768853527443186789,
+      -1.11154383882071719e-08 * 1. / (1_MeV), 0, -0.000647178201020877667,
+      1.42908758929754525e-05, 1.96035034605301917e-05, 3.94051157866699596e-07,
+      2.12308161941993043e-08 * 1. / (1_MeV), 0, -5.51537304078277638e-06,
+      0.000768853527443186789, 3.94051157866699596e-07, 1.20725653687259182e-05,
+      -9.05413371576357781e-11 * 1. / (1_MeV), 0,
+      -4.24940247733336709e-07 * 1. / (1_MeV),
+      -1.11154383882071719e-08 * 1. / (1_MeV),
+      2.12308161941993043e-08 * 1. / (1_MeV),
+      -9.05413371576357781e-11 * 1. / (1_MeV),
+      6.28650798084606777e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams154 =
+      BoundParameters(gctx, std::move(covMat154), params154, perigeeSurface);
+  tracks.push_back(boundParams154);
+
+  // track 155 :
+  BoundVector params155;
+  params155 << 0.261458933353424072, -2.39843320846557617, 1.05141377449035645,
+      0.232830539345741272, 0.000250596785917878151 * 1. / (1_MeV), 0;
+  Covariance covMat155;
+  covMat155 << 0.0212338902056217194, 0.000353406616331773335,
+      -0.00064520728113282098, 9.74350339390978654e-07,
+      -1.69741491338621847e-07 * 1. / (1_MeV), 0, 0.000353406616331773335,
+      0.41215890645980835, -4.22061888380635897e-05, 0.000653800381523604113,
+      -1.34245812546777072e-08 * 1. / (1_MeV), 0, -0.00064520728113282098,
+      -4.22061888380635897e-05, 1.98819634533720091e-05,
+      -7.83604692222462539e-08, 8.68476512257556142e-09 * 1. / (1_MeV), 0,
+      9.74350339390978654e-07, 0.000653800381523604113,
+      -7.83604692222462539e-08, 1.04632010788918706e-06,
+      -1.19444645168272657e-11 * 1. / (1_MeV), 0,
+      -1.69741491338621847e-07 * 1. / (1_MeV),
+      -1.34245812546777072e-08 * 1. / (1_MeV),
+      8.68476512257556142e-09 * 1. / (1_MeV),
+      -1.19444645168272657e-11 * 1. / (1_MeV),
+      8.34616611933292063e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams155 =
+      BoundParameters(gctx, std::move(covMat155), params155, perigeeSurface);
+  tracks.push_back(boundParams155);
+
+  // track 156 :
+  BoundVector params156;
+  params156 << -0.105008736252784729, -4.60046195983886719,
+      -2.15087199211120605, 2.53013730049133301,
+      0.000869307026732712984 * 1. / (1_MeV), 0;
+  Covariance covMat156;
+  covMat156 << 0.0136917401105165482, 0.000115121263015629808,
+      -0.000413429347423517678, -2.62571780336553623e-06,
+      -2.07199662141073358e-07 * 1. / (1_MeV), 0, 0.000115121263015629808,
+      0.0558724924921989441, 8.99969196056981436e-06, 0.000514698386282201061,
+      -6.20886185541909694e-09 * 1. / (1_MeV), 0, -0.000413429347423517678,
+      8.99969196056981436e-06, 1.26550057757413015e-05, 1.92253160785162133e-07,
+      1.01717537862091531e-08 * 1. / (1_MeV), 0, -2.62571780336553623e-06,
+      0.000514698386282201061, 1.92253160785162133e-07, 4.87851730213151313e-06,
+      -7.31342694223202373e-12 * 1. / (1_MeV), 0,
+      -2.07199662141073358e-07 * 1. / (1_MeV),
+      -6.20886185541909694e-09 * 1. / (1_MeV),
+      1.01717537862091531e-08 * 1. / (1_MeV),
+      -7.31342694223202373e-12 * 1. / (1_MeV),
+      2.3365928636387423e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams156 =
+      BoundParameters(gctx, std::move(covMat156), params156, perigeeSurface);
+  tracks.push_back(boundParams156);
+
+  // track 157 :
+  BoundVector params157;
+  params157 << 0.449398219585418701, -27.5547370910644531, -2.98990011215209961,
+      0.584414243698120117, -0.000796562700998038054 * 1. / (1_MeV), 0;
+  Covariance covMat157;
+  covMat157 << 0.0147328255698084831, 0.000102396442328031638,
+      -0.000442161702936779853, -4.51768449626899611e-06,
+      -1.75125426997186622e-07 * 1. / (1_MeV), 0, 0.000102396442328031638,
+      0.0676895305514335632, 9.61359721658456181e-06, 0.000602606334717200459,
+      -8.66739114473183283e-09 * 1. / (1_MeV), 0, -0.000442161702936779853,
+      9.61359721658456181e-06, 1.34547990455757827e-05, 2.52859101937164529e-07,
+      8.84959810661187708e-09 * 1. / (1_MeV), 0, -4.51768449626899611e-06,
+      0.000602606334717200459, 2.52859101937164529e-07, 5.48358138985349797e-06,
+      2.42683894231848255e-12 * 1. / (1_MeV), 0,
+      -1.75125426997186622e-07 * 1. / (1_MeV),
+      -8.66739114473183283e-09 * 1. / (1_MeV),
+      8.84959810661187708e-09 * 1. / (1_MeV),
+      2.42683894231848255e-12 * 1. / (1_MeV),
+      1.96425084530993388e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams157 =
+      BoundParameters(gctx, std::move(covMat157), params157, perigeeSurface);
+  tracks.push_back(boundParams157);
+
+  // track 158 :
+  BoundVector params158;
+  params158 << -0.47096705436706543, -23.1657295227050781, -1.74237358570098877,
+      2.32017350196838379, 0.000883807893842458725 * 1. / (1_MeV), 0;
+  Covariance covMat158;
+  covMat158 << 0.00741111813113093376, 3.92975220400803806e-05,
+      -0.000222045332813570817, -2.88822099446990028e-06,
+      -2.12788927612163033e-07 * 1. / (1_MeV), 0, 3.92975220400803806e-05,
+      0.0265452265739440918, 3.83772358007061724e-06, 0.000388211046384209855,
+      -5.72504289628637471e-09 * 1. / (1_MeV), 0, -0.000222045332813570817,
+      3.83772358007061724e-06, 6.7778209995594807e-06, 1.57738925506559928e-07,
+      1.01751060319750463e-08 * 1. / (1_MeV), 0, -2.88822099446990028e-06,
+      0.000388211046384209855, 1.57738925506559928e-07, 5.97009920966229402e-06,
+      2.72996826709048491e-11 * 1. / (1_MeV), 0,
+      -2.12788927612163033e-07 * 1. / (1_MeV),
+      -5.72504289628637471e-09 * 1. / (1_MeV),
+      1.01751060319750463e-08 * 1. / (1_MeV),
+      2.72996826709048491e-11 * 1. / (1_MeV),
+      2.86495771550931977e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams158 =
+      BoundParameters(gctx, std::move(covMat158), params158, perigeeSurface);
+  tracks.push_back(boundParams158);
+
+  // track 159 :
+  BoundVector params159;
+  params159 << -0.772880673408508301, -0.194379150867462158,
+      -0.128169164061546326, 0.661742448806762695,
+      0.00110341468825936317 * 1. / (1_MeV), 0;
+  Covariance covMat159;
+  covMat159 << 0.020627237856388092, -0.000651662753287368906,
+      -0.00061276879384480475, 5.7418960693298186e-06,
+      -2.67843352789052197e-07 * 1. / (1_MeV), 0, -0.000651662753287368906,
+      0.0692515745759010315, -2.26766543920346976e-07, 0.000746164457055286962,
+      1.87684603862415885e-08 * 1. / (1_MeV), 0, -0.00061276879384480475,
+      -2.26766543920346976e-07, 1.8517455828259699e-05,
+      -3.78605360981018502e-07, 1.36753554668844785e-08 * 1. / (1_MeV), 0,
+      5.7418960693298186e-06, 0.000746164457055286962, -3.78605360981018502e-07,
+      8.24847211333690211e-06, -3.39037168618683865e-12 * 1. / (1_MeV), 0,
+      -2.67843352789052197e-07 * 1. / (1_MeV),
+      1.87684603862415885e-08 * 1. / (1_MeV),
+      1.36753554668844785e-08 * 1. / (1_MeV),
+      -3.39037168618683865e-12 * 1. / (1_MeV),
+      3.48178236242446815e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams159 =
+      BoundParameters(gctx, std::move(covMat159), params159, perigeeSurface);
+  tracks.push_back(boundParams159);
+
+  // track 160 :
+  BoundVector params160;
+  params160 << -0.347648710012435913, -45.7085342407226562,
+      0.140009865164756775, 0.641895532608032227,
+      0.00117580872029066086 * 1. / (1_MeV), 0;
+  Covariance covMat160;
+  covMat160 << 0.0375818982720375061, -0.000303276309189704169,
+      -0.00110587969340759386, 1.29061987071589049e-05,
+      -4.12294858313896687e-07 * 1. / (1_MeV), 0, -0.000303276309189704169,
+      0.125086501240730286, -2.57186227015147112e-05, 0.00124988554053600013,
+      1.69162268005727335e-08 * 1. / (1_MeV), 0, -0.00110587969340759386,
+      -2.57186227015147112e-05, 3.28488567902240902e-05,
+      -7.27553385059438972e-07, 1.83230555024144881e-08 * 1. / (1_MeV), 0,
+      1.29061987071589049e-05, 0.00124988554053600013, -7.27553385059438972e-07,
+      1.28745887195691466e-05, -1.87734052287320618e-11 * 1. / (1_MeV), 0,
+      -4.12294858313896687e-07 * 1. / (1_MeV),
+      1.69162268005727335e-08 * 1. / (1_MeV),
+      1.83230555024144881e-08 * 1. / (1_MeV),
+      -1.87734052287320618e-11 * 1. / (1_MeV),
+      3.79933057237380467e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams160 =
+      BoundParameters(gctx, std::move(covMat160), params160, perigeeSurface);
+  tracks.push_back(boundParams160);
+
+  // track 161 :
+  BoundVector params161;
+  params161 << -0.2922801673412323, -0.921251356601715088,
+      0.0930548682808876038, 1.51108169555664062,
+      0.00123066513333469629 * 1. / (1_MeV), 0;
+  Covariance covMat161;
+  covMat161 << 0.00921367853879928589, 4.5284958991639089e-06,
+      -0.000270542651850571756, 4.18970364145019236e-07,
+      -1.24935012983859226e-07 * 1. / (1_MeV), 0, 4.5284958991639089e-06,
+      0.0202056393027305603, -5.18878459713167351e-07, 0.000441547249561386889,
+      -1.60400630155777733e-09 * 1. / (1_MeV), 0, -0.000270542651850571756,
+      -5.18878459713167351e-07, 8.02594786364352331e-06,
+      -2.14580558624309511e-08, 5.3323840067832493e-09 * 1. / (1_MeV), 0,
+      4.18970364145019236e-07, 0.000441547249561386889,
+      -2.14580558624309511e-08, 1.14672693598549813e-05,
+      -2.71866026406819207e-11 * 1. / (1_MeV), 0,
+      -1.24935012983859226e-07 * 1. / (1_MeV),
+      -1.60400630155777733e-09 * 1. / (1_MeV),
+      5.3323840067832493e-09 * 1. / (1_MeV),
+      -2.71866026406819207e-11 * 1. / (1_MeV),
+      1.68986658000136458e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams161 =
+      BoundParameters(gctx, std::move(covMat161), params161, perigeeSurface);
+  tracks.push_back(boundParams161);
+
+  // track 162 :
+  BoundVector params162;
+  params162 << 0.4121856689453125, -23.2384719848632812, 3.07601475715637207,
+      2.50852036476135254, -0.00103297142777591944 * 1. / (1_MeV), 0;
+  Covariance covMat162;
+  covMat162 << 0.0184979140758514404, 0.000137593374859579015,
+      -0.000556487007709731548, 8.2413879715742071e-06,
+      -2.98670195072288683e-07 * 1. / (1_MeV), 0, 0.000137593374859579015,
+      0.0723279938101768494, -1.91025340155191667e-05, 0.00072751066352708994,
+      1.28089131983040278e-08 * 1. / (1_MeV), 0, -0.000556487007709731548,
+      -1.91025340155191667e-05, 1.6993884855764918e-05,
+      -4.09609317210932893e-07, 1.47520025775196756e-08 * 1. / (1_MeV), 0,
+      8.2413879715742071e-06, 0.00072751066352708994, -4.09609317210932893e-07,
+      7.47372678233659826e-06, -6.9067412337676577e-12 * 1. / (1_MeV), 0,
+      -2.98670195072288683e-07 * 1. / (1_MeV),
+      1.28089131983040278e-08 * 1. / (1_MeV),
+      1.47520025775196756e-08 * 1. / (1_MeV),
+      -6.9067412337676577e-12 * 1. / (1_MeV),
+      3.46785045124420321e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams162 =
+      BoundParameters(gctx, std::move(covMat162), params162, perigeeSurface);
+  tracks.push_back(boundParams162);
+
+  // track 163 :
+  BoundVector params163;
+  params163 << -0.483950525522232056, -26.1256237030029297,
+      0.0553041622042655945, 0.949812471866607666,
+      -0.00125660584308207035 * 1. / (1_MeV), 0;
+  Covariance covMat163;
+  covMat163 << 0.0255814455449581146, -0.000497574279907850563,
+      -0.000750143259475374879, -9.48529005801767566e-06,
+      -1.80692002549941218e-07 * 1. / (1_MeV), 0, -0.000497574279907850563,
+      0.0536283813416957855, 2.52424588427675564e-05, 0.000992537455962576656,
+      -6.36132286347180259e-10 * 1. / (1_MeV), 0, -0.000750143259475374879,
+      2.52424588427675564e-05, 2.21376776607939973e-05, 4.85059345667416894e-07,
+      8.91432167580867079e-09 * 1. / (1_MeV), 0, -9.48529005801767566e-06,
+      0.000992537455962576656, 4.85059345667416894e-07, 1.88748454093001783e-05,
+      -4.62705821113891289e-11 * 1. / (1_MeV), 0,
+      -1.80692002549941218e-07 * 1. / (1_MeV),
+      -6.36132286347180259e-10 * 1. / (1_MeV),
+      8.91432167580867079e-09 * 1. / (1_MeV),
+      -4.62705821113891289e-11 * 1. / (1_MeV),
+      2.9073463081452644e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams163 =
+      BoundParameters(gctx, std::move(covMat163), params163, perigeeSurface);
+  tracks.push_back(boundParams163);
+
+  // track 164 :
+  BoundVector params164;
+  params164 << 0.446096986532211304, -45.5545768737792969, 1.52503681182861328,
+      0.665921330451965332, -3.70692359865643084e-05 * 1. / (1_MeV), 0;
+  Covariance covMat164;
+  covMat164 << 0.000154954337631352246, -2.7711175651334654e-06,
+      -2.81480069777612953e-06, 5.24993610348611895e-09,
+      -1.85158695435768846e-09 * 1. / (1_MeV), 0, -2.7711175651334654e-06,
+      0.00208598608151078224, -5.19392850454352899e-09, 9.56207419135546286e-06,
+      -8.58618417511969728e-10 * 1. / (1_MeV), 0, -2.81480069777612953e-06,
+      -5.19392850454352899e-09, 5.87558872666704701e-08,
+      -2.14259485564807477e-10, 4.70134905851354349e-11 * 1. / (1_MeV), 0,
+      5.24993610348611895e-09, 9.56207419135546286e-06,
+      -2.14259485564807477e-10, 6.29812220154235547e-08,
+      -5.34156221200548834e-12 * 1. / (1_MeV), 0,
+      -1.85158695435768846e-09 * 1. / (1_MeV),
+      -8.58618417511969728e-10 * 1. / (1_MeV),
+      4.70134905851354349e-11 * 1. / (1_MeV),
+      -5.34156221200548834e-12 * 1. / (1_MeV),
+      6.18826441912273539e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams164 =
+      BoundParameters(gctx, std::move(covMat164), params164, perigeeSurface);
+  tracks.push_back(boundParams164);
+
+  // track 165 :
+  BoundVector params165;
+  params165 << -0.193144664168357849, -39.8290443420410156,
+      0.404710888862609863, 2.53834176063537598,
+      0.000577296596020460129 * 1. / (1_MeV), 0;
+  Covariance covMat165;
+  covMat165 << 0.00723315775394439697, 0.000260372419450370792,
+      -0.000213528892024644653, 8.64182027576564045e-08,
+      -1.62459623796150906e-07 * 1. / (1_MeV), 0, 0.000260372419450370792,
+      0.0307485610246658325, -1.36157327480265165e-06, 0.000270086486223694014,
+      -7.61741612270504069e-09 * 1. / (1_MeV), 0, -0.000213528892024644653,
+      -1.36157327480265165e-06, 6.46902481094002724e-06,
+      4.73498669259185492e-08, 7.96054784235342818e-09 * 1. / (1_MeV), 0,
+      8.64182027576564045e-08, 0.000270086486223694014, 4.73498669259185492e-08,
+      2.46902618528110906e-06, -1.95104992239772127e-11 * 1. / (1_MeV), 0,
+      -1.62459623796150906e-07 * 1. / (1_MeV),
+      -7.61741612270504069e-09 * 1. / (1_MeV),
+      7.96054784235342818e-09 * 1. / (1_MeV),
+      -1.95104992239772127e-11 * 1. / (1_MeV),
+      1.81045026192983016e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams165 =
+      BoundParameters(gctx, std::move(covMat165), params165, perigeeSurface);
+  tracks.push_back(boundParams165);
+
+  // track 166 :
+  BoundVector params166;
+  params166 << 0.799288451671600342, -27.6733474731445312, 1.79553651809692383,
+      2.62628865242004395, 0.000649376073852181435 * 1. / (1_MeV), 0;
+  Covariance covMat166;
+  covMat166 << 0.0184728335589170456, 0.000576206559643558606,
+      -0.000498748322512280475, 2.46767730379623049e-06,
+      -2.41244600997874658e-07 * 1. / (1_MeV), 0, 0.000576206559643558606,
+      0.1421927809715271, 1.81454957973484008e-05, 0.000800767644742904545,
+      -5.41325547148110521e-09 * 1. / (1_MeV), 0, -0.000498748322512280475,
+      1.81454957973484008e-05, 1.40697147799073718e-05, 1.08885275385941302e-07,
+      1.05514606536829556e-08 * 1. / (1_MeV), 0, 2.46767730379623049e-06,
+      0.000800767644742904545, 1.08885275385941302e-07, 4.79977052236790769e-06,
+      -6.6186235709197681e-11 * 1. / (1_MeV), 0,
+      -2.41244600997874658e-07 * 1. / (1_MeV),
+      -5.41325547148110521e-09 * 1. / (1_MeV),
+      1.05514606536829556e-08 * 1. / (1_MeV),
+      -6.6186235709197681e-11 * 1. / (1_MeV),
+      1.90290047608066004e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams166 =
+      BoundParameters(gctx, std::move(covMat166), params166, perigeeSurface);
+  tracks.push_back(boundParams166);
+
+  // track 167 :
+  BoundVector params167;
+  params167 << -0.35574042797088623, -24.7030124664306641, -2.12256479263305664,
+      0.692609786987304688, -0.00104050105437636375 * 1. / (1_MeV), 0;
+  Covariance covMat167;
+  covMat167 << 0.015440003015100956, -0.000624176001675493886,
+      -0.000464574482277491259, -7.70109899823705722e-06,
+      -2.81178338802018056e-07 * 1. / (1_MeV), 0, -0.000624176001675493886,
+      0.0619786754250526428, 3.09368817688975256e-05, 0.000695986322192939863,
+      5.11273110436170716e-09 * 1. / (1_MeV), 0, -0.000464574482277491259,
+      3.09368817688975256e-05, 1.41627569973934442e-05, 3.76623335304221592e-07,
+      1.32070729647698356e-08 * 1. / (1_MeV), 0, -7.70109899823705722e-06,
+      0.000695986322192939863, 3.76623335304221592e-07, 8.04879437055205926e-06,
+      4.26309578361557248e-11 * 1. / (1_MeV), 0,
+      -2.81178338802018056e-07 * 1. / (1_MeV),
+      5.11273110436170716e-09 * 1. / (1_MeV),
+      1.32070729647698356e-08 * 1. / (1_MeV),
+      4.26309578361557248e-11 * 1. / (1_MeV),
+      3.20331428049769329e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams167 =
+      BoundParameters(gctx, std::move(covMat167), params167, perigeeSurface);
+  tracks.push_back(boundParams167);
+
+  // track 168 :
+  BoundVector params168;
+  params168 << 0.11886557936668396, -47.7819938659667969, -2.63996195793151855,
+      0.518789112567901611, 0.000841481960378587246 * 1. / (1_MeV), 0;
+  Covariance covMat168;
+  covMat168 << 0.0208285339176654816, -0.000140944469367757928,
+      -0.000628714493802016365, 2.85093059534874148e-06,
+      -2.52877307106631281e-07 * 1. / (1_MeV), 0, -0.000140944469367757928,
+      0.0990117564797401428, -1.87049319949921501e-05, 0.000699713933447829585,
+      5.35561789668739302e-09 * 1. / (1_MeV), 0, -0.000628714493802016365,
+      -1.87049319949921501e-05, 1.92184870684286579e-05,
+      -2.45129716626087157e-07, 1.23193818731095067e-08 * 1. / (1_MeV), 0,
+      2.85093059534874148e-06, 0.000699713933447829585,
+      -2.45129716626087157e-07, 5.04362697029137053e-06,
+      1.03376886437529416e-11 * 1. / (1_MeV), 0,
+      -2.52877307106631281e-07 * 1. / (1_MeV),
+      5.35561789668739302e-09 * 1. / (1_MeV),
+      1.23193818731095067e-08 * 1. / (1_MeV),
+      1.03376886437529416e-11 * 1. / (1_MeV),
+      2.40058611877813632e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams168 =
+      BoundParameters(gctx, std::move(covMat168), params168, perigeeSurface);
+  tracks.push_back(boundParams168);
+
+  // track 169 :
+  BoundVector params169;
+  params169 << -0.753641188144683838, -24.6972694396972656,
+      -1.26335954666137695, 2.93867397308349609,
+      -5.220841194386594e-05 * 1. / (1_MeV), 0;
+  Covariance covMat169;
+  covMat169 << 0.00236013904213905334, 0.00154376213001722611,
+      -6.73646577569984184e-05, 1.30328176525545106e-06,
+      -1.67714425087651653e-08 * 1. / (1_MeV), 0, 0.00154376213001722611,
+      0.0721083357930183411, -3.89344568551530906e-05, 7.66922827229373638e-05,
+      -5.41191330879136116e-09 * 1. / (1_MeV), 0, -6.73646577569984184e-05,
+      -3.89344568551530906e-05, 1.97714439309493173e-06,
+      -3.33291794511282267e-08, 7.90020084251383031e-10 * 1. / (1_MeV), 0,
+      1.30328176525545106e-06, 7.66922827229373638e-05,
+      -3.33291794511282267e-08, 8.44821670398232527e-08,
+      -2.55639621894285378e-12 * 1. / (1_MeV), 0,
+      -1.67714425087651653e-08 * 1. / (1_MeV),
+      -5.41191330879136116e-09 * 1. / (1_MeV),
+      7.90020084251383031e-10 * 1. / (1_MeV),
+      -2.55639621894285378e-12 * 1. / (1_MeV),
+      6.093434784526508e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams169 =
+      BoundParameters(gctx, std::move(covMat169), params169, perigeeSurface);
+  tracks.push_back(boundParams169);
+
+  // track 170 :
+  BoundVector params170;
+  params170 << -2.15710759162902832, -45.7950439453125, 1.61371970176696777,
+      0.570733428001403809, 0.000358434394001960754 * 1. / (1_MeV), 0;
+  Covariance covMat170;
+  covMat170 << 0.00374916614964604378, -0.000480773005103489936,
+      -0.000105863497891874796, -1.61542653193409112e-07,
+      -1.17937713758139657e-07 * 1. / (1_MeV), 0, -0.000480773005103489936,
+      0.017858605831861496, 1.13532057634138872e-05, 0.000137701393792528048,
+      2.46103911881579324e-08 * 1. / (1_MeV), 0, -0.000105863497891874796,
+      1.13532057634138872e-05, 3.12180145556339994e-06, -1.2843229301556418e-08,
+      5.5197340225094278e-09 * 1. / (1_MeV), 0, -1.61542653193409112e-07,
+      0.000137701393792528048, -1.2843229301556418e-08, 1.12689849629532546e-06,
+      2.78956850716596797e-11 * 1. / (1_MeV), 0,
+      -1.17937713758139657e-07 * 1. / (1_MeV),
+      2.46103911881579324e-08 * 1. / (1_MeV),
+      5.5197340225094278e-09 * 1. / (1_MeV),
+      2.78956850716596797e-11 * 1. / (1_MeV),
+      1.16566450936161914e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams170 =
+      BoundParameters(gctx, std::move(covMat170), params170, perigeeSurface);
+  tracks.push_back(boundParams170);
+
+  // track 171 :
+  BoundVector params171;
+  params171 << 0.297651320695877075, -45.3023033142089844, 1.42410826683044434,
+      0.565678238868713379, -0.000133898094645701349 * 1. / (1_MeV), 0;
+  Covariance covMat171;
+  covMat171 << 0.0027103363536298275, -0.000399266654113502575,
+      -6.23420930522729119e-05, -1.82670658152625359e-06,
+      -7.69916514339241363e-08 * 1. / (1_MeV), 0, -0.000399266654113502575,
+      0.0117103047668933868, 7.28538372498596201e-06, 6.72442964353909048e-05,
+      5.10417192350336677e-09 * 1. / (1_MeV), 0, -6.23420930522729119e-05,
+      7.28538372498596201e-06, 1.54875021962652681e-06, 3.63352506955697989e-08,
+      2.88464097247522637e-09 * 1. / (1_MeV), 0, -1.82670658152625359e-06,
+      6.72442964353909048e-05, 3.63352506955697989e-08, 4.41652872495978954e-07,
+      3.38702398090118851e-11 * 1. / (1_MeV), 0,
+      -7.69916514339241363e-08 * 1. / (1_MeV),
+      5.10417192350336677e-09 * 1. / (1_MeV),
+      2.88464097247522637e-09 * 1. / (1_MeV),
+      3.38702398090118851e-11 * 1. / (1_MeV),
+      5.12816594744336385e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams171 =
+      BoundParameters(gctx, std::move(covMat171), params171, perigeeSurface);
+  tracks.push_back(boundParams171);
+
+  // track 172 :
+  BoundVector params172;
+  params172 << -0.260308802127838135, -25.6350498199462891,
+      -1.41230368614196777, 0.262120574712753296,
+      0.000281498883850872517 * 1. / (1_MeV), 0;
+  Covariance covMat172;
+  covMat172 << 0.0194595623761415482, -0.00222148450059943877,
+      -0.00058252322875270953, -1.15501756925054456e-06,
+      -1.81610552902542074e-07 * 1. / (1_MeV), 0, -0.00222148450059943877,
+      0.29862898588180542, 3.40986013403370269e-05, 0.000587010747958494408,
+      2.04544462489257834e-08 * 1. / (1_MeV), 0, -0.00058252322875270953,
+      3.40986013403370269e-05, 1.77671008714241907e-05,
+      -2.35695411054423683e-08, 8.95910636378094416e-09 * 1. / (1_MeV), 0,
+      -1.15501756925054456e-06, 0.000587010747958494408,
+      -2.35695411054423683e-08, 1.17103115826466819e-06,
+      1.04135839016089135e-11 * 1. / (1_MeV), 0,
+      -1.81610552902542074e-07 * 1. / (1_MeV),
+      2.04544462489257834e-08 * 1. / (1_MeV),
+      8.95910636378094416e-09 * 1. / (1_MeV),
+      1.04135839016089135e-11 * 1. / (1_MeV),
+      9.13651862499698098e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams172 =
+      BoundParameters(gctx, std::move(covMat172), params172, perigeeSurface);
+  tracks.push_back(boundParams172);
+
+  // track 173 :
+  BoundVector params173;
+  params173 << -0.594252109527587891, -5.60402631759643555,
+      -0.336331099271774292, 1.13270664215087891,
+      0.000378493685275316238 * 1. / (1_MeV), 0;
+  Covariance covMat173;
+  covMat173 << 0.00115027138963341713, -2.19197368548817592e-05,
+      -3.13219643767075195e-05, 1.15073899304131421e-07,
+      -1.65870850823649665e-08 * 1. / (1_MeV), 0, -2.19197368548817592e-05,
+      0.00670524360612034798, 1.96229471089852108e-07, 9.39307543268990297e-05,
+      2.47498208313890995e-09 * 1. / (1_MeV), 0, -3.13219643767075195e-05,
+      1.96229471089852108e-07, 8.87292799234273843e-07,
+      -8.13976292236793086e-09, 6.99034330539053411e-10 * 1. / (1_MeV), 0,
+      1.15073899304131421e-07, 9.39307543268990297e-05,
+      -8.13976292236793086e-09, 1.76549144725868246e-06,
+      2.24057572896354012e-11 * 1. / (1_MeV), 0,
+      -1.65870850823649665e-08 * 1. / (1_MeV),
+      2.47498208313890995e-09 * 1. / (1_MeV),
+      6.99034330539053411e-10 * 1. / (1_MeV),
+      2.24057572896354012e-11 * 1. / (1_MeV),
+      2.14914561841306195e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams173 =
+      BoundParameters(gctx, std::move(covMat173), params173, perigeeSurface);
+  tracks.push_back(boundParams173);
+
+  // track 174 :
+  BoundVector params174;
+  params174 << 0.52924954891204834, -45.4634666442871094, 1.54447901248931885,
+      0.575577259063720703, 0.000140380390803329647 * 1. / (1_MeV), 0;
+  Covariance covMat174;
+  covMat174 << 0.00100269797258079052, -1.87621193858972703e-05,
+      -2.4220765886711641e-05, -1.19159820826764043e-07,
+      -1.29051422917792668e-08 * 1. / (1_MeV), 0, -1.87621193858972703e-05,
+      0.00537070957943797112, -5.56254936329620509e-08, 3.29737664105863798e-05,
+      3.42796441483104706e-11 * 1. / (1_MeV), 0, -2.4220765886711641e-05,
+      -5.56254936329620509e-08, 6.28942132152587874e-07,
+      9.62406379884910632e-10, 4.7992442755515698e-10 * 1. / (1_MeV), 0,
+      -1.19159820826764043e-07, 3.29737664105863798e-05,
+      9.62406379884910632e-10, 2.3663132253659569e-07,
+      2.21547914401007548e-12 * 1. / (1_MeV), 0,
+      -1.29051422917792668e-08 * 1. / (1_MeV),
+      3.42796441483104706e-11 * 1. / (1_MeV),
+      4.7992442755515698e-10 * 1. / (1_MeV),
+      2.21547914401007548e-12 * 1. / (1_MeV),
+      8.28479385789337996e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams174 =
+      BoundParameters(gctx, std::move(covMat174), params174, perigeeSurface);
+  tracks.push_back(boundParams174);
+
+  // track 175 :
+  BoundVector params175;
+  params175 << -0.450001835823059082, -24.8905086517333984, -1.6759798526763916,
+      2.58415007591247559, 0.000905881694052368402 * 1. / (1_MeV), 0;
+  Covariance covMat175;
+  covMat175 << 0.0191041901707649231, 0.000428026557284443552,
+      -0.000578871801601514016, -4.45544214020110735e-06,
+      -2.95792810909549861e-07 * 1. / (1_MeV), 0, 0.000428026557284443552,
+      0.0838873609900474548, 6.5131177683482284e-06, 0.000669239272102370875,
+      -1.83345569355485214e-08 * 1. / (1_MeV), 0, -0.000578871801601514016,
+      6.5131177683482284e-06, 1.77657839230960235e-05, 2.90084065510616385e-07,
+      1.41475994510483018e-08 * 1. / (1_MeV), 0, -4.45544214020110735e-06,
+      0.000669239272102370875, 2.90084065510616385e-07, 5.4637353059661109e-06,
+      -8.89617608490651688e-12 * 1. / (1_MeV), 0,
+      -2.95792810909549861e-07 * 1. / (1_MeV),
+      -1.83345569355485214e-08 * 1. / (1_MeV),
+      1.41475994510483018e-08 * 1. / (1_MeV),
+      -8.89617608490651688e-12 * 1. / (1_MeV),
+      2.89176599332918727e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams175 =
+      BoundParameters(gctx, std::move(covMat175), params175, perigeeSurface);
+  tracks.push_back(boundParams175);
+
+  // track 176 :
+  BoundVector params176;
+  params176 << -1.09194684028625488, -51.893341064453125, -2.42328953742980957,
+      0.323457986116409302, -9.37030999921262264e-05 * 1. / (1_MeV), 0;
+  Covariance covMat176;
+  covMat176 << 0.00412589358165860176, -0.000375938547586086044,
+      -9.1347763501019072e-05, -2.06706237329043565e-07,
+      -3.10176057568745453e-08 * 1. / (1_MeV), 0, -0.000375938547586086044,
+      0.044574592262506485, 9.1346382981081699e-06, 9.46204435551554129e-05,
+      3.18549795465229701e-09 * 1. / (1_MeV), 0, -9.1347763501019072e-05,
+      9.1346382981081699e-06, 2.12798704524175264e-06, 6.25620778480259521e-09,
+      9.45920987209876617e-10 * 1. / (1_MeV), 0, -2.06706237329043565e-07,
+      9.46204435551554129e-05, 6.25620778480259521e-09, 2.1415434048321913e-07,
+      2.81623324330943026e-13 * 1. / (1_MeV), 0,
+      -3.10176057568745453e-08 * 1. / (1_MeV),
+      3.18549795465229701e-09 * 1. / (1_MeV),
+      9.45920987209876617e-10 * 1. / (1_MeV),
+      2.81623324330943026e-13 * 1. / (1_MeV),
+      7.16269968684124514e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams176 =
+      BoundParameters(gctx, std::move(covMat176), params176, perigeeSurface);
+  tracks.push_back(boundParams176);
+
+  // track 177 :
+  BoundVector params177;
+  params177 << -0.625615954399108887, -46.6411361694335938,
+      -1.67621421813964844, 0.80771172046661377,
+      -0.000952719361521303654 * 1. / (1_MeV), 0;
+  Covariance covMat177;
+  covMat177 << 0.00838966574519872665, -0.000390657537966586301,
+      -0.000252564060557339894, -4.46970396215082643e-06,
+      -1.84211977604922163e-07 * 1. / (1_MeV), 0, -0.000390657537966586301,
+      0.0338415279984474182, 1.69225585373511505e-05, 0.000474475732694860702,
+      5.60214482748251599e-09 * 1. / (1_MeV), 0, -0.000252564060557339894,
+      1.69225585373511505e-05, 7.7171598604763858e-06, 2.14307467715597906e-07,
+      8.70000260399467453e-09 * 1. / (1_MeV), 0, -4.46970396215082643e-06,
+      0.000474475732694860702, 2.14307467715597906e-07, 6.95064863975858316e-06,
+      3.34801528438062845e-11 * 1. / (1_MeV), 0,
+      -1.84211977604922163e-07 * 1. / (1_MeV),
+      5.60214482748251599e-09 * 1. / (1_MeV),
+      8.70000260399467453e-09 * 1. / (1_MeV),
+      3.34801528438062845e-11 * 1. / (1_MeV),
+      2.40241548876696243e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams177 =
+      BoundParameters(gctx, std::move(covMat177), params177, perigeeSurface);
+  tracks.push_back(boundParams177);
+
+  // track 178 :
+  BoundVector params178;
+  params178 << 0.249076232314109802, -45.2034416198730469, 1.10756564140319824,
+      0.49081951379776001, 0.000841880100779235363 * 1. / (1_MeV), 0;
+  Covariance covMat178;
+  covMat178 << 0.0248545967042446136, 0.000258131336002727254,
+      -0.000766693038710525494, 4.70029301471237248e-06,
+      -9.08506397185599934e-07 * 1. / (1_MeV), 0, 0.000258131336002727254,
+      0.119198836386203766, -3.3659753635808291e-05, 0.000777684091309682095,
+      1.1712654493269838e-08 * 1. / (1_MeV), 0, -0.000766693038710525494,
+      -3.3659753635808291e-05, 2.41926300077466294e-05,
+      -3.10682537473999761e-07, 4.60434144629863134e-08 * 1. / (1_MeV), 0,
+      4.70029301471237248e-06, 0.000777684091309682095,
+      -3.10682537473999761e-07, 5.14959992869989946e-06,
+      6.61054698516293509e-11 * 1. / (1_MeV), 0,
+      -9.08506397185599934e-07 * 1. / (1_MeV),
+      1.1712654493269838e-08 * 1. / (1_MeV),
+      4.60434144629863134e-08 * 1. / (1_MeV),
+      6.61054698516293509e-11 * 1. / (1_MeV),
+      8.71379024491858445e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams178 =
+      BoundParameters(gctx, std::move(covMat178), params178, perigeeSurface);
+  tracks.push_back(boundParams178);
+
+  // track 179 :
+  BoundVector params179;
+  params179 << -0.351021707057952881, -22.8008213043212891,
+      -1.84860432147979736, 2.58694338798522949,
+      -0.000485390948597341776 * 1. / (1_MeV), 0;
+  Covariance covMat179;
+  covMat179 << 0.00608975626528263092, 0.000321320464682472128,
+      -0.000183190187843461718, 2.34032168014660546e-06,
+      -7.63023209733254009e-08 * 1. / (1_MeV), 0, 0.000321320464682472128,
+      0.0319467782974243164, -1.25274257766205381e-05, 0.000241198831469217781,
+      -2.23777402096878229e-09 * 1. / (1_MeV), 0, -0.000183190187843461718,
+      -1.25274257766205381e-05, 5.58611691303667612e-06,
+      -9.42901609067163353e-08, 3.72169224602511146e-09 * 1. / (1_MeV), 0,
+      2.34032168014660546e-06, 0.000241198831469217781,
+      -9.42901609067163353e-08, 1.88807791801082203e-06,
+      -8.61261950846322556e-12 * 1. / (1_MeV), 0,
+      -7.63023209733254009e-08 * 1. / (1_MeV),
+      -2.23777402096878229e-09 * 1. / (1_MeV),
+      3.72169224602511146e-09 * 1. / (1_MeV),
+      -8.61261950846322556e-12 * 1. / (1_MeV),
+      7.60389459730781425e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams179 =
+      BoundParameters(gctx, std::move(covMat179), params179, perigeeSurface);
+  tracks.push_back(boundParams179);
+
+  // track 180 :
+  BoundVector params180;
+  params180 << 0.651896417140960693, -46.7836685180664062, 2.76631903648376465,
+      0.470141232013702393, 1.55008747242391109e-05 * 1. / (1_MeV), 0;
+  Covariance covMat180;
+  covMat180 << 0.000128315252368338406, -3.22642732016210971e-05,
+      -1.99036999570274823e-06, -7.04322809885584826e-08,
+      -1.0059405196984426e-09 * 1. / (1_MeV), 0, -3.22642732016210971e-05,
+      0.00309902383014559746, 3.32147694595742431e-07, 7.25987283305179582e-06,
+      4.75892992516188328e-11 * 1. / (1_MeV), 0, -1.99036999570274823e-06,
+      3.32147694595742431e-07, 3.70899009283220948e-08, 8.60572979362656713e-10,
+      2.24457480954691427e-11 * 1. / (1_MeV), 0, -7.04322809885584826e-08,
+      7.25987283305179582e-06, 8.60572979362656713e-10, 2.08767385601049682e-08,
+      3.80890047398306893e-14 * 1. / (1_MeV), 0,
+      -1.0059405196984426e-09 * 1. / (1_MeV),
+      4.75892992516188328e-11 * 1. / (1_MeV),
+      2.24457480954691427e-11 * 1. / (1_MeV),
+      3.80890047398306893e-14 * 1. / (1_MeV),
+      2.13997019432067559e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams180 =
+      BoundParameters(gctx, std::move(covMat180), params180, perigeeSurface);
+  tracks.push_back(boundParams180);
+
+  // track 181 :
+  BoundVector params181;
+  params181 << 0.3097667396068573, -23.4043254852294922, -2.6382148265838623,
+      2.12934017181396484, 0.00137407251168042421 * 1. / (1_MeV), 0;
+  Covariance covMat181;
+  covMat181 << 0.0118062039837241173, -0.000109254910565050641,
+      -0.000350342450795821422, -4.40406929924205366e-06,
+      -1.69602117125455836e-07 * 1. / (1_MeV), 0, -0.000109254910565050641,
+      0.0281959716230630875, 9.69099679268529228e-06, 0.000552701234963060353,
+      -1.86788811100685945e-09 * 1. / (1_MeV), 0, -0.000350342450795821422,
+      9.69099679268529228e-06, 1.0552752428338863e-05, 2.52690458002615574e-07,
+      8.14523789406513383e-09 * 1. / (1_MeV), 0, -4.40406929924205366e-06,
+      0.000552701234963060353, 2.52690458002615574e-07, 1.13834439616766758e-05,
+      -4.34128100864560213e-11 * 1. / (1_MeV), 0,
+      -1.69602117125455836e-07 * 1. / (1_MeV),
+      -1.86788811100685945e-09 * 1. / (1_MeV),
+      8.14523789406513383e-09 * 1. / (1_MeV),
+      -4.34128100864560213e-11 * 1. / (1_MeV),
+      2.69415295628405715e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams181 =
+      BoundParameters(gctx, std::move(covMat181), params181, perigeeSurface);
+  tracks.push_back(boundParams181);
+
+  // track 182 :
+  BoundVector params182;
+  params182 << 0.642095208168029785, -46.7620658874511719, 2.74535226821899414,
+      0.476923286914825439, -2.45610826823394746e-05 * 1. / (1_MeV), 0;
+  Covariance covMat182;
+  covMat182 << 0.000100913421192672104, -2.33679616572281888e-05,
+      -2.07401176069228284e-06, -4.92462068561543299e-08,
+      -7.88576461002653878e-10 * 1. / (1_MeV), 0, -2.33679616572281888e-05,
+      0.00347701110877096653, 1.02118911354786458e-07, 1.11020572919389336e-05,
+      6.8980626296848663e-10 * 1. / (1_MeV), 0, -2.07401176069228284e-06,
+      1.02118911354786458e-07, 5.15610665274834901e-08, 1.91829932276107212e-10,
+      2.57034296242806379e-11 * 1. / (1_MeV), 0, -4.92462068561543299e-08,
+      1.11020572919389336e-05, 1.91829932276107212e-10, 4.51592896411057154e-08,
+      2.18691904163845164e-12 * 1. / (1_MeV), 0,
+      -7.88576461002653878e-10 * 1. / (1_MeV),
+      6.8980626296848663e-10 * 1. / (1_MeV),
+      2.57034296242806379e-11 * 1. / (1_MeV),
+      2.18691904163845164e-12 * 1. / (1_MeV),
+      3.96474248830908094e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams182 =
+      BoundParameters(gctx, std::move(covMat182), params182, perigeeSurface);
+  tracks.push_back(boundParams182);
+
+  // track 183 :
+  BoundVector params183;
+  params183 << -0.858931362628936768, -26.3201007843017578,
+      -1.06501162052154541, 2.00542879104614258,
+      -0.00147176207974553108 * 1. / (1_MeV), 0;
+  Covariance covMat183;
+  covMat183 << 0.011342288926243782, 0.000290935310731487665,
+      -0.000333001654335057632, 4.59266904966147677e-06,
+      -1.51592966891820935e-07 * 1. / (1_MeV), 0, 0.000290935310731487665,
+      0.0283716730773448944, -1.24780364597086955e-05, 0.000574239226233242469,
+      -9.53412665718049786e-09 * 1. / (1_MeV), 0, -0.000333001654335057632,
+      -1.24780364597086955e-05, 9.96404742181766778e-06,
+      -2.20760287088705507e-07, 7.55984162080033033e-09 * 1. / (1_MeV), 0,
+      4.59266904966147677e-06, 0.000574239226233242469,
+      -2.20760287088705507e-07, 1.23750987768289633e-05,
+      -1.19858856846402273e-10 * 1. / (1_MeV), 0,
+      -1.51592966891820935e-07 * 1. / (1_MeV),
+      -9.53412665718049786e-09 * 1. / (1_MeV),
+      7.55984162080033033e-09 * 1. / (1_MeV),
+      -1.19858856846402273e-10 * 1. / (1_MeV),
+      2.77350448163460328e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams183 =
+      BoundParameters(gctx, std::move(covMat183), params183, perigeeSurface);
+  tracks.push_back(boundParams183);
+
+  // track 184 :
+  BoundVector params184;
+  params184 << 0.845212101936340332, -24.126739501953125, 2.38256359100341797,
+      0.824191451072692871, 0.00116483436431735754 * 1. / (1_MeV), 0;
+  Covariance covMat184;
+  covMat184 << 0.0120219700038433075, 0.000314479883882060258,
+      -0.000367754344864782703, 3.16651031569499765e-06,
+      -5.50176211668336246e-07 * 1. / (1_MeV), 0, 0.000314479883882060258,
+      0.0294524524360895157, -1.65477014501080602e-05, 0.00044716975418939163,
+      -1.85121059683026354e-08 * 1. / (1_MeV), 0, -0.000367754344864782703,
+      -1.65477014501080602e-05, 1.14791173473349772e-05,
+      -1.9939615532523593e-07, 2.734052899630625e-08 * 1. / (1_MeV), 0,
+      3.16651031569499765e-06, 0.00044716975418939163, -1.9939615532523593e-07,
+      6.98199028192902915e-06, -3.56882818335140094e-11 * 1. / (1_MeV), 0,
+      -5.50176211668336246e-07 * 1. / (1_MeV),
+      -1.85121059683026354e-08 * 1. / (1_MeV),
+      2.734052899630625e-08 * 1. / (1_MeV),
+      -3.56882818335140094e-11 * 1. / (1_MeV),
+      8.01815225326407699e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams184 =
+      BoundParameters(gctx, std::move(covMat184), params184, perigeeSurface);
+  tracks.push_back(boundParams184);
+
+  // track 185 :
+  BoundVector params185;
+  params185 << -0.647501945495605469, -26.0731620788574219,
+      -0.995935499668121338, 2.34878754615783691,
+      -0.00110976793803274632 * 1. / (1_MeV), 0;
+  Covariance covMat185;
+  covMat185 << 0.0123600270599126816, 0.000410363839412986508,
+      -0.000381886789830261913, 4.94468486056877076e-06,
+      -7.64568886360537938e-07 * 1. / (1_MeV), 0, 0.000410363839412986508,
+      0.0372607558965682983, -2.04358797977256596e-05, 0.000530848800251920608,
+      -1.84281636372081495e-08 * 1. / (1_MeV), 0, -0.000381886789830261913,
+      -2.04358797977256596e-05, 1.20873473861138336e-05,
+      -2.66094668793066799e-07, 3.82825795137663461e-08 * 1. / (1_MeV), 0,
+      4.94468486056877076e-06, 0.000530848800251920608,
+      -2.66094668793066799e-07, 7.83790710556786507e-06,
+      -5.28708663533158423e-11 * 1. / (1_MeV), 0,
+      -7.64568886360537938e-07 * 1. / (1_MeV),
+      -1.84281636372081495e-08 * 1. / (1_MeV),
+      3.82825795137663461e-08 * 1. / (1_MeV),
+      -5.28708663533158423e-11 * 1. / (1_MeV),
+      1.09044751006592833e-09 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams185 =
+      BoundParameters(gctx, std::move(covMat185), params185, perigeeSurface);
+  tracks.push_back(boundParams185);
+
+  // track 186 :
+  BoundVector params186;
+  params186 << 0.319027870893478394, -46.8204345703125, -2.81523966789245605,
+      0.552423059940338135, -0.000565428519621491432 * 1. / (1_MeV), 0;
+  Covariance covMat186;
+  covMat186 << 0.00984183419495820999, -0.000107861702339279294,
+      -0.000293623369079297144, -2.57141056900692002e-06,
+      -2.68841014325236236e-07 * 1. / (1_MeV), 0, -0.000107861702339279294,
+      0.0447328835725784302, 6.98001302362255524e-06, 0.000354029532888733148,
+      -7.43175254803814895e-09 * 1. / (1_MeV), 0, -0.000293623369079297144,
+      6.98001302362255524e-06, 8.98743746802210808e-06, 1.18656413477563677e-07,
+      1.2513898586729675e-08 * 1. / (1_MeV), 0, -2.57141056900692002e-06,
+      0.000354029532888733148, 1.18656413477563677e-07, 2.89464674096961971e-06,
+      9.64087163963260696e-12 * 1. / (1_MeV), 0,
+      -2.68841014325236236e-07 * 1. / (1_MeV),
+      -7.43175254803814895e-09 * 1. / (1_MeV),
+      1.2513898586729675e-08 * 1. / (1_MeV),
+      9.64087163963260696e-12 * 1. / (1_MeV),
+      2.39039704696963895e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams186 =
+      BoundParameters(gctx, std::move(covMat186), params186, perigeeSurface);
+  tracks.push_back(boundParams186);
+
+  // track 187 :
+  BoundVector params187;
+  params187 << 0.200757488608360291, -26.9347019195556641, 1.57208847999572754,
+      2.04276847839355469, -0.00149231334216892719 * 1. / (1_MeV), 0;
+  Covariance covMat187;
+  covMat187 << 0.0462070293724536896, 1.90087908538328356e-05,
+      -0.00102549302847446035, 1.05894079671972913e-05,
+      -5.64029011801386039e-07 * 1. / (1_MeV), 0, 1.90087908538328356e-05,
+      0.0641310736536979675, -1.20655144555816986e-05, 0.00107456409340518297,
+      7.16318519179297501e-09 * 1. / (1_MeV), 0, -0.00102549302847446035,
+      -1.20655144555816986e-05, 2.3894455807749182e-05,
+      -4.41047372315603779e-07, 1.78538275775300426e-08 * 1. / (1_MeV), 0,
+      1.05894079671972913e-05, 0.00107456409340518297, -4.41047372315603779e-07,
+      1.92008483281824738e-05, -2.57140078054900237e-12 * 1. / (1_MeV), 0,
+      -5.64029011801386039e-07 * 1. / (1_MeV),
+      7.16318519179297501e-09 * 1. / (1_MeV),
+      1.78538275775300426e-08 * 1. / (1_MeV),
+      -2.57140078054900237e-12 * 1. / (1_MeV),
+      3.88259702166493526e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams187 =
+      BoundParameters(gctx, std::move(covMat187), params187, perigeeSurface);
+  tracks.push_back(boundParams187);
+
+  // track 188 :
+  BoundVector params188;
+  params188 << 0.206104561686515808, -26.3112201690673828, 1.16691756248474121,
+      1.37588953971862793, 0.00132282346021384001 * 1. / (1_MeV), 0;
+  Covariance covMat188;
+  covMat188 << 0.00764826126396656036, 2.58893561269243087e-05,
+      -0.000224053920824634036, 1.17201917881422574e-06,
+      -6.15634478426662571e-07 * 1. / (1_MeV), 0, 2.58893561269243087e-05,
+      0.0230550467967987061, -2.20380176677741682e-06, 0.000482425977760371505,
+      5.06151582160123152e-09 * 1. / (1_MeV), 0, -0.000224053920824634036,
+      -2.20380176677741682e-06, 6.82648260408313945e-06,
+      -6.86203109211295378e-08, 2.94694781059607752e-08 * 1. / (1_MeV), 0,
+      1.17201917881422574e-06, 0.000482425977760371505,
+      -6.86203109211295378e-08, 1.19285659820889123e-05,
+      -8.07723581241271915e-12 * 1. / (1_MeV), 0,
+      -6.15634478426662571e-07 * 1. / (1_MeV),
+      5.06151582160123152e-09 * 1. / (1_MeV),
+      2.94694781059607752e-08 * 1. / (1_MeV),
+      -8.07723581241271915e-12 * 1. / (1_MeV),
+      1.11964115756535421e-09 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams188 =
+      BoundParameters(gctx, std::move(covMat188), params188, perigeeSurface);
+  tracks.push_back(boundParams188);
+
+  // track 189 :
+  BoundVector params189;
+  params189 << 1.26870429515838623, -46.6835365295410156, 2.73736929893493652,
+      0.47043222188949585, -0.000411598914070054889 * 1. / (1_MeV), 0;
+  Covariance covMat189;
+  covMat189 << 0.01254259143024683, -0.00206373011378385143,
+      -0.000333126060112854414, -1.27171802273924282e-05,
+      -3.42805695619100495e-07 * 1. / (1_MeV), 0, -0.00206373011378385143,
+      0.063680604100227356, 4.27260303702722393e-05, 0.000335381549435983519,
+      6.98047989676528565e-09 * 1. / (1_MeV), 0, -0.000333126060112854414,
+      4.27260303702722393e-05, 9.29942689253948629e-06, 3.07921052012408952e-07,
+      1.3794266136933136e-08 * 1. / (1_MeV), 0, -1.27171802273924282e-05,
+      0.000335381549435983519, 3.07921052012408952e-07, 1.85226963367313147e-06,
+      1.88533015927685212e-10 * 1. / (1_MeV), 0,
+      -3.42805695619100495e-07 * 1. / (1_MeV),
+      6.98047989676528565e-09 * 1. / (1_MeV),
+      1.3794266136933136e-08 * 1. / (1_MeV),
+      1.88533015927685212e-10 * 1. / (1_MeV),
+      2.06299227700768029e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams189 =
+      BoundParameters(gctx, std::move(covMat189), params189, perigeeSurface);
+  tracks.push_back(boundParams189);
+
+  // track 190 :
+  BoundVector params190;
+  params190 << 0.520144522190093994, -26.78125, 2.87916159629821777,
+      0.913090944290161133, 0.000958578370045870543 * 1. / (1_MeV), 0;
+  Covariance covMat190;
+  covMat190 << 0.0566640235483646393, 0.000619879059068139857,
+      -0.0011829013005423088, 1.13578597071357791e-05,
+      -2.92844240909480606e-07 * 1. / (1_MeV), 0, 0.000619879059068139857,
+      0.112776532769203186, -3.16848163975865004e-05, 0.00133383261677284099,
+      1.65364516509722375e-10 * 1. / (1_MeV), 0, -0.0011829013005423088,
+      -3.16848163975865004e-05, 2.54572314588585868e-05,
+      -4.61895451801213113e-07, 9.13941830794303589e-09 * 1. / (1_MeV), 0,
+      1.13578597071357791e-05, 0.00133383261677284099, -4.61895451801213113e-07,
+      1.69904978974955156e-05, 2.02537558480182913e-11 * 1. / (1_MeV), 0,
+      -2.92844240909480606e-07 * 1. / (1_MeV),
+      1.65364516509722375e-10 * 1. / (1_MeV),
+      9.13941830794303589e-09 * 1. / (1_MeV),
+      2.02537558480182913e-11 * 1. / (1_MeV),
+      1.74747369352523663e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams190 =
+      BoundParameters(gctx, std::move(covMat190), params190, perigeeSurface);
+  tracks.push_back(boundParams190);
+
+  // track 191 :
+  BoundVector params191;
+  params191 << 3.12282395362854004, -65.509918212890625, -0.187527939677238464,
+      2.73361945152282715, 0.000346441811416298151 * 1. / (1_MeV), 0;
+  Covariance covMat191;
+  covMat191 << 0.0481044948101043701, -0.00734549814752950836,
+      -0.00103489854597267421, -4.2235125913880291e-06,
+      -3.96252766190557419e-07 * 1. / (1_MeV), 0, -0.00734549814752950836,
+      0.311487704515457153, 0.000193686295137312744, 0.00101870529268977775,
+      7.69202591235202105e-08 * 1. / (1_MeV), 0, -0.00103489854597267421,
+      0.000193686295137312744, 2.31200901907868683e-05, 1.875400366292023e-07,
+      1.18979733649928015e-08 * 1. / (1_MeV), 0, -4.2235125913880291e-06,
+      0.00101870529268977775, 1.875400366292023e-07, 3.4847455481212819e-06,
+      4.99503482968757551e-12 * 1. / (1_MeV), 0,
+      -3.96252766190557419e-07 * 1. / (1_MeV),
+      7.69202591235202105e-08 * 1. / (1_MeV),
+      1.18979733649928015e-08 * 1. / (1_MeV),
+      4.99503482968757551e-12 * 1. / (1_MeV),
+      1.1102829766684863e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams191 =
+      BoundParameters(gctx, std::move(covMat191), params191, perigeeSurface);
+  tracks.push_back(boundParams191);
+
+  // track 192 :
+  BoundVector params192;
+  params192 << 1.94856953620910645, 32.0474395751953125, 1.59367656707763672,
+      0.301271170377731323, -0.000417216855566948652 * 1. / (1_MeV), 0;
+  Covariance covMat192;
+  covMat192 << 0.11419309675693512, 0.0161650360627660812,
+      -0.00256272073865566842, -1.33614281853937828e-05,
+      -1.05474827860620141e-06 * 1. / (1_MeV), 0, 0.0161650360627660812,
+      1.25828850269317627, -0.000234076459249502955, 0.00243207131735968243,
+      -2.73285579882235462e-07 * 1. / (1_MeV), 0, -0.00256272073865566842,
+      -0.000234076459249502955, 6.02843829256016761e-05,
+      5.83439505836653557e-07, 3.3253261709379142e-08 * 1. / (1_MeV), 0,
+      -1.33614281853937828e-05, 0.00243207131735968243, 5.83439505836653557e-07,
+      4.93446850668988191e-06, -1.22599704885134249e-11 * 1. / (1_MeV), 0,
+      -1.05474827860620141e-06 * 1. / (1_MeV),
+      -2.73285579882235462e-07 * 1. / (1_MeV),
+      3.3253261709379142e-08 * 1. / (1_MeV),
+      -1.22599704885134249e-11 * 1. / (1_MeV),
+      2.39606362528732575e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams192 =
+      BoundParameters(gctx, std::move(covMat192), params192, perigeeSurface);
+  tracks.push_back(boundParams192);
+
+  // track 193 :
+  BoundVector params193;
+  params193 << 0.523398816585540771, -46.3878059387207031, 2.57148909568786621,
+      0.468454271554946899, 0.000597213569562882185 * 1. / (1_MeV), 0;
+  Covariance covMat193;
+  covMat193 << 0.0160064026713371277, 0.000101030272422620432,
+      -0.000480147175700083547, 8.08765442010045379e-07,
+      -4.30079426986170688e-07 * 1. / (1_MeV), 0, 0.000101030272422620432,
+      0.090941987931728363, -2.0664086011827537e-05, 0.000523265493974074398,
+      -1.2205651249153285e-09 * 1. / (1_MeV), 0, -0.000480147175700083547,
+      -2.0664086011827537e-05, 1.47662221934297122e-05,
+      -1.17382332277604896e-07, 2.09396062746074539e-08 * 1. / (1_MeV), 0,
+      8.08765442010045379e-07, 0.000523265493974074398,
+      -1.17382332277604896e-07, 3.09063830172817688e-06,
+      5.33983405657483665e-11 * 1. / (1_MeV), 0,
+      -4.30079426986170688e-07 * 1. / (1_MeV),
+      -1.2205651249153285e-09 * 1. / (1_MeV),
+      2.09396062746074539e-08 * 1. / (1_MeV),
+      5.33983405657483665e-11 * 1. / (1_MeV),
+      3.6832190075664073e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams193 =
+      BoundParameters(gctx, std::move(covMat193), params193, perigeeSurface);
+  tracks.push_back(boundParams193);
+
+  // track 194 :
+  BoundVector params194;
+  params194 << -0.0635648146271705627, -14.7882223129272461,
+      -2.64156651496887207, 0.224920362234115601,
+      -0.000183147756615653634 * 1. / (1_MeV), 0;
+  Covariance covMat194;
+  covMat194 << 0.0120655400678515434, -0.0006910453838693592,
+      -0.000365977142399209201, -1.28533147920557146e-06,
+      -1.01339535493182776e-07 * 1. / (1_MeV), 0, -0.0006910453838693592,
+      0.273133754730224609, 3.06268979203341366e-05, 0.000393899454679768192,
+      -1.35539555434146533e-10 * 1. / (1_MeV), 0, -0.000365977142399209201,
+      3.06268979203341366e-05, 1.12705602077767253e-05, 5.48705815401846056e-08,
+      4.95433244701872377e-09 * 1. / (1_MeV), 0, -1.28533147920557146e-06,
+      0.000393899454679768192, 5.48705815401846056e-08, 5.77933633394422941e-07,
+      1.62498821676485166e-12 * 1. / (1_MeV), 0,
+      -1.01339535493182776e-07 * 1. / (1_MeV),
+      -1.35539555434146533e-10 * 1. / (1_MeV),
+      4.95433244701872377e-09 * 1. / (1_MeV),
+      1.62498821676485166e-12 * 1. / (1_MeV),
+      4.37339504888445418e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams194 =
+      BoundParameters(gctx, std::move(covMat194), params194, perigeeSurface);
+  tracks.push_back(boundParams194);
+
+  // track 195 :
+  BoundVector params195;
+  params195 << -0.455407500267028809, 0.212499335408210754,
+      -2.02245116233825684, 2.88869571685791016,
+      0.000139400261105038226 * 1. / (1_MeV), 0;
+  Covariance covMat195;
+  covMat195 << 0.0228636190295219421, 0.00132628619103978239,
+      -0.000501410814590430576, -5.05350529972164141e-07,
+      -1.15052451624681027e-07 * 1. / (1_MeV), 0, 0.00132628619103978239,
+      0.374587059020996094, -1.18830711055222554e-05, 0.000496772398167388309,
+      -8.53100318867495256e-09 * 1. / (1_MeV), 0, -0.000501410814590430576,
+      -1.18830711055222554e-05, 1.15277352961129509e-05,
+      3.33864252437007874e-08, 3.65227707433702304e-09 * 1. / (1_MeV), 0,
+      -5.05350529972164141e-07, 0.000496772398167388309,
+      3.33864252437007874e-08, 6.9544324787784717e-07,
+      9.05586100425189466e-13 * 1. / (1_MeV), 0,
+      -1.15052451624681027e-07 * 1. / (1_MeV),
+      -8.53100318867495256e-09 * 1. / (1_MeV),
+      3.65227707433702304e-09 * 1. / (1_MeV),
+      9.05586100425189466e-13 * 1. / (1_MeV),
+      2.24803491793990062e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams195 =
+      BoundParameters(gctx, std::move(covMat195), params195, perigeeSurface);
+  tracks.push_back(boundParams195);
+
+  // track 196 :
+  BoundVector params196;
+  params196 << 0.0801024585962295532, 22.3374137878417969, -1.32229578495025635,
+      2.88867521286010742, -0.000216519838431850076 * 1. / (1_MeV), 0;
+  Covariance covMat196;
+  covMat196 << 0.0681927874684333801, 0.00231532290305440673,
+      -0.00145939788550150835, 7.36670177096379346e-06,
+      -3.68450500773211916e-07 * 1. / (1_MeV), 0, 0.00231532290305440673,
+      1.3315422534942627, -0.000122508412210780388, 0.00171897979661990116,
+      1.76497106084476643e-08 * 1. / (1_MeV), 0, -0.00145939788550150835,
+      -0.000122508412210780388, 3.25632354361005127e-05,
+      -2.55214252507531063e-07, 1.09182558397378106e-08 * 1. / (1_MeV), 0,
+      7.36670177096379346e-06, 0.00171897979661990116, -2.55214252507531063e-07,
+      2.29971669796213973e-06, -1.84419314901396339e-12 * 1. / (1_MeV), 0,
+      -3.68450500773211916e-07 * 1. / (1_MeV),
+      1.76497106084476643e-08 * 1. / (1_MeV),
+      1.09182558397378106e-08 * 1. / (1_MeV),
+      -1.84419314901396339e-12 * 1. / (1_MeV),
+      6.27720861401392938e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams196 =
+      BoundParameters(gctx, std::move(covMat196), params196, perigeeSurface);
+  tracks.push_back(boundParams196);
+
+  // track 197 :
+  BoundVector params197;
+  params197 << 0.193900123238563538, -49.2524490356445312, 1.49366855621337891,
+      0.566030263900756836, -0.000631641771178692579 * 1. / (1_MeV), 0;
+  Covariance covMat197;
+  covMat197 << 0.0389422886073589325, 9.48181031765662076e-05,
+      -0.000864193462432249256, -6.76416801720607369e-06,
+      -2.91262857280178875e-07 * 1. / (1_MeV), 0, 9.48181031765662076e-05,
+      0.157681390643119812, 2.04442639286554837e-05, 0.000927270582484305585,
+      -1.8757136234213445e-08 * 1. / (1_MeV), 0, -0.000864193462432249256,
+      2.04442639286554837e-05, 2.00722697627497837e-05, 2.89773386592212807e-07,
+      8.81223262771924531e-09 * 1. / (1_MeV), 0, -6.76416801720607369e-06,
+      0.000927270582484305585, 2.89773386592212807e-07, 5.88341436014161445e-06,
+      -3.63880446087211061e-11 * 1. / (1_MeV), 0,
+      -2.91262857280178875e-07 * 1. / (1_MeV),
+      -1.8757136234213445e-08 * 1. / (1_MeV),
+      8.81223262771924531e-09 * 1. / (1_MeV),
+      -3.63880446087211061e-11 * 1. / (1_MeV),
+      1.12412849861964759e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
+  auto boundParams197 =
+      BoundParameters(gctx, std::move(covMat197), params197, perigeeSurface);
+  tracks.push_back(boundParams197);
+
+  return tracks;
+}
+
+}  // namespace Test
+}  // namespace Acts
\ No newline at end of file
diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
index 223dfcf0f..a43117db2 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
@@ -23,6 +23,8 @@
 #include "Acts/Vertexing/TrackDensityVertexFinder.hpp"
 #include "Acts/Vertexing/Vertex.hpp"
 
+#include "AMVFTestData.ipp"
+
 namespace Acts {
 namespace Test {
 
@@ -32,15 +34,13 @@ using Covariance = BoundSymMatrix;
 using Propagator = Propagator<EigenStepper<ConstantBField>>;
 using Linearizer = HelicalTrackLinearizer<Propagator>;
 
-std::vector<const BoundParameters> getAthenaTracks();
-
 // Create a test context
 GeometryContext tgContext = GeometryContext();
 MagneticFieldContext mfContext = MagneticFieldContext();
 
 BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
   // Set debug mode
-  bool debugMode = true;
+  bool debugMode = false;
   // Set up constant B-Field
   ConstantBField bField(Vector3D(0., 0., 2_T));
 
@@ -160,4688 +160,80 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
       std::cout << "\t with n tracks: " << vtx.tracks().size() << std::endl;
     }
   }
-}
-
-// Return all tracks of one single event as reconstructed in athena.
-std::vector<const BoundParameters> getAthenaTracks() {
-  std::vector<const BoundParameters> tracks;
-
-  std::shared_ptr<PerigeeSurface> perigeeSurface =
-      Surface::makeShared<PerigeeSurface>(Vector3D(0, 0, 0));
-
-  // track 0 :
-  BoundVector params0;
-  params0 << 0.208999365568161011, -7.4357142448425293, -2.55163192749023438,
-      0.400493592023849487, 0.000171513980603776872 * 1. / (1_MeV), 0;
-  Covariance covMat0;
-  covMat0 << 0.00214068428613245487, -7.96709354183403084e-05,
-      -6.33177642943666364e-05, -3.00625320493796891e-07,
-      -4.07648672868712677e-08 * 1. / (1_MeV), 0, -7.96709354183403084e-05,
-      0.0202132239937782288, 6.98606246685060205e-07, 8.37879139489858309e-05,
-      -8.87738057299842411e-10 * 1. / (1_MeV), 0, -6.33177642943666364e-05,
-      6.98606246685060205e-07, 1.92246739061374683e-06, 3.3797454010498409e-09,
-      1.96217863793276324e-09 * 1. / (1_MeV), 0, -3.00625320493796891e-07,
-      8.37879139489858309e-05, 3.3797454010498409e-09, 3.60428089152264874e-07,
-      -2.89474607768885319e-13 * 1. / (1_MeV), 0,
-      -4.07648672868712677e-08 * 1. / (1_MeV),
-      -8.87738057299842411e-10 * 1. / (1_MeV),
-      1.96217863793276324e-09 * 1. / (1_MeV),
-      -2.89474607768885319e-13 * 1. / (1_MeV),
-      2.95636293223822122e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams0 =
-      BoundParameters(tgContext, std::move(covMat0), params0, perigeeSurface);
-  tracks.push_back(boundParams0);
-
-  // track 1 :
-  BoundVector params1;
-  params1 << -0.824735164642333984, -26.9860115051269531, -0.7550087571144104,
-      2.88085079193115234, -0.000325617991620674729 * 1. / (1_MeV), 0;
-  Covariance covMat1;
-  covMat1 << 0.0251417625695466995, 0.00420630678879723493,
-      -0.000765272953239746903, 6.15640108953951687e-06,
-      -2.11256706714709132e-07 * 1. / (1_MeV), 0, 0.00420630678879723493,
-      0.45946967601776123, -0.00017342003098708611, 0.000916811988348789977,
-      -4.01729661445370942e-08 * 1. / (1_MeV), 0, -0.000765272953239746903,
-      -0.00017342003098708611, 2.36324631259776652e-05,
-      -2.76756048013333578e-07, 1.12351950637584698e-08 * 1. / (1_MeV), 0,
-      6.15640108953951687e-06, 0.000916811988348789977,
-      -2.76756048013333578e-07, 1.84237103439954808e-06,
-      -2.85976888807477401e-11 * 1. / (1_MeV), 0,
-      -2.11256706714709132e-07 * 1. / (1_MeV),
-      -4.01729661445370942e-08 * 1. / (1_MeV),
-      1.12351950637584698e-08 * 1. / (1_MeV),
-      -2.85976888807477401e-11 * 1. / (1_MeV),
-      1.26268676070573349e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams1 =
-      BoundParameters(tgContext, std::move(covMat1), params1, perigeeSurface);
-  tracks.push_back(boundParams1);
-
-  // track 2 :
-  BoundVector params2;
-  params2 << 0.118518374860286713, -48.0805015563964844, -2.49598431587219238,
-      0.356813013553619385, 1.4544933037541341e-05 * 1. / (1_MeV), 0;
-  Covariance covMat2;
-  covMat2 << 0.00012035925465170294, -1.71798710526704588e-05,
-      -2.2860801492818823e-06, -2.13407107938616708e-08,
-      -8.14879249062358672e-10 * 1. / (1_MeV), 0, -1.71798710526704588e-05,
-      0.00348281394690275192, 1.23563722604002285e-07, 5.49114154040670388e-06,
-      2.65331046074031372e-11 * 1. / (1_MeV), 0, -2.2860801492818823e-06,
-      1.23563722604002285e-07, 5.03515273919674655e-08, 2.09996509522900305e-10,
-      2.36859555262461008e-11 * 1. / (1_MeV), 0, -2.13407107938616708e-08,
-      5.49114154040670388e-06, 2.09996509522900305e-10, 1.09355804411848112e-08,
-      4.89767384223879453e-14 * 1. / (1_MeV), 0,
-      -8.14879249062358672e-10 * 1. / (1_MeV),
-      2.65331046074031372e-11 * 1. / (1_MeV),
-      2.36859555262461008e-11 * 1. / (1_MeV),
-      4.89767384223879453e-14 * 1. / (1_MeV),
-      2.01368720417934022e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams2 =
-      BoundParameters(tgContext, std::move(covMat2), params2, perigeeSurface);
-  tracks.push_back(boundParams2);
-
-  // track 3 :
-  BoundVector params3;
-  params3 << 0.368123382329940796, -20.0190258026123047, -3.06338405609130859,
-      0.214836537837982178, -7.34859349904581904e-05 * 1. / (1_MeV), 0;
-  Covariance covMat3;
-  covMat3 << 0.00247312174178659916, -0.000435264296712661316,
-      -7.28904508252383349e-05, -6.00209640313102993e-07,
-      -1.5146067160372626e-08 * 1. / (1_MeV), 0, -0.000435264296712661316,
-      0.0798703059554100037, 1.0091468480348509e-05, 9.74132025003542101e-05,
-      -1.07193522414496703e-09 * 1. / (1_MeV), 0, -7.28904508252383349e-05,
-      1.0091468480348509e-05, 2.19589765038108453e-06, 1.58931373903659957e-08,
-      7.46303764303131372e-10 * 1. / (1_MeV), 0, -6.00209640313102993e-07,
-      9.74132025003542101e-05, 1.58931373903659957e-08, 1.23175823318888433e-07,
-      3.22868607412569302e-13 * 1. / (1_MeV), 0,
-      -1.5146067160372626e-08 * 1. / (1_MeV),
-      -1.07193522414496703e-09 * 1. / (1_MeV),
-      7.46303764303131372e-10 * 1. / (1_MeV),
-      3.22868607412569302e-13 * 1. / (1_MeV),
-      6.43069972272591883e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams3 =
-      BoundParameters(tgContext, std::move(covMat3), params3, perigeeSurface);
-  tracks.push_back(boundParams3);
-
-  // track 4 :
-  BoundVector params4;
-  params4 << 0.462106257677078247, -45.3825263977050781, 1.54434430599212646,
-      0.558617532253265381, -3.18408128805458546e-05 * 1. / (1_MeV), 0;
-  Covariance covMat4;
-  covMat4 << 0.000138078830786980689, -4.74506524313709474e-06,
-      -2.59465406890078115e-06, -1.74446828994113136e-08,
-      -1.79858408809330508e-09 * 1. / (1_MeV), 0, -4.74506524313709474e-06,
-      0.00170238339342176914, 4.66287404599609629e-08, 6.20544387605423323e-06,
-      -4.15978667666583788e-10 * 1. / (1_MeV), 0, -2.59465406890078115e-06,
-      4.66287404599609629e-08, 5.59409834011148632e-08, 2.68972091189718476e-10,
-      4.44398634319667074e-11 * 1. / (1_MeV), 0, -1.74446828994113136e-08,
-      6.20544387605423323e-06, 2.68972091189718476e-10, 3.03028748760425515e-08,
-      -1.68471064059951095e-12 * 1. / (1_MeV), 0,
-      -1.79858408809330508e-09 * 1. / (1_MeV),
-      -4.15978667666583788e-10 * 1. / (1_MeV),
-      4.44398634319667074e-11 * 1. / (1_MeV),
-      -1.68471064059951095e-12 * 1. / (1_MeV),
-      5.01555231808420432e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams4 =
-      BoundParameters(tgContext, std::move(covMat4), params4, perigeeSurface);
-  tracks.push_back(boundParams4);
-
-  // track 5 :
-  BoundVector params5;
-  params5 << -0.243943929672241211, 0.680740892887115479, 0.597834229469299316,
-      0.471394985914230347, 0.000422831799369305372 * 1. / (1_MeV), 0;
-  Covariance covMat5;
-  covMat5 << 0.00671237893402576447, 5.08571871304874882e-05,
-      -0.000202164056117718448, 1.79538343147805643e-06,
-      -7.75962475463819757e-08 * 1. / (1_MeV), 0, 5.08571871304874882e-05,
-      0.0489778071641921997, -6.91368197228182291e-06, 0.000294139645283991724,
-      3.11541037258698699e-09 * 1. / (1_MeV), 0, -0.000202164056117718448,
-      -6.91368197228182291e-06, 6.17467458141618408e-06,
-      -8.53989223955858972e-08, 3.75976367980382885e-09 * 1. / (1_MeV), 0,
-      1.79538343147805643e-06, 0.000294139645283991724,
-      -8.53989223955858972e-08, 1.79972050773358205e-06,
-      2.80142049328043291e-12 * 1. / (1_MeV), 0,
-      -7.75962475463819757e-08 * 1. / (1_MeV),
-      3.11541037258698699e-09 * 1. / (1_MeV),
-      3.75976367980382885e-09 * 1. / (1_MeV),
-      2.80142049328043291e-12 * 1. / (1_MeV),
-      6.64618290957541547e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams5 =
-      BoundParameters(tgContext, std::move(covMat5), params5, perigeeSurface);
-  tracks.push_back(boundParams5);
-
-  // track 6 :
-  BoundVector params6;
-  params6 << 0.475236207246780396, -0.555901706218719482, -2.99527096748352051,
-      1.8675537109375, 0.000811780162621289492 * 1. / (1_MeV), 0;
-  Covariance covMat6;
-  covMat6 << 0.00304217985831201077, -2.25882172757928212e-05,
-      -8.97036319376342655e-05, -4.59106853961998723e-07,
-      -4.27624663748239102e-08 * 1. / (1_MeV), 0, -2.25882172757928212e-05,
-      0.00797311495989561081, 1.20376337146220198e-06, 0.000183945562259729228,
-      2.1216330790963481e-09 * 1. / (1_MeV), 0, -8.97036319376342655e-05,
-      1.20376337146220198e-06, 2.68421172222588211e-06, 2.66801954035878537e-08,
-      2.01812436010421032e-09 * 1. / (1_MeV), 0, -4.59106853961998723e-07,
-      0.000183945562259729228, 2.66801954035878537e-08, 4.72296460429788567e-06,
-      5.98997883150413798e-11 * 1. / (1_MeV), 0,
-      -4.27624663748239102e-08 * 1. / (1_MeV),
-      2.1216330790963481e-09 * 1. / (1_MeV),
-      2.01812436010421032e-09 * 1. / (1_MeV),
-      5.98997883150413798e-11 * 1. / (1_MeV),
-      7.336908858235347e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams6 =
-      BoundParameters(tgContext, std::move(covMat6), params6, perigeeSurface);
-  tracks.push_back(boundParams6);
-
-  // track 7 :
-  BoundVector params7;
-  params7 << 0.448179751634597778, -45.4515190124511719, 1.47425985336303711,
-      0.590856075286865234, 0.000101737932709511369 * 1. / (1_MeV), 0;
-  Covariance covMat7;
-  covMat7 << 0.000363267812645062804, -5.84171889726608582e-06,
-      -9.84987562994702426e-06, -3.80723442526054169e-08,
-      -5.40267153936386849e-09 * 1. / (1_MeV), 0, -5.84171889726608582e-06,
-      0.00307919480837881565, -5.80046399822108589e-08, 2.00901792637231817e-05,
-      -1.06284200946168232e-10 * 1. / (1_MeV), 0, -9.84987562994702426e-06,
-      -5.80046399822108589e-08, 2.79255488067065016e-07,
-      1.31849282891976127e-10, 2.35086178574079181e-10 * 1. / (1_MeV), 0,
-      -3.80723442526054169e-08, 2.00901792637231817e-05,
-      1.31849282891976127e-10, 1.53749851961038075e-07,
-      1.15397785221538584e-12 * 1. / (1_MeV), 0,
-      -5.40267153936386849e-09 * 1. / (1_MeV),
-      -1.06284200946168232e-10 * 1. / (1_MeV),
-      2.35086178574079181e-10 * 1. / (1_MeV),
-      1.15397785221538584e-12 * 1. / (1_MeV),
-      4.62566573586342678e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams7 =
-      BoundParameters(tgContext, std::move(covMat7), params7, perigeeSurface);
-  tracks.push_back(boundParams7);
-
-  // track 8 :
-  BoundVector params8;
-  params8 << -0.0999302864074707031, -28.5842227935791016, -1.68599784374237061,
-      0.212112680077552795, 0.000165652469149790704 * 1. / (1_MeV), 0;
-  Covariance covMat8;
-  covMat8 << 0.0116489045321941376, -0.000940270776104953194,
-      -0.000352319442915666192, -2.13370040931020126e-07,
-      -8.36209125013331952e-08 * 1. / (1_MeV), 0, -0.000940270776104953194,
-      0.291504502296447754, 8.5972731503188673e-06, 0.000378374215149366048,
-      5.11104877714145611e-09 * 1. / (1_MeV), 0, -0.000352319442915666192,
-      8.5972731503188673e-06, 1.08157237264094874e-05, -1.70526684678213333e-08,
-      4.01226430794326207e-09 * 1. / (1_MeV), 0, -2.13370040931020126e-07,
-      0.000378374215149366048, -1.70526684678213333e-08, 4.9813826308309217e-07,
-      7.61584071858783847e-13 * 1. / (1_MeV), 0,
-      -8.36209125013331952e-08 * 1. / (1_MeV),
-      5.11104877714145611e-09 * 1. / (1_MeV),
-      4.01226430794326207e-09 * 1. / (1_MeV),
-      7.61584071858783847e-13 * 1. / (1_MeV),
-      3.27873631023045675e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams8 =
-      BoundParameters(tgContext, std::move(covMat8), params8, perigeeSurface);
-  tracks.push_back(boundParams8);
-
-  // track 9 :
-  BoundVector params9;
-  params9 << 0.152172759175300598, -44.9148368835449219, 1.11447858810424805,
-      0.444638043642044067, -4.85752825625240803e-05 * 1. / (1_MeV), 0;
-  Covariance covMat9;
-  covMat9 << 0.000584102817811071873, -5.44941413560534802e-05,
-      -1.26293938525266511e-05, -1.64085737189133858e-07,
-      -2.36394827653963764e-09 * 1. / (1_MeV), 0, -5.44941413560534802e-05,
-      0.00448216451331973076, 1.03947024549991706e-06, 1.60899248222629787e-05,
-      -6.13962752714581741e-10 * 1. / (1_MeV), 0, -1.26293938525266511e-05,
-      1.03947024549991706e-06, 2.90120709678376443e-07, 3.39785893631303301e-09,
-      8.40703862829191019e-11 * 1. / (1_MeV), 0, -1.64085737189133858e-07,
-      1.60899248222629787e-05, 3.39785893631303301e-09, 6.88935983816918451e-08,
-      -1.33380435332641628e-12 * 1. / (1_MeV), 0,
-      -2.36394827653963764e-09 * 1. / (1_MeV),
-      -6.13962752714581741e-10 * 1. / (1_MeV),
-      8.40703862829191019e-11 * 1. / (1_MeV),
-      -1.33380435332641628e-12 * 1. / (1_MeV),
-      1.12903610072212501e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams9 =
-      BoundParameters(tgContext, std::move(covMat9), params9, perigeeSurface);
-  tracks.push_back(boundParams9);
-
-  // track 10 :
-  BoundVector params10;
-  params10 << -0.389045566320419312, -24.5613670349121094, -1.53248834609985352,
-      2.95340991020202637, 4.71094026579521596e-05 * 1. / (1_MeV), 0;
-  Covariance covMat10;
-  covMat10 << 0.00179947458673268557, 0.000515301817937796288,
-      -5.33457823139441806e-05, 3.56486698371958979e-07,
-      -1.94156960953159151e-08 * 1. / (1_MeV), 0, 0.000515301817937796288,
-      0.0590848624706268311, -1.31940455534009742e-05, 5.69552185596370288e-05,
-      -4.96614965526505315e-10 * 1. / (1_MeV), 0, -5.33457823139441806e-05,
-      -1.31940455534009742e-05, 1.63217691806494258e-06,
-      -8.93780411334805054e-09, 9.9924929691409935e-10 * 1. / (1_MeV), 0,
-      3.56486698371958979e-07, 5.69552185596370288e-05,
-      -8.93780411334805054e-09, 5.66441578087051312e-08,
-      1.78960551097981704e-12 * 1. / (1_MeV), 0,
-      -1.94156960953159151e-08 * 1. / (1_MeV),
-      -4.96614965526505315e-10 * 1. / (1_MeV),
-      9.9924929691409935e-10 * 1. / (1_MeV),
-      1.78960551097981704e-12 * 1. / (1_MeV),
-      7.76793473294956627e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams10 =
-      BoundParameters(tgContext, std::move(covMat10), params10, perigeeSurface);
-  tracks.push_back(boundParams10);
-
-  // track 11 :
-  BoundVector params11;
-  params11 << 0.185064643621444702, -0.313567250967025757, -2.70109248161315918,
-      1.87472164630889893, 0.00110536499414592981 * 1. / (1_MeV), 0;
-  Covariance covMat11;
-  covMat11 << 0.00607731565833091736, 1.88963384623831746e-05,
-      -0.000169582357508678549, -6.27965247220519728e-07,
-      -8.0749598939812492e-08 * 1. / (1_MeV), 0, 1.88963384623831746e-05,
-      0.0179781261831521988, 1.49729644512497734e-06, 0.00036414153838812695,
-      2.41630691182238931e-09 * 1. / (1_MeV), 0, -0.000169582357508678549,
-      1.49729644512497734e-06, 4.88961950395605527e-06, 5.74954357912554399e-08,
-      3.74836269648672209e-09 * 1. / (1_MeV), 0, -6.27965247220519728e-07,
-      0.00036414153838812695, 5.74954357912554399e-08, 8.48198396852239966e-06,
-      7.0596004861697542e-11 * 1. / (1_MeV), 0,
-      -8.0749598939812492e-08 * 1. / (1_MeV),
-      2.41630691182238931e-09 * 1. / (1_MeV),
-      3.74836269648672209e-09 * 1. / (1_MeV),
-      7.0596004861697542e-11 * 1. / (1_MeV),
-      1.38257211235170985e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams11 =
-      BoundParameters(tgContext, std::move(covMat11), params11, perigeeSurface);
-  tracks.push_back(boundParams11);
-
-  // track 12 :
-  BoundVector params12;
-  params12 << -0.706103920936584473, -8.715667724609375, -1.11427760124206543,
-      0.390437692403793335, -0.000532702077180147171 * 1. / (1_MeV), 0;
-  Covariance covMat12;
-  covMat12 << 0.0187691841274499893, -0.0011922780217786253,
-      -0.00057461193605452235, -3.44533681528817511e-06,
-      -4.01344704143888752e-07 * 1. / (1_MeV), 0, -0.0011922780217786253,
-      0.151490718126296997, 5.75941132180694864e-05, 0.000636005119141786097,
-      2.44353971236399676e-08 * 1. / (1_MeV), 0, -0.00057461193605452235,
-      5.75941132180694864e-05, 1.79298804141581059e-05, 1.93515522095858729e-07,
-      2.04097502268213299e-08 * 1. / (1_MeV), 0, -3.44533681528817511e-06,
-      0.000636005119141786097, 1.93515522095858729e-07, 2.72269880952080712e-06,
-      -8.79447815502355232e-13 * 1. / (1_MeV), 0,
-      -4.01344704143888752e-07 * 1. / (1_MeV),
-      2.44353971236399676e-08 * 1. / (1_MeV),
-      2.04097502268213299e-08 * 1. / (1_MeV),
-      -8.79447815502355232e-13 * 1. / (1_MeV),
-      3.13229303605666587e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams12 =
-      BoundParameters(tgContext, std::move(covMat12), params12, perigeeSurface);
-  tracks.push_back(boundParams12);
-
-  // track 13 :
-  BoundVector params13;
-  params13 << -0.154836609959602356, -20.9581050872802734, -2.51126766204833984,
-      2.93840575218200684, -0.000163531469297595322 * 1. / (1_MeV), 0;
-  Covariance covMat13;
-  covMat13 << 0.0135372020304203033, 0.000522583301631817797,
-      -0.000414465124389575392, 8.5218793332842329e-07,
-      -1.76418161813100027e-07 * 1. / (1_MeV), 0, 0.000522583301631817797,
-      0.337794691324234009, -3.07875272696438078e-05, 0.00040703982941800882,
-      -1.5122350796412209e-09 * 1. / (1_MeV), 0, -0.000414465124389575392,
-      -3.07875272696438078e-05, 1.29683203340391628e-05,
-      -4.41435125773279206e-08, 8.99447573145401141e-09 * 1. / (1_MeV), 0,
-      8.5218793332842329e-07, 0.00040703982941800882, -4.41435125773279206e-08,
-      4.96554378059954615e-07, 1.01639646010204121e-13 * 1. / (1_MeV), 0,
-      -1.76418161813100027e-07 * 1. / (1_MeV),
-      -1.5122350796412209e-09 * 1. / (1_MeV),
-      8.99447573145401141e-09 * 1. / (1_MeV),
-      1.01639646010204121e-13 * 1. / (1_MeV),
-      7.34017638337469691e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams13 =
-      BoundParameters(tgContext, std::move(covMat13), params13, perigeeSurface);
-  tracks.push_back(boundParams13);
-
-  // track 14 :
-  BoundVector params14;
-  params14 << 0.429115772247314453, -24.0853328704833984, -3.03889799118041992,
-      1.37072885036468506, -0.00179144914727658033 * 1. / (1_MeV), 0;
-  Covariance covMat14;
-  covMat14 << 0.011815081350505352, -4.35886846561170212e-05,
-      -0.000356196480791449814, -3.06510243603507525e-06,
-      -2.49215155156052749e-07 * 1. / (1_MeV), 0, -4.35886846561170212e-05,
-      0.0279703252017498016, 3.82172586877418007e-06, 0.000700707100556712979,
-      2.18971032423624985e-10 * 1. / (1_MeV), 0, -0.000356196480791449814,
-      3.82172586877418007e-06, 1.08708409243263304e-05, 1.60096981832880633e-07,
-      1.23485013066819254e-08 * 1. / (1_MeV), 0, -3.06510243603507525e-06,
-      0.000700707100556712979, 1.60096981832880633e-07, 1.87871864909538999e-05,
-      3.9118155474036915e-11 * 1. / (1_MeV), 0,
-      -2.49215155156052749e-07 * 1. / (1_MeV),
-      2.18971032423624985e-10 * 1. / (1_MeV),
-      1.23485013066819254e-08 * 1. / (1_MeV),
-      3.9118155474036915e-11 * 1. / (1_MeV),
-      4.91916063438679885e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams14 =
-      BoundParameters(tgContext, std::move(covMat14), params14, perigeeSurface);
-  tracks.push_back(boundParams14);
-
-  // track 15 :
-  BoundVector params15;
-  params15 << 0.0964239463210105896, -47.889434814453125, -2.51376533508300781,
-      0.37591966986656189, -7.28844097466208041e-05 * 1. / (1_MeV), 0;
-  Covariance covMat15;
-  covMat15 << 0.000915166805498301983, -5.63928610000066137e-05,
-      -2.30546935251043627e-05, -1.39514212094140237e-07,
-      -8.05606781506218595e-09 * 1. / (1_MeV), 0, -5.63928610000066137e-05,
-      0.00867577362805604935, 1.03957424061424194e-06, 2.75793322198900407e-05,
-      -3.50129287353289466e-11 * 1. / (1_MeV), 0, -2.30546935251043627e-05,
-      1.03957424061424194e-06, 6.37507866940723034e-07, 3.5300612609194207e-09,
-      3.32995301645455374e-10 * 1. / (1_MeV), 0, -1.39514212094140237e-07,
-      2.75793322198900407e-05, 3.5300612609194207e-09, 1.00911485390042799e-07,
-      -2.86168849963761193e-13 * 1. / (1_MeV), 0,
-      -8.05606781506218595e-09 * 1. / (1_MeV),
-      -3.50129287353289466e-11 * 1. / (1_MeV),
-      3.32995301645455374e-10 * 1. / (1_MeV),
-      -2.86168849963761193e-13 * 1. / (1_MeV),
-      3.81985762465397727e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams15 =
-      BoundParameters(tgContext, std::move(covMat15), params15, perigeeSurface);
-  tracks.push_back(boundParams15);
-
-  // track 16 :
-  BoundVector params16;
-  params16 << -1.083709716796875, -0.935704529285430908, -0.732377231121063232,
-      2.61545205116271973, -0.00085982074961066246 * 1. / (1_MeV), 0;
-  Covariance covMat16;
-  covMat16 << 0.020250808447599411, 0.00134430434697943471,
-      -0.000619652083316512593, 5.49275271760961433e-06,
-      -5.75555269925167598e-07 * 1. / (1_MeV), 0, 0.00134430434697943471,
-      0.0884110480546951294, -5.99276194628552559e-05, 0.000655524024191507732,
-      -5.54305280465676383e-08 * 1. / (1_MeV), 0, -0.000619652083316512593,
-      -5.99276194628552559e-05, 1.93270625459263101e-05,
-      -3.0658624571105338e-07, 2.90396851494721417e-08 * 1. / (1_MeV), 0,
-      5.49275271760961433e-06, 0.000655524024191507732, -3.0658624571105338e-07,
-      4.93054767503053881e-06, -1.14583522129541419e-10 * 1. / (1_MeV), 0,
-      -5.75555269925167598e-07 * 1. / (1_MeV),
-      -5.54305280465676383e-08 * 1. / (1_MeV),
-      2.90396851494721417e-08 * 1. / (1_MeV),
-      -1.14583522129541419e-10 * 1. / (1_MeV),
-      6.01911798181475888e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams16 =
-      BoundParameters(tgContext, std::move(covMat16), params16, perigeeSurface);
-  tracks.push_back(boundParams16);
-
-  // track 17 :
-  BoundVector params17;
-  params17 << -0.655812859535217285, -13.5116653442382812, -1.45666837692260742,
-      0.292341023683547974, -0.000473626889288425446 * 1. / (1_MeV), 0;
-  Covariance covMat17;
-  covMat17 << 0.0376270599663257599, -0.00331542860473353455,
-      -0.00114237259512064548, -6.46160583865347861e-06,
-      -5.41927356748457027e-07 * 1. / (1_MeV), 0, -0.00331542860473353455,
-      0.453363090753555298, 0.000154569181769570089, 0.00111683225416074725,
-      4.13684226275355482e-08 * 1. / (1_MeV), 0, -0.00114237259512064548,
-      0.000154569181769570089, 3.53331015503499657e-05, 3.31737366693554871e-07,
-      2.71004393542162535e-08 * 1. / (1_MeV), 0, -6.46160583865347861e-06,
-      0.00111683225416074725, 3.31737366693554871e-07, 2.77932576864259318e-06,
-      8.98558886340603463e-12 * 1. / (1_MeV), 0,
-      -5.41927356748457027e-07 * 1. / (1_MeV),
-      4.13684226275355482e-08 * 1. / (1_MeV),
-      2.71004393542162535e-08 * 1. / (1_MeV),
-      8.98558886340603463e-12 * 1. / (1_MeV),
-      3.11804027042228427e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams17 =
-      BoundParameters(tgContext, std::move(covMat17), params17, perigeeSurface);
-  tracks.push_back(boundParams17);
-
-  // track 18 :
-  BoundVector params18;
-  params18 << 0.575450718402862549, -15.9936590194702148, -2.98787665367126465,
-      0.166759386658668518, 9.08106376300565898e-05 * 1. / (1_MeV), 0;
-  Covariance covMat18;
-  covMat18 << 0.00828655995428562164, 0.000185564554592324227,
-      -0.000254140606495853623, -3.35073246108407e-07,
-      -1.308304405438276e-07 * 1. / (1_MeV), 0, 0.000185564554592324227,
-      0.291260480880737305, -1.50678458478300795e-05, 0.000236462002833863597,
-      -2.12250899201718451e-08 * 1. / (1_MeV), 0, -0.000254140606495853623,
-      -1.50678458478300795e-05, 8.0477584560867399e-06, 3.73422528117420346e-09,
-      6.7895997118531728e-09 * 1. / (1_MeV), 0, -3.35073246108407e-07,
-      0.000236462002833863597, 3.73422528117420346e-09, 1.94628071881197684e-07,
-      -1.03714183548395548e-12 * 1. / (1_MeV), 0,
-      -1.308304405438276e-07 * 1. / (1_MeV),
-      -2.12250899201718451e-08 * 1. / (1_MeV),
-      6.7895997118531728e-09 * 1. / (1_MeV),
-      -1.03714183548395548e-12 * 1. / (1_MeV),
-      4.68583748192141769e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams18 =
-      BoundParameters(tgContext, std::move(covMat18), params18, perigeeSurface);
-  tracks.push_back(boundParams18);
-
-  // track 19 :
-  BoundVector params19;
-  params19 << 0.450536131858825684, -45.6087112426757812, 1.54512977600097656,
-      0.65365976095199585, 5.42995185242034495e-05 * 1. / (1_MeV), 0;
-  Covariance covMat19;
-  covMat19 << 0.000259126914897933602, -7.71187497722190822e-06,
-      -5.15114709723808123e-06, -2.6619027249675935e-08,
-      -2.6312704155352256e-09 * 1. / (1_MeV), 0, -7.71187497722190822e-06,
-      0.00295044109225273132, 4.46207192501835153e-08, 1.36801867739356403e-05,
-      -6.77873236221157013e-10 * 1. / (1_MeV), 0, -5.15114709723808123e-06,
-      4.46207192501835153e-08, 1.1458803328423528e-07, 1.22672567207018586e-10,
-      8.3325729033356906e-11 * 1. / (1_MeV), 0, -2.6619027249675935e-08,
-      1.36801867739356403e-05, 1.22672567207018586e-10, 8.8454470414944808e-08,
-      -4.19827894841714947e-12 * 1. / (1_MeV), 0,
-      -2.6312704155352256e-09 * 1. / (1_MeV),
-      -6.77873236221157013e-10 * 1. / (1_MeV),
-      8.3325729033356906e-11 * 1. / (1_MeV),
-      -4.19827894841714947e-12 * 1. / (1_MeV),
-      1.43134245775278224e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams19 =
-      BoundParameters(tgContext, std::move(covMat19), params19, perigeeSurface);
-  tracks.push_back(boundParams19);
-
-  // track 20 :
-  BoundVector params20;
-  params20 << 0.473463654518127441, -26.5566444396972656, 2.22220945358276367,
-      2.8751678466796875, -0.000256116356467828155 * 1. / (1_MeV), 0;
-  Covariance covMat20;
-  covMat20 << 0.0143999364227056503, -6.2299028153707387e-05,
-      -0.000435219809783413591, 2.17336195005980567e-06,
-      -1.21769702441849882e-07 * 1. / (1_MeV), 0, -6.2299028153707387e-05,
-      0.225834131240844727, -9.51855047040289537e-06, 0.000458192287494221199,
-      1.25566461565313107e-08 * 1. / (1_MeV), 0, -0.000435219809783413591,
-      -9.51855047040289537e-06, 1.33511766762239859e-05,
-      -9.24405891210373471e-08, 6.00420036495892829e-09 * 1. / (1_MeV), 0,
-      2.17336195005980567e-06, 0.000458192287494221199,
-      -9.24405891210373471e-08, 9.43835061661957297e-07,
-      -1.98670297988379238e-12 * 1. / (1_MeV), 0,
-      -1.21769702441849882e-07 * 1. / (1_MeV),
-      1.25566461565313107e-08 * 1. / (1_MeV),
-      6.00420036495892829e-09 * 1. / (1_MeV),
-      -1.98670297988379238e-12 * 1. / (1_MeV),
-      6.28335161678705845e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams20 =
-      BoundParameters(tgContext, std::move(covMat20), params20, perigeeSurface);
-  tracks.push_back(boundParams20);
-
-  // track 21 :
-  BoundVector params21;
-  params21 << 0.474121242761611938, -45.3727645874023438, 1.55173587799072266,
-      0.574172139167785645, 5.4487241868628189e-05 * 1. / (1_MeV), 0;
-  Covariance covMat21;
-  covMat21 << 0.000224435978452675045, -3.34686356158648375e-08,
-      -4.87554553510472616e-06, -1.05072650608508861e-08,
-      -3.01031009155958153e-09 * 1. / (1_MeV), 0, -3.34686356158648375e-08,
-      0.00355649716220796108, -1.23797957582243194e-09, 1.29672827928777902e-05,
-      -5.29747367549304477e-10 * 1. / (1_MeV), 0, -4.87554553510472616e-06,
-      -1.23797957582243194e-09, 1.18275345073470817e-07,
-      1.10832502633235662e-10, 9.64028556852257677e-11 * 1. / (1_MeV), 0,
-      -1.05072650608508861e-08, 1.29672827928777902e-05,
-      1.10832502633235662e-10, 6.4137751110138197e-08,
-      -1.6225318684374243e-12 * 1. / (1_MeV), 0,
-      -3.01031009155958153e-09 * 1. / (1_MeV),
-      -5.29747367549304477e-10 * 1. / (1_MeV),
-      9.64028556852257677e-11 * 1. / (1_MeV),
-      -1.6225318684374243e-12 * 1. / (1_MeV),
-      1.46339776234405416e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams21 =
-      BoundParameters(tgContext, std::move(covMat21), params21, perigeeSurface);
-  tracks.push_back(boundParams21);
-
-  // track 22 :
-  BoundVector params22;
-  params22 << -1.09075939655303955, -45.9652023315429688, -1.37540817260742188,
-      2.04655265808105469, -3.31696282955817878e-05 * 1. / (1_MeV), 0;
-  Covariance covMat22;
-  covMat22 << 0.000312969175865873694, 0.0001463311972326757,
-      -3.44899335412854335e-06, 1.27787244910060675e-06,
-      -1.09905405688468608e-08 * 1. / (1_MeV), 0, 0.0001463311972326757,
-      0.00594136770814657211, -1.71895848646021814e-06, 4.22735853806673674e-05,
-      -1.192286442570364e-08 * 1. / (1_MeV), 0, -3.44899335412854335e-06,
-      -1.71895848646021814e-06, 4.42678249612526997e-08,
-      -1.47011582918932722e-08, 1.32897993796644671e-10 * 1. / (1_MeV), 0,
-      1.27787244910060675e-06, 4.22735853806673674e-05,
-      -1.47011582918932722e-08, 3.68511109627434053e-07,
-      -1.04379022097924494e-10 * 1. / (1_MeV), 0,
-      -1.09905405688468608e-08 * 1. / (1_MeV),
-      -1.192286442570364e-08 * 1. / (1_MeV),
-      1.32897993796644671e-10 * 1. / (1_MeV),
-      -1.04379022097924494e-10 * 1. / (1_MeV),
-      1.09507943078096526e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams22 =
-      BoundParameters(tgContext, std::move(covMat22), params22, perigeeSurface);
-  tracks.push_back(boundParams22);
-
-  // track 23 :
-  BoundVector params23;
-  params23 << -1.31657886505126953, -44.3285789489746094, -1.36793792247772217,
-      2.08678793907165527, -6.51905575068667531e-05 * 1. / (1_MeV), 0;
-  Covariance covMat23;
-  covMat23 << 0.000181945419171825051, -2.81234401866508066e-05,
-      -3.22076197235801949e-06, -7.63838237863357019e-08,
-      -3.46247467047687857e-09 * 1. / (1_MeV), 0, -2.81234401866508066e-05,
-      0.0078449668362736702, -1.27915101440830079e-07, 4.12960218865452011e-05,
-      -5.4435441037029841e-09 * 1. / (1_MeV), 0, -3.22076197235801949e-06,
-      -1.27915101440830079e-07, 6.53957670238014543e-08,
-      -1.06815947474639986e-09, 8.7867543161386892e-11 * 1. / (1_MeV), 0,
-      -7.63838237863357019e-08, 4.12960218865452011e-05,
-      -1.06815947474639986e-09, 3.63342195441873628e-07,
-      -5.37524150950671376e-11 * 1. / (1_MeV), 0,
-      -3.46247467047687857e-09 * 1. / (1_MeV),
-      -5.4435441037029841e-09 * 1. / (1_MeV),
-      8.7867543161386892e-11 * 1. / (1_MeV),
-      -5.37524150950671376e-11 * 1. / (1_MeV),
-      1.83543284737464063e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams23 =
-      BoundParameters(tgContext, std::move(covMat23), params23, perigeeSurface);
-  tracks.push_back(boundParams23);
-
-  // track 24 :
-  BoundVector params24;
-  params24 << 0.468431740999221802, -45.6113662719726562, 1.57319939136505127,
-      0.724432468414306641, -6.46604967187158763e-05 * 1. / (1_MeV), 0;
-  Covariance covMat24;
-  covMat24 << 0.000443243887275457382, -2.3272761085957688e-05,
-      -8.05724456303655931e-06, -1.10478345604928828e-07,
-      -5.12934471198391627e-09 * 1. / (1_MeV), 0, -2.3272761085957688e-05,
-      0.00292888842523097992, 2.09734580782484699e-07, 1.69251524164295596e-05,
-      2.63255285816454836e-10 * 1. / (1_MeV), 0, -8.05724456303655931e-06,
-      2.09734580782484699e-07, 1.72984968571654463e-07, 1.6524169254854016e-09,
-      1.09902161546833325e-10 * 1. / (1_MeV), 0, -1.10478345604928828e-07,
-      1.69251524164295596e-05, 1.6524169254854016e-09, 1.26708812331344234e-07,
-      1.02436393801765789e-12 * 1. / (1_MeV), 0,
-      -5.12934471198391627e-09 * 1. / (1_MeV),
-      2.63255285816454836e-10 * 1. / (1_MeV),
-      1.09902161546833325e-10 * 1. / (1_MeV),
-      1.02436393801765789e-12 * 1. / (1_MeV),
-      1.77089365307331326e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams24 =
-      BoundParameters(tgContext, std::move(covMat24), params24, perigeeSurface);
-  tracks.push_back(boundParams24);
-
-  // track 25 :
-  BoundVector params25;
-  params25 << 0.605970263481140137, -27.2015609741210938, 2.96404910087585449,
-      0.461374938488006592, -0.000201874907361343503 * 1. / (1_MeV), 0;
-  Covariance covMat25;
-  covMat25 << 0.00265368912369012833, -0.000160160863867693455,
-      -7.10252410690768288e-05, -1.03680404805919409e-06,
-      -2.01188254958249733e-08 * 1. / (1_MeV), 0, -0.000160160863867693455,
-      0.0171342100948095322, 3.50132547577921485e-06, 8.76344783019533907e-05,
-      7.09798679472868797e-10 * 1. / (1_MeV), 0, -7.10252410690768288e-05,
-      3.50132547577921485e-06, 1.98413022189924959e-06, 2.72794764037440166e-08,
-      8.99215162966161182e-10 * 1. / (1_MeV), 0, -1.03680404805919409e-06,
-      8.76344783019533907e-05, 2.72794764037440166e-08, 4.75305114377988502e-07,
-      8.86034124151153122e-12 * 1. / (1_MeV), 0,
-      -2.01188254958249733e-08 * 1. / (1_MeV),
-      7.09798679472868797e-10 * 1. / (1_MeV),
-      8.99215162966161182e-10 * 1. / (1_MeV),
-      8.86034124151153122e-12 * 1. / (1_MeV),
-      1.49597105536525277e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams25 =
-      BoundParameters(tgContext, std::move(covMat25), params25, perigeeSurface);
-  tracks.push_back(boundParams25);
-
-  // track 26 :
-  BoundVector params26;
-  params26 << 0.373259454965591431, -45.9041404724121094, -2.82848834991455078,
-      2.05866789817810059, -0.000124583908473141491 * 1. / (1_MeV), 0;
-  Covariance covMat26;
-  covMat26 << 0.000358323537511751056, 5.45377012590961527e-06,
-      -7.43998460263549215e-06, -2.04257445390517592e-08,
-      -2.8271193498608263e-09 * 1. / (1_MeV), 0, 5.45377012590961527e-06,
-      0.00235699070617556572, -1.65012257788975246e-07, 2.44201179406483771e-05,
-      -1.12260566358553804e-09 * 1. / (1_MeV), 0, -7.43998460263549215e-06,
-      -1.65012257788975246e-07, 1.71034542972847703e-07,
-      5.99568256402865656e-10, 9.80197960016773152e-11 * 1. / (1_MeV), 0,
-      -2.04257445390517592e-08, 2.44201179406483771e-05,
-      5.99568256402865656e-10, 4.42280850165843731e-07,
-      -1.97182050693094459e-11 * 1. / (1_MeV), 0,
-      -2.8271193498608263e-09 * 1. / (1_MeV),
-      -1.12260566358553804e-09 * 1. / (1_MeV),
-      9.80197960016773152e-11 * 1. / (1_MeV),
-      -1.97182050693094459e-11 * 1. / (1_MeV),
-      2.83151215148269575e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams26 =
-      BoundParameters(tgContext, std::move(covMat26), params26, perigeeSurface);
-  tracks.push_back(boundParams26);
-
-  // track 27 :
-  BoundVector params27;
-  params27 << 0.23818458616733551, -43.9735908508300781, 1.15663206577301025,
-      0.325361251831054688, -0.000120135584438685328 * 1. / (1_MeV), 0;
-  Covariance covMat27;
-  covMat27 << 0.00264720292761921883, -0.000279904810298890847,
-      -7.0787471462461463e-05, -6.09630619944338989e-07,
-      -2.72122881545780153e-08 * 1. / (1_MeV), 0, -0.000279904810298890847,
-      0.0381099320948123932, 6.2210670995119084e-06, 0.00010238674474765499,
-      8.91128192470317596e-11 * 1. / (1_MeV), 0, -7.0787471462461463e-05,
-      6.2210670995119084e-06, 1.99035594050656073e-06, 1.5641300493302086e-08,
-      1.26289836850190108e-09 * 1. / (1_MeV), 0, -6.09630619944338989e-07,
-      0.00010238674474765499, 1.5641300493302086e-08, 2.93358084491046611e-07,
-      2.02230046547630554e-12 * 1. / (1_MeV), 0,
-      -2.72122881545780153e-08 * 1. / (1_MeV),
-      8.91128192470317596e-11 * 1. / (1_MeV),
-      1.26289836850190108e-09 * 1. / (1_MeV),
-      2.02230046547630554e-12 * 1. / (1_MeV),
-      1.52509879725037933e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams27 =
-      BoundParameters(tgContext, std::move(covMat27), params27, perigeeSurface);
-  tracks.push_back(boundParams27);
-
-  // track 28 :
-  BoundVector params28;
-  params28 << 0.379233330488204956, -45.0619316101074219, 1.36501443386077881,
-      0.467382907867431641, 7.43830823921598494e-05 * 1. / (1_MeV), 0;
-  Covariance covMat28;
-  covMat28 << 0.000463021540781483054, -3.19743694997498169e-05,
-      -1.22576460878201678e-05, -1.17553161873688474e-07,
-      -5.1874231027619962e-09 * 1. / (1_MeV), 0, -3.19743694997498169e-05,
-      0.00478032277897000313, 1.17327598364092336e-07, 1.94133319938421418e-05,
-      -2.06704265685090959e-10 * 1. / (1_MeV), 0, -1.22576460878201678e-05,
-      1.17327598364092336e-07, 3.46005350593259209e-07, 1.4500069383794639e-09,
-      2.06696790491209021e-10 * 1. / (1_MeV), 0, -1.17553161873688474e-07,
-      1.94133319938421418e-05, 1.4500069383794639e-09, 9.33096515609577182e-08,
-      1.00703744558876763e-12 * 1. / (1_MeV), 0,
-      -5.1874231027619962e-09 * 1. / (1_MeV),
-      -2.06704265685090959e-10 * 1. / (1_MeV),
-      2.06696790491209021e-10 * 1. / (1_MeV),
-      1.00703744558876763e-12 * 1. / (1_MeV),
-      2.83601007261546911e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams28 =
-      BoundParameters(tgContext, std::move(covMat28), params28, perigeeSurface);
-  tracks.push_back(boundParams28);
-
-  // track 29 :
-  BoundVector params29;
-  params29 << 0.0437062010169029236, -6.05203485488891602, 0.845894753932952881,
-      2.40220952033996582, -0.00021497465786524117 * 1. / (1_MeV), 0;
-  Covariance covMat29;
-  covMat29 << 0.00100414641201496124, 7.52416013682256636e-05,
-      -2.59772254577332751e-05, 3.8490891938040421e-07,
-      -1.6676738431268612e-08 * 1. / (1_MeV), 0, 7.52416013682256636e-05,
-      0.00544706359505653381, -1.72766771292602573e-06, 4.92784133153511604e-05,
-      -1.22367109538203667e-09 * 1. / (1_MeV), 0, -2.59772254577332751e-05,
-      -1.72766771292602573e-06, 7.08758761902572587e-07,
-      -9.85089323790014416e-09, 6.84218014584375542e-10 * 1. / (1_MeV), 0,
-      3.8490891938040421e-07, 4.92784133153511604e-05, -9.85089323790014416e-09,
-      5.590306955127744e-07, -9.11246232266255587e-12 * 1. / (1_MeV), 0,
-      -1.6676738431268612e-08 * 1. / (1_MeV),
-      -1.22367109538203667e-09 * 1. / (1_MeV),
-      6.84218014584375542e-10 * 1. / (1_MeV),
-      -9.11246232266255587e-12 * 1. / (1_MeV),
-      1.55326706358094313e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams29 =
-      BoundParameters(tgContext, std::move(covMat29), params29, perigeeSurface);
-  tracks.push_back(boundParams29);
-
-  // track 30 :
-  BoundVector params30;
-  params30 << -0.517760396003723145, -46.0633049011230469, -1.40931129455566406,
-      1.87501537799835205, 0.000927834073081612587 * 1. / (1_MeV), 0;
-  Covariance covMat30;
-  covMat30 << 0.00338696571998298168, 2.2701516820957546e-05,
-      -0.000100746524188053817, -6.39718888889637967e-07,
-      -5.16928846777282941e-08 * 1. / (1_MeV), 0, 2.2701516820957546e-05,
-      0.0142748663201928139, 1.52136563622953833e-07, 0.000252430357142510112,
-      -3.20784296654136601e-10 * 1. / (1_MeV), 0, -0.000100746524188053817,
-      1.52136563622953833e-07, 3.04392483485571574e-06, 3.67106627303256195e-08,
-      2.52688458153465702e-09 * 1. / (1_MeV), 0, -6.39718888889637967e-07,
-      0.000252430357142510112, 3.67106627303256195e-08, 5.46493629371980205e-06,
-      9.90579325614409665e-12 * 1. / (1_MeV), 0,
-      -5.16928846777282941e-08 * 1. / (1_MeV),
-      -3.20784296654136601e-10 * 1. / (1_MeV),
-      2.52688458153465702e-09 * 1. / (1_MeV),
-      9.90579325614409665e-12 * 1. / (1_MeV),
-      9.43339711900748057e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams30 =
-      BoundParameters(tgContext, std::move(covMat30), params30, perigeeSurface);
-  tracks.push_back(boundParams30);
-
-  // track 31 :
-  BoundVector params31;
-  params31 << -0.525244832038879395, -0.217865616083145142,
-      -0.475070565938949585, 0.477265685796737671,
-      0.000297125487122684717 * 1. / (1_MeV), 0;
-  Covariance covMat31;
-  covMat31 << 0.00397888477891683578, -0.000295814951524862792,
-      -0.00011510871599225749, -1.88877208528145442e-07,
-      -3.65170360119058424e-08 * 1. / (1_MeV), 0, -0.000295814951524862792,
-      0.0287617519497871399, 4.36081614729639213e-06, 0.000165308229332130187,
-      2.86168612064016744e-09 * 1. / (1_MeV), 0, -0.00011510871599225749,
-      4.36081614729639213e-06, 3.41281020155292936e-06,
-      -1.47002165497313678e-08, 1.75686917916454533e-09 * 1. / (1_MeV), 0,
-      -1.88877208528145442e-07, 0.000165308229332130187,
-      -1.47002165497313678e-08, 9.93909566204820294e-07,
-      1.22169439162607638e-12 * 1. / (1_MeV), 0,
-      -3.65170360119058424e-08 * 1. / (1_MeV),
-      2.86168612064016744e-09 * 1. / (1_MeV),
-      1.75686917916454533e-09 * 1. / (1_MeV),
-      1.22169439162607638e-12 * 1. / (1_MeV),
-      3.16079003248592727e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams31 =
-      BoundParameters(tgContext, std::move(covMat31), params31, perigeeSurface);
-  tracks.push_back(boundParams31);
-
-  // track 32 :
-  BoundVector params32;
-  params32 << -0.164086505770683289, -37.753753662109375, -1.87344110012054443,
-      2.57577276229858398, 0.000515770167112350464 * 1. / (1_MeV), 0;
-  Covariance covMat32;
-  covMat32 << 0.00635964749380946159, 4.45514887833019807e-05,
-      -0.000193066686713004587, -9.8075773789463948e-07,
-      -1.543514422213774e-07 * 1. / (1_MeV), 0, 4.45514887833019807e-05,
-      0.0324134901165962219, 3.01616810351035857e-06, 0.000257514567093702538,
-      -4.60722406707723369e-09 * 1. / (1_MeV), 0, -0.000193066686713004587,
-      3.01616810351035857e-06, 5.97237203692202456e-06, 6.40635690248244268e-08,
-      7.82772160913690927e-09 * 1. / (1_MeV), 0, -9.8075773789463948e-07,
-      0.000257514567093702538, 6.40635690248244268e-08, 2.12554232348338701e-06,
-      -2.69885970530160845e-12 * 1. / (1_MeV), 0,
-      -1.543514422213774e-07 * 1. / (1_MeV),
-      -4.60722406707723369e-09 * 1. / (1_MeV),
-      7.82772160913690927e-09 * 1. / (1_MeV),
-      -2.69885970530160845e-12 * 1. / (1_MeV),
-      1.721506964758035e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams32 =
-      BoundParameters(tgContext, std::move(covMat32), params32, perigeeSurface);
-  tracks.push_back(boundParams32);
-
-  // track 33 :
-  BoundVector params33;
-  params33 << -0.422558963298797607, -25.4688777923583984, -1.69958257675170898,
-      2.64382648468017578, 0.00017704063793644309 * 1. / (1_MeV), 0;
-  Covariance covMat33;
-  covMat33 << 0.0013904899824410677, 0.000162016200161348015,
-      -3.89817331369023135e-05, 4.29909627029974153e-07,
-      -1.45160757016235074e-08 * 1. / (1_MeV), 0, 0.000162016200161348015,
-      0.0123065607622265816, -2.87947509703742562e-06, 6.703852723089744e-05,
-      -8.48754668083118025e-10 * 1. / (1_MeV), 0, -3.89817331369023135e-05,
-      -2.87947509703742562e-06, 1.12921497930074111e-06,
-      -4.83207911132727673e-09, 6.53490602957053302e-10 * 1. / (1_MeV), 0,
-      4.29909627029974153e-07, 6.703852723089744e-05, -4.83207911132727673e-09,
-      3.95028536104291561e-07, 5.22664500397267715e-13 * 1. / (1_MeV), 0,
-      -1.45160757016235074e-08 * 1. / (1_MeV),
-      -8.48754668083118025e-10 * 1. / (1_MeV),
-      6.53490602957053302e-10 * 1. / (1_MeV),
-      5.22664500397267715e-13 * 1. / (1_MeV),
-      1.14117890484544127e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams33 =
-      BoundParameters(tgContext, std::move(covMat33), params33, perigeeSurface);
-  tracks.push_back(boundParams33);
-
-  // track 34 :
-  BoundVector params34;
-  params34 << -0.706149637699127197, -5.55039787292480469, -1.03704202175140381,
-      2.66923093795776367, 0.000632659648545086384 * 1. / (1_MeV), 0;
-  Covariance covMat34;
-  covMat34 << 0.0149489222094416618, 0.000618369321077981275,
-      -0.000455378611332247401, -2.5954498544077396e-06,
-      -2.91043194495528445e-07 * 1. / (1_MeV), 0, 0.000618369321077981275,
-      0.0851441845297813416, -4.93271553790423069e-06, 0.0005094039417602418,
-      -2.83093285269249633e-08 * 1. / (1_MeV), 0, -0.000455378611332247401,
-      -4.93271553790423069e-06, 1.41044911288190633e-05,
-      1.63956270962265813e-07, 1.48782651378673617e-08 * 1. / (1_MeV), 0,
-      -2.5954498544077396e-06, 0.0005094039417602418, 1.63956270962265813e-07,
-      3.11431858790456317e-06, -8.52575602760203913e-12 * 1. / (1_MeV), 0,
-      -2.91043194495528445e-07 * 1. / (1_MeV),
-      -2.83093285269249633e-08 * 1. / (1_MeV),
-      1.48782651378673617e-08 * 1. / (1_MeV),
-      -8.52575602760203913e-12 * 1. / (1_MeV),
-      2.77564138340125055e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams34 =
-      BoundParameters(tgContext, std::move(covMat34), params34, perigeeSurface);
-  tracks.push_back(boundParams34);
-
-  // track 35 :
-  BoundVector params35;
-  params35 << 0.66977304220199585, -45.2442741394042969, 1.78884363174438477,
-      0.401856839656829834, 0.000140385964186862111 * 1. / (1_MeV), 0;
-  Covariance covMat35;
-  covMat35 << 0.00143626355566084385, -5.35207803621203505e-05,
-      -4.22572311413643752e-05, -3.20053881947622934e-07,
-      -4.44998922265500791e-08 * 1. / (1_MeV), 0, -5.35207803621203505e-05,
-      0.0170358996838331223, -9.72014409846223381e-08, 6.54062168950196484e-05,
-      -5.2860188976227197e-10 * 1. / (1_MeV), 0, -4.22572311413643752e-05,
-      -9.72014409846223381e-08, 1.28950614453060552e-06,
-      4.58471361676392425e-09, 2.07668118549997414e-09 * 1. / (1_MeV), 0,
-      -3.20053881947622934e-07, 6.54062168950196484e-05,
-      4.58471361676392425e-09, 2.676340216112294e-07,
-      8.60400887008258369e-12 * 1. / (1_MeV), 0,
-      -4.44998922265500791e-08 * 1. / (1_MeV),
-      -5.2860188976227197e-10 * 1. / (1_MeV),
-      2.07668118549997414e-09 * 1. / (1_MeV),
-      8.60400887008258369e-12 * 1. / (1_MeV),
-      3.06659697635325301e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams35 =
-      BoundParameters(tgContext, std::move(covMat35), params35, perigeeSurface);
-  tracks.push_back(boundParams35);
-
-  // track 36 :
-  BoundVector params36;
-  params36 << 0.413177251815795898, -44.2774276733398438, 1.65670633316040039,
-      0.282397657632827759, 0.000249879318289458752 * 1. / (1_MeV), 0;
-  Covariance covMat36;
-  covMat36 << 0.0265074372291564941, -0.0048766653213794765,
-      -0.000651586934053853908, -7.10144307243836228e-06,
-      -2.56150394427947489e-07 * 1. / (1_MeV), 0, -0.0048766653213794765,
-      0.360502183437347412, 6.96873463333104177e-05, 0.000667993313991547253,
-      3.22042667667872301e-08 * 1. / (1_MeV), 0, -0.000651586934053853908,
-      6.96873463333104177e-05, 1.68455553648527712e-05, 9.1205915360878042e-08,
-      9.93307233918962727e-09 * 1. / (1_MeV), 0, -7.10144307243836228e-06,
-      0.000667993313991547253, 9.1205915360878042e-08, 1.2959271771251224e-06,
-      5.92305231785808206e-11 * 1. / (1_MeV), 0,
-      -2.56150394427947489e-07 * 1. / (1_MeV),
-      3.22042667667872301e-08 * 1. / (1_MeV),
-      9.93307233918962727e-09 * 1. / (1_MeV),
-      5.92305231785808206e-11 * 1. / (1_MeV),
-      8.93205231999871785e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams36 =
-      BoundParameters(tgContext, std::move(covMat36), params36, perigeeSurface);
-  tracks.push_back(boundParams36);
-
-  // track 37 :
-  BoundVector params37;
-  params37 << 0.498688608407974243, -24.5804386138916016, 1.52300190925598145,
-      2.57985329627990723, -0.000602965301368385553 * 1. / (1_MeV), 0;
-  Covariance covMat37;
-  covMat37 << 0.00829706247895956039, -9.98736632524845883e-05,
-      -0.00024923303906360778, 1.90709718139177409e-06,
-      -7.88885613202604259e-08 * 1. / (1_MeV), 0, -9.98736632524845883e-05,
-      0.0392925664782524109, -2.2279263572824716e-06, 0.000312385200119348323,
-      4.01687609353752231e-09 * 1. / (1_MeV), 0, -0.00024923303906360778,
-      -2.2279263572824716e-06, 7.59069098421605304e-06,
-      -1.01456043862080861e-07, 4.11041373461571408e-09 * 1. / (1_MeV), 0,
-      1.90709718139177409e-06, 0.000312385200119348323,
-      -1.01456043862080861e-07, 2.56480029747763183e-06,
-      -2.55342842411113774e-12 * 1. / (1_MeV), 0,
-      -7.88885613202604259e-08 * 1. / (1_MeV),
-      4.01687609353752231e-09 * 1. / (1_MeV),
-      4.11041373461571408e-09 * 1. / (1_MeV),
-      -2.55342842411113774e-12 * 1. / (1_MeV),
-      9.23438478461768852e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams37 =
-      BoundParameters(tgContext, std::move(covMat37), params37, perigeeSurface);
-  tracks.push_back(boundParams37);
-
-  // track 38 :
-  BoundVector params38;
-  params38 << 0.136582925915718079, -4.81802463531494141, -2.5786285400390625,
-      2.42307066917419434, 0.000150643929373472929 * 1. / (1_MeV), 0;
-  Covariance covMat38;
-  covMat38 << 0.000507234770338982344, 2.1336988269281213e-05,
-      -1.35209599010707551e-05, 1.0410117459028839e-07,
-      -9.58138079071134127e-09 * 1. / (1_MeV), 0, 2.1336988269281213e-05,
-      0.00488950824365019798, -3.46387683816058679e-07, 3.650374061662458e-05,
-      -4.69743203747746844e-09 * 1. / (1_MeV), 0, -1.35209599010707551e-05,
-      -3.46387683816058679e-07, 3.77618221136799548e-07,
-      -1.29143148179678594e-09, 3.91247397541968152e-10 * 1. / (1_MeV), 0,
-      1.0410117459028839e-07, 3.650374061662458e-05, -1.29143148179678594e-09,
-      3.27887306639240705e-07, -2.82010017781291024e-11 * 1. / (1_MeV), 0,
-      -9.58138079071134127e-09 * 1. / (1_MeV),
-      -4.69743203747746844e-09 * 1. / (1_MeV),
-      3.91247397541968152e-10 * 1. / (1_MeV),
-      -2.82010017781291024e-11 * 1. / (1_MeV),
-      8.54110965980980907e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams38 =
-      BoundParameters(tgContext, std::move(covMat38), params38, perigeeSurface);
-  tracks.push_back(boundParams38);
-
-  // track 39 :
-  BoundVector params39;
-  params39 << 0.595804989337921143, -45.6078872680664062, 1.77534663677215576,
-      0.6340065598487854, 0.000248436292167752981 * 1. / (1_MeV), 0;
-  Covariance covMat39;
-  covMat39 << 0.00133234611712396145, -1.25221378814500536e-05,
-      -3.7965405863780084e-05, -1.36477460859891688e-07,
-      -1.64839701014251819e-08 * 1. / (1_MeV), 0, -1.25221378814500536e-05,
-      0.00918729789555072784, -6.07022323103743485e-07, 7.3648342192368039e-05,
-      -2.81287484533099953e-10 * 1. / (1_MeV), 0, -3.7965405863780084e-05,
-      -6.07022323103743485e-07, 1.113939106289763e-06, -2.37922716438868783e-09,
-      7.63262387403224464e-10 * 1. / (1_MeV), 0, -1.36477460859891688e-07,
-      7.3648342192368039e-05, -2.37922716438868783e-09, 6.66182188524544472e-07,
-      1.08505726379481843e-12 * 1. / (1_MeV), 0,
-      -1.64839701014251819e-08 * 1. / (1_MeV),
-      -2.81287484533099953e-10 * 1. / (1_MeV),
-      7.63262387403224464e-10 * 1. / (1_MeV),
-      1.08505726379481843e-12 * 1. / (1_MeV),
-      1.69044726133771306e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams39 =
-      BoundParameters(tgContext, std::move(covMat39), params39, perigeeSurface);
-  tracks.push_back(boundParams39);
-
-  // track 40 :
-  BoundVector params40;
-  params40 << 0.536075055599212646, -38.6850814819335938, 2.99125289916992188,
-      1.66691744327545166, -0.000342374085448682308 * 1. / (1_MeV), 0;
-  Covariance covMat40;
-  covMat40 << 0.00137188716325908899, 4.5762325967963918e-06,
-      -2.98856022058698631e-05, -7.0850830871642625e-08,
-      -1.97128857840108858e-08 * 1. / (1_MeV), 0, 4.5762325967963918e-06,
-      0.00638887425884604454, -1.76478143227192729e-07, 8.48770224160730878e-05,
-      -1.45698149891952607e-09 * 1. / (1_MeV), 0, -2.98856022058698631e-05,
-      -1.76478143227192729e-07, 7.38780101983138593e-07,
-      1.85882878019951661e-09, 6.72217443687235182e-10 * 1. / (1_MeV), 0,
-      -7.0850830871642625e-08, 8.48770224160730878e-05, 1.85882878019951661e-09,
-      1.77700985659612343e-06, -2.50821896355620095e-11 * 1. / (1_MeV), 0,
-      -1.97128857840108858e-08 * 1. / (1_MeV),
-      -1.45698149891952607e-09 * 1. / (1_MeV),
-      6.72217443687235182e-10 * 1. / (1_MeV),
-      -2.50821896355620095e-11 * 1. / (1_MeV),
-      1.938233948339807e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams40 =
-      BoundParameters(tgContext, std::move(covMat40), params40, perigeeSurface);
-  tracks.push_back(boundParams40);
-
-  // track 41 :
-  BoundVector params41;
-  params41 << -0.428327828645706177, -22.2199287414550781, 0.257566869258880615,
-      0.331243127584457397, -0.000147191138239577413 * 1. / (1_MeV), 0;
-  Covariance covMat41;
-  covMat41 << 0.00331501034088432789, -0.000402231679056904746,
-      -9.11024456904284614e-05, -5.25031012402464848e-07,
-      -3.85090693495478952e-08 * 1. / (1_MeV), 0, -0.000402231679056904746,
-      0.0420148223638534546, 1.02748198387320961e-05, 0.000127530944468113439,
-      5.32950012849014807e-10 * 1. / (1_MeV), 0, -9.11024456904284614e-05,
-      1.02748198387320961e-05, 2.61258151112997439e-06, 1.50109511208772318e-08,
-      1.78440131718612806e-09 * 1. / (1_MeV), 0, -5.25031012402464848e-07,
-      0.000127530944468113439, 1.50109511208772318e-08, 4.0045941318567202e-07,
-      -7.30460799902715398e-12 * 1. / (1_MeV), 0,
-      -3.85090693495478952e-08 * 1. / (1_MeV),
-      5.32950012849014807e-10 * 1. / (1_MeV),
-      1.78440131718612806e-09 * 1. / (1_MeV),
-      -7.30460799902715398e-12 * 1. / (1_MeV),
-      2.19001535656238033e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams41 =
-      BoundParameters(tgContext, std::move(covMat41), params41, perigeeSurface);
-  tracks.push_back(boundParams41);
-
-  // track 42 :
-  BoundVector params42;
-  params42 << 0.653292655944824219, -26.9052543640136719, 2.44972705841064453,
-      0.300775229930877686, -0.000126484796055592597 * 1. / (1_MeV), 0;
-  Covariance covMat42;
-  covMat42 << 0.00361175555735826492, -0.000145092938087995886,
-      -0.000101172023225305413, -8.20245834004805885e-07,
-      -4.59128816485603501e-08 * 1. / (1_MeV), 0, -0.000145092938087995886,
-      0.0409743189811706543, 3.61313611193146349e-06, 0.000101264190622654121,
-      -2.39200094119792923e-09 * 1. / (1_MeV), 0, -0.000101172023225305413,
-      3.61313611193146349e-06, 2.95380596071481705e-06, 2.49031335596621612e-08,
-      2.08122633356299761e-09 * 1. / (1_MeV), 0, -8.20245834004805885e-07,
-      0.000101264190622654121, 2.49031335596621612e-08, 2.5834717121142603e-07,
-      5.02372502596273887e-12 * 1. / (1_MeV), 0,
-      -4.59128816485603501e-08 * 1. / (1_MeV),
-      -2.39200094119792923e-09 * 1. / (1_MeV),
-      2.08122633356299761e-09 * 1. / (1_MeV),
-      5.02372502596273887e-12 * 1. / (1_MeV),
-      2.24156318506807395e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams42 =
-      BoundParameters(tgContext, std::move(covMat42), params42, perigeeSurface);
-  tracks.push_back(boundParams42);
-
-  // track 43 :
-  BoundVector params43;
-  params43 << 0.0787500590085983276, -5.06010723114013672, -2.50320339202880859,
-      2.27719211578369141, -0.000224699513637460768 * 1. / (1_MeV), 0;
-  Covariance covMat43;
-  covMat43 << 0.000872635049745440483, 2.94171319120868002e-05,
-      -2.12370270488864835e-05, 2.61547510497884302e-07,
-      -1.68371736189228777e-08 * 1. / (1_MeV), 0, 2.94171319120868002e-05,
-      0.00385157112032175064, -8.95594258975597383e-07, 3.97548389387994175e-05,
-      -6.99780771762925697e-09 * 1. / (1_MeV), 0, -2.12370270488864835e-05,
-      -8.95594258975597383e-07, 5.52114101992629003e-07,
-      -8.06623935930032111e-09, 6.36599567289482473e-10 * 1. / (1_MeV), 0,
-      2.61547510497884302e-07, 3.97548389387994175e-05,
-      -8.06623935930032111e-09, 5.23487074133299757e-07,
-      -6.36775855132313344e-11 * 1. / (1_MeV), 0,
-      -1.68371736189228777e-08 * 1. / (1_MeV),
-      -6.99780771762925697e-09 * 1. / (1_MeV),
-      6.36599567289482473e-10 * 1. / (1_MeV),
-      -6.36775855132313344e-11 * 1. / (1_MeV),
-      1.53753346859852869e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams43 =
-      BoundParameters(tgContext, std::move(covMat43), params43, perigeeSurface);
-  tracks.push_back(boundParams43);
-
-  // track 44 :
-  BoundVector params44;
-  params44 << -0.667890667915344238, -26.4306564331054688,
-      -0.519191086292266846, 1.6297152042388916,
-      0.000324116728734225035 * 1. / (1_MeV), 0;
-  Covariance covMat44;
-  covMat44 << 0.00108695926610380411, 7.82180373432526278e-06,
-      -2.48846267524919409e-05, -9.69900814831316844e-08,
-      -1.40750276354789122e-08 * 1. / (1_MeV), 0, 7.82180373432526278e-06,
-      0.00617291871458292007, -1.81813433580045645e-07, 7.85765795126072551e-05,
-      -3.23756334365082546e-09 * 1. / (1_MeV), 0, -2.48846267524919409e-05,
-      -1.81813433580045645e-07, 6.10426923230988905e-07,
-      1.84604413254372613e-09, 4.89069275340707137e-10 * 1. / (1_MeV), 0,
-      -9.69900814831316844e-08, 7.85765795126072551e-05,
-      1.84604413254372613e-09, 1.63906986472284188e-06,
-      -5.57887414635642927e-11 * 1. / (1_MeV), 0,
-      -1.40750276354789122e-08 * 1. / (1_MeV),
-      -3.23756334365082546e-09 * 1. / (1_MeV),
-      4.89069275340707137e-10 * 1. / (1_MeV),
-      -5.57887414635642927e-11 * 1. / (1_MeV),
-      1.4045833940379282e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams44 =
-      BoundParameters(tgContext, std::move(covMat44), params44, perigeeSurface);
-  tracks.push_back(boundParams44);
-
-  // track 45 :
-  BoundVector params45;
-  params45 << -0.476996541023254395, -10.2552490234375, -1.7952648401260376,
-      2.92429637908935547, -0.000136506365379318595 * 1. / (1_MeV), 0;
-  Covariance covMat45;
-  covMat45 << 0.00768429320305585861, 0.00109988557537010995,
-      -0.000231500581337145973, 9.1348816939045401e-07,
-      -5.63601372249975442e-08 * 1. / (1_MeV), 0, 0.00109988557537010995,
-      0.189449697732925415, -3.59507566995492182e-05, 0.000252646856270792965,
-      -5.46718705987526794e-09 * 1. / (1_MeV), 0, -0.000231500581337145973,
-      -3.59507566995492182e-05, 7.09176856616977602e-06,
-      -3.28587508657521865e-08, 2.79242397856570532e-09 * 1. / (1_MeV), 0,
-      9.1348816939045401e-07, 0.000252646856270792965, -3.28587508657521865e-08,
-      3.43827053939094185e-07, -6.9029270759318352e-13 * 1. / (1_MeV), 0,
-      -5.63601372249975442e-08 * 1. / (1_MeV),
-      -5.46718705987526794e-09 * 1. / (1_MeV),
-      2.79242397856570532e-09 * 1. / (1_MeV),
-      -6.9029270759318352e-13 * 1. / (1_MeV),
-      2.4027510883706249e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams45 =
-      BoundParameters(tgContext, std::move(covMat45), params45, perigeeSurface);
-  tracks.push_back(boundParams45);
-
-  // track 46 :
-  BoundVector params46;
-  params46 << -0.42024993896484375, -23.2919502258300781, -1.68882715702056885,
-      2.90132379531860352, 5.77600185351911932e-05 * 1. / (1_MeV), 0;
-  Covariance covMat46;
-  covMat46 << 0.00207295711152255535, 0.000908217743513093658,
-      -5.86378931102357517e-05, 1.21430336966273425e-06,
-      -1.06873090546652326e-08 * 1. / (1_MeV), 0, 0.000908217743513093658,
-      0.0524019971489906311, -2.13007825335927641e-05, 7.23961054167061288e-05,
-      -9.20706515105713893e-10 * 1. / (1_MeV), 0, -5.86378931102357517e-05,
-      -2.13007825335927641e-05, 1.70187172443547752e-06,
-      -2.99895102076280531e-08, 4.8877497815574335e-10 * 1. / (1_MeV), 0,
-      1.21430336966273425e-06, 7.23961054167061288e-05,
-      -2.99895102076280531e-08, 1.06208936756502226e-07,
-      5.48951242834580673e-13 * 1. / (1_MeV), 0,
-      -1.06873090546652326e-08 * 1. / (1_MeV),
-      -9.20706515105713893e-10 * 1. / (1_MeV),
-      4.8877497815574335e-10 * 1. / (1_MeV),
-      5.48951242834580673e-13 * 1. / (1_MeV),
-      4.31213008009190268e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams46 =
-      BoundParameters(tgContext, std::move(covMat46), params46, perigeeSurface);
-  tracks.push_back(boundParams46);
-
-  // track 47 :
-  BoundVector params47;
-  params47 << 0.099998176097869873, -28.7298069000244141, -2.47280740737915039,
-      0.362899661064147949, 0.000242739581153728068 * 1. / (1_MeV), 0;
-  Covariance covMat47;
-  covMat47 << 0.0060739489272236824, -0.000228269915109891231,
-      -0.000175137091140785308, -2.85641093745946927e-07,
-      -9.02268162913695653e-08 * 1. / (1_MeV), 0, -0.000228269915109891231,
-      0.0536332316696643829, 6.97667401826663415e-07, 0.000189819333742468862,
-      1.50668591753161066e-09 * 1. / (1_MeV), 0, -0.000175137091140785308,
-      6.97667401826663415e-07, 5.22334448760375381e-06,
-      -9.75788662698204661e-09, 4.53229459790751107e-09 * 1. / (1_MeV), 0,
-      -2.85641093745946927e-07, 0.000189819333742468862,
-      -9.75788662698204661e-09, 6.91088189341826364e-07,
-      3.54234059812463208e-12 * 1. / (1_MeV), 0,
-      -9.02268162913695653e-08 * 1. / (1_MeV),
-      1.50668591753161066e-09 * 1. / (1_MeV),
-      4.53229459790751107e-09 * 1. / (1_MeV),
-      3.54234059812463208e-12 * 1. / (1_MeV),
-      6.56103088525483713e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams47 =
-      BoundParameters(tgContext, std::move(covMat47), params47, perigeeSurface);
-  tracks.push_back(boundParams47);
-
-  // track 48 :
-  BoundVector params48;
-  params48 << -0.638817727565765381, -46.7263984680175781,
-      -0.0762649774551391602, 2.44958138465881348,
-      0.00033917097607627511 * 1. / (1_MeV), 0;
-  Covariance covMat48;
-  covMat48 << 0.00275217113085091114, 0.00021318761584315771,
-      -7.17503295784262051e-05, 5.19027545172934056e-07,
-      -3.27445192482216638e-08 * 1. / (1_MeV), 0, 0.00021318761584315771,
-      0.0129677252843976021, -3.76428307295029104e-06, 0.000116100785357966014,
-      -3.04730203134838935e-09 * 1. / (1_MeV), 0, -7.17503295784262051e-05,
-      -3.76428307295029104e-06, 1.9585518202802632e-06, 1.06617289122836538e-09,
-      1.3563696615201376e-09 * 1. / (1_MeV), 0, 5.19027545172934056e-07,
-      0.000116100785357966014, 1.06617289122836538e-09, 1.19973151413432788e-06,
-      -2.78975801873471684e-12 * 1. / (1_MeV), 0,
-      -3.27445192482216638e-08 * 1. / (1_MeV),
-      -3.04730203134838935e-09 * 1. / (1_MeV),
-      1.3563696615201376e-09 * 1. / (1_MeV),
-      -2.78975801873471684e-12 * 1. / (1_MeV),
-      2.97016820860473985e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams48 =
-      BoundParameters(tgContext, std::move(covMat48), params48, perigeeSurface);
-  tracks.push_back(boundParams48);
-
-  // track 49 :
-  BoundVector params49;
-  params49 << -0.64014434814453125, -46.3312034606933594, -1.05530393123626709,
-      1.65516412258148193, 6.55830517644062638e-05 * 1. / (1_MeV), 0;
-  Covariance covMat49;
-  covMat49 << 0.00014873131294734776, -3.25668154925161195e-06,
-      -2.57186509895848779e-06, 1.03651221484145729e-07,
-      -4.02098191895756443e-09 * 1. / (1_MeV), 0, -3.25668154925161195e-06,
-      0.00208531459793448448, -3.00105708930370322e-08, 2.31327739872350428e-05,
-      -3.79285333931827184e-10 * 1. / (1_MeV), 0, -2.57186509895848779e-06,
-      -3.00105708930370322e-08, 5.21384144747116807e-08,
-      -1.13043687468235159e-09, 8.74314611771519845e-11 * 1. / (1_MeV), 0,
-      1.03651221484145729e-07, 2.31327739872350428e-05,
-      -1.13043687468235159e-09, 4.8820493248058483e-07,
-      -9.77849218642090565e-12 * 1. / (1_MeV), 0,
-      -4.02098191895756443e-09 * 1. / (1_MeV),
-      -3.79285333931827184e-10 * 1. / (1_MeV),
-      8.74314611771519845e-11 * 1. / (1_MeV),
-      -9.77849218642090565e-12 * 1. / (1_MeV),
-      1.17200834540837073e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams49 =
-      BoundParameters(tgContext, std::move(covMat49), params49, perigeeSurface);
-  tracks.push_back(boundParams49);
-
-  // track 50 :
-  BoundVector params50;
-  params50 << 0.679204404354095459, -23.8228569030761719, 2.55430388450622559,
-      0.620291829109191895, -0.000398631149437278509 * 1. / (1_MeV), 0;
-  Covariance covMat50;
-  covMat50 << 0.00396185368299484253, -0.000125750330223895206,
-      -0.000109741625616368232, -1.77279611732068793e-06,
-      -4.59372500797877474e-08 * 1. / (1_MeV), 0, -0.000125750330223895206,
-      0.016484508290886879, 3.18639890004686668e-06, 0.000143314523991435627,
-      -9.97977172285195535e-10 * 1. / (1_MeV), 0, -0.000109741625616368232,
-      3.18639890004686668e-06, 3.15156694341567345e-06, 5.29784994588306965e-08,
-      2.0784715645265731e-09 * 1. / (1_MeV), 0, -1.77279611732068793e-06,
-      0.000143314523991435627, 5.29784994588306965e-08, 1.32396576191240456e-06,
-      7.96588919931270625e-12 * 1. / (1_MeV), 0,
-      -4.59372500797877474e-08 * 1. / (1_MeV),
-      -9.97977172285195535e-10 * 1. / (1_MeV),
-      2.0784715645265731e-09 * 1. / (1_MeV),
-      7.96588919931270625e-12 * 1. / (1_MeV),
-      4.46022628552977807e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams50 =
-      BoundParameters(tgContext, std::move(covMat50), params50, perigeeSurface);
-  tracks.push_back(boundParams50);
-
-  // track 51 :
-  BoundVector params51;
-  params51 << 0.0953129231929779053, -6.67084884643554688, 0.758422255516052246,
-      2.50242829322814941, 0.000553281046450138092 * 1. / (1_MeV), 0;
-  Covariance covMat51;
-  covMat51 << 0.00646894052624702454, 0.00018205583963275726,
-      -0.000184070642760310164, 4.01968699095653562e-07,
-      -7.26072619004993246e-08 * 1. / (1_MeV), 0, 0.00018205583963275726,
-      0.0242310706526041031, -2.67127070573839354e-07, 0.000235120330855929796,
-      -1.69241003100018407e-09 * 1. / (1_MeV), 0, -0.000184070642760310164,
-      -2.67127070573839354e-07, 5.39285929335164838e-06,
-      2.94062803351906824e-08, 3.36582393282827341e-09 * 1. / (1_MeV), 0,
-      4.01968699095653562e-07, 0.000235120330855929796, 2.94062803351906824e-08,
-      2.3894551759440219e-06, -7.96709832496419101e-12 * 1. / (1_MeV), 0,
-      -7.26072619004993246e-08 * 1. / (1_MeV),
-      -1.69241003100018407e-09 * 1. / (1_MeV),
-      3.36582393282827341e-09 * 1. / (1_MeV),
-      -7.96709832496419101e-12 * 1. / (1_MeV),
-      7.49710918346302435e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams51 =
-      BoundParameters(tgContext, std::move(covMat51), params51, perigeeSurface);
-  tracks.push_back(boundParams51);
-
-  // track 52 :
-  BoundVector params52;
-  params52 << 0.596444904804229736, -46.791473388671875, 2.81760692596435547,
-      0.466173619031906128, -4.01311117457225919e-05 * 1. / (1_MeV), 0;
-  Covariance covMat52;
-  covMat52 << 0.000178020185558125377, -1.20741123187898347e-05,
-      -4.47439657042341053e-06, -5.00683209793379036e-08,
-      -1.74763438138931432e-09 * 1. / (1_MeV), 0, -1.20741123187898347e-05,
-      0.00217202818021178246, 1.64534794833318549e-08, 7.73194260617184203e-06,
-      1.58039148376204822e-10 * 1. / (1_MeV), 0, -4.47439657042341053e-06,
-      1.64534794833318549e-08, 1.25094288705440704e-07, 9.26271094478818689e-10,
-      6.72005839541690491e-11 * 1. / (1_MeV), 0, -5.00683209793379036e-08,
-      7.73194260617184203e-06, 9.26271094478818689e-10, 3.52726665653335658e-08,
-      6.38826446714830372e-13 * 1. / (1_MeV), 0,
-      -1.74763438138931432e-09 * 1. / (1_MeV),
-      1.58039148376204822e-10 * 1. / (1_MeV),
-      6.72005839541690491e-11 * 1. / (1_MeV),
-      6.38826446714830372e-13 * 1. / (1_MeV),
-      8.76188607345368409e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams52 =
-      BoundParameters(tgContext, std::move(covMat52), params52, perigeeSurface);
-  tracks.push_back(boundParams52);
-
-  // track 53 :
-  BoundVector params53;
-  params53 << -0.509457647800445557, -6.32682275772094727, -1.33872759342193604,
-      0.491079181432723999, 0.00053247174946591258 * 1. / (1_MeV), 0;
-  Covariance covMat53;
-  covMat53 << 0.0100084031000733376, -0.000479280897979647135,
-      -0.000299479223647432344, 6.22369951852639685e-07,
-      -1.22423028040487334e-07 * 1. / (1_MeV), 0, -0.000479280897979647135,
-      0.0567438751459121704, 4.44730771047373873e-06, 0.000355637421562457208,
-      9.09945816895274824e-09 * 1. / (1_MeV), 0, -0.000299479223647432344,
-      4.44730771047373873e-06, 9.10697599465493113e-06,
-      -7.71163662653393619e-08, 5.96647706005148785e-09 * 1. / (1_MeV), 0,
-      6.22369951852639685e-07, 0.000355637421562457208,
-      -7.71163662653393619e-08, 2.29044917432474904e-06,
-      5.6513620234422192e-12 * 1. / (1_MeV), 0,
-      -1.22423028040487334e-07 * 1. / (1_MeV),
-      9.09945816895274824e-09 * 1. / (1_MeV),
-      5.96647706005148785e-09 * 1. / (1_MeV),
-      5.6513620234422192e-12 * 1. / (1_MeV),
-      1.10141243347960938e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams53 =
-      BoundParameters(tgContext, std::move(covMat53), params53, perigeeSurface);
-  tracks.push_back(boundParams53);
-
-  // track 54 :
-  BoundVector params54;
-  params54 << 0.0559646449983119965, -27.9413089752197266, -2.75167965888977051,
-      0.386726617813110352, -0.000363107450539246202 * 1. / (1_MeV), 0;
-  Covariance covMat54;
-  covMat54 << 0.00913079828023910522, -0.000177719306007508867,
-      -0.000277420127510917254, -1.59392792391846542e-06,
-      -1.63671693721281069e-07 * 1. / (1_MeV), 0, -0.000177719306007508867,
-      0.0778327509760856628, 1.14397241749803718e-05, 0.00031574579409467628,
-      -2.24438577982619877e-09 * 1. / (1_MeV), 0, -0.000277420127510917254,
-      1.14397241749803718e-05, 8.58535440784180537e-06, 7.52518631694262801e-08,
-      8.36903947194818426e-09 * 1. / (1_MeV), 0, -1.59392792391846542e-06,
-      0.00031574579409467628, 7.52518631694262801e-08, 1.31181081997056026e-06,
-      6.22930295116186707e-12 * 1. / (1_MeV), 0,
-      -1.63671693721281069e-07 * 1. / (1_MeV),
-      -2.24438577982619877e-09 * 1. / (1_MeV),
-      8.36903947194818426e-09 * 1. / (1_MeV),
-      6.22930295116186707e-12 * 1. / (1_MeV),
-      1.3151608968531292e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams54 =
-      BoundParameters(tgContext, std::move(covMat54), params54, perigeeSurface);
-  tracks.push_back(boundParams54);
-
-  // track 55 :
-  BoundVector params55;
-  params55 << 0.313830852508544922, -0.35525098443031311, -2.79895758628845215,
-      2.27995705604553223, 0.000609797949437052011 * 1. / (1_MeV), 0;
-  Covariance covMat55;
-  covMat55 << 0.0030504278838634491, -3.81297205072847354e-05,
-      -9.09237206775645104e-05, -8.09544327444282553e-07,
-      -5.66159970214913546e-08 * 1. / (1_MeV), 0, -3.81297205072847354e-05,
-      0.0142782162874937057, 2.63776141900322284e-06, 0.00018603481737948765,
-      1.51670403755547486e-09 * 1. / (1_MeV), 0, -9.09237206775645104e-05,
-      2.63776141900322284e-06, 2.75821184914093465e-06, 4.54309779123903346e-08,
-      2.79668441371068291e-09 * 1. / (1_MeV), 0, -8.09544327444282553e-07,
-      0.00018603481737948765, 4.54309779123903346e-08, 2.758416712822509e-06,
-      4.93865123861046129e-11 * 1. / (1_MeV), 0,
-      -5.66159970214913546e-08 * 1. / (1_MeV),
-      1.51670403755547486e-09 * 1. / (1_MeV),
-      2.79668441371068291e-09 * 1. / (1_MeV),
-      4.93865123861046129e-11 * 1. / (1_MeV),
-      8.41345951241301293e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams55 =
-      BoundParameters(tgContext, std::move(covMat55), params55, perigeeSurface);
-  tracks.push_back(boundParams55);
-
-  // track 56 :
-  BoundVector params56;
-  params56 << 0.155255094170570374, 5.48450565338134766, -2.57013368606567383,
-      2.0009157657623291, -0.00166504201479256153 * 1. / (1_MeV), 0;
-  Covariance covMat56;
-  covMat56 << 0.0131199266761541367, 0.000131623878451009752,
-      -0.000394009320893070269, 6.03472828037634446e-06,
-      -2.10906706685497427e-07 * 1. / (1_MeV), 0, 0.000131623878451009752,
-      0.0316174179315567017, -9.5725861230159473e-06, 0.000710392294531094187,
-      9.45078749853857351e-09 * 1. / (1_MeV), 0, -0.000394009320893070269,
-      -9.5725861230159473e-06, 1.19737778732087463e-05,
-      -3.15962032494940612e-07, 1.01155494796444282e-08 * 1. / (1_MeV), 0,
-      6.03472828037634446e-06, 0.000710392294531094187,
-      -3.15962032494940612e-07, 1.67491944011999294e-05,
-      1.71955939069872652e-10 * 1. / (1_MeV), 0,
-      -2.10906706685497427e-07 * 1. / (1_MeV),
-      9.45078749853857351e-09 * 1. / (1_MeV),
-      1.01155494796444282e-08 * 1. / (1_MeV),
-      1.71955939069872652e-10 * 1. / (1_MeV),
-      3.56558282899044343e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams56 =
-      BoundParameters(tgContext, std::move(covMat56), params56, perigeeSurface);
-  tracks.push_back(boundParams56);
-
-  // track 57 :
-  BoundVector params57;
-  params57 << 0.246611848473548889, -26.5061550140380859, -2.83754277229309082,
-      1.51932394504547119, 0.00129061494953930378 * 1. / (1_MeV), 0;
-  Covariance covMat57;
-  covMat57 << 0.00866833329200744629, 3.01401983869387291e-06,
-      -0.000239535524096211392, 2.72296952977166461e-07,
-      -1.26333629804036578e-07 * 1. / (1_MeV), 0, 3.01401983869387291e-06,
-      0.0214755143970251083, -5.52645836342027297e-07, 0.000483994911188721929,
-      -2.39220428270368834e-09 * 1. / (1_MeV), 0, -0.000239535524096211392,
-      -5.52645836342027297e-07, 6.85501072439365089e-06,
-      -1.80955198945319287e-08, 5.68860497435955863e-09 * 1. / (1_MeV), 0,
-      2.72296952977166461e-07, 0.000483994911188721929,
-      -1.80955198945319287e-08, 1.2657999832299538e-05,
-      -4.49134917661611488e-11 * 1. / (1_MeV), 0,
-      -1.26333629804036578e-07 * 1. / (1_MeV),
-      -2.39220428270368834e-09 * 1. / (1_MeV),
-      5.68860497435955863e-09 * 1. / (1_MeV),
-      -4.49134917661611488e-11 * 1. / (1_MeV),
-      2.06098235699947452e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams57 =
-      BoundParameters(tgContext, std::move(covMat57), params57, perigeeSurface);
-  tracks.push_back(boundParams57);
-
-  // track 58 :
-  BoundVector params58;
-  params58 << 0.753639280796051025, -6.00856494903564453, 2.30286669731140137,
-      0.268404930830001831, 0.000222592061618342996 * 1. / (1_MeV), 0;
-  Covariance covMat58;
-  covMat58 << 0.0102735972031950951, 0.000561483560818463708,
-      -0.00031188075048945189, 2.28136549511333255e-07,
-      -1.11255212859507957e-07 * 1. / (1_MeV), 0, 0.000561483560818463708,
-      0.171909451484680176, -3.10575259235835638e-05, 0.000346326413890911768,
-      -1.04190472154705827e-08 * 1. / (1_MeV), 0, -0.00031188075048945189,
-      -3.10575259235835638e-05, 9.61947171163046733e-06,
-      -3.25676596064154555e-08, 5.32616098447415082e-09 * 1. / (1_MeV), 0,
-      2.28136549511333255e-07, 0.000346326413890911768,
-      -3.25676596064154555e-08, 7.13259510121133644e-07,
-      1.99585598211435834e-12 * 1. / (1_MeV), 0,
-      -1.11255212859507957e-07 * 1. / (1_MeV),
-      -1.04190472154705827e-08 * 1. / (1_MeV),
-      5.32616098447415082e-09 * 1. / (1_MeV),
-      1.99585598211435834e-12 * 1. / (1_MeV),
-      5.44141676162013255e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams58 =
-      BoundParameters(tgContext, std::move(covMat58), params58, perigeeSurface);
-  tracks.push_back(boundParams58);
-
-  // track 59 :
-  BoundVector params59;
-  params59 << -0.740706324577331543, -26.4523181915283203, -0.33198884129524231,
-      1.24688541889190674, 0.00112402497325092554 * 1. / (1_MeV), 0;
-  Covariance covMat59;
-  covMat59 << 0.00939919613301753998, -0.000330953811817127669,
-      -0.000243319623521406008, -1.98870275046275838e-06,
-      -1.10875607601281475e-07 * 1. / (1_MeV), 0, -0.000330953811817127669,
-      0.0170400068163871765, 5.20070220108950583e-06, 0.000343470715600280925,
-      2.37905357060564215e-09 * 1. / (1_MeV), 0, -0.000243319623521406008,
-      5.20070220108950583e-06, 6.58395856589777395e-06,
-      -4.89928191758482858e-09, 4.48106445691990887e-09 * 1. / (1_MeV), 0,
-      -1.98870275046275838e-06, 0.000343470715600280925,
-      -4.89928191758482858e-09, 7.88109264249214903e-06,
-      1.57469333177652749e-11 * 1. / (1_MeV), 0,
-      -1.10875607601281475e-07 * 1. / (1_MeV),
-      2.37905357060564215e-09 * 1. / (1_MeV),
-      4.48106445691990887e-09 * 1. / (1_MeV),
-      1.57469333177652749e-11 * 1. / (1_MeV),
-      1.41142181275810685e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams59 =
-      BoundParameters(tgContext, std::move(covMat59), params59, perigeeSurface);
-  tracks.push_back(boundParams59);
-
-  // track 60 :
-  BoundVector params60;
-  params60 << 0.404530495405197144, -45.1964073181152344, 1.50114703178405762,
-      0.477049559354782104, 0.000178427377250045538 * 1. / (1_MeV), 0;
-  Covariance covMat60;
-  covMat60 << 0.00160884018987417221, 2.48786024325549841e-05,
-      -4.55158622795351621e-05, 5.27237356570212567e-08,
-      -1.71578397922792243e-08 * 1. / (1_MeV), 0, 2.48786024325549841e-05,
-      0.0133713036775588989, -1.47535371521175571e-06, 7.02707466725490158e-05,
-      -2.00878031112618562e-10 * 1. / (1_MeV), 0, -4.55158622795351621e-05,
-      -1.47535371521175571e-06, 1.33205401198210893e-06,
-      -5.17880198705678666e-09, 8.08198329216027338e-10 * 1. / (1_MeV), 0,
-      5.27237356570212567e-08, 7.02707466725490158e-05,
-      -5.17880198705678666e-09, 4.04392295649813605e-07,
-      1.74801379954387645e-12 * 1. / (1_MeV), 0,
-      -1.71578397922792243e-08 * 1. / (1_MeV),
-      -2.00878031112618562e-10 * 1. / (1_MeV),
-      8.08198329216027338e-10 * 1. / (1_MeV),
-      1.74801379954387645e-12 * 1. / (1_MeV),
-      1.40280183302810002e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams60 =
-      BoundParameters(tgContext, std::move(covMat60), params60, perigeeSurface);
-  tracks.push_back(boundParams60);
-
-  // track 61 :
-  BoundVector params61;
-  params61 << 0.481095165014266968, -45.3241767883300781, 1.63423991203308105,
-      0.527970552444458008, -0.000266404327703639865 * 1. / (1_MeV), 0;
-  Covariance covMat61;
-  covMat61 << 0.00288071134127676487, -0.000155863492110799547,
-      -7.77621373783901631e-05, -1.18027593530364395e-06,
-      -2.48196096965139494e-08 * 1. / (1_MeV), 0, -0.000155863492110799547,
-      0.0149536263197660446, 3.65078035069732869e-06, 9.743912874541411e-05,
-      8.37675468431534094e-11 * 1. / (1_MeV), 0, -7.77621373783901631e-05,
-      3.65078035069732869e-06, 2.18776540350518189e-06, 3.25560801512905163e-08,
-      1.08576617849883842e-09 * 1. / (1_MeV), 0, -1.18027593530364395e-06,
-      9.743912874541411e-05, 3.25560801512905163e-08, 6.77229820666980231e-07,
-      5.47754434165355313e-12 * 1. / (1_MeV), 0,
-      -2.48196096965139494e-08 * 1. / (1_MeV),
-      8.37675468431534094e-11 * 1. / (1_MeV),
-      1.08576617849883842e-09 * 1. / (1_MeV),
-      5.47754434165355313e-12 * 1. / (1_MeV),
-      1.96000368712923034e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams61 =
-      BoundParameters(tgContext, std::move(covMat61), params61, perigeeSurface);
-  tracks.push_back(boundParams61);
-
-  // track 62 :
-  BoundVector params62;
-  params62 << 0.46620604395866394, -39.1152420043945312, 2.9602348804473877,
-      2.54967498779296875, -0.000812723359558731318 * 1. / (1_MeV), 0;
-  Covariance covMat62;
-  covMat62 << 0.0155730284750461578, 0.00038755317191748362,
-      -0.000450653030958149533, 7.46684313401321562e-06,
-      -1.56837822709803982e-07 * 1. / (1_MeV), 0, 0.00038755317191748362,
-      0.0830775722861289978, -2.15848125497517351e-05, 0.000657707917473032439,
-      7.52506139410446467e-09 * 1. / (1_MeV), 0, -0.000450653030958149533,
-      -2.15848125497517351e-05, 1.33805215227766894e-05,
-      -3.1197420281739802e-07, 8.02502888738918489e-09 * 1. / (1_MeV), 0,
-      7.46684313401321562e-06, 0.000657707917473032439, -3.1197420281739802e-07,
-      5.4718084356863983e-06, -5.04380269074694918e-12 * 1. / (1_MeV), 0,
-      -1.56837822709803982e-07 * 1. / (1_MeV),
-      7.52506139410446467e-09 * 1. / (1_MeV),
-      8.02502888738918489e-09 * 1. / (1_MeV),
-      -5.04380269074694918e-12 * 1. / (1_MeV),
-      1.86463025575456243e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams62 =
-      BoundParameters(tgContext, std::move(covMat62), params62, perigeeSurface);
-  tracks.push_back(boundParams62);
-
-  // track 63 :
-  BoundVector params63;
-  params63 << -0.645694375038146973, -45.9093971252441406, -1.42855286598205566,
-      2.14151239395141602, -0.000308145768940448761 * 1. / (1_MeV), 0;
-  Covariance covMat63;
-  covMat63 << 0.00141701370012015104, 8.16846515917965093e-05,
-      -3.3697989251933814e-05, 6.17724276590095669e-07,
-      -1.6156751085000028e-08 * 1. / (1_MeV), 0, 8.16846515917965093e-05,
-      0.00634454051032662392, -2.08952126392131457e-06, 7.15744916836027302e-05,
-      -1.49091147779785594e-09 * 1. / (1_MeV), 0, -3.3697989251933814e-05,
-      -2.08952126392131457e-06, 8.4832106495014159e-07,
-      -1.64115671055080147e-08, 5.9837667986473886e-10 * 1. / (1_MeV), 0,
-      6.17724276590095669e-07, 7.15744916836027302e-05,
-      -1.64115671055080147e-08, 1.0292989145455067e-06,
-      -1.46674673345839605e-11 * 1. / (1_MeV), 0,
-      -1.6156751085000028e-08 * 1. / (1_MeV),
-      -1.49091147779785594e-09 * 1. / (1_MeV),
-      5.9837667986473886e-10 * 1. / (1_MeV),
-      -1.46674673345839605e-11 * 1. / (1_MeV),
-      1.54105235516954764e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams63 =
-      BoundParameters(tgContext, std::move(covMat63), params63, perigeeSurface);
-  tracks.push_back(boundParams63);
-
-  // track 64 :
-  BoundVector params64;
-  params64 << -0.608972728252410889, -0.205871865153312683,
-      -0.337655186653137207, 0.617485642433166504,
-      0.000326765264617279172 * 1. / (1_MeV), 0;
-  Covariance covMat64;
-  covMat64 << 0.00256323744542896748, -0.000102964159443142377,
-      -7.43746711326680654e-05, 2.77199836373549426e-07,
-      -3.16870017552968717e-08 * 1. / (1_MeV), 0, -0.000102964159443142377,
-      0.0179459210485219955, 9.927183095141406e-07, 0.000150291132415494166,
-      1.84401452515339684e-09 * 1. / (1_MeV), 0, -7.43746711326680654e-05,
-      9.927183095141406e-07, 2.20178139898052905e-06, -2.23963294945635655e-08,
-      1.42819207588526508e-09 * 1. / (1_MeV), 0, 2.77199836373549426e-07,
-      0.000150291132415494166, -2.23963294945635655e-08,
-      1.36840594677778427e-06, 1.15087456059600686e-12 * 1. / (1_MeV), 0,
-      -3.16870017552968717e-08 * 1. / (1_MeV),
-      1.84401452515339684e-09 * 1. / (1_MeV),
-      1.42819207588526508e-09 * 1. / (1_MeV),
-      1.15087456059600686e-12 * 1. / (1_MeV),
-      2.95290424057181866e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams64 =
-      BoundParameters(tgContext, std::move(covMat64), params64, perigeeSurface);
-  tracks.push_back(boundParams64);
-
-  // track 65 :
-  BoundVector params65;
-  params65 << -0.651330411434173584, -46.6501655578613281,
-      -0.162742897868156433, 2.37663960456848145,
-      0.000465616496512666345 * 1. / (1_MeV), 0;
-  Covariance covMat65;
-  covMat65 << 0.00349642685614526272, 0.000141372948412694558,
-      -9.42089049286210813e-05, 1.58411676533929063e-07,
-      -5.51507903718466048e-08 * 1. / (1_MeV), 0, 0.000141372948412694558,
-      0.0145636545494198799, -1.8376679472879644e-06, 0.000159144530910216837,
-      -9.77799777456030559e-10 * 1. / (1_MeV), 0, -9.42089049286210813e-05,
-      -1.8376679472879644e-06, 2.6513741886446951e-06, 1.6927620638758599e-08,
-      2.44350119045523328e-09 * 1. / (1_MeV), 0, 1.58411676533929063e-07,
-      0.000159144530910216837, 1.6927620638758599e-08, 1.91570370589033701e-06,
-      2.43993447359552124e-11 * 1. / (1_MeV), 0,
-      -5.51507903718466048e-08 * 1. / (1_MeV),
-      -9.77799777456030559e-10 * 1. / (1_MeV),
-      2.44350119045523328e-09 * 1. / (1_MeV),
-      2.43993447359552124e-11 * 1. / (1_MeV),
-      6.30697091774656826e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams65 =
-      BoundParameters(tgContext, std::move(covMat65), params65, perigeeSurface);
-  tracks.push_back(boundParams65);
-
-  // track 66 :
-  BoundVector params66;
-  params66 << 0.64414292573928833, -37.8168792724609375, 1.41348385810852051,
-      0.628789603710174561, -0.000711047730874270201 * 1. / (1_MeV), 0;
-  Covariance covMat66;
-  covMat66 << 0.00865435414016246796, 4.30179014559714792e-05,
-      -0.000260259753258794142, -2.77364333528555447e-06,
-      -1.18175630051794391e-07 * 1. / (1_MeV), 0, 4.30179014559714792e-05,
-      0.0385085344314575195, 3.5186803309031585e-06, 0.000362887855399699421,
-      -6.57911033053770427e-09 * 1. / (1_MeV), 0, -0.000260259753258794142,
-      3.5186803309031585e-06, 7.93121216702274978e-06, 1.35170575721091198e-07,
-      5.61496221132519249e-09 * 1. / (1_MeV), 0, -2.77364333528555447e-06,
-      0.000362887855399699421, 1.35170575721091198e-07, 3.55381462213699706e-06,
-      -1.76572689736880453e-12 * 1. / (1_MeV), 0,
-      -1.18175630051794391e-07 * 1. / (1_MeV),
-      -6.57911033053770427e-09 * 1. / (1_MeV),
-      5.61496221132519249e-09 * 1. / (1_MeV),
-      -1.76572689736880453e-12 * 1. / (1_MeV),
-      1.27183083509230244e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams66 =
-      BoundParameters(tgContext, std::move(covMat66), params66, perigeeSurface);
-  tracks.push_back(boundParams66);
-
-  // track 67 :
-  BoundVector params67;
-  params67 << -0.332721292972564697, -22.5682830810546875, 0.226930230855941772,
-      0.439133286476135254, 0.000341838604072108865 * 1. / (1_MeV), 0;
-  Covariance covMat67;
-  covMat67 << 0.00658620009198784828, -0.000468461936445102546,
-      -0.000190280257733648498, -8.77654618295631542e-07,
-      -7.41082017465768966e-08 * 1. / (1_MeV), 0, -0.000468461936445102546,
-      0.0421695522964000702, 8.37362681235735137e-06, 0.000212639250704076973,
-      5.59919585012054894e-09 * 1. / (1_MeV), 0, -0.000190280257733648498,
-      8.37362681235735137e-06, 5.653947482642252e-06, 2.05904961050614474e-09,
-      3.61592933955667245e-09 * 1. / (1_MeV), 0, -8.77654618295631542e-07,
-      0.000212639250704076973, 2.05904961050614474e-09, 1.10556209165224573e-06,
-      9.31555819953937805e-12 * 1. / (1_MeV), 0,
-      -7.41082017465768966e-08 * 1. / (1_MeV),
-      5.59919585012054894e-09 * 1. / (1_MeV),
-      3.61592933955667245e-09 * 1. / (1_MeV),
-      9.31555819953937805e-12 * 1. / (1_MeV),
-      6.02211544520336872e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams67 =
-      BoundParameters(tgContext, std::move(covMat67), params67, perigeeSurface);
-  tracks.push_back(boundParams67);
-
-  // track 68 :
-  BoundVector params68;
-  params68 << 0.228807628154754639, -45.5291328430175781, 1.88212299346923828,
-      0.391405045986175537, -0.000272470730124041438 * 1. / (1_MeV), 0;
-  Covariance covMat68;
-  covMat68 << 0.00558751169592142105, -0.000526476410891340272,
-      -0.000165610234749681399, -2.61479347877094164e-06,
-      -6.61682300501314344e-08 * 1. / (1_MeV), 0, -0.000526476410891340272,
-      0.0537347830832004547, 1.60095985217531436e-05, 0.000211228233160033968,
-      -7.3861724702695647e-11 * 1. / (1_MeV), 0, -0.000165610234749681399,
-      1.60095985217531436e-05, 4.99409998155897483e-06, 8.27335653273563984e-08,
-      3.08626652913981362e-09 * 1. / (1_MeV), 0, -2.61479347877094164e-06,
-      0.000211228233160033968, 8.27335653273563984e-08, 8.58062662700831424e-07,
-      9.8161963481123767e-12 * 1. / (1_MeV), 0,
-      -6.61682300501314344e-08 * 1. / (1_MeV),
-      -7.3861724702695647e-11 * 1. / (1_MeV),
-      3.08626652913981362e-09 * 1. / (1_MeV),
-      9.8161963481123767e-12 * 1. / (1_MeV),
-      4.41570460751883331e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams68 =
-      BoundParameters(tgContext, std::move(covMat68), params68, perigeeSurface);
-  tracks.push_back(boundParams68);
-
-  // track 69 :
-  BoundVector params69;
-  params69 << -0.774779915809631348, -7.18358039855957031, -1.68472623825073242,
-      0.294571459293365479, -0.00012300643720664084 * 1. / (1_MeV), 0;
-  Covariance covMat69;
-  covMat69 << 0.00796640384942293167, -0.00308066711056936707,
-      -0.000183902465217028856, -4.40322681469892384e-06,
-      -4.28751518274954345e-08 * 1. / (1_MeV), 0, -0.00308066711056936707,
-      0.256041616201400757, 7.1248927562660272e-05, 0.000440831013812017375,
-      7.95526672562874677e-09 * 1. / (1_MeV), 0, -0.000183902465217028856,
-      7.1248927562660272e-05, 4.48159107691026293e-06, 1.02520016937503953e-07,
-      1.75117724904492434e-09 * 1. / (1_MeV), 0, -4.40322681469892384e-06,
-      0.000440831013812017375, 1.02520016937503953e-07, 7.90239880643639481e-07,
-      6.37842082317695236e-12 * 1. / (1_MeV), 0,
-      -4.28751518274954345e-08 * 1. / (1_MeV),
-      7.95526672562874677e-09 * 1. / (1_MeV),
-      1.75117724904492434e-09 * 1. / (1_MeV),
-      6.37842082317695236e-12 * 1. / (1_MeV),
-      1.73160132066474404e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams69 =
-      BoundParameters(tgContext, std::move(covMat69), params69, perigeeSurface);
-  tracks.push_back(boundParams69);
-
-  // track 70 :
-  BoundVector params70;
-  params70 << -0.799591720104217529, -4.63163089752197266, 0.405971020460128784,
-      0.378831923007965088, 0.000591743737459182739 * 1. / (1_MeV), 0;
-  Covariance covMat70;
-  covMat70 << 0.0266661942005157471, -0.00183957268711347835,
-      -0.000807137683582467521, 3.8442389767195023e-06,
-      -3.49680195741055849e-07 * 1. / (1_MeV), 0, -0.00183957268711347835,
-      0.211709365248680115, 1.93959104101635743e-05, 0.000855412169330214186,
-      4.91598206364535424e-08 * 1. / (1_MeV), 0, -0.000807137683582467521,
-      1.93959104101635743e-05, 2.48053565883310512e-05,
-      -2.62219580174192418e-07, 1.76141434145594417e-08 * 1. / (1_MeV), 0,
-      3.8442389767195023e-06, 0.000855412169330214186, -2.62219580174192418e-07,
-      3.50158666151401121e-06, 8.73307509198330779e-12 * 1. / (1_MeV), 0,
-      -3.49680195741055849e-07 * 1. / (1_MeV),
-      4.91598206364535424e-08 * 1. / (1_MeV),
-      1.76141434145594417e-08 * 1. / (1_MeV),
-      8.73307509198330779e-12 * 1. / (1_MeV),
-      2.64328670063207483e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams70 =
-      BoundParameters(tgContext, std::move(covMat70), params70, perigeeSurface);
-  tracks.push_back(boundParams70);
-
-  // track 71 :
-  BoundVector params71;
-  params71 << -0.600866556167602539, -46.0752182006835938, -1.38232946395874023,
-      2.03518390655517578, 0.000216916509089060128 * 1. / (1_MeV), 0;
-  Covariance covMat71;
-  covMat71 << 0.000447078287834301591, 6.4246307431772498e-06,
-      -1.22906651502427452e-05, -1.99116263412532374e-09,
-      -1.43109528065029844e-08 * 1. / (1_MeV), 0, 6.4246307431772498e-06,
-      0.00480788340792059898, -5.87978219682613621e-08, 5.37988074894698367e-05,
-      -1.93974344917808111e-09 * 1. / (1_MeV), 0, -1.22906651502427452e-05,
-      -5.87978219682613621e-08, 3.57868174205577816e-07, 1.5805389300162696e-09,
-      6.29499582429645186e-10 * 1. / (1_MeV), 0, -1.99116263412532374e-09,
-      5.37988074894698367e-05, 1.5805389300162696e-09, 7.68185657307185465e-07,
-      -6.71150128191831827e-12 * 1. / (1_MeV), 0,
-      -1.43109528065029844e-08 * 1. / (1_MeV),
-      -1.93974344917808111e-09 * 1. / (1_MeV),
-      6.29499582429645186e-10 * 1. / (1_MeV),
-      -6.71150128191831827e-12 * 1. / (1_MeV),
-      1.96153805004373183e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams71 =
-      BoundParameters(tgContext, std::move(covMat71), params71, perigeeSurface);
-  tracks.push_back(boundParams71);
-
-  // track 72 :
-  BoundVector params72;
-  params72 << 0.934263527393341064, -26.3208255767822266, 2.37594270706176758,
-      2.72768449783325195, 0.000554551603272557259 * 1. / (1_MeV), 0;
-  Covariance covMat72;
-  covMat72 << 0.0188611242920160294, -0.00121691842277711322,
-      -0.000576619514959964973, -2.82991619355262503e-06,
-      -4.0010412648847567e-07 * 1. / (1_MeV), 0, -0.00121691842277711322,
-      0.123724676668643951, 5.66678562685891124e-05, 0.000592259000642492389,
-      3.76165411298313188e-08 * 1. / (1_MeV), 0, -0.000576619514959964973,
-      5.66678562685891124e-05, 1.79301478056004271e-05, 1.75725099274939068e-07,
-      1.9855251791033252e-08 * 1. / (1_MeV), 0, -2.82991619355262503e-06,
-      0.000592259000642492389, 1.75725099274939068e-07, 2.86794875137275085e-06,
-      1.52908464521253004e-11 * 1. / (1_MeV), 0,
-      -4.0010412648847567e-07 * 1. / (1_MeV),
-      3.76165411298313188e-08 * 1. / (1_MeV),
-      1.9855251791033252e-08 * 1. / (1_MeV),
-      1.52908464521253004e-11 * 1. / (1_MeV),
-      3.20209747606270412e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams72 =
-      BoundParameters(tgContext, std::move(covMat72), params72, perigeeSurface);
-  tracks.push_back(boundParams72);
-
-  // track 73 :
-  BoundVector params73;
-  params73 << 0.730206131935119629, -0.356079369783401489, 1.74193072319030762,
-      0.789627969264984131, 0.000864426896441727877 * 1. / (1_MeV), 0;
-  Covariance covMat73;
-  covMat73 << 0.00696328096091747284, 0.000192718431767054029,
-      -0.000210651783787634309, 1.79142534806142213e-06,
-      -1.60408967532742937e-07 * 1. / (1_MeV), 0, 0.000192718431767054029,
-      0.0250711347907781601, -1.01345165607011824e-05, 0.000326248033176201218,
-      -2.92212069047691244e-09 * 1. / (1_MeV), 0, -0.000210651783787634309,
-      -1.01345165607011824e-05, 6.47193519398570061e-06,
-      -1.10382166450068239e-07, 7.86957679995017337e-09 * 1. / (1_MeV), 0,
-      1.79142534806142213e-06, 0.000326248033176201218,
-      -1.10382166450068239e-07, 4.4890334720548708e-06,
-      1.43532649831609989e-11 * 1. / (1_MeV), 0,
-      -1.60408967532742937e-07 * 1. / (1_MeV),
-      -2.92212069047691244e-09 * 1. / (1_MeV),
-      7.86957679995017337e-09 * 1. / (1_MeV),
-      1.43532649831609989e-11 * 1. / (1_MeV),
-      2.18980167332460951e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams73 =
-      BoundParameters(tgContext, std::move(covMat73), params73, perigeeSurface);
-  tracks.push_back(boundParams73);
-
-  // track 74 :
-  BoundVector params74;
-  params74 << -0.697826266288757324, -23.5827674865722656,
-      -0.712247550487518311, 0.6665802001953125,
-      0.000837316561955958605 * 1. / (1_MeV), 0;
-  Covariance covMat74;
-  covMat74 << 0.0102707967162132263, -0.000136778664959171002,
-      -0.000310806316136640959, 3.61658036657657105e-06,
-      -1.57486458126811822e-07 * 1. / (1_MeV), 0, -0.000136778664959171002,
-      0.0391799546778202057, -3.21871642520172128e-06, 0.000429004761143547957,
-      7.25027250869408224e-09 * 1. / (1_MeV), 0, -0.000310806316136640959,
-      -3.21871642520172128e-06, 9.52503432927187532e-06,
-      -1.91221331833284833e-07, 8.03748117560459975e-09 * 1. / (1_MeV), 0,
-      3.61658036657657105e-06, 0.000429004761143547957,
-      -1.91221331833284833e-07, 4.81143752040225081e-06,
-      -1.69302933545922802e-11 * 1. / (1_MeV), 0,
-      -1.57486458126811822e-07 * 1. / (1_MeV),
-      7.25027250869408224e-09 * 1. / (1_MeV),
-      8.03748117560459975e-09 * 1. / (1_MeV),
-      -1.69302933545922802e-11 * 1. / (1_MeV),
-      2.06939729241462089e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams74 =
-      BoundParameters(tgContext, std::move(covMat74), params74, perigeeSurface);
-  tracks.push_back(boundParams74);
-
-  // track 75 :
-  BoundVector params75;
-  params75 << 0.0529175736010074615, -12.0598258972167969, 1.1199498176574707,
-      1.30395138263702393, 0.000916379212867468596 * 1. / (1_MeV), 0;
-  Covariance covMat75;
-  covMat75 << 0.00428111432120203972, 2.62827478725743552e-05,
-      -0.000120566700934877791, 7.54315472354089557e-07,
-      -5.43323675648758046e-08 * 1. / (1_MeV), 0, 2.62827478725743552e-05,
-      0.0172699503600597382, -1.77099448321877513e-06, 0.000338392047693610422,
-      -9.53148133943496205e-10 * 1. / (1_MeV), 0, -0.000120566700934877791,
-      -1.77099448321877513e-06, 3.49290257872780785e-06,
-      -4.25857281398289675e-08, 2.55990108225490642e-09 * 1. / (1_MeV), 0,
-      7.54315472354089557e-07, 0.000338392047693610422,
-      -4.25857281398289675e-08, 7.29711200619931333e-06,
-      -2.28893257339241436e-11 * 1. / (1_MeV), 0,
-      -5.43323675648758046e-08 * 1. / (1_MeV),
-      -9.53148133943496205e-10 * 1. / (1_MeV),
-      2.55990108225490642e-09 * 1. / (1_MeV),
-      -2.28893257339241436e-11 * 1. / (1_MeV),
-      9.44539516045672656e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams75 =
-      BoundParameters(tgContext, std::move(covMat75), params75, perigeeSurface);
-  tracks.push_back(boundParams75);
-
-  // track 76 :
-  BoundVector params76;
-  params76 << 0.640764772891998291, -0.930534124374389648, 2.15712094306945801,
-      2.28308653831481934, 0.000431261461926624179 * 1. / (1_MeV), 0;
-  Covariance covMat76;
-  covMat76 << 0.00260529923252761364, 4.58412423896785499e-05,
-      -6.7969661726482311e-05, 1.81599714744093986e-08,
-      -4.24128181647569863e-08 * 1. / (1_MeV), 0, 4.58412423896785499e-05,
-      0.0122323241084814072, 8.04787994406084613e-08, 0.000150878291840991384,
-      -1.26706283098581222e-08 * 1. / (1_MeV), 0, -6.7969661726482311e-05,
-      8.04787994406084613e-08, 1.85573071576072834e-06, 1.38421707121045597e-08,
-      1.77332557811301974e-09 * 1. / (1_MeV), 0, 1.81599714744093986e-08,
-      0.000150878291840991384, 1.38421707121045597e-08, 2.22777407543617301e-06,
-      -1.58479619806951909e-10 * 1. / (1_MeV), 0,
-      -4.24128181647569863e-08 * 1. / (1_MeV),
-      -1.26706283098581222e-08 * 1. / (1_MeV),
-      1.77332557811301974e-09 * 1. / (1_MeV),
-      -1.58479619806951909e-10 * 1. / (1_MeV),
-      4.6452456464729508e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams76 =
-      BoundParameters(tgContext, std::move(covMat76), params76, perigeeSurface);
-  tracks.push_back(boundParams76);
-
-  // track 77 :
-  BoundVector params77;
-  params77 << 0.653912067413330078, -38.5965461730957031, 2.62386393547058105,
-      2.6188347339630127, -0.000398666656110435724 * 1. / (1_MeV), 0;
-  Covariance covMat77;
-  covMat77 << 0.00521424366161227226, 0.000139879184703866033,
-      -0.000151905000687639944, 1.9792889758053464e-06,
-      -7.62257896696214591e-08 * 1. / (1_MeV), 0, 0.000139879184703866033,
-      0.032011859118938446, -4.45397794194540351e-06, 0.000216144809062415678,
-      4.33223192345790811e-09 * 1. / (1_MeV), 0, -0.000151905000687639944,
-      -4.45397794194540351e-06, 4.54638166047516279e-06,
-      -6.7860751060001615e-08, 3.68501084222524602e-09 * 1. / (1_MeV), 0,
-      1.9792889758053464e-06, 0.000216144809062415678, -6.7860751060001615e-08,
-      1.52451764279248891e-06, -1.26932170430756531e-12 * 1. / (1_MeV), 0,
-      -7.62257896696214591e-08 * 1. / (1_MeV),
-      4.33223192345790811e-09 * 1. / (1_MeV),
-      3.68501084222524602e-09 * 1. / (1_MeV),
-      -1.26932170430756531e-12 * 1. / (1_MeV),
-      7.21128712299901053e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams77 =
-      BoundParameters(tgContext, std::move(covMat77), params77, perigeeSurface);
-  tracks.push_back(boundParams77);
-
-  // track 78 :
-  BoundVector params78;
-  params78 << -0.147352397441864014, -5.29536819458007812, -2.19698119163513184,
-      2.19908237457275391, 0.000603679509367793798 * 1. / (1_MeV), 0;
-  Covariance covMat78;
-  covMat78 << 0.0025317345280200243, 3.93469647761186486e-06,
-      -7.47220338226873746e-05, -8.47547663426674989e-07,
-      -4.10995834716985269e-08 * 1. / (1_MeV), 0, 3.93469647761186486e-06,
-      0.0137719558551907539, 1.18341805513367972e-06, 0.000192888227764741909,
-      8.4659628993769127e-11 * 1. / (1_MeV), 0, -7.47220338226873746e-05,
-      1.18341805513367972e-06, 2.24668019654927775e-06, 4.44216205306269896e-08,
-      1.9813795664012159e-09 * 1. / (1_MeV), 0, -8.47547663426674989e-07,
-      0.000192888227764741909, 4.44216205306269896e-08, 3.1759927878738381e-06,
-      2.44401588800591696e-11 * 1. / (1_MeV), 0,
-      -4.10995834716985269e-08 * 1. / (1_MeV),
-      8.4659628993769127e-11 * 1. / (1_MeV),
-      1.9813795664012159e-09 * 1. / (1_MeV),
-      2.44401588800591696e-11 * 1. / (1_MeV),
-      6.28857244056035825e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams78 =
-      BoundParameters(tgContext, std::move(covMat78), params78, perigeeSurface);
-  tracks.push_back(boundParams78);
-
-  // track 79 :
-  BoundVector params79;
-  params79 << 0.678209245204925537, -26.9999599456787109, 1.87300777435302734,
-      2.68262672424316406, 0.000182776289875619113 * 1. / (1_MeV), 0;
-  Covariance covMat79;
-  covMat79 << 0.00191749841906130314, 0.000110412661743103727,
-      -5.49806951977405462e-05, 6.60175592356722232e-07,
-      -2.1776932514113485e-08 * 1. / (1_MeV), 0, 0.000110412661743103727,
-      0.0226654317229986191, -6.31152562384800887e-07, 0.000109733381182499073,
-      9.56806544278803705e-10 * 1. / (1_MeV), 0, -5.49806951977405462e-05,
-      -6.31152562384800887e-07, 1.61751074756466551e-06,
-      -8.57919113866550056e-09, 1.02398276394864458e-09 * 1. / (1_MeV), 0,
-      6.60175592356722232e-07, 0.000109733381182499073,
-      -8.57919113866550056e-09, 5.57945270429627271e-07,
-      -9.30864559448818034e-13 * 1. / (1_MeV), 0,
-      -2.1776932514113485e-08 * 1. / (1_MeV),
-      9.56806544278803705e-10 * 1. / (1_MeV),
-      1.02398276394864458e-09 * 1. / (1_MeV),
-      -9.30864559448818034e-13 * 1. / (1_MeV),
-      1.72951982596591947e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams79 =
-      BoundParameters(tgContext, std::move(covMat79), params79, perigeeSurface);
-  tracks.push_back(boundParams79);
-
-  // track 80 :
-  BoundVector params80;
-  params80 << 0.64381110668182373, -6.46031522750854492, 2.02721667289733887,
-      2.68821907043457031, -0.000553313468117266893 * 1. / (1_MeV), 0;
-  Covariance covMat80;
-  covMat80 << 0.0134714795276522636, -0.000148150339418309318,
-      -0.000399405999997743766, 3.50936426643331028e-06,
-      -1.66954978163253585e-07 * 1. / (1_MeV), 0, -0.000148150339418309318,
-      0.0778103619813919067, -3.53222213147371605e-06, 0.000429908786653424371,
-      1.29938534403212134e-08 * 1. / (1_MeV), 0, -0.000399405999997743766,
-      -3.53222213147371605e-06, 1.20958047773456201e-05,
-      -1.55765136847599568e-07, 8.36922640021012843e-09 * 1. / (1_MeV), 0,
-      3.50936426643331028e-06, 0.000429908786653424371,
-      -1.55765136847599568e-07, 2.42866008193232119e-06,
-      -5.38086858591292421e-12 * 1. / (1_MeV), 0,
-      -1.66954978163253585e-07 * 1. / (1_MeV),
-      1.29938534403212134e-08 * 1. / (1_MeV),
-      8.36922640021012843e-09 * 1. / (1_MeV),
-      -5.38086858591292421e-12 * 1. / (1_MeV),
-      1.47779136150383295e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams80 =
-      BoundParameters(tgContext, std::move(covMat80), params80, perigeeSurface);
-  tracks.push_back(boundParams80);
-
-  // track 81 :
-  BoundVector params81;
-  params81 << 0.13216361403465271, -5.14932060241699219, 0.880854129791259766,
-      0.992275714874267578, -0.000997516443021595478 * 1. / (1_MeV), 0;
-  Covariance covMat81;
-  covMat81 << 0.00625587906688451767, -0.000110949013866784292,
-      -0.000185194923985265947, -2.88485291842903976e-06,
-      -9.58251834750225767e-08 * 1. / (1_MeV), 0, -0.000110949013866784292,
-      0.0189361255615949631, 5.522171408563187e-06, 0.000352685543849685001,
-      -3.54823960396222519e-11 * 1. / (1_MeV), 0, -0.000185194923985265947,
-      5.522171408563187e-06, 5.57630210096249357e-06, 1.35760624085924114e-07,
-      4.58229751365888916e-09 * 1. / (1_MeV), 0, -2.88485291842903976e-06,
-      0.000352685543849685001, 1.35760624085924114e-07, 7.01960607329965569e-06,
-      9.7695621439726223e-12 * 1. / (1_MeV), 0,
-      -9.58251834750225767e-08 * 1. / (1_MeV),
-      -3.54823960396222519e-11 * 1. / (1_MeV),
-      4.58229751365888916e-09 * 1. / (1_MeV),
-      9.7695621439726223e-12 * 1. / (1_MeV),
-      1.47325138200038452e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams81 =
-      BoundParameters(tgContext, std::move(covMat81), params81, perigeeSurface);
-  tracks.push_back(boundParams81);
-
-  // track 82 :
-  BoundVector params82;
-  params82 << 0.227797195315361023, -48.2234649658203125, -2.77569174766540527,
-      0.305090576410293579, -0.000179648617631755769 * 1. / (1_MeV), 0;
-  Covariance covMat82;
-  covMat82 << 0.00557572394609451294, -0.000663197008771320177,
-      -0.000161846338406778913, -1.69794778867290902e-06,
-      -9.04045033146821151e-08 * 1. / (1_MeV), 0, -0.000663197008771320177,
-      0.0660624504089355469, 1.59902907216536034e-05, 0.000168873299181685442,
-      2.14987267373142885e-10 * 1. / (1_MeV), 0, -0.000161846338406778913,
-      1.59902907216536034e-05, 4.86282624478917569e-06, 4.67482134719900594e-08,
-      4.44175415702797833e-09 * 1. / (1_MeV), 0, -1.69794778867290902e-06,
-      0.000168873299181685442, 4.67482134719900594e-08, 4.42445099224642036e-07,
-      8.83536325828199794e-12 * 1. / (1_MeV), 0,
-      -9.04045033146821151e-08 * 1. / (1_MeV),
-      2.14987267373142885e-10 * 1. / (1_MeV),
-      4.44175415702797833e-09 * 1. / (1_MeV),
-      8.83536325828199794e-12 * 1. / (1_MeV),
-      5.34931300644192476e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams82 =
-      BoundParameters(tgContext, std::move(covMat82), params82, perigeeSurface);
-  tracks.push_back(boundParams82);
-
-  // track 83 :
-  BoundVector params83;
-  params83 << -0.00143859826494008303, -15.1650552749633789,
-      -2.28632807731628418, 0.256175190210342407,
-      0.000115477916551753879 * 1. / (1_MeV), 0;
-  Covariance covMat83;
-  covMat83 << 0.00375564000569283962, -0.000551671739993432088,
-      -0.00010947611885112353, -5.73661445135283778e-07,
-      -4.22778383392875813e-08 * 1. / (1_MeV), 0, -0.000551671739993432088,
-      0.0728673934936523438, 9.0784263305680404e-06, 0.000129420350572193905,
-      2.27171510114886803e-09 * 1. / (1_MeV), 0, -0.00010947611885112353,
-      9.0784263305680404e-06, 3.28997566612088121e-06, 7.07299627862913823e-09,
-      1.99936639608643397e-09 * 1. / (1_MeV), 0, -5.73661445135283778e-07,
-      0.000129420350572193905, 7.07299627862913823e-09, 2.37868235331006872e-07,
-      1.04279595331346869e-12 * 1. / (1_MeV), 0,
-      -4.22778383392875813e-08 * 1. / (1_MeV),
-      2.27171510114886803e-09 * 1. / (1_MeV),
-      1.99936639608643397e-09 * 1. / (1_MeV),
-      1.04279595331346869e-12 * 1. / (1_MeV),
-      1.92760772621536347e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams83 =
-      BoundParameters(tgContext, std::move(covMat83), params83, perigeeSurface);
-  tracks.push_back(boundParams83);
-
-  // track 84 :
-  BoundVector params84;
-  params84 << -0.78146892786026001, -23.751434326171875, -0.999060988426208496,
-      2.0324549674987793, -0.000969979155343025923 * 1. / (1_MeV), 0;
-  Covariance covMat84;
-  covMat84 << 0.0048350747674703598, 0.000120963946599512005,
-      -0.000144374569500283449, 1.3788048161874064e-06,
-      -7.09094644554907288e-08 * 1. / (1_MeV), 0, 0.000120963946599512005,
-      0.0167757254093885422, -5.14354340070674043e-06, 0.000297219118512754719,
-      -1.79593641161986059e-09 * 1. / (1_MeV), 0, -0.000144374569500283449,
-      -5.14354340070674043e-06, 4.36926575275720097e-06,
-      -7.26679966160986237e-08, 3.53139150458423765e-09 * 1. / (1_MeV), 0,
-      1.3788048161874064e-06, 0.000297219118512754719, -7.26679966160986237e-08,
-      6.093463071010774e-06, 6.19247327016922366e-12 * 1. / (1_MeV), 0,
-      -7.09094644554907288e-08 * 1. / (1_MeV),
-      -1.79593641161986059e-09 * 1. / (1_MeV),
-      3.53139150458423765e-09 * 1. / (1_MeV),
-      6.19247327016922366e-12 * 1. / (1_MeV),
-      1.26404206546304465e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams84 =
-      BoundParameters(tgContext, std::move(covMat84), params84, perigeeSurface);
-  tracks.push_back(boundParams84);
-
-  // track 85 :
-  BoundVector params85;
-  params85 << -0.419987142086029053, -23.2181625366210938, -1.72765111923217773,
-      2.3730311393737793, 0.000834245642181485891 * 1. / (1_MeV), 0;
-  Covariance covMat85;
-  covMat85 << 0.00711026880890130997, 2.11381997852235886e-05,
-      -0.000214070355238693376, -2.47722478700721587e-06,
-      -1.49308714645023079e-07 * 1. / (1_MeV), 0, 2.11381997852235886e-05,
-      0.0319119654595851898, 4.62741704063705679e-06, 0.000389666316763969648,
-      -4.99086836094690827e-09 * 1. / (1_MeV), 0, -0.000214070355238693376,
-      4.62741704063705679e-06, 6.5447911765659228e-06, 1.4062768144653077e-07,
-      7.23939037737933651e-09 * 1. / (1_MeV), 0, -2.47722478700721587e-06,
-      0.000389666316763969648, 1.4062768144653077e-07, 5.10100881001562811e-06,
-      4.05519853361521036e-12 * 1. / (1_MeV), 0,
-      -1.49308714645023079e-07 * 1. / (1_MeV),
-      -4.99086836094690827e-09 * 1. / (1_MeV),
-      7.23939037737933651e-09 * 1. / (1_MeV),
-      4.05519853361521036e-12 * 1. / (1_MeV),
-      1.97367219789690296e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams85 =
-      BoundParameters(tgContext, std::move(covMat85), params85, perigeeSurface);
-  tracks.push_back(boundParams85);
-
-  // track 86 :
-  BoundVector params86;
-  params86 << 0.280342727899551392, -1.76902174949645996, 1.17941749095916748,
-      2.43773078918457031, 0.00124833709560334682 * 1. / (1_MeV), 0;
-  Covariance covMat86;
-  covMat86 << 0.0222384743392467499, -0.000469551059919313127,
-      -0.000668093464709992738, -1.03170210424629496e-05,
-      -6.31322167864463976e-07 * 1. / (1_MeV), 0, -0.000469551059919313127,
-      0.0734211504459381104, 3.64346959713435348e-05, 0.000901481115280004927,
-      7.77891238924622843e-09 * 1. / (1_MeV), 0, -0.000668093464709992738,
-      3.64346959713435348e-05, 2.04888619919074699e-05, 5.77626316243002577e-07,
-      3.13812114656612788e-08 * 1. / (1_MeV), 0, -1.03170210424629496e-05,
-      0.000901481115280004927, 5.77626316243002577e-07, 1.12906618596753106e-05,
-      1.32123927173378508e-10 * 1. / (1_MeV), 0,
-      -6.31322167864463976e-07 * 1. / (1_MeV),
-      7.77891238924622843e-09 * 1. / (1_MeV),
-      3.13812114656612788e-08 * 1. / (1_MeV),
-      1.32123927173378508e-10 * 1. / (1_MeV),
-      8.04692867895084873e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams86 =
-      BoundParameters(tgContext, std::move(covMat86), params86, perigeeSurface);
-  tracks.push_back(boundParams86);
-
-  // track 87 :
-  BoundVector params87;
-  params87 << -0.655172765254974365, -26.7765121459960938,
-      -0.736525535583496094, 2.02205944061279297,
-      0.000604338070843368769 * 1. / (1_MeV), 0;
-  Covariance covMat87;
-  covMat87 << 0.00198961631394922733, 3.05661867898970239e-06,
-      -5.82364130628319071e-05, -8.33779895790357002e-07,
-      -3.03302168166956188e-08 * 1. / (1_MeV), 0, 3.05661867898970239e-06,
-      0.00704017188400030136, 3.30304839880078472e-07, 0.000134940363950436851,
-      -3.70578310628897577e-09 * 1. / (1_MeV), 0, -5.82364130628319071e-05,
-      3.30304839880078472e-07, 1.73737998920842074e-06, 3.39209195261311275e-08,
-      1.44265069638837021e-09 * 1. / (1_MeV), 0, -8.33779895790357002e-07,
-      0.000134940363950436851, 3.39209195261311275e-08, 3.01883733300201129e-06,
-      -3.51121860297362421e-11 * 1. / (1_MeV), 0,
-      -3.03302168166956188e-08 * 1. / (1_MeV),
-      -3.70578310628897577e-09 * 1. / (1_MeV),
-      1.44265069638837021e-09 * 1. / (1_MeV),
-      -3.51121860297362421e-11 * 1. / (1_MeV),
-      5.05374214698761648e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams87 =
-      BoundParameters(tgContext, std::move(covMat87), params87, perigeeSurface);
-  tracks.push_back(boundParams87);
-
-  // track 88 :
-  BoundVector params88;
-  params88 << 0.550101339817047119, -1.01730048656463623, 1.95360791683197021,
-      1.34285402297973633, -0.00163667963352054358 * 1. / (1_MeV), 0;
-  Covariance covMat88;
-  covMat88 << 0.0107496930286288261, -7.68611913775611998e-05,
-      -0.000315102046698671615, -3.90352989298854716e-06,
-      -1.47303449929830411e-07 * 1. / (1_MeV), 0, -7.68611913775611998e-05,
-      0.0372591577470302582, 5.62124909349075963e-06, 0.000868637235426337399,
-      -2.50207485117721545e-09 * 1. / (1_MeV), 0, -0.000315102046698671615,
-      5.62124909349075963e-06, 9.41804592002881691e-06, 2.0220920354903416e-07,
-      7.44695559286270222e-09 * 1. / (1_MeV), 0, -3.90352989298854716e-06,
-      0.000868637235426337399, 2.0220920354903416e-07, 2.23459410335635766e-05,
-      -5.58945405173847072e-11 * 1. / (1_MeV), 0,
-      -1.47303449929830411e-07 * 1. / (1_MeV),
-      -2.50207485117721545e-09 * 1. / (1_MeV),
-      7.44695559286270222e-09 * 1. / (1_MeV),
-      -5.58945405173847072e-11 * 1. / (1_MeV),
-      2.93490870495460854e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams88 =
-      BoundParameters(tgContext, std::move(covMat88), params88, perigeeSurface);
-  tracks.push_back(boundParams88);
-
-  // track 89 :
-  BoundVector params89;
-  params89 << -0.0243351589888334274, -6.1328587532043457, -2.17217230796813965,
-      0.851706326007843018, -0.00123827718198299408 * 1. / (1_MeV), 0;
-  Covariance covMat89;
-  covMat89 << 0.013601384125649929, -0.000238490415799996243,
-      -0.000407308591532023773, -5.81321625599451904e-06,
-      -2.20563854841242778e-07 * 1. / (1_MeV), 0, -0.000238490415799996243,
-      0.0385725460946559906, 1.44713061143640791e-05, 0.000594927870114984056,
-      -4.2657516143838364e-09 * 1. / (1_MeV), 0, -0.000407308591532023773,
-      1.44713061143640791e-05, 1.23664985949289985e-05, 2.98472027659172679e-07,
-      1.09973686096897418e-08 * 1. / (1_MeV), 0, -5.81321625599451904e-06,
-      0.000594927870114984056, 2.98472027659172679e-07, 9.52084610617021099e-06,
-      -3.86199606571132037e-11 * 1. / (1_MeV), 0,
-      -2.20563854841242778e-07 * 1. / (1_MeV),
-      -4.2657516143838364e-09 * 1. / (1_MeV),
-      1.09973686096897418e-08 * 1. / (1_MeV),
-      -3.86199606571132037e-11 * 1. / (1_MeV),
-      3.39196892795712301e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams89 =
-      BoundParameters(tgContext, std::move(covMat89), params89, perigeeSurface);
-  tracks.push_back(boundParams89);
-
-  // track 90 :
-  BoundVector params90;
-  params90 << 0.723694682121276855, -26.568511962890625, 2.23595356941223145,
-      2.48232841491699219, -0.000482781761093065143 * 1. / (1_MeV), 0;
-  Covariance covMat90;
-  covMat90 << 0.00387407466769218445, 2.81628374958135634e-05,
-      -0.000114726948246347626, 1.29467025144414135e-06,
-      -9.82718568940813015e-08 * 1. / (1_MeV), 0, 2.81628374958135634e-05,
-      0.0211086571216583252, -1.99152008947953991e-06, 0.000209110626146605873,
-      3.14540254121542699e-09 * 1. / (1_MeV), 0, -0.000114726948246347626,
-      -1.99152008947953991e-06, 3.47766376762592699e-06,
-      -5.54193827886431388e-08, 4.70571016940573361e-09 * 1. / (1_MeV), 0,
-      1.29467025144414135e-06, 0.000209110626146605873,
-      -5.54193827886431388e-08, 2.18847662836196832e-06,
-      -1.76163300018645983e-11 * 1. / (1_MeV), 0,
-      -9.82718568940813015e-08 * 1. / (1_MeV),
-      3.14540254121542699e-09 * 1. / (1_MeV),
-      4.70571016940573361e-09 * 1. / (1_MeV),
-      -1.76163300018645983e-11 * 1. / (1_MeV),
-      1.11767643751203849e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams90 =
-      BoundParameters(tgContext, std::move(covMat90), params90, perigeeSurface);
-  tracks.push_back(boundParams90);
-
-  // track 91 :
-  BoundVector params91;
-  params91 << -0.2323446124792099, -1.08657681941986084, -2.02921128273010254,
-      1.34838950634002686, -0.000909031485207378864 * 1. / (1_MeV), 0;
-  Covariance covMat91;
-  covMat91 << 0.0042699095793068409, -4.94646692795497152e-05,
-      -0.00011729394910827925, -1.00433771415922194e-06,
-      -4.90878501892060452e-08 * 1. / (1_MeV), 0, -4.94646692795497152e-05,
-      0.0193016305565834045, 2.10226265958507905e-06, 0.000365190230248221902,
-      7.18162424846205697e-10 * 1. / (1_MeV), 0, -0.00011729394910827925,
-      2.10226265958507905e-06, 3.3351993806718383e-06, 4.49848539144146812e-08,
-      2.39365529077948547e-09 * 1. / (1_MeV), 0, -1.00433771415922194e-06,
-      0.000365190230248221902, 4.49848539144146812e-08, 8.12437156127998605e-06,
-      1.11281704892510676e-11 * 1. / (1_MeV), 0,
-      -4.90878501892060452e-08 * 1. / (1_MeV),
-      7.18162424846205697e-10 * 1. / (1_MeV),
-      2.39365529077948547e-09 * 1. / (1_MeV),
-      1.11281704892510676e-11 * 1. / (1_MeV),
-      9.21146006693795982e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams91 =
-      BoundParameters(tgContext, std::move(covMat91), params91, perigeeSurface);
-  tracks.push_back(boundParams91);
-
-  // track 92 :
-  BoundVector params92;
-  params92 << 0.265045791864395142, -27.2973098754882812, 1.05269753932952881,
-      2.81940984725952148, -0.000315688434056937695 * 1. / (1_MeV), 0;
-  Covariance covMat92;
-  covMat92 << 0.0140700377523899078, 0.000593323783968879382,
-      -0.000416014263318039551, 3.4111828236548417e-06,
-      -2.73414962589024817e-07 * 1. / (1_MeV), 0, 0.000593323783968879382,
-      0.35917237401008606, -4.08578592997089967e-05, 0.000845220423224244104,
-      1.86785150218537236e-08 * 1. / (1_MeV), 0, -0.000416014263318039551,
-      -4.08578592997089967e-05, 1.27100629470078275e-05,
-      -1.59836018444417662e-07, 1.37035759118268963e-08 * 1. / (1_MeV), 0,
-      3.4111828236548417e-06, 0.000845220423224244104, -1.59836018444417662e-07,
-      2.07905191018653568e-06, 2.14949156818848357e-12 * 1. / (1_MeV), 0,
-      -2.73414962589024817e-07 * 1. / (1_MeV),
-      1.86785150218537236e-08 * 1. / (1_MeV),
-      1.37035759118268963e-08 * 1. / (1_MeV),
-      2.14949156818848357e-12 * 1. / (1_MeV),
-      1.74355599402709061e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams92 =
-      BoundParameters(tgContext, std::move(covMat92), params92, perigeeSurface);
-  tracks.push_back(boundParams92);
-
-  // track 93 :
-  BoundVector params93;
-  params93 << 0.789679765701293945, -24.0303401947021484, 2.51740336418151855,
-      0.428744226694107056, 0.000271489931037649512 * 1. / (1_MeV), 0;
-  Covariance covMat93;
-  covMat93 << 0.00483581656590104103, -0.00014841558570857861,
-      -0.000137122191448320704, -1.15095639449306219e-06,
-      -5.72764878155495094e-08 * 1. / (1_MeV), 0, -0.00014841558570857861,
-      0.0322524122893810272, -4.39218594800754952e-07, 0.000152778757565279151,
-      -1.06383037100379797e-09 * 1. / (1_MeV), 0, -0.000137122191448320704,
-      -4.39218594800754952e-07, 4.02241357733146288e-06, 1.598528605493444e-08,
-      2.66714797310526465e-09 * 1. / (1_MeV), 0, -1.15095639449306219e-06,
-      0.000152778757565279151, 1.598528605493444e-08, 7.50712217723048525e-07,
-      1.22675320789893397e-11 * 1. / (1_MeV), 0,
-      -5.72764878155495094e-08 * 1. / (1_MeV),
-      -1.06383037100379797e-09 * 1. / (1_MeV),
-      2.66714797310526465e-09 * 1. / (1_MeV),
-      1.22675320789893397e-11 * 1. / (1_MeV),
-      4.13053515002648197e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams93 =
-      BoundParameters(tgContext, std::move(covMat93), params93, perigeeSurface);
-  tracks.push_back(boundParams93);
-
-  // track 94 :
-  BoundVector params94;
-  params94 << 0.0419332981109619141, -22.403900146484375, 1.04268980026245117,
-      0.541070818901062012, -0.000843891466502100229 * 1. / (1_MeV), 0;
-  Covariance covMat94;
-  covMat94 << 0.0182619895786046982, -0.000309098329579466258,
-      -0.000548046706254767617, -6.4069930181110618e-06,
-      -2.1453733001269524e-07 * 1. / (1_MeV), 0, -0.000309098329579466258,
-      0.0862535983324050903, 2.67156807455599936e-05, 0.000666602107346143339,
-      -5.16283304523887763e-09 * 1. / (1_MeV), 0, -0.000548046706254767617,
-      2.67156807455599936e-05, 1.6711990610929206e-05, 3.3081373187341857e-07,
-      1.096216345456462e-08 * 1. / (1_MeV), 0, -6.4069930181110618e-06,
-      0.000666602107346143339, 3.3081373187341857e-07, 5.25060204381588846e-06,
-      2.56585402895446448e-14 * 1. / (1_MeV), 0,
-      -2.1453733001269524e-07 * 1. / (1_MeV),
-      -5.16283304523887763e-09 * 1. / (1_MeV),
-      1.096216345456462e-08 * 1. / (1_MeV),
-      2.56585402895446448e-14 * 1. / (1_MeV),
-      2.29805854901066198e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams94 =
-      BoundParameters(tgContext, std::move(covMat94), params94, perigeeSurface);
-  tracks.push_back(boundParams94);
-
-  // track 95 :
-  BoundVector params95;
-  params95 << 0.176779255270957947, -37.7216300964355469, -2.91102933883666992,
-      2.48529434204101562, -0.000805854273494333029 * 1. / (1_MeV), 0;
-  Covariance covMat95;
-  covMat95 << 0.0118867438286542892, 0.000227795118694210991,
-      -0.000348746534646607244, 4.75699803725603849e-06,
-      -2.10260526953580937e-07 * 1. / (1_MeV), 0, 0.000227795118694210991,
-      0.0444288402795791626, -1.27103127595436328e-05, 0.00044249878890344381,
-      3.24775989820321723e-09 * 1. / (1_MeV), 0, -0.000348746534646607244,
-      -1.27103127595436328e-05, 1.04705995909171179e-05,
-      -2.08165437755266941e-07, 1.02343642189694215e-08 * 1. / (1_MeV), 0,
-      4.75699803725603849e-06, 0.00044249878890344381, -2.08165437755266941e-07,
-      4.59913690065150149e-06, -1.77698327525688441e-11 * 1. / (1_MeV), 0,
-      -2.10260526953580937e-07 * 1. / (1_MeV),
-      3.24775989820321723e-09 * 1. / (1_MeV),
-      1.02343642189694215e-08 * 1. / (1_MeV),
-      -1.77698327525688441e-11 * 1. / (1_MeV),
-      2.43435688274118434e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams95 =
-      BoundParameters(tgContext, std::move(covMat95), params95, perigeeSurface);
-  tracks.push_back(boundParams95);
-
-  // track 96 :
-  BoundVector params96;
-  params96 << 0.447810828685760498, -26.3884296417236328, 1.54339611530303955,
-      1.56189525127410889, 0.00136160221882164478 * 1. / (1_MeV), 0;
-  Covariance covMat96;
-  covMat96 << 0.00786379911005496979, 2.44020731388588477e-06,
-      -0.000226637467024543921, 6.05815686194600369e-08,
-      -9.290821859919166e-08 * 1. / (1_MeV), 0, 2.44020731388588477e-06,
-      0.0212073065340518951, -1.41751539171569177e-07, 0.000477572767546785625,
-      -6.58794985364503272e-10 * 1. / (1_MeV), 0, -0.000226637467024543921,
-      -1.41751539171569177e-07, 6.68278789817122743e-06,
-      -3.38178369258151404e-09, 4.51877708122468826e-09 * 1. / (1_MeV), 0,
-      6.05815686194600369e-08, 0.000477572767546785625,
-      -3.38178369258151404e-09, 1.25970709632383659e-05,
-      -7.18296901266119286e-13 * 1. / (1_MeV), 0,
-      -9.290821859919166e-08 * 1. / (1_MeV),
-      -6.58794985364503272e-10 * 1. / (1_MeV),
-      4.51877708122468826e-09 * 1. / (1_MeV),
-      -7.18296901266119286e-13 * 1. / (1_MeV),
-      1.78482867374540888e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams96 =
-      BoundParameters(tgContext, std::move(covMat96), params96, perigeeSurface);
-  tracks.push_back(boundParams96);
-
-  // track 97 :
-  BoundVector params97;
-  params97 << 0.69138866662979126, -0.824633300304412842, 1.62790572643280029,
-      2.17131519317626953, -0.00157829432282596827 * 1. / (1_MeV), 0;
-  Covariance covMat97;
-  covMat97 << 0.0180772673338651657, 6.76792935648847091e-05,
-      -0.000534082747176570683, 9.79180919063570467e-06,
-      -2.87445677290829436e-07 * 1. / (1_MeV), 0, 6.76792935648847091e-05,
-      0.0473108701407909393, -1.27657009238910182e-05, 0.000919307781488095115,
-      2.86386577268916162e-09 * 1. / (1_MeV), 0, -0.000534082747176570683,
-      -1.27657009238910182e-05, 1.60557119670556858e-05, -5.161388544210652e-07,
-      1.4339166470730082e-08 * 1. / (1_MeV), 0, 9.79180919063570467e-06,
-      0.000919307781488095115, -5.161388544210652e-07, 1.83516385732218623e-05,
-      -1.41501241215600609e-10 * 1. / (1_MeV), 0,
-      -2.87445677290829436e-07 * 1. / (1_MeV),
-      2.86386577268916162e-09 * 1. / (1_MeV),
-      1.4339166470730082e-08 * 1. / (1_MeV),
-      -1.41501241215600609e-10 * 1. / (1_MeV),
-      4.72637817772181279e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams97 =
-      BoundParameters(tgContext, std::move(covMat97), params97, perigeeSurface);
-  tracks.push_back(boundParams97);
 
-  // track 98 :
-  BoundVector params98;
-  params98 << 2.12992453575134277, -18.7516555786132812, 0.322550356388092041,
-      0.368121087551116943, 0.000346695247571915388 * 1. / (1_MeV), 0;
-  Covariance covMat98;
-  covMat98 << 0.0101209962740540504, 0.0011374339858220674,
-      -0.000299095329991897287, -3.14932882056957461e-07,
-      -1.65684092374357599e-07 * 1. / (1_MeV), 0, 0.0011374339858220674,
-      0.0939061492681503296, -4.8902690159540195e-05, 0.000337479548580967448,
-      -3.9036311873074078e-08 * 1. / (1_MeV), 0, -0.000299095329991897287,
-      -4.8902690159540195e-05, 9.09368463908322155e-06,
-      -3.51741511269112836e-08, 8.19782135067778202e-09 * 1. / (1_MeV), 0,
-      -3.14932882056957461e-07, 0.000337479548580967448,
-      -3.51741511269112836e-08, 1.25376061532733729e-06,
-      7.26578444477865009e-12 * 1. / (1_MeV), 0,
-      -1.65684092374357599e-07 * 1. / (1_MeV),
-      -3.9036311873074078e-08 * 1. / (1_MeV),
-      8.19782135067778202e-09 * 1. / (1_MeV),
-      7.26578444477865009e-12 * 1. / (1_MeV),
-      1.17719708980779103e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams98 =
-      BoundParameters(tgContext, std::move(covMat98), params98, perigeeSurface);
-  tracks.push_back(boundParams98);
-
-  // track 99 :
-  BoundVector params99;
-  params99 << -0.535510718822479248, -28.7000522613525391,
-      -0.231238842010498047, 1.41121876239776611,
-      0.00161712500266730785 * 1. / (1_MeV), 0;
-  Covariance covMat99;
-  covMat99 << 0.0117115778848528862, -7.67866557470544008e-06,
-      -0.000338518527122336449, 1.34603162757949205e-06,
-      -1.72783210997185512e-07 * 1. / (1_MeV), 0, -7.67866557470544008e-06,
-      0.0252319127321243286, -1.52781402695736202e-06, 0.000597511113212106579,
-      3.90113700709114385e-10 * 1. / (1_MeV), 0, -0.000338518527122336449,
-      -1.52781402695736202e-06, 1.00057823146926239e-05,
-      -8.19645843713344724e-08, 8.35848601602763903e-09 * 1. / (1_MeV), 0,
-      1.34603162757949205e-06, 0.000597511113212106579,
-      -8.19645843713344724e-08, 1.51151134559768252e-05,
-      -1.22177379055824259e-11 * 1. / (1_MeV), 0,
-      -1.72783210997185512e-07 * 1. / (1_MeV),
-      3.90113700709114385e-10 * 1. / (1_MeV),
-      8.35848601602763903e-09 * 1. / (1_MeV),
-      -1.22177379055824259e-11 * 1. / (1_MeV),
-      3.21954796156376233e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams99 =
-      BoundParameters(tgContext, std::move(covMat99), params99, perigeeSurface);
-  tracks.push_back(boundParams99);
-
-  // track 100 :
-  BoundVector params100;
-  params100 << -0.843921840190887451, -49.1135101318359375,
-      -0.365095585584640503, 2.96138834953308105,
-      -6.34708048892207444e-05 * 1. / (1_MeV), 0;
-  Covariance covMat100;
-  covMat100 << 0.00338416872546076775, 0.00177216971338738029,
-      -9.9789567797386219e-05, 9.88074736457750535e-07,
-      -3.61024835134689107e-08 * 1. / (1_MeV), 0, 0.00177216971338738029,
-      0.116565637290477753, -4.51521351414238938e-05, 0.000105721181896181534,
-      -9.47131199620464829e-09 * 1. / (1_MeV), 0, -9.9789567797386219e-05,
-      -4.51521351414238938e-05, 3.03179808724962641e-06,
-      -2.47402428503374937e-08, 1.75584896641553984e-09 * 1. / (1_MeV), 0,
-      9.88074736457750535e-07, 0.000105721181896181534,
-      -2.47402428503374937e-08, 9.8112643343029049e-08,
-      -1.43857092852611679e-12 * 1. / (1_MeV), 0,
-      -3.61024835134689107e-08 * 1. / (1_MeV),
-      -9.47131199620464829e-09 * 1. / (1_MeV),
-      1.75584896641553984e-09 * 1. / (1_MeV),
-      -1.43857092852611679e-12 * 1. / (1_MeV),
-      1.24140029852948253e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams100 = BoundParameters(tgContext, std::move(covMat100),
-                                        params100, perigeeSurface);
-  tracks.push_back(boundParams100);
-
-  // track 101 :
-  BoundVector params101;
-  params101 << 0.641214549541473389, -26.0584869384765625, 1.89008140563964844,
-      0.860124528408050537, 0.00106167653575539589 * 1. / (1_MeV), 0;
-  Covariance covMat101;
-  covMat101 << 0.0103070121258497238, 0.000236402176595641814,
-      -0.000307985893857692168, 3.39085785889227025e-06,
-      -1.78250227329527766e-07 * 1. / (1_MeV), 0, 0.000236402176595641814,
-      0.0338090509176254272, -1.38128442497058292e-05, 0.000515236218679150171,
-      4.11640035508361721e-10 * 1. / (1_MeV), 0, -0.000307985893857692168,
-      -1.38128442497058292e-05, 9.32193688640836626e-06,
-      -2.03856681051109258e-07, 8.47974964267322053e-09 * 1. / (1_MeV), 0,
-      3.39085785889227025e-06, 0.000515236218679150171,
-      -2.03856681051109258e-07, 8.28272459330037236e-06,
-      5.47351419013377902e-11 * 1. / (1_MeV), 0,
-      -1.78250227329527766e-07 * 1. / (1_MeV),
-      4.11640035508361721e-10 * 1. / (1_MeV),
-      8.47974964267322053e-09 * 1. / (1_MeV),
-      5.47351419013377902e-11 * 1. / (1_MeV),
-      2.47352943683054605e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams101 = BoundParameters(tgContext, std::move(covMat101),
-                                        params101, perigeeSurface);
-  tracks.push_back(boundParams101);
-
-  // track 102 :
-  BoundVector params102;
-  params102 << -0.362777590751647949, -46.8636550903320312,
-      0.170416802167892456, 2.36327528953552246,
-      -0.000455565168522298336 * 1. / (1_MeV), 0;
-  Covariance covMat102;
-  covMat102 << 0.00364208268001675606, 8.14110252555974963e-05,
-      -0.000105730958373490328, 7.352639037761148e-07,
-      -1.11606862640893415e-07 * 1. / (1_MeV), 0, 8.14110252555974963e-05,
-      0.0136387618258595467, -2.96848315587999865e-06, 0.00014858030669170883,
-      -2.44465634156851802e-09 * 1. / (1_MeV), 0, -0.000105730958373490328,
-      -2.96848315587999865e-06, 3.21430798067012802e-06,
-      -3.21777938528106935e-08, 4.84297827278802643e-09 * 1. / (1_MeV), 0,
-      7.352639037761148e-07, 0.00014858030669170883, -3.21777938528106935e-08,
-      1.92027391676674597e-06, 7.89285090595557677e-12 * 1. / (1_MeV), 0,
-      -1.11606862640893415e-07 * 1. / (1_MeV),
-      -2.44465634156851802e-09 * 1. / (1_MeV),
-      4.84297827278802643e-09 * 1. / (1_MeV),
-      7.89285090595557677e-12 * 1. / (1_MeV),
-      1.05506943459676705e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams102 = BoundParameters(tgContext, std::move(covMat102),
-                                        params102, perigeeSurface);
-  tracks.push_back(boundParams102);
-
-  // track 103 :
-  BoundVector params103;
-  params103 << -0.40931740403175354, -26.7641277313232422, 0.23282817006111145,
-      1.9218742847442627, -0.00123902841005474329 * 1. / (1_MeV), 0;
-  Covariance covMat103;
-  covMat103 << 0.00617217039689421654, 8.91950346564854339e-05,
-      -0.000185605375297960145, 1.82571256326137244e-06,
-      -9.99364389719838625e-08 * 1. / (1_MeV), 0, 8.91950346564854339e-05,
-      0.0202017351984977722, -4.70036532729824457e-06, 0.000417853265694033654,
-      -3.42294422890168881e-09 * 1. / (1_MeV), 0, -0.000185605375297960145,
-      -4.70036532729824457e-06, 5.65443906452856027e-06,
-      -9.94552627423270062e-08, 5.03852824195809614e-09 * 1. / (1_MeV), 0,
-      1.82571256326137244e-06, 0.000417853265694033654,
-      -9.94552627423270062e-08, 9.30496571527328342e-06,
-      -5.69843357485556815e-11 * 1. / (1_MeV), 0,
-      -9.99364389719838625e-08 * 1. / (1_MeV),
-      -3.42294422890168881e-09 * 1. / (1_MeV),
-      5.03852824195809614e-09 * 1. / (1_MeV),
-      -5.69843357485556815e-11 * 1. / (1_MeV),
-      1.89580739995420799e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams103 = BoundParameters(tgContext, std::move(covMat103),
-                                        params103, perigeeSurface);
-  tracks.push_back(boundParams103);
-
-  // track 104 :
-  BoundVector params104;
-  params104 << -0.404072463512420654, -38.5120201110839844,
-      0.344911128282546997, 1.1619257926940918,
-      0.000986460363492369652 * 1. / (1_MeV), 0;
-  Covariance covMat104;
-  covMat104 << 0.00567628862336277962, 1.63609496095437183e-05,
-      -0.000170335731137528478, 1.2532630967862434e-06,
-      -7.98636404443589343e-08 * 1. / (1_MeV), 0, 1.63609496095437183e-05,
-      0.0189783293753862381, -2.2718372282879903e-06, 0.000355776438418386749,
-      -2.11084620426846086e-09 * 1. / (1_MeV), 0, -0.000170335731137528478,
-      -2.2718372282879903e-06, 5.16884620083146729e-06,
-      -7.55285582881687735e-08, 3.807619848578843e-09 * 1. / (1_MeV), 0,
-      1.2532630967862434e-06, 0.000355776438418386749, -7.55285582881687735e-08,
-      7.77826517150970176e-06, -9.50285600530462166e-11 * 1. / (1_MeV), 0,
-      -7.98636404443589343e-08 * 1. / (1_MeV),
-      -2.11084620426846086e-09 * 1. / (1_MeV),
-      3.807619848578843e-09 * 1. / (1_MeV),
-      -9.50285600530462166e-11 * 1. / (1_MeV),
-      1.29019364636384637e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams104 = BoundParameters(tgContext, std::move(covMat104),
-                                        params104, perigeeSurface);
-  tracks.push_back(boundParams104);
-
-  // track 105 :
-  BoundVector params105;
-  params105 << -0.748140871524810791, -23.7969169616699219,
-      -1.03605329990386963, 2.42653083801269531,
-      -0.00107949809171259403 * 1. / (1_MeV), 0;
-  Covariance covMat105;
-  covMat105 << 0.0166618265211582184, 0.000828099383602299449,
-      -0.000494286373322627617, 7.81528533501132929e-06,
-      -2.37068070630336222e-07 * 1. / (1_MeV), 0, 0.000828099383602299449,
-      0.054433431476354599, -3.50962664017384553e-05, 0.000667669965196798754,
-      -8.65990164654914017e-09 * 1. / (1_MeV), 0, -0.000494286373322627617,
-      -3.50962664017384553e-05, 1.49260613397927955e-05,
-      -3.71389679468892074e-07, 1.21273109287785646e-08 * 1. / (1_MeV), 0,
-      7.81528533501132929e-06, 0.000667669965196798754,
-      -3.71389679468892074e-07, 8.39095991977956146e-06,
-      -1.74774216671551251e-11 * 1. / (1_MeV), 0,
-      -2.37068070630336222e-07 * 1. / (1_MeV),
-      -8.65990164654914017e-09 * 1. / (1_MeV),
-      1.21273109287785646e-08 * 1. / (1_MeV),
-      -1.74774216671551251e-11 * 1. / (1_MeV),
-      3.28096633195329446e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams105 = BoundParameters(tgContext, std::move(covMat105),
-                                        params105, perigeeSurface);
-  tracks.push_back(boundParams105);
-
-  // track 106 :
-  BoundVector params106;
-  params106 << -0.1366615891456604, -27.5638828277587891, -2.49039888381958008,
-      2.61403965950012207, -0.000799041183199733496 * 1. / (1_MeV), 0;
-  Covariance covMat106;
-  covMat106 << 0.0195895861834287643, 0.000432913617665369582,
-      -0.000583389996389527331, 5.64615132296629398e-06,
-      -2.21743636175833062e-07 * 1. / (1_MeV), 0, 0.000432913617665369582,
-      0.0853368565440177917, -2.81463041205404891e-05, 0.00062887185835232241,
-      7.3903210045338403e-10 * 1. / (1_MeV), 0, -0.000583389996389527331,
-      -2.81463041205404891e-05, 1.76701887539820746e-05,
-      -2.86129485279660388e-07, 1.13733623250742995e-08 * 1. / (1_MeV), 0,
-      5.64615132296629398e-06, 0.00062887185835232241, -2.86129485279660388e-07,
-      4.7167955017357599e-06, -6.31956258410507594e-12 * 1. / (1_MeV), 0,
-      -2.21743636175833062e-07 * 1. / (1_MeV),
-      7.3903210045338403e-10 * 1. / (1_MeV),
-      1.13733623250742995e-08 * 1. / (1_MeV),
-      -6.31956258410507594e-12 * 1. / (1_MeV),
-      2.37201536190667639e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams106 = BoundParameters(tgContext, std::move(covMat106),
-                                        params106, perigeeSurface);
-  tracks.push_back(boundParams106);
-
-  // track 107 :
-  BoundVector params107;
-  params107 << -0.281952261924743652, -27.2675514221191406,
-      0.283114522695541382, 2.50815463066101074,
-      0.000522553629707545042 * 1. / (1_MeV), 0;
-  Covariance covMat107;
-  covMat107 << 0.00573171814903616905, 0.00019089292202471595,
-      -0.00016298341980869213, -1.57774753003534747e-07,
-      -1.76578997119228594e-07 * 1. / (1_MeV), 0, 0.00019089292202471595,
-      0.0275938734412193298, -6.10260426027345211e-07, 0.000245123840061546561,
-      -1.87936821571313464e-09 * 1. / (1_MeV), 0, -0.00016298341980869213,
-      -6.10260426027345211e-07, 4.82601581097696908e-06,
-      4.47867660897611079e-08, 8.397331774157027e-09 * 1. / (1_MeV), 0,
-      -1.57774753003534747e-07, 0.000245123840061546561,
-      4.47867660897611079e-08, 2.33085211220895872e-06,
-      4.17575815132199387e-11 * 1. / (1_MeV), 0,
-      -1.76578997119228594e-07 * 1. / (1_MeV),
-      -1.87936821571313464e-09 * 1. / (1_MeV),
-      8.397331774157027e-09 * 1. / (1_MeV),
-      4.17575815132199387e-11 * 1. / (1_MeV),
-      1.90833182589500439e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams107 = BoundParameters(tgContext, std::move(covMat107),
-                                        params107, perigeeSurface);
-  tracks.push_back(boundParams107);
-
-  // track 108 :
-  BoundVector params108;
-  params108 << -0.209811851382255554, -38.4141693115234375,
-      -2.18240070343017578, 2.00559163093566895,
-      0.000823514885269105434 * 1. / (1_MeV), 0;
-  Covariance covMat108;
-  covMat108 << 0.00320075475610792637, -1.04729464667693049e-05,
-      -9.46977753717566058e-05, -8.47132736283527935e-07,
-      -5.70312221165104945e-08 * 1. / (1_MeV), 0, -1.04729464667693049e-05,
-      0.014612528495490551, 1.60439917204324993e-06, 0.00026047244379319754,
-      1.66653208275732943e-09 * 1. / (1_MeV), 0, -9.46977753717566058e-05,
-      1.60439917204324993e-06, 2.8525080324470764e-06, 4.92819818644437109e-08,
-      2.74010143274654739e-09 * 1. / (1_MeV), 0, -8.47132736283527935e-07,
-      0.00026047244379319754, 4.92819818644437109e-08, 5.10619156557368115e-06,
-      4.4716062401029798e-11 * 1. / (1_MeV), 0,
-      -5.70312221165104945e-08 * 1. / (1_MeV),
-      1.66653208275732943e-09 * 1. / (1_MeV),
-      2.74010143274654739e-09 * 1. / (1_MeV),
-      4.4716062401029798e-11 * 1. / (1_MeV),
-      9.70698590951890594e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams108 = BoundParameters(tgContext, std::move(covMat108),
-                                        params108, perigeeSurface);
-  tracks.push_back(boundParams108);
-
-  // track 109 :
-  BoundVector params109;
-  params109 << 0.400049686431884766, 5.43777561187744141, 1.30985116958618164,
-      0.949728786945343018, 0.00125019415281713009 * 1. / (1_MeV), 0;
-  Covariance covMat109;
-  covMat109 << 0.0109754176810383797, 8.39713551440950264e-05,
-      -0.000324492312141962081, 3.05687976180540516e-06,
-      -1.72665763951203633e-07 * 1. / (1_MeV), 0, 8.39713551440950264e-05,
-      0.0270265769213438034, -9.01515946057451831e-06, 0.000490121886147781502,
-      1.08024475744600902e-09 * 1. / (1_MeV), 0, -0.000324492312141962081,
-      -9.01515946057451831e-06, 9.76565206656232476e-06,
-      -2.03225115069697751e-07, 8.22356836237723778e-09 * 1. / (1_MeV), 0,
-      3.05687976180540516e-06, 0.000490121886147781502,
-      -2.03225115069697751e-07, 9.30580608837772161e-06,
-      3.42299696660580778e-11 * 1. / (1_MeV), 0,
-      -1.72665763951203633e-07 * 1. / (1_MeV),
-      1.08024475744600902e-09 * 1. / (1_MeV),
-      8.22356836237723778e-09 * 1. / (1_MeV),
-      3.42299696660580778e-11 * 1. / (1_MeV),
-      2.54714332958982936e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams109 = BoundParameters(tgContext, std::move(covMat109),
-                                        params109, perigeeSurface);
-  tracks.push_back(boundParams109);
-
-  // track 110 :
-  BoundVector params110;
-  params110 << -0.539265453815460205, -1.51409578323364258,
-      -1.46416330337524414, 0.445282995700836182,
-      -0.000581343425437808037 * 1. / (1_MeV), 0;
-  Covariance covMat110;
-  covMat110 << 0.0150984814390540123, -0.00078787709593504591,
-      -0.000463668385076406234, -3.40126069737758356e-06,
-      -4.7594001233568186e-07 * 1. / (1_MeV), 0, -0.00078787709593504591,
-      0.0981750190258026123, 3.73198782812315689e-05, 0.000517547473711687102,
-      1.71900525614601273e-08 * 1. / (1_MeV), 0, -0.000463668385076406234,
-      3.73198782812315689e-05, 1.45666390380938537e-05, 1.75249294465507646e-07,
-      2.38844165520381005e-08 * 1. / (1_MeV), 0, -3.40126069737758356e-06,
-      0.000517547473711687102, 1.75249294465507646e-07, 2.79596974905871321e-06,
-      1.81008924621221718e-12 * 1. / (1_MeV), 0,
-      -4.7594001233568186e-07 * 1. / (1_MeV),
-      1.71900525614601273e-08 * 1. / (1_MeV),
-      2.38844165520381005e-08 * 1. / (1_MeV),
-      1.81008924621221718e-12 * 1. / (1_MeV),
-      4.11227746299758223e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams110 = BoundParameters(tgContext, std::move(covMat110),
-                                        params110, perigeeSurface);
-  tracks.push_back(boundParams110);
-
-  // track 111 :
-  BoundVector params111;
-  params111 << 0.671114623546600342, -23.2680797576904297, 2.88971590995788574,
-      2.53794145584106445, 0.000528754433616995811 * 1. / (1_MeV), 0;
-  Covariance covMat111;
-  covMat111 << 0.00582297053188085556, -0.000178269433632520676,
-      -0.00017064040508346805, -9.16577544786184328e-07,
-      -7.39871471870988742e-08 * 1. / (1_MeV), 0, -0.000178269433632520676,
-      0.0320282876491546631, 9.47676944871473379e-06, 0.000262375079643188658,
-      2.3446639759563834e-09 * 1. / (1_MeV), 0, -0.00017064040508346805,
-      9.47676944871473379e-06, 5.11728148921974935e-06, 6.10420777287489119e-08,
-      3.63856481310620549e-09 * 1. / (1_MeV), 0, -9.16577544786184328e-07,
-      0.000262375079643188658, 6.10420777287489119e-08, 2.29290367315115873e-06,
-      -1.73298870890743619e-12 * 1. / (1_MeV), 0,
-      -7.39871471870988742e-08 * 1. / (1_MeV),
-      2.3446639759563834e-09 * 1. / (1_MeV),
-      3.63856481310620549e-09 * 1. / (1_MeV),
-      -1.73298870890743619e-12 * 1. / (1_MeV),
-      8.13164466317850554e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams111 = BoundParameters(tgContext, std::move(covMat111),
-                                        params111, perigeeSurface);
-  tracks.push_back(boundParams111);
-
-  // track 112 :
-  BoundVector params112;
-  params112 << -0.567338824272155762, -39.2379379272460938,
-      -0.573527812957763672, 2.7919611930847168,
-      0.000323907297570258379 * 1. / (1_MeV), 0;
-  Covariance covMat112;
-  covMat112 << 0.0145241515710949898, 0.00100893966705628622,
-      -0.000435175147220113426, -7.91300794951697705e-07,
-      -1.50984912241323336e-07 * 1. / (1_MeV), 0, 0.00100893966705628622,
-      0.162825420498847961, -1.17342322710575323e-05, 0.000570896267478980253,
-      -1.57354143788096226e-08 * 1. / (1_MeV), 0, -0.000435175147220113426,
-      -1.17342322710575323e-05, 1.32923332785139792e-05,
-      8.24493698474199101e-08, 7.3705206571867806e-09 * 1. / (1_MeV), 0,
-      -7.91300794951697705e-07, 0.000570896267478980253,
-      8.24493698474199101e-08, 2.02825663109251764e-06,
-      -1.36270420577401879e-12 * 1. / (1_MeV), 0,
-      -1.50984912241323336e-07 * 1. / (1_MeV),
-      -1.57354143788096226e-08 * 1. / (1_MeV),
-      7.3705206571867806e-09 * 1. / (1_MeV),
-      -1.36270420577401879e-12 * 1. / (1_MeV),
-      9.7393829112668584e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams112 = BoundParameters(tgContext, std::move(covMat112),
-                                        params112, perigeeSurface);
-  tracks.push_back(boundParams112);
-
-  // track 113 :
-  BoundVector params113;
-  params113 << -0.352110147476196289, -42.806732177734375, -1.94127309322357178,
-      0.234347626566886902, 0.000298306811600923538 * 1. / (1_MeV), 0;
-  Covariance covMat113;
-  covMat113 << 0.0297679267823696136, -0.000157760492633259443,
-      -0.000897409671925476033, 5.00768443241615978e-06,
-      -2.84713002525393994e-07 * 1. / (1_MeV), 0, -0.000157760492633259443,
-      0.755975544452667236, -6.81046218350048719e-05, 0.00122586976424697179,
-      3.04180315460180327e-08 * 1. / (1_MeV), 0, -0.000897409671925476033,
-      -6.81046218350048719e-05, 2.75633337878389284e-05,
-      -2.65506639049251932e-07, 1.4268675855279823e-08 * 1. / (1_MeV), 0,
-      5.00768443241615978e-06, 0.00122586976424697179, -2.65506639049251932e-07,
-      2.00353611035097856e-06, -5.77783317368770183e-12 * 1. / (1_MeV), 0,
-      -2.84713002525393994e-07 * 1. / (1_MeV),
-      3.04180315460180327e-08 * 1. / (1_MeV),
-      1.4268675855279823e-08 * 1. / (1_MeV),
-      -5.77783317368770183e-12 * 1. / (1_MeV),
-      1.32142283226777124e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams113 = BoundParameters(tgContext, std::move(covMat113),
-                                        params113, perigeeSurface);
-  tracks.push_back(boundParams113);
-
-  // track 114 :
-  BoundVector params114;
-  params114 << 0.70326077938079834, -23.8514003753662109, 2.19736742973327637,
-      2.66175127029418945, -0.000729386345483362675 * 1. / (1_MeV), 0;
-  Covariance covMat114;
-  covMat114 << 0.0201517790555953979, -0.000402410594205282815,
-      -0.000615109406015380898, 6.20916466189531659e-06,
-      -5.01304650979099997e-07 * 1. / (1_MeV), 0, -0.000402410594205282815,
-      0.106326393783092499, -5.39270699210803652e-06, 0.000656929741407722974,
-      4.16003452981261856e-08 * 1. / (1_MeV), 0, -0.000615109406015380898,
-      -5.39270699210803652e-06, 1.91017334145726636e-05,
-      -3.05136297241337109e-07, 2.46257505980399243e-08 * 1. / (1_MeV), 0,
-      6.20916466189531659e-06, 0.000656929741407722974,
-      -3.05136297241337109e-07, 4.13353836847818457e-06,
-      -2.25280483073948522e-11 * 1. / (1_MeV), 0,
-      -5.01304650979099997e-07 * 1. / (1_MeV),
-      4.16003452981261856e-08 * 1. / (1_MeV),
-      2.46257505980399243e-08 * 1. / (1_MeV),
-      -2.25280483073948522e-11 * 1. / (1_MeV),
-      4.48457743162933298e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams114 = BoundParameters(tgContext, std::move(covMat114),
-                                        params114, perigeeSurface);
-  tracks.push_back(boundParams114);
-
-  // track 115 :
-  BoundVector params115;
-  params115 << 0.671093463897705078, -45.1692886352539062, 1.74538934230804443,
-      0.344533443450927734, -0.000281130109215155244 * 1. / (1_MeV), 0;
-  Covariance covMat115;
-  covMat115 << 0.00903735589236021042, -0.00019873340309471113,
-      -0.000273524033995838783, -2.89533457392990707e-06,
-      -1.61454060310120352e-07 * 1. / (1_MeV), 0, -0.00019873340309471113,
-      0.107433833181858063, 1.17062433953150529e-05, 0.000347414063588650612,
-      -5.60630576356142156e-09 * 1. / (1_MeV), 0, -0.000273524033995838783,
-      1.17062433953150529e-05, 8.43327961774775758e-06, 1.10675918622981839e-07,
-      7.60358813812795812e-09 * 1. / (1_MeV), 0, -2.89533457392990707e-06,
-      0.000347414063588650612, 1.10675918622981839e-07, 1.1579301144593046e-06,
-      3.89686466885357287e-11 * 1. / (1_MeV), 0,
-      -1.61454060310120352e-07 * 1. / (1_MeV),
-      -5.60630576356142156e-09 * 1. / (1_MeV),
-      7.60358813812795812e-09 * 1. / (1_MeV),
-      3.89686466885357287e-11 * 1. / (1_MeV),
-      9.49285094975493848e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams115 = BoundParameters(tgContext, std::move(covMat115),
-                                        params115, perigeeSurface);
-  tracks.push_back(boundParams115);
-
-  // track 116 :
-  BoundVector params116;
-  params116 << -0.513536512851715088, -24.0025615692138672,
-      -1.29378879070281982, 0.68014836311340332,
-      -0.00116809376049786806 * 1. / (1_MeV), 0;
-  Covariance covMat116;
-  covMat116 << 0.0196314919739961624, -0.000964473384199337471,
-      -0.000592159047274326794, -1.01560641560312488e-05,
-      -3.59403968241742458e-07 * 1. / (1_MeV), 0, -0.000964473384199337471,
-      0.0900372341275215149, 4.81210676710760611e-05, 0.000917365400873606292,
-      4.18182893772007853e-09 * 1. / (1_MeV), 0, -0.000592159047274326794,
-      4.81210676710760611e-05, 1.81187115231296048e-05, 5.11456018571083069e-07,
-      1.74822784071129361e-08 * 1. / (1_MeV), 0, -1.01560641560312488e-05,
-      0.000917365400873606292, 5.11456018571083069e-07, 9.76017781795235351e-06,
-      -2.45815925497200098e-12 * 1. / (1_MeV), 0,
-      -3.59403968241742458e-07 * 1. / (1_MeV),
-      4.18182893772007853e-09 * 1. / (1_MeV),
-      1.74822784071129361e-08 * 1. / (1_MeV),
-      -2.45815925497200098e-12 * 1. / (1_MeV),
-      4.33391877940891845e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams116 = BoundParameters(tgContext, std::move(covMat116),
-                                        params116, perigeeSurface);
-  tracks.push_back(boundParams116);
-
-  // track 117 :
-  BoundVector params117;
-  params117 << -0.188389301300048828, -27.492034912109375, -2.0469822883605957,
-      0.402536779642105103, -0.000401498342398554087 * 1. / (1_MeV), 0;
-  Covariance covMat117;
-  covMat117 << 0.0106127634644508362, -0.000530327986901170411,
-      -0.000318114363953226264, -2.58171609717844701e-06,
-      -3.04161855482286476e-07 * 1. / (1_MeV), 0, -0.000530327986901170411,
-      0.0728393122553825378, 2.18031202084567084e-05, 0.000323112379856879315,
-      8.72212302001908086e-09 * 1. / (1_MeV), 0, -0.000318114363953226264,
-      2.18031202084567084e-05, 9.83124391495948657e-06, 1.0660118653808876e-07,
-      1.49552172231130049e-08 * 1. / (1_MeV), 0, -2.58171609717844701e-06,
-      0.000323112379856879315, 1.0660118653808876e-07, 1.46258253153064288e-06,
-      3.10238162026694015e-11 * 1. / (1_MeV), 0,
-      -3.04161855482286476e-07 * 1. / (1_MeV),
-      8.72212302001908086e-09 * 1. / (1_MeV),
-      1.49552172231130049e-08 * 1. / (1_MeV),
-      3.10238162026694015e-11 * 1. / (1_MeV),
-      2.30750710206173437e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams117 = BoundParameters(tgContext, std::move(covMat117),
-                                        params117, perigeeSurface);
-  tracks.push_back(boundParams117);
-
-  // track 118 :
-  BoundVector params118;
-  params118 << -0.0811463147401809692, -27.6623687744140625,
-      0.45338207483291626, 2.77416062355041504,
-      0.000383521459298208356 * 1. / (1_MeV), 0;
-  Covariance covMat118;
-  covMat118 << 0.0120377568528056145, 0.000348936630741464966,
-      -0.000367708072083872627, -4.00268806455590574e-07,
-      -2.44429806871556943e-07 * 1. / (1_MeV), 0, 0.000348936630741464966,
-      0.106920868158340454, 2.02262643355694362e-06, 0.000396612496039519481,
-      -1.29354667260461022e-08 * 1. / (1_MeV), 0, -0.000367708072083872627,
-      2.02262643355694362e-06, 1.14461399789433926e-05, 5.77674609016439322e-08,
-      1.20551713367857255e-08 * 1. / (1_MeV), 0, -4.00268806455590574e-07,
-      0.000396612496039519481, 5.77674609016439322e-08, 1.50108360230660765e-06,
-      -1.71918312121670268e-11 * 1. / (1_MeV), 0,
-      -2.44429806871556943e-07 * 1. / (1_MeV),
-      -1.29354667260461022e-08 * 1. / (1_MeV),
-      1.20551713367857255e-08 * 1. / (1_MeV),
-      -1.71918312121670268e-11 * 1. / (1_MeV),
-      1.72003744580706552e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams118 = BoundParameters(tgContext, std::move(covMat118),
-                                        params118, perigeeSurface);
-  tracks.push_back(boundParams118);
-
-  // track 119 :
-  BoundVector params119;
-  params119 << -0.669821977615356445, -0.254957705736160278,
-      -0.642573356628417969, 0.338302493095397949,
-      -0.000448048056568950415 * 1. / (1_MeV), 0;
-  Covariance covMat119;
-  covMat119 << 0.0216007865965366364, -0.00185881288533683146,
-      -0.000647740560197286076, -4.15704652410560125e-06,
-      -2.75570705855937687e-07 * 1. / (1_MeV), 0, -0.00185881288533683146,
-      0.205522537231445312, 7.6902207402064222e-05, 0.00067089446492805667,
-      2.13544688641597921e-08 * 1. / (1_MeV), 0, -0.000647740560197286076,
-      7.6902207402064222e-05, 1.98106827156152576e-05, 1.96993374819633446e-07,
-      1.39122962799931803e-08 * 1. / (1_MeV), 0, -4.15704652410560125e-06,
-      0.00067089446492805667, 1.96993374819633446e-07, 2.21493996832577977e-06,
-      6.08338264527575119e-12 * 1. / (1_MeV), 0,
-      -2.75570705855937687e-07 * 1. / (1_MeV),
-      2.13544688641597921e-08 * 1. / (1_MeV),
-      1.39122962799931803e-08 * 1. / (1_MeV),
-      6.08338264527575119e-12 * 1. / (1_MeV),
-      1.86805737545370221e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams119 = BoundParameters(tgContext, std::move(covMat119),
-                                        params119, perigeeSurface);
-  tracks.push_back(boundParams119);
-
-  // track 120 :
-  BoundVector params120;
-  params120 << 0.620538651943206787, -5.9463653564453125, 2.88366031646728516,
-      0.806014358997344971, 0.000814548286143690348 * 1. / (1_MeV), 0;
-  Covariance covMat120;
-  covMat120 << 0.00660947803407907486, 0.000148207317841221223,
-      -0.000194191570441951892, 1.81425520658158306e-06,
-      -1.30802501722950138e-07 * 1. / (1_MeV), 0, 0.000148207317841221223,
-      0.0214615482836961746, -8.02621091024865615e-06, 0.000291939065786425093,
-      -3.37860649239220225e-09 * 1. / (1_MeV), 0, -0.000194191570441951892,
-      -8.02621091024865615e-06, 5.84407371206907555e-06,
-      -1.03748135696870454e-07, 6.35917118456449052e-09 * 1. / (1_MeV), 0,
-      1.81425520658158306e-06, 0.000291939065786425093,
-      -1.03748135696870454e-07, 4.28725343226687983e-06,
-      -2.51583629069704591e-11 * 1. / (1_MeV), 0,
-      -1.30802501722950138e-07 * 1. / (1_MeV),
-      -3.37860649239220225e-09 * 1. / (1_MeV),
-      6.35917118456449052e-09 * 1. / (1_MeV),
-      -2.51583629069704591e-11 * 1. / (1_MeV),
-      1.78077538826038051e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams120 = BoundParameters(tgContext, std::move(covMat120),
-                                        params120, perigeeSurface);
-  tracks.push_back(boundParams120);
-
-  // track 121 :
-  BoundVector params121;
-  params121 << 0.628487765789031982, -46.8420448303222656, 2.83293843269348145,
-      0.440805107355117798, 0.00010274051601300016 * 1. / (1_MeV), 0;
-  Covariance covMat121;
-  covMat121 << 0.000842933135572820902, -2.19657301004237121e-05,
-      -2.40593078576417954e-05, -2.61079431395439085e-07,
-      -6.29023439716158914e-09 * 1. / (1_MeV), 0, -2.19657301004237121e-05,
-      0.00974787771701812744, -2.23540359415713673e-08, 4.29750192042335346e-05,
-      -3.28310247664964105e-10 * 1. / (1_MeV), 0, -2.40593078576417954e-05,
-      -2.23540359415713673e-08, 7.04093849890341517e-07,
-      5.44971636290248205e-09, 3.05175081762309306e-10 * 1. / (1_MeV), 0,
-      -2.61079431395439085e-07, 4.29750192042335346e-05,
-      5.44971636290248205e-09, 2.0320584326327662e-07,
-      1.64157138196977762e-13 * 1. / (1_MeV), 0,
-      -6.29023439716158914e-09 * 1. / (1_MeV),
-      -3.28310247664964105e-10 * 1. / (1_MeV),
-      3.05175081762309306e-10 * 1. / (1_MeV),
-      1.64157138196977762e-13 * 1. / (1_MeV),
-      5.16425357338645696e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams121 = BoundParameters(tgContext, std::move(covMat121),
-                                        params121, perigeeSurface);
-  tracks.push_back(boundParams121);
-
-  // track 122 :
-  BoundVector params122;
-  params122 << -0.812381505966186523, -28.9338283538818359, -1.2193833589553833,
-      1.04633200168609619, 0.00115260039456188679 * 1. / (1_MeV), 0;
-  Covariance covMat122;
-  covMat122 << 0.00886439252644777298, -7.98301718682701986e-05,
-      -0.000261729182772038702, 2.80699128527500705e-06,
-      -1.19181091476079831e-07 * 1. / (1_MeV), 0, -7.98301718682701986e-05,
-      0.0244551245123147964, -1.85192755523473285e-06, 0.000485515751149120391,
-      2.3685986667229676e-09 * 1. / (1_MeV), 0, -0.000261729182772038702,
-      -1.85192755523473285e-06, 7.82700044510420412e-06,
-      -1.65953545175140125e-07, 5.47590882437587651e-09 * 1. / (1_MeV), 0,
-      2.80699128527500705e-06, 0.000485515751149120391,
-      -1.65953545175140125e-07, 1.0220603144261986e-05,
-      -1.07937619402598992e-11 * 1. / (1_MeV), 0,
-      -1.19181091476079831e-07 * 1. / (1_MeV),
-      2.3685986667229676e-09 * 1. / (1_MeV),
-      5.47590882437587651e-09 * 1. / (1_MeV),
-      -1.07937619402598992e-11 * 1. / (1_MeV),
-      1.73649483681259653e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams122 = BoundParameters(tgContext, std::move(covMat122),
-                                        params122, perigeeSurface);
-  tracks.push_back(boundParams122);
-
-  // track 123 :
-  BoundVector params123;
-  params123 << 0.674202203750610352, -46.3594818115234375, 2.85884332656860352,
-      0.887206554412841797, -0.000505877542309463024 * 1. / (1_MeV), 0;
-  Covariance covMat123;
-  covMat123 << 0.00251318048685789108, -1.66645647325415036e-06,
-      -6.98672509700519375e-05, -7.12881638668814119e-07,
-      -6.71595898982830382e-08 * 1. / (1_MeV), 0, -1.66645647325415036e-06,
-      0.00859435927122831345, 5.71233764557248797e-07, 0.000121854224792618618,
-      1.32173469014469017e-09 * 1. / (1_MeV), 0, -6.98672509700519375e-05,
-      5.71233764557248797e-07, 2.02263481696718372e-06, 3.12296641803006321e-08,
-      3.09126253015111042e-09 * 1. / (1_MeV), 0, -7.12881638668814119e-07,
-      0.000121854224792618618, 3.12296641803006321e-08, 1.98942507267929614e-06,
-      9.00985395948335217e-11 * 1. / (1_MeV), 0,
-      -6.71595898982830382e-08 * 1. / (1_MeV),
-      1.32173469014469017e-09 * 1. / (1_MeV),
-      3.09126253015111042e-09 * 1. / (1_MeV),
-      9.00985395948335217e-11 * 1. / (1_MeV),
-      8.96472895917099777e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams123 = BoundParameters(tgContext, std::move(covMat123),
-                                        params123, perigeeSurface);
-  tracks.push_back(boundParams123);
-
-  // track 124 :
-  BoundVector params124;
-  params124 << -0.317187309265136719, -5.00441408157348633,
-      0.162307113409042358, 0.750772595405578613,
-      -0.000692651956342160702 * 1. / (1_MeV), 0;
-  Covariance covMat124;
-  covMat124 << 0.00589033449068665504, -0.000147228859748553363,
-      -0.000171248391294949903, -1.76774655708203412e-06,
-      -1.07121129211567312e-07 * 1. / (1_MeV), 0, -0.000147228859748553363,
-      0.0193875245749950409, 6.6144993330992646e-06, 0.000238616816721432543,
-      1.73743427737471889e-09 * 1. / (1_MeV), 0, -0.000171248391294949903,
-      6.6144993330992646e-06, 5.10799418407259509e-06, 8.27169602099734583e-08,
-      5.19150014241903916e-09 * 1. / (1_MeV), 0, -1.76774655708203412e-06,
-      0.000238616816721432543, 8.27169602099734583e-08, 3.09604706671962049e-06,
-      1.1663553056713431e-11 * 1. / (1_MeV), 0,
-      -1.07121129211567312e-07 * 1. / (1_MeV),
-      1.73743427737471889e-09 * 1. / (1_MeV),
-      5.19150014241903916e-09 * 1. / (1_MeV),
-      1.1663553056713431e-11 * 1. / (1_MeV),
-      1.38518113645957897e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams124 = BoundParameters(tgContext, std::move(covMat124),
-                                        params124, perigeeSurface);
-  tracks.push_back(boundParams124);
-
-  // track 125 :
-  BoundVector params125;
-  params125 << -0.367212682962417603, -26.4488010406494141,
-      -0.589624702930450439, 0.890817821025848389,
-      -0.00130973628256469965 * 1. / (1_MeV), 0;
-  Covariance covMat125;
-  covMat125 << 0.0136615298688411713, -0.000553210438098500888,
-      -0.000408959420512909242, -9.54127328493114892e-06,
-      -2.28585933325679961e-07 * 1. / (1_MeV), 0, -0.000553210438098500888,
-      0.0606655515730381012, 2.85290059337265401e-05, 0.000919541054049329964,
-      6.41373777463503296e-10 * 1. / (1_MeV), 0, -0.000408959420512909242,
-      2.85290059337265401e-05, 1.2425651220837608e-05, 4.81781448104062685e-07,
-      1.15319447682158026e-08 * 1. / (1_MeV), 0, -9.54127328493114892e-06,
-      0.000919541054049329964, 4.81781448104062685e-07, 1.48983235703781247e-05,
-      -4.6401369967705386e-12 * 1. / (1_MeV), 0,
-      -2.28585933325679961e-07 * 1. / (1_MeV),
-      6.41373777463503296e-10 * 1. / (1_MeV),
-      1.15319447682158026e-08 * 1. / (1_MeV),
-      -4.6401369967705386e-12 * 1. / (1_MeV),
-      3.61465746223643691e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams125 = BoundParameters(tgContext, std::move(covMat125),
-                                        params125, perigeeSurface);
-  tracks.push_back(boundParams125);
-
-  // track 126 :
-  BoundVector params126;
-  params126 << -0.819772541522979736, -15.088465690612793, -1.57550454139709473,
-      2.87169027328491211, -0.000316481309710070491 * 1. / (1_MeV), 0;
-  Covariance covMat126;
-  covMat126 << 0.020475972443819046, 0.00244909382101079955,
-      -0.000612602284994073114, 2.84735667237426659e-06,
-      -1.18856619171178898e-07 * 1. / (1_MeV), 0, 0.00244909382101079955,
-      0.285471856594085693, -9.50848052190165181e-05, 0.00060520112781335168,
-      -1.42274967363324924e-08 * 1. / (1_MeV), 0, -0.000612602284994073114,
-      -9.50848052190165181e-05, 1.86471988854464144e-05,
-      -1.33140486250698117e-07, 6.17048734091374837e-09 * 1. / (1_MeV), 0,
-      2.84735667237426659e-06, 0.00060520112781335168, -1.33140486250698117e-07,
-      1.2966377198608825e-06, 1.20738678057781713e-12 * 1. / (1_MeV), 0,
-      -1.18856619171178898e-07 * 1. / (1_MeV),
-      -1.42274967363324924e-08 * 1. / (1_MeV),
-      6.17048734091374837e-09 * 1. / (1_MeV),
-      1.20738678057781713e-12 * 1. / (1_MeV),
-      6.87515253061654619e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams126 = BoundParameters(tgContext, std::move(covMat126),
-                                        params126, perigeeSurface);
-  tracks.push_back(boundParams126);
-
-  // track 127 :
-  BoundVector params127;
-  params127 << -0.318770557641983032, -24.7678050994873047,
-      0.258936554193496704, 0.221435293555259705,
-      0.000250038632657378912 * 1. / (1_MeV), 0;
-  Covariance covMat127;
-  covMat127 << 0.0237364936619997025, -0.00216027412516154932,
-      -0.000714136299484843372, 3.91136153798043594e-07,
-      -1.92060015221202961e-07 * 1. / (1_MeV), 0, -0.00216027412516154932,
-      0.474111497402191162, 2.45504002711651886e-05, 0.000683401475519821908,
-      2.31633021184019983e-08 * 1. / (1_MeV), 0, -0.000714136299484843372,
-      2.45504002711651886e-05, 2.19113735511200503e-05,
-      -6.74041726618829811e-08, 9.78682020756434252e-09 * 1. / (1_MeV), 0,
-      3.91136153798043594e-07, 0.000683401475519821908,
-      -6.74041726618829811e-08, 9.95008008430886548e-07,
-      2.37236751652554644e-12 * 1. / (1_MeV), 0,
-      -1.92060015221202961e-07 * 1. / (1_MeV),
-      2.31633021184019983e-08 * 1. / (1_MeV),
-      9.78682020756434252e-09 * 1. / (1_MeV),
-      2.37236751652554644e-12 * 1. / (1_MeV),
-      8.74325264965669646e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams127 = BoundParameters(tgContext, std::move(covMat127),
-                                        params127, perigeeSurface);
-  tracks.push_back(boundParams127);
-
-  // track 128 :
-  BoundVector params128;
-  params128 << -0.786545097827911377, -38.7401618957519531,
-      -0.845708072185516357, 0.685007095336914062,
-      -0.00115627096965909004 * 1. / (1_MeV), 0;
-  Covariance covMat128;
-  covMat128 << 0.0192839577794075012, -0.000884148373743458998,
-      -0.000582462336183784323, -8.08110064280186493e-06,
-      -2.82867484656328478e-07 * 1. / (1_MeV), 0, -0.000884148373743458998,
-      0.0635840222239494324, 4.14378320186397384e-05, 0.000713555828392625161,
-      1.15057697948470685e-08 * 1. / (1_MeV), 0, -0.000582462336183784323,
-      4.14378320186397384e-05, 1.78008613147540018e-05, 4.15133191686953799e-07,
-      1.37170909103508374e-08 * 1. / (1_MeV), 0, -8.08110064280186493e-06,
-      0.000713555828392625161, 4.15133191686953799e-07, 8.22206584416562691e-06,
-      3.36288899333749929e-11 * 1. / (1_MeV), 0,
-      -2.82867484656328478e-07 * 1. / (1_MeV),
-      1.15057697948470685e-08 * 1. / (1_MeV),
-      1.37170909103508374e-08 * 1. / (1_MeV),
-      3.36288899333749929e-11 * 1. / (1_MeV),
-      3.38668010302356493e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams128 = BoundParameters(tgContext, std::move(covMat128),
-                                        params128, perigeeSurface);
-  tracks.push_back(boundParams128);
-
-  // track 129 :
-  BoundVector params129;
-  params129 << 0.486697107553482056, -27.5921802520751953, 1.46391701698303223,
-      2.71947717666625977, -0.000425876642111688852 * 1. / (1_MeV), 0;
-  Covariance covMat129;
-  covMat129 << 0.0104358252137899399, -0.000194071380788289307,
-      -0.000315099921452716538, 1.76392275881344802e-06,
-      -1.10626700413367959e-07 * 1. / (1_MeV), 0, -0.000194071380788289307,
-      0.0726201385259628296, -1.22225312305688994e-06, 0.000354468038776242019,
-      1.07847367917163246e-08 * 1. / (1_MeV), 0, -0.000315099921452716538,
-      -1.22225312305688994e-06, 9.63851289270678535e-06,
-      -9.06071612650389521e-08, 5.46013101705028866e-09 * 1. / (1_MeV), 0,
-      1.76392275881344802e-06, 0.000354468038776242019,
-      -9.06071612650389521e-08, 1.75927425516420044e-06,
-      8.12217710906210286e-12 * 1. / (1_MeV), 0,
-      -1.10626700413367959e-07 * 1. / (1_MeV),
-      1.07847367917163246e-08 * 1. / (1_MeV),
-      5.46013101705028866e-09 * 1. / (1_MeV),
-      8.12217710906210286e-12 * 1. / (1_MeV),
-      8.87762224843768877e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams129 = BoundParameters(tgContext, std::move(covMat129),
-                                        params129, perigeeSurface);
-  tracks.push_back(boundParams129);
-
-  // track 130 :
-  BoundVector params130;
-  params130 << -0.617856025695800781, -0.871593713760375977,
-      -0.820657730102539062, 1.98759174346923828,
-      0.00110533414408564568 * 1. / (1_MeV), 0;
-  Covariance covMat130;
-  covMat130 << 0.00552858132869005203, -6.21963191966173515e-06,
-      -0.000165318571599927403, -1.87050290953511793e-06,
-      -9.12087055682573263e-08 * 1. / (1_MeV), 0, -6.21963191966173515e-06,
-      0.0224491767585277557, 2.49900583889646317e-06, 0.000406727201832187205,
-      -1.6111436767727037e-09 * 1. / (1_MeV), 0, -0.000165318571599927403,
-      2.49900583889646317e-06, 5.011198027204955e-06, 1.03599533976687726e-07,
-      4.3871518926068891e-09 * 1. / (1_MeV), 0, -1.87050290953511793e-06,
-      0.000406727201832187205, 1.03599533976687726e-07, 8.68987262947484851e-06,
-      1.25136088613115525e-11 * 1. / (1_MeV), 0,
-      -9.12087055682573263e-08 * 1. / (1_MeV),
-      -1.6111436767727037e-09 * 1. / (1_MeV),
-      4.3871518926068891e-09 * 1. / (1_MeV),
-      1.25136088613115525e-11 * 1. / (1_MeV),
-      1.55834969928214662e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams130 = BoundParameters(tgContext, std::move(covMat130),
-                                        params130, perigeeSurface);
-  tracks.push_back(boundParams130);
-
-  // track 131 :
-  BoundVector params131;
-  params131 << -0.317273795604705811, -39.7836227416992188,
-      0.271088778972625732, 2.60198879241943359,
-      -0.000791704689618200064 * 1. / (1_MeV), 0;
-  Covariance covMat131;
-  covMat131 << 0.0173647217452526093, 0.000699109712679081823,
-      -0.000517395274305629347, 5.83878339750726826e-06,
-      -2.16819932799887328e-07 * 1. / (1_MeV), 0, 0.000699109712679081823,
-      0.0743361711502075195, -3.22919950885157238e-05, 0.000565554144244462416,
-      -2.84215790760252208e-09 * 1. / (1_MeV), 0, -0.000517395274305629347,
-      -3.22919950885157238e-05, 1.57065533130662516e-05,
-      -2.69347200961308565e-07, 1.07852728031145877e-08 * 1. / (1_MeV), 0,
-      5.83878339750726826e-06, 0.000565554144244462416,
-      -2.69347200961308565e-07, 4.39661971540772356e-06,
-      -7.1469095279936026e-12 * 1. / (1_MeV), 0,
-      -2.16819932799887328e-07 * 1. / (1_MeV),
-      -2.84215790760252208e-09 * 1. / (1_MeV),
-      1.07852728031145877e-08 * 1. / (1_MeV),
-      -7.1469095279936026e-12 * 1. / (1_MeV),
-      2.20003334994167687e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams131 = BoundParameters(tgContext, std::move(covMat131),
-                                        params131, perigeeSurface);
-  tracks.push_back(boundParams131);
-
-  // track 132 :
-  BoundVector params132;
-  params132 << -0.176747366786003113, -6.18134498596191406,
-      -2.44022130966186523, 1.06020462512969971,
-      -0.00166206969879567623 * 1. / (1_MeV), 0;
-  Covariance covMat132;
-  covMat132 << 0.0163360219448804855, -0.0003172835243235103,
-      -0.000474475361325176945, -8.23511726091334258e-06,
-      -2.30416042777669323e-07 * 1. / (1_MeV), 0, -0.0003172835243235103,
-      0.0361283980309963226, 1.62689442711704658e-05, 0.000735986183239389154,
-      -2.55052024057200266e-09 * 1. / (1_MeV), 0, -0.000474475361325176945,
-      1.62689442711704658e-05, 1.40814063342986628e-05, 4.00503665767196095e-07,
-      1.13634723345292126e-08 * 1. / (1_MeV), 0, -8.23511726091334258e-06,
-      0.000735986183239389154, 4.00503665767196095e-07, 1.59251703735208139e-05,
-      -4.93303581762030017e-11 * 1. / (1_MeV), 0,
-      -2.30416042777669323e-07 * 1. / (1_MeV),
-      -2.55052024057200266e-09 * 1. / (1_MeV),
-      1.13634723345292126e-08 * 1. / (1_MeV),
-      -4.93303581762030017e-11 * 1. / (1_MeV),
-      3.97582966549236971e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams132 = BoundParameters(tgContext, std::move(covMat132),
-                                        params132, perigeeSurface);
-  tracks.push_back(boundParams132);
-
-  // track 133 :
-  BoundVector params133;
-  params133 << 0.252984225749969482, -0.155150562524795532,
-      -2.66754698753356934, 2.31749868392944336,
-      0.000917813042178750038 * 1. / (1_MeV), 0;
-  Covariance covMat133;
-  covMat133 << 0.00944171752780675888, 0.000145823562828363914,
-      -0.000271052957960221707, -4.55321772559130365e-07,
-      -2.43926736564194306e-07 * 1. / (1_MeV), 0, 0.000145823562828363914,
-      0.0299511272460222244, 3.38575145014588503e-06, 0.000406530300163432086,
-      -3.0856143118849151e-09 * 1. / (1_MeV), 0, -0.000271052957960221707,
-      3.38575145014588503e-06, 8.01670285000000149e-06, 1.05147518352289746e-07,
-      1.1170956971681221e-08 * 1. / (1_MeV), 0, -4.55321772559130365e-07,
-      0.000406530300163432086, 1.05147518352289746e-07, 5.94885204918682575e-06,
-      -1.05152517914159529e-11 * 1. / (1_MeV), 0,
-      -2.43926736564194306e-07 * 1. / (1_MeV),
-      -3.0856143118849151e-09 * 1. / (1_MeV),
-      1.1170956971681221e-08 * 1. / (1_MeV),
-      -1.05152517914159529e-11 * 1. / (1_MeV),
-      3.04403169337774671e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams133 = BoundParameters(tgContext, std::move(covMat133),
-                                        params133, perigeeSurface);
-  tracks.push_back(boundParams133);
-
-  // track 134 :
-  BoundVector params134;
-  params134 << 0.261232942342758179, -4.98270845413208008, -2.7913355827331543,
-      2.3903357982635498, -0.000602899584919214249 * 1. / (1_MeV), 0;
-  Covariance covMat134;
-  covMat134 << 0.00512111512944102287, 0.000151096985693622513,
-      -0.000145316183125153919, 1.87182314845306937e-06,
-      -1.11018028044376921e-07 * 1. / (1_MeV), 0, 0.000151096985693622513,
-      0.0171234942972660065, -4.80042332048881649e-06, 0.000210849209555024551,
-      1.07928525134701817e-09 * 1. / (1_MeV), 0, -0.000145316183125153919,
-      -4.80042332048881649e-06, 4.26421911470242776e-06,
-      -6.99455919823715623e-08, 5.18060114302286267e-09 * 1. / (1_MeV), 0,
-      1.87182314845306937e-06, 0.000210849209555024551,
-      -6.99455919823715623e-08, 2.78515085483377334e-06,
-      2.16936360639539862e-12 * 1. / (1_MeV), 0,
-      -1.11018028044376921e-07 * 1. / (1_MeV),
-      1.07928525134701817e-09 * 1. / (1_MeV),
-      5.18060114302286267e-09 * 1. / (1_MeV),
-      2.16936360639539862e-12 * 1. / (1_MeV),
-      1.35624275698909003e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams134 = BoundParameters(tgContext, std::move(covMat134),
-                                        params134, perigeeSurface);
-  tracks.push_back(boundParams134);
-
-  // track 135 :
-  BoundVector params135;
-  params135 << 0.485514432191848755, -45.5758934020996094, 1.94401109218597412,
-      0.505930542945861816, -0.000614787102676928043 * 1. / (1_MeV), 0;
-  Covariance covMat135;
-  covMat135 << 0.0123122958466410637, 0.000103715887417680144,
-      -0.000367851729220063496, -3.31341741262174798e-06,
-      -1.40577584093730895e-07 * 1. / (1_MeV), 0, 0.000103715887417680144,
-      0.0622931979596614838, 5.81297839975361217e-06, 0.000418717043270157351,
-      -7.78615764923604825e-09 * 1. / (1_MeV), 0, -0.000367851729220063496,
-      5.81297839975361217e-06, 1.11767485577729531e-05, 1.62622397510481766e-07,
-      7.02699563203032516e-09 * 1. / (1_MeV), 0, -3.31341741262174798e-06,
-      0.000418717043270157351, 1.62622397510481766e-07, 2.88416777038946748e-06,
-      6.04537737743006593e-12 * 1. / (1_MeV), 0,
-      -1.40577584093730895e-07 * 1. / (1_MeV),
-      -7.78615764923604825e-09 * 1. / (1_MeV),
-      7.02699563203032516e-09 * 1. / (1_MeV),
-      6.04537737743006593e-12 * 1. / (1_MeV),
-      1.35220848407335836e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams135 = BoundParameters(tgContext, std::move(covMat135),
-                                        params135, perigeeSurface);
-  tracks.push_back(boundParams135);
-
-  // track 136 :
-  BoundVector params136;
-  params136 << -0.670421361923217773, -23.7245407104492188,
-      -0.64520871639251709, 1.0696331262588501,
-      -0.00114500056952238083 * 1. / (1_MeV), 0;
-  Covariance covMat136;
-  covMat136 << 0.00867419224232435226, -0.000238439934654708106,
-      -0.000247132726740291432, -3.75722689616700562e-06,
-      -9.94438198214882919e-08 * 1. / (1_MeV), 0, -0.000238439934654708106,
-      0.0179926082491874695, 8.82013517111327567e-06, 0.000362395650514492373,
-      2.75455883099119192e-09 * 1. / (1_MeV), 0, -0.000247132726740291432,
-      8.82013517111327567e-06, 7.21778906154213473e-06, 1.5386779713221143e-07,
-      4.75511246715568753e-09 * 1. / (1_MeV), 0, -3.75722689616700562e-06,
-      0.000362395650514492373, 1.5386779713221143e-07, 7.68224344938062131e-06,
-      2.56252285968062862e-11 * 1. / (1_MeV), 0,
-      -9.94438198214882919e-08 * 1. / (1_MeV),
-      2.75455883099119192e-09 * 1. / (1_MeV),
-      4.75511246715568753e-09 * 1. / (1_MeV),
-      2.56252285968062862e-11 * 1. / (1_MeV),
-      1.62369812040097372e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams136 = BoundParameters(tgContext, std::move(covMat136),
-                                        params136, perigeeSurface);
-  tracks.push_back(boundParams136);
-
-  // track 137 :
-  BoundVector params137;
-  params137 << -0.115538112819194794, 1.36448657512664795, -1.94587123394012451,
-      2.86434054374694824, 0.000385540741262957454 * 1. / (1_MeV), 0;
-  Covariance covMat137;
-  covMat137 << 0.0277297049760818481, 0.00109366535881475391,
-      -0.000837399106664793598, -1.86861717914986654e-06,
-      -3.02391750465843443e-07 * 1. / (1_MeV), 0, 0.00109366535881475391,
-      0.36750379204750061, 1.37618244604514028e-05, 0.000820460451267350272,
-      -2.09467237202718329e-08 * 1. / (1_MeV), 0, -0.000837399106664793598,
-      1.37618244604514028e-05, 2.5784886020119302e-05, 1.55912763303336569e-07,
-      1.51901283557160921e-08 * 1. / (1_MeV), 0, -1.86861717914986654e-06,
-      0.000820460451267350272, 1.55912763303336569e-07, 1.85243084160902072e-06,
-      -5.89799137780591859e-12 * 1. / (1_MeV), 0,
-      -3.02391750465843443e-07 * 1. / (1_MeV),
-      -2.09467237202718329e-08 * 1. / (1_MeV),
-      1.51901283557160921e-08 * 1. / (1_MeV),
-      -5.89799137780591859e-12 * 1. / (1_MeV),
-      1.66225588849044925e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams137 = BoundParameters(tgContext, std::move(covMat137),
-                                        params137, perigeeSurface);
-  tracks.push_back(boundParams137);
-
-  // track 138 :
-  BoundVector params138;
-  params138 << -0.437855541706085205, 0.00233042589388787746,
-      -1.61236178874969482, 2.66223287582397461,
-      -0.00048968649934977293 * 1. / (1_MeV), 0;
-  Covariance covMat138;
-  covMat138 << 0.0102480929344892502, 0.000472131789165782347,
-      -0.00030005184152762706, 2.30777092355429649e-06,
-      -8.23733339483005762e-08 * 1. / (1_MeV), 0, 0.000472131789165782347,
-      0.0548162646591663361, -1.93984184037375696e-05, 0.0003337112441505619,
-      -3.15116273492404661e-09 * 1. / (1_MeV), 0, -0.00030005184152762706,
-      -1.93984184037375696e-05, 8.96569144970271736e-06,
-      -1.04404311461369532e-07, 4.16595730488154716e-09 * 1. / (1_MeV), 0,
-      2.30777092355429649e-06, 0.0003337112441505619, -1.04404311461369532e-07,
-      2.07969515031436458e-06, -4.21540260659907555e-12 * 1. / (1_MeV), 0,
-      -8.23733339483005762e-08 * 1. / (1_MeV),
-      -3.15116273492404661e-09 * 1. / (1_MeV),
-      4.16595730488154716e-09 * 1. / (1_MeV),
-      -4.21540260659907555e-12 * 1. / (1_MeV),
-      7.92930027193605724e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams138 = BoundParameters(tgContext, std::move(covMat138),
-                                        params138, perigeeSurface);
-  tracks.push_back(boundParams138);
-
-  // track 139 :
-  BoundVector params139;
-  params139 << -0.508741080760955811, -46.586151123046875,
-      -0.155602023005485535, 2.23871588706970215,
-      0.00108059775084257126 * 1. / (1_MeV), 0;
-  Covariance covMat139;
-  covMat139 << 0.0092028668150305748, 2.68137590592830111e-06,
-      -0.000267328437856131614, -4.45051587392828996e-06,
-      -1.7870806347180625e-07 * 1. / (1_MeV), 0, 2.68137590592830111e-06,
-      0.0370477475225925446, 7.6281684549949988e-06, 0.000581077286055830654,
-      -4.87564726794623446e-09 * 1. / (1_MeV), 0, -0.000267328437856131614,
-      7.6281684549949988e-06, 7.97686789155704901e-06, 2.52891502516708447e-07,
-      8.98278177902545255e-09 * 1. / (1_MeV), 0, -4.45051587392828996e-06,
-      0.000581077286055830654, 2.52891502516708447e-07, 9.77692525339080021e-06,
-      1.52214832118640255e-11 * 1. / (1_MeV), 0,
-      -1.7870806347180625e-07 * 1. / (1_MeV),
-      -4.87564726794623446e-09 * 1. / (1_MeV),
-      8.98278177902545255e-09 * 1. / (1_MeV),
-      1.52214832118640255e-11 * 1. / (1_MeV),
-      2.85946016864713215e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams139 = BoundParameters(tgContext, std::move(covMat139),
-                                        params139, perigeeSurface);
-  tracks.push_back(boundParams139);
-
-  // track 140 :
-  BoundVector params140;
-  params140 << -0.0287109911441802979, -46.0042991638183594,
-      -2.35494875907897949, 1.89670753479003906,
-      -0.00176577572710812092 * 1. / (1_MeV), 0;
-  Covariance covMat140;
-  covMat140 << 0.0144642842933535576, 0.000202304881255863523,
-      -0.0004315195269340391, 5.3491723128578935e-06,
-      -2.30140530552361737e-07 * 1. / (1_MeV), 0, 0.000202304881255863523,
-      0.0459608733654022217, -1.13086865182124149e-05, 0.000878128453669932505,
-      -5.83245686148190731e-10 * 1. / (1_MeV), 0, -0.0004315195269340391,
-      -1.13086865182124149e-05, 1.30631951833493076e-05,
-      -2.77542364129523601e-07, 1.1015992963213548e-08 * 1. / (1_MeV), 0,
-      5.3491723128578935e-06, 0.000878128453669932505, -2.77542364129523601e-07,
-      1.93870200746459886e-05, 1.69476858439270149e-11 * 1. / (1_MeV), 0,
-      -2.30140530552361737e-07 * 1. / (1_MeV),
-      -5.83245686148190731e-10 * 1. / (1_MeV),
-      1.1015992963213548e-08 * 1. / (1_MeV),
-      1.69476858439270149e-11 * 1. / (1_MeV),
-      3.93277660437618692e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams140 = BoundParameters(tgContext, std::move(covMat140),
-                                        params140, perigeeSurface);
-  tracks.push_back(boundParams140);
-
-  // track 141 :
-  BoundVector params141;
-  params141 << -0.324331343173980713, -23.5119915008544922,
-      -1.97980344295501709, 1.80859279632568359,
-      0.00151402072515338659 * 1. / (1_MeV), 0;
-  Covariance covMat141;
-  covMat141 << 0.0087733948603272438, -9.15304093536118931e-05,
-      -0.000263482306437119978, -4.30371014091713246e-06,
-      -1.27371578273573737e-07 * 1. / (1_MeV), 0, -9.15304093536118931e-05,
-      0.0360054671764373779, 5.80982901356528686e-06, 0.00079117892231876717,
-      -1.84955003459008438e-09 * 1. / (1_MeV), 0, -0.000263482306437119978,
-      5.80982901356528686e-06, 8.00929956312756985e-06, 2.04894742385078515e-07,
-      6.42585697371379892e-09 * 1. / (1_MeV), 0, -4.30371014091713246e-06,
-      0.00079117892231876717, 2.04894742385078515e-07, 1.9523367882356979e-05,
-      -2.99674425730772401e-11 * 1. / (1_MeV), 0,
-      -1.27371578273573737e-07 * 1. / (1_MeV),
-      -1.84955003459008438e-09 * 1. / (1_MeV),
-      6.42585697371379892e-09 * 1. / (1_MeV),
-      -2.99674425730772401e-11 * 1. / (1_MeV),
-      2.4992743985485788e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams141 = BoundParameters(tgContext, std::move(covMat141),
-                                        params141, perigeeSurface);
-  tracks.push_back(boundParams141);
-
-  // track 142 :
-  BoundVector params142;
-  params142 << 0.833708107471466064, -26.5761394500732422, 2.42632651329040527,
-      0.695800244808197021, -0.00123036885634064674 * 1. / (1_MeV), 0;
-  Covariance covMat142;
-  covMat142 << 0.0211165659129619598, 0.000359701005864806447,
-      -0.000640851902958058375, -9.11472752482565601e-06,
-      -3.61128702466976842e-07 * 1. / (1_MeV), 0, 0.000359701005864806447,
-      0.0739856362342834473, 8.7222025530136249e-06, 0.000880846867037469831,
-      -2.53787934713242592e-08 * 1. / (1_MeV), 0, -0.000640851902958058375,
-      8.7222025530136249e-06, 1.96944329218240455e-05, 5.19825459711244045e-07,
-      1.80691074173165322e-08 * 1. / (1_MeV), 0, -9.11472752482565601e-06,
-      0.000880846867037469831, 5.19825459711244045e-07, 1.07980968095944263e-05,
-      -8.35165165596293098e-12 * 1. / (1_MeV), 0,
-      -3.61128702466976842e-07 * 1. / (1_MeV),
-      -2.53787934713242592e-08 * 1. / (1_MeV),
-      1.80691074173165322e-08 * 1. / (1_MeV),
-      -8.35165165596293098e-12 * 1. / (1_MeV),
-      4.57582055579663916e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams142 = BoundParameters(tgContext, std::move(covMat142),
-                                        params142, perigeeSurface);
-  tracks.push_back(boundParams142);
-
-  // track 143 :
-  BoundVector params143;
-  params143 << 0.431655138731002808, -29.9960479736328125, 3.04886436462402344,
-      0.219654783606529236, -0.000162235795869491994 * 1. / (1_MeV), 0;
-  Covariance covMat143;
-  covMat143 << 0.0106745027005672455, -8.84194609194169812e-05,
-      -0.000323117334005453873, -1.40461092014443657e-06,
-      -7.26826880107808198e-08 * 1. / (1_MeV), 0, -8.84194609194169812e-05,
-      0.237027347087860107, 1.1001073976894211e-05, 0.000332182033533801643,
-      -6.39605428797278291e-09 * 1. / (1_MeV), 0, -0.000323117334005453873,
-      1.1001073976894211e-05, 9.92172226688126102e-06, 5.57033782439724886e-08,
-      3.63950477953687594e-09 * 1. / (1_MeV), 0, -1.40461092014443657e-06,
-      0.000332182033533801643, 5.57033782439724886e-08, 4.7147932491498068e-07,
-      3.22132744873936636e-12 * 1. / (1_MeV), 0,
-      -7.26826880107808198e-08 * 1. / (1_MeV),
-      -6.39605428797278291e-09 * 1. / (1_MeV),
-      3.63950477953687594e-09 * 1. / (1_MeV),
-      3.22132744873936636e-12 * 1. / (1_MeV),
-      3.18471672644538017e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams143 = BoundParameters(tgContext, std::move(covMat143),
-                                        params143, perigeeSurface);
-  tracks.push_back(boundParams143);
-
-  // track 144 :
-  BoundVector params144;
-  params144 << 0.453293651342391968, -3.70734310150146484, 1.55869936943054199,
-      0.256132364273071289, 0.000176838657353073359 * 1. / (1_MeV), 0;
-  Covariance covMat144;
-  covMat144 << 0.00827712379395961761, 2.30498411629412509e-05,
-      -0.000244603197258337732, -1.09126589030407755e-07,
-      -1.23444322806264544e-07 * 1. / (1_MeV), 0, 2.30498411629412509e-05,
-      0.129736632108688354, -1.08938113172420931e-05, 0.00024017541022616651,
-      -4.9073936291752883e-09 * 1. / (1_MeV), 0, -0.000244603197258337732,
-      -1.08938113172420931e-05, 7.46843306842492893e-06,
-      -1.2793133595916256e-08, 6.20080490265058224e-09 * 1. / (1_MeV), 0,
-      -1.09126589030407755e-07, 0.00024017541022616651, -1.2793133595916256e-08,
-      4.53893193252952187e-07, 4.19473349424168581e-12 * 1. / (1_MeV), 0,
-      -1.23444322806264544e-07 * 1. / (1_MeV),
-      -4.9073936291752883e-09 * 1. / (1_MeV),
-      6.20080490265058224e-09 * 1. / (1_MeV),
-      4.19473349424168581e-12 * 1. / (1_MeV),
-      6.42161740449509466e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams144 = BoundParameters(tgContext, std::move(covMat144),
-                                        params144, perigeeSurface);
-  tracks.push_back(boundParams144);
-
-  // track 145 :
-  BoundVector params145;
-  params145 << -0.061490967869758606, -26.7054595947265625,
-      -2.24733877182006836, 0.956555545330047607,
-      0.00144492473918944597 * 1. / (1_MeV), 0;
-  Covariance covMat145;
-  covMat145 << 0.0162842385470867157, -0.000263099496401078266,
-      -0.00047392584055408227, 9.13166470635725779e-07,
-      -2.48568574213736665e-07 * 1. / (1_MeV), 0, -0.000263099496401078266,
-      0.0405553430318832397, -4.6234755882358841e-06, 0.000706847528783378985,
-      3.8766189110419867e-09 * 1. / (1_MeV), 0, -0.00047392584055408227,
-      -4.6234755882358841e-06, 1.40937036121613346e-05, -2.3073629352790705e-07,
-      1.21477695022017926e-08 * 1. / (1_MeV), 0, 9.13166470635725779e-07,
-      0.000706847528783378985, -2.3073629352790705e-07, 1.28429355754633434e-05,
-      8.96597163070042405e-12 * 1. / (1_MeV), 0,
-      -2.48568574213736665e-07 * 1. / (1_MeV),
-      3.8766189110419867e-09 * 1. / (1_MeV),
-      1.21477695022017926e-08 * 1. / (1_MeV),
-      8.96597163070042405e-12 * 1. / (1_MeV),
-      3.91443821801118474e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams145 = BoundParameters(tgContext, std::move(covMat145),
-                                        params145, perigeeSurface);
-  tracks.push_back(boundParams145);
-
-  // track 146 :
-  BoundVector params146;
-  params146 << 0.763872087001800537, -38.5857467651367188, 2.27715539932250977,
-      1.21252071857452393, -0.00143153721000999212 * 1. / (1_MeV), 0;
-  Covariance covMat146;
-  covMat146 << 0.00959093961864709854, -5.95333196772062091e-05,
-      -0.000286590504535243261, -3.89848736920619265e-06,
-      -1.27862245568167995e-07 * 1. / (1_MeV), 0, -5.95333196772062091e-05,
-      0.0381334424018859863, 5.54447234346008645e-06, 0.000701959475459679595,
-      -3.38021765880820443e-09 * 1. / (1_MeV), 0, -0.000286590504535243261,
-      5.54447234346008645e-06, 8.66082245920551941e-06, 1.98754844823631596e-07,
-      6.11745668929922213e-09 * 1. / (1_MeV), 0, -3.89848736920619265e-06,
-      0.000701959475459679595, 1.98754844823631596e-07, 1.4981656931922771e-05,
-      -3.86232878211289549e-11 * 1. / (1_MeV), 0,
-      -1.27862245568167995e-07 * 1. / (1_MeV),
-      -3.38021765880820443e-09 * 1. / (1_MeV),
-      6.11745668929922213e-09 * 1. / (1_MeV),
-      -3.86232878211289549e-11 * 1. / (1_MeV),
-      2.21742652017908881e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams146 = BoundParameters(tgContext, std::move(covMat146),
-                                        params146, perigeeSurface);
-  tracks.push_back(boundParams146);
-
-  // track 147 :
-  BoundVector params147;
-  params147 << 0.103607669472694397, 2.84468746185302734, -2.64531970024108887,
-      0.422175496816635132, 0.000728976272512227297 * 1. / (1_MeV), 0;
-  Covariance covMat147;
-  covMat147 << 0.0291666984558105469, -0.00028174513634597289,
-      -0.000896671963135054384, 3.65521430545857715e-06,
-      -9.28791760013186476e-07 * 1. / (1_MeV), 0, -0.00028174513634597289,
-      0.183342501521110535, -2.96247041841360439e-05, 0.000901552718064765435,
-      2.53499877322050493e-08 * 1. / (1_MeV), 0, -0.000896671963135054384,
-      -2.96247041841360439e-05, 2.81649827229557559e-05,
-      -2.96050592993603566e-07, 4.56613110250769837e-08 * 1. / (1_MeV), 0,
-      3.65521430545857715e-06, 0.000901552718064765435,
-      -2.96050592993603566e-07, 4.49623166787205264e-06,
-      2.77175608301356693e-11 * 1. / (1_MeV), 0,
-      -9.28791760013186476e-07 * 1. / (1_MeV),
-      2.53499877322050493e-08 * 1. / (1_MeV),
-      4.56613110250769837e-08 * 1. / (1_MeV),
-      2.77175608301356693e-11 * 1. / (1_MeV),
-      7.42934380681958828e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams147 = BoundParameters(tgContext, std::move(covMat147),
-                                        params147, perigeeSurface);
-  tracks.push_back(boundParams147);
-
-  // track 148 :
-  BoundVector params148;
-  params148 << 0.0596604086458683014, -22.0404262542724609,
-      -2.35440278053283691, 2.71709132194519043,
-      0.000393175549106672406 * 1. / (1_MeV), 0;
-  Covariance covMat148;
-  covMat148 << 0.00926339346915483475, 0.000528247059013484989,
-      -0.000273002338954134941, 1.18533332081702857e-06,
-      -1.0181309061738991e-07 * 1. / (1_MeV), 0, 0.000528247059013484989,
-      0.0657876729965209961, -4.89306573522013593e-06, 0.000319671212486525062,
-      -1.99118715573116921e-09 * 1. / (1_MeV), 0, -0.000273002338954134941,
-      -4.89306573522013593e-06, 8.228425940615125e-06, 1.0922913420953112e-08,
-      5.11517095198890007e-09 * 1. / (1_MeV), 0, 1.18533332081702857e-06,
-      0.000319671212486525062, 1.0922913420953112e-08, 1.58801094585214742e-06,
-      -3.45854711927653862e-12 * 1. / (1_MeV), 0,
-      -1.0181309061738991e-07 * 1. / (1_MeV),
-      -1.99118715573116921e-09 * 1. / (1_MeV),
-      5.11517095198890007e-09 * 1. / (1_MeV),
-      -3.45854711927653862e-12 * 1. / (1_MeV),
-      8.50769107940685387e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams148 = BoundParameters(tgContext, std::move(covMat148),
-                                        params148, perigeeSurface);
-  tracks.push_back(boundParams148);
-
-  // track 149 :
-  BoundVector params149;
-  params149 << -0.100074939429759979, -45.496917724609375, -2.26213359832763672,
-      2.41107773780822754, -0.00105385575443506241 * 1. / (1_MeV), 0;
-  Covariance covMat149;
-  covMat149 << 0.0151377040892839432, 0.000602634067371094167,
-      -0.000444356777866817588, 7.9758927859093853e-06,
-      -2.44218026422960964e-07 * 1. / (1_MeV), 0, 0.000602634067371094167,
-      0.0541137345135211945, -2.54764657299984998e-05, 0.000650772244522164326,
-      -2.86525491239922761e-10 * 1. / (1_MeV), 0, -0.000444356777866817588,
-      -2.54764657299984998e-05, 1.33216317408368923e-05,
-      -3.50343885338622606e-07, 1.17735415136484234e-08 * 1. / (1_MeV), 0,
-      7.9758927859093853e-06, 0.000650772244522164326, -3.50343885338622606e-07,
-      8.18384978629183024e-06, -1.33592110665984887e-11 * 1. / (1_MeV), 0,
-      -2.44218026422960964e-07 * 1. / (1_MeV),
-      -2.86525491239922761e-10 * 1. / (1_MeV),
-      1.17735415136484234e-08 * 1. / (1_MeV),
-      -1.33592110665984887e-11 * 1. / (1_MeV),
-      3.07479458561132901e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams149 = BoundParameters(tgContext, std::move(covMat149),
-                                        params149, perigeeSurface);
-  tracks.push_back(boundParams149);
-
-  // track 150 :
-  BoundVector params150;
-  params150 << -0.475683718919754028, -7.06369543075561523, 0.21792110800743103,
-      2.59036850929260254, 0.000621944374870508909 * 1. / (1_MeV), 0;
-  Covariance covMat150;
-  covMat150 << 0.0113344583660364151, 0.000305280624649602989,
-      -0.000332487044324006938, -1.63824948116055707e-06,
-      -9.71480251237366926e-08 * 1. / (1_MeV), 0, 0.000305280624649602989,
-      0.0582733377814292908, 7.6302914477251913e-07, 0.000438738226848568399,
-      -5.91422448133011881e-09 * 1. / (1_MeV), 0, -0.000332487044324006938,
-      7.6302914477251913e-07, 9.93357571132946759e-06, 1.21010113810928627e-07,
-      4.84814135648083373e-09 * 1. / (1_MeV), 0, -1.63824948116055707e-06,
-      0.000438738226848568399, 1.21010113810928627e-07, 3.42198154612560757e-06,
-      -3.26867840396934173e-12 * 1. / (1_MeV), 0,
-      -9.71480251237366926e-08 * 1. / (1_MeV),
-      -5.91422448133011881e-09 * 1. / (1_MeV),
-      4.84814135648083373e-09 * 1. / (1_MeV),
-      -3.26867840396934173e-12 * 1. / (1_MeV),
-      1.01995072110394602e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams150 = BoundParameters(tgContext, std::move(covMat150),
-                                        params150, perigeeSurface);
-  tracks.push_back(boundParams150);
-
-  // track 151 :
-  BoundVector params151;
-  params151 << 0.98848491907119751, -23.9967403411865234, 2.97214531898498535,
-      2.47884941101074219, -0.000928516499698162079 * 1. / (1_MeV), 0;
-  Covariance covMat151;
-  covMat151 << 0.0139401322230696678, -0.000109650695280206099,
-      -0.000410603766136218755, 6.34942242156624963e-06,
-      -1.91480875943633338e-07 * 1. / (1_MeV), 0, -0.000109650695280206099,
-      0.051623273640871048, -4.96380863496017579e-06, 0.000554779761149708835,
-      1.06928217588898346e-08 * 1. / (1_MeV), 0, -0.000410603766136218755,
-      -4.96380863496017579e-06, 1.23366617117426358e-05,
-      -2.8907121314848788e-07, 9.51416150401782656e-09 * 1. / (1_MeV), 0,
-      6.34942242156624963e-06, 0.000554779761149708835, -2.8907121314848788e-07,
-      6.12514031672617421e-06, -4.0379007049062301e-11 * 1. / (1_MeV), 0,
-      -1.91480875943633338e-07 * 1. / (1_MeV),
-      1.06928217588898346e-08 * 1. / (1_MeV),
-      9.51416150401782656e-09 * 1. / (1_MeV),
-      -4.0379007049062301e-11 * 1. / (1_MeV),
-      2.35979236151706573e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams151 = BoundParameters(tgContext, std::move(covMat151),
-                                        params151, perigeeSurface);
-  tracks.push_back(boundParams151);
-
-  // track 152 :
-  BoundVector params152;
-  params152 << 0.55860060453414917, -45.7249908447265625, 1.83190596103668213,
-      0.48145294189453125, 0.000721027201507240534 * 1. / (1_MeV), 0;
-  Covariance covMat152;
-  covMat152 << 0.0186744499951601028, 0.000493292771603547758,
-      -0.000565849238931288596, 3.05813720670537946e-06,
-      -2.66483594264544379e-07 * 1. / (1_MeV), 0, 0.000493292771603547758,
-      0.101673096418380737, -3.54761000333760567e-05, 0.000629179521496957923,
-      -6.15039861676908778e-09 * 1. / (1_MeV), 0, -0.000565849238931288596,
-      -3.54761000333760567e-05, 1.73863791133044288e-05,
-      -2.15955155252030693e-07, 1.3347851460192395e-08 * 1. / (1_MeV), 0,
-      3.05813720670537946e-06, 0.000629179521496957923,
-      -2.15955155252030693e-07, 3.96863515561562963e-06,
-      9.51450535762684209e-12 * 1. / (1_MeV), 0,
-      -2.66483594264544379e-07 * 1. / (1_MeV),
-      -6.15039861676908778e-09 * 1. / (1_MeV),
-      1.3347851460192395e-08 * 1. / (1_MeV),
-      9.51450535762684209e-12 * 1. / (1_MeV),
-      2.52067755557305873e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams152 = BoundParameters(tgContext, std::move(covMat152),
-                                        params152, perigeeSurface);
-  tracks.push_back(boundParams152);
-
-  // track 153 :
-  BoundVector params153;
-  params153 << -0.675277292728424072, -17.5367851257324219,
-      -1.09335136413574219, 1.29379391670227051,
-      0.00186408217996358871 * 1. / (1_MeV), 0;
-  Covariance covMat153;
-  covMat153 << 0.0150135625153779984, -5.98760396689701493e-06,
-      -0.000439278218315922013, 4.52858267312502235e-06,
-      -2.12443419817206803e-07 * 1. / (1_MeV), 0, -5.98760396689701493e-06,
-      0.0350622236728668213, -4.82582268169156601e-06, 0.000836372815788150622,
-      2.09070433346646154e-09 * 1. / (1_MeV), 0, -0.000439278218315922013,
-      -4.82582268169156601e-06, 1.31102533487137407e-05,
-      -2.59231851245594785e-07, 1.04858623295484113e-08 * 1. / (1_MeV), 0,
-      4.52858267312502235e-06, 0.000836372815788150622,
-      -2.59231851245594785e-07, 2.17701854126062244e-05,
-      -2.62710156705971042e-11 * 1. / (1_MeV), 0,
-      -2.12443419817206803e-07 * 1. / (1_MeV),
-      2.09070433346646154e-09 * 1. / (1_MeV),
-      1.04858623295484113e-08 * 1. / (1_MeV),
-      -2.62710156705971042e-11 * 1. / (1_MeV),
-      4.00474514661297576e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams153 = BoundParameters(tgContext, std::move(covMat153),
-                                        params153, perigeeSurface);
-  tracks.push_back(boundParams153);
-
-  // track 154 :
-  BoundVector params154;
-  params154 << 0.0753030404448509216, -29.1891746520996094,
-      0.738724231719970703, 2.31334257125854492,
-      0.00144911545794457197 * 1. / (1_MeV), 0;
-  Covariance covMat154;
-  covMat154 << 0.0217308551073074341, 3.24991188634454485e-05,
-      -0.000647178201020877667, -5.51537304078277638e-06,
-      -4.24940247733336709e-07 * 1. / (1_MeV), 0, 3.24991188634454485e-05,
-      0.0502317957580089569, 1.42908758929754525e-05, 0.000768853527443186789,
-      -1.11154383882071719e-08 * 1. / (1_MeV), 0, -0.000647178201020877667,
-      1.42908758929754525e-05, 1.96035034605301917e-05, 3.94051157866699596e-07,
-      2.12308161941993043e-08 * 1. / (1_MeV), 0, -5.51537304078277638e-06,
-      0.000768853527443186789, 3.94051157866699596e-07, 1.20725653687259182e-05,
-      -9.05413371576357781e-11 * 1. / (1_MeV), 0,
-      -4.24940247733336709e-07 * 1. / (1_MeV),
-      -1.11154383882071719e-08 * 1. / (1_MeV),
-      2.12308161941993043e-08 * 1. / (1_MeV),
-      -9.05413371576357781e-11 * 1. / (1_MeV),
-      6.28650798084606777e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams154 = BoundParameters(tgContext, std::move(covMat154),
-                                        params154, perigeeSurface);
-  tracks.push_back(boundParams154);
-
-  // track 155 :
-  BoundVector params155;
-  params155 << 0.261458933353424072, -2.39843320846557617, 1.05141377449035645,
-      0.232830539345741272, 0.000250596785917878151 * 1. / (1_MeV), 0;
-  Covariance covMat155;
-  covMat155 << 0.0212338902056217194, 0.000353406616331773335,
-      -0.00064520728113282098, 9.74350339390978654e-07,
-      -1.69741491338621847e-07 * 1. / (1_MeV), 0, 0.000353406616331773335,
-      0.41215890645980835, -4.22061888380635897e-05, 0.000653800381523604113,
-      -1.34245812546777072e-08 * 1. / (1_MeV), 0, -0.00064520728113282098,
-      -4.22061888380635897e-05, 1.98819634533720091e-05,
-      -7.83604692222462539e-08, 8.68476512257556142e-09 * 1. / (1_MeV), 0,
-      9.74350339390978654e-07, 0.000653800381523604113,
-      -7.83604692222462539e-08, 1.04632010788918706e-06,
-      -1.19444645168272657e-11 * 1. / (1_MeV), 0,
-      -1.69741491338621847e-07 * 1. / (1_MeV),
-      -1.34245812546777072e-08 * 1. / (1_MeV),
-      8.68476512257556142e-09 * 1. / (1_MeV),
-      -1.19444645168272657e-11 * 1. / (1_MeV),
-      8.34616611933292063e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams155 = BoundParameters(tgContext, std::move(covMat155),
-                                        params155, perigeeSurface);
-  tracks.push_back(boundParams155);
-
-  // track 156 :
-  BoundVector params156;
-  params156 << -0.105008736252784729, -4.60046195983886719,
-      -2.15087199211120605, 2.53013730049133301,
-      0.000869307026732712984 * 1. / (1_MeV), 0;
-  Covariance covMat156;
-  covMat156 << 0.0136917401105165482, 0.000115121263015629808,
-      -0.000413429347423517678, -2.62571780336553623e-06,
-      -2.07199662141073358e-07 * 1. / (1_MeV), 0, 0.000115121263015629808,
-      0.0558724924921989441, 8.99969196056981436e-06, 0.000514698386282201061,
-      -6.20886185541909694e-09 * 1. / (1_MeV), 0, -0.000413429347423517678,
-      8.99969196056981436e-06, 1.26550057757413015e-05, 1.92253160785162133e-07,
-      1.01717537862091531e-08 * 1. / (1_MeV), 0, -2.62571780336553623e-06,
-      0.000514698386282201061, 1.92253160785162133e-07, 4.87851730213151313e-06,
-      -7.31342694223202373e-12 * 1. / (1_MeV), 0,
-      -2.07199662141073358e-07 * 1. / (1_MeV),
-      -6.20886185541909694e-09 * 1. / (1_MeV),
-      1.01717537862091531e-08 * 1. / (1_MeV),
-      -7.31342694223202373e-12 * 1. / (1_MeV),
-      2.3365928636387423e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams156 = BoundParameters(tgContext, std::move(covMat156),
-                                        params156, perigeeSurface);
-  tracks.push_back(boundParams156);
-
-  // track 157 :
-  BoundVector params157;
-  params157 << 0.449398219585418701, -27.5547370910644531, -2.98990011215209961,
-      0.584414243698120117, -0.000796562700998038054 * 1. / (1_MeV), 0;
-  Covariance covMat157;
-  covMat157 << 0.0147328255698084831, 0.000102396442328031638,
-      -0.000442161702936779853, -4.51768449626899611e-06,
-      -1.75125426997186622e-07 * 1. / (1_MeV), 0, 0.000102396442328031638,
-      0.0676895305514335632, 9.61359721658456181e-06, 0.000602606334717200459,
-      -8.66739114473183283e-09 * 1. / (1_MeV), 0, -0.000442161702936779853,
-      9.61359721658456181e-06, 1.34547990455757827e-05, 2.52859101937164529e-07,
-      8.84959810661187708e-09 * 1. / (1_MeV), 0, -4.51768449626899611e-06,
-      0.000602606334717200459, 2.52859101937164529e-07, 5.48358138985349797e-06,
-      2.42683894231848255e-12 * 1. / (1_MeV), 0,
-      -1.75125426997186622e-07 * 1. / (1_MeV),
-      -8.66739114473183283e-09 * 1. / (1_MeV),
-      8.84959810661187708e-09 * 1. / (1_MeV),
-      2.42683894231848255e-12 * 1. / (1_MeV),
-      1.96425084530993388e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams157 = BoundParameters(tgContext, std::move(covMat157),
-                                        params157, perigeeSurface);
-  tracks.push_back(boundParams157);
-
-  // track 158 :
-  BoundVector params158;
-  params158 << -0.47096705436706543, -23.1657295227050781, -1.74237358570098877,
-      2.32017350196838379, 0.000883807893842458725 * 1. / (1_MeV), 0;
-  Covariance covMat158;
-  covMat158 << 0.00741111813113093376, 3.92975220400803806e-05,
-      -0.000222045332813570817, -2.88822099446990028e-06,
-      -2.12788927612163033e-07 * 1. / (1_MeV), 0, 3.92975220400803806e-05,
-      0.0265452265739440918, 3.83772358007061724e-06, 0.000388211046384209855,
-      -5.72504289628637471e-09 * 1. / (1_MeV), 0, -0.000222045332813570817,
-      3.83772358007061724e-06, 6.7778209995594807e-06, 1.57738925506559928e-07,
-      1.01751060319750463e-08 * 1. / (1_MeV), 0, -2.88822099446990028e-06,
-      0.000388211046384209855, 1.57738925506559928e-07, 5.97009920966229402e-06,
-      2.72996826709048491e-11 * 1. / (1_MeV), 0,
-      -2.12788927612163033e-07 * 1. / (1_MeV),
-      -5.72504289628637471e-09 * 1. / (1_MeV),
-      1.01751060319750463e-08 * 1. / (1_MeV),
-      2.72996826709048491e-11 * 1. / (1_MeV),
-      2.86495771550931977e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams158 = BoundParameters(tgContext, std::move(covMat158),
-                                        params158, perigeeSurface);
-  tracks.push_back(boundParams158);
-
-  // track 159 :
-  BoundVector params159;
-  params159 << -0.772880673408508301, -0.194379150867462158,
-      -0.128169164061546326, 0.661742448806762695,
-      0.00110341468825936317 * 1. / (1_MeV), 0;
-  Covariance covMat159;
-  covMat159 << 0.020627237856388092, -0.000651662753287368906,
-      -0.00061276879384480475, 5.7418960693298186e-06,
-      -2.67843352789052197e-07 * 1. / (1_MeV), 0, -0.000651662753287368906,
-      0.0692515745759010315, -2.26766543920346976e-07, 0.000746164457055286962,
-      1.87684603862415885e-08 * 1. / (1_MeV), 0, -0.00061276879384480475,
-      -2.26766543920346976e-07, 1.8517455828259699e-05,
-      -3.78605360981018502e-07, 1.36753554668844785e-08 * 1. / (1_MeV), 0,
-      5.7418960693298186e-06, 0.000746164457055286962, -3.78605360981018502e-07,
-      8.24847211333690211e-06, -3.39037168618683865e-12 * 1. / (1_MeV), 0,
-      -2.67843352789052197e-07 * 1. / (1_MeV),
-      1.87684603862415885e-08 * 1. / (1_MeV),
-      1.36753554668844785e-08 * 1. / (1_MeV),
-      -3.39037168618683865e-12 * 1. / (1_MeV),
-      3.48178236242446815e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams159 = BoundParameters(tgContext, std::move(covMat159),
-                                        params159, perigeeSurface);
-  tracks.push_back(boundParams159);
-
-  // track 160 :
-  BoundVector params160;
-  params160 << -0.347648710012435913, -45.7085342407226562,
-      0.140009865164756775, 0.641895532608032227,
-      0.00117580872029066086 * 1. / (1_MeV), 0;
-  Covariance covMat160;
-  covMat160 << 0.0375818982720375061, -0.000303276309189704169,
-      -0.00110587969340759386, 1.29061987071589049e-05,
-      -4.12294858313896687e-07 * 1. / (1_MeV), 0, -0.000303276309189704169,
-      0.125086501240730286, -2.57186227015147112e-05, 0.00124988554053600013,
-      1.69162268005727335e-08 * 1. / (1_MeV), 0, -0.00110587969340759386,
-      -2.57186227015147112e-05, 3.28488567902240902e-05,
-      -7.27553385059438972e-07, 1.83230555024144881e-08 * 1. / (1_MeV), 0,
-      1.29061987071589049e-05, 0.00124988554053600013, -7.27553385059438972e-07,
-      1.28745887195691466e-05, -1.87734052287320618e-11 * 1. / (1_MeV), 0,
-      -4.12294858313896687e-07 * 1. / (1_MeV),
-      1.69162268005727335e-08 * 1. / (1_MeV),
-      1.83230555024144881e-08 * 1. / (1_MeV),
-      -1.87734052287320618e-11 * 1. / (1_MeV),
-      3.79933057237380467e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams160 = BoundParameters(tgContext, std::move(covMat160),
-                                        params160, perigeeSurface);
-  tracks.push_back(boundParams160);
-
-  // track 161 :
-  BoundVector params161;
-  params161 << -0.2922801673412323, -0.921251356601715088,
-      0.0930548682808876038, 1.51108169555664062,
-      0.00123066513333469629 * 1. / (1_MeV), 0;
-  Covariance covMat161;
-  covMat161 << 0.00921367853879928589, 4.5284958991639089e-06,
-      -0.000270542651850571756, 4.18970364145019236e-07,
-      -1.24935012983859226e-07 * 1. / (1_MeV), 0, 4.5284958991639089e-06,
-      0.0202056393027305603, -5.18878459713167351e-07, 0.000441547249561386889,
-      -1.60400630155777733e-09 * 1. / (1_MeV), 0, -0.000270542651850571756,
-      -5.18878459713167351e-07, 8.02594786364352331e-06,
-      -2.14580558624309511e-08, 5.3323840067832493e-09 * 1. / (1_MeV), 0,
-      4.18970364145019236e-07, 0.000441547249561386889,
-      -2.14580558624309511e-08, 1.14672693598549813e-05,
-      -2.71866026406819207e-11 * 1. / (1_MeV), 0,
-      -1.24935012983859226e-07 * 1. / (1_MeV),
-      -1.60400630155777733e-09 * 1. / (1_MeV),
-      5.3323840067832493e-09 * 1. / (1_MeV),
-      -2.71866026406819207e-11 * 1. / (1_MeV),
-      1.68986658000136458e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams161 = BoundParameters(tgContext, std::move(covMat161),
-                                        params161, perigeeSurface);
-  tracks.push_back(boundParams161);
-
-  // track 162 :
-  BoundVector params162;
-  params162 << 0.4121856689453125, -23.2384719848632812, 3.07601475715637207,
-      2.50852036476135254, -0.00103297142777591944 * 1. / (1_MeV), 0;
-  Covariance covMat162;
-  covMat162 << 0.0184979140758514404, 0.000137593374859579015,
-      -0.000556487007709731548, 8.2413879715742071e-06,
-      -2.98670195072288683e-07 * 1. / (1_MeV), 0, 0.000137593374859579015,
-      0.0723279938101768494, -1.91025340155191667e-05, 0.00072751066352708994,
-      1.28089131983040278e-08 * 1. / (1_MeV), 0, -0.000556487007709731548,
-      -1.91025340155191667e-05, 1.6993884855764918e-05,
-      -4.09609317210932893e-07, 1.47520025775196756e-08 * 1. / (1_MeV), 0,
-      8.2413879715742071e-06, 0.00072751066352708994, -4.09609317210932893e-07,
-      7.47372678233659826e-06, -6.9067412337676577e-12 * 1. / (1_MeV), 0,
-      -2.98670195072288683e-07 * 1. / (1_MeV),
-      1.28089131983040278e-08 * 1. / (1_MeV),
-      1.47520025775196756e-08 * 1. / (1_MeV),
-      -6.9067412337676577e-12 * 1. / (1_MeV),
-      3.46785045124420321e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams162 = BoundParameters(tgContext, std::move(covMat162),
-                                        params162, perigeeSurface);
-  tracks.push_back(boundParams162);
-
-  // track 163 :
-  BoundVector params163;
-  params163 << -0.483950525522232056, -26.1256237030029297,
-      0.0553041622042655945, 0.949812471866607666,
-      -0.00125660584308207035 * 1. / (1_MeV), 0;
-  Covariance covMat163;
-  covMat163 << 0.0255814455449581146, -0.000497574279907850563,
-      -0.000750143259475374879, -9.48529005801767566e-06,
-      -1.80692002549941218e-07 * 1. / (1_MeV), 0, -0.000497574279907850563,
-      0.0536283813416957855, 2.52424588427675564e-05, 0.000992537455962576656,
-      -6.36132286347180259e-10 * 1. / (1_MeV), 0, -0.000750143259475374879,
-      2.52424588427675564e-05, 2.21376776607939973e-05, 4.85059345667416894e-07,
-      8.91432167580867079e-09 * 1. / (1_MeV), 0, -9.48529005801767566e-06,
-      0.000992537455962576656, 4.85059345667416894e-07, 1.88748454093001783e-05,
-      -4.62705821113891289e-11 * 1. / (1_MeV), 0,
-      -1.80692002549941218e-07 * 1. / (1_MeV),
-      -6.36132286347180259e-10 * 1. / (1_MeV),
-      8.91432167580867079e-09 * 1. / (1_MeV),
-      -4.62705821113891289e-11 * 1. / (1_MeV),
-      2.9073463081452644e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams163 = BoundParameters(tgContext, std::move(covMat163),
-                                        params163, perigeeSurface);
-  tracks.push_back(boundParams163);
-
-  // track 164 :
-  BoundVector params164;
-  params164 << 0.446096986532211304, -45.5545768737792969, 1.52503681182861328,
-      0.665921330451965332, -3.70692359865643084e-05 * 1. / (1_MeV), 0;
-  Covariance covMat164;
-  covMat164 << 0.000154954337631352246, -2.7711175651334654e-06,
-      -2.81480069777612953e-06, 5.24993610348611895e-09,
-      -1.85158695435768846e-09 * 1. / (1_MeV), 0, -2.7711175651334654e-06,
-      0.00208598608151078224, -5.19392850454352899e-09, 9.56207419135546286e-06,
-      -8.58618417511969728e-10 * 1. / (1_MeV), 0, -2.81480069777612953e-06,
-      -5.19392850454352899e-09, 5.87558872666704701e-08,
-      -2.14259485564807477e-10, 4.70134905851354349e-11 * 1. / (1_MeV), 0,
-      5.24993610348611895e-09, 9.56207419135546286e-06,
-      -2.14259485564807477e-10, 6.29812220154235547e-08,
-      -5.34156221200548834e-12 * 1. / (1_MeV), 0,
-      -1.85158695435768846e-09 * 1. / (1_MeV),
-      -8.58618417511969728e-10 * 1. / (1_MeV),
-      4.70134905851354349e-11 * 1. / (1_MeV),
-      -5.34156221200548834e-12 * 1. / (1_MeV),
-      6.18826441912273539e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams164 = BoundParameters(tgContext, std::move(covMat164),
-                                        params164, perigeeSurface);
-  tracks.push_back(boundParams164);
-
-  // track 165 :
-  BoundVector params165;
-  params165 << -0.193144664168357849, -39.8290443420410156,
-      0.404710888862609863, 2.53834176063537598,
-      0.000577296596020460129 * 1. / (1_MeV), 0;
-  Covariance covMat165;
-  covMat165 << 0.00723315775394439697, 0.000260372419450370792,
-      -0.000213528892024644653, 8.64182027576564045e-08,
-      -1.62459623796150906e-07 * 1. / (1_MeV), 0, 0.000260372419450370792,
-      0.0307485610246658325, -1.36157327480265165e-06, 0.000270086486223694014,
-      -7.61741612270504069e-09 * 1. / (1_MeV), 0, -0.000213528892024644653,
-      -1.36157327480265165e-06, 6.46902481094002724e-06,
-      4.73498669259185492e-08, 7.96054784235342818e-09 * 1. / (1_MeV), 0,
-      8.64182027576564045e-08, 0.000270086486223694014, 4.73498669259185492e-08,
-      2.46902618528110906e-06, -1.95104992239772127e-11 * 1. / (1_MeV), 0,
-      -1.62459623796150906e-07 * 1. / (1_MeV),
-      -7.61741612270504069e-09 * 1. / (1_MeV),
-      7.96054784235342818e-09 * 1. / (1_MeV),
-      -1.95104992239772127e-11 * 1. / (1_MeV),
-      1.81045026192983016e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams165 = BoundParameters(tgContext, std::move(covMat165),
-                                        params165, perigeeSurface);
-  tracks.push_back(boundParams165);
-
-  // track 166 :
-  BoundVector params166;
-  params166 << 0.799288451671600342, -27.6733474731445312, 1.79553651809692383,
-      2.62628865242004395, 0.000649376073852181435 * 1. / (1_MeV), 0;
-  Covariance covMat166;
-  covMat166 << 0.0184728335589170456, 0.000576206559643558606,
-      -0.000498748322512280475, 2.46767730379623049e-06,
-      -2.41244600997874658e-07 * 1. / (1_MeV), 0, 0.000576206559643558606,
-      0.1421927809715271, 1.81454957973484008e-05, 0.000800767644742904545,
-      -5.41325547148110521e-09 * 1. / (1_MeV), 0, -0.000498748322512280475,
-      1.81454957973484008e-05, 1.40697147799073718e-05, 1.08885275385941302e-07,
-      1.05514606536829556e-08 * 1. / (1_MeV), 0, 2.46767730379623049e-06,
-      0.000800767644742904545, 1.08885275385941302e-07, 4.79977052236790769e-06,
-      -6.6186235709197681e-11 * 1. / (1_MeV), 0,
-      -2.41244600997874658e-07 * 1. / (1_MeV),
-      -5.41325547148110521e-09 * 1. / (1_MeV),
-      1.05514606536829556e-08 * 1. / (1_MeV),
-      -6.6186235709197681e-11 * 1. / (1_MeV),
-      1.90290047608066004e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams166 = BoundParameters(tgContext, std::move(covMat166),
-                                        params166, perigeeSurface);
-  tracks.push_back(boundParams166);
-
-  // track 167 :
-  BoundVector params167;
-  params167 << -0.35574042797088623, -24.7030124664306641, -2.12256479263305664,
-      0.692609786987304688, -0.00104050105437636375 * 1. / (1_MeV), 0;
-  Covariance covMat167;
-  covMat167 << 0.015440003015100956, -0.000624176001675493886,
-      -0.000464574482277491259, -7.70109899823705722e-06,
-      -2.81178338802018056e-07 * 1. / (1_MeV), 0, -0.000624176001675493886,
-      0.0619786754250526428, 3.09368817688975256e-05, 0.000695986322192939863,
-      5.11273110436170716e-09 * 1. / (1_MeV), 0, -0.000464574482277491259,
-      3.09368817688975256e-05, 1.41627569973934442e-05, 3.76623335304221592e-07,
-      1.32070729647698356e-08 * 1. / (1_MeV), 0, -7.70109899823705722e-06,
-      0.000695986322192939863, 3.76623335304221592e-07, 8.04879437055205926e-06,
-      4.26309578361557248e-11 * 1. / (1_MeV), 0,
-      -2.81178338802018056e-07 * 1. / (1_MeV),
-      5.11273110436170716e-09 * 1. / (1_MeV),
-      1.32070729647698356e-08 * 1. / (1_MeV),
-      4.26309578361557248e-11 * 1. / (1_MeV),
-      3.20331428049769329e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams167 = BoundParameters(tgContext, std::move(covMat167),
-                                        params167, perigeeSurface);
-  tracks.push_back(boundParams167);
-
-  // track 168 :
-  BoundVector params168;
-  params168 << 0.11886557936668396, -47.7819938659667969, -2.63996195793151855,
-      0.518789112567901611, 0.000841481960378587246 * 1. / (1_MeV), 0;
-  Covariance covMat168;
-  covMat168 << 0.0208285339176654816, -0.000140944469367757928,
-      -0.000628714493802016365, 2.85093059534874148e-06,
-      -2.52877307106631281e-07 * 1. / (1_MeV), 0, -0.000140944469367757928,
-      0.0990117564797401428, -1.87049319949921501e-05, 0.000699713933447829585,
-      5.35561789668739302e-09 * 1. / (1_MeV), 0, -0.000628714493802016365,
-      -1.87049319949921501e-05, 1.92184870684286579e-05,
-      -2.45129716626087157e-07, 1.23193818731095067e-08 * 1. / (1_MeV), 0,
-      2.85093059534874148e-06, 0.000699713933447829585,
-      -2.45129716626087157e-07, 5.04362697029137053e-06,
-      1.03376886437529416e-11 * 1. / (1_MeV), 0,
-      -2.52877307106631281e-07 * 1. / (1_MeV),
-      5.35561789668739302e-09 * 1. / (1_MeV),
-      1.23193818731095067e-08 * 1. / (1_MeV),
-      1.03376886437529416e-11 * 1. / (1_MeV),
-      2.40058611877813632e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams168 = BoundParameters(tgContext, std::move(covMat168),
-                                        params168, perigeeSurface);
-  tracks.push_back(boundParams168);
-
-  // track 169 :
-  BoundVector params169;
-  params169 << -0.753641188144683838, -24.6972694396972656,
-      -1.26335954666137695, 2.93867397308349609,
-      -5.220841194386594e-05 * 1. / (1_MeV), 0;
-  Covariance covMat169;
-  covMat169 << 0.00236013904213905334, 0.00154376213001722611,
-      -6.73646577569984184e-05, 1.30328176525545106e-06,
-      -1.67714425087651653e-08 * 1. / (1_MeV), 0, 0.00154376213001722611,
-      0.0721083357930183411, -3.89344568551530906e-05, 7.66922827229373638e-05,
-      -5.41191330879136116e-09 * 1. / (1_MeV), 0, -6.73646577569984184e-05,
-      -3.89344568551530906e-05, 1.97714439309493173e-06,
-      -3.33291794511282267e-08, 7.90020084251383031e-10 * 1. / (1_MeV), 0,
-      1.30328176525545106e-06, 7.66922827229373638e-05,
-      -3.33291794511282267e-08, 8.44821670398232527e-08,
-      -2.55639621894285378e-12 * 1. / (1_MeV), 0,
-      -1.67714425087651653e-08 * 1. / (1_MeV),
-      -5.41191330879136116e-09 * 1. / (1_MeV),
-      7.90020084251383031e-10 * 1. / (1_MeV),
-      -2.55639621894285378e-12 * 1. / (1_MeV),
-      6.093434784526508e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams169 = BoundParameters(tgContext, std::move(covMat169),
-                                        params169, perigeeSurface);
-  tracks.push_back(boundParams169);
-
-  // track 170 :
-  BoundVector params170;
-  params170 << -2.15710759162902832, -45.7950439453125, 1.61371970176696777,
-      0.570733428001403809, 0.000358434394001960754 * 1. / (1_MeV), 0;
-  Covariance covMat170;
-  covMat170 << 0.00374916614964604378, -0.000480773005103489936,
-      -0.000105863497891874796, -1.61542653193409112e-07,
-      -1.17937713758139657e-07 * 1. / (1_MeV), 0, -0.000480773005103489936,
-      0.017858605831861496, 1.13532057634138872e-05, 0.000137701393792528048,
-      2.46103911881579324e-08 * 1. / (1_MeV), 0, -0.000105863497891874796,
-      1.13532057634138872e-05, 3.12180145556339994e-06, -1.2843229301556418e-08,
-      5.5197340225094278e-09 * 1. / (1_MeV), 0, -1.61542653193409112e-07,
-      0.000137701393792528048, -1.2843229301556418e-08, 1.12689849629532546e-06,
-      2.78956850716596797e-11 * 1. / (1_MeV), 0,
-      -1.17937713758139657e-07 * 1. / (1_MeV),
-      2.46103911881579324e-08 * 1. / (1_MeV),
-      5.5197340225094278e-09 * 1. / (1_MeV),
-      2.78956850716596797e-11 * 1. / (1_MeV),
-      1.16566450936161914e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams170 = BoundParameters(tgContext, std::move(covMat170),
-                                        params170, perigeeSurface);
-  tracks.push_back(boundParams170);
-
-  // track 171 :
-  BoundVector params171;
-  params171 << 0.297651320695877075, -45.3023033142089844, 1.42410826683044434,
-      0.565678238868713379, -0.000133898094645701349 * 1. / (1_MeV), 0;
-  Covariance covMat171;
-  covMat171 << 0.0027103363536298275, -0.000399266654113502575,
-      -6.23420930522729119e-05, -1.82670658152625359e-06,
-      -7.69916514339241363e-08 * 1. / (1_MeV), 0, -0.000399266654113502575,
-      0.0117103047668933868, 7.28538372498596201e-06, 6.72442964353909048e-05,
-      5.10417192350336677e-09 * 1. / (1_MeV), 0, -6.23420930522729119e-05,
-      7.28538372498596201e-06, 1.54875021962652681e-06, 3.63352506955697989e-08,
-      2.88464097247522637e-09 * 1. / (1_MeV), 0, -1.82670658152625359e-06,
-      6.72442964353909048e-05, 3.63352506955697989e-08, 4.41652872495978954e-07,
-      3.38702398090118851e-11 * 1. / (1_MeV), 0,
-      -7.69916514339241363e-08 * 1. / (1_MeV),
-      5.10417192350336677e-09 * 1. / (1_MeV),
-      2.88464097247522637e-09 * 1. / (1_MeV),
-      3.38702398090118851e-11 * 1. / (1_MeV),
-      5.12816594744336385e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams171 = BoundParameters(tgContext, std::move(covMat171),
-                                        params171, perigeeSurface);
-  tracks.push_back(boundParams171);
-
-  // track 172 :
-  BoundVector params172;
-  params172 << -0.260308802127838135, -25.6350498199462891,
-      -1.41230368614196777, 0.262120574712753296,
-      0.000281498883850872517 * 1. / (1_MeV), 0;
-  Covariance covMat172;
-  covMat172 << 0.0194595623761415482, -0.00222148450059943877,
-      -0.00058252322875270953, -1.15501756925054456e-06,
-      -1.81610552902542074e-07 * 1. / (1_MeV), 0, -0.00222148450059943877,
-      0.29862898588180542, 3.40986013403370269e-05, 0.000587010747958494408,
-      2.04544462489257834e-08 * 1. / (1_MeV), 0, -0.00058252322875270953,
-      3.40986013403370269e-05, 1.77671008714241907e-05,
-      -2.35695411054423683e-08, 8.95910636378094416e-09 * 1. / (1_MeV), 0,
-      -1.15501756925054456e-06, 0.000587010747958494408,
-      -2.35695411054423683e-08, 1.17103115826466819e-06,
-      1.04135839016089135e-11 * 1. / (1_MeV), 0,
-      -1.81610552902542074e-07 * 1. / (1_MeV),
-      2.04544462489257834e-08 * 1. / (1_MeV),
-      8.95910636378094416e-09 * 1. / (1_MeV),
-      1.04135839016089135e-11 * 1. / (1_MeV),
-      9.13651862499698098e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams172 = BoundParameters(tgContext, std::move(covMat172),
-                                        params172, perigeeSurface);
-  tracks.push_back(boundParams172);
-
-  // track 173 :
-  BoundVector params173;
-  params173 << -0.594252109527587891, -5.60402631759643555,
-      -0.336331099271774292, 1.13270664215087891,
-      0.000378493685275316238 * 1. / (1_MeV), 0;
-  Covariance covMat173;
-  covMat173 << 0.00115027138963341713, -2.19197368548817592e-05,
-      -3.13219643767075195e-05, 1.15073899304131421e-07,
-      -1.65870850823649665e-08 * 1. / (1_MeV), 0, -2.19197368548817592e-05,
-      0.00670524360612034798, 1.96229471089852108e-07, 9.39307543268990297e-05,
-      2.47498208313890995e-09 * 1. / (1_MeV), 0, -3.13219643767075195e-05,
-      1.96229471089852108e-07, 8.87292799234273843e-07,
-      -8.13976292236793086e-09, 6.99034330539053411e-10 * 1. / (1_MeV), 0,
-      1.15073899304131421e-07, 9.39307543268990297e-05,
-      -8.13976292236793086e-09, 1.76549144725868246e-06,
-      2.24057572896354012e-11 * 1. / (1_MeV), 0,
-      -1.65870850823649665e-08 * 1. / (1_MeV),
-      2.47498208313890995e-09 * 1. / (1_MeV),
-      6.99034330539053411e-10 * 1. / (1_MeV),
-      2.24057572896354012e-11 * 1. / (1_MeV),
-      2.14914561841306195e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams173 = BoundParameters(tgContext, std::move(covMat173),
-                                        params173, perigeeSurface);
-  tracks.push_back(boundParams173);
-
-  // track 174 :
-  BoundVector params174;
-  params174 << 0.52924954891204834, -45.4634666442871094, 1.54447901248931885,
-      0.575577259063720703, 0.000140380390803329647 * 1. / (1_MeV), 0;
-  Covariance covMat174;
-  covMat174 << 0.00100269797258079052, -1.87621193858972703e-05,
-      -2.4220765886711641e-05, -1.19159820826764043e-07,
-      -1.29051422917792668e-08 * 1. / (1_MeV), 0, -1.87621193858972703e-05,
-      0.00537070957943797112, -5.56254936329620509e-08, 3.29737664105863798e-05,
-      3.42796441483104706e-11 * 1. / (1_MeV), 0, -2.4220765886711641e-05,
-      -5.56254936329620509e-08, 6.28942132152587874e-07,
-      9.62406379884910632e-10, 4.7992442755515698e-10 * 1. / (1_MeV), 0,
-      -1.19159820826764043e-07, 3.29737664105863798e-05,
-      9.62406379884910632e-10, 2.3663132253659569e-07,
-      2.21547914401007548e-12 * 1. / (1_MeV), 0,
-      -1.29051422917792668e-08 * 1. / (1_MeV),
-      3.42796441483104706e-11 * 1. / (1_MeV),
-      4.7992442755515698e-10 * 1. / (1_MeV),
-      2.21547914401007548e-12 * 1. / (1_MeV),
-      8.28479385789337996e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams174 = BoundParameters(tgContext, std::move(covMat174),
-                                        params174, perigeeSurface);
-  tracks.push_back(boundParams174);
-
-  // track 175 :
-  BoundVector params175;
-  params175 << -0.450001835823059082, -24.8905086517333984, -1.6759798526763916,
-      2.58415007591247559, 0.000905881694052368402 * 1. / (1_MeV), 0;
-  Covariance covMat175;
-  covMat175 << 0.0191041901707649231, 0.000428026557284443552,
-      -0.000578871801601514016, -4.45544214020110735e-06,
-      -2.95792810909549861e-07 * 1. / (1_MeV), 0, 0.000428026557284443552,
-      0.0838873609900474548, 6.5131177683482284e-06, 0.000669239272102370875,
-      -1.83345569355485214e-08 * 1. / (1_MeV), 0, -0.000578871801601514016,
-      6.5131177683482284e-06, 1.77657839230960235e-05, 2.90084065510616385e-07,
-      1.41475994510483018e-08 * 1. / (1_MeV), 0, -4.45544214020110735e-06,
-      0.000669239272102370875, 2.90084065510616385e-07, 5.4637353059661109e-06,
-      -8.89617608490651688e-12 * 1. / (1_MeV), 0,
-      -2.95792810909549861e-07 * 1. / (1_MeV),
-      -1.83345569355485214e-08 * 1. / (1_MeV),
-      1.41475994510483018e-08 * 1. / (1_MeV),
-      -8.89617608490651688e-12 * 1. / (1_MeV),
-      2.89176599332918727e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams175 = BoundParameters(tgContext, std::move(covMat175),
-                                        params175, perigeeSurface);
-  tracks.push_back(boundParams175);
-
-  // track 176 :
-  BoundVector params176;
-  params176 << -1.09194684028625488, -51.893341064453125, -2.42328953742980957,
-      0.323457986116409302, -9.37030999921262264e-05 * 1. / (1_MeV), 0;
-  Covariance covMat176;
-  covMat176 << 0.00412589358165860176, -0.000375938547586086044,
-      -9.1347763501019072e-05, -2.06706237329043565e-07,
-      -3.10176057568745453e-08 * 1. / (1_MeV), 0, -0.000375938547586086044,
-      0.044574592262506485, 9.1346382981081699e-06, 9.46204435551554129e-05,
-      3.18549795465229701e-09 * 1. / (1_MeV), 0, -9.1347763501019072e-05,
-      9.1346382981081699e-06, 2.12798704524175264e-06, 6.25620778480259521e-09,
-      9.45920987209876617e-10 * 1. / (1_MeV), 0, -2.06706237329043565e-07,
-      9.46204435551554129e-05, 6.25620778480259521e-09, 2.1415434048321913e-07,
-      2.81623324330943026e-13 * 1. / (1_MeV), 0,
-      -3.10176057568745453e-08 * 1. / (1_MeV),
-      3.18549795465229701e-09 * 1. / (1_MeV),
-      9.45920987209876617e-10 * 1. / (1_MeV),
-      2.81623324330943026e-13 * 1. / (1_MeV),
-      7.16269968684124514e-12 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams176 = BoundParameters(tgContext, std::move(covMat176),
-                                        params176, perigeeSurface);
-  tracks.push_back(boundParams176);
-
-  // track 177 :
-  BoundVector params177;
-  params177 << -0.625615954399108887, -46.6411361694335938,
-      -1.67621421813964844, 0.80771172046661377,
-      -0.000952719361521303654 * 1. / (1_MeV), 0;
-  Covariance covMat177;
-  covMat177 << 0.00838966574519872665, -0.000390657537966586301,
-      -0.000252564060557339894, -4.46970396215082643e-06,
-      -1.84211977604922163e-07 * 1. / (1_MeV), 0, -0.000390657537966586301,
-      0.0338415279984474182, 1.69225585373511505e-05, 0.000474475732694860702,
-      5.60214482748251599e-09 * 1. / (1_MeV), 0, -0.000252564060557339894,
-      1.69225585373511505e-05, 7.7171598604763858e-06, 2.14307467715597906e-07,
-      8.70000260399467453e-09 * 1. / (1_MeV), 0, -4.46970396215082643e-06,
-      0.000474475732694860702, 2.14307467715597906e-07, 6.95064863975858316e-06,
-      3.34801528438062845e-11 * 1. / (1_MeV), 0,
-      -1.84211977604922163e-07 * 1. / (1_MeV),
-      5.60214482748251599e-09 * 1. / (1_MeV),
-      8.70000260399467453e-09 * 1. / (1_MeV),
-      3.34801528438062845e-11 * 1. / (1_MeV),
-      2.40241548876696243e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams177 = BoundParameters(tgContext, std::move(covMat177),
-                                        params177, perigeeSurface);
-  tracks.push_back(boundParams177);
-
-  // track 178 :
-  BoundVector params178;
-  params178 << 0.249076232314109802, -45.2034416198730469, 1.10756564140319824,
-      0.49081951379776001, 0.000841880100779235363 * 1. / (1_MeV), 0;
-  Covariance covMat178;
-  covMat178 << 0.0248545967042446136, 0.000258131336002727254,
-      -0.000766693038710525494, 4.70029301471237248e-06,
-      -9.08506397185599934e-07 * 1. / (1_MeV), 0, 0.000258131336002727254,
-      0.119198836386203766, -3.3659753635808291e-05, 0.000777684091309682095,
-      1.1712654493269838e-08 * 1. / (1_MeV), 0, -0.000766693038710525494,
-      -3.3659753635808291e-05, 2.41926300077466294e-05,
-      -3.10682537473999761e-07, 4.60434144629863134e-08 * 1. / (1_MeV), 0,
-      4.70029301471237248e-06, 0.000777684091309682095,
-      -3.10682537473999761e-07, 5.14959992869989946e-06,
-      6.61054698516293509e-11 * 1. / (1_MeV), 0,
-      -9.08506397185599934e-07 * 1. / (1_MeV),
-      1.1712654493269838e-08 * 1. / (1_MeV),
-      4.60434144629863134e-08 * 1. / (1_MeV),
-      6.61054698516293509e-11 * 1. / (1_MeV),
-      8.71379024491858445e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams178 = BoundParameters(tgContext, std::move(covMat178),
-                                        params178, perigeeSurface);
-  tracks.push_back(boundParams178);
-
-  // track 179 :
-  BoundVector params179;
-  params179 << -0.351021707057952881, -22.8008213043212891,
-      -1.84860432147979736, 2.58694338798522949,
-      -0.000485390948597341776 * 1. / (1_MeV), 0;
-  Covariance covMat179;
-  covMat179 << 0.00608975626528263092, 0.000321320464682472128,
-      -0.000183190187843461718, 2.34032168014660546e-06,
-      -7.63023209733254009e-08 * 1. / (1_MeV), 0, 0.000321320464682472128,
-      0.0319467782974243164, -1.25274257766205381e-05, 0.000241198831469217781,
-      -2.23777402096878229e-09 * 1. / (1_MeV), 0, -0.000183190187843461718,
-      -1.25274257766205381e-05, 5.58611691303667612e-06,
-      -9.42901609067163353e-08, 3.72169224602511146e-09 * 1. / (1_MeV), 0,
-      2.34032168014660546e-06, 0.000241198831469217781,
-      -9.42901609067163353e-08, 1.88807791801082203e-06,
-      -8.61261950846322556e-12 * 1. / (1_MeV), 0,
-      -7.63023209733254009e-08 * 1. / (1_MeV),
-      -2.23777402096878229e-09 * 1. / (1_MeV),
-      3.72169224602511146e-09 * 1. / (1_MeV),
-      -8.61261950846322556e-12 * 1. / (1_MeV),
-      7.60389459730781425e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams179 = BoundParameters(tgContext, std::move(covMat179),
-                                        params179, perigeeSurface);
-  tracks.push_back(boundParams179);
-
-  // track 180 :
-  BoundVector params180;
-  params180 << 0.651896417140960693, -46.7836685180664062, 2.76631903648376465,
-      0.470141232013702393, 1.55008747242391109e-05 * 1. / (1_MeV), 0;
-  Covariance covMat180;
-  covMat180 << 0.000128315252368338406, -3.22642732016210971e-05,
-      -1.99036999570274823e-06, -7.04322809885584826e-08,
-      -1.0059405196984426e-09 * 1. / (1_MeV), 0, -3.22642732016210971e-05,
-      0.00309902383014559746, 3.32147694595742431e-07, 7.25987283305179582e-06,
-      4.75892992516188328e-11 * 1. / (1_MeV), 0, -1.99036999570274823e-06,
-      3.32147694595742431e-07, 3.70899009283220948e-08, 8.60572979362656713e-10,
-      2.24457480954691427e-11 * 1. / (1_MeV), 0, -7.04322809885584826e-08,
-      7.25987283305179582e-06, 8.60572979362656713e-10, 2.08767385601049682e-08,
-      3.80890047398306893e-14 * 1. / (1_MeV), 0,
-      -1.0059405196984426e-09 * 1. / (1_MeV),
-      4.75892992516188328e-11 * 1. / (1_MeV),
-      2.24457480954691427e-11 * 1. / (1_MeV),
-      3.80890047398306893e-14 * 1. / (1_MeV),
-      2.13997019432067559e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams180 = BoundParameters(tgContext, std::move(covMat180),
-                                        params180, perigeeSurface);
-  tracks.push_back(boundParams180);
-
-  // track 181 :
-  BoundVector params181;
-  params181 << 0.3097667396068573, -23.4043254852294922, -2.6382148265838623,
-      2.12934017181396484, 0.00137407251168042421 * 1. / (1_MeV), 0;
-  Covariance covMat181;
-  covMat181 << 0.0118062039837241173, -0.000109254910565050641,
-      -0.000350342450795821422, -4.40406929924205366e-06,
-      -1.69602117125455836e-07 * 1. / (1_MeV), 0, -0.000109254910565050641,
-      0.0281959716230630875, 9.69099679268529228e-06, 0.000552701234963060353,
-      -1.86788811100685945e-09 * 1. / (1_MeV), 0, -0.000350342450795821422,
-      9.69099679268529228e-06, 1.0552752428338863e-05, 2.52690458002615574e-07,
-      8.14523789406513383e-09 * 1. / (1_MeV), 0, -4.40406929924205366e-06,
-      0.000552701234963060353, 2.52690458002615574e-07, 1.13834439616766758e-05,
-      -4.34128100864560213e-11 * 1. / (1_MeV), 0,
-      -1.69602117125455836e-07 * 1. / (1_MeV),
-      -1.86788811100685945e-09 * 1. / (1_MeV),
-      8.14523789406513383e-09 * 1. / (1_MeV),
-      -4.34128100864560213e-11 * 1. / (1_MeV),
-      2.69415295628405715e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams181 = BoundParameters(tgContext, std::move(covMat181),
-                                        params181, perigeeSurface);
-  tracks.push_back(boundParams181);
-
-  // track 182 :
-  BoundVector params182;
-  params182 << 0.642095208168029785, -46.7620658874511719, 2.74535226821899414,
-      0.476923286914825439, -2.45610826823394746e-05 * 1. / (1_MeV), 0;
-  Covariance covMat182;
-  covMat182 << 0.000100913421192672104, -2.33679616572281888e-05,
-      -2.07401176069228284e-06, -4.92462068561543299e-08,
-      -7.88576461002653878e-10 * 1. / (1_MeV), 0, -2.33679616572281888e-05,
-      0.00347701110877096653, 1.02118911354786458e-07, 1.11020572919389336e-05,
-      6.8980626296848663e-10 * 1. / (1_MeV), 0, -2.07401176069228284e-06,
-      1.02118911354786458e-07, 5.15610665274834901e-08, 1.91829932276107212e-10,
-      2.57034296242806379e-11 * 1. / (1_MeV), 0, -4.92462068561543299e-08,
-      1.11020572919389336e-05, 1.91829932276107212e-10, 4.51592896411057154e-08,
-      2.18691904163845164e-12 * 1. / (1_MeV), 0,
-      -7.88576461002653878e-10 * 1. / (1_MeV),
-      6.8980626296848663e-10 * 1. / (1_MeV),
-      2.57034296242806379e-11 * 1. / (1_MeV),
-      2.18691904163845164e-12 * 1. / (1_MeV),
-      3.96474248830908094e-13 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams182 = BoundParameters(tgContext, std::move(covMat182),
-                                        params182, perigeeSurface);
-  tracks.push_back(boundParams182);
-
-  // track 183 :
-  BoundVector params183;
-  params183 << -0.858931362628936768, -26.3201007843017578,
-      -1.06501162052154541, 2.00542879104614258,
-      -0.00147176207974553108 * 1. / (1_MeV), 0;
-  Covariance covMat183;
-  covMat183 << 0.011342288926243782, 0.000290935310731487665,
-      -0.000333001654335057632, 4.59266904966147677e-06,
-      -1.51592966891820935e-07 * 1. / (1_MeV), 0, 0.000290935310731487665,
-      0.0283716730773448944, -1.24780364597086955e-05, 0.000574239226233242469,
-      -9.53412665718049786e-09 * 1. / (1_MeV), 0, -0.000333001654335057632,
-      -1.24780364597086955e-05, 9.96404742181766778e-06,
-      -2.20760287088705507e-07, 7.55984162080033033e-09 * 1. / (1_MeV), 0,
-      4.59266904966147677e-06, 0.000574239226233242469,
-      -2.20760287088705507e-07, 1.23750987768289633e-05,
-      -1.19858856846402273e-10 * 1. / (1_MeV), 0,
-      -1.51592966891820935e-07 * 1. / (1_MeV),
-      -9.53412665718049786e-09 * 1. / (1_MeV),
-      7.55984162080033033e-09 * 1. / (1_MeV),
-      -1.19858856846402273e-10 * 1. / (1_MeV),
-      2.77350448163460328e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams183 = BoundParameters(tgContext, std::move(covMat183),
-                                        params183, perigeeSurface);
-  tracks.push_back(boundParams183);
-
-  // track 184 :
-  BoundVector params184;
-  params184 << 0.845212101936340332, -24.126739501953125, 2.38256359100341797,
-      0.824191451072692871, 0.00116483436431735754 * 1. / (1_MeV), 0;
-  Covariance covMat184;
-  covMat184 << 0.0120219700038433075, 0.000314479883882060258,
-      -0.000367754344864782703, 3.16651031569499765e-06,
-      -5.50176211668336246e-07 * 1. / (1_MeV), 0, 0.000314479883882060258,
-      0.0294524524360895157, -1.65477014501080602e-05, 0.00044716975418939163,
-      -1.85121059683026354e-08 * 1. / (1_MeV), 0, -0.000367754344864782703,
-      -1.65477014501080602e-05, 1.14791173473349772e-05,
-      -1.9939615532523593e-07, 2.734052899630625e-08 * 1. / (1_MeV), 0,
-      3.16651031569499765e-06, 0.00044716975418939163, -1.9939615532523593e-07,
-      6.98199028192902915e-06, -3.56882818335140094e-11 * 1. / (1_MeV), 0,
-      -5.50176211668336246e-07 * 1. / (1_MeV),
-      -1.85121059683026354e-08 * 1. / (1_MeV),
-      2.734052899630625e-08 * 1. / (1_MeV),
-      -3.56882818335140094e-11 * 1. / (1_MeV),
-      8.01815225326407699e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams184 = BoundParameters(tgContext, std::move(covMat184),
-                                        params184, perigeeSurface);
-  tracks.push_back(boundParams184);
-
-  // track 185 :
-  BoundVector params185;
-  params185 << -0.647501945495605469, -26.0731620788574219,
-      -0.995935499668121338, 2.34878754615783691,
-      -0.00110976793803274632 * 1. / (1_MeV), 0;
-  Covariance covMat185;
-  covMat185 << 0.0123600270599126816, 0.000410363839412986508,
-      -0.000381886789830261913, 4.94468486056877076e-06,
-      -7.64568886360537938e-07 * 1. / (1_MeV), 0, 0.000410363839412986508,
-      0.0372607558965682983, -2.04358797977256596e-05, 0.000530848800251920608,
-      -1.84281636372081495e-08 * 1. / (1_MeV), 0, -0.000381886789830261913,
-      -2.04358797977256596e-05, 1.20873473861138336e-05,
-      -2.66094668793066799e-07, 3.82825795137663461e-08 * 1. / (1_MeV), 0,
-      4.94468486056877076e-06, 0.000530848800251920608,
-      -2.66094668793066799e-07, 7.83790710556786507e-06,
-      -5.28708663533158423e-11 * 1. / (1_MeV), 0,
-      -7.64568886360537938e-07 * 1. / (1_MeV),
-      -1.84281636372081495e-08 * 1. / (1_MeV),
-      3.82825795137663461e-08 * 1. / (1_MeV),
-      -5.28708663533158423e-11 * 1. / (1_MeV),
-      1.09044751006592833e-09 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams185 = BoundParameters(tgContext, std::move(covMat185),
-                                        params185, perigeeSurface);
-  tracks.push_back(boundParams185);
-
-  // track 186 :
-  BoundVector params186;
-  params186 << 0.319027870893478394, -46.8204345703125, -2.81523966789245605,
-      0.552423059940338135, -0.000565428519621491432 * 1. / (1_MeV), 0;
-  Covariance covMat186;
-  covMat186 << 0.00984183419495820999, -0.000107861702339279294,
-      -0.000293623369079297144, -2.57141056900692002e-06,
-      -2.68841014325236236e-07 * 1. / (1_MeV), 0, -0.000107861702339279294,
-      0.0447328835725784302, 6.98001302362255524e-06, 0.000354029532888733148,
-      -7.43175254803814895e-09 * 1. / (1_MeV), 0, -0.000293623369079297144,
-      6.98001302362255524e-06, 8.98743746802210808e-06, 1.18656413477563677e-07,
-      1.2513898586729675e-08 * 1. / (1_MeV), 0, -2.57141056900692002e-06,
-      0.000354029532888733148, 1.18656413477563677e-07, 2.89464674096961971e-06,
-      9.64087163963260696e-12 * 1. / (1_MeV), 0,
-      -2.68841014325236236e-07 * 1. / (1_MeV),
-      -7.43175254803814895e-09 * 1. / (1_MeV),
-      1.2513898586729675e-08 * 1. / (1_MeV),
-      9.64087163963260696e-12 * 1. / (1_MeV),
-      2.39039704696963895e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams186 = BoundParameters(tgContext, std::move(covMat186),
-                                        params186, perigeeSurface);
-  tracks.push_back(boundParams186);
-
-  // track 187 :
-  BoundVector params187;
-  params187 << 0.200757488608360291, -26.9347019195556641, 1.57208847999572754,
-      2.04276847839355469, -0.00149231334216892719 * 1. / (1_MeV), 0;
-  Covariance covMat187;
-  covMat187 << 0.0462070293724536896, 1.90087908538328356e-05,
-      -0.00102549302847446035, 1.05894079671972913e-05,
-      -5.64029011801386039e-07 * 1. / (1_MeV), 0, 1.90087908538328356e-05,
-      0.0641310736536979675, -1.20655144555816986e-05, 0.00107456409340518297,
-      7.16318519179297501e-09 * 1. / (1_MeV), 0, -0.00102549302847446035,
-      -1.20655144555816986e-05, 2.3894455807749182e-05,
-      -4.41047372315603779e-07, 1.78538275775300426e-08 * 1. / (1_MeV), 0,
-      1.05894079671972913e-05, 0.00107456409340518297, -4.41047372315603779e-07,
-      1.92008483281824738e-05, -2.57140078054900237e-12 * 1. / (1_MeV), 0,
-      -5.64029011801386039e-07 * 1. / (1_MeV),
-      7.16318519179297501e-09 * 1. / (1_MeV),
-      1.78538275775300426e-08 * 1. / (1_MeV),
-      -2.57140078054900237e-12 * 1. / (1_MeV),
-      3.88259702166493526e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams187 = BoundParameters(tgContext, std::move(covMat187),
-                                        params187, perigeeSurface);
-  tracks.push_back(boundParams187);
-
-  // track 188 :
-  BoundVector params188;
-  params188 << 0.206104561686515808, -26.3112201690673828, 1.16691756248474121,
-      1.37588953971862793, 0.00132282346021384001 * 1. / (1_MeV), 0;
-  Covariance covMat188;
-  covMat188 << 0.00764826126396656036, 2.58893561269243087e-05,
-      -0.000224053920824634036, 1.17201917881422574e-06,
-      -6.15634478426662571e-07 * 1. / (1_MeV), 0, 2.58893561269243087e-05,
-      0.0230550467967987061, -2.20380176677741682e-06, 0.000482425977760371505,
-      5.06151582160123152e-09 * 1. / (1_MeV), 0, -0.000224053920824634036,
-      -2.20380176677741682e-06, 6.82648260408313945e-06,
-      -6.86203109211295378e-08, 2.94694781059607752e-08 * 1. / (1_MeV), 0,
-      1.17201917881422574e-06, 0.000482425977760371505,
-      -6.86203109211295378e-08, 1.19285659820889123e-05,
-      -8.07723581241271915e-12 * 1. / (1_MeV), 0,
-      -6.15634478426662571e-07 * 1. / (1_MeV),
-      5.06151582160123152e-09 * 1. / (1_MeV),
-      2.94694781059607752e-08 * 1. / (1_MeV),
-      -8.07723581241271915e-12 * 1. / (1_MeV),
-      1.11964115756535421e-09 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams188 = BoundParameters(tgContext, std::move(covMat188),
-                                        params188, perigeeSurface);
-  tracks.push_back(boundParams188);
-
-  // track 189 :
-  BoundVector params189;
-  params189 << 1.26870429515838623, -46.6835365295410156, 2.73736929893493652,
-      0.47043222188949585, -0.000411598914070054889 * 1. / (1_MeV), 0;
-  Covariance covMat189;
-  covMat189 << 0.01254259143024683, -0.00206373011378385143,
-      -0.000333126060112854414, -1.27171802273924282e-05,
-      -3.42805695619100495e-07 * 1. / (1_MeV), 0, -0.00206373011378385143,
-      0.063680604100227356, 4.27260303702722393e-05, 0.000335381549435983519,
-      6.98047989676528565e-09 * 1. / (1_MeV), 0, -0.000333126060112854414,
-      4.27260303702722393e-05, 9.29942689253948629e-06, 3.07921052012408952e-07,
-      1.3794266136933136e-08 * 1. / (1_MeV), 0, -1.27171802273924282e-05,
-      0.000335381549435983519, 3.07921052012408952e-07, 1.85226963367313147e-06,
-      1.88533015927685212e-10 * 1. / (1_MeV), 0,
-      -3.42805695619100495e-07 * 1. / (1_MeV),
-      6.98047989676528565e-09 * 1. / (1_MeV),
-      1.3794266136933136e-08 * 1. / (1_MeV),
-      1.88533015927685212e-10 * 1. / (1_MeV),
-      2.06299227700768029e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams189 = BoundParameters(tgContext, std::move(covMat189),
-                                        params189, perigeeSurface);
-  tracks.push_back(boundParams189);
-
-  // track 190 :
-  BoundVector params190;
-  params190 << 0.520144522190093994, -26.78125, 2.87916159629821777,
-      0.913090944290161133, 0.000958578370045870543 * 1. / (1_MeV), 0;
-  Covariance covMat190;
-  covMat190 << 0.0566640235483646393, 0.000619879059068139857,
-      -0.0011829013005423088, 1.13578597071357791e-05,
-      -2.92844240909480606e-07 * 1. / (1_MeV), 0, 0.000619879059068139857,
-      0.112776532769203186, -3.16848163975865004e-05, 0.00133383261677284099,
-      1.65364516509722375e-10 * 1. / (1_MeV), 0, -0.0011829013005423088,
-      -3.16848163975865004e-05, 2.54572314588585868e-05,
-      -4.61895451801213113e-07, 9.13941830794303589e-09 * 1. / (1_MeV), 0,
-      1.13578597071357791e-05, 0.00133383261677284099, -4.61895451801213113e-07,
-      1.69904978974955156e-05, 2.02537558480182913e-11 * 1. / (1_MeV), 0,
-      -2.92844240909480606e-07 * 1. / (1_MeV),
-      1.65364516509722375e-10 * 1. / (1_MeV),
-      9.13941830794303589e-09 * 1. / (1_MeV),
-      2.02537558480182913e-11 * 1. / (1_MeV),
-      1.74747369352523663e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams190 = BoundParameters(tgContext, std::move(covMat190),
-                                        params190, perigeeSurface);
-  tracks.push_back(boundParams190);
-
-  // track 191 :
-  BoundVector params191;
-  params191 << 3.12282395362854004, -65.509918212890625, -0.187527939677238464,
-      2.73361945152282715, 0.000346441811416298151 * 1. / (1_MeV), 0;
-  Covariance covMat191;
-  covMat191 << 0.0481044948101043701, -0.00734549814752950836,
-      -0.00103489854597267421, -4.2235125913880291e-06,
-      -3.96252766190557419e-07 * 1. / (1_MeV), 0, -0.00734549814752950836,
-      0.311487704515457153, 0.000193686295137312744, 0.00101870529268977775,
-      7.69202591235202105e-08 * 1. / (1_MeV), 0, -0.00103489854597267421,
-      0.000193686295137312744, 2.31200901907868683e-05, 1.875400366292023e-07,
-      1.18979733649928015e-08 * 1. / (1_MeV), 0, -4.2235125913880291e-06,
-      0.00101870529268977775, 1.875400366292023e-07, 3.4847455481212819e-06,
-      4.99503482968757551e-12 * 1. / (1_MeV), 0,
-      -3.96252766190557419e-07 * 1. / (1_MeV),
-      7.69202591235202105e-08 * 1. / (1_MeV),
-      1.18979733649928015e-08 * 1. / (1_MeV),
-      4.99503482968757551e-12 * 1. / (1_MeV),
-      1.1102829766684863e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams191 = BoundParameters(tgContext, std::move(covMat191),
-                                        params191, perigeeSurface);
-  tracks.push_back(boundParams191);
-
-  // track 192 :
-  BoundVector params192;
-  params192 << 1.94856953620910645, 32.0474395751953125, 1.59367656707763672,
-      0.301271170377731323, -0.000417216855566948652 * 1. / (1_MeV), 0;
-  Covariance covMat192;
-  covMat192 << 0.11419309675693512, 0.0161650360627660812,
-      -0.00256272073865566842, -1.33614281853937828e-05,
-      -1.05474827860620141e-06 * 1. / (1_MeV), 0, 0.0161650360627660812,
-      1.25828850269317627, -0.000234076459249502955, 0.00243207131735968243,
-      -2.73285579882235462e-07 * 1. / (1_MeV), 0, -0.00256272073865566842,
-      -0.000234076459249502955, 6.02843829256016761e-05,
-      5.83439505836653557e-07, 3.3253261709379142e-08 * 1. / (1_MeV), 0,
-      -1.33614281853937828e-05, 0.00243207131735968243, 5.83439505836653557e-07,
-      4.93446850668988191e-06, -1.22599704885134249e-11 * 1. / (1_MeV), 0,
-      -1.05474827860620141e-06 * 1. / (1_MeV),
-      -2.73285579882235462e-07 * 1. / (1_MeV),
-      3.3253261709379142e-08 * 1. / (1_MeV),
-      -1.22599704885134249e-11 * 1. / (1_MeV),
-      2.39606362528732575e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams192 = BoundParameters(tgContext, std::move(covMat192),
-                                        params192, perigeeSurface);
-  tracks.push_back(boundParams192);
-
-  // track 193 :
-  BoundVector params193;
-  params193 << 0.523398816585540771, -46.3878059387207031, 2.57148909568786621,
-      0.468454271554946899, 0.000597213569562882185 * 1. / (1_MeV), 0;
-  Covariance covMat193;
-  covMat193 << 0.0160064026713371277, 0.000101030272422620432,
-      -0.000480147175700083547, 8.08765442010045379e-07,
-      -4.30079426986170688e-07 * 1. / (1_MeV), 0, 0.000101030272422620432,
-      0.090941987931728363, -2.0664086011827537e-05, 0.000523265493974074398,
-      -1.2205651249153285e-09 * 1. / (1_MeV), 0, -0.000480147175700083547,
-      -2.0664086011827537e-05, 1.47662221934297122e-05,
-      -1.17382332277604896e-07, 2.09396062746074539e-08 * 1. / (1_MeV), 0,
-      8.08765442010045379e-07, 0.000523265493974074398,
-      -1.17382332277604896e-07, 3.09063830172817688e-06,
-      5.33983405657483665e-11 * 1. / (1_MeV), 0,
-      -4.30079426986170688e-07 * 1. / (1_MeV),
-      -1.2205651249153285e-09 * 1. / (1_MeV),
-      2.09396062746074539e-08 * 1. / (1_MeV),
-      5.33983405657483665e-11 * 1. / (1_MeV),
-      3.6832190075664073e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams193 = BoundParameters(tgContext, std::move(covMat193),
-                                        params193, perigeeSurface);
-  tracks.push_back(boundParams193);
-
-  // track 194 :
-  BoundVector params194;
-  params194 << -0.0635648146271705627, -14.7882223129272461,
-      -2.64156651496887207, 0.224920362234115601,
-      -0.000183147756615653634 * 1. / (1_MeV), 0;
-  Covariance covMat194;
-  covMat194 << 0.0120655400678515434, -0.0006910453838693592,
-      -0.000365977142399209201, -1.28533147920557146e-06,
-      -1.01339535493182776e-07 * 1. / (1_MeV), 0, -0.0006910453838693592,
-      0.273133754730224609, 3.06268979203341366e-05, 0.000393899454679768192,
-      -1.35539555434146533e-10 * 1. / (1_MeV), 0, -0.000365977142399209201,
-      3.06268979203341366e-05, 1.12705602077767253e-05, 5.48705815401846056e-08,
-      4.95433244701872377e-09 * 1. / (1_MeV), 0, -1.28533147920557146e-06,
-      0.000393899454679768192, 5.48705815401846056e-08, 5.77933633394422941e-07,
-      1.62498821676485166e-12 * 1. / (1_MeV), 0,
-      -1.01339535493182776e-07 * 1. / (1_MeV),
-      -1.35539555434146533e-10 * 1. / (1_MeV),
-      4.95433244701872377e-09 * 1. / (1_MeV),
-      1.62498821676485166e-12 * 1. / (1_MeV),
-      4.37339504888445418e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams194 = BoundParameters(tgContext, std::move(covMat194),
-                                        params194, perigeeSurface);
-  tracks.push_back(boundParams194);
-
-  // track 195 :
-  BoundVector params195;
-  params195 << -0.455407500267028809, 0.212499335408210754,
-      -2.02245116233825684, 2.88869571685791016,
-      0.000139400261105038226 * 1. / (1_MeV), 0;
-  Covariance covMat195;
-  covMat195 << 0.0228636190295219421, 0.00132628619103978239,
-      -0.000501410814590430576, -5.05350529972164141e-07,
-      -1.15052451624681027e-07 * 1. / (1_MeV), 0, 0.00132628619103978239,
-      0.374587059020996094, -1.18830711055222554e-05, 0.000496772398167388309,
-      -8.53100318867495256e-09 * 1. / (1_MeV), 0, -0.000501410814590430576,
-      -1.18830711055222554e-05, 1.15277352961129509e-05,
-      3.33864252437007874e-08, 3.65227707433702304e-09 * 1. / (1_MeV), 0,
-      -5.05350529972164141e-07, 0.000496772398167388309,
-      3.33864252437007874e-08, 6.9544324787784717e-07,
-      9.05586100425189466e-13 * 1. / (1_MeV), 0,
-      -1.15052451624681027e-07 * 1. / (1_MeV),
-      -8.53100318867495256e-09 * 1. / (1_MeV),
-      3.65227707433702304e-09 * 1. / (1_MeV),
-      9.05586100425189466e-13 * 1. / (1_MeV),
-      2.24803491793990062e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams195 = BoundParameters(tgContext, std::move(covMat195),
-                                        params195, perigeeSurface);
-  tracks.push_back(boundParams195);
-
-  // track 196 :
-  BoundVector params196;
-  params196 << 0.0801024585962295532, 22.3374137878417969, -1.32229578495025635,
-      2.88867521286010742, -0.000216519838431850076 * 1. / (1_MeV), 0;
-  Covariance covMat196;
-  covMat196 << 0.0681927874684333801, 0.00231532290305440673,
-      -0.00145939788550150835, 7.36670177096379346e-06,
-      -3.68450500773211916e-07 * 1. / (1_MeV), 0, 0.00231532290305440673,
-      1.3315422534942627, -0.000122508412210780388, 0.00171897979661990116,
-      1.76497106084476643e-08 * 1. / (1_MeV), 0, -0.00145939788550150835,
-      -0.000122508412210780388, 3.25632354361005127e-05,
-      -2.55214252507531063e-07, 1.09182558397378106e-08 * 1. / (1_MeV), 0,
-      7.36670177096379346e-06, 0.00171897979661990116, -2.55214252507531063e-07,
-      2.29971669796213973e-06, -1.84419314901396339e-12 * 1. / (1_MeV), 0,
-      -3.68450500773211916e-07 * 1. / (1_MeV),
-      1.76497106084476643e-08 * 1. / (1_MeV),
-      1.09182558397378106e-08 * 1. / (1_MeV),
-      -1.84419314901396339e-12 * 1. / (1_MeV),
-      6.27720861401392938e-11 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams196 = BoundParameters(tgContext, std::move(covMat196),
-                                        params196, perigeeSurface);
-  tracks.push_back(boundParams196);
+  // Test expected outcomes from athena implementation
+  // Number of reconstructed vertices
+  const int expNRecoVertices = 15;
+
+  // First vertex
+  const Vector3D expVtx1Pos(-0.0067_mm, 0.0060_mm, -6.0709_mm);
+  ActsSymMatrixD<3> expVtx1Cov;
+  expVtx1Cov << 0.000, 1.e-05, -8.e-05, 1.e-05, 0.000, -8.e-05, -8.e-05,
+      -8.e-05, 0.002;
+  std::vector<double> expVtx1TrkWeights{0.9796, 0.0334, 0.9884, 0.9697};
+  std::vector<double> expVtx1TrkComp{1.2542, 15.7317, 0.1144, 2.067};
+  std::vector<double> expVtx1TrkChi2{0, 0, 0, 0};
+
+  // Last vertex
+  const Vector3D expVtx15Pos(0.00264_mm, -0.0072_mm, -39.8197_mm);
+  ActsSymMatrixD<3> expVtx15Cov;
+  expVtx15Cov << 0.000, 1.e-06, 0.000, 1.e-06, 0.000, -6.e-05, 0.000, -6.e-05,
+      0.014;
+  std::vector<double> expVtx15TrkWeights{0.0048, 0.0005, 0.0236, 0.8481,
+                                         0.8924};
+  std::vector<double> expVtx15TrkComp{19.6561, 24.1389, 16.4425, 5.5604,
+                                      4.7683};
+  std::vector<double> expVtx15TrkChi2{0, 0, 0, 0};
+
+  // Vertex z positions of all found vertices
+  const std::vector<double> expAllVtxZPos{
+      -6.070_mm,   -12.0605_mm, -15.1093_mm, -27.6569_mm, -22.1054_mm,
+      -45.7010_mm, -5.0622_mm,  -26.5496_mm, -28.9597_mm, -37.7430_mm,
+      5.4828_mm,   -47.8939_mm, 2.5777_mm,   -0.2656_mm,  -39.8197_mm};
+
+  // Number of tracks of all vertices
+  const std::vector<int> expAllNTracks{4, 2, 3, 14, 5, 9, 8, 17,
+                                       7, 2, 2, 4,  2, 7, 5};
+
+  BOOST_CHECK_EQUAL(allVertices.size(), expNRecoVertices);
+
+  int count = 0;
+  for (const auto& vtx : allVertices) {
+    // Check vertex z positions
+    CHECK_CLOSE_ABS(vtx.position()[2], expAllVtxZPos[count], 0.003_mm);
+    // Check number of tracks
+    BOOST_CHECK_EQUAL(vtx.tracks().size(), expAllNTracks[count]);
+
+    // Check vertex 1 thoroughly
+    if (count == 0) {
+      CHECK_CLOSE_ABS(vtx.position(), expVtx1Pos, 0.001_mm);
+      CHECK_CLOSE_ABS(vtx.covariance(), expVtx1Cov, 0.001_mm);
+      int trkCount = 0;
+      for (const auto& trk : vtx.tracks()) {
+        CHECK_CLOSE_ABS(trk.trackWeight, expVtx1TrkWeights[trkCount], 0.01);
+        CHECK_CLOSE_ABS(trk.vertexCompatibility, expVtx1TrkComp[trkCount],
+                        0.15);
+        // CHECK_CLOSE_ABS(trk.chi2Track, expVtx1TrkChi2[trkCount], 0.001);
+        trkCount++;
+      }
+    }
 
-  // track 197 :
-  BoundVector params197;
-  params197 << 0.193900123238563538, -49.2524490356445312, 1.49366855621337891,
-      0.566030263900756836, -0.000631641771178692579 * 1. / (1_MeV), 0;
-  Covariance covMat197;
-  covMat197 << 0.0389422886073589325, 9.48181031765662076e-05,
-      -0.000864193462432249256, -6.76416801720607369e-06,
-      -2.91262857280178875e-07 * 1. / (1_MeV), 0, 9.48181031765662076e-05,
-      0.157681390643119812, 2.04442639286554837e-05, 0.000927270582484305585,
-      -1.8757136234213445e-08 * 1. / (1_MeV), 0, -0.000864193462432249256,
-      2.04442639286554837e-05, 2.00722697627497837e-05, 2.89773386592212807e-07,
-      8.81223262771924531e-09 * 1. / (1_MeV), 0, -6.76416801720607369e-06,
-      0.000927270582484305585, 2.89773386592212807e-07, 5.88341436014161445e-06,
-      -3.63880446087211061e-11 * 1. / (1_MeV), 0,
-      -2.91262857280178875e-07 * 1. / (1_MeV),
-      -1.8757136234213445e-08 * 1. / (1_MeV),
-      8.81223262771924531e-09 * 1. / (1_MeV),
-      -3.63880446087211061e-11 * 1. / (1_MeV),
-      1.12412849861964759e-10 * 1. / (1_MeV), 0, 0, 0, 0, 0, 0, 1;
-  auto boundParams197 = BoundParameters(tgContext, std::move(covMat197),
-                                        params197, perigeeSurface);
-  tracks.push_back(boundParams197);
+    // Check vertex 15 thoroughly
+    if (count == 14) {
+      CHECK_CLOSE_ABS(vtx.position(), expVtx15Pos, 0.001_mm);
+      CHECK_CLOSE_ABS(vtx.covariance(), expVtx15Cov, 0.001_mm);
+      int trkCount = 0;
+      for (const auto& trk : vtx.tracks()) {
+        CHECK_CLOSE_ABS(trk.trackWeight, expVtx15TrkWeights[trkCount], 0.01);
+        CHECK_CLOSE_ABS(trk.vertexCompatibility, expVtx15TrkComp[trkCount],
+                        0.15);
+        // CHECK_CLOSE_ABS(trk.chi2Track, expVtx15TrkChi2[trkCount], 0.001);
+        trkCount++;
+      }
+    }
 
-  return tracks;
+    count++;
+  }
 }
 
 }  // namespace Test
-- 
GitLab


From f043315efb97b42f4cf07b9cb748b3b7d29e39a7 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Fri, 28 Feb 2020 17:53:59 +0100
Subject: [PATCH 37/60] remove AMVF legacy code

---
 Core/include/Acts/Vertexing/legacy/AMVF.cxx | 1089 -------------------
 Core/include/Acts/Vertexing/legacy/AMVF.h   |  327 ------
 2 files changed, 1416 deletions(-)
 delete mode 100644 Core/include/Acts/Vertexing/legacy/AMVF.cxx
 delete mode 100644 Core/include/Acts/Vertexing/legacy/AMVF.h

diff --git a/Core/include/Acts/Vertexing/legacy/AMVF.cxx b/Core/include/Acts/Vertexing/legacy/AMVF.cxx
deleted file mode 100644
index e6b897bda..000000000
--- a/Core/include/Acts/Vertexing/legacy/AMVF.cxx
+++ /dev/null
@@ -1,1089 +0,0 @@
-/*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-
-
-/***************************************************************************
-                         InDetAdaptivePriVxFinderTool.cxx  -  Description
-                             -------------------
-    begin   : 29-05-2006
-    authors : Giacinto Piacquadio (Freiburg Univ),
-              this is a modified version of the adaptive primary vertex finder to fit more vertexes at the same time
-    changes :
-          06/12/2006   Kirill.Prokofiev@cern.ch
-          EDM cleanup and switching to the FitQuality use
-              2007-02-15  bug fix by scott s snyder  <snyder@bnl.gov>
-              Fix memory leak.  Don't use a map for sorting.
-              2007-10-xx  Giacinto Piacquadio
-                          Many improvements (MultiVertexFinder v. 2)
-              2016-03-09  D. Casper
-                          Change default value of TracksMaxZinterval to 1 mm
-                          (trial working point for high luminosities)
-
-***************************************************************************/
-#include "VxVertex/RecVertex.h"
-#include "VxVertex/Vertex.h"
-#include "InDetPriVxFinderTool/InDetAdaptiveMultiPriVxFinderTool.h"
-#include "TrkTrack/Track.h"
-#include "TrkParameters/TrackParameters.h"
-#include <map>
-#include <vector>
-
-#include "EventPrimitives/EventPrimitives.h"
-#include "EventPrimitives/EventPrimitivesHelpers.h"
-#include "GeoPrimitives/GeoPrimitives.h"
-
-#include "NN.h"
-#include "InDetTrackSelectionTool/IInDetTrackSelectionTool.h"
-
-
-#include "VxMultiVertex/MvfFitInfo.h"
-#include "VxMultiVertex/MVFVxTrackAtVertex.h"
-#include "VxMultiVertex/TrackToVtxLink.h"
-#include "AthContainers/DataVector.h"
-#include "TrkEventPrimitives/ParamDefs.h"
-#include "TrkVertexFitters/AdaptiveMultiVertexFitter.h"
-#include "TrkVertexFitterInterfaces/IVertexAnalyticSeedFinder.h"
-#include "TrkTrack/LinkToTrack.h"
-#include "TrkParticleBase/LinkToTrackParticleBase.h"
-#include "TrkLinks/LinkToXAODTrackParticle.h"
-
-#include "xAODTracking/Vertex.h"
-#include "xAODTracking/TrackParticle.h"
-#include "xAODTracking/VertexContainer.h"
-#include "xAODTracking/VertexAuxContainer.h"
-#include "xAODTracking/TrackParticleContainer.h"
-#include "xAODTracking/TrackParticleAuxContainer.h"
-
-#include <cmath>
-
-
-
-namespace InDet
-{
-  InDetAdaptiveMultiPriVxFinderTool::InDetAdaptiveMultiPriVxFinderTool(const std::string& t, const std::string& n,
-                                                                       const IInterface* p)
-    : AthAlgTool(t, n, p),
-    m_MultiVertexFitter("Trk::AdaptiveMultiVertexFitter"),
-    m_analyticSeedFinder("Trk::TrackDensitySeedFinder"),
-    m_trkFilter("InDet::InDetTrackSelection"),
-    m_useBeamConstraint(true),
-    m_TracksMaxZinterval(1.),
-    m_maxVertexChi2(18.42),
-    m_realMultiVertex(true),
-    m_useFastCompatibility(true),
-    m_selectiontype(0),
-    m_finalCutMaxVertexChi2(18.42),
-    m_cutVertexDependence(3.),
-    m_minweight(0.0001),
-    m_maxIterations(100),
-    m_testingclass(0),
-    m_addSingleTrackVertices(false),
-    m_do3dSplitting(false),
-    m_zBfieldApprox(0.60407),
-    m_maximumVertexContamination(0.5),
-    m_tracksMaxSignificance(5.),
-    m_useSeedConstraint(true)
-  {
-    declareInterface<IVertexFinder>(this);//by GP: changed from InDetMultiAdaptivePriVxFinderTool to IPriVxFinderTool
-    /* Retrieve StoreGate container and tool names from job options */
-    declareProperty("SeedFinder", m_analyticSeedFinder);
-    declareProperty("VertexFitterTool", m_MultiVertexFitter);
-    declareProperty("TrackSelector", m_trkFilter);
-
-    //finder options
-    declareProperty("TracksMaxZinterval", m_TracksMaxZinterval);
-    declareProperty("maxVertexChi2", m_maxVertexChi2);
-    declareProperty("finalCutMaxVertexChi2", m_finalCutMaxVertexChi2);
-    declareProperty("cutVertexDependence", m_cutVertexDependence);
-    declareProperty("MinWeight", m_minweight);
-    declareProperty("realMultiVertex", m_realMultiVertex);
-    declareProperty("useFastCompatibility", m_useFastCompatibility);
-    declareProperty("useBeamConstraint", m_useBeamConstraint);
-    declareProperty("addSingleTrackVertices", m_addSingleTrackVertices);
-    declareProperty("tracksMaxSignificance",m_tracksMaxSignificance);
-    declareProperty("m_useSeedConstraint",m_useSeedConstraint);
-    //********* signal vertex selection (for pile up) ****
-    declareProperty("selectiontype", m_selectiontype);
-    //==0 for sum p_t^2
-    //==1 for NN
-    //==2 for min bias compatibility estimation (in the future)
-    declareProperty("maxIterations", m_maxIterations);
-    declareProperty("do3dSplitting", m_do3dSplitting);
-    declareProperty("zBfieldApprox", m_zBfieldApprox);
-    declareProperty("maximumVertexContamination", m_maximumVertexContamination);
-    declareProperty( "IPEstimator", m_ipEstimator );
-
-  }
-
-  InDetAdaptiveMultiPriVxFinderTool::~InDetAdaptiveMultiPriVxFinderTool()
-  {}
-
-  StatusCode
-  InDetAdaptiveMultiPriVxFinderTool::initialize() {
-    /* Get the right vertex fitting tool */
-    ATH_CHECK(m_MultiVertexFitter.retrieve());
-
-    ATH_CHECK(m_analyticSeedFinder.retrieve());
-
-    ATH_CHECK(m_beamSpotKey.initialize());
-
-    ATH_CHECK(m_trkFilter.retrieve());
-
-    // since some parameters special to an inherited class this method
-    // will be overloaded by the inherited class
-    if (msgLvl(MSG::DEBUG)) printParameterSettings();
-
-    ATH_MSG_INFO("Initialization successful");
-    return StatusCode::SUCCESS;
-  }
-
-  namespace
-  {
-    struct xAODVertex_pair {
-      double first;
-      xAOD::Vertex* second;
-      xAODVertex_pair(double p1, xAOD::Vertex* p2)
-        : first(p1), second(p2) {}
-      bool
-      operator < (const xAODVertex_pair& other) const
-      {return first > other.first;}
-    };
-  } //anonymous namespace
-
-
-
-
-
-
-xAOD::Vertex::Decorator< Trk::MvfFitInfo* > MvfFitInfo("MvfFitInfo");
-    xAOD::Vertex::Decorator< bool > isInitialized("isInitialized");
-    xAOD::Vertex::Decorator< std::vector< Trk::VxTrackAtVertex* > > VTAV("VTAV");
-
-    if (m_selectiontype == 1) {//if you have to use NN, load the class
-      m_testingclass = new NN();//check later for MEMORY LEAK
-    }
-
-    //---- Start of preselection of tracks according to perigee parameters ---------------//
-    std::vector<const Trk::ITrackLink*> origTracks = trackVector;
-    std::vector<const Trk::ITrackLink*> seedTracks = trackVector;
-  
-    //now all tracks are in origTracks... std::vector<const Track*> origTracks;
-    std::vector<xAODVertex_pair> myxAODVertices;
-
-    std::vector<Trk::TrackToVtxLink*> myTrackToVtxLinks;
-
-    xAOD::VertexContainer* theVertexContainer = new xAOD::VertexContainer;
-    xAOD::VertexAuxContainer* theVertexAuxContainer = new xAOD::VertexAuxContainer;
-    theVertexContainer->setStore(theVertexAuxContainer);
-
-    Amg::Vector3D actualVertex;
-
-
-    std::map<const Trk::ITrackLink*, Trk::TrackToVtxLink*> TrackLinkOf;
-
-    //create a map between ITrackLink* and TrackToVtxLink*
-    std::vector<const Trk::ITrackLink*>::const_iterator trkbegin = origTracks.begin();
-    std::vector<const Trk::ITrackLink*>::const_iterator trkend = origTracks.end();
-
-
-    for (std::vector<const Trk::ITrackLink*>::const_iterator trkiter = trkbegin; trkiter != trkend; ++trkiter) {
-      Trk::TrackToVtxLink* newTrkToVtxLink(new Trk::TrackToVtxLink(new std::vector<xAOD::Vertex*>)); // makePrivateStore()
-                                                                                                     // is called for
-                                                                                                     // each vertex to
-                                                                                                     // add in iteration
-      TrackLinkOf[*trkiter] = newTrkToVtxLink;
-      myTrackToVtxLinks.push_back(newTrkToVtxLink);
-    }
-
-
-    //prepare iterators for tracks only necessary for seeding
-    std::vector<const Trk::ITrackLink*>::iterator seedtrkbegin = seedTracks.begin();
-    std::vector<const Trk::ITrackLink*>::iterator seedtrkend = seedTracks.end();
-    SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
-    int iteration = 0;
-
-  int nNoCompatibleTracks(0);
-  int nContamintationCut(0);
-  int nWithin3sigma(0);
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    unsigned int seedtracknumber = seedTracks.size();
-    do {
-      if (seedtracknumber == 0) {
-        ATH_MSG_DEBUG("No tracks available after track selection for seeding. No finding done.");
-        break;
-      }
-      iteration += 1;
-      ATH_MSG_DEBUG("Starting iteration number " << iteration << " with " << seedtracknumber << " seed tracks.");
-      //now use all the perigee parameters you have so far
-      if (m_realMultiVertex == true) {
-        trkbegin = origTracks.begin();
-        trkend = origTracks.end();
-      } else {
-        trkbegin = seedTracks.begin();
-        trkend = seedTracks.end();
-      }
-      std::vector<const Trk::TrackParameters*> perigeeList;
-      for (std::vector<const Trk::ITrackLink*>::iterator seedtrkAtVtxIter = seedtrkbegin;
-           seedtrkAtVtxIter != seedtrkend; ++seedtrkAtVtxIter) {
-        perigeeList.push_back((*seedtrkAtVtxIter)->parameters());
-      }
-      xAOD::Vertex* constraintVertex = 0;
-
-  // SEEDING START
-      
-      if (m_useBeamConstraint) {
-        constraintVertex = new xAOD::Vertex();
-        constraintVertex->makePrivateStore();
-        constraintVertex->setPosition(beamSpotHandle->beamVtx().position());
-        constraintVertex->setCovariancePosition(beamSpotHandle->beamVtx().covariancePosition());
-        constraintVertex->setFitQuality(beamSpotHandle->beamVtx().fitQuality().chiSquared(),
-                                        beamSpotHandle->beamVtx().fitQuality().doubleNumberDoF());
-        std::pair<Amg::Vector3D,Amg::MatrixX> seedConstraintVertex = m_analyticSeedFinder->findAnalyticSeed(perigeeList, constraintVertex);
-        actualVertex = seedConstraintVertex.first;
-        if(m_useSeedConstraint){
-          constraintVertex->setPosition(seedConstraintVertex.first);
-          constraintVertex->setCovariancePosition(seedConstraintVertex.second);
-        }
-      } else {
-        actualVertex = m_analyticSeedFinder->findSeed(perigeeList);
-        Amg::MatrixX looseConstraintCovariance(3, 3);
-        looseConstraintCovariance.setIdentity();
-        looseConstraintCovariance = looseConstraintCovariance * 1e+8;
-        constraintVertex = new xAOD::Vertex();
-        constraintVertex->makePrivateStore();
-        constraintVertex->setPosition(actualVertex);
-        constraintVertex->setCovariancePosition(looseConstraintCovariance);
-        constraintVertex->setFitQuality(0., -3.);
-      }
-      // TODO: memory leak here with theconstraint when the loop breaks?
-      if (actualVertex.z() == 0.) {
-        ATH_MSG_DEBUG("No seed found: no further primary vertex finding performed on this event");
-        ATH_MSG_DEBUG(perigeeList.size() << " tracks passed to seed finder, but no seed returned.");
-        // TODO: Do I need this?
-        delete constraintVertex;
-        constraintVertex = 0;
-        break;
-      }
-
-  // SEEDING END
-
-      //new xAOD::Vertex with this
-      xAOD::Vertex* actualcandidate = new xAOD::Vertex;
-      actualcandidate->makePrivateStore();
-      actualcandidate->setVertexType(xAOD::VxType::NotSpecified); // to mimic the initialization present in the old EDM                                                          // constructor
-      // now add decorations!
-      MvfFitInfo(*actualcandidate) = new Trk::MvfFitInfo(constraintVertex,
-                                                         new Amg::Vector3D(actualVertex),
-                                                         new Amg::Vector3D(actualVertex));
-      isInitialized(*actualcandidate) = false;
-      std::vector<Trk::VxTrackAtVertex*> vector_of_tracks(0);
-      VTAV(*actualcandidate) = vector_of_tracks; // TODO: maybe needed before push_back?
-      //now iterate on all tracks and find out if they are sufficiently close to the found vertex
-
-      ATH_MSG_VERBOSE("Adding tracks to the vertex candidate now");
-
-  // ADD COMPATIBLE TRACKS TO VTX CANDIDATE START
-
-      for (std::vector<const Trk::ITrackLink*>::const_iterator trkiter = trkbegin; trkiter != trkend; ++trkiter) {
-        if (std::fabs(estimateDeltaZ(*(*trkiter)->parameters(), actualVertex)) < m_TracksMaxZinterval) {
-          const double thisTracksSignificance = ipSignificance((*trkiter)->parameters(),&actualVertex); // calculate significance
-          if ( thisTracksSignificance<m_tracksMaxSignificance)
-          {
-            //accessing corresponding link to vertices
-            Trk::TrackToVtxLink* actuallink = TrackLinkOf[*trkiter];
-            std::vector<xAOD::Vertex*>* actualvtxlink = actuallink->vertices();
-            //adding vertex to candidates of track
-            actualvtxlink->push_back(actualcandidate);
-            ATH_MSG_VERBOSE("Adding an MVFVxTrackAtVertex with tracklink " << actuallink <<
-                            " to the vertex candidate VTAV decoration");
-            VTAV(*actualcandidate).push_back(new Trk::MVFVxTrackAtVertex((*trkiter)->clone(),
-                                                                         actuallink));
-          }
-        }
-      }
-      ATH_MSG_DEBUG(VTAV(*actualcandidate).size() << " tracks added to vertex candidate for IP significance less than " << m_tracksMaxSignificance << " within " << m_TracksMaxZinterval << " mm of seed position.");
-      //now consider to recovery from the case where no tracks were added to the vertex
-      if (VTAV(*actualcandidate).empty()) {
-        //you need to define a new seed (because the old one is probably in between two ones...)
-        double zdistance = 1e8;
-        const Trk::ITrackLink* nearestTrack = 0;
-        for (std::vector<const Trk::ITrackLink*>::const_iterator seedtrkiter = seedtrkbegin;
-             seedtrkiter != seedtrkend; ++seedtrkiter) {
-          if (std::fabs((*seedtrkiter)->parameters()->position()[Trk::z] - actualVertex.z()) < zdistance) {
-            zdistance = std::fabs((*seedtrkiter)->parameters()->position()[Trk::z] - actualVertex.z());
-            nearestTrack = *seedtrkiter;
-          }
-        }
-        if (nearestTrack) {
-          double newz = (nearestTrack->parameters())->position()[Trk::z];
-          xAOD::Vertex* oldcandidate = actualcandidate; // to placehold old pointers
-
-          actualVertex = Amg::Vector3D(0., 0., newz);
-          actualcandidate = new xAOD::Vertex();
-          actualcandidate->makePrivateStore();
-          actualcandidate->setVertexType(xAOD::VxType::NotSpecified); // to mimic the initialization present in the old
-                                                                      // EDM constructor
-          // TODO: Think about where everything is deleted! Does Trk::MvfFitInfo destructor and do MVFVxTrackAtVertex
-          // destructors get called when actualcandidate gets deleted?
-          // now add decorations!
-          MvfFitInfo(*actualcandidate) = new Trk::MvfFitInfo(new xAOD::Vertex(*constraintVertex),
-                                                             new Amg::Vector3D(actualVertex),
-                                                             new Amg::Vector3D(actualVertex));
-          isInitialized(*actualcandidate) = false;
-          VTAV(*actualcandidate) = vector_of_tracks; // TODO: maybe needed before push_back?
-         
-          releaseCandidate(oldcandidate);
-
-          for (std::vector<const Trk::ITrackLink*>::const_iterator trkiter = trkbegin; trkiter != trkend; ++trkiter) {
-
-              if (std::fabs(estimateDeltaZ(*(*trkiter)->parameters(), actualVertex)) < m_TracksMaxZinterval) {
-              const double thisTracksSignificance = ipSignificance((*trkiter)->parameters(),&actualVertex); // calculate significance
-              if ( thisTracksSignificance<m_tracksMaxSignificance)
-              {
-                //accessing corresponding link to vertices
-                Trk::TrackToVtxLink* actuallink = TrackLinkOf[*trkiter];
-                std::vector<xAOD::Vertex*>* actualvtxlink = actuallink->vertices();
-                //adding vertex to candidates of track
-                actualvtxlink->push_back(actualcandidate);
-                ATH_MSG_VERBOSE("Adding an MVFVxTrackAtVertex with tracklink " << actuallink <<
-                                " to the vertex candidate VTAV decoration");
-                VTAV(*actualcandidate).push_back(new Trk::MVFVxTrackAtVertex((*trkiter)->clone(),
-                                                                             actuallink));
-              }
-            }
-          }
-
-          if (VTAV(*actualcandidate).empty()) {
-            ATH_MSG_DEBUG("No tracks found near seed, while at least one track was expected.");
-            delete actualcandidate;
-            break;
-          }
-        } else {
-          ATH_MSG_DEBUG("Nearest track to seed is missing.");
-          delete actualcandidate;
-          break;
-        }
-      }
-
-  // ADD COMPATIBLE TRACKS TO VTX CANDIDATE END
-
-  // RUN FITTER START
-
-      ATH_MSG_VERBOSE("Running addVtxTofit(); The current candidate has " << VTAV(*actualcandidate).size() <<
-                      " tracks in the vector");
-      m_MultiVertexFitter->addVtxTofit(actualcandidate);
-      ATH_MSG_DEBUG("After fit the current candidate has z: " << actualcandidate->position()[Trk::z]);
-
-  // RUN FITTER END
-
-  // CHECK TRACKS/GOOD VTX AFTER FIT START
-
-      //get link to the tracks (they are now all properly in the std::vector<Trk::VxTrackAtVertex> of the xAOD::Vertex)
-      // TODO: maybe I shouldn't be using xAOD::Vertex vector at all for VxTrackAtVertex...
-      std::vector<Trk::VxTrackAtVertex*>::iterator trkAtVtxbegin = VTAV(*actualcandidate).begin();
-      std::vector<Trk::VxTrackAtVertex*>::iterator trkAtVtxend = VTAV(*actualcandidate).end();
-      //now check that there is at least one track added to the fit
-      //(this is not always the case because only tracks above a certain compatibility threshold are considered)
-      bool atleastonecompatibletrack = false;
-      int numberOfCompatibleTracks = 0;
-      for (std::vector<Trk::VxTrackAtVertex*>::iterator trkAtVtxIter = trkAtVtxbegin;
-           trkAtVtxIter != trkAtVtxend; ++trkAtVtxIter) {
-        ATH_MSG_VERBOSE("Compatibility: " << (*trkAtVtxIter)->vtxCompatibility() <<
-                        " weight " << (*trkAtVtxIter)->weight());
-
-
-        if (((*trkAtVtxIter)->vtxCompatibility() < m_maxVertexChi2 && m_useFastCompatibility) ||
-            ((*trkAtVtxIter)->weight() > m_minweight
-             && (*trkAtVtxIter)->trackQuality().chiSquared() < m_maxVertexChi2
-             && !m_useFastCompatibility)) {
-
-                  const Trk::ITrackLink* foundTrack = 0;
-                  for (std::vector<const Trk::ITrackLink*>::const_iterator seedtrkiter =
-                         seedtrkbegin; seedtrkiter != seedtrkend;
-                       ++seedtrkiter) {
-                    if ((*seedtrkiter)->parameters() == (*trkAtVtxIter)->trackOrParticleLink()->parameters()) {
-                      foundTrack = *seedtrkiter;
-                    }
-                  }
-                  if (foundTrack != 0) {
-                    atleastonecompatibletrack = true;
-                    numberOfCompatibleTracks += 1;
-                    ATH_MSG_VERBOSE("Found compatible track");
-                    if (m_addSingleTrackVertices) {
-                      if (m_useBeamConstraint) break;
-                      if (numberOfCompatibleTracks > 1 && (!m_useBeamConstraint)) break;
-                    } else {
-                      if (numberOfCompatibleTracks > 1) break;
-                    }
-                  }
-        }
-
-
-      }
-
-      bool newVertexIsFine = false;
-      if (m_addSingleTrackVertices) {
-        if (m_useBeamConstraint) {
-          if (numberOfCompatibleTracks > 0) {
-            newVertexIsFine = true;
-          }
-        } else {
-          if (numberOfCompatibleTracks > 1) {
-            newVertexIsFine = true;
-          }
-        }
-      } 
-
-
-
-      else {
-        if (numberOfCompatibleTracks > 1) {
-          newVertexIsFine = true;
-        }
-      }
-
-
-  // CHECK TRACKS/GOOD VTX AFTER FIT END
-
-  // REMOVE COMPATIBLE TRACKS FROM SEED START
-
-      ATH_MSG_VERBOSE("newVertexIsFine = " << newVertexIsFine);
-      //this now should be so powerful to do everything by itself
-      //problem now is to delete the really compatible tracks to this fit from the tracks
-      //which still remain to be fitted
-      if (atleastonecompatibletrack) {
-        for (std::vector<Trk::VxTrackAtVertex*>::iterator trkAtVtxIter = trkAtVtxbegin;
-             trkAtVtxIter != trkAtVtxend; ++trkAtVtxIter) {
-
-
-          //for now using the compatibility at stage before end...
-          ATH_MSG_VERBOSE("The compatibility value of the track " << *trkAtVtxIter <<
-                          " is " << (*trkAtVtxIter)->vtxCompatibility());
-          if (((*trkAtVtxIter)->vtxCompatibility() < m_maxVertexChi2 && m_useFastCompatibility) ||
-              ((*trkAtVtxIter)->weight() > m_minweight
-               && (*trkAtVtxIter)->trackQuality().chiSquared() < m_maxVertexChi2
-               && !m_useFastCompatibility)) {
-            ATH_MSG_VERBOSE("Eliminating incompatible track");
-
-            std::vector<const Trk::ITrackLink*>::iterator foundTrack = seedtrkend;
-            for (std::vector<const Trk::ITrackLink*>::iterator seedtrkiter = seedtrkbegin; seedtrkiter != seedtrkend;
-                 ++seedtrkiter) {
-              if ((*seedtrkiter)->parameters() == (*trkAtVtxIter)->trackOrParticleLink()->parameters()) {
-                foundTrack = seedtrkiter;
-              }
-            }
-            ATH_MSG_VERBOSE("Trying to find track now");
-            if (foundTrack != seedtrkend) {
-              ATH_MSG_VERBOSE("Track found: eliminating it");
-              seedTracks.erase(foundTrack);
-
-              //update end and begin??? should I? yes, he can copy, regenerate, you don't know!
-              seedtrkbegin = seedTracks.begin();
-              seedtrkend = seedTracks.end();
-
-              ATH_MSG_VERBOSE("Remaining seeds: " << seedTracks.size());
-            }
-          }
-
-
-
-        } // trackatvertex loop end
-      } 
-
-  // REMOVE COMPATIBLE TRACKS FROM SEED END
-
-  // NO COMPATIBLE TRACKS FOUND START
-
-
-      else {//no compatible track found...
-        //in this case put out the highest seeding track which didn't give any good result...
-        double highestcompatibility = 0;
-        Trk::VxTrackAtVertex* trackHighestCompatibility = 0;
-
-        ATH_MSG_VERBOSE("Analyzing new vertex");
-
-        for (std::vector<Trk::VxTrackAtVertex*>::iterator trkAtVtxIter = trkAtVtxbegin;
-             trkAtVtxIter != trkAtVtxend; ++trkAtVtxIter) {
-          ATH_MSG_VERBOSE("Checking new track for compatibility");
-          const Trk::ITrackLink* foundTrack = 0;
-          for (std::vector<const Trk::ITrackLink*>::const_iterator seedtrkiter =
-                 seedtrkbegin; seedtrkiter != seedtrkend;
-               ++seedtrkiter) {
-            if ((*seedtrkiter)->parameters() == (*trkAtVtxIter)->trackOrParticleLink()->parameters()) {
-              foundTrack = *seedtrkiter;
-            }
-          }
-          if (foundTrack != 0) {
-            double compatibility = (*trkAtVtxIter)->vtxCompatibility();
-            ATH_MSG_VERBOSE("New track has compatibility: " << compatibility);
-            if (compatibility > highestcompatibility) {
-              highestcompatibility = compatibility;
-              trackHighestCompatibility = *trkAtVtxIter;
-            }
-          }
-        }
-
-        
-        ATH_MSG_VERBOSE("Highest compatibility track:" << trackHighestCompatibility <<
-                        "with compatibility: " << highestcompatibility);
-        if (trackHighestCompatibility != 0) {
-          std::vector<const Trk::ITrackLink*>::iterator foundTrack = seedtrkend;
-          for (std::vector<const Trk::ITrackLink*>::iterator seedtrkiter = seedtrkbegin; seedtrkiter != seedtrkend;
-               ++seedtrkiter) {
-            if ((*seedtrkiter)->parameters() == trackHighestCompatibility->trackOrParticleLink()->parameters()) {
-              foundTrack = seedtrkiter;
-            }
-          }
-          if (foundTrack != seedtrkend) {
-            seedTracks.erase(foundTrack);
-            seedtrkbegin = seedTracks.begin();
-            seedtrkend = seedTracks.end();
-          } else {
-            ATH_MSG_FATAL("Cannot find previously determined track ");
-            throw;
-          }
-        } else {
-          //alternative method: delete seed track nearest in z to the seed
-          double zdistance = 1e8;
-          const Trk::ITrackLink* nearestTrack = 0;
-          for (std::vector<const Trk::ITrackLink*>::const_iterator seedtrkiter = seedtrkbegin;
-               seedtrkiter != seedtrkend; ++seedtrkiter) {
-            if (std::fabs((*seedtrkiter)->parameters()->position()[Trk::z] - actualVertex.z()) < zdistance) {
-              zdistance = std::fabs((*seedtrkiter)->parameters()->position()[Trk::z] - actualVertex.z());
-              nearestTrack = *seedtrkiter;
-            }
-          }
-          if (nearestTrack != 0) {
-            std::vector<const Trk::ITrackLink*>::iterator foundTrackToDelete =
-              std::find(seedtrkbegin, seedtrkend, nearestTrack);
-            if (foundTrackToDelete != seedtrkend) {
-              seedTracks.erase(foundTrackToDelete);
-              seedtrkbegin = seedTracks.begin();
-              seedtrkend = seedTracks.end();
-            } else {
-              ATH_MSG_DEBUG("No nearest track found while it was expected.");
-              break;
-            }
-          } else {
-            ATH_MSG_DEBUG("No further seeding track was found (3 methods used) while it was expected.");
-            break;
-          }
-        }
-      }
-
-  // NO COMPATIBLE TRACKS FOUND END
-
-  // DEAL WITH BAD VERTEX 1 START
-
-
-      ///////////////
-      //now break the cycle if you didn't diminish the number of seeds...
-      ATH_MSG_DEBUG("Remaining seeds: " << seedTracks.size() << " previous round " << seedtracknumber);
-      bool deleteLastVertex = false;
-      if (!newVertexIsFine) {
-        deleteLastVertex = true;
-        nNoCompatibleTracks++;
-        ATH_MSG_DEBUG("Vertex has no compatible tracks");
-      } 
-
-  // DEAL WITH BAD VERTEX 1 END
-
-  // DEAL WITH GOOD VERTEX 1 START
-
-      else {
-        double contamination = 0.;
-        double contaminationNum = 0;
-        double contaminationDeNom = 0;
-        std::vector<Trk::VxTrackAtVertex*>::iterator TRKtrkbegin(VTAV(*actualcandidate).begin());
-        std::vector<Trk::VxTrackAtVertex*>::iterator TRKtrkend(VTAV(*actualcandidate).end());
-        for (std::vector<Trk::VxTrackAtVertex*>::iterator TRKtrkiter = TRKtrkbegin; TRKtrkiter != TRKtrkend;
-             ++TRKtrkiter) {
-          double trackWeight = (*TRKtrkiter)->weight();
-          contaminationNum += trackWeight * (1. - trackWeight);
-          contaminationDeNom += trackWeight * trackWeight;
-        }
-        if (contaminationDeNom > 0) {
-          contamination = contaminationNum / contaminationDeNom;
-        }
-        if (contamination > m_maximumVertexContamination) {
-          ATH_MSG_VERBOSE(
-            "Contamination estimator " << contamination << " fails cut of " << m_maximumVertexContamination);
-          deleteLastVertex = true;
-          nContamintationCut++;
-          ATH_MSG_DEBUG("Vertex failed contamination cut");
-        }
-        //now try to understand if the vertex was merged with another one...
-        const auto & candidatePosition = actualcandidate->position();
-        const auto & candidateZPosition = candidatePosition[Trk::z];
-        const auto & candidatePositionCovariance = actualcandidate->covariancePosition();
-        const auto & candidateZPositionCovariance = candidatePositionCovariance(Trk::z, Trk::z);
-        for (const auto & thisVertex: myxAODVertices) {
-          const auto & thisVertexPosition = (thisVertex.second)->position();
-          const auto & thisVertexZPosition = thisVertexPosition[Trk::z];
-          const auto & thisVertexPositionCovariance = thisVertex.second->covariancePosition();
-          const auto & thisVertexZPositionCovariance = thisVertexPositionCovariance(Trk::z, Trk::z);
-          const auto deltaPosition = thisVertexPosition - candidatePosition;
-          const auto deltaZPosition = thisVertexZPosition - candidateZPosition;
-          const auto sumZCovSq = thisVertexZPositionCovariance + candidateZPositionCovariance;
-          
-          ATH_MSG_VERBOSE("Estimating compatibility of z positions: " << thisVertexZPosition <<" and " << candidateZPosition);
-          //in case of no beam spot constraint you should use the full 3d significance on the distance
-          double dependence = 0;
-          if (!m_do3dSplitting) {
-            if (sumZCovSq > 0. ){
-              dependence = std::fabs(deltaZPosition) / std::sqrt(sumZCovSq);
-            } else {
-              dependence = 0.;
-            }
-          } else {
-            Amg::MatrixX sumCovariances = thisVertexPositionCovariance + candidatePositionCovariance;
-            sumCovariances = sumCovariances.inverse().eval();
-            Amg::Vector3D hepVectorPosition;
-            hepVectorPosition[0] = deltaPosition.x();
-            hepVectorPosition[1] = deltaPosition.y();
-            hepVectorPosition[2] = deltaPosition.z();
-            dependence = std::sqrt(hepVectorPosition.dot(sumCovariances * hepVectorPosition));
-          }
-          ATH_MSG_VERBOSE("Significance of vertex pair is: " << dependence << "vs. cut at " << m_cutVertexDependence);
-          if (dependence < m_cutVertexDependence) {
-            ATH_MSG_VERBOSE("Deleting last vertex since it was found to be merged with another!");
-            deleteLastVertex = true;
-            nWithin3sigma++;
-            ATH_MSG_DEBUG("Vertex failed significance (cut vertex dependence) test");
-            break;
-          }
-        }
-      }
-      ATH_MSG_VERBOSE("Decision to delete last vertex: " << deleteLastVertex);
-
-  // DEAL WITH GOOD VERTEX 1 END
-
-  // DELETE BAD VERTEX START
-
-
-      ////////////
-      //Ok all tracks in seed were deleted. You can go ahead and discover further vertices...
-      //please clean the track to vertices links before (required by real multivertexfit)
-      if (deleteLastVertex) {
-        std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkAtVtxBegin = VTAV(*actualcandidate).begin();
-        std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkAtVtxEnd = VTAV(*actualcandidate).end();
-        for (std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkIterator = MVFtrkAtVtxBegin;
-             MVFtrkIterator != MVFtrkAtVtxEnd; ++MVFtrkIterator) {
-          ATH_MSG_VERBOSE("Deleting one vertex from tracklink " <<
-                          (static_cast<Trk::MVFVxTrackAtVertex*>(*MVFtrkIterator))->linkToVertices());
-          (static_cast<Trk::MVFVxTrackAtVertex*>(*MVFtrkIterator))->linkToVertices()->vertices()->pop_back();
-        }
-        seedtracknumber = seedTracks.size();
-        ATH_MSG_VERBOSE("Redoing fit after scrapping last vertex");
-        m_MultiVertexFitter->addVtxTofit(actualcandidate); // TODO: I think this is fine still, but think about it more
-        releaseCandidate(actualcandidate);
-      } 
-
-  // DELETE BAD VERTEX START
-
-  // SAVE GOOD VERTEX START
-
-      else {
-        seedtracknumber = seedTracks.size();
-        ATH_MSG_VERBOSE("Storing new vertex with " << actualcandidate->vxTrackAtVertex().size() << " tracks");
-        myxAODVertices.push_back(xAODVertex_pair(0,actualcandidate));
-      }
-  // SAVE GOOD VERTEX END
-    } while ((
-               (m_addSingleTrackVertices && seedTracks.size() > 0) ||
-               ((!m_addSingleTrackVertices) && seedTracks.size() > 1))
-             && iteration < m_maxIterations);
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    if (iteration >= m_maxIterations) {
-      ATH_MSG_WARNING("Maximum number of iterations (" << m_maxIterations <<
-                      ") reached; to reconstruct more vertices, set maxIterations to a higher value.");
-    }
-
-  ATH_MSG_DEBUG("Vertices deleted for no compatible tracks: " << nNoCompatibleTracks);
-  ATH_MSG_DEBUG("Vertices deleted for contamination cut: " << nContamintationCut);
-  ATH_MSG_DEBUG("Vertices deleted for proximity to previous: " << nWithin3sigma);
-
-    ATH_MSG_DEBUG("Primary vertex finding complete with " << iteration <<
-                  " iterations and " << myxAODVertices.size() << " vertices found.");
-
-    //correction of a bug: you can estimate the probability of being
-    //the primary interaction vertex only after the whole multivertexfit
-    //is finished!!! (the first is influenced by the fit of the second and so
-    //on...)
-    std::vector<xAODVertex_pair>::iterator vtxBegin = myxAODVertices.begin();
-    std::vector<xAODVertex_pair>::iterator vtxEnd = myxAODVertices.end();
-    // To make sure that the right tracks are in the std::vector<Trk::VxTrackAtVertex> of each vertex - up until now,
-    // they are kept in the VTAV decoration
-    for (std::vector<xAODVertex_pair>::iterator vtxIter = vtxBegin; vtxIter != vtxEnd; ++vtxIter) {
-      xAOD::Vertex* cand = vtxIter->second;
-      std::vector<Trk::VxTrackAtVertex>* tracksOfVertex = &(cand->vxTrackAtVertex());
-      tracksOfVertex->clear();
-      std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkBegin = VTAV(*cand).begin();
-      std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkEnd = VTAV(*cand).end();
-      for (std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkIter = MVFtrkBegin; MVFtrkIter != MVFtrkEnd;
-           ++MVFtrkIter) {
-        tracksOfVertex->push_back(**MVFtrkIter);
-      }
-    }
-    //before filling the container, you have to decide what is your most probable signal vertex
-    for (std::vector<xAODVertex_pair>::iterator vtxIter = vtxBegin; vtxIter != vtxEnd; ++vtxIter) {
-      (*vtxIter).first = estimateSignalCompatibility((*vtxIter).second);
-    }
-    std::sort(myxAODVertices.begin(), myxAODVertices.end());
-    if (msgLvl(MSG::VERBOSE)) {
-      ATH_MSG_VERBOSE("Vertex positions after sorting");
-      for (std::vector<xAODVertex_pair>::iterator vtxIter = vtxBegin; vtxIter != vtxEnd; ++vtxIter) {
-        ATH_MSG_VERBOSE("z position: " << (*vtxIter).second->position().z());
-      }
-    }
-    if (myxAODVertices.size() == 0) {
-      ATH_MSG_WARNING("No vertices found: returning a place-holder at the beam spot center.");
-      xAOD::Vertex* beamspotCandidate = new xAOD::Vertex;
-      beamspotCandidate->makePrivateStore();
-      beamspotCandidate->setPosition(beamSpotHandle->beamVtx().position());
-      beamspotCandidate->setCovariancePosition(beamSpotHandle->beamVtx().covariancePosition());
-      beamspotCandidate->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
-      // TODO: I don't need to set fitQuality too do I?
-      myxAODVertices.push_back(xAODVertex_pair(0, beamspotCandidate));
-    }
-    vtxBegin = myxAODVertices.begin();
-    vtxEnd = myxAODVertices.end();
-    for (std::vector<xAODVertex_pair>::const_iterator vtxIter = vtxBegin; vtxIter != vtxEnd; ++vtxIter) {
-      xAOD::Vertex* cand = vtxIter->second;
-      std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkBegin = VTAV(*cand).begin();
-      std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkEnd = VTAV(*cand).end();
-      // TODO: here, I must clean up VTAV decoration separately from vector of VxTrackAtVertex
-      for (std::vector<Trk::VxTrackAtVertex*>::iterator MVFtrkIter = MVFtrkBegin; MVFtrkIter != MVFtrkEnd;
-           ++MVFtrkIter) {
-        //setting link to TrackToVtxLink to 0 (all TrackToVtxLink will be deleted some lines later)
-        (static_cast<Trk::MVFVxTrackAtVertex*>(*MVFtrkIter))->setLinkToVertices(0);
-        delete *MVFtrkIter;
-        *MVFtrkIter = 0;
-      }
-      //delete VTAV( *cand );
-      delete MvfFitInfo(*cand);
-      std::vector<Trk::VxTrackAtVertex>::iterator trkAtVtxBegin = cand->vxTrackAtVertex().begin();
-      std::vector<Trk::VxTrackAtVertex>::iterator trkAtVtxEnd = cand->vxTrackAtVertex().end();
-      for (std::vector<Trk::VxTrackAtVertex>::iterator trkAtVtxIter = trkAtVtxBegin; trkAtVtxIter != trkAtVtxEnd; ) {//++trkAtVtxIter)                                                                                            // {
-        //cleaning up incompatible vertices
-        if (((*trkAtVtxIter).vtxCompatibility() > m_maxVertexChi2 && m_useFastCompatibility) ||
-            (((*trkAtVtxIter).weight() < m_minweight
-              || (*trkAtVtxIter).trackQuality().chiSquared() > m_maxVertexChi2)
-             && !m_useFastCompatibility)) {
-          trkAtVtxIter = cand->vxTrackAtVertex().erase(trkAtVtxIter);
-          trkAtVtxEnd = cand->vxTrackAtVertex().end();
-        } else {
-          ++trkAtVtxIter;
-        }
-      }
-      theVertexContainer->push_back(cand);
-    }
-    // If track links are to xAOD::TrackParticles, set the links directly in xAOD::Vertex with their weights
-    // Needed for weight calculator in sorting tool
-    xAOD::VertexContainer::iterator vxBegin = theVertexContainer->begin();
-    xAOD::VertexContainer::iterator vxEnd = theVertexContainer->end();
-    for (xAOD::VertexContainer::iterator vxIter = vxBegin; vxIter != vxEnd; ++vxIter) {
-      std::vector<Trk::VxTrackAtVertex>* myVxTracksAtVtx = &((*vxIter)->vxTrackAtVertex());
-      if (!myVxTracksAtVtx) continue;
-      std::vector<Trk::VxTrackAtVertex>::iterator tracksBegin = myVxTracksAtVtx->begin();
-      std::vector<Trk::VxTrackAtVertex>::iterator tracksEnd = myVxTracksAtVtx->end();
-      for (std::vector<Trk::VxTrackAtVertex>::iterator tracksIter = tracksBegin;
-           tracksIter != tracksEnd; ++tracksIter) {
-        // only set link if track link is to an xAOD::TrackParticle
-        Trk::LinkToXAODTrackParticle* linkToXAODTP =
-          dynamic_cast<Trk::LinkToXAODTrackParticle*>((*tracksIter).trackOrParticleLink());
-        if (linkToXAODTP) {
-          ATH_MSG_VERBOSE("Iterating over new vertex in fixing xAOD::TrackParticle links... ");
-          (*vxIter)->addTrackAtVertex(*linkToXAODTP, (*tracksIter).weight());
-        } // TODO: esle write in a warning? (if tracks were TrkTracks or Trk::TrackParticleBase) - sorting tool expects
-          // there to be xAOD::TrackParticleLinks!
-      }
-    }
-    if (m_selectiontype == 1 && m_testingclass != 0) delete m_testingclass;
-    std::vector<Trk::TrackToVtxLink*>::iterator begin = myTrackToVtxLinks.begin();
-    std::vector<Trk::TrackToVtxLink*>::iterator end = myTrackToVtxLinks.end();
-    //delete all TrackToVtxLink objects
-    for (std::vector<Trk::TrackToVtxLink*>::iterator iterator = begin; iterator != end; ++iterator) {
-      delete *iterator;
-    }
-    //---- add dummy vertex at the end ------------------------------------------------------//
-    //---- if one or more vertices are already there: let dummy have same position as primary vertex
-    if (theVertexContainer->size() >= 1) {
-      xAOD::Vertex* primaryVtx = theVertexContainer->front();
-      if (primaryVtx->vxTrackAtVertex().size() > 0) {
-        primaryVtx->setVertexType(xAOD::VxType::PriVtx);
-        xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
-        theVertexContainer->push_back(dummyxAODVertex); // have to add vertex to container here first so it can use its
-                                                        // aux store
-        dummyxAODVertex->setPosition(primaryVtx->position());
-        dummyxAODVertex->setCovariancePosition(primaryVtx->covariancePosition());
-        dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
-        dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
-      } else {
-        primaryVtx->setVertexType(xAOD::VxType::NoVtx);
-      }
-    }
-    //---- if no vertex is there let dummy be at beam spot
-    else if (theVertexContainer->size() == 0) {
-      xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
-      theVertexContainer->push_back(dummyxAODVertex); // have to add vertex to container here first so it can use its
-                                                      // aux store
-      dummyxAODVertex->setPosition(beamSpotHandle->beamVtx().position());
-      dummyxAODVertex->setCovariancePosition(beamSpotHandle->beamVtx().covariancePosition());
-      dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
-      dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
-    }
-    // loop over the pile up to set it as pile up (EXCLUDE first and last vertex: loop from 1 to size-1)
-    for (unsigned int i = 0; i < theVertexContainer->size() - 1; i++) {
-      if (i > 0) {
-        (*theVertexContainer)[i]->setVertexType(xAOD::VxType::PileUp);
-      }
-      ATH_MSG_VERBOSE("Vertex at z =" << (*theVertexContainer)[i]->position().z() <<
-                      " with ntracks: " << (*theVertexContainer)[i]->vxTrackAtVertex().size());
-    }
-    return std::make_pair(theVertexContainer, theVertexAuxContainer);
-  }
-
-  double
-  InDetAdaptiveMultiPriVxFinderTool::estimateSignalCompatibility(xAOD::Vertex* mycand) {
-    // TODO: put this in a better place
-    // Prepare objects holding the decoration of xAOD::Vertex with MVF auxdata
-    // For optimization of access speed
-    xAOD::Vertex::Decorator< std::vector<Trk::VxTrackAtVertex*> > VTAV("VTAV");
-
-    std::vector<Trk::VxTrackAtVertex*>::iterator begintracks = VTAV(*mycand).begin();
-    std::vector<Trk::VxTrackAtVertex*>::iterator endtracks = VTAV(*mycand).end();
-
-    if (m_selectiontype == 0) {
-      //use just sum over pt squared
-      //first get all the variables you need for to discriminate between signal and minimum bias event
-
-      double total_pt_squared = 0;
-      int total_num_tracks = 0;
-
-      for (std::vector<Trk::VxTrackAtVertex*>::iterator i = begintracks; i != endtracks; i++) {
-        ATH_MSG_VERBOSE("Compatibility is: " << (*i)->vtxCompatibility() <<
-                        " and chi^2 is: " << (*i)->trackQuality().chiSquared());
-
-        if (((*i)->vtxCompatibility() < m_finalCutMaxVertexChi2 && m_useFastCompatibility) ||
-            ((*i)->weight() > m_minweight
-             && (*i)->trackQuality().chiSquared() < m_finalCutMaxVertexChi2
-             && !m_useFastCompatibility)) {
-          const Trk::TrackParameters* perigee(0);
-          if ((*i)->perigeeAtVertex() != 0) {
-            perigee = (*i)->perigeeAtVertex();
-          } else {
-            ATH_MSG_VERBOSE("Only initialPerigee is available");
-            perigee = (*i)->initialPerigee();
-          }
-          if (perigee == 0) {
-            ATH_MSG_ERROR("Neutrals are not supported. Skipping track in pT calculation...");
-            continue;
-          }
-          total_pt_squared +=
-            std::pow(std::fabs(1. / perigee->parameters()[Trk::qOverP]) * sin(perigee->parameters()[Trk::theta]), 2);
-          total_num_tracks += 1;
-        }
-      }//finishing iterating on VxTrackAtVertex associated to **vtxIter xAOD::Vertex
-
-      return total_pt_squared * std::sqrt((double) total_num_tracks);
-    } else if (m_selectiontype == 1) {//use NN
-      double pt_track1 = 0.;
-      double pt_track2 = 0.;
-      double pt_track3 = 0.;
-      double pt_sum_linear = 0.;
-      double pt_sum_quadratic = 0.;
-
-      int total_num_tracks = 0;
-      int prognumber = 0;
-
-      for (std::vector<Trk::VxTrackAtVertex*>::iterator i = begintracks; i != endtracks; i++) {
-        if (((*i)->vtxCompatibility() < m_finalCutMaxVertexChi2 && m_useFastCompatibility) ||
-            ((*i)->weight() > m_minweight
-             && (*i)->trackQuality().chiSquared() < m_finalCutMaxVertexChi2
-             && !m_useFastCompatibility)) {
-          const Trk::TrackParameters* perigee(0);
-          if ((*i)->perigeeAtVertex() != 0) {
-            perigee = (*i)->perigeeAtVertex();
-          } else {
-            ATH_MSG_VERBOSE("Only initialPerigee is available");
-            perigee = (*i)->initialPerigee();
-          }
-          if (perigee == 0) {
-            ATH_MSG_ERROR("Neutrals not supported. Skipping track in pT calculation...");
-            continue;
-          }
-          double actualpt(std::fabs(1. / perigee->parameters()[Trk::qOverP]) * sin(perigee->parameters()[Trk::theta]));
-          pt_sum_quadratic += std::pow(actualpt, 2);
-          pt_sum_linear += actualpt;
-          if (prognumber == 0) {
-            pt_track1 = actualpt;
-            prognumber += 1;
-          } else if (prognumber == 1) {
-            pt_track2 = actualpt;
-            prognumber += 1;
-          } else if (prognumber == 2) {
-            pt_track3 = actualpt;
-            prognumber += 1;
-          }
-          total_num_tracks += 1;
-        }
-      }
-      if (total_num_tracks == 0 || pt_track2 == 0 || pt_track3 == 0) {
-        return 0.;
-      } else {
-        return m_testingclass->value(0, pt_track1, pt_track2, pt_track3,
-                                     pt_sum_linear, pt_sum_quadratic,
-                                     total_num_tracks);
-      }
-    }
-    return 0;
-  }
-
-  StatusCode
-  InDetAdaptiveMultiPriVxFinderTool::finalize() {
-    return StatusCode::SUCCESS;
-  }
-
-  void
-  InDetAdaptiveMultiPriVxFinderTool::printParameterSettings() {
-    ATH_MSG_DEBUG("Adaptive Multi-Vertex Finder: Parameter settings ");
-    ATH_MSG_DEBUG("Trackselection cuts handled by the TrackSelectorTool: " << m_trkFilter);
-    ATH_MSG_DEBUG("Finder settings: ");
-    ATH_MSG_DEBUG(
-      "Maximum distance to include track in simultaneous vertex fits: TracksMaxZinterval " << m_TracksMaxZinterval);
-    ATH_MSG_DEBUG("Seeding: minimum chi^2 for a track being an outlier:  maxVertexChi2 " << m_maxVertexChi2);
-    ATH_MSG_DEBUG("Signal identification: final cut on track chi2: finalCutMaxVertexChi2 = " <<
-    m_finalCutMaxVertexChi2);
-    ATH_MSG_DEBUG("Activate complete multi vertex fitting feature: realMultiVertex " << m_realMultiVertex);
-    ATH_MSG_DEBUG("Merging vertices: upper cut on significance to merge two vertices: cutVertexDependence = " <<
-                  m_cutVertexDependence);
-    ATH_MSG_DEBUG("Maximum number of iterations (and vertices): maxIterations = " << m_maxIterations);
-    ATH_MSG_DEBUG("Selection type (0 is sqrt(Ntr)*Sum_{tr} pT^2): selectiontype = " << m_selectiontype);
-    ATH_MSG_DEBUG("Use fast compatibility (if false use refitted chi2 instead of approximation): useFastCompatibility = " <<
-                  m_useFastCompatibility);
-    ATH_MSG_DEBUG("MinWeight (if track weight in the fit is lower, don't perform the Kalman Update) = " << m_minweight);
-    ATH_MSG_DEBUG("");
-  }
-
-  void
-  InDetAdaptiveMultiPriVxFinderTool::SGError(std::string errService) {
-    ATH_MSG_FATAL(errService << " not found. Exiting !");
-  }
-
-  double
-  InDetAdaptiveMultiPriVxFinderTool::estimateDeltaZ(const Trk::TrackParameters& myPerigee,
-                                                    const Amg::Vector3D& myTransvVertex) {
-    Amg::Vector3D lp = myTransvVertex;
-
-    Amg::Vector3D expPoint;
-    Amg::Vector3D predStatePosition = myPerigee.position();
-    expPoint[0] = predStatePosition.x();
-    expPoint[1] = predStatePosition.y();
-    expPoint[2] = predStatePosition.z();
-
-    //phi_v and functions
-    double phi_v = myPerigee.parameters()[Trk::phi];
-    double th = myPerigee.parameters()[Trk::theta];
-    double tan_th = std::tan(th);
-    double sin_phi_v = std::sin(phi_v);
-    double cos_phi_v = std::cos(phi_v);
-    double q_ov_p = myPerigee.parameters()[Trk::qOverP];
-
-    //momentum
-    Amg::Vector3D expMomentum;
-    expMomentum[0] = phi_v;
-    expMomentum[1] = th;
-    expMomentum[2] = q_ov_p;
-
-    double X = expPoint[0] - lp.x();
-    double Y = expPoint[1] - lp.y();
-
-    return expPoint[2] - lp.z() - 1. / tan_th * (X * cos_phi_v + Y * sin_phi_v);
-  }
-
-  double InDetAdaptiveMultiPriVxFinderTool::ipSignificance( const Trk::TrackParameters* params, 
-                                                 const Amg::Vector3D * vertex ) const
-  {
-    xAOD::Vertex v;
-    v.makePrivateStore();
-    v.setPosition(*vertex);
-    v.setCovariancePosition(AmgSymMatrix(3)::Zero(3,3));
-    v.setFitQuality(0., 0.);
-
-    double significance = 0.0;
-    const Trk::ImpactParametersAndSigma* ipas = m_ipEstimator->estimate( params, &v );
-    if ( ipas != nullptr )
-    {  
-      if ( ipas->sigmad0 > 0 && ipas->sigmaz0 > 0)
-      {
-  significance = std::sqrt( std::pow(ipas->IPd0/ipas->sigmad0,2) + std::pow(ipas->IPz0/ipas->sigmaz0,2) );
-      }
-      delete ipas;
-    }
-    return significance;
-  }
-
-  void
-  InDetAdaptiveMultiPriVxFinderTool::releaseCandidate(xAOD::Vertex*& candidate) {
-    if (candidate == nullptr) return;
-
-    // decorators
-    xAOD::Vertex::Decorator< Trk::MvfFitInfo* > MvfFitInfo("MvfFitInfo");
-    xAOD::Vertex::Decorator< std::vector< Trk::VxTrackAtVertex* > > VTAV("VTAV");
-
-    if (VTAV.isAvailable(*candidate)) {
-      for (auto tav : VTAV(*candidate)) {
-        if (tav == nullptr) continue;
-        (static_cast<Trk::MVFVxTrackAtVertex*>(tav))->setLinkToVertices(nullptr);
-        delete tav;
-        tav = nullptr;
-      }
-      VTAV(*candidate).clear();
-    }
-
-    if (MvfFitInfo.isAvailable(*candidate) && MvfFitInfo(*candidate) != nullptr) {
-      delete MvfFitInfo(*candidate);
-      MvfFitInfo(*candidate) = nullptr;
-    }
-
-    delete candidate;
-    candidate = nullptr;
-  }
-
diff --git a/Core/include/Acts/Vertexing/legacy/AMVF.h b/Core/include/Acts/Vertexing/legacy/AMVF.h
deleted file mode 100644
index ce186b1ef..000000000
--- a/Core/include/Acts/Vertexing/legacy/AMVF.h
+++ /dev/null
@@ -1,327 +0,0 @@
-/*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-/**
- * @class InDet::InDetAdaptiveMultiPriVxFinderTool
- *
- * @author Giacinto Piacquadio (Freiburg University)
- * 
- * (giacinto.piacquadio@physik.uni-freiburg.de)
- * 
- * This class provides an implementation for a primary 
- * vertex finding tool, which uses the \<i\>Adaptive MultiVertex\</i\> 
- * Fitter to solve the problem of finding the multiple 
- * interaction vertices and to find out the best possible 
- * assignment of the track to the vertices.
- *
- * The steps done are the following:
- * - the selection cuts are applied
- * 
- * then iteratively:
- * - a new vertex is seeded with the remaining tracks
- *    (the seed finder is used)
- * - all the tracks whose Z at PCA is closer to the seeded 
- *    vertex by more than TracksMaxZinterval (by JobOption), 
- *    are added to the new vertex candidate
- * -  the new vertex candidate is added on top of the previous fit and 
- *    the AdaptiveMultiVertexFitter is used to fit all them 
- *    together (more information in the \<br\>\<i\>TrkVertexFitters\</br\>\</i\>
- *    package).
- * -  the tracks already used are removed from the tracks 
- *    from which the next seed would be obtained and if there 
- *    are more than 2 left, a new iteration is started.
- *
- * when no more than 2 seeding tracks are left:
- * - a vector of MVFVxCandidate is provided as result and 
- *   according to the selection type, the order in which it is 
- *   provided represents how high the probability of that 
- *   particular vertex to come from the primary vertex is. 
- *
- * In general the first VxCandidate* in the collection is 
- * the one with highest sqrt(N_tracks)*Sum Pt_track^2. This 
- * is the case if the selectiontype in the jobOptions is set 
- * to 0 (default).
- *
- *
- * This finder is particularly suited for the high luminosities 
- * scenarios which will came up at LHC.
- *
- * ------------------------------------------------------------
- * Changes:
- *
- * David Shope <david.richard.shope@cern.ch> (2016-04-19)
- *
- * EDM Migration to xAOD - from Trk::VxCandidate to xAOD::Vertex, 
- *                         from Trk::RecVertex   to xAOD::Vertex,
- *                         from Trk::Vertex      to Amg::Vector3D
- *
- * Also, VxMultiVertex EDM has been migrated to the following:
- *
- *   Trk::MvfFitInfo  
- *     constraintVertex     now uses xAOD::Vertex
- *     seedVertex           now uses Amg::Vector3D
- *     linearizationVertex  now uses Amg::Vector3D
- *
- *   Trk::TrackToVtxLink
- *     Vertex objects stored using this class are now xAOD::Vertex
- *
- * Instead of using the MVFVxCandidate class, xAOD::Vertex is employed by decorating it
- * with the multi-vertex information:
- *
- *   bool                              isInitialized
- *   MvfFitInfo*                       MvfFitInfo
- *   std::Vector\<VxTrackAtVertex*\>     VTAV
- *
- *   This last decoration is needed in order to be able to use MVFVxTrackAtVertex objects
- *   which have the additional information of xAOD::Vertices associated to the track
- *   and (through polymorphism) to still be able to pass them to the KalmanVertexUpdator as
- *   VxTracksAtVertex objects.
- */
-
-#ifndef INDETPRIVXFINDERTOOL_INDETADAPTIVEMULTIPRIVXFINDERTOOL_H
-#define INDETPRIVXFINDERTOOL_INDETADAPTIVEMULTIPRIVXFINDERTOOL_H
-
-#include "InDetRecToolInterfaces/IVertexFinder.h"
-#include "AthenaBaseComps/AthAlgTool.h"
-#include "GaudiKernel/ToolHandle.h"
-#include "GaudiKernel/ServiceHandle.h"
-#include "TrkTrack/TrackCollection.h" // type def ...
-#include "TrkParticleBase/TrackParticleBaseCollection.h"
-#include "TrkParameters/TrackParameters.h"
-
-/**
- * Forward declarations 
- */
-#include "xAODTracking/VertexFwd.h"
-#include "xAODTracking/TrackParticleFwd.h"
-#include "xAODTracking/VertexContainerFwd.h"
-#include "xAODTracking/TrackParticleContainerFwd.h"
-#include "BeamSpotConditionsData/BeamSpotData.h"
-#include "TrkVertexFitterInterfaces/ITrackToVertexIPEstimator.h"
-class TrackToVtxLinkContainer;
-class NN;
-
-
-namespace Trk
-{
-  class IVertexAnalyticSeedFinder;
-  class AdaptiveMultiVertexFitter;
-  class Track;
-  class ITrackLink;
-  class TrkQuality;
-  class IVxCandidateXAODVertex;
-}
-
-
-namespace InDet
-{
-  class IInDetTrackSelectionTool;
-
- class InDetAdaptiveMultiPriVxFinderTool : public AthAlgTool, virtual public IVertexFinder
- {
- 
-  public:
-    
-    InDetAdaptiveMultiPriVxFinderTool(const std::string& t, const std::string& n, const IInterface*  p);
-    virtual ~InDetAdaptiveMultiPriVxFinderTool();
-   
-    StatusCode initialize();
-
-    /**
-     * The MultiVertexFinding is performed.
-     *
-     * Input is the Track Collection. Output is the VertexContainer 
-     * with a list of fitted vertices, according to the probability 
-     * of being the primary interaction point.
-     * 
-     * Description of the finder is provided as doxygen info on the class.
-     *
-     */
-
-    std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*> findVertex(const TrackCollection* trackTES);
-    std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*> findVertex(const Trk::TrackParticleBaseCollection* trackTES);
-    std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*> findVertex(const xAOD::TrackParticleContainer* trackParticles);
-
-    StatusCode finalize();
-    
-  private:
-
-    std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*> findVertex(const std::vector<const Trk::ITrackLink*> & trackVector);
-  
-    void SGError(std::string errService);
-    virtual void printParameterSettings();
-
-    ToolHandle< Trk::AdaptiveMultiVertexFitter > m_MultiVertexFitter;
-    ToolHandle< Trk::IVertexAnalyticSeedFinder > m_analyticSeedFinder;
-    ToolHandle< InDet::IInDetTrackSelectionTool > m_trkFilter;
-
-    SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };
-
-    /** Define a beam constraint for the fit */
-    bool m_useBeamConstraint; //!<  Use a vertex/beam constraint
-    
-
-    /**
-     * When adding a new vertex to the multi vertex fit,
-     * only the tracks whose Z at PCA is closer 
-     * to the seeded by more than this TracksMaxZinterval 
-     * value are added to this new vertex.
-     *
-     * Default is 4 mm. If you cut too hard, you cut out 
-     * the good cases where the seed finder is not 
-     * reliable, but the fit would be still able to converge 
-     * towards the right vertex. If you cut too soft, you 
-     * consider a lot of tracks which just slow down the fit.
-     */
-
-    double m_TracksMaxZinterval;
-
-    /**
-     * After having added one vertex to the fit and having 
-     * performed the MultiVertex fit again, all the tracks 
-     * which are compatible to the new vertex by more than 
-     * this maxVertexChi2 (in units of chi2) value are eliminated from the 
-     * tracks from which still to seed the next vertex.
-     *
-     */
-
-    double m_maxVertexChi2;
-
-    /**
-     * As a default the realMultiVertex should stay to false (because this is very well tested).
-     *
-     * If switched to true, all the tracks are considered to be added to the new vertex 
-     * after this new one is seeded, and not only the ones which are considered as outliers 
-     * of previous fitted vertices.
-     *
-     * The presence of a core of tracks the previous vertices are as attached to stabilizes 
-     * the fit quite drastically. In case of luminosities higher than the low lumi scenario,
-     * one should probably to try to switch this on, or, if this doesn't work, decrease the 
-     * maxVertexChi2 and the cleaningZinterval to lower values.
-     */
-    
-    bool m_realMultiVertex;
-
-
-    /*
-     * Decides if you want to use the vtxCompatibility() of the track (set to true) or 
-     * the chi2() (set to false) as an estimate for a track being an outlier or not.
-     * The vtxCompatibility() is the default. In case the track refitting 
-     * is switched on in the AdaptiveMultiVertex fitter, you may want to 
-     * use the refutted chi2().
-     *
-     */
-
-    bool m_useFastCompatibility;
-
-    /*
-     * Selection of the most probable primary interaction vertex is done accordingly to:
-     * - selectiontype is 0:  just sqrt(N_tracks)*Sum_track p_t_track^2
-     * - selectiontype is 1:  Neural Network is used, trained on WH(120)
-     */
-
-    int m_selectiontype;
-
-    /*
-     * During the estimation of probability of vertex candidate to be the primary interaction 
-     * vertex, only all the tracks which have chi2 in the vertex fit higher than this value 
-     * are used for the sum of p_t^2 or as input for the Neural Network.
-     */
-
-    double m_finalCutMaxVertexChi2;
-
- 
-    /*
-     * Maximum significance on the distance between two vertices 
-     * to allow merging of two vertices.
-     *
-     */
-
-    double m_cutVertexDependence;
-    
-
-    /*
-     * Has to be setup equal to the minimum weight set in the fitter.
-     *
-     * In the fitting, when a track has a weight lower than this value,
-     * the track is not updated during that iteration.
-     */
-
-    double m_minweight;
-
-
-    /*
-    * Impact parameter estimator used to calculate significance
-    */
-    ToolHandle< Trk::ITrackToVertexIPEstimator > m_ipEstimator { "Trk::TrackToVertexIPEstimator" };
-    
-    /*
-     * Maximum amount of iterations allowed for vertex finding.
-     * 
-     * The more vertices you have in the event, the more iterations you have to 
-     * allow (safe factor: number of expected vertices * 10)
-     *
-     */
-
-    double m_maxIterations;
-
-    NN* m_testingclass;
-
-   /*
-    * Fit also single track vertices
-    * (could be usefull for example for H-> gamma gamma)\
-    *
-    */
-
-   bool m_addSingleTrackVertices;
-
-   bool m_do3dSplitting;
-   
-   double m_zBfieldApprox;
-
-   double m_maximumVertexContamination;
-
-    /*
-    * Maximum allowed significance of track position to vertex seed
-    */
-    double m_tracksMaxSignificance ;
-
-    /*
-    * Toggle vertex seed constraint on/off
-    */
-    bool m_useSeedConstraint ;
-
-
-   struct CompareTheTwoVertices {
-     bool operator()( xAOD::Vertex* const & first, xAOD::Vertex* const & second);
-   };
-
-   /**												     
-    * Internal method to estimate the probability to be signal vertex of a certain vertex candidate. 
-    */												     
-
-   double estimateSignalCompatibility(xAOD::Vertex *myxAODVertex);				     
-
-   /**
-    * Estimate DeltaZ given a certain track parameters and beam spot center position
-    * ONLY TEMPORARY 15-08-2009: common tool needed to collect this method
-    */
-   
-   double estimateDeltaZ(const Trk::TrackParameters& myPerigee, const Amg::Vector3D& myTransvVertex);
-
-   /** 
-   * copying from the guassian density alg
-   */
-   double ipSignificance(const Trk::TrackParameters* params, const Amg::Vector3D * vertex) const;
-
-   /**
-    * Clean decorator data from a vertex candidate (to avoid memory leaks) and then delete it and set to zero
-    */
-   
-   void releaseCandidate(xAOD::Vertex*& candidate);
-   
-
- };//end of class
-}//end of namespace definitions
-#endif
-- 
GitLab


From 29c9f1f741ade8a7086344c48bd7a4c2a08b1bd0 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Sat, 29 Feb 2020 00:45:28 +0100
Subject: [PATCH 38/60] store const originalParams pointer in TrackAtVertex and
 adapt entire vertexing code accordingly

---
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   |  4 +-
 .../Vertexing/FullBilloirVertexFitter.hpp     |  2 +-
 .../Vertexing/FullBilloirVertexFitter.ipp     | 10 +-
 .../Acts/Vertexing/IterativeVertexFinder.hpp  | 25 ++---
 .../Acts/Vertexing/IterativeVertexFinder.ipp  | 97 +++++++++----------
 Core/include/Acts/Vertexing/TrackAtVertex.hpp | 50 +++++-----
 .../Acts/Vertexing/VertexFinderConcept.hpp    |  2 +-
 .../Acts/Vertexing/VertexFitterConcept.hpp    |  2 +-
 .../Acts/Vertexing/ZScanVertexFinder.hpp      |  2 +-
 .../Acts/Vertexing/ZScanVertexFinder.ipp      |  6 +-
 .../AdaptiveMultiVertexFitterTests.cpp        |  8 +-
 .../FullBilloirVertexFitterTests.cpp          | 21 +++-
 .../Vertexing/IterativeVertexFinderTests.cpp  | 35 ++++---
 .../KalmanVertexTrackUpdaterTests.cpp         |  2 +-
 .../Vertexing/KalmanVertexUpdaterTests.cpp    |  2 +-
 .../Core/Vertexing/ZScanVertexFinderTests.cpp | 14 ++-
 16 files changed, 152 insertions(+), 130 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index 313c30761..642d8b5a3 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -240,8 +240,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
         (ipSig < m_cfg.tracksMaxSignificance)) {
       // Create TrackAtVertex objects, unique for each (track, vertex) pair
       // fitterState.tracksAtVerticesMap.clear();
-      fitterState.tracksAtVerticesMap.insert(std::make_pair(
-          std::make_pair(trk, vtx), TrackAtVertex(params, *trk)));
+      fitterState.tracksAtVerticesMap.insert(
+          std::make_pair(std::make_pair(trk, vtx), TrackAtVertex(params, trk)));
 
       // Add the original track parameters to the list for vtx
       fitterState.vtxInfoMap[vtx].trackLinks.push_back(trk);
diff --git a/Core/include/Acts/Vertexing/FullBilloirVertexFitter.hpp b/Core/include/Acts/Vertexing/FullBilloirVertexFitter.hpp
index 702b16066..b7aee51db 100644
--- a/Core/include/Acts/Vertexing/FullBilloirVertexFitter.hpp
+++ b/Core/include/Acts/Vertexing/FullBilloirVertexFitter.hpp
@@ -69,7 +69,7 @@ class FullBilloirVertexFitter {
   ///
   /// @return Fitted vertex
   Result<Vertex<input_track_t>> fit(
-      const std::vector<input_track_t>& paramVector,
+      const std::vector<const input_track_t*>& paramVector,
       const linearizer_t& linearizer,
       const VertexFitterOptions<input_track_t>& vFitterOptions) const;
 
diff --git a/Core/include/Acts/Vertexing/FullBilloirVertexFitter.ipp b/Core/include/Acts/Vertexing/FullBilloirVertexFitter.ipp
index f7574c9d6..50c6f12e6 100644
--- a/Core/include/Acts/Vertexing/FullBilloirVertexFitter.ipp
+++ b/Core/include/Acts/Vertexing/FullBilloirVertexFitter.ipp
@@ -21,12 +21,12 @@ template <typename input_track_t>
 struct BilloirTrack {
   using Jacobian = Acts::SpacePointToBoundMatrix;
 
-  BilloirTrack(const input_track_t& params, Acts::LinearizedTrack lTrack)
+  BilloirTrack(const input_track_t* params, Acts::LinearizedTrack lTrack)
       : originalTrack(params), linTrack(std::move(lTrack)) {}
 
   BilloirTrack(const BilloirTrack& arg) = default;
 
-  const input_track_t originalTrack;
+  const input_track_t* originalTrack;
   Acts::LinearizedTrack linTrack;
   double chi2;
   Jacobian DiMat;                                  // position jacobian
@@ -63,7 +63,7 @@ struct BilloirVertex {
 template <typename input_track_t, typename linearizer_t>
 Acts::Result<Acts::Vertex<input_track_t>>
 Acts::FullBilloirVertexFitter<input_track_t, linearizer_t>::fit(
-    const std::vector<input_track_t>& paramVector,
+    const std::vector<const input_track_t*>& paramVector,
     const linearizer_t& linearizer,
     const VertexFitterOptions<input_track_t>& vFitterOptions) const {
   double chi2 = std::numeric_limits<double>::max();
@@ -105,8 +105,8 @@ Acts::FullBilloirVertexFitter<input_track_t, linearizer_t>::fit(
     BilloirVertex billoirVertex;
     int iTrack = 0;
     // iterate over all tracks
-    for (const input_track_t& trackContainer : paramVector) {
-      const auto& trackParams = extractParameters(trackContainer);
+    for (const input_track_t* trackContainer : paramVector) {
+      const auto& trackParams = extractParameters(*trackContainer);
       if (nIter == 0) {
         double phi = trackParams.parameters()[ParID_t::ePHI];
         double theta = trackParams.parameters()[ParID_t::eTHETA];
diff --git a/Core/include/Acts/Vertexing/IterativeVertexFinder.hpp b/Core/include/Acts/Vertexing/IterativeVertexFinder.hpp
index 41990b315..c2ea776fb 100644
--- a/Core/include/Acts/Vertexing/IterativeVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/IterativeVertexFinder.hpp
@@ -142,7 +142,7 @@ class IterativeVertexFinder {
   ///
   /// @return Collection of vertices found by finder
   Result<std::vector<Vertex<InputTrack_t>>> find(
-      const std::vector<InputTrack_t>& trackVector,
+      const std::vector<const InputTrack_t*>& trackVector,
       const VertexFinderOptions<InputTrack_t>& vFinderOptions) const;
 
  private:
@@ -167,15 +167,15 @@ class IterativeVertexFinder {
   /// @param seedTracks Seeding tracks
   /// @param vFinderOptions Vertex finder options
   Result<Vertex<InputTrack_t>> getVertexSeed(
-      const std::vector<InputTrack_t>& seedTracks,
+      const std::vector<const InputTrack_t*>& seedTracks,
       const VertexFinderOptions<InputTrack_t>& vFinderOptions) const;
 
   /// @brief Removes all tracks in perigeesToFit from seedTracks
   ///
   /// @param perigeesToFit Tracks to be removed from seedTracks
   /// @param seedTracks List to remove tracks from
-  void removeAllTracks(const std::vector<InputTrack_t>& perigeesToFit,
-                       std::vector<InputTrack_t>& seedTracks) const;
+  void removeAllTracks(const std::vector<const InputTrack_t*>& perigeesToFit,
+                       std::vector<const InputTrack_t*>& seedTracks) const;
 
   /// @brief Function for calculating how compatible
   /// a given track is to a given vertex
@@ -193,8 +193,9 @@ class IterativeVertexFinder {
   /// @param perigeesToFit Tracks used to fit `myVertex`
   /// @param seedTracks Tracks used for vertex seeding
   Result<void> removeUsedCompatibleTracks(
-      Vertex<InputTrack_t>& myVertex, std::vector<InputTrack_t>& perigeesToFit,
-      std::vector<InputTrack_t>& seedTracks) const;
+      Vertex<InputTrack_t>& myVertex,
+      std::vector<const InputTrack_t*>& perigeesToFit,
+      std::vector<const InputTrack_t*>& seedTracks) const;
 
   /// @brief Function that fills vector with tracks compatible with seed vertex
   ///
@@ -204,10 +205,10 @@ class IterativeVertexFinder {
   /// @param perigeesToFitSplitVertexOut Perigees to fit split vertex
   /// @param vFinderOptions Vertex finder options
   Result<void> fillPerigeesToFit(
-      const std::vector<InputTrack_t>& perigeeList,
+      const std::vector<const InputTrack_t*>& perigeeList,
       const Vertex<InputTrack_t>& seedVertex,
-      std::vector<InputTrack_t>& perigeesToFitOut,
-      std::vector<InputTrack_t>& perigeesToFitSplitVertexOut,
+      std::vector<const InputTrack_t*>& perigeesToFitOut,
+      std::vector<const InputTrack_t*>& perigeesToFitSplitVertexOut,
       const VertexFinderOptions<InputTrack_t>& vFinderOptions) const;
 
   /// @brief Function that reassigns tracks from other vertices
@@ -224,9 +225,9 @@ class IterativeVertexFinder {
   Result<bool> reassignTracksToNewVertex(
       std::vector<Vertex<InputTrack_t>>& vertexCollection,
       Vertex<InputTrack_t>& currentVertex,
-      std::vector<InputTrack_t>& perigeesToFit,
-      std::vector<InputTrack_t>& seedTracks,
-      const std::vector<InputTrack_t>& origTracks,
+      std::vector<const InputTrack_t*>& perigeesToFit,
+      std::vector<const InputTrack_t*>& seedTracks,
+      const std::vector<const InputTrack_t*>& origTracks,
       const VertexFitterOptions<InputTrack_t>& vFitterOptions) const;
 
   /// @brief Counts all tracks that are significant for a vertex
diff --git a/Core/include/Acts/Vertexing/IterativeVertexFinder.ipp b/Core/include/Acts/Vertexing/IterativeVertexFinder.ipp
index bf6946a8e..83b16e07e 100644
--- a/Core/include/Acts/Vertexing/IterativeVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/IterativeVertexFinder.ipp
@@ -10,19 +10,13 @@
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::find(
-    const std::vector<InputTrack_t>& trackVector,
+    const std::vector<const InputTrack_t*>& trackVector,
     const VertexFinderOptions<InputTrack_t>& vFinderOptions) const
     -> Result<std::vector<Vertex<InputTrack_t>>> {
   // Original tracks
-  const std::vector<InputTrack_t>& origTracks = trackVector;
+  const std::vector<const InputTrack_t*>& origTracks = trackVector;
   // Tracks for seeding
-  // Note: Remains to be investigated if another container (e.g. std::list)
-  // or also std::vector<InputTrack_t*> is a faster option since erasures
-  // of tracks is quite expensive with std::vector.
-  // std::vector<InputTrack_t*> would however also come with an overhead
-  // since m_cfg.vertexFitter.fit and m_cfg.seedFinder.find take
-  // vector<InputTrack_t> and hence a lot of copying would be required.
-  std::vector<InputTrack_t> seedTracks = trackVector;
+  std::vector<const InputTrack_t*> seedTracks = trackVector;
 
   // Construct the vertex fitter options from vertex finder options
   VertexFitterOptions<InputTrack_t> vFitterOptions(
@@ -46,8 +40,8 @@ auto Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::find(
     /// End seeding
     /// Now take only tracks compatible with current seed
     // Tracks used for the fit in this iteration
-    std::vector<InputTrack_t> perigeesToFit;
-    std::vector<InputTrack_t> perigeesToFitSplitVertex;
+    std::vector<const InputTrack_t*> perigeesToFit;
+    std::vector<const InputTrack_t*> perigeesToFitSplitVertex;
 
     // Fill vector with tracks to fit, only compatible with seed:
     auto res = fillPerigeesToFit(seedTracks, seedVertex, perigeesToFit,
@@ -160,7 +154,7 @@ auto Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::find(
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::getVertexSeed(
-    const std::vector<InputTrack_t>& seedTracks,
+    const std::vector<const InputTrack_t*>& seedTracks,
     const VertexFinderOptions<InputTrack_t>& vFinderOptions) const
     -> Result<Vertex<InputTrack_t>> {
   auto res = m_cfg.seedFinder.find(seedTracks, vFinderOptions);
@@ -187,15 +181,15 @@ auto Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::getVertexSeed(
 
 template <typename vfitter_t, typename sfinder_t>
 void Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::removeAllTracks(
-    const std::vector<InputTrack_t>& perigeesToFit,
-    std::vector<InputTrack_t>& seedTracks) const {
+    const std::vector<const InputTrack_t*>& perigeesToFit,
+    std::vector<const InputTrack_t*>& seedTracks) const {
   for (const auto& fitPerigee : perigeesToFit) {
-    const BoundParameters& fitPerigeeParams = m_extractParameters(fitPerigee);
+    const BoundParameters& fitPerigeeParams = m_extractParameters(*fitPerigee);
     // Find track in seedTracks
     auto foundIter =
         std::find_if(seedTracks.begin(), seedTracks.end(),
-                     [&fitPerigeeParams, this](auto seedTrk) {
-                       return fitPerigeeParams == m_extractParameters(seedTrk);
+                     [&fitPerigeeParams, this](const auto seedTrk) {
+                       return fitPerigeeParams == m_extractParameters(*seedTrk);
                      });
     if (foundIter != seedTracks.end()) {
       // Remove track from seed tracks
@@ -241,8 +235,9 @@ Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::getCompatibility(
 template <typename vfitter_t, typename sfinder_t>
 Acts::Result<void>
 Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::removeUsedCompatibleTracks(
-    Vertex<InputTrack_t>& myVertex, std::vector<InputTrack_t>& perigeesToFit,
-    std::vector<InputTrack_t>& seedTracks) const {
+    Vertex<InputTrack_t>& myVertex,
+    std::vector<const InputTrack_t*>& perigeesToFit,
+    std::vector<const InputTrack_t*>& seedTracks) const {
   std::vector<TrackAtVertex<InputTrack_t>> tracksAtVertex = myVertex.tracks();
 
   for (const auto& trackAtVtx : tracksAtVertex) {
@@ -251,14 +246,11 @@ Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::removeUsedCompatibleTracks(
       // Do not remove track here, since it is not compatible with the vertex
       continue;
     }
-
-    auto trkAtVtxParam = m_extractParameters(trackAtVtx.originalTrack);
-
     // Find and remove track from seedTracks
     auto foundSeedIter =
         std::find_if(seedTracks.begin(), seedTracks.end(),
-                     [&trkAtVtxParam, this](auto seedTrk) {
-                       return trkAtVtxParam == m_extractParameters(seedTrk);
+                     [&trackAtVtx, this](const auto seedTrk) {
+                       return trackAtVtx.originalParams == seedTrk;
                      });
     if (foundSeedIter != seedTracks.end()) {
       seedTracks.erase(foundSeedIter);
@@ -269,8 +261,8 @@ Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::removeUsedCompatibleTracks(
     // Find and remove track from perigeesToFit
     auto foundFitIter =
         std::find_if(perigeesToFit.begin(), perigeesToFit.end(),
-                     [&trkAtVtxParam, this](auto fitTrk) {
-                       return trkAtVtxParam == m_extractParameters(fitTrk);
+                     [&trackAtVtx, this](const auto fitTrk) {
+                       return trackAtVtx.originalParams == fitTrk;
                      });
     if (foundFitIter != perigeesToFit.end()) {
       perigeesToFit.erase(foundFitIter);
@@ -289,8 +281,8 @@ Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::removeUsedCompatibleTracks(
 
   for (const auto& myPerigeeToFit : perigeesToFit) {
     // calculate chi2 w.r.t. last fitted vertex
-    auto fitPerigeeParams = m_extractParameters(myPerigeeToFit);
-    auto result = getCompatibility(fitPerigeeParams, myVertex);
+    auto result =
+        getCompatibility(m_extractParameters(*myPerigeeToFit), myVertex);
 
     if (!result.ok()) {
       return result.error();
@@ -301,11 +293,11 @@ Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::removeUsedCompatibleTracks(
     // check if sufficiently compatible with last fitted vertex
     // (quite loose constraint)
     if (chi2 < m_cfg.maximumChi2cutForSeeding) {
-      auto foundIter = std::find_if(seedTracks.begin(), seedTracks.end(),
-                                    [&fitPerigeeParams, this](auto seedTrk) {
-                                      return fitPerigeeParams ==
-                                             m_extractParameters(seedTrk);
-                                    });
+      auto foundIter =
+          std::find_if(seedTracks.begin(), seedTracks.end(),
+                       [&myPerigeeToFit, this](const auto seedTrk) {
+                         return myPerigeeToFit == seedTrk;
+                       });
       if (foundIter != seedTracks.end()) {
         // Remove track from seed tracks
         seedTracks.erase(foundIter);
@@ -314,11 +306,11 @@ Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::removeUsedCompatibleTracks(
     } else {
       // Track not compatible with vertex
       // Remove track from current vertex
-      auto foundIter = std::find_if(
-          tracksAtVertex.begin(), tracksAtVertex.end(),
-          [&fitPerigeeParams, this](auto trk) {
-            return fitPerigeeParams == m_extractParameters(trk.originalTrack);
-          });
+      auto foundIter =
+          std::find_if(tracksAtVertex.begin(), tracksAtVertex.end(),
+                       [&myPerigeeToFit, this](auto trk) {
+                         return myPerigeeToFit == trk.originalParams;
+                       });
       if (foundIter != tracksAtVertex.end()) {
         // Remove track from seed tracks
         tracksAtVertex.erase(foundIter);
@@ -335,10 +327,10 @@ Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::removeUsedCompatibleTracks(
 template <typename vfitter_t, typename sfinder_t>
 Acts::Result<void>
 Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::fillPerigeesToFit(
-    const std::vector<InputTrack_t>& perigeeList,
+    const std::vector<const InputTrack_t*>& perigeeList,
     const Vertex<InputTrack_t>& seedVertex,
-    std::vector<InputTrack_t>& perigeesToFitOut,
-    std::vector<InputTrack_t>& perigeesToFitSplitVertexOut,
+    std::vector<const InputTrack_t*>& perigeesToFitOut,
+    std::vector<const InputTrack_t*>& perigeesToFitSplitVertexOut,
     const VertexFinderOptions<InputTrack_t>& vFinderOptions) const {
   int numberOfTracks = perigeeList.size();
 
@@ -366,7 +358,7 @@ Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::fillPerigeesToFit(
     // still large amount of tracks available, check compatibility
     else {
       // check first that distance is not too large
-      const BoundParameters& sTrackParams = m_extractParameters(sTrack);
+      const BoundParameters& sTrackParams = m_extractParameters(*sTrack);
       auto distanceRes = m_cfg.ipEst.calculateDistance(
           vFinderOptions.geoContext, sTrackParams, seedVertex.position());
       if (!distanceRes.ok()) {
@@ -405,9 +397,9 @@ Acts::Result<bool>
 Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::reassignTracksToNewVertex(
     std::vector<Vertex<InputTrack_t>>& vertexCollection,
     Vertex<InputTrack_t>& currentVertex,
-    std::vector<InputTrack_t>& perigeesToFit,
-    std::vector<InputTrack_t>& seedTracks,
-    const std::vector<InputTrack_t>& origTracks,
+    std::vector<const InputTrack_t*>& perigeesToFit,
+    std::vector<const InputTrack_t*>& seedTracks,
+    const std::vector<const InputTrack_t*>& origTracks,
     const VertexFitterOptions<InputTrack_t>& vFitterOptions) const {
   int numberOfAddedTracks = 0;
 
@@ -428,7 +420,7 @@ Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::reassignTracksToNewVertex(
       }
       // use original perigee parameter of course
       BoundParameters trackPerigee =
-          m_extractParameters(tracksIter->originalTrack);
+          m_extractParameters(*(tracksIter->originalParams));
 
       // compute compatibility
       auto resultNew = getCompatibility(trackPerigee, currentVertex);
@@ -447,17 +439,18 @@ Acts::IterativeVertexFinder<vfitter_t, sfinder_t>::reassignTracksToNewVertex(
       ACTS_DEBUG("Compatibility to old vertex: " << chi2OldVtx);
 
       if (chi2NewVtx < chi2OldVtx) {
-        perigeesToFit.push_back(tracksIter->originalTrack);
+        perigeesToFit.push_back(tracksIter->originalParams);
         // origTrack was already deleted from seedTracks previously
         // (when assigned to old vertex)
         // add it now back to seedTracks to be able to consistently
         // delete it later
         // when all tracks used to fit current vertex are deleted
-        seedTracks.push_back(*std::find_if(
-            origTracks.begin(), origTracks.end(),
-            [&trackPerigee, this](auto origTrack) {
-              return trackPerigee == m_extractParameters(origTrack);
-            }));
+        seedTracks.push_back(tracksIter->originalParams);
+        // seedTracks.push_back(*std::find_if(
+        //     origTracks.begin(), origTracks.end(),
+        //     [&trackPerigee, this](auto origTrack) {
+        //       return trackPerigee == m_extractParameters(*origTrack);
+        //     }));
 
         numberOfAddedTracks += 1;
 
diff --git a/Core/include/Acts/Vertexing/TrackAtVertex.hpp b/Core/include/Acts/Vertexing/TrackAtVertex.hpp
index 1d63c25a8..689e52a2c 100644
--- a/Core/include/Acts/Vertexing/TrackAtVertex.hpp
+++ b/Core/include/Acts/Vertexing/TrackAtVertex.hpp
@@ -30,29 +30,35 @@ struct TrackAtVertex {
   ///
   /// @param chi2perTrack Chi2 of track
   /// @param paramsAtVertex Fitted perigee parameter
-  /// @param originalParams Original perigee parameter
+  /// @param originalTrack Original perigee parameter
   TrackAtVertex(double chi2perTrack, const BoundParameters& paramsAtVertex,
-                const input_track_t& originalParams)
-      : chi2Track(chi2perTrack),
+                const input_track_t* originalTrack)
+      : fittedParams(paramsAtVertex),
+        originalParams(originalTrack),
+        chi2Track(chi2perTrack),
         ndf(0.),
-        fittedParams(paramsAtVertex),
-        originalTrack(originalParams),
-        trackWeight(1.),
-        vertexCompatibility(0.) {}
+        vertexCompatibility(0.),
+        trackWeight(1.) {}
 
   /// @brief Constructor with default chi2
   ///
   /// @param chi2perTrack Chi2 of track
   /// @param paramsAtVertex Fitted perigee parameter
-  /// @param originalParams Original perigee parameter
+  /// @param originalTrack Original perigee parameter
   TrackAtVertex(const BoundParameters& paramsAtVertex,
-                const input_track_t& originalParams)
-      : chi2Track(0.),
+                const input_track_t* originalTrack)
+      : fittedParams(paramsAtVertex),
+        originalParams(originalTrack),
+        chi2Track(0.),
         ndf(0.),
-        fittedParams(paramsAtVertex),
-        originalTrack(originalParams),
-        trackWeight(1.),
-        vertexCompatibility(0.) {}
+        vertexCompatibility(0.),
+        trackWeight(1.) {}
+
+  /// Fitted perigee
+  BoundParameters fittedParams;
+
+  /// Original input parameters
+  const input_track_t* originalParams;
 
   /// Chi2 of track
   double chi2Track;
@@ -63,25 +69,15 @@ struct TrackAtVertex {
   /// non-interger values
   double ndf;
 
-  /// Fitted perigee
-  BoundParameters fittedParams;
-
-  /// Original input track
-  // TODO: to be fully replaced by pointer version below
-  input_track_t originalTrack;
-
-  /// Original input parameters
-  input_track_t* originalTrack2;
+  /// Value of the compatibility of the track to the actual vertex, based
+  /// on the estimation of the 3d distance between the track and the vertex
+  double vertexCompatibility;
 
   /// Weight of track in fit
   double trackWeight;
 
   /// The linearized state of the track at vertex
   LinearizedTrack linearizedState;
-
-  /// Value of the compatibility of the track to the actual vertex, based
-  /// on the estimation of the 3d distance between the track and the vertex
-  double vertexCompatibility;
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Vertexing/VertexFinderConcept.hpp b/Core/include/Acts/Vertexing/VertexFinderConcept.hpp
index 8aba5ff1b..57e57ecca 100644
--- a/Core/include/Acts/Vertexing/VertexFinderConcept.hpp
+++ b/Core/include/Acts/Vertexing/VertexFinderConcept.hpp
@@ -26,7 +26,7 @@ namespace concept {
       struct VertexFinderConcept {
         
         constexpr static bool find_exists = has_method<const S, Result<std::vector<Vertex<typename S::InputTrack_t>>>,
-         find_t, const std::vector<typename S::InputTrack_t>&, 
+         find_t, const std::vector<const typename S::InputTrack_t*>&, 
          const VertexFinderOptions<typename S::InputTrack_t>&>;
         static_assert(find_exists, "find method not found");
 
diff --git a/Core/include/Acts/Vertexing/VertexFitterConcept.hpp b/Core/include/Acts/Vertexing/VertexFitterConcept.hpp
index e3d9d60b5..9164c714d 100644
--- a/Core/include/Acts/Vertexing/VertexFitterConcept.hpp
+++ b/Core/include/Acts/Vertexing/VertexFitterConcept.hpp
@@ -33,7 +33,7 @@ namespace concept {
       struct VertexFitterConcept {
         constexpr static bool fit_exists = has_method<const S, Result<Vertex<typename S::InputTrack_t>>,
          fit_t, 
-         const std::vector<typename S::InputTrack_t>&, 
+         const std::vector<const typename S::InputTrack_t*>&, 
          const typename S::Linearizer_t&,
          const VertexFitterOptions<typename S::InputTrack_t>&>;
         static_assert(fit_exists, "fit method not found");
diff --git a/Core/include/Acts/Vertexing/ZScanVertexFinder.hpp b/Core/include/Acts/Vertexing/ZScanVertexFinder.hpp
index 93f08bc07..e738d705d 100644
--- a/Core/include/Acts/Vertexing/ZScanVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/ZScanVertexFinder.hpp
@@ -108,7 +108,7 @@ class ZScanVertexFinder {
   /// @return Vector of vertices, filled with a single
   ///         vertex (for consistent interfaces)
   Result<std::vector<Vertex<InputTrack_t>>> find(
-      const std::vector<InputTrack_t>& trackVector,
+      const std::vector<const InputTrack_t*>& trackVector,
       const VertexFinderOptions<InputTrack_t>& vFinderOptions) const;
 
  private:
diff --git a/Core/include/Acts/Vertexing/ZScanVertexFinder.ipp b/Core/include/Acts/Vertexing/ZScanVertexFinder.ipp
index 409029641..0c950c805 100644
--- a/Core/include/Acts/Vertexing/ZScanVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/ZScanVertexFinder.ipp
@@ -8,7 +8,7 @@
 
 template <typename vfitter_t>
 auto Acts::ZScanVertexFinder<vfitter_t>::find(
-    const std::vector<InputTrack_t>& trackVector,
+    const std::vector<const InputTrack_t*>& trackVector,
     const VertexFinderOptions<InputTrack_t>& vFinderOptions) const
     -> Result<std::vector<Vertex<InputTrack_t>>> {
   // Determine if we use constraint or not
@@ -22,9 +22,9 @@ auto Acts::ZScanVertexFinder<vfitter_t>::find(
   // calculated
   std::vector<std::pair<double, double>> zPositions;
 
-  for (auto& iTrk : trackVector) {
+  for (const auto& iTrk : trackVector) {
     // Extract BoundParameters from InputTrack_t object
-    const BoundParameters& params = m_extractParameters(iTrk);
+    const BoundParameters& params = m_extractParameters(*iTrk);
 
     std::pair<double, double> z0AndWeight;
     std::unique_ptr<ImpactParametersAndSigma> ipas = nullptr;
diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
index 7bb06769c..5d482bf36 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
@@ -186,7 +186,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test) {
     state.tracksAtVerticesMap.insert(
         std::make_pair(std::make_pair(&allTracks[iTrack], &vtxList[vtxIdx]),
                        TrackAtVertex<BoundParameters>(1., allTracks[iTrack],
-                                                      allTracks[iTrack])));
+                                                      &allTracks[iTrack])));
 
     // Use first track also for second vertex to let vtx1 and vtx2
     // share this track
@@ -195,7 +195,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test) {
       state.tracksAtVerticesMap.insert(
           std::make_pair(std::make_pair(&allTracks[iTrack], &vtxList[1]),
                          TrackAtVertex<BoundParameters>(1., allTracks[iTrack],
-                                                        allTracks[iTrack])));
+                                                        &allTracks[iTrack])));
     }
   }
 
@@ -445,7 +445,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test_athena) {
     vtxInfo1.trackLinks.push_back(&trk);
     state.tracksAtVerticesMap.insert(
         std::make_pair(std::make_pair(&trk, &vtx1),
-                       TrackAtVertex<BoundParameters>(1.5, trk, trk)));
+                       TrackAtVertex<BoundParameters>(1.5, trk, &trk)));
   }
 
   // Prepare second vertex
@@ -472,7 +472,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test_athena) {
     vtxInfo2.trackLinks.push_back(&trk);
     state.tracksAtVerticesMap.insert(
         std::make_pair(std::make_pair(&trk, &vtx2),
-                       TrackAtVertex<BoundParameters>(1.5, trk, trk)));
+                       TrackAtVertex<BoundParameters>(1.5, trk, &trk)));
   }
 
   state.vtxInfoMap[&vtx1] = std::move(vtxInfo1);
diff --git a/Tests/UnitTests/Core/Vertexing/FullBilloirVertexFitterTests.cpp b/Tests/UnitTests/Core/Vertexing/FullBilloirVertexFitterTests.cpp
index 650bdd817..cf4c79332 100644
--- a/Tests/UnitTests/Core/Vertexing/FullBilloirVertexFitterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/FullBilloirVertexFitterTests.cpp
@@ -70,7 +70,7 @@ BOOST_AUTO_TEST_CASE(billoir_vertex_fitter_empty_input_test) {
   myConstraint.setFullCovariance(std::move(myCovMat));
   myConstraint.setFullPosition(SpacePointVector(0, 0, 0, 0));
 
-  std::vector<BoundParameters> emptyVector;
+  const std::vector<const BoundParameters*> emptyVector;
 
   VertexFitterOptions<BoundParameters> vfOptions(tgContext, mfContext,
                                                  myConstraint);
@@ -205,15 +205,21 @@ BOOST_AUTO_TEST_CASE(billoir_vertex_fitter_defaulttrack_test) {
       tracks.push_back(BoundParameters(tgContext, std::move(covMat), paramVec,
                                        perigeeSurface));
     }
+
+    std::vector<const BoundParameters*> tracksPtr;
+    for (const auto& trk : tracks) {
+      tracksPtr.push_back(&trk);
+    }
+
     // Do the actual fit with 4 tracks without constraint
     Vertex<BoundParameters> fittedVertex =
-        billoirFitter.fit(tracks, linearizer, vfOptions).value();
+        billoirFitter.fit(tracksPtr, linearizer, vfOptions).value();
     if (fittedVertex.tracks().size() > 0) {
       CHECK_CLOSE_ABS(fittedVertex.position(), vertexPosition, 1_mm);
     }
     // Do the fit with a constraint
     Vertex<BoundParameters> fittedVertexConstraint =
-        billoirFitter.fit(tracks, linearizer, vfOptionsConstr).value();
+        billoirFitter.fit(tracksPtr, linearizer, vfOptionsConstr).value();
     if (fittedVertexConstraint.tracks().size() > 0) {
       CHECK_CLOSE_ABS(fittedVertexConstraint.position(), vertexPosition, 1_mm);
     }
@@ -341,15 +347,20 @@ BOOST_AUTO_TEST_CASE(billoir_vertex_fitter_usertrack_test) {
                                                   paramVec, perigeeSurface)));
     }
 
+    std::vector<const InputTrack*> tracksPtr;
+    for (const auto& trk : tracks) {
+      tracksPtr.push_back(&trk);
+    }
+
     // Do the actual fit with 4 tracks without constraint
     Vertex<InputTrack> fittedVertex =
-        billoirFitter.fit(tracks, linearizer, vfOptions).value();
+        billoirFitter.fit(tracksPtr, linearizer, vfOptions).value();
     if (fittedVertex.tracks().size() > 0) {
       CHECK_CLOSE_ABS(fittedVertex.position(), vertexPosition, 1_mm);
     }
     // Do the fit with a constraint
     Vertex<InputTrack> fittedVertexConstraint =
-        billoirFitter.fit(tracks, linearizer, vfOptionsConstr).value();
+        billoirFitter.fit(tracksPtr, linearizer, vfOptionsConstr).value();
     if (fittedVertexConstraint.tracks().size() > 0) {
       CHECK_CLOSE_ABS(fittedVertexConstraint.position(), vertexPosition, 1_mm);
     }
diff --git a/Tests/UnitTests/Core/Vertexing/IterativeVertexFinderTests.cpp b/Tests/UnitTests/Core/Vertexing/IterativeVertexFinderTests.cpp
index b317df4b8..99bf17eec 100644
--- a/Tests/UnitTests/Core/Vertexing/IterativeVertexFinderTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/IterativeVertexFinderTests.cpp
@@ -150,7 +150,9 @@ BOOST_AUTO_TEST_CASE(iterative_finder_test) {
     VertexFinder finder(cfg);
 
     // Vector to be filled with all tracks in current event
-    std::vector<BoundParameters> tracks;
+    std::vector<std::unique_ptr<const BoundParameters>> tracks;
+
+    std::vector<const BoundParameters*> tracksPtr;
 
     // Vector to be filled with truth vertices for later comparison
     std::vector<Vertex<BoundParameters>> trueVertices;
@@ -211,9 +213,9 @@ BOOST_AUTO_TEST_CASE(iterative_finder_test) {
         auto params = BoundParameters(tgContext, std::move(covMat), paramVec,
                                       perigeeSurface);
 
-        tracks.push_back(params);
+        tracks.push_back(std::make_unique<BoundParameters>(params));
 
-        TrackAtVertex<BoundParameters> trAtVt(0., params, params);
+        TrackAtVertex<BoundParameters> trAtVt(0., params, tracks.back().get());
         tracksAtTrueVtx.push_back(trAtVt);
       }
 
@@ -225,10 +227,14 @@ BOOST_AUTO_TEST_CASE(iterative_finder_test) {
     // shuffle list of tracks
     std::shuffle(std::begin(tracks), std::end(tracks), gen);
 
+    for (const auto& trk : tracks) {
+      tracksPtr.push_back(trk.get());
+    }
+
     VertexFinderOptions<BoundParameters> vFinderOptions(tgContext, mfContext);
 
     // find vertices
-    auto res = finder.find(tracks, vFinderOptions);
+    auto res = finder.find(tracksPtr, vFinderOptions);
 
     BOOST_CHECK(res.ok());
 
@@ -364,10 +370,12 @@ BOOST_AUTO_TEST_CASE(iterative_finder_test_user_track_type) {
     VertexFinder finder(cfg, extractParameters);
 
     // Same for user track type tracks
-    std::vector<InputTrack> tracks;
+    std::vector<std::unique_ptr<const InputTrack>> tracks;
+
+    std::vector<const InputTrack*> tracksPtr;
 
     // Vector to be filled with truth vertices for later comparison
-    std::vector<Vertex<BoundParameters>> trueVertices;
+    std::vector<Vertex<InputTrack>> trueVertices;
 
     // start creating event with nVertices vertices
     unsigned int nVertices = nVertexDist(gen);
@@ -390,8 +398,8 @@ BOOST_AUTO_TEST_CASE(iterative_finder_test_user_track_type) {
       double z = vZDist(gen);
 
       // True vertex
-      Vertex<BoundParameters> trueV(Vector3D(x, y, z));
-      std::vector<TrackAtVertex<BoundParameters>> tracksAtTrueVtx;
+      Vertex<InputTrack> trueV(Vector3D(x, y, z));
+      std::vector<TrackAtVertex<InputTrack>> tracksAtTrueVtx;
 
       // Calculate d0 and z0 corresponding to vertex position
       double d0_v = sqrt(x * x + y * y);
@@ -426,11 +434,11 @@ BOOST_AUTO_TEST_CASE(iterative_finder_test_user_track_type) {
         auto paramsUT = InputTrack(BoundParameters(tgContext, std::move(covMat),
                                                    paramVec, perigeeSurface));
 
-        tracks.push_back(paramsUT);
+        tracks.push_back(std::make_unique<InputTrack>(paramsUT));
 
         auto params = extractParameters(paramsUT);
 
-        TrackAtVertex<BoundParameters> trAtVt(0., params, params);
+        TrackAtVertex<InputTrack> trAtVt(0., params, tracks.back().get());
         tracksAtTrueVtx.push_back(trAtVt);
       }
 
@@ -442,11 +450,14 @@ BOOST_AUTO_TEST_CASE(iterative_finder_test_user_track_type) {
     // shuffle list of tracks
     std::shuffle(std::begin(tracks), std::end(tracks), gen);
 
-    VertexFinderOptions<BoundParameters> vFinderOptions(tgContext, mfContext);
+    for (const auto& trk : tracks) {
+      tracksPtr.push_back(trk.get());
+    }
+
     VertexFinderOptions<InputTrack> vFinderOptionsUT(tgContext, mfContext);
 
     // find vertices
-    auto res = finder.find(tracks, vFinderOptionsUT);
+    auto res = finder.find(tracksPtr, vFinderOptionsUT);
 
     BOOST_CHECK(res.ok());
 
diff --git a/Tests/UnitTests/Core/Vertexing/KalmanVertexTrackUpdaterTests.cpp b/Tests/UnitTests/Core/Vertexing/KalmanVertexTrackUpdaterTests.cpp
index 7b69991ee..12ad0af59 100644
--- a/Tests/UnitTests/Core/Vertexing/KalmanVertexTrackUpdaterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/KalmanVertexTrackUpdaterTests.cpp
@@ -137,7 +137,7 @@ BOOST_AUTO_TEST_CASE(Kalman_Vertex_TrackUpdater) {
         linearizer.linearizeTrack(params, SpacePointVector::Zero()).value();
 
     // Create TrackAtVertex
-    TrackAtVertex<BoundParameters> trkAtVtx(0., params, params);
+    TrackAtVertex<BoundParameters> trkAtVtx(0., params, &params);
 
     // Set linearized state of trackAtVertex
     trkAtVtx.linearizedState = linTrack;
diff --git a/Tests/UnitTests/Core/Vertexing/KalmanVertexUpdaterTests.cpp b/Tests/UnitTests/Core/Vertexing/KalmanVertexUpdaterTests.cpp
index 8708c4224..f9a9563ef 100644
--- a/Tests/UnitTests/Core/Vertexing/KalmanVertexUpdaterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/KalmanVertexUpdaterTests.cpp
@@ -134,7 +134,7 @@ BOOST_AUTO_TEST_CASE(Kalman_Vertex_Updater) {
         linearizer.linearizeTrack(params, SpacePointVector::Zero()).value();
 
     // Create TrackAtVertex
-    TrackAtVertex<BoundParameters> trkAtVtx(0., params, params);
+    TrackAtVertex<BoundParameters> trkAtVtx(0., params, &params);
 
     // Set linearized state of trackAtVertex
     trkAtVtx.linearizedState = linTrack;
diff --git a/Tests/UnitTests/Core/Vertexing/ZScanVertexFinderTests.cpp b/Tests/UnitTests/Core/Vertexing/ZScanVertexFinderTests.cpp
index 21a7a4e81..c92a86641 100644
--- a/Tests/UnitTests/Core/Vertexing/ZScanVertexFinderTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/ZScanVertexFinderTests.cpp
@@ -135,6 +135,11 @@ BOOST_AUTO_TEST_CASE(zscan_finder_test) {
                                        perigeeSurface));
     }
 
+    std::vector<const BoundParameters*> tracksPtr;
+    for (const auto& trk : tracks) {
+      tracksPtr.push_back(&trk);
+    }
+
     using VertexFinder = ZScanVertexFinder<BilloirFitter>;
 
     static_assert(VertexFinderConcept<VertexFinder>,
@@ -150,7 +155,7 @@ BOOST_AUTO_TEST_CASE(zscan_finder_test) {
 
     VertexFinderOptions<BoundParameters> vFinderOptions(tgContext, mfContext);
 
-    auto res = finder.find(tracks, vFinderOptions);
+    auto res = finder.find(tracksPtr, vFinderOptions);
 
     BOOST_CHECK(res.ok());
 
@@ -250,6 +255,11 @@ BOOST_AUTO_TEST_CASE(zscan_finder_usertrack_test) {
                                                   paramVec, perigeeSurface)));
     }
 
+    std::vector<const InputTrack*> tracksPtr;
+    for (const auto& trk : tracks) {
+      tracksPtr.push_back(&trk);
+    }
+
     using VertexFinder = ZScanVertexFinder<BilloirFitter>;
 
     static_assert(VertexFinderConcept<VertexFinder>,
@@ -270,7 +280,7 @@ BOOST_AUTO_TEST_CASE(zscan_finder_usertrack_test) {
 
     VertexFinderOptions<InputTrack> vFinderOptions(tgContext, mfContext);
 
-    auto res = finder.find(tracks, vFinderOptions);
+    auto res = finder.find(tracksPtr, vFinderOptions);
 
     BOOST_CHECK(res.ok());
 
-- 
GitLab


From 4a5a8162a84d2ad4ba1d8278446cbeff3e5864ed Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Sat, 29 Feb 2020 01:18:53 +0100
Subject: [PATCH 39/60] enable VertexSmootherTests again

---
 Tests/UnitTests/Core/Vertexing/CMakeLists.txt          | 2 +-
 Tests/UnitTests/Core/Vertexing/VertexSmootherTests.cpp | 7 ++++++-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/Tests/UnitTests/Core/Vertexing/CMakeLists.txt b/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
index 60512520f..829ef494c 100644
--- a/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
+++ b/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
@@ -7,6 +7,6 @@ add_unittest(LinearizedTrackFactoryTests LinearizedTrackFactoryTests.cpp)
 add_unittest(AdaptiveMultiVertexFitterTests AdaptiveMultiVertexFitterTests.cpp)
 add_unittest(AdaptiveMultiVertexFinderTests AdaptiveMultiVertexFinderTests.cpp)
 add_unittest(TrackToVertexIPEstimatorTests TrackToVertexIPEstimatorTests.cpp)
-# add_unittest(VertexSmootherTests VertexSmootherTests.cpp)
+add_unittest(VertexSmootherTests VertexSmootherTests.cpp)
 add_unittest(ZScanVertexFinderTests ZScanVertexFinderTests.cpp)
 add_unittest(TrackDensityVertexFinderTests TrackDensityVertexFinderTests.cpp)
\ No newline at end of file
diff --git a/Tests/UnitTests/Core/Vertexing/VertexSmootherTests.cpp b/Tests/UnitTests/Core/Vertexing/VertexSmootherTests.cpp
index fc3e23639..8970a28a1 100644
--- a/Tests/UnitTests/Core/Vertexing/VertexSmootherTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/VertexSmootherTests.cpp
@@ -139,8 +139,13 @@ BOOST_AUTO_TEST_CASE(sequential_vertex_smoother_test) {
                                      perigeeSurface));
   }
 
+  std::vector<const BoundParameters*> tracksPtr;
+  for (const auto& trk : tracks) {
+    tracksPtr.push_back(&trk);
+  }
+
   Vertex<BoundParameters> fittedVertex =
-      billoirFitter.fit(tracks, linearizer, vfOptions).value();
+      billoirFitter.fit(tracksPtr, linearizer, vfOptions).value();
 
   // copy vertex for later comparison
   Vertex<BoundParameters> vertexBeforeSmoothing = fittedVertex;
-- 
GitLab


From e4245018cda1008a37fe5331434c49cbc4ec848d Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Sat, 29 Feb 2020 01:22:12 +0100
Subject: [PATCH 40/60] remove unused AMVFitter state constructors

---
 .../Acts/Vertexing/AdaptiveMultiVertexFitter.hpp      | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
index b33841262..70fedf60c 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
@@ -71,17 +71,6 @@ class AdaptiveMultiVertexFitter {
     /// @brief Default State constructor
     State() = default;
 
-    /// @brief State constructor to initialize trackToVerticesMultiMap
-    ///
-    /// @param vtxList List of all vertices with trackAtVertex information
-    State(std::vector<Vertex<input_track_t>>& vtxList) {
-      updateTrkToVerticesMultiMap(vtxList);
-    }
-
-    State(std::vector<Vertex<input_track_t>*>& vtxList) {
-      updateTrkToVerticesMultiMap(vtxList);
-    }
-
     void updateTrkToVerticesMultiMap(
         std::vector<Vertex<input_track_t>>& vtxList) {
       trackToVerticesMultiMap.clear();
-- 
GitLab


From e61268caf48b35b313056b182defd4438d8026a3 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Sat, 29 Feb 2020 14:28:37 +0100
Subject: [PATCH 41/60] update unittest cmakelist

---
 Tests/UnitTests/Core/Utilities/CMakeLists.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Tests/UnitTests/Core/Utilities/CMakeLists.txt b/Tests/UnitTests/Core/Utilities/CMakeLists.txt
index 82fe124a3..5462c9b65 100644
--- a/Tests/UnitTests/Core/Utilities/CMakeLists.txt
+++ b/Tests/UnitTests/Core/Utilities/CMakeLists.txt
@@ -1,6 +1,5 @@
 add_unittest(AnnealingUtilityTests AnnealingUtilityTests.cpp)
 add_unittest(AxesTests AxesTests.cpp)
-add_unittest(BenchmarkTools BenchmarkTools.cpp)
 add_unittest(BFieldMapUtilsTests BFieldMapUtilsTests.cpp)
 add_unittest(BinningDataTests BinningDataTests.cpp)
 add_unittest(BinUtilityTests BinUtilityTests.cpp)
-- 
GitLab


From a1f04d66412d0d590cf1fdbcfab557e180d92d90 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Sat, 29 Feb 2020 22:40:07 +0100
Subject: [PATCH 42/60] enable possibility to use old fitter state after bad
 vertex instead of refit

---
 Core/include/Acts/Vertexing/AMVFInfo.hpp      |  3 +-
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   |  7 ++++
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 35 ++++++++++++++-----
 .../Vertexing/AdaptiveMultiVertexFitter.ipp   | 11 +++---
 4 files changed, 39 insertions(+), 17 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AMVFInfo.hpp b/Core/include/Acts/Vertexing/AMVFInfo.hpp
index 74297bdc8..8174a09db 100644
--- a/Core/include/Acts/Vertexing/AMVFInfo.hpp
+++ b/Core/include/Acts/Vertexing/AMVFInfo.hpp
@@ -44,8 +44,7 @@ struct VertexInfo {
   // Vector of all track currently held by vertex
   std::vector<const input_track_t*> trackLinks;
 
-  std::map<const input_track_t*, std::unique_ptr<const BoundParameters>>
-      ip3dParams;
+  std::map<const input_track_t*, const BoundParameters> ip3dParams;
 };
 
 }  // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index 2eada8b97..0656a2b91 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -141,6 +141,13 @@ class AdaptiveMultiVertexFinder {
     // constraint is provided
     std::pair<double, double> defaultConstrFitQuality{0., -3.};
 
+    // Do an adaptive multi vertex fit after
+    // a bad vertex was removed.
+    // If false, the old fitter state is just copied,
+    // this should give the same results with better
+    // performance. To be further investigated.
+    bool refitAfterBadVertex = true;
+
   };  // Config struct
 
   struct State {};
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index 642d8b5a3..b9822c1d4 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -38,6 +38,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
   while (((m_cfg.addSingleTrackVertices && seedTracks.size() > 0) ||
           ((!m_cfg.addSingleTrackVertices) && seedTracks.size() > 1)) &&
          iteration < m_cfg.maxIterations) {
+    auto oldFitterState = fitterState;
+
     // Tracks that are used for searching compatible tracks
     // near a vertex candidate
     std::vector<const InputTrack_t*> myTracks;
@@ -121,17 +123,32 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     if (not keepVertex) {
       allVertices.pop_back();
       allVerticesPtr.pop_back();
-      // Update fitter state with removed vertex candidate
-      fitterState.updateTrkToVerticesMultiMap(allVerticesPtr);
 
-      // TODO: clean tracksAtVerticesMap maybe here? i.e. remove all entries
-      // with old vertex?
+      if (!m_cfg.refitAfterBadVertex) {
+        fitterState.vertexCollection = oldFitterState.vertexCollection;
+        fitterState.annealingState = oldFitterState.annealingState;
+        fitterState.vtxInfoMap.clear();
+        for (const auto& vtx : allVerticesPtr) {
+          fitterState.vtxInfoMap.insert(
+              std::make_pair(vtx, oldFitterState.vtxInfoMap[vtx]));
+        }
+        fitterState.trackToVerticesMultiMap =
+            oldFitterState.trackToVerticesMultiMap;
+        fitterState.tracksAtVerticesMap = oldFitterState.tracksAtVerticesMap;
+
+      } else {
+        // Update fitter state with removed vertex candidate
+        fitterState.updateTrkToVerticesMultiMap(allVerticesPtr);
+
+        // TODO: clean tracksAtVerticesMap maybe here? i.e. remove all entries
+        // with old vertex?
 
-      // Do the fit with removed vertex
-      auto fitResult = m_cfg.vertexFitter.fit(fitterState, allVerticesPtr,
-                                              m_cfg.linearizer, vFitterOptions);
-      if (!fitResult.ok()) {
-        return fitResult.error();
+        // Do the fit with removed vertex
+        auto fitResult = m_cfg.vertexFitter.fit(
+            fitterState, allVerticesPtr, m_cfg.linearizer, vFitterOptions);
+        if (!fitResult.ok()) {
+          return fitResult.error();
+        }
       }
     }
     iteration++;
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
index 819c1a9b4..388283435 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
@@ -223,8 +223,7 @@ Acts::Result<void> Acts::
       return res.error();
     }
     // Set ip3dParams for current trackAtVertex
-    currentVtxInfo.ip3dParams.insert(
-        std::make_pair(trk, std::move(res.value())));
+    currentVtxInfo.ip3dParams.insert(std::make_pair(trk, *(res.value())));
   }
   return {};
 }
@@ -254,11 +253,11 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::
       // Set ip3dParams for current trackAtVertex
       auto value = std::move(res.value());
 
-      currentVtxInfo.ip3dParams.insert(std::make_pair(trk, std::move(value)));
+      currentVtxInfo.ip3dParams.insert(std::make_pair(trk, *value));
     }
     // Set compatibility with current vertex
     auto compRes = m_cfg.ipEst.getVertexCompatibility(
-        geoContext, currentVtxInfo.ip3dParams.at(trk).get(),
+        geoContext, &(currentVtxInfo.ip3dParams.at(trk)),
         VectorHelpers::position(currentVtxInfo.oldPosition));
     if (!compRes.ok()) {
       return compRes.error();
@@ -304,8 +303,8 @@ Acts::Result<void> Acts::AdaptiveMultiVertexFitter<
         }
         // Update the vertex with the new track
         auto updateRes =
-            KalmanVertexUpdater::updateVertexWithTrack<input_track_t>(
-                vtx, trkAtVtx);
+            KalmanVertexUpdater::updateVertexWithTrack<input_track_t>(vtx,
+                                                                      trkAtVtx);
         if (!updateRes.ok()) {
           return updateRes.error();
         }
-- 
GitLab


From 39a5fbd753beecca91fb13730620ee0c825db7fd Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Sun, 1 Mar 2020 00:40:17 +0100
Subject: [PATCH 43/60] remove unnecessary const keyword in vector of
 BoundParameters

---
 Core/include/Acts/Vertexing/GaussianTrackDensity.hpp   | 10 ++++------
 Core/include/Acts/Vertexing/TrackDensity.hpp           |  8 ++++----
 .../Acts/Vertexing/TrackDensityVertexFinder.ipp        |  2 +-
 Core/src/Vertexing/GaussianTrackDensity.cpp            |  9 +++------
 4 files changed, 12 insertions(+), 17 deletions(-)

diff --git a/Core/include/Acts/Vertexing/GaussianTrackDensity.hpp b/Core/include/Acts/Vertexing/GaussianTrackDensity.hpp
index f30d03b78..6ac751d13 100644
--- a/Core/include/Acts/Vertexing/GaussianTrackDensity.hpp
+++ b/Core/include/Acts/Vertexing/GaussianTrackDensity.hpp
@@ -50,9 +50,8 @@ class GaussianTrackDensity {
   /// @param state The GaussianTrackDensity state
   ///
   /// @return The z position of the maximum
-  double globalMaximum(
-      const std::vector<const Acts::BoundParameters>& trackList,
-      State& state) const;
+  double globalMaximum(const std::vector<Acts::BoundParameters>& trackList,
+                       State& state) const;
 
   /// @brief Calculates the global maximum with width
   ///
@@ -61,8 +60,7 @@ class GaussianTrackDensity {
   ///
   /// @return The z position of the maximum and its width
   std::pair<double, double> globalMaximumWithWidth(
-      const std::vector<const Acts::BoundParameters>& trackList,
-      State& state) const;
+      const std::vector<Acts::BoundParameters>& trackList, State& state) const;
 
  private:
   /// The configuration
@@ -72,7 +70,7 @@ class GaussianTrackDensity {
   ///
   /// @param trackList The list of tracks
   /// @param state The GaussianTrackDensity state
-  void addTracks(const std::vector<const Acts::BoundParameters>& trackList,
+  void addTracks(const std::vector<Acts::BoundParameters>& trackList,
                  State& state) const;
 };
 }  // namespace Acts
diff --git a/Core/include/Acts/Vertexing/TrackDensity.hpp b/Core/include/Acts/Vertexing/TrackDensity.hpp
index 574439ec5..ad6d08cbe 100644
--- a/Core/include/Acts/Vertexing/TrackDensity.hpp
+++ b/Core/include/Acts/Vertexing/TrackDensity.hpp
@@ -66,9 +66,9 @@ class TrackDensity {
     }
   };
 
-  using TrackMap = std::map<BoundParameters, TrackEntry, predPerigee>;
-  using LowerMap = std::map<TrackEntry, BoundParameters, predEntryByMax>;
-  using UpperMap = std::map<TrackEntry, BoundParameters, predEntryByMin>;
+  using TrackMap = std::map<const BoundParameters, TrackEntry, predPerigee>;
+  using LowerMap = std::map<TrackEntry, const BoundParameters, predEntryByMax>;
+  using UpperMap = std::map<TrackEntry, const BoundParameters, predEntryByMin>;
 
   /// @brief The Config struct
   struct Config {
@@ -82,7 +82,7 @@ class TrackDensity {
     double maxZRange = 0;
 
     // Maps to cache track information
-    std::set<BoundParameters, predPerigee> trackSet;
+    std::set<const BoundParameters, predPerigee> trackSet;
     LowerMap lowerMap;
     UpperMap upperMap;
   };
diff --git a/Core/include/Acts/Vertexing/TrackDensityVertexFinder.ipp b/Core/include/Acts/Vertexing/TrackDensityVertexFinder.ipp
index d2e957f29..ed26c5631 100644
--- a/Core/include/Acts/Vertexing/TrackDensityVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/TrackDensityVertexFinder.ipp
@@ -13,7 +13,7 @@ auto Acts::TrackDensityVertexFinder<vfitter_t, track_density_t>::find(
     -> Result<std::vector<Vertex<InputTrack_t>>> {
   typename track_density_t::State densityState;
 
-  std::vector<const BoundParameters> trackList;
+  std::vector<BoundParameters> trackList;
   trackList.reserve(trackVector.size());
 
   for (const auto& trk : trackVector) {
diff --git a/Core/src/Vertexing/GaussianTrackDensity.cpp b/Core/src/Vertexing/GaussianTrackDensity.cpp
index b36a85c37..44a080f9c 100644
--- a/Core/src/Vertexing/GaussianTrackDensity.cpp
+++ b/Core/src/Vertexing/GaussianTrackDensity.cpp
@@ -9,22 +9,19 @@
 #include "Acts/Vertexing/GaussianTrackDensity.hpp"
 
 double Acts::GaussianTrackDensity::globalMaximum(
-    const std::vector<const Acts::BoundParameters>& trackList,
-    State& state) const {
+    const std::vector<Acts::BoundParameters>& trackList, State& state) const {
   addTracks(trackList, state);
   return state.trackDensity.globalMaximum(state.trackDensityState);
 }
 
 std::pair<double, double> Acts::GaussianTrackDensity::globalMaximumWithWidth(
-    const std::vector<const Acts::BoundParameters>& trackList,
-    State& state) const {
+    const std::vector<Acts::BoundParameters>& trackList, State& state) const {
   addTracks(trackList, state);
   return state.trackDensity.globalMaximumWithWidth(state.trackDensityState);
 }
 
 void Acts::GaussianTrackDensity::addTracks(
-    const std::vector<const Acts::BoundParameters>& trackList,
-    State& state) const {
+    const std::vector<Acts::BoundParameters>& trackList, State& state) const {
   const double d0SignificanceCut =
       m_cfg.d0MaxSignificance * m_cfg.d0MaxSignificance;
   const double z0SignificanceCut =
-- 
GitLab


From 62e55929ac0f5c833f1a7431e3ced8ffa5d2c5e9 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Sun, 1 Mar 2020 00:45:29 +0100
Subject: [PATCH 44/60] remove const value type from set

---
 Core/include/Acts/Vertexing/TrackDensity.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Core/include/Acts/Vertexing/TrackDensity.hpp b/Core/include/Acts/Vertexing/TrackDensity.hpp
index ad6d08cbe..dcef1c5f7 100644
--- a/Core/include/Acts/Vertexing/TrackDensity.hpp
+++ b/Core/include/Acts/Vertexing/TrackDensity.hpp
@@ -67,8 +67,8 @@ class TrackDensity {
   };
 
   using TrackMap = std::map<const BoundParameters, TrackEntry, predPerigee>;
-  using LowerMap = std::map<TrackEntry, const BoundParameters, predEntryByMax>;
-  using UpperMap = std::map<TrackEntry, const BoundParameters, predEntryByMin>;
+  using LowerMap = std::map<TrackEntry, BoundParameters, predEntryByMax>;
+  using UpperMap = std::map<TrackEntry, BoundParameters, predEntryByMin>;
 
   /// @brief The Config struct
   struct Config {
-- 
GitLab


From a8c4d2fb65dc008de66c44e1008e3cf783b51dc4 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Sun, 1 Mar 2020 00:51:36 +0100
Subject: [PATCH 45/60] remove unnecessary const keywords in set

---
 Core/include/Acts/Vertexing/TrackDensity.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Core/include/Acts/Vertexing/TrackDensity.hpp b/Core/include/Acts/Vertexing/TrackDensity.hpp
index dcef1c5f7..574439ec5 100644
--- a/Core/include/Acts/Vertexing/TrackDensity.hpp
+++ b/Core/include/Acts/Vertexing/TrackDensity.hpp
@@ -66,7 +66,7 @@ class TrackDensity {
     }
   };
 
-  using TrackMap = std::map<const BoundParameters, TrackEntry, predPerigee>;
+  using TrackMap = std::map<BoundParameters, TrackEntry, predPerigee>;
   using LowerMap = std::map<TrackEntry, BoundParameters, predEntryByMax>;
   using UpperMap = std::map<TrackEntry, BoundParameters, predEntryByMin>;
 
@@ -82,7 +82,7 @@ class TrackDensity {
     double maxZRange = 0;
 
     // Maps to cache track information
-    std::set<const BoundParameters, predPerigee> trackSet;
+    std::set<BoundParameters, predPerigee> trackSet;
     LowerMap lowerMap;
     UpperMap upperMap;
   };
-- 
GitLab


From 3ddae340efe6541e44706f669bddd9de46377bde Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Sun, 1 Mar 2020 01:04:47 +0100
Subject: [PATCH 46/60] clean unit tests from vectors of const objects

---
 Tests/UnitTests/Core/Vertexing/AMVFTestData.ipp               | 4 ++--
 .../Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp         | 2 +-
 .../Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp         | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Tests/UnitTests/Core/Vertexing/AMVFTestData.ipp b/Tests/UnitTests/Core/Vertexing/AMVFTestData.ipp
index f16726c13..efb94b0be 100644
--- a/Tests/UnitTests/Core/Vertexing/AMVFTestData.ipp
+++ b/Tests/UnitTests/Core/Vertexing/AMVFTestData.ipp
@@ -24,8 +24,8 @@ using Covariance = Acts::BoundSymMatrix;
 
 GeometryContext gctx = GeometryContext();
 // Return all tracks of one single event as reconstructed in athena.
-std::vector<const BoundParameters> getAthenaTracks() {
-  std::vector<const BoundParameters> tracks;
+std::vector<BoundParameters> getAthenaTracks() {
+  std::vector<BoundParameters> tracks;
 
   std::shared_ptr<PerigeeSurface> perigeeSurface =
       Surface::makeShared<PerigeeSurface>(Vector3D(0, 0, 0));
diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
index a43117db2..105c59607 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFinderTests.cpp
@@ -101,7 +101,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_finder_test) {
 
   Finder finder(finderConfig);
 
-  std::vector<const BoundParameters> tracks = getAthenaTracks();
+  auto tracks = getAthenaTracks();
 
   if (debugMode) {
     std::cout << "Number of tracks in event: " << tracks.size() << std::endl;
diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
index 5d482bf36..92a38873c 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
@@ -135,7 +135,7 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test) {
     vtxPtrList.push_back(&vtx);
   }
 
-  std::vector<const BoundParameters> allTracks;
+  std::vector<BoundParameters> allTracks;
 
   unsigned int nTracksPerVtx = 4;
   // Construct nTracksPerVtx * 3 (3 vertices) random track emerging
-- 
GitLab


From 8bbdec14f4f69088a9f195db290072ac6acb3a43 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Mon, 2 Mar 2020 19:16:16 +0100
Subject: [PATCH 47/60] performance updates in KalmanVertexUpdater

---
 .../Vertexing/AdaptiveMultiVertexFitter.hpp   |   2 +-
 .../Vertexing/AdaptiveMultiVertexFitter.ipp   |  19 +---
 .../Acts/Vertexing/HelicalTrackLinearizer.ipp |  28 +++--
 .../Vertexing/KalmanVertexTrackUpdater.ipp    |  22 ++--
 .../Acts/Vertexing/KalmanVertexUpdater.hpp    |  30 +++--
 .../Acts/Vertexing/KalmanVertexUpdater.ipp    | 106 +++++++-----------
 .../Vertexing/KalmanVertexUpdaterTests.cpp    |   5 +-
 7 files changed, 93 insertions(+), 119 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
index 70fedf60c..334a35ac0 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
@@ -278,7 +278,7 @@ class AdaptiveMultiVertexFitter {
   /// @param trk The track
   ///
   /// @return Vector of compatibility values
-  Result<std::vector<double>> collectTrackToVertexCompatibilities(
+  std::vector<double> collectTrackToVertexCompatibilities(
       State& state, const InputTrack_t* trk) const;
 
   /// @brief Determines if vertex position has shifted more than
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
index 388283435..bd3755220 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
@@ -278,14 +278,10 @@ Acts::Result<void> Acts::AdaptiveMultiVertexFitter<
     for (const auto& trk : currentVtxInfo.trackLinks) {
       auto& trkAtVtx = state.tracksAtVerticesMap.at(std::make_pair(trk, vtx));
 
-      // Get all compatibilities of track to all vertices it is attached to
-      auto collectRes = collectTrackToVertexCompatibilities(state, trk);
-      if (!collectRes.ok()) {
-        return collectRes.error();
-      }
       // Set trackWeight for current track
       double currentTrkWeight = m_cfg.annealingTool.getWeight(
-          state.annealingState, trkAtVtx.vertexCompatibility, *collectRes);
+          state.annealingState, trkAtVtx.vertexCompatibility,
+          collectTrackToVertexCompatibilities(state, trk));
       trkAtVtx.trackWeight = currentTrkWeight;
 
       if (trkAtVtx.trackWeight > m_cfg.minWeight) {
@@ -302,12 +298,8 @@ Acts::Result<void> Acts::AdaptiveMultiVertexFitter<
           state.vtxInfoMap[vtx].linPoint = state.vtxInfoMap[vtx].oldPosition;
         }
         // Update the vertex with the new track
-        auto updateRes =
-            KalmanVertexUpdater::updateVertexWithTrack<input_track_t>(vtx,
-                                                                      trkAtVtx);
-        if (!updateRes.ok()) {
-          return updateRes.error();
-        }
+        KalmanVertexUpdater::updateVertexWithTrack<input_track_t>(vtx,
+                                                                  trkAtVtx);
       } else {
         ACTS_VERBOSE("Track weight too low. Skip track.");
       }
@@ -320,11 +312,12 @@ Acts::Result<void> Acts::AdaptiveMultiVertexFitter<
 }
 
 template <typename input_track_t, typename linearizer_t>
-Acts::Result<std::vector<double>>
+std::vector<double>
 Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::
     collectTrackToVertexCompatibilities(State& state,
                                         const input_track_t* trk) const {
   std::vector<double> trkToVtxCompatibilities;
+  trkToVtxCompatibilities.reserve(state.vertexCollection.size());
   auto range = state.trackToVerticesMultiMap.equal_range(trk);
 
   for (auto vtxIter = range.first; vtxIter != range.second; ++vtxIter) {
diff --git a/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp b/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp
index cd794c47a..342c9037c 100644
--- a/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp
+++ b/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp
@@ -47,8 +47,8 @@ Acts::Result<Acts::LinearizedTrack> Acts::
 
   // theta and functions
   double th = paramsAtPCA(ParID_t::eTHETA);
-  double sinTh = std::sin(th);
-  double tanTh = std::tan(th);
+  const double sinTh = std::sin(th);
+  const double tanTh = std::tan(th);
 
   // q over p
   double qOvP = paramsAtPCA(ParID_t::eQOP);
@@ -73,8 +73,8 @@ Acts::Result<Acts::LinearizedTrack> Acts::
   // Eq. 5.34 in Ref(1) (see .hpp)
   double X = positionAtPCA(0) - linPointPos.x() + rho * sinPhiV;
   double Y = positionAtPCA(1) - linPointPos.y() - rho * cosPhiV;
-  double S2 = (X * X + Y * Y);
-  double S = std::sqrt(S2);
+  const double S2 = (X * X + Y * Y);
+  const double S = std::sqrt(S2);
 
   /// F(V, p_i) at PCA in Billoir paper
   /// (see FullBilloirVertexFitter.hpp for paper reference,
@@ -110,9 +110,11 @@ Acts::Result<Acts::LinearizedTrack> Acts::
   positionJacobian(0, 0) = -sgnH * X / S;
   positionJacobian(0, 1) = -sgnH * Y / S;
 
+  const double S2tanTh = S2 * tanTh;
+
   // Second row
-  positionJacobian(1, 0) = rho * Y / (tanTh * S2);
-  positionJacobian(1, 1) = -rho * X / (tanTh * S2);
+  positionJacobian(1, 0) = rho * Y / S2tanTh;
+  positionJacobian(1, 1) = -rho * X / S2tanTh;
   positionJacobian(1, 2) = 1.;
 
   // Third row
@@ -139,15 +141,17 @@ Acts::Result<Acts::LinearizedTrack> Acts::
   momentumJacobian(0, 1) = qOvSred * rho / tanTh;
   momentumJacobian(0, 2) = -qOvSred * rho / qOvP;
 
+  const double rhoOverS2 = rho / S2;
+
   // Second row
-  momentumJacobian(1, 0) = (1 - rho * Q / S2) * rho / tanTh;
-  momentumJacobian(1, 1) = (dPhi + rho * R / (S2 * tanTh * tanTh)) * rho;
-  momentumJacobian(1, 2) = (dPhi - rho * R / S2) * rho / (qOvP * tanTh);
+  momentumJacobian(1, 0) = (1 - rhoOverS2 * Q) * rho / tanTh;
+  momentumJacobian(1, 1) = (dPhi + rho * R / (S2tanTh * tanTh)) * rho;
+  momentumJacobian(1, 2) = (dPhi - rhoOverS2 * R) * rho / (qOvP * tanTh);
 
   // Third row
-  momentumJacobian(2, 0) = rho * Q / S2;
-  momentumJacobian(2, 1) = -rho * R / (S2 * tanTh);
-  momentumJacobian(2, 2) = rho * R / (qOvP * S2);
+  momentumJacobian(2, 0) = rhoOverS2 * Q;
+  momentumJacobian(2, 1) = -rho * R / S2tanTh;
+  momentumJacobian(2, 2) = rhoOverS2 * R / qOvP;
 
   // Last two rows:
   momentumJacobian(3, 1) = 1.;
diff --git a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
index d8e60721d..10df70791 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
+++ b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
@@ -66,23 +66,21 @@ Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
   auto newTrkCov =
       -vtxCov * posJac.transpose() * trkParamWeight * momJac * sMat;
 
-  // Now determine the smoothed chi2 of the track in the following
-  auto res = KalmanVertexUpdater::updatePosition<input_track_t>(
-      vtx, linTrack, track.trackWeight, -1);
-
-  if (!res.ok()) {
-    return res.error();
-  }
+  Vector3D newVertexPos = Vector3D::Zero();
+  ActsSymMatrixD<3> newVertexCov = ActsSymMatrixD<3>::Zero();
+  ActsSymMatrixD<3> oldVertexWeight = ActsSymMatrixD<3>::Zero();
+  ActsSymMatrixD<5> tempWeight = ActsSymMatrixD<5>::Zero();
 
-  Vertex<input_track_t> reducedVtx = *res;
+  // Now determine the smoothed chi2 of the track in the following
+  KalmanVertexUpdater::updatePosition<input_track_t>(
+      vtx, linTrack, track.trackWeight, -1, newVertexPos, newVertexCov,
+      oldVertexWeight, tempWeight);
 
   // Corresponding weight matrix
-  const auto reducedVtxWeight =
-      (reducedVtx.fullCovariance().template block<3, 3>(0, 0)).inverse();
+  const auto reducedVtxWeight = newVertexCov.inverse();
 
   // Difference in positions
-  auto posDiff =
-      (vtx->fullPosition() - reducedVtx.fullPosition()).template head<3>();
+  auto posDiff = vtx->position() - newVertexPos;
 
   // Get smoothed params
   auto smParams =
diff --git a/Core/include/Acts/Vertexing/KalmanVertexUpdater.hpp b/Core/include/Acts/Vertexing/KalmanVertexUpdater.hpp
index 3d5d1c033..efb5a98b6 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexUpdater.hpp
+++ b/Core/include/Acts/Vertexing/KalmanVertexUpdater.hpp
@@ -31,8 +31,8 @@ namespace KalmanVertexUpdater {
 /// @param vtx Vertex to be updated
 /// @param trk Track to be used for updating the vertex
 template <typename input_track_t>
-Result<void> updateVertexWithTrack(Vertex<input_track_t>* vtx,
-                                   TrackAtVertex<input_track_t>& trk);
+void updateVertexWithTrack(Vertex<input_track_t>* vtx,
+                           TrackAtVertex<input_track_t>& trk);
 
 /// @brief Updates vertex position
 ///
@@ -40,34 +40,44 @@ Result<void> updateVertexWithTrack(Vertex<input_track_t>* vtx,
 /// @param linTrack Linearized version of track to be added or removed
 /// @param trackWeight Track weight
 /// @param sign +1 (add track) or -1 (remove track)
+/// @param[out] newVtxPos The new vertex position
+/// @param[out] newVtxCov The new vertex covariance
+/// @param[out] oldVtxWeight The old vertex weight
+/// @param[out] trkParamWeight The track parameter weight
 ///
 /// @return Vertex with updated position and covariance
 template <typename input_track_t>
-Result<Vertex<input_track_t>> updatePosition(const Vertex<input_track_t>* vtx,
-                                             const LinearizedTrack& linTrack,
-                                             double trackWeight, int sign);
+void updatePosition(const Acts::Vertex<input_track_t>* vtx,
+                    const Acts::LinearizedTrack& linTrack, double trackWeight,
+                    int sign, Vector3D& newVtxPos, ActsSymMatrixD<3>& newVtxCov,
+                    ActsSymMatrixD<3>& oldVtxWeight,
+                    ActsSymMatrixD<5>& trkParamWeight);
 
 namespace detail {
 /// @brief Takes old and new vtx and calculates position chi2
 ///
 /// @param oldVtx Old vertex
 /// @param newVtx New vertex
+/// @param oldVertexWeight The old vertex weight
 ///
 /// @return Chi2
 template <typename input_track_t>
 double vertexPositionChi2(const Vertex<input_track_t>* oldVtx,
-                          const Vertex<input_track_t>* newVtx);
+                          const Vector3D& newVtxPos,
+                          const ActsSymMatrixD<3>& oldVertexWeight);
 
 /// @brief Calculates chi2 of refitted track parameters
 /// w.r.t. updated vertex
 ///
 /// @param vtx The already updated vertex
 /// @param linTrack Linearized version of track
+/// @param trkParamWeight The track parameter weight
 ///
 /// @return Chi2
 template <typename input_track_t>
-double trackParametersChi2(const Vertex<input_track_t>& vtx,
-                           const LinearizedTrack& linTrack);
+double trackParametersChi2(const Vector3D& vtxPos,
+                           const LinearizedTrack& linTrack,
+                           const ActsSymMatrixD<5>& trkParamWeight);
 
 /// @brief Adds or removes (depending on `sign`) tracks from vertex
 /// and updates the vertex
@@ -76,8 +86,8 @@ double trackParametersChi2(const Vertex<input_track_t>& vtx,
 /// @param trk Track to be added to/removed from vtx
 /// @param sign +1 (add track) or -1 (remove track)
 template <typename input_track_t>
-Result<void> update(Vertex<input_track_t>* vtx,
-                    TrackAtVertex<input_track_t>& trk, int sign);
+void update(Vertex<input_track_t>* vtx, TrackAtVertex<input_track_t>& trk,
+            int sign);
 }  // Namespace detail
 
 }  // Namespace KalmanVertexUpdater
diff --git a/Core/include/Acts/Vertexing/KalmanVertexUpdater.ipp b/Core/include/Acts/Vertexing/KalmanVertexUpdater.ipp
index c20b29f4c..71cec0186 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexUpdater.ipp
+++ b/Core/include/Acts/Vertexing/KalmanVertexUpdater.ipp
@@ -10,30 +10,17 @@
 #include "Acts/Vertexing/VertexingError.hpp"
 
 template <typename input_track_t>
-Acts::Result<void> Acts::KalmanVertexUpdater::updateVertexWithTrack(
+void Acts::KalmanVertexUpdater::updateVertexWithTrack(
     Vertex<input_track_t>* vtx, TrackAtVertex<input_track_t>& trk) {
-  if (vtx == nullptr) {
-    return VertexingError::EmptyInput;
-  }
-
-  auto res = detail::update<input_track_t>(vtx, trk, 1);
-
-  if (!res.ok()) {
-    return res.error();
-  }
-
-  return {};
+  detail::update<input_track_t>(vtx, trk, 1);
 }
 
 template <typename input_track_t>
-Acts::Result<Acts::Vertex<input_track_t>>
-Acts::KalmanVertexUpdater::updatePosition(
+void Acts::KalmanVertexUpdater::updatePosition(
     const Acts::Vertex<input_track_t>* vtx,
-    const Acts::LinearizedTrack& linTrack, double trackWeight, int sign) {
-  if (vtx == nullptr) {
-    return VertexingError::EmptyInput;
-  }
-
+    const Acts::LinearizedTrack& linTrack, double trackWeight, int sign,
+    Vector3D& newVtxPos, ActsSymMatrixD<3>& newVtxCov,
+    ActsSymMatrixD<3>& oldVtxWeight, ActsSymMatrixD<5>& trkParamWeight) {
   // Retrieve linTrack information
   // To make 4-D compatible, remove block<> and head<> statements
   const auto& posJac = linTrack.positionJacobian.block<5, 3>(0, 0);
@@ -41,12 +28,12 @@ Acts::KalmanVertexUpdater::updatePosition(
       linTrack.momentumJacobian.block<5, 3>(0, 0);  // B_k in comments below
   const auto& trkParams = linTrack.parametersAtPCA.head<5>();
   const auto& constTerm = linTrack.constantTerm.head<5>();
-  const auto& trkParamWeight = (linTrack.covarianceAtPCA.block<5, 5>(0, 0))
-                                   .inverse();  // G_k in comments below
+  trkParamWeight = (linTrack.covarianceAtPCA.block<5, 5>(0, 0))
+                       .inverse();  // G_k in comments below
 
   // Vertex to be updated
   const auto& oldVtxPos = vtx->position();
-  const auto& oldVtxWeight = (vtx->covariance()).inverse().eval();
+  oldVtxWeight = (vtx->covariance()).inverse();
 
   // W_k matrix
   ActsSymMatrixD<3> wMat =
@@ -57,62 +44,48 @@ Acts::KalmanVertexUpdater::updatePosition(
                                     (momJac * (wMat * momJac.transpose())) *
                                     trkParamWeight.transpose();
   // New vertex cov matrix
-  auto newVtxCov = (oldVtxWeight +
-                    trackWeight * sign * posJac.transpose() * (gBmat * posJac))
-                       .inverse();
+  newVtxCov = (oldVtxWeight +
+               trackWeight * sign * posJac.transpose() * (gBmat * posJac))
+                  .inverse();
+
   // New vertex position
-  auto newVtxPos = newVtxCov * (oldVtxWeight * oldVtxPos +
-                                trackWeight * sign * posJac.transpose() *
-                                    gBmat * (trkParams - constTerm));
-  // Create return vertex with new position
-  // and covariance, but w/o tracks
-  Vertex<input_track_t> returnVertex;
-
-  // Set position
-  returnVertex.setPosition(newVtxPos);
-  // Set cov
-  returnVertex.setCovariance(newVtxCov);
-  // Set fit quality
-  returnVertex.setFitQuality(vtx->fitQuality().first, vtx->fitQuality().second);
-
-  return returnVertex;
+  newVtxPos = newVtxCov * (oldVtxWeight * oldVtxPos +
+                           trackWeight * sign * posJac.transpose() * gBmat *
+                               (trkParams - constTerm));
 }
 
 template <typename input_track_t>
 double Acts::KalmanVertexUpdater::detail::vertexPositionChi2(
-    const Vertex<input_track_t>* oldVtx, const Vertex<input_track_t>* newVtx) {
-  auto oldWeight =
-      (oldVtx->fullCovariance().template block<3, 3>(0, 0)).inverse();
-  auto posDiff =
-      (newVtx->fullPosition() - oldVtx->fullPosition()).template head<3>();
+    const Vertex<input_track_t>* oldVtx, const Vector3D& newVtxPos,
+    const ActsSymMatrixD<3>& oldVertexWeight) {
+  auto posDiff = newVtxPos - oldVtx->position();
 
   // Calculate and return corresponding chi2
-  return posDiff.transpose() * (oldWeight * posDiff);
+  return posDiff.transpose() * (oldVertexWeight * posDiff);
 }
 
 template <typename input_track_t>
 double Acts::KalmanVertexUpdater::detail::trackParametersChi2(
-    const Vertex<input_track_t>& vtx, const LinearizedTrack& linTrack) {
-  const auto& vtxPos = vtx.fullPosition().template head<3>();
-
+    const Vector3D& vtxPos, const LinearizedTrack& linTrack,
+    const ActsSymMatrixD<5>& trkParamWeight) {
   // Track properties
   const auto& posJac = linTrack.positionJacobian.block<5, 3>(0, 0);
   const auto& momJac = linTrack.momentumJacobian.block<5, 3>(0, 0);
   const auto& trkParams = linTrack.parametersAtPCA.head<5>();
   const auto& constTerm = linTrack.constantTerm.head<5>();
-  const auto& trkParamWeight =
-      linTrack.covarianceAtPCA.block<5, 5>(0, 0).inverse();
 
   // Calculate temp matrix S
   ActsSymMatrixD<3> matS =
       (momJac.transpose() * (trkParamWeight * momJac)).inverse();
 
+  const auto jacVtx = posJac * vtxPos;
+
   // Refitted track momentum
   Vector3D newTrackMomentum = matS * momJac.transpose() * trkParamWeight *
-                              (trkParams - constTerm - posJac * vtxPos);
+                              (trkParams - constTerm - jacVtx);
 
   // Refitted track parameters
-  auto newTrkParams = constTerm + posJac * vtxPos + momJac * newTrackMomentum;
+  auto newTrkParams = constTerm + jacVtx + momJac * newTrackMomentum;
 
   // Parameter difference
   auto paramDiff = trkParams - newTrkParams;
@@ -122,17 +95,17 @@ double Acts::KalmanVertexUpdater::detail::trackParametersChi2(
 }
 
 template <typename input_track_t>
-Acts::Result<void> Acts::KalmanVertexUpdater::detail::update(
+void Acts::KalmanVertexUpdater::detail::update(
     Vertex<input_track_t>* vtx, TrackAtVertex<input_track_t>& trk, int sign) {
   double trackWeight = trk.trackWeight;
 
-  auto res = updatePosition(vtx, trk.linearizedState, trackWeight, sign);
+  Vector3D newVertexPos = Vector3D::Zero();
+  ActsSymMatrixD<3> newVertexCov = ActsSymMatrixD<3>::Zero();
+  ActsSymMatrixD<3> oldVertexWeight = ActsSymMatrixD<3>::Zero();
+  ActsSymMatrixD<5> trkParamWeight = ActsSymMatrixD<5>::Zero();
 
-  if (!res.ok()) {
-    return res.error();
-  }
-
-  Vertex<input_track_t> tempVtx = *res;
+  updatePosition(vtx, trk.linearizedState, trackWeight, sign, newVertexPos,
+                 newVertexCov, oldVertexWeight, trkParamWeight);
 
   // Get fit quality parameters wrt to old vertex
   std::pair fitQuality = vtx->fitQuality();
@@ -140,19 +113,20 @@ Acts::Result<void> Acts::KalmanVertexUpdater::detail::update(
   double ndf = fitQuality.second;
 
   // Chi2 wrt to track parameters
-  double trkChi2 =
-      detail::trackParametersChi2<input_track_t>(tempVtx, trk.linearizedState);
+  double trkChi2 = detail::trackParametersChi2<input_track_t>(
+      newVertexPos, trk.linearizedState, trkParamWeight);
 
   // Calculate new chi2
-  chi2 += sign * (detail::vertexPositionChi2<input_track_t>(vtx, &tempVtx) +
+  chi2 += sign * (detail::vertexPositionChi2<input_track_t>(vtx, newVertexPos,
+                                                            oldVertexWeight) +
                   trackWeight * trkChi2);
 
   // Calculate ndf
   ndf += sign * trackWeight * 2.;
 
   // Updating the vertex
-  vtx->setFullPosition(tempVtx.fullPosition());
-  vtx->setFullCovariance(tempVtx.fullCovariance());
+  vtx->setPosition(newVertexPos);
+  vtx->setCovariance(newVertexCov);
   vtx->setFitQuality(chi2, ndf);
 
   // Updates track at vertex if already there
@@ -167,6 +141,4 @@ Acts::Result<void> Acts::KalmanVertexUpdater::detail::update(
   if (sign < 0) {
     trk.trackWeight = 0;
   }
-
-  return {};
 }
diff --git a/Tests/UnitTests/Core/Vertexing/KalmanVertexUpdaterTests.cpp b/Tests/UnitTests/Core/Vertexing/KalmanVertexUpdaterTests.cpp
index f9a9563ef..4afde035d 100644
--- a/Tests/UnitTests/Core/Vertexing/KalmanVertexUpdaterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/KalmanVertexUpdaterTests.cpp
@@ -145,10 +145,7 @@ BOOST_AUTO_TEST_CASE(Kalman_Vertex_Updater) {
     vtx.setFullCovariance(SpacePointSymMatrix::Identity() * 0.01);
 
     // Update trkAtVertex with assumption of originating from vtx
-    auto res = KalmanVertexUpdater::updateVertexWithTrack<BoundParameters>(
-        &vtx, trkAtVtx);
-
-    BOOST_CHECK(res.ok());
+    KalmanVertexUpdater::updateVertexWithTrack<BoundParameters>(&vtx, trkAtVtx);
 
     if (debug) {
       std::cout << "Old vertex position: " << vtxPos << std::endl;
-- 
GitLab


From 773bd07ea55da8c5fb850398e71339f80e5b5c39 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Wed, 4 Mar 2020 22:38:43 +0100
Subject: [PATCH 48/60] initialize uninitialized iterator bug fix

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   |  2 --
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 24 +++++++++----------
 2 files changed, 11 insertions(+), 15 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index 0656a2b91..e8ad766a4 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -150,8 +150,6 @@ class AdaptiveMultiVertexFinder {
 
   };  // Config struct
 
-  struct State {};
-
   /// @brief Constructor used if InputTrack_t type == BoundParameters
   ///
   /// @param cfg Configuration object
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index b9822c1d4..785cb1fce 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -369,10 +369,9 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
          !m_cfg.useFastCompatibility)) {
       // TODO: Understand why looking for compatible tracks only in seed tracks
       // and not also in all tracks
-      auto foundIter = std::find_if(
-          seedTracks.begin(), seedTracks.end(), [&trk, this](auto seedTrk) {
-            return m_extractParameters(*trk) == m_extractParameters(*seedTrk);
-          });
+      auto foundIter =
+          std::find_if(seedTracks.begin(), seedTracks.end(),
+                       [&trk, this](auto seedTrk) { return trk == seedTrk; });
       if (foundIter != seedTracks.end()) {
         nCompatibleTracks++;
         ACTS_DEBUG("Compatible track found.");
@@ -404,10 +403,9 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
          trkAtVtx.chi2Track < m_cfg.maxVertexChi2 &&
          !m_cfg.useFastCompatibility)) {
       // Find and remove track from seedTracks
-      auto foundSeedIter = std::find_if(
-          seedTracks.begin(), seedTracks.end(), [&trk, this](auto seedTrk) {
-            return m_extractParameters(*trk) == m_extractParameters(*seedTrk);
-          });
+      auto foundSeedIter =
+          std::find_if(seedTracks.begin(), seedTracks.end(),
+                       [&trk, this](auto seedTrk) { return trk == seedTrk; });
       if (foundSeedIter != seedTracks.end()) {
         seedTracks.erase(foundSeedIter);
       }
@@ -422,7 +420,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
         FitterState_t& fitterState) const -> bool {
   // Try to find the track with highest compatibility
   double maxCompatibility = 0;
-  typename std::vector<const InputTrack_t*>::iterator maxCompSeedIt;
+  typename std::vector<const InputTrack_t*>::iterator maxCompSeedIt =
+      seedTracks.end();
 
   for (const auto& trk : fitterState.vtxInfoMap[vtx].trackLinks) {
     const auto& trkAtVtx =
@@ -430,10 +429,9 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     double compatibility = trkAtVtx.vertexCompatibility;
     if (compatibility > maxCompatibility) {
       // Try to find track in seed tracks
-      auto foundSeedIter = std::find_if(
-          seedTracks.begin(), seedTracks.end(), [&trk, this](auto seedTrk) {
-            return m_extractParameters(*trk) == m_extractParameters(*seedTrk);
-          });
+      auto foundSeedIter =
+          std::find_if(seedTracks.begin(), seedTracks.end(),
+                       [&trk, this](auto seedTrk) { return trk == seedTrk; });
       if (foundSeedIter != seedTracks.end()) {
         maxCompatibility = compatibility;
         maxCompSeedIt = foundSeedIter;
-- 
GitLab


From 9ff7ee84e7bd8cfa6da66bf7d0fe1e4aed07a9f3 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Thu, 5 Mar 2020 13:17:19 +0100
Subject: [PATCH 49/60] move removeLastVertex functionality to separate method

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   | 17 +++++
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 75 +++++++++++--------
 2 files changed, 61 insertions(+), 31 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index e8ad766a4..ae9923fff 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -16,6 +16,7 @@
 #include "Acts/Vertexing/AMVFInfo.hpp"
 #include "Acts/Vertexing/TrackToVertexIPEstimator.hpp"
 #include "Acts/Vertexing/VertexFinderOptions.hpp"
+#include "Acts/Vertexing/VertexFitterOptions.hpp"
 
 namespace Acts {
 /// @class AdaptiveMultiVertexFinder
@@ -339,6 +340,22 @@ class AdaptiveMultiVertexFinder {
       const Vertex<InputTrack_t>* vtx,
       const std::vector<Vertex<InputTrack_t>*>& allVertices) const;
 
+  /// @brief Method that deletes last vertex from list of all vertices
+  /// and either refits all vertices afterwards (if refitAfterBadVertex)
+  /// of reverts to the old state of the vertex fitter before the bad
+  /// vertex was added to the fit (if not refitAfterBadVertex).
+  ///
+  /// @param allVertices Vector containing the unique_ptr to vertices
+  /// @param allVerticesPtr Vector containing the actual addresses
+  /// @param fitterState The current vertex fitter state
+  /// @param oldFitterState The old vertex fitter state
+  /// @param vFitterOptions The vertex fitter options
+  Result<void> deleteLastVertex(
+      std::vector<std::unique_ptr<Vertex<InputTrack_t>>>& allVertices,
+      std::vector<Vertex<InputTrack_t>*>& allVerticesPtr,
+      FitterState_t& fitterState, FitterState_t& oldFitterState,
+      const VertexFitterOptions<InputTrack_t>& vFitterOptions) const;
+
   /// @brief Prepares the output vector of vertices
   ///
   /// @param allVerticesPtr Vector of pointers to vertices
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index 785cb1fce..f41e1e8b3 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -6,7 +6,6 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-#include "Acts/Vertexing/VertexFitterOptions.hpp"
 #include "Acts/Vertexing/VertexingError.hpp"
 
 template <typename vfitter_t, typename sfinder_t>
@@ -91,7 +90,6 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     }
     ACTS_DEBUG("New position of current vertex candidate after fit: "
                << vtxCandidate->fullPosition());
-
     // Check if vertex is good vertex
     bool isGoodVertex = false;
     int nCompatibleTracks = 0;
@@ -106,7 +104,6 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
       bool removedNonCompatibleTrack =
           canRemoveNonCompatibleTrackFromSeedTracks(vtxCandidate, seedTracks,
                                                     fitterState);
-
       if (!removedNonCompatibleTrack) {
         ACTS_DEBUG(
             "Could not remove any further track from seed tracks. Break.");
@@ -121,34 +118,11 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
 
     // Delete vertex from allVertices list again if it's not kept
     if (not keepVertex) {
-      allVertices.pop_back();
-      allVerticesPtr.pop_back();
-
-      if (!m_cfg.refitAfterBadVertex) {
-        fitterState.vertexCollection = oldFitterState.vertexCollection;
-        fitterState.annealingState = oldFitterState.annealingState;
-        fitterState.vtxInfoMap.clear();
-        for (const auto& vtx : allVerticesPtr) {
-          fitterState.vtxInfoMap.insert(
-              std::make_pair(vtx, oldFitterState.vtxInfoMap[vtx]));
-        }
-        fitterState.trackToVerticesMultiMap =
-            oldFitterState.trackToVerticesMultiMap;
-        fitterState.tracksAtVerticesMap = oldFitterState.tracksAtVerticesMap;
-
-      } else {
-        // Update fitter state with removed vertex candidate
-        fitterState.updateTrkToVerticesMultiMap(allVerticesPtr);
-
-        // TODO: clean tracksAtVerticesMap maybe here? i.e. remove all entries
-        // with old vertex?
-
-        // Do the fit with removed vertex
-        auto fitResult = m_cfg.vertexFitter.fit(
-            fitterState, allVerticesPtr, m_cfg.linearizer, vFitterOptions);
-        if (!fitResult.ok()) {
-          return fitResult.error();
-        }
+      auto deleteVertexResult =
+          deleteLastVertex(allVertices, allVerticesPtr, fitterState,
+                           oldFitterState, vFitterOptions);
+      if (not deleteVertexResult.ok()) {
+        return deleteVertexResult.error();
       }
     }
     iteration++;
@@ -543,6 +517,45 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::isMergedVertex(
   return false;
 }
 
+template <typename vfitter_t, typename sfinder_t>
+auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::deleteLastVertex(
+    std::vector<std::unique_ptr<Vertex<InputTrack_t>>>& allVertices,
+    std::vector<Vertex<InputTrack_t>*>& allVerticesPtr,
+    FitterState_t& fitterState, FitterState_t& oldFitterState,
+    const VertexFitterOptions<InputTrack_t>& vFitterOptions) const
+    -> Result<void> {
+  allVertices.pop_back();
+  allVerticesPtr.pop_back();
+
+  if (!m_cfg.refitAfterBadVertex) {
+    fitterState.vertexCollection = oldFitterState.vertexCollection;
+    fitterState.annealingState = oldFitterState.annealingState;
+    fitterState.vtxInfoMap.clear();
+    for (const auto& vtx : allVerticesPtr) {
+      fitterState.vtxInfoMap.insert(
+          std::make_pair(vtx, oldFitterState.vtxInfoMap[vtx]));
+    }
+    fitterState.trackToVerticesMultiMap =
+        oldFitterState.trackToVerticesMultiMap;
+    fitterState.tracksAtVerticesMap = oldFitterState.tracksAtVerticesMap;
+
+  } else {
+    // Update fitter state with removed vertex candidate
+    fitterState.updateTrkToVerticesMultiMap(allVerticesPtr);
+
+    // TODO: clean tracksAtVerticesMap maybe here? i.e. remove all entries
+    // with old vertex?
+
+    // Do the fit with removed vertex
+    auto fitResult = m_cfg.vertexFitter.fit(fitterState, allVerticesPtr,
+                                            m_cfg.linearizer, vFitterOptions);
+    if (!fitResult.ok()) {
+      return fitResult.error();
+    }
+  }
+  return {};
+}
+
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::getVertexOutputList(
     const std::vector<Vertex<InputTrack_t>*>& allVerticesPtr,
-- 
GitLab


From 0af41588eae5d426a6592e2f566dea3e22284dcf Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Fri, 6 Mar 2020 15:36:43 +0100
Subject: [PATCH 50/60] store track cov inverse in LinearizedTrack and
 introduce cache object to KalmanVertexUpdater

---
 .../Vertexing/FullBilloirVertexFitter.ipp     |  17 +-
 .../Acts/Vertexing/HelicalTrackLinearizer.ipp |   9 +-
 .../Vertexing/KalmanVertexTrackUpdater.ipp    |  15 +-
 .../Acts/Vertexing/KalmanVertexUpdater.hpp    |  34 ++--
 .../Acts/Vertexing/KalmanVertexUpdater.ipp    | 147 ++++++++----------
 .../Acts/Vertexing/LinearizedTrack.hpp        |   3 +
 6 files changed, 112 insertions(+), 113 deletions(-)

diff --git a/Core/include/Acts/Vertexing/FullBilloirVertexFitter.ipp b/Core/include/Acts/Vertexing/FullBilloirVertexFitter.ipp
index 50c6f12e6..5c65f5543 100644
--- a/Core/include/Acts/Vertexing/FullBilloirVertexFitter.ipp
+++ b/Core/include/Acts/Vertexing/FullBilloirVertexFitter.ipp
@@ -116,12 +116,13 @@ Acts::FullBilloirVertexFitter<input_track_t, linearizer_t>::fit(
 
       auto result = linearizer.linearizeTrack(trackParams, linPoint);
       if (result.ok()) {
-        const auto linTrack = *result;
-        double d0 = linTrack.parametersAtPCA[ParID_t::eLOC_D0];
-        double z0 = linTrack.parametersAtPCA[ParID_t::eLOC_Z0];
-        double phi = linTrack.parametersAtPCA[ParID_t::ePHI];
-        double theta = linTrack.parametersAtPCA[ParID_t::eTHETA];
-        double qOverP = linTrack.parametersAtPCA[ParID_t::eQOP];
+        const auto& linTrack = *result;
+        const auto& parametersAtPCA = linTrack.parametersAtPCA;
+        double d0 = parametersAtPCA[ParID_t::eLOC_D0];
+        double z0 = parametersAtPCA[ParID_t::eLOC_Z0];
+        double phi = parametersAtPCA[ParID_t::ePHI];
+        double theta = parametersAtPCA[ParID_t::eTHETA];
+        double qOverP = parametersAtPCA[ParID_t::eQOP];
 
         // calculate f(V_0,p_0)  f_d0 = f_z0 = 0
         double fPhi = trackMomenta[iTrack][0];
@@ -143,7 +144,7 @@ Acts::FullBilloirVertexFitter<input_track_t, linearizer_t>::fit(
         // cache some matrix multiplications
         BoundToSpacePointMatrix DtWmat;
         ActsMatrixD<3, BoundParsDim> EtWmat;
-        BoundSymMatrix Wi = linTrack.covarianceAtPCA.inverse();
+        BoundSymMatrix Wi = linTrack.weightAtPCA;
 
         DtWmat = Dmat.transpose() * Wi;
         EtWmat = Emat.transpose() * Wi;
@@ -274,7 +275,7 @@ Acts::FullBilloirVertexFitter<input_track_t, linearizer_t>::fit(
       bTrack.chi2 =
           ((bTrack.deltaQ - bTrack.DiMat * deltaV - bTrack.EiMat * deltaP)
                .transpose())
-              .dot(bTrack.linTrack.covarianceAtPCA.inverse() *
+              .dot(bTrack.linTrack.weightAtPCA *
                    (bTrack.deltaQ - bTrack.DiMat * deltaV -
                     bTrack.EiMat * deltaP));
       newChi2 += bTrack.chi2;
diff --git a/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp b/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp
index 342c9037c..d1a8e16bb 100644
--- a/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp
+++ b/Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp
@@ -161,7 +161,14 @@ Acts::Result<Acts::LinearizedTrack> Acts::
   BoundVector constTerm = predParamsAtPCA - positionJacobian * positionAtPCA -
                           momentumJacobian * momentumAtPCA;
 
-  return LinearizedTrack(paramsAtPCA, parCovarianceAtPCA, linPoint,
+  // The parameter weight
+  ActsSymMatrixD<5> parWeight =
+      (parCovarianceAtPCA.block<5, 5>(0, 0)).inverse();
+
+  BoundSymMatrix weightAtPCA{BoundSymMatrix::Identity()};
+  weightAtPCA.block<5, 5>(0, 0) = parWeight;
+
+  return LinearizedTrack(paramsAtPCA, parCovarianceAtPCA, weightAtPCA, linPoint,
                          positionJacobian, momentumJacobian, positionAtPCA,
                          momentumAtPCA, constTerm);
 }
diff --git a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
index 10df70791..f06cca333 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
+++ b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
@@ -34,8 +34,7 @@ Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
   const auto& posJac = linTrack.positionJacobian.block<5, 3>(0, 0);
   const auto& momJac = linTrack.momentumJacobian.block<5, 3>(0, 0);
   const auto& trkParams = linTrack.parametersAtPCA.head<5>();
-  const auto& trkParamWeight =
-      (linTrack.covarianceAtPCA.block<5, 5>(0, 0)).inverse();
+  const auto& trkParamWeight = linTrack.weightAtPCA.block<5, 5>(0, 0);
 
   // Calculate S matrix
   ActsSymMatrixD<3> sMat =
@@ -66,21 +65,17 @@ Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
   auto newTrkCov =
       -vtxCov * posJac.transpose() * trkParamWeight * momJac * sMat;
 
-  Vector3D newVertexPos = Vector3D::Zero();
-  ActsSymMatrixD<3> newVertexCov = ActsSymMatrixD<3>::Zero();
-  ActsSymMatrixD<3> oldVertexWeight = ActsSymMatrixD<3>::Zero();
-  ActsSymMatrixD<5> tempWeight = ActsSymMatrixD<5>::Zero();
+  KalmanVertexUpdater::MatrixCache matrixCache;
 
   // Now determine the smoothed chi2 of the track in the following
   KalmanVertexUpdater::updatePosition<input_track_t>(
-      vtx, linTrack, track.trackWeight, -1, newVertexPos, newVertexCov,
-      oldVertexWeight, tempWeight);
+      vtx, linTrack, track.trackWeight, -1, matrixCache);
 
   // Corresponding weight matrix
-  const auto reducedVtxWeight = newVertexCov.inverse();
+  const auto& reducedVtxWeight = matrixCache.newVertexWeight;
 
   // Difference in positions
-  auto posDiff = vtx->position() - newVertexPos;
+  auto posDiff = vtx->position() - matrixCache.newVertexPos;
 
   // Get smoothed params
   auto smParams =
diff --git a/Core/include/Acts/Vertexing/KalmanVertexUpdater.hpp b/Core/include/Acts/Vertexing/KalmanVertexUpdater.hpp
index efb5a98b6..adb667eea 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexUpdater.hpp
+++ b/Core/include/Acts/Vertexing/KalmanVertexUpdater.hpp
@@ -22,6 +22,16 @@ namespace KalmanVertexUpdater {
 /// Vertex reconstruction and track bundling at the lep collider using
 /// robust Algorithms Computer Physics Comm.: 96 (1996) 189, chapter 2.1
 
+/// Cache object to store matrix information
+struct MatrixCache {
+  Vector3D newVertexPos = Vector3D::Zero();
+  ActsSymMatrixD<3> newVertexCov = ActsSymMatrixD<3>::Zero();
+  ActsSymMatrixD<3> newVertexWeight = ActsSymMatrixD<3>::Zero();
+  ActsSymMatrixD<3> oldVertexWeight = ActsSymMatrixD<3>::Zero();
+  ActsSymMatrixD<5> trkParamWeight = ActsSymMatrixD<5>::Zero();
+  ActsSymMatrixD<3> momWeightInv = ActsSymMatrixD<3>::Zero();
+};
+
 /// @brief Updates vertex with knowledge of new track
 /// @note KalmanVertexUpdater updates the vertex w.r.t. the
 /// newly given track, but does NOT add the track to the
@@ -40,44 +50,36 @@ void updateVertexWithTrack(Vertex<input_track_t>* vtx,
 /// @param linTrack Linearized version of track to be added or removed
 /// @param trackWeight Track weight
 /// @param sign +1 (add track) or -1 (remove track)
-/// @param[out] newVtxPos The new vertex position
-/// @param[out] newVtxCov The new vertex covariance
-/// @param[out] oldVtxWeight The old vertex weight
-/// @param[out] trkParamWeight The track parameter weight
+/// @param[out] matrixCache A cache to store matrix information
 ///
 /// @return Vertex with updated position and covariance
 template <typename input_track_t>
 void updatePosition(const Acts::Vertex<input_track_t>* vtx,
                     const Acts::LinearizedTrack& linTrack, double trackWeight,
-                    int sign, Vector3D& newVtxPos, ActsSymMatrixD<3>& newVtxCov,
-                    ActsSymMatrixD<3>& oldVtxWeight,
-                    ActsSymMatrixD<5>& trkParamWeight);
+                    int sign, MatrixCache& matrixCache);
 
 namespace detail {
+
 /// @brief Takes old and new vtx and calculates position chi2
 ///
 /// @param oldVtx Old vertex
-/// @param newVtx New vertex
-/// @param oldVertexWeight The old vertex weight
+/// @param matrixCache A cache to store matrix information
 ///
 /// @return Chi2
 template <typename input_track_t>
 double vertexPositionChi2(const Vertex<input_track_t>* oldVtx,
-                          const Vector3D& newVtxPos,
-                          const ActsSymMatrixD<3>& oldVertexWeight);
+                          const MatrixCache& matrixCache);
 
 /// @brief Calculates chi2 of refitted track parameters
 /// w.r.t. updated vertex
 ///
-/// @param vtx The already updated vertex
 /// @param linTrack Linearized version of track
-/// @param trkParamWeight The track parameter weight
+/// @param matrixCache A cache to store matrix information
 ///
 /// @return Chi2
 template <typename input_track_t>
-double trackParametersChi2(const Vector3D& vtxPos,
-                           const LinearizedTrack& linTrack,
-                           const ActsSymMatrixD<5>& trkParamWeight);
+double trackParametersChi2(const LinearizedTrack& linTrack,
+                           const MatrixCache& matrixCache);
 
 /// @brief Adds or removes (depending on `sign`) tracks from vertex
 /// and updates the vertex
diff --git a/Core/include/Acts/Vertexing/KalmanVertexUpdater.ipp b/Core/include/Acts/Vertexing/KalmanVertexUpdater.ipp
index 71cec0186..64b9e8337 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexUpdater.ipp
+++ b/Core/include/Acts/Vertexing/KalmanVertexUpdater.ipp
@@ -15,74 +15,114 @@ void Acts::KalmanVertexUpdater::updateVertexWithTrack(
   detail::update<input_track_t>(vtx, trk, 1);
 }
 
+template <typename input_track_t>
+void Acts::KalmanVertexUpdater::detail::update(
+    Vertex<input_track_t>* vtx, TrackAtVertex<input_track_t>& trk, int sign) {
+  double trackWeight = trk.trackWeight;
+
+  MatrixCache matrixCache;
+
+  updatePosition(vtx, trk.linearizedState, trackWeight, sign, matrixCache);
+
+  // Get fit quality parameters wrt to old vertex
+  std::pair fitQuality = vtx->fitQuality();
+  double chi2 = fitQuality.first;
+  double ndf = fitQuality.second;
+
+  // Chi2 wrt to track parameters
+  double trkChi2 = detail::trackParametersChi2<input_track_t>(
+      trk.linearizedState, matrixCache);
+
+  // Calculate new chi2
+  chi2 += sign * (detail::vertexPositionChi2<input_track_t>(vtx, matrixCache) +
+                  trackWeight * trkChi2);
+
+  // Calculate ndf
+  ndf += sign * trackWeight * 2.;
+
+  // Updating the vertex
+  vtx->setPosition(matrixCache.newVertexPos);
+  vtx->setCovariance(matrixCache.newVertexCov);
+  vtx->setFitQuality(chi2, ndf);
+
+  // Updates track at vertex if already there
+  // by removing it first and adding new one.
+  // Otherwise just adds track to existing list of tracks at vertex
+  if (sign > 0) {
+    // Update track
+    trk.chi2Track = trkChi2;
+    trk.ndf = 2 * trackWeight;
+  }
+  // Remove trk from current vertex
+  if (sign < 0) {
+    trk.trackWeight = 0;
+  }
+}
+
 template <typename input_track_t>
 void Acts::KalmanVertexUpdater::updatePosition(
     const Acts::Vertex<input_track_t>* vtx,
     const Acts::LinearizedTrack& linTrack, double trackWeight, int sign,
-    Vector3D& newVtxPos, ActsSymMatrixD<3>& newVtxCov,
-    ActsSymMatrixD<3>& oldVtxWeight, ActsSymMatrixD<5>& trkParamWeight) {
+    MatrixCache& matrixCache) {
   // Retrieve linTrack information
-  // To make 4-D compatible, remove block<> and head<> statements
+  // TODO: To make 4-D compatible, remove block<> and head<> statements
   const auto& posJac = linTrack.positionJacobian.block<5, 3>(0, 0);
   const auto& momJac =
       linTrack.momentumJacobian.block<5, 3>(0, 0);  // B_k in comments below
   const auto& trkParams = linTrack.parametersAtPCA.head<5>();
   const auto& constTerm = linTrack.constantTerm.head<5>();
-  trkParamWeight = (linTrack.covarianceAtPCA.block<5, 5>(0, 0))
-                       .inverse();  // G_k in comments below
+  const auto& trkParamWeight = linTrack.weightAtPCA.block<5, 5>(0, 0);
 
   // Vertex to be updated
   const auto& oldVtxPos = vtx->position();
-  oldVtxWeight = (vtx->covariance()).inverse();
+  matrixCache.oldVertexWeight = (vtx->covariance()).inverse();
 
   // W_k matrix
-  ActsSymMatrixD<3> wMat =
+  matrixCache.momWeightInv =
       (momJac.transpose() * (trkParamWeight * momJac)).inverse();
 
   // G_b = G_k - G_k*B_k*W_k*B_k^(T)*G_k^T
-  auto gBmat = trkParamWeight - trkParamWeight *
-                                    (momJac * (wMat * momJac.transpose())) *
-                                    trkParamWeight.transpose();
+  auto gBmat = trkParamWeight -
+               trkParamWeight *
+                   (momJac * (matrixCache.momWeightInv * momJac.transpose())) *
+                   trkParamWeight.transpose();
   // New vertex cov matrix
-  newVtxCov = (oldVtxWeight +
-               trackWeight * sign * posJac.transpose() * (gBmat * posJac))
-                  .inverse();
+  matrixCache.newVertexWeight =
+      matrixCache.oldVertexWeight +
+      trackWeight * sign * posJac.transpose() * (gBmat * posJac);
+  matrixCache.newVertexCov = matrixCache.newVertexWeight.inverse();
 
   // New vertex position
-  newVtxPos = newVtxCov * (oldVtxWeight * oldVtxPos +
-                           trackWeight * sign * posJac.transpose() * gBmat *
-                               (trkParams - constTerm));
+  matrixCache.newVertexPos =
+      matrixCache.newVertexCov * (matrixCache.oldVertexWeight * oldVtxPos +
+                                  trackWeight * sign * posJac.transpose() *
+                                      gBmat * (trkParams - constTerm));
 }
 
 template <typename input_track_t>
 double Acts::KalmanVertexUpdater::detail::vertexPositionChi2(
-    const Vertex<input_track_t>* oldVtx, const Vector3D& newVtxPos,
-    const ActsSymMatrixD<3>& oldVertexWeight) {
-  auto posDiff = newVtxPos - oldVtx->position();
+    const Vertex<input_track_t>* oldVtx, const MatrixCache& matrixCache) {
+  auto posDiff = matrixCache.newVertexPos - oldVtx->position();
 
   // Calculate and return corresponding chi2
-  return posDiff.transpose() * (oldVertexWeight * posDiff);
+  return posDiff.transpose() * (matrixCache.oldVertexWeight * posDiff);
 }
 
 template <typename input_track_t>
 double Acts::KalmanVertexUpdater::detail::trackParametersChi2(
-    const Vector3D& vtxPos, const LinearizedTrack& linTrack,
-    const ActsSymMatrixD<5>& trkParamWeight) {
+    const LinearizedTrack& linTrack, const MatrixCache& matrixCache) {
   // Track properties
   const auto& posJac = linTrack.positionJacobian.block<5, 3>(0, 0);
   const auto& momJac = linTrack.momentumJacobian.block<5, 3>(0, 0);
   const auto& trkParams = linTrack.parametersAtPCA.head<5>();
   const auto& constTerm = linTrack.constantTerm.head<5>();
+  const auto& trkParamWeight = linTrack.weightAtPCA.block<5, 5>(0, 0);
 
-  // Calculate temp matrix S
-  ActsSymMatrixD<3> matS =
-      (momJac.transpose() * (trkParamWeight * momJac)).inverse();
-
-  const auto jacVtx = posJac * vtxPos;
+  const auto& jacVtx = posJac * matrixCache.newVertexPos;
 
   // Refitted track momentum
-  Vector3D newTrackMomentum = matS * momJac.transpose() * trkParamWeight *
-                              (trkParams - constTerm - jacVtx);
+  Vector3D newTrackMomentum = matrixCache.momWeightInv * momJac.transpose() *
+                              trkParamWeight * (trkParams - constTerm - jacVtx);
 
   // Refitted track parameters
   auto newTrkParams = constTerm + jacVtx + momJac * newTrackMomentum;
@@ -93,52 +133,3 @@ double Acts::KalmanVertexUpdater::detail::trackParametersChi2(
   // Return chi2
   return paramDiff.transpose() * (trkParamWeight * paramDiff);
 }
-
-template <typename input_track_t>
-void Acts::KalmanVertexUpdater::detail::update(
-    Vertex<input_track_t>* vtx, TrackAtVertex<input_track_t>& trk, int sign) {
-  double trackWeight = trk.trackWeight;
-
-  Vector3D newVertexPos = Vector3D::Zero();
-  ActsSymMatrixD<3> newVertexCov = ActsSymMatrixD<3>::Zero();
-  ActsSymMatrixD<3> oldVertexWeight = ActsSymMatrixD<3>::Zero();
-  ActsSymMatrixD<5> trkParamWeight = ActsSymMatrixD<5>::Zero();
-
-  updatePosition(vtx, trk.linearizedState, trackWeight, sign, newVertexPos,
-                 newVertexCov, oldVertexWeight, trkParamWeight);
-
-  // Get fit quality parameters wrt to old vertex
-  std::pair fitQuality = vtx->fitQuality();
-  double chi2 = fitQuality.first;
-  double ndf = fitQuality.second;
-
-  // Chi2 wrt to track parameters
-  double trkChi2 = detail::trackParametersChi2<input_track_t>(
-      newVertexPos, trk.linearizedState, trkParamWeight);
-
-  // Calculate new chi2
-  chi2 += sign * (detail::vertexPositionChi2<input_track_t>(vtx, newVertexPos,
-                                                            oldVertexWeight) +
-                  trackWeight * trkChi2);
-
-  // Calculate ndf
-  ndf += sign * trackWeight * 2.;
-
-  // Updating the vertex
-  vtx->setPosition(newVertexPos);
-  vtx->setCovariance(newVertexCov);
-  vtx->setFitQuality(chi2, ndf);
-
-  // Updates track at vertex if already there
-  // by removing it first and adding new one.
-  // Otherwise just adds track to existing list of tracks at vertex
-  if (sign > 0) {
-    // Update track
-    trk.chi2Track = trkChi2;
-    trk.ndf = 2 * trackWeight;
-  }
-  // Remove trk from current vertex
-  if (sign < 0) {
-    trk.trackWeight = 0;
-  }
-}
diff --git a/Core/include/Acts/Vertexing/LinearizedTrack.hpp b/Core/include/Acts/Vertexing/LinearizedTrack.hpp
index 3be7dc6cf..5facd966b 100644
--- a/Core/include/Acts/Vertexing/LinearizedTrack.hpp
+++ b/Core/include/Acts/Vertexing/LinearizedTrack.hpp
@@ -46,6 +46,7 @@ struct LinearizedTrack {
 
   LinearizedTrack(const BoundVector& paramsAtPCA,
                   const BoundSymMatrix& parCovarianceAtPCA,
+                  const BoundSymMatrix& parWeightAtPCA,
                   const SpacePointVector& linPoint,
                   const SpacePointToBoundMatrix& posJacobian,
                   const ActsMatrixD<BoundParsDim, 3>& momJacobian,
@@ -53,6 +54,7 @@ struct LinearizedTrack {
                   const BoundVector& constTerm)
       : parametersAtPCA(paramsAtPCA),
         covarianceAtPCA(parCovarianceAtPCA),
+        weightAtPCA(parWeightAtPCA),
         linearizationPoint(linPoint),
         positionJacobian(posJacobian),
         momentumJacobian(momJacobian),
@@ -62,6 +64,7 @@ struct LinearizedTrack {
 
   BoundVector parametersAtPCA{BoundVector::Zero()};
   BoundSymMatrix covarianceAtPCA{BoundSymMatrix::Zero()};
+  BoundSymMatrix weightAtPCA{BoundSymMatrix::Zero()};
   SpacePointVector linearizationPoint{SpacePointVector::Zero()};
   SpacePointToBoundMatrix positionJacobian{SpacePointToBoundMatrix::Zero()};
   ActsMatrixD<BoundParsDim, 3> momentumJacobian{
-- 
GitLab


From 3cd4ea305397ba38e0e18bdbfd0fbeac5d7cf8b1 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Fri, 6 Mar 2020 16:57:46 +0100
Subject: [PATCH 51/60] use emplace instead of insert for maps, some minor
 changes

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   | 12 +++----
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 35 ++++++++-----------
 2 files changed, 20 insertions(+), 27 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index ae9923fff..199514b6e 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -99,7 +99,7 @@ class AdaptiveMultiVertexFinder {
     // added to the new vertex candidate after seeding. If switched to
     // false, only the seedTracks, i.e. all tracks that are considered
     // as outliers of previously fitted vertices, are used.
-    bool realMultiVertex = true;
+    bool doRealMultiVertex = true;
 
     // Decides if you want to use the ```vertexCompatibility``` of the
     //  track (set to true) or the ```chi2Track``` (set to false) as an
@@ -285,13 +285,12 @@ class AdaptiveMultiVertexFinder {
   ///
   /// @param vtx The vertex candidate
   /// @param seedTracks The seed tracks
-  /// @param[out] nCompatibleTracks Number of compatible tracks
-  /// @param[out] isGoodVertex Vertex is good vertex
   /// @param fitterState The vertex fitter state
-  void checkVertexAndCompatibleTracks(
+  ///
+  /// @return pair(nCompatibleTracks, isGoodVertex)
+  std::pair<int, bool> checkVertexAndCompatibleTracks(
       Vertex<InputTrack_t>* vtx,
       const std::vector<const InputTrack_t*>& seedTracks,
-      int& nCompatibleTracks, bool& isGoodVertex,
       FitterState_t& fitterState) const;
 
   /// @brief Method that removes all tracks that are compatible with
@@ -321,13 +320,12 @@ class AdaptiveMultiVertexFinder {
   ///
   /// @param vtx The vertex candidate
   /// @param allVertices All so far found vertices
-  /// @param isGoodVertex Vertex is good vertex
   /// @param fitterState The vertex fitter state
   ///
   /// @return Keep new vertex
   bool keepNewVertex(Vertex<InputTrack_t>* vtx,
                      const std::vector<Vertex<InputTrack_t>*>& allVertices,
-                     bool isGoodVertex, FitterState_t& fitterState) const;
+                     FitterState_t& fitterState) const;
 
   /// @brief Method that evaluates if the new vertex candidate is
   /// merged with one of the previously found vertices
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index f41e1e8b3..5ca8bff18 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -42,7 +42,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     // Tracks that are used for searching compatible tracks
     // near a vertex candidate
     std::vector<const InputTrack_t*> myTracks;
-    if (m_cfg.realMultiVertex == true) {
+    if (m_cfg.doRealMultiVertex) {
       myTracks = origTracks;
     } else {
       myTracks = seedTracks;
@@ -91,10 +91,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     ACTS_DEBUG("New position of current vertex candidate after fit: "
                << vtxCandidate->fullPosition());
     // Check if vertex is good vertex
-    bool isGoodVertex = false;
-    int nCompatibleTracks = 0;
-    checkVertexAndCompatibleTracks(vtxCandidate, seedTracks, nCompatibleTracks,
-                                   isGoodVertex, fitterState);
+    auto [nCompatibleTracks, isGoodVertex] =
+        checkVertexAndCompatibleTracks(vtxCandidate, seedTracks, fitterState);
 
     ACTS_DEBUG("Vertex is good vertex: " << isGoodVertex);
     if (nCompatibleTracks > 0) {
@@ -112,8 +110,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
         break;
       }
     }
-    bool keepVertex =
-        keepNewVertex(vtxCandidate, allVerticesPtr, isGoodVertex, fitterState);
+    bool keepVertex = isGoodVertex &&
+                      keepNewVertex(vtxCandidate, allVerticesPtr, fitterState);
     ACTS_DEBUG("New vertex will be saved: " << keepVertex);
 
     // Delete vertex from allVertices list again if it's not kept
@@ -231,8 +229,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
         (ipSig < m_cfg.tracksMaxSignificance)) {
       // Create TrackAtVertex objects, unique for each (track, vertex) pair
       // fitterState.tracksAtVerticesMap.clear();
-      fitterState.tracksAtVerticesMap.insert(
-          std::make_pair(std::make_pair(trk, vtx), TrackAtVertex(params, trk)));
+      fitterState.tracksAtVerticesMap.emplace(std::make_pair(trk, vtx),
+                                              TrackAtVertex(params, trk));
 
       // Add the original track parameters to the list for vtx
       fitterState.vtxInfoMap[vtx].trackLinks.push_back(trk);
@@ -331,8 +329,9 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     checkVertexAndCompatibleTracks(
         Vertex<InputTrack_t>* vtx,
         const std::vector<const InputTrack_t*>& seedTracks,
-        int& nCompatibleTracks, bool& isGoodVertex,
-        FitterState_t& fitterState) const -> void {
+        FitterState_t& fitterState) const -> std::pair<int, bool> {
+  bool isGoodVertex = false;
+  int nCompatibleTracks = 0;
   for (const auto& trk : fitterState.vtxInfoMap[vtx].trackLinks) {
     const auto& trkAtVtx =
         fitterState.tracksAtVerticesMap.at(std::make_pair(trk, vtx));
@@ -361,6 +360,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
       }
     }
   }  // end loop over all tracks at vertex
+
+  return {nCompatibleTracks, isGoodVertex};
 }
 
 template <typename vfitter_t, typename sfinder_t>
@@ -394,9 +395,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
         FitterState_t& fitterState) const -> bool {
   // Try to find the track with highest compatibility
   double maxCompatibility = 0;
-  typename std::vector<const InputTrack_t*>::iterator maxCompSeedIt =
-      seedTracks.end();
 
+  auto maxCompSeedIt = seedTracks.end();
   for (const auto& trk : fitterState.vtxInfoMap[vtx].trackLinks) {
     const auto& trkAtVtx =
         fitterState.tracksAtVerticesMap.at(std::make_pair(trk, vtx));
@@ -444,12 +444,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::keepNewVertex(
     Vertex<InputTrack_t>* vtx,
-    const std::vector<Vertex<InputTrack_t>*>& allVertices, bool isGoodVertex,
+    const std::vector<Vertex<InputTrack_t>*>& allVertices,
     FitterState_t& fitterState) const -> bool {
-  if (not isGoodVertex) {
-    return false;
-  }
-
   double contamination = 0.;
   double contaminationNum = 0;
   double contaminationDeNom = 0;
@@ -532,8 +528,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::deleteLastVertex(
     fitterState.annealingState = oldFitterState.annealingState;
     fitterState.vtxInfoMap.clear();
     for (const auto& vtx : allVerticesPtr) {
-      fitterState.vtxInfoMap.insert(
-          std::make_pair(vtx, oldFitterState.vtxInfoMap[vtx]));
+      fitterState.vtxInfoMap.emplace(vtx, oldFitterState.vtxInfoMap[vtx]);
     }
     fitterState.trackToVerticesMultiMap =
         oldFitterState.trackToVerticesMultiMap;
-- 
GitLab


From c13b365dfb272339567ae5af1f3b2624c579a775 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Fri, 6 Mar 2020 17:17:47 +0100
Subject: [PATCH 52/60] some renamings of variables, etc.

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   |  8 +++----
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 22 +++++++++----------
 .../Vertexing/KalmanVertexTrackUpdater.ipp    |  2 +-
 .../AdaptiveMultiVertexFitterTests.cpp        |  1 -
 4 files changed, 16 insertions(+), 17 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index 199514b6e..86881226a 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -250,7 +250,7 @@ class AdaptiveMultiVertexFinder {
   /// @brief Method that tries to recover from cases where no tracks
   /// where added to the vertex candidate after seeding
   ///
-  /// @param myTracks The tracks to be considered (either origTrack or
+  /// @param allTracks The tracks to be considered (either origTrack or
   /// seedTracks)
   /// @param seedTracks The seed tracks
   /// @param[out] vtx The vertex candidate
@@ -259,14 +259,14 @@ class AdaptiveMultiVertexFinder {
   ///
   /// return True if recovery was successful, false otherwise
   Result<bool> canRecoverFromNoCompatibleTracks(
-      const std::vector<const InputTrack_t*>& myTracks,
+      const std::vector<const InputTrack_t*>& allTracks,
       const std::vector<const InputTrack_t*>& seedTracks,
       Vertex<InputTrack_t>* vtx, const Vertex<InputTrack_t>& currentConstraint,
       FitterState_t& fitterState) const;
 
   /// @brief Method that tries to prepare the vertex for the fit
   ///
-  /// @param myTracks The tracks to be considered (either origTrack or
+  /// @param allTracks The tracks to be considered (either origTrack or
   /// seedTracks)
   /// @param seedTracks The seed tracks
   /// @param[out] vtx The vertex candidate
@@ -275,7 +275,7 @@ class AdaptiveMultiVertexFinder {
   ///
   /// @return True if preparation was successful, false otherwise
   Result<bool> canPrepareVertexForFit(
-      const std::vector<const InputTrack_t*>& myTracks,
+      const std::vector<const InputTrack_t*>& allTracks,
       const std::vector<const InputTrack_t*>& seedTracks,
       Vertex<InputTrack_t>* vtx, const Vertex<InputTrack_t>& currentConstraint,
       FitterState_t& fitterState) const;
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index 5ca8bff18..292b56dd7 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -37,15 +37,15 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
   while (((m_cfg.addSingleTrackVertices && seedTracks.size() > 0) ||
           ((!m_cfg.addSingleTrackVertices) && seedTracks.size() > 1)) &&
          iteration < m_cfg.maxIterations) {
-    auto oldFitterState = fitterState;
+    FitterState_t oldFitterState = fitterState;
 
     // Tracks that are used for searching compatible tracks
     // near a vertex candidate
-    std::vector<const InputTrack_t*> myTracks;
+    std::vector<const InputTrack_t*> allTracks;
     if (m_cfg.doRealMultiVertex) {
-      myTracks = origTracks;
+      allTracks = origTracks;
     } else {
-      myTracks = seedTracks;
+      allTracks = seedTracks;
     }
     Vertex<InputTrack_t> currentConstraint = vFinderOptions.vertexConstraint;
     // Retrieve seed vertex from all remaining seedTracks
@@ -67,8 +67,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
       allVerticesPtr.pop_back();
       break;
     }
-    auto prepResult = canPrepareVertexForFit(myTracks, seedTracks, vtxCandidate,
-                                             currentConstraint, fitterState);
+    auto prepResult = canPrepareVertexForFit(
+        allTracks, seedTracks, vtxCandidate, currentConstraint, fitterState);
 
     if (!prepResult.ok()) {
       return prepResult.error();
@@ -242,7 +242,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     canRecoverFromNoCompatibleTracks(
-        const std::vector<const InputTrack_t*>& myTracks,
+        const std::vector<const InputTrack_t*>& allTracks,
         const std::vector<const InputTrack_t*>& seedTracks,
         Vertex<InputTrack_t>* vtx,
         const Vertex<InputTrack_t>& currentConstraint,
@@ -276,7 +276,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
           VertexInfo<InputTrack_t>(currentConstraint, vtx->fullPosition());
 
       // Try to add compatible track with adapted vertex position
-      auto res = addCompatibleTracksToVertex(myTracks, vtx, fitterState);
+      auto res = addCompatibleTracksToVertex(allTracks, vtx, fitterState);
       if (!res.ok()) {
         return Result<bool>::failure(res.error());
       }
@@ -299,7 +299,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
-    canPrepareVertexForFit(const std::vector<const InputTrack_t*>& myTracks,
+    canPrepareVertexForFit(const std::vector<const InputTrack_t*>& allTracks,
                            const std::vector<const InputTrack_t*>& seedTracks,
                            Vertex<InputTrack_t>* vtx,
                            const Vertex<InputTrack_t>& currentConstraint,
@@ -309,14 +309,14 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
       VertexInfo<InputTrack_t>(currentConstraint, vtx->fullPosition());
 
   // Add all compatible tracks to vertex
-  auto resComp = addCompatibleTracksToVertex(myTracks, vtx, fitterState);
+  auto resComp = addCompatibleTracksToVertex(allTracks, vtx, fitterState);
   if (!resComp.ok()) {
     return Result<bool>::failure(resComp.error());
   }
 
   // Try to recover from cases where adding compatible track was not possible
   auto resRec = canRecoverFromNoCompatibleTracks(
-      myTracks, seedTracks, vtx, currentConstraint, fitterState);
+      allTracks, seedTracks, vtx, currentConstraint, fitterState);
   if (!resRec.ok()) {
     return Result<bool>::failure(resRec.error());
   }
diff --git a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
index f06cca333..4d685f9cd 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
+++ b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
@@ -58,7 +58,7 @@ Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
   newTrkParams(ParID_t::eQOP) = newTrkMomentum(2);           // qOverP
 
   // Vertex covariance and weight matrices
-  const auto& vtxCov = vtx->fullCovariance().template block<3, 3>(0, 0);
+  const auto vtxCov = vtx->fullCovariance().template block<3, 3>(0, 0);
   const auto vtxWeight = vtxCov.inverse();
 
   // New track covariance matrix
diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
index 92a38873c..a89f326fc 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
@@ -229,7 +229,6 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test) {
   // list in order to be able to compare later
   std::vector<Vertex<BoundParameters>> seedListCopy = vtxList;
 
-  std::cout << "HERE 0" << std::endl;
   auto res1 = fitter.addVtxToFit(state, vtxList[0], linearizer, fitterOptions);
 
   if (debugMode) {
-- 
GitLab


From 65377119d858ec21b43bff8db5c014fcc5bf1b76 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Fri, 6 Mar 2020 17:43:07 +0100
Subject: [PATCH 53/60] remove const keyword for m_extractParameters member

---
 Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp | 6 +++---
 Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp | 2 +-
 Core/include/Acts/Vertexing/IterativeVertexFinder.hpp     | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index 86881226a..c5ddca235 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -78,7 +78,7 @@ class AdaptiveMultiVertexFinder {
     // to the seeded vertex than tracksMaxZinterval
     // are added to this new vertex.
     //
-    // Note: Default is 4 mm. If you cut too hard, you cut out
+    // Note: If you cut too hard, you cut out
     // the good cases where the seed finder is not
     // reliable, but the fit would be still able to converge
     // towards the right vertex. If you cut too soft, you
@@ -199,7 +199,7 @@ class AdaptiveMultiVertexFinder {
   /// overwritten to return BoundParameters for other InputTrack_t objects.
   ///
   /// @param InputTrack_t object to extract track parameters from
-  const std::function<BoundParameters(InputTrack_t)> m_extractParameters;
+  std::function<BoundParameters(InputTrack_t)> m_extractParameters;
 
   /// Logging instance
   std::unique_ptr<const Logger> m_logger;
@@ -248,7 +248,7 @@ class AdaptiveMultiVertexFinder {
       FitterState_t& fitterState) const;
 
   /// @brief Method that tries to recover from cases where no tracks
-  /// where added to the vertex candidate after seeding
+  /// were added to the vertex candidate after seeding
   ///
   /// @param allTracks The tracks to be considered (either origTrack or
   /// seedTracks)
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
index 334a35ac0..bd6301374 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
@@ -210,7 +210,7 @@ class AdaptiveMultiVertexFitter {
   /// overwritten to return BoundParameters for other InputTrack_t objects.
   ///
   /// @param InputTrack_t object to extract track parameters from
-  const std::function<BoundParameters(InputTrack_t)> m_extractParameters;
+  std::function<BoundParameters(InputTrack_t)> m_extractParameters;
 
   /// Logging instance
   std::unique_ptr<const Logger> m_logger;
diff --git a/Core/include/Acts/Vertexing/IterativeVertexFinder.hpp b/Core/include/Acts/Vertexing/IterativeVertexFinder.hpp
index c2ea776fb..ac3db92ff 100644
--- a/Core/include/Acts/Vertexing/IterativeVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/IterativeVertexFinder.hpp
@@ -154,7 +154,7 @@ class IterativeVertexFinder {
   /// overwritten to return BoundParameters for other InputTrack_t objects.
   ///
   /// @param InputTrack_t object to extract track parameters from
-  const std::function<BoundParameters(InputTrack_t)> m_extractParameters;
+  std::function<BoundParameters(InputTrack_t)> m_extractParameters;
 
   /// Logging instance
   std::unique_ptr<const Logger> m_logger;
-- 
GitLab


From 58cc430e30ee084cbf3a63ee6b8af896fa9454c5 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Fri, 6 Mar 2020 17:53:10 +0100
Subject: [PATCH 54/60] use reference to vtxCandidate instead of pointer
 throughout AMVF

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   | 18 ++---
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 78 +++++++++----------
 2 files changed, 48 insertions(+), 48 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index c5ddca235..af2f66cff 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -236,7 +236,7 @@ class AdaptiveMultiVertexFinder {
   ///
   /// @return The IP significance
   Result<double> getIPSignificance(const InputTrack_t* track,
-                                   const Vertex<InputTrack_t>* vtx) const;
+                                   const Vertex<InputTrack_t>& vtx) const;
 
   /// @brief Adds compatible track to vertex candidate
   ///
@@ -244,7 +244,7 @@ class AdaptiveMultiVertexFinder {
   /// @param vtx The vertex candidate
   /// @param[out] fitterState The vertex fitter state
   Result<void> addCompatibleTracksToVertex(
-      const std::vector<const InputTrack_t*>& tracks, Vertex<InputTrack_t>* vtx,
+      const std::vector<const InputTrack_t*>& tracks, Vertex<InputTrack_t>& vtx,
       FitterState_t& fitterState) const;
 
   /// @brief Method that tries to recover from cases where no tracks
@@ -261,7 +261,7 @@ class AdaptiveMultiVertexFinder {
   Result<bool> canRecoverFromNoCompatibleTracks(
       const std::vector<const InputTrack_t*>& allTracks,
       const std::vector<const InputTrack_t*>& seedTracks,
-      Vertex<InputTrack_t>* vtx, const Vertex<InputTrack_t>& currentConstraint,
+      Vertex<InputTrack_t>& vtx, const Vertex<InputTrack_t>& currentConstraint,
       FitterState_t& fitterState) const;
 
   /// @brief Method that tries to prepare the vertex for the fit
@@ -277,7 +277,7 @@ class AdaptiveMultiVertexFinder {
   Result<bool> canPrepareVertexForFit(
       const std::vector<const InputTrack_t*>& allTracks,
       const std::vector<const InputTrack_t*>& seedTracks,
-      Vertex<InputTrack_t>* vtx, const Vertex<InputTrack_t>& currentConstraint,
+      Vertex<InputTrack_t>& vtx, const Vertex<InputTrack_t>& currentConstraint,
       FitterState_t& fitterState) const;
 
   /// @brief Method that checks if vertex is a good vertex and if
@@ -289,7 +289,7 @@ class AdaptiveMultiVertexFinder {
   ///
   /// @return pair(nCompatibleTracks, isGoodVertex)
   std::pair<int, bool> checkVertexAndCompatibleTracks(
-      Vertex<InputTrack_t>* vtx,
+      Vertex<InputTrack_t>& vtx,
       const std::vector<const InputTrack_t*>& seedTracks,
       FitterState_t& fitterState) const;
 
@@ -300,7 +300,7 @@ class AdaptiveMultiVertexFinder {
   /// @param[out] seedTracks The seed tracks
   /// @param fitterState The vertex fitter state
   void removeCompatibleTracksFromSeedTracks(
-      Vertex<InputTrack_t>* vtx, std::vector<const InputTrack_t*>& seedTracks,
+      Vertex<InputTrack_t>& vtx, std::vector<const InputTrack_t*>& seedTracks,
       FitterState_t& fitterState) const;
 
   /// @brief Method that tries to remove a non-compatible track
@@ -312,7 +312,7 @@ class AdaptiveMultiVertexFinder {
   ///
   /// @return Non-compatible track was removed
   bool canRemoveNonCompatibleTrackFromSeedTracks(
-      Vertex<InputTrack_t>* vtx, std::vector<const InputTrack_t*>& seedTracks,
+      Vertex<InputTrack_t>& vtx, std::vector<const InputTrack_t*>& seedTracks,
       FitterState_t& fitterState) const;
 
   /// @brief Method that evaluates if the new vertex candidate should
@@ -323,7 +323,7 @@ class AdaptiveMultiVertexFinder {
   /// @param fitterState The vertex fitter state
   ///
   /// @return Keep new vertex
-  bool keepNewVertex(Vertex<InputTrack_t>* vtx,
+  bool keepNewVertex(Vertex<InputTrack_t>& vtx,
                      const std::vector<Vertex<InputTrack_t>*>& allVertices,
                      FitterState_t& fitterState) const;
 
@@ -335,7 +335,7 @@ class AdaptiveMultiVertexFinder {
   ///
   /// @return Vertex is merged
   bool isMergedVertex(
-      const Vertex<InputTrack_t>* vtx,
+      const Vertex<InputTrack_t>& vtx,
       const std::vector<Vertex<InputTrack_t>*>& allVertices) const;
 
   /// @brief Method that deletes last vertex from list of all vertices
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index 292b56dd7..d39f233ce 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -55,12 +55,12 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     }
     allVertices.push_back(std::make_unique<Vertex<InputTrack_t>>(*seedResult));
 
-    Vertex<InputTrack_t>* vtxCandidate = (allVertices.back()).get();
-    allVerticesPtr.push_back(vtxCandidate);
+    Vertex<InputTrack_t>& vtxCandidate = *allVertices.back();
+    allVerticesPtr.push_back(&vtxCandidate);
 
     ACTS_DEBUG("Position of current vertex candidate after seeding: "
-               << vtxCandidate->fullPosition());
-    if (vtxCandidate->position().z() == 0.) {
+               << vtxCandidate.fullPosition());
+    if (vtxCandidate.position().z() == 0.) {
       ACTS_DEBUG(
           "No seed found anymore. Break and stop primary vertex finding.");
       allVertices.pop_back();
@@ -84,12 +84,12 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
 
     // Perform the fit
     auto fitResult = m_cfg.vertexFitter.addVtxToFit(
-        fitterState, *vtxCandidate, m_cfg.linearizer, vFitterOptions);
+        fitterState, vtxCandidate, m_cfg.linearizer, vFitterOptions);
     if (!fitResult.ok()) {
       return fitResult.error();
     }
     ACTS_DEBUG("New position of current vertex candidate after fit: "
-               << vtxCandidate->fullPosition());
+               << vtxCandidate.fullPosition());
     // Check if vertex is good vertex
     auto [nCompatibleTracks, isGoodVertex] =
         checkVertexAndCompatibleTracks(vtxCandidate, seedTracks, fitterState);
@@ -184,14 +184,14 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::estimateDeltaZ(
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::getIPSignificance(
-    const InputTrack_t* track, const Vertex<InputTrack_t>* vtx) const
+    const InputTrack_t* track, const Vertex<InputTrack_t>& vtx) const
     -> Result<double> {
   // TODO: In original implementation the covariance of the given vertex is set
   // to zero. I did the same here now, but consider removing this and just
   // passing the vtx object to the estimator without changing its covariance.
   // After all, the vertex seed does have a non-zero convariance in general and
   // it probably should be used.
-  Vertex<InputTrack_t> newVtx = *vtx;
+  Vertex<InputTrack_t> newVtx = vtx;
   newVtx.setFullCovariance(SpacePointSymMatrix::Zero());
 
   double significance = 0.;
@@ -214,7 +214,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::getIPSignificance(
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     addCompatibleTracksToVertex(const std::vector<const InputTrack_t*>& tracks,
-                                Vertex<InputTrack_t>* vtx,
+                                Vertex<InputTrack_t>& vtx,
                                 FitterState_t& fitterState) const
     -> Result<void> {
   for (const auto& trk : tracks) {
@@ -224,16 +224,16 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     }
     double ipSig = *sigRes;
     auto params = m_extractParameters(*trk);
-    if ((std::abs(estimateDeltaZ(params, vtx->position())) <
+    if ((std::abs(estimateDeltaZ(params, vtx.position())) <
          m_cfg.tracksMaxZinterval) &&
         (ipSig < m_cfg.tracksMaxSignificance)) {
       // Create TrackAtVertex objects, unique for each (track, vertex) pair
       // fitterState.tracksAtVerticesMap.clear();
-      fitterState.tracksAtVerticesMap.emplace(std::make_pair(trk, vtx),
+      fitterState.tracksAtVerticesMap.emplace(std::make_pair(trk, &vtx),
                                               TrackAtVertex(params, trk));
 
       // Add the original track parameters to the list for vtx
-      fitterState.vtxInfoMap[vtx].trackLinks.push_back(trk);
+      fitterState.vtxInfoMap[&vtx].trackLinks.push_back(trk);
     }
   }
   return {};
@@ -244,21 +244,21 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     canRecoverFromNoCompatibleTracks(
         const std::vector<const InputTrack_t*>& allTracks,
         const std::vector<const InputTrack_t*>& seedTracks,
-        Vertex<InputTrack_t>* vtx,
+        Vertex<InputTrack_t>& vtx,
         const Vertex<InputTrack_t>& currentConstraint,
         FitterState_t& fitterState) const -> Result<bool> {
   // Recover from cases where no compatible tracks to vertex
   // candidate were found
   // TODO: This is for now how it's done in athena... this look a bit
   // nasty to me
-  if (fitterState.vtxInfoMap[vtx].trackLinks.empty()) {
+  if (fitterState.vtxInfoMap[&vtx].trackLinks.empty()) {
     // Find nearest track to vertex candidate
     double smallestDeltaZ = std::numeric_limits<double>::max();
     double newZ = 0;
     bool nearTrackFound = false;
     for (const auto& trk : seedTracks) {
       double zDistance = std::abs(m_extractParameters(*trk).position()[eZ] -
-                                  vtx->position()[eZ]);
+                                  vtx.position()[eZ]);
       if (zDistance < smallestDeltaZ) {
         smallestDeltaZ = zDistance;
         nearTrackFound = true;
@@ -269,11 +269,11 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     if (nearTrackFound) {
       // TODO: check athena actualcandidate position here (has not changed?)
       // TODO: so do I want to change the vtx position here?
-      vtx->setFullPosition(SpacePointVector(0., 0., newZ, 0.));
+      vtx.setFullPosition(SpacePointVector(0., 0., newZ, 0.));
 
       // Update vertex info for current vertex
-      fitterState.vtxInfoMap[vtx] =
-          VertexInfo<InputTrack_t>(currentConstraint, vtx->fullPosition());
+      fitterState.vtxInfoMap[&vtx] =
+          VertexInfo<InputTrack_t>(currentConstraint, vtx.fullPosition());
 
       // Try to add compatible track with adapted vertex position
       auto res = addCompatibleTracksToVertex(allTracks, vtx, fitterState);
@@ -281,7 +281,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
         return Result<bool>::failure(res.error());
       }
 
-      if (fitterState.vtxInfoMap[vtx].trackLinks.empty()) {
+      if (fitterState.vtxInfoMap[&vtx].trackLinks.empty()) {
         ACTS_DEBUG(
             "No tracks near seed were found, while at least one was "
             "expected. Break.");
@@ -301,12 +301,12 @@ template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     canPrepareVertexForFit(const std::vector<const InputTrack_t*>& allTracks,
                            const std::vector<const InputTrack_t*>& seedTracks,
-                           Vertex<InputTrack_t>* vtx,
+                           Vertex<InputTrack_t>& vtx,
                            const Vertex<InputTrack_t>& currentConstraint,
                            FitterState_t& fitterState) const -> Result<bool> {
   // Add vertex info to fitter state
-  fitterState.vtxInfoMap[vtx] =
-      VertexInfo<InputTrack_t>(currentConstraint, vtx->fullPosition());
+  fitterState.vtxInfoMap[&vtx] =
+      VertexInfo<InputTrack_t>(currentConstraint, vtx.fullPosition());
 
   // Add all compatible tracks to vertex
   auto resComp = addCompatibleTracksToVertex(allTracks, vtx, fitterState);
@@ -327,14 +327,14 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     checkVertexAndCompatibleTracks(
-        Vertex<InputTrack_t>* vtx,
+        Vertex<InputTrack_t>& vtx,
         const std::vector<const InputTrack_t*>& seedTracks,
         FitterState_t& fitterState) const -> std::pair<int, bool> {
   bool isGoodVertex = false;
   int nCompatibleTracks = 0;
-  for (const auto& trk : fitterState.vtxInfoMap[vtx].trackLinks) {
+  for (const auto& trk : fitterState.vtxInfoMap[&vtx].trackLinks) {
     const auto& trkAtVtx =
-        fitterState.tracksAtVerticesMap.at(std::make_pair(trk, vtx));
+        fitterState.tracksAtVerticesMap.at(std::make_pair(trk, &vtx));
     if ((trkAtVtx.vertexCompatibility < m_cfg.maxVertexChi2 &&
          m_cfg.useFastCompatibility) ||
         (trkAtVtx.trackWeight > m_cfg.minWeight &&
@@ -367,11 +367,11 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     removeCompatibleTracksFromSeedTracks(
-        Vertex<InputTrack_t>* vtx, std::vector<const InputTrack_t*>& seedTracks,
+        Vertex<InputTrack_t>& vtx, std::vector<const InputTrack_t*>& seedTracks,
         FitterState_t& fitterState) const -> void {
-  for (const auto& trk : fitterState.vtxInfoMap[vtx].trackLinks) {
+  for (const auto& trk : fitterState.vtxInfoMap[&vtx].trackLinks) {
     const auto& trkAtVtx =
-        fitterState.tracksAtVerticesMap.at(std::make_pair(trk, vtx));
+        fitterState.tracksAtVerticesMap.at(std::make_pair(trk, &vtx));
     if ((trkAtVtx.vertexCompatibility < m_cfg.maxVertexChi2 &&
          m_cfg.useFastCompatibility) ||
         (trkAtVtx.trackWeight > m_cfg.minWeight &&
@@ -391,15 +391,15 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     canRemoveNonCompatibleTrackFromSeedTracks(
-        Vertex<InputTrack_t>* vtx, std::vector<const InputTrack_t*>& seedTracks,
+        Vertex<InputTrack_t>& vtx, std::vector<const InputTrack_t*>& seedTracks,
         FitterState_t& fitterState) const -> bool {
   // Try to find the track with highest compatibility
   double maxCompatibility = 0;
 
   auto maxCompSeedIt = seedTracks.end();
-  for (const auto& trk : fitterState.vtxInfoMap[vtx].trackLinks) {
+  for (const auto& trk : fitterState.vtxInfoMap[&vtx].trackLinks) {
     const auto& trkAtVtx =
-        fitterState.tracksAtVerticesMap.at(std::make_pair(trk, vtx));
+        fitterState.tracksAtVerticesMap.at(std::make_pair(trk, &vtx));
     double compatibility = trkAtVtx.vertexCompatibility;
     if (compatibility > maxCompatibility) {
       // Try to find track in seed tracks
@@ -424,7 +424,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
         seedTracks.begin(), seedTracks.end(),
         [&vtx, &smallestDeltaZ, this](auto trk) {
           double zDistance = std::abs(m_extractParameters(*trk).position()[eZ] -
-                                      vtx->position()[eZ]);
+                                      vtx.position()[eZ]);
           if (zDistance < smallestDeltaZ) {
             smallestDeltaZ = zDistance;
             return true;
@@ -443,15 +443,15 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::keepNewVertex(
-    Vertex<InputTrack_t>* vtx,
+    Vertex<InputTrack_t>& vtx,
     const std::vector<Vertex<InputTrack_t>*>& allVertices,
     FitterState_t& fitterState) const -> bool {
   double contamination = 0.;
   double contaminationNum = 0;
   double contaminationDeNom = 0;
-  for (const auto& trk : fitterState.vtxInfoMap[vtx].trackLinks) {
+  for (const auto& trk : fitterState.vtxInfoMap[&vtx].trackLinks) {
     const auto& trkAtVtx =
-        fitterState.tracksAtVerticesMap.at(std::make_pair(trk, vtx));
+        fitterState.tracksAtVerticesMap.at(std::make_pair(trk, &vtx));
     double trackWeight = trkAtVtx.trackWeight;
     contaminationNum += trackWeight * (1. - trackWeight);
     contaminationDeNom += trackWeight * trackWeight;
@@ -472,15 +472,15 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::keepNewVertex(
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::isMergedVertex(
-    const Vertex<InputTrack_t>* vtx,
+    const Vertex<InputTrack_t>& vtx,
     const std::vector<Vertex<InputTrack_t>*>& allVertices) const -> bool {
-  const SpacePointVector& candidatePos = vtx->fullPosition();
-  const SpacePointSymMatrix& candidateCov = vtx->fullCovariance();
+  const SpacePointVector& candidatePos = vtx.fullPosition();
+  const SpacePointSymMatrix& candidateCov = vtx.fullCovariance();
   const double candidateZPos = candidatePos[eZ];
   const double candidateZCov = candidateCov(eZ, eZ);
 
   for (const auto otherVtx : allVertices) {
-    if (vtx == otherVtx) {
+    if (&vtx == otherVtx) {
       continue;
     }
     const SpacePointVector& otherPos = otherVtx->fullPosition();
-- 
GitLab


From 59dcf84fd9f579ed927b83d8e97122f7b2e9f46b Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Fri, 6 Mar 2020 17:55:52 +0100
Subject: [PATCH 55/60] remove reference in .head call

---
 Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
index 4d685f9cd..257d147b3 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
+++ b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
@@ -19,7 +19,7 @@ Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
     return VertexingError::EmptyInput;
   }
 
-  const auto& vtxPos = vtx->fullPosition().template head<3>();
+  const auto vtxPos = vtx->fullPosition().template head<3>();
 
   // Get the linearized track
   const LinearizedTrack& linTrack = track.linearizedState;
-- 
GitLab


From 666d4ec70abf8845df9ee389e1c807264b6707fe Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Sun, 8 Mar 2020 13:10:43 +0100
Subject: [PATCH 56/60] replace find_if by for loop for finding closest track
 in z

---
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 21 +++++++++----------
 .../Vertexing/AdaptiveMultiVertexFitter.hpp   |  4 ++--
 2 files changed, 12 insertions(+), 13 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index d39f233ce..b89c6509b 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -420,17 +420,16 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
     // method to remove a track from seed tracks: Closest track in z to
     // vtx candidate
     double smallestDeltaZ = std::numeric_limits<double>::max();
-    auto smallestDzSeedIter = std::find_if(
-        seedTracks.begin(), seedTracks.end(),
-        [&vtx, &smallestDeltaZ, this](auto trk) {
-          double zDistance = std::abs(m_extractParameters(*trk).position()[eZ] -
-                                      vtx.position()[eZ]);
-          if (zDistance < smallestDeltaZ) {
-            smallestDeltaZ = zDistance;
-            return true;
-          }
-          return false;
-        });
+    auto smallestDzSeedIter = seedTracks.end();
+    for (auto trkIter = seedTracks.begin(); trkIter != seedTracks.end();
+         trkIter++) {
+      double zDistance = std::abs(
+          m_extractParameters(**trkIter).position()[eZ] - vtx.position()[eZ]);
+      if (zDistance < smallestDeltaZ) {
+        smallestDeltaZ = zDistance;
+        smallestDzSeedIter = trkIter;
+      }
+    }
     if (smallestDzSeedIter != seedTracks.end()) {
       seedTracks.erase(smallestDzSeedIter);
     } else {
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
index bd6301374..839cb7e07 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
@@ -77,7 +77,7 @@ class AdaptiveMultiVertexFitter {
       for (auto& vtx : vtxList) {
         // Add vertex link for each track
         for (auto& trk : vtxInfoMap[&vtx].trackLinks) {
-          trackToVerticesMultiMap.insert(std::make_pair(trk, &vtx));
+          trackToVerticesMultiMap.emplace(trk, &vtx);
         }
       }
     }
@@ -88,7 +88,7 @@ class AdaptiveMultiVertexFitter {
       for (auto vtx : vtxList) {
         // Add vertex link for each track
         for (auto trk : vtxInfoMap[vtx].trackLinks) {
-          trackToVerticesMultiMap.insert(std::make_pair(trk, vtx));
+          trackToVerticesMultiMap.emplace(trk, vtx);
         }
       }
     }
-- 
GitLab


From 06d205a082bd20d64d2e3117e848419d5f0402dc Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Mon, 9 Mar 2020 16:25:02 +0100
Subject: [PATCH 57/60] use references instead of pointers for KalmanUpdaters,
 use VertexSmoothing properly without TracksAtVertex

---
 .../Vertexing/AdaptiveMultiVertexFitter.hpp   |   7 +
 .../Vertexing/AdaptiveMultiVertexFitter.ipp   |  25 ++-
 .../Vertexing/KalmanVertexTrackUpdater.hpp    |   5 +-
 .../Vertexing/KalmanVertexTrackUpdater.ipp    |  24 +--
 .../Acts/Vertexing/KalmanVertexUpdater.hpp    |   8 +-
 .../Acts/Vertexing/KalmanVertexUpdater.ipp    |  22 +-
 .../include/Acts/Vertexing/VertexSmoother.hpp |  48 -----
 Tests/UnitTests/Core/Vertexing/CMakeLists.txt |   1 -
 .../KalmanVertexTrackUpdaterTests.cpp         |   5 +-
 .../Vertexing/KalmanVertexUpdaterTests.cpp    |   2 +-
 .../Core/Vertexing/VertexSmootherTests.cpp    | 192 ------------------
 11 files changed, 51 insertions(+), 288 deletions(-)
 delete mode 100644 Core/include/Acts/Vertexing/VertexSmoother.hpp
 delete mode 100644 Tests/UnitTests/Core/Vertexing/VertexSmootherTests.cpp

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
index 839cb7e07..c96566e97 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
@@ -288,6 +288,13 @@ class AdaptiveMultiVertexFitter {
   ///
   /// @return False if shift was larger than maxRelativeShift
   bool checkSmallShift(State& state) const;
+
+  /// @brief Updates tracks for current vertex with knowledge
+  /// of current vertex position
+  ///
+  /// @param state The state object
+  /// @param geoContext The geometry context
+  void doVertexSmoothing(State& state, const GeometryContext& geoContext) const;
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
index bd3755220..2f6b90fa4 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
@@ -6,8 +6,8 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
+#include "Acts/Vertexing/KalmanVertexTrackUpdater.hpp"
 #include "Acts/Vertexing/KalmanVertexUpdater.hpp"
-#include "Acts/Vertexing/VertexSmoother.hpp"
 #include "Acts/Vertexing/VertexingError.hpp"
 
 template <typename input_track_t, typename linearizer_t>
@@ -114,14 +114,7 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::fitImpl(
 
   // Check if smoothing is required
   if (m_cfg.doSmoothing) {
-    for (auto vtx : state.vertexCollection) {
-      // Smooth all tracks at vertex `vtx`
-      auto smoothRes = VertexSmoothing::smoothVertexSequentially<input_track_t>(
-          geoContext, vtx);
-      if (!smoothRes.ok()) {
-        return smoothRes.error();
-      }
-    }
+    doVertexSmoothing(state, geoContext);
   }
 
   return {};
@@ -298,7 +291,7 @@ Acts::Result<void> Acts::AdaptiveMultiVertexFitter<
           state.vtxInfoMap[vtx].linPoint = state.vtxInfoMap[vtx].oldPosition;
         }
         // Update the vertex with the new track
-        KalmanVertexUpdater::updateVertexWithTrack<input_track_t>(vtx,
+        KalmanVertexUpdater::updateVertexWithTrack<input_track_t>(*vtx,
                                                                   trkAtVtx);
       } else {
         ACTS_VERBOSE("Track weight too low. Skip track.");
@@ -344,3 +337,15 @@ bool Acts::AdaptiveMultiVertexFitter<
   }
   return true;
 }
+
+template <typename input_track_t, typename linearizer_t>
+void Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::
+    doVertexSmoothing(State& state, const GeometryContext& geoContext) const {
+  for (const auto vtx : state.vertexCollection) {
+    for (const auto trk : state.vtxInfoMap[vtx].trackLinks) {
+      KalmanVertexTrackUpdater::update<input_track_t>(
+          geoContext, state.tracksAtVerticesMap.at(std::make_pair(trk, vtx)),
+          *vtx);
+    }
+  }
+}
diff --git a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.hpp b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.hpp
index 6341b48a7..b069b2bb5 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.hpp
+++ b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.hpp
@@ -26,9 +26,8 @@ namespace KalmanVertexTrackUpdater {
 /// @param track Track to update
 /// @param vtx Vertex `track` belongs to
 template <typename input_track_t>
-Result<void> update(const GeometryContext& gctx,
-                    TrackAtVertex<input_track_t>& track,
-                    const Vertex<input_track_t>* vtx);
+void update(const GeometryContext& gctx, TrackAtVertex<input_track_t>& track,
+            const Vertex<input_track_t>& vtx);
 
 namespace detail {
 
diff --git a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
index 257d147b3..c898142c2 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
+++ b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
@@ -12,14 +12,10 @@
 #include "Acts/Vertexing/VertexingError.hpp"
 
 template <typename input_track_t>
-Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
-    const GeometryContext& gctx, TrackAtVertex<input_track_t>& track,
-    const Vertex<input_track_t>* vtx) {
-  if (vtx == nullptr) {
-    return VertexingError::EmptyInput;
-  }
-
-  const auto vtxPos = vtx->fullPosition().template head<3>();
+void Acts::KalmanVertexTrackUpdater::update(const GeometryContext& gctx,
+                                            TrackAtVertex<input_track_t>& track,
+                                            const Vertex<input_track_t>& vtx) {
+  const auto vtxPos = vtx.fullPosition().template head<3>();
 
   // Get the linearized track
   const LinearizedTrack& linTrack = track.linearizedState;
@@ -27,7 +23,7 @@ Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
   // Check if linearized state exists
   if (linTrack.covarianceAtPCA.determinant() == 0.) {
     // Track has no linearized state, returning w/o update
-    return {};
+    return;
   }
 
   // Retrieve linTrack information
@@ -58,7 +54,7 @@ Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
   newTrkParams(ParID_t::eQOP) = newTrkMomentum(2);           // qOverP
 
   // Vertex covariance and weight matrices
-  const auto vtxCov = vtx->fullCovariance().template block<3, 3>(0, 0);
+  const auto vtxCov = vtx.fullCovariance().template block<3, 3>(0, 0);
   const auto vtxWeight = vtxCov.inverse();
 
   // New track covariance matrix
@@ -75,11 +71,11 @@ Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
   const auto& reducedVtxWeight = matrixCache.newVertexWeight;
 
   // Difference in positions
-  auto posDiff = vtx->position() - matrixCache.newVertexPos;
+  auto posDiff = vtx.position() - matrixCache.newVertexPos;
 
   // Get smoothed params
   auto smParams =
-      trkParams - (residual + posJac * vtx->fullPosition().template head<3>() +
+      trkParams - (residual + posJac * vtx.fullPosition().template head<3>() +
                    momJac * newTrkMomentum);
 
   // New chi2 to be set later
@@ -104,7 +100,7 @@ Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
   // Create new refitted parameters
   std::shared_ptr<PerigeeSurface> perigeeSurface =
       Surface::makeShared<PerigeeSurface>(
-          VectorHelpers::position(vtx->fullPosition()));
+          VectorHelpers::position(vtx.fullPosition()));
 
   BoundParameters refittedPerigee = BoundParameters(
       gctx, std::move(fullPerTrackCov), newTrkParams, perigeeSurface);
@@ -114,7 +110,7 @@ Acts::Result<void> Acts::KalmanVertexTrackUpdater::update(
   track.chi2Track = chi2;
   track.ndf = 2 * track.trackWeight;
 
-  return {};
+  return;
 }
 
 Acts::BoundMatrix
diff --git a/Core/include/Acts/Vertexing/KalmanVertexUpdater.hpp b/Core/include/Acts/Vertexing/KalmanVertexUpdater.hpp
index adb667eea..e682b5e6a 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexUpdater.hpp
+++ b/Core/include/Acts/Vertexing/KalmanVertexUpdater.hpp
@@ -41,7 +41,7 @@ struct MatrixCache {
 /// @param vtx Vertex to be updated
 /// @param trk Track to be used for updating the vertex
 template <typename input_track_t>
-void updateVertexWithTrack(Vertex<input_track_t>* vtx,
+void updateVertexWithTrack(Vertex<input_track_t>& vtx,
                            TrackAtVertex<input_track_t>& trk);
 
 /// @brief Updates vertex position
@@ -54,7 +54,7 @@ void updateVertexWithTrack(Vertex<input_track_t>* vtx,
 ///
 /// @return Vertex with updated position and covariance
 template <typename input_track_t>
-void updatePosition(const Acts::Vertex<input_track_t>* vtx,
+void updatePosition(const Acts::Vertex<input_track_t>& vtx,
                     const Acts::LinearizedTrack& linTrack, double trackWeight,
                     int sign, MatrixCache& matrixCache);
 
@@ -67,7 +67,7 @@ namespace detail {
 ///
 /// @return Chi2
 template <typename input_track_t>
-double vertexPositionChi2(const Vertex<input_track_t>* oldVtx,
+double vertexPositionChi2(const Vertex<input_track_t>& oldVtx,
                           const MatrixCache& matrixCache);
 
 /// @brief Calculates chi2 of refitted track parameters
@@ -88,7 +88,7 @@ double trackParametersChi2(const LinearizedTrack& linTrack,
 /// @param trk Track to be added to/removed from vtx
 /// @param sign +1 (add track) or -1 (remove track)
 template <typename input_track_t>
-void update(Vertex<input_track_t>* vtx, TrackAtVertex<input_track_t>& trk,
+void update(Vertex<input_track_t>& vtx, TrackAtVertex<input_track_t>& trk,
             int sign);
 }  // Namespace detail
 
diff --git a/Core/include/Acts/Vertexing/KalmanVertexUpdater.ipp b/Core/include/Acts/Vertexing/KalmanVertexUpdater.ipp
index 64b9e8337..aac2e8508 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexUpdater.ipp
+++ b/Core/include/Acts/Vertexing/KalmanVertexUpdater.ipp
@@ -11,13 +11,13 @@
 
 template <typename input_track_t>
 void Acts::KalmanVertexUpdater::updateVertexWithTrack(
-    Vertex<input_track_t>* vtx, TrackAtVertex<input_track_t>& trk) {
+    Vertex<input_track_t>& vtx, TrackAtVertex<input_track_t>& trk) {
   detail::update<input_track_t>(vtx, trk, 1);
 }
 
 template <typename input_track_t>
 void Acts::KalmanVertexUpdater::detail::update(
-    Vertex<input_track_t>* vtx, TrackAtVertex<input_track_t>& trk, int sign) {
+    Vertex<input_track_t>& vtx, TrackAtVertex<input_track_t>& trk, int sign) {
   double trackWeight = trk.trackWeight;
 
   MatrixCache matrixCache;
@@ -25,7 +25,7 @@ void Acts::KalmanVertexUpdater::detail::update(
   updatePosition(vtx, trk.linearizedState, trackWeight, sign, matrixCache);
 
   // Get fit quality parameters wrt to old vertex
-  std::pair fitQuality = vtx->fitQuality();
+  std::pair fitQuality = vtx.fitQuality();
   double chi2 = fitQuality.first;
   double ndf = fitQuality.second;
 
@@ -41,9 +41,9 @@ void Acts::KalmanVertexUpdater::detail::update(
   ndf += sign * trackWeight * 2.;
 
   // Updating the vertex
-  vtx->setPosition(matrixCache.newVertexPos);
-  vtx->setCovariance(matrixCache.newVertexCov);
-  vtx->setFitQuality(chi2, ndf);
+  vtx.setPosition(matrixCache.newVertexPos);
+  vtx.setCovariance(matrixCache.newVertexCov);
+  vtx.setFitQuality(chi2, ndf);
 
   // Updates track at vertex if already there
   // by removing it first and adding new one.
@@ -61,7 +61,7 @@ void Acts::KalmanVertexUpdater::detail::update(
 
 template <typename input_track_t>
 void Acts::KalmanVertexUpdater::updatePosition(
-    const Acts::Vertex<input_track_t>* vtx,
+    const Acts::Vertex<input_track_t>& vtx,
     const Acts::LinearizedTrack& linTrack, double trackWeight, int sign,
     MatrixCache& matrixCache) {
   // Retrieve linTrack information
@@ -74,8 +74,8 @@ void Acts::KalmanVertexUpdater::updatePosition(
   const auto& trkParamWeight = linTrack.weightAtPCA.block<5, 5>(0, 0);
 
   // Vertex to be updated
-  const auto& oldVtxPos = vtx->position();
-  matrixCache.oldVertexWeight = (vtx->covariance()).inverse();
+  const auto& oldVtxPos = vtx.position();
+  matrixCache.oldVertexWeight = (vtx.covariance()).inverse();
 
   // W_k matrix
   matrixCache.momWeightInv =
@@ -101,8 +101,8 @@ void Acts::KalmanVertexUpdater::updatePosition(
 
 template <typename input_track_t>
 double Acts::KalmanVertexUpdater::detail::vertexPositionChi2(
-    const Vertex<input_track_t>* oldVtx, const MatrixCache& matrixCache) {
-  auto posDiff = matrixCache.newVertexPos - oldVtx->position();
+    const Vertex<input_track_t>& oldVtx, const MatrixCache& matrixCache) {
+  auto posDiff = matrixCache.newVertexPos - oldVtx.position();
 
   // Calculate and return corresponding chi2
   return posDiff.transpose() * (matrixCache.oldVertexWeight * posDiff);
diff --git a/Core/include/Acts/Vertexing/VertexSmoother.hpp b/Core/include/Acts/Vertexing/VertexSmoother.hpp
deleted file mode 100644
index a2065e1a6..000000000
--- a/Core/include/Acts/Vertexing/VertexSmoother.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-// This file is part of the Acts project.
-//
-// Copyright (C) 2019 CERN for the benefit of the Acts project
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#pragma once
-
-#include "Acts/Utilities/Result.hpp"
-#include "Acts/Vertexing/KalmanVertexTrackUpdater.hpp"
-#include "Acts/Vertexing/TrackAtVertex.hpp"
-#include "Acts/Vertexing/Vertex.hpp"
-
-namespace Acts {
-namespace VertexSmoothing {
-
-/// @brief Updates all tracks at vertex
-/// with knowledge of the vertex position
-///
-/// @param gctx The Geometry Context
-/// @param vtx The vertex
-///
-/// @tparam input_track_t Track object type
-template <typename input_track_t>
-static Result<void> smoothVertexSequentially(const GeometryContext& gctx,
-                                             Vertex<input_track_t>* vtx) {
-  if (vtx == nullptr) {
-    return VertexingError::EmptyInput;
-  }
-
-  std::vector<TrackAtVertex<input_track_t>> tracks = vtx->tracks();
-  for (auto& trk : tracks) {
-    // update trk
-    auto res = KalmanVertexTrackUpdater::update<input_track_t>(gctx, trk, vtx);
-    if (!res.ok()) {
-      return res.error();
-    }
-  }
-
-  vtx->setTracksAtVertex(tracks);
-
-  return {};
-}
-
-}  // Namespace VertexSmoothing
-}  // Namespace Acts
diff --git a/Tests/UnitTests/Core/Vertexing/CMakeLists.txt b/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
index 829ef494c..e7f49ea2f 100644
--- a/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
+++ b/Tests/UnitTests/Core/Vertexing/CMakeLists.txt
@@ -7,6 +7,5 @@ add_unittest(LinearizedTrackFactoryTests LinearizedTrackFactoryTests.cpp)
 add_unittest(AdaptiveMultiVertexFitterTests AdaptiveMultiVertexFitterTests.cpp)
 add_unittest(AdaptiveMultiVertexFinderTests AdaptiveMultiVertexFinderTests.cpp)
 add_unittest(TrackToVertexIPEstimatorTests TrackToVertexIPEstimatorTests.cpp)
-add_unittest(VertexSmootherTests VertexSmootherTests.cpp)
 add_unittest(ZScanVertexFinderTests ZScanVertexFinderTests.cpp)
 add_unittest(TrackDensityVertexFinderTests TrackDensityVertexFinderTests.cpp)
\ No newline at end of file
diff --git a/Tests/UnitTests/Core/Vertexing/KalmanVertexTrackUpdaterTests.cpp b/Tests/UnitTests/Core/Vertexing/KalmanVertexTrackUpdaterTests.cpp
index 12ad0af59..864d36741 100644
--- a/Tests/UnitTests/Core/Vertexing/KalmanVertexTrackUpdaterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/KalmanVertexTrackUpdaterTests.cpp
@@ -150,10 +150,7 @@ BOOST_AUTO_TEST_CASE(Kalman_Vertex_TrackUpdater) {
     Vertex<BoundParameters> vtx(vtxPos);
 
     // Update trkAtVertex with assumption of originating from vtx
-    auto res = KalmanVertexTrackUpdater::update<BoundParameters>(
-        tgContext, trkAtVtx, &vtx);
-
-    BOOST_CHECK(res.ok());
+    KalmanVertexTrackUpdater::update<BoundParameters>(tgContext, trkAtVtx, vtx);
 
     // The old distance
     double oldDistance =
diff --git a/Tests/UnitTests/Core/Vertexing/KalmanVertexUpdaterTests.cpp b/Tests/UnitTests/Core/Vertexing/KalmanVertexUpdaterTests.cpp
index 4afde035d..8141369f7 100644
--- a/Tests/UnitTests/Core/Vertexing/KalmanVertexUpdaterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/KalmanVertexUpdaterTests.cpp
@@ -145,7 +145,7 @@ BOOST_AUTO_TEST_CASE(Kalman_Vertex_Updater) {
     vtx.setFullCovariance(SpacePointSymMatrix::Identity() * 0.01);
 
     // Update trkAtVertex with assumption of originating from vtx
-    KalmanVertexUpdater::updateVertexWithTrack<BoundParameters>(&vtx, trkAtVtx);
+    KalmanVertexUpdater::updateVertexWithTrack<BoundParameters>(vtx, trkAtVtx);
 
     if (debug) {
       std::cout << "Old vertex position: " << vtxPos << std::endl;
diff --git a/Tests/UnitTests/Core/Vertexing/VertexSmootherTests.cpp b/Tests/UnitTests/Core/Vertexing/VertexSmootherTests.cpp
deleted file mode 100644
index 8970a28a1..000000000
--- a/Tests/UnitTests/Core/Vertexing/VertexSmootherTests.cpp
+++ /dev/null
@@ -1,192 +0,0 @@
-// This file is part of the Acts project.
-//
-// Copyright (C) 2019 CERN for the benefit of the Acts project
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include <boost/test/data/test_case.hpp>
-#include <boost/test/tools/output_test_stream.hpp>
-#include <boost/test/unit_test.hpp>
-
-#include <Acts/Vertexing/VertexSmoother.hpp>
-#include "Acts/MagneticField/ConstantBField.hpp"
-#include "Acts/Propagator/EigenStepper.hpp"
-#include "Acts/Propagator/Propagator.hpp"
-#include "Acts/Surfaces/PerigeeSurface.hpp"
-#include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
-#include "Acts/Utilities/Definitions.hpp"
-#include "Acts/Utilities/Units.hpp"
-#include "Acts/Vertexing/FullBilloirVertexFitter.hpp"
-#include "Acts/Vertexing/HelicalTrackLinearizer.hpp"
-#include "Acts/Vertexing/Vertex.hpp"
-
-namespace Acts {
-namespace Test {
-
-using Covariance = BoundSymMatrix;
-using Propagator = Propagator<EigenStepper<ConstantBField>>;
-using Linearizer_t = HelicalTrackLinearizer<Propagator>;
-
-// Create a test context
-GeometryContext tgContext = GeometryContext();
-MagneticFieldContext mfContext = MagneticFieldContext();
-
-// Vertex x/y position distribution
-std::uniform_real_distribution<> vXYDist(-0.1 * units::_mm, 0.1 * units::_mm);
-// Vertex z position distribution
-std::uniform_real_distribution<> vZDist(-20 * units::_mm, 20 * units::_mm);
-// Track d0 distribution
-std::uniform_real_distribution<> d0Dist(-0.01 * units::_mm, 0.01 * units::_mm);
-// Track z0 distribution
-std::uniform_real_distribution<> z0Dist(-0.2 * units::_mm, 0.2 * units::_mm);
-// Track pT distribution
-std::uniform_real_distribution<> pTDist(0.4 * units::_GeV, 10. * units::_GeV);
-// Track phi distribution
-std::uniform_real_distribution<> phiDist(-M_PI, M_PI);
-// Track theta distribution
-std::uniform_real_distribution<> thetaDist(1.0, M_PI - 1.0);
-// Track charge helper distribution
-std::uniform_real_distribution<> qDist(-1, 1);
-// Track IP resolution distribution
-std::uniform_real_distribution<> resIPDist(0., 100. * units::_um);
-// Track angular distribution
-std::uniform_real_distribution<> resAngDist(0., 0.1);
-// Track q/p resolution distribution
-std::uniform_real_distribution<> resQoPDist(-0.1, 0.1);
-// Number of tracks distritbution
-std::uniform_int_distribution<> nTracksDist(3, 10);
-
-/// @brief Unit test for VertexSmoother
-///
-BOOST_AUTO_TEST_CASE(sequential_vertex_smoother_test) {
-  bool debugMode = false;
-
-  // Set up RNG
-  int mySeed = 31415;
-  std::mt19937 gen(mySeed);
-
-  // Number of tracks
-  unsigned int nTracks = nTracksDist(gen);
-
-  // Set up constant B-Field
-  ConstantBField bField(Vector3D(0., 0., 1.) * units::_T);
-
-  // Set up Eigenstepper
-  EigenStepper<ConstantBField> stepper(bField);
-
-  // Set up propagator with void navigator
-  auto propagator = std::make_shared<Propagator>(stepper);
-
-  // Set up LinearizedTrackFactory, needed for linearizing the tracks
-  PropagatorOptions<> pOptions(tgContext, mfContext);
-
-  // Linearizer for BoundParameters type test
-  Linearizer_t::Config ltConfig(bField, propagator, pOptions);
-  Linearizer_t linearizer(ltConfig);
-
-  // Set up Billoir Vertex Fitter
-  FullBilloirVertexFitter<BoundParameters, Linearizer_t>::Config
-      vertexFitterCfg;
-  FullBilloirVertexFitter<BoundParameters, Linearizer_t> billoirFitter(
-      vertexFitterCfg);
-
-  VertexFitterOptions<BoundParameters> vfOptions(tgContext, mfContext);
-
-  // Now: create some tracks, fit and retrieve vertex using Billoirfitter
-  // Create position of vertex and perigee surface
-  double x = vXYDist(gen);
-  double y = vXYDist(gen);
-  double z = vZDist(gen);
-
-  SpacePointVector vertexPosition(x, y, z, 0.);
-  std::shared_ptr<PerigeeSurface> perigeeSurface =
-      Surface::makeShared<PerigeeSurface>(Vector3D(0., 0., 0.));
-
-  // Calculate d0 and z0 corresponding to vertex position
-  double d0V = sqrt(x * x + y * y);
-  double z0V = z;
-
-  // Start constructing nTracks tracks in the following
-  std::vector<BoundParameters> tracks;
-
-  // Construct random track emerging from vicinity of vertex position
-  // Vector to store track objects used for vertex fit
-  for (unsigned int iTrack = 0; iTrack < nTracks; iTrack++) {
-    // Construct positive or negative charge randomly
-    double q = qDist(gen) < 0 ? -1. : 1.;
-
-    // Construct random track parameters
-    BoundParameters::ParVector_t paramVec;
-    paramVec << d0V + d0Dist(gen), z0V + z0Dist(gen), phiDist(gen),
-        thetaDist(gen), q / pTDist(gen), 0.;
-
-    // Fill vector of track objects with simple covariance matrix
-    Covariance covMat;
-
-    // Resolutions
-    double resD0 = resIPDist(gen);
-    double resZ0 = resIPDist(gen);
-    double resPh = resAngDist(gen);
-    double resTh = resAngDist(gen);
-    double resQp = resQoPDist(gen);
-
-    covMat << resD0 * resD0, 0., 0., 0., 0., 0., 0., resZ0 * resZ0, 0., 0., 0.,
-        0., 0., 0., resPh * resPh, 0., 0., 0., 0., 0., 0., resTh * resTh, 0.,
-        0., 0., 0., 0., 0., resQp * resQp, 0., 0., 0., 0., 0., 0., 1.;
-    tracks.push_back(BoundParameters(tgContext, std::move(covMat), paramVec,
-                                     perigeeSurface));
-  }
-
-  std::vector<const BoundParameters*> tracksPtr;
-  for (const auto& trk : tracks) {
-    tracksPtr.push_back(&trk);
-  }
-
-  Vertex<BoundParameters> fittedVertex =
-      billoirFitter.fit(tracksPtr, linearizer, vfOptions).value();
-
-  // copy vertex for later comparison
-  Vertex<BoundParameters> vertexBeforeSmoothing = fittedVertex;
-
-  VertexSmoothing::smoothVertexSequentially<BoundParameters>(tgContext,
-                                                             &fittedVertex);
-
-  // Billoirfitter does not provide the TracksAtVertex with a linearized
-  // state,
-  // hence returns tracks not refitted. However, sizes should match.
-  BOOST_CHECK_EQUAL(vertexBeforeSmoothing.tracks().size(),
-                    fittedVertex.tracks().size());
-
-  std::vector<TrackAtVertex<BoundParameters>> tracksWithLinState;
-  for (auto trackAtVtx : fittedVertex.tracks()) {
-    BoundParameters fittedParams = trackAtVtx.fittedParams;
-
-    LinearizedTrack linTrack =
-        linearizer.linearizeTrack(fittedParams, vertexPosition).value();
-    trackAtVtx.linearizedState = linTrack;
-    tracksWithLinState.push_back(trackAtVtx);
-  }
-
-  // set tracks with linearized state to vertex
-  fittedVertex.setTracksAtVertex(tracksWithLinState);
-  VertexSmoothing::smoothVertexSequentially<BoundParameters>(tgContext,
-                                                             &fittedVertex);
-
-  BOOST_CHECK_EQUAL(vertexBeforeSmoothing.tracks().size(),
-                    fittedVertex.tracks().size());
-
-  for (unsigned int i = 0; i < fittedVertex.tracks().size(); ++i) {
-    auto paramOld = vertexBeforeSmoothing.tracks()[i].fittedParams;
-    auto paramNew = fittedVertex.tracks()[i].fittedParams;
-    BOOST_CHECK_NE(paramOld, paramNew);
-    if (debugMode) {
-      std::cout << "Track %d, old params: " << paramOld << std::endl;
-      std::cout << "Track %d, new params: " << paramNew << std::endl;
-    }
-  }
-}
-
-}  // namespace Test
-}  // namespace Acts
-- 
GitLab


From 21cb0e08319346116d0a824843f19bb4dbc883e6 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Thu, 12 Mar 2020 12:26:25 +0100
Subject: [PATCH 58/60] bug fixes: remove auto keyword where Eigen doesnt like
 it

---
 .../Acts/Utilities/AnnealingUtility.hpp       |  4 +-
 Core/include/Acts/Vertexing/AMVFInfo.hpp      |  2 +-
 .../Vertexing/AdaptiveMultiVertexFitter.ipp   | 24 +++--
 .../Vertexing/KalmanVertexTrackUpdater.ipp    | 12 +--
 .../Acts/Vertexing/KalmanVertexUpdater.hpp    |  1 -
 .../Acts/Vertexing/KalmanVertexUpdater.ipp    | 25 +++---
 Core/include/Acts/Vertexing/TrackAtVertex.hpp |  8 +-
 Core/include/Acts/Vertexing/Vertex.hpp        |  8 +-
 Core/include/Acts/Vertexing/Vertex.ipp        | 12 +--
 .../AdaptiveMultiVertexFitterTests.cpp        | 90 ++++++++++---------
 10 files changed, 95 insertions(+), 91 deletions(-)

diff --git a/Core/include/Acts/Utilities/AnnealingUtility.hpp b/Core/include/Acts/Utilities/AnnealingUtility.hpp
index df6208715..92b2119fc 100644
--- a/Core/include/Acts/Utilities/AnnealingUtility.hpp
+++ b/Core/include/Acts/Utilities/AnnealingUtility.hpp
@@ -19,10 +19,10 @@ class AnnealingUtility {
   /// Resetting the state is done by just creating a new instance
   struct State {
     // Points to current temperature value in m_cfg.setOfTemperatures
-    unsigned int currentTemperatureIndex = 0;
+    unsigned int currentTemperatureIndex{0};
 
     // Checks if equilibrium is reached
-    bool equilibriumReached = false;
+    bool equilibriumReached{false};
   };
 
   /// @brief The configuration struct
diff --git a/Core/include/Acts/Vertexing/AMVFInfo.hpp b/Core/include/Acts/Vertexing/AMVFInfo.hpp
index 8174a09db..f796f4507 100644
--- a/Core/include/Acts/Vertexing/AMVFInfo.hpp
+++ b/Core/include/Acts/Vertexing/AMVFInfo.hpp
@@ -39,7 +39,7 @@ struct VertexInfo {
   Acts::SpacePointVector seedPosition{Acts::SpacePointVector::Zero()};
 
   // Needs relinearization bool
-  bool relinearize;
+  bool relinearize = true;
 
   // Vector of all track currently held by vertex
   std::vector<const input_track_t*> trackLinks;
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
index 2f6b90fa4..4cdfd4732 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp
@@ -63,7 +63,8 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::fitImpl(
       // in previous iteration afterwards
       currentVtxInfo.oldPosition = currentVtx->fullPosition();
 
-      auto dist = currentVtxInfo.oldPosition - currentVtxInfo.linPoint;
+      SpacePointVector dist =
+          currentVtxInfo.oldPosition - currentVtxInfo.linPoint;
       double perpDist = std::sqrt(dist[0] * dist[0] + dist[1] * dist[1]);
       // Determine if relinearization is needed
       if (perpDist > m_cfg.maxDistToLinPoint) {
@@ -75,24 +76,21 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::fitImpl(
       // Determine if constraint vertex exist
       if (state.vtxInfoMap[currentVtx].constraintVertex.fullCovariance() !=
           SpacePointSymMatrix::Zero()) {
-        currentVtx->setPosition(state.vtxInfoMap[currentVtx]
-                                    .constraintVertex.fullPosition()
-                                    .template head<3>());
+        currentVtx->setFullPosition(
+            state.vtxInfoMap[currentVtx].constraintVertex.fullPosition());
         currentVtx->setFitQuality(
             state.vtxInfoMap[currentVtx].constraintVertex.fitQuality());
-        currentVtx->setCovariance(state.vtxInfoMap[currentVtx]
-                                      .constraintVertex.fullCovariance()
-                                      .template block<3, 3>(0, 0));
+        currentVtx->setFullCovariance(
+            state.vtxInfoMap[currentVtx].constraintVertex.fullCovariance());
       }
 
       else if (currentVtx->fullCovariance() == SpacePointSymMatrix::Zero()) {
         return VertexingError::NoCovariance;
       }
-      auto weight =
+      double weight =
           1. / m_cfg.annealingTool.getWeight(state.annealingState, 1.);
 
-      auto covAnn = currentVtx->fullCovariance() * weight;
-      currentVtx->setCovariance(covAnn.template block<3, 3>(0, 0));
+      currentVtx->setFullCovariance(currentVtx->fullCovariance() * weight);
 
       // Set vertexCompatibility for all TrackAtVertex objects
       // at current vertex
@@ -216,7 +214,7 @@ Acts::Result<void> Acts::
       return res.error();
     }
     // Set ip3dParams for current trackAtVertex
-    currentVtxInfo.ip3dParams.insert(std::make_pair(trk, *(res.value())));
+    currentVtxInfo.ip3dParams.emplace(trk, *(res.value()));
   }
   return {};
 }
@@ -244,9 +242,7 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::
         return res.error();
       }
       // Set ip3dParams for current trackAtVertex
-      auto value = std::move(res.value());
-
-      currentVtxInfo.ip3dParams.insert(std::make_pair(trk, *value));
+      currentVtxInfo.ip3dParams.emplace(trk, *(res.value()));
     }
     // Set compatibility with current vertex
     auto compRes = m_cfg.ipEst.getVertexCompatibility(
diff --git a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
index c898142c2..2e28a2c3f 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
+++ b/Core/include/Acts/Vertexing/KalmanVertexTrackUpdater.ipp
@@ -27,16 +27,16 @@ void Acts::KalmanVertexTrackUpdater::update(const GeometryContext& gctx,
   }
 
   // Retrieve linTrack information
-  const auto& posJac = linTrack.positionJacobian.block<5, 3>(0, 0);
-  const auto& momJac = linTrack.momentumJacobian.block<5, 3>(0, 0);
-  const auto& trkParams = linTrack.parametersAtPCA.head<5>();
-  const auto& trkParamWeight = linTrack.weightAtPCA.block<5, 5>(0, 0);
+  const auto posJac = linTrack.positionJacobian.block<5, 3>(0, 0);
+  const auto momJac = linTrack.momentumJacobian.block<5, 3>(0, 0);
+  const auto trkParams = linTrack.parametersAtPCA.head<5>();
+  const auto trkParamWeight = linTrack.weightAtPCA.block<5, 5>(0, 0);
 
   // Calculate S matrix
   ActsSymMatrixD<3> sMat =
       (momJac.transpose() * (trkParamWeight * momJac)).inverse();
 
-  const auto& residual = linTrack.constantTerm.head<5>();
+  const auto residual = linTrack.constantTerm.head<5>();
 
   // Refit track momentum
   Vector3D newTrkMomentum = sMat * momJac.transpose() * trkParamWeight *
@@ -94,7 +94,7 @@ void Acts::KalmanVertexTrackUpdater::update(const GeometryContext& gctx,
   SpacePointSymMatrix vtxFullCov(SpacePointSymMatrix::Zero());
   vtxFullCov.block<3, 3>(0, 0) = vtxCov;
 
-  const auto& fullPerTrackCov = detail::createFullTrackCovariance(
+  const auto fullPerTrackCov = detail::createFullTrackCovariance(
       sMat, newFullTrkCov, vtxFullWeight, vtxFullCov, newTrkParams);
 
   // Create new refitted parameters
diff --git a/Core/include/Acts/Vertexing/KalmanVertexUpdater.hpp b/Core/include/Acts/Vertexing/KalmanVertexUpdater.hpp
index e682b5e6a..ebcef8cc5 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexUpdater.hpp
+++ b/Core/include/Acts/Vertexing/KalmanVertexUpdater.hpp
@@ -28,7 +28,6 @@ struct MatrixCache {
   ActsSymMatrixD<3> newVertexCov = ActsSymMatrixD<3>::Zero();
   ActsSymMatrixD<3> newVertexWeight = ActsSymMatrixD<3>::Zero();
   ActsSymMatrixD<3> oldVertexWeight = ActsSymMatrixD<3>::Zero();
-  ActsSymMatrixD<5> trkParamWeight = ActsSymMatrixD<5>::Zero();
   ActsSymMatrixD<3> momWeightInv = ActsSymMatrixD<3>::Zero();
 };
 
diff --git a/Core/include/Acts/Vertexing/KalmanVertexUpdater.ipp b/Core/include/Acts/Vertexing/KalmanVertexUpdater.ipp
index aac2e8508..4bfc4341d 100644
--- a/Core/include/Acts/Vertexing/KalmanVertexUpdater.ipp
+++ b/Core/include/Acts/Vertexing/KalmanVertexUpdater.ipp
@@ -66,12 +66,12 @@ void Acts::KalmanVertexUpdater::updatePosition(
     MatrixCache& matrixCache) {
   // Retrieve linTrack information
   // TODO: To make 4-D compatible, remove block<> and head<> statements
-  const auto& posJac = linTrack.positionJacobian.block<5, 3>(0, 0);
-  const auto& momJac =
+  const auto posJac = linTrack.positionJacobian.block<5, 3>(0, 0);
+  const auto momJac =
       linTrack.momentumJacobian.block<5, 3>(0, 0);  // B_k in comments below
-  const auto& trkParams = linTrack.parametersAtPCA.head<5>();
-  const auto& constTerm = linTrack.constantTerm.head<5>();
-  const auto& trkParamWeight = linTrack.weightAtPCA.block<5, 5>(0, 0);
+  const auto trkParams = linTrack.parametersAtPCA.head<5>();
+  const auto constTerm = linTrack.constantTerm.head<5>();
+  const auto trkParamWeight = linTrack.weightAtPCA.block<5, 5>(0, 0);
 
   // Vertex to be updated
   const auto& oldVtxPos = vtx.position();
@@ -86,6 +86,7 @@ void Acts::KalmanVertexUpdater::updatePosition(
                trkParamWeight *
                    (momJac * (matrixCache.momWeightInv * momJac.transpose())) *
                    trkParamWeight.transpose();
+
   // New vertex cov matrix
   matrixCache.newVertexWeight =
       matrixCache.oldVertexWeight +
@@ -102,7 +103,7 @@ void Acts::KalmanVertexUpdater::updatePosition(
 template <typename input_track_t>
 double Acts::KalmanVertexUpdater::detail::vertexPositionChi2(
     const Vertex<input_track_t>& oldVtx, const MatrixCache& matrixCache) {
-  auto posDiff = matrixCache.newVertexPos - oldVtx.position();
+  Vector3D posDiff = matrixCache.newVertexPos - oldVtx.position();
 
   // Calculate and return corresponding chi2
   return posDiff.transpose() * (matrixCache.oldVertexWeight * posDiff);
@@ -112,13 +113,13 @@ template <typename input_track_t>
 double Acts::KalmanVertexUpdater::detail::trackParametersChi2(
     const LinearizedTrack& linTrack, const MatrixCache& matrixCache) {
   // Track properties
-  const auto& posJac = linTrack.positionJacobian.block<5, 3>(0, 0);
-  const auto& momJac = linTrack.momentumJacobian.block<5, 3>(0, 0);
-  const auto& trkParams = linTrack.parametersAtPCA.head<5>();
-  const auto& constTerm = linTrack.constantTerm.head<5>();
-  const auto& trkParamWeight = linTrack.weightAtPCA.block<5, 5>(0, 0);
+  const auto posJac = linTrack.positionJacobian.block<5, 3>(0, 0);
+  const auto momJac = linTrack.momentumJacobian.block<5, 3>(0, 0);
+  const auto trkParams = linTrack.parametersAtPCA.head<5>();
+  const auto constTerm = linTrack.constantTerm.head<5>();
+  const auto trkParamWeight = linTrack.weightAtPCA.block<5, 5>(0, 0);
 
-  const auto& jacVtx = posJac * matrixCache.newVertexPos;
+  const auto jacVtx = posJac * matrixCache.newVertexPos;
 
   // Refitted track momentum
   Vector3D newTrackMomentum = matrixCache.momWeightInv * momJac.transpose() *
diff --git a/Core/include/Acts/Vertexing/TrackAtVertex.hpp b/Core/include/Acts/Vertexing/TrackAtVertex.hpp
index 689e52a2c..b404c54c8 100644
--- a/Core/include/Acts/Vertexing/TrackAtVertex.hpp
+++ b/Core/include/Acts/Vertexing/TrackAtVertex.hpp
@@ -61,20 +61,20 @@ struct TrackAtVertex {
   const input_track_t* originalParams;
 
   /// Chi2 of track
-  double chi2Track;
+  double chi2Track = 0;
 
   /// Number degrees of freedom
   /// Note: Can be different from integer value
   /// since annealing can result in effective
   /// non-interger values
-  double ndf;
+  double ndf = 0;
 
   /// Value of the compatibility of the track to the actual vertex, based
   /// on the estimation of the 3d distance between the track and the vertex
-  double vertexCompatibility;
+  double vertexCompatibility = 0;
 
   /// Weight of track in fit
-  double trackWeight;
+  double trackWeight = 0;
 
   /// The linearized state of the track at vertex
   LinearizedTrack linearizedState;
diff --git a/Core/include/Acts/Vertexing/Vertex.hpp b/Core/include/Acts/Vertexing/Vertex.hpp
index 45549e63c..fcb4c24fd 100644
--- a/Core/include/Acts/Vertexing/Vertex.hpp
+++ b/Core/include/Acts/Vertexing/Vertex.hpp
@@ -41,7 +41,7 @@ class Vertex {
   /// @param covariance Position covariance matrix
   /// @param tracks Vector of tracks associated with the vertex
   Vertex(const Vector3D& position, const ActsSymMatrixD<3>& covariance,
-         std::vector<TrackAtVertex<input_track_t>>& tracks);
+         const std::vector<TrackAtVertex<input_track_t>>& tracks);
 
   /// @brief Vertex constructor
   ///
@@ -50,7 +50,7 @@ class Vertex {
   /// @param tracks Vector of tracks associated with the vertex
   Vertex(const SpacePointVector& position,
          const SpacePointSymMatrix& covariance,
-         std::vector<TrackAtVertex<input_track_t>>& tracks);
+         const std::vector<TrackAtVertex<input_track_t>>& tracks);
 
   /// @return Returns 3-position
   Vector3D position() const;
@@ -114,8 +114,8 @@ class Vertex {
   SpacePointVector m_position = SpacePointVector::Zero();
   SpacePointSymMatrix m_covariance = SpacePointSymMatrix::Zero();
   std::vector<TrackAtVertex<input_track_t>> m_tracksAtVertex;
-  double m_chiSquared = std::numeric_limits<double>::max();  // chi2 of the fit
-  double m_numberDoF = 0.;  // number of degrees of freedom
+  double m_chiSquared = 1e9;  // chi2 of the fit
+  double m_numberDoF = 0.;    // number of degrees of freedom
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Vertexing/Vertex.ipp b/Core/include/Acts/Vertexing/Vertex.ipp
index 61c0fe08c..12ac7106f 100644
--- a/Core/include/Acts/Vertexing/Vertex.ipp
+++ b/Core/include/Acts/Vertexing/Vertex.ipp
@@ -24,8 +24,8 @@ Acts::Vertex<input_track_t>::Vertex(const SpacePointVector& position)
 template <typename input_track_t>
 Acts::Vertex<input_track_t>::Vertex(
     const Vector3D& position, const ActsSymMatrixD<3>& covariance,
-    std::vector<TrackAtVertex<input_track_t>>& tracks)
-    : m_tracksAtVertex(std::move(tracks)) {
+    const std::vector<TrackAtVertex<input_track_t>>& tracks)
+    : m_tracksAtVertex(tracks) {
   m_position.setZero();
   VectorHelpers::position(m_position) = position;
   m_covariance.setZero();
@@ -35,10 +35,10 @@ Acts::Vertex<input_track_t>::Vertex(
 template <typename input_track_t>
 Acts::Vertex<input_track_t>::Vertex(
     const SpacePointVector& position, const SpacePointSymMatrix& covariance,
-    std::vector<TrackAtVertex<input_track_t>>& tracks)
+    const std::vector<TrackAtVertex<input_track_t>>& tracks)
     : m_position(position),
       m_covariance(covariance),
-      m_tracksAtVertex(std::move(tracks)) {}
+      m_tracksAtVertex(tracks) {}
 
 template <typename input_track_t>
 Acts::Vector3D Acts::Vertex<input_track_t>::position() const {
@@ -81,6 +81,7 @@ std::pair<double, double> Acts::Vertex<input_track_t>::fitQuality() const {
 template <typename input_track_t>
 void Acts::Vertex<input_track_t>::setPosition(const Vector3D& position,
                                               ParValue_t time) {
+  m_position.setZero();
   VectorHelpers::position(m_position) = position;
   VectorHelpers::time(m_position) = time;
 }
@@ -99,6 +100,7 @@ void Acts::Vertex<input_track_t>::setTime(ParValue_t time) {
 template <typename input_track_t>
 void Acts::Vertex<input_track_t>::setCovariance(
     const ActsSymMatrixD<3>& covariance) {
+  m_covariance.setZero();
   m_covariance.block<3, 3>(0, 0) = covariance;
 }
 
@@ -111,7 +113,7 @@ void Acts::Vertex<input_track_t>::setFullCovariance(
 template <typename input_track_t>
 void Acts::Vertex<input_track_t>::setTracksAtVertex(
     const std::vector<TrackAtVertex<input_track_t>>& tracks) {
-  m_tracksAtVertex = std::move(tracks);
+  m_tracksAtVertex = tracks;
 }
 
 template <typename input_track_t>
diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
index a89f326fc..71bbdb19c 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
@@ -182,20 +182,22 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test) {
        iTrack++) {
     // Index of current vertex
     int vtxIdx = (int)(iTrack / nTracksPerVtx);
-    state.vtxInfoMap[&vtxList[vtxIdx]].trackLinks.push_back(&allTracks[iTrack]);
+    state.vtxInfoMap[&(vtxList[vtxIdx])].trackLinks.push_back(
+        &(allTracks[iTrack]));
     state.tracksAtVerticesMap.insert(
-        std::make_pair(std::make_pair(&allTracks[iTrack], &vtxList[vtxIdx]),
+        std::make_pair(std::make_pair(&(allTracks[iTrack]), &(vtxList[vtxIdx])),
                        TrackAtVertex<BoundParameters>(1., allTracks[iTrack],
-                                                      &allTracks[iTrack])));
+                                                      &(allTracks[iTrack]))));
 
     // Use first track also for second vertex to let vtx1 and vtx2
     // share this track
     if (iTrack == 0) {
-      state.vtxInfoMap[&vtxList[1]].trackLinks.push_back(&allTracks[iTrack]);
+      state.vtxInfoMap[&(vtxList.at(1))].trackLinks.push_back(
+          &(allTracks[iTrack]));
       state.tracksAtVerticesMap.insert(
-          std::make_pair(std::make_pair(&allTracks[iTrack], &vtxList[1]),
+          std::make_pair(std::make_pair(&(allTracks[iTrack]), &(vtxList.at(1))),
                          TrackAtVertex<BoundParameters>(1., allTracks[iTrack],
-                                                        &allTracks[iTrack])));
+                                                        &(allTracks[iTrack]))));
     }
   }
 
@@ -229,8 +231,8 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test) {
   // list in order to be able to compare later
   std::vector<Vertex<BoundParameters>> seedListCopy = vtxList;
 
-  auto res1 = fitter.addVtxToFit(state, vtxList[0], linearizer, fitterOptions);
-
+  auto res1 =
+      fitter.addVtxToFit(state, vtxList.at(0), linearizer, fitterOptions);
   if (debugMode) {
     std::cout << "Tracks linked to each vertex AFTER fit: " << std::endl;
     int c = 0;
@@ -259,47 +261,51 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test) {
 
   if (debugMode) {
     std::cout << "Vertex positions after fit of vertex 1 and 2:" << std::endl;
-    std::cout << "Vtx 1, seed position:\n " << seedListCopy[0].fullPosition()
-              << "\nFitted position:\n " << vtxList[0].fullPosition()
+    std::cout << "Vtx 1, seed position:\n " << seedListCopy.at(0).fullPosition()
+              << "\nFitted position:\n " << vtxList.at(0).fullPosition()
               << std::endl;
-    std::cout << "Vtx 2, seed position:\n " << seedListCopy[1].fullPosition()
-              << "\nFitted position:\n " << vtxList[1].fullPosition()
+    std::cout << "Vtx 2, seed position:\n " << seedListCopy.at(1).fullPosition()
+              << "\nFitted position:\n " << vtxList.at(1).fullPosition()
               << std::endl;
-    std::cout << "Vtx 3, seed position:\n " << seedListCopy[2].fullPosition()
-              << "\nFitted position:\n " << vtxList[2].fullPosition()
+    std::cout << "Vtx 3, seed position:\n " << seedListCopy.at(2).fullPosition()
+              << "\nFitted position:\n " << vtxList.at(2).fullPosition()
               << std::endl;
   }
 
   // After fit of first vertex, only first and second vertex seed
   // should have been modified while third vertex should remain untouched
-  BOOST_CHECK_NE(vtxList[0].fullPosition(), seedListCopy[0].fullPosition());
-  BOOST_CHECK_NE(vtxList[1].fullPosition(), seedListCopy[1].fullPosition());
-  BOOST_CHECK_EQUAL(vtxList[2].fullPosition(), seedListCopy[2].fullPosition());
-
-  CHECK_CLOSE_ABS(vtxList[0].fullPosition(), seedListCopy[0].fullPosition(),
-                  1_mm);
-  CHECK_CLOSE_ABS(vtxList[1].fullPosition(), seedListCopy[1].fullPosition(),
-                  1_mm);
-
-  auto res2 = fitter.addVtxToFit(state, vtxList[2], linearizer, fitterOptions);
-
+  BOOST_CHECK_NE(vtxList.at(0).fullPosition(),
+                 seedListCopy.at(0).fullPosition());
+  BOOST_CHECK_NE(vtxList.at(1).fullPosition(),
+                 seedListCopy.at(1).fullPosition());
+  BOOST_CHECK_EQUAL(vtxList.at(2).fullPosition(),
+                    seedListCopy.at(2).fullPosition());
+
+  CHECK_CLOSE_ABS(vtxList.at(0).fullPosition(),
+                  seedListCopy.at(0).fullPosition(), 1_mm);
+  CHECK_CLOSE_ABS(vtxList.at(1).fullPosition(),
+                  seedListCopy.at(1).fullPosition(), 1_mm);
+
+  auto res2 =
+      fitter.addVtxToFit(state, vtxList.at(2), linearizer, fitterOptions);
   BOOST_CHECK(res2.ok());
 
   // Now also the third vertex should have been modified and fitted
-  BOOST_CHECK_NE(vtxList[2].fullPosition(), seedListCopy[2].fullPosition());
-  CHECK_CLOSE_ABS(vtxList[2].fullPosition(), seedListCopy[2].fullPosition(),
-                  1_mm);
+  BOOST_CHECK_NE(vtxList.at(2).fullPosition(),
+                 seedListCopy.at(2).fullPosition());
+  CHECK_CLOSE_ABS(vtxList.at(2).fullPosition(),
+                  seedListCopy.at(2).fullPosition(), 1_mm);
 
   if (debugMode) {
     std::cout << "Vertex positions after fit of vertex 3:" << std::endl;
-    std::cout << "Vtx 1, seed position:\n " << seedListCopy[0].fullPosition()
-              << "\nFitted position:\n " << vtxList[0].fullPosition()
+    std::cout << "Vtx 1, seed position:\n " << seedListCopy.at(0).fullPosition()
+              << "\nFitted position:\n " << vtxList.at(0).fullPosition()
               << std::endl;
-    std::cout << "Vtx 2, seed position:\n " << seedListCopy[1].fullPosition()
-              << "\nFitted position:\n " << vtxList[1].fullPosition()
+    std::cout << "Vtx 2, seed position:\n " << seedListCopy.at(1).fullPosition()
+              << "\nFitted position:\n " << vtxList.at(1).fullPosition()
               << std::endl;
-    std::cout << "Vtx 3, seed position:\n " << seedListCopy[2].fullPosition()
-              << "\nFitted position:\n " << vtxList[2].fullPosition()
+    std::cout << "Vtx 3, seed position:\n " << seedListCopy.at(2).fullPosition()
+              << "\nFitted position:\n " << vtxList.at(2).fullPosition()
               << std::endl;
   }
 }
@@ -482,15 +488,15 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test_athena) {
   // Fit vertices
   fitter.fit(state, vtxList, linearizer, fitterOptions);
 
-  auto vtx1Pos = state.vertexCollection[0]->position();
-  auto vtx1Cov = state.vertexCollection[0]->covariance();
-  // auto vtx1Trks = state.vertexCollection[0]->tracks();
-  auto vtx1FQ = state.vertexCollection[0]->fitQuality();
+  auto vtx1Pos = state.vertexCollection.at(0)->position();
+  auto vtx1Cov = state.vertexCollection.at(0)->covariance();
+  // auto vtx1Trks = state.vertexCollection.at(0)->tracks();
+  auto vtx1FQ = state.vertexCollection.at(0)->fitQuality();
 
-  auto vtx2Pos = state.vertexCollection[1]->position();
-  auto vtx2Cov = state.vertexCollection[1]->covariance();
-  // auto vtx2Trks = state.vertexCollection[1]->tracks();
-  auto vtx2FQ = state.vertexCollection[1]->fitQuality();
+  auto vtx2Pos = state.vertexCollection.at(1)->position();
+  auto vtx2Cov = state.vertexCollection.at(1)->covariance();
+  // auto vtx2Trks = state.vertexCollection.at(1)->tracks();
+  auto vtx2FQ = state.vertexCollection.at(1)->fitQuality();
 
   if (debugMode) {
     // Vertex 1
-- 
GitLab


From cd3d42aa96f2245822f6f4c911375ff3217a37c9 Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Thu, 12 Mar 2020 15:49:47 +0100
Subject: [PATCH 59/60] add two methods to add and remove single vertex from
 fitter state multiMap as opposed to update entire map every single time

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   |  2 ++
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   |  9 +++---
 .../Vertexing/AdaptiveMultiVertexFitter.hpp   | 31 +++++++++----------
 .../AdaptiveMultiVertexFitterTests.cpp        | 15 ++++-----
 4 files changed, 27 insertions(+), 30 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index af2f66cff..6cf61f8dd 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -343,12 +343,14 @@ class AdaptiveMultiVertexFinder {
   /// of reverts to the old state of the vertex fitter before the bad
   /// vertex was added to the fit (if not refitAfterBadVertex).
   ///
+  /// @param vtx The last added vertex which will be removed
   /// @param allVertices Vector containing the unique_ptr to vertices
   /// @param allVerticesPtr Vector containing the actual addresses
   /// @param fitterState The current vertex fitter state
   /// @param oldFitterState The old vertex fitter state
   /// @param vFitterOptions The vertex fitter options
   Result<void> deleteLastVertex(
+      Vertex<InputTrack_t>& vtx,
       std::vector<std::unique_ptr<Vertex<InputTrack_t>>>& allVertices,
       std::vector<Vertex<InputTrack_t>*>& allVerticesPtr,
       FitterState_t& fitterState, FitterState_t& oldFitterState,
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index b89c6509b..94d44719c 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -80,7 +80,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
       break;
     }
     // Update fitter state with all vertices
-    fitterState.updateTrkToVerticesMultiMap(allVerticesPtr);
+    fitterState.addVertexToMultiMap(vtxCandidate);
 
     // Perform the fit
     auto fitResult = m_cfg.vertexFitter.addVtxToFit(
@@ -117,8 +117,8 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::find(
     // Delete vertex from allVertices list again if it's not kept
     if (not keepVertex) {
       auto deleteVertexResult =
-          deleteLastVertex(allVertices, allVerticesPtr, fitterState,
-                           oldFitterState, vFitterOptions);
+          deleteLastVertex(vtxCandidate, allVertices, allVerticesPtr,
+                           fitterState, oldFitterState, vFitterOptions);
       if (not deleteVertexResult.ok()) {
         return deleteVertexResult.error();
       }
@@ -514,6 +514,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::isMergedVertex(
 
 template <typename vfitter_t, typename sfinder_t>
 auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::deleteLastVertex(
+    Vertex<InputTrack_t>& vtx,
     std::vector<std::unique_ptr<Vertex<InputTrack_t>>>& allVertices,
     std::vector<Vertex<InputTrack_t>*>& allVerticesPtr,
     FitterState_t& fitterState, FitterState_t& oldFitterState,
@@ -535,7 +536,7 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::deleteLastVertex(
 
   } else {
     // Update fitter state with removed vertex candidate
-    fitterState.updateTrkToVerticesMultiMap(allVerticesPtr);
+    fitterState.removeVertexFromMultiMap(vtx);
 
     // TODO: clean tracksAtVerticesMap maybe here? i.e. remove all entries
     // with old vertex?
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
index c96566e97..dc7c03bcc 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.hpp
@@ -71,24 +71,21 @@ class AdaptiveMultiVertexFitter {
     /// @brief Default State constructor
     State() = default;
 
-    void updateTrkToVerticesMultiMap(
-        std::vector<Vertex<input_track_t>>& vtxList) {
-      trackToVerticesMultiMap.clear();
-      for (auto& vtx : vtxList) {
-        // Add vertex link for each track
-        for (auto& trk : vtxInfoMap[&vtx].trackLinks) {
-          trackToVerticesMultiMap.emplace(trk, &vtx);
-        }
+    // Adds a vertex to trackToVerticesMultiMap
+    void addVertexToMultiMap(Vertex<InputTrack_t>& vtx) {
+      for (auto trk : vtxInfoMap[&vtx].trackLinks) {
+        trackToVerticesMultiMap.emplace(trk, &vtx);
       }
     }
 
-    void updateTrkToVerticesMultiMap(
-        std::vector<Vertex<input_track_t>*>& vtxList) {
-      trackToVerticesMultiMap.clear();
-      for (auto vtx : vtxList) {
-        // Add vertex link for each track
-        for (auto trk : vtxInfoMap[vtx].trackLinks) {
-          trackToVerticesMultiMap.emplace(trk, vtx);
+    // Removes a vertex from trackToVerticesMultiMap
+    void removeVertexFromMultiMap(Vertex<InputTrack_t>& vtx) {
+      for (auto iter = trackToVerticesMultiMap.begin();
+           iter != trackToVerticesMultiMap.end();) {
+        if (iter->second == &vtx) {
+          iter = trackToVerticesMultiMap.erase(iter);
+        } else {
+          ++iter;
         }
       }
     }
@@ -169,9 +166,9 @@ class AdaptiveMultiVertexFitter {
   ///
   /// @return Result<void> object
   Result<void> fit(
-      State& state, const std::vector<Vertex<input_track_t>*>& verticesToFit,
+      State& state, const std::vector<Vertex<InputTrack_t>*>& verticesToFit,
       const Linearizer_t& linearizer,
-      const VertexFitterOptions<input_track_t>& vFitterOptions) const;
+      const VertexFitterOptions<InputTrack_t>& vFitterOptions) const;
 
   /// @brief Adds new vertex to an existing multi-vertex fit
   /// and fits everything together (by invoking the fit_impl method):
diff --git a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
index 71bbdb19c..dffb8fc63 100644
--- a/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/AdaptiveMultiVertexFitterTests.cpp
@@ -201,20 +201,16 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test) {
     }
   }
 
-  if (debugMode) {
-    std::cout << "Tracks linked to each vertex: " << std::endl;
-    int c = 0;
-    for (auto& vtx : vtxPtrList) {
-      c++;
-      std::cout << c << ". vertex, with ptr: " << vtx << std::endl;
+  for (auto& vtx : vtxPtrList) {
+    state.addVertexToMultiMap(*vtx);
+    if (debugMode) {
+      std::cout << "Vertex, with ptr: " << vtx << std::endl;
       for (auto& trk : state.vtxInfoMap[vtx].trackLinks) {
         std::cout << "\t track ptr: " << trk << std::endl;
       }
     }
   }
 
-  state.updateTrkToVerticesMultiMap(vtxPtrList);
-
   if (debugMode) {
     std::cout << "Checking all vertices linked to a single track: "
               << std::endl;
@@ -483,7 +479,8 @@ BOOST_AUTO_TEST_CASE(adaptive_multi_vertex_fitter_test_athena) {
   state.vtxInfoMap[&vtx1] = std::move(vtxInfo1);
   state.vtxInfoMap[&vtx2] = std::move(vtxInfo2);
 
-  state.updateTrkToVerticesMultiMap(vtxList);
+  state.addVertexToMultiMap(vtx1);
+  state.addVertexToMultiMap(vtx2);
 
   // Fit vertices
   fitter.fit(state, vtxList, linearizer, fitterOptions);
-- 
GitLab


From b0afc6f8b02c988e8dc05bd1fdf4ffeff816f62d Mon Sep 17 00:00:00 2001
From: Bastian Schlag <bastian.schlag@cern.ch>
Date: Thu, 12 Mar 2020 17:19:37 +0100
Subject: [PATCH 60/60] introduce option to use full vertex covariance for IP
 estimation and remove unique_ptr for TrackToVertexIPEstimator return value

---
 .../Vertexing/AdaptiveMultiVertexFinder.hpp   |  6 +++
 .../Vertexing/AdaptiveMultiVertexFinder.ipp   | 17 ++++---
 .../Acts/Vertexing/IterativeVertexFinder.hpp  |  1 -
 .../Vertexing/TrackToVertexIPEstimator.hpp    |  2 +-
 .../Vertexing/TrackToVertexIPEstimator.ipp    | 48 +++++++++----------
 .../Acts/Vertexing/ZScanVertexFinder.ipp      | 10 ++--
 .../TrackToVertexIPEstimatorTests.cpp         |  6 +--
 7 files changed, 45 insertions(+), 45 deletions(-)

diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
index 6cf61f8dd..1ef31dd6a 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.hpp
@@ -149,6 +149,12 @@ class AdaptiveMultiVertexFinder {
     // performance. To be further investigated.
     bool refitAfterBadVertex = true;
 
+    // Use the full available vertex covariance information after
+    // seeding for the IP estimation. In original implementation
+    // this is not (!) done, however, this is probably not correct.
+    // So definitely consider setting this to true.
+    bool useVertexCovForIPEstimation = false;
+
   };  // Config struct
 
   /// @brief Constructor used if InputTrack_t type == BoundParameters
diff --git a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
index 94d44719c..a3dd9dd6a 100644
--- a/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/AdaptiveMultiVertexFinder.ipp
@@ -192,20 +192,21 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::getIPSignificance(
   // After all, the vertex seed does have a non-zero convariance in general and
   // it probably should be used.
   Vertex<InputTrack_t> newVtx = vtx;
-  newVtx.setFullCovariance(SpacePointSymMatrix::Zero());
-
-  double significance = 0.;
+  if (not m_cfg.useVertexCovForIPEstimation) {
+    newVtx.setFullCovariance(SpacePointSymMatrix::Zero());
+  }
 
   auto estRes = m_cfg.ipEstimator.estimate(*track, newVtx);
   if (!estRes.ok()) {
     return estRes.error();
   }
 
-  auto ipas = std::move(*estRes);
+  ImpactParametersAndSigma ipas = *estRes;
 
-  if (ipas->sigmad0 > 0 && ipas->sigmaz0 > 0) {
-    significance = std::sqrt(std::pow(ipas->IPd0 / ipas->sigmad0, 2) +
-                             std::pow(ipas->IPz0 / ipas->sigmaz0, 2));
+  double significance = 0.;
+  if (ipas.sigmad0 > 0 && ipas.sigmaz0 > 0) {
+    significance = std::sqrt(std::pow(ipas.IPd0 / ipas.sigmad0, 2) +
+                             std::pow(ipas.IPz0 / ipas.sigmaz0, 2));
   }
 
   return significance;
@@ -267,8 +268,6 @@ auto Acts::AdaptiveMultiVertexFinder<vfitter_t, sfinder_t>::
       }
     }
     if (nearTrackFound) {
-      // TODO: check athena actualcandidate position here (has not changed?)
-      // TODO: so do I want to change the vtx position here?
       vtx.setFullPosition(SpacePointVector(0., 0., newZ, 0.));
 
       // Update vertex info for current vertex
diff --git a/Core/include/Acts/Vertexing/IterativeVertexFinder.hpp b/Core/include/Acts/Vertexing/IterativeVertexFinder.hpp
index ac3db92ff..9ba61ed22 100644
--- a/Core/include/Acts/Vertexing/IterativeVertexFinder.hpp
+++ b/Core/include/Acts/Vertexing/IterativeVertexFinder.hpp
@@ -16,7 +16,6 @@
 #include "Acts/Vertexing/FullBilloirVertexFitter.hpp"
 #include "Acts/Vertexing/HelicalTrackLinearizer.hpp"
 #include "Acts/Vertexing/ImpactPoint3dEstimator.hpp"
-#include "Acts/Vertexing/TrackToVertexIPEstimator.hpp"
 #include "Acts/Vertexing/Vertex.hpp"
 #include "Acts/Vertexing/VertexFinderOptions.hpp"
 #include "Acts/Vertexing/VertexFitterConcept.hpp"
diff --git a/Core/include/Acts/Vertexing/TrackToVertexIPEstimator.hpp b/Core/include/Acts/Vertexing/TrackToVertexIPEstimator.hpp
index 62be0e8dc..8c34eea4d 100644
--- a/Core/include/Acts/Vertexing/TrackToVertexIPEstimator.hpp
+++ b/Core/include/Acts/Vertexing/TrackToVertexIPEstimator.hpp
@@ -77,7 +77,7 @@ class TrackToVertexIPEstimator {
   ///
   /// @param track Track to estimate IP from
   /// @param vtx Vertex the track belongs to
-  Result<std::unique_ptr<ImpactParametersAndSigma>> estimate(
+  Result<ImpactParametersAndSigma> estimate(
       const BoundParameters& track, const Vertex<input_track_t>& vtx) const;
 
  private:
diff --git a/Core/include/Acts/Vertexing/TrackToVertexIPEstimator.ipp b/Core/include/Acts/Vertexing/TrackToVertexIPEstimator.ipp
index e570e3e24..3d3989b21 100644
--- a/Core/include/Acts/Vertexing/TrackToVertexIPEstimator.ipp
+++ b/Core/include/Acts/Vertexing/TrackToVertexIPEstimator.ipp
@@ -10,8 +10,7 @@
 
 template <typename input_track_t, typename propagator_t,
           typename propagator_options_t>
-Acts::Result<std::unique_ptr<Acts::ImpactParametersAndSigma>>
-Acts::TrackToVertexIPEstimator<
+Acts::Result<Acts::ImpactParametersAndSigma> Acts::TrackToVertexIPEstimator<
     input_track_t, propagator_t,
     propagator_options_t>::estimate(const BoundParameters& track,
                                     const Vertex<input_track_t>& vtx) const {
@@ -19,11 +18,8 @@ Acts::TrackToVertexIPEstimator<
   // towards
   // the vertex position. By this time the vertex should NOT contain this
   // trajectory anymore
-
-  const Vector3D& lp = vtx.position();
-
   const std::shared_ptr<PerigeeSurface> perigeeSurface =
-      Surface::makeShared<PerigeeSurface>(lp);
+      Surface::makeShared<PerigeeSurface>(vtx.position());
 
   // Do the propagation to linPoint
   auto result =
@@ -47,18 +43,18 @@ Acts::TrackToVertexIPEstimator<
 
   ActsVectorD<2> d0JacXY(-std::sin(phi), std::cos(phi));
 
-  std::unique_ptr<ImpactParametersAndSigma> newIPandSigma =
-      std::make_unique<ImpactParametersAndSigma>();
-  newIPandSigma->IPd0 = d0;
+  ImpactParametersAndSigma newIPandSigma;
+
+  newIPandSigma.IPd0 = d0;
   double d0_PVcontrib = d0JacXY.transpose() * (vrtXYCov * d0JacXY);
   if (d0_PVcontrib >= 0) {
-    newIPandSigma->sigmad0 = std::sqrt(
+    newIPandSigma.sigmad0 = std::sqrt(
         d0_PVcontrib + perigeeCov(ParID_t::eLOC_D0, ParID_t::eLOC_D0));
-    newIPandSigma->PVsigmad0 = std::sqrt(d0_PVcontrib);
+    newIPandSigma.PVsigmad0 = std::sqrt(d0_PVcontrib);
   } else {
-    newIPandSigma->sigmad0 =
+    newIPandSigma.sigmad0 =
         std::sqrt(perigeeCov(ParID_t::eLOC_D0, ParID_t::eLOC_D0));
-    newIPandSigma->PVsigmad0 = 0;
+    newIPandSigma.PVsigmad0 = 0;
   }
 
   ActsSymMatrixD<2> covPerigeeZ0Theta;
@@ -72,32 +68,32 @@ Acts::TrackToVertexIPEstimator<
   ActsVectorD<2> z0JacZ0Theta(std::sin(theta), z0 * std::cos(theta));
 
   if (vtxZZCov >= 0) {
-    newIPandSigma->IPz0SinTheta = z0 * std::sin(theta);
-    newIPandSigma->sigmaz0SinTheta = std::sqrt(
+    newIPandSigma.IPz0SinTheta = z0 * std::sin(theta);
+    newIPandSigma.sigmaz0SinTheta = std::sqrt(
         z0JacZ0Theta.transpose() * (covPerigeeZ0Theta * z0JacZ0Theta) +
         std::sin(theta) * vtxZZCov * std::sin(theta));
 
-    newIPandSigma->PVsigmaz0SinTheta =
+    newIPandSigma.PVsigmaz0SinTheta =
         std::sqrt(std::sin(theta) * vtxZZCov * std::sin(theta));
-    newIPandSigma->IPz0 = z0;
-    newIPandSigma->sigmaz0 =
+    newIPandSigma.IPz0 = z0;
+    newIPandSigma.sigmaz0 =
         std::sqrt(vtxZZCov + perigeeCov(ParID_t::eLOC_Z0, ParID_t::eLOC_Z0));
-    newIPandSigma->PVsigmaz0 = std::sqrt(vtxZZCov);
+    newIPandSigma.PVsigmaz0 = std::sqrt(vtxZZCov);
   } else {
     ACTS_WARNING(
         "Contribution to z0_err from PV is negative: Error in PV "
         "error matrix! Removing contribution from PV");
-    newIPandSigma->IPz0SinTheta = z0 * std::sin(theta);
+    newIPandSigma.IPz0SinTheta = z0 * std::sin(theta);
     double sigma2z0sinTheta =
         (z0JacZ0Theta.transpose() * (covPerigeeZ0Theta * z0JacZ0Theta));
-    newIPandSigma->sigmaz0SinTheta = std::sqrt(sigma2z0sinTheta);
-    newIPandSigma->PVsigmaz0SinTheta = 0;
+    newIPandSigma.sigmaz0SinTheta = std::sqrt(sigma2z0sinTheta);
+    newIPandSigma.PVsigmaz0SinTheta = 0;
 
-    newIPandSigma->IPz0 = z0;
-    newIPandSigma->sigmaz0 =
+    newIPandSigma.IPz0 = z0;
+    newIPandSigma.sigmaz0 =
         std::sqrt(perigeeCov(ParID_t::eLOC_Z0, ParID_t::eLOC_Z0));
-    newIPandSigma->PVsigmaz0 = 0;
+    newIPandSigma.PVsigmaz0 = 0;
   }
 
-  return std::move(newIPandSigma);
+  return newIPandSigma;
 }
diff --git a/Core/include/Acts/Vertexing/ZScanVertexFinder.ipp b/Core/include/Acts/Vertexing/ZScanVertexFinder.ipp
index 0c950c805..f15579ec2 100644
--- a/Core/include/Acts/Vertexing/ZScanVertexFinder.ipp
+++ b/Core/include/Acts/Vertexing/ZScanVertexFinder.ipp
@@ -27,25 +27,25 @@ auto Acts::ZScanVertexFinder<vfitter_t>::find(
     const BoundParameters& params = m_extractParameters(*iTrk);
 
     std::pair<double, double> z0AndWeight;
-    std::unique_ptr<ImpactParametersAndSigma> ipas = nullptr;
+    ImpactParametersAndSigma ipas;
     if (useConstraint &&
         vFinderOptions.vertexConstraint.covariance()(0, 0) != 0) {
       auto estRes =
           m_cfg.ipEstimator.estimate(params, vFinderOptions.vertexConstraint);
       if (estRes.ok()) {
-        ipas = std::move(*estRes);
+        ipas = *estRes;
       } else {
         return estRes.error();
       }
     }
 
-    if (ipas != nullptr && ipas->sigmad0 > 0) {
+    if (ipas.sigmad0 > 0) {
       // calculate z0
       z0AndWeight.first =
-          ipas->IPz0 + vFinderOptions.vertexConstraint.position().z();
+          ipas.IPz0 + vFinderOptions.vertexConstraint.position().z();
 
       // calculate chi2 of IP
-      double chi2IP = std::pow(ipas->IPd0 / ipas->sigmad0, 2);
+      double chi2IP = std::pow(ipas.IPd0 / ipas.sigmad0, 2);
 
       if (!m_cfg.disableAllWeights) {
         z0AndWeight.second =
diff --git a/Tests/UnitTests/Core/Vertexing/TrackToVertexIPEstimatorTests.cpp b/Tests/UnitTests/Core/Vertexing/TrackToVertexIPEstimatorTests.cpp
index 97bba2f01..9e99cc163 100644
--- a/Tests/UnitTests/Core/Vertexing/TrackToVertexIPEstimatorTests.cpp
+++ b/Tests/UnitTests/Core/Vertexing/TrackToVertexIPEstimatorTests.cpp
@@ -144,10 +144,10 @@ BOOST_AUTO_TEST_CASE(track_to_vertex_ip_estimator_test) {
         BoundParameters(tgContext, std::move(covMat), paramVec, perigeeSurface);
 
     // Check if IP are retrieved
-    std::unique_ptr<ImpactParametersAndSigma> output =
+    ImpactParametersAndSigma output =
         ipEst.estimate(track, myConstraint).value();
-    BOOST_CHECK_NE(output->IPd0, 0.);
-    BOOST_CHECK_NE(output->IPz0, 0.);
+    BOOST_CHECK_NE(output.IPd0, 0.);
+    BOOST_CHECK_NE(output.IPz0, 0.);
   }
 }
 }  // namespace Test
-- 
GitLab