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