Output.h

Go to the documentation of this file.

#pragma once
 
 
#include "io/Path.h"
#include "objects/utility/EnumMap.h"
#include "objects/wrappers/Expected.h"
#include "objects/wrappers/Outcome.h"
#include "physics/Constants.h"
#include "quantities/Storage.h"
 
NAMESPACE_SPH_BEGIN
 
class OutputFile {
private:
    mutable Size dumpNum = 0;
    Path pathMask;
 
public:
    OutputFile() = default;
 
    OutputFile(const Path& pathMask, const Size firstDumpIdx = 0);
 
    Path getNextPath(const Statistics& stats) const;
 
    bool hasWildcard() const;
 
    Path getMask() const;
 
    static Optional<Size> getDumpIdx(const Path& path);
 
    static Optional<OutputFile> getMaskFromPath(const Path& path, const Size firstDumpIdx = 0);
};
 
class IOutput : public Polymorphic {
protected:
    OutputFile paths;
 
public:
    explicit IOutput(const OutputFile& fileMask);
 
    virtual Expected<Path> dump(const Storage& storage, const Statistics& stats) = 0;
};
 
class IInput : public Polymorphic {
public:
    virtual Outcome load(const Path& path, Storage& storage, Statistics& stats) = 0;
};
 
 
enum class OutputQuantityFlag {
    POSITION = 1 << 0,
 
    VELOCITY = 1 << 1,
 
    SMOOTHING_LENGTH = 1 << 2,
 
    MASS = 1 << 3,
 
    PRESSURE = 1 << 4,
 
    DENSITY = 1 << 5,
 
    ENERGY = 1 << 6,
 
    DEVIATORIC_STRESS = 1 << 7,
 
    DAMAGE = 1 << 8,
 
    ANGULAR_FREQUENCY = 1 << 9,
 
    STRAIN_RATE_CORRECTION_TENSOR = 1 << 10,
 
    MATERIAL_ID = 1 << 11,
 
    INDEX = 1 << 12,
};
 
class ITextColumn;
 
class TextOutput : public IOutput {
public:
    enum class Options {
        DUMP_ALL = 1 << 0,
 
        SCIENTIFIC = 1 << 1,
    };
 
private:
    std::string runName;
 
    Flags<Options> options;
 
    Array<AutoPtr<ITextColumn>> columns;
 
public:
    TextOutput(const OutputFile& fileMask,
        const std::string& runName,
        Flags<OutputQuantityFlag> quantities,
        Flags<Options> options = EMPTY_FLAGS);
 
    ~TextOutput();
 
    TextOutput& addColumn(AutoPtr<ITextColumn>&& column);
 
    virtual Expected<Path> dump(const Storage& storage, const Statistics& stats) override;
};
 
class TextInput : public IInput {
private:
    Array<AutoPtr<ITextColumn>> columns;
 
public:
    explicit TextInput(Flags<OutputQuantityFlag> quantities);
 
    TextInput& addColumn(AutoPtr<ITextColumn>&& column);
 
    virtual Outcome load(const Path& path, Storage& storage, Statistics& stats) override;
};
 
class GnuplotOutput : public TextOutput {
private:
    std::string scriptPath;
 
public:
    GnuplotOutput(const OutputFile& fileMask,
        const std::string& runName,
        const std::string& scriptPath,
        const Flags<OutputQuantityFlag> quantities,
        const Flags<Options> flags)
        : TextOutput(fileMask, runName, quantities, flags)
        , scriptPath(scriptPath) {}
 
    virtual Expected<Path> dump(const Storage& storage, const Statistics& stats) override;
};
 
 
enum class RunTypeEnum {
    SPH,
 
    STABILIZATION,
 
    RUBBLE_PILE,
 
    NBODY,
};
 
static RegisterEnum<RunTypeEnum> sRunType({
    { RunTypeEnum::SPH, "sph", "Main SPH simulation" },
    { RunTypeEnum::STABILIZATION, "stabilization", "Convergence SPH phase" },
    { RunTypeEnum::RUBBLE_PILE, "rubble-pile", "Simulation creating rubble-pile target" },
    { RunTypeEnum::NBODY, "nbody", "Main N-body simulation" },
});
 
enum class BinaryIoVersion : int64_t {
    FIRST = 0,
    V2018_04_07 = 20180407, 
    V2018_10_24 = 20181024, 
    V2021_03_20 = 20210320, 
    LATEST = V2021_03_20,
};
 
class BinaryOutput : public IOutput {
    friend class BinaryInput;
 
private:
    static constexpr Size PADDING_SIZE = 164;
 
    RunTypeEnum runTypeId;
 
public:
    explicit BinaryOutput(const OutputFile& fileMask, const RunTypeEnum runTypeId = RunTypeEnum::SPH);
 
