include/N3AnaBase/event/ana_event.h

#ifndef __N3AnaBase__ana_event_h
#define __N3AnaBase__ana_event_h 1

#include <stdexcept>
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <vector>
#include <list>
#include <map>

extern "C"
{
#include <time.h>
}

#include <boost/cstdint.hpp>

#include <boost/serialization/list.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/version.hpp>

#include <datatools/event/event_id.h>
#include <datatools/utils/properties.h>
#include <datatools/utils/i_tree_dump.h>
#include <datatools/utils/i_clear.h>
#include <datatools/utils/i_propinit.h>
#include <datatools/serialization/safe_serial.h>
#include <datatools/serialization/i_serializable.h>

#include <N3GeomDef/N3GeigerGeom.h>

#include <N3AnaBase/event/sim_event_utils.h>
#include <N3AnaBase/event/event_utils.h>
#include <N3AnaBase/event/scin_hit.h>
#include <N3AnaBase/event/gg_hit.h>
#include <N3AnaBase/event/tracking.h>
#include <N3AnaBase/event/gamma_tracking.h>
#include <N3AnaBase/event/tof_col.h>


namespace nemo3 {


  class ana_event :
    public datatools::utils::i_tree_dumpable,
    public datatools::utils::i_clear,
    public datatools::serialization::i_serializable
  {

  public:

    class i_measurement : public datatools::utils::i_propinit
    {
    public:
      virtual void do_measurement (ana_event &) = 0;
      ana_event & operator () (ana_event &);

    };

    class i_predicate : public datatools::utils::i_propinit
    {
    public:
      virtual bool do_test (ana_event &) = 0;
      bool operator () (ana_event &);

    };

    class timestamp
    {
    public:
      static const char IO_FORMAT_SEP = '_';
      static int32_t convert_to_sec_epoch (int date_, int time_);
      static int32_t extract_millisec (int time_);

   public:
      int32_t  __date;      
      int32_t  __time;      
      uint32_t __sec_epoch; 
      int32_t  __millisec;  
    public:

      timestamp (); 
      timestamp (int date_, int time_);
      void set (int date_, int time_);
      int32_t get_date () const;      
      int32_t get_time () const;      
      int32_t get_sec_epoch () const; 
      int32_t get_millisec () const;  
      int32_t get_year () const;      
      int32_t get_month () const;     
      int32_t get_day () const;       
      int32_t get_hours () const;     
      int32_t get_minutes () const;   
      int32_t get_seconds () const;   
      int32_t get_milliseconds () const 
      {
        return get_millisec ();
      }

      bool is_valid () const; 
      void clear (); 
      std::string to_string () const; 
      void from_string (const std::string &); 
      friend std::ostream & operator<< (std::ostream &, const timestamp &); 
      friend std::istream & operator>> (std::istream &, timestamp &);
    private:

      friend class boost::serialization::access;      
      template<class Archive>
      void serialize (Archive            & ar_ ,
                      const unsigned int version_)
      {
        ar_ & boost::serialization::make_nvp ("date",      __date);
        ar_ & boost::serialization::make_nvp ("time",      __time);
        ar_ & boost::serialization::make_nvp ("sec_epoch", __sec_epoch);
        ar_ & boost::serialization::make_nvp ("millisec",  __millisec);
      }
    };//end of timestamp


  public:
    typedef std::list<sim_vertex>    sim_vertex_col;
    typedef std::list<sim_particle>  sim_particle_col;
    typedef std::list<scin_hit>      scin_hit_col;
    typedef std::list<gg_hit>        gg_hit_col;
    typedef std::map<std::string, tracking> tracking_col;

  public:
    bool is_calib_ok () {return __calib_is_ok;}
    void set_calib_ok () {__calib_is_ok = true;}

    void revert_pm_time ();

    bool is_debug () const; 

    void set_debug (bool);  


    void set_selected (bool);
    bool is_selected () const;

    bool is_simulated () const;

    void set_simulated (bool);

    const datatools::event::event_id & get_id () const;
    const datatools::event::event_id & get_id_ro () const
    {
      return get_id ();
    }

    int get_run_number () const
    {
      return get_id ().get_run_number (); 
    }

    int get_event_number () const 
    {
      return get_id ().get_event_number ();
    }
    datatools::event::event_id & get_id ();
    datatools::event::event_id & get_id_rw ()
    {
      return get_id ();
    }
    void set_id (const datatools::event::event_id &);
    const datatools::utils::properties & properties () const;
    const datatools::utils::properties & get_properties_ro () const
    {
      return properties ();
    }
    const datatools::utils::properties & get_properties_const () const
    {
      return properties ();
    }
    datatools::utils::properties & properties ();
    datatools::utils::properties & get_properties_rw ()
    {
      return properties ();
    }
    const timestamp & get_timestamp () const;
    const timestamp & get_timestamp_ro () const
    {
      return get_timestamp ();
    }
    void set_timestamp (const timestamp &);
    int get_year () const
    {
      return __timestamp.get_year ();
    }
    int get_month () const
    {
      return __timestamp.get_month ();
    }
    int get_day () const
    {
      return __timestamp.get_day ();
    }
    int get_hours () const
    {
      return __timestamp.get_hours ();
    }
    int get_minutes () const
    {
      return __timestamp.get_minutes ();
    }
    int get_seconds () const
    {
      return __timestamp.get_seconds ();
    }
    int get_milliseconds () const
    {
      return __timestamp.get_milliseconds ();
    }
    int get_sec_epoch () const
    {
      return __timestamp.get_sec_epoch ();
    }
    void clear_scin_hits ();
    void clear_gg_hits ();
    void clear_trackings ();
    void clear_sim_data ();
    void set_sim_data (const sim_primary_event &);
    const sim_primary_event & get_sim_data () const;
    const sim_primary_event & get_sim_data_ro () const
    {
      return get_sim_data ();
    }
    sim_primary_event & get_sim_data ();
    sim_primary_event & get_sim_data_rw ()
    {
      return get_sim_data ();
    }
    scin_hit_col & scin_hits ();
    gg_hit_col & gg_hits ();
    const gg_hit_col & gg_hits () const;
    int get_number_of_gg_hits () const
    {
      return gg_hits ().size ();
    }
    tracking_col & trackings ();
    const scin_hit_col & scin_hits () const;
    int get_number_of_scin_hits () const
    {
      return scin_hits ().size ();
    }
    const gg_hit & get_gg_hit (int i_) const;
    gg_hit & gg (int i_);
    const scin_hit & get_scin_hit (int i_) const;
    scin_hit & scin (int i_);
    const tracking_col & trackings () const;
    void set_default_tracking (const std::string & name_);
    bool has_default_tracking () const;

    bool has_tracking () const;

    bool has_tracking_with_name (const std::string & name_) const;
    const tracking & get_tracking (const std::string & name_) const;
    const tracking & get_tracking_const (const std::string & name_) const
    {
      return get_tracking (name_);
    }
    const tracking & get_tracking_ro (const std::string & name_) const
    {
      return get_tracking (name_);
    }
    void add_tracking (const std::string & name_,
                       const tracking & tracking_,
                       bool default_ = true);

    tracking & get_tracking (const std::string & name_);
    tracking & get_tracking_rw (const std::string & name_)
    {
      return get_tracking  (name_);
    }
    const tracking & get_default_tracking () const;
    const tracking & get_default_tracking_const () const
    {
      return get_default_tracking ();
    }
    const tracking & get_default_tracking_ro () const
    {
      return get_default_tracking ();
    }
    tracking & get_default_tracking ();
    tracking & get_default_tracking_rw ()
    {
      return get_default_tracking ( );
    }
    gamma_tracking & get_gamma_tracking () {return __gamma_tracks;}
    gamma_tracking copy_gamma_tracking () const {return __gamma_tracks;}
    const tof_col& get_tof_col () const   {return __tof_col;};
    tof_col& get_tof_col_no_const () {return __tof_col;};
  public:
    void measure (i_measurement & measurement_);

  public:

    ana_event ();

    ana_event (const datatools::event::event_id & id_,
               bool simulated_ = false);
    virtual ~ana_event ();

  private:
    bool                         __debug;
    bool                         __selected; 
    bool                         __calib_is_ok; 
    datatools::event::event_id   __id;
    bool                         __simulated;
    timestamp                    __timestamp; 
    datatools::utils::properties __properties;
    sim_primary_event            __sim_data;//non vérifié!!!!
    scin_hit_col                 __scin_hits; 
    gg_hit_col                   __gg_hits;   
    tracking_col                 __trackings; 
    std::string                  __default_tracking_name; 
    gamma_tracking               __gamma_tracks; 
      tof_col                      __tof_col; 

  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, "ana_event");
    }
    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_)
    {
      //version 0
      ar_ & boost::serialization::make_nvp ("id",            __id);
      ar_ & boost::serialization::make_nvp ("simulated",     __simulated);
      ar_ & boost::serialization::make_nvp ("timestamp",     __timestamp);
      ar_ & boost::serialization::make_nvp ("properties",    __properties);
      ar_ & boost::serialization::make_nvp ("sim_data",      __sim_data);
      ar_ & boost::serialization::make_nvp ("scin_hits",     __scin_hits);
      ar_ & boost::serialization::make_nvp ("gg_hits",       __gg_hits);
      ar_ & boost::serialization::make_nvp ("trackings",     __trackings);
      ar_ & boost::serialization::make_nvp ("default_tracking_name",
                                            __default_tracking_name);
      //version 1 and more
      if(version_ > 0)
        {
          ar_ & boost::serialization::make_nvp ("gamma_track",   __gamma_tracks);

          if (version_ > 1)
            {
              ar_ & boost::serialization::make_nvp ("tof_col",__tof_col);
              if (version_ > 2)
                {
                  ar_ & boost::serialization::make_nvp ("calib_is_ok",__calib_is_ok);
                }
            }
        }
    }

  public:

    typedef datatools::serialization::safe_serial<ana_event> safe_serial;

  };

  class ana_event_has_id
    : public std::unary_function<ana_event, bool>
  {
    datatools::event::event_id __id;
  public:

    explicit ana_event_has_id (const datatools::event::event_id & id_)
    {
      __id = id_;
    }

    bool operator () (const ana_event & event_) const
    {
      return (__id == event_.get_id ());
    }
  };

} // end of namespace nemo3

BOOST_CLASS_VERSION(nemo3::ana_event, 3)
#endif // __N3AnaBase__ana_event_h

// end of ana_event.h