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