MDTransfAxisNames.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 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 +
#include "MantidMDAlgorithms/MDTransfAxisNames.h"
#include "MantidMDAlgorithms/DllConfig.h"
#include <boost/format.hpp>
 
namespace Mantid::MDAlgorithms {
using namespace Mantid::Kernel;
 
MDTransfAxisNames::MDTransfAxisNames() : m_DefaultDimID(CnvrtToMD::nDefaultID) {
  // this defines default dimension ID-s which are used to indentify dimensions
  // when using the target MD workspace later
  // for ModQ transformation:
  m_DefaultDimID[CnvrtToMD::ModQ_ID] = "|Q|";
  // for Q3D transformation
  m_DefaultDimID[CnvrtToMD::Q1_ID] = "Q1";
  m_DefaultDimID[CnvrtToMD::Q2_ID] = "Q2";
  m_DefaultDimID[CnvrtToMD::Q3_ID] = "Q3";
  m_DefaultDimID[CnvrtToMD::dE_ID] = "DeltaE";
}
 
//
std::vector<std::string> MDTransfAxisNames::getDefaultDimIDQ3D(DeltaEMode::Type dEMode) const {
  std::vector<std::string> rez;
  if (dEMode == DeltaEMode::Elastic) {
    rez.resize(3);
  } else {
 
    if (dEMode == DeltaEMode::Direct || dEMode == DeltaEMode::Indirect) {
      rez.resize(4);
      rez[3] = m_DefaultDimID[CnvrtToMD::dE_ID];
    } else {
      throw(std::invalid_argument("Unknown dE mode provided"));
    }
  }
  rez[0] = m_DefaultDimID[CnvrtToMD::Q1_ID];
  rez[1] = m_DefaultDimID[CnvrtToMD::Q2_ID];
  rez[2] = m_DefaultDimID[CnvrtToMD::Q3_ID];
  return rez;
}
 
std::vector<std::string> MDTransfAxisNames::getDefaultDimIDModQ(DeltaEMode::Type dEMode) const {
  std::vector<std::string> rez;
 
  if (dEMode == DeltaEMode::Elastic) {
    rez.resize(1);
  } else {
    if (dEMode == DeltaEMode::Direct || dEMode == DeltaEMode::Indirect) {
      rez.resize(2);
      rez[1] = m_DefaultDimID[CnvrtToMD::dE_ID];
    } else {
      throw(std::invalid_argument("Unknown dE mode provided"));
    }
  }
  rez[0] = m_DefaultDimID[CnvrtToMD::ModQ_ID];
  return rez;
}
 
std::string makeAxisName(const Kernel::V3D &Dir, const std::vector<std::string> &QNames) {
  double eps(1.e-3);
  Kernel::V3D absDir(fabs(Dir.X()), fabs(Dir.Y()), fabs(Dir.Z()));
  std::string mainName;
 
  if ((absDir[0] >= absDir[1]) && (absDir[0] >= absDir[2])) {
    mainName = QNames[0];
  } else if (absDir[1] >= absDir[2]) {
    mainName = QNames[1];
  } else {
    mainName = QNames[2];
  }
 
  std::string name("["), separator = ",";
  for (size_t i = 0; i < 3; i++) {
 
    if (i == 2)
      separator = "]";
    if (absDir[i] < eps) {
      name += "0" + separator;
      continue;
    }
    if (Dir[i] < 0) {
      name += "-";
    }
    if (std::fabs(absDir[i] - 1) < eps) {
      name.append(mainName).append(separator);
      continue;
    }
    name.append(sprintfd(absDir[i], eps)).append(mainName).append(separator);
  }
 
  return name;
}
std::string MANTID_MDALGORITHMS_DLL sprintfd(const double data, const double eps) {
  // truncate to eps decimal points
  double dist = std::round(data / eps) * eps;
  return boost::str(boost::format("%d") % dist);
}
 
} // namespace Mantid::MDAlgorithms