include/N3AnaBase/event/gg_hit.h

#ifndef __N3AnaBase__gg_hit_h
#define __N3AnaBase__gg_hit_h 1

#include <stdexcept>
#include <iostream>
#include <sstream>
#include <string>
#include <cmath>
#include <limits>

#include <datatools/serialization/serialization.h>
#include <datatools/utils/i_tree_dump.h>
#include <datatools/utils/i_clear.h>
#include <datatools/utils/i_propinit.h>
#include <datatools/utils/properties.h>

#include <geomtools/utils.h>

#include <N3GeomDef/N3GeigerGeom.h>
#include <N3Event/N3StdTrackedEvent.h>

#include <N3AnaBase/event/event_utils.h>

namespace nemo3 {
  
  template<class Archive>
  void serialize (Archive & ar_, 
                  nemo3::gg_hit_id & id_, 
                  const unsigned int version_)
  {
    ar_ & boost::serialization::make_nvp ("sector", id_.fSector);
    ar_ & boost::serialization::make_nvp ("side",   id_.fIo);
    ar_ & boost::serialization::make_nvp ("plane",  id_.fAbcg);
    ar_ & boost::serialization::make_nvp ("cell",   id_.fNcell);
  }

  class gg_hit : 
    public datatools::utils::i_tree_dumpable,
    public datatools::utils::i_clear,
    public datatools::serialization::i_serializable  
  {
  public:
    static const int    INVALID_NUMBER = -1;
    static const double INVALID_Z_VALUE;
    static const double INVALID_POS_VALUE;
    static const double MISSING_BOTH_Z;
    static const double MISSING_BOTH_SIGMA_Z;
    static const std::string NEMOS_STATUS_LABEL;
    static const std::string MISSING_HIT_LABEL;
    static const int32_t MISSING_TOP_BOTTOM = 0;
    static const double CELL_RADIUS;
    // see also GeigerHitCalibData::kCELL_RADIUS (cm)

  private: 

    int32_t                      __number;
    gg_hit_id                    __id;
    datatools::utils::properties __properties;
    int32_t                      __fast_tdc;
    int32_t                      __slow_tdc;
    int32_t                      __time_bottom;
    int32_t                      __time_top;
    bool                         __off;
    bool                         __noisy;
    bool                         __delayed;
    bool                         __hot;
    double                       __x;       // cm
    double                       __y;       // cm
    double                       __z;       // cm
    double                       __sigma_z; // cm
    double                       __r;       // cm
    double                       __sigma_r; // cm

  public: 

    geomtools::vector_3d get_position () const
    {
      return geomtools::vector_3d (__x, __y, __z);
    }

    int get_sector () const
    {
      return __id.get_sector ();
    }

    int get_side () const
    {
      return __id.get_side ();
    }

    int get_plane () const
    {
      return __id.get_plane ();
    }

    int get_cell () const
    {
      return __id.get_cell ();
    }

    bool is_normal () const;

    bool is_off () const;
    
    bool is_on () const;
    
    bool is_hot () const;
    
    bool is_noisy () const;
    
    bool is_delayed () const;

    bool is_prompt () const;

    bool is_missing_bottom () const;

    bool is_missing_top () const;

    bool is_missing_both () const;

    bool is_missing_none () const;

    void set_off (bool off_ = true)
    {
      __off = off_;
    }

    void set_hot (bool hot_ = true)
    {
      __hot = hot_;
    }

    void set_noisy (bool noisy_ = true)
    {
      __noisy = noisy_;
    }

    void set_delayed (bool delayed_ = true)
    {
      __delayed = delayed_;
    }

    void set_missing_top ();

    void set_missing_bottom ();

    int32_t get_number () const;

    void set_number (int32_t);

    const nemo3::gg_hit_id & get_id () const;

    const nemo3::gg_hit_id & get_id_const () const
    {
      return get_id ();
    }

    nemo3::gg_hit_id & get_id ();

    void set_id (const gg_hit_id &);
    
    const datatools::utils::properties & properties () const;

    const datatools::utils::properties & get_properties_const () const
    {
      return properties ( );
    }

    const datatools::utils::properties & get_properties_ro () const
    {
      return properties ( );
    }

    datatools::utils::properties & properties ();

    datatools::utils::properties & get_properties ()
    {
      return properties ( );
    }

    datatools::utils::properties & get_properties_rw ()
    {
      return properties ( );
    }

    void set_properties (const datatools::utils::properties &);

    int32_t get_fast_tdc () const;

    void set_fast_tdc (int32_t);

    int32_t get_slow_tdc () const;

    void set_slow_tdc (int32_t);

    int32_t get_time_bottom () const;

    void set_time_bottom (int32_t);

    int32_t get_time_top () const;

    void set_time_top (int32_t);
    
    double get_x () const;

    void set_x (double);

    double get_y () const;

    void set_y (double);

    double get_z () const;

    void set_z (double);

    bool has_valid_z () const;

    bool has_valid_r () const;

    void set_z_sigma_z (double z_, double sigma_z_);

    double get_sigma_z () const;

    void set_sigma_z (double);

    double get_r () const;

    void set_r (double);

    double get_sigma_r () const;

    void set_sigma_r (double);

    void set_r_sigma_r (double r_, double sigma_r_);

    bool is_z_valid () const;
    
    bool is_r_valid () const;

    bool is_sigma_z_valid () const;
    
    bool is_sigma_r_valid () const;

    static void make_missing_hit (gg_hit &, 
                                  int number_,
                                  const nemo3::gg_hit_id & id_,
                                  bool delayed_,
                                  double r_,
                                  double r_err_,
                                  double z_,
                                  double z_err_);

    void make_missing (int number_,
                       const nemo3::gg_hit_id & id_,
                       bool delayed_,
                       double r_,
                       double r_err_,
                       double z_,
                       double z_err_);

  public:
    
    gg_hit ();

    virtual ~gg_hit ();
  
  public: 
    
    virtual void clear ();
    
    virtual void tree_dump (std::ostream & out_         = std::clog, 
                            const std::string & title_  = "",
                            const std::string & indent_ = "",
                            bool inherit_               = false) const;
    
    void dump () const
    {
      tree_dump (std::clog, "gg_hit", "" , false);
    }

    static const std::string SERIAL_TAG;

    virtual const std::string & get_serial_tag () const;
    
  private:

    friend class boost::serialization::access;
    
    template<class Archive>
    void serialize (Archive            & ar_, 
                    const unsigned int version_) 
    {
      ar_ & boost::serialization::make_nvp ("number",       __number);
      ar_ & boost::serialization::make_nvp ("id",           __id);
      ar_ & boost::serialization::make_nvp ("properties",   __properties);
      ar_ & boost::serialization::make_nvp ("fast_tdc",     __fast_tdc);
      ar_ & boost::serialization::make_nvp ("slow_tdc",     __slow_tdc);
      ar_ & boost::serialization::make_nvp ("time_bottom",  __time_bottom);
      ar_ & boost::serialization::make_nvp ("time_top",     __time_top);
      ar_ & boost::serialization::make_nvp ("off",          __off);
      ar_ & boost::serialization::make_nvp ("noisy",        __noisy);
      ar_ & boost::serialization::make_nvp ("delayed",      __delayed);
      ar_ & boost::serialization::make_nvp ("hot",          __hot);
      ar_ & boost::serialization::make_nvp ("x",            __x);
      ar_ & boost::serialization::make_nvp ("y",            __y);
      ar_ & boost::serialization::make_nvp ("z",            __z);
      ar_ & boost::serialization::make_nvp ("sigma_z",      __sigma_z);
      ar_ & boost::serialization::make_nvp ("r",            __r);
      ar_ & boost::serialization::make_nvp ("sigma_r",      __sigma_r);
    }
    
  };

  class gg_hit_has_id 
    : public std::unary_function<gg_hit, bool>
  {
    gg_hit_id __id;
  public:
    explicit gg_hit_has_id (const gg_hit_id & id_)
    {
      __id = id_;
    }
    
    bool operator () (const gg_hit & gg_hit_) const
    {
      return (__id == gg_hit_.get_id ());
    }
  };

  class gg_hit_has_number 
    : public std::unary_function<gg_hit, bool>
  {
    int __number;
  public:
    explicit gg_hit_has_number (int number_)
    {
      __number = number_;
    }
    
    bool operator () (const gg_hit & gg_hit_) const
    {
      return (__number == gg_hit_.get_number ());
    }
  };

} // end of namespace nemo3

#endif // __N3AnaBase__gg_hit_h

// end of gg_hit.h