EIC code displayed by LXR master/​include/​edm4eic/​MutableCalorimeterHit.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-07-03 08:34:32

 // AUTOMATICALLY GENERATED FILE - DO NOT EDIT
 
 #ifndef EDM4EIC_MutableCalorimeterHit_H
 #define EDM4EIC_MutableCalorimeterHit_H
 
 #include "edm4eic/CalorimeterHitObj.h"
 // Make the immutable class available from its mutable version but not vice versa
 #include "edm4eic/CalorimeterHit.h"
 
 #include "edm4hep/Vector3f.h"
 #include <cstdint>
 
 #include "podio/utilities/MaybeSharedPtr.h"
 
 #include <cstdint>
 
 #if defined(PODIO_JSON_OUTPUT) && !defined(__CLING__)
 #include "nlohmann/json_fwd.hpp"
 #endif
 
 // forward declarations
 namespace edm4eic {
 class CalorimeterHitCollection;
 }
 namespace edm4hep {
 class RawCalorimeterHit;
 class MutableRawCalorimeterHit;
 }
 
 
 namespace edm4eic {
 
 
 /** @class MutableCalorimeterHit
  *  Calorimeter hit
  *  @author: W. Armstrong, S. Joosten
  */
 class MutableCalorimeterHit {
 
   friend class CalorimeterHitCollection;
   friend class CalorimeterHitMutableCollectionIterator;
   friend class CalorimeterHit;
 
 public:
   using object_type = CalorimeterHit;
   using collection_type = CalorimeterHitCollection;
 
   /// default constructor
   MutableCalorimeterHit();
 
   /// Constructor initializing all members
   MutableCalorimeterHit(std::uint64_t cellID, float energy, float energyError, float time, float timeError, edm4hep::Vector3f position, edm4hep::Vector3f dimension, std::int32_t sector, std::int32_t layer, edm4hep::Vector3f local);
 
   /// copy constructor
   MutableCalorimeterHit(const MutableCalorimeterHit& other) = default;
 
   /// copy-assignment operator
   MutableCalorimeterHit& operator=(MutableCalorimeterHit other);
 
   /// create a mutable deep-copy of the object with identical relations
   /// if cloneRelations=false, the relations are not cloned and will be empty
   MutableCalorimeterHit clone(bool cloneRelations=true) const;
 
   /// destructor
   ~MutableCalorimeterHit() = default;
 
 
 public:
 
   /// Access the The detector specific (geometrical) cell id.
   std::uint64_t getCellID() const;
 
   /// Access the The energy for this hit in [GeV].
   float getEnergy() const;
 
   /// Access the Error on energy [GeV].
   float getEnergyError() const;
 
   /// Access the The time of the hit in [ns].
   float getTime() const;
 
   /// Access the Error on the time
   float getTimeError() const;
 
   /// Access the The global position of the hit in world coordinates [mm].
   const edm4hep::Vector3f& getPosition() const;
 
   /// Access the The dimension information of the cell [mm].
   const edm4hep::Vector3f& getDimension() const;
 
   /// Access the Sector that this hit occurred in
   std::int32_t getSector() const;
 
   /// Access the Layer that the hit occurred in
   std::int32_t getLayer() const;
 
   /// Access the The local coordinates of the hit in the detector segment [mm].
   const edm4hep::Vector3f& getLocal() const;
 
 
   /// Access the Related raw calorimeter hit
   const edm4hep::RawCalorimeterHit getRawHit() const;
 
   /// Set the The detector specific (geometrical) cell id.
   void setCellID(std::uint64_t value);
   /// Get mutable reference to The detector specific (geometrical) cell id.
   std::uint64_t& getCellID();
   /// Get reference to The detector specific (geometrical) cell id.
   [[deprecated("use getCellID instead")]]
   std::uint64_t& cellID();
 
   /// Set the The energy for this hit in [GeV].
   void setEnergy(float value);
   /// Get mutable reference to The energy for this hit in [GeV].
   float& getEnergy();
   /// Get reference to The energy for this hit in [GeV].
   [[deprecated("use getEnergy instead")]]
   float& energy();
 
   /// Set the Error on energy [GeV].
   void setEnergyError(float value);
   /// Get mutable reference to Error on energy [GeV].
   float& getEnergyError();
   /// Get reference to Error on energy [GeV].
   [[deprecated("use getEnergyError instead")]]
   float& energyError();
 
   /// Set the The time of the hit in [ns].
   void setTime(float value);
   /// Get mutable reference to The time of the hit in [ns].
   float& getTime();
   /// Get reference to The time of the hit in [ns].
   [[deprecated("use getTime instead")]]
   float& time();
 
   /// Set the Error on the time
   void setTimeError(float value);
   /// Get mutable reference to Error on the time
   float& getTimeError();
   /// Get reference to Error on the time
   [[deprecated("use getTimeError instead")]]
   float& timeError();
 
   /// Set the The global position of the hit in world coordinates [mm].
   void setPosition(edm4hep::Vector3f value);
   /// Get mutable reference to The global position of the hit in world coordinates [mm].
   edm4hep::Vector3f& getPosition();
   /// Get reference to The global position of the hit in world coordinates [mm].
   [[deprecated("use getPosition instead")]]
   edm4hep::Vector3f& position();
 
   /// Set the The dimension information of the cell [mm].
   void setDimension(edm4hep::Vector3f value);
   /// Get mutable reference to The dimension information of the cell [mm].
   edm4hep::Vector3f& getDimension();
   /// Get reference to The dimension information of the cell [mm].
   [[deprecated("use getDimension instead")]]
   edm4hep::Vector3f& dimension();
 
   /// Set the Sector that this hit occurred in
   void setSector(std::int32_t value);
   /// Get mutable reference to Sector that this hit occurred in
   std::int32_t& getSector();
   /// Get reference to Sector that this hit occurred in
   [[deprecated("use getSector instead")]]
   std::int32_t& sector();
 
   /// Set the Layer that the hit occurred in
   void setLayer(std::int32_t value);
   /// Get mutable reference to Layer that the hit occurred in
   std::int32_t& getLayer();
   /// Get reference to Layer that the hit occurred in
   [[deprecated("use getLayer instead")]]
   std::int32_t& layer();
 
   /// Set the The local coordinates of the hit in the detector segment [mm].
   void setLocal(edm4hep::Vector3f value);
   /// Get mutable reference to The local coordinates of the hit in the detector segment [mm].
   edm4hep::Vector3f& getLocal();
   /// Get reference to The local coordinates of the hit in the detector segment [mm].
   [[deprecated("use getLocal instead")]]
   edm4hep::Vector3f& local();
 
 
   /// Set the Related raw calorimeter hit
   void setRawHit(const edm4hep::RawCalorimeterHit& value);
 
 
 
 
   /// check whether the object is actually available
   bool isAvailable() const;
   /// disconnect from CalorimeterHitObj instance
   void unlink() { m_obj = podio::utils::MaybeSharedPtr<CalorimeterHitObj>{nullptr}; }
 
   bool operator==(const MutableCalorimeterHit& other) const { return m_obj == other.m_obj; }
   bool operator==(const CalorimeterHit& other) const;
 
   bool operator!=(const MutableCalorimeterHit& other) const { return !(*this == other); }
   bool operator!=(const CalorimeterHit& other) const { return !(*this == other); }
 
   // less comparison operator, so that objects can be e.g. stored in sets.
   bool operator<(const MutableCalorimeterHit& other) const { return podio::detail::getOrderKey(*this) < podio::detail::getOrderKey(other); }
 
   podio::ObjectID id() const { return getObjectID(); }
 
   const podio::ObjectID getObjectID() const;
 
   friend void swap(MutableCalorimeterHit& a, MutableCalorimeterHit& b) {
     using std::swap;
     swap(a.m_obj, b.m_obj); // swap out the internal pointers
   }
 
 private:
   /// constructor from existing CalorimeterHitObj
   explicit MutableCalorimeterHit(podio::utils::MaybeSharedPtr<CalorimeterHitObj> obj);
 
   podio::utils::MaybeSharedPtr<CalorimeterHitObj> m_obj{nullptr};
 };
 
 #if defined(PODIO_JSON_OUTPUT) && !defined(__CLING__)
 void to_json(nlohmann::json& j, const MutableCalorimeterHit& value);
 #endif
 
 
 } // namespace edm4eic
 
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team