CP::detail Namespace Reference

Classes
struct	ShallowCopy< xAOD::EgammaContainer >
struct	ContainerType
	check what kind of object/container the argument is More...
struct	ShallowCopy
	a helper class to create shallow copies and register them in the event store More...
struct	ShallowCopy< T, 1 >
struct	ShallowCopy< T, 2 >
struct	ShallowCopy< T, 3 >
struct	ShallowCopy< xAOD::IParticleContainer >

Functions
StatusCode	addSysDependency (MsgStream &msg, const ISystematicsSvc &svc, const std::function< void(const DataObjID &, Gaudi::DataHandle::Mode)> &addAlgDependency, const CLID clid, const std::string &name, Gaudi::DataHandle::Mode mode, const std::string &decoName, bool decoWrite)
template<typename ContainerType>
CLID	getClidForDependency (const std::string &typeName, const std::string &decoName, bool decoWrite)

Function Documentation

addSysDependency()

StatusCode CP::detail::addSysDependency	(	MsgStream &	msg,
		const ISystematicsSvc &	svc,
		const std::function< void(const DataObjID &, Gaudi::DataHandle::Mode)> &	addAlgDependency,
		const CLID	clid,
		const std::string &	name,
		Gaudi::DataHandle::Mode	mode,
		const std::string &	decoName,
		bool	decoWrite )

I'm only adding a dependency for nominal here, as there are currently no use cases in which a downstream user would only read a systematic, but not the nominal. The concern is that we might add dozens (or in extreme cases hundreds) of dependencies, without those adding providing any value.

Definition at line 26 of file AthenaDependencyHelpers.cxx.

    {
      // Build full key string: "StoreGateSvc+name"
      std::string fullKeyStr = "StoreGateSvc+";
 
      {
        std::string temp;
        if (svc.makeSystematicsName (temp, name, CP::SystematicSet{}).isFailure())
        {
          msg << MSG::ERROR << "could not build nominal systematic name for " + name << endmsg;
          return StatusCode::FAILURE;
        }
        fullKeyStr += temp;
      }
 
      if (!decoName.empty())
      {
        std::string temp;
        if (svc.makeSystematicsName (temp, decoName, CP::SystematicSet{}).isFailure())
        {
          msg << MSG::ERROR << "could not build nominal systematic name for " + decoName << endmsg;
          return StatusCode::FAILURE;
        }
 
        // Build decoration key string
        fullKeyStr += "." + temp;
 
        // Decoration mode
        mode = decoWrite ? Gaudi::DataHandle::Writer : Gaudi::DataHandle::Reader;
      }
 
      addAlgDependency(DataObjID{clid, std::move(fullKeyStr)}, mode);
      return StatusCode::SUCCESS;
    }

getClidForDependency()

template<typename ContainerType>

CLID CP::detail::getClidForDependency	(	const std::string &	typeName,
		const std::string &	decoName,
		bool	decoWrite )

Definition at line 39 of file AthenaDependencyHelpers.h.

    {
      // MissingETContainer special case: `TopBase` is not defined for
      // it, so we don't use it. Instead we will just use the regular
      // CLID. Should the `TopBase` ever be defined for
      // `xAOD::MissingETContainer`, this special case can be removed,
      // and with it the dependency in `CMakeLists.txt`.
      if constexpr (!std::same_as<ContainerType, xAOD::MissingETContainer>)
      {
        // For reading decorations we have a special case that matches
        // what the @ref SG::ReadDecorHandle does: Essentially it
        // registers with the top-most base, instead of the actual type.
        if (!decoName.empty() && !decoWrite)
        {
          // For decorations being read, use TopBase<ContainerType>
          using topbase_t = typename SG::TopBase<ContainerType>::type;
          return ClassID_traits<topbase_t>::ID();
        }
      }
      if (!typeName.empty())
        return DataObjID(typeName, "").clid();
      else
        return ClassID_traits<ContainerType>::ID();
    }