Algorithm.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/Algorithm.h"
#include "MantidAPI/ADSValidator.h"
#include "MantidAPI/AlgorithmHistory.h"
#include "MantidAPI/AlgorithmManager.h"
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/DeprecatedAlgorithm.h"
#include "MantidAPI/DeprecatedAlias.h"
#include "MantidAPI/IWorkspaceProperty.h"
#include "MantidAPI/WorkspaceGroup.h"
#include "MantidAPI/WorkspaceHistory.h"
 
#include "MantidJson/Json.h"
#include "MantidKernel/CompositeValidator.h"
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/EmptyValues.h"
#include "MantidKernel/MultiThreaded.h"
#include "MantidKernel/PropertyWithValue.h"
#include "MantidKernel/Strings.h"
#include "MantidKernel/Timer.h"
#include "MantidKernel/UsageService.h"
 
#include "MantidParallel/Communicator.h"
 
#include "MantidKernel/StringTokenizer.h"
#include <Poco/ActiveMethod.h>
#include <Poco/ActiveResult.h>
#include <Poco/NotificationCenter.h>
#include <Poco/RWLock.h>
#include <Poco/Void.h>
 
#include <json/json.h>
 
#include <algorithm>
#include <iterator>
#include <map>
#include <memory>
#include <utility>
 
// Index property handling template definitions
#include "MantidAPI/Algorithm.tcc"
 
using namespace Mantid::Kernel;
 
