CTL::SaturatedLinearModel Class Reference

The SaturatedLinearModel is a data model to map values according to a linear central segment that connects two constant regimes (saturation). More...

#include <datamodels1d.h>

Inheritance diagram for CTL::SaturatedLinearModel:

Collaboration diagram for CTL::SaturatedLinearModel:

Public Types
enum	{ Type = 10 }
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
	Returns the value from the model at position. More...
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...
AbstractIntegrableDataModel *	clone () const override
	SaturatedLinearModel (float lowerCap=0.0f, float upperCap=FLT_MAX)
QVariant	parameter () const override
void	setParameter (const QVariant &parameter) override
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

Private Member Functions
void	setParFromList (const QVariantList &list)
void	setParFromMap (const QVariantMap &map)

Private Attributes
float	_a = 0.0f
	lower saturation level
float	_b = FLT_MAX
	upper saturation level

Friends
template<class >
struct	SerializationHelper::RegisterWithSerializationHelper

Related Functions
(Note that these are not member functions.)
	DetectorSaturationLinearModel
	Alias for SaturatedLinearModel used here to map true (or expected) values to actually measured values.
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.

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

Detailed Description

The SaturatedLinearModel is a data model to map values according to a linear central segment that connects two constant regimes (saturation).

The model is defined by two parameters:

• lower saturation level \( a \)
• upper saturation level \( b \)

This is illustrated in the following figure.

Illustration of a SaturatedLinearModel with parameters (2, 8)

See also

DetectorSaturationLinearModel

Constructor & Destructor Documentation

SaturatedLinearModel()

CTL::SaturatedLinearModel::SaturatedLinearModel ( float  lowerCap = 0.0f, float  upperCap = FLT_MAX  )

explicit

Constructs a SaturatedLinearModel with (lower/upper) saturation levels at lowerCap and upperCap.

Member Function Documentation

binIntegral()

float CTL::SaturatedLinearModel::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()

AbstractIntegrableDataModel * CTL::SaturatedLinearModel::clone ( ) const

overridevirtual

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

Implements CTL::AbstractIntegrableDataModel.

parameter()

QVariant CTL::SaturatedLinearModel::parameter ( ) const

overridevirtual

Returns the parameters of this instance as QVariant.

This returns a QVariantMap with two key-value-pairs: ("a",a), ("b",b), where a and b denote the lower and upper saturation level, respectively.

Reimplemented from CTL::AbstractDataModel.

setParameter()

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

overridevirtual

Sets the parameters of this instance based on the passed QVariant parameter.

Parameters can be passed by either of the following two options:

1. As a QVariantMap with two key-value-pairs: ("a", a), ("b", b). In this case, a and b denote the lower and upper saturation level.
2. As a QVariantList: In this case, the list must contain two floating point values sorted in the following order: a, b.

Example:

SaturatedLinearModel linearModel;
// option 1
QVariantMap parameterMap;
parameterMap.insert("a", 1.0f);
parameterMap.insert("b", 5.0f);
linearModel.setParameter(parameterMap);

// option 1 - alternative way
linearModel.setParameter(QVariantMap{ {"a", 1.0f},
                                      {"b", 5.0f} });

// option 2
linearModel.setParameter(QVariantList{1.0f, 5.0f});

Reimplemented from CTL::AbstractDataModel.

setParFromList()

void CTL::SaturatedLinearModel::setParFromList ( const QVariantList &  list )

private

Helper method for setParameter().

setParFromMap()

void CTL::SaturatedLinearModel::setParFromMap ( const QVariantMap &  map )

private

Helper method for setParameter().

type()

int CTL::SaturatedLinearModel::type ( ) const

inlineoverridevirtual

Returns the type id of this instance.

Reimplemented from CTL::AbstractDataModel.

valueAt()

float CTL::SaturatedLinearModel::valueAt ( float  position ) const

overridevirtual

Returns the value from the model at position.

The resulting value is described by the follwoing relation: \( f(x)=\begin{cases} a & x<a\\ x & a\leq x\leq b\\ b & x>b \end{cases} \)

Implements CTL::AbstractDataModel.

---

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

• modules/src/models/datamodels1d.h
• modules/src/models/datamodels1d.cpp