LogManager.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2010 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
 
#include "MantidAPI/DllConfig.h"
#include "MantidKernel/PropertyWithValue.h"
#include "MantidKernel/Statistics.h"
 
#include <memory>
#include <vector>
 
namespace Mantid {
namespace Types {
namespace Core {
class DateAndTime;
}
} // namespace Types
namespace Kernel {
template <class KEYTYPE, class VALUETYPE> class Cache;
template <typename TYPE> class TimeSeriesProperty;
template <typename TYPE> class TimeSeriesProperty;
class SplittingInterval;
using SplittingIntervalVec = std::vector<SplittingInterval>;
class PropertyManager;
class LogFilter;
class TimeROI;
struct TimeSeriesPropertyStatistics;
} // namespace Kernel
 
namespace API {
 
class MANTID_API_DLL LogManager {
public:
  // Gets the correct log name for the matching invalid values log for a given
  // log name
  static std::string getInvalidValuesFilterLogName(const std::string &logName);
 
  LogManager();
  LogManager(const LogManager &other);
  virtual ~LogManager();
  LogManager &operator=(const LogManager &other);
 
  //-------------------------------------------------------------
  void setStartAndEndTime(const Types::Core::DateAndTime &start, const Types::Core::DateAndTime &end);
  const Types::Core::DateAndTime startTime() const;
  const Types::Core::DateAndTime endTime() const;
  const Types::Core::DateAndTime getFirstPulseTime() const;
  const Types::Core::DateAndTime getLastPulseTime() const;
  //-------------------------------------------------------------
 
  virtual void filterByTime(const Types::Core::DateAndTime start, const Types::Core::DateAndTime stop);
 
  virtual void removeDataOutsideTimeROI();
 
  LogManager *cloneInTimeROI(const Kernel::TimeROI &timeROI);
 
  void copyAndFilterProperties(const LogManager &other, const Kernel::TimeROI &timeROI);
 
  void filterByLog(Mantid::Kernel::LogFilter *filter,
                   const std::vector<std::string> &excludedFromFiltering = std::vector<std::string>());
 
  virtual size_t getMemorySize() const;
 
  void addProperty(Kernel::Property *prop, bool overwrite = false) {
    addProperty(std::unique_ptr<Kernel::Property>(prop), overwrite);
  };
  void addProperty(std::unique_ptr<Kernel::Property> prop, bool overwrite = false);
  template <class TYPE> void addProperty(const std::string &name, const TYPE &value, bool overwrite = false);
 
  template <class TYPE>
  void addProperty(const std::string &name, const TYPE &value, const std::string &units, bool overwrite = false);
 
  bool hasProperty(const std::string &name) const;
  void removeProperty(const std::string &name, bool delProperty = true);
  const std::vector<Kernel::Property *> &getProperties() const;
 
  template <typename T> Kernel::TimeSeriesProperty<T> *getTimeSeriesProperty(const std::string &name) const;
  template <typename HeldType> HeldType getPropertyValueAsType(const std::string &name) const;
  double getPropertyAsSingleValue(const std::string &name,
                                  Kernel::Math::StatisticType statistic = Kernel::Math::Mean) const;
  int getPropertyAsIntegerValue(const std::string &name) const;
  Kernel::Property *getProperty(const std::string &name) const;
 
  void addLogData(Kernel::Property *p) { addLogData(std::unique_ptr<Kernel::Property>(p)); }
 
  void addLogData(std::unique_ptr<Kernel::Property> p, bool overwrite = false) { addProperty(std::move(p), overwrite); }
 
  Kernel::Property *getLogData(const std::string &name) const { return getProperty(name); }
  const std::vector<Kernel::Property *> &getLogData() const { return getProperties(); }
  void removeLogData(const std::string &name, const bool delproperty = true) {
    return removeProperty(name, delproperty);
  }
  double getLogAsSingleValue(const std::string &name,
                             Kernel::Math::StatisticType statistic = Kernel::Math::Mean) const {
    return getPropertyAsSingleValue(name, statistic);
  }
 
  double getTimeAveragedStd(const std::string &name) const;
  double getTimeAveragedValue(const std::string &name) const;
 
  Kernel::TimeSeriesPropertyStatistics getStatistics(const std::string &name) const;
 
  void clearTimeSeriesLogs();
  void clearOutdatedTimeSeriesLogValues();
 
  const Kernel::TimeROI &getTimeROI() const;
  virtual void setTimeROI(const Kernel::TimeROI &timeroi);
 
  virtual void saveNexus(Nexus::File *file, const std::string &group, bool keepOpen = false) const;
 
  virtual void loadNexus(Nexus::File *file, std::string const &group, std::string const &prefix, bool keepOpen = false);
  virtual void loadNexus(Nexus::File *file, std::string const &group, bool keepOpen);
  void clearLogs();
 
  void clearSingleValueCache();
 
  // returns true if the log has a matching invalid values log filter
  bool hasInvalidValuesFilter(const std::string &logName) const;
 
  // returns the invalid values log if the log has a matching invalid values log filter
  Kernel::TimeSeriesProperty<bool> *getInvalidValuesFilter(const std::string &logName) const;
 
  bool operator==(const LogManager &other) const;
  bool operator!=(const LogManager &other) const;
 
  const std::string &getProtonChargeLogName() const { return PROTON_CHARGE_LOG_NAME; }
  const std::string &getProtonChargeUnfilteredName() const { return PROTON_CHARGE_UNFILTERED_LOG_NAME; }
 
protected:
  bool hasStartTime() const;
  bool hasEndTime() const;
  bool hasValidProtonChargeLog(std::string &error) const;
 
  void loadNexus(Nexus::File *file, const std::string &prefix);
  void loadNexus(Nexus::File *file, const std::map<std::string, std::string> &entries);
  std::unique_ptr<Kernel::PropertyManager> m_manager;
  std::unique_ptr<Kernel::TimeROI> m_timeroi;
  static const std::string PROTON_CHARGE_LOG_NAME;
  static const std::string PROTON_CHARGE_UNFILTERED_LOG_NAME;
 
private:
  mutable std::unique_ptr<Kernel::Cache<std::pair<std::string, Kernel::Math::StatisticType>, double>>
      m_singleValueCache;
};
using LogManager_sptr = std::shared_ptr<LogManager>;
using LogManager_const_sptr = std::shared_ptr<const LogManager>;
 
template <class TYPE> void LogManager::addProperty(const std::string &name, const TYPE &value, bool overwrite) {
  addProperty(std::make_unique<Kernel::PropertyWithValue<TYPE>>(name, value), overwrite);
}
 
template <class TYPE>
void LogManager::addProperty(const std::string &name, const TYPE &value, const std::string &units, bool overwrite) {
  auto newProp = std::make_unique<Kernel::PropertyWithValue<TYPE>>(name, value);
  newProp->setUnits(units);
  addProperty(std::move(newProp), overwrite);
}
} // namespace API
} // namespace Mantid