simulated_data.h

Go to the documentation of this file.

/* Author(s) :    Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2010-03-15
 * Last modified: 2018-08-30
 *
 * License: GPL3
 *
 * Description:
 *
 *   Simulation data based on the 'genbb::primary_event'
 *   class from the 'genbb_help' package.
 *
 */

#ifndef MCTOOLS_SIMULATED_DATA_H
#define MCTOOLS_SIMULATED_DATA_H 1

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

// Third party:
// - Boost :
#include <boost/serialization/access.hpp>
#include <boost/cstdint.hpp>
// - Bayeux/datatools :
#include <datatools/i_serializable.h>
#include <datatools/i_clear.h>
#include <datatools/i_tree_dump.h>
#include <datatools/handle.h>
#include <datatools/bit_mask.h>
#include <datatools/properties.h>
// - Bayeux/genbb_help :
#include <genbb_help/primary_event.h>

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

namespace mctools {

  class simulated_data
    : public datatools::i_serializable
    , public datatools::i_tree_dumpable
    , public datatools::i_clear
  {
  public:

    enum collection_type {
      INVALID_HIT_COLLECTION_TYPE = -1, 
      PLAIN_HIT_COLLECTION_TYPE   =  0, 
      HANDLE_HIT_COLLECTION_TYPE  =  1  
    };

    enum hit_category_type {
      HIT_CATEGORY_TYPE_PUBLIC  = datatools::bit_mask::bit00,
      HIT_CATEGORY_TYPE_PRIVATE = datatools::bit_mask::bit01,
      HIT_CATEGORY_TYPE_PREFIX  = datatools::bit_mask::bit02,
      HIT_CATEGORY_TYPE_ALL     = HIT_CATEGORY_TYPE_PUBLIC | HIT_CATEGORY_TYPE_PRIVATE
    };

    typedef datatools::handle<base_step_hit>  hit_handle_type;
    
    typedef std::vector<hit_handle_type>      hit_handle_collection_type;
    
    typedef std::vector<base_step_hit>        hit_collection_type;

    typedef std::map<std::string, hit_handle_collection_type> step_hits_dict_type;
    
    typedef std::map<std::string, hit_collection_type>        plain_step_hits_dict_type;

    typedef ::genbb::primary_event primary_event_type;

    void reset_collection_type();

    void set_collection_type(const int collection_type_);

    bool use_plain_hit_collection() const;

    bool use_handle_hit_collection() const;

    bool has_data() const;

    bool has_vertex() const;

    const geomtools::vector_3d & get_vertex() const;

    geomtools::vector_3d & grab_vertex();

    void set_vertex(const geomtools::vector_3d &);

    bool has_time() const;

    double get_time() const;

    void set_time(const double);

    const primary_event_type & get_primary_event() const;

    primary_event_type & grab_primary_event();

    void set_primary_event(const primary_event_type &);

    const datatools::properties & get_properties() const;

    datatools::properties & grab_properties();

    // Set the collection of auxiliary properties
    void set_properties(const datatools::properties &);
    
    step_hits_dict_type & grab_step_hits_dict();

    const step_hits_dict_type & get_step_hits_dict() const;

    plain_step_hits_dict_type & grab_plain_step_hits_dict();

    const plain_step_hits_dict_type & get_plain_step_hits_dict() const;

    void get_step_hits_categories(std::vector<std::string> & categories_,
                                  unsigned int mode_ = HIT_CATEGORY_TYPE_ALL,
                                  const std::string & prefix_ = "") const;

    simulated_data & add_step_hits(const std::string & category_, size_t capacity_ = 0);

    simulated_data & remove_step_hits(const std::string & category_);

    base_step_hit & add_step_hit(const std::string & category_);

    bool has_step_hits(const std::string & category_) const;

    size_t get_number_of_step_hits(const std::string & category_) const;

    const base_step_hit & get_step_hit(const std::string & category_, int hit_index_) const;

    base_step_hit & grab_step_hit(const std::string & category_, int hit_index_);

    template <class Hit>
    Hit & add_hit(const std::string & category_)
    {
      Hit * h = nullptr;
      if (use_handle_hit_collection()) {
        step_hits_dict_type::iterator found
          = _step_hits_dict_.find(category_);
        DT_THROW_IF(found == _step_hits_dict_.end(),
                    std::logic_error,
                    "No collection of hits with category '" << category_ << "' !");
        datatools::handle<mctools::base_step_hit> hh(dynamic_cast<mctools::base_step_hit*>(new Hit));
        found->second.push_back(hh);
        h = dynamic_cast<Hit*>(&found->second.back().grab());
      } else {
        DT_THROW(std::logic_error, "Unsupported method for plain hit collection!");
      }
      return *h;
    }

    bool has_hit(const std::string & category_, const int index_) const;

    template <class Hit>
    bool is_hit(const std::string & category_, const int index_) const
    {
      DT_THROW_IF(!use_handle_hit_collection(), std::logic_error, "Unsupported method for plain hit collection!");
      step_hits_dict_type::const_iterator found = _step_hits_dict_.find(category_);
      DT_THROW_IF(found == _step_hits_dict_.end(),
                  std::logic_error,
                  "No collection of handles of hits with category '" << category_ << "' !");
      DT_THROW_IF(index_ < 0 || index_ >=(int)found->second.size(),
                  std::logic_error,
                  "Invalid hit index in category '" << category_ << "' !");
      DT_THROW_IF(! found->second[index_].has_data(),
                  std::logic_error,
                  "Null handle at index " << index_ << " in category '" << category_ << "' !");
      // Extract the hit:
      const base_step_hit * bsh = &found->second[index_].get();
      // Attempt to cast it to the proper type:
      if (dynamic_cast<const Hit *>(bsh) == nullptr) {
        return false;
      }
      return true;
    }
  
    template <class Hit>
    const Hit & get_hit(const std::string & category_, const int index_) const
    {
      DT_THROW_IF(!use_handle_hit_collection(), std::logic_error, "Unsupported method for plain hit collection!");
      step_hits_dict_type::const_iterator found = _step_hits_dict_.find(category_);
      DT_THROW_IF(found == _step_hits_dict_.end(),
                  std::logic_error,
                  "No collection of hits with category '" << category_ << "' !");
      DT_THROW_IF(index_ < 0 || index_ >=(int)found->second.size(),
                  std::logic_error,
                  "Invalid hit index in category '" << category_ << "' !");
      DT_THROW_IF(! found->second[index_].has_data(),
                  std::logic_error,
                  "Null handle at index " << index_ << " in category '" << category_ << "' !");
      // Extract the hit:
      const base_step_hit * bsh = &found->second[index_].get();
      // Attempt to cast it to the proper type:
      const Hit * h = dynamic_cast<const Hit*>(bsh);
      if (h == nullptr) {
        DT_THROW(std::logic_error, "Invalid type for hit #" << index_ << " in category '" << category_ << "'!");
      } 
      return *h;
    }
      
    hit_handle_collection_type & grab_step_hits(const std::string & category_);

    const hit_handle_collection_type & get_step_hits(const std::string & category_) const;

    hit_collection_type & grab_plain_step_hits(const std::string & category_);

    const hit_collection_type & get_plain_step_hits(const std::string & category_) const;

    simulated_data & reset(bool reset_collection_type_);

    void reset();

    simulated_data();

    explicit simulated_data(int collection_type_);

    virtual ~simulated_data();

    virtual void clear();

    virtual void tree_dump(std::ostream & out_         = std::clog,
                           const std::string & title_  = "",
                           const std::string & indent_ = "",
                           bool inherit_          = false) const;
    
    void print_tree(std::ostream & out_ = std::clog,
                    const boost::property_tree::ptree & options_ = datatools::i_tree_dumpable::empty_options()) const override;
  

  protected:

    void _set_defaults();

  private:

    // Attributes :
    geomtools::vector_3d      _vertex_;               
    double                    _time_;                 
    primary_event_type        _primary_event_;        
    datatools::properties     _properties_;           
    int8_t                    _collection_type_;      
    step_hits_dict_type       _step_hits_dict_;       
    plain_step_hits_dict_type _plain_step_hits_dict_; 

    // datatools/Boost/brio serialization:
    DATATOOLS_SERIALIZATION_DECLARATION()

#if MCTOOLS_WITH_REFLECTION == 1
    DR_CLASS_RTTI()
#endif

  };

} // end of namespace mctools

#include <boost/serialization/export.hpp>
BOOST_CLASS_EXPORT_KEY2(mctools::simulated_data, "mctools::simulated_data")

#if MCTOOLS_WITH_REFLECTION == 1
// Activate reflection layer for the mctools::simulated_data class :
DR_CLASS_INIT(::mctools::simulated_data)
#endif // MCTOOLS_WITH_REFLECTION

#include <boost/serialization/version.hpp>
BOOST_CLASS_VERSION(mctools::simulated_data, 3)

#endif // MCTOOLS_SIMULATED_DATA_H

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