abstractsource.h

Go to the documentation of this file.

#ifndef CTL_ABSTRACTSOURCE_H
#define CTL_ABSTRACTSOURCE_H
#include "mat/matrix_types.h"
#include "models/intervaldataseries.h"
#include "models/abstractxrayspectrummodel.h"
#include "systemcomponent.h"
#include <QJsonArray>
#include <QSizeF>

/*
 * NOTE: This is header only.
 */

namespace CTL {

class GenericSource;

typedef Range<float> EnergyRange;

class AbstractSource : public SystemComponent
{
    CTL_TYPE_ID(300)
    DECLARE_ELEMENTAL_TYPE

public:
    static const uint DEFAULT_SPECTRUM_RESOLUTION_HINT = 10;

    // abstract interface
    public:virtual EnergyRange nominalEnergyRange() const = 0;
    protected:virtual double nominalPhotonFlux() const = 0;

public:
    // virtual methods  
    virtual IntervalDataSeries spectrum(uint nbSamples) const;
    virtual uint spectrumDiscretizationHint() const;
    virtual void setSpectrumModel(AbstractXraySpectrumModel* model);
    QString info() const override;
    void fromVariant(const QVariant& variant) override; // de-serialization
    QVariant toVariant() const override; // serialization

    // getter methods
    EnergyRange energyRange() const;
    float meanEnergy() const;
    double photonFlux() const;
    double fluxModifier() const;
    const QSizeF& focalSpotSize() const;
    const Vector3x1& focalSpotPosition() const;
    const AbstractXraySpectrumModel* spectrumModel() const;

    // setter methods
    void setFluxModifier(double modifier);
    void setFocalSpotSize(const QSizeF& size);
    void setFocalSpotSize(double width, double height); // convenience alternative
    void setFocalSpotPosition(const Vector3x1& position);
    void setFocalSpotPosition(double x, double y, double z); // convenience alternative
    void setEnergyRangeRestriction(const EnergyRange& window);

    // other methods
    IntervalDataSeries spectrum(EnergyRange range, uint nbSamples) const;
    bool hasSpectrumModel() const;
    void setSpectrumModel(std::unique_ptr<AbstractXraySpectrumModel> model);

    // converter
    std::unique_ptr<GenericSource> toGeneric() const;

    ~AbstractSource() override = default;

protected:
    AbstractSource() = default;
    AbstractSource(const QString& name);
    AbstractSource(const QSizeF& focalSpotSize, const QString& name);
    AbstractSource(const QSizeF& focalSpotSize,
                   const Vector3x1& focalSpotPosition,
                   const QString& name);
    AbstractSource(const QSizeF& focalSpotSize,
                   const Vector3x1& focalSpotPosition,
                   AbstractXraySpectrumModel* spectumModel,
                   const QString& name);

    AbstractSource(const AbstractSource&) = default;
    AbstractSource(AbstractSource&&) = default;
    AbstractSource& operator=(const AbstractSource&) = default;
    AbstractSource& operator=(AbstractSource&&) = default;

    QSizeF _focalSpotSize = QSizeF(0.0, 0.0); 
    Vector3x1 _focalSpotPosition = Vector3x1(0.0); 
    double _fluxModifier = 1.0; 

