The FixedXraySpectrumModel class is a data model that uses a single well-defined lookup table to sample its values, independent of the energy parameter that has been set to it. More...

#include <xrayspectrummodels.h>

Inheritance diagram for CTL::FixedXraySpectrumModel:

[legend]

Collaboration diagram for CTL::FixedXraySpectrumModel:

[legend]

Public Types
enum	{ Type = 36 }

Public Types inherited from CTL::AbstractDataModel
enum	{ Type = 0 }

Public Types inherited from CTL::SerializationInterface
enum	{ Type = -1, UserType = 65536 }

Public Member Functions
int	type () const override

float	valueAt (float position) const override

float	binIntegral (float position, float binWidth) const override
	Returns the integral over model values in the interval [position - 0.5 * binWidth, position + 0.5 * binWidth]. More...

FixedXraySpectrumModel *	clone () const override

	FixedXraySpectrumModel (const TabulatedDataModel &table)

QVariant	parameter () const override

void	setParameter (const QVariant &parameter) override
	Sets the energy parameter to parameter. More...

TabulatedDataModel &	lookupTable ()
	Returns the integral over model values in the interval [position - 0.5 * binWidth, position + 0.5 * binWidth]. More...

const TabulatedDataModel &	lookupTable () const
	Returns this instance's lookup table.

void	setLookupTable (const TabulatedDataModel &table)
	Sets the lookup table to table. More...

Public Member Functions inherited from CTL::AbstractIntegrableDataModel
float	meanValue (float position, float binWidth) const

Public Member Functions inherited from CTL::AbstractDataModel
void	fromVariant (const QVariant &variant) override

QVariant	toVariant () const override

bool	isIntegrable () const

void	setName (const QString &name)

const QString &	name () const

Public Member Functions inherited from CTL::SerializationInterface
virtual	~SerializationInterface ()=default

Protected Attributes
TabulatedDataModel	_lookupTable
	The spectrum lookup table.

Protected Attributes inherited from CTL::AbstractXraySpectrumModel
float	_energy = 0.0f
	Control parameter of device setting (usually tube voltage).

Friends
template<class >
struct	SerializationHelper::RegisterWithSerializationHelper

Additional Inherited Members
Protected Member Functions inherited from CTL::AbstractIntegrableDataModel
	AbstractIntegrableDataModel (const AbstractIntegrableDataModel &)=default

	AbstractIntegrableDataModel (AbstractIntegrableDataModel &&)=default

AbstractIntegrableDataModel &	operator= (const AbstractIntegrableDataModel &)=default

AbstractIntegrableDataModel &	operator= (AbstractIntegrableDataModel &&)=default

Protected Member Functions inherited from CTL::AbstractDataModel
	AbstractDataModel (const AbstractDataModel &)=default

	AbstractDataModel (AbstractDataModel &&)=default

AbstractDataModel &	operator= (const AbstractDataModel &)=default

AbstractDataModel &	operator= (AbstractDataModel &&)=default

Protected Member Functions inherited from CTL::SerializationInterface
	SerializationInterface ()=default

	SerializationInterface (const SerializationInterface &)=default

	SerializationInterface (SerializationInterface &&)=default

SerializationInterface &	operator= (const SerializationInterface &)=default

SerializationInterface &	operator= (SerializationInterface &&)=default

Related Functions inherited from CTL::AbstractDataModel
	DataModelPtr
	Template alias name for CopyableUniquePtr<ModelType> to a suitable ModelType.

	AbstractDataModelPtr
	Alias name for DataModelPtr<AbstractDataModel>. More...

std::unique_ptr< ModelType >	makeDataModel (ConstructorArguments &&... arguments)

using DataModelPtr	CopyableUniquePtr
	Alias name for CopyableUniquePtr<ModelType> to a suitable ModelType.

Detailed Description

The FixedXraySpectrumModel class is a data model that uses a single well-defined lookup table to sample its values, independent of the energy parameter that has been set to it.

