Commit e417a079 authored by Stephen's avatar Stephen
Browse files

Changes from code review

This commit responds to the code review comments:

- Extract constant strings which are used multiple times into const string variables
- Throw immediately if multi period.
- Remove unclear call to getProperty("OutputWorkspace) in LoadMuonNexusV2
- Remove unnecessary includes and in doing so create forward declarations for TableWorkspace and Workspace2D
- Use std::move for string and workspace copying.
- Remove unnecessary pointer casting, which will be dealt with by the compiler.
parent 6b0f7d17
......@@ -505,6 +505,7 @@ set(TEST_FILES
LoadMuonNexus1Test.h
LoadMuonNexus2Test.h
LoadMuonNexusV2Test.h
LoadNGEMTest.h
LoadNXSPETest.h
LoadNXcanSASTest.h
LoadNexusLogsTest.h
......
......@@ -34,6 +34,7 @@ OutputWorkspace_PeriodNo)
@author Stephen Smith, ISIS
*/
// Forward declare Muon Load Strategy
class DLLExport LoadMuonNexusV2 : public API::NexusFileLoader {
public:
// Default constructor
......@@ -62,8 +63,8 @@ private:
void execLoader() override;
// Determines whether entry contains multi period data
void isEntryMultiPeriod(const NeXus::NXEntry &entry);
// Run child algorithm LoadISISNexus3
void runLoadISISNexus();
// Run child algorithm LoadISISNexus2
API::Workspace_sptr runLoadISISNexus();
// Load Muon specific properties
void loadMuonProperties(const NeXus::NXEntry &entry);
/// The name and path of the input file
......
......@@ -6,19 +6,16 @@
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
#include "MantidAPI/Workspace_fwd.h"
#include "MantidDataObjects/TableWorkspace.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidDataObjects/TableWorkspace_fwd.h"
#include "MantidGeometry/IDTypes.h"
#include "MantidKernel/Logger.h"
#include "MantidNexus/NexusClasses.h"
namespace Mantid {
namespace DataHandling {
class DLLExport LoadMuonStrategy {
public:
// Constructor
LoadMuonStrategy(Kernel::Logger &g_log, const std::string &filename);
LoadMuonStrategy(Kernel::Logger &g_log, std::string filename);
// Virtual destructor
virtual ~LoadMuonStrategy() {}
// Load muon log data
......@@ -44,7 +41,7 @@ protected:
// Logger
Kernel::Logger &m_logger;
// Filename, used for running child algorithms
const std::string &m_filename;
const std::string m_filename;
};
} // namespace DataHandling
} // namespace Mantid
......@@ -6,6 +6,8 @@
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
#include "MantidDataHandling/LoadMuonStrategy.h"
#include "MantidDataObjects/Workspace2D_fwd.h"
#include "MantidNexus/NexusClasses.h"
namespace Mantid {
namespace DataHandling {
......@@ -13,7 +15,7 @@ class SinglePeriodLoadMuonStrategy : public LoadMuonStrategy {
public:
// Constructor
SinglePeriodLoadMuonStrategy(Kernel::Logger &g_log,
const std::string &filename,
const std::string filename,
NeXus::NXEntry &entry,
DataObjects::Workspace2D_sptr workspace,
int entryNumber, bool isFileMultiPeriod);
......
......@@ -31,6 +31,12 @@ using namespace HistogramData;
using std::size_t;
using namespace DataObjects;
namespace NeXusEntry {
const std::string RAWDATA{"/raw_data_1"};
const std::string DEFINITION{"/raw_data_1/definition"};
const std::string PERIOD{"/periods"};
} // namespace NeXusEntry
/// Empty default constructor
LoadMuonNexusV2::LoadMuonNexusV2()
: m_filename(), m_entrynumber(0), m_isFileMultiPeriod(false),
......@@ -44,15 +50,14 @@ LoadMuonNexusV2::LoadMuonNexusV2()
*/
int LoadMuonNexusV2::confidence(NexusHDF5Descriptor &descriptor) const {
// Without this entry we cannot use LoadISISNexus
if (!descriptor.isEntry("/raw_data_1", "NXentry")) {
if (!descriptor.isEntry(NeXusEntry::RAWDATA, "NXentry")) {
return 0;
}
const std::string root = "/raw_data_1";
// Check if Muon source in definition entry
if (!descriptor.isEntry(root + "/definition"))
if (!descriptor.isEntry(NeXusEntry::DEFINITION))
return 0;
::NeXus::File file(descriptor.getFilename());
file.openPath(root + "/definition");
file.openPath(NeXusEntry::DEFINITION);
std::string def = file.getStrData();
if (def == "muonTD" || def == "pulsedTD") {
return 82; // have to return 82 to "beat" the LoadMuonNexus2 algorithm,
......@@ -114,25 +119,26 @@ void LoadMuonNexusV2::init() {
"detector grouping.");
}
void LoadMuonNexusV2::execLoader() {
this->setRethrows(true);
// this->setRethrows(true);
// prepare nexus entry
m_entrynumber = getProperty("EntryNumber");
m_filename = getPropertyValue("Filename");
NXRoot root(m_filename);
NXEntry entry = root.openEntry("raw_data_1");
NXEntry entry = root.openEntry(NeXusEntry::RAWDATA);
isEntryMultiPeriod(entry);
if (m_isFileMultiPeriod) {
throw std::invalid_argument(
"Multiperiod nexus files not yet supported by LoadMuonNexusV2");
}
// Execute child algorithm LoadISISNexus2 and load Muon specific properties
runLoadISISNexus();
auto outWS = runLoadISISNexus();
loadMuonProperties(entry);
// Check if single or multi period file and create appropriate loading
// strategy
isEntryMultiPeriod(entry);
Workspace_sptr outWS = getProperty("OutputWorkspace");
if (m_multiPeriodsLoaded) {
WorkspaceGroup_sptr wksp_grp =
std::dynamic_pointer_cast<WorkspaceGroup>(outWS);
g_log.warning("Multi period files not yet supported by LoadMuonNexusV2");
// Currently not implemented
return;
} else {
// we just have a single workspace
......@@ -162,7 +168,7 @@ void LoadMuonNexusV2::execLoader() {
* If multi period the function determines whether multi periods are loaded
*/
void LoadMuonNexusV2::isEntryMultiPeriod(const NXEntry &entry) {
NXClass periodClass = entry.openNXGroup("periods");
NXClass periodClass = entry.openNXGroup(NeXusEntry::PERIOD);
int numberOfPeriods = periodClass.getInt("number");
if (numberOfPeriods > 1) {
m_isFileMultiPeriod = true;
......@@ -177,8 +183,9 @@ void LoadMuonNexusV2::isEntryMultiPeriod(const NXEntry &entry) {
/**
* Runs the child algorithm LoadISISNexus, which loads data into an output
* workspace
* @returns :: Workspace loaded by runLoadISISNexus
*/
void LoadMuonNexusV2::runLoadISISNexus() {
Workspace_sptr LoadMuonNexusV2::runLoadISISNexus() {
// Here we explicit set the number of OpenMP threads, as by default
// LoadISISNexus spawns up a large number of threads,
// which is unnecessary for the size (~100 spectra) of workspaces seen here.
......@@ -206,6 +213,8 @@ void LoadMuonNexusV2::runLoadISISNexus() {
ISISLoader->copyPropertiesFrom(*this);
ISISLoader->execute();
this->copyPropertiesFrom(*ISISLoader);
Workspace_sptr outWS = getProperty("OutputWorkspace");
return outWS;
}
/**
* Loads Muon specific data from the nexus entry
......
......@@ -13,6 +13,19 @@ namespace Mantid {
namespace DataHandling {
namespace LoadMuonNexusV2Helper {
namespace NeXusEntry {
const std::string GOODFRAMES{"good_frames"};
const std::string DETECTOR{"instrument/detector_1"};
const std::string PERIOD{"periods"};
const std::string ORIENTATON{"instrument/detector_1/orientation"};
const std::string RESOLUTION{"resolution"};
const std::string GROUPING{"grouping"};
const std::string DEADTIME{"dead_time"};
const std::string COUNTS{"counts"};
const std::string FIRSTGOODBIN{"first_good_bin"};
const std::string TIMEZERO{"time_zero"};
} // namespace NeXusEntry
using namespace NeXus;
using namespace Kernel;
using namespace API;
......@@ -27,7 +40,7 @@ NXInt loadGoodFramesDataFromNexus(const NXEntry &entry,
if (!isFileMultiPeriod) {
try {
NXInt goodFrames = entry.openNXInt("good_frames");
NXInt goodFrames = entry.openNXInt(NeXusEntry::GOODFRAMES);
goodFrames.load();
return goodFrames;
} catch (std::runtime_error) {
......@@ -36,9 +49,9 @@ NXInt loadGoodFramesDataFromNexus(const NXEntry &entry,
}
} else {
try {
NXClass periodClass = entry.openNXGroup("periods");
NXClass periodClass = entry.openNXGroup(NeXusEntry::PERIOD);
// For multiperiod datasets, read raw_data_1/periods/good_frames
NXInt goodFrames = periodClass.openNXInt("good_frames");
NXInt goodFrames = periodClass.openNXInt(NeXusEntry::GOODFRAMES);
goodFrames.load();
return goodFrames;
} catch (std::runtime_error) {
......@@ -55,9 +68,9 @@ loadDetectorGroupingFromNexus(const NXEntry &entry,
std::vector<detid_t> grouping;
// Open nexus entry
NXClass detectorGroup = entry.openNXGroup("instrument/detector_1");
if (detectorGroup.containsDataSet("grouping")) {
NXInt groupingData = detectorGroup.openNXInt("grouping");
NXClass detectorGroup = entry.openNXGroup(NeXusEntry::DETECTOR);
if (detectorGroup.containsDataSet(NeXusEntry::GROUPING)) {
NXInt groupingData = detectorGroup.openNXInt(NeXusEntry::GROUPING);
groupingData.load();
if (!isFileMultiPeriod) {
for (const auto &detectorNumber : detectorsLoaded) {
......@@ -70,7 +83,7 @@ loadDetectorGroupingFromNexus(const NXEntry &entry,
std::string loadMainFieldDirectionFromNexus(const NeXus::NXEntry &entry) {
std::string mainFieldDirection = "Longitudinal"; // default
try {
NXChar orientation = entry.openNXChar("instrument/detector_1/orientation");
NXChar orientation = entry.openNXChar(NeXusEntry::ORIENTATON);
// some files have no data there
orientation.load();
if (orientation[0] == 't') {
......@@ -88,9 +101,9 @@ loadDeadTimesFromNexus(const NeXus::NXEntry &entry,
std::vector<double> deadTimes;
// Open detector nexus entry
NXClass detectorGroup = entry.openNXGroup("instrument/detector_1");
if (detectorGroup.containsDataSet("dead_time")) {
NXFloat deadTimesData = detectorGroup.openNXFloat("dead_time");
NXClass detectorGroup = entry.openNXGroup(NeXusEntry::DETECTOR);
if (detectorGroup.containsDataSet(NeXusEntry::DEADTIME)) {
NXFloat deadTimesData = detectorGroup.openNXFloat(NeXusEntry::DEADTIME);
deadTimesData.load();
if (!isFileMultiPeriod) {
// Simplest case - one grouping entry per detector
......@@ -104,17 +117,20 @@ loadDeadTimesFromNexus(const NeXus::NXEntry &entry,
double loadFirstGoodDataFromNexus(const NeXus::NXEntry &entry) {
try {
NXClass detectorEntry = entry.openNXGroup("instrument/detector_1");
NXInfo infoResolution = detectorEntry.getDataSetInfo("resolution");
NXInt counts = detectorEntry.openNXInt("counts");
std::string firstGoodBin = counts.attributes("first_good_bin");
NXClass detectorEntry = entry.openNXGroup(NeXusEntry::DETECTOR);
NXInfo infoResolution =
detectorEntry.getDataSetInfo(NeXusEntry::RESOLUTION);
NXInt counts = detectorEntry.openNXInt(NeXusEntry::COUNTS);
std::string firstGoodBin = counts.attributes(NeXusEntry::FIRSTGOODBIN);
double resolution;
switch (infoResolution.type) {
case NX_FLOAT32:
resolution = static_cast<double>(detectorEntry.getFloat("resolution"));
resolution =
static_cast<double>(detectorEntry.getFloat(NeXusEntry::RESOLUTION));
break;
case NX_INT32:
resolution = static_cast<double>(detectorEntry.getInt("resolution"));
resolution =
static_cast<double>(detectorEntry.getInt(NeXusEntry::RESOLUTION));
break;
default:
throw std::runtime_error("Unsupported data type for resolution");
......@@ -129,8 +145,9 @@ double loadFirstGoodDataFromNexus(const NeXus::NXEntry &entry) {
double loadTimeZeroFromNexusFile(const NeXus::NXEntry &entry) {
try {
NXClass detectorEntry = entry.openNXGroup("instrument/detector_1");
double timeZero = static_cast<double>(detectorEntry.getFloat("time_zero"));
NXClass detectorEntry = entry.openNXGroup(NeXusEntry::DETECTOR);
double timeZero =
static_cast<double>(detectorEntry.getFloat(NeXusEntry::TIMEZERO));
return timeZero;
} catch (std::runtime_error) {
throw std::runtime_error("Could not load time zero, check Nexus file");
......
......@@ -9,15 +9,16 @@
#include "MantidDataHandling/LoadMuonStrategy.h"
#include "MantidAPI/TableRow.h"
#include "MantidAPI/WorkspaceFactory.h"
#include "MantidDataObjects/TableWorkspace.h"
#include "MantidNexus/NexusClasses.h"
#include <vector>
namespace Mantid {
namespace DataHandling {
// Constructor
LoadMuonStrategy::LoadMuonStrategy(Kernel::Logger &g_log,
const std::string &filename)
: m_logger(g_log), m_filename(filename) {}
LoadMuonStrategy::LoadMuonStrategy(Kernel::Logger &g_log, std::string filename)
: m_logger(g_log), m_filename(std::move(filename)) {}
/**
* Creates Detector Grouping Table .
......@@ -31,7 +32,6 @@ DataObjects::TableWorkspace_sptr LoadMuonStrategy::createDetectorGroupingTable(
auto detectorGroupingTable =
std::dynamic_pointer_cast<DataObjects::TableWorkspace>(
API::WorkspaceFactory::Instance().createTable("TableWorkspace"));
detectorGroupingTable->addColumn("vector_int", "Detectors");
std::map<detid_t, std::vector<detid_t>> groupingMap;
......
......@@ -12,6 +12,8 @@
#include "MantidDataHandling/ISISRunLogs.h"
#include "MantidDataHandling/LoadMuonLog.h"
#include "MantidDataHandling/LoadMuonNexusV2Helper.h"
#include "MantidDataObjects/TableWorkspace.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidKernel/UnitFactory.h"
#include "MantidKernel/UnitLabelTypes.h"
......@@ -24,12 +26,19 @@ using namespace HistogramData;
using std::size_t;
using namespace DataObjects;
namespace NeXusEntry {
const std::string SAMPLE{"sample"};
const std::string TEMPERATURE{"temperature"};
const std::string MAGNETICFIELD{"magnetic_field"};
} // namespace NeXusEntry
// Constructor
SinglePeriodLoadMuonStrategy::SinglePeriodLoadMuonStrategy(
Kernel::Logger &g_log, const std::string &filename, NXEntry &entry,
Kernel::Logger &g_log, const std::string filename, NXEntry &entry,
Workspace2D_sptr workspace, int entryNumber, bool isFileMultiPeriod)
: LoadMuonStrategy(g_log, filename), m_entry(entry), m_workspace(workspace),
m_entryNumber(entryNumber), m_isFileMultiPeriod(isFileMultiPeriod),
: LoadMuonStrategy(g_log, filename), m_entry(entry),
m_workspace(std::move(workspace)), m_entryNumber(entryNumber),
m_isFileMultiPeriod(isFileMultiPeriod),
m_detectors(getLoadedDetectors()) {}
/**
......@@ -39,15 +48,15 @@ SinglePeriodLoadMuonStrategy::SinglePeriodLoadMuonStrategy(
void SinglePeriodLoadMuonStrategy::loadMuonLogData() {
auto &run = m_workspace->mutableRun();
auto runSample = m_entry.openNXGroup("sample");
auto runSample = m_entry.openNXGroup(NeXusEntry::SAMPLE);
if (runSample.containsDataSet("temperature")) {
float temperature = runSample.getFloat("temperature");
if (runSample.containsDataSet(NeXusEntry::TEMPERATURE)) {
float temperature = runSample.getFloat(NeXusEntry::TEMPERATURE);
run.addProperty("sample_temp", static_cast<double>(temperature));
}
if (runSample.containsDataSet("magnetic_field")) {
float magn_field = runSample.getFloat("magnetic_field");
if (runSample.containsDataSet(NeXusEntry::MAGNETICFIELD)) {
float magn_field = runSample.getFloat(NeXusEntry::MAGNETICFIELD);
run.addProperty("sample_magn_field", static_cast<double>(magn_field));
}
std::string mainFieldDirection =
......@@ -64,16 +73,18 @@ void SinglePeriodLoadMuonStrategy::loadMuonLogData() {
*/
void SinglePeriodLoadMuonStrategy::loadGoodFrames() {
// Overwrite existing log entry
std::string goodframeProp{"goodfrm"};
auto &run = m_workspace->mutableRun();
run.removeProperty("goodfrm");
run.removeProperty(goodframeProp);
NXInt goodframes = LoadMuonNexusV2Helper::loadGoodFramesDataFromNexus(
m_entry, m_isFileMultiPeriod);
if (m_isFileMultiPeriod) {
run.addProperty("goodfrm", goodframes[static_cast<int>(m_entryNumber - 1)]);
run.addProperty(goodframeProp,
goodframes[static_cast<int>(m_entryNumber - 1)]);
} else {
run.addProperty("goodfrm", goodframes[0]);
run.addProperty(goodframeProp, goodframes[0]);
}
}
......@@ -87,17 +98,15 @@ Workspace_sptr SinglePeriodLoadMuonStrategy::loadDetectorGrouping() const {
auto grouping = LoadMuonNexusV2Helper::loadDetectorGroupingFromNexus(
m_entry, m_detectors, m_isFileMultiPeriod);
DataObjects::TableWorkspace_sptr table =
TableWorkspace_sptr table =
createDetectorGroupingTable(m_detectors, grouping);
Workspace_sptr table_workspace;
if (table->rowCount() != 0) {
table_workspace = std::dynamic_pointer_cast<Workspace>(table);
return table;
} else {
m_logger.notice("Loading grouping information from IDF");
table_workspace = loadDefaultDetectorGrouping();
return loadDefaultDetectorGrouping();
}
return table_workspace;
}
/**
* Loads default detector grouping, if this isn't present
......@@ -135,15 +144,9 @@ SinglePeriodLoadMuonStrategy::loadDefaultDetectorGrouping() const {
* @returns :: Dead time table
*/
Workspace_sptr SinglePeriodLoadMuonStrategy::loadDeadTimeTable() const {
auto deadTimes = LoadMuonNexusV2Helper::loadDeadTimesFromNexus(
m_entry, m_detectors, m_isFileMultiPeriod);
auto deadTimeTable = createDeadTimeTable(m_detectors, deadTimes);
Workspace_sptr deadtimeWorkspace =
std::dynamic_pointer_cast<Workspace>(deadTimeTable);
return deadtimeWorkspace;
return createDeadTimeTable(m_detectors, deadTimes);
}
/**
* Performs time-zero correction on the loaded workspace and also changes the
......@@ -151,7 +154,6 @@ Workspace_sptr SinglePeriodLoadMuonStrategy::loadDeadTimeTable() const {
* LoadISISNexus2
*/
void SinglePeriodLoadMuonStrategy::applyTimeZeroCorrection() {
double timeZero = LoadMuonNexusV2Helper::loadTimeZeroFromNexusFile(m_entry);
auto newUnit = std::dynamic_pointer_cast<Kernel::Units::Label>(
Kernel::UnitFactory::Instance().create("Label"));
......
......@@ -12,6 +12,7 @@
#include "MantidAPI/Run.h"
#include "MantidAPI/WorkspaceGroup.h"
#include "MantidDataHandling/LoadMuonNexusV2.h"
#include "MantidDataObjects/TableWorkspace.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidKernel/UnitFactory.h"
#include "MantidKernel/UnitLabelTypes.h"
......@@ -242,17 +243,17 @@ public:
TS_ASSERT_EQUALS(*detectorgroup.begin(), specMax);
}
void testLoadThrowsIfEntryNumberOutOfRange() {
void testLoadFailsIfEntryNumberOutOfRange() {
LoadMuonNexusV2 ld;
ld.initialize();
ld.setPropertyValue("Filename", "EMU00103638.nxs_v2");
ld.setPropertyValue("OutputWorkspace", "outWS");
ld.setPropertyValue("EntryNumber", "10");
TS_ASSERT_THROWS(ld.execute(), const std::invalid_argument &)
TS_ASSERT(!ld.isExecuted())
}
void testLoadThrowsIfInvalidSpectraProperties() {
void testLoadFailsIfInvalidSpectraProperties() {
std::vector<int> spectraIntegerList = {1, 123, 157};
auto spectraList = createSpectraList(spectraIntegerList);
LoadMuonNexusV2 ld;
......@@ -261,7 +262,7 @@ public:
ld.setPropertyValue("OutputWorkspace", "outWS");
ld.setPropertyValue("SpectrumList", spectraList);
TS_ASSERT_THROWS(ld.execute(), const std::invalid_argument &)
TS_ASSERT(!ld.isExecuted())
}
void testMaxThreadsRestoredWhenAlgorithmFinished() {
......
......@@ -125,8 +125,10 @@ set(INC_FILES
inc/MantidDataObjects/SplittersWorkspace.h
inc/MantidDataObjects/TableColumn.h
inc/MantidDataObjects/TableWorkspace.h
inc/MantidDataObjects/TableWorkspace_fwd.h
inc/MantidDataObjects/VectorColumn.h
inc/MantidDataObjects/Workspace2D.h
inc/MantidDataObjects/Workspace2D_fwd.h
inc/MantidDataObjects/WorkspaceCreation.h
inc/MantidDataObjects/WorkspaceSingleValue.h)
......
// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright &copy; 2020 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 <memory>
namespace Mantid {
namespace DataObjects {
/**
This file provides forward declarations for
Mantid::DataObjects::TableWorkspace
*/
/// forward declare of Mantid::DataObjects::TableWorkspace
class TableWorkspace;
/// shared pointer to Mantid::DataObjects::TableWorkspace
using TableWorkspace_sptr = std::shared_ptr<TableWorkspace>;
/// shared pointer to Mantid::DataObjects::TableWorkspace (const version)
using TableWorkspace_const_sptr = std::shared_ptr<const TableWorkspace>;
/// unique pointer to Mantid::DataObjects::TableWorkspace
using TableWorkspace_uptr = std::unique_ptr<TableWorkspace>;
/// unique pointer to Mantid::DataObjects::TableWorkspace (const version)
using TableWorkspace_const_uptr = std::unique_ptr<const TableWorkspace>;
} // namespace DataObjects
} // namespace Mantid
// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright &copy; 2020 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 <memory>
namespace Mantid {
namespace DataObjects {
/**
This file provides forward declarations for Mantid::DataObjects::Workspace2D
*/
/// forward declare of Mantid::DataObjects::Workspace2D
class Workspace2D;
/// shared pointer to Mantid::DataObjects::Workspace2D
using Workspace2D_sptr = std::shared_ptr<Workspace2D>;
/// shared pointer to Mantid::DataObjects::Workspace2D (const version)
using Workspace2D_const_sptr = std::shared_ptr<const Workspace2D>;
/// unique pointer to Mantid::DataObjects::Workspace2D
using Workspace2D_uptr = std::unique_ptr<Workspace2D>;
/// unique pointer to Mantid::DataObjects::Workspace2D (const version)
using Workspace2D_const_uptr = std::unique_ptr<const Workspace2D>;
} // namespace DataObjects
} // namespace Mantid
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment