Settings.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/Exceptions.h"
#include "objects/geometry/TracelessTensor.h"
#include "objects/utility/EnumMap.h"
#include "objects/wrappers/ClonePtr.h"
#include "objects/wrappers/Expected.h"
#include "objects/wrappers/Flags.h"
#include "objects/wrappers/Interval.h"
#include "objects/wrappers/Outcome.h"
#include "objects/wrappers/Variant.h"
#include <typeinfo>
 
NAMESPACE_SPH_BEGIN
 
class Path;
 
template <typename TEnum>
class Settings;
 
template <typename TEnum>
class SettingsIterator;
 
struct EmptySettingsTag {};
 
const EmptySettingsTag EMPTY_SETTINGS;
 
struct EnumWrapper {
    int value;
 
    EnumIndex index;
 
    EnumWrapper() = default;
 
    template <typename TEnum>
    explicit EnumWrapper(TEnum e)
        : value(int(e))
        , index(typeid(TEnum)) {
        static_assert(std::is_enum<TEnum>::value, "Can be used only for enums");
    }
 
    EnumWrapper(const int value, const EnumIndex& index)
        : value(value)
        , index(index) {}
 
    explicit operator int() const {
        return value;
    }
 
    template <typename T, typename = std::enable_if_t<std::is_enum<T>::value>>
    explicit operator T() const {
        SPH_ASSERT(std::type_index(typeid(T)) == index);
        return T(value);
    }
 
    bool operator==(const EnumWrapper& other) const {
        return value == other.value && index == other.index;
    }
 
    friend std::ostream& operator<<(std::ostream& ofs, const EnumWrapper& e) {
        ofs << e.value << " (" << (e.index ? e.index->hash_code() : 0) << ")";
        return ofs;
    }
};
 
class InvalidSettingsAccess : public Exception {
public:
    template <typename TEnum>
    explicit InvalidSettingsAccess(const TEnum key)
        : Exception("Error accessing parameter '" +
                    Settings<TEnum>::getEntryName(key).valueOr("unknown parameter") + "'") {
        static_assert(std::is_enum<TEnum>::value, "InvalidSettingsAccess can only be used with enums");
    }
};
 
template <typename TEnum>
INLINE void checkSettingsAccess(const bool result, const TEnum key) {
    if (!result) {
        throw InvalidSettingsAccess(key);
    }
}
 
template <typename TEnum>
class Settings {
    template <typename>
    friend class SettingsIterator;
 
private:
    enum Types {
        BOOL,
        INT,
        FLOAT,
        INTERVAL,
        STRING,
        VECTOR,
        SYMMETRIC_TENSOR,
        TRACELESS_TENSOR,
        ENUM,
    };
 
    using Value = Variant<bool,
        int,
        Float,
        Interval,
        std::string,
        Vector,
        SymmetricTensor,
        TracelessTensor,
        EnumWrapper>;
 
    struct Entry {
        TEnum id;
 
        std::string name;
 
        Value value;
 
        std::string desc;
 
        Entry() = default;
 
        Entry(TEnum id, const std::string& name, const Value& value, const std::string& desc = "")
            : id(id)
            , name(name)
            , value(value)
            , desc(desc) {}
 
        template <typename T, typename = std::enable_if_t<std::is_enum<T>::value>>
        Entry(TEnum id, const std::string& name, const T& value, const std::string& desc = "")
            : id(id)
            , name(name)
            , value(EnumWrapper(value))
            , desc(desc) {}
 
        template <typename T>
        Entry(TEnum id, const std::string& name, Flags<T> flags, const std::string& desc = "")
            : id(id)
            , name(name)
            , value(EnumWrapper(T(flags.value())))
            , desc(desc) {}
 
        template <typename T>
        INLINE bool hasType(std::enable_if_t<!std::is_enum<T>::value, int> = 0) const {
            return value.has<T>();
        }
 
