manager.h

Go to the documentation of this file.

/* Author(s) :    Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2010-05-04
 * Last modified: 2016-06-28
 *
 * License:
 *
 * Copyright (C) 2011-2016 Francois Mauger <mauger@lpccaen.in2p3.fr>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 *
 * Description:
 *
 *   G4 simulation manager
 *
 * History:
 *
 */

#ifndef MCTOOLS_G4_MANAGER_H
#define MCTOOLS_G4_MANAGER_H 1

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

// Third party:
// - Boost:
#include <boost/cstdint.hpp>
// - Bayeux/datatools :
#include <datatools/time_tools.h>
#include <datatools/logger.h>
// - Bayeux/mygsl :
#include <mygsl/rng.h>
#include <mygsl/seed_manager.h>
#include <mygsl/prng_state_manager.h>
// - Bayeux/geomtools :
#include <geomtools/manager.h>
// - Bayeux/genvtx :
#include <genvtx/manager.h>
// - Bayeux/genbb_help :
#include <genbb_help/manager.h>

// This project:
#include <mctools/mctools_config.h>
#include <mctools/utils.h>
#include <mctools/g4/loggable_support.h>

namespace genvtx {
  class manager;
  class i_vertex_generator;
}
namespace genbb {
  class manager;
  class i_genbb;
}

#include <mctools/g4/g4_prng.h>
#include <mctools/g4/track_history.h>

#ifdef G4VIS_USE
// #pragma message("NOTE: G4VIS_USE is set: declaring class 'G4VisManager'...")
class G4VisManager;
// #else
// #pragma message("NOTE: G4VIS_USE is NOT set.")
#endif // G4VIS_USE

class G4VSteppingVerbose;

#ifdef G4MULTITHREADED
class G4MTRunManager;
#else
class G4RunManager;
#endif

class G4UImanager;

namespace datatools {
  class multi_properties;
  class service_manager;
}

namespace mctools {
  namespace g4 {
    // Forward declarations
    class run_action;
    class event_action;
    class detector_construction;
    class primary_generator;
    class physics_list;
    class tracking_action;
    class stepping_action;
    class stacking_action;
    class simulation_ctrl;

    class manager : public loggable_support {
    public:
      typedef datatools::computing_time      CT_type;
      typedef std::map<std::string, CT_type> CT_map;

      // 2012-04-24 : limit the maximum allowed number of events:
      // http://hypernews.slac.stanford.edu/HyperNews/geant4/get/particles/528/1.html
      static const uint32_t NUMBER_OF_EVENTS_UPPER_LIMIT   = 1000000000; 
      static const uint32_t NUMBER_OF_EVENTS_LOWER_LIMIT   = 1;          
      static const uint32_t NUMBER_OF_EVENTS_WARNING_LIMIT = 1000000;    
      static const uint32_t NO_LIMIT = manager::NUMBER_OF_EVENTS_UPPER_LIMIT;
      static const uint32_t DEFAULT_PRNG_STATES_SAVE_MODULO = 100;

      static const std::string & g4_manager_label();
      static const std::string & vertex_generator_label();
      static const std::string & event_generator_label();
      static const std::string & shpf_label();
      static const std::string & default_prng_id();
      static const std::string & default_prng_states_file();

      // struct dummy { int value = 0; };

    public:
      manager();

      virtual ~manager();

      void initialize(const datatools::multi_properties& mp_);

      void reset();

      void run_simulation();

      bool is_initialized() const;

      bool is_automatic() const;

      //----------------------------------------------------------------------
      // Simulation Initializations (Geometry/Physics, possibly via services)
      //----------------------------------------------------------------------
      bool has_service_manager() const;

      datatools::service_manager& grab_service_manager();

      const datatools::service_manager& get_service_manager() const;

      void set_service_manager(datatools::service_manager& sm);

      bool has_external_geom_manager() const;

      void set_external_geom_manager(const geomtools::manager& gm);

      const geomtools::manager& get_geom_manager() const;

      //----------------------------------------------------------------------
      // Simulation User Actions (EvtGen, Run, Event etc)
      //----------------------------------------------------------------------
      void set_event_generator_name(const std::string &);

      void set_event_generator_seed(int);

      const genbb::manager& get_eg_manager() const;

      genbb::manager& grab_eg_manager();

      bool has_event_generator() const;

      const genbb::i_genbb& get_event_generator() const;

      void set_vertex_generator_name(const std::string&);

      void set_vertex_generator_seed(int);

      const genvtx::manager& get_vg_manager() const;

      genvtx::manager& grab_vg_manager();

      bool has_vertex_generator() const;

      const genvtx::i_vertex_generator& get_vertex_generator() const;

      event_action& grab_user_event_action();

      // Run
      uint32_t get_number_of_events() const;

      void set_number_of_events(uint32_t);

      bool has_number_of_events_modulo() const;

      int get_number_of_events_modulo() const;

      void set_number_of_events_modulo(int);

      void set_use_run_header_footer(bool a_use_run_header_footer);

