GravitySANSHelper.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 "MantidAlgorithms/GravitySANSHelper.h"
#include "MantidAPI/SpectrumInfo.h"
#include "MantidKernel/PhysicalConstants.h"
 
#include <cmath>
 
namespace Mantid::Algorithms {
using Kernel::V3D;
 
GravitySANSHelper::GravitySANSHelper(const API::SpectrumInfo &spectrumInfo, const size_t index,
                                     const double extraLength)
    : m_samplePos(spectrumInfo.samplePosition()), m_beamLine(m_samplePos - spectrumInfo.sourcePosition()),
      m_beamLineNorm(2.0 * spectrumInfo.l1()), m_dropPerAngstrom2(-1), m_cachedDrop(0) {
  // this is the LineOfSight assuming no drop, the drop is added (and
  // subtracted) later in the code when required
  m_cachedLineOfSight = spectrumInfo.position(index) - m_samplePos;
  // the drop is proportional to the wave length squared and using this to do
  // the full calculation only once increases the speed a lot
  m_dropPerAngstrom2 = gravitationalDrop(spectrumInfo.l2(index), 1e-10, extraLength);
}
double GravitySANSHelper::calcSinTheta(const double wavAngstroms) const {
  getDetLoc(wavAngstroms);
  return calcSinTheta();
}
double GravitySANSHelper::calcComponents(const double wavAngstroms, double &xFrac, double &yFrac) const {
  const V3D &detPos = getDetLoc(wavAngstroms);
 
  const double phi = atan2(detPos.Y(), detPos.X());
  xFrac = cos(phi);
  yFrac = sin(phi);
  return calcSinTheta();
}
const V3D &GravitySANSHelper::getDetLoc(const double wav) const {
  // Calculate the drop
  const double drop = gravitationalDrop(wav);
  // I'm fairly confident that Y is up! Using the previous drop to allow the
  // same V3D to be modified many times
  m_cachedLineOfSight[1] += drop - m_cachedDrop;
  m_cachedDrop = drop;
  // must return a member variable, not a local!
  return m_cachedLineOfSight;
}
double GravitySANSHelper::calcSinTheta() const {
  // This is 0.5*cos(2theta)
  double halfcosTheta = m_cachedLineOfSight.scalar_prod(m_beamLine) / m_cachedLineOfSight.norm() / m_beamLineNorm;
  // This is sin(theta)
  return sqrt(0.5 - halfcosTheta);
}
 
double GravitySANSHelper::gravitationalDrop(const double l2, const double waveLength, const double extraLength) const {
  using namespace PhysicalConstants;
  static const double gm2_OVER_2h2 = g * NeutronMass * NeutronMass / (2.0 * h * h);
 
  // Perform a path length correction if an Lextra is specified.
  // The correction is Lcorr^2 = (L + Lextra)^2 -(LExtra)^2
  const auto pathLengthWithExtraLength = l2 + extraLength;
  const auto pathLengthSquared = std::pow(pathLengthWithExtraLength, 2) - std::pow(extraLength, 2);
 
  // Want L2 (sample-pixel distance) squared, times the prefactor g^2/h^2
  const double L2 = gm2_OVER_2h2 * pathLengthSquared;
 
  return waveLength * waveLength * L2;
}
} // namespace Mantid::Algorithms