        template <typename T>
        INLINE bool hasType(std::enable_if_t<std::is_enum<T>::value, int> = 0) const {
            return value.has<EnumWrapper>() && value.get<EnumWrapper>().index == std::type_index(typeid(T));
        }
    };
 
    FlatMap<TEnum, Entry> entries;
 
    static AutoPtr<Settings> instance;
 
    Settings(std::initializer_list<Entry> list);
 
public:
    Settings();
 
    Settings(EmptySettingsTag);
 
    Settings(const Settings& other);
 
    Settings(Settings&& other);
 
    Settings& operator=(std::initializer_list<Entry> list);
 
    Settings& operator=(const Settings& other);
 
    Settings& operator=(Settings&& other);
 
    template <typename TValue>
    Settings& set(const TEnum idx,
        TValue&& value,
        std::enable_if_t<!std::is_enum<std::decay_t<TValue>>::value, int> = 0) {
        Optional<Entry&> entry = entries.tryGet(idx);
        if (!entry) {
            Entry& newEntry = entries.insert(idx, Entry{});
            newEntry.value = std::forward<TValue>(value);
        } else {
            checkSettingsAccess(entry->template hasType<std::decay_t<TValue>>(), idx);
            entry->value = std::forward<TValue>(value);
        }
        return *this;
    }
 
    template <typename TValue>
    Settings& set(const TEnum idx,
        TValue&& value,
        std::enable_if_t<std::is_enum<std::decay_t<TValue>>::value, int> = 0) {
        Optional<Entry&> entry = entries.tryGet(idx);
        if (!entry) {
            Entry& newEntry = entries.insert(idx, Entry{});
            newEntry.value = EnumWrapper(value);
        } else {
            checkSettingsAccess(entry->template hasType<std::decay_t<TValue>>(), idx);
            entry->value = EnumWrapper(value);
        }
        return *this;
    }
 
    template <typename TValue, typename = std::enable_if_t<std::is_enum<TValue>::value>>
    Settings& set(const TEnum idx, const Flags<TValue> flags) {
        return this->set(idx, EnumWrapper(TValue(flags.value())));
    }
 
    Settings& set(const TEnum idx, EmptyFlags) {
        Optional<Entry&> entry = entries.tryGet(idx);
        checkSettingsAccess(entry && entry->value.template has<EnumWrapper>(), idx);
        entry->value.template get<EnumWrapper>().value = 0;
        return *this;
    }
 
    Settings& set(const TEnum idx, const EnumWrapper ew) {
        Optional<Entry&> entry = entries.tryGet(idx);
        if (entry) {
            Optional<EnumWrapper> current = entry->value.template tryGet<EnumWrapper>();
            checkSettingsAccess(current && current->index == ew.index, idx);
        }
        this->set(idx, ew, 0); // zero needed to call the other overload
        return *this;
    }
 
    void addEntries(const Settings& settings) {
        for (const typename SettingsIterator<TEnum>::IteratorValue& iv : settings) {
            Optional<Entry&> entry = entries.tryGet(iv.id);
            if (!entry) {
                Entry& newEntry = entries.insert(iv.id, getDefaults().entries[iv.id]);
                newEntry.value = iv.value;
            } else {
                checkSettingsAccess(entry->value.getTypeIdx() == iv.value.getTypeIdx(), iv.id);
                entry->value = iv.value;
            }
        }
    }
 
    void unset(const TEnum idx) {
        entries.tryRemove(idx);
    }
 
    template <typename TValue>
    TValue get(const TEnum idx, std::enable_if_t<!std::is_enum<std::decay_t<TValue>>::value, int> = 0) const {
        Optional<const Entry&> entry = entries.tryGet(idx);
        checkSettingsAccess(entry && entry->value.template has<TValue>(), idx);
 
        return entry->value.template get<TValue>();
    }
 
