AtlasTest/CITest/Athena.cmake

@@ -259,6 +259,9 @@ atlas_add_citest( ACTS_ValidateAmbiguityResolution
 atlas_add_citest( ACTS_ActsKfRefitting
    SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/test/ActsKfRefitting.sh )
 
+atlas_add_citest( ACTS_ActsEFTrackFit
+   SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/test/ActsEFTrackFit.sh )
+
 atlas_add_citest( ACTS_ActsGSFRefitting
    SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/test/ActsGSFRefitting.sh )
 

AtlasTest/CITest/test/ActsEFTrackFit.sh

+#!/usr/bin/bash
+# Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+
+# run the example script
+python3 -m ActsConfig.ActsProtoTrackCreationAndFitConfig

AtlasTest/CITest/test/ActsWorkflow.sh

@@ -14,4 +14,5 @@ Reco_tf.py --CA \
   --ignorePatterns "${ignore_pattern}" \
   --inputRDOFile ${input_rdo} \
   --outputAODFile AOD.pool.root \
+  --outputESDFile ESD.pool.root \
   --maxEvents ${n_events}

Calorimeter/CaloClusterCorrection/test/ToolWithConstants_test.py

@@ -93,7 +93,7 @@ from AthenaConfiguration.AllConfigFlags import initConfigFlags
 from AthenaConfiguration.TestDefaults import defaultTestFiles
 flags = initConfigFlags()
 flags.Input.Files = defaultTestFiles.RDO_RUN2
-flags.Input.TimeStamp = 1000
+flags.Input.TimeStamps = [1000]
 
 flags.lock()
 from AthenaConfiguration.MainServicesConfig import MainServicesCfg

Calorimeter/CaloCondBlobObjs/src/CaloCondBlobFlt.cxx

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "CaloCondBlobObjs/CaloCondBlobFlt.h"
@@ -28,8 +28,8 @@ CaloCondBlobFlt::CaloCondBlobFlt(const coral::Blob& blob)
 {
   //=== check for correct blob type
   if(getBlobSize()){
-    if(getObjType() != getType()){
-      throw CaloCond::TypeConflict("CaloCondBlobFlt::Ctor",getObjType(),getType());
+    if(getObjType() != CaloCondBlobFlt::getType()){
+      throw CaloCond::TypeConflict("CaloCondBlobFlt::Ctor",getObjType(),CaloCondBlobFlt::getType());
     }
   }
 }
@@ -41,8 +41,8 @@ CaloCondBlobFlt::CaloCondBlobFlt(coral::Blob& blob)
 {
   //=== check for correct blob type
   if(getBlobSize()){
-    if(getObjType() != getType()){
-      throw CaloCond::TypeConflict("CaloCondBlobFlt::Ctor",getObjType(),getType());
+    if(getObjType() != CaloCondBlobFlt::getType()){
+      throw CaloCond::TypeConflict("CaloCondBlobFlt::Ctor",getObjType(),CaloCondBlobFlt::getType());
     }
   }
 }

Calorimeter/CaloCondPhysAlgs/python/CaloScaleNoiseConfig.py

@@ -101,8 +101,8 @@ if __name__=="__main__":
 
     from AthenaConfiguration.AllConfigFlags import initConfigFlags
     flags = initConfigFlags()
-    flags.Input.RunNumber=rlb[0]
-    flags.Input.TimeStamp=TimeStamp
+    flags.Input.RunNumbers=[rlb[0]]
+    flags.Input.TimeStamps=[TimeStamp]
     flags.Input.Files=[]
     flags.IOVDb.DatabaseInstance="CONDBR2"
   

Calorimeter/CaloDetDescr/python/CaloDetDescrManager_test.py

@@ -74,7 +74,7 @@ def testCfg(configFlags):
 
 
 ConfigFlags.Input.Files = defaultTestFiles.RDO_RUN2
-ConfigFlags.Input.TimeStamp = 1000
+ConfigFlags.Input.TimeStamps = [1000]
 ConfigFlags.Detector.GeometryLAr = True
 ConfigFlags.Detector.GeometryTile = True
 ConfigFlags.needFlagsCategory('Tile')

Calorimeter/CaloEvent/test/CaloCellContainerTestCommon.icc

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
 */
 /**
  * @file CaloEvent/test/CaloCellContainerTestCommon.icc
@@ -14,6 +14,7 @@
 
 
 #include "TestTools/random.h"
+#include <utility>
 
 
 void fill_cells1 (CellVector selected_cells[],
@@ -156,7 +157,7 @@ void check_cells (Athena_test::URNG& stlrand,
     }
   }
 
-  assert (cont.findCell (static_cast<unsigned int>(-1)) == 0);
+  assert (std::as_const(cont).findCell (static_cast<unsigned int>(-1)) == 0);
   assert (cont.findIndex (static_cast<unsigned int>(-1)) == -1);
 }
 

Calorimeter/CaloRec/python/CaloCellContainerAliasAlg_test.py

@@ -54,7 +54,7 @@ from AthenaConfiguration.AllConfigFlags import initConfigFlags
 from AthenaConfiguration.TestDefaults import defaultTestFiles
 flags = initConfigFlags()
 flags.Input.Files = defaultTestFiles.RDO_RUN2
-flags.Input.TimeStamp = 1000
+flags.Input.TimeStamps = [1000]
 flags.Detector.GeometryLAr = True
 flags.Detector.GeometryTile = True
 flags.needFlagsCategory('Tile')

Calorimeter/CaloRec/python/CaloThinCellsByClusterAlg_test.py

@@ -141,7 +141,7 @@ from AthenaConfiguration.AllConfigFlags import initConfigFlags
 from AthenaConfiguration.TestDefaults import defaultTestFiles
 flags = initConfigFlags()
 flags.Input.Files = defaultTestFiles.RDO_RUN2
-flags.Input.TimeStamp = 1000
+flags.Input.TimeStamps = [1000]
 flags.Detector.GeometryLAr = True
 flags.Detector.GeometryTile = True
 flags.needFlagsCategory('Tile')

Calorimeter/CaloRec/python/CaloThinCellsBySamplingAlg_test.py

@@ -77,7 +77,7 @@ from AthenaConfiguration.AllConfigFlags import initConfigFlags
 from AthenaConfiguration.TestDefaults import defaultTestFiles
 flags = initConfigFlags()
 flags.Input.Files = defaultTestFiles.RDO_RUN2
-flags.Input.TimeStamp = 1000
+flags.Input.TimeStamps = [1000]
 flags.Detector.GeometryLAr = True
 flags.Detector.GeometryTile = True
 flags.needFlagsCategory('Tile')

Calorimeter/CaloRec/src/CaloCellMaker.cxx

@@ -34,37 +34,6 @@
 using CLHEP::microsecond;
 using CLHEP::second;
 
-/////////////////////////////////////////////////////////////////////
-// CONSTRUCTOR:
-/////////////////////////////////////////////////////////////////////
-
-CaloCellMaker::CaloCellMaker(const std::string& name, ISvcLocator* pSvcLocator)
-    : AthReentrantAlgorithm(name, pSvcLocator)
-  , m_chrono("ChronoStatSvc", name)
-  , m_doChronoStat(true)
-  , m_ownPolicy(static_cast<int>(SG::VIEW_ELEMENTS))
-  , m_caloCellsOutputKey("")
-      //, m_caloCellHack(false)
-  , m_caloCellMakerTools(this)
-      //, m_evCounter(0)
-{
-  declareProperty("EnableChronoStat", m_doChronoStat);
-  declareProperty("OwnPolicy", m_ownPolicy);
-  declareProperty("CaloCellMakerToolNames", m_caloCellMakerTools);
-  declareProperty("CaloCellsOutputName", m_caloCellsOutputKey);
-  //declareProperty("CaloCellHack", m_caloCellHack);
-}
-
-/////////////////////////////////////////////////////////////////////
-// DESTRUCTOR:
-/////////////////////////////////////////////////////////////////////
-
-CaloCellMaker::~CaloCellMaker() = default;
-
-/////////////////////////////////////////////////////////////////////
-// INITIALIZE:
-// The initialize method will create all the required algorithm objects
-/////////////////////////////////////////////////////////////////////
 
 StatusCode CaloCellMaker::initialize() {
 
@@ -73,31 +42,20 @@ StatusCode CaloCellMaker::initialize() {
     ATH_CHECK( m_chrono.retrieve() );
   }
 
-  // // Add ":PUBLIC" to the tool names to force ToolSvc into creating
-  // // public tools.
-  // std::vector< std::string > typesAndNames;
-  // for( const std::string& typeName : m_caloCellMakerTools.typesAndNames() ) {
-  //    typesAndNames.push_back( typeName + ":PUBLIC" );
-  // }
-  // m_caloCellMakerTools.setTypesAndNames( typesAndNames );
-
   // access tools and store them
   CHECK( m_caloCellMakerTools.retrieve() );
   ATH_MSG_DEBUG( "Successfully retrieve CaloCellMakerTools: " << m_caloCellMakerTools );
-
+  
   ATH_CHECK(m_caloCellsOutputKey.initialize());
+
+  m_ownPolicy =  m_ownPolicyProp.value() ? SG::OWN_ELEMENTS : SG::VIEW_ELEMENTS;
+
   ATH_MSG_INFO( " Output CaloCellContainer Name " << m_caloCellsOutputKey.key() );
   if (m_ownPolicy == SG::OWN_ELEMENTS) {
     ATH_MSG_INFO( "...will OWN its cells." );
   } else {
     ATH_MSG_INFO( "...will VIEW its cells." );
   }
-
-  // if (m_caloCellHack) {
-  //   ATH_MSG_WARNING( " CaloCellContainer: " << m_caloCellsOutputName
-  //                   << "will be read in and modified !. To be used with care. " );
-  // }
-
   return StatusCode::SUCCESS;
 
 }

Calorimeter/CaloRec/src/CaloCellMaker.h

@@ -27,18 +27,17 @@
 #include "StoreGate/WriteHandleKey.h"
 
 // Calo includes
+#include "CaloEvent/CaloCellContainer.h"
 //#include "CaloInterface/ICaloCellMakerTool.h"
 
 class IChronoStatSvc;
 class ICaloCellMakerTool;
-class CaloCellContainer;
 
 class CaloCellMaker: public AthReentrantAlgorithm {
 
   public:
-
-    CaloCellMaker(const std::string& name, ISvcLocator* pSvcLocator);
-    virtual ~CaloCellMaker();
+    using AthReentrantAlgorithm::AthReentrantAlgorithm;
+    virtual ~CaloCellMaker() = default;
 
     virtual StatusCode initialize() override;
     virtual StatusCode execute (const EventContext& ctx) const override;
@@ -46,26 +45,19 @@ class CaloCellMaker: public AthReentrantAlgorithm {
 
   private:
 
-    // ChronoStatSvc
-    ServiceHandle<IChronoStatSvc> m_chrono;
-    bool m_doChronoStat;
-
-    /** whether CellContainer to be created will own (default) its cells or not */
-    int m_ownPolicy;
-
-    // Output cell continer to be used 
-    //std::string m_caloCellsOutputName;
-    SG::WriteHandleKey<CaloCellContainer> m_caloCellsOutputKey;
+    /// ChronoStatSvc
+    ServiceHandle<IChronoStatSvc> m_chrono{this,"ChronoStatSvc","ChronoStatSvc"};
+    Gaudi::Property<bool> m_doChronoStat{this,"EnableChronoStat",true};
 
-    // Authorize input to be the same as output (to be done with care)
-    //bool m_caloCellHack;
+    //Decide if the container owns the cells or views it (default false=view)
+    Gaudi::Property<bool> m_ownPolicyProp{this,"OwnPolicy",false};
+    SG::OwnershipPolicy m_ownPolicy{SG::VIEW_ELEMENTS};
 
-    // list of tools to be used
-    //std::vector< std::string > m_caloCellMakerToolNames ;
-    //std::vector < ICaloCellMakerTool *> m_caloCellMakerTools ;
-    ToolHandleArray<ICaloCellMakerTool> m_caloCellMakerTools;
+    /// Output cell continer to be used 
+    SG::WriteHandleKey<CaloCellContainer> m_caloCellsOutputKey{this,"CaloCellsOutputName","AllCalo","SG Key of the output container"};
 
-    //unsigned m_evCounter;
+    /// Array of CellMaker (and corrector) AlgTools
+    ToolHandleArray<ICaloCellMakerTool> m_caloCellMakerTools{this,"CaloCellMakerToolNames",{}};
 
 };
 #endif

Calorimeter/CaloRec/test/ToolConstantsCondAlg_test.py

@@ -47,7 +47,7 @@ from AthenaConfiguration.AllConfigFlags import initConfigFlags
 from AthenaConfiguration.TestDefaults import defaultTestFiles
 flags = initConfigFlags()
 flags.Input.Files = defaultTestFiles.RDO_RUN2
-flags.Input.TimeStamp = 1000
+flags.Input.TimeStamps = [1000]
 
 flags.lock()
 from AthenaConfiguration.MainServicesConfig import MainServicesCfg

Control/AthContainers/AthContainers/AuxVectorBase.h

 // This file's extension implies that it's C, but it's really -*- C++ -*-.
 
 /*
-  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 /**
  * @file AthContainers/AuxVectorBase.h
@@ -21,6 +21,7 @@
 #include "AthContainers/AuxElement.h"
 #include "AthContainers/AuxTypeRegistry.h"
 #include "AthContainers/exceptions.h"
+#include "AthContainers/tools/AuxDataTraits.h"
 #include "AthContainers/tools/ATHCONTAINERS_ASSERT.h"
 #include "AthContainersInterfaces/IAuxStore.h"
 #include "AthContainersInterfaces/AuxStore_traits.h"
@@ -96,6 +97,11 @@ class AuxVectorBase
   : public AuxVectorData
 {
 public:
+  /// Spans over auxiliary variables.
+  template <class T> using span = typename AuxDataTraits<T>::span;
+  template <class T> using const_span = typename AuxDataTraits<T>::const_span;
+
+
   /**
    * @brief Default constructor.
    *
@@ -190,6 +196,113 @@ public:
   void setNonConstStore (SG::IAuxStore* store);
 
 
+  // Templated versions of isAvailable, etc.
+  // We put them here rather than in AuxVectorData so that AuxVectorData.h
+  // doesn't need to include AuxTypeRegistry.h.  Otherwise we get a
+  // a cyclic header dependency:
+  //  AuxTypeRegistry -> AuxTypeVectorFactory -> AuxVectorData -> AuxTypeRegistry
+
+  using AuxVectorData::isAvailable;
+  using AuxVectorData::isAvailableWritable;
+  using AuxVectorData::isAvailableWritableAsDecoration;
+
+
+  /**
+   * @brief Test to see if a variable exists in the store.
+   * @param name Name of the aux variable.
+   * @param clsname The name of the associated class.  May be blank.
+   */
+  template <class T>
+  bool isAvailable (const std::string& name,
+                    const std::string& clsname = "") const;
+
+
+  /**
+   * @brief Test to see if a variable is available for writing.
+   * @param name Name of the aux variable.
+   * @param clsname The name of the associated class.  May be blank.
+   */
+  template <class T>
+  bool isAvailableWritable (const std::string& name,
+                            const std::string& clsname = "");
+
+
+  /**
+   * @brief Test to see if a variable is available for writing as a decoration.
+   * @param name Name of the aux variable.
+   * @param clsname The name of the associated class.  May be blank.
+   */
+  template <class T>
+  bool isAvailableWritableAsDecoration (const std::string& name,
+                                        const std::string& clsname = "") const;
+
+
+  /**
+   * @brief Return a span over an aux data item.
+   * @param auxid The desired aux data item.
+   *
+   * This will return a span containing the value of the requested
+   * auxiliary variable for all elements in the container.
+   * If the item doesn't exist, it will be created.
+   * Errors are signaled by raising an exception.
+   * Note that the @c value_type of the span is not necessarily @c T;
+   * an example is @c bool for which we return a span of @c char.
+   */
+  template <class T>
+  span<T> getDataSpan (const std::string& name);
+
+
+  /**
+   * @brief Return a span over an aux data item.
+   * @param auxid The desired aux data item.
+   *
+   * This will return a span containing the value of the requested
+   * auxiliary variable for all elements in the container.
+   * If the item doesn't exist, it will be created.
+   * Errors are signaled by raising an exception.
+   * Note that the @c value_type of the span is not necessarily @c T;
+   * an example is @c bool for which we return a span of @c char.
+   */
+  template <class T>
+  const_span<T> getDataSpan (const std::string& name) const;
+
+
+  /**
+   * @brief Return a span over an aux data item.
+   * @param auxid The desired aux data item.
+   *
+   * This will return a span containing the value of the requested
+   * auxiliary variable for all elements in the container.
+   * If the item doesn't exist, it will be created.
+   * Errors are signaled by raising an exception.
+   * Note that the @c value_type of the span is not necessarily @c T;
+   * an example is @c bool for which we return a span of @c char.
+   */
+  template <class T>
+  const_span<T> getConstDataSpan (const std::string& name) const;
+
+
+  /**
+   * @brief Return a span over an aux data item for a decoration.
+   * @param auxid The desired aux data item.
+   *
+   * This will return a span containing the value of the requested
+   * auxiliary variable for all elements in the container.
+   * If the item doesn't exist, it will be created.
+   * Errors are signaled by raising an exception.
+   * Note that the @c value_type of the span is not necessarily @c T;
+   * an example is @c bool for which we return a span of @c char.
+   *
+   * The difference between @c getDecorationSpan and @c getDataSpan is that
+   * @c getDecorationSpan takes a const container as input, but returns
+   * a span over non-const objects.  This will only succeed if either the
+   * container is not locked or the item was first accessed
+   * as a decoration.
+   */
+  template <class T>
+  span<T> getDecorationSpan (const std::string& name) const;
+
+
   /// Mark that this type supports thinning operations.
   /// See AthContainers/supportsThinning.h and
   /// AthenaPoolCnvSvc/T_AthenaPoolCnv.h.

Control/AthContainers/AthContainers/AuxVectorBase.icc

 /*
-  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 /**
@@ -45,6 +45,146 @@ void AuxVectorBase::setNonConstStore (SG::IAuxStore* store)
 }
 
 
+/**
+ * @brief Test to see if a variable exists in the store.
+ * @param name Name of the aux variable.
+ * @param clsname The name of the associated class.  May be blank.
+ */
+template <class T>
+inline
+bool AuxVectorBase::isAvailable (const std::string& name,
+                                 const std::string& clsname /*= ""*/) const
+{
+  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name, clsname);
+  return AuxVectorData::isAvailable (id);
+}
+
+
+/**
+ * @brief Test to see if a variable is available for writing.
+ * @param name Name of the aux variable.
+ * @param clsname The name of the associated class.  May be blank.
+ */
+template <class T>
+inline
+bool
+AuxVectorBase::isAvailableWritable (const std::string& name,
+                                    const std::string& clsname /*= ""*/)
+{
+  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name, clsname);
+  return AuxVectorData::isAvailableWritable (id);
+}
+
+
+/**
+ * @brief Test to see if a variable is available for writing as a decoration.
+ * @param name Name of the aux variable.
+ * @param clsname The name of the associated class.  May be blank.
+ */
+template <class T>
+inline
+bool
+AuxVectorBase::isAvailableWritableAsDecoration (const std::string& name,
+                                                const std::string& clsname /*= ""*/) const
+{
+  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name, clsname);
+  return AuxVectorData::isAvailableWritableAsDecoration (id);
+}
+
+
+/**
+ * @brief Return a span over an aux data item.
+ * @param auxid The desired aux data item.
+ *
+ * This will return a span containing the value of the requested
+ * auxiliary variable for all elements in the container.
+ * If the item doesn't exist, it will be created.
+ * Errors are signaled by raising an exception.
+ * Note that the @c value_type of the span is not necessarily @c T;
+ * an example is @c bool for which we return a span of @c char.
+ */
+template <class T>
+AuxVectorBase::span<T> AuxVectorBase::getDataSpan (const std::string& name)
+{
+  using container_pointer_type = typename AuxDataTraits<T>::container_pointer_type;
+  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name);
+  auto beg = reinterpret_cast<container_pointer_type> (AuxVectorData::getDataArray (id));
+  return span<T> (beg, size_v());
+}
+
+
+/**
+ * @brief Return a span over an aux data item.
+ * @param auxid The desired aux data item.
+ *
+ * This will return a span containing the value of the requested
+ * auxiliary variable for all elements in the container.
+ * If the item doesn't exist, it will be created.
+ * Errors are signaled by raising an exception.
+ * Note that the @c value_type of the span is not necessarily @c T;
+ * an example is @c bool for which we return a span of @c char.
+ */
+template <class T>
+AuxVectorBase::const_span<T>
+AuxVectorBase::getDataSpan (const std::string& name) const
+{
+  using const_container_pointer_type = typename AuxDataTraits<T>::const_container_pointer_type;
+  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name);
+  auto beg = reinterpret_cast<const_container_pointer_type> (AuxVectorData::getDataArray (id));
+  return const_span<T> (beg, size_v());
+}
+
+
+/**
+ * @brief Return a span over an aux data item for a decoration.
+ * @param auxid The desired aux data item.
+ *
+ * This will return a span containing the value of the requested
+ * auxiliary variable for all elements in the container.
+ * If the item doesn't exist, it will be created.
+ * Errors are signaled by raising an exception.
+ * Note that the @c value_type of the span is not necessarily @c T;
+ * an example is @c bool for which we return a span of @c char.
+ *
+ * The difference between @c getDecorationSpan and @c getDataSpan is that
+ * @c getDecorationSpan takes a const container as input, but returns
+ * a span over non-const objects.  This will only succeed if either the
+ * container is not locked or the item was first accessed
+ * as a decoration.
+ */
+template <class T>
+AuxVectorBase::span<T>
+AuxVectorBase::getDecorationSpan (const std::string& name) const
+{
+  using container_pointer_type = typename AuxDataTraits<T>::container_pointer_type;
+  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name);
+  auto beg = reinterpret_cast<container_pointer_type> (AuxVectorData::getDecorationArray (id));
+  return span<T> (beg, size_v());
+}
+
+
+/**
+ * @brief Return a span over an aux data item.
+ * @param auxid The desired aux data item.
+ *
+ * This will return a span containing the value of the requested
+ * auxiliary variable for all elements in the container.
+ * If the item doesn't exist, it will be created.
+ * Errors are signaled by raising an exception.
+ * Note that the @c value_type of the span is not necessarily @c T;
+ * an example is @c bool for which we return a span of @c char.
+ */
+template <class T>
+AuxVectorBase::const_span<T>
+AuxVectorBase::getConstDataSpan (const std::string& name) const
+{
+  using const_container_pointer_type = typename AuxDataTraits<T>::const_container_pointer_type;
+  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name);
+  auto beg = reinterpret_cast<const_container_pointer_type> (AuxVectorData::getDataArray (id));
+  return const_span<T> (beg, size_v());
+}
+
+
 /**
  * @brief Initialize index tracking mode.
  * @param ownPolicy The container ownership policy.

Control/AthContainers/AthContainers/AuxVectorData.h

 // This file's extension implies that it's C, but it's really -*- C++ -*-.
-
 /*
-  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 /**
  * @file AthContainers/AuxVectorData.h
@@ -167,11 +166,6 @@ class AuxVectorData
 #endif // not XAOD_STANDALONE
 {
 public:
-  /// Spans over auxiliary variables.
-  template <class T> using span = typename AuxDataTraits<T>::span;
-  template <class T> using const_span = typename AuxDataTraits<T>::const_span;
-
-
   /// Constructor.
   AuxVectorData();
 
@@ -444,16 +438,6 @@ public:
   bool isAvailable (auxid_t id) const;
 
 
-  /**
-   * @brief Test to see if a variable exists in the store.
-   * @param name Name of the aux variable.
-   * @param clsname The name of the associated class.  May be blank.
-   */
-  template <class T>
-  bool isAvailable (const std::string& name,
-                    const std::string& clsname = "") const;
-
-
   /**
    * @brief Test to see if a variable is available for writing.
    * @param id The variable to test.
@@ -461,16 +445,6 @@ public:
   bool isAvailableWritable (auxid_t id);
 
 
-  /**
-   * @brief Test to see if a variable is available for writing.
-   * @param name Name of the aux variable.
-   * @param clsname The name of the associated class.  May be blank.
-   */
-  template <class T>
-  bool isAvailableWritable (const std::string& name,
-                            const std::string& clsname = "");
-
-
   /**
    * @brief Test to see if a variable is available for writing as a decoration.
    * @param id The variable to test.
@@ -478,14 +452,8 @@ public:
   bool isAvailableWritableAsDecoration (auxid_t id) const;
 
 
-  /**
-   * @brief Test to see if a variable is available for writing as a decoration.
-   * @param name Name of the aux variable.
-   * @param clsname The name of the associated class.  May be blank.
-   */
-  template <class T>
-  bool isAvailableWritableAsDecoration (const std::string& name,
-                                        const std::string& clsname = "") const;
+  // Versions of isAvailable* that take a name rather than an ID are
+  // in the derived class AuxVectorBase.
 
 
   /**
@@ -595,70 +563,6 @@ public:
   void* getDataArray (SG::auxid_t auxid);
 
 
-  /**
-   * @brief Return a span over an aux data item.
-   * @param auxid The desired aux data item.
-   *
-   * This will return a span containing the value of the requested
-   * auxiliary variable for all elements in the container.
-   * If the item doesn't exist, it will be created.
-   * Errors are signaled by raising an exception.
-   * Note that the @c value_type of the span is not necessarily @c T;
-   * an example is @c bool for which we return a span of @c char.
-   */
-  template <class T>
-  span<T> getDataSpan (const std::string& name);
-
-
-  /**
-   * @brief Return a span over an aux data item.
-   * @param auxid The desired aux data item.
-   *
-   * This will return a span containing the value of the requested
-   * auxiliary variable for all elements in the container.
-   * If the item doesn't exist, it will be created.
-   * Errors are signaled by raising an exception.
-   * Note that the @c value_type of the span is not necessarily @c T;
-   * an example is @c bool for which we return a span of @c char.
-   */
-  template <class T>
-  const_span<T> getDataSpan (const std::string& name) const;
-
-
-  /**
-   * @brief Return a span over an aux data item.
-   * @param auxid The desired aux data item.
-   *
-   * This will return a span containing the value of the requested
-   * auxiliary variable for all elements in the container.
-   * If the item doesn't exist, it will be created.
-   * Errors are signaled by raising an exception.
-   * Note that the @c value_type of the span is not necessarily @c T;
-   * an example is @c bool for which we return a span of @c char.
-   */
-  template <class T>
-  const_span<T> getConstDataSpan (const std::string& name) const;
-
-
-  /**
-   * @brief Return a span over an aux data item for a decoration.
-   * @param auxid The desired aux data item.
-   *
-   * This will return a span containing the value of the requested
-   * auxiliary variable for all elements in the container.
-   * If the item doesn't exist, it will be created.
-   * Errors are signaled by raising an exception.
-   * Note that the @c value_type of the span is not necessarily @c T;
-   * an example is @c bool for which we return a span of @c char.
-   *
-   * The difference between @c getDecorationSpan and @c getDataSpan is that
-   * @c getDecorationSpan takes a const container as input, but returns
-   * a span over non-const objects.  This will only succeed if either the
-   * container is not locked or the item was first accessed
-   * as a decoration.
-   */
-  template <class T>
-  span<T> getDecorationSpan (const std::string& name) const;
 
 
 protected:

