d6/d82/PeakHKLErrors_8cpp_source.html

// Mantid Repository : https://github.com/mantidproject/mantid

//

// Copyright &copy; 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 +

/*

 * PeakHKLErrors.cpp

 *

 *  Created on: Jan 26, 2013

 *      Author: ruth

 */

#include "MantidCrystal/PeakHKLErrors.h"

#include "MantidAPI/AnalysisDataService.h"

#include "MantidAPI/FunctionFactory.h"

#include "MantidAPI/IConstraint.h"

#include "MantidAPI/IFunction1D.h"

#include "MantidAPI/ParamFunction.h"

#include "MantidAPI/Sample.h"

#include "MantidGeometry/Crystal/IPeak.h"

#include "MantidGeometry/Instrument/ComponentInfo.h"

#include "MantidGeometry/Instrument/Goniometer.h"

#include "MantidKernel/Unit.h"


#include <boost/algorithm/string/classification.hpp>

#include <boost/algorithm/string/split.hpp>

#include <boost/math/special_functions/round.hpp>


using namespace Mantid::DataObjects;

using namespace Mantid::API;

using namespace Mantid::Kernel;

using namespace Mantid::Kernel::Units;

using Mantid::Geometry::IPeak;


namespace Mantid::Crystal {

namespace {

Kernel::Logger g_log("PeakHKLErrors");

} // namespace


DECLARE_FUNCTION(PeakHKLErrors)


PeakHKLErrors::PeakHKLErrors() : ParamFunction(), IFunction1D(), OptRuns(""), PeakWorkspaceName("") { initMode = 0; }


void PeakHKLErrors::init() {

  declareParameter("SampleXOffset", 0.0, "Sample x offset");

  declareParameter("SampleYOffset", 0.0, "Sample y offset");

  declareParameter("SampleZOffset", 0.0, "Sample z offset");

  declareParameter("GonRotx", 0.0, "3rd Rotation of Goniometer about the x axis");

  declareParameter("GonRoty", 0.0, "2nd Rotation of Goniometer about the y axis");

  declareParameter("GonRotz", 0.0, "1st Rotation of Goniometer about the z axis");

  initMode = 1;

  if (OptRuns.empty())

    return;


  initMode = 2;

  setUpOptRuns();

}


void PeakHKLErrors::setUpOptRuns() {


  std::vector<std::string> OptRunNums;

  std::string OptRunstemp(OptRuns);

  if (!OptRuns.empty() && OptRuns.at(0) == '/')

    OptRunstemp = OptRunstemp.substr(1, OptRunstemp.size() - 1);


  if (!OptRunstemp.empty() && OptRunstemp.at(OptRunstemp.size() - 1) == '/')

    OptRunstemp.pop_back();


  boost::split(OptRunNums, OptRunstemp, boost::is_any_of("/"));


  for (const auto &OptRunNum : OptRunNums) {

    declareParameter("phi" + OptRunNum, 0.0, "Phi sample orientation value");

    declareParameter("chi" + OptRunNum, 0.0, "Chi sample orientation value");

    declareParameter("omega" + OptRunNum, 0.0, "Omega sample orientation value");

  }

}


void PeakHKLErrors::getRun2MatMap(PeaksWorkspace_sptr &Peaks, const std::string &OptRuns,

                                  std::map<int, Mantid::Kernel::Matrix<double>> &Res) const {


  for (int i = 0; i < Peaks->getNumberPeaks(); ++i) {

    const Geometry::IPeak &peak_old = Peaks->getPeak(i);


    int runNum = peak_old.getRunNumber();

    std::string runNumStr = std::to_string(runNum);

    size_t N = OptRuns.find("/" + runNumStr + "/");

    if (N < OptRuns.size()) {

      double chi = getParameter("chi" + boost::lexical_cast<std::string>(runNumStr));

      double phi = getParameter("phi" + boost::lexical_cast<std::string>(runNumStr));

      double omega = getParameter("omega" + boost::lexical_cast<std::string>(runNumStr));

      Mantid::Geometry::Goniometer uniGonio;

      uniGonio.makeUniversalGoniometer();

      uniGonio.setRotationAngle("phi", phi);

      uniGonio.setRotationAngle("chi", chi);

      uniGonio.setRotationAngle("omega", omega);

      Res[runNum] = uniGonio.getR();

    }

  }

}


Matrix<double> PeakHKLErrors::RotationMatrixAboutRegAxis(double theta, char axis) {

  int cint = toupper(axis);

  auto c = static_cast<char>(cint);

  std::string S(std::string("") + c);

  size_t axisPos = std::string("XYZ").find(S);


  if (axisPos > 2) {

    Matrix<double> Res(3, 3, true);


    return Res;

  }

  double rTheta = theta / 180 * M_PI;

  Matrix<double> Res(3, 3);

  Res.zeroMatrix();

  Res[axisPos][axisPos] = 1.0;

  Res[(axisPos + 1) % 3][(axisPos + 1) % 3] = cos(rTheta);

  Res[(axisPos + 1) % 3][(axisPos + 2) % 3] = -sin(rTheta);

  Res[(axisPos + 2) % 3][(axisPos + 2) % 3] = cos(rTheta);

  Res[(axisPos + 2) % 3][(axisPos + 1) % 3] = sin(rTheta);

  return Res;

}


Matrix<double> PeakHKLErrors::DerivRotationMatrixAboutRegAxis(double theta, char axis) {

  int cint = toupper(axis);

  auto c = static_cast<char>(cint);

  std::string S(std::string("") + c);

  size_t axisPos = std::string("XYZ").find(S);


  if (axisPos > 2) {

    Matrix<double> Res(3, 3, true);


    return Res;

  }

  double rTheta = theta / 180 * M_PI;

  Matrix<double> Res(3, 3);

  Res.zeroMatrix();

  Res[axisPos][axisPos] = 0.0;

  Res[(axisPos + 1) % 3][(axisPos + 1) % 3] = -sin(rTheta);

  Res[(axisPos + 1) % 3][(axisPos + 2) % 3] = -cos(rTheta);

  Res[(axisPos + 2) % 3][(axisPos + 2) % 3] = -sin(rTheta);

  Res[(axisPos + 2) % 3][(axisPos + 1) % 3] = cos(rTheta);

  return Res * (M_PI / 180.);

}


void PeakHKLErrors::function1D(double *out, const double *xValues, const size_t nData) const {

  PeaksWorkspace_sptr peaksWs = AnalysisDataService::Instance().retrieveWS<PeaksWorkspace>(PeakWorkspaceName);


  if (!peaksWs)

    throw std::invalid_argument("Peaks not stored under the name " + PeakWorkspaceName);


  V3D const samplePosition = peaksWs->componentInfo().samplePosition();


  std::map<int, Mantid::Kernel::Matrix<double>> RunNum2GonMatrixMap;

  getRun2MatMap(peaksWs, OptRuns, RunNum2GonMatrixMap);

  const DblMatrix &UBx = peaksWs->sample().getOrientedLattice().getUB();


  DblMatrix UBinv(UBx);

  UBinv.Invert();

  UBinv /= (2 * M_PI);


  double GonRotx = getParameter("GonRotx");

  double GonRoty = getParameter("GonRoty");

  double GonRotz = getParameter("GonRotz");

  Matrix<double> GonRot = RotationMatrixAboutRegAxis(GonRotx, 'x') * RotationMatrixAboutRegAxis(GonRoty, 'y') *

                          RotationMatrixAboutRegAxis(GonRotz, 'z');


  double ChiSqTot = 0.0;

  for (size_t i = 0; i < nData; i += 3) {

    int peakNum = boost::math::iround(xValues[i]);

    const Peak &peak_old = peaksWs->getPeak(peakNum);


    int runNum = peak_old.getRunNumber();

    std::string runNumStr = std::to_string(runNum);

    Peak peak = createNewPeak(peak_old, samplePosition, 0, peak_old.getL1());


    size_t N = OptRuns.find("/" + runNumStr + "/");

    if (N < OptRuns.size()) {

      peak.setGoniometerMatrix(GonRot * RunNum2GonMatrixMap[runNum]);


    } else {

      peak.setGoniometerMatrix(GonRot * peak.getGoniometerMatrix());

    }

    V3D sampOffsets(getParameter("SampleXOffset"), getParameter("SampleYOffset"), getParameter("SampleZOffset"));

    peak.setSamplePos(peak.getSamplePos() + sampOffsets);


    V3D hkl = UBinv * peak.getQSampleFrame();


    for (int k = 0; k < 3; k++) {

      double d1 = hkl[k] - floor(hkl[k]);

      if (d1 > .5)

        d1 = d1 - 1;

      if (d1 < -.5)

        d1 = d1 + 1;


      out[i + k] = d1;

      ChiSqTot += d1 * d1;

    }

  }


  g_log.debug() << "------------------------Function---------------------------"

                   "--------------------\n";

  for (size_t p = 0; p < nParams(); p++) {

    g_log.debug() << parameterName(p) << "(" << getParameter(p) << "),";

  }

  g_log.debug() << '\n';

  g_log.debug() << "Off constraints=";

  for (size_t p = 0; p < nParams(); p++) {

    IConstraint *constr = getConstraint(p);

    if (constr)

      if ((constr->check() > 0))

        g_log.debug() << "(" << parameterName(p) << "=" << constr->check() << ");";

  }

  g_log.debug() << '\n';


  g_log.debug() << "    Chi**2 = " << ChiSqTot << "     nData = " << nData << '\n';

}


void PeakHKLErrors::functionDeriv1D(Jacobian *out, const double *xValues, const size_t nData) {

  PeaksWorkspace_sptr peaksWs = AnalysisDataService::Instance().retrieveWS<PeaksWorkspace>(PeakWorkspaceName);


  if (!peaksWs)

    throw std::invalid_argument("Peaks not stored under the name " + PeakWorkspaceName);


  const DblMatrix &UB = peaksWs->sample().getOrientedLattice().getUB();

  DblMatrix UBinv(UB);

  UBinv.Invert();

  UBinv /= 2 * M_PI;


  double GonRotx = getParameter("GonRotx");

  double GonRoty = getParameter("GonRoty");

  double GonRotz = getParameter("GonRotz");

  Matrix<double> InvGonRotxMat = RotationMatrixAboutRegAxis(GonRotx, 'x');

  Matrix<double> InvGonRotyMat = RotationMatrixAboutRegAxis(GonRoty, 'y');

  Matrix<double> InvGonRotzMat = RotationMatrixAboutRegAxis(GonRotz, 'z');

  Matrix<double> GonRot = InvGonRotxMat * InvGonRotyMat * InvGonRotzMat;


  InvGonRotxMat.Invert();

  InvGonRotyMat.Invert();

  InvGonRotzMat.Invert();


  std::map<int, Kernel::Matrix<double>> RunNums2GonMatrix;

  getRun2MatMap(peaksWs, OptRuns, RunNums2GonMatrix);


  g_log.debug() << "----------------------------Derivative------------------------\n";


  auto const &componentInfo = peaksWs->componentInfo();

  V3D const samplePosition = componentInfo.samplePosition();

  const IPeak &ppeak = peaksWs->getPeak(0);

  double L0 = ppeak.getL1();

  double velocity = (L0 + ppeak.getL2()) / ppeak.getTOF();


  double K = 2 * M_PI / ppeak.getWavelength() / velocity; // 2pi/lambda = K* velocity

  V3D const beamDir = normalize(samplePosition - componentInfo.sourcePosition());


  const size_t paramNums[] = {parameterIndex(std::string("SampleXOffset")),

                              parameterIndex(std::string("SampleYOffset")),

                              parameterIndex(std::string("SampleZOffset"))};


  for (size_t i = 0; i < nData; i += 3) {

    int peakNum = boost::math::iround(xValues[i]);

    const Peak &peak_old = peaksWs->getPeak(peakNum);

    Peak peak = createNewPeak(peak_old, samplePosition, 0, peak_old.getL1());


    int runNum = peak_old.getRunNumber();

    std::string runNumStr = std::to_string(runNum);


    for (int kk = 0; kk < static_cast<int>(nParams()); kk++) {

      out->set(i, kk, 0.0);

      out->set(i + 1, kk, 0.0);

      out->set(i + 2, kk, 0.0);

    }


    double chi, phi, omega;

    size_t chiParamNum, phiParamNum, omegaParamNum;


    size_t N = OptRuns.find("/" + runNumStr);

    if (N < OptRuns.size()) {

      chi = getParameter("chi" + (runNumStr));

      phi = getParameter("phi" + (runNumStr));

      omega = getParameter("omega" + (runNumStr));


      peak.setGoniometerMatrix(GonRot * RunNums2GonMatrix[runNum]);


      chiParamNum = parameterIndex("chi" + (runNumStr));

      phiParamNum = parameterIndex("phi" + (runNumStr));

      omegaParamNum = parameterIndex("omega" + (runNumStr));

    } else {


      Geometry::Goniometer Gon(peak.getGoniometerMatrix());

      std::vector<double> phichiOmega = Gon.getEulerAngles("YZY");

      chi = phichiOmega[1];

      phi = phichiOmega[2];

      omega = phichiOmega[0];

      // peak.setGoniometerMatrix( GonRot*Gon.getR());

      chiParamNum = phiParamNum = omegaParamNum = nParams() + 10;

      peak.setGoniometerMatrix(GonRot * peak.getGoniometerMatrix());

    }

    V3D sampOffsets(getParameter("SampleXOffset"), getParameter("SampleYOffset"), getParameter("SampleZOffset"));

    peak.setSamplePos(peak.getSamplePos() + sampOffsets);

    // NOTE:Use getQLabFrame except for below.

    // For parameters the getGoniometerMatrix should remove GonRot, for derivs

    // wrt GonRot*, wrt chi*,phi*,etc.


    // Deriv wrt chi phi and omega

    if (phiParamNum < nParams()) {

      Matrix<double> chiMatrix = RotationMatrixAboutRegAxis(chi, 'z');

      Matrix<double> phiMatrix = RotationMatrixAboutRegAxis(phi, 'y');

      Matrix<double> omegaMatrix = RotationMatrixAboutRegAxis(omega, 'y');


      Matrix<double> dchiMatrix = DerivRotationMatrixAboutRegAxis(chi, 'z');

      Matrix<double> dphiMatrix = DerivRotationMatrixAboutRegAxis(phi, 'y');

      Matrix<double> domegaMatrix = DerivRotationMatrixAboutRegAxis(omega, 'y');


      Matrix<double> InvG = omegaMatrix * chiMatrix * phiMatrix;

      InvG.Invert();

      // Calculate Derivatives wrt chi(phi,omega) in degrees

      Matrix<double> R = omegaMatrix * chiMatrix * dphiMatrix;

      Matrix<double> InvR = InvG * R * InvG * -1;

      V3D lab = peak.getQLabFrame();

      V3D Dhkl0 = UBinv * InvR * lab;


      R = omegaMatrix * dchiMatrix * phiMatrix;

      InvR = InvG * R * InvG * -1;

      V3D Dhkl1 = UBinv * InvR * peak.getQLabFrame();


      R = domegaMatrix * chiMatrix * phiMatrix;

      InvR = InvG * R * InvG * -1;

      V3D Dhkl2 = UBinv * InvR * peak.getQLabFrame(); // R.transpose should be R inverse


      out->set(i, chiParamNum, Dhkl1[0]);

      out->set(i + 1, chiParamNum, Dhkl1[1]);

      out->set(i + 2, chiParamNum, Dhkl1[2]);

      out->set(i, phiParamNum, Dhkl0[0]);

      out->set(i + 1, phiParamNum, Dhkl0[1]);

      out->set(i + 2, phiParamNum, Dhkl0[2]);

      out->set(i, omegaParamNum, Dhkl2[0]);

      out->set(i + 1, omegaParamNum, Dhkl2[1]);

      out->set(i + 2, omegaParamNum, Dhkl2[2]);


    } // if optimize for chi phi and omega on this peak


    //------------------------Goniometer Rotation Derivatives

    //-----------------------

    Matrix<double> InvGonRot(GonRot);

    InvGonRot.Invert();

    Matrix<double> InvGon = InvGonRot * peak.getGoniometerMatrix();

    InvGon.Invert();

    V3D DGonx = (UBinv * InvGon * InvGonRotzMat * InvGonRotyMat *

                 DerivRotationMatrixAboutRegAxis(-GonRotx, 'x') * // - gives inverse of GonRot

                 peak.getQLabFrame()) *

                -1;


    V3D DGony = (UBinv * InvGon * InvGonRotzMat * DerivRotationMatrixAboutRegAxis(-GonRoty, 'y') * InvGonRotxMat *

                 peak.getQLabFrame()) *

                -1;

    V3D DGonz = (UBinv * InvGon * DerivRotationMatrixAboutRegAxis(-GonRotz, 'z') * InvGonRotyMat * InvGonRotxMat *

                 peak.getQLabFrame()) *

                -1;


    size_t paramnum = parameterIndex("GonRotx");

    out->set(i, paramnum, DGonx[0]);

    out->set(i + 1, paramnum, DGonx[1]);

    out->set(i + 2, paramnum, DGonx[2]);

    out->set(i, parameterIndex("GonRoty"), DGony[0]);

    out->set(i + 1, parameterIndex("GonRoty"), DGony[1]);

    out->set(i + 2, parameterIndex("GonRoty"), DGony[2]);

    out->set(i, parameterIndex("GonRotz"), DGonz[0]);

    out->set(i + 1, parameterIndex("GonRotz"), DGonz[1]);

    out->set(i + 2, parameterIndex("GonRotz"), DGonz[2]);

    //-------------------- Sample Orientation derivatives

    //----------------------------------

    // Qlab = -KV + k|V|*beamdir

    // D = pos-sampPos

    //|V|= vmag=(L0 + D )/tof

    // t1= tof - L0/|V|   {time from sample to pixel}

    // V = D/t1

    V3D D = peak.getDetPos() - samplePosition;

    double vmag = (L0 + D.norm()) / peak.getTOF();

    double t1 = peak.getTOF() - L0 / vmag;


    // Derivs wrt sample x, y, z

    // Ddsx =( - 1, 0, 0),  d|D|^2/dsx -> 2|D|d|D|/dsx =d(tranp(D)* D)/dsx =2

    // Ddsx* tranp(D)

    //|D| also called Dmag

    V3D Dmagdsxsysz(D);

    Dmagdsxsysz *= (-1 / D.norm());


    V3D vmagdsxsysz = Dmagdsxsysz / peak.getTOF();


    V3D t1dsxsysz = vmagdsxsysz * (L0 / vmag / vmag);

    Matrix<double> Gon = peak.getGoniometerMatrix();

    Gon.Invert();


    // x=0 is deriv wrt SampleXoffset, x=1 is deriv wrt SampleYoffset, etc.

    for (int x = 0; x < 3; x++) {

      V3D pp;

      pp[x] = 1;

      V3D dQlab1 = pp / -t1 - D * (t1dsxsysz[x] / t1 / t1);

      V3D dQlab2 = beamDir * vmagdsxsysz[x];

      V3D dQlab = dQlab2 - dQlab1;

      dQlab *= K;


      V3D dQSamp = Gon * dQlab;

      V3D dhkl = UBinv * dQSamp;


      out->set(i, paramNums[x], dhkl[0]);

      out->set(i + 1, paramNums[x], dhkl[1]);

      out->set(i + 2, paramNums[x], dhkl[2]);

    }

  }

}


Peak PeakHKLErrors::createNewPeak(DataObjects::Peak const &peak_old, V3D const &samplePos, double T0, double L0) {

  double T = peak_old.getTOF() + T0;


  int ID = peak_old.getDetectorID();


  Kernel::V3D hkl = peak_old.getHKL();

  // peak_old.setDetectorID(ID); //set det positions

  Peak peak(peak_old.getInstrument(), ID, peak_old.getWavelength(), hkl, peak_old.getGoniometerMatrix());

  peak.setSamplePos(samplePos);


  Wavelength wl;


  wl.initialize(L0, 0,

                {{UnitParams::l2, peak.getL2()},

                 {UnitParams::twoTheta, peak.getScattering()},

                 {UnitParams::efixed, peak_old.getInitialEnergy()}});


  peak.setWavelength(wl.singleFromTOF(T));

  peak.setIntensity(peak_old.getIntensity());

  peak.setSigmaIntensity(peak_old.getSigmaIntensity());

  peak.setRunNumber(peak_old.getRunNumber());

  peak.setBinCount(peak_old.getBinCount());


  return peak;

}


} // namespace Mantid::Crystal

