diff --git a/Event/xAOD/xAODTracking/Root/TrackSummary_v1.cxx b/Event/xAOD/xAODTracking/Root/TrackSummary_v1.cxx
index 1cc6ba522ca0192d21acdd04754debdf0afd410e..88234cb35617f5c9f990416041f53e3917fc2e6c 100644
--- a/Event/xAOD/xAODTracking/Root/TrackSummary_v1.cxx
+++ b/Event/xAOD/xAODTracking/Root/TrackSummary_v1.cxx
@@ -31,6 +31,9 @@ DEFINE_API(TrackSummary_v1, unsigned int, tipIndex, setTipIndex)
DEFINE_API(TrackSummary_v1, unsigned int, stemIndex, setStemIndex)
+AUXSTORE_PRIMITIVE_SETTER_AND_GETTER(TrackSummary_v1, unsigned int, surfaceIndex, setSurfaceIndex)
+
+
AUXSTORE_OBJECT_SETTER_AND_GETTER(TrackSummary_v1, uint8_t, particleHypothesis, setParticleHypothesis)
diff --git a/Event/xAOD/xAODTracking/xAODTracking/versions/TrackSummaryAuxContainer_v1.h b/Event/xAOD/xAODTracking/xAODTracking/versions/TrackSummaryAuxContainer_v1.h
index b7f4aa1c1d3dd3610b0e3180640d41dc62b021e6..a5a94c5bcf0a9bbca43d2e842a5b6f76a36e7d99 100644
--- a/Event/xAOD/xAODTracking/xAODTracking/versions/TrackSummaryAuxContainer_v1.h
+++ b/Event/xAOD/xAODTracking/xAODTracking/versions/TrackSummaryAuxContainer_v1.h
@@ -28,6 +28,7 @@ namespace xAOD {
std::vector<unsigned int> nSharedHits;
std::vector<unsigned int> tipIndex;
std::vector<unsigned int> stemIndex;
+ std::vector<unsigned int> surfaceIndex;
std::vector<uint8_t> particleHypothesis;
};
}
diff --git a/Event/xAOD/xAODTracking/xAODTracking/versions/TrackSummary_v1.h b/Event/xAOD/xAODTracking/xAODTracking/versions/TrackSummary_v1.h
index cbf408ce4f508299596d68cbf4a2b08325dcb2c7..ba589f5e028d1ad953729ec82f83ad2c78d30290 100644
--- a/Event/xAOD/xAODTracking/xAODTracking/versions/TrackSummary_v1.h
+++ b/Event/xAOD/xAODTracking/xAODTracking/versions/TrackSummary_v1.h
@@ -200,6 +200,19 @@ namespace xAOD
const unsigned int* stemIndexPtr() const;
unsigned int* stemIndexPtr();
+
+ /**
+ * @brief index of the surfaces in the surfaces collection
+ */
+ unsigned int surfaceIndex() const;
+
+ /**
+ * @brief Set the index in surface container
+ */
+ void setSurfaceIndex(unsigned int);
+
+
+
/**
* particle hypothesis access
*/
diff --git a/Tracking/Acts/ActsConfig/python/ActsTrackFindingConfig.py b/Tracking/Acts/ActsConfig/python/ActsTrackFindingConfig.py
index ea9ba93b15b6aed76cbb7c8948a2d190a094b029..5f82db832f57e124431004dd258ba76b4c072d27 100644
--- a/Tracking/Acts/ActsConfig/python/ActsTrackFindingConfig.py
+++ b/Tracking/Acts/ActsConfig/python/ActsTrackFindingConfig.py
@@ -204,7 +204,11 @@ def ActsMainAmbiguityResolutionAlgCfg(flags,
from ActsConfig.ActsMonitoringConfig import ActsAmbiguityResolutionMonitoringToolCfg
kwargs.setdefault('MonTool', acc.popToolsAndMerge(
ActsAmbiguityResolutionMonitoringToolCfg(flags)))
-
+ if 'TrackingGeometryTool' not in kwargs:
+ from ActsConfig.ActsGeometryConfig import ActsTrackingGeometryToolCfg
+ kwargs.setdefault(
+ "TrackingGeometryTool",
+ acc.popToolsAndMerge(ActsTrackingGeometryToolCfg(flags)))
acc.addEventAlgo(
CompFactory.ActsTrk.AmbiguityResolutionAlg(name, **kwargs))
return acc
@@ -259,6 +263,12 @@ def ActsTrackMergerAlgCfg(flags,
**kwargs) -> ComponentAccumulator:
acc = ComponentAccumulator()
kwargs.setdefault('OutputTrackCollection', 'ActsCombinedTracks')
+ if 'TrackingGeometryTool' not in kwargs:
+ from ActsConfig.ActsGeometryConfig import ActsTrackingGeometryToolCfg
+ kwargs.setdefault(
+ "TrackingGeometryTool",
+ acc.popToolsAndMerge(ActsTrackingGeometryToolCfg(flags)))
+
acc.addEventAlgo(CompFactory.ActsTrk.TrackMergerAlg(name, **kwargs))
return acc
diff --git a/Tracking/Acts/ActsEvent/ActsEvent/MultiTrajectory.h b/Tracking/Acts/ActsEvent/ActsEvent/MultiTrajectory.h
index a2466ef11d8caef26ad9435aa0de8ae94688b91c..2fb4db7ec42d2056c895b906b25baea52b28d869 100644
--- a/Tracking/Acts/ActsEvent/ActsEvent/MultiTrajectory.h
+++ b/Tracking/Acts/ActsEvent/ActsEvent/MultiTrajectory.h
@@ -365,7 +365,6 @@ class MutableMultiTrajectory final
friend ActsTrk::MutableTrackContainerHandlesHelper;
-
private:
std::unique_ptr<xAOD::TrackStateAuxContainer> m_trackStatesAux;
@@ -389,7 +388,8 @@ class MutableMultiTrajectory final
std::vector<StoredSurface> m_surfaces;
ActsGeometryContext m_geoContext;
- // addjust prealocated size to actualy used
+
+ // adjust preallocated size to actually used
void trim();
};
diff --git a/Tracking/Acts/ActsEvent/ActsEvent/TrackContainerHandlesHelper.h b/Tracking/Acts/ActsEvent/ActsEvent/TrackContainerHandlesHelper.h
index b9ddec226e84449f84fe369b0229cb5f3ce115c7..5247ff0d1b2d1e91a735cb723947d5f6ad3d6d73 100644
--- a/Tracking/Acts/ActsEvent/ActsEvent/TrackContainerHandlesHelper.h
+++ b/Tracking/Acts/ActsEvent/ActsEvent/TrackContainerHandlesHelper.h
@@ -43,10 +43,13 @@ class MutableTrackContainerHandlesHelper {
* produces ActsTrk::ConstTrackContainer with all backends stored in SG
* @arg tc - MutableTrackContainer the source (will be disassembled
* after the operation)
- * @arg context - event context (needed for SG operations)
+ * @arg - geoContext - geometry context, needed in surfaces conversion
+ * @arg evtContext - event context (needed for SG operations)
*/
std::unique_ptr<ActsTrk::TrackContainer> moveToConst(
- ActsTrk::MutableTrackContainer&& tc, const EventContext& context) const;
+ ActsTrk::MutableTrackContainer&& tc,
+ const Acts::GeometryContext& geoContext,
+ const EventContext& evtContext) const;
private:
// MTJ part
diff --git a/Tracking/Acts/ActsEvent/ActsEvent/TrackSummaryContainer.h b/Tracking/Acts/ActsEvent/ActsEvent/TrackSummaryContainer.h
index d4fe15e216651a13bb0eb59d9cdd44cc55b593d8..ede1e645d4092dc34ad366f9ab0abcb6266d5f41 100644
--- a/Tracking/Acts/ActsEvent/ActsEvent/TrackSummaryContainer.h
+++ b/Tracking/Acts/ActsEvent/ActsEvent/TrackSummaryContainer.h
@@ -11,7 +11,6 @@
#include "ActsEvent/Decoration.h"
#include "xAODTracking/TrackSummaryContainer.h"
#include "xAODTracking/TrackSummaryAuxContainer.h"
-#include "xAODTracking/TrackSurfaceAuxContainer.h"
#include "xAODTracking/TrackSurfaceContainer.h"
#include "ActsEvent/SurfaceEncoding.h"
@@ -57,8 +56,7 @@ class TrackSummaryContainer {
public:
using IndexType = uint32_t; // TODO find common place for it
static constexpr auto kInvalid = Acts::MultiTrajectoryTraits::kInvalid;
- TrackSummaryContainer(const DataLink<xAOD::TrackSummaryContainer>& lin = nullptr,
- const DataLink<xAOD::TrackSurfaceAuxContainer>& surfLink = nullptr);
+ TrackSummaryContainer(const DataLink<xAOD::TrackSummaryContainer>& lin = nullptr);
static const std::set<std::string> staticVariables;
static const std::set<Acts::HashedString> staticVariableHashes;
/**
@@ -97,11 +95,6 @@ class TrackSummaryContainer {
*/
ActsTrk::ConstCovariance covariance(ActsTrk::IndexType itrack) const;
- /**
- * surface
- */
- std::shared_ptr<const Acts::Surface> surface(ActsTrk::IndexType itrack) const;
-
void fillFrom(ActsTrk::MutableTrackSummaryContainer& mtb);
template<typename T>
@@ -110,20 +103,15 @@ class TrackSummaryContainer {
void restoreDecorations();
- const xAOD::TrackSummaryContainer* trackBackend() const{
- return m_trackBackend.cptr();
- }
+ void decodeSurfaces(const xAOD::TrackSurfaceContainer* src, const Acts::GeometryContext&);
std::vector<Acts::HashedString> dynamicKeys_impl() const;
protected:
DataLink<xAOD::TrackSummaryContainer> m_trackBackend = nullptr;
- DataLink<xAOD::TrackSurfaceAuxContainer> m_surfBackendAux = nullptr;
-
std::vector<ActsTrk::detail::Decoration> m_decorations;
-
- std::vector<std::shared_ptr<const Acts::Surface>> m_surfaces;
+ std::vector<std::shared_ptr<const Acts::Surface>> m_surfaces; // decoded transient form of surfaces
};
class MutableTrackSummaryContainer : public TrackSummaryContainer {
@@ -134,17 +122,6 @@ class MutableTrackSummaryContainer : public TrackSummaryContainer {
MutableTrackSummaryContainer(MutableTrackSummaryContainer&&);
MutableTrackSummaryContainer& operator=(MutableTrackSummaryContainer&& other) noexcept;
-
- /**
- * adds new surface to the tail of the container
- */
- ActsTrk::IndexType addSurface_impl();
-
- /**
- * clears surface data under index
- */
- void removeSurface_impl(ActsTrk::IndexType isurf);
-
/**
* adds new track to the tail of the container
*/
@@ -225,16 +202,11 @@ class MutableTrackSummaryContainer : public TrackSummaryContainer {
return m_mutableTrackBackend.get();
}
- xAOD::TrackSurfaceContainer* surfBackend(){
- return m_mutableSurfBackend.get();
- }
+ void encodeSurfaces(xAOD::TrackSurfaceAuxContainer* dest, const Acts::GeometryContext&) const;
private:
std::unique_ptr<xAOD::TrackSummaryContainer> m_mutableTrackBackend;
std::unique_ptr<xAOD::TrackSummaryAuxContainer> m_mutableTrackBackendAux;
-
- std::unique_ptr<xAOD::TrackSurfaceContainer> m_mutableSurfBackend;
- std::unique_ptr<xAOD::TrackSurfaceAuxContainer> m_mutableSurfBackendAux;
};
diff --git a/Tracking/Acts/ActsEvent/Root/MultiTrajectory.cxx b/Tracking/Acts/ActsEvent/Root/MultiTrajectory.cxx
index eb974ed6882ddcb8e1924cfcd530083709102b2c..34b2c64d6ec8d59247233cbb1a5173ff1a9c967b 100644
--- a/Tracking/Acts/ActsEvent/Root/MultiTrajectory.cxx
+++ b/Tracking/Acts/ActsEvent/Root/MultiTrajectory.cxx
@@ -642,7 +642,6 @@ ActsTrk::MultiTrajectory::getUncalibratedSourceLink_impl(ActsTrk::IndexType ista
void ActsTrk::MultiTrajectory::moveSurfaces(const ActsTrk::MutableMultiTrajectory* mtj) {
m_surfaces = std::move(mtj->m_surfaces);
- INSPECTCALL(this << " " << m_surfaces.size());
}
// TODO remove this implementation once tracking uses only sourceLinks with EL
diff --git a/Tracking/Acts/ActsEvent/Root/TrackContainerHandlesHelper.cxx b/Tracking/Acts/ActsEvent/Root/TrackContainerHandlesHelper.cxx
index 589cbd5072c6e21d5516d47d2a08dd6152f41983..219260b621b81d21e9cf0c121b13cdd325614db6 100644
--- a/Tracking/Acts/ActsEvent/Root/TrackContainerHandlesHelper.cxx
+++ b/Tracking/Acts/ActsEvent/Root/TrackContainerHandlesHelper.cxx
@@ -25,8 +25,8 @@ std::string prefixFromTrackContainerName(const std::string& tracks) {
template <typename T, typename IFACE, typename AUX>
void recordxAOD(const SG::WriteHandleKey<T>& key, IFACE& iface, AUX& aux,
- const EventContext& context) {
- SG::WriteHandle<T> handle = SG::makeHandle(key, context);
+ const EventContext& evtContext) {
+ SG::WriteHandle<T> handle = SG::makeHandle(key, evtContext);
if (handle.record(std::move(iface), std::move(aux)).isFailure()) {
throw std::runtime_error(
std::string("MutableTrackContainerHandlesHelper::recordxAOD, can't record ") + key.key() + " backend");
@@ -74,44 +74,44 @@ StatusCode MutableTrackContainerHandlesHelper::initialize(
std::unique_ptr<ActsTrk::MultiTrajectory>
MutableTrackContainerHandlesHelper::moveToConst(
- ActsTrk::MutableMultiTrajectory&& mmtj, const EventContext& context) const {
+ ActsTrk::MutableMultiTrajectory&& mmtj, const EventContext& evtContext) const {
mmtj.trim();
- auto statesBackendHandle = SG::makeHandle(m_statesKey, context);
+ auto statesBackendHandle = SG::makeHandle(m_statesKey, evtContext);
auto statesInterface =
ActsTrk::makeInterfaceContainer<xAOD::TrackStateContainer>(
mmtj.trackStatesAux());
- recordxAOD(m_statesKey, statesInterface, mmtj.m_trackStatesAux, context);
+ recordxAOD(m_statesKey, statesInterface, mmtj.m_trackStatesAux, evtContext);
auto parametersInterface =
ActsTrk::makeInterfaceContainer<xAOD::TrackParametersContainer>(
mmtj.trackParametersAux());
- recordxAOD(m_parametersKey, parametersInterface, mmtj.m_trackParametersAux, context);
+ recordxAOD(m_parametersKey, parametersInterface, mmtj.m_trackParametersAux, evtContext);
auto jacobiansInterface =
ActsTrk::makeInterfaceContainer<xAOD::TrackJacobianContainer>(
mmtj.trackJacobiansAux());
- recordxAOD(m_jacobiansKey, jacobiansInterface, mmtj.m_trackJacobiansAux, context);
+ recordxAOD(m_jacobiansKey, jacobiansInterface, mmtj.m_trackJacobiansAux, evtContext);
auto measurementsInterface =
ActsTrk::makeInterfaceContainer<xAOD::TrackMeasurementContainer>(
mmtj.trackMeasurementsAux());
- recordxAOD(m_measurementsKey, measurementsInterface, mmtj.m_trackMeasurementsAux, context);
+ recordxAOD(m_measurementsKey, measurementsInterface, mmtj.m_trackMeasurementsAux, evtContext);
- auto surfacesBackendHandle = SG::makeHandle(m_surfacesKey, context);
- recordxAOD(m_surfacesKey, mmtj.m_surfacesBackend, mmtj.m_surfacesBackendAux, context);
+ auto surfacesBackendHandle = SG::makeHandle(m_surfacesKey, evtContext);
+ recordxAOD(m_surfacesKey, mmtj.m_surfacesBackend, mmtj.m_surfacesBackendAux, evtContext);
// construct const MTJ version
auto cmtj = std::make_unique<ActsTrk::MultiTrajectory>(
DataLink<xAOD::TrackStateAuxContainer>(m_statesKey.key() + "Aux.",
- context),
+ evtContext),
DataLink<xAOD::TrackParametersAuxContainer>(
- m_parametersKey.key() + "Aux.", context),
+ m_parametersKey.key() + "Aux.", evtContext),
DataLink<xAOD::TrackJacobianAuxContainer>(m_jacobiansKey.key() + "Aux.",
- context),
+ evtContext),
DataLink<xAOD::TrackMeasurementAuxContainer>(
- m_measurementsKey.key() + "Aux.", context));
+ m_measurementsKey.key() + "Aux.", evtContext));
cmtj->moveSurfaces(&mmtj);
cmtj->moveLinks(&mmtj);
@@ -120,12 +120,13 @@ MutableTrackContainerHandlesHelper::moveToConst(
std::unique_ptr<ActsTrk::TrackContainer>
MutableTrackContainerHandlesHelper::moveToConst(
- ActsTrk::MutableTrackContainer&& tc, const EventContext& context) const {
+ ActsTrk::MutableTrackContainer&& tc, const Acts::GeometryContext& geoContext, const EventContext& evtContext) const {
+
std::unique_ptr<ActsTrk::MultiTrajectory> constMtj =
- moveToConst(std::move(tc.trackStateContainer()), context);
+ moveToConst(std::move(tc.trackStateContainer()), evtContext);
- auto constMtjHandle = SG::makeHandle(m_mtjKey, context);
+ auto constMtjHandle = SG::makeHandle(m_mtjKey, evtContext);
if (constMtjHandle.record(std::move(constMtj)).isFailure()) {
throw std::runtime_error(
"MutableTrackContainerHandlesHelper::moveToConst, can't record "
@@ -135,17 +136,23 @@ MutableTrackContainerHandlesHelper::moveToConst(
auto interfaceTrackSummaryContainer =
ActsTrk::makeInterfaceContainer<xAOD::TrackSummaryContainer>(
tc.container().m_mutableTrackBackendAux.get());
- recordxAOD(m_xAODTrackSummaryKey, interfaceTrackSummaryContainer, tc.container().m_mutableTrackBackendAux, context);
+ recordxAOD(m_xAODTrackSummaryKey, interfaceTrackSummaryContainer, tc.container().m_mutableTrackBackendAux, evtContext);
+
+ auto trackSurfacesAux = std::make_unique<xAOD::TrackSurfaceAuxContainer>();
+ // TODO consider passing in GeoContext to this function
+ tc.container().encodeSurfaces(trackSurfacesAux.get(), geoContext);
- recordxAOD(m_trackSurfacesKey, tc.container().m_mutableSurfBackend, tc.container().m_mutableSurfBackendAux, context);
+ auto trackSurfaces = ActsTrk::makeInterfaceContainer<xAOD::TrackSurfaceContainer>(
+ trackSurfacesAux.get());
+ recordxAOD(m_trackSurfacesKey, trackSurfaces, trackSurfacesAux, evtContext);
auto constTrackSummary = std::make_unique<ActsTrk::TrackSummaryContainer>(
DataLink<xAOD::TrackSummaryContainer>(m_xAODTrackSummaryKey.key(),
- context));
+ evtContext));
constTrackSummary->restoreDecorations();
constTrackSummary->fillFrom(tc.container());
- auto constTrackSummaryHandle = SG::makeHandle(m_trackSummaryKey, context);
+ auto constTrackSummaryHandle = SG::makeHandle(m_trackSummaryKey, evtContext);
if (constTrackSummaryHandle.record(std::move(constTrackSummary))
.isFailure()) {
throw std::runtime_error(
@@ -154,8 +161,8 @@ MutableTrackContainerHandlesHelper::moveToConst(
}
auto constTrack = std::make_unique<ActsTrk::TrackContainer>(
DataLink<ActsTrk::TrackSummaryContainer>(m_trackSummaryKey.key(),
- context),
- DataLink<ActsTrk::MultiTrajectory>(m_mtjKey.key(), context));
+ evtContext),
+ DataLink<ActsTrk::MultiTrajectory>(m_mtjKey.key(), evtContext));
return constTrack;
}
@@ -190,30 +197,30 @@ StatusCode ConstTrackContainerHandlesHelper::initialize(
std::unique_ptr<ActsTrk::MultiTrajectory>
ConstTrackContainerHandlesHelper::buildMtj(const Acts::TrackingGeometry* geo,
const Acts::GeometryContext& geoContext,
- const EventContext& context) const {
+ const EventContext& evtContext) const {
// we need to build it from backends
DataLink<xAOD::TrackStateAuxContainer> statesLink(m_statesKey.key() + "Aux.",
- context);
+ evtContext);
if (not statesLink.isValid()) {
throw std::runtime_error(
"ConstMultiTrajectoryHandle::build, StatesLink is invalid");
}
DataLink<xAOD::TrackParametersAuxContainer> parametersLink(
- m_parametersKey.key() + "Aux.", context);
+ m_parametersKey.key() + "Aux.", evtContext);
if (not parametersLink.isValid()) {
throw std::runtime_error(
"ConstMultiTrajectoryHandle::build, ParametersLink is invalid");
}
DataLink<xAOD::TrackJacobianAuxContainer> jacobiansLink(
- m_jacobiansKey.key() + "Aux.", context);
+ m_jacobiansKey.key() + "Aux.", evtContext);
if (not jacobiansLink.isValid()) {
throw std::runtime_error(
"ConstMultiTrajectoryHandle::build, JacobiansLink is invalid");
}
DataLink<xAOD::TrackMeasurementAuxContainer> measurementsLink(
- m_measurementsKey.key() + "Aux.", context);
+ m_measurementsKey.key() + "Aux.", evtContext);
if (not measurementsLink.isValid()) {
throw std::runtime_error(
"ConstMultiTrajectoryHandle::build, MeasurementsLink is invalid");
@@ -228,42 +235,42 @@ ConstTrackContainerHandlesHelper::buildMtj(const Acts::TrackingGeometry* geo,
std::unique_ptr<ActsTrk::TrackContainer>
ConstTrackContainerHandlesHelper::build(const Acts::TrackingGeometry* geo,
const Acts::GeometryContext& geoContext,
- const EventContext& context) const {
+ const EventContext& evtContext) const {
std::unique_ptr<ActsTrk::MultiTrajectory> mtj =
- buildMtj(geo, geoContext, context);
- auto mtjHandle = SG::makeHandle(m_mtjKey, context);
+ buildMtj(geo, geoContext, evtContext);
+ auto mtjHandle = SG::makeHandle(m_mtjKey, evtContext);
if (mtjHandle.record(std::move(mtj)).isFailure()) {
throw std::runtime_error(
"ConstTrackContainerHandle<C>::build failed recording MTJ");
}
DataLink<xAOD::TrackSummaryContainer> summaryLink(m_xAODTrackSummaryKey.key(),
- context);
+ evtContext);
if (not summaryLink.isValid()) {
throw std::runtime_error(
"ConstTrackContainerHandle::build, SummaryLink is invalid");
}
- DataLink<xAOD::TrackSurfaceAuxContainer> surfacesLink(
- m_trackSurfacesKey.key() + "Aux.", context);
- if (not surfacesLink.isValid()) {
+ auto surfacesHandle = SG::makeHandle(m_trackSurfacesKey, evtContext);
+ if (not surfacesHandle.isValid()) {
throw std::runtime_error(
- "ConstTrackContainerHandle::build, SurfaceLink is invalid");
+ "ConstTrackContainerHandle::build, SurfaceHandle is invalid");
}
- auto constTrackSummary = std::make_unique<ActsTrk::TrackSummaryContainer>(
- summaryLink, surfacesLink);
- auto summaryHandle = SG::makeHandle(m_trackSummaryKey, context);
+ auto constTrackSummary = std::make_unique<ActsTrk::TrackSummaryContainer>(summaryLink);
+ constTrackSummary->decodeSurfaces( surfacesHandle.cptr(), geoContext);
+
+ auto summaryHandle = SG::makeHandle(m_trackSummaryKey, evtContext);
if (summaryHandle.record(std::move(constTrackSummary)).isFailure()) {
throw std::runtime_error(
- "MutableTrackContainerHandle::moveToConst, can't record "
+ "MutableTrackContainerHandle::build, can't record "
"TrackSummary");
}
auto constTrack = std::make_unique<ActsTrk::TrackContainer>(
DataLink<ActsTrk::TrackSummaryContainer>(m_trackSummaryKey.key(),
- context),
- DataLink<ActsTrk::MultiTrajectory>(m_mtjKey.key(), context));
+ evtContext),
+ DataLink<ActsTrk::MultiTrajectory>(m_mtjKey.key(), evtContext));
return constTrack;
diff --git a/Tracking/Acts/ActsEvent/Root/TrackSummaryContainer.cxx b/Tracking/Acts/ActsEvent/Root/TrackSummaryContainer.cxx
index 64cabf8497a40ca5e45dd54d4d980cd295b55c84..52b4365ad15b8e93283153790bcce998849db7c6 100644
--- a/Tracking/Acts/ActsEvent/Root/TrackSummaryContainer.cxx
+++ b/Tracking/Acts/ActsEvent/Root/TrackSummaryContainer.cxx
@@ -5,7 +5,7 @@
#include "xAODTracking/TrackSummary.h"
#include "ActsEvent/ParticleHypothesisEncoding.h"
-// this is list of xAOD container varaible names that are "hardcoded" in TrackSummary_v1
+// this is list of xAOD container variable names that are "hardcoded" in TrackSummary_v1
// their compatibility is maintain ed by the unit tests: AllStaticxAODVaraiblesAreKnown
const std::set<std::string> ActsTrk::TrackSummaryContainer::staticVariables = {
"params", "covParams", "nMeasurements", "nHoles", "chi2f",
@@ -23,9 +23,9 @@ const std::set<Acts::HashedString> ActsTrk::TrackSummaryContainer::staticVariabl
ActsTrk::TrackSummaryContainer::TrackSummaryContainer(
- const DataLink<xAOD::TrackSummaryContainer>& link,
- const DataLink<xAOD::TrackSurfaceAuxContainer>& surfLink)
- : m_trackBackend(link), m_surfBackendAux(surfLink) {}
+ const DataLink<xAOD::TrackSummaryContainer>& link)
+ : m_trackBackend(link)
+ {}
const Acts::Surface* ActsTrk::TrackSummaryContainer::referenceSurface_impl(
ActsTrk::IndexType itrack) const {
@@ -99,19 +99,11 @@ ActsTrk::ConstCovariance ActsTrk::TrackSummaryContainer::covariance(
return m_trackBackend->at(itrack)->covParamsEigen();
}
-std::shared_ptr<const Acts::Surface> ActsTrk::TrackSummaryContainer::surface(
- ActsTrk::IndexType itrack) const {
- const Acts::GeometryContext geoContext{};
- return decodeSurface( m_surfBackendAux.cptr(), itrack, geoContext );
-}
-
void ActsTrk::TrackSummaryContainer::fillFrom(
ActsTrk::MutableTrackSummaryContainer& mtb) {
m_surfaces = std::move(mtb.m_surfaces);
}
-
-
void ActsTrk::TrackSummaryContainer::restoreDecorations() {
m_decorations = ActsTrk::detail::restoreDecorations(m_trackBackend->getConstStore(), staticVariables);
}
@@ -127,6 +119,13 @@ std::vector<Acts::HashedString> ActsTrk::TrackSummaryContainer::dynamicKeys_impl
return result;
}
+void ActsTrk::TrackSummaryContainer::decodeSurfaces(const xAOD::TrackSurfaceContainer* src, const Acts::GeometryContext& geoContext) {
+ for ( auto xAODSurfacePtr: *src) {
+ m_surfaces.push_back( decodeSurface(xAODSurfacePtr, geoContext));
+ }
+}
+
+
////////////////////////////////////////////////////////////////////
@@ -139,11 +138,6 @@ ActsTrk::MutableTrackSummaryContainer::MutableTrackSummaryContainer() {
m_mutableTrackBackend->setStore(m_mutableTrackBackendAux.get());
TrackSummaryContainer::m_trackBackend = m_mutableTrackBackend.get();
- m_mutableSurfBackend = std::make_unique<xAOD::TrackSurfaceContainer>();
- m_mutableSurfBackendAux = std::make_unique<xAOD::TrackSurfaceAuxContainer>();
- m_mutableSurfBackend->setStore(m_mutableSurfBackendAux.get());
-
- TrackSummaryContainer::m_surfBackendAux = m_mutableSurfBackendAux.get();
}
ActsTrk::MutableTrackSummaryContainer::MutableTrackSummaryContainer(
@@ -153,11 +147,6 @@ ActsTrk::MutableTrackSummaryContainer::MutableTrackSummaryContainer(
m_mutableTrackBackend->setStore(m_mutableTrackBackendAux.get());
TrackSummaryContainer::m_trackBackend = m_mutableTrackBackend.get();
- m_mutableSurfBackend = std::move(other.m_mutableSurfBackend);
- m_mutableSurfBackendAux = std::move(other.m_mutableSurfBackendAux);
- m_mutableSurfBackend->setStore(m_mutableSurfBackendAux.get());
- TrackSummaryContainer::m_surfBackendAux = m_mutableSurfBackendAux.get();
-
m_surfaces = std::move(other.m_surfaces);
m_decorations = std::move(other.m_decorations);
}
@@ -171,11 +160,6 @@ ActsTrk::MutableTrackSummaryContainer& ActsTrk::MutableTrackSummaryContainer::op
m_mutableTrackBackend->setStore(m_mutableTrackBackendAux.get());
TrackSummaryContainer::m_trackBackend = m_mutableTrackBackend.get();
- m_mutableSurfBackend = std::exchange(other.m_mutableSurfBackend, nullptr);
- m_mutableSurfBackendAux = std::exchange(other.m_mutableSurfBackendAux, nullptr);
- m_mutableSurfBackend->setStore(m_mutableSurfBackendAux.get());
- TrackSummaryContainer::m_surfBackendAux = m_mutableSurfBackendAux.get();
-
m_surfaces = std::move(other.m_surfaces);
m_decorations = std::move(other.m_decorations);
@@ -205,29 +189,6 @@ void ActsTrk::MutableTrackSummaryContainer::removeTrack_impl(
m_mutableTrackBackend->erase(m_mutableTrackBackend->begin() + itrack);
}
-// Add and remove surface
-ActsTrk::IndexType ActsTrk::MutableTrackSummaryContainer::addSurface_impl() {
- m_mutableSurfBackendAux->resize(m_mutableSurfBackendAux->size()+1);
- return m_mutableSurfBackendAux->size() - 1;
-}
-
-void ActsTrk::MutableTrackSummaryContainer::removeSurface_impl(
- ActsTrk::IndexType isurf) {
- if (isurf >= m_mutableSurfBackendAux->size()) {
- throw std::out_of_range("removeSurface_impl");
- }
- // TODO find a more generic way to do this (possible issue may sneak ins when adding more variables to backend)
- for (auto i = isurf; i < m_mutableSurfBackendAux->size()-1; ++i) {
- m_mutableSurfBackendAux->surfaceType[i] = m_mutableSurfBackendAux->surfaceType[i+1];
- m_mutableSurfBackendAux->translation[i] = m_mutableSurfBackendAux->translation[i+1];
- m_mutableSurfBackendAux->rotation[i] = m_mutableSurfBackendAux->rotation[i+1];
- m_mutableSurfBackendAux->boundValues[i] = m_mutableSurfBackendAux->boundValues[i+1];
- }
- m_mutableSurfBackendAux->resize(m_mutableSurfBackendAux->size()-1);
-}
-
-
-
// this in fact may be a copy from other MutableTrackSymmaryContainer
void ActsTrk::MutableTrackSummaryContainer::copyDynamicFrom_impl(
ActsTrk::IndexType itrack, Acts::HashedString key,
@@ -290,7 +251,16 @@ void ActsTrk::MutableTrackSummaryContainer::clear() {
void ActsTrk::MutableTrackSummaryContainer::setReferenceSurface_impl(
ActsTrk::IndexType itrack, std::shared_ptr<const Acts::Surface> surface) {
m_surfaces.resize(itrack + 1, nullptr);
- m_surfaces[itrack] = std::move(surface);
+ m_surfaces[itrack] = surface;
+}
+
+void ActsTrk::MutableTrackSummaryContainer::encodeSurfaces( xAOD::TrackSurfaceAuxContainer* dest, const Acts::GeometryContext& geoContext) const {
+ dest->resize(m_surfaces.size());
+ size_t index = 0;
+ for ( auto& surface: m_surfaces ) {
+ encodeSurface(dest, index, surface.get(), geoContext);
+ index++;
+ }
}
void ActsTrk::MutableTrackSummaryContainer::setParticleHypothesis_impl(ActsTrk::IndexType itrack, const Acts::ParticleHypothesis& particleHypothesis) {
diff --git a/Tracking/Acts/ActsEvent/test/TrackSummaryContainer_test.cxx b/Tracking/Acts/ActsEvent/test/TrackSummaryContainer_test.cxx
index c03d518974db1a511c4e5a8cb09f37407ecd07ff..e30edea60dc8b666d42335f44626ae525e24f290 100644
--- a/Tracking/Acts/ActsEvent/test/TrackSummaryContainer_test.cxx
+++ b/Tracking/Acts/ActsEvent/test/TrackSummaryContainer_test.cxx
@@ -111,25 +111,6 @@ BOOST_FIXTURE_TEST_CASE(ImmutableAccess, FilledBackend) {
}
-/////////////////////////////////////////////////////////////////////
-// Test of TrackSurfaceContainer in mutable TrackSummaryContainer
-
-BOOST_FIXTURE_TEST_CASE(MutableSurfaceBackend_test, FilledBackend){
-
-//TODO: Here the empty surface is created. Tests of surfase filling are needed
-
- auto i = m->addSurface_impl();
- BOOST_CHECK_EQUAL(i, 0);
-
- i = m->addSurface_impl();
- BOOST_CHECK_EQUAL(i, 1);
-
- m->removeSurface_impl(i);
- i = m->addSurface_impl();
- BOOST_CHECK_EQUAL(i, 1);
-};
-
-
template<typename surfType>
void testSurface(surfType surf, std::shared_ptr<const Acts::Surface> outSurf, const Acts::GeometryContext& gctx) {
BOOST_CHECK_EQUAL(int(surf->type()), int(outSurf->type()));
@@ -149,14 +130,14 @@ BOOST_AUTO_TEST_CASE(ConstSurfaceBackend_test){
// Create filled xAOD::TrackSummaryContainer
constexpr static size_t sz = 6;
- xAOD::TrackSummaryContainer backend;
- xAOD::TrackSummaryAuxContainer aux;
- backend.setStore(&aux);
+ xAOD::TrackSummaryContainer summaryBackend;
+ xAOD::TrackSummaryAuxContainer summaryAux;
+ summaryBackend.setStore(&summaryAux);
std::vector<double> semirandoms = {0.12, 0.92};
for (const double sr : semirandoms) {
auto par = new xAOD::TrackSummary();
- backend.push_back(par);
+ summaryBackend.push_back(par);
par->resize();
for ( size_t i = 0; i < sz; ++i) {
par->paramsEigen()(i) = i * sr;
@@ -178,8 +159,8 @@ BOOST_AUTO_TEST_CASE(ConstSurfaceBackend_test){
transform *= Acts::AngleAxis3(rotation[2], Acts::Vector3(1., 0., 0.)); //rotX
xAOD::TrackSurfaceContainer surfBackend;
- xAOD::TrackSurfaceAuxContainer aux0;
- surfBackend.setStore(&aux0);
+ xAOD::TrackSurfaceAuxContainer surfAux;
+ surfBackend.setStore(&surfAux);
auto surfCurr = new xAOD::TrackSurface();
surfBackend.push_back(surfCurr);
@@ -191,11 +172,9 @@ BOOST_AUTO_TEST_CASE(ConstSurfaceBackend_test){
ActsTrk::encodeSurface(surfCurr, surf.get(), gctx);
// Create constant ActsTrk::TrackSummaryContainer
- std::unique_ptr<ActsTrk::TrackSummaryContainer> ms = std::make_unique<ActsTrk::TrackSummaryContainer>(&backend, &aux0);
+ std::unique_ptr<ActsTrk::TrackSummaryContainer> ms = std::make_unique<ActsTrk::TrackSummaryContainer>(&summaryBackend);
- // Read the ActsTrk::TrackSummaryContainer and check track storage and track surfaces
- auto cc = std::make_unique<ActsTrk::TrackSummaryContainer>(ms->trackBackend());
- BOOST_CHECK_EQUAL(cc->size_impl(), 2);
+ BOOST_CHECK_EQUAL(ms->size_impl(), 2);
auto outSurf = ActsTrk::decodeSurface(surfBackend[0], gctx);
testSurface(surf, outSurf, gctx);
diff --git a/Tracking/Acts/ActsEventCnv/src/TrkToActsConvertorAlg.cxx b/Tracking/Acts/ActsEventCnv/src/TrkToActsConvertorAlg.cxx
index cefd4be5c028d72e203e07a30f9789f5babc5746..17b9c8c0900f35e38180d98a59305a280fb16ced 100644
--- a/Tracking/Acts/ActsEventCnv/src/TrkToActsConvertorAlg.cxx
+++ b/Tracking/Acts/ActsEventCnv/src/TrkToActsConvertorAlg.cxx
@@ -50,7 +50,7 @@ StatusCode ActsTrk::TrkToActsConvertorAlg::execute(
ATH_MSG_VERBOSE("TrackStateContainer has " << tc.trackStateContainer().trackStatesAux()->size() << " states");
ATH_MSG_VERBOSE("TrackParametersContainer has " << tc.trackStateContainer().trackParametersAux()->size() << " parameters");
- std::unique_ptr<ActsTrk::TrackContainer> constTrackContainer = m_trackContainerBackendsHelper.moveToConst(std::move(tc), ctx);
+ std::unique_ptr<ActsTrk::TrackContainer> constTrackContainer = m_trackContainerBackendsHelper.moveToConst(std::move(tc), tgContext, ctx);
auto trackContainerHandle = SG::makeHandle(m_trackContainerKey, ctx);
ATH_MSG_VERBOSE("Saving " << constTrackContainer->size() << " tracks to "<< trackContainerHandle.key());
ATH_CHECK(trackContainerHandle.record(std::move(constTrackContainer)));
diff --git a/Tracking/Acts/ActsMonitoring/src/TrackAnalysisAlg.cxx b/Tracking/Acts/ActsMonitoring/src/TrackAnalysisAlg.cxx
index 82c7c1cc171ccc615a385aeb21b4ce7590652398..8496b80e5b69bf15d7d9ffdf78357ca57081e08a 100644
--- a/Tracking/Acts/ActsMonitoring/src/TrackAnalysisAlg.cxx
+++ b/Tracking/Acts/ActsMonitoring/src/TrackAnalysisAlg.cxx
@@ -52,13 +52,12 @@ namespace ActsTrk {
auto monitor_ndof = Monitored::Collection("ndof", proxies, [](const ConstTrackProxy& tp){ return static_cast<double>(tp.nDoF()); } );
auto monitor_nstates = Monitored::Collection("nStates", proxies, [](const ConstTrackProxy& tp){ return static_cast<double>(tp.nTrackStates()); } );
auto monitor_nmeas = Monitored::Collection("nMeasurements", proxies, [](const ConstTrackProxy& tp){ return static_cast<double>(tp.nMeasurements()); } );
- // TODO this needs to be fixed in the followup MR
- // auto monitor_surftype = Monitored::Collection("surfaceType", proxies, [](const ConstTrackProxy& tp){ return static_cast<double>(tp.referenceSurface().type()); } );
+ auto monitor_surftype = Monitored::Collection("surfaceType", proxies, [](const ConstTrackProxy& tp){ return static_cast<double>(tp.referenceSurface().type()); } );
fill(m_monGroupName.value(), monitor_ntracks, monitor_theta, monitor_phi,
monitor_qoverp, monitor_nstates, monitor_phi, monitor_chi2, monitor_chi2OverNdof,
- monitor_ndof, monitor_nstates, monitor_nmeas);
+ monitor_ndof, monitor_nstates, monitor_nmeas, monitor_surftype);
return StatusCode::SUCCESS;
}
diff --git a/Tracking/Acts/ActsTrackReconstruction/src/AmbiguityResolutionAlg.cxx b/Tracking/Acts/ActsTrackReconstruction/src/AmbiguityResolutionAlg.cxx
index 7c1aa8019fcdd25e97180b3171b2c7683e471f25..b47bd08f94ffa86811d812d3f3c9be389d2394a4 100644
--- a/Tracking/Acts/ActsTrackReconstruction/src/AmbiguityResolutionAlg.cxx
+++ b/Tracking/Acts/ActsTrackReconstruction/src/AmbiguityResolutionAlg.cxx
@@ -55,6 +55,7 @@ namespace ActsTrk
}
ATH_CHECK(m_monTool.retrieve(EnableTool{not m_monTool.empty()}));
+ ATH_CHECK(m_trackingGeometryTool.retrieve());
ATH_CHECK(m_tracksKey.initialize());
ATH_CHECK(m_resolvedTracksKey.initialize());
ATH_CHECK(m_resolvedTracksBackendHandles.initialize(ActsTrk::prefixFromTrackContainerName(m_resolvedTracksKey.key()))); //TODO choose prefix related to the output tracks name
@@ -85,7 +86,8 @@ namespace ActsTrk
auto destProxy = solvedTracks.getTrack(solvedTracks.addTrack());
destProxy.copyFrom(trackHandle->getTrack(state.trackTips.at(iTrack)));
}
- std::unique_ptr<ActsTrk::TrackContainer> outputTracks = m_resolvedTracksBackendHandles.moveToConst( std::move(solvedTracks), ctx);
+ std::unique_ptr<ActsTrk::TrackContainer> outputTracks = m_resolvedTracksBackendHandles.moveToConst(std::move(solvedTracks),
+ m_trackingGeometryTool->getGeometryContext(ctx).context(), ctx);
SG::WriteHandle<ActsTrk::TrackContainer> resolvedTrackHandle(m_resolvedTracksKey, ctx);
if (resolvedTrackHandle.record( std::move(outputTracks)).isFailure()) {
diff --git a/Tracking/Acts/ActsTrackReconstruction/src/AmbiguityResolutionAlg.h b/Tracking/Acts/ActsTrackReconstruction/src/AmbiguityResolutionAlg.h
index d51afa62a622597d206373e44d3ab0f0a9239b3c..15d29545f0d4da2e70d2d5b1a03aa8c2d4cdd401 100644
--- a/Tracking/Acts/ActsTrackReconstruction/src/AmbiguityResolutionAlg.h
+++ b/Tracking/Acts/ActsTrackReconstruction/src/AmbiguityResolutionAlg.h
@@ -22,6 +22,7 @@
#include "InDetReadoutGeometry/SiDetectorElementCollection.h"
#include "xAODInDetMeasurement/PixelClusterContainer.h"
#include "xAODInDetMeasurement/StripClusterContainer.h"
+#include "ActsGeometryInterfaces/IActsTrackingGeometryTool.h"
// Handle Keys
#include "StoreGate/ReadHandleKey.h"
@@ -45,6 +46,7 @@ namespace ActsTrk
private:
ToolHandle< GenericMonitoringTool > m_monTool {this, "MonTool", "", "Monitoring tool"};
+ ToolHandle<IActsTrackingGeometryTool> m_trackingGeometryTool{this, "TrackingGeometryTool", ""};
SG::ReadHandleKey<ActsTrk::TrackContainer> m_tracksKey
{this, "TracksLocation", "", "Input track collection"};
diff --git a/Tracking/Acts/ActsTrackReconstruction/src/ProtoTrackCreationAndFitAlg.cxx b/Tracking/Acts/ActsTrackReconstruction/src/ProtoTrackCreationAndFitAlg.cxx
index c5b1291e283a2233eea095836001755f03712619..b2ad2921d5d0576c4a0d4414ea0a790c285eead7 100755
--- a/Tracking/Acts/ActsTrackReconstruction/src/ProtoTrackCreationAndFitAlg.cxx
+++ b/Tracking/Acts/ActsTrackReconstruction/src/ProtoTrackCreationAndFitAlg.cxx
@@ -121,7 +121,8 @@ StatusCode ActsTrk::ProtoTrackCreationAndFitAlg::execute(const EventContext & ct
auto destProxy = trackContainer.getTrack(trackContainer.addTrack());
destProxy.copyFrom(trackProxy, true); // make sure we copy track states!
}
- std::unique_ptr<ActsTrk::TrackContainer> constTracksContainer = m_tracksBackendHandlesHelper.moveToConst(std::move(trackContainer), ctx);
+ std::unique_ptr<ActsTrk::TrackContainer> constTracksContainer = m_tracksBackendHandlesHelper.moveToConst(std::move(trackContainer),
+ m_trackingGeometryTool->getGeometryContext(ctx).context(), ctx);
ATH_CHECK(trackContainerHandle.record(std::move(constTracksContainer)));
diff --git a/Tracking/Acts/ActsTrackReconstruction/src/TrackFindingAlg.cxx b/Tracking/Acts/ActsTrackReconstruction/src/TrackFindingAlg.cxx
index 95f29bb6551e9e0a269a04c85bf408f8d20ad4df..e6fdab36fb17ca48f985dfa7c48188c4b074ce18 100644
--- a/Tracking/Acts/ActsTrackReconstruction/src/TrackFindingAlg.cxx
+++ b/Tracking/Acts/ActsTrackReconstruction/src/TrackFindingAlg.cxx
@@ -360,7 +360,8 @@ namespace ActsTrk
copyStats(event_stat);
- std::unique_ptr<ActsTrk::TrackContainer> constTracksContainer = m_tracksBackendHandlesHelper.moveToConst(std::move(tracksContainer), ctx);
+ std::unique_ptr<ActsTrk::TrackContainer> constTracksContainer = m_tracksBackendHandlesHelper.moveToConst(std::move(tracksContainer),
+ m_trackingGeometryTool->getGeometryContext(ctx).context(), ctx);
// ================================================== //
// ===================== OUTPUTS ==================== //
// ================================================== //
diff --git a/Tracking/Acts/ActsTrackReconstruction/src/TrackMergerAlg.cxx b/Tracking/Acts/ActsTrackReconstruction/src/TrackMergerAlg.cxx
index e0a181b8a2ca38cbc33ca74322bc5647a272e71a..84bfc4e673b40341f897e5ca41a7d3447fdf7def 100644
--- a/Tracking/Acts/ActsTrackReconstruction/src/TrackMergerAlg.cxx
+++ b/Tracking/Acts/ActsTrackReconstruction/src/TrackMergerAlg.cxx
@@ -19,7 +19,8 @@ namespace ActsTrk {
ATH_CHECK(m_outputTrackCollection.initialize());
// Create all the backends
ATH_CHECK(m_tracksBackendHandlesHelper.initialize(ActsTrk::prefixFromTrackContainerName(m_outputTrackCollection.key())));
-
+ ATH_CHECK(m_trackingGeometryTool.retrieve());
+
return StatusCode::SUCCESS;
}
@@ -55,7 +56,8 @@ namespace ActsTrk {
}
ATH_MSG_DEBUG("Created a track container with " << mergedTracks.size() << " elements");
- std::unique_ptr< ActsTrk::TrackContainer > constTracksContainer = m_tracksBackendHandlesHelper.moveToConst(std::move(mergedTracks), ctx);
+ std::unique_ptr< ActsTrk::TrackContainer > constTracksContainer = m_tracksBackendHandlesHelper.moveToConst(std::move(mergedTracks),
+ m_trackingGeometryTool->getGeometryContext(ctx).context(), ctx);
ATH_CHECK(mergedTracksHandle.record(std::move(constTracksContainer)));
return StatusCode::SUCCESS;
diff --git a/Tracking/Acts/ActsTrackReconstruction/src/TrackMergerAlg.h b/Tracking/Acts/ActsTrackReconstruction/src/TrackMergerAlg.h
index 1ce863759b51707e3b95d5962b7cad285b800a8c..31bf4d69bc02368d22fe8f2594156a6ea7e9c590 100644
--- a/Tracking/Acts/ActsTrackReconstruction/src/TrackMergerAlg.h
+++ b/Tracking/Acts/ActsTrackReconstruction/src/TrackMergerAlg.h
@@ -10,6 +10,7 @@
#include "StoreGate/WriteHandleKey.h"
#include "ActsEvent/TrackContainer.h"
#include "ActsEvent/TrackContainerHandlesHelper.h"
+#include "ActsGeometryInterfaces/IActsTrackingGeometryTool.h"
namespace ActsTrk {
@@ -28,6 +29,8 @@ namespace ActsTrk {
"Input Acts Tracks to be merged"};
SG::WriteHandleKey< ActsTrk::TrackContainer > m_outputTrackCollection {this, "OutputTrackCollection", "",
"Output Acts Tracks obtained from the merging of the input collections"};
+ ToolHandle<IActsTrackingGeometryTool> m_trackingGeometryTool{this, "TrackingGeometryTool", ""};
+
};
}