include/N3AnaBase/event/sim_event_utils.h

#ifndef __N3AnaBase__sim_event_utils_h
#define __N3AnaBase__sim_event_utils_h 1

#include <stdexcept>
#include <iostream>
#include <list>
#include <vector>

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

#include <geomtools/utils.h>


namespace nemo3 {


  class sim_vertex
    {
    public:

      static const int INVALID_ID = -1;

    private:

      int32_t __id;
      double __time;
      geomtools::vector_3d __position;
      
    public:

      sim_vertex (int32_t id_ = INVALID_ID, 
                  double time_ = 0.0);

      sim_vertex (int32_t id_, 
                  const geomtools::vector_3d & v_,
                  double time_ = 0.0);

      void set_id (int32_t id_);

      void set_time (double time_);

      int32_t get_id () const;
      
      double get_time () const;

      void set_position (const geomtools::vector_3d &);

      const geomtools::vector_3d & get_position () const;
     
      const geomtools::vector_3d & get_position_ro () const
      {
        return get_position ();
      }
      
      geomtools::vector_3d & get_position ();
     
      geomtools::vector_3d & get_position_rw ()
      {
        return get_position ();
      }

      const geomtools::vector_3d & get_vertex () const
      {
        return get_position ();
      }

      const geomtools::vector_3d & get_vertex_ro () const
      {
        return get_position ();
      }
      
    private:
      
      friend class boost::serialization::access; 

      template<class Archive>
        void serialize (Archive            & ar_, 
                        const unsigned int version_) 
        {
          ar_ & boost::serialization::make_nvp ("id", __id);
          ar_ & boost::serialization::make_nvp ("time", __time);
          ar_ & boost::serialization::make_nvp ("position", __position);
        }
      
  };

  class sim_particle
    {
    public:

      static const int INVALID_ID = -1;
      static const int INVALID_TYPE = -1;

    private:

      int32_t __id;
      int32_t __type;
      int32_t __vertex_id;
      double  __time;
      geomtools::vector_3d  __momentum;
      sim_vertex * __vertex;
      
    public:

      sim_particle (int32_t id_ = INVALID_ID, 
                    int32_t type_ = INVALID_TYPE, 
                    int32_t vertex_id_ = sim_vertex::INVALID_ID, 
                    double time_ = 0.0);

      virtual ~sim_particle ()
      {
        clear_vertex ();
      }

      int32_t get_id () const;

      void set_id (int32_t id_);

      int32_t get_type () const;

      void set_type (int32_t type_);

      int32_t get_vertex_id () const;

      void set_vertex_id (int32_t id_);

      void set_time (double time_);
      
      double get_time () const;

      const geomtools::vector_3d & get_momentum () const;
      
      void set_momentum (const geomtools::vector_3d &);

      bool has_vertex () const;

      void clear_vertex ();

      void set_vertex (const sim_vertex &);

      const sim_vertex & get_vertex () const;
      
    private:
      
      friend class boost::serialization::access; 
      
      template<class Archive>
        void serialize (Archive            & ar_, 
                        const unsigned int version_) 
        {
          ar_ & boost::serialization::make_nvp ("id", __id);
          ar_ & boost::serialization::make_nvp ("type", __type);
          ar_ & boost::serialization::make_nvp ("vertex_id", __vertex_id);
          ar_ & boost::serialization::make_nvp ("time", __time);
          ar_ & boost::serialization::make_nvp ("momentum", __momentum);
          ar_ & boost::serialization::make_nvp ("vertex", __vertex);
        }
      
  };

  class sim_primary_event :
    public datatools::utils::i_clear,     
    public datatools::serialization::i_serializable     
  {
  public:
    typedef std::vector<sim_vertex>   vertex_col;
    typedef std::vector<sim_particle> particle_col;

    static const std::string SERIAL_TAG;

  private:
    bool __lock;
    double __time;
    vertex_col   __vertices;
    particle_col __particles;
    datatools::utils::properties __properties;

  private:
    void __reset ()
    {
      __lock = false;
      __particles.clear ();
      __vertices.clear ();
      __properties.clear ();      
    }

  public:

    virtual void clear ();

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

    void set_time (double t_);

    double get_time () const;

    sim_primary_event ();
    
    virtual ~sim_primary_event ();

    size_t get_number_of_vertices () const
    {
      return __vertices.size ();
    }

    const vertex_col & get_vertices () const
    {
      return __vertices;
    } 

    vertex_col & get_vertices ()
    {
      if (is_locked ())
        {
          throw std::runtime_error ("sim_primary_event::get_vertices: Object is locked: cannot access vertex collection in write mode!");
        }
      return __vertices;
    } 

    const sim_vertex & get_vertex (int i_) const;

    void add_vertex (const sim_vertex &);

    const sim_particle & get_particle (int i_) const;

    size_t get_number_of_particles () const
    {
      return __particles.size ();
    }

    void add_particle (const sim_particle &);

    const particle_col & get_particles () const
    {
      return __particles;
    } 

    particle_col & get_particles ()
    {
      if (is_locked ())
        {
          throw std::runtime_error ("sim_primary_event::get_particles: Object is locked: cannot access particles collection in write mode!");
        }
      return __particles;
    } 

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

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

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

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

    bool is_locked () const;

    void lock ();

    void unlock ();

    void sync ();
    
    private:

      friend class boost::serialization::access; 

      template<class Archive>
        void serialize (Archive            & ar_, 
                        const unsigned int version_) 
        {
          ar_ & boost::serialization::make_nvp ("lock", __lock);
          ar_ & boost::serialization::make_nvp ("time", __time);
          ar_ & boost::serialization::make_nvp ("vertices", __vertices);
          ar_ & boost::serialization::make_nvp ("particles", __particles);
          ar_ & boost::serialization::make_nvp ("properties", __properties);
        }
  };

} // end of namespace nemo3

#endif // __N3AnaBase__sim_event_utils_h

// end of sim_event_utils.h