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(¶ms, 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(¶ms, 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(¶ms, 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(¶meters, 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(¶meters, 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 = {¶ms1a, ¶ms1b, ¶ms1c}; + std::vector<const BoundParameters*> vec2 = {¶ms1c, ¶ms1a, ¶ms1b}; 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 = {¶ms1a, ¶ms1b, ¶ms1c}; 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 = {¶ms1a, ¶ms1b, ¶ms1c}; 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, ¶ms); // 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, ¶ms); // 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