enumsStructs.h

Go to the documentation of this file.

//
// Created by daniel on 29.05.24.
//
 
#pragma once
 
#include <array>
 
namespace enumsStructs {
    enum class Side {
        front, right, back, left, top, bottom
    };
 
    enum class TypeOfForce {
        gravity, lennardJonesForce, invalid
    };
 
    enum class TypeOfModel {
        directSum, linkedCells, invalid
    };
 
    enum class BoundaryCondition {
        outflow, reflective, periodic, invalid
    };
 
    struct BoundarySet {
        BoundaryCondition front = BoundaryCondition::invalid;
        BoundaryCondition right = BoundaryCondition::invalid;
        BoundaryCondition back = BoundaryCondition::invalid;
        BoundaryCondition left = BoundaryCondition::invalid;
        BoundaryCondition top = BoundaryCondition::invalid;
        BoundaryCondition bottom = BoundaryCondition::invalid;
    };
 
    enum class TypeOfThermostat {
        defaultThermostat, flowThermostat
    };
 
    enum class ParallelizationStrategy {
        none, linear, skipping, reduction
    };
    struct DirectSumSimulationParameters {
        double deltaT;
        double endT;
        TypeOfForce force;
    };
 
    struct LinkedCellsSimulationParameters {
        double deltaT;
        double endT;
        TypeOfForce force;
        double rCutOff;
        std::array<double, 3> domainSize;
        BoundarySet boundaryConditions;
    };
 
    struct Cuboid {
        std::array<double, 3> position;
        std::array<unsigned, 3> dimensions;
        double h;
        double mass;
        std::array<double, 3> initVelocity;
        int dimensionsBrownianMotion;
        double brownianMotionAverageVelocity;
        double epsilon;
        double sigma;
        bool fixed;
    };
 
    struct Disc {
        std::array<double, 3> center;
        std::array<double, 3> initVelocity;
        int N;
        double h;
        double mass;
        int dimensionsBrownianMotion;
        double brownianMotionAverageVelocity;
        double epsilon;
        double sigma;
        bool fixed;
    };
 
    struct Sphere {
        std::array<double, 3> center;
        std::array<double, 3> initVelocity;
        int N;
        double h;
        double mass;
        int dimensionsBrownianMotion;
        double brownianMotionAverageVelocity;
        double epsilon;
        double sigma;
        bool fixed;
    };
 
    struct ParticleType {
        std::array<double, 3> x;
        std::array<double, 3> v;
        double m;
        double epsilon;
        double sigma;
    };
 
    struct ThermostatParameters {
        //If set to false, all other parameters are ignored
        bool useThermostat;
        TypeOfThermostat typeOfThermostat;
        bool initialiseSystemWithBrownianMotion;
        //If set to false, maxTemperatureChange will be ignored
        bool applyScalingGradually;
        double initialTemperature;
        double targetTemperature;
        double maxTemperatureChange;
        int applyAfterHowManySteps;
        int dimensions;
    };
 
    struct MembraneParameters {
        //Setting
        bool membraneSetting;
        bool pull;
        int pullingActiveUntil;
        std::array<double, 3> pullingForce;
        double r0;
        double k;
        //Membrane itself
        std::array<double, 3> initialVelocity;
        std::array<double, 3> position;
        unsigned N1;
        unsigned N2;
        double mass;
        double h;
        double epsilon;
        double sigma;
    };
 
    struct SimulationSettings {
        //general
        std::string outputFileName;
        int outputFrequency;
        bool gravityOn;
        std::array<double, 3> gravityVector;
        int maxNumThreads;
 
        //parallelization strategy
        ParallelizationStrategy parallelizationStrategy;
 
        //thermostat
        ThermostatParameters thermostatParameters;
 
        //membrane
        MembraneParameters membraneParameters;
 
        //model to use in the simulation
        TypeOfModel model;
 
        //Parameters for DirectSumModel
        DirectSumSimulationParameters parametersDirectSum;
 
