base_step_hit_processor.h

Go to the documentation of this file.

/* Author(s) :    Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2010-05-26
 * Last modified: 2013-03-08
 *
 * License:
 *
 * Description:
 *
 *   Abstract MC base step hit processor.
 *
 */

#ifndef MCTOOLS_BASE_STEP_HIT_PROCESSOR_H
#define MCTOOLS_BASE_STEP_HIT_PROCESSOR_H 1

// Standard library:
#include <sstream>
#include <string>
#include <map>
#include <stdexcept>
#include <vector>

// Third party:
// - Bayeux/datatools:
#include <datatools/handle_pool.h>
#include <datatools/factory_macros.h>
#include <datatools/i_tree_dump.h>
#include <datatools/logger.h>
#include <datatools/object_configuration_description.h>

// - Bayeux/mygsl:
#include <mygsl/rng.h>
// - Bayeux/geomtools:
#include <geomtools/manager.h>

// This project:
#include <mctools/base_step_hit.h>
#include <mctools/simulated_data.h>

namespace datatools {
  class service_manager;
}

namespace mctools {

  class base_step_hit_processor
    : public datatools::i_tree_dumpable
  {
  public:

    typedef std::vector<base_step_hit *>          step_hit_ptr_collection_type;
    typedef datatools::handle_pool<base_step_hit> pool_type;

    static const size_t DEFAULT_POOL_CAPACITY = 100;

    bool is_debug() const;

    void set_debug(bool);

    void set_pool(pool_type &);

    bool has_pool() const;

    pool_type & get_pool() const;

    bool using_private_pool() const;

    void setup_private_pool(size_t capacity_ = DEFAULT_POOL_CAPACITY);

    void add_new_hit(simulated_data::hit_handle_collection_type & hits_);

    const std::string & get_name() const;

    void set_name(const std::string &);

    base_step_hit_processor();

    virtual ~base_step_hit_processor();

    const std::string & get_hit_category() const;

    void set_hit_category(const std::string & hc_);

    const std::string & get_sensitive_category() const;

    void set_sensitive_category(const std::string & sc_);

    bool has_geom_manager() const;

    void set_geom_manager(const geomtools::manager & gmgr_);

    const geomtools::manager & get_geom_manager() const;

    const datatools::properties & get_auxiliaries() const;

    datatools::properties & grab_auxiliaries();

    virtual bool accept_external_rng() const;

    virtual void set_external_rng(mygsl::rng & rng_);

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

    virtual void initialize(const datatools::properties & config_,
                            datatools::service_manager & service_mgr_);

    void process(const step_hit_ptr_collection_type & base_step_hits_,
                 simulated_data & sim_data_);

    virtual void process(const step_hit_ptr_collection_type         & base_step_hits_,
                         simulated_data::hit_handle_collection_type & hits_) = 0;

    virtual void process(const step_hit_ptr_collection_type  & base_step_hit_s,
                         simulated_data::hit_collection_type & plain_hits_);

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

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

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

    static void init_ocd(datatools::object_configuration_description &);

  protected:

    void _initialize(const datatools::properties & config_,
                     datatools::service_manager & service_mgr_);

    /*
   virtual void _process(const i_step_hit_processor::step_hit_ptr_collection_type & the_base_step_hits,
   simulated_data::hit_handle_collection_type * the_gg_hits,
   simulated_data::hit_collection_type * the_plain_gg_hits);
    */

  protected:

    datatools::logger::priority      _logging_priority; 
    std::string                      _name;             
    std::string                      _hit_category; 
    std::string                      _sensitive_category; 
    const geomtools::manager       * _geom_manager = nullptr; 
    datatools::properties            _auxiliaries;            
    pool_type                      * _private_pool = nullptr; 
    bool                             _pool_owner;             
    pool_type                      * _pool = nullptr;         

    // Factory stuff :
    DATATOOLS_FACTORY_SYSTEM_REGISTER_INTERFACE(base_step_hit_processor)

  };

} // end of namespace mctools


#include <mctools/detail/step_hit_processor_macros.h>

namespace mctools {

  class push_all_step_hit_processor
    : public base_step_hit_processor
  {
  public:

    push_all_step_hit_processor();

    virtual ~push_all_step_hit_processor();

    virtual void initialize(const ::datatools::properties & config_,
                            ::datatools::service_manager & service_mgr_);

    virtual void process(const ::mctools::base_step_hit_processor::step_hit_ptr_collection_type & base_step_hits_,
                         ::mctools::simulated_data::hit_handle_collection_type & handle_hits_);

    virtual void process(const ::mctools::base_step_hit_processor::step_hit_ptr_collection_type & base_step_hits_,
                         ::mctools::simulated_data::hit_collection_type & plain_hits_);

    void set_visu_highlighted_hits(bool);

    bool are_visu_highlighted_hits() const;

    bool is_record_mc_step_hit_processor() const;

    void set_record_mc_step_hit_processor(bool);

  private:

    bool _visu_highlighted_hits_; 
    bool _record_mc_step_hit_processor_; 
    // Registration macro :
    MCTOOLS_STEP_HIT_PROCESSOR_REGISTRATION_INTERFACE(push_all_step_hit_processor)

  };


  class kill_all_step_hit_processor
    : public base_step_hit_processor
  {
  public:

    kill_all_step_hit_processor();

    virtual ~kill_all_step_hit_processor();

    virtual void initialize(const ::datatools::properties & config_,
                            ::datatools::service_manager & service_mgr_);

    virtual void process(const ::mctools::base_step_hit_processor::step_hit_ptr_collection_type & base_step_hits_,
                         ::mctools::simulated_data::hit_handle_collection_type & handle_hits_);

    virtual void process(const ::mctools::base_step_hit_processor::step_hit_ptr_collection_type & base_step_hits_,
                         ::mctools::simulated_data::hit_collection_type & plain_hits_);

    // Registration macro :
    MCTOOLS_STEP_HIT_PROCESSOR_REGISTRATION_INTERFACE(kill_all_step_hit_processor)

  };

} // end of namespace mctools

#include <datatools/ocd_macros.h>
DOCD_CLASS_DECLARATION(mctools::push_all_step_hit_processor)
DOCD_CLASS_DECLARATION(mctools::kill_all_step_hit_processor)

#endif // MCTOOLS_BASE_STEP_HIT_PROCESSOR_H

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