UnitConversion.cpp

#include "MantidKernel/UnitConversion.h"
#include "MantidKernel/Unit.h"
#include "MantidKernel/UnitFactory.h"

#include <boost/lexical_cast.hpp>

#include <cmath>

namespace Mantid
{
  namespace Kernel
  {
    /**
     * Convert a single value between the given units (as strings)
     * @param src :: The starting unit
     * @param dest :: The destination unit
     * @param srcValue :: The value to convert
     *  @param l1 ::       The source-sample distance (in metres)
     *  @param l2 ::       The sample-detector distance (in metres)
     *  @param twoTheta :: The scattering angle (in radians)
     *  @param emode ::    The energy mode enumeration
     *  @param efixed ::   Value of fixed energy: EI (emode=1) or EF (emode=2) (in meV)
     * @return The value converted to the destination unit
     */
    double UnitConversion::run(const std::string & src, const std::string & dest,
                               const double srcValue,
                               const double l1, const double l2,
                               const double twoTheta, const DeltaEMode::Type emode, const double efixed)
    {
      Unit_sptr srcUnit = UnitFactory::Instance().create(src);
      Unit_sptr destUnit = UnitFactory::Instance().create(dest);
      return UnitConversion::run(*srcUnit, *destUnit, srcValue, l1, l2, twoTheta, emode, efixed);
    }

    /**
     * Convert a single value between the given units (overload for Unit objects)
     * @param srcUnit :: The starting unit
     * @param destUnit :: The destination unit
     * @param srcValue :: The value to convert
     * @param l1 ::       The source-sample distance (in metres)
     * @param l2 ::       The sample-detector distance (in metres)
     * @param twoTheta :: The scattering angle (in radians)
     * @param emode ::    The energy mode enumeration
     * @param efixed ::   Value of fixed energy: EI (emode=1) or EF (emode=2) (in meV)
     * @return The value converted to the destination unit
     */
    double UnitConversion::run(Unit & srcUnit, Unit & destUnit,
                               const double srcValue,
                               const double l1, const double l2,
                               const double twoTheta, const DeltaEMode::Type emode, const double efixed)
    {
      double factor(0.0), power(0.0);
      if(srcUnit.quickConversion(destUnit, factor, power))
      {
        return convertQuickly(srcValue, factor, power);
      }
      else
      {
        return convertViaTOF(srcUnit, destUnit, srcValue, l1, l2, twoTheta, emode, efixed);
      }
    }

    /**
     * Convert a single value between the given units (overload for Unit objects)
     * @param twoTheta :: The scattering angle (in radians)
     * @param efixed ::   Value of fixed energy: EI (emode=1) or EF (emode=2) (in meV)
     * @return The value converted to the destination unit
     */
    double UnitConversion::run(const double twoTheta, const double efixed)
    {
      return convertToElasticQ(twoTheta, efixed);
    }


    //---------------------------------------------------------------------------------------------
    // Private methods
    //---------------------------------------------------------------------------------------------

    /**
     * Perform a quick conversion by raising the value to a power & multiplying by the factor
     * @param srcValue :: The value to convert
     * @param factor :: A multiplicative constant
     * @param power :: Raise the src value to this power
     * @return The converted unit
     */
    double UnitConversion::convertQuickly(const double srcValue, const double factor,
                                          const double power)
    {
      return factor *std::pow(srcValue, power);
    }

    /**
     * @param srcUnit :: The starting unit
     * @param destUnit :: The destination unit
     * @param srcValue :: The value to convert
     * @param l1 ::       The source-sample distance (in metres)
     * @param l2 ::       The sample-detector distance (in metres)
     * @param twoTheta :: The scattering angle (in radians)
     * @param emode ::    The energy mode enumeration
     * @param efixed ::   Value of fixed energy: EI (emode=1) or EF (emode=2) (in meV)
     * @return The value converted to the destination unit
     */
    double UnitConversion::convertViaTOF(Unit & srcUnit, Unit & destUnit,
                                         const double srcValue,
                                         const double l1, const double l2,
                                         const double twoTheta, const DeltaEMode::Type emode,
                                         const double efixed)
    {
      // Translate the emode to the int formulation
      int emodeAsInt(0);
      switch(emode)
      {
      case DeltaEMode::Elastic: emodeAsInt = 0;
        break;
      case DeltaEMode::Direct: emodeAsInt = 1;
        break;
      case DeltaEMode::Indirect: emodeAsInt = 2;
        break;
      default: throw std::invalid_argument("UnitConversion::convertViaTOF - Unknown emode " + boost::lexical_cast<std::string>(emode));
      };

      const double unused(0.0);
      const double tof = srcUnit.convertSingleToTOF(srcValue, l1, l2, twoTheta, emodeAsInt, efixed, unused);
      return destUnit.convertSingleFromTOF(tof, l1, l2, twoTheta, emodeAsInt, efixed, unused);
    }

    /**
     *  Convert a to ElasticQ
     *  @param twoTheta :: The scattering angle (in radians)
     *  @param efixed ::   Value of fixed energy: EI (emode=1) or EF (emode=2) (in meV)
     * @return The value converted to ElasticQ
     */
    double UnitConversion::convertToElasticQ(const double twoTheta, const double efixed)
    {

      Mantid::Kernel::Units::Energy energyUnit;
      double wavelengthFactor(0.0), wavelengthPower(0.0);
      energyUnit.quickConversion("Wavelength", wavelengthFactor,wavelengthPower);

      const double stheta = std::sin(twoTheta);
      //Calculate the wavelength to allow it to be used to convert to elasticQ.
      double wavelength = wavelengthFactor*std::pow(efixed, wavelengthPower);
      // The MomentumTransfer value.
      return 4.0*M_PI*stheta/wavelength;
    }


  } // namespace Kernel
} // namespace Mantid