RectangularConverter Class Reference

IUnitConverter class that handles the unit translations for rectangular detectors Its default units are mm for both axes. More...

Inheritance diagram for RectangularConverter:

Collaboration diagram for RectangularConverter:

Public Member Functions
	RectangularConverter (const RectangularDetector &detector, const Beam &beam)
	~RectangularConverter () override
std::vector< Axes::Units >	availableUnits () const override
	Returns the list of all available units. More...
std::string	axisName (size_t i_axis, Axes::Units units_type=Axes::Units::DEFAULT) const
size_t	axisSize (size_t i_axis) const override
double	calculateMax (size_t i_axis, Axes::Units units_type) const override
double	calculateMin (size_t i_axis, Axes::Units units_type) const override
RectangularConverter *	clone () const override
std::unique_ptr< IAxis >	createConvertedAxis (size_t i_axis, Axes::Units units) const override
virtual std::unique_ptr< OutputData< double > >	createConvertedData (const OutputData< double > &data, Axes::Units units) const
	Creates OutputData array in converter units. More...
Axes::Units	defaultUnits () const override
virtual size_t	dimension () const override
Axes::Units	substituteDefaultUnits (Axes::Units units) const
virtual void	transferToCPP ()
	Used for Python overriding of clone (see swig/tweaks.py) More...

Protected Member Functions
void	addAxisData (std::string name, double min, double max, Axes::Units default_units, size_t nbins)
void	addDetectorAxis (const IDetector &detector, size_t i_axis)
void	checkIndex (size_t i_axis) const
void	throwUnitsError (std::string method, std::vector< Axes::Units > available) const

Protected Attributes
double	m_alpha_i
std::vector< AxisData >	m_axis_data_table
double	m_phi_i
double	m_wavelength

Private Member Functions
	RectangularConverter (const RectangularConverter &other)
double	axisAngle (size_t i_axis, kvector_t k_f) const
double	calculateValue (size_t i_axis, Axes::Units units_type, double value) const override
std::vector< std::map< Axes::Units, std::string > >	createNameMaps () const override
kvector_t	normalizeToWavelength (kvector_t vector) const

Private Attributes
std::unique_ptr< RectangularPixel >	m_detector_pixel

Detailed Description

IUnitConverter class that handles the unit translations for rectangular detectors Its default units are mm for both axes.

Definition at line 103 of file SimpleUnitConverters.h.

Constructor & Destructor Documentation

RectangularConverter() [1/2]

RectangularConverter::RectangularConverter	(	const RectangularDetector &	detector,
		const Beam &	beam
	)

Definition at line 209 of file SimpleUnitConverters.cpp.

    : UnitConverterSimple(beam)
{
    if (detector.dimension() != 2)
        throw std::runtime_error("Error in RectangularConverter constructor: "
                                 "detector has wrong dimension: "
                                 + std::to_string(static_cast<int>(detector.dimension())));
    addDetectorAxis(detector, 0);
    addDetectorAxis(detector, 1);
    m_detector_pixel.reset(detector.regionOfInterestPixel());
}

References UnitConverterSimple::addDetectorAxis(), IDetector::dimension(), m_detector_pixel, and RectangularDetector::regionOfInterestPixel().

Referenced by clone().

Here is the call graph for this function:

~RectangularConverter()

RectangularConverter::~RectangularConverter ( )

overridedefault

RectangularConverter() [2/2]

RectangularConverter::RectangularConverter ( const RectangularConverter &  other )

private

Definition at line 241 of file SimpleUnitConverters.cpp.

    : UnitConverterSimple(other), m_detector_pixel(other.m_detector_pixel->clone())
{
}

Member Function Documentation

addAxisData()

void UnitConverterSimple::addAxisData ( std::string  name, double  min, double  max, Axes::Units  default_units, size_t  nbins  )

protectedinherited

Definition at line 51 of file SimpleUnitConverters.cpp.

{
    AxisData axis_data{name, min, max, default_units, nbins};
    m_axis_data_table.push_back(axis_data);
}