namespace Mantid {
namespace API {
namespace {
const std::string WORKSPACE_TYPES_SEPARATOR = ";";
 
const size_t DELAY_BEFORE_GC = 5;
 
class WorkspacePropertyValueIs {
public:
  explicit WorkspacePropertyValueIs(const std::string &value) : m_value(value) {}
  bool operator()(IWorkspaceProperty *property) {
    auto *prop = dynamic_cast<Property *>(property);
    if (!prop)
      return false;
    return prop->value() == m_value;
  }
 
private:
  const std::string &m_value;
};
 
template <typename T> struct RunOnFinish {
  RunOnFinish(T &&task) : m_onfinsh(std::move(task)) {}
  ~RunOnFinish() { m_onfinsh(); }
 
private:
  T m_onfinsh;
};
 
} // namespace
 
// Doxygen can't handle member specialization at the moment:
// https://bugzilla.gnome.org/show_bug.cgi?id=406027
// so we have to ignore them
template <typename NumT> bool Algorithm::isEmpty(const NumT toCheck) {
  return static_cast<int>(toCheck) == EMPTY_INT();
}
 
template <> MANTID_API_DLL bool Algorithm::isEmpty(const double toCheck) {
  return std::abs((toCheck - EMPTY_DBL()) / (EMPTY_DBL())) < 1e-8;
}
 
// concrete instantiations
template MANTID_API_DLL bool Algorithm::isEmpty<int>(const int);
template MANTID_API_DLL bool Algorithm::isEmpty<int64_t>(const int64_t);
template MANTID_API_DLL bool Algorithm::isEmpty<std::size_t>(const std::size_t);
 
//=============================================================================================
//================================== Constructors/Destructors
//=================================
//=============================================================================================
 
size_t Algorithm::g_execCount = 0;
 
Algorithm::Algorithm()
    : m_cancel(false), m_parallelException(false), m_log("Algorithm"), g_log(m_log), m_groupSize(0),
      m_executeAsync(nullptr), m_notificationCenter(nullptr), m_progressObserver(nullptr),
      m_executionState(ExecutionState::Uninitialized), m_resultState(ResultState::NotFinished),
      m_isChildAlgorithm(false), m_recordHistoryForChild(false), m_alwaysStoreInADS(true), m_runningAsync(false),
      m_rethrow(false), m_isAlgStartupLoggingEnabled(true), m_startChildProgress(0.), m_endChildProgress(0.),
      m_algorithmID(this), m_singleGroup(-1), m_groupsHaveSimilarNames(false), m_inputWorkspaceHistories(),
      m_communicator(std::make_unique<Parallel::Communicator>()), m_properties() {}
 
Algorithm::~Algorithm() = default;
 
//=============================================================================================
//================================== Simple Getters/Setters
//===================================
//=============================================================================================
 
ExecutionState Algorithm::executionState() const { return m_executionState; }
 
void Algorithm::setExecutionState(const ExecutionState state) { m_executionState = state; }
 
ResultState Algorithm::resultState() const { return m_resultState; }
 
void Algorithm::setResultState(const ResultState state) {
  if (state != ResultState::NotFinished) {
    setExecutionState(ExecutionState::Finished);
  }
  m_resultState = state;
}
 
//---------------------------------------------------------------------------------------------
bool Algorithm::isInitialized() const { return (m_executionState != ExecutionState::Uninitialized); }
 
bool Algorithm::isExecuted() const {
  return ((executionState() == ExecutionState::Finished) && (resultState() == ResultState::Success));
}
 
//---------------------------------------------------------------------------------------------
bool Algorithm::isChild() const { return m_isChildAlgorithm; }
 
void Algorithm::setChild(const bool isChild) {
  m_isChildAlgorithm = isChild;
  this->setAlwaysStoreInADS(!isChild);
}
 
void Algorithm::enableHistoryRecordingForChild(const bool on) { m_recordHistoryForChild = on; }
 
void Algorithm::setAlwaysStoreInADS(const bool doStore) { m_alwaysStoreInADS = doStore; }
 
bool Algorithm::getAlwaysStoreInADS() const { return m_alwaysStoreInADS; }
 
void Algorithm::setRethrows(const bool rethrow) { this->m_rethrow = rethrow; }
 
bool Algorithm::isRunning() const { return (executionState() == ExecutionState::Running); }
 
bool Algorithm::isReadyForGarbageCollection() const {
  if ((executionState() == ExecutionState::Finished) &&
      (Mantid::Types::Core::DateAndTime::getCurrentTime() > m_gcTime)) {
    return true;
  }
  return false;
}
 
//---------------------------------------------------------------------------------------------
void Algorithm::addObserver(const Poco::AbstractObserver &observer) const {
  notificationCenter().addObserver(observer);
}
 
void Algorithm::removeObserver(const Poco::AbstractObserver &observer) const {
  notificationCenter().removeObserver(observer);
}
 
//---------------------------------------------------------------------------------------------
void Algorithm::progress(double p, const std::string &msg, double estimatedTime, int progressPrecision) {
  notificationCenter().postNotification(new ProgressNotification(this, p, msg, estimatedTime, progressPrecision));
}
 
//---------------------------------------------------------------------------------------------
const std::vector<std::string> Algorithm::categories() const {
  Mantid::Kernel::StringTokenizer tokenizer(category(), categorySeparator(),
                                            Mantid::Kernel::StringTokenizer::TOK_TRIM |
                                                Mantid::Kernel::StringTokenizer::TOK_IGNORE_EMPTY);
 
  auto res = tokenizer.asVector();
 
  const auto *depo = dynamic_cast<const DeprecatedAlgorithm *>(this);
  if (depo != nullptr) {
    res.emplace_back("Deprecated");
  }
  return res;
}
 
const std::string Algorithm::workspaceMethodName() const { return ""; }
 
const std::vector<std::string> Algorithm::workspaceMethodOn() const {
  Mantid::Kernel::StringTokenizer tokenizer(this->workspaceMethodOnTypes(), WORKSPACE_TYPES_SEPARATOR,
                                            Mantid::Kernel::StringTokenizer::TOK_TRIM |
                                                Mantid::Kernel::StringTokenizer::TOK_IGNORE_EMPTY);
  return tokenizer.asVector();
}
 
const std::string Algorithm::workspaceMethodInputProperty() const { return ""; }
 
//---------------------------------------------------------------------------------------------
void Algorithm::initialize() {
  // Bypass the initialization if the algorithm has already been initialized.
  if (isInitialized())
    return;
 
  g_log.setName(this->name());
  setLoggingOffset(0);
  try {
    try {
      this->init();
      setupSkipValidationMasterOnly();
    } catch (std::runtime_error &) {
      throw;
    }
 
    // Indicate that this Algorithm has been initialized to prevent duplicate
    // attempts.
    setExecutionState(ExecutionState::Initialized);
  } catch (std::runtime_error &) {
    throw;
  }
  // Unpleasant catch-all! Along with this, Gaudi version catches GaudiException
  // & std::exception
  // but doesn't really do anything except (print fatal) messages.
  catch (...) {
    // Gaudi: A call to the auditor service is here
    // (1) perform the printout
    getLogger().fatal("UNKNOWN Exception is caught in initialize()");
    throw;
  }
}
 
//---------------------------------------------------------------------------------------------
std::map<std::string, std::string> Algorithm::validateInputs() { return std::map<std::string, std::string>(); }
 
//---------------------------------------------------------------------------------------------
void Algorithm::cacheWorkspaceProperties() {
  m_inputWorkspaceProps.clear();
  m_outputWorkspaceProps.clear();
  m_pureOutputWorkspaceProps.clear();
  const auto &props = this->getProperties();
  for (const auto &prop : props) {
    auto wsProp = dynamic_cast<IWorkspaceProperty *>(prop);
    if (!wsProp)
      continue;
    switch (prop->direction()) {
    case Kernel::Direction::Input:
      m_inputWorkspaceProps.emplace_back(wsProp);
      break;
    case Kernel::Direction::InOut:
      m_inputWorkspaceProps.emplace_back(wsProp);
      m_outputWorkspaceProps.emplace_back(wsProp);
      break;
    case Kernel::Direction::Output:
      m_outputWorkspaceProps.emplace_back(wsProp);
      m_pureOutputWorkspaceProps.emplace_back(wsProp);
      break;
    default:
      throw std::logic_error("Unexpected property direction found for property " + prop->name() + " of algorithm " +
                             this->name());
    }
  }
}
 
void Algorithm::cacheInputWorkspaceHistories() {
  if (!trackingHistory())
    return;
 
  auto cacheHistories = [this](const Workspace_sptr &ws) {
    if (auto group = dynamic_cast<const WorkspaceGroup *>(ws.get())) {
      m_inputWorkspaceHistories.reserve(m_inputWorkspaceHistories.size() + group->size());
      std::copy(group->begin(), group->end(), std::back_inserter(m_inputWorkspaceHistories));
    } else {
      m_inputWorkspaceHistories.emplace_back(ws);
    }
  };
  using ArrayPropertyString = ArrayProperty<std::string>;
  auto isADSValidator = [](const IValidator_sptr &validator) -> bool {
    if (!validator)
      return false;
    if (dynamic_cast<ADSValidator *>(validator.get()))
      return true;
    if (const auto compValidator = dynamic_cast<CompositeValidator *>(validator.get()))
      return compValidator->contains<ADSValidator>();
 
    return false;
  };
 
  // Look over all properties so we can catch an string array properties
  // with an ADSValidator. ADSValidator indicates that the strings
  // point to workspace names so we want to pick up the history from these too.
  const auto &ads = AnalysisDataService::Instance();
  m_inputWorkspaceHistories.clear();
  const auto &props = this->getProperties();
  for (const auto &prop : props) {
    if (prop->direction() != Direction::Input && prop->direction() != Direction::InOut)
      continue;
 
    if (auto wsProp = dynamic_cast<IWorkspaceProperty *>(prop)) {
      if (auto ws = wsProp->getWorkspace()) {
        cacheHistories(ws);
      } else {
        Workspace_sptr wsFromADS;
        try {
          wsFromADS = ads.retrieve(prop->value());
        } catch (Exception::NotFoundError &) {
          continue;
        }
        cacheHistories(wsFromADS);
      }
    } else if (auto strArrayProp = dynamic_cast<ArrayPropertyString *>(prop)) {
      if (!isADSValidator(strArrayProp->getValidator()))
        continue;
      const auto &wsNames((*strArrayProp)());
      for (const auto &name : wsNames) {
        cacheHistories(ads.retrieve(name));
      }
    }
  }
} // namespace API
 
//---------------------------------------------------------------------------------------------
void Algorithm::lockWorkspaces() {
  // Do not lock workspace for child algos
  if (this->isChild())
    return;
 
  if (!m_readLockedWorkspaces.empty() || !m_writeLockedWorkspaces.empty())
    throw std::logic_error("Algorithm::lockWorkspaces(): The workspaces have "
                           "already been locked!");
 
  // First, Write-lock the output workspaces
  auto &debugLog = g_log.debug();
  for (auto &outputWorkspaceProp : m_outputWorkspaceProps) {
    Workspace_sptr ws = outputWorkspaceProp->getWorkspace();
    if (ws) {
      // The workspace property says to do locking,
      // AND it has NOT already been write-locked
      if (outputWorkspaceProp->isLocking() && std::find(m_writeLockedWorkspaces.begin(), m_writeLockedWorkspaces.end(),
                                                        ws) == m_writeLockedWorkspaces.end()) {
        // Write-lock it if not already
        debugLog << "Write-locking " << ws->getName() << '\n';
        ws->getLock()->writeLock();
        m_writeLockedWorkspaces.emplace_back(ws);
      }
    }
  }
 
  // Next read-lock the input workspaces
  for (auto &inputWorkspaceProp : m_inputWorkspaceProps) {
    Workspace_sptr ws = inputWorkspaceProp->getWorkspace();
    if (ws) {
      // The workspace property says to do locking,
      // AND it has NOT already been write-locked
      if (inputWorkspaceProp->isLocking() && std::find(m_writeLockedWorkspaces.begin(), m_writeLockedWorkspaces.end(),
                                                       ws) == m_writeLockedWorkspaces.end()) {
        // Read-lock it if not already write-locked
        debugLog << "Read-locking " << ws->getName() << '\n';
        ws->getLock()->readLock();
        m_readLockedWorkspaces.emplace_back(ws);
      }
    }
  }
}
 
//---------------------------------------------------------------------------------------------
void Algorithm::unlockWorkspaces() {
  // Do not lock workspace for child algos
  if (this->isChild())
    return;
  auto &debugLog = g_log.debug();
  for (auto &ws : m_writeLockedWorkspaces) {
    if (ws) {
      debugLog << "Unlocking " << ws->getName() << '\n';
      ws->getLock()->unlock();
    }
  }
  for (auto &ws : m_readLockedWorkspaces) {
    if (ws) {
      debugLog << "Unlocking " << ws->getName() << '\n';
      ws->getLock()->unlock();
    }
  }
 
  // Don't double-unlock workspaces
  m_readLockedWorkspaces.clear();
  m_writeLockedWorkspaces.clear();
}
 
void Algorithm::clearWorkspaceCaches() {
  m_groupWorkspaces.clear();
  m_inputWorkspaceHistories.clear();
  m_inputWorkspaceProps.clear();
  m_outputWorkspaceProps.clear();
  m_pureOutputWorkspaceProps.clear();
  m_unrolledInputWorkspaces.clear();
}
 
//---------------------------------------------------------------------------------------------
bool Algorithm::executeInternal() {
  Timer timer;
  bool algIsExecuted = false;
  AlgorithmManager::Instance().notifyAlgorithmStarting(this->getAlgorithmID());
 
  // runtime check for deprecation warning
  {
    auto *depo = dynamic_cast<DeprecatedAlgorithm *>(this);
    if (depo != nullptr)
      getLogger().error(depo->deprecationMsg(this));
  }
 
  // runtime check for deprecated alias warning
  {
    auto *da_alg = dynamic_cast<DeprecatedAlias *>(this);
    if ((da_alg != nullptr) && (this->calledByAlias))
      getLogger().warning(da_alg->deprecationMessage(this));
  }
 
  // Register clean up tasks that should happen regardless of the route
  // out of the algorithm. These tasks will get run after this method
  // finishes.
  RunOnFinish onFinish([this]() { this->clearWorkspaceCaches(); });
 
  notificationCenter().postNotification(new StartedNotification(this));
  Mantid::Types::Core::DateAndTime startTime;
 
  // Return a failure if the algorithm hasn't been initialized
  if (!isInitialized()) {
    throw std::runtime_error("Algorithm is not initialised:" + this->name());
  }
 
  // no logging of input if a child algorithm (except for python child algos)
  if (!m_isChildAlgorithm || m_alwaysStoreInADS)
    logAlgorithmInfo();
 
  // Check all properties for validity
  constexpr bool resetTimer{true};
  float timingInit = timer.elapsed(resetTimer);
  if (!validateProperties()) {
    // Reset name on input workspaces to trigger attempt at collection from ADS
    const auto &props = getProperties();
    for (auto &prop : props) {
      auto wsProp = dynamic_cast<IWorkspaceProperty *>(prop);
      if (wsProp && !(wsProp->getWorkspace())) {
        // Setting it's name to the same one it already had
        prop->setValue(prop->value());
      }
    }
    // Try the validation again
    if (!validateProperties()) {
      notificationCenter().postNotification(new ErrorNotification(this, "Some invalid Properties found"));
      throw std::runtime_error("Some invalid Properties found");
    }
  }
  const float timingPropertyValidation = timer.elapsed(resetTimer);
 
  // All properties are now valid - cache workspace properties and histories
  cacheWorkspaceProperties();
  cacheInputWorkspaceHistories();
 
  // ----- Check for processing groups -------------
  // default true so that it has the right value at the check below the catch
  // block should checkGroups throw
  bool callProcessGroups = true;
  try {
    // Checking the input is a group. Throws if the sizes are wrong
    callProcessGroups = this->checkGroups();
  } catch (std::exception &ex) {
    getLogger().error() << "Error in execution of algorithm " << this->name() << "\n" << ex.what() << "\n";
    notificationCenter().postNotification(new ErrorNotification(this, ex.what()));
    setResultState(ResultState::Failed);
    if (m_isChildAlgorithm || m_runningAsync || m_rethrow) {
      m_runningAsync = false;
      throw;
    }
    return false;
  }
 
  const auto executionMode = getExecutionMode();
 
  timingInit += timer.elapsed(resetTimer);
  // ----- Perform validation of the whole set of properties -------------
  if ((!callProcessGroups) && (executionMode != Parallel::ExecutionMode::MasterOnly ||
                               communicator().rank() == 0)) // for groups this is called on each
                                                            // workspace separately
  {
    std::map<std::string, std::string> errors = this->validateInputs();
    if (!errors.empty()) {
      size_t numErrors = errors.size();
      // Log each issue
      auto &errorLog = getLogger().error();
      auto &warnLog = getLogger().warning();
      for (auto &error : errors) {
        if (this->existsProperty(error.first))
          errorLog << "Invalid value for " << error.first << ": " << error.second << "\n";
        else {
          numErrors -= 1; // don't count it as an error
          warnLog << "validateInputs() references non-existant property \"" << error.first << "\"\n";
        }
      }
      // Throw because something was invalid
      if (numErrors > 0) {
        std::stringstream msg;
        msg << "Some invalid Properties found: ";
        for (auto &error : errors) {
          msg << "\n " << error.first << ": " << error.second;
        }
        notificationCenter().postNotification(new ErrorNotification(this, "Some invalid Properties found"));
        throw std::runtime_error(msg.str());
      }
    }
  }
  const float timingInputValidation = timer.elapsed(resetTimer);
 
  if (trackingHistory()) {
    // count used for defining the algorithm execution order
    // If history is being recorded we need to count this as a separate
    // algorithm
    // as the history compares histories by their execution number
    ++Algorithm::g_execCount;
 
    // populate history record before execution so we can record child
    // algorithms in it
    AlgorithmHistory algHist;
    m_history = std::make_shared<AlgorithmHistory>(algHist);
  }
 
  // ----- Process groups -------------
  // If checkGroups() threw an exception but there ARE group workspaces
  // (means that the group sizes were incompatible)
  if (callProcessGroups) {
    return doCallProcessGroups(startTime);
  }
 
  // Read or write locks every input/output workspace
  this->lockWorkspaces();
  timingInit += timer.elapsed(resetTimer);
 
  // Invoke exec() method of derived class and catch all uncaught exceptions
  try {
    try {
      setExecutionState(ExecutionState::Running);
 
      startTime = Mantid::Types::Core::DateAndTime::getCurrentTime();
      // Call the concrete algorithm's exec method
      this->exec(executionMode);
      registerFeatureUsage();
      // Check for a cancellation request in case the concrete algorithm doesn't
      interruption_point();
      const float timingExec = timer.elapsed(resetTimer);
      // The total runtime including all init steps is used for general logging.
      const float duration = timingInit + timingPropertyValidation + timingInputValidation + timingExec;
      // need it to throw before trying to run fillhistory() on an algorithm
      // which has failed
      if (trackingHistory() && m_history) {
        m_history->fillAlgorithmHistory(this, startTime, duration, Algorithm::g_execCount);
        fillHistory();
        linkHistoryWithLastChild();
      }
 
      // Put the output workspaces into the AnalysisDataService - if requested
      if (m_alwaysStoreInADS)
        this->store();
 
      // just cache the value internally, it is set at the very end of this
      // method
      algIsExecuted = true;
 
      // Log that execution has completed.
      getLogger().debug("Time to validate properties: " + std::to_string(timingPropertyValidation) + " seconds\n" +
                        "Time for other input validation: " + std::to_string(timingInputValidation) + " seconds\n" +
                        "Time for other initialization: " + std::to_string(timingInit) + " seconds\n" +
                        "Time to run exec: " + std::to_string(timingExec) + " seconds\n");
      reportCompleted(duration);
    } catch (std::runtime_error &ex) {
      m_gcTime = Mantid::Types::Core::DateAndTime::getCurrentTime() +=
          (Mantid::Types::Core::DateAndTime::ONE_SECOND * DELAY_BEFORE_GC);
      setResultState(ResultState::Failed);
      notificationCenter().postNotification(new ErrorNotification(this, ex.what()));
      this->unlockWorkspaces();
      if (m_isChildAlgorithm || m_runningAsync || m_rethrow)
        throw;
      else {
        getLogger().error() << "Error in execution of algorithm " << this->name() << '\n' << ex.what() << '\n';
      }
 
    } catch (std::logic_error &ex) {
      m_gcTime = Mantid::Types::Core::DateAndTime::getCurrentTime() +=
          (Mantid::Types::Core::DateAndTime::ONE_SECOND * DELAY_BEFORE_GC);
      notificationCenter().postNotification(new ErrorNotification(this, ex.what()));
      setResultState(ResultState::Failed);
      this->unlockWorkspaces();
      if (m_isChildAlgorithm || m_runningAsync || m_rethrow)
        throw;
      else {
        getLogger().error() << "Logic Error in execution of algorithm " << this->name() << '\n' << ex.what() << '\n';
      }
    }
  } catch (CancelException &ex) {
    m_runningAsync = false;
    getLogger().warning() << this->name() << ": Execution cancelled by user.\n";
    m_gcTime = Mantid::Types::Core::DateAndTime::getCurrentTime() +=
        (Mantid::Types::Core::DateAndTime::ONE_SECOND * DELAY_BEFORE_GC);
    setResultState(ResultState::Failed);
    notificationCenter().postNotification(new ErrorNotification(this, ex.what()));
    this->unlockWorkspaces();
 
    throw;
  }
  // Gaudi also specifically catches GaudiException & std:exception.
  catch (std::exception &ex) {
    m_runningAsync = false;
    getLogger().error() << "Error in execution of algorithm " << this->name() << ":\n" << ex.what() << "\n";
    m_gcTime = Mantid::Types::Core::DateAndTime::getCurrentTime() +=
        (Mantid::Types::Core::DateAndTime::ONE_SECOND * DELAY_BEFORE_GC);
    setResultState(ResultState::Failed);
    notificationCenter().postNotification(new ErrorNotification(this, ex.what()));
    this->unlockWorkspaces();
 
    throw;
  }
 
  catch (...) {
    // Execution failed with an unknown exception object
    m_runningAsync = false;
 
    m_gcTime = Mantid::Types::Core::DateAndTime::getCurrentTime() +=
        (Mantid::Types::Core::DateAndTime::ONE_SECOND * DELAY_BEFORE_GC);
    setResultState(ResultState::Failed);
    notificationCenter().postNotification(new ErrorNotification(this, "UNKNOWN Exception is caught in exec()"));
    getLogger().error() << this->name() << ": UNKNOWN Exception is caught in exec()\n";
    this->unlockWorkspaces();
 
    throw;
  }
 
  m_gcTime = Mantid::Types::Core::DateAndTime::getCurrentTime() +=
      (Mantid::Types::Core::DateAndTime::ONE_SECOND * DELAY_BEFORE_GC);
  if (algIsExecuted) {
    setResultState(ResultState::Success);
  }
 
  // Only gets to here if algorithm ended normally
  notificationCenter().postNotification(new FinishedNotification(this, isExecuted()));
 
  // Unlock the workspaces once the notification has been sent, to prevent too early deletion
  this->unlockWorkspaces();
 
  return isExecuted();
}
 
//---------------------------------------------------------------------------------------------
void Algorithm::executeAsChildAlg() {
  bool executed = false;
  try {
    executed = execute();
  } catch (std::runtime_error &) {
    throw;
  }
 
  if (!executed) {
    throw std::runtime_error("Unable to successfully run ChildAlgorithm " + this->name());
  }
}
 
//---------------------------------------------------------------------------------------------
void Algorithm::store() {
  const std::vector<Property *> &props = getProperties();
  std::vector<int> groupWsIndicies;
 
  // add any regular/child workspaces first, then add the groups
  for (unsigned int i = 0; i < props.size(); ++i) {
    auto *wsProp = dynamic_cast<IWorkspaceProperty *>(props[i]);
    if (wsProp) {
      // check if the workspace is a group, if so remember where it is and add
      // it later
      auto group = std::dynamic_pointer_cast<WorkspaceGroup>(wsProp->getWorkspace());
      if (!group) {
        try {
          wsProp->store();
        } catch (std::runtime_error &) {
          throw;
        }
      } else {
        groupWsIndicies.emplace_back(i);
      }
    }
  }
 
  // now store workspace groups once their members have been added
  std::vector<int>::const_iterator wsIndex;
  for (wsIndex = groupWsIndicies.begin(); wsIndex != groupWsIndicies.end(); ++wsIndex) {
    auto *wsProp = dynamic_cast<IWorkspaceProperty *>(props[*wsIndex]);
    if (wsProp) {
      try {
        wsProp->store();
      } catch (std::runtime_error &) {
        throw;
      }
    }
  }
}
 
//---------------------------------------------------------------------------------------------
Algorithm_sptr Algorithm::createChildAlgorithm(const std::string &name, const double startProgress,
                                               const double endProgress, const bool enableLogging, const int &version) {
  Algorithm_sptr alg = AlgorithmManager::Instance().createUnmanaged(name, version);
  setupAsChildAlgorithm(alg, startProgress, endProgress, enableLogging);
  return alg;
}
 
void Algorithm::setupAsChildAlgorithm(const Algorithm_sptr &alg, const double startProgress, const double endProgress,
                                      const bool enableLogging) {
  // set as a child
  alg->setChild(true);
  alg->setLogging(enableLogging);
 
  // Initialise the Child Algorithm
  try {
    alg->initialize();
  } catch (std::runtime_error &) {
    throw std::runtime_error("Unable to initialise Child Algorithm '" + alg->name() + "'");
  }
 
  // If output workspaces are nameless, give them a temporary name to satisfy
  // validator
  const std::vector<Property *> &props = alg->getProperties();
  for (auto prop : props) {
    auto wsProp = dynamic_cast<IWorkspaceProperty *>(prop);
    if (prop->direction() == Mantid::Kernel::Direction::Output && wsProp) {
      if (prop->value().empty() && !wsProp->isOptional()) {
        prop->createTemporaryValue();
      }
    }
  }
 
  if (startProgress >= 0.0 && endProgress > startProgress && endProgress <= 1.0) {
    alg->addObserver(this->progressObserver());
    m_startChildProgress = startProgress;
    m_endChildProgress = endProgress;
  }
 
  // Before we return the shared pointer, use it to create a weak pointer and
  // keep that in a vector.
  // It will be used this to pass on cancellation requests
  // It must be protected by a critical block so that Child Algorithms can run
  // in parallel safely.
  std::weak_ptr<IAlgorithm> weakPtr(alg);
  PARALLEL_CRITICAL(Algorithm_StoreWeakPtr) { m_ChildAlgorithms.emplace_back(weakPtr); }
}
 
//=============================================================================================
//================================== Algorithm History
//========================================
//=============================================================================================
 
std::string Algorithm::toString() const { return Mantid::JsonHelpers::jsonToString(toJson()); }
 
::Json::Value Algorithm::toJson() const {
  ::Json::Value root;
 
  root["name"] = name();
  root["version"] = this->version();
  root["properties"] = m_properties.asJson(false);
 
  return root;
}
 
//--------------------------------------------------------------------------------------------
IAlgorithm_sptr Algorithm::fromHistory(const AlgorithmHistory &history) {
  ::Json::Value root;
  ::Json::Value jsonMap;
 
  auto props = history.getProperties();
  const size_t numProps(props.size());
  for (size_t i = 0; i < numProps; ++i) {
    PropertyHistory_sptr prop = props[i];
    if (!prop->isDefault()) {
      jsonMap[prop->name()] = prop->value();
    }
  }
 
  root["name"] = history.name();
  root["version"] = history.version();
  root["properties"] = jsonMap;
 
  const std::string output = Mantid::JsonHelpers::jsonToString(root);
  IAlgorithm_sptr alg;
 
  try {
    alg = Algorithm::fromString(output);
  } catch (std::invalid_argument &) {
    throw std::runtime_error("Could not create algorithm from history. "
                             "Is this a child algorithm whose workspaces are not in the ADS?");
  }
  return alg;
}
 
//--------------------------------------------------------------------------------------------
IAlgorithm_sptr Algorithm::fromString(const std::string &input) {
  ::Json::Value root;
  if (Mantid::JsonHelpers::parse(input, &root)) {
    return fromJson(root);
  } else {
    throw std::runtime_error("Cannot create algorithm, invalid string format.");
  }
}
 
IAlgorithm_sptr Algorithm::fromJson(const Json::Value &serialized) {
  const std::string algName = serialized["name"].asString();
  const int version = serialized.get("version", -1).asInt();
  auto alg = AlgorithmManager::Instance().createUnmanaged(algName, version);
  alg->initialize();
  alg->setProperties(serialized["properties"]);
  return alg;
}
 
void Algorithm::fillHistory() {
  WorkspaceVector outputWorkspaces;
  if (!isChild()) {
    findWorkspaces(outputWorkspaces, Direction::Output);
  }
  fillHistory(outputWorkspaces);
}
 
void Algorithm::linkHistoryWithLastChild() {
  if (!m_recordHistoryForChild)
    return;
 
  // iterate over the algorithms output workspaces
  const auto &algProperties = getProperties();
  for (const auto &prop : algProperties) {
    if (prop->direction() != Kernel::Direction::Output && prop->direction() != Kernel::Direction::InOut)
      continue;
    const auto *wsProp = dynamic_cast<IWorkspaceProperty *>(prop);
    if (!wsProp)
      continue;
    // Check we actually have a workspace, it may have been optional
    Workspace_sptr workspace = wsProp->getWorkspace();
    if (!workspace)
      continue;
 
    bool linked = false;
    // find child histories with anonymous output workspaces
    const auto &childHistories = m_history->getChildHistories();
    auto childIter = childHistories.rbegin();
    for (; childIter != childHistories.rend() && !linked; ++childIter) {
      const auto &props = (*childIter)->getProperties();
      auto propIter = props.begin();
      for (; propIter != props.end() && !linked; ++propIter) {
        // check we have a workspace property
        if ((*propIter)->direction() == Kernel::Direction::Output ||
            (*propIter)->direction() == Kernel::Direction::InOut) {
          // if the workspaces are equal, then rename the history
          std::ostringstream os;
          os << "__TMP" << wsProp->getWorkspace().get();
          if (os.str() == (*propIter)->value()) {
            (*propIter)->setValue(prop->value());
            linked = true;
          }
        }
      }
    }
  }
}
 
void Algorithm::trackAlgorithmHistory(std::shared_ptr<AlgorithmHistory> parentHist) {
  enableHistoryRecordingForChild(true);
  m_parentHistory = std::move(parentHist);
}
 
bool Algorithm::trackingHistory() { return (!isChild() || m_recordHistoryForChild); }
 
void Algorithm::findWorkspaces(WorkspaceVector &workspaces, unsigned int direction, bool checkADS) const {
  auto workspaceFromWSProperty = [](const IWorkspaceProperty &prop, const AnalysisDataServiceImpl &ads,
                                    const std::string &strValue, bool checkADS) {
    auto workspace = prop.getWorkspace();
    if (workspace)
      return workspace;
 
    // Empty string indicates optional workspace
    if (checkADS && !strValue.empty()) {
      return ads.retrieve(strValue);
    }
    return Workspace_sptr();
  };
  auto appendWS = [&workspaces](const Workspace_sptr &workspace) {
    if (!workspace)
      return false;
    workspaces.emplace_back(workspace);
    return true;
  };
 
  // Additional output properties can be declared on the fly
  // so we need a fresh loop over the properties
  const auto &algProperties = getProperties();
  const auto &ads = AnalysisDataService::Instance();
  for (const auto &prop : algProperties) {
    const unsigned int propDirection = prop->direction();
    if (propDirection != direction && propDirection != Direction::InOut)
      continue;
    if (const auto wsProp = dynamic_cast<IWorkspaceProperty *>(prop)) {
      appendWS(workspaceFromWSProperty(*wsProp, ads, prop->value(), checkADS));
    }
  }
}
 
void Algorithm::logAlgorithmInfo() const {
  auto &logger = getLogger();
 
  if (m_isAlgStartupLoggingEnabled) {
    logger.notice() << name() << " started";
    if (this->isChild())
      logger.notice() << " (child)";
    logger.notice() << '\n';
    // Make use of the AlgorithmHistory class, which holds all the info we
    // want here
    AlgorithmHistory algHistory(this);
    size_t maxPropertyLength = 40;
    if (logger.is(Logger::Priority::PRIO_DEBUG)) {
      // include the full property value when logging in debug
      maxPropertyLength = 0;
    }
    algHistory.printSelf(logger.information(), 0, maxPropertyLength);
  }
}
 
//=============================================================================================
//================================== WorkspaceGroup-related
//===================================
//=============================================================================================
 
bool Algorithm::checkGroups() {
  size_t numGroups = 0;
  bool processGroups = false;
 
  // Unroll the groups or single inputs into vectors of workspaces
  const auto &ads = AnalysisDataService::Instance();
  m_unrolledInputWorkspaces.clear();
  m_groupWorkspaces.clear();
  for (auto inputWorkspaceProp : m_inputWorkspaceProps) {
    auto prop = dynamic_cast<Property *>(inputWorkspaceProp);
    auto wsGroupProp = dynamic_cast<WorkspaceProperty<WorkspaceGroup> *>(prop);
    auto ws = inputWorkspaceProp->getWorkspace();
    auto wsGroup = std::dynamic_pointer_cast<WorkspaceGroup>(ws);
 
    // Workspace groups are NOT returned by IWP->getWorkspace() most of the
    // time because WorkspaceProperty is templated by <MatrixWorkspace> and
    // WorkspaceGroup does not subclass <MatrixWorkspace>
    if (!wsGroup && prop && !prop->value().empty()) {
      // So try to use the name in the AnalysisDataService
      try {
        wsGroup = ads.retrieveWS<WorkspaceGroup>(prop->value());
      } catch (Exception::NotFoundError &) { /* Do nothing */
      }
    }
 
    // Found the group either directly or by name?
    // If the property is of type WorkspaceGroup then don't unroll
    if (wsGroup && !wsGroupProp) {
      numGroups++;
      processGroups = true;
      m_unrolledInputWorkspaces.emplace_back(wsGroup->getAllItems());
    } else {
      // Single Workspace. Treat it as a "group" with only one member
      if (ws)
        m_unrolledInputWorkspaces.emplace_back(WorkspaceVector{ws});
      else
        m_unrolledInputWorkspaces.emplace_back(WorkspaceVector{});
    }
 
    // Add to the list of groups
    m_groupWorkspaces.emplace_back(wsGroup);
  }
 
  // No groups? Get out.
  if (numGroups == 0)
    return processGroups;
 
  // ---- Confirm that all the groups are the same size -----
  // Index of the single group
  m_singleGroup = -1;
  // Size of the single or of all the groups
  m_groupSize = 1;
  m_groupsHaveSimilarNames = true;
  for (size_t i = 0; i < m_unrolledInputWorkspaces.size(); i++) {
    const auto &thisGroup = m_unrolledInputWorkspaces[i];
    // We're ok with empty groups if the workspace property is optional
    if (thisGroup.empty() && !m_inputWorkspaceProps[i]->isOptional())
      throw std::invalid_argument("Empty group passed as input");
    if (!thisGroup.empty()) {
      // Record the index of the single group.
      WorkspaceGroup_sptr wsGroup = m_groupWorkspaces[i];
      if (wsGroup && (numGroups == 1))
        m_singleGroup = int(i);
 
      // For actual groups (>1 members)
      if (thisGroup.size() > 1) {
        // Check for matching group size
        if (m_groupSize > 1)
          if (thisGroup.size() != m_groupSize)
            throw std::invalid_argument("Input WorkspaceGroups are not of the same size.");
 
        // Are ALL the names similar?
        if (wsGroup)
          m_groupsHaveSimilarNames = m_groupsHaveSimilarNames && wsGroup->areNamesSimilar();
 
        // Save the size for the next group
        m_groupSize = thisGroup.size();
      }
    }
  } // end for each group
 
  // If you get here, then the groups are compatible
  return processGroups;
}
 
bool Algorithm::doCallProcessGroups(Mantid::Types::Core::DateAndTime &startTime) {
  // In the base implementation of processGroups, this normally calls
  // this->execute() again on each member of the group. Other algorithms may
  // choose to override that behavior (examples: CompareWorkspaces,
  // CheckWorkspacesMatch, RenameWorkspace)
 
  startTime = Mantid::Types::Core::DateAndTime::getCurrentTime();
  // Start a timer
  Timer timer;
  bool completed = false;
  try {
    // Call the concrete algorithm's processGroups method
    completed = processGroups();
  } catch (std::exception &ex) {
    // The child algorithm will already have logged the error etc.,
    // but we also need to update flags in the parent algorithm and
    // send an ErrorNotification (because the child isn't registered with the
    // AlgorithmMonitor).
    setResultState(ResultState::Failed);
    m_runningAsync = false;
    notificationCenter().postNotification(new ErrorNotification(this, ex.what()));
    throw;
  } catch (...) {
    setResultState(ResultState::Failed);
    m_runningAsync = false;
    notificationCenter().postNotification(new ErrorNotification(this, "UNKNOWN Exception caught from processGroups"));
    throw;
  }
 
  // Check for a cancellation request in case the concrete algorithm doesn't
  interruption_point();
 
  if (completed) {
    // Get how long this algorithm took to run
    const float duration = timer.elapsed();
 
    m_history = std::make_shared<AlgorithmHistory>(this, startTime, duration, ++g_execCount);
    if (trackingHistory() && m_history) {
      // find any further outputs created by the execution
      WorkspaceVector outputWorkspaces;
      const bool checkADS{true};
      findWorkspaces(outputWorkspaces, Direction::Output, checkADS);
      fillHistory(outputWorkspaces);
    }
 
    // in the base processGroups each individual exec stores its outputs
    if (!m_usingBaseProcessGroups && m_alwaysStoreInADS)
      this->store();
 
    // Log that execution has completed.
    reportCompleted(duration, true /* this is for group processing*/);
    setResultState(ResultState::Success);
  } else {
    setResultState(ResultState::Failed);
  }
 
  notificationCenter().postNotification(new FinishedNotification(this, isExecuted()));
 
  return completed;
}
 
void Algorithm::fillHistory(const std::vector<Workspace_sptr> &outputWorkspaces) {
  // this is not a child algorithm. Add the history algorithm to the
  // WorkspaceHistory object.
  if (!isChild()) {
    auto copyHistoryToGroup = [](const Workspace &in, WorkspaceGroup &out) {
      for (auto &outGroupItem : out) {
        outGroupItem->history().addHistory(in.getHistory());
      }
    };
 
    for (auto &outWS : outputWorkspaces) {
      auto outWSGroup = std::dynamic_pointer_cast<WorkspaceGroup>(outWS);
      // Copy the history from the cached input workspaces to the output ones
      for (const auto &inputWS : m_inputWorkspaceHistories) {
        if (outWSGroup) {
          copyHistoryToGroup(*inputWS, *outWSGroup);
        } else {
          outWS->history().addHistory(inputWS->getHistory());
        }
      }
      // Add history for this operation
      if (outWSGroup) {
        for (auto &outGroupItem : *outWSGroup) {
          outGroupItem->history().addHistory(m_history);
        }
      } else {
        // Add the history for the current algorithm to all the output
        // workspaces
        outWS->history().addHistory(m_history);
      }
    }
  }
  // this is a child algorithm, but we still want to keep the history.
  else if (m_recordHistoryForChild && m_parentHistory) {
    m_parentHistory->addChildHistory(m_history);
  }
}
 
//--------------------------------------------------------------------------------------------
bool Algorithm::processGroups() {
  m_usingBaseProcessGroups = true;
 
  std::vector<WorkspaceGroup_sptr> outGroups;
 
  // ---------- Create all the output workspaces ----------------------------
  for (auto &pureOutputWorkspaceProp : m_pureOutputWorkspaceProps) {
    auto *prop = dynamic_cast<Property *>(pureOutputWorkspaceProp);
    if (prop && !prop->value().empty()) {
      auto outWSGrp = std::make_shared<WorkspaceGroup>();
      outGroups.emplace_back(outWSGrp);
      // Put the GROUP in the ADS
      AnalysisDataService::Instance().addOrReplace(prop->value(), outWSGrp);
      outWSGrp->observeADSNotifications(false);
    }
  }
 
  double progress_proportion = 1.0 / static_cast<double>(m_groupSize);
  // Go through each entry in the input group(s)
  for (size_t entry = 0; entry < m_groupSize; entry++) {
    // use create Child Algorithm that look like this one
    Algorithm_sptr alg_sptr = this->createChildAlgorithm(this->name(), progress_proportion * static_cast<double>(entry),
                                                         progress_proportion * (1 + static_cast<double>(entry)),
                                                         this->isLogging(), this->version());
    // Make a child algorithm and turn off history recording for it, but always
    // store result in the ADS
    alg_sptr->setChild(true);
    alg_sptr->setAlwaysStoreInADS(true);
    alg_sptr->enableHistoryRecordingForChild(false);
    alg_sptr->setRethrows(true);
 
    Algorithm *alg = alg_sptr.get();
    // Set all non-workspace properties
    this->copyNonWorkspaceProperties(alg, int(entry) + 1);
 
    std::string outputBaseName;
 
    // ---------- Set all the input workspaces ----------------------------
    for (size_t iwp = 0; iwp < m_unrolledInputWorkspaces.size(); iwp++) {
      std::vector<Workspace_sptr> &thisGroup = m_unrolledInputWorkspaces[iwp];
      if (!thisGroup.empty()) {
        // By default (for a single group) point to the first/only workspace
        Workspace_sptr ws = thisGroup[0];
 
        if ((m_singleGroup == int(iwp)) || m_singleGroup < 0) {
          // Either: this is the single group
          // OR: all inputs are groups
          // ... so get then entry^th workspace in this group
          if (entry < thisGroup.size()) {
            ws = thisGroup[entry];
          } else {
            // This can happen when one has more than one input group
            // workspaces, having different sizes. For example one workspace
            // group is the corrections which has N parts (e.g. weights for
            // polarized measurement) while the other one is the actual input
            // workspace group, where each item needs to be corrected together
            // with all N inputs of the second group. In this case processGroup
            // needs to be overridden, which is currently not possible in
            // python.
            throw std::runtime_error("Unable to process over groups; consider passing workspaces "
                                     "one-by-one or override processGroup method of the algorithm.");
          }
        }
        // Append the names together
        if (!outputBaseName.empty())
          outputBaseName += "_";
        outputBaseName += ws->getName();
 
        // Set the property using the name of that workspace
        if (auto *prop = dynamic_cast<Property *>(m_inputWorkspaceProps[iwp])) {
          if (ws->getName().empty()) {
            alg->setProperty(prop->name(), ws);
          } else {
            alg->setPropertyValue(prop->name(), ws->getName());
          }
        } else {
          throw std::logic_error("Found a Workspace property which doesn't "
                                 "inherit from Property.");
        }
      } // not an empty (i.e. optional) input
    }   // for each InputWorkspace property
 
    std::vector<std::string> outputWSNames(m_pureOutputWorkspaceProps.size());
    // ---------- Set all the output workspaces ----------------------------
    for (size_t owp = 0; owp < m_pureOutputWorkspaceProps.size(); owp++) {
      if (auto *prop = dynamic_cast<Property *>(m_pureOutputWorkspaceProps[owp])) {
        // Default name = "in1_in2_out"
        const std::string inName = prop->value();
        if (inName.empty())
          continue;
        std::string outName;
        if (m_groupsHaveSimilarNames) {
          outName.append(inName).append("_").append(Strings::toString(entry + 1));
        } else {
          outName.append(outputBaseName).append("_").append(inName);
        }
 
        auto inputProp =
            std::find_if(m_inputWorkspaceProps.begin(), m_inputWorkspaceProps.end(), WorkspacePropertyValueIs(inName));
 
        // Overwrite workspaces in any input property if they have the same
        // name as an output (i.e. copy name button in algorithm dialog used)
        // (only need to do this for a single input, multiple will be handled
        // by ADS)
        if (inputProp != m_inputWorkspaceProps.end()) {
          const auto &inputGroup = m_unrolledInputWorkspaces[inputProp - m_inputWorkspaceProps.begin()];
          if (!inputGroup.empty())
            outName = inputGroup[entry]->getName();
        }
        // Except if all inputs had similar names, then the name is "out_1"
 
        // Set in the output
        alg->setPropertyValue(prop->name(), outName);
 
        outputWSNames[owp] = outName;
      } else {
        throw std::logic_error("Found a Workspace property which doesn't "
                               "inherit from Property.");
      }
    } // for each OutputWorkspace property
 
    // ------------ Execute the algo --------------
    try {
      alg->execute();
    } catch (std::exception &e) {
      std::ostringstream msg;
      msg << "Execution of " << this->name() << " for group entry " << (entry + 1) << " failed: ";
      msg << e.what(); // Add original message
      throw std::runtime_error(msg.str());
    }
 
    // ------------ Fill in the output workspace group ------------------
    // this has to be done after execute() because a workspace must exist
    // when it is added to a group
    for (size_t owp = 0; owp < m_pureOutputWorkspaceProps.size(); owp++) {
      auto *prop = dynamic_cast<Property *>(m_pureOutputWorkspaceProps[owp]);
      if (prop && prop->value().empty())
        continue;
      // And add it to the output group
      outGroups[owp]->add(outputWSNames[owp]);
    }
 
  } // for each entry in each group
 
  // restore group notifications
  for (auto &outGroup : outGroups) {
    outGroup->observeADSNotifications(true);
  }
 
  return true;
}
 
//--------------------------------------------------------------------------------------------
void Algorithm::copyNonWorkspaceProperties(IAlgorithm *alg, int periodNum) {
  if (!alg)
    throw std::runtime_error("Algorithm not created!");
  const auto &props = this->getProperties();
  for (const auto &prop : props) {
    if (prop) {
 
      auto *wsProp = dynamic_cast<IWorkspaceProperty *>(prop);
      // Copy the property using the string
      if (!wsProp)
        this->setOtherProperties(alg, prop->name(), prop->value(), periodNum);
    }
  }
}
 
//--------------------------------------------------------------------------------------------
void Algorithm::setOtherProperties(IAlgorithm *alg, const std::string &propertyName, const std::string &propertyValue,
                                   int periodNum) {
  (void)periodNum; // Avoid compiler warning
  if (alg)
    alg->setPropertyValue(propertyName, propertyValue);
}
 
//--------------------------------------------------------------------------------------------
bool Algorithm::isWorkspaceProperty(const Kernel::Property *const prop) const {
  if (!prop) {
    return false;
  }
  const auto *const wsProp = dynamic_cast<const IWorkspaceProperty *>(prop);
  return (wsProp != nullptr);
}
 
//=============================================================================================
//================================== Asynchronous Execution
//===================================
//=============================================================================================
namespace {
struct AsyncFlagHolder {
  explicit AsyncFlagHolder(bool &running_flag) : m_running_flag(running_flag) { m_running_flag = true; }
  ~AsyncFlagHolder() { m_running_flag = false; }
 
private:
  AsyncFlagHolder() = delete;
  bool &m_running_flag;
};
} // namespace
 
//--------------------------------------------------------------------------------------------
Poco::ActiveResult<bool> Algorithm::executeAsync() {
  m_executeAsync =
      std::make_unique<Poco::ActiveMethod<bool, Poco::Void, Algorithm>>(this, &Algorithm::executeAsyncImpl);
  return (*m_executeAsync)(Poco::Void());
}
 
bool Algorithm::executeAsyncImpl(const Poco::Void & /*unused*/) {
  AsyncFlagHolder running(m_runningAsync);
  return this->execute();
}
 
Poco::NotificationCenter &Algorithm::notificationCenter() const {
  if (!m_notificationCenter)
    m_notificationCenter = std::make_unique<Poco::NotificationCenter>();
  return *m_notificationCenter;
}
 
void Algorithm::handleChildProgressNotification(const Poco::AutoPtr<ProgressNotification> &pNf) {
  double p = m_startChildProgress + (m_endChildProgress - m_startChildProgress) * pNf->progress;
 
  progress(p, pNf->message);
}
 
const Poco::AbstractObserver &Algorithm::progressObserver() const {
  if (!m_progressObserver)
    m_progressObserver = std::make_unique<Poco::NObserver<Algorithm, ProgressNotification>>(
        *const_cast<Algorithm *>(this), &Algorithm::handleChildProgressNotification);
 
  return *m_progressObserver;
}
 
//--------------------------------------------------------------------------------------------
void Algorithm::cancel() {
  // set myself to be cancelled
  m_cancel = true;
 
  // Loop over the output workspaces and try to cancel them
  for (auto &weakPtr : m_ChildAlgorithms) {
    if (IAlgorithm_sptr sharedPtr = weakPtr.lock()) {
      sharedPtr->cancel();
    }
  }
}
 
bool Algorithm::getCancel() const { return m_cancel; }
 
Kernel::Logger &Algorithm::getLogger() const { return g_log; }
void Algorithm::setLogging(const bool value) { g_log.setEnabled(value); }
bool Algorithm::isLogging() const { return g_log.getEnabled(); }
 
/* Sets the logging priority offset. Values are subtracted from the log level.
 *
 * Example value=1 will turn warning into notice
 * Example value=-1 will turn notice into warning
 */
void Algorithm::setLoggingOffset(const int value) {
  if (m_communicator->rank() == 0)
    g_log.setLevelOffset(value);
  else {
    auto offset = ConfigService::Instance().getValue<int>("mpi.loggingOffset");
    g_log.setLevelOffset(value + offset.get_value_or(1));
  }
}
 
int Algorithm::getLoggingOffset() const { return g_log.getLevelOffset(); }
 
//--------------------------------------------------------------------------------------------
void Algorithm::interruption_point() {
  // only throw exceptions if the code is not multi threaded otherwise you
  // contravene the OpenMP standard
  // that defines that all loops must complete, and no exception can leave an
  // OpenMP section
  // openmp cancel handling is performed using the ??, ?? and ?? macros in
  // each algrothim
  IF_NOT_PARALLEL
  if (m_cancel)
    throw CancelException();
}
 
void Algorithm::reportCompleted(const double &duration, const bool groupProcessing) {
  std::string optionalMessage;
  if (groupProcessing) {
    optionalMessage = ". Processed as a workspace group";
  }
 
  if (!m_isChildAlgorithm || m_alwaysStoreInADS) {
    if (m_isAlgStartupLoggingEnabled) {
 
      std::stringstream msg;
      msg << name() << " successful, Duration ";
      double seconds = duration;
      if (seconds > 60.) {
        auto minutes = static_cast<int>(seconds / 60.);
        msg << minutes << " minutes ";
        seconds = seconds - static_cast<double>(minutes) * 60.;
      }
      msg << std::fixed << std::setprecision(2) << seconds << " seconds" << optionalMessage;
      getLogger().notice(msg.str());
    }
  }
 
  else {
    getLogger().debug() << name() << " finished with isChild = " << isChild() << '\n';
  }
  setExecutionState(ExecutionState::Finished);
}
 
void Algorithm::registerFeatureUsage() const {
  if (UsageService::Instance().isEnabled()) {
    std::ostringstream oss;
    oss << this->name() << ".v" << this->version();
    UsageService::Instance().registerFeatureUsage(FeatureType::Algorithm, oss.str(), isChild());
  }
}
 
void Algorithm::setAlgStartupLogging(const bool enabled) { m_isAlgStartupLoggingEnabled = enabled; }
 
bool Algorithm::getAlgStartupLogging() const { return m_isAlgStartupLoggingEnabled; }
 
bool Algorithm::isCompoundProperty(const std::string &name) const {
  return std::find(m_reservedList.cbegin(), m_reservedList.cend(), name) != m_reservedList.cend();
}
 
void Algorithm::exec(Parallel::ExecutionMode executionMode) {
  switch (executionMode) {
  case Parallel::ExecutionMode::Serial:
  case Parallel::ExecutionMode::Identical:
    return exec();
  case Parallel::ExecutionMode::Distributed:
    return execDistributed();
  case Parallel::ExecutionMode::MasterOnly:
    return execMasterOnly();
  default:
    throw(std::runtime_error("Algorithm " + name() + " does not support execution mode " +
                             Parallel::toString(executionMode)));
  }
}
 
void Algorithm::execDistributed() { exec(); }
 
void Algorithm::execMasterOnly() {
  if (communicator().rank() == 0)
    exec();
}
 
Parallel::ExecutionMode Algorithm::getExecutionMode() const {
  if (communicator().size() == 1)
    return Parallel::ExecutionMode::Serial;
 
  const auto storageModes = getInputWorkspaceStorageModes();
  const auto executionMode = getParallelExecutionMode(storageModes);
  if (executionMode == Parallel::ExecutionMode::Invalid) {
    std::string error("Algorithm does not support execution with input "
                      "workspaces of the following storage types: " +
                      Parallel::toString(storageModes) + ".");
    getLogger().error() << error << "\n";
    throw(std::runtime_error(error));
  }
  if (executionMode == Parallel::ExecutionMode::Serial) {
    std::string error(Parallel::toString(executionMode) + " is not a valid *parallel* execution mode.");
    getLogger().error() << error << "\n";
    throw(std::runtime_error(error));
  }
  getLogger().information() << "MPI Rank " << communicator().rank() << " running with "
                            << Parallel::toString(executionMode) << '\n';
  return executionMode;
}
 
std::map<std::string, Parallel::StorageMode> Algorithm::getInputWorkspaceStorageModes() const {
  std::map<std::string, Parallel::StorageMode> map;
  for (const auto &wsProp : m_inputWorkspaceProps) {
    // This is the reverse cast of what is done in cacheWorkspaceProperties(),
    // so it should never fail.
    const Property &prop = dynamic_cast<Property &>(*wsProp);
    // Check if we actually have that input workspace
    if (wsProp->getWorkspace())
      map.emplace(prop.name(), wsProp->getWorkspace()->storageMode());
    else if (!wsProp->isOptional())
      map.emplace(prop.name(), Parallel::StorageMode::MasterOnly);
  }
  getLogger().information() << "Input workspaces for determining execution mode:\n";
  for (const auto &item : map)
    getLogger().information() << "  " << item.first << " --- " << Parallel::toString(item.second) << '\n';
  return map;
}
 
Parallel::ExecutionMode
Algorithm::getParallelExecutionMode(const std::map<std::string, Parallel::StorageMode> &storageModes) const {
  UNUSED_ARG(storageModes)
  // By default no parallel execution is possible.
  return Parallel::ExecutionMode::Invalid;
}
 
void Algorithm::setupSkipValidationMasterOnly() {
  // If workspaces have StorageMode::MasterOnly, validation on non-master
  // ranks would usually fail. Therefore, WorkspaceProperty needs to skip
  // validation. Thus, we must notify it whether or not it is on the master
  // rank or not.
  if (communicator().rank() != 0)
    for (auto *prop : getProperties())
      if (auto *wsProp = dynamic_cast<IWorkspaceProperty *>(prop))
        wsProp->setIsMasterRank(false);
}
 
const Parallel::Communicator &Algorithm::communicator() const { return *m_communicator; }
 
void Algorithm::setCommunicator(const Parallel::Communicator &communicator) {
  m_communicator = std::make_unique<Parallel::Communicator>(communicator);
}
 
//---------------------------------------------------------------------------
// Algorithm's inner classes
//---------------------------------------------------------------------------
 
Algorithm::AlgorithmNotification::AlgorithmNotification(const Algorithm *const alg)
    : Poco::Notification(), m_algorithm(alg) {}
 
const IAlgorithm *Algorithm::AlgorithmNotification::algorithm() const { return m_algorithm; }
 
Algorithm::StartedNotification::StartedNotification(const Algorithm *const alg) : AlgorithmNotification(alg) {}
std::string Algorithm::StartedNotification::name() const { return "StartedNotification"; } 
 
Algorithm::FinishedNotification::FinishedNotification(const Algorithm *const alg, bool res)
    : AlgorithmNotification(alg), success(res) {}
std::string Algorithm::FinishedNotification::name() const { return "FinishedNotification"; }
 
Algorithm::ProgressNotification::ProgressNotification(const Algorithm *const alg, double p, std::string msg,
                                                      double estimatedTime, int progressPrecision)
    : AlgorithmNotification(alg), progress(p), message(std::move(msg)), estimatedTime(estimatedTime),
      progressPrecision(progressPrecision) {}
 
std::string Algorithm::ProgressNotification::name() const { return "ProgressNotification"; }
 
Algorithm::ErrorNotification::ErrorNotification(const Algorithm *const alg, std::string str)
    : AlgorithmNotification(alg), what(std::move(str)) {}
 
std::string Algorithm::ErrorNotification::name() const { return "ErrorNotification"; }
 
const char *Algorithm::CancelException::what() const noexcept { return "Algorithm terminated"; }
 
void Algorithm::declareProperty(std::unique_ptr<Property> p, const std::string &doc) {
  m_properties.declareProperty(std::move(p), doc);
}
 
void Algorithm::declareOrReplaceProperty(std::unique_ptr<Property> p, const std::string &doc) {
  m_properties.declareOrReplaceProperty(std::move(p), doc);
}
 
void Algorithm::resetProperties() { m_properties.resetProperties(); }
 
void Algorithm::setProperties(const std::string &propertiesJson,
                              const std::unordered_set<std::string> &ignoreProperties, bool createMissing) {
  m_properties.setProperties(propertiesJson, ignoreProperties, createMissing);
}
 
void Algorithm::setProperties(const ::Json::Value &jsonValue, const std::unordered_set<std::string> &ignoreProperties,
                              bool createMissing) {
  m_properties.setProperties(jsonValue, ignoreProperties, createMissing);
}
 
void Algorithm::setPropertiesWithString(const std::string &propertiesString,
                                        const std::unordered_set<std::string> &ignoreProperties) {
  m_properties.setPropertiesWithString(propertiesString, ignoreProperties);
}
 
void Algorithm::setPropertyValue(const std::string &name, const std::string &value) {
  m_properties.setPropertyValue(name, value);
  this->afterPropertySet(name);
}
 
void Algorithm::setPropertyValueFromJson(const std::string &name, const Json::Value &value) {
  m_properties.setPropertyValueFromJson(name, value);
  this->afterPropertySet(name);
}
 
void Algorithm::setPropertyOrdinal(const int &index, const std::string &value) {
  m_properties.setPropertyOrdinal(index, value);
  this->afterPropertySet(m_properties.getPointerToPropertyOrdinal(index)->name());
}
 
bool Algorithm::existsProperty(const std::string &name) const { return m_properties.existsProperty(name); }
 
bool Algorithm::validateProperties() const { return m_properties.validateProperties(); }
 
size_t Algorithm::propertyCount() const { return m_properties.propertyCount(); }
 
std::string Algorithm::getPropertyValue(const std::string &name) const { return m_properties.getPropertyValue(name); }
 
Property *Algorithm::getPointerToProperty(const std::string &name) const {
  return m_properties.getPointerToProperty(name);
}
 
Property *Algorithm::getPointerToPropertyOrdinal(const int &index) const {
  return m_properties.getPointerToPropertyOrdinal(index);
}
 
const std::vector<Property *> &Algorithm::getProperties() const { return m_properties.getProperties(); }
 
std::vector<std::string> Algorithm::getDeclaredPropertyNames() const noexcept {
  return m_properties.getDeclaredPropertyNames();
}
 
IPropertyManager::TypedValue Algorithm::getProperty(const std::string &name) const {
  return m_properties.getProperty(name);
}
 
bool Algorithm::isDefault(const std::string &name) const {
  return m_properties.getPointerToProperty(name)->isDefault();
}
 
std::string Algorithm::asString(bool withDefaultValues) const { return m_properties.asString(withDefaultValues); }
::Json::Value Algorithm::asJson(bool withDefaultValues) const { return m_properties.asJson(withDefaultValues); }
 
void Algorithm::removeProperty(const std::string &name, const bool delproperty) {
  m_properties.removeProperty(name, delproperty);
}
 
std::unique_ptr<Kernel::Property> Algorithm::takeProperty(const size_t index) {
  return m_properties.takeProperty(index);
}
 
void Algorithm::clear() { m_properties.clear(); }
 
void Algorithm::afterPropertySet(const std::string &name) { m_properties.afterPropertySet(name); }
 
} // namespace API
 
//---------------------------------------------------------------------------
// Specialized templated PropertyManager getValue definitions for Algorithm
// types
//---------------------------------------------------------------------------
namespace Kernel {
template <>
MANTID_API_DLL API::IAlgorithm_sptr IPropertyManager::getValue<API::IAlgorithm_sptr>(const std::string &name) const {
  auto *prop = dynamic_cast<PropertyWithValue<API::IAlgorithm_sptr> *>(getPointerToProperty(name));
  if (prop) {
    return *prop;
  } else {
    std::string message = "Attempt to assign property " + name + " to incorrect type. Expected shared_ptr<IAlgorithm>";
    throw std::runtime_error(message);
  }
}
 
template <>
MANTID_API_DLL API::IAlgorithm_const_sptr
IPropertyManager::getValue<API::IAlgorithm_const_sptr>(const std::string &name) const {
  auto *prop = dynamic_cast<PropertyWithValue<API::IAlgorithm_sptr> *>(getPointerToProperty(name));
  if (prop) {
    return prop->operator()();
  } else {
    std::string message =
        "Attempt to assign property " + name + " to incorrect type. Expected const shared_ptr<IAlgorithm>";
    throw std::runtime_error(message);
  }
}
 
} // namespace Kernel
 
} // namespace Mantid