AnalysisDataService.h

ComponentInfo.h

FunctionFactory.h

DECLARE_FUNCTION
#define DECLARE_FUNCTION(classname)
Macro for declaring a new type of function to be used with the FunctionFactory.
Definition FunctionFactory.h:151

Goniometer.h

IConstraint.h

IFunction1D.h

IPeak.h

ParamFunction.h

PeakHKLErrors.h

Sample.h

Unit.h

Mantid::API::IConstraint
An interface to a constraint.
Definition IConstraint.h:26

Mantid::API::IConstraint::check
virtual double check()=0
Returns a penalty number which is bigger than or equal to zero If zero it means that the constraint i...

Mantid::API::IFunction1D
This is a specialization of IFunction for functions of one real argument.
Definition IFunction1D.h:42

Mantid::API::IFunction::getConstraint
virtual IConstraint * getConstraint(size_t i) const
Get constraint of i-th parameter.
Definition IFunction.cpp:475

Mantid::API::Jacobian
Represents the Jacobian in IFitFunction::functionDeriv.
Definition Jacobian.h:22

Mantid::API::Jacobian::set
virtual void set(size_t iY, size_t iP, double value)=0
Set a value to a Jacobian matrix element.

Mantid::API::ParamFunction
Implements the part of IFunction interface dealing with parameters.
Definition ParamFunction.h:33

