HepMcParticleLink.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef GENERATOROBJECTS_HEPMCPARTICLELINK_H
#define GENERATOROBJECTS_HEPMCPARTICLELINK_H
 
#include "SGTools/DataProxy.h"
#include "SGTools/CurrentEventStore.h"
#include "AthenaKernel/ExtendedEventContext.h"
#include "CxxUtils/CachedValue.h"
#include "CxxUtils/no_unique_address.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/EventContext.h"
#include <cassert>
#include <cstdint> /*int32_t etc*/
#include <iostream>
#include <limits>  /* numeric_limits */
#include <string>
#include <vector>
 
#include "AtlasHepMC/GenEvent_fwd.h"
#include "AtlasHepMC/GenParticle.h"
#include "TruthUtils/MagicNumbers.h"
 
class IProxyDict;
class McEventCollection;
 
class HepMcParticleLink
{
public:
  typedef uint32_t barcode_type;
  typedef uint32_t index_type;
 
 
  enum PositionFlag {
    IS_EVENTNUM = 0,
    IS_POSITION = 1,
  };
 
  enum UniqueIDFlag {
    IS_ID = 0,
    IS_BARCODE = 1,
  };
 
 
  class ExtendedBarCode {
  public:
    constexpr static index_type UNDEFINED = ~static_cast<index_type>(0); // TODO Move to MagicNumbers.h?
    constexpr static barcode_type UNDEFINEDBC = ~static_cast<barcode_type>(0); // TODO Move to MagicNumbers.h?
 
 
    ExtendedBarCode();
 
 
    ExtendedBarCode (barcode_type uid,
                     index_type eventIndex,
                     PositionFlag isIndexEventPosition = IS_EVENTNUM,
                     UniqueIDFlag isUniqueIDBarcode = IS_ID);
 
    ExtendedBarCode(const ExtendedBarCode& rhs);
 
 
    ExtendedBarCode(ExtendedBarCode&& rhs) noexcept;
 
 
    ExtendedBarCode& operator= (const ExtendedBarCode& rhs);
 
    ExtendedBarCode& operator= (ExtendedBarCode&& rhs) noexcept;
 
    barcode_type uid() const;
 
    void uniqueID(barcode_type& id, barcode_type& barcode) const;
 
    void eventIndex (index_type& index, index_type& position) const;
 
 
    bool linkIsNull() const;
 
 
    inline EBC_SUPPRESSED_TRUTH getTruthSuppressionType() const { return m_truthSupp; }
 
 
    inline void setTruthSuppressionType(EBC_SUPPRESSED_TRUTH truthSupp) { m_truthSupp = truthSupp; }
 
 
    char getTruthSuppressionTypeAsChar() const;
 
 
    static char truthSuppressionTypeAsChar (EBC_SUPPRESSED_TRUTH suppEnum);
 
 
    static EBC_SUPPRESSED_TRUTH truthSuppressionTypeFromChar (char suppChar);
 
 
    bool operator == (const ExtendedBarCode& rhs ) const;
 
 
    bool operator != (const ExtendedBarCode& rhs ) const;
 
 
    bool operator < (const ExtendedBarCode& rhs ) const;
 
 
    static
    int compareIndex (const HepMcParticleLink& lhs,
                      const HepMcParticleLink& rhs);
 
 
    static
    int compareUniqueID (const HepMcParticleLink& lhs,
                      const HepMcParticleLink& rhs);
 
 
    void print(std::ostream& os) const;
 
 
    void print(MsgStream& os) const;
 
 
    void makeIndex (index_type index, index_type position) const;
 
 
    void makeID (barcode_type ID, barcode_type barcode) const;
 
 
  private:
    constexpr static index_type POSITION_MASK = UNDEFINED ^ (UNDEFINED>>1);
 
    constexpr static barcode_type BARCODE_MASK = UNDEFINEDBC ^ (UNDEFINEDBC>>1);
 
    void setIndex (index_type idx, PositionFlag positionFlag);
 
 
    void setUniqueID (barcode_type uid, UniqueIDFlag barcodeFlag);
 
 
    mutable std::atomic<barcode_type> m_BC;
 
    mutable std::atomic<index_type> m_evtIndex{0};
 