    template <typename TValue>
    TValue get(const TEnum idx, std::enable_if_t<std::is_enum<std::decay_t<TValue>>::value, int> = 0) const {
        Optional<const Entry&> entry = entries.tryGet(idx);
        checkSettingsAccess(entry && entry->value.template has<EnumWrapper>(), idx);
 
        const EnumWrapper wrapper = entry->value.template get<EnumWrapper>();
        checkSettingsAccess(wrapper.index == std::type_index(typeid(TValue)), idx);
        return TValue(wrapper.value);
    }
 
    template <typename TValue>
    Flags<TValue> getFlags(const TEnum idx) const {
        static_assert(std::is_enum<TValue>::value, "Can be only used for enums");
        TValue value = this->get<TValue>(idx);
        return Flags<TValue>::fromValue(std::underlying_type_t<TValue>(value));
    }
 
    static Optional<std::string> getEntryName(const TEnum idx) {
        const Settings& settings = getDefaults();
        Optional<const Entry&> entry = settings.entries.tryGet(idx);
        if (entry) {
            return entry->name;
        } else {
            // idx might be invalid if loaded from older config file
            return NOTHING;
        }
    }
 
    static Optional<int> getEntryType(const TEnum idx) {
        const Settings& settings = getDefaults();
        Optional<const Entry&> entry = settings.entries.tryGet(idx);
        if (entry) {
            return entry->value.getTypeIdx();
        } else {
            return NOTHING;
        }
    }
 
    static std::string typeToString(const int type);
 
    static Optional<std::string> getEntryDesc(const TEnum idx) {
        const Settings& settings = getDefaults();
        Optional<const Entry&> entry = settings.entries.tryGet(idx);
        if (entry) {
            return entry->desc;
        } else {
            // idx might be invalid if loaded from older config file
            return NOTHING;
        }
    }
 
    static Optional<TEnum> getEntryId(const std::string& name) {
        const Settings& settings = getDefaults();
        for (const auto& p : settings.entries) {
            if (p.value.name == name) {
                return p.key;
            }
        }
        return NOTHING;
    }
 
    bool has(const TEnum idx) const {
        return entries.contains(idx);
    }
 
    template <typename TValue>
    bool hasType(const TEnum idx) const {
        Optional<const Entry&> entry = entries.tryGet(idx);
        checkSettingsAccess(bool(entry), idx);
        return entry->value.template has<TValue>();
    }
 
    Outcome saveToFile(const Path& path) const;
 
    Outcome loadFromFile(const Path& path);
 
    bool tryLoadFileOrSaveCurrent(const Path& path, const Settings& overrides = EMPTY_SETTINGS);
 
    SettingsIterator<TEnum> begin() const;
 
    SettingsIterator<TEnum> end() const;
 
    Size size() const;
 
    static const Settings& getDefaults();
 
private:
    bool setValueByType(Entry& entry, const Value& defaultValue, const std::string& str);
};
 
template <typename TEnum>
class SettingsIterator {
private:
    using ActIterator = Iterator<const typename FlatMap<TEnum, typename Settings<TEnum>::Entry>::Element>;
 
    ActIterator iter;
 
public:
    SettingsIterator(const ActIterator& iter, Badge<Settings<TEnum>>);
 
    struct IteratorValue {
        TEnum id;
 
        typename Settings<TEnum>::Value value;
    };
 
    IteratorValue operator*() const;
 
    SettingsIterator& operator++();
 
    bool operator==(const SettingsIterator& other) const;
 
    bool operator!=(const SettingsIterator& other) const;
};
 
 
enum class KernelEnum {
    CUBIC_SPLINE,
 
    FOURTH_ORDER_SPLINE,
 
    GAUSSIAN,
 
    TRIANGLE,
 
    CORE_TRIANGLE,
 
    THOMAS_COUCHMAN,
 
    WENDLAND_C2,
 
    WENDLAND_C4,
 
    WENDLAND_C6,
};
 
enum class TimesteppingEnum {
    EULER_EXPLICIT,
 
