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.

Framework/DataHandling/CMakeLists.txt

@@ -505,6 +505,7 @@ set(TEST_FILES
     LoadMuonNexus1Test.h
     LoadMuonNexus2Test.h
     LoadMuonNexusV2Test.h
+    LoadNGEMTest.h
     LoadNXSPETest.h
     LoadNXcanSASTest.h
     LoadNexusLogsTest.h

Framework/DataHandling/inc/MantidDataHandling/LoadMuonNexusV2.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

Framework/DataHandling/inc/MantidDataHandling/LoadMuonStrategy.h

@@ -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

Framework/DataHandling/inc/MantidDataHandling/SinglePeriodLoadMuonStrategy.h

@@ -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);

Framework/DataHandling/src/LoadMuonNexusV2.cpp

@@ -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

Framework/DataHandling/src/LoadMuonNexusV2Helper.cpp

@@ -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");

Framework/DataHandling/src/LoadMuonStrategy.cpp

@@ -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;

Framework/DataHandling/src/SinglePeriodLoadMuonStrategy.cpp

@@ -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"));

Framework/DataHandling/test/LoadMuonNexusV2Test.h

@@ -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() {

Framework/DataObjects/CMakeLists.txt

@@ -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)
 

Framework/DataObjects/inc/MantidDataObjects/TableWorkspace_fwd.h

+// Mantid Repository : https://github.com/mantidproject/mantid
+//
+// Copyright © 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

Framework/DataObjects/inc/MantidDataObjects/Workspace2D_fwd.h

+// Mantid Repository : https://github.com/mantidproject/mantid
+//
+// Copyright © 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