SphericalConverter Class Reference

Inheritance diagram for SphericalConverter:

Collaboration diagram for SphericalConverter:

Public Member Functions
	SphericalConverter (const SphericalDetector &detector, const Beam &beam)
	~SphericalConverter () final
SphericalConverter *	clone () const final
std::vector< Axes::Units >	availableUnits () const final
Axes::Units	defaultUnits () const final
virtual size_t	dimension () const final
double	calculateMin (size_t i_axis, Axes::Units units_type) const final
double	calculateMax (size_t i_axis, Axes::Units units_type) const final
size_t	axisSize (size_t i_axis) const final
std::unique_ptr< IAxis >	createConvertedAxis (size_t i_axis, Axes::Units units) const final
std::string	axisName (size_t i_axis, Axes::Units units_type=Axes::Units::DEFAULT) const
Axes::Units	substituteDefaultUnits (Axes::Units units) const
virtual std::unique_ptr< OutputData< double > >	createConvertedData (const OutputData< double > &data, Axes::Units units) const
virtual void	transferToCPP ()

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

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

Private Member Functions
	SphericalConverter (const SphericalConverter &other)
double	calculateValue (size_t i_axis, Axes::Units units_type, double value) const final
std::vector< std::map< Axes::Units, std::string > >	createNameMaps () const final

Detailed Description

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

Definition at line 76 of file SimpleUnitConverters.h.

Constructor & Destructor Documentation

SphericalConverter() [1/2]

SphericalConverter::SphericalConverter	(	const SphericalDetector &	detector,
		const Beam &	beam
	)

Definition at line 118 of file SimpleUnitConverters.cpp.

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

References UnitConverterSimple::addDetectorAxis(), and IDetector::dimension().

Referenced by clone().

Here is the call graph for this function:

~SphericalConverter()

SphericalConverter::~SphericalConverter ( )

finaldefault

SphericalConverter() [2/2]

SphericalConverter::SphericalConverter ( const SphericalConverter &  other )

private

Definition at line 148 of file SimpleUnitConverters.cpp.

                                                                      : UnitConverterSimple(other)
{
}

Member Function Documentation

clone()

SphericalConverter * SphericalConverter::clone ( ) const

finalvirtual

Implements IUnitConverter.

Definition at line 131 of file SimpleUnitConverters.cpp.

{
    return new SphericalConverter(*this);
}

References SphericalConverter().

Here is the call graph for this function:

availableUnits()

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

finalvirtual

Returns the list of all available units.

Reimplemented from UnitConverterSimple.

Definition at line 136 of file SimpleUnitConverters.cpp.

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

References UnitConverterSimple::availableUnits().

Referenced by calculateValue().

Here is the call graph for this function:

defaultUnits()

Axes::Units SphericalConverter::defaultUnits ( ) const

finalvirtual

Implements IUnitConverter.

Definition at line 143 of file SimpleUnitConverters.cpp.

{
    return Axes::Units::DEGREES;
}

calculateValue()

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

finalprivatevirtual

Implements UnitConverterSimple.

Definition at line 152 of file SimpleUnitConverters.cpp.

{
    switch (units_type) {
    case Axes::Units::RADIANS:
        return value;
    case Axes::Units::DEGREES:
        return Units::rad2deg(value);
    case Axes::Units::QSPACE: {
        const auto k_i = vecOfLambdaAlphaPhi(m_wavelength, m_alpha_i, m_phi_i);
        if (i_axis == 0) {
            const auto k_f = vecOfLambdaAlphaPhi(m_wavelength, 0.0, value);
            return (k_i - k_f).y();
        } else if (i_axis == 1) {
            const auto k_f = vecOfLambdaAlphaPhi(m_wavelength, value, 0.0);
            return (k_f - k_i).z();
        }
        throw std::runtime_error("Error in SphericalConverter::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) {
            const auto k_f = vecOfLambdaAlphaPhi(m_wavelength, 0.0, value);
            return (k_i - k_f).y();
        } else if (i_axis == 1) {
            const auto k_f = vecOfLambdaAlphaPhi(m_wavelength, value, 0.0);
            return (k_f - k_i).x();
        }
        throw std::runtime_error("Error in SphericalConverter::calculateValue: "
                                 "incorrect axis index: "
                                 + std::to_string(static_cast<int>(i_axis)));
    }
    default:
        throwUnitsError("SphericalConverter::calculateValue", availableUnits());
    }
}

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

