include/N3AnaBase/event/scin_hit.h

#ifndef __N3AnaBase__scin_hit_h
#define __N3AnaBase__scin_hit_h 1

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

#include <boost/cstdint.hpp>

//#include <datatools/serialization/serialization.h>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/version.hpp>
#include <datatools/serialization/i_serializable.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/N3ScinHitId.h>

#include <N3AnaBase/event/event_utils.h>

namespace nemo3 {

  template<class Archive>
  void serialize (Archive & ar_,
                  nemo3::scin_hit_id & id_,
                  const unsigned int version_)
  {
    ar_ & boost::serialization::make_nvp ("sector", id_.fSector);
    ar_ & boost::serialization::make_nvp ("iobt",   id_.fIobt  );
    ar_ & boost::serialization::make_nvp ("fcll",   id_.fFcll  );
    ar_ & boost::serialization::make_nvp ("block",  id_.fBlock );
  }
  

  class scin_hit :
    public datatools::utils::i_tree_dumpable,
    public datatools::utils::i_clear,
    public datatools::serialization::i_serializable
  {
  public:
    static const int INVALID_NUMBER = -1;

  private:

    int32_t                      __number;
    nemo3::scin_hit_id           __id;
    datatools::utils::properties __properties;
    int32_t                      __adc;
    int32_t                      __tdc;
    bool                         __high_threshold;
    bool                         __off;
    bool                         __bad;
    bool                         __hot;
    bool                         __associated;
    double                       __energy;
    double                       __sigma_energy;
    double                       __time;
    double                       __sigma_time;

    std::list<ScinHitId>         __all_pmts;


  public:

    void init_PMT_table ();
    
    int  get_PMT_number ();


  public:

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

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

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

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

    bool is_off () const
    {
      return __off;
    }

    bool is_hot () const
    {
      return __hot;
    }

    bool is_on () const
    {
      return ! is_off ();
    }

    bool is_bad () const
    {
      return __bad;
    }

    bool is_good () const
    {
      return ! is_bad ();
    }

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

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

    void set_bad (bool bad_ = true)
    {
      __bad = bad_;
    }

    void set_associated (bool asso_)
    {
      __associated=asso_;
    }

    int32_t get_number () const;

    void set_number (int32_t);

    void set_id (const nemo3::scin_hit_id &);

    const nemo3::scin_hit_id & get_id () const;

    const nemo3::scin_hit_id & get_id_const () const
    {
      return get_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 ();
    }

    int32_t get_adc () const;

    void set_adc (const int32_t &);

    int32_t get_tdc () const;

    void set_tdc (const int32_t &);

    bool is_high_threshold () const;

    bool is_associated () const {return __associated;}

    void set_high_threshold (bool);

    double get_energy () const;

    void set_energy (double);

    double get_sigma_energy () const;

    void set_sigma_energy (double);

    double get_time () const;

    void set_time (double);

    double get_sigma_time () const;

    void set_sigma_time (double);

  public:
    
    scin_hit ();

    virtual ~scin_hit ();

  public:

    virtual void clear ();

    virtual void tree_dump (std::ostream & out_         = std::cerr,
                            const std::string & title_  = "",
                            const std::string & indent_ = "",
                            bool inherit_               = false) const;

    void dump () const
    {
      tree_dump (std::clog, "scin_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 ("adc",            __adc);
      ar_ & boost::serialization::make_nvp ("tdc",            __tdc);
      ar_ & boost::serialization::make_nvp ("high_threshold", __high_threshold);
      ar_ & boost::serialization::make_nvp ("energy",         __energy);
      ar_ & boost::serialization::make_nvp ("sigma_energy",   __sigma_energy);
      ar_ & boost::serialization::make_nvp ("time",           __time);
      ar_ & boost::serialization::make_nvp ("sigma_time",     __sigma_time);
      ar_ & boost::serialization::make_nvp ("off",            __off);
      ar_ & boost::serialization::make_nvp ("hot",            __hot);
      ar_ & boost::serialization::make_nvp ("bad",            __bad);
      if(version_ > 0)
        ar_ & boost::serialization::make_nvp ("associated",     __associated);
    }

  };

  class scin_hit_has_number
    : public std::unary_function<scin_hit, bool>
  {
    int __number;
  public:
    explicit scin_hit_has_number (int number_)
    {
      __number = number_;
    }

    bool operator () (const scin_hit & scin_hit_) const
    {
      return (__number == scin_hit_.get_number ());
    }
  };

} // end of namespace nemo3

BOOST_CLASS_VERSION(nemo3::scin_hit, 1)
#endif // __N3AnaBase__scin_hit_h

// end of scin_hit.h