AlgorithmHistory.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 +
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAPI/AlgorithmHistory.h"
#include "MantidAPI/Algorithm.h"
 
#if BOOST_VERSION == 106900
#ifndef BOOST_PENDING_INTEGER_LOG2_HPP
#define BOOST_PENDING_INTEGER_LOG2_HPP
#include <boost/integer/integer_log2.hpp>
#endif /* BOOST_PENDING_INTEGER_LOG2_HPP */
#endif /* BOOST_VERSION */
 
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
 
#include <algorithm>
#include <iterator>
#include <sstream>
#include <utility>
 
namespace Mantid::API {
 
using Kernel::Property;
using Kernel::PropertyHistories;
using Kernel::PropertyHistory;
using Kernel::PropertyHistory_const_sptr;
using Kernel::PropertyHistory_sptr;
using Types::Core::DateAndTime;
 
namespace {
static boost::uuids::random_generator uuidGen;
} // namespace
 
AlgorithmHistory::AlgorithmHistory(const Algorithm *const alg, const Types::Core::DateAndTime &start,
                                   const double &duration, std::size_t uexeccount)
    : m_name(alg->name()), m_version(alg->version()), m_executionDate(start), m_executionDuration(duration),
      m_execCount(uexeccount), m_childHistories() {
  // Now go through the algorithm's properties and create the PropertyHistory
  // objects.
  setProperties(alg);
  m_uuid = boost::uuids::to_string(uuidGen());
}
 
AlgorithmHistory::AlgorithmHistory() : m_uuid(boost::uuids::to_string(uuidGen())) {}
 
AlgorithmHistory::AlgorithmHistory(std::string name, int vers, std::string uuid, const Types::Core::DateAndTime &start,
                                   const double &duration, std::size_t uexeccount)
    : m_name(std::move(name)), m_version(vers), m_executionDate(start), m_executionDuration(duration),
      m_execCount(uexeccount), m_childHistories(), m_uuid(std::move(uuid)) {}
 
void AlgorithmHistory::setProperties(const Algorithm *const alg) {
  // overwrite any existing properties
  m_properties.clear();
  // Now go through the algorithm's properties and create the PropertyHistory
  // objects.
  const std::vector<Property *> &properties = alg->getProperties();
  std::transform(properties.cbegin(), properties.cend(), std::back_inserter(m_properties),
                 [](const auto &property) { return std::make_shared<PropertyHistory>(property->createHistory()); });
}
 
void AlgorithmHistory::fillAlgorithmHistory(const Algorithm *const alg, const Types::Core::DateAndTime &start,
                                            const double &duration, std::size_t uexeccount) {
  m_name = alg->name();
  m_version = alg->version();
  m_executionDate = start;
  m_executionDuration = duration;
  m_execCount = uexeccount;
  setProperties(alg);
}
 
void AlgorithmHistory::addExecutionInfo(const DateAndTime &start, const double &duration) {
  m_executionDate = start;
  m_executionDuration = duration;
}
 
void AlgorithmHistory::addProperty(const std::string &name, const std::string &value, bool isdefault,
                                   const unsigned int &direction) {
  m_properties.emplace_back(std::make_shared<PropertyHistory>(name, value, "", isdefault, direction));
}
 
void AlgorithmHistory::addChildHistory(const AlgorithmHistory_sptr &childHist) {
  // Don't copy one's own history onto oneself
  if (this == &(*childHist)) {
    return;
  }
 
  m_childHistories.emplace_back(childHist);
}
 
/*
 Return the child history length
 */
size_t AlgorithmHistory::childHistorySize() const { return m_childHistories.size(); }
 
AlgorithmHistory_sptr AlgorithmHistory::getChildAlgorithmHistory(const size_t index) const {
  if (index >= this->getChildHistories().size()) {
    throw std::out_of_range("AlgorithmHistory::getAlgorithmHistory() - Index out of range");
  }
  return *std::next(m_childHistories.cbegin(), index);
}
 
AlgorithmHistory_sptr AlgorithmHistory::operator[](const size_t index) const { return getChildAlgorithmHistory(index); }
 
const std::string &AlgorithmHistory::getPropertyValue(const std::string &name) const {
  const auto found = std::find_if(m_properties.cbegin(), m_properties.cend(),
                                  [&name](const auto &history) { return history->name() == name; });
  if (found == m_properties.cend()) {
    throw Kernel::Exception::NotFoundError("Could not find the specified property", name);
  }
  return (*found)->value();
}
 
std::shared_ptr<IAlgorithm> AlgorithmHistory::getChildAlgorithm(const size_t index) const {
  return Algorithm::fromHistory(*(this->getChildAlgorithmHistory(index)));
}
 
void AlgorithmHistory::printSelf(std::ostream &os, const int indent, const size_t maxPropertyLength) const {
  auto execDate = m_executionDate.toISO8601String();
  execDate.replace(execDate.find("T"), 1, " ");
  os << std::string(indent, ' ') << "Algorithm: " << m_name;
  os << std::string(indent, ' ') << " v" << m_version << '\n';
 
  os << std::string(indent, ' ') << "Execution Date: " << execDate << '\n';
  os << std::string(indent, ' ') << "Execution Duration: " << m_executionDuration << " seconds\n";
  os << std::string(indent, ' ') << "UUID: " << m_uuid << '\n';
  os << std::string(indent, ' ') << "Parameters:\n";
 
  for (const auto &property : m_properties) {
    property->printSelf(os, indent + 2, maxPropertyLength);
  }
}
 
std::shared_ptr<IAlgorithm> AlgorithmHistory::createAlgorithm() const { return Algorithm::fromHistory(*this); }
 
AlgorithmHistory &AlgorithmHistory::operator=(const AlgorithmHistory &A) {
  if (this != &A) {
    m_name = A.m_name;
    m_version = A.m_version;
    m_executionDate = A.m_executionDate;
    m_executionDuration = A.m_executionDuration;
    m_properties = A.m_properties;
    // required to prevent destruction of descendant if assigning a descendant
    // to an ancestor
    auto temp = A.m_childHistories;
    m_childHistories = temp;
    m_uuid = A.m_uuid;
  }
  return *this;
}
 
std::ostream &operator<<(std::ostream &os, const AlgorithmHistory &AH) {
  AH.printSelf(os);
  return os;
}
 
void AlgorithmHistory::saveNexus(::NeXus::File *file, int &algCount) const {
  std::stringstream algNumber;
  ++algCount;
  algNumber << "MantidAlgorithm_" << algCount; // history entry names start at 1 not 0
 
  std::stringstream algData;
  printSelf(algData);
 
  file->makeGroup(algNumber.str(), "NXnote", true);
  file->writeData("author", std::string("mantid"));
  file->writeData("description", std::string("Mantid Algorithm data"));
  file->writeData("data", algData.str());
 
  // child algorithms
  for (auto &history : m_childHistories) {
    history->saveNexus(file, algCount);
  }
  file->closeGroup();
}
} // namespace Mantid::API