Mantid::API::ParamFunction::parameterIndex
size_t parameterIndex(const std::string &name) const override
Returns the index of parameter name.
Definition ParamFunction.cpp:147

Mantid::API::ParamFunction::parameterName
std::string parameterName(size_t i) const override
Returns the name of parameter i.
Definition ParamFunction.cpp:161

Mantid::API::ParamFunction::declareParameter
void declareParameter(const std::string &name, double initValue=0, const std::string &description="") override
Declare a new parameter.
Definition ParamFunction.cpp:239

Mantid::API::ParamFunction::nParams
size_t nParams() const override
Total number of parameters.
Definition ParamFunction.h:53

Mantid::API::ParamFunction::getParameter
double getParameter(size_t i) const override
Get i-th parameter.
Definition ParamFunction.cpp:62

Mantid::Crystal::PeakHKLErrors
Definition PeakHKLErrors.h:32

Mantid::Crystal::PeakHKLErrors::PeakWorkspaceName
std::string PeakWorkspaceName
Definition PeakHKLErrors.h:130

Mantid::Crystal::PeakHKLErrors::initMode
int initMode
Definition PeakHKLErrors.h:132

Mantid::Crystal::PeakHKLErrors::DerivRotationMatrixAboutRegAxis
static Kernel::Matrix< double > DerivRotationMatrixAboutRegAxis(double theta, char axis)
Returns the derivative of the matrix corresponding to a rotation of theta(degrees) around axis with r...
Definition PeakHKLErrors.cpp:159