References UnitConverterSimple::m_axis_data_table, and RealSpace::Particles::name().

Referenced by DepthProbeConverter::DepthProbeConverter(), OffSpecularConverter::OffSpecularConverter(), UnitConverterSimple::addDetectorAxis(), and OffSpecularConverter::addDetectorYAxis().

Here is the call graph for this function:

addDetectorAxis()

void UnitConverterSimple::addDetectorAxis ( const IDetector &  detector, size_t  i_axis  )

protectedinherited

Definition at line 107 of file SimpleUnitConverters.cpp.

{
    const auto& axis = detector.axis(i_axis);
    const auto* p_roi = detector.regionOfInterest();
    const auto& axis_name = axisName(i_axis);
    if (!p_roi) {
        addAxisData(axis_name, axis.lowerBound(), axis.upperBound(), defaultUnits(), axis.size());
        return;
    }
    auto P_roi_axis = p_roi->clipAxisToRoi(i_axis, axis);
    addAxisData(axis_name, P_roi_axis->lowerBound(), P_roi_axis->upperBound(), defaultUnits(),
                P_roi_axis->size());
}

References UnitConverterSimple::addAxisData(), IDetector::axis(), IUnitConverter::axisName(), IUnitConverter::defaultUnits(), and IDetector::regionOfInterest().

Referenced by RectangularConverter(), and SphericalConverter::SphericalConverter().

Here is the call graph for this function:

availableUnits()

std::vector< Axes::Units > RectangularConverter::availableUnits ( ) const

overridevirtual

Returns the list of all available units.

Reimplemented from UnitConverterSimple.

Definition at line 228 of file SimpleUnitConverters.cpp.

{
    auto result = UnitConverterSimple::availableUnits();
    result.push_back(Axes::Units::QSPACE);
    result.push_back(Axes::Units::MM);
    return result;
}

References UnitConverterSimple::availableUnits().

Referenced by calculateValue().

Here is the call graph for this function:

axisAngle()

double RectangularConverter::axisAngle ( size_t  i_axis, kvector_t  k_f  ) const

private

Definition at line 304 of file SimpleUnitConverters.cpp.

{
    if (i_axis == 0)
        return k_f.phi();
    if (i_axis == 1)
        return M_PI_2 - k_f.theta();
    throw std::runtime_error("Error in RectangularConverter::axisAngle: "
                             "incorrect axis index: "
                             + std::to_string(static_cast<int>(i_axis)));
}

References M_PI_2, BasicVector3D< T >::phi(), and BasicVector3D< T >::theta().

Referenced by calculateValue().

Here is the call graph for this function:

axisName()

std::string IUnitConverter::axisName ( size_t  i_axis, Axes::Units  units_type = Axes::Units::DEFAULT  ) const

inherited

Definition at line 20 of file IUnitConverter.cpp.

{
    const auto& name_maps = createNameMaps();
    if (name_maps.size() <= i_axis)
        throw std::runtime_error("Error in IUnitConverter::axisName: the size of name map vector "
                                 "is smaller or equal to the axis index"
                                 + std::to_string(static_cast<int>(i_axis)));
    const auto& name_map = name_maps[i_axis];
    units_type = substituteDefaultUnits(units_type);
    const auto& it = name_map.find(units_type);
    if (it == name_map.cend())
        throwUnitsError("IUnitConverter::axisName", availableUnits());
    return it->second;
}

References IUnitConverter::availableUnits(), IUnitConverter::createNameMaps(), IUnitConverter::substituteDefaultUnits(), and IUnitConverter::throwUnitsError().

Referenced by DepthProbeConverter::DepthProbeConverter(), OffSpecularConverter::OffSpecularConverter(), UnitConverterConvSpec::UnitConverterConvSpec(), UnitConverterSimple::addDetectorAxis(), OffSpecularConverter::addDetectorYAxis(), UnitConverter1D::createConvertedAxis(), and UnitConverterSimple::createConvertedAxis().

Here is the call graph for this function:

axisSize()

size_t UnitConverterSimple::axisSize ( size_t  i_axis ) const