    DataModelPtr<AbstractXraySpectrumModel> _spectrumModel; 
    EnergyRange _restrictedEnergyWindow = { 0.0f, 0.0f }; 
    bool _hasRestrictedEnergyWindow = false;
};

inline AbstractSource::AbstractSource(const QString& name)
    : SystemComponent(name)
{
}

inline AbstractSource::AbstractSource(const QSizeF& focalSpotSize, const QString& name)
    : SystemComponent(name)
    , _focalSpotSize(focalSpotSize)
{
}

inline AbstractSource::AbstractSource(const QSizeF& focalSpotSize,
                                      const Vector3x1& focalSpotPosition,
                                      const QString& name)
    : SystemComponent(name)
    , _focalSpotSize(focalSpotSize)
    , _focalSpotPosition(focalSpotPosition)
{
}

inline AbstractSource::AbstractSource(const QSizeF& focalSpotSize,
                                      const Vector3x1& focalSpotPosition,
                                      AbstractXraySpectrumModel* spectumModel,
                                      const QString& name)
    : SystemComponent(name)
    , _focalSpotSize(focalSpotSize)
    , _focalSpotPosition(focalSpotPosition)
    , _spectrumModel(spectumModel)
{
}


inline IntervalDataSeries AbstractSource::spectrum(uint nbSamples) const
{
    if(!hasSpectrumModel())
        throw std::runtime_error("No spectrum model set.");

    const auto eRange = energyRange();
    auto spec = IntervalDataSeries::sampledFromModel(*_spectrumModel,
                                                     eRange.start(), eRange.end(), nbSamples);

    // normalization not well-defined on spectra with an integral of zero -> skip
    /* Notes:
     * This happens when energy range restiction is outside nominal energy range. The bin value of
     * that spectrum sample will be zero, which guarantees that if it is used somewhere, it is clear
     * that no radiation is emitted (because energy range restriction outside operation range of the
     * source).
     */
    if(!qFuzzyIsNull(spec.integral()))
        spec.normalizeByIntegral();

    return spec;
}


inline IntervalDataSeries AbstractSource::spectrum(EnergyRange range, uint nbSamples) const
{
    if(!hasSpectrumModel())
        throw std::runtime_error("No spectrum model set.");

    auto spec = IntervalDataSeries::sampledFromModel(*_spectrumModel,
                                                     range.start(), range.end(), nbSamples);
    const auto eRange = energyRange();
    spec.clampToRange({ eRange.start(), eRange.end() });

    // normalization not well-defined on spectra with an integral of zero -> skip
    if(!qFuzzyIsNull(spec.integral()))
        spec.normalizeByIntegral();

    return spec;
}

inline uint AbstractSource::spectrumDiscretizationHint() const
{
    return DEFAULT_SPECTRUM_RESOLUTION_HINT;
}

inline const QSizeF& AbstractSource::focalSpotSize() const { return _focalSpotSize; }

inline const Vector3x1& AbstractSource::focalSpotPosition() const { return _focalSpotPosition; }

inline const AbstractXraySpectrumModel* AbstractSource::spectrumModel() const
{
    return _spectrumModel.get();
}

inline void AbstractSource::setFocalSpotSize(const QSizeF& size) { _focalSpotSize = size; }

inline void AbstractSource::setFocalSpotSize(double width, double height)
{
    _focalSpotSize = QSizeF(width, height);
}

inline void AbstractSource::setFocalSpotPosition(const Vector3x1& position)
{
    _focalSpotPosition = position;
}

inline void AbstractSource::setFocalSpotPosition(double x, double y, double z)
{
    _focalSpotPosition = Vector3x1({ x, y, z });
}

inline void AbstractSource::setEnergyRangeRestriction(const EnergyRange& window)
{
    _restrictedEnergyWindow = window;
    _hasRestrictedEnergyWindow = true;
}

inline bool AbstractSource::hasSpectrumModel() const { return static_cast<bool>(_spectrumModel); }

inline QString AbstractSource::info() const
{
    QString ret(SystemComponent::info());

    ret += typeInfoString(typeid(this))
        + "\tEnergy range: [" + QString::number(energyRange().start()) + "," +
            QString::number(energyRange().end()) + "] keV\n"
        + "\tNominal photon flux: " + QString::number(nominalPhotonFlux())
            + "photons / cm^2 @ 1m\n"
        + "\tFlux modifier: "
        + QString::number(_fluxModifier) + "\n";
        + "\tFocal spot size: " + QString::number(_focalSpotSize.width()) + " mm x "
        + QString::number(_focalSpotSize.height())
        + " mm\n"
          "\tFocal spot position: "
        + QString::number(_focalSpotPosition(0, 0)) + " mm, "
        + QString::number(_focalSpotPosition(1, 0)) + " mm, "
        + QString::number(_focalSpotPosition(2, 0)) + " mm\n";

    ret += (this->type() == AbstractSource::Type) ? QLatin1String("}\n") : QLatin1String("");

    return ret;
}

inline void AbstractSource::setSpectrumModel(AbstractXraySpectrumModel* model)
{
    _spectrumModel.reset(model);
}

inline void AbstractSource::setSpectrumModel(std::unique_ptr<AbstractXraySpectrumModel> model)
{
    _spectrumModel = std::move(model);
}

// Use SerializationInterface::fromVariant() documentation.
inline void AbstractSource::fromVariant(const QVariant& variant)
{
    SystemComponent::fromVariant(variant);

    QVariantMap varMap = variant.toMap();
    auto fsPos = varMap.value(QStringLiteral("focal spot position"), QVariantList{0.0, 0.0, 0.0}).toList();
    Vector3x1 fsPosVec({ fsPos.at(0).toDouble(), fsPos.at(1).toDouble(), fsPos.at(2).toDouble() });

    auto fsSize = varMap.value(QStringLiteral("focal spot size")).toMap();
    QSizeF fsQSize;
    fsQSize.setWidth(fsSize.value(QStringLiteral("width")).toDouble());
    fsQSize.setHeight(fsSize.value(QStringLiteral("height")).toDouble());

    QVariant specMod = varMap.value(QStringLiteral("spectrum model"));

    _focalSpotSize = fsQSize;
    _focalSpotPosition = fsPosVec;
    _spectrumModel.reset(static_cast<AbstractXraySpectrumModel*>(
                             SerializationHelper::parseDataModel(specMod)));
}

// Use SerializationInterface::toVariant() documentation.
inline QVariant AbstractSource::toVariant() const
{
    QVariantMap ret = SystemComponent::toVariant().toMap();

    QVariantList fsPos;
    fsPos.append(_focalSpotPosition.get<0>());
    fsPos.append(_focalSpotPosition.get<1>());
    fsPos.append(_focalSpotPosition.get<2>());

    QVariantMap fsSize;
    fsSize.insert(QStringLiteral("width"), _focalSpotSize.width());
    fsSize.insert(QStringLiteral("height"), _focalSpotSize.height());

    QVariant specMod = _spectrumModel ? _spectrumModel->toVariant() : QVariant();

    ret.insert(QStringLiteral("focal spot position"), fsPos);
    ret.insert(QStringLiteral("focal spot size"), fsSize);
    ret.insert(QStringLiteral("spectrum model"), specMod);

    return ret;
}

inline EnergyRange AbstractSource::energyRange() const
{
    const auto clamp = [] (float val, float low, float high)
    {
        return (val<low) ? low : ((val>high) ? high : val);
    };

    const auto nomRange = nominalEnergyRange();
    if(!_hasRestrictedEnergyWindow)
        return nomRange;

    return { clamp(_restrictedEnergyWindow.start(), nomRange.start(), nomRange.end()),
             clamp(_restrictedEnergyWindow.end(), nomRange.start(), nomRange.end()), };
}

inline float AbstractSource::meanEnergy() const
{
    return spectrum(spectrumDiscretizationHint()).centroid();
}

inline double AbstractSource::photonFlux() const { return _fluxModifier * nominalPhotonFlux(); }

inline double AbstractSource::fluxModifier() const { return _fluxModifier; }

inline void AbstractSource::setFluxModifier(double modifier) { _fluxModifier = modifier; }

} // namespace CTL



#endif // CTL_ABSTRACTSOURCE_H