Control/AthContainers/AthContainers/AuxVectorData.icc

 // Dear emacs, this is -*- c++ -*-
-
 /*
-  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
-
 /**
  * @file AthContainers/AuxVectorData.icc
  * @author scott snyder <snyder@bnl.gov>
@@ -12,7 +10,6 @@
  */
 
 
-#include "AthContainers/AuxTypeRegistry.h"
 #include "AthContainersInterfaces/IAuxStore.h"
 #include "AthContainersInterfaces/IConstAuxStore.h"
 #include "AthContainers/tools/likely.h"
@@ -129,21 +126,6 @@ bool AuxVectorData::isAvailable (auxid_t id) const
 }
 
 
-/**
- * @brief Test to see if a variable exists in the store.
- * @param name Name of the aux variable.
- * @param clsname The name of the associated class.  May be blank.
- */
-template <class T>
-inline
-bool AuxVectorData::isAvailable (const std::string& name,
-                                 const std::string& clsname /*= ""*/) const
-{
-  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name, clsname);
-  return isAvailable (id);
-}
-
-
 /**
  * @brief Test to see if a variable is available for writing.
  * @param id The variable to test.
@@ -157,22 +139,6 @@ bool AuxVectorData::isAvailableWritable (auxid_t id)
 }
 
 
-/**
- * @brief Test to see if a variable is available for writing.
- * @param name Name of the aux variable.
- * @param clsname The name of the associated class.  May be blank.
- */
-template <class T>
-inline
-bool
-AuxVectorData::isAvailableWritable (const std::string& name,
-                                    const std::string& clsname /*= ""*/)
-{
-  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name, clsname);
-  return isAvailableWritable (id);
-}
-
-
 /**
  * @brief Test to see if a variable is available for writing as a decoration.
  * @param id The variable to test.
@@ -186,22 +152,6 @@ bool AuxVectorData::isAvailableWritableAsDecoration (auxid_t id) const
 }
 
 
-/**
- * @brief Test to see if a variable is available for writing as a decoration.
- * @param name Name of the aux variable.
- * @param clsname The name of the associated class.  May be blank.
- */
-template <class T>
-inline
-bool
-AuxVectorData::isAvailableWritableAsDecoration (const std::string& name,
-                                                const std::string& clsname /*= ""*/) const
-{
-  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name, clsname);
-  return isAvailableWritableAsDecoration (id);
-}
-
-
 /**
  * @brief Return reference to an aux data item.
  * @param auxid The desired aux data item.
@@ -342,99 +292,6 @@ void* AuxVectorData::getDecorationArray (SG::auxid_t auxid) const
 }
 
 
-/**
- * @brief Return a span over an aux data item.
- * @param auxid The desired aux data item.
- *
- * This will return a span containing the value of the requested
- * auxiliary variable for all elements in the container.
- * If the item doesn't exist, it will be created.
- * Errors are signaled by raising an exception.
- * Note that the @c value_type of the span is not necessarily @c T;
- * an example is @c bool for which we return a span of @c char.
- */
-template <class T>
-AuxVectorData::span<T> AuxVectorData::getDataSpan (const std::string& name)
-{
-  using container_pointer_type = typename AuxDataTraits<T>::container_pointer_type;
-  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name);
-  auto beg = reinterpret_cast<container_pointer_type> (getDataArray (id));
-  return span<T> (beg, size_v());
-}
-
-
-/**
- * @brief Return a span over an aux data item.
- * @param auxid The desired aux data item.
- *
- * This will return a span containing the value of the requested
- * auxiliary variable for all elements in the container.
- * If the item doesn't exist, it will be created.
- * Errors are signaled by raising an exception.
- * Note that the @c value_type of the span is not necessarily @c T;
- * an example is @c bool for which we return a span of @c char.
- */
-template <class T>
-AuxVectorData::const_span<T>
-AuxVectorData::getDataSpan (const std::string& name) const
-{
-  using const_container_pointer_type = typename AuxDataTraits<T>::const_container_pointer_type;
-  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name);
-  auto beg = reinterpret_cast<const_container_pointer_type> (getDataArray (id));
-  return const_span<T> (beg, size_v());
-}
-
-
-/**
- * @brief Return a span over an aux data item for a decoration.
- * @param auxid The desired aux data item.
- *
- * This will return a span containing the value of the requested
- * auxiliary variable for all elements in the container.
- * If the item doesn't exist, it will be created.
- * Errors are signaled by raising an exception.
- * Note that the @c value_type of the span is not necessarily @c T;
- * an example is @c bool for which we return a span of @c char.
- *
- * The difference between @c getDecorationSpan and @c getDataSpan is that
- * @c getDecorationSpan takes a const container as input, but returns
- * a span over non-const objects.  This will only succeed if either the
- * container is not locked or the item was first accessed
- * as a decoration.
- */
-template <class T>
-AuxVectorData::span<T>
-AuxVectorData::getDecorationSpan (const std::string& name) const
-{
-  using container_pointer_type = typename AuxDataTraits<T>::container_pointer_type;
-  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name);
-  auto beg = reinterpret_cast<container_pointer_type> (getDecorationArray (id));
-  return span<T> (beg, size_v());
-}
-
-
-/**
- * @brief Return a span over an aux data item.
- * @param auxid The desired aux data item.
- *
- * This will return a span containing the value of the requested
- * auxiliary variable for all elements in the container.
- * If the item doesn't exist, it will be created.
- * Errors are signaled by raising an exception.
- * Note that the @c value_type of the span is not necessarily @c T;
- * an example is @c bool for which we return a span of @c char.
- */
-template <class T>
-AuxVectorData::const_span<T>
-AuxVectorData::getConstDataSpan (const std::string& name) const
-{
-  using const_container_pointer_type = typename AuxDataTraits<T>::const_container_pointer_type;
-  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name);
-  auto beg = reinterpret_cast<const_container_pointer_type> (getDataArray (id));
-  return const_span<T> (beg, size_v());
-}
-
-
 /**
  * @brief Swap this instance with another.
  * @param other The other instance with which to swap.

Control/AthContainers/AthContainers/tools/AuxTypeVector.h

@@ -21,6 +21,7 @@
 #include <typeinfo>
 #include <vector>
 #include <algorithm>
+#include <utility>
 #include <stdint.h>
 #include <type_traits>
 
@@ -132,6 +133,12 @@ public:
   virtual void* toPtr() override;
 
 
+  /**
+   * @brief Return a pointer to the start of the vector's data.
+   */
+  virtual const void* toPtr() const override;
+
+
   /**
    * @brief Return a pointer to the STL vector itself.
    */

Control/AthContainers/AthContainers/tools/AuxTypeVector.icc

@@ -206,6 +206,19 @@ void* AuxTypeVectorHolder<T, CONT>::toPtr ()
 }
 
 
+/**
+ * @brief Return a pointer to the start of the vector's data.
+ */
+template <class T, class CONT>
+inline
+const void* AuxTypeVectorHolder<T, CONT>::toPtr () const
+{
+  if (m_vecPtr->empty())
+    return nullptr;
+  return std::as_const (*m_vecPtr).data();
+}
+
+
 /**
  * @brief Return a pointer to the STL vector itself.
  */