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

File indexing completed on 2026-10-04 09:03:31

 // AUTOMATICALLY GENERATED FILE - DO NOT EDIT
 
 #ifndef EDM4EIC_MutablePMTHit_H
 #define EDM4EIC_MutablePMTHit_H
 
 #include "edm4eic/PMTHitObj.h"
 // Make the immutable class available from its mutable version but not vice versa
 #include "edm4eic/PMTHit.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 PMTHitCollection;
 }
 
 
 namespace edm4eic {
 
 
 /** @class MutablePMTHit
  *  EIC PMT hit
  *  @author: S. Joosten, C. Peng
  */
 class MutablePMTHit {
 
   friend class PMTHitCollection;
   friend class PMTHitMutableCollectionIterator;
   friend class PMTHit;
 
 public:
   using object_type = PMTHit;
   using collection_type = PMTHitCollection;
 
   /// default constructor
   MutablePMTHit() = default;
 
   /// Constructor initializing all members
   MutablePMTHit(const std::uint64_t cellID, const float npe, const float time, const float timeError, const edm4hep::Vector3f& position, const edm4hep::Vector3f& dimension, const std::int32_t sector, const edm4hep::Vector3f& local);
 
   /// copy constructor
   MutablePMTHit(const MutablePMTHit& other) = default;
 
   /// copy-assignment operator
   MutablePMTHit& operator=(MutablePMTHit other) &; // Rebind this to other's internal object
   MutablePMTHit& operator=(MutablePMTHit other) && = delete; // Prevent rebinding temporary as the changes wouldn't persist
 
   /// create a mutable deep-copy of the object with identical relations
   /// if cloneRelations=false, the relations are not cloned and will be empty
   MutablePMTHit clone(bool cloneRelations=true) const;
 
   /// destructor
   ~MutablePMTHit() = default;
 
 
 public:
 
   /// Access the The detector specific (geometrical) cell id.
   std::uint64_t getCellID() const;
 
   /// Access the Estimated number of photo-electrons [#]
   float getNpe() const;
 
   /// Access the Time [ns]
   float getTime() const;
 
   /// Access the Error on the time [ns]
   float getTimeError() const;
 
   /// Access the PMT hit position [mm]
   const edm4hep::Vector3f& getPosition() const;
 
   /// Access the The dimension information of the pixel [mm].
   const edm4hep::Vector3f& getDimension() const;
 
   /// Access the The sector this hit occurred in
   std::int32_t getSector() const;
 
   /// Access the The local position of the hit in detector coordinates (relative to the sector) [mm]
   const edm4hep::Vector3f& getLocal() const;
 
 
 
   /// Set the The detector specific (geometrical) cell id.
   void setCellID(const std::uint64_t cellID);
   /// Get mutable reference to The detector specific (geometrical) cell id.
   std::uint64_t& getCellID();
 
   /// Set the Estimated number of photo-electrons [#]
   void setNpe(const float npe);
   /// Get mutable reference to Estimated number of photo-electrons [#]
   float& getNpe();
 
   /// Set the Time [ns]
   void setTime(const float time);
   /// Get mutable reference to Time [ns]
   float& getTime();
 
   /// Set the Error on the time [ns]
   void setTimeError(const float timeError);
   /// Get mutable reference to Error on the time [ns]
   float& getTimeError();
 
   /// Set the PMT hit position [mm]
   void setPosition(const edm4hep::Vector3f& position);
   /// Get mutable reference to PMT hit position [mm]
   edm4hep::Vector3f& getPosition();
 
   /// Set the The dimension information of the pixel [mm].
   void setDimension(const edm4hep::Vector3f& dimension);
   /// Get mutable reference to The dimension information of the pixel [mm].
   edm4hep::Vector3f& getDimension();
 
   /// Set the The sector this hit occurred in
   void setSector(const std::int32_t sector);
   /// Get mutable reference to The sector this hit occurred in
   std::int32_t& getSector();
 
   /// Set the The local position of the hit in detector coordinates (relative to the sector) [mm]
   void setLocal(const edm4hep::Vector3f& local);
   /// Get mutable reference to The local position of the hit in detector coordinates (relative to the sector) [mm]
   edm4hep::Vector3f& getLocal();
 
 
 
 
 
 
   /// check whether the object is actually available
   bool isAvailable() const;
   /// disconnect from PMTHitObj instance
   void unlink() { m_obj = podio::utils::MaybeSharedPtr<PMTHitObj>{nullptr}; }
 
   constexpr bool operator==(const MutablePMTHit& other) const { return m_obj == other.m_obj; }
   bool operator==(const PMTHit& other) const;
 
   constexpr bool operator!=(const MutablePMTHit& other) const { return !(*this == other); }
   bool operator!=(const PMTHit& other) const { return !(*this == other); }
 
   // less comparison operator, so that objects can be e.g. stored in sets.
   bool operator<(const MutablePMTHit& other) const { return podio::detail::getOrderKey(*this) < podio::detail::getOrderKey(other); }
 
   podio::ObjectID id() const { return getObjectID(); }
 
   const podio::ObjectID getObjectID() const;
 
   friend std::hash<MutablePMTHit>;
 
   friend void swap(MutablePMTHit& a, MutablePMTHit& b) {
     using std::swap;
     swap(a.m_obj, b.m_obj); // swap out the internal pointers
   }
 
 private:
   /// constructor from existing PMTHitObj
   explicit MutablePMTHit(podio::utils::MaybeSharedPtr<PMTHitObj> obj);
 
   podio::utils::MaybeSharedPtr<PMTHitObj> m_obj{new PMTHitObj{}, podio::utils::MarkOwned};
 };
 
 #if defined(PODIO_JSON_OUTPUT) && !defined(__CLING__)
 void to_json(nlohmann::json& j, const MutablePMTHit& value);
 #endif
 
 
 } // namespace edm4eic
 
 
 
 template<>
 struct std::hash<edm4eic::MutablePMTHit> {
   std::size_t operator()(const edm4eic::MutablePMTHit& obj) const {
     return std::hash<edm4eic::PMTHitObj*>{}(obj.m_obj.get());
   }
 };
 
 
 #endif

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