base_signal.h

Go to the documentation of this file.

/* Author(s)     : Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date : 2016-09-27
 * Last modified : 2016-09-27
 *
 * Copyright (C) 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:
 *
 *   A base class representing an analog signal associated to a hit detector.
 *
 */

#ifndef MCTOOLS_SIGNAL_BASE_SIGNAL_H
#define MCTOOLS_SIGNAL_BASE_SIGNAL_H

// Third party:
// - Bayeux/datatools:
#include <datatools/logger.h>
#include <datatools/properties.h>
#include <datatools/multi_properties.h>
// - Bayeux/mygsl:
#include <mygsl/i_unary_function.h>
// - Bayeux/geomtools:
#include <geomtools/base_hit.h>

namespace mctools {

  namespace signal {

    class signal_shape_builder;

    class base_signal : public geomtools::base_hit
    {
    public:

      static const std::string & shape_parameter_prefix();
      static const std::string & allow_no_shape_builder_key();
      static std::string build_shape_key(const int32_t);
      static std::string build_private_shape_key(const int32_t, const std::size_t);

      base_signal();

      base_signal(const base_signal &);

      virtual ~base_signal();

      base_signal & operator=(const base_signal &);

      virtual bool is_valid() const;

      void set_allow_no_shape_builder(bool a_);

      bool is_shape_builder_mandatory() const;

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

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

      bool has_time_ref() const;

      double get_time_ref() const;

      void set_time_ref(const double);

      void reset_time_ref();

      bool has_shape_builder() const;

      const signal_shape_builder & get_shape_builder() const;

      signal_shape_builder & grab_shape_builder();

      void set_shape_builder(signal_shape_builder &);

      bool has_category() const;

      const std::string & get_category() const;

      void set_category(const std::string &);

      void reset_category();

      bool has_shape_type_id() const;

      const std::string & get_shape_type_id() const;

      void set_shape_type_id(const std::string &);

      void set_shape_parameters(const datatools::properties & params_);

      void reset_shape_parameters();

      void reset_shape_parameter(const std::string & key_);

      void set_shape_boolean_parameter(const std::string & key_,
                                       const bool value_,
                                       const std::string & desc_ = "");

      void set_shape_boolean_parameters(const std::string & key_,
                                        const std::vector<bool> & values_,
                                        const std::string & desc_ = "");

      void set_shape_integer_parameter(const std::string & key_,
                                       const int value_,
                                       const std::string & desc_ = "");

      void set_shape_integer_parameters(const std::string & key_,
                                        const std::vector<int> & values_,
                                        const std::string & desc_ = "");

      void set_shape_string_parameter(const std::string & key_,
                                      const std::string & value_,
                                      const std::string & desc_ = "");

      void set_shape_string_parameters(const std::string & key_,
                                       const std::vector<std::string> & values_,
                                       const std::string & desc_ = "");

      void set_shape_real_parameter(const std::string & key_,
                                    const double value_,
                                    const std::string & desc_ = "");

      void set_shape_real_parameters(const std::string & key_,
                                     const std::vector<double> & values_,
                                     const std::string & desc_ = "");

      void set_shape_real_parameter_with_explicit_unit(const std::string & key_,
                                                       const double value_,
                                                       const std::string & unit_symbol_,
                                                       const std::string & desc_ = "");

      void set_shape_real_parameters_with_explicit_unit(const std::string & key_,
                                                        const std::vector<double> & values_,
                                                        const std::string & unit_symbol_,
                                                        const std::string & desc_ = "");

      void add_private_shape(const std::string & key_,
                             const std::string & type_id_,
                             const datatools::properties & parameters_);

      std::string add_auto_private_shape(const std::string & type_id_,
                                         const datatools::properties & parameters_);

      void remove_private_shape(const std::string & key_);

      void remove_private_shapes();

      bool is_shape_instantiated() const;

      const mygsl::i_unary_function & get_shape() const;

      void reset_shape();

      void set_shape(const mygsl::i_unary_function & shape_);

      void set_shape_owned(const mygsl::i_unary_function * shape_ptr_);

      void unlock();

      void relock();

      bool is_initialized() const;

      void initialize_simple();

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

      void reset();

      bool has_private_shapes_config() const;

      const datatools::multi_properties & get_private_shapes_config() const;

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

      double compute_shape(double time_) const;

      static bool build_signal_shape(signal_shape_builder & builder_,
                                     const std::string & key_,
                                     base_signal & signal_,
                                     const datatools::logger::priority logging_ = datatools::logger::PRIO_FATAL);

      bool instantiate_signal_shape(signal_shape_builder & builder_, const std::string & key_ = "");

    private:

      const mygsl::i_unary_function & _get_shape_();

      void _copy_(const base_signal & sig_);

      void _reset_shape_();

      void _set_shape_(const mygsl::i_unary_function &, bool owned_);

      void _init_();

      void _reset_();

      void _base_construct_();

    private:

      // Management:
      bool                         _initialized_ = false;     
      datatools::logger::priority  _logging_;                 
      signal_shape_builder *       _shape_builder_ = nullptr; 

      // Configuration:
      std::string _category_;      
      double      _time_ref_;      
      std::string _shape_type_id_; 
      datatools::multi_properties _private_shapes_config_; 

      // Working data:
      bool _owned_shape_ = false; 
      const mygsl::i_unary_function * _shape_ = nullptr; 

      DATATOOLS_SERIALIZATION_DECLARATION()

      
      DR_CLASS_RTTI()

    };

  } // end of namespace signal

} // end of namespace mctools

// Activate reflection layer :
DR_CLASS_INIT(::mctools::signal::base_signal)

#endif // MCTOOLS_SIGNAL_BASE_SIGNAL_H

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