Mantid::Crystal::PeakHKLErrors::getRun2MatMap
void getRun2MatMap(DataObjects::PeaksWorkspace_sptr &Peaks, const std::string &OptRuns, std::map< int, Mantid::Kernel::Matrix< double > > &Res) const
Updates the map from run number to GoniometerMatrix.
Definition PeakHKLErrors.cpp:93

Mantid::Crystal::PeakHKLErrors::RotationMatrixAboutRegAxis
static Kernel::Matrix< double > RotationMatrixAboutRegAxis(double theta, char axis)
Returns the matrix corresponding to a rotation of theta(degrees) around axis.
Definition PeakHKLErrors.cpp:126

Mantid::Crystal::PeakHKLErrors::createNewPeak
static DataObjects::Peak createNewPeak(DataObjects::Peak const &peak_old, Kernel::V3D const &samplePos, double T0, double L0)
Creates a new peak, matching the old peak, with its source and detector positions re-read from the ol...
Definition PeakHKLErrors.cpp:461

Mantid::Crystal::PeakHKLErrors::function1D
void function1D(double *out, const double *xValues, const size_t nData) const override
Calculates the h,k, and l offsets from an integer for (some of )the peaks, given the parameter values...
Definition PeakHKLErrors.cpp:193

Mantid::Crystal::PeakHKLErrors::functionDeriv1D
void functionDeriv1D(Mantid::API::Jacobian *out, const double *xValues, const size_t nData) override
Derivatives of function with respect to active parameters.
Definition PeakHKLErrors.cpp:266

