include/N3AnaBase/event/track.h

#ifndef __N3AnaBase__track_h
#define __N3AnaBase__track_h 1

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

#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 <N3AnaBase/utils/geom_utils.h>
#include <N3AnaBase/event/event_utils.h>
#include <N3AnaBase/event/hit_info.h>

namespace nemo3 {
  

  class track : 
    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 (track &) = 0;
      
      track & operator () (track &);

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

    };
    
  public:

    static const int INVALID_NUMBER = -1;
    static const std::string BAD_QUALITY_FLAG;
    static const double NO_LENGTH;

  public:

    typedef std::list<gg_hit>        gg_hit_col;

    void measure (i_measurement & measurement_);

    track (int32_t number_ = INVALID_NUMBER);

    virtual ~track ();
  
  private:

    int32_t                      __number;
    datatools::utils::properties __properties;
    bool                         __delayed;
    gg_hit_info_col              __gg_hits;
    gg_hit_col                   __missing_gg_hits;
    int                          __curve_type;
    geomtools::line_3d           __line_data;
    geomtools::helix_3d          __helix_data;
    double                       __length;
    geomtools::vector_3d         __vertex;
    geomtools::vector_3d         __scin_impact;
    scin_hit_info                __associated_scin;

  public: 

    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_number () const;

    void set_number (int32_t = INVALID_NUMBER);

    bool has_curve () const;

    int32_t get_curve_type () const;

    bool is_line () const;

    bool is_helix () const;

    void set_curve_type (int32_t = geom_utils::CURVE_INVALID);

    bool is_delayed () const;

    void set_delayed (bool = true);

    bool is_prompt () const;

    double get_length () const;

    void set_length (double length_);

    void reset_length ();

    bool has_length () const;
    
    bool has_vertex () const;

    bool has_impact_on_scin () const;

    bool has_scin_impact () const;

    const geomtools::vector_3d & vertex () const;

    const geomtools::vector_3d & get_vertex () const;

    void set_vertex (const geomtools::vector_3d &);

    void reset_vertex ();

    const geomtools::vector_3d & scin_impact () const;

    const geomtools::vector_3d & get_scin_impact () const;
    
    void set_scin_impact (const geomtools::vector_3d &);

    void reset_scin_impact ();

    const scin_hit_info & associated_scin () const;

    const scin_hit_info & get_associated_scin () const;

    void set_associated_scin (const scin_hit_info &);

    bool has_associated_scin () const;

    void reset_associated_scin ();

    void set_line_data (const geomtools::line_3d &);

    const geomtools::line_3d & get_line_data () const;

    geomtools::line_3d & get_line_data ();

    void set_helix_data (const geomtools::helix_3d &);

    const geomtools::helix_3d & get_helix_data () const;

    geomtools::helix_3d & get_helix_data ();

    geomtools::vector_3d get_first_point () const;

    geomtools::vector_3d get_last_point () const;

    const gg_hit_col & missing_gg_hits () const;

    gg_hit_col & missing_gg_hits ();

    const gg_hit_info_col & gg_hits () const;
    
    gg_hit_info_col & gg_hits ();

    int get_number_of_gg_hits () const
    {
      return __gg_hits.size ();
    }

    int get_number_of_missing_gg_hits () const
    {
      return __missing_gg_hits.size ();
    }

    gg_hit_info_col::iterator gg_hits_begin ()
    {
      return __gg_hits.begin ();
    }

    gg_hit_info_col::iterator gg_hits_end ()
    {
      return __gg_hits.end ();
    }

    void add_gg_hit (const gg_hit & hit_, bool close_to_track_ = false);

    void add_missing_gg_hit (const gg_hit & hit_);

    const gg_hit & get_gg_hit (int i_) const;
    
    gg_hit & get_gg_hit_no_const (int i_);

    const gg_hit & get_missing_gg_hit (int i_) const;

    void clear_missing_gg_hits ();

    void clear_gg_hits ();

    void clear_curve ();

    void clear_fit ();

  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 ();
    }
    
    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 ("properties",  __properties);
      ar_ & boost::serialization::make_nvp ("delayed",     __delayed);
      ar_ & boost::serialization::make_nvp ("gg_hits",     __gg_hits);
      ar_ & boost::serialization::make_nvp ("missing_gg_hits",    __missing_gg_hits);
      ar_ & boost::serialization::make_nvp ("length",      __length);
      ar_ & boost::serialization::make_nvp ("vertex",      __vertex);
      ar_ & boost::serialization::make_nvp ("scin_impact", __scin_impact);
      ar_ & boost::serialization::make_nvp ("associated_scin", __associated_scin);
      ar_ & boost::serialization::make_nvp ("curve_type", __curve_type);
      if (__curve_type == geom_utils::CURVE_HELIX)
        {
          ar_ & boost::serialization::make_nvp ("helix_data", __helix_data);
        }
      if (__curve_type == geom_utils::CURVE_LINE)
        {
          ar_ & boost::serialization::make_nvp ("line_data", __line_data);
        }
    }

  public:

    void set_helix_t1_t2 ();

    bool validate_gg_hit (const gg_hit & hit_, bool delayed_ = false) const;

    int compute_helix_chi_square_z (const geomtools::helix_3d & hd_, 
                                    double & chi2_, 
                                    unsigned int & n_) const;
  };

  class track_has_number 
    : public std::unary_function<track, bool>
  {
  private:
    int __number;
  public:
    explicit track_has_number (int n_)
    {
      __number = n_;
    }

    bool operator () (const track & track_) const
    {
      return (track_.get_number () == __number);
    }
  };

  class track_is_prompt 
    : public std::unary_function<track, bool>
  {
  public:
    explicit track_is_prompt () {} 
    bool operator () (const track & track_) const
    {
      return (track_.is_prompt ());
    }
  };

  class track_is_delayed 
    : public std::unary_function<track, bool>
  {
  public:
    explicit track_is_delayed () {} 
    bool operator () (const track & track_) const
    {
      return (track_.is_delayed ());
    }
  };

  class track_has_flag 
    : public std::unary_function<track, bool>
  {
  private:
    std::string __flag_name;
  public:
    explicit track_has_flag (const std::string & flag_name_)
    {
      __flag_name = flag_name_;
    }

    bool operator () (const track & track_) const
    {
      return (track_.properties ().has_flag (__flag_name));
    }
  };

} // end of namespace nemo3

#endif // __N3AnaBase__track_h

// end of track.h