feat: Acts v44.0.0

calibrations/tpc/TpcDVCalib/Makefile.am

@@ -24,10 +24,6 @@ libTpcDVCalib_la_LDFLAGS = \
   -L$(OFFLINE_MAIN)/lib
 
 libTpcDVCalib_la_LIBADD = \
-  -lActsCore \
-  -lActsPluginTGeo \
-  -lActsExamplesDetectorTGeo \
-  -lActsExamplesFramework \
   -lSubsysReco \
   -ltrackbase_historic_io \
   -ltrack_io \

calibrations/tpc/TpcDVCalib/TrackToCalo.cc

@@ -38,14 +38,7 @@
 #include <trackbase_historic/TrackSeedContainer.h>
 #include <trackbase_historic/TrackSeed.h>
 #include <trackbase_historic/TrackAnalysisUtils.h>
-#include <trackreco/ActsPropagator.h>
-
-#include <Acts/Geometry/GeometryIdentifier.hpp>
-#include <Acts/MagneticField/ConstantBField.hpp>
-#include <Acts/MagneticField/MagneticFieldProvider.hpp>
-#include <Acts/Surfaces/CylinderSurface.hpp>
-#include <Acts/Surfaces/PerigeeSurface.hpp>
-#include <Acts/Geometry/TrackingGeometry.hpp>
+
 
 #include <CLHEP/Vector/ThreeVector.h>
 #include <cmath>

offline/packages/TrackerMillepedeAlignment/MakeMilleFiles.cc

@@ -309,9 +309,9 @@ bool MakeMilleFiles::getLocalVtxDerivativesXY(SvtxTrack* track,
   auto param = propagator.makeTrackParams(firststate, track->get_charge(), surf).value();
   auto perigee = propagator.makeVertexSurface(vertex);
   auto actspropagator = propagator.makePropagator();
-
-  Acts::PropagatorOptions<> options(_tGeometry->geometry().getGeoContext(),
-                                    _tGeometry->geometry().magFieldContext);
+  ActsPropagator::SphenixPropagatorOptions 
+  options(_tGeometry->geometry().getGeoContext(),
+          _tGeometry->geometry().magFieldContext);
 
   auto result = actspropagator.propagate(param, *perigee, options);
 

offline/packages/TrackerMillepedeAlignment/MakeMilleFiles.h

@@ -23,6 +23,7 @@
 
 #include <ActsExamples/EventData/Trajectories.hpp>
 
+#include <fstream>
 #include <string>
 #include <vector>
 

offline/packages/trackbase/ActsGsfTrackFittingAlgorithm.h

@@ -62,7 +62,7 @@ namespace
         MixtureReductionAlgorithm::KLDistance;
     Acts::ComponentMergeMethod mergeMethod =
         Acts::ComponentMergeMethod::eMaxWeight;
-
+    double reverseFilteringCovarianceScaling = 100.;
     ActsSourceLink::SurfaceAccessor m_slSurfaceAccessor;
 
     GsfFitterFunctionImpl(Fitter&& f,
@@ -83,17 +83,18 @@ namespace
       extensions.updater.connect<&Acts::GainMatrixUpdater::operator()<Acts::VectorMultiTrajectory>>(&updater);
 
       Acts::GsfOptions<Acts::VectorMultiTrajectory> gsfOptions{
-          options.geoContext,
-          options.magFieldContext,
-          options.calibrationContext,
-          extensions,
-          options.propOptions,
-          &(*options.referenceSurface),
-          maxComponents,
-          weightCutoff,
-          abortOnError,
-          disableAllMaterialHandling};
+          options.geoContext, options.magFieldContext,
+          options.calibrationContext};
+      gsfOptions.extensions = extensions;
+      gsfOptions.propagatorPlainOptions = options.propOptions;
+      gsfOptions.referenceSurface = options.referenceSurface;
+      gsfOptions.maxComponents = maxComponents;
+      gsfOptions.weightCutoff = weightCutoff;
+      gsfOptions.abortOnError = abortOnError;
+      gsfOptions.disableAllMaterialHandling = disableAllMaterialHandling;
       gsfOptions.componentMergeMethod = mergeMethod;
+      gsfOptions.reverseFilteringCovarianceScaling =
+          reverseFilteringCovarianceScaling;
       gsfOptions.extensions.calibrator.connect<&calibrator_t::calibrate>(
           &calibrator);
       gsfOptions.extensions.surfaceAccessor.connect<&ActsSourceLink::SurfaceAccessor::operator()>(&m_slSurfaceAccessor);
@@ -152,5 +153,6 @@ class ActsGsfTrackFittingAlgorithm
       BetheHeitlerApprox betheHeitlerApprox, std::size_t maxComponents,
       double weightCutoff,
       MixtureReductionAlgorithm finalReductionMethod, bool abortOnError,
-      bool disableAllMaterialHandling, const Acts::Logger& logger = *Acts::getDefaultLogger("GSF", Acts::Logging::FATAL));
+      bool disableAllMaterialHandling, double reverseFilteringCovarianceScaling,
+      const Acts::Logger& logger = *Acts::getDefaultLogger("GSF", Acts::Logging::FATAL));
 };