Mantid::Crystal::PeakHKLErrors::OptRuns
std::string OptRuns
Definition PeakHKLErrors.h:128

Mantid::Crystal::PeakHKLErrors::init
void init() override
Function initialization. Declare function parameters in this method.
Definition PeakHKLErrors.cpp:45

Mantid::Crystal::PeakHKLErrors::setUpOptRuns
void setUpOptRuns()
Declares parameters for the chi,phi and omega angles for the run numbers where these will be optimize...
Definition PeakHKLErrors.cpp:63

Mantid::DataObjects::BasePeak::setSigmaIntensity
void setSigmaIntensity(double m_sigmaIntensity) override
Set the error on the integrated peak intensity.
Definition BasePeak.cpp:206

Mantid::DataObjects::BasePeak::setRunNumber
void setRunNumber(int m_runNumber) override
Set the run number that measured this peak.
Definition BasePeak.cpp:82

Mantid::DataObjects::BasePeak::getIntensity
double getIntensity() const override
Return the integrated peak intensity.
Definition BasePeak.cpp:185

Mantid::DataObjects::BasePeak::getSamplePos
Mantid::Kernel::V3D getSamplePos() const override
Return the sample position vector.
Definition BasePeak.cpp:156

Mantid::DataObjects::BasePeak::getSigmaIntensity
double getSigmaIntensity() const override
Return the error on the integrated peak intensity.
Definition BasePeak.cpp:188

