Cluster.h

Go to the documentation of this file.

#ifndef CLUSTER_H
#define CLUSTER_H

// C/C++ standard library
# include <iosfwd> // std::ostream

// LArSoft libraries
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h" // geo::PlaneID, geo::View_t


namespace recob {
  
  
  class Cluster {
      
    public:
      typedef int ID_t; 
      
      
      typedef enum {
        clStart,       
        clEnd,         
        NEnds,         
        clFirstEnd = 0 
      } ClusterEnds_t; 
      
      typedef enum {
        cmFit,          
        cmADC,          
        NChargeModes,   
        cmFirstMode = 0 
      } ChargeMode_t; 
      
      
      Cluster();
      
    private:
      
      unsigned int fNHits; 
      
      float fEndWires[NEnds];
      
      float fSigmaEndWires[NEnds];
      
      float fEndTicks[NEnds];
      
      float fSigmaEndTicks[NEnds];
      
      float fEndCharges[NEnds];
      
      float fAngles[NEnds];
      
      float fOpeningAngles[NEnds];
      
      
      float fChargeSum[NChargeModes];
      
      float fChargeStdDev[NChargeModes];
      
      float fChargeAverage[NChargeModes];
      
      float fMultipleHitDensity;
      
      float fWidth;
      
      ID_t fID;
      
      
      geo::View_t fView; 
      
      geo::PlaneID fPlaneID; 

      
    public:
      
      typedef struct {} SentryArgument_t;
      
      static constexpr ID_t InvalidID = -1;
      
      static const SentryArgument_t Sentry;
      
      
      Cluster(
        float start_wire,
        float sigma_start_wire,
        float start_tick,
        float sigma_start_tick,
        float start_charge,
        float start_angle,
        float start_opening,
        float end_wire,
        float sigma_end_wire,
        float end_tick,
        float sigma_end_tick,
        float end_charge,
        float end_angle,
        float end_opening,
        float integral,
        float integral_stddev,
        float summedADC,
        float summedADC_stddev,
        unsigned int n_hits,
        float multiple_hit_density,
        float width,
        ID_t ID,
        geo::View_t view,
        geo::PlaneID const& plane,
        SentryArgument_t sentry = Sentry
        );
      
      
      Cluster(Cluster const&) = default;
      
      Cluster(Cluster&& from): Cluster(from) { from.fID = InvalidID; }
      
      Cluster& operator= (Cluster const&) = default;
      
      Cluster& operator= (Cluster&& from)
        {
          if (&from != this) { operator=(from); from.fID = InvalidID; }
          return *this;
        }
      
      ~Cluster() = default;
      
      
      
      unsigned int NHits() const { return fNHits; }
      
      float StartWire() const { return fEndWires[clStart]; }
      
      float StartTick() const { return fEndTicks[clStart]; }
      
      float SigmaStartWire() const { return fSigmaEndWires[clStart]; }
      
      float SigmaStartTick() const { return fSigmaEndTicks[clStart]; }
      
      
      float EndWire() const { return fEndWires[clEnd]; }
      
      float EndTick() const { return fEndTicks[clEnd]; }
      
      float SigmaEndWire() const { return fSigmaEndWires[clEnd]; }
      
      float SigmaEndTick() const { return fSigmaEndTicks[clEnd]; }
      
      

      float WireCoord(ClusterEnds_t side) const { return fEndWires[side]; }
      float WireCoord(unsigned int side) const { return fEndWires[side]; }
      

      float TickCoord(ClusterEnds_t side) const { return fEndTicks[side]; }
      float TickCoord(unsigned int side) const { return fEndTicks[side]; }
      
      

      float SigmaWireCoord(ClusterEnds_t side) const { return fSigmaEndWires[side]; }
      float SigmaWireCoord(unsigned int side) const { return fSigmaEndWires[side]; }
      

      float SigmaTickCoord(ClusterEnds_t side) const { return fSigmaEndTicks[side]; }
      float SigmaTickCoord(unsigned int side) const { return fSigmaEndTicks[side]; }
      
      
      float StartCharge() const { return fEndCharges[clStart]; }
      
      float StartAngle() const { return fAngles[clStart]; }
      
      float StartOpeningAngle() const { return fOpeningAngles[clStart]; }
      
      
      float EndCharge() const { return fEndCharges[clEnd]; }
      
      float EndAngle() const { return fAngles[clEnd]; }
      
      float EndOpeningAngle() const { return fOpeningAngles[clEnd]; }
      
      

      float EdgeCharge(ClusterEnds_t side) const { return fEndCharges[side]; }
      float EdgeCharge(unsigned int side) const { return fEndCharges[side]; }
      

      float Angle(ClusterEnds_t side) const { return fAngles[side]; }
      float Angle(unsigned int side) const { return fAngles[side]; }
      

      float OpeningAngle(ClusterEnds_t side) const
        { return fOpeningAngles[side]; }
      float OpeningAngle(unsigned int side) const
        { return fOpeningAngles[side]; }
      
      
      float Integral() const { return fChargeSum[cmFit]; }
      
      float IntegralStdDev() const { return fChargeStdDev[cmFit]; }
      
      float IntegralAverage() const { return fChargeAverage[cmFit]; }
      
      
      float SummedADC() const { return fChargeSum[cmADC]; }
      
      float SummedADCstdDev() const { return fChargeStdDev[cmADC]; }
      
      float SummedADCaverage() const { return fChargeAverage[cmADC]; }
      
      

      float Charge(ChargeMode_t mode) const { return fChargeSum[mode]; }
      float Charge(unsigned int mode) const { return fChargeSum[mode]; }
      

      float ChargeStdDev(ChargeMode_t mode) const
        { return fChargeStdDev[mode]; }
      float ChargeStdDev(unsigned int mode) const
        { return fChargeStdDev[mode]; }
      

      float ChargeAverage(ChargeMode_t mode) const
        { return fChargeAverage[mode]; }
      float ChargeAverage(unsigned int mode) const
        { return fChargeAverage[mode]; }
      
      float MultipleHitDensity() const { return fMultipleHitDensity; }
      
      
      float Width() const { return fWidth; }
      
      
      ID_t  ID() const { return fID; }
      
      geo::View_t View() const { return fView; }
      
      geo::PlaneID Plane() const { return fPlaneID; }
      
      
      bool hasPlane() const { return fPlaneID.isValid; }
      
      
      bool isValid() const { return ID() != InvalidID; }
      
      
      friend std::ostream& operator << (std::ostream& o, Cluster const& c);
      friend bool          operator <  (Cluster const& a, Cluster const& b);
    
    
  }; // class Cluster
  
} // namespace recob


#endif //CLUSTER_H