SphericalConverter Class Reference

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

Inheritance diagram for SphericalConverter:

Collaboration diagram for SphericalConverter:

Public Member Functions
	SphericalConverter (const SphericalDetector &detector, const Beam &beam)
	~SphericalConverter () 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
SphericalConverter *	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
	SphericalConverter (const SphericalConverter &other)
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

Detailed Description

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

Definition at line 80 of file SimpleUnitConverters.h.

Constructor & Destructor Documentation

SphericalConverter() [1/2]

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

Definition at line 125 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 ( )

overridedefault

SphericalConverter() [2/2]

SphericalConverter::SphericalConverter ( const SphericalConverter &  other )

private

Definition at line 155 of file SimpleUnitConverters.cpp.

                                                                      : UnitConverterSimple(other)
{
}

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::RectangularConverter(), and SphericalConverter().

Here is the call graph for this function:

availableUnits()

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

overridevirtual

Returns the list of all available units.

Reimplemented from UnitConverterSimple.

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

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 SphericalConverter::calculateValue ( size_t  i_axis, Axes::Units  units_type, double  value  ) const

overrideprivatevirtual

Implements UnitConverterSimple.

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

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()

SphericalConverter * SphericalConverter::clone ( ) const

overridevirtual

Implements IUnitConverter.

Definition at line 138 of file SimpleUnitConverters.cpp.

{
    return new SphericalConverter(*this);
}

References SphericalConverter().

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 > > SphericalConverter::createNameMaps ( ) const

overrideprivatevirtual

Implements IUnitConverter.

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

defaultUnits()

Axes::Units SphericalConverter::defaultUnits ( ) const

overridevirtual

Implements IUnitConverter.

Definition at line 150 of file SimpleUnitConverters.cpp.

{
    return Axes::Units::DEGREES;
}

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.

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(), 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_alpha_i

double UnitConverterSimple::m_alpha_i

protectedinherited

Definition at line 69 of file SimpleUnitConverters.h.

Referenced by calculateValue(), and RectangularConverter::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(), RectangularConverter::calculateValue(), and UnitConverterSimple::dimension().

m_phi_i

double UnitConverterSimple::m_phi_i

protectedinherited

Definition at line 70 of file SimpleUnitConverters.h.

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

m_wavelength

double UnitConverterSimple::m_wavelength

protectedinherited

Definition at line 68 of file SimpleUnitConverters.h.

Referenced by calculateValue(), RectangularConverter::calculateValue(), DepthProbeConverter::calculateValue(), and RectangularConverter::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