Plot.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/containers/Queue.h"
#include "objects/utility/OperatorTemplate.h"
#include "physics/Integrals.h"
#include "post/Analysis.h"
 
NAMESPACE_SPH_BEGIN
 
struct PlotPoint;
struct ErrorPlotPoint;
class AffineMatrix2;
 
class IDrawPath : public Polymorphic {
public:
    virtual void addPoint(const PlotPoint& point) = 0;
 
    virtual void closePath() = 0;
 
    virtual void endPath() = 0;
};
 
class IDrawingContext : public Polymorphic {
public:
    virtual void drawPoint(const PlotPoint& point) = 0;
 
    virtual void drawErrorPoint(const ErrorPlotPoint& point) = 0;
 
    virtual void drawLine(const PlotPoint& from, const PlotPoint& to) = 0;
 
    virtual AutoPtr<IDrawPath> drawPath() = 0;
 
    virtual void setStyle(const Size index) = 0;
 
    virtual void setTransformMatrix(const AffineMatrix2& matrix) = 0;
};
 
 
class IPlot : public Polymorphic {
protected:
    struct {
        Interval x;
        Interval y;
    } ranges;
 
public:
    Interval rangeX() const {
        return ranges.x;
    }
 
    Interval rangeY() const {
        return ranges.y;
    }
 
    virtual std::string getCaption() const = 0;
 
    virtual void onTimeStep(const Storage& storage, const Statistics& stats) = 0;
 
    virtual void clear() = 0;
 
    virtual void plot(IDrawingContext& dc) const = 0;
};
 
template <typename TDerived>
class SpatialPlot : public IPlot {
protected:
    QuantityId id;
    Array<PlotPoint> points;
    Optional<Size> binCnt;
 
public:
    explicit SpatialPlot(const QuantityId id, const Optional<Size> binCnt = NOTHING)
        : id(id)
        , binCnt(binCnt) {}
 
    virtual std::string getCaption() const override {
        return getMetadata(id).quantityName;
    }
 
    virtual void onTimeStep(const Storage& storage, const Statistics& UNUSED(stats)) override;
 
    virtual void clear() override;
 
    virtual void plot(IDrawingContext& dc) const override;
 
private:
    Float getX(const Vector r) const {
        return static_cast<const TDerived*>(this)->getX(r);
    }
};
 
class AxialDistributionPlot : public SpatialPlot<AxialDistributionPlot> {
private:
    Vector axis;
 
public:
    AxialDistributionPlot(const Vector& axis, const QuantityId id, const Optional<Size> binCnt = NOTHING)
        : SpatialPlot<AxialDistributionPlot>(id, binCnt)
        , axis(axis) {}
 
    INLINE Float getX(const Vector& r) const {
        return getLength(r - dot(r, axis) * axis);
    }
};
 
class RadialDistributionPlot : public SpatialPlot<RadialDistributionPlot> {
public:
    RadialDistributionPlot(const QuantityId id, const Optional<Size> binCnt = NOTHING);
 
    INLINE Float getX(const Vector& r) const {
        return getLength(r);
    }
};
 
class TemporalPlot : public IPlot {
public:
    struct Params {
        Float segment = INFTY;
 
        Interval fixedRangeX = Interval{};
 
        Float minRangeY = 0._f;
 
        bool shrinkY = false;
 
        Size maxPointCnt = 100;
 
        Float period = 0._f;
    };
 
 
private:
    IntegralWrapper integral;
 
    Queue<PlotPoint> points;
 
    Float lastTime = -INFTY;
 
    const Params params;
 
    Float actPeriod;
 
public:
    TemporalPlot(const IntegralWrapper& integral, const Params& params)
        : integral(integral)
        , params(params) {
        SPH_ASSERT(params.segment > 0._f);
        actPeriod = params.period;
    }
 
    virtual std::string getCaption() const override {
        return integral.getName();
    }
 
    virtual void onTimeStep(const Storage& storage, const Statistics& stats) override;
 
    virtual void clear() override;
 
    virtual void plot(IDrawingContext& dc) const override;
 
private:
    bool isExpired(const Float x, const Float t) const;
};
 
 
class HistogramPlot : public IPlot {
protected:
    Post::ExtHistogramId id;
 
    Array<Post::HistPoint> points;
 
    Optional<Interval> interval;
 
    Float period;
 
    std::string name;
 
    Float lastTime = -INFTY;
 
public:
    HistogramPlot(const Post::HistogramId id,
        const Optional<Interval> interval,
        const Float period,
        const std::string& name)
        : id(id)
        , interval(interval)
        , period(period)
        , name(name) {}
 
    HistogramPlot(const QuantityId id, const Optional<Interval> interval, const Float period)
        : id(id)
        , interval(interval)
        , period(period) {
        name = getMetadata(id).quantityName;
    }
 
    virtual std::string getCaption() const override {
        return name;
    }
 
    virtual void onTimeStep(const Storage& storage, const Statistics& stats) override;
 
    virtual void clear() override;
 
    virtual void plot(IDrawingContext& dc) const override;
};
 
class AngularHistogramPlot : public IPlot {
    Array<PlotPoint> points;
 
    Float period;
 
    Float lastTime = -INFTY;
 
public:
    explicit AngularHistogramPlot(const Float period);
 
    virtual std::string getCaption() const override {
        return "Angular histogram of velocities";
    }
 
    virtual void onTimeStep(const Storage& storage, const Statistics& stats) override;
 
    virtual void clear() override;
 
    virtual void plot(IDrawingContext& dc) const override;
};
 
class SfdPlot : public IPlot {
private:
    Post::HistogramSource source;
    Flags<Post::ComponentFlag> connect;
    Float period;
    std::string name;
 
    Float lastTime = -INFTY;
    Array<PlotPoint> sfd;
 
public:
    SfdPlot(const Flags<Post::ComponentFlag> connectivity, const Float period);
 
    SfdPlot(const Float period);
 
    virtual std::string getCaption() const override;
 
    virtual void onTimeStep(const Storage& storage, const Statistics& stats) override;
 
    virtual void clear() override;
 
    virtual void plot(IDrawingContext& dc) const override;
};
 
enum class AxisScaleEnum {
    LOG_X = 1 << 0,
    LOG_Y = 1 << 1,
};
 
class DataPlot : public IPlot {
private:
    Array<PlotPoint> values;
    std::string name;
 
public:
    DataPlot(const Array<Post::HistPoint>& points, const Flags<AxisScaleEnum> scale, const std::string& name);
 
    virtual std::string getCaption() const override;
 
    virtual void onTimeStep(const Storage& storage, const Statistics& stats) override;
 
    virtual void clear() override;
 
    virtual void plot(IDrawingContext& dc) const override;
};
 
class MultiPlot : public IPlot {
private:
    Array<AutoPtr<IPlot>> plots;
 
public:
    explicit MultiPlot(Array<AutoPtr<IPlot>>&& plots)
        : plots(std::move(plots)) {}
 
    virtual std::string getCaption() const override {
        return plots[0]->getCaption(); 
    }
 
    virtual void onTimeStep(const Storage& storage, const Statistics& stats) override;
 
    virtual void clear() override;
 
    virtual void plot(IDrawingContext& dc) const override;
};
 
Array<Float> getLinearTics(const Interval& interval, const Size minCount);
 
Array<Float> getLogTics(const Interval& interval, const Size minCount);
 
NAMESPACE_SPH_END