The main use case of this model is introducing a fixed spectrum to the simulation, such as some spectrum pre-generated by an external tool, actual measurement data, or simply to make sure to exactly reproduce some spectrum from another source component without the need to consider its specific parameters.

The lookup table data can be set during construction, using setLookupTable(), or by direct manipulation through lookupTable().

Example 1: populate a TabulatedDataModel with data and use it as lookup table for a FixedXraySpectrumModel

auto table = TabulatedDataModel();
table.insertDataPoint(5.0f, 1.0f);
table.insertDataPoint(10.0f, 3.0f);
table.insertDataPoint(15.0f, 10.0f);
table.insertDataPoint(20.0f, 7.7f);
auto model = FixedXraySpectrumModel(table);
// get individual values (lin. interpolation)
qInfo() << model.valueAt(7.5f);             // output: 2
qInfo() << model.valueAt(14.5f);            // output: 9.3
// get bin integrals (trapezoidal rule)
qInfo() << model.binIntegral(7.5f, 5.0f);   // output: 10
qInfo() << model.binIntegral(10.0f, 20.0f); // output: 89.25
//trying to change energy of 'table'
model.setParameter(13.37f);
// output: "Warning: FixedXraySpectrumModel::setParameter(): Setting energy parameter is not
//          supported in FixedXraySpectrumModel. This call is ignored!"
// output is unchanged:
qInfo() << model.valueAt(7.5f);             // output: 2
qInfo() << model.binIntegral(7.5f, 5.0f);   // output: 10

Example 2: sample a spectrum from an XrayTube instance and use these values as a lookup table for a FixedXraySpectrumModel

// create an XrayTube object, set the tube voltage to 115 kV and sample its spectrum
XrayTube tube;
tube.setTubeVoltage(115.0f);
const auto sampledSpectrum = tube.spectrum(10);     // sample 10 values
// create a TabulatedDataModel with the points of the sampled spectrum
const auto table = TabulatedDataModel(sampledSpectrum);
// create our FixedXraySpectrumModel and directly set its lookup table to 'table'
auto model = FixedXraySpectrumModel(table);
// get some values
qInfo() << model.valueAt(10.0f);    // output: 0.0176055
qInfo() << model.valueAt(20.0f);    // output: 0.0824766
qInfo() << model.valueAt(40.0f);    // output: 0.218841
qInfo() << model.valueAt(90.0f);    // output: 0.0414241
// alternatively, visualize the model (requires 'gui_widgets_charts.pri' module)
gui::plot(model);

Member Function Documentation

◆ binIntegral()

float CTL::FixedXraySpectrumModel::binIntegral	(	float	position,
		float	binWidth
	)		const

overridevirtual

Returns the integral over model values in the interval [position - 0.5 * binWidth, position + 0.5 * binWidth].

If the model output to input parameter \( x \) is given by \( f(x) \), this method computes and returns:

\( \begin{align*} \int_{position-\frac{binWidth}{2}}^{position+\frac{binWidth}{2}} f(x) \,dx \end{align*} \)

Implements CTL::AbstractIntegrableDataModel.

◆ clone()

FixedXraySpectrumModel* CTL::FixedXraySpectrumModel::clone ( ) const

overridevirtual

Creates a copy of this instance and returns a base class pointer to the new object.

Implements CTL::AbstractXraySpectrumModel.

Reimplemented in CTL::TASMIPSpectrumModel.

◆ lookupTable()

TabulatedDataModel & CTL::FixedXraySpectrumModel::lookupTable ( )

Returns the integral over model values in the interval [position - 0.5 * binWidth, position + 0.5 * binWidth].

Returns 1.0 only if the bin contains the current energy parameter of this instance. All other bin integrals are always zero. Let \( E \) be the energy parameter of this instance; then binIntegral() returns:

\( \begin{cases} 1.0 & position - 1/2\cdot binWidth \leq E \leq position + 1/2\cdot binWidth \\ 0.0 & else \end{cases} \)

