TimeSeriesProperty.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/DateAndTime.h"
#include "MantidKernel/DllConfig.h"
#include "MantidKernel/ITimeSeriesProperty.h"
#include "MantidKernel/Property.h"
 
#include "MantidKernel/Statistics.h"
#include <cstdint>
#include <utility>
 
namespace Mantid {
namespace Kernel {
class DataItem;
class SplittingInterval;
 
enum TimeSeriesSortStatus { TSUNKNOWN, TSUNSORTED, TSSORTED };
 
//=========================================================================
struct MANTID_KERNEL_DLL TimeSeriesPropertyStatistics {
  double minimum;
  double maximum;
  double mean;
  double median;
  double standard_deviation;
  double time_mean;
  double time_standard_deviation;
  double duration;
 
  TimeSeriesPropertyStatistics() = default;
 
  TimeSeriesPropertyStatistics(const Statistics &stats) {
    constexpr double nan{std::numeric_limits<double>::quiet_NaN()};
    minimum = stats.minimum;
    maximum = stats.maximum;
    median = stats.median;
    mean = stats.mean;
    standard_deviation = stats.standard_deviation;
    time_mean = nan;
    time_standard_deviation = nan;
    duration = nan;
  }
 
  TimeSeriesPropertyStatistics(double value) {
    minimum = value;
    maximum = value;
    mean = value;
    median = value;
    standard_deviation = 0.0;
    time_mean = value;
    time_standard_deviation = 0.0;
    duration = std::numeric_limits<double>::quiet_NaN();
  }
 
