Moving to experimental namespace

Core/include/Acts/Seeding/GbtsBase.hpp

@@ -23,23 +23,23 @@ class TrigInDetTriplet {
  public:
   TrigInDetTriplet() = delete;  // to prevent creation w/o initialization
 
-  TrigInDetTriplet(Acts::GbtsSP<space_point_t> s1,
-                   Acts::GbtsSP<space_point_t> s2,
-                   Acts::GbtsSP<space_point_t> s3, float Q)
+  TrigInDetTriplet(Acts::Experimental::GbtsSP<space_point_t> s1,
+                   Acts::Experimental::GbtsSP<space_point_t> s2,
+                   Acts::Experimental::GbtsSP<space_point_t> s3, float Q)
       : m_s1(std::move(s1)), m_s2(std::move(s2)), m_s3(std::move(s3)), m_Q(Q) {}
 
   TrigInDetTriplet(TrigInDetTriplet* t)
       : m_s1(t->m_s1), m_s2(t->m_s2), m_s3(t->m_s3), m_Q(t->m_Q) {}
 
-  const Acts::GbtsSP<space_point_t>& s1() const { return m_s1; }
-  const Acts::GbtsSP<space_point_t>& s2() const { return m_s2; }
-  const Acts::GbtsSP<space_point_t>& s3() const { return m_s3; }
+  const Acts::Experimental::GbtsSP<space_point_t>& s1() const { return m_s1; }
+  const Acts::Experimental::GbtsSP<space_point_t>& s2() const { return m_s2; }
+  const Acts::Experimental::GbtsSP<space_point_t>& s3() const { return m_s3; }
   float Q() const { return m_Q; }
   void Q(double newQ) { m_Q = newQ; }
 
  protected:
-  Acts::GbtsSP<space_point_t> m_s1;
-  Acts::GbtsSP<space_point_t> m_s2;
-  Acts::GbtsSP<space_point_t> m_s3;
+  Acts::Experimental::GbtsSP<space_point_t> m_s1;
+  Acts::Experimental::GbtsSP<space_point_t> m_s2;
+  Acts::Experimental::GbtsSP<space_point_t> m_s3;
   float m_Q;  // Quality
 };

Core/include/Acts/Seeding/GbtsDataStorage.hpp

@@ -18,7 +18,7 @@
 #include <numbers>
 #include <vector>
 
-namespace Acts {
+namespace Acts::Experimental {
 
 constexpr std::size_t MAX_SEG_PER_NODE = 1000;  // was 30
 constexpr std::size_t N_SEG_CONNS = 6;          // was 6
@@ -286,4 +286,4 @@ class GbtsEdge {
   unsigned int m_vNei[N_SEG_CONNS]{};  // global indices of the connected edges
 };
 
-}  // namespace Acts
+}  // namespace Acts::Experimental

Core/include/Acts/Seeding/GbtsGeometry.hpp

@@ -18,7 +18,7 @@
 #include <memory>
 #include <vector>
 