    virtual Expected<Path> dump(const Storage& storage, const Statistics& stats) override;
};
 
class BinaryInput : public IInput {
public:
    virtual Outcome load(const Path& path, Storage& storage, Statistics& stats) override;
 
    struct Info {
        Size quantityCnt;
 
        Size particleCnt;
 
        Size materialCnt;
 
        struct QuantityInfo {
 
            QuantityId id;
 
            OrderEnum order;
 
            ValueEnum value;
        };
 
        Array<QuantityInfo> quantityInfo;
 
        Float runTime;
 
        Size wallclockTime;
 
        Float timeStep;
 
        Optional<RunTypeEnum> runType;
 
        Optional<std::string> buildDate;
 
        BinaryIoVersion version;
    };
 
    Expected<Info> getInfo(const Path& path) const;
};
 
enum class CompressedIoVersion : int {
    FIRST = 0,
};
 
enum class CompressionEnum {
    NONE,
    RLE,
};
 
class CompressedOutput : public IOutput {
private:
    CompressionEnum compression;
    RunTypeEnum runTypeId;
 
public:
    explicit CompressedOutput(const OutputFile& fileMask,
        const CompressionEnum compression,
        const RunTypeEnum runTypeId = RunTypeEnum::SPH);
 
    virtual Expected<Path> dump(const Storage& storage, const Statistics& stats) override;
};
 
class CompressedInput : public IInput {
public:
    virtual Outcome load(const Path& path, Storage& storage, Statistics& stats) override;
 
    struct Info {
        Size particleCnt;
 
        Float runTime;
 
        RunTypeEnum runType;
 
        CompressedIoVersion version;
    };
 
    Expected<Info> getInfo(const Path& path) const;
};
 
class VtkOutput : public IOutput {
private:
    Flags<OutputQuantityFlag> flags;
 
public:
    VtkOutput(const OutputFile& fileMask, const Flags<OutputQuantityFlag> flags);
 
    virtual Expected<Path> dump(const Storage& storage, const Statistics& stats) override;
};
 
class Hdf5Input : public IInput {
public:
    virtual Outcome load(const Path& path, Storage& storage, Statistics& stats) override;
};
 
class MpcorpInput : public IInput {
private:
    Float rho;
    Float albedo;
 
public:
    explicit MpcorpInput(const Float rho = 2700._f, const Float albedo = 0.2_f)
        : rho(rho)
        , albedo(albedo) {}
 
    virtual Outcome load(const Path& path, Storage& storage, Statistics& stats) override;
};
 
struct PkdgravParams {
 
    enum class Radius {
        FROM_SMOOTHING_LENGTH,
 
        FROM_DENSITY
    };
 
    Radius radius = Radius::FROM_DENSITY;
 
    struct Conversion {
 
        Float mass = Constants::M_sun;
 
        Float distance = Constants::au;
 
        Float velocity = Constants::au * 2._f * PI / (365.25_f * 86400._f);
 
    } conversion;
 
    Vector omega = Vector(0._f);
 
    Float vaporThreshold = 1.e6_f;
 
    Array<Size> colors{ 3, 13 };
};
 
 
class PkdgravOutput : public IOutput {
private:
    PkdgravParams params;
 
public:
    PkdgravOutput(const OutputFile& fileMask, PkdgravParams&& params);
 
    virtual Expected<Path> dump(const Storage& storage, const Statistics& stats) override;
 
private:
    INLINE Float getRadius(const Float h, const Float m, const Float rho) const {
        switch (params.radius) {
        case PkdgravParams::Radius::FROM_DENSITY:
            // 4/3 pi r^3 rho = m
            return cbrt(3._f * m / (4._f * PI * rho));
        case PkdgravParams::Radius::FROM_SMOOTHING_LENGTH:
            return h / 3._f;
        default:
            NOT_IMPLEMENTED;
        }
    }
};
 
class PkdgravInput : public IInput {
public:
    virtual Outcome load(const Path& path, Storage& storage, Statistics& stats) override;
};
 
class TabInput : public IInput {
private:
    // AutoPtr to avoid instantiation, ITextColumn is forward-declared only
    AutoPtr<TextInput> input;
 
public:
    TabInput();
 
    ~TabInput();
 
    virtual Outcome load(const Path& path, Storage& storage, Statistics& stats) override;
};
 
 
class NullOutput : public IOutput {
public:
    NullOutput()
        : IOutput(Path("file")) {} // we don't dump anything, but IOutput asserts non-empty path
 
    virtual Expected<Path> dump(const Storage& UNUSED(storage), const Statistics& UNUSED(stats)) override {
        return Path();
    }
};
 
 
NAMESPACE_SPH_END