diff --git a/CMakeLists.txt b/CMakeLists.txt index 28b27d7b47b6..418656a82b96 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -301,6 +301,8 @@ endmacro() # the same package twice. This avoids having complex if/else trees to sort out # when a particular package is actually needed. +add_definitions(-DALGEBRA_PLUGINS_INCLUDE_ARRAY) + # plugin dependencies if(ACTS_BUILD_PLUGIN_ACTSVG) diff --git a/Core/include/Acts/EventData/MultiTrajectory.hpp b/Core/include/Acts/EventData/MultiTrajectory.hpp index 9a148efeb9d2..6210e2273b42 100644 --- a/Core/include/Acts/EventData/MultiTrajectory.hpp +++ b/Core/include/Acts/EventData/MultiTrajectory.hpp @@ -88,6 +88,12 @@ class TrackStateRange { } } + Iterator operator++(int) { + Iterator tmp(*this); + operator++(); + return tmp; + } + bool operator==(const Iterator& other) const { if (!proxy && !other.proxy) { return true; @@ -107,8 +113,8 @@ class TrackStateRange { TrackStateRange(ProxyType _begin) : m_begin{_begin} {} TrackStateRange() : m_begin{std::nullopt} {} - Iterator begin() { return m_begin; } - Iterator end() { return Iterator{std::nullopt}; } + Iterator begin() const { return m_begin; } + Iterator end() const { return Iterator{std::nullopt}; } private: Iterator m_begin; diff --git a/Examples/Python/python/acts/examples/reconstruction.py b/Examples/Python/python/acts/examples/reconstruction.py index 8aaf70243e30..cb37834a303f 100644 --- a/Examples/Python/python/acts/examples/reconstruction.py +++ b/Examples/Python/python/acts/examples/reconstruction.py @@ -1862,7 +1862,7 @@ def addAmbiguityResolutionMLDBScan( addTrackWriters( s, name="ambiMLDBScan", - trajectories=alg.config.outputTracks, + tracks=alg.config.outputTracks, outputDirRoot=outputDirRoot, outputDirCsv=outputDirCsv, writeStates=writeTrajectories, diff --git a/Plugins/Traccc/CMakeLists.txt b/Plugins/Traccc/CMakeLists.txt new file mode 100644 index 000000000000..e59112d2d032 --- /dev/null +++ b/Plugins/Traccc/CMakeLists.txt @@ -0,0 +1,28 @@ +add_library( + ActsPluginTraccc SHARED + src/Detail/Module.cpp + src/CellConversion.cpp) + +target_include_directories( + ActsPluginTraccc + PUBLIC + $ + $) +target_link_libraries( + ActsPluginTraccc + PUBLIC + ActsCore + traccc::core + traccc::io + vecmem::core + detray::utils + detray::io + ActsPluginCovfie) + +install( + TARGETS ActsPluginTraccc + EXPORT ActsPluginTracccTargets + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}) +install( + DIRECTORY include/Acts + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) diff --git a/Plugins/Traccc/include/Acts/Plugins/Traccc/BarcodeMap.hpp b/Plugins/Traccc/include/Acts/Plugins/Traccc/BarcodeMap.hpp new file mode 100644 index 000000000000..d468da4db827 --- /dev/null +++ b/Plugins/Traccc/include/Acts/Plugins/Traccc/BarcodeMap.hpp @@ -0,0 +1,42 @@ +// This file is part of the Acts project. +// +// Copyright (C) 2023 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 + +// Acts include(s) +#include "Acts/Geometry/GeometryIdentifier.hpp" + +// Detray include(s) +#include "detray/core/detector.hpp" + +// System include(s) +#include +#include +#include +#include +#include +#include + +namespace Acts::TracccPlugin { + +/// @brief Creates a map from Acts geometry ID (value) to detray barcode. +/// @param detector the detray detector. +/// @return A map (key = geometry ID value, value = detray geometry barcode). +template +inline std::map +createBarcodeMap(const detray::detector& detector) { + // Construct a map from Acts surface identifiers to Detray barcodes. + std::map + barcodeMap; + for (const auto& surface : detector.surfaces()) { + barcodeMap[surface.source] = surface.barcode(); + } + return barcodeMap; +} + +} // namespace Acts::TracccPlugin diff --git a/Plugins/Traccc/include/Acts/Plugins/Traccc/CellConversion.hpp b/Plugins/Traccc/include/Acts/Plugins/Traccc/CellConversion.hpp new file mode 100644 index 000000000000..9570f85aeb0b --- /dev/null +++ b/Plugins/Traccc/include/Acts/Plugins/Traccc/CellConversion.hpp @@ -0,0 +1,56 @@ +// This file is part of the Acts project. +// +// Copyright (C) 2023 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 + +// Acts include(s) +#include "Acts/Geometry/GeometryHierarchyMap.hpp" +#include "Acts/Geometry/GeometryIdentifier.hpp" + +// Plugin include(s) +#include "Acts/Plugins/Traccc/BarcodeMap.hpp" +#include "Acts/Plugins/Traccc/Detail/Module.hpp" + +// Detray include(s) +#include "detray/core/detector.hpp" + +// Traccc include(s) +#include "traccc/edm/cell.hpp" +#include "traccc/geometry/geometry.hpp" +#include "traccc/io/digitization_config.hpp" +#include "traccc/io/read_geometry.hpp" +#include "traccc/io/reader_edm.hpp" + +// System include(s) +#include +#include +#include +#include +#include +#include + +namespace Acts::TracccPlugin { + +/// @brief Converts a "geometry ID -> traccc cells" map to traccc cells and modules. +/// @param mr The memory resource to use. +/// @param cellsMap A map from Acts geometry ID value to traccc cells. +/// @param geom The traccc geometry. +/// @param dconfig The traccc digitization configuration. +/// @param barcode_map A map from Acts geometry ID value to detray barcode. +/// @return A tuple containing the traccc cells (first item) and traccc modules (second item). +std::tuple +createCellsAndModules( + vecmem::memory_resource* mr, + std::map> + cellsMap, + const traccc::geometry* geom, const traccc::digitization_config* dconfig, + const std::map* + barcodeMap); + +} // namespace Acts::TracccPlugin diff --git a/Plugins/Traccc/include/Acts/Plugins/Traccc/Detail/AlgebraConversion.hpp b/Plugins/Traccc/include/Acts/Plugins/Traccc/Detail/AlgebraConversion.hpp new file mode 100644 index 000000000000..82f39080f166 --- /dev/null +++ b/Plugins/Traccc/include/Acts/Plugins/Traccc/Detail/AlgebraConversion.hpp @@ -0,0 +1,40 @@ +// This file is part of the Acts project. +// +// Copyright (C) 2023 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 + +// Acts include(s) +#include "Acts/Definitions/Algebra.hpp" + +// System include(s) +#include + +namespace Acts::TracccPlugin::detail { + +/// @brief Creates a new Acts vector from another vector type. +template +inline Acts::ActsVector toActsVector(const dvector_t& dvec) { + Acts::ActsVector res; + for (std::size_t i = 0; i < N; i++) { + res(i) = static_cast(dvec[i]); + } + return res; +} +/// @brief Creates a new Acts square matrix from another square matrix type. +template +inline Acts::ActsSquareMatrix toActsSquareMatrix(const matrixNxN_t& mat) { + Acts::ActsSquareMatrix res; + for (std::size_t x = 0; x < N; x++) { + for (std::size_t y = 0; y < N; y++) { + res(x, y) = static_cast(mat[x][y]); + } + } + return res; +} + +} // namespace Acts::TracccPlugin::detail diff --git a/Plugins/Traccc/include/Acts/Plugins/Traccc/Detail/Module.hpp b/Plugins/Traccc/include/Acts/Plugins/Traccc/Detail/Module.hpp new file mode 100644 index 000000000000..58d06333fcec --- /dev/null +++ b/Plugins/Traccc/include/Acts/Plugins/Traccc/Detail/Module.hpp @@ -0,0 +1,29 @@ +// This file is part of the Acts project. +// +// Copyright (C) 2023 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 + +// Acts include(s) +#include "Acts/Geometry/GeometryIdentifier.hpp" + +// Traccc include(s) +#include "traccc/edm/cell.hpp" +#include "traccc/geometry/geometry.hpp" +#include "traccc/io/digitization_config.hpp" + +namespace Acts::TracccPlugin::detail { + +/// @brief Helper function which finds module from csv::cell in the geometry and +/// digitization config, and initializes the modules limits with the cell's +/// properties. +traccc::cell_module getModule( + const Acts::GeometryIdentifier::Value geometryID, + const traccc::geometry* geom, const traccc::digitization_config* dconfig, + const Acts::GeometryIdentifier::Value originalGeometryID); + +} // namespace Acts::TracccPlugin::detail diff --git a/Plugins/Traccc/include/Acts/Plugins/Traccc/TrackConversion.hpp b/Plugins/Traccc/include/Acts/Plugins/Traccc/TrackConversion.hpp new file mode 100644 index 000000000000..da46de10b58e --- /dev/null +++ b/Plugins/Traccc/include/Acts/Plugins/Traccc/TrackConversion.hpp @@ -0,0 +1,238 @@ +// This file is part of the Acts project. +// +// Copyright (C) 2023 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 + +// Plugin include(s) +#include "Acts/Plugins/Traccc/Detail/AlgebraConversion.hpp" + +// Acts include(s) +#include "Acts/Definitions/Algebra.hpp" +#include "Acts/Definitions/TrackParametrization.hpp" +#include "Acts/EventData/ParticleHypothesis.hpp" +#include "Acts/EventData/SourceLink.hpp" +#include "Acts/EventData/TrackContainer.hpp" +#include "Acts/EventData/TrackParameters.hpp" +#include "Acts/EventData/TrackProxy.hpp" +#include "Acts/EventData/detail/ParameterTraits.hpp" +#include "Acts/Geometry/TrackingGeometry.hpp" +#include "Acts/Utilities/detail/Subspace.hpp" + +// Detray include(s) +#include "detray/core/detector.hpp" +#include "detray/tracks/bound_track_parameters.hpp" + +// Traccc include(s) +#include "traccc/edm/track_state.hpp" + +// Boost include(s) +#include + +// System include(s) +#include +#include +#include + +namespace Acts::TracccPlugin { + +/// @brief Creates a new Acts bound track parameters from detray bound track parameters. +/// @param dparams the detray bound track parameters. +/// @param detector the detray detector. +/// @param trackingGeometry the Acts tracking geometry. +/// @return An Acts BoundTrackParameters with data copied from a detray bound_track_parameters. +template +inline auto newParams(const detray::bound_track_parameters& dparams, + const detray::detector& detector, + const Acts::TrackingGeometry& trackingGeometry) { + constexpr std::size_t kFullSize = + Acts::detail::kParametersSize; + Acts::ActsVector parameterVector = + detail::toActsVector(dparams.vector()[0]); + typename Acts::BoundTrackParameters::CovarianceMatrix cov = + detail::toActsSquareMatrix(dparams.covariance()); + Acts::ParticleHypothesis particleHypothesis = + Acts::ParticleHypothesis::pion(); + + auto geoID = + Acts::GeometryIdentifier(detector.surface(dparams.surface_link()).source); + + auto surface = trackingGeometry.findSurface(geoID); + + if (surface == nullptr) { + throw std::runtime_error( + "Mismatch between Acts geometry and detray detector: Acts tracking " + "geometry does not contain geometry ID " + + std::to_string(geoID.value())); + } + + Acts::BoundTrackParameters params(surface->getSharedPtr(), parameterVector, + std::make_optional(std::move(cov)), + particleHypothesis); + + return params; +} + +/// @brief Copies data from a traccc fitting result to an Acts track proxy. +/// @param source the traccc track fitting result to copy from. +/// @param destination the Acts track proxy to copy to. +/// @param detector the detray detector of the traccc track fitting result. +/// @param trackingGeometry the Acts tracking geometry. +template class holder_t, typename metadata_t, + typename container_t> +inline void copyFittingResult( + const traccc::fitting_result& source, + Acts::TrackProxy& + destination, + const detray::detector& detector, + const Acts::TrackingGeometry& trackingGeometry) { + const auto params = newParams(source.fit_params, detector, trackingGeometry); + destination.parameters() = params.parameters(); + destination.covariance() = params.covariance().value(); + destination.setReferenceSurface(params.referenceSurface().getSharedPtr()); +} + +/// @brief Copies data from a traccc track state to a Acts track state proxy. +/// @param source the traccc track state to copy from. +/// @param destination the Acts track state proxy to copy to. +/// @param detector the detray detector of the traccc track track state. +/// @param trackingGeometry the Acts tracking geometry. +/// @note Sets the uncalibrated source link and calibrated measurement to the traccc measurement. +template +inline void copyTrackState( + const traccc::track_state& source, + Acts::TrackStateProxy& destination, + const detray::detector& detector, + const Acts::TrackingGeometry& trackingGeometry) { + constexpr std::size_t kFullSize = + Acts::detail::kParametersSize; + constexpr std::size_t kSize = 2UL; + + auto geoID = + Acts::GeometryIdentifier(detector.surface(source.surface_link()).source); + auto surface = trackingGeometry.findSurface(geoID)->getSharedPtr(); + destination.setReferenceSurface(surface); + + using Parameters = + typename Acts::TrackStateProxy::Parameters; + using Covariance = + typename Acts::TrackStateProxy::Covariance; + + destination.predicted() = Parameters( + detail::toActsVector(source.predicted().vector()[0]).data()); + destination.predictedCovariance() = Covariance( + detail::toActsSquareMatrix(source.predicted().covariance()) + .data()); + + destination.smoothed() = Parameters( + detail::toActsVector(source.smoothed().vector()[0]).data()); + destination.smoothedCovariance() = Covariance( + detail::toActsSquareMatrix(source.smoothed().covariance()) + .data()); + + destination.filtered() = Parameters( + detail::toActsVector(source.filtered().vector()[0]).data()); + destination.filteredCovariance() = Covariance( + detail::toActsSquareMatrix(source.filtered().covariance()) + .data()); + + destination.jacobian() = Covariance( + detail::toActsSquareMatrix(source.jacobian()).data()); + + destination.chi2() = source.smoothed_chi2(); + + auto typeFlags = destination.typeFlags(); + typeFlags.set(TrackStateFlag::ParameterFlag); + if (surface->surfaceMaterial() != nullptr) { + typeFlags.set(TrackStateFlag::MaterialFlag); + } + if (source.is_hole) { + typeFlags.set(TrackStateFlag::HoleFlag); + } + typeFlags.set(TrackStateFlag::MeasurementFlag); + + const traccc::measurement& measurement = source.get_measurement(); + + destination.setUncalibratedSourceLink(Acts::SourceLink{measurement}); + + destination.allocateCalibrated(kSize); + + destination.template calibrated() = + detail::toActsVector(measurement.local); + + auto cov = Eigen::DiagonalMatrix( + detail::toActsVector(measurement.variance)) + .toDenseMatrix(); + destination.template calibratedCovariance() = cov; + + Acts::detail::FixedSizeSubspace subspace( + measurement.subs.get_indices()); + destination.setProjector(subspace.template projector()); +} + +/// @brief Creates a new track in the Acts track container. +/// This new track will contain data copied from the traccc track container +/// element (track and track state data). +/// @param tracccTrack The traccc container element to copy from. +/// @param trackContainer The Acts track container. The new tracks will be added to this container. +/// @param detector The detray detector. +/// @param trackingGeometry The Acts tracking geometry. +/// @note Sets the uncalibrated source link and calibrated measurement to the traccc measurement. +template class holder_t, typename metadata_t, + typename container_t> +inline auto makeTrack( + const traccc::container_element& + tracccTrack, + Acts::TrackContainer& + trackContainer, + const detray::detector& detector, + const Acts::TrackingGeometry& trackingGeometry) { + auto fittingResult = tracccTrack.header; + auto trackStates = tracccTrack.items; + + auto track = trackContainer.makeTrack(); + copyFittingResult(fittingResult, track, detector, trackingGeometry); + + // Make the track states. + for (const auto& tstate : trackStates) { + auto state = track.appendTrackState(); + copyTrackState(tstate, state, detector, trackingGeometry); + } + + track.linkForward(); + + return track; +} + +/// @brief Creates a new track in the Acts track container for each track in the traccc track container. +/// The new tracks will contain data copied from the traccc track container +/// element (track and track state data). +/// @param tracccTrackContainer The traccc container containing the traccc tracks. +/// @param trackContainer The Acts track container. The new tracks will be added to this container. +/// @param detector The detray detector. +/// @param trackingGeometry The Acts tracking geometry. +/// @note Sets the uncalibrated source link and calibrated measurement to the traccc measurement. +template class holder_t, + typename metadata_t, typename container_t> +inline void makeTracks( + const traccc_track_container_t& tracccTrackContainer, + Acts::TrackContainer& + trackContainer, + const detray::detector& detector, + const Acts::TrackingGeometry& trackingGeometry) { + for (std::size_t i = 0; i < tracccTrackContainer.size(); i++) { + makeTrack(tracccTrackContainer[i], trackContainer, detector, + trackingGeometry); + } +} + +} // namespace Acts::TracccPlugin diff --git a/Plugins/Traccc/src/CellConversion.cpp b/Plugins/Traccc/src/CellConversion.cpp new file mode 100644 index 000000000000..8a5baaa6c5be --- /dev/null +++ b/Plugins/Traccc/src/CellConversion.cpp @@ -0,0 +1,94 @@ +// This file is part of the Acts project. +// +// Copyright (C) 2023 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/. + +// Acts include(s) +#include "Acts/Geometry/GeometryHierarchyMap.hpp" +#include "Acts/Geometry/GeometryIdentifier.hpp" + +// Plugin include(s) +#include "Acts/Plugins/Traccc/BarcodeMap.hpp" +#include "Acts/Plugins/Traccc/Detail/Module.hpp" + +// Detray include(s) +#include "detray/core/detector.hpp" + +// Traccc include(s) +#include "traccc/edm/cell.hpp" +#include "traccc/geometry/geometry.hpp" +#include "traccc/io/digitization_config.hpp" +#include "traccc/io/read_geometry.hpp" +#include "traccc/io/reader_edm.hpp" + +// VecMem include(s) +#include "vecmem/memory/memory_resource.hpp" + +// System include(s) +#include +#include +#include +#include +#include +#include + +namespace { + +/// Comparator used for sorting cells. This sorting is one of the assumptions +/// made in the clusterization algorithm +struct CellOrder { + bool operator()(const traccc::cell& lhs, const traccc::cell& rhs) const { + if (lhs.module_link != rhs.module_link) { + return lhs.module_link < rhs.module_link; + } else if (lhs.channel1 != rhs.channel1) { + return (lhs.channel1 < rhs.channel1); + } else { + return (lhs.channel0 < rhs.channel0); + } + } +}; // struct CellOrder + +} // namespace + +namespace Acts::TracccPlugin { + +std::tuple +createCellsAndModules( + vecmem::memory_resource* mr, + std::map> + cellsMap, + const traccc::geometry* geom, const traccc::digitization_config* dconfig, + const std::map* + barcodeMap) { + traccc::io::cell_reader_output out(mr); + + // Sort the cells. + for (auto& [_, cells] : cellsMap) { + std::sort(cells.begin(), cells.end(), CellOrder()); + } + + // Fill the output containers with the ordered cells and modules. + for (const auto& [originalGeometryID, cells] : cellsMap) { + // Modify the geometry ID of the module if a barcode map is + // provided. + Acts::GeometryIdentifier::Value geometryID = + (barcodeMap != nullptr) ? barcodeMap->at(originalGeometryID).value() + : originalGeometryID; + + // Add the module and its cells to the output. + out.modules.push_back( + detail::getModule(geometryID, geom, dconfig, originalGeometryID)); + for (auto& cell : cells) { + out.cells.push_back(cell); + // Set the module link. + out.cells.back().module_link = out.modules.size() - 1; + } + } + return std::make_tuple(std::move(out.cells), std::move(out.modules)); +} + +} // namespace Acts::TracccPlugin diff --git a/Plugins/Traccc/src/Detail/Module.cpp b/Plugins/Traccc/src/Detail/Module.cpp new file mode 100644 index 000000000000..08d9e3c3395d --- /dev/null +++ b/Plugins/Traccc/src/Detail/Module.cpp @@ -0,0 +1,82 @@ +// This file is part of the Acts project. +// +// Copyright (C) 2023 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/. + +// Plugin include(s) +#include "Acts/Plugins/Traccc/Detail/Module.hpp" + +// Acts include(s) +#include "Acts/Geometry/GeometryHierarchyMap.hpp" +#include "Acts/Geometry/GeometryIdentifier.hpp" + +// Detray include(s) +#include "detray/core/detector.hpp" + +// Traccc include(s) +#include "traccc/edm/cell.hpp" +#include "traccc/geometry/geometry.hpp" +#include "traccc/io/digitization_config.hpp" +#include "traccc/io/read_geometry.hpp" +#include "traccc/io/reader_edm.hpp" + +// System include(s) +#include +#include +#include +#include +#include +#include + +namespace Acts::TracccPlugin::detail { + +traccc::cell_module getModule( + const Acts::GeometryIdentifier::Value geometryID, + const traccc::geometry* geom, const traccc::digitization_config* dconfig, + const Acts::GeometryIdentifier::Value originalGeometryID) { + traccc::cell_module result; + result.surface_link = detray::geometry::barcode{geometryID}; + + // Find/set the 3D position of the detector module. + if (geom != nullptr) { + // Check if the module ID is known. + if (!geom->contains(result.surface_link.value())) { + throw std::runtime_error("Could not find placement for geometry ID " + + std::to_string(result.surface_link.value())); + } + + // Set the value on the module description. + result.placement = (*geom)[result.surface_link.value()]; + } + + // Find/set the digitization configuration of the detector module. + if (dconfig != nullptr) { + // Check if the module ID is known. + const traccc::digitization_config::Iterator geoIt = + dconfig->find(originalGeometryID); + if (geoIt == dconfig->end()) { + throw std::runtime_error( + "Could not find digitization config for geometry ID " + + std::to_string(originalGeometryID)); + } + + // Set the value on the module description. + const auto& binning_data = geoIt->segmentation.binningData(); + assert(binning_data.size() > 0); + result.pixel.min_corner_x = binning_data[0].min; + result.pixel.pitch_x = binning_data[0].step; + if (binning_data.size() > 1) { + result.pixel.min_corner_y = binning_data[1].min; + result.pixel.pitch_y = binning_data[1].step; + } + // result.pixel.dimension = geoIt->dimensions; + // result.pixel.variance_y = geoIt->variance_y; + } + + return result; +} + +} // namespace Acts::TracccPlugin::detail diff --git a/thirdparty/traccc/CMakeLists.txt b/thirdparty/traccc/CMakeLists.txt index 73597b29f36f..d187dc94d64e 100644 --- a/thirdparty/traccc/CMakeLists.txt +++ b/thirdparty/traccc/CMakeLists.txt @@ -11,7 +11,7 @@ cmake_minimum_required(VERSION 3.14) include(FetchContent) # Tell the user what's happening. -message( STATUS "Building tracc as part of the Acts project" ) +message( STATUS "Building traccc as part of the Acts project" ) set( TRACCC_VERSION "${_acts_traccc_version}")