    LEAP_FROG,
 
    RUNGE_KUTTA,
 
    PREDICTOR_CORRECTOR,
 
    MODIFIED_MIDPOINT,
 
    BULIRSCH_STOER
};
 
enum class TimeStepCriterionEnum {
    COURANT = 1 << 1,
 
    DERIVATIVES = 1 << 2,
 
    ACCELERATION = 1 << 3,
 
    DIVERGENCE = 1 << 4,
 
    ALL = COURANT | DERIVATIVES | ACCELERATION | DIVERGENCE,
};
 
enum class FinderEnum {
    BRUTE_FORCE,
 
    KD_TREE,
 
    OCTREE,
 
    LINKED_LIST,
 
    UNIFORM_GRID,
 
    HASH_MAP,
};
 
enum class BoundaryEnum {
    NONE,
 
    FROZEN_PARTICLES,
 
    GHOST_PARTICLES,
 
    FIXED_PARTICLES,
 
    WIND_TUNNEL,
 
    PERIODIC,
 
    SYMMETRIC,
 
    KILL_ESCAPERS,
 
    PROJECT_1D
};
 
enum class DomainEnum {
    NONE,
 
    SPHERICAL,
 
    ELLIPSOIDAL,
 
    BLOCK,
 
    CYLINDER,
 
    GAUSSIAN_SPHERE,
 
    HALF_SPACE,
};
 
enum class ForceEnum {
    PRESSURE = 1 << 0,
 
    SOLID_STRESS = 1 << 1,
 
    NAVIER_STOKES = 1 << 2,
 
    INTERNAL_FRICTION = 1 << 3,
 
    INERTIAL = 1 << 4,
 
    SELF_GRAVITY = 1 << 5,
 
    SURFACE_TENSION = 1 << 6,
};
 
enum class ArtificialViscosityEnum {
    NONE,
 
    STANDARD,
 
    RIEMANN,
 
    MORRIS_MONAGHAN,
};
 
enum class SolverEnum {
    SYMMETRIC_SOLVER,
 
    ASYMMETRIC_SOLVER,
 
    SUMMATION_SOLVER,
 
    ELASTIC_DEFORMATION_SOLVER,
 
    DENSITY_INDEPENDENT,
 
    ENERGY_CONSERVING_SOLVER,
 
    SIMPLE_SOLVER,
};
 
enum class ContinuityEnum {
    STANDARD,
 
    SUM_ONLY_UNDAMAGED,
 
    DAMAGED_DECREASE_BULK_DENSITY,
};
 
enum class DiscretizationEnum {
    STANDARD,
 
    BENZ_ASPHAUG,
};
 
enum class YieldingEnum {
    NONE,
 
    ELASTIC,
 
    VON_MISES,
 
    DRUCKER_PRAGER
};
 
enum class FractureEnum {
    NONE,
 
    SCALAR_GRADY_KIPP,
 
    TENSOR_GRADY_KIPP
};
 
enum class SmoothingLengthEnum {
    CONTINUITY_EQUATION = 1 << 1,
 
    SOUND_SPEED_ENFORCING = 1 << 2
};
 
enum class SignalSpeedEnum {
    PRESSURE_DIFFERENCE,
 
    VELOCITY_DIFFERENCE,
};
 
enum class GravityEnum {
    SPHERICAL,
 
    BRUTE_FORCE,
 
    BARNES_HUT,
};
 
enum class GravityKernelEnum {
    POINT_PARTICLES,
 
    SPH_KERNEL,
 
    SOLID_SPHERES,
};
 
enum class CollisionHandlerEnum {
    NONE,
 
    PERFECT_MERGING,
 
    ELASTIC_BOUNCE,
 
    MERGE_OR_BOUNCE,
};
 
enum class OverlapEnum {
    NONE,
 
    FORCE_MERGE,
 
    REPEL,
 
    REPEL_OR_MERGE,
 
    INTERNAL_BOUNCE,
 
