sampled_signal.h

Go to the documentation of this file.

/* Author(s)     : Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date : 2016-10-02
 * Last modified : 2016-10-02
 *
 * 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:
 *
 *   Time sampled signal (obtained from a ADC like sampler).
 *
 */

#ifndef MCTOOLS_DIGITIZATION_SAMPLED_SIGNAL_H
#define MCTOOLS_DIGITIZATION_SAMPLED_SIGNAL_H

// Standard library:
#include <limits>
#include <vector>
#include <bitset>

// Third party:
// - Bayeux/datatools:
#include <datatools/properties.h>
#include <datatools/i_tree_dump.h>
// - Bayeux/geomtools:
#include <geomtools/base_hit.h>

// This project:
// #include <mctools/digitization/i_adc.h>

namespace mctools {

  namespace digitization {

    class sampled_signal
      : public geomtools::base_hit
    {
    public:

      enum more_store_mask_type {
        STORE_SAMPLING_FREQUENCY = datatools::bit_mask::bit03, 
        STORE_SAMPLES            = datatools::bit_mask::bit04  
      };

      // Special sample values:
      static const int32_t INVALID_SAMPLE   = std::numeric_limits<int32_t>::min();
      static const int32_t UNDERFLOW_SAMPLE = std::numeric_limits<int32_t>::min() + 1;
      static const int32_t OVERFLOW_SAMPLE  = std::numeric_limits<int32_t>::max();

      static bool sample_is_normal(const int32_t);

      static bool sample_is_invalid(const int32_t);

      static bool sample_is_underflow(const int32_t);

      static bool sample_is_overflow(const int32_t);

      enum sampling_status_index {
        SS_INVALID   = 0, 
        SS_UNDERFLOW = 1, 
        SS_OVERFLOW  = 2  
      };

      sampled_signal();

      sampled_signal(const double sampling_frequency_, const std::size_t nsamples_, const int32_t value_ = INVALID_SAMPLE);

      virtual ~sampled_signal();

      virtual bool is_valid() const;

      bool has_sampling_frequency() const;

      void set_sampling_frequency(const double);

      double get_sampling_frequency() const;

      void reset_sampling_frequency();

      void set_sampling_period(const double);

      double get_sampling_period() const;

      std::size_t get_number_of_sampling_time_intervals() const;

      double get_sampling_duration() const;

      double get_min_sampling_time() const;

      double get_max_sampling_time() const;

      void set_number_of_samples(const std::size_t nsamples_, const int32_t value_ = INVALID_SAMPLE);

      void reset_number_of_samples();

      std::size_t get_number_of_samples() const;

      bool is_sampling_initialized() const;

      bool has_invalid_samples() const;

      bool has_underflow_samples() const;

      bool has_overflow_samples() const;

      bool has_only_valid_samples() const;

      bool has_min_sample() const;

      int32_t get_min_sample() const;

      bool has_max_sample() const;

      int32_t get_max_sample() const;

      void reset();

      void set_samples(const std::vector<int32_t> &, const bool update_ = true);

      const std::vector<int32_t> & get_samples() const;

      void set_sample(const uint32_t index_, const int32_t sample_, const bool update_ = false);

      uint32_t get_sample(const uint32_t index_) const;

      bool is_normal(const uint32_t index_) const;

      bool is_invalid(const uint32_t index_) const;

      bool is_underflow(const uint32_t index_) const;

      bool is_overflow(const uint32_t index_) const;

      double get_time(const uint32_t index_) const;

      uint32_t get_index(const double time_) const;

      void unset_sample(const uint32_t index_, const bool update_ = false);

      void set_underflow_sample(const uint32_t index_, const bool update_ = false);

      void set_overflow_sample(const uint32_t index_, const bool update_ = false);

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

      void update();

      enum slicing_bits {
        SLICING_HIT_ID      = datatools::bit_mask::bit00,
        SLICING_GEOM_ID     = datatools::bit_mask::bit01,
        SLICING_AUXILIARIES = datatools::bit_mask::bit02,
        SLICING_UPDATE      = datatools::bit_mask::bit03,
        SLICING_ALL         = SLICING_HIT_ID
        | SLICING_GEOM_ID
        | SLICING_AUXILIARIES
        | SLICING_UPDATE
      };

      void slice_from_to(sampled_signal & target_,
                         const std::size_t first_,
                         const std::size_t last_,
                         const uint32_t flags_ = 0) const;

      enum print_ascii_bits {
        PRINT_ASCII_NOHEADER = datatools::bit_mask::bit00,
        PRINT_ASCII_TIME_IN_NS = datatools::bit_mask::bit01,
        PRINT_ASCII_NODATABLOCKSEP = datatools::bit_mask::bit02
      };

      void print_ascii(std::ostream & out_, const uint32_t flags_ = 0) const;

      // //! Simple ASCII terminal plot
      // void plot_ascii(std::ostream & out_, const uint32_t flags_ = 0) const;

    protected:

      void _set_defaults();

      void _set_default_working_data();

      void _recompute_working_data();

    private:

      double _sampling_frequency_;    
      std::vector<int32_t> _samples_; 

      // Working data:
      std::bitset<8> _sampling_status_;      
      int32_t _min_sample_ = INVALID_SAMPLE; 
      int32_t _max_sample_ = INVALID_SAMPLE; 

      DATATOOLS_SERIALIZATION_DECLARATION()

      
      DR_CLASS_RTTI()

    };

  } // end of namespace digitization

} // end of namespace mctools

// Activate reflection layer :
DR_CLASS_INIT(::mctools::digitization::sampled_signal)

#endif // MCTOOLS_DIGITIZATION_SAMPLED_SIGNAL_H

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