-namespace Acts {
+namespace Acts::Experimental {
 class TrigInDetSiLayer {
  public:
   int m_subdet;  // combined ID
@@ -264,7 +264,7 @@ template <typename space_point_t>
 class GbtsGeometry {
  public:
   GbtsGeometry(const std::vector<TrigInDetSiLayer> &layers,
-               std::unique_ptr<Acts::GbtsConnector> &conn)
+               std::unique_ptr<Acts::Experimental::GbtsConnector> &conn)
 
       : m_connector(std::move(conn)) {
     const float min_z0 = -168.0;
@@ -334,7 +334,7 @@ class GbtsGeometry {
 
   int num_bins() const { return m_nEtaBins; }
 
-  Acts::GbtsConnector *connector() const { return m_connector.get(); }
+  Acts::Experimental::GbtsConnector *connector() const { return m_connector.get(); }
 
  protected:
   const GbtsLayer<space_point_t> *addNewLayer(const TrigInDetSiLayer &l,
@@ -358,7 +358,7 @@ class GbtsGeometry {
 
   int m_nEtaBins{0};
 
-  std::unique_ptr<Acts::GbtsConnector> m_connector;
+  std::unique_ptr<Acts::Experimental::GbtsConnector> m_connector;
 };
 
-}  // namespace Acts
+}  // namespace Acts::Experimental

Core/include/Acts/Seeding/GbtsTrackingFilter.hpp

@@ -33,7 +33,7 @@ struct GbtsEdgeState {
 
   GbtsEdgeState(bool f) : m_initialized(f) {}
 
-  void initialize(Acts::GbtsEdge<external_spacepoint_t>* pS) {
+  void initialize(Acts::Experimental::GbtsEdge<external_spacepoint_t>* pS) {
     m_initialized = true;
 
     m_J = 0.0;
@@ -99,7 +99,7 @@ struct GbtsEdgeState {
 
   float m_J{};
 
-  std::vector<Acts::GbtsEdge<external_spacepoint_t>*> m_vs;
+  std::vector<Acts::Experimental::GbtsEdge<external_spacepoint_t>*> m_vs;
 
   float m_X[3]{}, m_Y[2]{}, m_Cx[3][3]{}, m_Cy[2][2]{};
   float m_refX{}, m_refY{}, m_c{}, m_s{};
@@ -112,14 +112,14 @@ struct GbtsEdgeState {
 template <typename external_spacepoint_t>
 class GbtsTrackingFilter {
  public:
-  GbtsTrackingFilter(const std::vector<Acts::TrigInDetSiLayer>& g,
-                     std::vector<Acts::GbtsEdge<external_spacepoint_t>>& sb,
+  GbtsTrackingFilter(const std::vector<Acts::Experimental::TrigInDetSiLayer>& g,
+                     std::vector<Acts::Experimental::GbtsEdge<external_spacepoint_t>>& sb,
                      std::unique_ptr<const Acts::Logger> logger =
                          Acts::getDefaultLogger("Filter",
                                                 Acts::Logging::Level::INFO))
       : m_geo(g), m_segStore(sb), m_logger(std::move(logger)) {}
 
-  void followTrack(Acts::GbtsEdge<external_spacepoint_t>* pS,
+  void followTrack(Acts::Experimental::GbtsEdge<external_spacepoint_t>* pS,
                    GbtsEdgeState<external_spacepoint_t>& output) {
     if (pS->m_level == -1) {
       return;  // already collected
@@ -153,7 +153,7 @@ class GbtsTrackingFilter {
   }
 
  protected:
-  void propagate(Acts::GbtsEdge<external_spacepoint_t>* pS,
+  void propagate(Acts::Experimental::GbtsEdge<external_spacepoint_t>* pS,
                  GbtsEdgeState<external_spacepoint_t>& ts) {
     if (m_globalStateCounter >= MAX_EDGE_STATE) {
       return;
@@ -173,13 +173,13 @@ class GbtsTrackingFilter {
     }
     int level = pS->m_level;
 
-    std::list<Acts::GbtsEdge<external_spacepoint_t>*> lCont;
+    std::list<Acts::Experimental::GbtsEdge<external_spacepoint_t>*> lCont;
 
     for (int nIdx = 0; nIdx < pS->m_nNei;
          nIdx++) {  // loop over the neighbours of this segment
       unsigned int nextSegmentIdx = pS->m_vNei[nIdx];
 
-      Acts::GbtsEdge<external_spacepoint_t>* pN =
+      Acts::Experimental::GbtsEdge<external_spacepoint_t>* pN =
           &(m_segStore.at(nextSegmentIdx));
 
       if (pN->m_level == -1) {
@@ -210,15 +210,15 @@ class GbtsTrackingFilter {
       }
     } else {  // branching
       int nBranches = 0;
-      for (typename std::list<Acts::GbtsEdge<external_spacepoint_t>*>::iterator
+      for (typename std::list<Acts::Experimental::GbtsEdge<external_spacepoint_t>*>::iterator
                sIt = lCont.begin();
            sIt != lCont.end(); ++sIt, nBranches++) {
         propagate((*sIt), new_ts);  // recursive call
       }
     }
   }
 
-  bool update(Acts::GbtsEdge<external_spacepoint_t>* pS,
+  bool update(Acts::Experimental::GbtsEdge<external_spacepoint_t>* pS,
               GbtsEdgeState<external_spacepoint_t>& ts) {
     const float sigma_t = 0.0003;
     const float sigma_w = 0.00009;
@@ -379,9 +379,9 @@ class GbtsTrackingFilter {
     return m_geo.at(index).m_type;  // needs to be 0, 2, or -2
   }
 
-  const std::vector<Acts::TrigInDetSiLayer>& m_geo;
+  const std::vector<Acts::Experimental::TrigInDetSiLayer>& m_geo;
 
-  std::vector<Acts::GbtsEdge<external_spacepoint_t>>& m_segStore;
+  std::vector<Acts::Experimental::GbtsEdge<external_spacepoint_t>>& m_segStore;
 
   std::vector<GbtsEdgeState<external_spacepoint_t>*> m_stateVec;
 

Core/include/Acts/Seeding/SeedFinderGbts.hpp

@@ -27,7 +27,7 @@
 #include <utility>
 #include <vector>
 
-namespace Acts {
+namespace Acts::Experimental {
 
 template <typename external_spacepoint_t>
 struct GbtsTrigTracklet {
@@ -66,13 +66,13 @@ class SeedFinderGbts {
   // inner
   template <typename output_container_t>
   void createSeeds(
-      const Acts::RoiDescriptor & /*roi*/,
-      const Acts::GbtsGeometry<external_spacepoint_t> & /*gbtsgeo*/,
+      const Acts::Experimental::RoiDescriptor & /*roi*/,
+      const Acts::Experimental::GbtsGeometry<external_spacepoint_t> & /*gbtsgeo*/,
       output_container_t & /*out_cont*/);
   // outer
   std::vector<seed_t> createSeeds(
-      const Acts::RoiDescriptor & /*roi*/,
-      const Acts::GbtsGeometry<external_spacepoint_t> & /*gbtsgeo*/);
+      const Acts::Experimental::RoiDescriptor & /*roi*/,
+      const Acts::Experimental::GbtsGeometry<external_spacepoint_t> & /*gbtsgeo*/);
 
  private:
   enum Dim { DimPhi = 0, DimR = 1, DimZ = 2 };
@@ -82,8 +82,8 @@ class SeedFinderGbts {
 
   void runGbts_TrackFinder(
       std::vector<GbtsTrigTracklet<external_spacepoint_t>> &vTracks,
-      const Acts::RoiDescriptor &roi,
-      const Acts::GbtsGeometry<external_spacepoint_t> &gbtsgeo);
+      const Acts::Experimental::RoiDescriptor &roi,
+      const Acts::Experimental::GbtsGeometry<external_spacepoint_t> &gbtsgeo);
 
   // needs to be member of class so can accessed by all member functions
   std::unique_ptr<GbtsDataStorage<external_spacepoint_t>> m_storage{nullptr};
@@ -96,6 +96,6 @@ class SeedFinderGbts {
       Acts::getDefaultLogger("Finder", Acts::Logging::Level::INFO);
 };
 
-}  // namespace Acts
+}  // namespace Acts::Experimental
 
 #include "Acts/Seeding/SeedFinderGbts.ipp"

Core/include/Acts/Seeding/SeedFinderGbts.ipp

@@ -28,7 +28,7 @@
 
 // core so in ACTS namespace
 
-namespace Acts {
+namespace Acts::Experimental {
 
 template <typename external_spacepoint_t>
 SeedFinderGbts<external_spacepoint_t>::SeedFinderGbts(
@@ -59,8 +59,8 @@ void SeedFinderGbts<external_spacepoint_t>::loadSpacePoints(
 template <typename external_spacepoint_t>
 void SeedFinderGbts<external_spacepoint_t>::runGbts_TrackFinder(
     std::vector<GbtsTrigTracklet<external_spacepoint_t>>& vTracks,
-    const Acts::RoiDescriptor& roi,
-    const Acts::GbtsGeometry<external_spacepoint_t>& gbtsGeo) {
+    const Acts::Experimental::RoiDescriptor& roi,
+    const Acts::Experimental::GbtsGeometry<external_spacepoint_t>& gbtsGeo) {
   ACTS_VERBOSE("Running GBTS Track Finder");
   const float min_z0 = roi.zedMinus();
   const float max_z0 = roi.zedPlus();
@@ -76,9 +76,9 @@ void SeedFinderGbts<external_spacepoint_t>::runGbts_TrackFinder(
 
   int currentStage = 0;
 
-  const Acts::GbtsConnector& connector = *(gbtsGeo.connector());
+  const Acts::Experimental::GbtsConnector& connector = *(gbtsGeo.connector());
 
-  std::vector<Acts::GbtsEdge<external_spacepoint_t>> edgeStorage;
+  std::vector<Acts::Experimental::GbtsEdge<external_spacepoint_t>> edgeStorage;
 
   edgeStorage.reserve(m_config.MaxEdges);
 
@@ -330,13 +330,13 @@ void SeedFinderGbts<external_spacepoint_t>::runGbts_TrackFinder(
 
     for (int inIdx = 0; inIdx < static_cast<int>(pN.m_in.size()); inIdx++) {
       int inEdgeIdx = pN.m_in.at(inIdx);
-      Acts::GbtsEdge<external_spacepoint_t>* pS = &(edgeStorage.at(inEdgeIdx));
+      Acts::Experimental::GbtsEdge<external_spacepoint_t>* pS = &(edgeStorage.at(inEdgeIdx));
       in_sort[inIdx].second = inEdgeIdx;
       in_sort[inIdx].first = pS->m_p[0];
     }
     for (int outIdx = 0; outIdx < static_cast<int>(pN.m_out.size()); outIdx++) {
       int outEdgeIdx = pN.m_out.at(outIdx);
-      Acts::GbtsEdge<external_spacepoint_t>* pS = &(edgeStorage.at(outEdgeIdx));
+      Acts::Experimental::GbtsEdge<external_spacepoint_t>* pS = &(edgeStorage.at(outEdgeIdx));
       out_sort[outIdx].second = outEdgeIdx;
       out_sort[outIdx].first = pS->m_p[0];
     }
@@ -351,7 +351,7 @@ void SeedFinderGbts<external_spacepoint_t>::runGbts_TrackFinder(
 
       int inEdgeIdx = in_sort[in_idx].second;
 
-      Acts::GbtsEdge<external_spacepoint_t>* pS = &(edgeStorage.at(inEdgeIdx));
+      Acts::Experimental::GbtsEdge<external_spacepoint_t>* pS = &(edgeStorage.at(inEdgeIdx));
 
       pS->m_nNei = 0;
       float tau1 = pS->m_p[0];
@@ -363,7 +363,7 @@ void SeedFinderGbts<external_spacepoint_t>::runGbts_TrackFinder(
            out_idx++) {
         int outEdgeIdx = out_sort[out_idx].second;
 
-        Acts::GbtsEdge<external_spacepoint_t>* pNS =
+        Acts::Experimental::GbtsEdge<external_spacepoint_t>* pNS =
             &(edgeStorage.at(outEdgeIdx));
 
         float tau2 = pNS->m_p[0];
@@ -410,10 +410,10 @@ void SeedFinderGbts<external_spacepoint_t>::runGbts_TrackFinder(
 
   int iter = 0;
 
-  std::vector<Acts::GbtsEdge<external_spacepoint_t>*> v_old;
+  std::vector<Acts::Experimental::GbtsEdge<external_spacepoint_t>*> v_old;
 
   for (int edgeIndex = 0; edgeIndex < nEdges; edgeIndex++) {
-    Acts::GbtsEdge<external_spacepoint_t>* pS = &(edgeStorage.at(edgeIndex));
+    Acts::Experimental::GbtsEdge<external_spacepoint_t>* pS = &(edgeStorage.at(edgeIndex));
     if (pS->m_nNei == 0) {
       continue;
     }
@@ -423,7 +423,7 @@ void SeedFinderGbts<external_spacepoint_t>::runGbts_TrackFinder(
 
   for (; iter < maxIter; iter++) {
     // generate proposals
-    std::vector<Acts::GbtsEdge<external_spacepoint_t>*> v_new;
+    std::vector<Acts::Experimental::GbtsEdge<external_spacepoint_t>*> v_new;
     v_new.clear();
 
     for (auto pS : v_old) {
@@ -432,7 +432,7 @@ void SeedFinderGbts<external_spacepoint_t>::runGbts_TrackFinder(
       for (int nIdx = 0; nIdx < pS->m_nNei; nIdx++) {
         unsigned int nextEdgeIdx = pS->m_vNei[nIdx];
 
-        Acts::GbtsEdge<external_spacepoint_t>* pN =
+        Acts::Experimental::GbtsEdge<external_spacepoint_t>* pN =
             &(edgeStorage.at(nextEdgeIdx));
 
         if (pS->m_level == pN->m_level) {
@@ -468,12 +468,12 @@ void SeedFinderGbts<external_spacepoint_t>::runGbts_TrackFinder(
 
   int minLevel = 3;  // a triplet + 2 confirmation
 
-  std::vector<Acts::GbtsEdge<external_spacepoint_t>*> vSeeds;
+  std::vector<Acts::Experimental::GbtsEdge<external_spacepoint_t>*> vSeeds;
 
   vSeeds.reserve(m_config.MaxEdges / 2);
 
   for (int edgeIndex = 0; edgeIndex < nEdges; edgeIndex++) {
-    Acts::GbtsEdge<external_spacepoint_t>* pS = &(edgeStorage.at(edgeIndex));
+    Acts::Experimental::GbtsEdge<external_spacepoint_t>* pS = &(edgeStorage.at(edgeIndex));
 
     if (pS->m_level < minLevel) {
       continue;
@@ -485,7 +485,7 @@ void SeedFinderGbts<external_spacepoint_t>::runGbts_TrackFinder(
   m_triplets.clear();
 
   std::ranges::sort(
-      vSeeds, typename Acts::GbtsEdge<external_spacepoint_t>::CompareLevel());
+      vSeeds, typename Acts::Experimental::GbtsEdge<external_spacepoint_t>::CompareLevel());
 
   if (vSeeds.empty()) {
     return;
@@ -517,7 +517,7 @@ void SeedFinderGbts<external_spacepoint_t>::runGbts_TrackFinder(
     std::vector<const GbtsSP<external_spacepoint_t>*> vSP;
 
     for (typename std::vector<
-             Acts::GbtsEdge<external_spacepoint_t>*>::reverse_iterator sIt =
+             Acts::Experimental::GbtsEdge<external_spacepoint_t>*>::reverse_iterator sIt =
              rs.m_vs.rbegin();
          sIt != rs.m_vs.rend(); ++sIt) {
       (*sIt)->m_level = -1;  // mark as collected
@@ -636,8 +636,8 @@ void SeedFinderGbts<external_spacepoint_t>::runGbts_TrackFinder(
 template <typename external_spacepoint_t>
 template <typename output_container_t>
 void SeedFinderGbts<external_spacepoint_t>::createSeeds(
-    const Acts::RoiDescriptor& roi,
-    const Acts::GbtsGeometry<external_spacepoint_t>& gbtsGeo,
+    const Acts::Experimental::RoiDescriptor& roi,
+    const Acts::Experimental::GbtsGeometry<external_spacepoint_t>& gbtsGeo,
     output_container_t& out_cont) {
   ACTS_VERBOSE("Creating seeds");
   std::vector<GbtsTrigTracklet<external_spacepoint_t>>
@@ -702,11 +702,11 @@ void SeedFinderGbts<external_spacepoint_t>::createSeeds(
 template <typename external_spacepoint_t>
 std::vector<Seed<external_spacepoint_t>>
 SeedFinderGbts<external_spacepoint_t>::createSeeds(
-    const Acts::RoiDescriptor& roi,
-    const Acts::GbtsGeometry<external_spacepoint_t>& gbtsGeo) {
+    const Acts::Experimental::RoiDescriptor& roi,
+    const Acts::Experimental::GbtsGeometry<external_spacepoint_t>& gbtsGeo) {
   std::vector<seed_t> r;
   createSeeds(roi, gbtsGeo, r);
   return r;
 }
 
-}  // namespace Acts
+}  // namespace Acts::Experimental

Core/include/Acts/Seeding/SeedFinderGbtsConfig.hpp

@@ -18,7 +18,7 @@
 #include <memory>
 
 // core algorithm so in acts namespace
-namespace Acts {
+namespace Acts::Experimental {
 
 template <typename SpacePoint>
 struct SeedFinderGbtsConfig {
@@ -94,4 +94,4 @@ struct SeedFinderGbtsConfig {
 
 };  // end of config struct
 
-}  // namespace Acts
+}  // namespace Acts::Experimental