      bool using_run_header_footer() const;

      bool is_batch() const;

      bool is_interactive() const;

      void set_interactive(bool);

      void set_g4_visualization(bool);

      bool has_g4_visualization() const;

      bool has_g4_macro() const;

      const std::string& get_g4_macro() const;

      void set_g4_macro(const std::string& macroFile);

      // Track history management:
      void set_use_track_history(const bool);

      bool has_track_history() const;

      const track_history& get_track_history() const;

      track_history& grab_track_history();

      // Hit control ? Not clear yet where this belongs, but since it relates to
      // sensitive detectors, probably part of User Actions
      bool forbids_private_hits() const;
      void set_forbid_private_hits(bool a_forbid);

      void set_dont_save_no_sensitive_hit_events(bool a_dont_save);
      bool dont_save_no_sensitive_hit_events() const;


      //----------------------------------------------------------------------
      // Multithreaded Control
      //----------------------------------------------------------------------
      // NB: This is *not* Geant4 MT mode and is completely incompatible with it
      // It simply allows the simulation to be run in a pipeline with polling to
      // grab events as required.

      bool has_simulation_ctrl() const;

      void set_simulation_ctrl(simulation_ctrl & a_simulation_ctrl);

      void reset_simulation_ctrl();

      const simulation_ctrl& get_simulation_ctrl() const;

      simulation_ctrl& grab_simulation_ctrl();


      //----------------------------------------------------------------------
      // Random number (over)control
      //----------------------------------------------------------------------
      mygsl::rng& grab_vg_prng();

      mygsl::rng& grab_eg_prng();

      mygsl::rng& grab_shpf_prng();

      const mygsl::rng& get_mgr_prng() const;

      mygsl::rng& grab_mgr_prng();

      const g4_prng& get_g4_prng() const;

      g4_prng& grab_g4_prng();

      const mygsl::seed_manager& get_seed_manager() const;

      mygsl::seed_manager& grab_seed_manager();

      const mygsl::prng_state_manager& get_state_manager() const;

      mygsl::prng_state_manager& grab_state_manager();

      void record_current_prng_states();

      void set_prng_state_save_modulo(int a_modulo);

      int get_prng_state_save_modulo() const;

      bool has_prng_state_save_modulo() const;

      bool has_input_prng_seeds_file() const;

      void reset_input_prng_seeds_file();

      void set_input_prng_seeds_file(const std::string&);

      const std::string & get_input_prng_seeds_file() const;

      bool has_output_prng_seeds_file() const;

      void reset_output_prng_seeds_file();

      void set_output_prng_seeds_file(const std::string&);

      const std::string & get_output_prng_seeds_file() const;

      void reset_output_prng_states_file();

      bool has_output_prng_states_file() const;

      void set_output_prng_states_file(const std::string&);

      const std::string & get_output_prng_states_file() const;

      void reset_input_prng_states_file();

      bool has_input_prng_states_file() const;

      void set_input_prng_states_file(const std::string&);

      const std::string & get_input_prng_states_file() const;

      bool has_mgr_prng_seed() const;

      int get_mgr_prng_seed() const;

      void set_mgr_prng_seed(int seed);

      void set_shpf_prng_seed(int);

      bool has_init_seed_method() const;

      void set_init_seed_method(const std::string&);

      const std::string& get_init_seed_method() const;

      //----------------------------------------------------------------------
      // I/O (over)control
      //----------------------------------------------------------------------
      void set_output_data_format_by_label(const std::string &);

      void reset_output_data_format();

      void set_output_data_format(io_utils::data_format_type);

      void set_output_data_bank_label(const std::string &);

      io_utils::data_format_type get_output_data_format() const;

      void set_output_data_file(const std::string &);

      // CPU/Wall Time Statistics
      bool using_time_stat() const;

      void set_using_time_stat(bool);

      const CT_map& get_CT_map() const;

      CT_map& grab_CT_map();

      //----------------------------------------------------------------------
      // Output Profiles
      //----------------------------------------------------------------------
      bool has_supported_output_profile(const std::string & profile_id_) const;

      void add_supported_output_profile(const std::string & profile_id_,
                                        const std::string & description_);

      const std::map<std::string, std::string>& get_supported_output_profiles() const;

      bool has_activated_output_profiles() const;

      bool has_activated_output_profile(const std::string & profile_id_) const;

      void activate_output_profile(const std::string & profile_id_);

      void deactivate_output_profile(const std::string & profile_id_);

      void set_output_profiles_activation_rule(const std::string & rule_);

      void apply_output_profiles_activation_rule(const std::string & output_profiles_activation_rule_);

      void fetch_activated_output_profile_ids(std::vector<std::string> & activated_output_profile_ids_) const;

      const std::set<std::string>& get_activated_output_profile_ids() const;

      //----------------------------------------------------------------------
      // Dump-To-Stream
      //----------------------------------------------------------------------
      void dump(std::ostream & = std::clog) const;

