WorkspaceCreationHelper.h

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 +
/*********************************************************************************
 *  PLEASE READ THIS!!!!!!!
 *
 *  This header MAY NOT be included in any test from a package below DataObjects
 *    (e.g. Kernel, Geometry, API).
 *  Conversely, this file (and its cpp) MAY NOT be modified to use anything from
 *a
 *  package higher than DataObjects (e.g. any algorithm), even if via the
 *factory.
 *********************************************************************************/
#pragma once
 
#include "MantidAPI/Algorithm.h"
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/ITableWorkspace_fwd.h"
#include "MantidAPI/MatrixWorkspace_fwd.h"
#include "MantidAPI/Run.h"
#include "MantidAPI/WorkspaceFactory.h"
#include "MantidAPI/WorkspaceGroup_fwd.h"
#include "MantidDataObjects/EventWorkspace.h"
#include "MantidDataObjects/RebinnedOutput.h"
#include "MantidDataObjects/TableWorkspace.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidDataObjects/WorkspaceSingleValue.h"
#include "MantidGeometry/Instrument/Detector.h"
 
#include <gmock/gmock.h>
 
#include <string>
#include <vector>
 
namespace Mantid {
namespace DataObjects {
class PeaksWorkspace;
class LeanElasticPeaksWorkspace;
} // namespace DataObjects
namespace Kernel {
class Logger;
class V3D;
} // namespace Kernel
} // namespace Mantid
 
namespace WorkspaceCreationHelper {
template <typename T> struct FibSeries {
private:
  T x1; 
  T x2; 
public:
  inline FibSeries() : x1(1), x2(1) {}
  inline T operator()() {
    const T out(x1 + x2);
    x1 = x2;
    x2 = out;
    return out;
  }
};
class StubAlgorithm : public Mantid::API::Algorithm {
public:
  StubAlgorithm(size_t nSteps = 100);
  const std::string name() const override { return "MockAlgorithm"; }
  int version() const override { return 1; }
  const std::string category() const override { return "Test"; }
  const std::string summary() const override { return "Test summary."; }
 
  Mantid::Kernel::Logger &getLogger() { return g_log; }
 
  Mantid::API::Progress *getProgress() { return m_Progress.get(); }
  void resetProgress(size_t nSteps) { m_Progress = std::make_unique<Mantid::API::Progress>(this, 0.0, 1.0, nSteps); }
 
private:
  void init() override {}
  void exec() override {}
 
  std::unique_ptr<Mantid::API::Progress> m_Progress;
  static Mantid::Kernel::Logger &g_log;
};
 
struct EPPTableRow {
  enum class FitStatus { SUCCESS, FAILURE };
 
