include/N3AnaBase/event/gamma_tracking.h

#include <map>
#include <list>
#include <TH2.h>

#include <datatools/serialization/serialization.h>

#ifndef __N3AnaBase__gamma_tracking_h
#define __N3AnaBase__gamma_tracking_h 1

namespace nemo3 {


  class gamma_tracking
      {
      public:

        typedef std::list <int> ref_t;                                        
        typedef std::list <int>::iterator ref_it;                             
        typedef std::list <int>::const_iterator ref_const_it;                 
        typedef std::list<std::list <int> > refcoll_t;                        
        typedef std::list<std::list <int> >::iterator refcoll_it;             
        typedef std::list<std::list <int> >::const_iterator refcoll_const_it; 

      public:
        gamma_tracking ();                          
        gamma_tracking (const gamma_tracking&);     
        ~gamma_tracking ();                         
        bool has_tracks () {return __serie.size();} 
        void Add (int number1_);                                  

        void AddProb (int number1_, int number2_, double proba_); 
        void AddChi2 (int number1_, int number2_, double chi2_);  
        void AddStart (int number_);                              

        void Print ();         
        void Count ();         
        void FillIt (TH2* h_); 
        bool is_inside (const std::list <int>& check_, const std::list <int>& values_); 
        bool is_inside (const ref_t& check_, int value_);                               
        void extract (std::list <int>& source_, const std::list <int>& values_);        
        void put_inside (const std::list<int> &from_, std::list<int> &to_);             
        void set_absolute (bool a_) {__absolute=a_;} 
        bool is_absolute () {return __absolute;}     
        void set_extern (bool e_) {__extern=e_;}     
        bool is_extern () {return __extern;}         
        void set_prob_min (double min_prob_);        
        refcoll_t GetReflects (double prob_, const ref_t* starts_ = NULL, const ref_t *exclude_ = NULL, bool deathless_starts_ = false); 

        const refcoll_t& GetAll () {return __serie;}           
        double GetProb (int scin_id1_, int scin_id2_);         
        double GetProb (const ref_t &scin_ids_);               
        double GetChi2 (int scin_id1_, int scin_id2_);         
        double GetChi2 (ref_t &scin_ids_);                     
        static bool SortReflect (ref_t &ref1_, ref_t &ref2_);  
        void SortProb (std::list<std::list <int> > &list_);    
        double GetChiLimit (unsigned int);                     
        void Combine () ;                                      

        void Flush () ;                 
        static long factorial (int x);  

        /* /\* interface i_serializable *\/ */
        /* virtual const std::string & get_serial_tag () const{}     */
        /* /\* interface i_clear *\/ */
        /* virtual void clear (){} */
        /* /\* interface i_tree_dumpable *\/ */
        /* virtual void tree_dump (std::ostream & out_         = std::clog,  */
        /*                      const std::string & title_  = "", */
        /*                      const std::string & indent_ = "", */
        /*                      bool inherit_               = false) const{} */

      private:
        bool                  __absolute; 
        bool                  __extern; 
        int                   __max; 
        double                __min_prob; 
        ref_t                 __starts; 
        refcoll_t             __serie; 
        std::map<int,double>  __min_chi2;   
        std::map<std::list<int>* ,double> __chi2; 
        std::map<std::list<int>* ,double> __proba; 
        static std::map<long, double>  __fact; 
        pthread_mutex_t __mutex; 



      private:
        friend class boost::serialization::access;

        template<class Archive>
          void serialize (Archive            & ar_,
                          const unsigned int version_)
          {
            ar_ & boost::serialization::make_nvp ("serie",      __serie);
            ar_ & boost::serialization::make_nvp ("proba",      __proba);
            ar_ & boost::serialization::make_nvp ("max",        __max);
            //version !!!
            if (version_ > 0)
              {
                ar_ & boost::serialization::make_nvp ("starts",__starts);

                if (version_ > 1)
                  {
                    ar_ & boost::serialization::make_nvp ("chi2",__chi2);

                    if (version_ > 2)
                      {
                        ar_ & boost::serialization::make_nvp ("absolute",__absolute);
                        ar_ & boost::serialization::make_nvp ("extern",__extern);
                        ar_ & boost::serialization::make_nvp ("minprob",__min_prob);
                        ar_ & boost::serialization::make_nvp ("minchi2",__min_chi2);

                      }//2
                  }//1
              }//0
          }

      };
}

BOOST_CLASS_VERSION(nemo3::gamma_tracking, 3)

#endif