Mantid::DataObjects::BasePeak::getRunNumber
int getRunNumber() const override
Return the run number this peak was measured at.
Definition BasePeak.cpp:78

Mantid::DataObjects::BasePeak::setIntensity
void setIntensity(double m_intensity) override
Set the integrated peak intensity.
Definition BasePeak.cpp:198

Mantid::DataObjects::BasePeak::getHKL
Mantid::Kernel::V3D getHKL() const override
Return the HKL vector.
Definition BasePeak.cpp:103

Mantid::DataObjects::BasePeak::getBinCount
double getBinCount() const override
Return the # of counts in the bin at its peak.
Definition BasePeak.cpp:182

Mantid::DataObjects::BasePeak::getGoniometerMatrix
Mantid::Kernel::Matrix< double > getGoniometerMatrix() const override
Get the goniometer rotation matrix at which this peak was measured.
Definition BasePeak.cpp:210

Mantid::DataObjects::BasePeak::setSamplePos
void setSamplePos(double samX, double samY, double samZ) override
Set sample position.
Definition BasePeak.cpp:162

Mantid::DataObjects::BasePeak::setGoniometerMatrix
void setGoniometerMatrix(const Mantid::Kernel::Matrix< double > &goniometerMatrix) override
Set the goniometer rotation matrix at which this peak was measured.
Definition BasePeak.cpp:220

