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

File indexing completed on 2026-06-04 08:12:04

 // AUTOMATICALLY GENERATED FILE - DO NOT EDIT
 
 #ifndef ACTSPODIOEDM_MutableTrackerHitLocal_H
 #define ACTSPODIOEDM_MutableTrackerHitLocal_H
 
 #include "ActsPodioEdm/TrackerHitLocalObj.h"
 // Make the immutable class available from its mutable version but not vice
 // versa
 #include "ActsPodioEdm/TrackerHitLocal.h"
 
 #include <cstdint>
 #include <vector>
 
 #include "edm4hep/Vector3d.h"
 #include "podio/RelationRange.h"
 #include "podio/utilities/MaybeSharedPtr.h"
 
 #if defined(PODIO_JSON_OUTPUT) && !defined(__CLING__)
 #include "nlohmann/json_fwd.hpp"
 #endif
 
 // forward declarations
 namespace ActsPodioEdm {
 class TrackerHitLocalCollection;
 }
 
 namespace ActsPodioEdm {
 
 /** @class MutableTrackerHitLocal
  *  Sensor-local tracker hit
  *  @author: Paul Gessinger, CERN
  */
 class MutableTrackerHitLocal {
   friend class TrackerHitLocalCollection;
   friend class TrackerHitLocalMutableCollectionIterator;
   friend class TrackerHitLocal;
 
  public:
   using object_type = TrackerHitLocal;
   using collection_type = TrackerHitLocalCollection;
 
   /// default constructor
   MutableTrackerHitLocal() = default;
 
   /// Constructor initializing all members
   MutableTrackerHitLocal(const std::uint64_t cellID, const std::int32_t type,
                          const std::int32_t quality, const float time,
                          const float eDep, const float eDepError,
                          const edm4hep::Vector3d& position);
 
   /// copy constructor
   MutableTrackerHitLocal(const MutableTrackerHitLocal& other) = default;
 
   /// copy-assignment operator
   MutableTrackerHitLocal& operator=(
       MutableTrackerHitLocal
           other) &;  // Rebind this to other's internal object
   MutableTrackerHitLocal& operator=(MutableTrackerHitLocal 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
   MutableTrackerHitLocal clone(bool cloneRelations = true) const;
 
   /// destructor
   ~MutableTrackerHitLocal() = default;
 
  public:
   /// Access the ID of the sensor that created this hit
   std::uint64_t getCellID() const;
 
   /// Access the type of raw data hit, use depends on writer
   std::int32_t getType() const;
 
   /// Access the quality bit flag of the hit
   std::int32_t getQuality() const;
 
   /// Access the time of the hit (depends on measurement type) [ns]
   float getTime() const;
 
   /// Access the energy deposited on the hit (optional) [GeV]
   float getEDep() const;
 
   /// Access the error measured on EDep (optional) [GeV]
   float getEDepError() const;
 
   /// Access the global hit position (depends on measurement type) [mm]
   const edm4hep::Vector3d& getPosition() const;
 
   /// Set the ID of the sensor that created this hit
   void setCellID(const std::uint64_t cellID);
   /// Get mutable reference to ID of the sensor that created this hit
   std::uint64_t& getCellID();
   /// Get reference to ID of the sensor that created this hit
   [[deprecated("use getCellID instead")]]
   std::uint64_t& cellID();
 
   /// Set the type of raw data hit, use depends on writer
   void setType(const std::int32_t type);
   /// Get mutable reference to type of raw data hit, use depends on writer
   std::int32_t& getType();
   /// Get reference to type of raw data hit, use depends on writer
   [[deprecated("use getType instead")]]
   std::int32_t& type();
 
   /// Set the quality bit flag of the hit
   void setQuality(const std::int32_t quality);
   /// Get mutable reference to quality bit flag of the hit
   std::int32_t& getQuality();
   /// Get reference to quality bit flag of the hit
   [[deprecated("use getQuality instead")]]
   std::int32_t& quality();
 
   /// Set the time of the hit (depends on measurement type) [ns]
   void setTime(const float time);
   /// Get mutable reference to time of the hit (depends on measurement type)
   /// [ns]
   float& getTime();
   /// Get reference to time of the hit (depends on measurement type) [ns]
   [[deprecated("use getTime instead")]]
   float& time();
 
   /// Set the energy deposited on the hit (optional) [GeV]
   void setEDep(const float eDep);
   /// Get mutable reference to energy deposited on the hit (optional) [GeV]
   float& getEDep();
   /// Get reference to energy deposited on the hit (optional) [GeV]
   [[deprecated("use getEDep instead")]]
   float& eDep();
 
   /// Set the error measured on EDep (optional) [GeV]
   void setEDepError(const float eDepError);
   /// Get mutable reference to error measured on EDep (optional) [GeV]
   float& getEDepError();
   /// Get reference to error measured on EDep (optional) [GeV]
   [[deprecated("use getEDepError instead")]]
   float& eDepError();
 
   /// Set the global hit position (depends on measurement type) [mm]
   void setPosition(const edm4hep::Vector3d& position);
   /// Get mutable reference to global hit position (depends on measurement type)
   /// [mm]
   edm4hep::Vector3d& getPosition();
   /// Get reference to global hit position (depends on measurement type) [mm]
   [[deprecated("use getPosition instead")]]
   edm4hep::Vector3d& position();
 
   void addToMeasurement(const float&);
   std::size_t measurement_size() const;
   float getMeasurement(std::size_t) const;
   std::vector<float>::const_iterator measurement_begin() const;
   std::vector<float>::const_iterator measurement_end() const;
   podio::RelationRange<float> getMeasurement() const;
   void addToCovariance(const float&);
   std::size_t covariance_size() const;
   float getCovariance(std::size_t) const;
   std::vector<float>::const_iterator covariance_begin() const;
   std::vector<float>::const_iterator covariance_end() const;
   podio::RelationRange<float> getCovariance() const;
 
   /// check whether the object is actually available
   bool isAvailable() const;
   /// disconnect from TrackerHitLocalObj instance
   void unlink() {
     m_obj = podio::utils::MaybeSharedPtr<TrackerHitLocalObj>{nullptr};
   }
 
   bool operator==(const MutableTrackerHitLocal& other) const {
     return m_obj == other.m_obj;
   }
   bool operator==(const TrackerHitLocal& other) const;
 
   bool operator!=(const MutableTrackerHitLocal& other) const {
     return !(*this == other);
   }
   bool operator!=(const TrackerHitLocal& other) const {
     return !(*this == other);
   }
 
   // less comparison operator, so that objects can be e.g. stored in sets.
   bool operator<(const MutableTrackerHitLocal& 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<MutableTrackerHitLocal>;
 
   friend void swap(MutableTrackerHitLocal& a, MutableTrackerHitLocal& b) {
     using std::swap;
     swap(a.m_obj, b.m_obj);  // swap out the internal pointers
   }
 
  private:
   /// constructor from existing TrackerHitLocalObj
   explicit MutableTrackerHitLocal(
       podio::utils::MaybeSharedPtr<TrackerHitLocalObj> obj);
 
   podio::utils::MaybeSharedPtr<TrackerHitLocalObj> m_obj{
       new TrackerHitLocalObj{}, podio::utils::MarkOwned};
 };
 
 #if defined(PODIO_JSON_OUTPUT) && !defined(__CLING__)
 void to_json(nlohmann::json& j, const MutableTrackerHitLocal& value);
 #endif
 
 }  // namespace ActsPodioEdm
 
 template <>
 struct std::hash<ActsPodioEdm::MutableTrackerHitLocal> {
   std::size_t operator()(
       const ActsPodioEdm::MutableTrackerHitLocal& obj) const {
     return std::hash<ActsPodioEdm::TrackerHitLocalObj*>{}(obj.m_obj.get());
   }
 };
 
 #endif

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