manager.h

Go to the documentation of this file.

/* Author(s) :    Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2010-03-17
 * Last modified: 2014-04-09
 *
 * License:
 *
 * Copyright 2007-2014 F. Mauger
 *
 * 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:
 *
 *   Vertex generator factory and manager
 *
 */

#ifndef GENVTX_MANAGER_H
#define GENVTX_MANAGER_H 1

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

// Third party:
// - Boost:
#include <boost/scoped_ptr.hpp>
// - Bayeux/datatools:
#include <datatools/multi_properties.h>
#include <datatools/i_tree_dump.h>
#include <datatools/logger.h>
// - Bayeux/geomtools:
#include <geomtools/utils.h>
// - Bayeux/mygsl:
#include <mygsl/rng.h>
#include <mygsl/random_utils.h>

// This project:
#include <genvtx/detail/vg_tools.h>
#include <genvtx/i_vertex_generator.h>
#include <genvtx/utils.h>

namespace datatools {
  class service_manager;
}

// namespace cuts {
//   class cut_manager;
// }

namespace genvtx {


  class manager : public datatools::i_tree_dumpable
  {

  public:

    bool is_initialized() const;

    bool is_debug() const;

    void set_debug(bool);

    void set_service_manager(datatools::service_manager &);

    bool has_service_manager() const;

    const datatools::service_manager & get_service_manager() const;

    datatools::service_manager & grab_service_manager();

    bool has_geometry_manager() const;

    void set_geometry_manager(const geomtools::manager &);

    const geomtools::manager & get_geometry_manager() const;

    bool has_external_random() const;

    void set_external_random(mygsl::rng &);

    bool has_random_seed() const;

    void set_random_seed(int);

    int  get_random_seed() const;

    void set_rng_id(const std::string & rng_id_);

    const std::string & get_rng_id() const;

    const mygsl::rng & get_random() const;

    mygsl::rng & grab_random();

    bool has_generator_name() const;

    void set_generator_name(const std::string & vg_name_);

    const std::string & get_generator_name() const;

    bool has_generator(const std::string &) const;

    genvtx::vg_handle_type grab_generator(const std::string & vg_name_);

    manager(datatools::logger::priority p_ = datatools::logger::PRIO_WARNING);

    virtual ~manager();

    void reset();

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

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

    void load_vg(const std::string & vg_name_,
                  const std::string & vg_id_,
                  const datatools::properties & vg_config_);

    virtual void create_vg(genvtx::vg_entry_type & vg_entry_);

    virtual void initialize_vg(genvtx::vg_entry_type & vg_entry_);

    void load_vgs(const datatools::multi_properties & vgs_config_);

    bool has_current_vg() const;

    void activate_current_vg(const std::string & vg_name_ = "");

    void desactivate_current_vg();

    bool can_shoot_vertex() const;

    bool is_time_generator() const;

    void shoot_vertex(geomtools::vector_3d & vertex_);

    void shoot_vertex_and_time(geomtools::vector_3d & vertex_, double & time_);

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

    const genvtx::i_vertex_generator & get(const std::string & vg_name_) const;

    genvtx::i_vertex_generator & grab(const std::string & vg_name_);

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

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

    void vg_names(std::vector<std::string> & names_,
                  std::vector<std::string> & descriptions_,
                  std::string & current_) const;

  protected:

    void _load_vg(const std::string & vg_name_,
                   const std::string & vg_id_,
                   const datatools::properties & vg_config_);

    void _load_vgs(const datatools::multi_properties & vgs_config_);

    void _create_vg(genvtx::vg_entry_type & vg_entry_);

    void _initialize_vg(genvtx::vg_entry_type & vg_entry_);

    void _reset_vg(genvtx::vg_entry_type & vg_entry_);

  protected:

    datatools::logger::priority  _logging_priority; 

  private:

    bool _initialized_; 
    bool _debug_vg_;    

    genvtx::i_vertex_generator::factory_register_type _factory_register_; 
    bool _factory_preload_;         
    bool _factory_debug_;           
    int         _random_seed_;      
    std::string _rng_id_;           
    mygsl::rng  _random_;           
    mygsl::rng * _external_random_; 

    datatools::service_manager * _service_manager_;  
    const geomtools::manager   * _geometry_manager_; 
    genvtx::vg_dict_type         _vg_store_;         
    std::string                  _current_vg_name_;  
    genvtx::vg_handle_type       _current_vg_;       
    // boost::scoped_ptr<cuts::cut_manager> _vv_manager_;   //!< Manager for vertex validators/cuts

  };

} // end of namespace genvtx


/***************
 * OCD support *
 ***************/
#include <datatools/ocd_macros.h>
DOCD_CLASS_DECLARATION(genvtx::manager)

#endif // GENVTX_MANAGER_H

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