Mantid::DataObjects::BasePeak::setBinCount
void setBinCount(double m_binCount) override
Set the # of counts in the bin at its peak.
Definition BasePeak.cpp:202

Mantid::DataObjects::Peak
Structure describing a single-crystal peak.
Definition Peak.h:34

Mantid::DataObjects::Peak::getInstrument
Geometry::Instrument_const_sptr getInstrument() const
Return a shared ptr to the instrument for this peak.
Definition Peak.cpp:344

Mantid::DataObjects::Peak::setWavelength
void setWavelength(double wavelength) override
Set the incident wavelength of the neutron.
Definition Peak.cpp:212

Mantid::DataObjects::Peak::getL1
double getL1() const override
Return the L1 flight path length (source to sample), in meters.
Definition Peak.cpp:748

Mantid::DataObjects::Peak::getInitialEnergy
double getInitialEnergy() const override
Get the initial (incident) neutron energy in meV.
Definition Peak.cpp:729

Mantid::DataObjects::Peak::getQLabFrame
Mantid::Kernel::V3D getQLabFrame() const override
Return the Q change (of the lattice, k_i - k_f) for this peak.
Definition Peak.cpp:475

Mantid::DataObjects::Peak::getDetectorID
int getDetectorID() const override
Get the ID of the detector at the center of the peak
Definition Peak.cpp:289

