primary_event_bias.h

Go to the documentation of this file.

/* Author(s) :    Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2014-11-21
 * Last modified: 2014-12-17
 *
 * License:
 *
 * Description:
 *
 *   An algorithm that implements some biasing techniques at primary event generation
 *
 */

#ifndef MCTOOLS_BIASING_PRIMARY_EVENT_BIAS_H
#define MCTOOLS_BIASING_PRIMARY_EVENT_BIAS_H 1

// Standard library:
#include <string>
#include <map>
#include <set>

// Third party:
// - Bayeux/datatools :
#include <datatools/bit_mask.h>
#include <datatools/properties.h>
#include <datatools/i_tree_dump.h>
// - Bayeux/geomtools :
#include <geomtools/utils.h>

// This project:
#include <mctools/biasing/point_of_interest.h>

namespace genbb {
  // Forward declarations:
  class primary_event;
  class primary_particle;
}

namespace geomtools {
  // Forward declaration:
  class manager;
}

namespace mctools {

  namespace biasing {

    // Forward declaration:
    class primary_generator;

    class primary_event_bias
      : public datatools::i_tree_dumpable
    {
    public:

      static const std::string & killed_event_label();

      static const std::string & truncated_event_label();

      static const std::string & normal_event_label();

      static const std::string & biased_event_status_key();

      static const std::string & master_particle_flag();

      static const std::string & dont_track_this_particle_flag();

      enum bias_mode_type {
        BIAS_UNDEFINED            = 0, 
        BIAS_NONE                 = 1, 
        BIAS_ONLY_MASTER_PARTICLE = 2, 
        BIAS_ALL_PARTICLES        = 3, 
        BIAS_DEFAULT              = BIAS_ONLY_MASTER_PARTICLE 
      };

      enum biased_event_status {
        BES_UNDEFINED   = 0, 
        BES_NORMAL      = 1, 
        BES_TRUNCATED   = 2, 
        BES_KILLED      = 3  
      };

      struct biasing_info {
      public:
        biasing_info();

        void reset();

        bool is_normal() const;

        bool is_truncated() const;

        bool is_killed() const;

        void set_status(biased_event_status);

        biased_event_status get_status() const;

      public:
        biased_event_status _status_; 
      };

      struct stat_record
      {
        stat_record();
        void reset();
      public:
        int total_counts;
        int killed_counts;
        int truncated_counts;
        int normal_counts;
      };

      const stat_record & get_stats() const;

      void reset_stats();

      bool has_stats_store() const;

      void set_stats_store(const std::string &);

      struct poi_entry_type
      {
        point_of_interest poi; 
        // std::list<point_of_interest> associated_pois; //!< Associated points of interest
      };

      static const int DEFAULT_PARTICLE_RANK =  0;
      static const int INVALID_PARTICLE_RANK = -1;
      static const int ANY_PARTICLE_RANK     = 0x7FFFFFFF;

      // typedef std::map<std::string, point_of_interest> poi_dict_type;
      typedef std::map<std::string, poi_entry_type> poi_dict_type;

      primary_event_bias();

      virtual ~primary_event_bias();

      void set_geometry_manager(const geomtools::manager &);

      bool is_initialized() const;

      void initialize_simple();

      void initialize(const datatools::properties & config_);

      void reset();

      void set_bias_mode(bias_mode_type);

      bias_mode_type get_bias_mode() const;

      bool is_using_no_bias() const;

      bool is_using_master_particle() const;

      bool is_using_all_particles() const;

      void add_particle_by_label(const std::string &);

      void add_particle_by_type(int id_);

      // /// Add the identifier of the master particle
      // void add_particle_by_pdg_code(int code_);

      void set_particle_minimum_energy(double kemin_);

      void set_particle_maximum_energy(double kemax_);

      void set_master_particle_rank(int rank_);

      void set_track_only_master_particle(bool);

      void set_total_minimum_energy(double);

      void set_total_maximum_energy(double);

      void set_mapping_name(const std::string &);

      const std::string & get_mapping_name() const;

      void set_logging(datatools::logger::priority);

      datatools::logger::priority get_logging() const;

      void add_point_of_interest(const std::string & poi_name_, const point_of_interest & poi_);

      bool has_point_of_interest(const std::string & poi_name_) const;

      const poi_entry_type & get_point_of_interest(const std::string & poi_name_) const;

      poi_entry_type & grab_point_of_interest(const std::string & poi_name_);

      void process(const geomtools::vector_3d & vertex_,
                   genbb::primary_event & event_,
                   biasing_info & info_);

      virtual void tree_dump(std::ostream & out_         = std::clog,
                             const std::string & title_  = "",
                             const std::string & indent_ = "",
                             bool inherit_               = false) const;

      void draw(const geomtools::vector_3d & vertex_,
                genbb::primary_event & event_) const;

      void store_stats();

    protected:

      void _set_default();

      void _make_candidate_particles(genbb::primary_event &,
                                     std::vector<genbb::primary_particle *> &) const;

      bool _validate_particle_direction(const genbb::primary_particle &,
                                        const geomtools::vector_3d &) const;

    private:

      bool                          _initialized_;      
      datatools::logger::priority   _logging_;          
      const geomtools::manager    * _geom_mgr_;         
      std::string         _mapping_name_;               
      bias_mode_type      _bias_mode_;                  
      std::set<int>       _particle_types_;             
      double              _particle_min_energy_;        
      double              _particle_max_energy_;        
      double              _total_min_energy_;           
      double              _total_max_energy_;           
      int                 _master_particle_rank_;       
      bool                _track_only_master_particle_; 
      poi_dict_type       _pois_;                       
      stat_record         _stats_;                      
      std::string         _stats_store_;                

    };

  } // namespace biasing

} // namespace mctools

#include <datatools/ocd_macros.h>
DOCD_CLASS_DECLARATION(mctools::biasing::primary_event_bias)

#endif // MCTOOLS_BIASING_PRIMARY_EVENT_BIAS_H

// Local Variables: --
// mode: c++ --
// c-file-style: "gnu" --
// tab-width: 2 --
// End: --