TrigComposite_v1.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef XAODTRIGGER_VERSIONS_TRIGCOMPOSITE_V1_H
#define XAODTRIGGER_VERSIONS_TRIGCOMPOSITE_V1_H
 
// System include(s):
extern "C" {
#   include <stdint.h>
}
#include <string>
#include <vector>
#include <set>
 
// EDM include(s):
#include "AthContainers/AuxElement.h"
#include "AthLinks/ElementLink.h"
#include "xAODBase/IParticleContainer.h"
#include "SGCore/sgkey_t.h"
 
#include "CxxUtils/checker_macros.h"
 
namespace TrigCompositeUtils{
   typedef unsigned int DecisionID;
   typedef std::set<DecisionID> DecisionIDContainer;
}
 
namespace xAOD {
 
   class ExcNotIParticleContainer
     : public std::runtime_error
   {
   public:
     ExcNotIParticleContainer (const std::string& msg);
   };
 
   class TrigComposite_v1 : public SG::AuxElement {
 
   public:
      using sgkey_t = SG::sgkey_t;
      using index_type = uint32_t;
 
      TrigComposite_v1();
 
       TrigComposite_v1( const TrigComposite_v1& parent );
 
       TrigComposite_v1& operator=( const TrigComposite_v1& rhs );
 
 
      const std::string& name() const;
      void setName( const std::string& name );
 
      const std::vector<TrigCompositeUtils::DecisionID>& decisions() const;
      void setDecisions( const std::vector<TrigCompositeUtils::DecisionID>& decisions );
 
 
 
      template< typename TYPE >
      bool hasDetail( const std::string& name ) const;
 
      template< typename TYPE >
      bool setDetail( const std::string& name, const TYPE& value );
 
      template< typename TYPE >
      bool getDetail( const std::string& name, TYPE& value ) const;
 
      template<typename TYPE>
      TYPE getDetail( const std::string& name ) const;
 
 
 
      template< class CONTAINER >
      bool setObjectLink( const std::string& name,
                          const ElementLink< CONTAINER >& link );
      bool hasObjectLink( const std::string& name, const CLID clid = CLID_NULL ) const;
      template< class CONTAINER >
      ElementLink< CONTAINER >
      objectLink( const std::string& name ) const;
      template< class OBJECT >
      const OBJECT* object( const std::string& name  ) const;
 
      template< class CONTAINER >
      bool addObjectCollectionLink( const std::string& collectionName,
                                    const ElementLink< CONTAINER >& link );
      template< class CONTAINER >
      bool addObjectCollectionLinks( const std::string& collectionName,
                                     const std::vector<ElementLink< CONTAINER >>& links );
      bool hasObjectCollectionLinks( const std::string& collectionName, const CLID clid = CLID_NULL) const;
      template< class CONTAINER >
      std::vector<ElementLink< CONTAINER >>
      objectCollectionLinks( const std::string& collectionName ) const;
 
      void typelessSetObjectLink( const std::string& name,
                                  const sgkey_t key,
                                  const uint32_t clid,
                                  const index_type beginIndex,
                                  const index_type endIndex = 0 );
 
      bool typelessGetObjectLink( const std::string& name,
                                  sgkey_t& key,
                                  uint32_t& clid,
                                  index_type& index) const;
 
      bool typelessGetObjectCollectionLinks( const std::string& name,
                                  std::vector<sgkey_t>& keyVec,
                                  std::vector<uint32_t>& clidVec,
                                  std::vector<index_type>& indexVec) const;
 
 
      template< class CONTAINER >
      std::vector<std::string> getObjectNames() const;
 
      template< class CONTAINER >
      std::vector<std::string> getObjectCollectionNames() const;
 
      std::vector<std::string> getObjectNames(const CLID clid) const;
 
      std::vector<std::string> getObjectCollectionNames(const CLID clid) const;
 
      bool removeObjectLink(const std::string& name);
 
      bool removeObjectCollectionLinks(const std::string& name);
 
 
 
      bool copyLinkFrom(const xAOD::TrigComposite_v1& other, const std::string& name, std::string newName = "");
      bool copyLinkFrom(const xAOD::TrigComposite_v1* other, const std::string& name, std::string newName = "");
 
      bool copyLinkCollectionFrom(const xAOD::TrigComposite_v1& other, const std::string& name, std::string newName = "");
      bool copyLinkCollectionFrom(const xAOD::TrigComposite_v1* other, const std::string& name, std::string newName = "");
 
      bool copyAllLinksFrom(const xAOD::TrigComposite_v1& other);
      bool copyAllLinksFrom(const xAOD::TrigComposite_v1* other);
 
 
 
 
      const std::vector< std::string >& linkColNames() const;
      const std::vector< sgkey_t >& linkColKeys() const;
      const std::vector< index_type >& linkColIndices() const;
      const std::vector< uint32_t >& linkColClids() const;
 
      bool isRemapped() const;
 
      const std::vector< sgkey_t >& linkColKeysRemap() const;
      const std::vector< index_type >& linkColIndicesRemap() const;
 
 
      static bool s_throwOnCopyError ATLAS_THREAD_SAFE;
 
      static const std::string s_initialRoIString;
      static const std::string s_initialRecRoIString;
      static const std::string s_roiString;
      static const std::string s_viewString;
      static const std::string s_featureString;
      static const std::string s_seedString;
 
      static const std::string s_hltSeedingNodeNameString;
      static const std::string s_filterNodeNameString;
      static const std::string s_inputMakerNodeNameString;
      static const std::string s_hypoAlgNodeNameString;
      static const std::string s_comboHypoAlgNodeNameString;
      static const std::string s_summaryFilterNodeNameString;
      static const std::string s_summaryPassNodeNameString;
      static const std::string s_summaryPassExpressNodeNameString;
      static const std::string s_summaryPrescaledNodeNameString;
 
   private:
      std::vector< std::string >& linkColNamesNC();
      std::vector< sgkey_t >& linkColKeysNC();
      std::vector< index_type >& linkColIndicesNC();
      std::vector< uint32_t >& linkColClidsNC();
 
      // Helper function, check for exact link match
      bool hasObjectLinkExact(const std::string& name, const sgkey_t key, const index_type index, const uint32_t clid) const;
 
      void copyLinkInternal(const xAOD::TrigComposite_v1& other, const size_t index, const std::string& newName);
 
      bool derivesFromIParticle(const CLID clid) const;
 
      template< class CONTAINER >
      void checkTypes(const CLID storedCLID, const std::string& name) const;
 
 
      static const std::string s_collectionSuffix;
 
   }; // class TrigComposite_v1
 
std::ostream& operator<<(std::ostream& os, const xAOD::TrigComposite_v1& tc);
 
 
} // namespace xAOD
 
// Include the template implementation:
#include "TrigComposite_v1.icc"
 
#endif // XAODTRIGGER_VERSIONS_TRIGCOMPOSITE_V1_H