Homec4science
Diffusion ConSol (master) Browse

ConSol/ConSol/ConSol/Base/Configuration.cpp
09fe821ec8e2master

Last Change
Raw File

Configuration.cpp
View Options

//
// Configuration.cpp
// ConserSolver
//
// Created by Fabian Moenkeberg on 04.05.17.
// Copyright © 2017 FabianMoenkeberg. All rights reserved.
//
#include "Configuration.hpp"
#include <omp.h>
#include <iomanip>
Configuration::Configuration(){
};
Configuration::Configuration(char* file) {
this->input_file = file;
read();
this->SOLN_DIR = OUTPUT_PATH + "/SOLN_FILES";
// // Making solution directories
// std::string commandline0 = "rm -rf " + SOLN_DIR;
// system(commandline0.c_str());
// std::string commandline1 = "mkdir -p " + SOLN_DIR;
// system(commandline1.c_str());
//
// glob_filename = SOLN_DIR + "/globals.dat";
// glob_file.open (glob_filename.c_str());
//
// L1_err_filename = SOLN_DIR + "/l1_err.dat";
// L2_err_filename = SOLN_DIR + "/l2_err.dat";
// Linf_err_filename = SOLN_DIR + "/linf_err.dat";
//
// if(param.exact_available)
// {
// L1_err_file.open (L1_err_filename.c_str());
// L2_err_file.open (L2_err_filename.c_str());
// Linf_err_file.open (Linf_err_filename.c_str());
// }
//
// if(param.OOC)
// {
// print_globals = false;
// print_soln = false;
// disp_log = false;
// L1_err.resize(param.mesh_levels);
// L2_err.resize(param.mesh_levels);
// Linf_err.resize(param.mesh_levels);
// }
// else {
// print_globals = true;
// print_soln = true;
// disp_log = true;
// }
}
Configuration::Configuration(ModelName model, evaluationMethod evalMethod, bcName bc, int order, double tMax, double cfl){
this->model = model;
this->evalMethod = evalMethod;
this->bcname = bc;
this->order = order;
this->tMax = tMax;
this->cfl = cfl;
this->tInclude = *new std::vector<double>(0);
this->reconstr = NORECONSTR;
this->interpBase = POLYNOMIALS;
}
Configuration::Configuration(ModelName model, evaluationMethod evalMethod, bcName bc, int order, double tMax, std::vector<double> tInclude, double cfl){
this->model = model;
this->evalMethod = evalMethod;
this->bcname = bc;
this->order = order;
this->tMax = tMax;
this->cfl = cfl;
this->tInclude = tInclude;
this->reconstr = NORECONSTR;
this->interpBase = POLYNOMIALS;
}
Configuration::Configuration(ModelName model, evaluationMethod evalMethod, bcName bc, ReconstrName reconstr, InterpBaseName interpBase, int order, double tMax, double cfl){
this->model = model;
this->evalMethod = evalMethod;
this->bcname = bc;
this->order = order;
this->tMax = tMax;
this->cfl = cfl;
this->tInclude = *new std::vector<double>(0);
this->reconstr = reconstr;
this->interpBase = interpBase;
}
Configuration::Configuration(ModelName model, evaluationMethod evalMethod, bcName bc, ReconstrName reconstr, InterpBaseName interpBase, int order, double tMax, std::vector<double> tInclude, double cfl){
this->model = model;
this->evalMethod = evalMethod;
this->bcname = bc;
this->order = order;
this->tMax = tMax;
this->cfl = cfl;
this->tInclude = tInclude;
this->reconstr = reconstr;
this->interpBase = interpBase;
}
Configuration::Configuration(ModelName model, evaluationMethod evalMethod, bcName bc, ReconstrName reconstr, InterpBaseName interpBase, bool reconstrOnCharact, int order, double tMax, double cfl){
this->model = model;
this->evalMethod = evalMethod;
this->bcname = bc;
this->order = order;
this->tMax = tMax;
this->cfl = cfl;
this->tInclude = *new std::vector<double>(0);
this->reconstr = reconstr;
this->interpBase = interpBase;
this->reconstrOnCharact = reconstrOnCharact;
}
Configuration::Configuration(ModelName model, evaluationMethod evalMethod, bcName bc, ReconstrName reconstr, InterpBaseName interpBase, bool reconstrOnCharact, int order, double tMax, std::vector<double> tInclude, double cfl){
this->model = model;
this->evalMethod = evalMethod;
this->bcname = bc;
this->order = order;
this->tMax = tMax;
this->cfl = cfl;
this->tInclude = tInclude;
this->reconstr = reconstr;
this->interpBase = interpBase;
this->reconstrOnCharact = reconstrOnCharact;
}
ModelName Configuration::getModel(){return model;};
TimeIntegrationName Configuration::getTimeIntegration(){return time_scheme;};
int Configuration::getOrder(){return order;};
evaluationMethod Configuration::getEvalMethod(){return evalMethod;};
bcName Configuration::getBc(){return bcname;};
std::vector<double> Configuration::getTInclude(){return tInclude;};
limiterName Configuration::getLimiter(){return limiter_name; };
FluxName Configuration::getFlux(){return fluxScheme; };
double Configuration::getTmax(){return tMax;};
double Configuration::getCfl(){return cfl;};
int Configuration::getMaxNumWrite(){return maxNumWrite;};
ReconstrName Configuration::getReconstr(){return reconstr;};
sourceName Configuration::getSource() { return source;};
initalCondName Configuration::getInitialCond() {return initialCond;};
InterpBaseName Configuration::getInterpBase(){return interpBase;};
bool Configuration::getReconstrOnCharact(){return reconstrOnCharact;};
int Configuration::getDim(){return dim;};
double Configuration::getXmax(){return xmax;};
double Configuration::getXmin(){return xmin;};
double Configuration::getYmax(){return ymax;};
double Configuration::getYmin(){return ymin;};
double Configuration::getShapeParam(){ return shapeParam;};
std::vector<int> Configuration::getNx() { return Nx_cell;};
std::vector<int> Configuration::getNy() { return Ny_cell;};
std::string Configuration::getGridFile() { return grid_file;};
std::string Configuration::getOutputPath() { return OUTPUT_PATH;}
std::string Configuration::getImportPath() { return IMPORT_PATH;}
bool Configuration::getImportSol() {return import_sol;};
bool Configuration::getLoadGrid() { return load_grid;};
int Configuration::getNthreads() {return nThreads;};
stencilChoice Configuration::getStencilChoice() { return stencilchoice;};
std::map<std::string, double> Configuration::getConstants() {return constants;};
int Configuration::getDegPoly() {return degPoly;};
MeshType Configuration::getMeshType() {return meshType;};
//------------------------------------------------------------------------------
// Read parameters from file
//------------------------------------------------------------------------------
void Configuration::read ()
{
std::cout << "Reading input file " << input_file << std::endl;
Reader fin(input_file);
read_grid (fin);
read_numeric (fin);
read_model(fin);
read_constants (fin);
read_initial_condition (fin);
read_exact (fin);
read_boundary_condition (fin);
read_output (fin);
read_import(fin);
}
//------------------------------------------------------------------------------
// Read grid section
//------------------------------------------------------------------------------
void Configuration::read_grid (Reader &fin)
{
std::cout << " Reading grid section\n";
std::string input;
int N;
fin.begin_section ("grid");
fin.entry ("load_grid");
fin >> input;
if (input == "true") {
load_grid = true;
}
else{
load_grid = false;
}
fin.entry ("dim");
fin >> dim;
assert(dim == 1 || dim == 2 );
fin.entry ("x_min");
fin >> xmin;
fin.entry ("x_max");
fin >> xmax;
fin.begin_section ("Nx_cell");
while(!fin.eos())
{
fin >> N;
assert(N > 0);
Nx_cell.push_back(N);
}
if (dim == 2) {
fin.entry("y_min");
fin >> ymin;
fin.entry("y_max");
fin >> ymax;
}else{
ymin = 0;
ymax = 1;
}
fin.begin_section ("Ny_cell");
while(!fin.eos())
{
fin >> N;
assert(N > 0);
Ny_cell.push_back(N);
}
assert(xmin<xmax);
assert(ymin<ymax);
fin.entry ("grid_path");
fin >> grid_file;
fin.entry ("type");
fin >> input;
if (input == "triangular") {
meshType = TRI;
} else if (input == "hybrid") {
meshType = HYBRID;
}else if (input == "quadrilateral"){
meshType = QUAD;
}else if (input == "mixed"){
meshType = MIXED;
} else {
std::cout << " Error: unknown meshType " << input << std::endl;
exit(0);
}
fin.end_section ();
}
//------------------------------------------------------------------------------
// Read numeric section
//------------------------------------------------------------------------------
void Configuration::read_numeric (Reader &fin) {
std::cout << " Reading numeric section\n";
std::string input;
fin.begin_section("numeric");
fin.entry("nthreads");
fin >> nThreads;
fin.entry("time_scheme");
fin >> input;
if (input == "SSPRK3") {
time_scheme = SSPRK3;
} else if (input == "SSPRK5") {
time_scheme = SSPRK5;
}else if (input == "SSPRK2"){
time_scheme = SSPRK2;
}else if (input == "FE") {
time_scheme = FE;
} else {
std::cout << " Error: unknown time_scheme " << input << std::endl;
exit(0);
}
fin.entry("cfl");
fin >> cfl;
assert (cfl > 0.0);
fin.entry("max_iter");
fin >> max_iter;
assert (max_iter > 0);
fin.entry("final_time");
fin >> tMax;
assert (tMax >= 0.0);
fin.entry("min_residue");
fin >> min_residue;
assert (min_residue > 0.0);
fin.entry("reconstruct");
fin >> input;
if (input == "noReconstruct") {
reconstr = NORECONSTR;
} else if (input == "eno") {
reconstr = ENO;
} else if (input == "weno") {
reconstr = WENO;
} else {
std::cout << " Error: unknown reconstruction method " << input << std::endl;
exit(0);
}
fin.entry("stencilChoice");
fin >> input;
if (input == "std") {
stencilchoice = STD;
} else if (input == "otf") {
stencilchoice = OTF;
} else if (input == "symm") {
stencilchoice = SYMM;
} else if (input == "symmb") {
stencilchoice = SYMMb;
} else {
std::cout << " Error: unknown stencil choice " << input << std::endl;
exit(0);
}
fin.entry("order");
fin >> order;
fin.entry("degPoly");
fin >> input;
if (input == "x"){
degPoly = order - 2;
} else {
degPoly = std::stoi(input);
}
fin.entry("interpolationBase");
fin >> input;
if (input == "Multiquadratics") {
interpBase = MULTIQUADS;
} else if (input == "Polynomials") {
interpBase = POLYNOMIALS;
} else if (input == "Polyharmonics") {
interpBase = POLYHARMONICS;
} else if (input == "Gaussians") {
interpBase = GAUSSIANS;
} else {
std::cout << " Error: unknown interpolation base " << input << std::endl;
exit(0);
}
fin.entry("shapeParameter");
fin >> shapeParam;
fin.entry("reconstrOnCharact");
fin >> input;
if (input == "true") {
reconstrOnCharact = true;
}
else{
reconstrOnCharact = false;
}
fin.entry("evaluationMethod");
fin >> input;
if (input == "meanvalue") {
evalMethod = MEANVALUE;
}
else{
evalMethod = PTWISE;
}
fin.entry("fluxScheme");
fin >> input;
if (input == "LaxFried") {
fluxScheme = LAXFRIEDRICHS;
}
else {
std::cout << " Error: unknown flux scheme " << input << std::endl;
exit(0);
}
fin.entry("limiter");
fin >> input;
if (input == "noLimiter") {
limiter_name = NOLIMITER;
}
else if (input == "extremaPreserving") {
limiter_name = EXTREMAPRES;
}
else {
std::cout << " Error: unknown limiter " << input << std::endl;
exit(0);
}
fin.begin_section("tInclude");
double value;
this->tInclude = std::vector<double>(0);
while (!fin.eos())
{
fin >> value;
tInclude.push_back(value);
}
fin.end_section ();
}
//------------------------------------------------------------------------------
// Read material section
//------------------------------------------------------------------------------
void Configuration::read_model (Reader &fin)
{
std::cout << " Reading model section\n";
std::string input;
fin.begin_section ("model");
fin.entry("model");
fin >> input;
if (input == "linAdv") {
model = LINEARADVECTION;
} else if (input == "burgers") {
model = BURGERS;
} else if (input == "SW") {
model = SW;
} else if (input == "Euler") {
model = EULER;
} else if (input == "BuckleyLeverett") {
model = BUCKLEYLEVERETT;
}else if (input == "KPP"){
model = KPP;
}else if (input == "KPPY"){
model = KPPY;
}else if (input == "KPPX"){
model = KPPX;
}
else {
std::cout << " Error: unknown model " << input << std::endl;
exit(0);
}
fin.entry("source");
fin >> input;
if (input == "noSource") {
source = NOSOURCE;
}else{
std::cout << " Error: unknown source " << input << std::endl;
exit(0);
}
fin.end_section ();
}
//------------------------------------------------------------------------------
// Read constants section
//------------------------------------------------------------------------------
void Configuration::read_constants (Reader &fin)
{
std::cout << " Reading constants section\n";
std::string input;
double value;
fin.begin_section ("constants");
while (!fin.eos())
{
fin >> input;
fin >> value;
std::cout << std::setw(16) << input << std::setw(16) << value << std::endl;
constants.insert ( std::pair<std::string,double>(input, value) );
}
}
//------------------------------------------------------------------------------
// Read initial condition
//------------------------------------------------------------------------------
void Configuration::read_initial_condition (Reader &fin)
{
std::cout << " Reading initial condition section\n";
std::string input;
fin.begin_section ("initial_condition");
switch (model){
case LINEARADVECTION:
fin.entry("y");
fin >> input;
if (input == "sin(2*pi*x)"){
initialCond = SIN;
}else if (input == "bubble") {
initialCond = BUBBLE;
}
else if ( input == "coscos") {
initialCond = COSCOS;
}
else if ( input == "sinsin") {
initialCond = SINSIN;
}
else if (input == "shockX"){
initialCond = SHOCKX;
}
else if (input == "cube"){
initialCond = InitCUBE;
}else {
std::cout << " Error:: unknown initial Condition: " << input << std::endl;
exit (0);
}
break;
case EULER:
fin.entry("y");
fin >> input;
if (input == "isentropicVortex"){
initialCond = InitISENTROPICVORTEX;
}else if (input == "eulerBlast"){
initialCond = InitEULERBLAST;
}else if (input == "vortexShock"){
initialCond = InitVORTEXSHOCK;
}else if (input == "RP"){
initialCond = RP;
}else if (input == "initDoubleMachRef"){
initialCond = InitDOUBLEMACHREF;
}else if (input == "initFAC"){
initialCond = InitFAC;
}else if (input == "initAirFoil"){
initialCond = InitAIRFOIL;
}else if (input == "initNozzle"){
initialCond = InitNOZZLE;
}
else {
std::cout << " Error:: unknown initial Condition: " << input << std::endl;
exit (0);
}
break;
case BURGERS:
fin.entry("y");
fin >> input;
if (input == "sin(2*pi*x)"){
initialCond = SIN;
}else if (input == "bubble") {
initialCond = BUBBLE;}
else if (input == "burgers") {
initialCond = InitBURGERS;}
else{
std::cout << " Error:: unknown initial Condition: " << input << std::endl;
exit (0);
}
break;
case SW:
std::cout << " Error:: Not implemented, yet: " << input << std::endl;
exit (0);
break;
case BUCKLEYLEVERETT:
std::cout << " Error:: Not implemented, yet: " << input << std::endl;
exit (0);
break;
case KPP:
fin.entry("y");
fin >> input;
if (input == "KPP") {
initialCond = InitKPP;
}else {
std::cout << " Error:: unknown initial Condition: " << input << std::endl;
exit (0);
}
break;
case KPPY:
fin.entry("y");
fin >> input;
if (input == "KPP") {
initialCond = InitKPP;
}else if (input == "KPPY") {
initialCond = InitKPPY;
}else {
std::cout << " Error:: unknown initial Condition: " << input << std::endl;
exit (0);
}
break;
case KPPX:
fin.entry("y");
fin >> input;
if (input == "KPP") {
initialCond = InitKPP;
}else {
std::cout << " Error:: unknown initial Condition: " << input << std::endl;
exit (0);
}
break;
}
//
//
// fin.entry("density");
// fin.getline (input);
// initial_condition.add ("density", input);
//
// fin.entry ("xvelocity");
// fin.getline (input);
// initial_condition.add ("xvelocity", input);
//
// fin.entry ("yvelocity");
// fin.getline (input);
// initial_condition.add ("yvelocity", input);
//
// fin.entry ("zvelocity");
// fin.getline (input);
// initial_condition.add ("zvelocity", input);
//
// fin.entry ("pressure");
// fin.getline (input);
// initial_condition.add ("pressure", input);
//
//
fin.end_section ();
}
//------------------------------------------------------------------------------
// Read exact solution
//------------------------------------------------------------------------------
void Configuration::read_exact (Reader &fin)
{
std::cout << " Reading exact solution section\n";
std::string input;
fin.begin_section ("exact_soln");
fin.entry("available");
fin >> input;
if(input == "yes")
exact_available = true;
else if(input == "no")
exact_available = false;
else
{
std::cout << " Error:: unknown exact solution availability option: " << input << std::endl;
exit (0);
}
if(exact_available)
{
// fin.entry("density");
// fin.getline (input);
// exact_soln.add ("density", input);
//
// fin.entry ("xvelocity");
// fin.getline (input);
// exact_soln.add ("xvelocity", input);
//
// fin.entry ("yvelocity");
// fin.getline (input);
// exact_soln.add ("yvelocity", input);
//
// fin.entry ("zvelocity");
// fin.getline (input);
// exact_soln.add ("zvelocity", input);
//
// fin.entry ("pressure");
// fin.getline (input);
// exact_soln.add ("pressure", input);
//
// fin.end_section ();
}
else
{
while(!fin.eos())
fin >> input;
}
}
//------------------------------------------------------------------------------
// Read boundary conditions
//------------------------------------------------------------------------------
void Configuration::read_boundary_condition (Reader &fin)
{
std::cout << " Reading boundary condition section\n";
std::string input;
fin.begin_section ("boundary_condition");
fin.entry("bc");
fin >> input;
if(input == "mixedBC")
bcname = MIXEDBC;
else if(input == "periodic")
bcname = PERIODIC;
else if(input == "absorb")
bcname = ABSORBINGBC;
else if(input == "slipWall")
bcname = SLIPWALL;
else if(input == "doubleMachRefBC")
bcname = DOUBLEMACHREF;
else if(input == "FAC")
bcname = FAC;
else if(input == "OpenFlow")
bcname = OPENFLOW;
else if(input == "ScramJet")
bcname = SCRAMJET;
else if(input == "Nozzle")
bcname = NOZZLE;
else
{
std::cout << " Error:: unknown boundary condition: " << input << std::endl;
exit (0);
}
std::string boundary_names[] = {"xleft","xright","yleft","yright","zleft","zright"};
for(int i=0; i<2*dim;++i)
{
fin.begin_section (boundary_names[i]);
fin.entry("type");
fin >> input;
if(input=="periodic")
{
bcType[i] = PERIODIC;
}
else if(input=="dirichlet")
{
bcType[i] = DIRICHLET;
}
else if(input=="donothing")
{
bcType[i] = NEUMANN;
}
else if(input=="slipWall")
{
bcType[i] = SLIPWALL;
}
else if(input == "doubleMachRefBC")
bcType[i] = DOUBLEMACHREF;
else if(input == "absorb")
bcType[i] = ABSORBINGBC;
else if(input == "FAC")
bcType[i] = FAC;
else if(input == "OpenFlow")
bcType[i] = OPENFLOW;
else if(input == "ScramJet")
bcType[i] = SCRAMJET;
else if(input == "Nozzle")
bcType[i] = NOZZLE;
else
{
std::cout << " Error: unknown boundary type " << input << std::endl;
exit (0);
}
if(input == "dirichlet")
{
std::cout << " Error: Dirichlet type BC not implemented yet "<< std::endl;
exit (0);
}
fin.end_section();
}
fin.end_section ();
}
//------------------------------------------------------------------------------
// Read output section
//------------------------------------------------------------------------------
void Configuration::read_output (Reader &fin)
{
std::cout << " Reading output section\n";
std::string input;
fin.begin_section ("output");
// fin.entry("OOC_study");
// fin >> input;
// if(input == "yes")
// OOC = true;
// else if(input == "no")
// OOC = false;
// else
// {
// std::cout << " Error:: unknown OOC_study option: " << input << std::endl;
// exit (0);
// }
// if(OOC && (Nx_cell.size() <2 || Ny_cell.size() < 2))
// {
// std::cout << " Error:: Cannot perform OOC study without at least two mesh levels"<< std::endl;
// exit (0);
// }
//
// if(OOC && !exact_available)
// {
// std::cout << " Error:: Cannot perform OOC study as exact solution not avaible"<<std::endl;
// exit (0);
// }
// fin.entry ("time_stamps");
// fin >> t_stamps;
// assert (t_stamps >= 1);
fin.entry ("output_path");
fin >> OUTPUT_PATH;
fin.end_section ();
}
//------------------------------------------------------------------------------
// Read Import section
//------------------------------------------------------------------------------
void Configuration::read_import (Reader &fin)
{
std::cout << " Reading import section\n";
std::string input;
fin.begin_section ("import");
fin.entry ("import");
fin >> input;
if (input == "true") {
import_sol = true;
}
else{
import_sol = false;
}
fin.entry ("import_path");
fin >> IMPORT_PATH;
fin.end_section ();
}
c4science · Help