PeaksWorkspace.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/Peak.h"
#include "MantidDataObjects/PeakColumn.h"
#include "MantidGeometry/Crystal/IPeak.h"
#include "MantidKernel/PropertyWithValue.h"
#include "MantidKernel/SpecialCoordinateSystem.h"
#include "MantidKernel/V3D.h"
 
using Mantid::Geometry::IPeak_uptr;
// IsamplePosition should be IsampleOrientation
namespace Mantid {
//----------------------------------------------------------------------
// Forward declarations
//----------------------------------------------------------------------
namespace Kernel {
class Logger;
}
 
namespace DataObjects {
//==========================================================================================
class MANTID_DATAOBJECTS_DLL PeaksWorkspace : public Mantid::API::IPeaksWorkspace {
public:
  using ColumnAndDirection = std::pair<std::string, bool>;
 
public:
  const std::string id() const override { return "PeaksWorkspace"; }
 
  PeaksWorkspace();
  PeaksWorkspace &operator=(const PeaksWorkspace &other) = delete;
 
  API::LogManager_sptr logs() override;
  API::LogManager_const_sptr getLogs() const override;
 
  std::unique_ptr<PeaksWorkspace> clone() const { return std::unique_ptr<PeaksWorkspace>(doClone()); }
 
  std::unique_ptr<PeaksWorkspace> cloneEmpty() const { return std::unique_ptr<PeaksWorkspace>(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(Peak &&peak);
  void addPeak(const Kernel::V3D &position, const Kernel::SpecialCoordinateSystem &frame) override;
  Peak &getPeak(size_t const peakNum) override;
  const Peak &getPeak(size_t const peakNum) const override;
 
  IPeak_uptr createPeak(const Kernel::V3D &QLabFrame,
                        std::optional<double> detectorDistance = std::nullopt) const override;
 
  IPeak_uptr createPeak(const Kernel::V3D &Position, const Kernel::SpecialCoordinateSystem &frame) const override;
 
  IPeak_uptr createPeakQSample(const Kernel::V3D &position) const override;
 
  std::vector<std::pair<std::string, std::string>> peakInfo(const Kernel::V3D &qFrame, bool labCoords) const override;
 
  IPeak_uptr createPeakHKL(const Kernel::V3D &HKL) const override;
 
  IPeak_uptr createPeak() const override;
 
  int peakInfoNumber(const Kernel::V3D &qFrame, bool labCoords) const override;
 
  std::vector<Peak> &getPeaks();
  const std::vector<Peak> &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:
  PeaksWorkspace(const PeaksWorkspace &other);
 
private:
  PeaksWorkspace *doClone() const override { return new PeaksWorkspace(*this); }
  PeaksWorkspace *doCloneEmpty() const override { return new PeaksWorkspace(); }
  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("PeaksWorkspace 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("PeaksWorkspace structure is read-only. Cannot add columns.");
  }
 
  void removeColumn(const std::string & /*name*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError(
        "PeaksWorkspace structure is read-only. Cannot remove column.");
  }
 
  void setRowCount(size_t /*count*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError("PeaksWorkspace structure is read-only. Cannot setRowCount");
  }
 
  size_t insertRow(size_t /*index*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError("PeaksWorkspace structure is read-only. Cannot insertRow");
  }
 
  void removeRow(size_t /*index*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError("PeaksWorkspace structure is read-only. Cannot removeRow.");
  }
 
  void find(size_t /*value*/, size_t & /*row*/, size_t /*col*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError("PeaksWorkspace::find() not implemented.");
  }
  void find(double /*value*/, size_t & /*row*/, size_t /*col*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError("PeaksWorkspace::find() not implemented.");
  }
  void find(float /*value*/, size_t & /*row*/, size_t /*col*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError("PeaksWorkspace::find() not implemented.");
  }
  void find(API::Boolean /*value*/, size_t & /*row*/, size_t /*col*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError("PeaksWorkspace::find() not implemented.");
  }
  void find(const std::string & /*value*/, size_t & /*row*/, size_t /*col*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError("PeaksWorkspace::find() not implemented.");
  }
  void find(const Mantid::Kernel::V3D & /*value*/, size_t & /*row*/, size_t /*col*/) override {
    throw Mantid::Kernel::Exception::NotImplementedError("PeaksWorkspace::find() not implemented.");
  }
 
  // ====================================== End ITableWorkspace Methods
  // ==================================
 
  std::vector<Peak> m_peaks;
 
  std::vector<std::shared_ptr<Mantid::DataObjects::PeakColumn<Peak>>> m_columns;
 
  std::vector<std::string> m_columnNames;
 
  Kernel::SpecialCoordinateSystem m_coordSystem;
};
 
using PeaksWorkspace_sptr = std::shared_ptr<PeaksWorkspace>;
 
using PeaksWorkspace_const_sptr = std::shared_ptr<const PeaksWorkspace>;
} // namespace DataObjects
} // namespace Mantid
 
// Instantiated and exported by DataObjects/src/PropertyWithValue.cpp
MANTID_DATAOBJECTS_EXTERN_TEMPLATE(
    Mantid::Kernel::PropertyWithValue<std::shared_ptr<Mantid::DataObjects::PeaksWorkspace>>);
 
#ifndef DataObjects_EXPORTS
#include "MantidAPI/WorkspaceProperty.h"
namespace Mantid::API {
extern template class MANTID_DATAOBJECTS_DLL WorkspaceProperty<DataObjects::PeaksWorkspace>;
} // namespace Mantid::API
#endif