diff --git a/calibrations/tpc/TpcDVCalib/Makefile.am b/calibrations/tpc/TpcDVCalib/Makefile.am index 033929f967..6ae4411894 100644 --- a/calibrations/tpc/TpcDVCalib/Makefile.am +++ b/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 \ diff --git a/calibrations/tpc/TpcDVCalib/TrackToCalo.cc b/calibrations/tpc/TpcDVCalib/TrackToCalo.cc index f9707e4862..0a6bf6117f 100644 --- a/calibrations/tpc/TpcDVCalib/TrackToCalo.cc +++ b/calibrations/tpc/TpcDVCalib/TrackToCalo.cc @@ -38,14 +38,7 @@ #include #include #include -#include - -#include -#include -#include -#include -#include -#include + #include #include diff --git a/offline/QA/Tracking/CosmicTrackQA.cc b/offline/QA/Tracking/CosmicTrackQA.cc index 08f9cdadea..c3ae615158 100644 --- a/offline/QA/Tracking/CosmicTrackQA.cc +++ b/offline/QA/Tracking/CosmicTrackQA.cc @@ -149,7 +149,7 @@ int CosmicTrackQA::process_event(PHCompositeNode *topNode) } else { - Acts::Vector3 loc = surf->transform(geometry->geometry().getGeoContext()).inverse() * (intersection * Acts::UnitConstants::cm); + Acts::Vector3 loc = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).inverse() * (intersection * Acts::UnitConstants::cm); loc /= Acts::UnitConstants::cm; statelx = loc(0); statelz = loc(1); @@ -191,7 +191,7 @@ int CosmicTrackQA::process_event(PHCompositeNode *topNode) } else { - Acts::Vector3 loc = surf->transform(geometry->geometry().getGeoContext()).inverse() * (stateglob * Acts::UnitConstants::cm); + Acts::Vector3 loc = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).inverse() * (stateglob * Acts::UnitConstants::cm); loc /= Acts::UnitConstants::cm; statelx = loc(0); statelz = loc(1); diff --git a/offline/packages/TrackerMillepedeAlignment/HelicalFitter.cc b/offline/packages/TrackerMillepedeAlignment/HelicalFitter.cc index e50a41a3f6..8331a8b491 100644 --- a/offline/packages/TrackerMillepedeAlignment/HelicalFitter.cc +++ b/offline/packages/TrackerMillepedeAlignment/HelicalFitter.cc @@ -594,8 +594,8 @@ int HelicalFitter::process_event(PHCompositeNode* /*unused*/) // fitpoint is the point where the helical fit intersects the plane of the surface // Now transform the helix fitpoint to local coordinates to compare with cluster local coordinates - Acts::Vector3 fitpoint_local = surf->transform(_tGeometry->geometry().getGeoContext()).inverse() * (fitpoint * Acts::UnitConstants::cm); - Acts::Vector3 fitpoint_mvtx_half_local = surf->transform(_tGeometry->geometry().getGeoContext()).inverse() * (fitpoint_mvtx_half * Acts::UnitConstants::cm); + Acts::Vector3 fitpoint_local = surf->localToGlobalTransform(_tGeometry->geometry().getGeoContext()).inverse() * (fitpoint * Acts::UnitConstants::cm); + Acts::Vector3 fitpoint_mvtx_half_local = surf->localToGlobalTransform(_tGeometry->geometry().getGeoContext()).inverse() * (fitpoint_mvtx_half * Acts::UnitConstants::cm); fitpoint_local /= Acts::UnitConstants::cm; fitpoint_mvtx_half_local /= Acts::UnitConstants::cm; @@ -634,7 +634,7 @@ int HelicalFitter::process_event(PHCompositeNode* /*unused*/) if (Verbosity() > 1) { - Acts::Vector3 loc_check = surf->transform(_tGeometry->geometry().getGeoContext()).inverse() * (global * Acts::UnitConstants::cm); + Acts::Vector3 loc_check = surf->localToGlobalTransform(_tGeometry->geometry().getGeoContext()).inverse() * (global * Acts::UnitConstants::cm); loc_check /= Acts::UnitConstants::cm; std::cout << " layer " << layer << std::endl << " cluster global " << global(0) << " " << global(1) << " " << global(2) << std::endl @@ -647,10 +647,10 @@ int HelicalFitter::process_event(PHCompositeNode* /*unused*/) if (Verbosity() > 1) { - Acts::Transform3 transform = surf->transform(_tGeometry->geometry().getGeoContext()); + Acts::Transform3 transform = surf->localToGlobalTransform(_tGeometry->geometry().getGeoContext()); std::cout << "Transform is:" << std::endl; std::cout << transform.matrix() << std::endl; - Acts::Vector3 loc_check = surf->transform(_tGeometry->geometry().getGeoContext()).inverse() * (global * Acts::UnitConstants::cm); + Acts::Vector3 loc_check = surf->localToGlobalTransform(_tGeometry->geometry().getGeoContext()).inverse() * (global * Acts::UnitConstants::cm); loc_check /= Acts::UnitConstants::cm; unsigned int const sector = TpcDefs::getSectorId(cluskey_vec[ivec]); unsigned int const side = TpcDefs::getSide(cluskey_vec[ivec]); @@ -779,7 +779,7 @@ int HelicalFitter::process_event(PHCompositeNode* /*unused*/) Acts::Vector3 ideal_center = surf->center(_tGeometry->geometry().getGeoContext()) * 0.1; Acts::Vector3 ideal_norm = -surf->normal(_tGeometry->geometry().getGeoContext(),Acts::Vector3(1,1,1), Acts::Vector3(1,1,1)); Acts::Vector3 const ideal_local(xloc, zloc, 0.0); // cm - Acts::Vector3 ideal_glob = surf->transform(_tGeometry->geometry().getGeoContext()) * (ideal_local * Acts::UnitConstants::cm); + Acts::Vector3 ideal_glob = surf->localToGlobalTransform(_tGeometry->geometry().getGeoContext()) * (ideal_local * Acts::UnitConstants::cm); ideal_glob /= Acts::UnitConstants::cm; alignmentTransformationContainer::use_alignment = true; @@ -1953,10 +1953,10 @@ void HelicalFitter::get_projectionXY(const Surface& surf, const std::pairtransform(_tGeometry->geometry().getGeoContext()) * (xloc * Acts::UnitConstants::cm); + Acts::Vector3 xglob = surf->localToGlobalTransform(_tGeometry->geometry().getGeoContext()) * (xloc * Acts::UnitConstants::cm); xglob /= Acts::UnitConstants::cm; Acts::Vector3 const yloc(0.0, 1.0, 0.0); - Acts::Vector3 yglob = surf->transform(_tGeometry->geometry().getGeoContext()) * (yloc * Acts::UnitConstants::cm); + Acts::Vector3 yglob = surf->localToGlobalTransform(_tGeometry->geometry().getGeoContext()) * (yloc * Acts::UnitConstants::cm); yglob /= Acts::UnitConstants::cm; // These are the local frame unit vectors transformed to the global frame Acts::Vector3 const X = (xglob - sensorCenter) / (xglob - sensorCenter).norm(); diff --git a/offline/packages/TrackerMillepedeAlignment/MakeMilleFiles.cc b/offline/packages/TrackerMillepedeAlignment/MakeMilleFiles.cc index c894542990..939de889a7 100644 --- a/offline/packages/TrackerMillepedeAlignment/MakeMilleFiles.cc +++ b/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); diff --git a/offline/packages/TrackerMillepedeAlignment/MakeMilleFiles.h b/offline/packages/TrackerMillepedeAlignment/MakeMilleFiles.h index 25a8963987..0733e22bb6 100644 --- a/offline/packages/TrackerMillepedeAlignment/MakeMilleFiles.h +++ b/offline/packages/TrackerMillepedeAlignment/MakeMilleFiles.h @@ -23,6 +23,7 @@ #include +#include #include #include diff --git a/offline/packages/TrackingDiagnostics/TrackResiduals.cc b/offline/packages/TrackingDiagnostics/TrackResiduals.cc index d029ded711..1a5a69fae0 100644 --- a/offline/packages/TrackingDiagnostics/TrackResiduals.cc +++ b/offline/packages/TrackingDiagnostics/TrackResiduals.cc @@ -1128,7 +1128,7 @@ void TrackResiduals::fillClusterBranchesKF(TrkrDefs::cluskey ckey, SvtxTrack* tr { // otherwise take the manual calculation for the TPC // doing it this way just avoids the bounds check that occurs in the surface class method - Acts::Vector3 loct = surf->transform(geometry->geometry().getGeoContext()).inverse() * clusglob_moved; // global is in mm + Acts::Vector3 loct = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).inverse() * clusglob_moved; // global is in mm loct /= Acts::UnitConstants::cm; loc(0) = loct(0); @@ -1166,7 +1166,7 @@ void TrackResiduals::fillClusterBranchesKF(TrkrDefs::cluskey ckey, SvtxTrack* tr auto misaligncenter = surf->center(geometry->geometry().getGeoContext()); auto misalignnorm = -1 * surf->normal(geometry->geometry().getGeoContext(), Acts::Vector3(1, 1, 1), Acts::Vector3(1, 1, 1)); - auto misrot = surf->transform(geometry->geometry().getGeoContext()).rotation(); + auto misrot = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).rotation(); float mgamma = atan2(-misrot(1, 0), misrot(0, 0)); float mbeta = -asin(misrot(0, 1)); @@ -1183,11 +1183,11 @@ void TrackResiduals::fillClusterBranchesKF(TrkrDefs::cluskey ckey, SvtxTrack* tr std::cout << "resids: layer " << layer << " ideal center z " << idealcenter.z() << " mm " << std::endl; std::cout << " surface bounds " << surfbounds[0] << " " << surfbounds[1] << " mm " << std::endl; alignmentTransformationContainer::use_alignment = false; - Acts::Transform3 transform = surf_ideal->transform(geometry->geometry().getGeoContext()); + Acts::Transform3 transform = surf_ideal->localToGlobalTransform(geometry->geometry().getGeoContext()); std::cout << "Ideal transform is:" << std::endl; std::cout << transform.matrix() << std::endl; alignmentTransformationContainer::use_alignment = true; - Acts::Transform3 transform1 = surf_ideal->transform(geometry->geometry().getGeoContext()); + Acts::Transform3 transform1 = surf_ideal->localToGlobalTransform(geometry->geometry().getGeoContext()); std::cout << "Alignment transform is:" << std::endl; std::cout << transform1.matrix() << std::endl; @@ -1199,8 +1199,8 @@ void TrackResiduals::fillClusterBranchesKF(TrkrDefs::cluskey ckey, SvtxTrack* tr // Acts::Vector3 ideal_local(loc.x(), loc.y(), 0.0); auto nominal_loc = geometry->getLocalCoords(ckey, cluster); Acts::Vector3 ideal_local(nominal_loc.x(), nominal_loc.y(), 0.0); - Acts::Vector3 ideal_glob = surf_ideal->transform(geometry->geometry().getGeoContext()) * (ideal_local * Acts::UnitConstants::cm); - auto idealrot = surf_ideal->transform(geometry->geometry().getGeoContext()).rotation(); + Acts::Vector3 ideal_glob = surf_ideal->localToGlobalTransform(geometry->geometry().getGeoContext()) * (ideal_local * Acts::UnitConstants::cm); + auto idealrot = surf_ideal->localToGlobalTransform(geometry->geometry().getGeoContext()).rotation(); //! These calculations are taken from the wikipedia page for Euler angles, //! under the Tait-Bryan angle explanation. Formulas for the angles @@ -1453,7 +1453,7 @@ void TrackResiduals::fillClusterBranchesSeeds(TrkrDefs::cluskey ckey, // SvtxTr auto misaligncenter = surf->center(geometry->geometry().getGeoContext()); auto misalignnorm = -1 * surf->normal(geometry->geometry().getGeoContext(), Acts::Vector3(1, 1, 1), Acts::Vector3(1, 1, 1)); - auto misrot = surf->transform(geometry->geometry().getGeoContext()).rotation(); + auto misrot = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).rotation(); float mgamma = atan2(-misrot(1, 0), misrot(0, 0)); float mbeta = -asin(misrot(0, 1)); @@ -1464,8 +1464,8 @@ void TrackResiduals::fillClusterBranchesSeeds(TrkrDefs::cluskey ckey, // SvtxTr auto idealcenter = surf->center(geometry->geometry().getGeoContext()); auto idealnorm = -1 * surf->normal(geometry->geometry().getGeoContext(), Acts::Vector3(1, 1, 1), Acts::Vector3(1, 1, 1)); Acts::Vector3 ideal_local(loc.x(), loc.y(), 0.0); - Acts::Vector3 ideal_glob = surf->transform(geometry->geometry().getGeoContext()) * (ideal_local * Acts::UnitConstants::cm); - auto idealrot = surf->transform(geometry->geometry().getGeoContext()).rotation(); + Acts::Vector3 ideal_glob = surf->localToGlobalTransform(geometry->geometry().getGeoContext()) * (ideal_local * Acts::UnitConstants::cm); + auto idealrot = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).rotation(); //! These calculations are taken from the wikipedia page for Euler angles, //! under the Tait-Bryan angle explanation. Formulas for the angles @@ -1552,7 +1552,7 @@ void TrackResiduals::fillStatesWithCircleFit(const TrkrDefs::cluskey& key, } else { - auto local = (surf->transform(geometry->geometry().getGeoContext())).inverse() * (intersection * Acts::UnitConstants::cm); + auto local = (surf->localToGlobalTransform(geometry->geometry().getGeoContext())).inverse() * (intersection * Acts::UnitConstants::cm); local /= Acts::UnitConstants::cm; m_statelx.push_back(local.x()); m_statelz.push_back(local.y()); @@ -1579,7 +1579,7 @@ void TrackResiduals::fillStatesWithLineFit(const TrkrDefs::cluskey& key, } else { - Acts::Vector3 loct = surf->transform(geometry->geometry().getGeoContext()).inverse() * (intersection * Acts::UnitConstants::cm); + Acts::Vector3 loct = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).inverse() * (intersection * Acts::UnitConstants::cm); loct /= Acts::UnitConstants::cm; m_statelx.push_back(loct(0)); m_statelz.push_back(loct(1)); diff --git a/offline/packages/intt/CylinderGeomInttHelper.cc b/offline/packages/intt/CylinderGeomInttHelper.cc index 952002c7ba..979ee6d0d7 100644 --- a/offline/packages/intt/CylinderGeomInttHelper.cc +++ b/offline/packages/intt/CylinderGeomInttHelper.cc @@ -18,7 +18,7 @@ TVector3 CylinderGeomInttHelper::get_world_from_local_coords(const Surface& surf Acts::Vector3 loc(local.x(), local.y(), local.z()); loc *= Acts::UnitConstants::cm; - Acts::Vector3 glob = surface->transform(tGeometry->geometry().getGeoContext()) * loc; + Acts::Vector3 glob = surface->localToGlobalTransform(tGeometry->geometry().getGeoContext()) * loc; glob /= Acts::UnitConstants::cm; return TVector3(glob(0), glob(1), glob(2)); } @@ -53,7 +53,7 @@ TVector3 CylinderGeomInttHelper::get_local_from_world_coords(const Surface& surf global(2) = world[2]; global *= Acts::UnitConstants::cm; - Acts::Vector3 local = surface->transform(tGeometry->geometry().getGeoContext()).inverse() * global; + Acts::Vector3 local = surface->localToGlobalTransform(tGeometry->geometry().getGeoContext()).inverse() * global; local /= Acts::UnitConstants::cm; diff --git a/offline/packages/micromegas/CylinderGeomMicromegas.cc b/offline/packages/micromegas/CylinderGeomMicromegas.cc index 5681eed3bd..ccf7395d06 100644 --- a/offline/packages/micromegas/CylinderGeomMicromegas.cc +++ b/offline/packages/micromegas/CylinderGeomMicromegas.cc @@ -50,7 +50,7 @@ TVector3 CylinderGeomMicromegas::get_local_from_world_coords( uint tileid, ActsG // convert to local /* this is equivalent to calling surface->globalToLocal but without the "on surface" check, and while returning a full Acts::Vector3 */ - const auto local = surface->transform(geometry->geometry().getGeoContext()).inverse()*global; + const auto local = surface->localToGlobalTransform(geometry->geometry().getGeoContext()).inverse()*global; return TVector3( local.x()/Acts::UnitConstants::cm, local.y()/Acts::UnitConstants::cm, @@ -109,7 +109,7 @@ TVector3 CylinderGeomMicromegas::get_world_from_local_coords( uint tileid, ActsG // convert to global /* this is equivalent to calling surface->localToGlobal but without assuming that the local point is on surface */ - const auto global = surface->transform(geometry->geometry().getGeoContext())*local; + const auto global = surface->localToGlobalTransform(geometry->geometry().getGeoContext())*local; return TVector3( global.x()/Acts::UnitConstants::cm, global.y()/Acts::UnitConstants::cm, diff --git a/offline/packages/mvtx/CylinderGeom_MvtxHelper.cc b/offline/packages/mvtx/CylinderGeom_MvtxHelper.cc index 41db23e434..e077d80964 100644 --- a/offline/packages/mvtx/CylinderGeom_MvtxHelper.cc +++ b/offline/packages/mvtx/CylinderGeom_MvtxHelper.cc @@ -23,7 +23,7 @@ CylinderGeom_MvtxHelper::get_local_from_world_coords ( global *= Acts::UnitConstants::cm; - Acts::Vector3 local = surface->transform(tGeometry->geometry().getGeoContext()).inverse() * global; + Acts::Vector3 local = surface->localToGlobalTransform(tGeometry->geometry().getGeoContext()).inverse() * global; local /= Acts::UnitConstants::cm; /// The Acts transform swaps a few of the coordinates @@ -67,7 +67,7 @@ CylinderGeom_MvtxHelper::get_world_from_local_coords ( Acts::Vector3 loc(local.x(), local.y(), local.z()); loc *= Acts::UnitConstants::cm; - Acts::Vector3 glob = surface->transform(tGeometry->geometry().getGeoContext()) * loc; + Acts::Vector3 glob = surface->localToGlobalTransform(tGeometry->geometry().getGeoContext()) * loc; glob /= Acts::UnitConstants::cm; return TVector3(glob(0), glob(1), glob(2)); diff --git a/offline/packages/tpc/LaserClusterizer.cc b/offline/packages/tpc/LaserClusterizer.cc index 8ecd28688e..925b0c6e8a 100644 --- a/offline/packages/tpc/LaserClusterizer.cc +++ b/offline/packages/tpc/LaserClusterizer.cc @@ -872,12 +872,12 @@ namespace } // Convert from ideal TPC coordinates to surface coordinates - Acts::Vector3 local = surface->transform(my_data.tGeometry->geometry().getGeoContext()).inverse() * (ideal * Acts::UnitConstants::cm); + Acts::Vector3 local = surface->localToGlobalTransform(my_data.tGeometry->geometry().getGeoContext()).inverse() * (ideal * Acts::UnitConstants::cm); local /= Acts::UnitConstants::cm; // Convert back to TPC coordinates with alignment applied alignmentTransformationContainer::use_alignment = true; - Acts::Vector3 global = surface->transform(my_data.tGeometry->geometry().getGeoContext()) * (local * Acts::UnitConstants::cm); + Acts::Vector3 global = surface->localToGlobalTransform(my_data.tGeometry->geometry().getGeoContext()) * (local * Acts::UnitConstants::cm); global /= Acts::UnitConstants::cm; clus->setX(global(0)); clus->setY(global(1)); diff --git a/offline/packages/tpc/TpcClusterizer.cc b/offline/packages/tpc/TpcClusterizer.cc index dc815eacae..687d5b58f9 100644 --- a/offline/packages/tpc/TpcClusterizer.cc +++ b/offline/packages/tpc/TpcClusterizer.cc @@ -714,7 +714,7 @@ namespace /// convert to Acts units global *= Acts::UnitConstants::cm; // std::cout << "transform" << std::endl; - Acts::Vector3 local = surface->transform(my_data.tGeometry->geometry().getGeoContext()).inverse() * global; + Acts::Vector3 local = surface->localToGlobalTransform(my_data.tGeometry->geometry().getGeoContext()).inverse() * global; local /= Acts::UnitConstants::cm; // std::cout << "done transform" << std::endl; // we need the cluster key and all associated hit keys (note: the cluster key includes the hitset key) @@ -763,7 +763,7 @@ namespace double nn_y = radius * std::sin(nn_phi); Acts::Vector3 nn_global(nn_x, nn_y, nn_z); nn_global *= Acts::UnitConstants::cm; - Acts::Vector3 nn_local = surface->transform(my_data.tGeometry->geometry().geoContext).inverse() * nn_global; + Acts::Vector3 nn_local = surface->localToGlobalTransform(my_data.tGeometry->geometry().geoContext).inverse() * nn_global; nn_local /= Acts::UnitConstants::cm; double nn_t = my_data.m_tdriftmax - std::fabs(nn_z) / my_data.tGeometry->get_drift_velocity(); clus_base->setLocalX(nn_local(0)); diff --git a/offline/packages/trackbase/ActsGeometry.h b/offline/packages/trackbase/ActsGeometry.h index 957a1a8e62..df391d98bb 100644 --- a/offline/packages/trackbase/ActsGeometry.h +++ b/offline/packages/trackbase/ActsGeometry.h @@ -10,7 +10,6 @@ class TrkrCluster; class ActsGeometry { public: - ActsGeometry() = default; ~ActsGeometry() = default; void setGeometry(const ActsTrackingGeometry& tGeometry) diff --git a/offline/packages/trackbase/ActsGsfTrackFittingAlgorithm.h b/offline/packages/trackbase/ActsGsfTrackFittingAlgorithm.h index fd144c1163..d0de5fadbd 100644 --- a/offline/packages/trackbase/ActsGsfTrackFittingAlgorithm.h +++ b/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()>(&updater); Acts::GsfOptions 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)); }; diff --git a/offline/packages/trackbase/ActsTrackFittingAlgorithm.h b/offline/packages/trackbase/ActsTrackFittingAlgorithm.h index 425c669da2..c68698b9d7 100644 --- a/offline/packages/trackbase/ActsTrackFittingAlgorithm.h +++ b/offline/packages/trackbase/ActsTrackFittingAlgorithm.h @@ -11,7 +11,7 @@ #include #include #include - +#include #pragma GCC diagnostic push // needed for local Act compilation #pragma GCC diagnostic ignored "-Wunused-local-typedefs" #include @@ -32,8 +32,7 @@ class ActsTrackFittingAlgorithm final { public: using TrackParameters = ::Acts::BoundTrackParameters; - using Measurement = ::Acts::BoundVariantMeasurement; - using MeasurementContainer = std::vector; + using MeasurementContainer = ActsExamples::MeasurementContainer; using TrackContainer = Acts::TrackContainer tGeo, // ActsTrackingGeometry(std::shared_ptr tGeo, std::shared_ptr mag, @@ -49,7 +49,7 @@ struct ActsTrackingGeometry /// Acts context, for Kalman options Acts::CalibrationContext calibContext; - Acts::GeometryContext geoContext; + Acts::GeometryContext geoContext = Acts::GeometryContext::dangerouslyDefaultConstruct(); Acts::MagneticFieldContext magFieldContext; const Acts::GeometryContext& getGeoContext() const diff --git a/offline/packages/trackbase/AlignmentTransformation.cc b/offline/packages/trackbase/AlignmentTransformation.cc index 2e8647ab01..171d9684ac 100644 --- a/offline/packages/trackbase/AlignmentTransformation.cc +++ b/offline/packages/trackbase/AlignmentTransformation.cc @@ -351,7 +351,8 @@ void AlignmentTransformation::createMap(PHCompositeNode* topNode) } // copy map into geoContext - m_tGeometry->geometry().geoContext = transformMap; + Acts::GeometryContext gctx{transformMap}; + m_tGeometry->geometry().geoContext = gctx; std::cout << " AlignmentTransformation processed " << linecount << " input lines " << std::endl; @@ -372,7 +373,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->localToGlobalTransform(m_tGeometry->geometry().getGeoContext()); Eigen::Matrix3d actsRotationPart = actsTransform.rotation(); Eigen::Vector3d actsTranslationPart = actsTransform.translation(); diff --git a/offline/packages/trackbase/Calibrator.cc b/offline/packages/trackbase/Calibrator.cc index 44b66bce1a..ce9839e7f5 100644 --- a/offline/packages/trackbase/Calibrator.cc +++ b/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(); - 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 fixedMeasurement = + static_cast>( + measurement); + const auto cov = fixedMeasurement.covariance(); + const TrkrDefs::cluskey cluskey = sl.cluskey(); + const uint8_t layer = TrkrDefs::getLayer(cluskey); + const double misalignmentFactor = gctx.get()->getMisalignmentFactor(layer); + + Acts::ActsSquareMatrix expandedCov = Acts::ActsSquareMatrix::Zero(); + + for (int i = 0; i < cov.rows(); i++) + { + for (int j = 0; j < cov.cols(); j++) { - std::array 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()->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 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( diff --git a/offline/packages/trackbase/Calibrator.h b/offline/packages/trackbase/Calibrator.h index 2f9d4f2fc0..651091ad5b 100644 --- a/offline/packages/trackbase/Calibrator.h +++ b/offline/packages/trackbase/Calibrator.h @@ -6,7 +6,7 @@ #include "TrkrDefs.h" #include "alignmentTransformationContainer.h" -#include +#include #include #include @@ -14,13 +14,7 @@ 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; + using MeasurementContainer = ActsExamples::MeasurementContainer; void calibrate(const MeasurementContainer& measurements, const Acts::GeometryContext& gctx, diff --git a/offline/packages/trackbase/IBaseDetector.h b/offline/packages/trackbase/IBaseDetector.h index a52e5f1b0b..8f1f0f16d5 100644 --- a/offline/packages/trackbase/IBaseDetector.h +++ b/offline/packages/trackbase/IBaseDetector.h @@ -8,12 +8,20 @@ #pragma once -#include "ActsExamples/Utilities/OptionsFwd.hpp" - #include #include #include - +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 finalize( - const boost::program_options::variables_map& vm, - std::shared_ptr mdecorator) = 0; }; } // namespace ActsExamples diff --git a/offline/packages/trackbase/MagneticFieldOptions.cc b/offline/packages/trackbase/MagneticFieldOptions.cc index 4043397f76..52ee028196 100644 --- a/offline/packages/trackbase/MagneticFieldOptions.cc +++ b/offline/packages/trackbase/MagneticFieldOptions.cc @@ -7,8 +7,8 @@ #include #include #include -#include -#include +#include +#include #include #include @@ -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(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(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(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(std::move(map)); diff --git a/offline/packages/trackbase/MagneticFieldOptions.h b/offline/packages/trackbase/MagneticFieldOptions.h index 7604c026c4..e827e456be 100644 --- a/offline/packages/trackbase/MagneticFieldOptions.h +++ b/offline/packages/trackbase/MagneticFieldOptions.h @@ -3,7 +3,18 @@ #include #include -#include + +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 readMagneticField( } // namespace Options } // namespace ActsExamples -#endif // _MAGNETICFIELDOPTIONS_H \ No newline at end of file +#endif // _MAGNETICFIELDOPTIONS_H diff --git a/offline/packages/trackbase/Makefile.am b/offline/packages/trackbase/Makefile.am index 29d090c40a..bcb0b81d96 100644 --- a/offline/packages/trackbase/Makefile.am +++ b/offline/packages/trackbase/Makefile.am @@ -40,7 +40,6 @@ AM_LDFLAGS = \ pkginclude_HEADERS = \ ActsAborter.h \ ActsGeometry.h \ - ActsGsfTrackFittingAlgorithm.h \ ActsSourceLink.h \ ActsSurfaceMaps.h \ ActsTrackFittingAlgorithm.h \ @@ -71,8 +70,8 @@ pkginclude_HEADERS = \ LaserClusterContainerv1.h \ LaserClusterv1.h \ LaserClusterv2.h \ - MagneticFieldOptions.h \ MaterialWiper.h \ + MagneticFieldOptions.h \ MvtxDefs.h \ MvtxEventInfo.h \ MvtxEventInfov1.h \ @@ -219,7 +218,6 @@ libtrack_la_SOURCES = \ MagneticFieldOptions.cc \ sPHENIXActsDetectorElement.cc \ TGeoDetectorWithOptions.cc \ - TrackFittingAlgorithmFunctionsGsf.cc \ TrackFittingAlgorithmFunctionsKalman.cc \ TrackFitUtils.cc @@ -292,8 +290,7 @@ libtrack_io_la_SOURCES = \ libtrack_la_LIBADD = \ libtrack_io.la \ -lActsCore \ - -lActsExamplesMagneticField \ - -lActsPluginTGeo \ + -lActsPluginRoot \ -lActsExamplesDetectorTGeo \ -lffamodules \ -lboost_program_options diff --git a/offline/packages/trackbase/ResidualOutlierFinder.h b/offline/packages/trackbase/ResidualOutlierFinder.h index 593f5df981..d0ace7fb12 100644 --- a/offline/packages/trackbase/ResidualOutlierFinder.h +++ b/offline/packages/trackbase/ResidualOutlierFinder.h @@ -6,10 +6,12 @@ #include #include #include -#include + +#include #include #include #include +#include #include struct ResidualOutlierFinder @@ -49,44 +51,14 @@ struct ResidualOutlierFinder auto sourceLink = state.getUncalibratedSourceLink().template get(); const auto& cluskey = sourceLink.cluskey(); - const auto predicted = state.predicted(); - const auto predictedCovariance = state.predictedCovariance(); - float chi2 = std::numeric_limits::max(); - - auto fullCalibrated = state - .template calibrated() - .data(); - auto fullCalibratedCovariance = state - .template calibratedCovariance() - .data(); - - chi2 = Acts::visit_measurement(state.calibratedSize(), [&](auto N) -> double - { - constexpr size_t kMeasurementSize = decltype(N)::value; - typename Acts::TrackStateTraits::Measurement calibrated{ - fullCalibrated}; - - typename Acts::TrackStateTraits::MeasurementCovariance - calibratedCovariance{fullCalibratedCovariance}; - - using ParametersVector = Acts::ActsVector; - const auto H = state.projector().template topLeftCorner().eval(); - ParametersVector res; - res = calibrated - H * predicted; - chi2 = (res.transpose() * ((calibratedCovariance + H * predictedCovariance * H.transpose())).inverse() * res).eval()(0, 0); - - return chi2; }); + double chi2 = Acts::calculatePredictedChi2(state); float distance = Acts::visit_measurement(state.calibratedSize(), [&](auto N) { constexpr size_t kMeasurementSize = decltype(N)::value; - auto residuals = - state.template calibrated() - - state.projector() - .template topLeftCorner() * - state.predicted(); - auto cdistance = residuals.norm(); - return cdistance; }); + auto [residual, residualCovariance] = + calculatePredictedResidual(state); + return residual.norm(); }); if (verbosity > 2) { @@ -108,6 +80,10 @@ struct ResidualOutlierFinder std::cout << PHWHERE << "no geometry set in residual outlier finder" << std::endl; exit(1); } + const auto predicted = state.predicted(); + auto fullCalibrated = state + .template calibrated() + .data(); Acts::FreeVector freeParams = Acts::transformBoundToFreeParameters(state.referenceSurface(), m_tGeometry->geometry().getGeoContext(), @@ -117,7 +93,7 @@ struct ResidualOutlierFinder m_tGeometry->geometry().getGeoContext(), local, Acts::Vector3(1, 1, 1)); float data[] = { - (float) sphenixlayer, (float) layer, (float) volume, distance, chi2, + (float) sphenixlayer, (float) layer, (float) volume, distance, (float)chi2, (float) freeParams[Acts::eFreePos0], (float) freeParams[Acts::eFreePos1], (float) freeParams[Acts::eFreePos2], (float) predicted[Acts::eBoundLoc0], (float) predicted[Acts::eBoundLoc1], (float) global[Acts::eFreePos0], (float) global[Acts::eFreePos1], (float) global[Acts::eFreePos2], diff --git a/offline/packages/trackbase/SpacePoint.h b/offline/packages/trackbase/SpacePoint.h index 74bff8b1c2..afede18a3b 100644 --- a/offline/packages/trackbase/SpacePoint.h +++ b/offline/packages/trackbase/SpacePoint.h @@ -5,8 +5,9 @@ #include #include "trackbase/TrkrDefs.h" +#include #include -#include +#include /** * A struct for Acts to take cluster information for seeding @@ -40,8 +41,11 @@ inline bool operator==(SpacePoint a, SpacePoint b) { return (a.m_clusKey == b.m_clusKey); } +using SpacePointContainerType = ActsExamples::SpacePointContainer>; +using proxy_type = typename Acts::SpacePointContainer::SpacePointProxyType; using SpacePointPtr = std::unique_ptr; -using SeedContainer = std::vector>; +using SpacePointContainer = std::vector; +using SeedContainer = std::vector>; #endif diff --git a/offline/packages/trackbase/TGeoDetectorWithOptions.cc b/offline/packages/trackbase/TGeoDetectorWithOptions.cc index 4467c20754..6c0698cec7 100644 --- a/offline/packages/trackbase/TGeoDetectorWithOptions.cc +++ b/offline/packages/trackbase/TGeoDetectorWithOptions.cc @@ -10,9 +10,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include #include #include #include @@ -79,36 +79,4 @@ void TGeoDetectorWithOptions::addOptions( "Json file to dump empty config into."); } -auto TGeoDetectorWithOptions::finalize( - const boost::program_options::variables_map& vm, - std::shared_ptr mdecorator) - -> std::pair { - TGeoDetector::Config config; - - config.fileName = vm["geo-tgeo-filename"].as(); - - config.surfaceLogLevel = - Acts::Logging::Level(vm["geo-surface-loglevel"].template as()); - config.layerLogLevel = - Acts::Logging::Level(vm["geo-layer-loglevel"].template as()); - config.volumeLogLevel = - Acts::Logging::Level(vm["geo-volume-loglevel"].template as()); - - // No valid geometry configuration. Stop - if (vm["geo-tgeo-jsonconfig"].as().empty()) { - writeTGeoDetectorConfig(vm, config); - std::exit(EXIT_SUCCESS); - } - // Enable dump from full config - else if (!(vm["geo-tgeo-dump-jsonconfig"].as().compare( - "tgeo_empty_cofig.json") == 0)) { - readTGeoLayerBuilderConfigs(vm, config); - writeTGeoDetectorConfig(vm, config); - } else { - readTGeoLayerBuilderConfigs(vm, config); - } - - return m_detector.finalize(config, std::move(mdecorator)); -} - } // namespace ActsExamples diff --git a/offline/packages/trackbase/TGeoDetectorWithOptions.h b/offline/packages/trackbase/TGeoDetectorWithOptions.h index cc8467c92d..af3358abdf 100644 --- a/offline/packages/trackbase/TGeoDetectorWithOptions.h +++ b/offline/packages/trackbase/TGeoDetectorWithOptions.h @@ -4,20 +4,17 @@ #include "IBaseDetector.h" #include -#include namespace ActsExamples { class TGeoDetectorWithOptions : public IBaseDetector { public: + TGeoDetectorWithOptions(TGeoDetector::Config config) : m_detector(config) {} TGeoDetector m_detector; void addOptions( boost::program_options::options_description& opt) const override; - - auto finalize(const boost::program_options::variables_map& vm, - std::shared_ptr mdecorator) - -> std::pair override; + }; } // namespace ActsExamples diff --git a/offline/packages/trackbase/TrackFittingAlgorithmFunctionsGsf.cc b/offline/packages/trackbase/TrackFittingAlgorithmFunctionsGsf.cc index cecd2898b9..16d5912532 100644 --- a/offline/packages/trackbase/TrackFittingAlgorithmFunctionsGsf.cc +++ b/offline/packages/trackbase/TrackFittingAlgorithmFunctionsGsf.cc @@ -9,7 +9,8 @@ ActsGsfTrackFittingAlgorithm::makeGsfFitterFunction( BetheHeitlerApprox betheHeitlerApprox, std::size_t maxComponents, double weightCutoff, MixtureReductionAlgorithm finalReductionMethod, bool abortOnError, - bool disableAllMaterialHandling, const Acts::Logger& logger) + bool disableAllMaterialHandling, double reverseFilteringCovarianceScaling, + const Acts::Logger& logger) { MultiStepper stepper(std::move(magneticField), logger.cloneWithSuffix("GSFStep")); @@ -35,6 +36,7 @@ ActsGsfTrackFittingAlgorithm::makeGsfFitterFunction( fitterFunction->abortOnError = abortOnError; fitterFunction->disableAllMaterialHandling = disableAllMaterialHandling; fitterFunction->reductionAlg = finalReductionMethod; - + fitterFunction->reverseFilteringCovarianceScaling = + reverseFilteringCovarianceScaling; return fitterFunction; } diff --git a/offline/packages/trackbase/alignmentTransformationContainer.h b/offline/packages/trackbase/alignmentTransformationContainer.h index e6eb6c2df8..8711ec5b45 100644 --- a/offline/packages/trackbase/alignmentTransformationContainer.h +++ b/offline/packages/trackbase/alignmentTransformationContainer.h @@ -23,7 +23,7 @@ * * Association object holding transformations associated with given tracker hitset */ -class alignmentTransformationContainer : public Acts::GeometryContext +class alignmentTransformationContainer { public: alignmentTransformationContainer(); diff --git a/offline/packages/trackbase/sPHENIXActsDetectorElement.cc b/offline/packages/trackbase/sPHENIXActsDetectorElement.cc index 3daec79ca2..3751f68a6c 100644 --- a/offline/packages/trackbase/sPHENIXActsDetectorElement.cc +++ b/offline/packages/trackbase/sPHENIXActsDetectorElement.cc @@ -6,7 +6,7 @@ sPHENIXActsDetectorElement::~sPHENIXActsDetectorElement() = default; -const Acts::Transform3& sPHENIXActsDetectorElement::transform(const Acts::GeometryContext& ctxt) const +const Acts::Transform3& sPHENIXActsDetectorElement::localToGlobalTransform(const Acts::GeometryContext& ctxt) const { if (alignmentTransformationContainer::use_alignment) { @@ -23,16 +23,7 @@ const Acts::Transform3& sPHENIXActsDetectorElement::transform(const Acts::Geomet auto& layerVec = transformVec[sphlayer]; // get the vector of transforms for this layer if (layerVec.size() > sensor) - { - /* - if(sphlayer > 7) - { - std::cout << "sPHENIXActsDetectorElement: volume " << volume <<" Acts layer " << layer << " sensor " << sensor - << " sphenix layer " << sphlayer << std::endl; - std::cout << layerVec[sensor].matrix() << std::endl; - } - */ - + { return layerVec[sensor]; } @@ -44,7 +35,7 @@ const Acts::Transform3& sPHENIXActsDetectorElement::transform(const Acts::Geomet else { // return the construction transform - const Acts::Transform3& transform = TGeoDetectorElement::transform(ctxt); // ctxt is unused here + const Acts::Transform3& transform = TGeoDetectorElement::nominalTransform(); // ctxt is unused here return transform; } } diff --git a/offline/packages/trackbase/sPHENIXActsDetectorElement.h b/offline/packages/trackbase/sPHENIXActsDetectorElement.h index 7abf4a511f..98a4813989 100644 --- a/offline/packages/trackbase/sPHENIXActsDetectorElement.h +++ b/offline/packages/trackbase/sPHENIXActsDetectorElement.h @@ -2,8 +2,8 @@ #define TRACKBASE_SPHENIXACTSDETECTORELEMENT_H #include -#include -#include +#include +#include /** * This class implements an sphenix detector element to build @@ -13,9 +13,10 @@ class ActsGeometry; -class sPHENIXActsDetectorElement : public Acts::TGeoDetectorElement +class sPHENIXActsDetectorElement : public ActsPlugins::TGeoDetectorElement { public: + using Identifier = ActsPlugins::TGeoDetectorElement::Identifier; sPHENIXActsDetectorElement() = delete; sPHENIXActsDetectorElement(const Identifier& identifier, @@ -24,7 +25,7 @@ class sPHENIXActsDetectorElement : public Acts::TGeoDetectorElement const std::string& axes = "XYZ", double scalor = 10., std::shared_ptr material = nullptr) - : Acts::TGeoDetectorElement(identifier, tGeoNode, tGeoMatrix, + : ActsPlugins::TGeoDetectorElement(identifier, tGeoNode, tGeoMatrix, axes, scalor, material) { } @@ -34,7 +35,7 @@ class sPHENIXActsDetectorElement : public Acts::TGeoDetectorElement Acts::Transform3& tgTransform, std::shared_ptr tgBounds, double tgThickness = 0.) - : Acts::TGeoDetectorElement(identifier, tGeoNode, tgTransform, + : ActsPlugins::TGeoDetectorElement(identifier, tGeoNode, tgTransform, tgBounds, tgThickness) { } @@ -44,21 +45,21 @@ class sPHENIXActsDetectorElement : public Acts::TGeoDetectorElement Acts::Transform3& tgTransform, std::shared_ptr tgBounds, double tgThickness = 0.) - : Acts::TGeoDetectorElement(identifier, tGeoNode, tgTransform, tgBounds, + : ActsPlugins::TGeoDetectorElement(identifier, tGeoNode, tgTransform, tgBounds, tgThickness) { } ~sPHENIXActsDetectorElement() override; - const Acts::Transform3& transform(const Acts::GeometryContext& ctxt) const override; + const Acts::Transform3& localToGlobalTransform(const Acts::GeometryContext& ctxt) const override; private: std::map base_layer_map = {{10, 0}, {12, 3}, {14, 7}, {16, 55}}; }; std::shared_ptr sPHENIXElementFactory( - const Identifier& identifier, const TGeoNode& tGeoNode, + const sPHENIXActsDetectorElement::Identifier& identifier, const TGeoNode& tGeoNode, const TGeoMatrix& tGeoMatrix, const std::string& axes, double scalor, std::shared_ptr material) { diff --git a/offline/packages/trackbase_historic/ActsTransformations.cc b/offline/packages/trackbase_historic/ActsTransformations.cc index ae76cec640..5bf08082e5 100644 --- a/offline/packages/trackbase_historic/ActsTransformations.cc +++ b/offline/packages/trackbase_historic/ActsTransformations.cc @@ -286,7 +286,7 @@ void ActsTransformations::calculateDCA(const Acts::BoundTrackParameters& param, } void ActsTransformations::fillSvtxTrackStates( - const Acts::ConstVectorMultiTrajectory& traj, + const Acts::VectorMultiTrajectory& traj, const size_t& trackTip, SvtxTrack* svtxTrack, const Acts::GeometryContext& geoContext) const @@ -295,8 +295,7 @@ void ActsTransformations::fillSvtxTrackStates( { /// Only fill the track states with non-outlier measurement - const auto typeFlags = state.typeFlags(); - if( !typeFlags.test(Acts::TrackStateFlag::MeasurementFlag) ) + if (!state.typeFlags().isMeasurement()) { return true; } // only fill for state vectors with proper smoothed parameters diff --git a/offline/packages/trackbase_historic/ActsTransformations.h b/offline/packages/trackbase_historic/ActsTransformations.h index 3cc90b7311..986488b4ea 100644 --- a/offline/packages/trackbase_historic/ActsTransformations.h +++ b/offline/packages/trackbase_historic/ActsTransformations.h @@ -70,7 +70,7 @@ class ActsTransformations //___________________________________________________________________________________________________________ void fillSvtxTrackStates( - const Acts::ConstVectorMultiTrajectory& traj, + const Acts::VectorMultiTrajectory& traj, const size_t& trackTip, SvtxTrack* svtxTrack, const Acts::GeometryContext& geoContext diff --git a/offline/packages/trackbase_historic/Makefile.am b/offline/packages/trackbase_historic/Makefile.am index a27554a914..3f1ed12e2a 100644 --- a/offline/packages/trackbase_historic/Makefile.am +++ b/offline/packages/trackbase_historic/Makefile.am @@ -16,9 +16,9 @@ AM_CPPFLAGS = \ AM_LDFLAGS = \ -L$(libdir) \ - -L$(ROOTSYS)/lib \ -L$(OFFLINE_MAIN)/lib \ - -L$(OFFLINE_MAIN)/lib64 + -L$(OFFLINE_MAIN)/lib64 \ + -L$(ROOTSYS)/lib pkginclude_HEADERS = \ ActsTransformations.h \ @@ -180,11 +180,6 @@ libtrackbase_historic_io_la_SOURCES = \ WeightedTrackZeroField.cc \ WeightedTrackMap.cc -AM_LDFLAGS = \ - -L$(libdir) \ - -L$(OFFLINE_MAIN)/lib \ - -L$(OFFLINE_MAIN)/lib64 - # dependency on libtrack.so breaks the io only library concept libtrackbase_historic_io_la_LIBADD = \ -lphool \ diff --git a/offline/packages/trackbase_historic/TrackAnalysisUtils.cc b/offline/packages/trackbase_historic/TrackAnalysisUtils.cc index 04f5ff341c..0a04d41f26 100644 --- a/offline/packages/trackbase_historic/TrackAnalysisUtils.cc +++ b/offline/packages/trackbase_historic/TrackAnalysisUtils.cc @@ -392,7 +392,7 @@ namespace TrackAnalysisUtils { // otherwise take the manual calculation for the TPC // doing it this way just avoids the bounds check that occurs in the surface class method - Acts::Vector3 loct = surf->transform(geometry->geometry().getGeoContext()).inverse() * clusglob_moved; // global is in mm + Acts::Vector3 loct = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).inverse() * clusglob_moved; // global is in mm loct /= Acts::UnitConstants::cm; loc(0) = loct(0); diff --git a/offline/packages/trackbase_historic/TrackAnalysisUtils.h b/offline/packages/trackbase_historic/TrackAnalysisUtils.h index aab282da20..fc53a45b2d 100644 --- a/offline/packages/trackbase_historic/TrackAnalysisUtils.h +++ b/offline/packages/trackbase_historic/TrackAnalysisUtils.h @@ -40,7 +40,7 @@ namespace TrackAnalysisUtils // when/if the tpc geometry changes in the future. This is to get us going const float thickness_per_region[4]); float calc_dedx(TrackSeed* tpcseed, TrkrClusterContainer* clustermap, ActsGeometry* tgeometry, - float const thickness_per_region[4]); + const float thickness_per_region[4]); TrackFitResiduals get_residuals(SvtxTrack* track, TrkrClusterContainer* clustermap, PHCompositeNode* topNode); diff --git a/offline/packages/trackreco/ActsAlignmentStates.cc b/offline/packages/trackreco/ActsAlignmentStates.cc index d99fc1c178..070f78e53f 100644 --- a/offline/packages/trackreco/ActsAlignmentStates.cc +++ b/offline/packages/trackreco/ActsAlignmentStates.cc @@ -56,7 +56,7 @@ void ActsAlignmentStates::loadNodes( PHCompositeNode* topNode ) //_________________________________________________________________ void ActsAlignmentStates::fillAlignmentStateMap( const ActsTrackFittingAlgorithm::TrackContainer& tracks, - const std::vector& tips, + const std::vector& tips, SvtxTrack* track, const ActsTrackFittingAlgorithm::MeasurementContainer& measurements) { @@ -117,7 +117,7 @@ void ActsAlignmentStates::fillAlignmentStateMap( { /// Collect only track states which were used in smoothing of KF and are measurements if (! state.hasSmoothed() || - ! state.typeFlags().test(Acts::TrackStateFlag::MeasurementFlag)) + ! state.typeFlags().isMeasurement()) { return true; } @@ -127,10 +127,9 @@ void ActsAlignmentStates::fillAlignmentStateMap( auto ckey = sl.cluskey(); Acts::Vector2 localMeas = Acts::Vector2::Zero(); /// get the local measurement that acts used - std::visit([&](const auto& meas) { - localMeas(0) = meas.parameters()[0]; - localMeas(1) = meas.parameters()[1]; - }, measurements[sl.index()]); + const auto measurement = measurements.getMeasurement(sl.index()); + localMeas(0) = measurement.parameters()[0]; + localMeas(1) = measurement.parameters()[1]; if (m_verbosity > 2) { @@ -142,7 +141,9 @@ void ActsAlignmentStates::fillAlignmentStateMap( auto clus = m_clusterMap->findCluster(ckey); // local state vector - const Acts::Vector2 localState = state.effectiveProjector() * state.smoothed(); + const auto H = state.projectorSubspaceHelper().fullProjector().topLeftCorner( + state.calibratedSize(), Acts::eBoundSize); + const Acts::Vector2 localState = H * state.smoothed(); // Local residual between measurement and smoothed Acts state const Acts::Vector2 localResidual = localMeas - localState; @@ -205,8 +206,8 @@ void ActsAlignmentStates::fillAlignmentStateMap( //! this is the derivative of the state wrt to Acts track parameters //! e.g. (d_0, z_0, phi, theta, q/p, t) - auto localDeriv = state.effectiveProjector() * state.jacobian(); - if(m_verbosity > 2) + auto localDeriv = H * state.jacobian(); + if (m_verbosity > 2) { std::cout << "local deriv " << std::endl << localDeriv << std::endl; } @@ -275,10 +276,10 @@ std::pair ActsAlignmentStates::get_projectionXY(co // get surface X and Y unit vectors in global frame // transform Xlocal = 1.0 to global, subtract the surface center, normalize to 1 Acts::Vector3 xloc(1.0, 0.0, 0.0); - Acts::Vector3 xglob = surface.transform(m_tGeometry->geometry().getGeoContext()) * xloc; + Acts::Vector3 xglob = surface.localToGlobalTransform(m_tGeometry->geometry().getGeoContext()) * xloc; Acts::Vector3 yloc(0.0, 1.0, 0.0); - Acts::Vector3 yglob = surface.transform(m_tGeometry->geometry().getGeoContext()) * yloc; + Acts::Vector3 yglob = surface.localToGlobalTransform(m_tGeometry->geometry().getGeoContext()) * yloc; Acts::Vector3 X = (xglob - sensorCenter) / (xglob - sensorCenter).norm(); Acts::Vector3 Y = (yglob - sensorCenter) / (yglob - sensorCenter).norm(); diff --git a/offline/packages/trackreco/ActsAlignmentStates.h b/offline/packages/trackreco/ActsAlignmentStates.h index caeae77a00..9d891c906d 100644 --- a/offline/packages/trackreco/ActsAlignmentStates.h +++ b/offline/packages/trackreco/ActsAlignmentStates.h @@ -33,7 +33,7 @@ class ActsAlignmentStates explicit ActsAlignmentStates() = default; void fillAlignmentStateMap(const ActsTrackFittingAlgorithm::TrackContainer& tracks, - const std::vector& tips, + const std::vector& tips, SvtxTrack* track, const ActsTrackFittingAlgorithm::MeasurementContainer& measurements); diff --git a/offline/packages/trackreco/ActsEvaluator.cc b/offline/packages/trackreco/ActsEvaluator.cc index 9ecdbf2b7a..9edb4a441a 100644 --- a/offline/packages/trackreco/ActsEvaluator.cc +++ b/offline/packages/trackreco/ActsEvaluator.cc @@ -83,7 +83,7 @@ void ActsEvaluator::next_event(PHCompositeNode* topNode) } void ActsEvaluator::process_track(const ActsTrackFittingAlgorithm::TrackContainer& tracks, - std::vector& trackTips, + std::vector& trackTips, Trajectory::IndexedParameters& paramsMap, SvtxTrack* track, const TrackSeed* seed, @@ -105,7 +105,7 @@ void ActsEvaluator::process_track(const ActsTrackFittingAlgorithm::TrackContaine } void ActsEvaluator::evaluateTrackFit(const ActsTrackFittingAlgorithm::TrackContainer& tracks, - std::vector& trackTips, + std::vector& trackTips, Trajectory::IndexedParameters& paramsMap, SvtxTrack* track, const TrackSeed* seed, @@ -238,7 +238,7 @@ void ActsEvaluator::End() m_trackFile->Close(); } -void ActsEvaluator::visitTrackStates(const Acts::ConstVectorMultiTrajectory& traj, +void ActsEvaluator::visitTrackStates(const Acts::VectorMultiTrajectory& traj, const size_t& trackTip, const ActsTrackFittingAlgorithm::MeasurementContainer& measurements) { @@ -251,7 +251,7 @@ void ActsEvaluator::visitTrackStates(const Acts::ConstVectorMultiTrajectory& tra { /// Only fill the track states with non-outlier measurement auto typeFlags = state.typeFlags(); - if (! typeFlags.test(Acts::TrackStateFlag::MeasurementFlag)) + if (! typeFlags.isMeasurement()) { return true; } @@ -276,10 +276,9 @@ void ActsEvaluator::visitTrackStates(const Acts::ConstVectorMultiTrajectory& tra Acts::Vector2 local = Acts::Vector2::Zero(); /// get the local measurement that acts used - std::visit([&](const auto& meas) { - local(0) = meas.parameters()[0]; - local(1) = meas.parameters()[1]; - }, measurements[sourceLink.index()]); + const auto measurement = measurements.getMeasurement(sourceLink.index()); + local(0) = measurement.parameters()[0]; + local(1) = measurement.parameters()[1]; /// Get global position /// This is an arbitrary vector. Doesn't matter in coordinate transformation @@ -396,7 +395,8 @@ void ActsEvaluator::visitTrackStates(const Acts::ConstVectorMultiTrajectory& tra auto covariance = state.predictedCovariance(); /// Local hit residual info - auto H = state.effectiveProjector(); + const auto H = state.projectorSubspaceHelper().fullProjector().topLeftCorner( + state.calibratedSize(), Acts::eBoundSize); auto resCov = cov + H * covariance * H.transpose(); auto residual = state.effectiveCalibrated() - H * parameters; m_res_x_hit.push_back(residual(Acts::eBoundLoc0)); @@ -907,7 +907,7 @@ void ActsEvaluator::fillProtoTrack(const TrackSeed* seed) } else { - Acts::Vector3 loct = (*surf).transform(m_tGeometry->geometry().getGeoContext()).inverse() * globalTruthPos; + Acts::Vector3 loct = (*surf).localToGlobalTransform(m_tGeometry->geometry().getGeoContext()).inverse() * globalTruthPos; m_t_SL_lx.push_back(loct(0)); m_t_SL_ly.push_back(loct(1)); diff --git a/offline/packages/trackreco/ActsEvaluator.h b/offline/packages/trackreco/ActsEvaluator.h index fda1e1ebb8..fae0515049 100644 --- a/offline/packages/trackreco/ActsEvaluator.h +++ b/offline/packages/trackreco/ActsEvaluator.h @@ -9,7 +9,7 @@ #include #include - +#include #include class TTree; @@ -31,7 +31,6 @@ class TrackSeedContainer; using SourceLink = ActsSourceLink; using Trajectory = ActsExamples::Trajectories; -using Measurement = Acts::Measurement; using Acts::VectorHelpers::eta; using Acts::VectorHelpers::perp; using Acts::VectorHelpers::phi; @@ -52,7 +51,7 @@ class ActsEvaluator void Init(PHCompositeNode* topNode); void process_track(const ActsTrackFittingAlgorithm::TrackContainer& tracks, - std::vector& trackTips, + std::vector& trackTips, Trajectory::IndexedParameters& paramsMap, SvtxTrack* track, const TrackSeed* seed, @@ -65,7 +64,7 @@ class ActsEvaluator /// Function to evaluate Trajectories fit results from the KF void evaluateTrackFit(const ActsTrackFittingAlgorithm::TrackContainer& trackContainer, - std::vector& trackTips, + std::vector& trackTips, Trajectory::IndexedParameters& paramsMap, SvtxTrack* track, const TrackSeed* seed, @@ -83,7 +82,7 @@ class ActsEvaluator void fillFittedTrackParams(const Trajectory::IndexedParameters& paramsMap, const size_t& trackTip); - void visitTrackStates(const Acts::ConstVectorMultiTrajectory& traj, + void visitTrackStates(const Acts::VectorMultiTrajectory& traj, const size_t& trackTip, const ActsTrackFittingAlgorithm::MeasurementContainer& measurements); diff --git a/offline/packages/trackreco/ActsPropagator.cc b/offline/packages/trackreco/ActsPropagator.cc index 2578f05e61..6170edb2a6 100644 --- a/offline/packages/trackreco/ActsPropagator.cc +++ b/offline/packages/trackreco/ActsPropagator.cc @@ -48,12 +48,12 @@ ActsPropagator::makeTrackParams(SvtxTrackState* state, Acts::BoundSquareMatrix cov = transformer.rotateSvtxTrackCovToActs(state); return ActsTrackFittingAlgorithm::TrackParameters::create( - surf, // NOLINT (performance-unnecessary-value-param) - m_geometry->geometry().getGeoContext(), - actsFourPos, momentum, - trackCharge / momentum.norm(), - cov, - Acts::ParticleHypothesis::pion()); + m_geometry->geometry().getGeoContext(), + surf, // NOLINT (performance-unnecessary-value-param) + actsFourPos, momentum, + trackCharge / momentum.norm(), + cov, + Acts::ParticleHypothesis::pion()); } ActsPropagator::BoundTrackParamResult ActsPropagator::makeTrackParams(SvtxTrack* track, @@ -85,13 +85,13 @@ ActsPropagator::makeTrackParams(SvtxTrack* track, Acts::BoundSquareMatrix cov = transformer.rotateSvtxTrackCovToActs(track); - return ActsTrackFittingAlgorithm::TrackParameters::create(perigee, - m_geometry->geometry().getGeoContext(), - actsFourPos, momentum, - track->get_charge() / track->get_p(), - cov, - Acts::ParticleHypothesis::pion(), - 1*Acts::UnitConstants::cm); + return ActsTrackFittingAlgorithm::TrackParameters::create( + m_geometry->geometry().getGeoContext(), perigee, + actsFourPos, momentum, + track->get_charge() / track->get_p(), + cov, + Acts::ParticleHypothesis::pion(), + 1 * Acts::UnitConstants::cm); } ActsPropagator::BTPPairResult @@ -112,15 +112,14 @@ ActsPropagator::propagateTrack(const Acts::BoundTrackParameters& params, auto propagator = makePropagator(); - using Actors = Acts::ActionList<>; - using Aborters = Acts::AbortList; - - Acts::PropagatorOptions options( + SphenixPropagatorOptions options( m_geometry->geometry().getGeoContext(), m_geometry->geometry().magFieldContext); + ActsAborter aborter; + aborter.abortlayer = actslayer; + aborter.abortvolume = actsvolume; + options.actorList.append(aborter); - options.abortList.get().abortlayer = actslayer; - options.abortList.get().abortvolume = actsvolume; auto result = propagator.propagate(params, options); @@ -147,7 +146,7 @@ ActsPropagator::propagateTrack(const Acts::BoundTrackParameters& params, auto propagator = makePropagator(); - Acts::PropagatorOptions<> options(m_geometry->geometry().getGeoContext(), + SphenixPropagator::Options> options(m_geometry->geometry().getGeoContext(), m_geometry->geometry().magFieldContext); auto result = propagator.propagate(params, *surface, @@ -175,9 +174,9 @@ ActsPropagator::propagateTrackFast(const Acts::BoundTrackParameters& params, } auto propagator = makeFastPropagator(); - - Acts::PropagatorOptions<> options(m_geometry->geometry().getGeoContext(), - m_geometry->geometry().magFieldContext); + using Propagator = Acts::Propagator; + Propagator::Options> options(m_geometry->geometry().getGeoContext(), + m_geometry->geometry().magFieldContext); auto result = propagator.propagate(params, *surface, options); @@ -232,7 +231,7 @@ ActsPropagator::SphenixPropagator ActsPropagator::makePropagator() } auto trackingGeometry = m_geometry->geometry().tGeometry; - Stepper stepper(field, m_overstepLimit); + Stepper stepper(field); Acts::Navigator::Config cfg{trackingGeometry}; cfg.resolvePassive = false; cfg.resolveMaterial = true; diff --git a/offline/packages/trackreco/ActsPropagator.h b/offline/packages/trackreco/ActsPropagator.h index 95a4655f81..164145156b 100644 --- a/offline/packages/trackreco/ActsPropagator.h +++ b/offline/packages/trackreco/ActsPropagator.h @@ -38,7 +38,9 @@ class ActsPropagator using Stepper = Acts::EigenStepper<>; using FastPropagator = Acts::Propagator; using SphenixPropagator = Acts::Propagator; - + using Actors = Acts::ActorList<>; + using SphenixPropagatorOptions = SphenixPropagator::Options; + ActsPropagator() {} ActsPropagator(ActsGeometry* geometry) : m_geometry(geometry) diff --git a/offline/packages/trackreco/MakeActsGeometry.cc b/offline/packages/trackreco/MakeActsGeometry.cc index 07f3dbe71c..0afea11b6c 100644 --- a/offline/packages/trackreco/MakeActsGeometry.cc +++ b/offline/packages/trackreco/MakeActsGeometry.cc @@ -14,6 +14,7 @@ #include #include #include +#include #include @@ -59,24 +60,25 @@ #include #include #include +#include #include #include +#include +#include + #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" #pragma GCC diagnostic ignored "-Wuninitialized" #include #pragma GCC diagnostic pop -#include #include #include #include -#include -#include #include #include @@ -297,19 +299,18 @@ int MakeActsGeometry::InitRun(PHCompositeNode *topNode) m_actsGeometry->set_tpc_tzero(m_tpc_tzero); m_actsGeometry->set_sampa_tzero_bias(m_sampa_tzero_bias); // alignment_transformation.useInttSurveyGeometry(m_inttSurvey); + if (Verbosity() > 1) { alignment_transformation.verbosity(); } alignment_transformation.createMap(topNode); - for (auto &[layer, factor] : m_misalignmentFactor) { alignment_transformation.misalignmentFactor(layer, factor); } - // print - if (Verbosity()) + if (Verbosity() > 3) { for (const auto &id : surfMaps.m_tpcVolumeIds) { @@ -664,7 +665,7 @@ void MakeActsGeometry::buildActsSurfaces() // acts/Examples/Run/Common/src/GeometryExampleBase::ProcessGeometry() in MakeActsGeometry() // so we get access to the results. The layer builder magically gets the TGeoManager - makeGeometry(argstr.size(), argv, m_detector); + makeGeometry(argstr.size(), argv, responseFile, materialFile); for (size_t i = 0; i < argstr.size(); ++i) { @@ -707,115 +708,59 @@ void MakeActsGeometry::setMaterialResponseFile(std::string &responseFile, return; } -void MakeActsGeometry::makeGeometry(int argc, char *argv[], - ActsExamples::TGeoDetectorWithOptions &detector) +void MakeActsGeometry::makeGeometry(int argc, char *argv[], const std::string& responseFile, const std::string& materialFile) { + // setup and parse options boost::program_options::options_description desc; ActsExamples::Options::addGeometryOptions(desc); ActsExamples::Options::addMaterialOptions(desc); ActsExamples::Options::addMagneticFieldOptions(desc); - // Add specific options for this geometry - detector.addOptions(desc); - auto vm = ActsExamples::Options::parse(desc, argc, argv); - - // The geometry, material and decoration - auto geometry = build(vm, detector); - // Geometry is a pair of (tgeoTrackingGeometry, tgeoContextDecorators) - - m_tGeometry = geometry.first; - if (m_useField) - { - m_magneticField = ActsExamples::Options::readMagneticField(vm); - } - else - { - m_magneticField = nullptr; - } - - m_geoCtxt = Acts::GeometryContext(); - - unpackVolumes(); - - return; -} - -std::pair, - std::vector>> -MakeActsGeometry::build(const boost::program_options::variables_map &vm, - ActsExamples::TGeoDetectorWithOptions &detector) -{ - // Material decoration - std::shared_ptr matDeco = nullptr; + ActsExamples::TGeoDetector::Config config; + config.surfaceLogLevel = Acts::Logging::FATAL; + config.layerLogLevel = Acts::Logging::FATAL; + config.volumeLogLevel = Acts::Logging::FATAL; + config.logLevel = Acts::Logging::FATAL; + config.detectorElementFactory = sPHENIXElementFactory; + config.readJson(responseFile); - // Retrieve the filename - auto fileName = vm["mat-input-file"].template as(); - // json or root based decorator - if (fileName.find(".json") != std::string::npos || - fileName.find(".cbor") != std::string::npos) + std::shared_ptr matDeco = nullptr; + if (materialFile.find(".json") != std::string::npos || + materialFile.find(".cbor") != std::string::npos) { // Set up the converter first Acts::MaterialMapJsonConverter::Config jsonGeoConvConfig; // Set up the json-based decorator - matDeco = std::make_shared( - jsonGeoConvConfig, fileName, Acts::Logging::FATAL); + matDeco = std::make_shared( + jsonGeoConvConfig, materialFile, Acts::Logging::FATAL); } else { - matDeco = std::make_shared(); + matDeco = std::make_shared(); } + config.materialDecorator = matDeco; + // this does the building now. The TGeoDetector owns the + // tracking geometry + m_TGeoDetector = std::make_unique(config); - ActsExamples::TGeoDetector::Config config; - - config.elementFactory = sPHENIXElementFactory; - - config.fileName = vm["geo-tgeo-filename"].as(); - - config.surfaceLogLevel = Acts::Logging::FATAL; - config.layerLogLevel = Acts::Logging::FATAL; - config.volumeLogLevel = Acts::Logging::FATAL; - - const auto path = vm["geo-tgeo-jsonconfig"].template as(); - - readTGeoLayerBuilderConfigsFile(path, config); - - // Return the geometry and context decorators - return detector.m_detector.finalize(config, matDeco); -} + // Add specific options for this geometry + m_TGeoDetector->addOptions(desc); + auto vm = ActsExamples::Options::parse(desc, argc, argv); -void MakeActsGeometry::readTGeoLayerBuilderConfigsFile(const std::string &path, - ActsExamples::TGeoDetector::Config &config) -{ - if (path.empty()) + m_tGeometry = m_TGeoDetector->m_detector.trackingGeometry(); + if (m_useField) { - std::cout << "There is no acts geometry response file loaded. Cannot build, exiting" - << std::endl; - exit(1); + m_magneticField = ActsExamples::Options::readMagneticField(vm); } - - nlohmann::json djson; - std::ifstream infile(path, std::ifstream::in | std::ifstream::binary); - infile >> djson; - - config.unitScalor = djson["geo-tgeo-unit-scalor"]; - - config.buildBeamPipe = djson["geo-tgeo-build-beampipe"]; - if (config.buildBeamPipe) + else { - const auto beamPipeParameters = - djson["geo-tgeo-beampipe-parameters"].get>(); - config.beamPipeRadius = beamPipeParameters[0]; - config.beamPipeHalflengthZ = beamPipeParameters[1]; - config.beamPipeLayerThickness = beamPipeParameters[2]; + m_magneticField = nullptr; } - // Fill nested volume configs - for (const auto &volume : djson["Volumes"]) - { - auto &vol = config.volumes.emplace_back(); - vol = volume; - } + unpackVolumes(); + + return; } void MakeActsGeometry::unpackVolumes() @@ -1082,7 +1027,7 @@ void MakeActsGeometry::makeInttMapPairs(TrackingVolumePtr &inttVolume) TrkrDefs::hitsetkey hitsetkey = getInttHitSetKeyFromCoords(layer, world_center); // Add this surface to the map - std::pair tmp = make_pair(hitsetkey, surf); + std::pair tmp = std::make_pair(hitsetkey, surf); m_clusterSurfaceMapSilicon.insert(tmp); if (Verbosity() > 10) @@ -1098,14 +1043,14 @@ void MakeActsGeometry::makeInttMapPairs(TrackingVolumePtr &inttVolume) std::cout << std::endl << " Layer type " << assoc_layer->layerType() << std::endl; - auto assoc_det_element = surf->associatedDetectorElement(); + auto assoc_det_element = surf->surfacePlacement(); if (assoc_det_element != nullptr) { std::cout << " Associated detElement has non-null pointer " << assoc_det_element << std::endl; std::cout << std::endl << " Associated detElement found, thickness = " - << assoc_det_element->thickness() << std::endl; + << surf->thickness() << std::endl; } else { @@ -1171,10 +1116,10 @@ void MakeActsGeometry::makeMvtxMapPairs(TrackingVolumePtr &mvtxVolume) std::cout << "[DEBUG] MVTX surface center: (x,y,z)=(" << world_center[0] << "," << world_center[1] << "," << world_center[2] << "), layer_rad=" << layer_rad << std::endl; } - auto detelement = surf->associatedDetectorElement(); + auto detelement = surf->surfacePlacement(); if(!detelement) { - std::cout << PHWHERE << " Did not find associatedDetectorElement, have to quit! " << std::endl; + std::cout << PHWHERE << " Did not find surfacePlacement, have to quit! " << std::endl; exit(1); } @@ -1219,7 +1164,7 @@ void MakeActsGeometry::makeMvtxMapPairs(TrackingVolumePtr &mvtxVolume) } // Add this surface to the map - std::pair tmp = make_pair(hitsetkey, surf); + std::pair tmp = std::make_pair(hitsetkey, surf); m_clusterSurfaceMapSilicon.insert(tmp); if (Verbosity() > 10) @@ -1244,14 +1189,14 @@ void MakeActsGeometry::makeMvtxMapPairs(TrackingVolumePtr &mvtxVolume) << " Layer type " << assoc_layer->layerType() << std::endl; - auto assoc_det_element = surf->associatedDetectorElement(); + auto assoc_det_element = surf->surfacePlacement(); if (assoc_det_element != nullptr) { std::cout << " Associated detElement has non-null pointer " << assoc_det_element << std::endl; std::cout << std::endl << " Associated detElement found, thickness = " - << assoc_det_element->thickness() << std::endl; + << surf->thickness() << std::endl; } else { diff --git a/offline/packages/trackreco/MakeActsGeometry.h b/offline/packages/trackreco/MakeActsGeometry.h index f437236131..272182b713 100644 --- a/offline/packages/trackreco/MakeActsGeometry.h +++ b/offline/packages/trackreco/MakeActsGeometry.h @@ -41,7 +41,7 @@ class TGeoVolume; namespace Acts { class Surface; -} +} // namespace Acts using Surface = std::shared_ptr; using TrackingGeometry = std::shared_ptr; @@ -174,16 +174,7 @@ class MakeActsGeometry : public SubsysReco void buildActsSurfaces(); /// Function that mimics ActsExamples::GeometryExampleBase - void makeGeometry(int argc, char *argv[], - ActsExamples::TGeoDetectorWithOptions &detector); -#ifndef __CLING__ - std::pair, - std::vector>> - build(const boost::program_options::variables_map &vm, - ActsExamples::TGeoDetectorWithOptions &detector); -#endif - void readTGeoLayerBuilderConfigsFile(const std::string &path, - ActsExamples::TGeoDetector::Config &config); + void makeGeometry(int argc, char *argv[], const std::string& responseFile, const std::string& materialFile); void setMaterialResponseFile(std::string &responseFile, std::string &materialFile); @@ -216,6 +207,7 @@ class MakeActsGeometry : public SubsysReco // void makeTGeoNodeMap(PHCompositeNode *topNode); void unpackVolumes(); + std::unique_ptr m_TGeoDetector = nullptr; /// Subdetector geometry containers for getting layer information PHG4CylinderGeomContainer *m_geomContainerMvtx = nullptr; @@ -273,13 +265,10 @@ class MakeActsGeometry : public SubsysReco /// z does not need spacing as the boxes are rotated around the z axis const double half_width_clearance_z = 0.5; - /// The acts geometry object - ActsExamples::TGeoDetectorWithOptions m_detector; - /// Acts geometry objects that are needed to create (for example) the fitter TrackingGeometry m_tGeometry; std::shared_ptr m_magneticField; - Acts::GeometryContext m_geoCtxt; + Acts::GeometryContext m_geoCtxt = Acts::GeometryContext::dangerouslyDefaultConstruct(); /// Structs to put on the node tree which carry around ActsGeom info ActsGeometry *m_actsGeometry = nullptr; diff --git a/offline/packages/trackreco/MakeSourceLinks.cc b/offline/packages/trackreco/MakeSourceLinks.cc index f9038d182e..f2975ac952 100644 --- a/offline/packages/trackreco/MakeSourceLinks.cc +++ b/offline/packages/trackreco/MakeSourceLinks.cc @@ -23,6 +23,8 @@ #include #include +#include + #include #include @@ -166,8 +168,7 @@ SourceLinkVec MakeSourceLinks::getSourceLinks( auto* check_cluster = clusterContainer->findCluster(key); Acts::Vector2 check_local2d = tGeometry->getLocalCoords(key, check_cluster) * Acts::UnitConstants::cm; // need mm Acts::Vector3 check_local3d(check_local2d(0), check_local2d(1), 0); - Acts::GeometryContext temp_transient_geocontext; - temp_transient_geocontext = transformMapTransient; + Acts::GeometryContext temp_transient_geocontext{transformMapTransient}; Acts::Vector3 check_before_pos_surf = this_surf->localToGlobal(temp_transient_geocontext, check_local2d, Acts::Vector3(1, 1, 1)); @@ -207,8 +208,7 @@ SourceLinkVec MakeSourceLinks::getSourceLinks( } // end loop over clusters here - Acts::GeometryContext transient_geocontext; - transient_geocontext = transformMapTransient; + Acts::GeometryContext transient_geocontext{transformMapTransient}; // loop over cluster_vec and make source links for (auto& cluskey : cluster_vec) @@ -257,7 +257,7 @@ SourceLinkVec MakeSourceLinks::getSourceLinks( SourceLink sl(surf->geometryId(), index, cluskey); Acts::SourceLink actsSL{sl}; - Acts::Measurement meas(actsSL, indices, loc, cov); + measurements.emplaceMeasurement<2>(surf->geometryId(), indices, loc, cov); if (m_verbosity > 3) { unsigned int this_layer = TrkrDefs::getLayer(cluskey); @@ -268,10 +268,10 @@ SourceLinkVec MakeSourceLinks::getSourceLinks( << ", cov : " << cov.transpose() << std::endl << " geo id " << sl.geometryId() << std::endl; std::cout << "Surface original transform: " << std::endl; - surf.get()->toStream(tGeometry->geometry().getGeoContext(), std::cout); + surf.get()->toStream(tGeometry->geometry().getGeoContext()); std::cout << std::endl << "Surface transient transform: " << std::endl; - surf.get()->toStream(transient_geocontext, std::cout); + surf.get()->toStream(transient_geocontext); std::cout << std::endl; std::cout << "Corrected surface transform:" << std::endl; std::cout << transformMapTransient->getTransform(surf->geometryId()).matrix() << std::endl; @@ -284,7 +284,6 @@ SourceLinkVec MakeSourceLinks::getSourceLinks( } sourcelinks.push_back(actsSL); - measurements.emplace_back(meas); } SLTrackTimer.stop(); @@ -502,7 +501,7 @@ SourceLinkVec MakeSourceLinks::getSourceLinksClusterMover( /// otherwise take the manual calculation for the TPC // doing it this way just avoids the bounds check that occurs in the surface class method - Acts::Vector3 loct = surf->transform(tGeometry->geometry().getGeoContext()).inverse() * global; // global is in mm + Acts::Vector3 loct = surf->localToGlobalTransform(tGeometry->geometry().getGeoContext()).inverse() * global; // global is in mm loct /= Acts::UnitConstants::cm; localPos(0) = loct(0); @@ -544,7 +543,7 @@ SourceLinkVec MakeSourceLinks::getSourceLinksClusterMover( SourceLink sl(surf->geometryId(), index, cluskey); Acts::SourceLink actsSL{sl}; - Acts::Measurement meas(actsSL, indices, loc, cov); + measurements.emplaceMeasurement<2>(surf->geometryId(), indices, loc, cov); if (m_verbosity > 3) { std::cout << "MakeSourceLinks::getSourceLinksClusterMover - source link " << sl.index() << ", loc : " @@ -552,7 +551,7 @@ SourceLinkVec MakeSourceLinks::getSourceLinksClusterMover( << ", cov : " << cov.transpose() << std::endl << " geo id " << sl.geometryId() << std::endl; std::cout << "Surface : " << std::endl; - surf.get()->toStream(tGeometry->geometry().getGeoContext(), std::cout); + surf.get()->toStream(tGeometry->geometry().getGeoContext()); std::cout << std::endl; std::cout << "Cluster error " << cluster->getRPhiError() << " , " << cluster->getZError() << std::endl; std::cout << "For key " << cluskey << " with local pos " << std::endl @@ -561,7 +560,6 @@ SourceLinkVec MakeSourceLinks::getSourceLinksClusterMover( } sourcelinks.push_back(actsSL); - measurements.emplace_back(meas); } SLTrackTimer.stop(); diff --git a/offline/packages/trackreco/MakeSourceLinks.h b/offline/packages/trackreco/MakeSourceLinks.h index d22acc4881..7cabf268dc 100644 --- a/offline/packages/trackreco/MakeSourceLinks.h +++ b/offline/packages/trackreco/MakeSourceLinks.h @@ -74,6 +74,7 @@ class MakeSourceLinks short int crossing); private: + int m_verbosity = 0; bool m_pp_mode = false; std::set m_ignoreLayer; diff --git a/offline/packages/trackreco/Makefile.am b/offline/packages/trackreco/Makefile.am index 3b70c0e270..74626f2c60 100644 --- a/offline/packages/trackreco/Makefile.am +++ b/offline/packages/trackreco/Makefile.am @@ -34,7 +34,6 @@ pkginclude_HEADERS = \ MakeActsGeometry.h \ MakeSourceLinks.h \ nanoflann.hpp \ - PHActsGSF.h \ PHActsKDTreeSeeding.h \ PHActsSiliconSeeding.h \ PHActsVertexPropagator.h \ @@ -101,7 +100,6 @@ ACTS_SOURCES = \ ActsPropagator.cc \ MakeActsGeometry.cc \ MakeSourceLinks.cc \ - PHActsGSF.cc \ PHActsKDTreeSeeding.cc \ PHActsSiliconSeeding.cc \ PHActsTrkFitter.cc \ @@ -119,7 +117,7 @@ AM_CPPFLAGS += -I$(OFFLINE_MAIN)/include/ActsFatras ACTS_LIBS = \ -lActsCore \ - -lActsPluginTGeo \ + -lActsPluginRoot \ -lActsExamplesDetectorTGeo \ -lActsExamplesFramework @@ -174,7 +172,6 @@ libtrack_reco_la_SOURCES = \ libtrack_reco_la_LIBADD = \ -lActsCore \ - -lActsPluginTGeo \ -lActsExamplesDetectorTGeo \ -lActsExamplesFramework \ -lcalo_io \ diff --git a/offline/packages/trackreco/PHActsGSF.cc b/offline/packages/trackreco/PHActsGSF.cc index 4d75b257dd..6523e87beb 100644 --- a/offline/packages/trackreco/PHActsGSF.cc +++ b/offline/packages/trackreco/PHActsGSF.cc @@ -102,7 +102,7 @@ int PHActsGSF::InitRun(PHCompositeNode* topNode) m_tGeometry->geometry().magField, bha, 12, 1e-4, - MixtureReductionAlgorithm::KLDistance, false, false); + MixtureReductionAlgorithm::KLDistance, false, false,100.); if (m_actsEvaluator) { @@ -233,7 +233,7 @@ int PHActsGSF::process_event(PHCompositeNode* topNode) auto magcontext = m_tGeometry->geometry().magFieldContext; auto calcontext = m_tGeometry->geometry().calibContext; - auto ppoptions = Acts::PropagatorPlainOptions(); + auto ppoptions = Acts::PropagatorPlainOptions(m_transient_geocontext, magcontext); ActsTrackFittingAlgorithm::GeneralFitterOptions options{ m_transient_geocontext, @@ -294,8 +294,8 @@ ActsTrackFittingAlgorithm::TrackParameters PHActsGSF::makeSeed(SvtxTrack* track, ActsTransformations transformer; auto cov = transformer.rotateSvtxTrackCovToActs(track); - return ActsTrackFittingAlgorithm::TrackParameters::create(psurf, - m_tGeometry->geometry().getGeoContext(), + return ActsTrackFittingAlgorithm::TrackParameters::create(m_tGeometry->geometry().getGeoContext(), + psurf, fourpos, momentum, charge / momentum.norm(), diff --git a/offline/packages/trackreco/PHActsGSF.h b/offline/packages/trackreco/PHActsGSF.h index ce5bea1749..0a1561675a 100644 --- a/offline/packages/trackreco/PHActsGSF.h +++ b/offline/packages/trackreco/PHActsGSF.h @@ -37,7 +37,6 @@ class SvtxTrack; using SourceLink = ActsSourceLink; using FitResult = ActsTrackFittingAlgorithm::TrackFitterResult; using Trajectory = ActsExamples::Trajectories; -using Measurement = Acts::Measurement; using SurfacePtrVec = std::vector; using SourceLinkVec = std::vector; diff --git a/offline/packages/trackreco/PHActsKDTreeSeeding.cc b/offline/packages/trackreco/PHActsKDTreeSeeding.cc index 3bd70410d9..6914a0e60f 100644 --- a/offline/packages/trackreco/PHActsKDTreeSeeding.cc +++ b/offline/packages/trackreco/PHActsKDTreeSeeding.cc @@ -15,8 +15,8 @@ #include #include #include -#include #include +#include #include #include @@ -33,8 +33,7 @@ #include #include -#include -#include +#include #include #include #include @@ -60,7 +59,7 @@ PHActsKDTreeSeeding::PHActsKDTreeSeeding(const std::string& name) { } -//____________________________________________________________________________.. +//______________________ ______________________________________________________.. PHActsKDTreeSeeding::~PHActsKDTreeSeeding() { } @@ -116,23 +115,18 @@ int PHActsKDTreeSeeding::process_event(PHCompositeNode* topNode) SeedContainer PHActsKDTreeSeeding::runSeeder() { - Acts::SeedFinderOrthogonal finder(m_seedFinderConfig); + auto finder = std::make_unique>(m_seedFinderConfig); auto spacePoints = getMvtxSpacePoints(); + Acts::SpacePointContainerConfig spConfig; + Acts::SpacePointContainerOptions spOptions; + spOptions.beamPos = {0, 0}; - std::function< - std::tuple>( - const SpacePoint* sp)> - create_coordinates = [](const SpacePoint* sp) - { - Acts::Vector3 position(sp->x(), sp->y(), sp->z()); - Acts::Vector2 variance(sp->varianceR(), sp->varianceZ()); - return std::make_tuple(position, variance, sp->t()); - }; - + ActsExamples::SpacePointContainer container(spacePoints); + Acts::SpacePointContainer spContainer(spConfig, spOptions, container); /// Call acts seeding algo - SeedContainer seeds = finder.createSeeds(m_seedFinderOptions, - spacePoints, create_coordinates); + auto seeds = finder->createSeeds(m_seedFinderOptions, spContainer); + if (Verbosity() > 1) { std::cout << "Acts::OrthogonalSeeder found " << seeds.size() @@ -148,19 +142,19 @@ void PHActsKDTreeSeeding::fillTrackSeedContainer(SeedContainer& seeds) { auto siseed = std::make_unique(); std::map positions; - - for (auto& spptr : seed.sp()) + const auto& sps = seed.sp(); + for (int spid = 0; spid < 3; spid++) { - auto ckey = spptr->Id(); + auto ckey = sps[spid]->externalSpacePoint()->Id(); siseed->insert_cluster_key(ckey); auto globalPosition = m_tGeometry->getGlobalPosition( ckey, m_clusterMap->findCluster(ckey)); positions.insert(std::make_pair(ckey, globalPosition)); } - - TrackSeedHelper::circleFitByTaubin(siseed.get(),positions, 0, 8); - TrackSeedHelper::lineFit(siseed.get(),positions, 0, 8); + + TrackSeedHelper::circleFitByTaubin(siseed.get(), positions, 0, 8); + TrackSeedHelper::lineFit(siseed.get(), positions, 0, 8); /// Project to INTT and find matches to add to positions findInttMatches(positions, *siseed); @@ -439,7 +433,7 @@ SpacePointPtr PHActsKDTreeSeeding::makeSpacePoint(const Surface& surf, * uncertainties by a tuned factor that gives the v17 performance * Track reconstruction is an art as much as it is a science... */ - SpacePointPtr spPtr(new SpacePoint{key, x, y, z, r, surf->geometryId(), var[0] * m_uncfactor, var[1] * m_uncfactor,std::nullopt}); + SpacePointPtr spPtr(new SpacePoint{key, x, y, z, r, surf->geometryId(), var[0] * m_uncfactor, var[1] * m_uncfactor, std::nullopt}); if (Verbosity() > 2) { @@ -537,8 +531,7 @@ void PHActsKDTreeSeeding::configureSeedFinder() filterCfg.maxSeedsPerSpM = m_maxSeedsPerSpM; m_seedFinderConfig.seedFilter = - std::make_unique>( - Acts::SeedFilter(filterCfg)); + std::make_unique>(filterCfg); m_seedFinderConfig.rMax = m_rMax; m_seedFinderConfig.deltaRMinTopSP = m_deltaRMinTopSP; @@ -561,8 +554,4 @@ void PHActsKDTreeSeeding::configureSeedFinder() m_seedFinderConfig.rMinMiddle = m_rMinMiddle; m_seedFinderConfig.rMaxMiddle = m_rMaxMiddle; - m_seedFinderConfig = - m_seedFinderConfig.toInternalUnits().calculateDerivedQuantities(); - m_seedFinderOptions = - m_seedFinderOptions.toInternalUnits().calculateDerivedQuantities(m_seedFinderConfig); } diff --git a/offline/packages/trackreco/PHActsKDTreeSeeding.h b/offline/packages/trackreco/PHActsKDTreeSeeding.h index f4db9e5f1d..b05abeb39d 100644 --- a/offline/packages/trackreco/PHActsKDTreeSeeding.h +++ b/offline/packages/trackreco/PHActsKDTreeSeeding.h @@ -28,87 +28,88 @@ class TrackSeed; class PHActsKDTreeSeeding : public SubsysReco { public: - PHActsKDTreeSeeding(const std::string& name = "PHActsKDTreeSeeding"); - - ~PHActsKDTreeSeeding() override; - - int Init(PHCompositeNode* topNode) override; - int InitRun(PHCompositeNode* topNode) override; - int process_event(PHCompositeNode* topNode) override; - int End(PHCompositeNode* topNode) override; - - void useTruthClusters(bool truth) { m_useTruthClusters = truth; } - - private: - void configureSeedFinder(); - int getNodes(PHCompositeNode* topNode); - int createNodes(PHCompositeNode* topNode); - SeedContainer runSeeder(); - void fillTrackSeedContainer(SeedContainer& seeds); - std::vector getMvtxSpacePoints(); - SpacePointPtr makeSpacePoint(const Surface& surf, - const TrkrDefs::cluskey key, - TrkrCluster* clus); - - /// Projects circle fit to INTT radii to find possible INTT clusters - /// belonging to MVTX track stub - void findInttMatches(std::map& clusters, - TrackSeed& seed); - - void matchInttClusters(std::map& clusters, - const double xProj[], - const double yProj[], - const double zProj[]); - - Acts::SeedFilterConfig m_seedFilterConfig; - Acts::SeedFinderOrthogonalConfig m_seedFinderConfig; - Acts::SeedFinderOptions m_seedFinderOptions; - - /// configured to seed in the MVTX using the middle layer - /// as the seed anchor - /// Defines volume to search for seeds in - float m_rMax = 200. * Acts::UnitConstants::mm; - float m_deltaRMinTopSP = 1. * Acts::UnitConstants::mm; - float m_deltaRMaxTopSP = 20. * Acts::UnitConstants::mm; - float m_deltaRMinBottomSP = 1. * Acts::UnitConstants::mm; - float m_deltaRMaxBottomSP = 20. * Acts::UnitConstants::mm; - float m_collisionRegionMin = -300 * Acts::UnitConstants::mm; - float m_collisionRegionMax = 300 * Acts::UnitConstants::mm; - float m_zMin = -300. * Acts::UnitConstants::mm; - float m_zMax = 300. * Acts::UnitConstants::mm; - - /// max number of seeds a single middle sp can belong to - float m_maxSeedsPerSpM = 1; - float m_cotThetaMax = 2.9; - float m_sigmaScattering = 5; - float m_radLengthPerSeed = 0.05; - float m_minPt = 100.; // MeV - float m_bFieldInZ = 0.0014; // kTesla - float m_beamPosX = 0; - float m_beamPosY = 0; - - /// Maximum transverse PCA allowed - float m_impactMax = 20. * Acts::UnitConstants::mm; - - /// Middle spacepoint must fall between these two radii - float m_rMinMiddle = 28. * Acts::UnitConstants::mm; - float m_rMaxMiddle = 36. * Acts::UnitConstants::mm; - - int m_nIteration = 0; - std::string m_trackMapName = "SiliconTrackSeedContainer"; - bool m_useTruthClusters = false; - - ClusterErrorPara m_clusErrPara; - float m_uncfactor = 3.175; - const static int m_nInttLayers = 4; - float m_nInttLayerRadii[m_nInttLayers] = {0}; - float m_rPhiSearchWin = 0.1; - - PHG4CylinderGeomContainer* m_geomContainerIntt = nullptr; - TrkrClusterIterationMapv1* m_iterationMap = nullptr; - ActsGeometry* m_tGeometry = nullptr; - TrkrClusterContainer* m_clusterMap = nullptr; - TrackSeedContainer* m_seedContainer = nullptr; +using proxy_type = typename Acts::SpacePointContainer>, Acts::detail::RefHolder>::SpacePointProxyType; + PHActsKDTreeSeeding(const std::string& name = "PHActsKDTreeSeeding"); + + ~PHActsKDTreeSeeding() override; + + int Init(PHCompositeNode* topNode) override; + int InitRun(PHCompositeNode* topNode) override; + int process_event(PHCompositeNode* topNode) override; + int End(PHCompositeNode* topNode) override; + + void useTruthClusters(bool truth) { m_useTruthClusters = truth; } + +private: + void configureSeedFinder(); + int getNodes(PHCompositeNode* topNode); + int createNodes(PHCompositeNode* topNode); + SeedContainer runSeeder(); + void fillTrackSeedContainer(SeedContainer& seeds); + std::vector getMvtxSpacePoints(); + SpacePointPtr makeSpacePoint(const Surface& surf, + const TrkrDefs::cluskey key, + TrkrCluster* clus); + + /// Projects circle fit to INTT radii to find possible INTT clusters + /// belonging to MVTX track stub + void findInttMatches(std::map& clusters, + TrackSeed& seed); + + void matchInttClusters(std::map& clusters, + const double xProj[], + const double yProj[], + const double zProj[]); + + Acts::SeedFilterConfig m_seedFilterConfig; + Acts::SeedFinderOrthogonalConfig m_seedFinderConfig; + Acts::SeedFinderOptions m_seedFinderOptions; + + /// configured to seed in the MVTX using the middle layer + /// as the seed anchor + /// Defines volume to search for seeds in + float m_rMax = 200. * Acts::UnitConstants::mm; + float m_deltaRMinTopSP = 1. * Acts::UnitConstants::mm; + float m_deltaRMaxTopSP = 20. * Acts::UnitConstants::mm; + float m_deltaRMinBottomSP = 1. * Acts::UnitConstants::mm; + float m_deltaRMaxBottomSP = 20. * Acts::UnitConstants::mm; + float m_collisionRegionMin = -300 * Acts::UnitConstants::mm; + float m_collisionRegionMax = 300 * Acts::UnitConstants::mm; + float m_zMin = -300. * Acts::UnitConstants::mm; + float m_zMax = 300. * Acts::UnitConstants::mm; + + /// max number of seeds a single middle sp can belong to + float m_maxSeedsPerSpM = 1; + float m_cotThetaMax = 2.9; + float m_sigmaScattering = 5; + float m_radLengthPerSeed = 0.05; + float m_minPt = 100.; // MeV + float m_bFieldInZ = 0.0014; // kTesla + float m_beamPosX = 0; + float m_beamPosY = 0; + + /// Maximum transverse PCA allowed + float m_impactMax = 20. * Acts::UnitConstants::mm; + + /// Middle spacepoint must fall between these two radii + float m_rMinMiddle = 28. * Acts::UnitConstants::mm; + float m_rMaxMiddle = 36. * Acts::UnitConstants::mm; + + int m_nIteration = 0; + std::string m_trackMapName = "SiliconTrackSeedContainer"; + bool m_useTruthClusters = false; + + ClusterErrorPara m_clusErrPara; + float m_uncfactor = 3.175; + const static int m_nInttLayers = 4; + float m_nInttLayerRadii[m_nInttLayers] = {0}; + float m_rPhiSearchWin = 0.1; + + PHG4CylinderGeomContainer* m_geomContainerIntt = nullptr; + TrkrClusterIterationMapv1* m_iterationMap = nullptr; + ActsGeometry* m_tGeometry = nullptr; + TrkrClusterContainer* m_clusterMap = nullptr; + TrackSeedContainer* m_seedContainer = nullptr; }; #endif // PHACTSKDTREESEEDING_H diff --git a/offline/packages/trackreco/PHActsSiliconSeeding.cc b/offline/packages/trackreco/PHActsSiliconSeeding.cc index 8af74c701f..397610cd2a 100644 --- a/offline/packages/trackreco/PHActsSiliconSeeding.cc +++ b/offline/packages/trackreco/PHActsSiliconSeeding.cc @@ -43,9 +43,7 @@ #ifndef __clang__ #pragma GCC diagnostic pop #endif -#include -#include -#include +#include #include #include @@ -86,10 +84,9 @@ PHActsSiliconSeeding::~PHActsSiliconSeeding() int PHActsSiliconSeeding::Init(PHCompositeNode* /*topNode*/) { Acts::SeedFilterConfig sfCfg = configureSeedFilter(); - sfCfg = sfCfg.toInternalUnits(); - m_seedFinderCfg.seedFilter = std::make_unique>( - Acts::SeedFilter(sfCfg)); + m_seedFinderCfg.seedFilter = std::make_unique>( + sfCfg); configureSeeder(); configureSPGrid(); @@ -100,10 +97,10 @@ int PHActsSiliconSeeding::Init(PHCompositeNode* /*topNode*/) } // vector containing the map of z bins in the top and bottom layers - m_bottomBinFinder = std::make_unique>( - nphineighbors, zBinNeighborsBottom); - m_topBinFinder = std::make_unique>( - nphineighbors, zBinNeighborsTop); + m_bottomBinFinder = std::make_unique>( + nphineighbors, zBinNeighborsBottom, 0); + m_topBinFinder = std::make_unique>( + nphineighbors, zBinNeighborsTop, 0); if (m_seedAnalysis) { @@ -196,7 +193,8 @@ int PHActsSiliconSeeding::End(PHCompositeNode* /*topNode*/) void PHActsSiliconSeeding::runSeeder() { - Acts::SeedFinder> seedFinder(m_seedFinderCfg); + Acts::SeedFinder> seedFinder(m_seedFinderCfg); auto eventTimer = std::make_unique("eventTimer"); eventTimer->stop(); @@ -210,20 +208,9 @@ void PHActsSiliconSeeding::runSeeder() std::cout << "Seeding for strobe " << strobe << std::endl; } GridSeeds seedVector; - /// Covariance converter functor needed by seed finder - auto covConverter = [=](const SpacePoint& sp, float zAlign, float rAlign, - float sigmaError) - { - Acts::Vector3 position{sp.x(), sp.y(), sp.z()}; - Acts::Vector2 cov; - cov[0] = (sp.m_varianceR + rAlign * rAlign) * sigmaError; - cov[1] = (sp.m_varianceZ + zAlign * zAlign) * sigmaError; - return std::make_tuple(position, cov, sp.t()); - }; - - Acts::Extent rRangeSPExtent; + eventTimer->restart(); - auto spVec = getSiliconSpacePoints(rRangeSPExtent, strobe); + auto spVec = getSiliconSpacePoints(strobe); eventTimer->stop(); spTime += eventTimer->get_accumulated_time(); if (m_seedAnalysis) @@ -231,37 +218,70 @@ void PHActsSiliconSeeding::runSeeder() h_nInputMeas->Fill(spVec.size()); } - Acts::CylindricalSpacePointGrid grid = - Acts::CylindricalSpacePointGridCreator::createGrid( + Acts::SpacePointContainerConfig spConfig; + spConfig.useDetailedDoubleMeasurementInfo = + m_seedFinderCfg.useDetailedDoubleMeasurementInfo; + // Options + // TODO - check beam pos information + Acts::SpacePointContainerOptions spOptions; + spOptions.beamPos = {0., 0.}; + + // Prepare interface SpacePoint backend-ACTS + ActsExamples::SpacePointContainer container(spVec); + // Prepare Acts API + SpacePointContainerRefHolder + spContainer(spConfig, spOptions, container); + + + + Acts::CylindricalSpacePointGrid grid = + Acts::CylindricalSpacePointGridCreator::createGrid( m_gridCfg, m_gridOptions); - Acts::CylindricalSpacePointGridCreator::fillGrid( + Acts::CylindricalSpacePointGridCreator::fillGrid( m_seedFinderCfg, m_seedFinderOptions, grid, - spVec.begin(), spVec.end(), covConverter, - rRangeSPExtent); + spContainer); + + // Compute radius Range + // we rely on the fact the grid is storing the proxies + // with a sorting in the radius + float minRange = std::numeric_limits::max(); + float maxRange = std::numeric_limits::lowest(); + for (const auto& coll : grid) + { + if (coll.empty()) + { + continue; + } + const auto* firstEl = coll.front(); + const auto* lastEl = coll.back(); + minRange = std::min(firstEl->radius(), minRange); + maxRange = std::max(lastEl->radius(), maxRange); + } - std::array, 2UL> navigation; - navigation[1UL] = m_seedFinderCfg.zBinsCustomLooping; + std::array, 3ul> navigation; + navigation[1ul] = m_seedFinderCfg.zBinsCustomLooping; - auto spacePointsGrouping = Acts::CylindricalBinnedGroup( + auto spacePointsGrouping = Acts::CylindricalBinnedGroup( std::move(grid), *m_bottomBinFinder, *m_topBinFinder, std::move(navigation)); /// variable middle SP radial region of interest const Acts::Range1D rMiddleSPRange( - std::floor(rRangeSPExtent.min(Acts::binR) / 2) * 2 + 1.5, - std::floor(rRangeSPExtent.max(Acts::binR) / 2) * 2 - 1.5); + // TODO check these values in current code with Acts::Extent + std::floor(minRange / 2) * 2 + 1.5, + std::floor(maxRange / 2) * 2 - 1.5); eventTimer->restart(); - SeedContainer seeds; + static thread_local std::vector seeds; seeds.clear(); + decltype(seedFinder)::SeedingState state; - state.spacePointData.resize(spVec.size(), - m_seedFinderCfg.useDetailedDoubleMeasurementInfo); + state.spacePointMutableData.resize(spContainer.size()); for (const auto [bottom, middle, top] : spacePointsGrouping) { seedFinder.createSeedsForGroup(m_seedFinderOptions, state, spacePointsGrouping.grid(), - std::back_inserter(seeds), + seeds, bottom, middle, top, @@ -271,15 +291,13 @@ void PHActsSiliconSeeding::runSeeder() seederTime += eventTimer->get_accumulated_time(); eventTimer->restart(); - seedVector.push_back(seeds); - if (m_streaming) { - makeSvtxTracksWithTime(seedVector, strobe); + makeSvtxTracksWithTime(seeds, strobe); } else { - makeSvtxTracks(seedVector); + makeSvtxTracks(seeds); } eventTimer->stop(); @@ -306,7 +324,7 @@ void PHActsSiliconSeeding::runSeeder() return; } -void PHActsSiliconSeeding::makeSvtxTracksWithTime(const GridSeeds& seedVector, +void PHActsSiliconSeeding::makeSvtxTracksWithTime(const std::vector& seedVector, const int& strobe) { @@ -314,17 +332,8 @@ void PHActsSiliconSeeding::makeSvtxTracksWithTime(const GridSeeds& seedVector, int numGoodSeeds = 0; m_seedid = -1; - for (const auto& seeds : seedVector) + for (const auto& seed : seedVector) { - /// loop over acts triplets - for (const auto& seed : seeds) - { - if (Verbosity() > 1) - { - std::cout << "Seed " << numSeeds << " has " - << seed.sp().size() << " measurements " - << std::endl; - } numSeeds++; if (m_seedAnalysis) { @@ -334,10 +343,10 @@ void PHActsSiliconSeeding::makeSvtxTracksWithTime(const GridSeeds& seedVector, std::map positions; std::vector clus_positions; - - for (const auto& spacePoint : seed.sp()) + const auto& sps = seed.sp(); + for (int spid = 0; spid < 3; spid++) { - const auto& cluskey = spacePoint->Id(); + const auto& cluskey = sps[spid]->externalSpacePoint()->Id(); auto globalPosition = m_tGeometry->getGlobalPosition( cluskey, @@ -380,9 +389,10 @@ void PHActsSiliconSeeding::makeSvtxTracksWithTime(const GridSeeds& seedVector, { // make the svtxtrack seed with both mvtx + intt clusters auto trackSeed = std::make_unique(); - for (const auto& mvtx_clus : seed.sp()) + + for (int spid = 0; spid < 3; spid++) { - const auto& cluskey = mvtx_clus->Id(); + const auto& cluskey = sps[spid]->externalSpacePoint()->Id(); trackSeed->insert_cluster_key(cluskey); } for (auto& intt_clus : intt_clus_vec) @@ -405,9 +415,9 @@ void PHActsSiliconSeeding::makeSvtxTracksWithTime(const GridSeeds& seedVector, { /// make a single mvtx only seed auto trackSeed = std::make_unique(); - for (const auto& mvtx_clus : seed.sp()) + for (int spid = 0; spid < 3; spid++) { - const auto& cluskey = mvtx_clus->Id(); + const auto& cluskey = sps[spid]->externalSpacePoint()->Id(); trackSeed->insert_cluster_key(cluskey); } TrackSeedHelper::circleFitByTaubin(trackSeed.get(), positions, 0, 7); @@ -418,34 +428,22 @@ void PHActsSiliconSeeding::makeSvtxTracksWithTime(const GridSeeds& seedVector, m_seedContainer->insert(trackSeed.get()); numGoodSeeds++; } - } + } if (Verbosity() > 4) { std::cout << "num good seeds : " << numGoodSeeds << std::endl; } } -void PHActsSiliconSeeding::makeSvtxTracks(const GridSeeds& seedVector) +void PHActsSiliconSeeding::makeSvtxTracks(const std::vector& seedVector) { int numSeeds = 0; int numGoodSeeds = 0; m_seedid = -1; - int strobe = m_lowStrobeIndex; - /// Loop over grid volumes. In our case this will be strobe - for (const auto& seeds : seedVector) + for (const auto& seed : seedVector) { - /// Loop over actual seeds in this grid volume - for (const auto& seed : seeds) - { - if (Verbosity() > 1) - { - std::cout << "Seed " << numSeeds << " has " - << seed.sp().size() << " measurements " - << std::endl; - } - - if (m_seedAnalysis) + if (m_seedAnalysis) { clearTreeVariables(); m_seedid++; @@ -458,9 +456,10 @@ void PHActsSiliconSeeding::makeSvtxTracks(const GridSeeds& seedVector) std::map positions; auto trackSeed = std::make_unique(); - for (const auto& spacePoint : seed.sp()) + const auto& sps = seed.sp(); + for (int spid = 0; spid < 3; spid++) { - const auto& cluskey = spacePoint->Id(); + const auto& cluskey = sps[spid]->externalSpacePoint()->Id(); cluster_keys.push_back(cluskey); trackSeed->insert_cluster_key(cluskey); @@ -478,7 +477,7 @@ void PHActsSiliconSeeding::makeSvtxTracks(const GridSeeds& seedVector) if (Verbosity() > 1) { std::cout << "Adding cluster with x,y " - << spacePoint->x() << ", " << spacePoint->y() + << sps[spid]->externalSpacePoint()->x() << ", " << sps[spid]->externalSpacePoint()->y() << " mm in detector " << (unsigned int) TrkrDefs::getTrkrId(cluskey) << " with cluskey " << cluskey @@ -599,12 +598,7 @@ void PHActsSiliconSeeding::makeSvtxTracks(const GridSeeds& seedVector) std::cout << "Intt fit time " << circlefittime << " and svtx time " << svtxtracktime << std::endl; } - } - strobe++; - if (strobe > m_highStrobeIndex) - { - std::cout << PHWHERE << "Error: some how grid seed vector is not the same as the number of strobes" << std::endl; - } + } if (m_seedAnalysis) @@ -962,7 +956,7 @@ std::vector PHActsSiliconSeeding::findMatches( { intersection = TrackFitUtils::get_helix_surface_intersection(surf, dummypars, glob, m_tGeometry); } - auto local = (surf->transform(m_tGeometry->geometry().getGeoContext())).inverse() * (intersection * Acts::UnitConstants::cm); + auto local = (surf->localToGlobalTransform(m_tGeometry->geometry().getGeoContext())).inverse() * (intersection * Acts::UnitConstants::cm); local /= Acts::UnitConstants::cm; m_projgx = intersection.x(); m_projgy = intersection.y(); @@ -1265,7 +1259,7 @@ std::vector> PHActsSiliconSeeding::iterateLayers( auto glob = m_tGeometry->getGlobalPosition( cluskey, cluster); auto intersection = TrackFitUtils::get_helix_surface_intersection(surf, fitpars, glob, m_tGeometry); - auto local = (surf->transform(m_tGeometry->geometry().getGeoContext())).inverse() * (intersection * Acts::UnitConstants::cm); + auto local = (surf->localToGlobalTransform(m_tGeometry->geometry().getGeoContext())).inverse() * (intersection * Acts::UnitConstants::cm); local /= Acts::UnitConstants::cm; m_projgx = intersection.x(); m_projgy = intersection.y(); @@ -1418,8 +1412,7 @@ SpacePointPtr PHActsSiliconSeeding::makeSpacePoint( return spPtr; } -std::vector PHActsSiliconSeeding::getSiliconSpacePoints(Acts::Extent& rRangeSPExtent, - const int strobe) +std::vector PHActsSiliconSeeding::getSiliconSpacePoints(const int strobe) { std::vector spVec; unsigned int numSiliconHits = 0; @@ -1465,7 +1458,6 @@ std::vector PHActsSiliconSeeding::getSiliconSpacePoints(Acts: auto* sp = makeSpacePoint(surface, cluskey, cluster).release(); spVec.push_back(sp); - rRangeSPExtent.extend({sp->x(), sp->y(), sp->z()}); numSiliconHits++; } } @@ -1496,8 +1488,6 @@ void PHActsSiliconSeeding::configureSPGrid() m_gridCfg.phiBinDeflectionCoverage = m_numPhiNeighbors; m_gridOptions.bFieldInZ = m_bField; - m_gridCfg = m_gridCfg.toInternalUnits(); - m_gridOptions = m_gridOptions.toInternalUnits(); } Acts::SeedFilterConfig PHActsSiliconSeeding::configureSeedFilter() const @@ -1551,9 +1541,6 @@ void PHActsSiliconSeeding::configureSeeder() m_seedFinderCfg.sigmaError = m_sigmaError; m_seedFinderCfg.helixCutTolerance = m_helixcut; - m_seedFinderCfg = - m_seedFinderCfg.toInternalUnits().calculateDerivedQuantities(); - m_seedFinderOptions = m_seedFinderOptions.toInternalUnits().calculateDerivedQuantities(m_seedFinderCfg); } int PHActsSiliconSeeding::getNodes(PHCompositeNode* topNode) diff --git a/offline/packages/trackreco/PHActsSiliconSeeding.h b/offline/packages/trackreco/PHActsSiliconSeeding.h index 506f9c225c..09081d088f 100644 --- a/offline/packages/trackreco/PHActsSiliconSeeding.h +++ b/offline/packages/trackreco/PHActsSiliconSeeding.h @@ -14,6 +14,7 @@ #include #include +#include #include #include @@ -33,7 +34,10 @@ class TrkrClusterIterationMap; class TrkrClusterCrossingAssoc; using GridSeeds = std::vector>>; - +using SpacePointContainerRefHolder = Acts::SpacePointContainer; +using SpacePointProxy_type = typename SpacePointContainerRefHolder::SpacePointProxyType; +using value_type = SpacePointContainerRefHolder::SpacePointProxyType; +using seed_type = Acts::Seed; /** * This class runs the Acts seeder over the MVTX measurements * to create track stubs for the rest of the stub matching pattern @@ -212,10 +216,10 @@ class PHActsSiliconSeeding : public SubsysReco Acts::SeedFilterConfig configureSeedFilter() const; /// Take final seeds and fill the TrackSeedContainer - void makeSvtxTracks(const GridSeeds &seedVector); + void makeSvtxTracks(const std::vector& seedVector); /// Take final seeds and fill the TrackSeedContainer - void makeSvtxTracksWithTime(const GridSeeds &seedVector, const int &strobe); + void makeSvtxTracksWithTime(const std::vector& seedVector, const int &strobe); /// Create a seeding space point out of an Acts::SourceLink SpacePointPtr makeSpacePoint( @@ -225,8 +229,7 @@ class PHActsSiliconSeeding : public SubsysReco TrkrCluster *clus); /// Get all space points for the seeder - std::vector getSiliconSpacePoints(Acts::Extent &rRangeSPExtent, - const int strobe); + std::vector getSiliconSpacePoints(const int strobe); void printSeedConfigs(Acts::SeedFilterConfig &sfconfig); bool isTimingMismatched(TrackSeed& seed) const; @@ -288,7 +291,7 @@ class PHActsSiliconSeeding : public SubsysReco int m_lowStrobeIndex = 0; int m_highStrobeIndex = 1; /// Configuration classes for Acts seeding - Acts::SeedFinderConfig m_seedFinderCfg; + Acts::SeedFinderConfig m_seedFinderCfg; Acts::CylindricalSpacePointGridConfig m_gridCfg; Acts::CylindricalSpacePointGridOptions m_gridOptions; Acts::SeedFinderOptions m_seedFinderOptions; @@ -353,8 +356,8 @@ class PHActsSiliconSeeding : public SubsysReco std::vector> zBinNeighborsTop; std::vector> zBinNeighborsBottom; int nphineighbors = 1; - std::unique_ptr> m_bottomBinFinder; - std::unique_ptr> m_topBinFinder; + std::unique_ptr> m_bottomBinFinder; + std::unique_ptr> m_topBinFinder; int m_event = 0; diff --git a/offline/packages/trackreco/PHActsTrkFitter.cc b/offline/packages/trackreco/PHActsTrkFitter.cc index d0006ac25c..1cf72bdfdc 100644 --- a/offline/packages/trackreco/PHActsTrkFitter.cc +++ b/offline/packages/trackreco/PHActsTrkFitter.cc @@ -128,13 +128,12 @@ int PHActsTrkFitter::InitRun(PHCompositeNode* topNode) m_fitCfg.dFit = ActsTrackFittingAlgorithm::makeDirectedKalmanFitterFunction( m_tGeometry->geometry().tGeometry, - m_tGeometry->geometry().magField); + m_tGeometry->geometry().magField, true, true, 0.0, Acts::FreeToBoundCorrection(), *Acts::getDefaultLogger("DirectedKalman", level)); MaterialSurfaceSelector selector; if (m_fitSiliconMMs || m_directNavigation) { m_tGeometry->geometry().tGeometry->visitSurfaces(selector, false); - // std::cout<<"selector.surfaces.size() "<(); CalibratorAdapter calibrator{*calibptr, measurements}; auto magcontext = m_tGeometry->geometry().magFieldContext; auto calibcontext = m_tGeometry->geometry().calibContext; + auto ppPlainOptions = Acts::PropagatorPlainOptions(m_transient_geocontext, magcontext); ActsTrackFittingAlgorithm::GeneralFitterOptions kfOptions{ @@ -736,6 +734,7 @@ void PHActsTrkFitter::loopTracks(Acts::Logging::Level logLevel) if (Verbosity() > 1) { std::cout << "Calling fitTrack for track with siid " << siid << " tpcid " << tpcid << " crossing " << crossing << std::endl; + std::cout << "surfaces size " << surfaces.size() << " and source links size " << sourceLinks.size() << std::endl; } auto result = fitTrack(sourceLinks, seed, kfOptions, surfaces, calibrator, tracks); @@ -869,7 +868,7 @@ bool PHActsTrkFitter::getTrackFitResult( { /// Make a trajectory state for storage, which conforms to Acts track fit /// analysis tool - std::vector trackTips; + std::vector trackTips; trackTips.reserve(1); const auto& outtrack = fitOutput.value(); if (outtrack.hasReferenceSurface()) @@ -928,10 +927,7 @@ bool PHActsTrkFitter::getTrackFitResult( { h_updateTime->Fill(updateTime); } - - Trajectory trajectory(tracks.trackStateContainer(), - trackTips, indexedParams); - + if (m_actsEvaluator) { m_evaluator->evaluateTrackFit(tracks, trackTips, indexedParams, track, @@ -1054,7 +1050,7 @@ void PHActsTrkFitter::checkSurfaceVec(SurfacePtrVec& surfaces) const } void PHActsTrkFitter::updateSvtxTrack( - const std::vector& tips, + const std::vector& tips, const Trajectory::IndexedParameters& paramsMap, const ActsTrackFittingAlgorithm::TrackContainer& tracks, SvtxTrack* track) diff --git a/offline/packages/trackreco/PHActsTrkFitter.h b/offline/packages/trackreco/PHActsTrkFitter.h index 056c3e88b3..3e0ee71132 100644 --- a/offline/packages/trackreco/PHActsTrkFitter.h +++ b/offline/packages/trackreco/PHActsTrkFitter.h @@ -45,7 +45,6 @@ class PHG4TpcGeomContainer; using SourceLink = ActsSourceLink; using FitResult = ActsTrackFittingAlgorithm::TrackFitterResult; using Trajectory = ActsExamples::Trajectories; -using Measurement = Acts::Measurement; using SurfacePtrVec = std::vector; using SourceLinkVec = std::vector; @@ -156,7 +155,7 @@ class PHActsTrkFitter : public SubsysReco /// Convert the acts track fit result to an svtx track void updateSvtxTrack( - const std::vector& tips, + const std::vector& tips, const Trajectory::IndexedParameters& paramsMap, const ActsTrackFittingAlgorithm::TrackContainer& tracks, SvtxTrack* track); @@ -201,7 +200,7 @@ class PHActsTrkFitter : public SubsysReco alignmentTransformationContainer* m_alignmentTransformationMap = nullptr; // added for testing purposes alignmentTransformationContainer* m_alignmentTransformationMapTransient = nullptr; std::set m_transient_id_set; - Acts::GeometryContext m_transient_geocontext; + Acts::GeometryContext m_transient_geocontext = Acts::GeometryContext::dangerouslyDefaultConstruct(); SvtxTrackMap* m_trackMap = nullptr; SvtxTrackMap* m_directedTrackMap = nullptr; TrkrClusterContainer* m_clusterContainer = nullptr; diff --git a/offline/packages/trackreco/PHCosmicsTrkFitter.cc b/offline/packages/trackreco/PHCosmicsTrkFitter.cc index d4664415ad..b4f096ba92 100644 --- a/offline/packages/trackreco/PHCosmicsTrkFitter.cc +++ b/offline/packages/trackreco/PHCosmicsTrkFitter.cc @@ -81,7 +81,6 @@ namespace PHCosmicsTrkFitter::PHCosmicsTrkFitter(const std::string& name) : SubsysReco(name) - , m_trajectories(nullptr) { } @@ -207,8 +206,6 @@ int PHCosmicsTrkFitter::ResetEvent(PHCompositeNode* /*topNode*/) std::cout << "Reset PHCosmicsTrkFitter" << std::endl; } - m_trajectories->clear(); - return Fun4AllReturnCodes::EVENT_OK; } @@ -327,8 +324,9 @@ void PHCosmicsTrkFitter::loopTracks(Acts::Logging::Level logLevel) getCharge(tpcseed, charge, cosmicslope); + Acts::GeometryContext geoContext{m_alignmentTransformationMapTransient}; // copy transient map for this track into transient geoContext - m_transient_geocontext = m_alignmentTransformationMapTransient; + m_transient_geocontext = geoContext; { // get positions from cluster keys @@ -498,8 +496,8 @@ void PHCosmicsTrkFitter::loopTracks(Acts::Logging::Level logLevel) } //! Reset the track seed with the dummy covariance auto seed = ActsTrackFittingAlgorithm::TrackParameters::create( - pSurface, m_transient_geocontext, + pSurface, actsFourPos, momentum, charge / momentum.norm(), @@ -519,13 +517,12 @@ void PHCosmicsTrkFitter::loopTracks(Acts::Logging::Level logLevel) } //! Set host of propagator options for Acts to do e.g. material integration - Acts::PropagatorPlainOptions ppPlainOptions; - auto calibptr = std::make_unique(); CalibratorAdapter calibrator{*calibptr, measurements}; auto magcontext = m_tGeometry->geometry().magFieldContext; auto calibcontext = m_tGeometry->geometry().calibContext; + auto ppPlainOptions = Acts::PropagatorPlainOptions(m_transient_geocontext, magcontext); ActsTrackFittingAlgorithm::GeneralFitterOptions kfOptions{ @@ -585,7 +582,7 @@ bool PHCosmicsTrkFitter::getTrackFitResult(FitResult& fitOutput, /// Make a trajectory state for storage, which conforms to Acts track fit /// analysis tool auto& outtrack = fitOutput.value(); - std::vector trackTips; + std::vector trackTips; trackTips.reserve(1); trackTips.emplace_back(outtrack.tipIndex()); Trajectory::IndexedParameters indexedParams; @@ -608,11 +605,6 @@ bool PHCosmicsTrkFitter::getTrackFitResult(FitResult& fitOutput, std::cout << "For trackTip == " << outtrack.tipIndex() << std::endl; } - Trajectory trajectory(tracks.trackStateContainer(), - trackTips, indexedParams); - - m_trajectories->insert(std::make_pair(track->get_id(), trajectory)); - /// Get position, momentum from the Acts output. Update the values of /// the proto track updateSvtxTrack(trackTips, indexedParams, tracks, track); @@ -646,7 +638,7 @@ inline ActsTrackFittingAlgorithm::TrackFitterResult PHCosmicsTrkFitter::fitTrack } void PHCosmicsTrkFitter::updateSvtxTrack( - std::vector& tips, + std::vector& tips, Trajectory::IndexedParameters& paramsMap, ActsTrackFittingAlgorithm::TrackContainer& tracks, SvtxTrack* track) @@ -793,15 +785,6 @@ int PHCosmicsTrkFitter::createNodes(PHCompositeNode* topNode) dstNode->addNode(svtxNode); } - m_trajectories = findNode::getClass>(topNode, "ActsTrajectories"); - if (!m_trajectories) - { - m_trajectories = new std::map; - auto node = - new PHDataNode>(m_trajectories, "ActsTrajectories"); - svtxNode->addNode(node); - } - m_trackMap = findNode::getClass(topNode, _track_map_name); if (!m_trackMap) @@ -1007,8 +990,7 @@ void PHCosmicsTrkFitter::getCharge( int& charge, float& cosmicslope) { - Acts::GeometryContext transient_geocontext; - transient_geocontext = m_alignmentTransformationMapTransient; // set local/global transforms to distortion corrected ones for this track + Acts::GeometryContext transient_geocontext{m_alignmentTransformationMapTransient}; std::vector global_vec; diff --git a/offline/packages/trackreco/PHCosmicsTrkFitter.h b/offline/packages/trackreco/PHCosmicsTrkFitter.h index 2619cc7dd2..79be4c14f8 100644 --- a/offline/packages/trackreco/PHCosmicsTrkFitter.h +++ b/offline/packages/trackreco/PHCosmicsTrkFitter.h @@ -39,7 +39,6 @@ class TTree; using SourceLink = ActsSourceLink; using FitResult = ActsTrackFittingAlgorithm::TrackFitterResult; using Trajectory = ActsExamples::Trajectories; -using Measurement = Acts::Measurement; using SurfacePtrVec = std::vector; using SourceLinkVec = std::vector; @@ -107,7 +106,7 @@ class PHCosmicsTrkFitter : public SubsysReco void getCharge(TrackSeed* track, int& charge, float& cosmicslope); /// Convert the acts track fit result to an svtx track - void updateSvtxTrack(std::vector& tips, + void updateSvtxTrack(std::vector& tips, Trajectory::IndexedParameters& paramsMap, ActsTrackFittingAlgorithm::TrackContainer& tracks, SvtxTrack* track); @@ -151,7 +150,7 @@ class PHCosmicsTrkFitter : public SubsysReco // Used for distortion correction transformations alignmentTransformationContainer* m_alignmentTransformationMapTransient = nullptr; std::set m_transient_id_set; - Acts::GeometryContext m_transient_geocontext; + Acts::GeometryContext m_transient_geocontext = Acts::GeometryContext::dangerouslyDefaultConstruct(); /// Number of acts fits that returned an error int m_nBadFits = 0; @@ -177,7 +176,6 @@ class PHCosmicsTrkFitter : public SubsysReco std::unique_ptr m_evaluator = nullptr; std::string m_evalname = "ActsEvaluator.root"; - std::map* m_trajectories = nullptr; SvtxTrackMap* m_seedTracks = nullptr; //! tpc global position wrapper diff --git a/offline/packages/trackreco/WeightedFitter.cc b/offline/packages/trackreco/WeightedFitter.cc index 090775a0da..2897b3a337 100644 --- a/offline/packages/trackreco/WeightedFitter.cc +++ b/offline/packages/trackreco/WeightedFitter.cc @@ -390,7 +390,7 @@ WeightedFitter::get_points ( Surface const surf = m_geometry->maps().getSurface(cluster_key, cluster); if (!surf) { continue; } - auto local_to_global_transform = surf->transform(m_geometry->geometry().getGeoContext()); // in mm + auto local_to_global_transform = surf->localToGlobalTransform(m_geometry->geometry().getGeoContext()); // in mm local_to_global_transform.translation() /= Acts::UnitConstants::cm; // converted to cm Eigen::Vector3d local_pos = Eigen::Vector3d { cluster->getLocalX(), cluster->getLocalY(), 0.0 }; // in cm diff --git a/simulation/g4simulation/g4tpc/PHG4TpcPadPlaneReadout.cc b/simulation/g4simulation/g4tpc/PHG4TpcPadPlaneReadout.cc index 6cd968883e..7006241673 100644 --- a/simulation/g4simulation/g4tpc/PHG4TpcPadPlaneReadout.cc +++ b/simulation/g4simulation/g4tpc/PHG4TpcPadPlaneReadout.cc @@ -40,6 +40,7 @@ #include #include // for getenv #include +#include #include #include // for _Rb_tree_cons... #include // for pair diff --git a/simulation/g4simulation/g4tpc/TpcClusterBuilder.cc b/simulation/g4simulation/g4tpc/TpcClusterBuilder.cc index fb6a02ba26..eb39ed8033 100644 --- a/simulation/g4simulation/g4tpc/TpcClusterBuilder.cc +++ b/simulation/g4simulation/g4tpc/TpcClusterBuilder.cc @@ -15,7 +15,7 @@ #include - +#include #include #include // for sqrt, cos, sin #include @@ -351,7 +351,7 @@ void TpcClusterBuilder::cluster_hits(TrkrTruthTrack* track) global *= Acts::UnitConstants::cm; - Acts::Vector3 local = surface->transform(m_tGeometry->geometry().getGeoContext()).inverse() * global; + Acts::Vector3 local = surface->localToGlobalTransform(m_tGeometry->geometry().getGeoContext()).inverse() * global; local /= Acts::UnitConstants::cm; auto* cluster = new TrkrClusterv4; //