include/N3AnaBase/event/hit_info.h

#ifndef __N3AnaBase__hit_info_h
#define __N3AnaBase__hit_info_h 1

#include <stdexcept>
#include <iostream>
#include <sstream>
#include <string>
#include <list>
#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 <N3AnaBase/utils/geom_utils.h>
#include <N3AnaBase/event/event_utils.h>
#include <N3AnaBase/event/gg_hit.h>
#include <N3AnaBase/event/scin_hit.h>

namespace nemo3 {

  class scin_hit_info :

    public datatools::serialization::i_serializable
    {
    private:
      datatools::utils::properties __properties;
      scin_hit *                   __hit;
    public:

      scin_hit_info ();

      scin_hit_info (const scin_hit & hit_);

      void set (const scin_hit & hit_);

      void set_associated (bool);

      void reset ();

      bool is_valid () const;

      int32_t get_hit_number () const;

      bool operator== ( const scin_hit_info & ) const;

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

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

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

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

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

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

      const scin_hit & get_hit () const;

      scin_hit & get_hit_no_const ();

      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 ("properties", __properties);
          ar_ & boost::serialization::make_nvp ("hit",        __hit);
        }

    };

  typedef std::list<scin_hit_info> scin_hit_info_col;

  typedef enum
    {
      CHARGE_UNDEFINED = -2,
      CHARGE_NUL      = -1,
      CHARGE_POSITIVE = 0,
      CHARGE_NEGATIVE = 1
    } charge_t ;



  class gg_hit_info :
    
    public datatools::serialization::i_serializable
    {
    public:
      static const std::string HIT_CLOSE_TO_TRACK_FLAG;
      static const std::string HIT_ON_TRACK_FLAG;
      static const std::string HIT_NOT_ON_TRACK_FLAG;

    private:
      datatools::utils::properties __properties;
      gg_hit *                     __hit;

    public:

      gg_hit_info ();

      gg_hit_info (const gg_hit & hit_);

      void set (const gg_hit & hit_);

      void reset ();

      bool is_valid () const;

      int32_t get_hit_number () const;

      bool operator== ( const gg_hit_info & ) const;

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

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

      const gg_hit & get_hit () const;
      
      gg_hit & get_hit_no_const ();

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

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

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

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

      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 ("properties", __properties);
          ar_ & boost::serialization::make_nvp ("hit",     __hit);
        }

    };

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

    bool operator () (const scin_hit_info & scin_hit_info_) const
    {
      if (! scin_hit_info_.is_valid ()) return false;
      return (__number == scin_hit_info_.get_hit ().get_number ());
    }
  };

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

    bool operator () (const gg_hit_info & gg_hit_info_) const
    {
      if (! gg_hit_info_.is_valid ()) return false;
      return (__number == gg_hit_info_.get_hit ().get_number ());
    }
  };

  typedef std::list<gg_hit_info> gg_hit_info_col;


} // end of namespace nemo3

#endif // __N3AnaBase__hit_info_h

// end of hit_info.h