overridevirtualinherited

Implements IUnitConverter.

Definition at line 78 of file SimpleUnitConverters.cpp.

{
    checkIndex(i_axis);
    return m_axis_data_table[i_axis].nbins;
}

References IUnitConverter::checkIndex(), and UnitConverterSimple::m_axis_data_table.

Referenced by UnitConverterSimple::createConvertedAxis().

Here is the call graph for this function:

calculateMax()

double UnitConverterSimple::calculateMax ( size_t  i_axis, Axes::Units  units_type  ) const

overridevirtualinherited

Implements IUnitConverter.

Definition at line 68 of file SimpleUnitConverters.cpp.

{
    checkIndex(i_axis);
    units_type = substituteDefaultUnits(units_type);
    const auto& axis_data = m_axis_data_table[i_axis];
    if (units_type == Axes::Units::NBINS)
        return static_cast<double>(axis_data.nbins);
    return calculateValue(i_axis, units_type, axis_data.max);
}

References UnitConverterSimple::calculateValue(), IUnitConverter::checkIndex(), UnitConverterSimple::m_axis_data_table, and IUnitConverter::substituteDefaultUnits().

Referenced by UnitConverterSimple::createConvertedAxis().

Here is the call graph for this function:

calculateMin()

double UnitConverterSimple::calculateMin ( size_t  i_axis, Axes::Units  units_type  ) const

overridevirtualinherited

Implements IUnitConverter.

Definition at line 58 of file SimpleUnitConverters.cpp.

{
    checkIndex(i_axis);
    units_type = substituteDefaultUnits(units_type);
    const auto& axis_data = m_axis_data_table[i_axis];
    if (units_type == Axes::Units::NBINS)
        return 0.0;
    return calculateValue(i_axis, units_type, axis_data.min);
}

References UnitConverterSimple::calculateValue(), IUnitConverter::checkIndex(), UnitConverterSimple::m_axis_data_table, and IUnitConverter::substituteDefaultUnits().

Referenced by UnitConverterSimple::createConvertedAxis().

Here is the call graph for this function:

calculateValue()

double RectangularConverter::calculateValue ( size_t  i_axis, Axes::Units  units_type, double  value  ) const

overrideprivatevirtual

Implements UnitConverterSimple.

Definition at line 246 of file SimpleUnitConverters.cpp.

{
    if (units_type == Axes::Units::MM)
        return value;
    const auto k00 = m_detector_pixel->getPosition(0.0, 0.0);
    const auto k01 = m_detector_pixel->getPosition(0.0, 1.0);
    const auto k10 = m_detector_pixel->getPosition(1.0, 0.0);
    const auto& max_pos = i_axis == 0 ? k10 : k01; // position of max along given axis
    const double shift = value - m_axis_data_table[i_axis].min;
    const auto k_f = normalizeToWavelength(k00 + shift * (max_pos - k00).unit());
    switch (units_type) {
    case Axes::Units::RADIANS:
        return axisAngle(i_axis, k_f);
    case Axes::Units::DEGREES:
        return Units::rad2deg(axisAngle(i_axis, k_f));
    case Axes::Units::QSPACE: {
        const auto k_i = vecOfLambdaAlphaPhi(m_wavelength, m_alpha_i, m_phi_i);
        if (i_axis == 0)
            return (k_i - k_f).y();
        if (i_axis == 1)
            return (k_f - k_i).z();
        throw std::runtime_error("Error in RectangularConverter::calculateValue: "
                                 "incorrect axis index: "
                                 + std::to_string(static_cast<int>(i_axis)));
    }
    case Axes::Units::QXQY: {
        const auto k_i = vecOfLambdaAlphaPhi(m_wavelength, m_alpha_i, m_phi_i);
        if (i_axis == 0)
            return (k_i - k_f).y();
        if (i_axis == 1)
            return (k_f - k_i).x();
        throw std::runtime_error("Error in RectangularConverter::calculateValue: "
                                 "incorrect axis index: "
                                 + std::to_string(static_cast<int>(i_axis)));
    }
    default:
        throwUnitsError("RectangularConverter::calculateValue", availableUnits());
    }
}

