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

File indexing completed on 2026-10-31 09:24:16

 // AUTOMATICALLY GENERATED FILE - DO NOT EDIT
 
 #ifndef EDM4EIC_MutableTrackerHit_H
 #define EDM4EIC_MutableTrackerHit_H
 
 #include "edm4eic/TrackerHitObj.h"
 // Make the immutable class available from its mutable version but not vice versa
 #include "edm4eic/TrackerHit.h"
 
 #include "edm4eic/CovDiag3f.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 TrackerHitCollection;
 class RawTrackerHit;
 class MutableRawTrackerHit;
 }
 
 
 namespace edm4eic {
 
 
 /** @class MutableTrackerHit
  *  Tracker hit (reconstructed from Raw)
  *  @author: W. Armstrong, S. Joosten
  */
 class MutableTrackerHit {
 
   friend class TrackerHitCollection;
   friend class TrackerHitMutableCollectionIterator;
   friend class TrackerHit;
 
 public:
   using object_type = TrackerHit;
   using collection_type = TrackerHitCollection;
 
   /// default constructor
   MutableTrackerHit() = default;
 
   /// Constructor initializing all members
   MutableTrackerHit(const std::uint64_t cellID, const edm4hep::Vector3f& position, const edm4eic::CovDiag3f& positionError, const float time, const float timeError, const float edep, const float edepError);
 
   /// copy constructor
   MutableTrackerHit(const MutableTrackerHit& other) = default;
 
   /// copy-assignment operator
   MutableTrackerHit& operator=(MutableTrackerHit other) &; // Rebind this to other's internal object
   MutableTrackerHit& operator=(MutableTrackerHit 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
   MutableTrackerHit clone(bool cloneRelations=true) const;
 
   /// destructor
   ~MutableTrackerHit() = default;
 
 
 public:
 
   /// Access the The detector specific (geometrical) cell id.
   std::uint64_t getCellID() const;
 
   /// Access the Hit (cell) position [mm]
   const edm4hep::Vector3f& getPosition() const;
 
   /// Access the Covariance Matrix
   const edm4eic::CovDiag3f& getPositionError() const;
 
   /// Access the Hit time [ns]
   float getTime() const;
 
   /// Access the Error on the time
   float getTimeError() const;
 
   /// Access the Energy deposit in this hit [GeV]
   float getEdep() const;
 
   /// Access the Error on the energy deposit [GeV]
   float getEdepError() const;
 
 
   /// Access the Related raw tracker hit
   const edm4eic::RawTrackerHit getRawHit() 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 Hit (cell) position [mm]
   void setPosition(const edm4hep::Vector3f& position);
   /// Get mutable reference to Hit (cell) position [mm]
   edm4hep::Vector3f& getPosition();
 
   /// Set the Covariance Matrix
   void setPositionError(const edm4eic::CovDiag3f& positionError);
   /// Get mutable reference to Covariance Matrix
   edm4eic::CovDiag3f& getPositionError();
 
   /// Set the Hit time [ns]
   void setTime(const float time);
   /// Get mutable reference to Hit time [ns]
   float& getTime();
 
   /// Set the Error on the time
   void setTimeError(const float timeError);
   /// Get mutable reference to Error on the time
   float& getTimeError();
 
   /// Set the Energy deposit in this hit [GeV]
   void setEdep(const float edep);
   /// Get mutable reference to Energy deposit in this hit [GeV]
   float& getEdep();
 
   /// Set the Error on the energy deposit [GeV]
   void setEdepError(const float edepError);
   /// Get mutable reference to Error on the energy deposit [GeV]
   float& getEdepError();
 
 
   /// Set the Related raw tracker hit
   void setRawHit(const edm4eic::RawTrackerHit& value);
 
 
 
 
   /// check whether the object is actually available
   bool isAvailable() const;
   /// disconnect from TrackerHitObj instance
   void unlink() { m_obj = podio::utils::MaybeSharedPtr<TrackerHitObj>{nullptr}; }
 
   constexpr bool operator==(const MutableTrackerHit& other) const { return m_obj == other.m_obj; }
   bool operator==(const TrackerHit& other) const;
 
   constexpr bool operator!=(const MutableTrackerHit& other) const { return !(*this == other); }
   bool operator!=(const TrackerHit& other) const { return !(*this == other); }
 
   // less comparison operator, so that objects can be e.g. stored in sets.
   bool operator<(const MutableTrackerHit& 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<MutableTrackerHit>;
 
   friend void swap(MutableTrackerHit& a, MutableTrackerHit& b) {
     using std::swap;
     swap(a.m_obj, b.m_obj); // swap out the internal pointers
   }
 
 private:
   /// constructor from existing TrackerHitObj
   explicit MutableTrackerHit(podio::utils::MaybeSharedPtr<TrackerHitObj> obj);
 
   podio::utils::MaybeSharedPtr<TrackerHitObj> m_obj{new TrackerHitObj{}, podio::utils::MarkOwned};
 };
 
 #if defined(PODIO_JSON_OUTPUT) && !defined(__CLING__)
 void to_json(nlohmann::json& j, const MutableTrackerHit& value);
 #endif
 
 
 } // namespace edm4eic
 
 
 
 template<>
 struct std::hash<edm4eic::MutableTrackerHit> {
   std::size_t operator()(const edm4eic::MutableTrackerHit& obj) const {
     return std::hash<edm4eic::TrackerHitObj*>{}(obj.m_obj.get());
   }
 };
 
 
 #endif

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