Mantid::DataObjects::Peak::getWavelength
double getWavelength() const override
Calculate the neutron wavelength (in angstroms) at the peak (Note for inelastic scattering - it is th...
Definition Peak.cpp:382

Mantid::DataObjects::Peak::getTOF
double getTOF() const override
Calculate the time of flight (in microseconds) of the neutrons for this peak, using the geometry of t...
Definition Peak.cpp:397

Mantid::DataObjects::Peak::getDetPos
virtual Mantid::Kernel::V3D getDetPos() const
Return the detector position vector.
Definition Peak.cpp:744

Mantid::DataObjects::Peak::getQSampleFrame
Mantid::Kernel::V3D getQSampleFrame() const override
Return the Q change (of the lattice, k_i - k_f) for this peak.
Definition Peak.cpp:506

Mantid::DataObjects::Peak::getL2
double getL2() const override
Return the L2 flight path length (sample to detector), in meters.
Definition Peak.cpp:752

Mantid::DataObjects::Peak::getScattering
double getScattering() const override
Calculate the scattering angle of the peak
Definition Peak.cpp:415

Mantid::DataObjects::PeaksWorkspace
The class PeaksWorkspace stores information about a set of SCD peaks.
Definition PeaksWorkspace.h:38

Mantid::Geometry::Goniometer
Class to represent a particular goniometer setting, which is described by the rotation matrix.
Definition Goniometer.h:55

Mantid::Geometry::Goniometer::setRotationAngle
void setRotationAngle(const std::string &name, double value)
Set rotation angle for an axis using motor name.
Definition Goniometer.cpp:188

Mantid::Geometry::Goniometer::getEulerAngles
std::vector< double > getEulerAngles(const std::string &convention="YZX")
Return Euler angles acording to a convention.
Definition Goniometer.cpp:309

Mantid::Geometry::Goniometer::makeUniversalGoniometer
void makeUniversalGoniometer()
Make a default universal goniometer with phi,chi,omega angles according to SNS convention.
Definition Goniometer.cpp:298

Mantid::Geometry::Goniometer::getR
const Kernel::DblMatrix & getR() const
Return global rotation matrix.
Definition Goniometer.cpp:107

Mantid::Geometry::IPeak
Structure describing a single-crystal peak.
Definition IPeak.h:26

Mantid::Geometry::IPeak::getTOF
virtual double getTOF() const =0

Mantid::Geometry::IPeak::getWavelength
virtual double getWavelength() const =0

Mantid::Geometry::IPeak::getL2
virtual double getL2() const =0

Mantid::Geometry::IPeak::getRunNumber
virtual int getRunNumber() const =0

Mantid::Geometry::IPeak::getL1
virtual double getL1() const =0

Mantid::Kernel::Logger
The Logger class is in charge of the publishing messages from the framework through various channels.
Definition Logger.h:51

Mantid::Kernel::Logger::debug
void debug(const std::string &msg)
Logs at debug level.
Definition Logger.cpp:145

Mantid::Kernel::Matrix
Numerical Matrix class.
Definition Matrix.h:41

Mantid::Kernel::Matrix::Invert
T Invert()
LU inversion routine.
Definition Matrix.cpp:924

Mantid::Kernel::Matrix::zeroMatrix
void zeroMatrix()
Set the matrix to zero.
Definition Matrix.cpp:646

Mantid::Kernel::Unit::initialize
void initialize(const double &_l1, const int &_emode, const UnitParametersMap &params)
Initialize the unit to perform conversion using singleToTof() and singleFromTof()
Definition Unit.cpp:133

Mantid::Kernel::Units::Wavelength
Wavelength in Angstrom.
Definition Unit.h:305

Mantid::Kernel::Units::Wavelength::singleFromTOF
double singleFromTOF(const double tof) const override
Convert a single tof value to this unit.
Definition Unit.cpp:394

Mantid::Kernel::V3D
Class for 3D vectors.
Definition V3D.h:35

Mantid::Kernel::V3D::norm
double norm() const noexcept
Definition V3D.h:270

Mantid::API
Definition AbsorptionCorrection.h:20

Mantid::API::g_log
Kernel::Logger g_log("ExperimentInfo")
static logger object

Mantid::Crystal
Definition AddPeakHKL.h:13

Mantid::DataObjects
Definition ConjoinWorkspaces.h:17

Mantid::DataObjects::PeaksWorkspace_sptr
std::shared_ptr< PeaksWorkspace > PeaksWorkspace_sptr
Typedef for a shared pointer to a peaks workspace.
Definition SaveIsawPeaks.h:18

Mantid::Geometry::x
I a m x
Definition SpaceGroupFactory.cpp:674

Mantid::Kernel::Units
The namespace for concrete units classes.
Definition IQTransform.h:18

Mantid::Kernel
Definition AnnularRingAbsorption.h:16

Mantid::Kernel::normalize
MANTID_KERNEL_DLL V3D normalize(V3D v)
Normalizes a V3D.
Definition V3D.h:353

std::to_string
std::string to_string(const wide_integer< Bits, Signed > &n)