offline/packages/trackbase/ActsTrackFittingAlgorithm.h

@@ -11,7 +11,7 @@
 #include <Acts/EventData/TrackParameters.hpp>
 #include <Acts/EventData/VectorTrackContainer.hpp>
 #include <Acts/Geometry/TrackingGeometry.hpp>
-
+#include <ActsExamples/EventData/Measurement.hpp>
 #pragma GCC diagnostic push // needed for local Act compilation
 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
 #include <Acts/Propagator/MultiEigenStepperLoop.hpp>
@@ -32,8 +32,7 @@ class ActsTrackFittingAlgorithm final
 {
  public:
   using TrackParameters = ::Acts::BoundTrackParameters;
-  using Measurement = ::Acts::BoundVariantMeasurement;
-  using MeasurementContainer = std::vector<Measurement>;
+  using MeasurementContainer = ActsExamples::MeasurementContainer;
 
   using TrackContainer =
       Acts::TrackContainer<Acts::VectorTrackContainer,

offline/packages/trackbase/AlignmentTransformation.cc

@@ -372,7 +372,7 @@ Acts::Transform3 AlignmentTransformation::newMakeTransform(const Surface& surf,
 
   // get the acts transform components
   // Note that Acts transforms local coordinates of (x,z,y) to global (x,y,z)
-  Acts::Transform3 actsTransform = surf->transform(m_tGeometry->geometry().getGeoContext());
+  auto actsTransform = surf->transform(m_tGeometry->geometry().getGeoContext());
   Eigen::Matrix3d actsRotationPart = actsTransform.rotation();
   Eigen::Vector3d actsTranslationPart = actsTransform.translation();
 

offline/packages/trackbase/Calibrator.cc

@@ -6,43 +6,34 @@ void Calibrator::calibrate(const Calibrator::MeasurementContainer& measurements,
                            const Acts::SourceLink& sourceLink,
                            Acts::VectorMultiTrajectory::TrackStateProxy& trackState) const
 {
-  trackState.setUncalibratedSourceLink(sourceLink);
+  trackState.setUncalibratedSourceLink(Acts::SourceLink{sourceLink});
   const ActsSourceLink sl = sourceLink.get<ActsSourceLink>();
-  const ActsSourceLink::Index index = sl.index();
-  std::visit(
-      [&](const auto& uncalibmeas)
+  const ActsExamples::ConstVariableBoundMeasurementProxy measurement =
+      measurements.getMeasurement(sl.index());
+
+  Acts::visit_measurement(measurement.size(), [&](auto N) -> void
+                          {
+    constexpr std::size_t kMeasurementSize = decltype(N)::value;
+    const ActsExamples::ConstFixedBoundMeasurementProxy<kMeasurementSize> fixedMeasurement =
+        static_cast<ActsExamples::ConstFixedBoundMeasurementProxy<kMeasurementSize>>(
+            measurement);
+    const auto cov = fixedMeasurement.covariance();
+    const TrkrDefs::cluskey cluskey = sl.cluskey();
+    const uint8_t layer = TrkrDefs::getLayer(cluskey);
+    const double misalignmentFactor = gctx.get<alignmentTransformationContainer*>()->getMisalignmentFactor(layer);
+
+    Acts::ActsSquareMatrix<kMeasurementSize> expandedCov = Acts::ActsSquareMatrix<kMeasurementSize>::Zero();
+
+    for (int i = 0; i < cov.rows(); i++)
+    {
+      for (int j = 0; j < cov.cols(); j++)
       {
-        std::array<Acts::BoundIndices, 2> indices{};
-        indices[0] = Acts::BoundIndices::eBoundLoc0;
-        indices[1] = Acts::BoundIndices::eBoundLoc1;
-
-        Acts::ActsVector<2> loc;
-        loc(0) = uncalibmeas.parameters()[Acts::eBoundLoc0];
-        loc(1) = uncalibmeas.parameters()[Acts::eBoundLoc1];
-
-        auto cov = uncalibmeas.covariance();
-        const TrkrDefs::cluskey cluskey = sl.cluskey();
-        const uint8_t layer = TrkrDefs::getLayer(cluskey);
-        const double misalignmentFactor = gctx.get<alignmentTransformationContainer*>()->getMisalignmentFactor(layer);
-
-        Acts::ActsSquareMatrix<2> expandedCov = Acts::ActsSquareMatrix<2>::Zero();
-
-        for (int i = 0; i < cov.rows(); i++)
-        {
-          for (int j = 0; j < cov.cols(); j++)
-          {
-            expandedCov(i, j) = cov(i, j) * misalignmentFactor;
-          }
-        }
-
-        Acts::Measurement<Acts::BoundIndices, 2> meas(sourceLink,
-                                                      indices,
-                                                      loc, expandedCov);
-
-        trackState.allocateCalibrated(meas.size());
-        trackState.setCalibrated(meas);
-      },
-      (measurements)[index]);
+        expandedCov(i, j) = cov(i, j) * misalignmentFactor;
+      }
+    }
+    trackState.allocateCalibrated(fixedMeasurement.parameters().eval(),
+                                  expandedCov.eval());
+    trackState.setProjectorSubspaceIndices(fixedMeasurement.subspaceIndices()); });
 }
 
 void CalibratorAdapter::calibrate(

offline/packages/trackbase/Calibrator.h

@@ -6,21 +6,15 @@
 #include "TrkrDefs.h"
 #include "alignmentTransformationContainer.h"
 
-#include <Acts/EventData/Measurement.hpp>
+#include <ActsExamples/EventData/Measurement.hpp>
 #include <Acts/EventData/MultiTrajectory.hpp>
 #include <Acts/EventData/VectorMultiTrajectory.hpp>
 
 
 class Calibrator
 {
  public:
-  using Measurement = ::Acts::BoundVariantMeasurement;
-  /// Container of measurements.
-  ///
-  /// In contrast to the source links, the measurements themself must not be
-  /// orderable. The source links stored in the measurements are treated
-  /// as opaque here and no ordering is enforced on the stored measurements.
-  using MeasurementContainer = std::vector<Measurement>;
+  using MeasurementContainer = ActsExamples::MeasurementContainer;
 
   void calibrate(const MeasurementContainer& measurements,
                  const Acts::GeometryContext& gctx,

offline/packages/trackbase/IBaseDetector.h

@@ -8,12 +8,20 @@
 
 #pragma once
 
-#include "ActsExamples/Utilities/OptionsFwd.hpp"
-
 #include <memory>
 #include <utility>
 #include <vector>
-
+namespace boost::program_options
+{
+  class options_description;
+  class variables_map;
+}  // namespace boost::program_options
+
+namespace ActsExamples::Options
+{
+  using Description = ::boost::program_options::options_description;
+  using Variables = ::boost::program_options::variables_map;
+}  // namespace ActsExamples::Options
 namespace Acts {
 class TrackingGeometry;
 class IMaterialDecorator;
@@ -34,8 +42,5 @@ class IBaseDetector {
   virtual void addOptions(
       boost::program_options::options_description& opt) const = 0;
 
-  virtual std::pair<TrackingGeometryPtr, ContextDecorators> finalize(
-      const boost::program_options::variables_map& vm,
-      std::shared_ptr<const Acts::IMaterialDecorator> mdecorator) = 0;
 };
 }  // namespace ActsExamples

offline/packages/trackbase/MagneticFieldOptions.cc

@@ -7,8 +7,8 @@
 #include <Acts/MagneticField/MagneticFieldProvider.hpp>
 #include <Acts/MagneticField/SolenoidBField.hpp>
 #include <Acts/Utilities/Logger.hpp>
-#include <ActsExamples/MagneticField/FieldMapRootIo.hpp>
-#include <ActsExamples/MagneticField/FieldMapTextIo.hpp>
+#include <Acts/MagneticField/TextMagneticFieldIo.hpp>
+#include <ActsPlugins/Root/RootMagneticFieldIo.hpp>
 #include <ActsExamples/MagneticField/ScalableBFieldService.hpp>
 #include <ActsExamples/Utilities/Options.hpp>
 
@@ -129,13 +129,13 @@ ActsExamples::Options::readMagneticField(const Variables& vars) {
       };
 
       if (readRoot) {
-        auto map = makeMagneticFieldMapXyzFromRoot(
+        auto map = ActsPlugins::makeMagneticFieldMapXyzFromRoot(
             std::move(mapBins), file.native(), tree, lengthUnit, fieldUnit,
             useOctantOnly);
         return std::make_shared<InterpolatedMagneticField3>(std::move(map));
 
       } else {
-        auto map = makeMagneticFieldMapXyzFromText(std::move(mapBins),
+        auto map = Acts::makeMagneticFieldMapXyzFromText(std::move(mapBins),
                                                    file.native(), lengthUnit,
                                                    fieldUnit, useOctantOnly);
         return std::make_shared<InterpolatedMagneticField3>(std::move(map));
@@ -148,13 +148,13 @@ ActsExamples::Options::readMagneticField(const Variables& vars) {
       };
 
       if (readRoot) {
-        auto map = makeMagneticFieldMapRzFromRoot(
+        auto map = ActsPlugins::makeMagneticFieldMapRzFromRoot(
             std::move(mapBins), file.native(), tree, lengthUnit, fieldUnit,
             useOctantOnly);
         return std::make_shared<InterpolatedMagneticField2>(std::move(map));
 
       } else {
-        auto map = makeMagneticFieldMapRzFromText(std::move(mapBins),
+        auto map = Acts::makeMagneticFieldMapRzFromText(std::move(mapBins),
                                                   file.native(), lengthUnit,
                                                   fieldUnit, useOctantOnly);
         return std::make_shared<InterpolatedMagneticField2>(std::move(map));

offline/packages/trackbase/MagneticFieldOptions.h

@@ -3,7 +3,18 @@
 
 #include <Acts/MagneticField/MagneticFieldProvider.hpp>
 #include <ActsExamples/MagneticField/MagneticField.hpp>
-#include <ActsExamples/Utilities/OptionsFwd.hpp>
+
+namespace boost::program_options
+{
+  class options_description;
+  class variables_map;
+}  // namespace boost::program_options
+
+namespace ActsExamples::Options
+{
+  using Description = ::boost::program_options::options_description;
+  using Variables = ::boost::program_options::variables_map;
+}  // namespace ActsExamples::Options
 
 namespace ActsExamples {
 
@@ -19,4 +30,4 @@ std::shared_ptr<Acts::MagneticFieldProvider> readMagneticField(
 }  // namespace Options
 }  // namespace ActsExamples
 
-#endif  // _MAGNETICFIELDOPTIONS_H
+#endif  // _MAGNETICFIELDOPTIONS_H

offline/packages/trackbase/Makefile.am

@@ -71,8 +71,8 @@ pkginclude_HEADERS = \
   LaserClusterContainerv1.h \
   LaserClusterv1.h \
   LaserClusterv2.h \
-  MagneticFieldOptions.h \
   MaterialWiper.h \
+  MagneticFieldOptions.h \
   MvtxDefs.h \
   MvtxEventInfo.h \
   MvtxEventInfov1.h \
@@ -292,8 +292,7 @@ libtrack_io_la_SOURCES = \
 libtrack_la_LIBADD = \
   libtrack_io.la \
   -lActsCore \
-  -lActsExamplesMagneticField \
-  -lActsPluginTGeo \
+  -lActsPluginRoot \
   -lActsExamplesDetectorTGeo \
   -lffamodules \
   -lboost_program_options