References availableUnits(), axisAngle(), UnitConverterSimple::m_alpha_i, UnitConverterSimple::m_axis_data_table, m_detector_pixel, UnitConverterSimple::m_phi_i, UnitConverterSimple::m_wavelength, normalizeToWavelength(), Units::rad2deg(), IUnitConverter::throwUnitsError(), and vecOfLambdaAlphaPhi().

Here is the call graph for this function:

checkIndex()

void IUnitConverter::checkIndex ( size_t  i_axis ) const

protectedinherited

Definition at line 46 of file IUnitConverter.cpp.

{
    if (i_axis < dimension())
        return;
    throw std::runtime_error("Error in IUnitConverter::checkIndex: passed axis index too big: "
                             + std::to_string(static_cast<int>(i_axis)));
}

References IUnitConverter::dimension().

Referenced by UnitConverterConvSpec::axisSize(), UnitConverterQSpec::axisSize(), UnitConverterSimple::axisSize(), UnitConverter1D::calculateMax(), UnitConverterSimple::calculateMax(), UnitConverter1D::calculateMin(), UnitConverterSimple::calculateMin(), and UnitConverter1D::createConvertedAxis().

Here is the call graph for this function:

clone()

RectangularConverter * RectangularConverter::clone ( ) const

overridevirtual

Implements IUnitConverter.

Definition at line 223 of file SimpleUnitConverters.cpp.

{
    return new RectangularConverter(*this);
}

References RectangularConverter().

Here is the call graph for this function:

createConvertedAxis()

std::unique_ptr< IAxis > UnitConverterSimple::createConvertedAxis ( size_t  i_axis, Axes::Units  units  ) const

overridevirtualinherited

Implements IUnitConverter.

Definition at line 89 of file SimpleUnitConverters.cpp.

{
    const double min = calculateMin(i_axis, units);
    const double max = calculateMax(i_axis, units);
    const auto& axis_name = axisName(i_axis, units);
    const auto axis_size = axisSize(i_axis);
    return std::make_unique<FixedBinAxis>(axis_name, axis_size, min, max);
}

References IUnitConverter::axisName(), UnitConverterSimple::axisSize(), UnitConverterSimple::calculateMax(), and UnitConverterSimple::calculateMin().

Here is the call graph for this function:

createConvertedData()

std::unique_ptr< OutputData< double > > IUnitConverter::createConvertedData ( const OutputData< double > &  data, Axes::Units  units  ) const

virtualinherited

Creates OutputData array in converter units.

Reimplemented in UnitConverter1D.

Definition at line 36 of file IUnitConverter.cpp.

{
    const size_t dim = data.rank();
    std::unique_ptr<OutputData<double>> result(new OutputData<double>);
    for (size_t i = 0; i < dim; ++i)
        result->addAxis(*createConvertedAxis(i, units));
    result->setRawDataVector(data.getRawDataVector());
    return result;
}

References IUnitConverter::createConvertedAxis(), OutputData< T >::getRawDataVector(), and OutputData< T >::rank().

Here is the call graph for this function:

createNameMaps()

std::vector< std::map< Axes::Units, std::string > > RectangularConverter::createNameMaps ( ) const

overrideprivatevirtual

Implements IUnitConverter.

Definition at line 287 of file SimpleUnitConverters.cpp.

{
    std::vector<std::map<Axes::Units, std::string>> result;
    result.push_back(AxisNames::InitRectangularAxis0());
    result.push_back(AxisNames::InitRectangularAxis1());
    return result;
}

References AxisNames::InitRectangularAxis0(), and AxisNames::InitRectangularAxis1().

Here is the call graph for this function:

defaultUnits()

Axes::Units RectangularConverter::defaultUnits ( ) const

overridevirtual

Implements IUnitConverter.

Definition at line 236 of file SimpleUnitConverters.cpp.

{
    return Axes::Units::MM;
}

dimension()

size_t UnitConverterSimple::dimension ( ) const

overridevirtualinherited

