CreateLogPropertyTable.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/CreateLogPropertyTable.h"
 
#include "MantidAPI/ITableWorkspace.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAPI/Run.h"
#include "MantidAPI/TableRow.h"
#include "MantidAPI/WorkspaceGroup.h"
#include "MantidDataObjects/TableWorkspace.h"
#include "MantidKernel/ArrayProperty.h"
#include "MantidKernel/ListValidator.h"
#include "MantidKernel/MandatoryValidator.h"
#include "MantidKernel/VisibleWhenProperty.h"
 
#include "boost/shared_ptr.hpp"
 
#include <algorithm>
#include <cassert>
#include <map>
#include <vector>
 
namespace Mantid::Algorithms {
// Register the algorithm into the AlgorithmFactory
DECLARE_ALGORITHM(CreateLogPropertyTable)
 
using namespace Kernel;
using namespace API;
 
namespace {
enum GroupPolicy { ALL, FIRST, NONE };
 
// Forward declarations.
std::vector<MatrixWorkspace_sptr> retrieveMatrixWsList(const std::vector<std::string> &wsNames,
                                                       GroupPolicy groupPolicy);
GroupPolicy getGroupPolicyByName(const std::string &name);
std::set<std::string> getAllGroupPolicyNames();
Math::StatisticType getStatisticTypeByName(const std::string &name);
std::set<std::string> getAllStatisticTypeNames();
} // namespace
 
void CreateLogPropertyTable::init() {
  // Input workspaces
  declareProperty(std::make_unique<ArrayProperty<std::string>>(
                      "InputWorkspaces", std::make_shared<MandatoryValidator<std::vector<std::string>>>()),
                  "Name of the Input Workspaces from which to get log properties.");
 
  // Output workspace
  declareProperty(std::make_unique<WorkspaceProperty<ITableWorkspace>>("OutputWorkspace", "", Direction::Output),
                  "Name of the output ITableWorkspace.");
 
  // Which log properties to use
  declareProperty(std::make_unique<ArrayProperty<std::string>>(
                      "LogPropertyNames", std::make_shared<MandatoryValidator<std::vector<std::string>>>()),
                  "The names of the log properties to place in table.");
 
  // How to handle time series logs
  const std::set<std::string> statisticNames = getAllStatisticTypeNames();
  declareProperty("TimeSeriesStatistic", "Mean", std::make_shared<StringListValidator>(statisticNames),
                  "The statistic to use when adding a time series log.");
 
  // How to handle workspace groups
  const std::set<std::string> groupPolicies = getAllGroupPolicyNames();
  declareProperty("GroupPolicy", "First", std::make_shared<StringListValidator>(groupPolicies),
                  "The policy by which to handle GroupWorkspaces.  \"All\" "
                  "will include all children in the table, \"First\" will "
                  "include "
                  "the first child, and \"None\" will not include any.");
}
 
void CreateLogPropertyTable::exec() {
  std::vector<std::string> wsNames = this->getProperty("InputWorkspaces");
 
  // Retrieve a list of MatrixWorkspace pointers, using the given "GroupPolicy".
  const std::string groupPolicyName = this->getPropertyValue("GroupPolicy");
  const GroupPolicy groupPolicy = getGroupPolicyByName(groupPolicyName);
  const std::vector<MatrixWorkspace_sptr> matrixWsList = retrieveMatrixWsList(wsNames, groupPolicy);
 
  // Get the names of the properties that will be stored.
  const std::vector<std::string> propNames = this->getProperty("LogPropertyNames");
 
  // Make sure all workspaces contain the properties.
  for (const auto &matrixWs : matrixWsList) {
    const Run &run = matrixWs->run();
    const std::string wsName = matrixWs->getName();
 
    // Throw if a run does not have a property.
    auto it = std::find_if(propNames.cbegin(), propNames.cend(),
                           [&run](const auto &propName) { return !run.hasProperty(propName); });
    if (it != propNames.cend())
      throw std::runtime_error("\"" + wsName + "\" does not have a run property of \"" + (*it) + "\".");
  }
 
  // Set up output table.
  auto outputTable = std::make_shared<DataObjects::TableWorkspace>();
  // One column for each property.
  for (const auto &propName : propNames)
    outputTable->addColumn("str", propName);
  // One row for each workspace.
  for (size_t i = 0; i < matrixWsList.size(); ++i)
    outputTable->appendRow();
 
  // Set the first column to X and all others to Y
  // This is to reduce the number of steps required to plot the data
  for (size_t i = 0; i < outputTable->columnCount(); ++i)
    outputTable->getColumn(i)->setPlotType(i == 0 ? 1 : 2);
 
  const std::string timeSeriesStatName = this->getPropertyValue("TimeSeriesStatistic");
  const Math::StatisticType timeSeriesStat = getStatisticTypeByName(timeSeriesStatName);
  // Populate output table with the requested run properties.
  for (size_t i = 0; i < outputTable->rowCount(); ++i) {
    TableRow row = outputTable->getRow(i);
    MatrixWorkspace_sptr matrixWs = matrixWsList[i];
 
    for (const auto &propName : propNames) {
      Property *prop = matrixWs->run().getProperty(propName);
      std::stringstream propValue;
 
      if (prop->type().find("TimeValue") != std::string::npos) {
        propValue << matrixWs->run().getLogAsSingleValue(propName, timeSeriesStat);
      } else {
        propValue << prop->value();
      }
 
      row << propValue.str();
    }
  }
 
  this->setProperty("OutputWorkspace", outputTable);
}
 
namespace {
std::vector<MatrixWorkspace_sptr> retrieveMatrixWsList(const std::vector<std::string> &wsNames,
                                                       GroupPolicy groupPolicy) {
  std::vector<MatrixWorkspace_sptr> matrixWsList;
 
  // Get all the workspaces which are to be inspected for log proeprties.
  auto &ADS = AnalysisDataService::Instance();
  for (const auto &wsName : wsNames) {
 
    WorkspaceGroup_sptr wsGroup = std::dynamic_pointer_cast<WorkspaceGroup>(ADS.retrieve(wsName));
    MatrixWorkspace_sptr matrixWs = std::dynamic_pointer_cast<MatrixWorkspace>(ADS.retrieve(wsName));
 
    if (wsGroup) {
      const std::vector<std::string> childNames = wsGroup->getNames();
 
      // If there are no child workspaces in the group (is this possible?), just
      // ignore it.
      if (childNames.empty())
        break;
 
      // Retrieve pointers to all the child workspaces.
      std::vector<MatrixWorkspace_sptr> childWsList;
      childWsList.reserve(childNames.size());
 
      std::transform(childNames.begin(), childNames.end(), std::back_inserter(childWsList),
                     [&ADS](const auto &childName) { return ADS.retrieveWS<MatrixWorkspace>(childName); });
 
      // Deal with child workspaces according to policy.
      switch (groupPolicy) {
      case ALL: {
        // Append all the children to the list.
        std::move(childWsList.cbegin(), childWsList.cend(), std::back_inserter(matrixWsList));
        break;
      }
      case FIRST:
        // Append only the first child to the list.
        matrixWsList.emplace_back(childWsList[0]);
        break;
      case NONE:
        // Add nothing to the list.
        break;
      default:
        // We should never reach here.
        assert(false);
      }
    } else if (matrixWs) {
      matrixWsList.emplace_back(matrixWs);
    }
  }
 
  return matrixWsList;
}
 
const std::map<std::string, GroupPolicy> &getGroupPolicyMap() {
  static std::map<std::string, GroupPolicy> map;
 
  // Populate the map if empty.
  if (map.empty()) {
    map.emplace("All", ALL);
    map.emplace("First", FIRST);
    map.emplace("None", NONE);
  }
 
  return map;
}
 
GroupPolicy getGroupPolicyByName(const std::string &name) {
  const std::map<std::string, GroupPolicy> &map = getGroupPolicyMap();
 
  // If we can find a policy with the given name, return it.
  auto policy = map.find(name);
  if (policy != map.end())
    return policy->second;
 
  // Else return ALL as default.  Assert since we should never reach here.
  assert(false);
  return ALL;
}
 
std::set<std::string> getAllGroupPolicyNames() {
  const std::map<std::string, GroupPolicy> &map = getGroupPolicyMap();
  std::set<std::string> groupPolicyNames;
 
  for (const auto &policy : map)
    groupPolicyNames.insert(policy.first);
 
  return groupPolicyNames;
}
 
const std::map<std::string, Math::StatisticType> &getStatisticTypeMap() {
  static std::map<std::string, Math::StatisticType> map;
 
  // Populate the map if empty.
  if (map.empty()) {
    map.emplace("FirstValue", Math::StatisticType::FirstValue);
    map.emplace("LastValue", Math::StatisticType::LastValue);
    map.emplace("Minimum", Math::StatisticType::Minimum);
    map.emplace("Maximum", Math::StatisticType::Maximum);
    map.emplace("Mean", Math::StatisticType::Mean);
    map.emplace("Median", Math::StatisticType::Median);
  }
 
  return map;
}
 
Math::StatisticType getStatisticTypeByName(const std::string &name) {
  const std::map<std::string, Math::StatisticType> &map = getStatisticTypeMap();
 
  // If we can find a policy with the given name, return it.
  auto policy = map.find(name);
  if (policy != map.end())
    return policy->second;
 
  // Else return ALL as default.  Assert since we should never reach here.
  return Math::StatisticType::Mean;
}
 
std::set<std::string> getAllStatisticTypeNames() {
  const std::map<std::string, Math::StatisticType> &map = getStatisticTypeMap();
  std::set<std::string> statisticTypeNames;
 
  for (const auto &policy : map)
    statisticTypeNames.insert(policy.first);
 
  return statisticTypeNames;
}
} // namespace
} // namespace Mantid::Algorithms