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>
 
// Forward declare
namespace NeXus {
class File;
}
 
namespace Mantid {
namespace Kernel {
class DataItem;
class SplittingInterval;
 
enum TimeSeriesSortStatus { TSUNKNOWN, TSUNSORTED, TSSORTED };
 
//=========================================================================
struct TimeSeriesPropertyStatistics {
  double minimum;
  double maximum;
  double mean;
  double median;
  double standard_deviation;
  double time_mean;
  double time_standard_deviation;
  double duration;
};
 
//================================================================================================
template <class TYPE> class TimeValueUnit {
private:
  Types::Core::DateAndTime mtime;
  TYPE mvalue;
 
public:
  TimeValueUnit(const Types::Core::DateAndTime &time, const TYPE &value) : mtime(time), mvalue(value) {}
 
  ~TimeValueUnit() = default;
 
  bool operator>(const TimeValueUnit &rhs) { return (mtime > rhs.mtime); }
 
  friend bool operator>(const TimeValueUnit &lhs, const TimeValueUnit &rhs) { return (lhs.mtime > rhs.mtime); }
 
  bool operator==(const TimeValueUnit &rhs) { return (mtime == rhs.mtime); }
 
  friend bool operator==(const TimeValueUnit &lhs, const TimeValueUnit &rhs) { return (lhs.mtime == rhs.mtime); }
 
  bool operator<(const TimeValueUnit &rhs) { return (mtime < rhs.mtime); }
 
  friend bool operator<(const TimeValueUnit &lhs, const TimeValueUnit &rhs) { return (lhs.mtime < rhs.mtime); }
 
  Types::Core::DateAndTime time() const { return mtime; }
 
  void setTime(Types::Core::DateAndTime newtime) { mtime = newtime; }
 
  TYPE value() const { return mvalue; }
 
  static bool valueCmp(const TimeValueUnit &lhs, const TimeValueUnit &rhs) { return (lhs.mvalue < rhs.mvalue); }
};
//========================================================================================================
 
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;
  TimeSeriesProperty<TYPE> *clone() 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);
 
  void filterByTime(const Types::Core::DateAndTime &start, const Types::Core::DateAndTime &stop) override;
  void filterByTimes(const std::vector<SplittingInterval> &splittervec);
 
  void splitByTime(std::vector<SplittingInterval> &splitter, std::vector<Property *> outputs,
                   bool isPeriodic) const override;
 
  void splitByTimeVector(const std::vector<Types::Core::DateAndTime> &splitter_time_vec,
                         const std::vector<int> &target_vec, const std::vector<TimeSeriesProperty *> &outputs);
 
  void makeFilterByValue(std::vector<SplittingInterval> &split, double min, double max, double TimeTolerance = 0.0,
                         bool centre = false) const override;
  void expandFilterToRange(std::vector<SplittingInterval> &split, double min, double max,
                           const TimeInterval &range) const override;
  double averageValueInFilter(const std::vector<SplittingInterval> &filter) const override;
  std::pair<double, double> averageAndStdDevInFilter(const std::vector<SplittingInterval> &filter) const override;
  double timeAverageValue() 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;
  std::vector<TYPE> filteredValuesAsVector() const;
 
  std::vector<Types::Core::DateAndTime> timesAsVector() const override;
  std::vector<Types::Core::DateAndTime> filteredTimesAsVector() const;
  std::vector<double> timesAsVectorSeconds() 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;
  Types::Core::DateAndTime firstTime() const;
  TYPE lastValue() 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;
 
  TimeInterval nthInterval(int n) const;
  TYPE nthValue(int n) const;
  Types::Core::DateAndTime nthTime(int n) const;
 
  void filterWith(const TimeSeriesProperty<bool> *filter);
  void clearFilter();
  // Returns whether the time series has been filtered
  bool isFiltered() const { return m_filterApplied; }
 
  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;
 
  void eliminateDuplicates();
 
  std::string toString() const;
 
  void reserve(size_t size) { m_values.reserve(size); };
 
  std::vector<Mantid::Kernel::SplittingInterval> getSplittingIntervals() const;
 
private:
  //----------------------------------------------------------------------------------------------
  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;
  void applyFilter() const;
  size_t findNthIndexFromQuickRef(int n) const;
  std::string setValueFromProperty(const Property &right) override;
  bool isTimeFiltered(const Types::Core::DateAndTime &time) const;
  std::pair<double, double> timeAverageValueAndStdDev() const;
 
  mutable std::vector<TimeValueUnit<TYPE>> m_values;
 
  mutable int m_size;
 
  mutable TimeSeriesSortStatus m_propSortedFlag;
 
  mutable std::vector<std::pair<Types::Core::DateAndTime, bool>> m_filter;
  mutable std::vector<std::pair<size_t, size_t>> m_filterQuickRef;
  mutable bool m_filterApplied;
};
 
double DLLExport filterByStatistic(TimeSeriesProperty<double> const *const propertyToFilter,
                                   Kernel::Math::StatisticType statisticType);
 
} // namespace Kernel
} // namespace Mantid