        //Parameters for LinkedCellModel
        LinkedCellsSimulationParameters parametersLinkedCells;
 
        //Particles and objects of particles
        std::vector<Cuboid> cuboids;
        std::vector<Disc> discs;
        std::vector<ParticleType> particles;
        std::vector<Sphere> spheres;
    };
 
    inline TypeOfForce setForce(const std::string &selectedForce) {
        static const std::unordered_map<std::string, TypeOfForce> formatMap = {
            {"Gravity", TypeOfForce::gravity},
            {"LennardJonesForce", TypeOfForce::lennardJonesForce}
        };
 
        auto it = formatMap.find(selectedForce);
        return (it != formatMap.end()) ? it->second : TypeOfForce::invalid;
    }
 
    inline std::string getForce(TypeOfForce &force) {
        static const std::unordered_map<TypeOfForce, std::string> formatMap = {
            {TypeOfForce::gravity, "Gravity"},
            {TypeOfForce::lennardJonesForce, "LennardJonesForce"}
        };
        auto it = formatMap.find(force);
        return (it != formatMap.end()) ? it->second : "Invalid";
    }
 
    inline TypeOfModel setModel(const std::string &selectedModel) {
        static const std::unordered_map<std::string, TypeOfModel> formatMap = {
            {"DirectSum", TypeOfModel::directSum},
            {"LinkedCells", TypeOfModel::linkedCells}
        };
 
        auto it = formatMap.find(selectedModel);
        return (it != formatMap.end()) ? it->second : TypeOfModel::invalid;
    }
 
    inline std::string getModel(TypeOfModel &model) {
        static const std::unordered_map<TypeOfModel, std::string> formatMap = {
            {TypeOfModel::directSum, "DirectSum"},
            {TypeOfModel::linkedCells, "LinkedCells"}
        };
        auto it = formatMap.find(model);
        return (it != formatMap.end()) ? it->second : "Invalid";
    }
 
    inline BoundaryCondition setBoundaryCondition(const std::string &selectedBoundaryCondition) {
        static const std::unordered_map<std::string, BoundaryCondition> formatMap = {
            {"Reflective", BoundaryCondition::reflective},
            {"Outflow", BoundaryCondition::outflow},
            {"Periodic", BoundaryCondition::periodic}
        };
        auto it = formatMap.find(selectedBoundaryCondition);
        return (it != formatMap.end()) ? it->second : BoundaryCondition::invalid;
    }
 
    inline std::string getBoundaryCondition(BoundaryCondition &boundaryCondition) {
        static const std::unordered_map<BoundaryCondition, std::string> formatMap = {
            {BoundaryCondition::reflective, "Reflective"},
            {BoundaryCondition::outflow, "Outflow"},
            {BoundaryCondition::periodic, "Periodic"}
        };
        auto it = formatMap.find(boundaryCondition);
        return (it != formatMap.end()) ? it->second : "Invalid";
    }
 
    inline TypeOfThermostat setTypeOfThermostat(const std::string &typeOfThermostat) {
        static const std::unordered_map<std::string, TypeOfThermostat> formatMap = {
            {"Default", TypeOfThermostat::defaultThermostat},
            {"Flow", TypeOfThermostat::flowThermostat}
        };
        auto it = formatMap.find(typeOfThermostat);
        return (it != formatMap.end()) ? it->second : throw std::runtime_error("Invalid thermostat selected!");
    }
 
    inline ParallelizationStrategy setTypeOfParallelizationStrategy(const std::string &typeOfParallelizationStrategy) {
        static const std::unordered_map<std::string, ParallelizationStrategy> formatMap = {
            {"None", ParallelizationStrategy::none},
            {"Linear", ParallelizationStrategy::linear},
            {"Skipping", ParallelizationStrategy::skipping},
              {"Reduction", ParallelizationStrategy::reduction}
        };
        auto it = formatMap.find(typeOfParallelizationStrategy);
        return (it != formatMap.end()) ? it->second : throw std::runtime_error("Invalid parallelizatin strategy selected!");
    }
 
 
}