LeanElasticPeaksWorkspace.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2010 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/IPeaksWorkspace.h"
#include "MantidAPI/ITableWorkspace.h"
#include "MantidDataObjects/DllConfig.h"
#include "MantidDataObjects/LeanElasticPeak.h"
#include "MantidDataObjects/PeakColumn.h"
#include "MantidGeometry/Crystal/IPeak.h"
#include "MantidKernel/PropertyWithValue.h"
#include "MantidKernel/SpecialCoordinateSystem.h"
#include "MantidKernel/V3D.h"
 
// IsamplePosition should be IsampleOrientation
namespace Mantid {
//----------------------------------------------------------------------
// Forward declarations
//----------------------------------------------------------------------
namespace Kernel {
class Logger;
}
 
namespace DataObjects {
//==========================================================================================
class MANTID_DATAOBJECTS_DLL LeanElasticPeaksWorkspace : public Mantid::API::IPeaksWorkspace {
public:
  using ColumnAndDirection = std::pair<std::string, bool>;
 
public:
  const std::string id() const override { return "LeanElasticPeaksWorkspace"; }
 
  LeanElasticPeaksWorkspace();
  LeanElasticPeaksWorkspace &operator=(const LeanElasticPeaksWorkspace &other) = delete;
 
  API::LogManager_sptr logs() override;
  API::LogManager_const_sptr getLogs() const override;
 
  std::unique_ptr<LeanElasticPeaksWorkspace> clone() const {
    return std::unique_ptr<LeanElasticPeaksWorkspace>(doClone());
  }
 
  std::unique_ptr<LeanElasticPeaksWorkspace> cloneEmpty() const {
    return std::unique_ptr<LeanElasticPeaksWorkspace>(doCloneEmpty());
  }
 
  void appendFile(std::string filename, Geometry::Instrument_sptr inst);
 
  bool customSort() const override { return true; }
 
  void sort(std::vector<ColumnAndDirection> &criteria) override;
 
  int getNumberPeaks() const override;
  std::string getConvention() const override;
  void removePeak(int peakNum) override;
  void removePeaks(std::vector<int> badPeaks) override;
  void addPeak(const Geometry::IPeak &peak) override;
  void addPeak(LeanElasticPeak &&peak);
  void addPeak(const Kernel::V3D &position, const Kernel::SpecialCoordinateSystem &frame) override;
  LeanElasticPeak &getPeak(size_t const peakNum) override;
  const LeanElasticPeak &getPeak(size_t const peakNum) const override;
 
  std::unique_ptr<Geometry::IPeak> createPeak(const Kernel::V3D &QLabFrame,
                                              std::optional<double> detectorDistance = std::nullopt) const override;
 
  std::unique_ptr<Geometry::IPeak> createPeak(const Kernel::V3D &Position,
                                              const Kernel::SpecialCoordinateSystem &frame) const override;
 
  std::unique_ptr<Geometry::IPeak> createPeakQSample(const Kernel::V3D &position) const override;
 
  std::vector<std::pair<std::string, std::string>> peakInfo(const Kernel::V3D &qFrame, bool labCoords) const override;
 
  std::unique_ptr<Geometry::IPeak> createPeakHKL(const Kernel::V3D &HKL) const override;
 
  std::unique_ptr<Geometry::IPeak> createPeak() const override;
 
  int peakInfoNumber(const Kernel::V3D &qFrame, bool labCoords) const override;
 
  std::vector<LeanElasticPeak> &getPeaks();
  const std::vector<LeanElasticPeak> &getPeaks() const;
  bool hasIntegratedPeaks() const override;
  size_t getMemorySize() const override;
 
  API::ITableWorkspace_sptr createDetectorTable() const override;
 
  void setCoordinateSystem(const Kernel::SpecialCoordinateSystem coordinateSystem) override;
 
  Kernel::SpecialCoordinateSystem getSpecialCoordinateSystem() const override;
 
  // ====================================== ITableWorkspace Methods
  // ==================================
  size_t columnCount() const override { return static_cast<int>(m_columns.size()); }
 
  size_t rowCount() const override { return getNumberPeaks(); }
 
  std::shared_ptr<Mantid::API::Column> getColumn(const std::string &name) override {
    return getColumn(getColumnIndex(name));
  }
 