Implements IUnitConverter.

Definition at line 46 of file SimpleUnitConverters.cpp.

{
    return m_axis_data_table.size();
}

References UnitConverterSimple::m_axis_data_table.

normalizeToWavelength()

kvector_t RectangularConverter::normalizeToWavelength ( kvector_t  vector ) const

private

Definition at line 295 of file SimpleUnitConverters.cpp.

{
    if (m_wavelength <= 0.0)
        throw std::runtime_error("Error in RectangularConverter::normalizeToWavelength: "
                                 "wavelength <= 0");
    double K = M_TWOPI / m_wavelength;
    return vector.unit() * K;
}

References M_TWOPI, UnitConverterSimple::m_wavelength, and BasicVector3D< T >::unit().

Referenced by calculateValue().

Here is the call graph for this function:

substituteDefaultUnits()

Axes::Units IUnitConverter::substituteDefaultUnits ( Axes::Units  units ) const

inherited

Definition at line 65 of file IUnitConverter.cpp.

{
    return units == Axes::Units::DEFAULT ? defaultUnits() : units;
}

References IUnitConverter::defaultUnits().

Referenced by IUnitConverter::axisName(), UnitConverter1D::calculateMax(), UnitConverterSimple::calculateMax(), UnitConverter1D::calculateMin(), UnitConverterSimple::calculateMin(), and UnitConverter1D::createConvertedAxis().

Here is the call graph for this function:

throwUnitsError()

void IUnitConverter::throwUnitsError ( std::string  method, std::vector< Axes::Units >  available  ) const

protectedinherited

Definition at line 54 of file IUnitConverter.cpp.

{
    std::stringstream ss;
    ss << "Unit type error in " << method
       << ": unknown or unsupported unit type. Available units "
          "are:\n";
    for (auto unit : available)
        ss << axisUnitLabel.at(unit) << "\n";
    throw std::runtime_error(ss.str());
}

References axisUnitLabel.

Referenced by IUnitConverter::axisName(), SphericalConverter::calculateValue(), calculateValue(), OffSpecularConverter::calculateValue(), DepthProbeConverter::checkUnits(), UnitConverterConvSpec::getTraslatorFrom(), UnitConverterConvSpec::getTraslatorTo(), and UnitConverterQSpec::getTraslatorTo().

transferToCPP()

virtual void ICloneable::transferToCPP ( )

inlinevirtualinherited

Used for Python overriding of clone (see swig/tweaks.py)

Definition at line 34 of file ICloneable.h.

Member Data Documentation

m_alpha_i

double UnitConverterSimple::m_alpha_i

protectedinherited

Definition at line 69 of file SimpleUnitConverters.h.

Referenced by SphericalConverter::calculateValue(), and calculateValue().

m_axis_data_table

std::vector<AxisData> UnitConverterSimple::m_axis_data_table

protectedinherited

Definition at line 66 of file SimpleUnitConverters.h.

Referenced by UnitConverterSimple::addAxisData(), UnitConverterSimple::axisSize(), UnitConverterSimple::calculateMax(), UnitConverterSimple::calculateMin(), calculateValue(), and UnitConverterSimple::dimension().

m_detector_pixel

std::unique_ptr<RectangularPixel> RectangularConverter::m_detector_pixel

private

Definition at line 121 of file SimpleUnitConverters.h.

Referenced by RectangularConverter(), and calculateValue().

m_phi_i

double UnitConverterSimple::m_phi_i

protectedinherited

Definition at line 70 of file SimpleUnitConverters.h.

Referenced by SphericalConverter::calculateValue(), and calculateValue().

m_wavelength

double UnitConverterSimple::m_wavelength

protectedinherited

Definition at line 68 of file SimpleUnitConverters.h.

Referenced by SphericalConverter::calculateValue(), calculateValue(), DepthProbeConverter::calculateValue(), and normalizeToWavelength().

---

The documentation for this class was generated from the following files:

• /home/www/ba/Device/Detector/SimpleUnitConverters.h
• /home/www/ba/Device/Detector/SimpleUnitConverters.cpp