Here is the call graph for this function:

createNameMaps()

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

finalprivatevirtual

Implements IUnitConverter.

Definition at line 190 of file SimpleUnitConverters.cpp.

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

References AxisNames::InitSphericalAxis0(), and AxisNames::InitSphericalAxis1().

Here is the call graph for this function:

dimension()

size_t UnitConverterSimple::dimension ( ) const

finalvirtualinherited

Implements IUnitConverter.

Definition at line 41 of file SimpleUnitConverters.cpp.

{
    return m_axis_data_table.size();
}

References UnitConverterSimple::m_axis_data_table.

calculateMin()

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

finalvirtualinherited

Implements IUnitConverter.

Definition at line 53 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:

calculateMax()

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

finalvirtualinherited

Implements IUnitConverter.

Definition at line 64 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:

axisSize()

size_t UnitConverterSimple::axisSize ( size_t  i_axis ) const

finalvirtualinherited

Implements IUnitConverter.

Definition at line 75 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:

createConvertedAxis()

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

finalvirtualinherited

Implements IUnitConverter.

Definition at line 86 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:

addDetectorAxis()

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

protectedinherited

Definition at line 102 of file SimpleUnitConverters.cpp.

{
    const auto& axis = detector.getAxis(i_axis);
    const auto* p_roi = detector.regionOfInterest();
    const auto& axis_name = axisName(i_axis);
    if (p_roi) {
        auto P_roi_axis = p_roi->clipAxisToRoi(i_axis, axis);
        addAxisData(axis_name, P_roi_axis->getMin(), P_roi_axis->getMax(), defaultUnits(),
                    P_roi_axis->size());
    } else {
        addAxisData(axis_name, axis.getMin(), axis.getMax(), defaultUnits(), axis.size());
    }
}

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

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

Here is the call graph for this function:

addAxisData()

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

protectedinherited

Definition at line 46 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.

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

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 UnitConverterSimple::addDetectorAxis(), OffSpecularConverter::addDetectorYAxis(), UnitConverterSimple::createConvertedAxis(), UnitConverter1D::createConvertedAxis(), DepthProbeConverter::DepthProbeConverter(), OffSpecularConverter::OffSpecularConverter(), and UnitConverterConvSpec::UnitConverterConvSpec().

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(), UnitConverterSimple::calculateMax(), UnitConverter1D::calculateMax(), UnitConverterSimple::calculateMin(), UnitConverter1D::calculateMin(), and UnitConverter1D::createConvertedAxis().

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.getRank();
    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 >::getRank(), and OutputData< T >::getRawDataVector().

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 UnitConverterSimple::axisSize(), UnitConverterConvSpec::axisSize(), UnitConverterQSpec::axisSize(), UnitConverterSimple::calculateMax(), UnitConverter1D::calculateMax(), UnitConverterSimple::calculateMin(), UnitConverter1D::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 << axisUnitName.at(unit) << "\n";
    throw std::runtime_error(ss.str());
}

References axisUnitName.

Referenced by IUnitConverter::axisName(), calculateValue(), RectangularConverter::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_axis_data_table

std::vector<AxisData> UnitConverterSimple::m_axis_data_table

protectedinherited

Definition at line 62 of file SimpleUnitConverters.h.

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

m_wavelength

double UnitConverterSimple::m_wavelength

protectedinherited

Definition at line 64 of file SimpleUnitConverters.h.

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

m_alpha_i

double UnitConverterSimple::m_alpha_i

protectedinherited

Definition at line 65 of file SimpleUnitConverters.h.

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

m_phi_i

double UnitConverterSimple::m_phi_i

protectedinherited

Definition at line 66 of file SimpleUnitConverters.h.

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

---

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