  std::shared_ptr<const Mantid::API::Column> getColumn(const std::string &name) const override {
    return getColumn(getColumnIndex(name));
  }
 
  virtual size_t getColumnIndex(const std::string &name) const;
 
  std::shared_ptr<Mantid::API::Column> getColumn(size_t index) override;
 
  API::Column_const_sptr getColumn(size_t index) const override;
  // ====================================== End ITableWorkspace Methods
  // ==================================
 
  //---------------------------------------------------------------------------------------------
  std::vector<std::string> getColumnNames() const override { return this->m_columnNames; }
  bool threadSafe() const override { return true; }
 
  // --- Nexus Methods ---
  // Save to Nexus
  void saveNexus(Nexus::File *file) const override;
 
protected:
  LeanElasticPeaksWorkspace(const LeanElasticPeaksWorkspace &other);
 
private:
  LeanElasticPeaksWorkspace *doClone() const override { return new LeanElasticPeaksWorkspace(*this); }
  LeanElasticPeaksWorkspace *doCloneEmpty() const override { return new LeanElasticPeaksWorkspace(); }
  ITableWorkspace *doCloneColumns(const std::vector<std::string> &colNames) const override;
 
  void initColumns();
  void addPeakColumn(const std::string &name);
 
  // ====================================== ITableWorkspace Methods
  // ==================================
 
  // ===== Methods that are not implemented (read-only table) ==========
  API::Column_sptr addColumn(const std::string & /*type*/, const std::string & /*name*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError(
        "LeanElasticPeaksWorkspace structure is read-only. Cannot add column.");
  }
 
  bool addColumns(const std::string & /*type*/, const std::string & /*name*/, size_t /*n*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError("LeanElasticPeaksWorkspace structure is read-only. Cannot add "
                                                         "columns.");
  }
 
  void removeColumn(const std::string & /*name*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError(
        "LeanElasticPeaksWorkspace structure is read-only. Cannot remove "
        "column.");
  }
 
  void setRowCount(size_t /*count*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError(
        "LeanElasticPeaksWorkspace structure is read-only. Cannot setRowCount");
  }
 
  size_t insertRow(size_t /*index*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError(
        "LeanElasticPeaksWorkspace structure is read-only. Cannot insertRow");
  }
 
  void removeRow(size_t /*index*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError(
        "LeanElasticPeaksWorkspace structure is read-only. Cannot removeRow.");
  }
 
  void find(size_t /*value*/, size_t & /*row*/, size_t /*col*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError("LeanElasticPeaksWorkspace::find() not implemented.");
  }
  void find(double /*value*/, size_t & /*row*/, size_t /*col*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError("LeanElasticPeaksWorkspace::find() not implemented.");
  }
  void find(float /*value*/, size_t & /*row*/, size_t /*col*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError("LeanElasticPeaksWorkspace::find() not implemented.");
  }
  void find(API::Boolean /*value*/, size_t & /*row*/, size_t /*col*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError("LeanElasticPeaksWorkspace::find() not implemented.");
  }
  void find(const std::string & /*value*/, size_t & /*row*/, size_t /*col*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError("LeanElasticPeaksWorkspace::find() not implemented.");
  }
  void find(const Mantid::Kernel::V3D & /*value*/, size_t & /*row*/, size_t /*col*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError("LeanElasticPeaksWorkspace::find() not implemented.");
  }
 
  // ====================================== End ITableWorkspace Methods
  // ==================================
 
  std::vector<LeanElasticPeak> m_peaks;
 
  std::vector<std::shared_ptr<Mantid::DataObjects::PeakColumn<LeanElasticPeak>>> m_columns;
 
  std::vector<std::string> m_columnNames;
 
  Kernel::SpecialCoordinateSystem m_coordSystem;
};
 
using LeanElasticPeaksWorkspace_sptr = std::shared_ptr<LeanElasticPeaksWorkspace>;
 
using LeanElasticPeaksWorkspace_const_sptr = std::shared_ptr<const LeanElasticPeaksWorkspace>;
} // namespace DataObjects
} // namespace Mantid
 
// Instantiated and exported by DataObjects/src/PropertyWithValue.cpp
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(
    Mantid::Kernel::PropertyWithValue<std::shared_ptr<Mantid::DataObjects::LeanElasticPeaksWorkspace>>);