MDWSDescription.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2011 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/IMDEventWorkspace_fwd.h"
#include "MantidAPI/LogManager.h"
#include "MantidAPI/MatrixWorkspace.h"
 
#include "MantidGeometry/Crystal/OrientedLattice.h"
#include "MantidGeometry/MDGeometry/MDFrame.h"
 
#include "MantidKernel/Logger.h"
#include "MantidKernel/PhysicalConstants.h"
#include "MantidKernel/PropertyManager.h"
#include "MantidKernel/SpecialCoordinateSystem.h"
 
#include "MantidDataObjects/MDEvent.h"
#include "MantidDataObjects/TableWorkspace.h"
 
#include "MantidMDAlgorithms/DllConfig.h"
 
namespace Mantid {
namespace MDAlgorithms {
/***  Class wrapping together all parameters, related to conversion from a
   workspace to MDEventoWorkspace
   *
   *  used to provide common interface for subclasses, dealing with creation of
   MD workspace and conversion of
   *  ws data into DataObjects
   *
   * It also defines some auxiliary functions, used for convenient description
   of MD workspace
   *
   *
   * See http://www.mantidproject.org/Writing_custom_ConvertTo_MD_transformation
   for detailed description of this
   * class place in the algorithms hierarchy.
   *
 
   @date 2011-28-12
*/
 
class MANTID_MDALGORITHMS_DLL MDWSDescription : public API::LogManager {
public: // for the time being
  std::string AlgID;
  // the matrix which describes target coordinate system of the workspace and
  // connected with convert_to_factor;
  Kernel::DblMatrix m_Wtransf;
  // the vector which represent linear form of momentum transformation
  std::vector<double> m_RotMatrix;
 
  // preprocessed detectors workspace:
  DataObjects::TableWorkspace_const_sptr m_PreprDetTable;
  // helper parameter, which identifies if we are building new workspace or
  // adding data to the existing one. Allows to generate clearer error messages
  bool m_buildingNewWorkspace;
  //=======================
  /*---> accessors: */
  unsigned int nDimensions() const { return m_NDims; }
 
  std::vector<std::string> getDimNames() const { return m_DimNames; }
  std::vector<std::string> getDimIDs() const { return m_DimIDs; }
  std::vector<std::string> getDimUnits() const { return m_DimUnits; }
  std::vector<double> getDimMin() const { return m_DimMin; }
  std::vector<double> getDimMax() const { return m_DimMax; }
  std::vector<size_t> getNBins() const { return m_NBins; }
  std::vector<coord_t> getAddCoord() const { return m_AddCoord; }
  std::string getEModeStr() const;
  Kernel::DeltaEMode::Type getEMode() const { return m_Emode; }
  std::string getQMode() const { return AlgID; }
 
  bool isLorentsCorrections() const { return m_LorentzCorr; }
  double absMin() const { return m_AbsMin; }
  void getMinMax(std::vector<double> &min, std::vector<double> &max) const;
  std::vector<double> getTransfMatrix() const { return m_RotMatrix; }
 
  // workspace related helper functions, providing access to various workspace
  // functions
  API::MatrixWorkspace_const_sptr getInWS() const { return m_InWS; }
  void setWS(API::MatrixWorkspace_sptr otherMatrixWS);
  const std::string &getWSName() const { return m_InWS->getName(); }
  bool isPowder() const;
  bool isQ3DMode() const;
  bool hasLattice() const;
 
  std::shared_ptr<Geometry::OrientedLattice> getLattice() const { return getOrientedLattice(m_InWS); }
  Kernel::Matrix<double> getGoniometerMatr() const;
  bool hasGoniometer() const;
 
  MDWSDescription(unsigned int nDimensions = 0);
 
  void buildFromMDWS(const API::IMDEventWorkspace_const_sptr &pWS);
  void setUpMissingParameters(const MDWSDescription &SourceMatrWS);
 
  void buildFromMatrixWS(const API::MatrixWorkspace_sptr &pWS, const std::string &QMode, const std::string &dEMode,
                         const std::vector<std::string> &dimPropertyNames = std::vector<std::string>());
 
  void checkWSCorresponsMDWorkspace(const MDWSDescription &NewMDWorkspaceD);
 
  void setMinMax(const std::vector<double> &minVal, const std::vector<double> &maxVal);
  void setDimName(unsigned int nDim, const std::string &Name);
  // this is rather misleading function, as MD workspace do not have dimension
  // units
  void setDimUnit(unsigned int nDim, const std::string &Unit);
  void setLorentsCorr(bool On = false) { m_LorentzCorr = On; }
  void setAbsMin(double absMin) { m_AbsMin = absMin; }
  // static helper functions:
  static void checkMinMaxNdimConsistent(const std::vector<double> &minVal, const std::vector<double> &maxVal);
  static void fillAddProperties(const Mantid::API::MatrixWorkspace_const_sptr &inWS2D,
                                const std::vector<std::string> &dimPropertyNames, std::vector<coord_t> &AddCoord);
 
  static std::shared_ptr<Geometry::OrientedLattice>
  getOrientedLattice(const Mantid::API::MatrixWorkspace_const_sptr &inWS2D);
 
  void setCoordinateSystem(const Mantid::Kernel::SpecialCoordinateSystem system);
  Mantid::Kernel::SpecialCoordinateSystem getCoordinateSystem() const;
  void setFrame(const std::string &frameKey);
  Geometry::MDFrame_uptr getFrame(size_t d) const;
 
  void setNumBins(const std::vector<int> &nBins_toSplit);
 
protected: // until MDWSDesctiptionDepricatedExist
  unsigned int m_NDims;
  // shared pointer to the source matrix workspace
  API::MatrixWorkspace_sptr m_InWS;
  Kernel::DeltaEMode::Type m_Emode;
  bool m_LorentzCorr;
  double m_AbsMin;
  std::vector<coord_t> m_AddCoord;
  std::vector<std::string> m_DimNames;
  std::vector<std::string> m_DimIDs;
  std::vector<std::string> m_DimUnits;
  std::vector<size_t> m_NBins;
  std::vector<double> m_DimMin, m_DimMax;
  //********************* internal helpers
  void resizeDimDescriptions(unsigned int nDimensions, size_t nBins = 10);
 
private:
  Mantid::Kernel::SpecialCoordinateSystem m_coordinateSystem;
  std::string m_frameKey;
};
} // namespace MDAlgorithms
} // namespace Mantid