AddTimeSeriesLog.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 "MantidAlgorithms/AddTimeSeriesLog.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAPI/Run.h"
#include "MantidKernel/DateTimeValidator.h"
#include "MantidKernel/ListValidator.h"
#include "MantidKernel/MandatoryValidator.h"
#include "MantidKernel/TimeSeriesProperty.h"
 
namespace Mantid::Algorithms {
using namespace API;
using namespace Kernel;
 
namespace {
template <typename T>
void createOrUpdateValue(API::Run &run, const std::string &name, const std::string &time, const T value) {
  TimeSeriesProperty<T> *timeSeries(nullptr);
  if (run.hasProperty(name)) {
    timeSeries = dynamic_cast<TimeSeriesProperty<T> *>(run.getLogData(name));
    if (!timeSeries)
      throw std::invalid_argument("Log '" + name + "' already exists but the values are a different type.");
  } else {
    timeSeries = new TimeSeriesProperty<T>(name);
    run.addProperty(timeSeries);
  }
  timeSeries->addValue(time, value);
}
} // namespace
 
// Register the algorithm into the AlgorithmFactory
DECLARE_ALGORITHM(AddTimeSeriesLog)
 
//----------------------------------------------------------------------------------------------
const std::string AddTimeSeriesLog::name() const { return "AddTimeSeriesLog"; }
 
int AddTimeSeriesLog::version() const { return 1; }
 
const std::string AddTimeSeriesLog::category() const { return "DataHandling\\Logs"; }
 
//----------------------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------------------
void AddTimeSeriesLog::init() {
  declareProperty(std::make_unique<WorkspaceProperty<MatrixWorkspace>>("Workspace", "", Direction::InOut),
                  "In/out workspace that will store the new log information");
 
  declareProperty("Name", "", std::make_shared<MandatoryValidator<std::string>>(),
                  "A string name for either a new time series log to be created "
                  "or an existing name to update",
                  Direction::Input);
  declareProperty("Time", "", std::make_shared<DateTimeValidator>(),
                  "An ISO formatted date/time string specifying the timestamp for "
                  "the given log value, e.g 2010-09-14T04:20:12",
                  Direction::Input);
  auto nonEmtpyDbl = std::make_shared<MandatoryValidator<double>>();
  declareProperty("Value", EMPTY_DBL(), nonEmtpyDbl, "The value for the log at the given time", Direction::Input);
 
  auto optionsValidator = std::make_shared<ListValidator<std::string>>();
  optionsValidator->addAllowedValue("double");
  optionsValidator->addAllowedValue("int");
  declareProperty("Type", "double", optionsValidator,
                  "An optional type for the given value. A double value with a "
                  "Type=int will have "
                  "the fractional part chopped off.",
                  Direction::Input);
  declareProperty("DeleteExisting", false, "If true and the named log exists then the whole log is removed first.",
                  Direction::Input);
}
 
//----------------------------------------------------------------------------------------------
void AddTimeSeriesLog::exec() {
  MatrixWorkspace_sptr logWS = getProperty("Workspace");
  std::string name = getProperty("Name");
 
  const bool deleteExisting = getProperty("DeleteExisting");
  auto &run = logWS->mutableRun();
  if (deleteExisting && run.hasProperty(name))
    removeExisting(logWS, name);
 
  createOrUpdate(run, name);
}
 
void AddTimeSeriesLog::removeExisting(API::MatrixWorkspace_sptr &logWS, const std::string &name) {
  auto deleter = createChildAlgorithm("DeleteLog", -1, -1, false);
  deleter->setProperty("Workspace", logWS);
  deleter->setProperty("Name", name);
  deleter->executeAsChildAlg();
}
 
void AddTimeSeriesLog::createOrUpdate(API::Run &run, const std::string &name) {
  std::string time = getProperty("Time");
  double valueAsDouble = getProperty("Value");
  std::string type = getProperty("Type");
  bool asInt = (type == "int");
 
  if (asInt) {
    createOrUpdateValue<int>(run, name, time, static_cast<int>(valueAsDouble));
  } else {
    createOrUpdateValue<double>(run, name, time, valueAsDouble);
  }
}
 
} // namespace Mantid::Algorithms