  void setAllToNan() {
    constexpr double nan{std::numeric_limits<double>::quiet_NaN()};
    minimum = nan;
    maximum = nan;
    mean = nan;
    median = nan;
    standard_deviation = nan;
    time_mean = nan;
    time_standard_deviation = nan;
    duration = nan;
  }
};
 
//================================================================================================
template <class TYPE> class TimeValueUnit {
private:
  Types::Core::DateAndTime m_time;
  TYPE m_value;
 
public:
  TimeValueUnit(const Types::Core::DateAndTime &time, const TYPE &value) : m_time(time), m_value(value) {}
 
  ~TimeValueUnit() = default;
 
  bool operator>(const TimeValueUnit &rhs) { return (m_time > rhs.m_time); }
 
  friend bool operator>(const TimeValueUnit &lhs, const TimeValueUnit &rhs) { return (lhs.m_time > rhs.m_time); }
 
  bool operator==(const TimeValueUnit &rhs) { return (m_time == rhs.m_time); }
 
  friend bool operator==(const TimeValueUnit &lhs, const TimeValueUnit &rhs) { return (lhs.m_time == rhs.m_time); }
 
  bool operator<(const TimeValueUnit &rhs) { return (m_time < rhs.m_time); }
 
  friend bool operator<(const TimeValueUnit &lhs, const TimeValueUnit &rhs) { return (lhs.m_time < rhs.m_time); }
 
  Types::Core::DateAndTime time() const { return m_time; }
 
  void setTime(Types::Core::DateAndTime newtime) { m_time = newtime; }
 
  const TYPE &value() const { return m_value; }
 
  static bool valueCmp(const TimeValueUnit &lhs, const TimeValueUnit &rhs) { return (lhs.m_value < rhs.m_value); }
};
//========================================================================================================
 
template <typename TYPE> class DLLExport TimeSeriesProperty : public Property, public ITimeSeriesProperty {
public:
  explicit TimeSeriesProperty(const std::string &name);
  TimeSeriesProperty(const std::string &name, const std::vector<Types::Core::DateAndTime> &times,
                     const std::vector<TYPE> &values);
 
  ~TimeSeriesProperty() override;
 
private:
  TimeSeriesProperty(const Property *const p);
 
public:
  TimeSeriesProperty<TYPE> *clone() const override;
 
  Property *cloneInTimeROI(const TimeROI &timeROI) const override;
  //
  std::unique_ptr<TimeSeriesProperty<double>> getDerivative() const;
 
  void saveProperty(Nexus::File *file) override;
  Json::Value valueAsJson() const override;
 
  Property *cloneWithTimeShift(const double timeShift) const override;
  size_t getMemorySize() const override;
  TimeSeriesProperty<TYPE> &merge(Property *rhs) override;
 
  //--------------------------------------------------------------------------------------
  TimeSeriesProperty &operator+=(Property const *right) override;
  virtual bool operator==(const TimeSeriesProperty<TYPE> &right) const;
  virtual bool operator!=(const TimeSeriesProperty<TYPE> &right) const;
  virtual bool operator==(const Property &right) const;
  virtual bool operator!=(const Property &right) const;
 
  void setName(const std::string &name);
 
  // Remove time series values according to TimeROI
  void removeDataOutsideTimeROI(const TimeROI &timeRoi) override;
 
  void makeFilterByValue(std::vector<SplittingInterval> &split, double min, double max, double TimeTolerance = 0.0,
                         bool centre = false) const override;
  TimeROI makeFilterByValue(double min, double max, bool expand = false,
                            const TimeInterval &expandRange = TimeInterval(0, 1), double TimeTolerance = 0.0,
                            bool centre = false, const TimeROI *existingROI = nullptr) const override;
  void expandFilterToRange(std::vector<SplittingInterval> &split, double min, double max,
                           const TimeInterval &range) const override;
  std::pair<double, double> timeAverageValueAndStdDev(const Kernel::TimeROI *timeRoi = nullptr) const override;
  double timeAverageValue(const TimeROI *timeRoi = nullptr) const override;
  void histogramData(const Types::Core::DateAndTime &tMin, const Types::Core::DateAndTime &tMax,
                     std::vector<double> &counts) const;
 
  std::map<Types::Core::DateAndTime, TYPE> valueAsCorrectMap() const;
  std::vector<TYPE> valuesAsVector() const;
  std::multimap<Types::Core::DateAndTime, TYPE> valueAsMultiMap() const;
  virtual std::vector<TYPE> filteredValuesAsVector(const Kernel::TimeROI *roi) const;
  // overload method rather than default value so python bindings work
  virtual std::vector<TYPE> filteredValuesAsVector() const;
 
  std::vector<Types::Core::DateAndTime> timesAsVector() const override;
 
  std::vector<double> timesAsVectorSeconds() const;
  std::vector<double> timesAsVectorSeconds(Types::Core::DateAndTime start) const;
 
  virtual std::vector<Types::Core::DateAndTime> filteredTimesAsVector(const Kernel::TimeROI *roi) const;
  // overload method rather than default value so python bindings work
  virtual std::vector<Types::Core::DateAndTime> filteredTimesAsVector() const;
  void addValue(const Types::Core::DateAndTime &time, const TYPE &value);
  void addValue(const std::string &time, const TYPE &value);
  void addValue(const std::time_t &time, const TYPE &value);
  void addValues(const std::vector<Types::Core::DateAndTime> &times, const std::vector<TYPE> &values);
  void replaceValues(const std::vector<Types::Core::DateAndTime> &times, const std::vector<TYPE> &values);
 
  Types::Core::DateAndTime lastTime() const;
  TYPE firstValue() const;
  TYPE firstValue(const Kernel::TimeROI &roi) const;
  Types::Core::DateAndTime firstTime() const;
  TYPE lastValue() const;
  TYPE lastValue(const Kernel::TimeROI &roi) const;
  double durationInSeconds(const Kernel::TimeROI *roi = nullptr) const;
 
  TYPE minValue() const;
  TYPE maxValue() const;
  double mean() const;
 
  int size() const override;
  int realSize() const override;
 
  // ==== The following functions are specific to the odd mechanism of
  // FilterByLogValue =========
  std::string value() const override;
  std::vector<std::string> time_tValue() const;
  std::map<Types::Core::DateAndTime, TYPE> valueAsMap() const;
  // ============================================================================================
 
  std::string setValue(const std::string &) override;
  std::string setValueFromJson(const Json::Value &) override;
  std::string setDataItem(const std::shared_ptr<DataItem> &) override;
 
  void clear() override;
  void clearOutdated() override;
  void create(const Types::Core::DateAndTime &start_time, const std::vector<double> &time_sec,
              const std::vector<TYPE> &new_values);
  void create(const std::vector<Types::Core::DateAndTime> &new_times, const std::vector<TYPE> &new_values);
 
  TYPE getSingleValue(const Types::Core::DateAndTime &t) const;
  TYPE getSingleValue(const Types::Core::DateAndTime &t, int &index) const;
 
  virtual TimeInterval nthInterval(int n) const;
  virtual TYPE nthValue(int n) const;
  virtual Types::Core::DateAndTime nthTime(int n) const;
 
  // Returns whether the time series has been filtered
  bool isFiltered() const override { return false; }
 
  void countSize() const;
 
  static bool isTimeString(const std::string &str);
 
  std::string isValid() const override;
  std::string getDefault() const override;
  bool isDefault() const override;
 
  TimeSeriesPropertyStatistics getStatistics(const Kernel::TimeROI *roi = nullptr) const override;
 
  double extractStatistic(Math::StatisticType selection, const TimeROI *roi = nullptr) const override;
 
  void eliminateDuplicates();
 
  std::string toString() const;
 
  void reserve(size_t size) { m_values.reserve(size); };
 
  virtual std::vector<Mantid::Kernel::TimeInterval> getTimeIntervals() const;
 
private:
  double averageValueInFilter(const std::vector<TimeInterval> &filter) const;
  std::pair<double, double> averageAndStdDevInFilter(const std::vector<TimeInterval> &intervals) const;
  void createFilteredData(const TimeROI &timeROI, std::vector<TimeValueUnit<TYPE>> &filteredData) const;
 
protected:
  //----------------------------------------------------------------------------------------------
  void saveTimeVector(Nexus::File *file);
  void sortIfNecessary() const;
  int findIndex(Types::Core::DateAndTime t) const;
  int upperBound(Types::Core::DateAndTime t, int istart, int iend) const;
  Types::Core::DateAndTime getFakeEndTime() const;
 
  std::string setValueFromProperty(const Property &right) override;
 
  mutable std::vector<TimeValueUnit<TYPE>> m_values;
 
  mutable int m_size;
 
  mutable TimeSeriesSortStatus m_propSortedFlag;
};
 
} // namespace Kernel
} // namespace Mantid