      void dump_base(std::ostream & out_ = std::clog,
                     const std::string & title_ = "",
                     const std::string & indent_ = "") const;

    protected:
      virtual void initialize_impl();

      virtual void reset_impl();

      virtual void run_simulation_impl();

      void _init_defaults();

      virtual void _init_core();

      virtual void _init_geometry();

      virtual void _init_vertex_generator();

      virtual void _init_event_generator();

      virtual void _init_detector_construction();

      virtual void _init_physics_list();

      virtual void _init_run_action();

      virtual void _init_event_action();

      virtual void _init_primary_generator_action();

      virtual void _init_tracking_action();

      virtual void _init_stepping_action();

      virtual void _init_stacking_action();

      void _init_seeds();

      void _init_prngs_states();

      virtual void _init_prngs();

      virtual void _init_time_stat();

    private:
      // Controls:
      bool _initialized_ = false; 

      // Configuration:
      const datatools::multi_properties* _multi_config_ = nullptr; 

      // User interface mode:
      bool _interactive_ = false;              
      bool _g4_visualization_ = false;         

      std::string      _simulation_ctrl_label_; 
      simulation_ctrl* _simulation_ctrl_ = nullptr;       

      std::map<std::string,std::string> _supported_output_profile_ids_; 
      std::string           _output_profiles_activation_rule_; 
      std::set<std::string> _activated_output_profile_ids_;    

      // Service manager :
      datatools::service_manager* _service_manager_ = nullptr; 

      // Geometry manager :
      const geomtools::manager*  _external_geom_manager_ = nullptr; 
      geomtools::manager         _geom_manager_;          

      // Vertex generation manager :
      int                         _vg_prng_seed_;     
      mygsl::rng                  _vg_prng_;          
      genvtx::manager             _vg_manager_;       
      std::string                 _vg_name_;          
      genvtx::i_vertex_generator* _vertex_generator_ = nullptr; 

      // Event generation manager :
      int              _eg_prng_seed_;    
      mygsl::rng       _eg_prng_;         
      genbb::manager   _eg_manager_;      
      std::string      _eg_name_;         
      genbb::i_genbb*  _event_generator_ = nullptr; 

      // Step hit processor factory PRNG :
      int              _shpf_prng_seed_;  
      mygsl::rng       _shpf_prng_;       

      // Main Geant4 PRNG :
      int         _mgr_prng_seed_; 
      mygsl::rng  _mgr_prng_;      
      g4_prng     _g4_prng_;       

      // G4 objects:
      G4VSteppingVerbose* _g4_stepping_verbosity_ = nullptr; 
#ifdef G4MULTITHREADED
      G4MTRunManager*     _g4_run_manager_ = nullptr;        
#else     
      G4RunManager*       _g4_run_manager_ = nullptr;        
#endif
      G4UImanager*        _g4_UI_ = nullptr;                 

      // User specified G4 interfaces :
      mctools::g4::detector_construction* _user_detector_construction_ = nullptr;
      mctools::g4::physics_list*          _user_physics_list_ = nullptr;
      mctools::g4::primary_generator*     _user_primary_generator_ = nullptr;
      mctools::g4::run_action*            _user_run_action_ = nullptr;
      mctools::g4::event_action*          _user_event_action_ = nullptr;
      mctools::g4::tracking_action*       _user_tracking_action_ = nullptr;
      mctools::g4::stepping_action*       _user_stepping_action_ = nullptr;
      mctools::g4::stacking_action*       _user_stacking_action_ = nullptr;

#ifdef G4VIS_USE
      // G4 visualization, if you choose to have it!
      G4VisManager * _g4_vis_manager_ = nullptr; 
#endif // G4VIS_USE


      // A PRNG seed manager :
      std::string               _init_seed_method_; 
      mygsl::prng_seed_manager  _seed_manager_;     

      // A PRNG state manager :
      mygsl::prng_state_manager _prng_state_manager_;     
      int                       _prng_state_save_modulo_; 

      // Track historical infos :
      bool          _use_track_history_; 
      track_history _track_history_;     

      // User:
      std::string _input_prng_seeds_file_;   
      std::string _output_prng_seeds_file_;  
      std::string _input_prng_states_file_;  
      std::string _output_prng_states_file_; 
      io_utils::data_format_type _output_data_format_; 
      std::string _output_data_bank_label_;  
      std::string _output_data_file_;        
      uint32_t    _number_of_events_;        
      int         _number_of_events_modulo_; 
      std::string _g4_macro_;                
      int         _g4_tracking_verbosity_;   
      bool        _forbid_private_hits_;     
      bool        _dont_save_no_sensitive_hit_events_; 
      bool        _use_run_header_footer_; 
      bool        _use_time_stat_;         
      CT_map      _CTs_;                   
    };
    
  } // end of namespace g4
} // end of namespace mctools

/***************************
 * OCD support : interface *
 ***************************/

#include <datatools/ocd_macros.h>
DOCD_CLASS_DECLARATION(mctools::g4::manager)

#endif // MCTOOLS_G4_MANAGER_H

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