    PASS_OR_MERGE,
};
 
enum class LoggerEnum {
    NONE,
 
    STD_OUT,
 
    FILE
 
};
 
enum class IoEnum {
    NONE,
 
    TEXT_FILE,
 
    GNUPLOT_OUTPUT,
 
    BINARY_FILE,
 
    COMPRESSED_FILE,
 
    VTK_FILE,
 
    HDF5_FILE,
 
    MPCORP_FILE,
 
    PKDGRAV_INPUT,
};
 
Optional<std::string> getIoExtension(const IoEnum type);
 
Optional<IoEnum> getIoEnum(const std::string& ext);
 
std::string getIoDescription(const IoEnum type);
 
enum class IoCapability {
    INPUT = 1 << 1,
 
    OUTPUT = 1 << 2,
};
 
Flags<IoCapability> getIoCapabilities(const IoEnum type);
 
 
enum class OutputSpacing {
    LINEAR,
 
    LOGARITHMIC,
 
    CUSTOM,
};
 
enum class RngEnum {
    UNIFORM,
 
    HALTON,
 
    BENZ_ASPHAUG
};
 
enum class UvMapEnum {
    PLANAR,
 
    SPHERICAL,
};
 
enum class RunSettingsId {
    RUN_NAME,
 
    RUN_COMMENT,
 
    RUN_AUTHOR,
 
    RUN_EMAIL,
 
    RUN_TYPE,
 
    RUN_OUTPUT_TYPE,
 
    RUN_OUTPUT_INTERVAL,
 
    RUN_OUTPUT_SPACING,
 
    RUN_OUTPUT_CUSTOM_TIMES,
 
    RUN_OUTPUT_FIRST_INDEX,
 
    RUN_OUTPUT_NAME,
 
    RUN_OUTPUT_PATH,
 
    RUN_OUTPUT_QUANTITIES,
 
    RUN_THREAD_CNT,
 
    RUN_THREAD_GRANULARITY,
 
    RUN_LOGGER,
 
    RUN_LOGGER_FILE,
 
    RUN_LOGGER_VERBOSITY,
 
    RUN_VERBOSE_ENABLE,
 
    RUN_VERBOSE_NAME,
 
    RUN_START_TIME,
 
    RUN_END_TIME,
 
    RUN_TIMESTEP_CNT,
 
    RUN_WALLCLOCK_TIME,
 
    RUN_RNG,
 
    RUN_RNG_SEED,
 
    RUN_DIAGNOSTICS_INTERVAL,
 
    SPH_SOLVER_TYPE,
 
    SPH_SOLVER_FORCES,
 
    SPH_ADAPTIVE_SMOOTHING_LENGTH,
 
    SPH_SUMMATION_MAX_ITERATIONS,
 
    SPH_SUMMATION_DENSITY_DELTA,
 
    SPH_ASYMMETRIC_COMPUTE_RADII_HASH_MAP,
 
    SPH_KERNEL,
 
    SPH_FINDER,
 
    SPH_DISCRETIZATION,
 
    SPH_STRAIN_RATE_CORRECTION_TENSOR,
 
    SPH_SUM_ONLY_UNDAMAGED,
 
    SPH_CONTINUITY_MODE,
 
    SPH_PHASE_ANGLE,
 
    SPH_NEIGHBOUR_RANGE,
 
    SPH_NEIGHBOUR_ENFORCING,
 
    SPH_AV_ALPHA,
 
    SPH_AV_BETA,
 
    SPH_SMOOTHING_LENGTH_MIN,
 
    SPH_AV_TYPE,
 
    SPH_AV_USE_BALSARA,
 
    SPH_AV_BALSARA_STORE,
 
    SPH_USE_AC,
 
    SPH_AC_ALPHA,
 
    SPH_AC_BETA,
 
    SPH_AC_SIGNAL_SPEED,
 
    SPH_USE_XSPH,
 
    SPH_XSPH_EPSILON,
 
