MergeRuns.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2008 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 +
#pragma once
 
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAPI/MultiPeriodGroupAlgorithm.h"
#include "MantidAPI/WorkspaceHistory.h"
#include "MantidAlgorithms/DllConfig.h"
#include "MantidDataObjects/EventWorkspace.h"
#include "MantidGeometry/Instrument/DetectorInfo.h"
 
#include <list>
#include <optional>
#include <span>
 
namespace Mantid {
namespace API {
class WorkspaceGroup;
}
namespace HistogramData {
class HistogramX;
}
namespace Algorithms {
namespace MergeRunsParameter {
static const std::string SUM_MERGE = "sample_logs_sum";
static const std::string TIME_SERIES_MERGE = "sample_logs_time_series";
static const std::string LIST_MERGE = "sample_logs_list";
static const std::string WARN_MERGE = "sample_logs_warn";
static const std::string WARN_MERGE_TOLERANCES = "sample_logs_warn_tolerances";
static const std::string FAIL_MERGE = "sample_logs_fail";
static const std::string FAIL_MERGE_TOLERANCES = "sample_logs_fail_tolerances";
} // namespace MergeRunsParameter
 
class MANTID_ALGORITHMS_DLL MergeRuns : public API::MultiPeriodGroupAlgorithm {
public:
  const std::string name() const override { return "MergeRuns"; }
  const std::string summary() const override {
    return "Combines the data contained in an arbitrary number of input "
           "workspaces.";
  }
 
  int version() const override { return 1; }
  const std::vector<std::string> seeAlso() const override { return {"ConjoinWorkspaces"}; }
  const std::string category() const override { return "Transforms\\Merging"; }
  // Overriden MultiPeriodGroupAlgorithm method.
  bool useCustomInputPropertyName() const override;
 
protected:
  void fillHistory() override;
 
private:
  // Overridden Algorithm methods
  void init() override;
  void exec() override;
  void execEvent();
  void execHistogram(const std::vector<std::string> &inputs);
  void buildAdditionTables();
  // Overriden MultiPeriodGroupAlgorithm method.
  std::string fetchInputPropertyName() const override;
 
  using AdditionTable = std::vector<std::pair<int, int>>;
  template <typename Container> void copyHistoryFromInputWorkspaces(const Container &workspaces) {
    API::Workspace_sptr outWS = this->getProperty("OutputWorkspace");
 
    // this is not a child algorithm. Add the history algorithm to the
    // WorkspaceHistory object.
    if (!isChild()) {
      // Loop over the input workspaces, making the call that copies their
      // history to the output ones
      // (Protection against copy to self is in
      // WorkspaceHistory::copyAlgorithmHistory)
      for (auto inWS = workspaces.begin(); inWS != workspaces.end(); ++inWS) {
        outWS->history().addHistory((*inWS)->getHistory());
      }
      // 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 (isRecordingHistoryForChild() && m_parentHistory) {
      m_parentHistory->addChildHistory(m_history);
    }
  }
 
  // Methods called by exec()
  using Mantid::API::Algorithm::validateInputs;
  bool validateInputsForEventWorkspaces(const std::vector<std::string> &inputWorkspaces);
  std::optional<std::vector<double>> checkRebinning();
  static std::vector<double> calculateRebinParams(std::span<double const> bins1, std::span<double const> bins2);
  static void noOverlapParams(std::span<double const> X1, std::span<double const> X2, std::vector<double> &params);
  static void intersectionParams(std::span<double const> X1, size_t &i, std::span<double const> X2,
                                 std::vector<double> &params);
  static void inclusionParams(std::span<double const> X1, size_t &i, std::span<double const> X2,
                              std::vector<double> &params);
  API::MatrixWorkspace_sptr rebinInput(const API::MatrixWorkspace_sptr &workspace, const std::vector<double> &params);
  API::MatrixWorkspace_sptr buildScanningOutputWorkspace(const API::MatrixWorkspace_sptr &outWS,
                                                         const API::MatrixWorkspace_sptr &addee);
  std::unique_ptr<API::Progress> m_progress;
 
  std::vector<Mantid::DataObjects::EventWorkspace_sptr> m_inEventWS;
  std::list<API::MatrixWorkspace_sptr> m_inMatrixWS;
  std::vector<AdditionTable> m_tables;
  size_t m_outputSize = 0;
 
  std::vector<SpectrumDefinition> buildScanIntervals(const std::vector<SpectrumDefinition> &addeeSpecDefs,
                                                     const Geometry::DetectorInfo &addeeDetInfo,
                                                     const Geometry::DetectorInfo &newOutDetInfo);
};
 
} // namespace Algorithms
} // namespace Mantid