Example:

    XrayLaserSpectrumModel model;
    model.setParameter(42.0f);
  
    qInfo() << model.binIntegral(40.0f, 6.0f);    // output: 1 [ Note: fully inside ]
    qInfo() << model.binIntegral(40.0f, 4.0f);    // output: 1 [ Note: on border ]
    qInfo() << model.binIntegral(40.0f, 2.0f);    // output: 0 [ Note: outside ]
  /
float XrayLaserSpectrumModel::binIntegral(float position, float binWidth) const
{
    if((_energy >= position - 0.5f * binWidth) && (_energy <= position + 0.5f * binWidth))
        return 1.0f;
    else
        return 0.0f;
}
// use base class documentation
XrayLaserSpectrumModel* XrayLaserSpectrumModel::clone() const
{
    return new XrayLaserSpectrumModel(*this);
}
// _____________________________
// # FixedXraySpectrumModel
// -----------------------------
FixedXraySpectrumModel::FixedXraySpectrumModel()
{
    setName(QStringLiteral("FixedXraySpectrumModel"));
}
FixedXraySpectrumModel::FixedXraySpectrumModel(const TabulatedDataModel& table)
    : FixedXraySpectrumModel()
{
    setLookupTable(table);
}
float FixedXraySpectrumModel::valueAt(float position) const
{
    return _lookupTable.valueAt(position);
}
float FixedXraySpectrumModel::binIntegral(float position, float binWidth) const
{
    return _lookupTable.binIntegral(position, binWidth);
}
// use base class documentation
FixedXraySpectrumModel* FixedXraySpectrumModel::clone() const
{
    return new FixedXraySpectrumModel(*this);
}
// use base class documentation
QVariant FixedXraySpectrumModel::parameter() const
{
    auto ret = AbstractXraySpectrumModel::parameter().toMap();
    ret.insert(QStringLiteral("lookup table"), _lookupTable.toVariant());
    return ret;
}
void FixedXraySpectrumModel::setParameter(const QVariant& parameter)
{
    if(parameter.canConvert(QMetaType::Float))
    {
        qWarning() << "FixedXraySpectrumModel::setParameter(): Setting energy parameter is not "
                      "supported in FixedXraySpectrumModel. This call is ignored!";
        return;
    }
    if(parameter.toMap().value(QStringLiteral("energy"), 0.0f).toFloat() != 0.0f)
    {
        qWarning() << "FixedXraySpectrumModel::setParameter(): Setting energy parameter is not "
                      "supported in FixedXraySpectrumModel. The corresponding entry in the "
                      "parameters is ignored!";
    }
    if(parameter.toMap().contains(QStringLiteral("lookup table")))
    {
        // populate lookup table
        auto lookupTableData = parameter.toMap().value(QStringLiteral("lookup table"));
        TabulatedDataModel table;
        table.fromVariant(lookupTableData);
        setLookupTable(table);
    }
}

◆ parameter()

QVariant CTL::FixedXraySpectrumModel::parameter ( ) const

overridevirtual

Returns the parameters of this instance as a QVariant.

Re-implement this method within your sub-class such that it encapsulates all necessary information into a QVariant.

Best practice is to invoke the base class version of this method to take care of all content originating from underlying base classes.

A typical reimplementation in sub-classes might look like this:

QVariantMap ret = DirectBaseClass::parameter().toMap();
ret.insert("my new parameter", _myNewParameter);
return ret;

Reimplemented from CTL::AbstractXraySpectrumModel.

◆ setLookupTable()

void CTL::FixedXraySpectrumModel::setLookupTable ( const TabulatedDataModel & table )

Sets the lookup table to table.

This replaces the previous lookup table.

◆ setParameter()

void CTL::FixedXraySpectrumModel::setParameter ( const QVariant & parameter )

overridevirtual

Sets the energy parameter to parameter.

parameter can be either a single float (i.e. the energy in keV) or a QVariantMap that contains the key-value-pair ("energy", [float] value_to_set).

Note that, when used within an actual source component (AbstractSource::setSpectrumModel()), you do not need to deal with setting this parameter. This should be done automatically by the specific source component class.

Reimplemented from CTL::AbstractXraySpectrumModel.

Reimplemented in CTL::TASMIPSpectrumModel.