    SPH_USE_DELTASPH,
 
    SPH_DENSITY_DIFFUSION_DELTA,
 
    SPH_VELOCITY_DIFFUSION_ALPHA,
 
    SPH_AV_USE_STRESS,
 
    SPH_AV_STRESS_EXPONENT,
 
    SPH_AV_STRESS_FACTOR,
 
    SPH_STABILIZATION_DAMPING,
 
    SPH_DI_ALPHA,
 
    SPH_SCRIPT_ENABLE,
 
    SPH_SCRIPT_FILE,
 
    SPH_SCRIPT_PERIOD,
 
    SPH_SCRIPT_ONESHOT,
 
    NBODY_INERTIA_TENSOR,
 
    NBODY_MAX_ROTATION_ANGLE,
 
    NBODY_AGGREGATES_ENABLE,
 
    NBODY_AGGREGATES_SOURCE,
 
    GRAVITY_SOLVER,
 
    GRAVITY_OPENING_ANGLE,
 
    GRAVITY_MULTIPOLE_ORDER,
 
    GRAVITY_KERNEL,
 
    GRAVITY_CONSTANT,
 
    GRAVITY_RECOMPUTATION_PERIOD,
 
    COLLISION_HANDLER,
 
    COLLISION_OVERLAP,
 
    COLLISION_RESTITUTION_NORMAL,
 
    COLLISION_RESTITUTION_TANGENT,
 
    COLLISION_ALLOWED_OVERLAP,
 
    COLLISION_BOUNCE_MERGE_LIMIT,
 
    COLLISION_ROTATION_MERGE_LIMIT,
 
    SOFT_REPEL_STRENGTH,
 
    SOFT_FRICTION_STRENGTH,
 
    TIMESTEPPING_INTEGRATOR,
 
    TIMESTEPPING_COURANT_NUMBER,
 
    TIMESTEPPING_MAX_TIMESTEP,
 
    TIMESTEPPING_INITIAL_TIMESTEP,
 
    TIMESTEPPING_CRITERION,
 
    TIMESTEPPING_DERIVATIVE_FACTOR,
 
    TIMESTEPPING_DIVERGENCE_FACTOR,
 
    TIMESTEPPING_MEAN_POWER,
 
    TIMESTEPPING_MAX_INCREASE,
 
    TIMESTEPPING_MIDPOINT_COUNT,
 
    TIMESTEPPING_BS_ACCURACY,
 
    FRAME_ANGULAR_FREQUENCY,
 
    FRAME_CONSTANT_ACCELERATION,
 
    FRAME_TIDES_MASS,
 
    FRAME_TIDES_POSITION,
 
    FINDER_LEAF_SIZE,
 
    FINDER_MAX_PARALLEL_DEPTH,
 
    DOMAIN_TYPE,
 
    DOMAIN_BOUNDARY,
 
    DOMAIN_CENTER,
 
    DOMAIN_RADIUS,
 
    DOMAIN_HEIGHT,
 
    DOMAIN_SIZE,
 
    DOMAIN_GHOST_MIN_DIST,
 
    DOMAIN_FROZEN_DIST,
 
    GENERATE_UVWS,
 
    UVW_MAPPING,
};
 
 
enum class DistributionEnum {
    HEXAGONAL,
 
    CUBIC,
 
    RANDOM,
 
    DIEHL_ET_AL,
 
    STRATIFIED,
 
    PARAMETRIZED_SPIRALING,
 
    LINEAR
};
 
 
enum class EosEnum {
    NONE,
 
    IDEAL_GAS,
 
    TAIT,
 
    MIE_GRUNEISEN,
 
    TILLOTSON,
 
    MURNAGHAN,
 
    SIMPLIFIED_TILLOTSON,
 
    ANEOS
};
 
enum class BodySettingsId {
    EOS = 0,
 
    INITIAL_DISTRIBUTION = 1,
 
