VesuvioCalculateMS.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2014 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
//-----------------------------------------------------------------------------
// Includes
//-----------------------------------------------------------------------------
#include "MantidAPI/Algorithm.h"
#include "MantidCurveFitting/DllConfig.h"
#include "MantidCurveFitting/MSVesuvioHelpers.h"
#include "MantidGeometry/Instrument/ReferenceFrame.h"
#include "MantidKernel/V3D.h"
 
namespace Mantid {
 
namespace API {
class ISpectrum;
}
 
namespace Geometry {
class IObject;
}
 
namespace CurveFitting {
namespace Functions {
struct ResolutionParams;
}
 
namespace Algorithms {
struct DetectorParams;
 
class MANTID_CURVEFITTING_DLL VesuvioCalculateMS final : public API::Algorithm {
private:
  // Holds date on the compton scattering properties of an atom
  struct ComptonNeutronAtom {
    ComptonNeutronAtom() : mass(-1.0), sclength(-1.0), profile(-1.0) {}
    double mass;     // in amu
    double sclength; // 4pi/xsec
    double profile;  // s.d of J(y)
  };
  // Holds data about sample as a whole.
  struct SampleComptonProperties {
    SampleComptonProperties(const int nprops) : atoms(nprops), density(-1.0), totalxsec(-1.0), mu(-1.0) {}
 
    std::vector<ComptonNeutronAtom> atoms;
    double density;   // g/cm^3
    double totalxsec; // total free-scattering cross section
    double mu;        // attenuation factor (1/m)
  };
 
public:
  VesuvioCalculateMS();
  const std::string name() const override { return "VesuvioCalculateMS"; }
  int version() const override { return 1; }
  const std::string category() const override { return "CorrectionFunctions\\SpecialCorrections"; }
  const std::string summary() const override {
    return "Calculates the contributions of multiple scattering "
           "on a flat plate sample for VESUVIO";
  }
 
  const std::vector<std::string> seeAlso() const override {
    return {"MayersSampleCorrection", "MonteCarloAbsorption", "CarpenterSampleCorrection"};
  }
 
private:
  void init() override;
  void exec() override;
 
  void cacheInputs();
 
  void calculateMS(CurveFitting::MSVesuvioHelper::RandomVariateGenerator &rng, const size_t wsIndex,
                   API::ISpectrum &totalsc, API::ISpectrum &multsc) const;
  void simulate(CurveFitting::MSVesuvioHelper::RandomVariateGenerator &rng, const DetectorParams &detpar,
                const Functions::ResolutionParams &respar, MSVesuvioHelper::Simulation &simulCounts) const;
  void assignToOutput(const MSVesuvioHelper::SimulationWithErrors &avgCounts, API::ISpectrum &totalsc,
                      API::ISpectrum &multsc) const;
  double calculateCounts(CurveFitting::MSVesuvioHelper::RandomVariateGenerator &rng, const DetectorParams &detpar,
                         const Functions::ResolutionParams &respar, MSVesuvioHelper::Simulation &simulation) const;
 
  // single-event helpers
  Kernel::V3D generateSrcPos(CurveFitting::MSVesuvioHelper::RandomVariateGenerator &rng, const double l1) const;
  double generateE0(CurveFitting::MSVesuvioHelper::RandomVariateGenerator &rng, const double l1, const double t2,
                    double &weight) const;
  double generateTOF(CurveFitting::MSVesuvioHelper::RandomVariateGenerator &rng, const double en0, const double dtof,
                     const double dl1) const;
 
  bool generateScatter(CurveFitting::MSVesuvioHelper::RandomVariateGenerator &rng, const Kernel::V3D &startPos,
                       const Kernel::V3D &direc, double &weight, Kernel::V3D &scatterPt) const;
  std::pair<double, double> calculateE1Range(const double theta, const double en0) const;
  double partialDiffXSec(const double en0, const double en1, const double theta) const;
  Kernel::V3D generateDetectorPos(CurveFitting::MSVesuvioHelper::RandomVariateGenerator &rng,
                                  const Kernel::V3D &nominalPos, const double energy, const Kernel::V3D &scatterPt,
                                  const Kernel::V3D &direcBeforeSc, double &scang, double &distToExit) const;
  double generateE1(CurveFitting::MSVesuvioHelper::RandomVariateGenerator &rng, const double angle, const double e1nom,
                    const double e1res) const;
 
  // Member Variables
  size_t m_acrossIdx, m_upIdx, m_beamIdx;                          // indices of each direction
  Kernel::V3D m_beamDir;                                           // Directional vector for beam
  double m_srcR2;                                                  // beam penumbra radius (m)
  double m_halfSampleHeight, m_halfSampleWidth, m_halfSampleThick; // (m)
  Geometry::IObject const *m_sampleShape;                          // sample shape
  std::unique_ptr<SampleComptonProperties> m_sampleProps;          // description of sample properties
  double m_detHeight, m_detWidth, m_detThick;                      // (m)
  double m_tmin, m_tmax, m_delt;                                   // min, max & dt TOF value
  double m_foilRes;                                                // resolution in energy of foil
 
  size_t m_nscatters; // highest order of scattering to generate
  size_t m_nruns;     // number of runs per spectrum
  size_t m_nevents;   // number of single events per run
 
  std::unique_ptr<API::Progress> m_progress;
  API::MatrixWorkspace_sptr m_inputWS;
};
 
} // namespace Algorithms
} // namespace CurveFitting
} // namespace Mantid