LogFilterGenerator.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 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 +
#include "MantidAPI/LogFilterGenerator.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/TimeSeriesProperty.h"
 
using Mantid::Kernel::LogFilter;
using Mantid::Kernel::Property;
using Mantid::Kernel::TimeSeriesProperty;
 
namespace {
Mantid::Kernel::Logger g_log("LogFilterGenerator");
} // namespace
 
namespace Mantid::API {
 
LogFilterGenerator::LogFilterGenerator(const LogFilterGenerator::FilterType filterType,
                                       const Mantid::API::MatrixWorkspace_const_sptr &workspace)
    : m_filterType(filterType), m_run(workspace->run()) {}
 
LogFilterGenerator::LogFilterGenerator(const LogFilterGenerator::FilterType filterType, const Mantid::API::Run &run)
    : m_filterType(filterType), m_run(run) {}
 
std::unique_ptr<LogFilter> LogFilterGenerator::generateFilter(const std::string &logName) const {
  const auto *logData = getLogData(logName);
  if (!logData) {
    throw std::invalid_argument("Workspace does not contain log " + logName);
  }
 
  // This will throw if the log is not a numeric time series.
  // This behaviour is what we want, so don't catch the exception
  auto flt = std::make_unique<LogFilter>(logData);
 
  switch (m_filterType) {
  case FilterType::None:
    break; // Do nothing
  case FilterType::Period:
    filterByPeriod(flt.get());
    break;
  case FilterType::Status:
    filterByStatus(flt.get());
    break;
  case FilterType::StatusAndPeriod:
    filterByPeriod(flt.get());
    filterByStatus(flt.get());
    break;
  default:
    break;
  }
 
  return flt;
}
 
void LogFilterGenerator::filterByStatus(LogFilter *filter) const {
  const auto status = dynamic_cast<Mantid::Kernel::TimeSeriesProperty<bool> *>(getLogData("running", false));
  if (!status) {
    return;
  }
  filter->addFilter(*status);
  const auto &time_value_map = filter->data()->valueAsCorrectMap();
  const auto &firstTime = time_value_map.begin()->first;
  // If filter records start later than the data we add a value at the
  // filter's front
  if (status->firstTime() > firstTime) {
    // add a "not running" value to the status filter
    Mantid::Kernel::TimeSeriesProperty<bool> atStart("tmp");
    atStart.addValue(firstTime, false);
    atStart.addValue(status->firstTime(), status->firstValue());
    filter->addFilter(atStart);
  }
}
 
void LogFilterGenerator::filterByPeriod(LogFilter *filter) const {
  const auto &logs = m_run.getLogData();
  for (const auto &log : logs) {
    if (log->name().find("period ") == 0) {
      try {
        const auto periodLog = dynamic_cast<Mantid::Kernel::TimeSeriesProperty<bool> *>(log);
        if (periodLog) {
          filter->addFilter(*periodLog);
        } else {
          g_log.warning("Could not filter by period");
          return;
        }
      } catch (const std::runtime_error &err) {
        g_log.warning() << "Could not filter by period: " << err.what();
        return;
      }
      break;
    }
  }
}
 
Property *LogFilterGenerator::getLogData(const std::string &logName, bool warnIfNotFound) const {
  try {
    const auto logData = m_run.getLogData(logName);
    return logData;
  } catch (const std::runtime_error &) {
    if (warnIfNotFound)
      g_log.warning("Could not find log value " + logName + " in workspace");
    return nullptr;
  }
}
 
} // namespace Mantid::API