  EPPTableRow() = default;
  EPPTableRow(const double peakCentre, const double sigma, const double height, const FitStatus fitStatus);
  EPPTableRow(const int index, const double peakCentre, const double sigma, const double height,
              const FitStatus fitStatus);
  int workspaceIndex = -1;
  double peakCentre = 0;
  double peakCentreError = 0;
  double sigma = 0;
  double sigmaError = 0;
  double height = 0;
  double heightError = 0;
  double chiSq = 0;
  FitStatus fitStatus = FitStatus::SUCCESS;
};
 
template <typename WSType> void storeWS(const std::string &name, WSType &ws) {
  Mantid::API::AnalysisDataService::Instance().add(name, ws);
}
void removeWS(const std::string &name);
template <typename T> std::shared_ptr<T> getWS(const std::string &name) {
  return Mantid::API::AnalysisDataService::Instance().retrieveWS<T>(name);
}
 
template <typename YType, typename EType>
Mantid::HistogramData::Histogram createHisto(bool isHistogram, YType &&yAxis, EType &&eAxis);
Mantid::DataObjects::Workspace2D_sptr create1DWorkspaceRand(int size, bool isHisto);
Mantid::DataObjects::Workspace2D_sptr create1DWorkspaceConstant(int size, double value, double error, bool isHisto);
Mantid::DataObjects::Workspace2D_sptr create1DWorkspaceFib(int size, bool isHisto);
Mantid::DataObjects::Workspace2D_sptr create1DWorkspaceConstantWithXerror(int size, double value, double error,
                                                                          double xError, bool isHisto = true);
Mantid::DataObjects::Workspace2D_sptr create2DWorkspace(size_t nhist, size_t numBoundaries);
Mantid::DataObjects::Workspace2D_sptr create2DWorkspaceWhereYIsWorkspaceIndex(int nhist, int numBoundaries);
Mantid::DataObjects::Workspace2D_sptr
create2DWorkspace123(int64_t nHist, int64_t nBins, bool isHist = false,
                     const std::set<int64_t> &maskedWorkspaceIndices = std::set<int64_t>(), bool hasDx = false);
Mantid::DataObjects::Workspace2D_sptr
create2DWorkspace154(int64_t nHist, int64_t nBins, bool isHist = false,
                     const std::set<int64_t> &maskedWorkspaceIndices = std::set<int64_t>(), bool hasDx = false);
Mantid::DataObjects::Workspace2D_sptr
create2DWorkspaceWithValuesAndXerror(int64_t nHist, int64_t nBins, bool isHist, double xVal, double yVal, double eVal,
                                     double dxVal,
                                     const std::set<int64_t> &maskedWorkspaceIndices = std::set<int64_t>());
Mantid::DataObjects::Workspace2D_sptr maskSpectra(Mantid::DataObjects::Workspace2D_sptr workspace,
                                                  const std::set<int64_t> &maskedWorkspaceIndices);
Mantid::API::WorkspaceGroup_sptr createWorkspaceGroup(int nEntries, int nHist, int nBins, const std::string &stem);
Mantid::DataObjects::Workspace2D_sptr create2DWorkspaceBinned(size_t nhist, size_t numVals, double x0 = 0.0,
                                                              double deltax = 1.0);
 
Mantid::API::MatrixWorkspace_sptr create2DWorkspaceRagged(int version = 0);
 
Mantid::DataObjects::Workspace2D_sptr create2DWorkspacePoints(size_t nhist, size_t numVals, double x0 = 0.0,
                                                              double deltax = 1.0);
 
Mantid::DataObjects::Workspace2D_sptr
create2DWorkspaceNonUniformlyBinned(int nhist, const int numBoundaries, const double xBoundaries[], bool hasDx = false);
 
struct ReturnOne {
  double operator()(const double, std::size_t) { return 1.0; };
};
 
template <typename fT, typename gT = ReturnOne>
Mantid::DataObjects::Workspace2D_sptr create2DWorkspaceFromFunction(fT yFunc, int nSpec, double x0, double x1,
                                                                    double dx, bool isHist = false,
                                                                    gT eFunc = ReturnOne()) {
  int nX = int((x1 - x0) / dx) + 1;
  int nY = nX - (isHist ? 1 : 0);
  if (nY <= 0)
    throw std::invalid_argument("Number of bins <=0. Cannot create an empty workspace");
 
  auto ws = std::dynamic_pointer_cast<Mantid::DataObjects::Workspace2D>(
      Mantid::API::WorkspaceFactory::Instance().create("Workspace2D", nSpec, nX, nY));
 
  for (int iSpec = 0; iSpec < nSpec; iSpec++) {
    auto &X = ws->mutableX(iSpec);
    auto &Y = ws->mutableY(iSpec);
    auto &E = ws->mutableE(iSpec);
    for (int i = 0; i < nY; i++) {
      double x = x0 + dx * i;
      X[i] = x;
      Y[i] = yFunc(x, iSpec);
      E[i] = eFunc(x, iSpec);
    }
    if (isHist)
      X.back() = X[nY - 1] + dx;
  }
  return ws;
}
 
void addNoise(const Mantid::API::MatrixWorkspace_sptr &ws, double noise, const double lower = -0.5,
              const double upper = 0.5);
 
Mantid::DataObjects::Workspace2D_sptr
create2DWorkspaceWithFullInstrument(int nhist, int nbins, bool includeMonitors = false, bool startYNegative = false,
                                    bool isHistogram = true,
                                    const std::string &instrumentName = std::string("testInst"), bool hasDx = false);
 
Mantid::API::MatrixWorkspace_sptr
create2DDetectorScanWorkspaceWithFullInstrument(int nhist, int nbins, size_t nTimeIndexes, size_t startTime = 0,
                                                size_t firstInterval = 1, bool includeMonitors = false,
                                                bool startYNegative = false, bool isHistogram = true,
                                                const std::string &instrumentName = std::string("testInst"));
 
Mantid::DataObjects::Workspace2D_sptr create2DWorkspaceWithGeographicalDetectors(
    const int nlat, const int nlong, const double anginc, int nbins, const double x0 = 0.5, const double deltax = 1.0,
    const std::string &instrumentName = std::string("testInst"), const std::string &xunit = std::string("Momentum"));
 
Mantid::DataObjects::Workspace2D_sptr create2DWorkspaceThetaVsTOF(int nHist, int nBins);
 
Mantid::DataObjects::Workspace2D_sptr
create2DWorkspaceWithRectangularInstrument(int numBanks, int numPixels, int numBins,
                                           const std::string &instrumentName = "basic_rect");
 
Mantid::DataObjects::Workspace2D_sptr create2DWorkspace123WithMaskedBin(int numHist, int numBins,
                                                                        int maskedWorkspaceIndex, int maskedBinIndex);
 
Mantid::DataObjects::EventWorkspace_sptr createEventWorkspaceWithFullInstrument(int numBanks, int numPixels,
                                                                                bool clearEvents = true);
 
Mantid::DataObjects::EventWorkspace_sptr createEventWorkspaceWithFullInstrument2(int numBanks, int numPixels,
                                                                                 bool clearEvents = true);
 
Mantid::DataObjects::EventWorkspace_sptr createEventWorkspaceWithNonUniformInstrument(int numBanks, bool clearEvents);
 
Mantid::DataObjects::WorkspaceSingleValue_sptr createWorkspaceSingleValue(double value);
Mantid::DataObjects::WorkspaceSingleValue_sptr createWorkspaceSingleValueWithError(double value, double error);
void eventWorkspace_Finalize(const Mantid::DataObjects::EventWorkspace_sptr &ew);
Mantid::DataObjects::EventWorkspace_sptr createEventWorkspace();
 
Mantid::DataObjects::EventWorkspace_sptr createEventWorkspace2(int numPixels = 50, int numBins = 100);
 
Mantid::DataObjects::EventWorkspace_sptr createEventWorkspace(int numPixels, int numBins, int numEvents = 100,
                                                              double x0 = 0.0, double binDelta = 1.0,
                                                              int eventPattern = 1, int start_at_pixelID = 0);
 
Mantid::DataObjects::EventWorkspace_sptr createEventWorkspaceWithStartTime(
    int numPixels, int numBins, int numEvents = 100, double x0 = 0.0, double binDelta = 1.0, int eventPattern = 1,
    int start_at_pixelID = 0,
    Mantid::Types::Core::DateAndTime run_start = Mantid::Types::Core::DateAndTime("2010-01-01T00:00:00"));
 
Mantid::DataObjects::EventWorkspace_sptr createGroupedEventWorkspace(std::vector<std::vector<int>> const &groups,
                                                                     int numBins, double binDelta = 1.,
                                                                     double xOffset = 0.);
 
Mantid::DataObjects::EventWorkspace_sptr createRandomEventWorkspace(size_t numbins, size_t numpixels,
                                                                    double bin_delta = 1.0);
 
Mantid::API::MatrixWorkspace_sptr createGroupedWorkspace2D(size_t numHist, int numBins, double binDelta);
// grouped workspace with detectors arranges in rings in center and into boxes
// outside
Mantid::API::MatrixWorkspace_sptr createGroupedWorkspace2DWithRingsAndBoxes(size_t RootOfNumHist = 10, int numBins = 10,
                                                                            double binDelta = 1.0);
// not strictly creating a workspace, but really helpful to see what one
// contains
void displayDataY(const Mantid::API::MatrixWorkspace_const_sptr &ws);
// not strictly creating a workspace, but really helpful to see what one
// contains
void displayData(const Mantid::API::MatrixWorkspace_const_sptr &ws);
// not strictly creating a workspace, but really helpful to see what one
// contains
void displayDataX(const Mantid::API::MatrixWorkspace_const_sptr &ws);
// not strictly creating a workspace, but really helpful to see what one
// contains
void displayDataE(const Mantid::API::MatrixWorkspace_const_sptr &ws);
 
void addTSPEntry(Mantid::API::Run &runInfo, const std::string &name, double val);
void setOrientedLattice(const Mantid::API::MatrixWorkspace_sptr &ws, double a, double b, double c);
void setGoniometer(const Mantid::API::MatrixWorkspace_sptr &ws, double phi, double chi, double omega);
 
// create workspace which should be result of homering (transform to energy in
// inelastic)
Mantid::API::MatrixWorkspace_sptr createProcessedWorkspaceWithCylComplexInstrument(size_t numPixels = 100,
                                                                                   size_t numBins = 20,
                                                                                   bool has_oriented_lattice = true);
 
// Create a workspace with all components needed for inelastic analysis;
Mantid::API::MatrixWorkspace_sptr createProcessedInelasticWS(const std::vector<double> &L2,
                                                             const std::vector<double> &polar,
                                                             const std::vector<double> &azimutal, size_t numBins = 4,
                                                             double Emin = -10, double Emax = 10, double Ei = 11);
 
Mantid::DataObjects::EventWorkspace_sptr
createEventWorkspace3(const Mantid::DataObjects::EventWorkspace_const_sptr &sourceWS, const std::string &wsname,
                      Mantid::API::Algorithm *alg);
 
Mantid::DataObjects::RebinnedOutput_sptr createRebinnedOutputWorkspace();
 
template <typename T>
void populateWsWithInitList(T &destination, size_t startingIndex, const std::initializer_list<double> &values);
 
std::shared_ptr<Mantid::DataObjects::PeaksWorkspace> createPeaksWorkspace(const int numPeaks,
                                                                          const bool createOrientedLattice = false);
std::shared_ptr<Mantid::DataObjects::PeaksWorkspace> createPeaksWorkspace(const int numPeaks,
                                                                          const Mantid::Kernel::DblMatrix &ubMat);
 
std::shared_ptr<Mantid::DataObjects::LeanElasticPeaksWorkspace>
createLeanPeaksWorkspace(const int numPeaks, const bool createOrientedLattice = false);
std::shared_ptr<Mantid::DataObjects::LeanElasticPeaksWorkspace>
createLeanPeaksWorkspace(const int numPeaks, const Mantid::Kernel::DblMatrix &ubMat);
 
std::shared_ptr<Mantid::DataObjects::TableWorkspace>
buildPreprocessedDetectorsWorkspace(const Mantid::API::MatrixWorkspace_sptr &ws);
// create range of angular detectors positions
void create2DAngles(std::vector<double> &L2, std::vector<double> &polar, std::vector<double> &azim, size_t nPolar = 10,
                    size_t nAzim = 10, double polStart = 0, double polEnd = 90, double azimStart = -30,
                    double azimEnd = 30);
 
Mantid::API::MatrixWorkspace_sptr create2DWorkspaceWithReflectometryInstrument(
    const double startX = 0.0, const Mantid::Kernel::V3D &slit1Pos = Mantid::Kernel::V3D(0, 0, 0),
    const Mantid::Kernel::V3D &slit2Pos = Mantid::Kernel::V3D(0, 0, 1), const double vg1 = 0.5, const double vg2 = 1.0,
    const Mantid::Kernel::V3D &sourcePos = Mantid::Kernel::V3D(0, 0, 0),
    const Mantid::Kernel::V3D &monitorPos = Mantid::Kernel::V3D(14, 0, 0),
    const Mantid::Kernel::V3D &samplePos = Mantid::Kernel::V3D(15, 0, 0),
    const Mantid::Kernel::V3D &detectorPos = Mantid::Kernel::V3D(20, (20 - 15), 0), const int nBins = 100,
    const double deltaX = 2000.0);
 
Mantid::API::MatrixWorkspace_sptr create2DWorkspaceWithReflectometryInstrumentMultiDetector(
    const double startX = 0.0, const double detSize = 0.0,
    const Mantid::Kernel::V3D &slit1Pos = Mantid::Kernel::V3D(0, 0, 0),
    const Mantid::Kernel::V3D &slit2Pos = Mantid::Kernel::V3D(0, 0, 1), const double vg1 = 0.5, const double vg2 = 1.0,
    const Mantid::Kernel::V3D &sourcePos = Mantid::Kernel::V3D(0, 0, 0),
    const Mantid::Kernel::V3D &monitorPos = Mantid::Kernel::V3D(14, 0, 0),
    const Mantid::Kernel::V3D &samplePos = Mantid::Kernel::V3D(15, 0, 0),
    const Mantid::Kernel::V3D &detectorCenterPos = Mantid::Kernel::V3D(20, (20 - 15), 0), const int nSpectra = 4,
    const int nBins = 20, const double deltaX = 5000.0);
 
void createInstrumentForWorkspaceWithDistances(const Mantid::API::MatrixWorkspace_sptr &workspace,
                                               const Mantid::Kernel::V3D &samplePosition,
                                               const Mantid::Kernel::V3D &sourcePosition,
                                               const std::vector<Mantid::Kernel::V3D> &detectorPositions);
 
Mantid::API::ITableWorkspace_sptr createEPPTableWorkspace(const std::vector<EPPTableRow> &rows = {});
 
Mantid::API::MatrixWorkspace_sptr createSNAPLiteInstrument(const std::string &wkspName, const double ang1 = -65.3,
                                                           const double ang2 = 104.95);
Mantid::API::MatrixWorkspace_sptr createFocusedSNAPLiteInstrument(const std::string &wkspName,
                                                                  const std::string &groupingAlg,
                                                                  const std::string &groupingDescr,
                                                                  const double ang1 = -65.3,
                                                                  const double ang2 = 104.95);
} // namespace WorkspaceCreationHelper