    CENTER_PARTICLES = 2,
 
    PARTICLE_SORTING = 3,
 
    DISTRIBUTE_MODE_SPH5 = 4,
 
    DIEHL_STRENGTH = 5,
 
    DIEHL_MAX_DIFFERENCE = 6,
 
    DIEHL_ITERATION_COUNT = 71,
 
    SMOOTHING_LENGTH_ETA = 72,
 
    DENSITY = 7,
 
    DENSITY_RANGE = 8,
 
    DENSITY_MIN = 9,
 
    ENERGY = 10,
 
    ENERGY_RANGE = 11,
 
    ENERGY_MIN = 12,
 
    STRESS_TENSOR = 13,
 
    STRESS_TENSOR_MIN = 14,
 
    DAMAGE = 15,
 
    DAMAGE_RANGE = 16,
 
    DAMAGE_MIN = 17,
 
    ADIABATIC_INDEX = 18,
 
    TAIT_GAMMA = 19,
 
    TAIT_SOUND_SPEED = 20,
 
    BULK_MODULUS = 21,
 
    TILLOTSON_NONLINEAR_B = 22,
 
    TILLOTSON_SMALL_A = 23,
 
    TILLOTSON_SMALL_B = 24,
 
    TILLOTSON_ALPHA = 25,
 
    TILLOTSON_BETA = 26,
 
    TILLOTSON_SUBLIMATION = 27,
 
    TILLOTSON_ENERGY_IV = 28,
 
    TILLOTSON_ENERGY_CV = 29,
 
    GRUNEISEN_GAMMA = 30,
 
    BULK_SOUND_SPEED = 31,
 
    HUGONIOT_SLOPE = 32,
 
    RHEOLOGY_YIELDING = 33,
 
    RHEOLOGY_DAMAGE = 34,
 
    SHEAR_MODULUS = 35,
 
    YOUNG_MODULUS = 36,
 
    ELASTIC_MODULUS = 37,
 
    ELASTICITY_LIMIT = 38,
 
    MELT_ENERGY = 39,
 
    COHESION = 40,
 
    INTERNAL_FRICTION = 41,
 
    DRY_FRICTION = 42,
 
    USE_ACOUSTIC_FLUDIZATION = 43,
 
    OSCILLATION_DECAY_TIME = 44,
 
    OSCILLATION_REGENERATION = 74,
 
    FLUIDIZATION_VISCOSITY = 45,
 
    RAYLEIGH_SOUND_SPEED = 47,
 
    WEIBULL_COEFFICIENT = 48,
 
    WEIBULL_EXPONENT = 49,
 
    WEIBULL_SAMPLE_DISTRIBUTIONS = 66,
 
    DISTENTION = 81,
 
 
    BULK_VISCOSITY = 50,
 
    SHEAR_VISCOSITY = 51,
 
    DAMPING_COEFFICIENT = 52,
 
    DIFFUSIVITY = 53,
 
    SURFACE_TENSION = 54,
 
    PARTICLE_COUNT = 55,
 
    MIN_PARTICLE_COUNT = 56,
 
    AV_ALPHA = 57,
 
    AV_ALPHA_RANGE = 58,
 
    BULK_POROSITY = 64,
 
    HEAT_CAPACITY = 67,
 
    BODY_SHAPE_TYPE = 59,
 
    BODY_CENTER = 61,
 
    BODY_RADIUS = 68,
 
    BODY_DIMENSIONS = 69,
 
    BODY_HEIGHT = 73,
 
    BODY_SPIN_RATE = 70,
 
    VISUALIZATION_TEXTURE = 80,
 
    IDENTIFIER = 99,
};
 
using RunSettings = Settings<RunSettingsId>;
template <>
AutoPtr<RunSettings> RunSettings::instance;
 
using BodySettings = Settings<BodySettingsId>;
template <>
AutoPtr<BodySettings> BodySettings::instance;
 
NAMESPACE_SPH_END