parameters.hpp

Go to the documentation of this file.

 
#ifndef PARAMETERS_H_INCLUDED
#define PARAMETERS_H_INCLUDED
 
//=================================
// included dependencies
 
#include <array>
#include <cstdlib>
#include <ctime>
#include <string>
#include <vector>
 
//=================================
// Code
//
// This file defines parameters to be used in other parts of the
// RSVS snaking framework. Default values are defined in "parameters.cpp"
//
// Substructure names are all 4-5 letters
 
namespace param
{
typedef std::array<double, 2> realbounds;
typedef std::vector<std::pair<std::string, std::string>> exports;
typedef std::vector<std::pair<int, std::string>> varconfig;
template <class T> struct filltype
{
    bool active = false;
    T fill;
};
 
class outputtemplate
{
  public:
    std::string directory;
    std::string templateregex;
    std::string filenameregex;
    varconfig loglvlspecialisation;
 
    outputtemplate();
};
 
class tecplottemplate : public outputtemplate
{
  public:
    using outputtemplate::outputtemplate;
 
    std::string TemplateLogging(int lvl, bool withPath = true, std::string pattern = "") const;
};
class rsvs
{
  public:
    int solveralgorithm;
    filltype<double> cstfill;
    filltype<std::string> filefill;
    filltype<std::string> makefill;
    rsvs();
    ~rsvs();
    void PrepareForUse();
};
 
class snaking
{
  public:
    // Velocity engine
    std::string engine;
    double arrivaltolerance;
    double multiarrivaltolerance;
    double snaxtimestep;
    double snaxdiststep;
    int initboundary;
    int maxsteps;
    double spawnposition;
 
    snaking();
    ~snaking();
    void PrepareForUse();
};
 
class voxel
{
  public:
    std::array<int, 3> gridsizebackground;
    std::array<int, 3> gridsizesnake;
 
    voxel();
    ~voxel();
    void PrepareForUse();
};
 
class voronoi
{
  public:
    std::vector<double> inputpoints;
    double distancebox;
    std::string pointfile;
    double snakecoarseness;
    int vorosnakelayers;
 
    voronoi();
    ~voronoi();
    void PrepareForUse();
    void ReadPoints();
};
 
class grid
{
  public:
    voxel voxel;
    voronoi voronoi;
    std::array<realbounds, 3> domain;
    std::array<realbounds, 3> physdomain;
    std::string activegrid;
 
    grid();
    void PrepareForUse();
};
 
class ioin
{
  public:
    std::string snakemeshname;
    std::string volumeshname;
    std::string snakefile;
    std::string casename;
 
    ioin();
    void PrepareForUse();
};
class ioout
{
  private:
  public:
    std::string pathoutdir;
    std::string pathpattern;
    std::string basenamepattern;
    std::string basenameoutdir;
    std::string outdir;
    std::string pattern;
 
    bool redirectcout;
    bool redirectcerr;
 
    int logginglvl;
    int outputlvl;
 
    tecplottemplate tecplot;
 
    ioout();
    void PrepareForUse();
};
 
class files
{
  public:
    bool appcasename2outdir;
    ioin ioin;
    ioout ioout;
    exports exportconfig;
    files();
    void PrepareForUse();
};
 
namespace dev
{
 
class rsvseps
{
  public:
    double rsvsmath_automatic_eps_edge;
    double rsvsmath_automatic_eps_surf;
    double rsvsmath_automatic_eps_volu;
    double rsvsmath_automatic_eps_centre;
    double rsvsmath_automatic_eps_centre2;
 
    rsvseps();
};
 
class devparam
{
  public:
    double limitlagrangian;
    int mindesvarsparse;
    bool surfcentrejacobian;
    bool surfcentrehessian;
    bool snaxDistanceLimit_conserveShape;
    std::string smoothstepmethod;
    rsvseps rsvsepsilons;
    devparam();
};
} // namespace dev
class parameters
{
  public:
    rsvs rsvs;
    snaking snak;
    grid grid;
    files files;
 
    dev::devparam dev;
 
    void PrepareForUse();
};
 
namespace io
{
void read(const std::string &fileName, parameters &p);
void readflat(const std::string &fileName, parameters &p);
void write(const std::string &fileName, const parameters &p);
void writeflat(const std::string &fileName, const parameters &p);
int updatefromstring(const std::vector<std::string> &flatjsonKeyVal, parameters &p,
                     const std::string &&sep = std::string(":"));
 
void defaultconf();
} // namespace io
 
namespace test
{
 
int base();
int io();
int ioflat();
int ipartialread();
int prepareforuse();
int autoflat();
int symmetry();
int symmetry_makefillactive();
} // namespace test
} // namespace param
 
#endif