    EBC_SUPPRESSED_TRUTH m_truthSupp{EBC_UNSUPPRESSED};
  };
 
 
  HepMcParticleLink (IProxyDict* sg = nullptr);
 
 
  HepMcParticleLink (const EventContext& ctx);
 
 
  HepMcParticleLink (barcode_type uid,
                     uint32_t eventIndex /*= 0*/,
                     PositionFlag positionFlag /*= IS_EVENTNUM*/,
                     UniqueIDFlag uniqueIDFlag /*= IS_ID*/,
                     IProxyDict* sg = SG::CurrentEventStore::store());
 
 
  HepMcParticleLink (barcode_type uid,
                     uint32_t eventIndex,
                     PositionFlag positionFlag,
                     UniqueIDFlag uniqueIDFlag,
                     const EventContext& ctx);
 
 
  HepMcParticleLink (const HepMC::ConstGenParticlePtr& p,
                     uint32_t eventIndex /*= 0 */,
                     PositionFlag positionFlag /*= IS_EVENTNUM */,
                     IProxyDict* sg = SG::CurrentEventStore::store());
 
 
  HepMcParticleLink (const HepMC::ConstGenParticlePtr& part,
                     uint32_t eventIndex,
                     PositionFlag positionFlag,
                     const EventContext& ctx);
 
 
  HepMcParticleLink(const HepMcParticleLink& rhs) = default;
 
 
  HepMcParticleLink(HepMcParticleLink&& rhs) noexcept = default;
 
  HepMcParticleLink& operator=(const HepMcParticleLink& rhs) = default;
 
  HepMcParticleLink& operator=(HepMcParticleLink&& rhs) = default;
 
 
 
 
 
  const HepMC::GenParticle& operator* () const;
 
 
  HepMC::ConstGenParticlePtr operator->() const;
 
 
  operator HepMC::ConstGenParticlePtr() const;
 
 
  HepMC::ConstGenParticlePtr cptr() const;
 
 
  HepMC::ConstGenParticlePtr scptr() const { return cptr(); }
 
 
  bool linkIsNull() const;
 
 
  bool isValid() const;
 
 
  bool operator!() const;
 
  operator bool() const;
 
 
 
 
 
  bool operator == (const HepMcParticleLink& rhs) const;
 
 
  bool operator != (const HepMcParticleLink& rhs) const;
 
 
  bool operator < (const HepMcParticleLink& rhs) const;
 
 
 
 
 
 
  int barcode() const;
 
 
  int id() const;
 
 
  index_type eventIndex() const;
 
 
  static int getEventNumberAtPosition (index_type position, const IProxyDict* sg);
 
 
  static std::vector<index_type> getEventPositionInCollection (index_type index, const IProxyDict* sg);
 
 
  index_type getEventPositionInCollection (const IProxyDict* sg) const;
 
 
  static HepMcParticleLink getRedirectedLink(const HepMcParticleLink& particleLink, uint32_t eventIndex, const EventContext& ctx);
 
 
  EBC_SUPPRESSED_TRUTH getTruthSuppressionType() const;
 
 
  void setTruthSuppressionType(EBC_SUPPRESSED_TRUTH truthSupp);
 
 
  char getTruthSuppressionTypeAsChar() const;
 
 
  barcode_type compress() const;
 
 
  void setExtendedBarCode (const ExtendedBarCode& extBarcode);
 
 
 
 
 private:
  friend std::ostream& operator << (std::ostream&, const HepMcParticleLink&);
  friend MsgStream& operator << (MsgStream&, const HepMcParticleLink&);
 
 
   static const McEventCollection*
   retrieveMcEventCollection (const IProxyDict* sg);
 
 
  static SG::DataProxy* find_proxy (const IProxyDict* sg);
 
 
  static std::string getLastEventCollectionName ();
 
 
  IProxyDict* m_store;
 
 
  // This qualifier allows m_extBarcode to overlap the trailing padding
  // of @c CachedValue.  On x86_64, this reduces the size
  // of @c HepMcParticleLink from 48 to 40.
  ATH_NO_UNIQUE_ADDRESS
  CxxUtils::CachedValue<HepMC::ConstGenParticlePtr> m_ptr;
 
 
  ExtendedBarCode m_extBarcode;
};
 
 
bool operator== (HepMC::ConstGenParticlePtr a,
                 const HepMcParticleLink& b);
 
 
std::ostream& operator<< (std::ostream& os, const HepMcParticleLink& link);
 
 
MsgStream& operator<< (MsgStream& os, const HepMcParticleLink& link);
 
 
#include "GeneratorObjects/HepMcParticleLink.icc"
 
 
#endif