diff --git a/CMakeLists.txt b/CMakeLists.txt index 228e93c71654c3f5965cf18a197acfa08d9a292e..6f67595e329ee4dbead9cde5d7938004b7fcca42 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,8 +1,8 @@ cmake_minimum_required(VERSION 3.14) -project(MFIX-Parser - DESCRIPTION "Parser for CSG files for MFiX-Exa" - HOMEPAGE_URL "https://mfix.netl.doe.gov/gitlab/exa/mfix-parser" +project(CSG-EB + DESCRIPTION "Parser for CSG files to define Embedded Boundaries" + HOMEPAGE_URL "https://mfix.netl.doe.gov/gitlab/exa/csg-eb" LANGUAGES CXX ) diff --git a/README.md b/README.md index ca548f41e3fd625ea84f500a74df4688078c5713..5d5a3d5453e40a9cd404dcd85ed1a2ea34c33e93 100644 --- a/README.md +++ b/README.md @@ -1,11 +1,9 @@ -# mfix-parser +# csg-eb Repo for parsing and validating MFIX input(s) files for use by mfix-app. Uses PEGTL for parsing and Catch2 for tests. -This has the MFIX-Exa repo as a submodule in order to test against existing ``inputs`` files. - ## Build diff --git a/meson.build b/meson.build index e3fec93c49f801a398fda6d68d72b3aafcfc8a6c..22344fe4e6b2393a6a25a57144cb161eb671191f 100644 --- a/meson.build +++ b/meson.build @@ -1,4 +1,4 @@ -project('mfix-parser', 'cpp', +project('csg-eb', 'cpp', version : '0.1', default_options : [ 'warning_level=3', @@ -15,10 +15,9 @@ cgal = dependency('cgal', method: 'pkg-config') parser_inc = include_directories('include', 'src') subdir('src/csg') -subdir('src/inputs') parser_dep = declare_dependency( include_directories: parser_inc, - link_with: [lib_csg_parser, lib_inputs_parser], + link_with: lib_csg_parser, dependencies: [cgal], ) diff --git a/src/inputs/geometry.cpp b/src/inputs/geometry.cpp deleted file mode 100644 index f21ae135363457a8ceac9a343a4cdd946237d5a7..0000000000000000000000000000000000000000 --- a/src/inputs/geometry.cpp +++ /dev/null @@ -1,58 +0,0 @@ -#include "solver.hpp" -#include "solver_impl.hpp" - -namespace solver { - -std::pair> -make_geometry(solver::InputInfo ii) { - std::vector messages; - solver::GeometrySettings geo; - - geo.csg_filename = ""; - if (!ii.count(CSG_FILENAME)) { - add_missing_msg(CSG_FILENAME, messages, std::vector{""}); - } else { - auto csg_filename = std::get(ii[CSG_FILENAME]); - if (csg_filename.size() != 1) { - add_msg(CSG_FILENAME, messages, std::vector{""}); - } else { - geo.csg_filename = csg_filename[0]; - } - } - - if (!ii.count(PROB_LO)) { - add_missing_msg(PROB_LO, messages, std::vector{}); - } - if (!ii.count(PROB_HI)) { - add_missing_msg(PROB_HI, messages, std::vector{}); - } - if (!ii.count(PERIODIC)) { - add_missing_msg(PERIODIC, messages, std::vector{0, 0, 0}); - } - auto lows = std::get(ii[PROB_LO]); - auto highs = std::get(ii[PROB_HI]); - auto is_periodic = std::get(ii[PERIODIC]); - if (lows.size() != 3) { - add_msg(PROB_LO, messages, std::vector{0, 0, 0}); - } else { - std::get<0>(geo.axes).low = lows[0]; - std::get<1>(geo.axes).low = lows[1]; - std::get<2>(geo.axes).low = lows[2]; - } - if (highs.size() != 3) { - add_msg(PROB_HI, messages, std::vector{0, 0, 0}); - } else { - std::get<0>(geo.axes).high = highs[0]; - std::get<1>(geo.axes).high = highs[1]; - std::get<2>(geo.axes).high = highs[2]; - } - if (is_periodic.size() != 3) { - add_msg(PERIODIC, messages, std::vector{0, 0, 0}); - } else { - std::get<0>(geo.axes).periodic = is_periodic[0]; - std::get<1>(geo.axes).periodic = is_periodic[1]; - std::get<2>(geo.axes).periodic = is_periodic[2]; - } - return std::make_pair(geo, messages); -} -} // namespace solver diff --git a/src/inputs/mesh.cpp b/src/inputs/mesh.cpp deleted file mode 100644 index db021b85cb677e08c162c3af859fdcfbb5b95c24..0000000000000000000000000000000000000000 --- a/src/inputs/mesh.cpp +++ /dev/null @@ -1,106 +0,0 @@ -#include "solver.hpp" -#include "solver_impl.hpp" - -namespace solver { - -std::pair> -make_mesh(solver::InputInfo ii) { - std::vector messages; - solver::MeshSettings mesh; - auto [mx, my, mz] = mesh.axes; - - if (!ii.count(N_CELL)) { - // NumberArray defaults = std::vector {0}; - add_msg(N_CELL, messages, std::vector{}); - } else { - - auto n_cell = std::get(ii[N_CELL]); - if (n_cell.size() != 3) { - add_msg(N_CELL, messages, std::vector{0, 0, 0}); - } else { - mx.n_cell = n_cell[0]; - my.n_cell = n_cell[1]; - mz.n_cell = n_cell[2]; - } - } - - auto fabarray_size = std::get(ii[FABARRAY_TILE_SZ]); - if (fabarray_size.size() != 3) { - add_msg(FABARRAY_TILE_SZ, messages, std::vector{0, 0, 0}); - } else { - mx.fluid_max_tile_size = fabarray_size[0]; - my.fluid_max_tile_size = fabarray_size[1]; - mz.fluid_max_tile_size = fabarray_size[2]; - } - - auto part_grid_size = std::get(ii[PARTICLE_TILE_SZ]); - if (part_grid_size.size() != 3) { - add_msg(PARTICLE_TILE_SZ, messages, std::vector{0, 0, 0}); - } else { - mx.particle_max_tile_size = part_grid_size[0]; - my.particle_max_tile_size = part_grid_size[1]; - mz.particle_max_tile_size = part_grid_size[2]; - } - - auto grid_size_x = std::get(ii[GRID_SIZE_X]); - if (grid_size_x.size() != 1) { - add_msg(GRID_SIZE_X, messages, std::vector{0}); - } else { - mx.max_grid_size = grid_size_x[0]; - } - auto grid_size_y = std::get(ii[GRID_SIZE_Y]); - if (grid_size_y.size() != 1) { - add_msg(GRID_SIZE_Y, messages, std::vector{0}); - } else { - my.max_grid_size = grid_size_y[0]; - } - auto grid_size_z = std::get(ii[GRID_SIZE_Z]); - if (grid_size_z.size() != 1) { - add_msg(GRID_SIZE_Z, messages, std::vector{0}); - } else { - mz.max_grid_size = grid_size_z[0]; - } - - auto particle_grid_size_x = - std::get(ii[PARTICLE_GRID_SIZE_X]); - if (particle_grid_size_x.size() != 1) { - add_msg(PARTICLE_GRID_SIZE_X, messages, std::vector{0}); - } else { - mx.particle_max_grid_size = particle_grid_size_x[0]; - } - auto particle_grid_size_y = - std::get(ii[PARTICLE_GRID_SIZE_Y]); - if (particle_grid_size_y.size() != 1) { - add_msg(PARTICLE_GRID_SIZE_Y, messages, std::vector{0}); - } else { - my.particle_max_grid_size = particle_grid_size_y[0]; - } - auto particle_grid_size_z = - std::get(ii[PARTICLE_GRID_SIZE_Z]); - if (particle_grid_size_z.size() != 1) { - add_msg(PARTICLE_GRID_SIZE_Z, messages, std::vector{0}); - } else { - mz.particle_max_grid_size = particle_grid_size_z[0]; - } - - auto bf = std::get(ii[BLOCKING_FACTOR]); - if (bf.size() != 1) { - add_msg(BLOCKING_FACTOR, messages, std::vector{0}); - } else { - mesh.blocking_factor = bf[0]; - } - - auto volfrac = std::get(ii[SMALL_VOLFRAC]); - if (volfrac.size() != 1) { - add_msg(SMALL_VOLFRAC, messages, std::vector{0}); - } else { - mesh.small_volfrac = volfrac[0]; - } - - mesh.axes[0] = mx; - mesh.axes[1] = my; - mesh.axes[2] = mz; - - return std::make_pair(mesh, messages); -} -} // namespace solver diff --git a/src/inputs/meson.build b/src/inputs/meson.build deleted file mode 100644 index ecc738394d6cad8c26466dabb75f11b485963478..0000000000000000000000000000000000000000 --- a/src/inputs/meson.build +++ /dev/null @@ -1,21 +0,0 @@ -lib_inputs_parser = static_library( - 'inputs-parser', - 'geometry.cpp', - 'mesh.cpp', - 'parser.cpp', - 'solver.cpp', - 'time.cpp', - include_directories: parser_inc, - dependencies: [pegtl], - install : true) - -executable( - 'mfix-parser', - 'mfix-parser.main.cpp', - include_directories: parser_inc, - link_with: [ - lib_csg_parser, - lib_inputs_parser, - ]) - -subdir('tests') diff --git a/src/inputs/mfix-parser.main.cpp b/src/inputs/mfix-parser.main.cpp deleted file mode 100644 index 2e925c7345bcd72f6440710f8eb64b1314a90a74..0000000000000000000000000000000000000000 --- a/src/inputs/mfix-parser.main.cpp +++ /dev/null @@ -1,28 +0,0 @@ -#include -#include -#include - -#include "solver.hpp" - -std::string read_file(std::string inputs_file) { - std::ifstream in_stream; - in_stream.open(inputs_file.c_str()); - - std::stringstream str_stream; - str_stream << in_stream.rdbuf(); - return str_stream.str(); -} - -int main(int argc, char *argv[]) { - if (argc < 2) { - std::cout << "Usage: mfix-parser "; - return -1; - } - std::string fname(argv[1]); - auto inputs_str = read_file(fname); - auto maybe_success = solver::parse_inputs(inputs_str); - if (maybe_success.has_value()) { - return 0; - } - return -1; -} diff --git a/src/inputs/parser.cpp b/src/inputs/parser.cpp deleted file mode 100644 index 68a65c2f84a72729a347849a2af24ddef3d0428f..0000000000000000000000000000000000000000 --- a/src/inputs/parser.cpp +++ /dev/null @@ -1,166 +0,0 @@ -// standard includes -#include -#include -#include - -// subproject includes -#include - -// includes -#include "solver.hpp" - -using namespace tao::pegtl; - -namespace { - -struct parser_state { - std::string current_key; - std::variant, std::vector> current_value; - std::vector current_num_vec; - std::vector current_str_vec; - solver::InputInfo info; -}; - -} // namespace - -namespace { - -struct escaped_x : seq, rep<2, must>> {}; -struct escaped_u : seq, rep<4, must>> {}; -struct escaped_U : seq, rep<8, must>> {}; -struct escaped_c - : one<'\'', '"', '?', '\\', 'a', 'b', 'f', 'n', 'r', 't', 'v'> {}; - -struct escaped : sor {}; - -struct key : plus, one<'_'>, one<'-'>, one<'.'>>> {}; - -struct character - : if_must_else, escaped, utf8::range<0x20, 0x10FFFF>> {}; -struct quoted_string : if_must, until, character>> {}; -struct unquoted_string : key {}; -struct string_literal : sor {}; - -struct plus_minus : opt> {}; -struct dot : one<'.'> {}; - -struct decimal - : if_then_else, seq, opt>>> { -}; -struct e : one<'e', 'E'> {}; -struct p : one<'p', 'P'> {}; -struct exponent : seq> {}; -struct double_ : seq> {}; - -struct num_array : list> {}; -struct str_array : list> {}; - -struct value : sor {}; -struct comment : if_must, until> {}; - -struct value_item : pad {}; -struct value_list : list_must> {}; -struct keyval_line - : if_must, string<'='>, value_list, sor> {}; -struct comment_line : seq, until> {}; -struct blank_line : seq, until> {}; -struct line : sor {}; -struct grammar : until {}; - -template struct action {}; - -template <> struct action { - template - static void apply(const Input &in, parser_state &st) { - std::stringstream ss(in.string()); - ss >> st.current_key; - } -}; - -template <> struct action { - template - static void apply(const Input &in, parser_state &st) { - std::stringstream ss(in.string()); - std::string v; - ss >> v; - auto str_val = v.substr(1, v.length() - 2); // strip quotes - st.current_str_vec.push_back(str_val); - } -}; - -template <> struct action { - template - static void apply(const Input &in, parser_state &st) { - std::stringstream ss(in.string()); - std::string v; - ss >> v; - st.current_str_vec.push_back(v); - } -}; - -template <> struct action { - template - static void apply(const Input &in, parser_state &st) { - std::stringstream ss(in.string()); - double v; - ss >> v; - st.current_num_vec.push_back(v); - } -}; - -template <> struct action { - template - static void apply(const Input &in, parser_state &st) { - std::stringstream ss(in.string()); - st.current_value = st.current_num_vec; - st.current_num_vec.clear(); - } -}; - -template <> struct action { - template - static void apply(const Input &in, parser_state &st) { - std::stringstream ss(in.string()); - st.current_value = st.current_str_vec; - st.current_str_vec.clear(); - } -}; - -template <> struct action { - template - static void apply(const Input &in, parser_state &st) { - std::stringstream ss(in.string()); - st.info[st.current_key] = st.current_value; - } -}; - -std::optional do_parse(std::string str) { - parser_state st; - memory_input in(str, "std::cin"); - - try { - if (!parse(in, st)) { - return std::nullopt; - } - } catch (const parse_error &e) { - const auto p = e.positions.front(); - std::cerr << e.what() << std::endl - << in.line_at(p) << std::endl - << std::string(p.byte_in_line, ' ') << '^' << std::endl; - } - - return st; -} - -} // namespace - -namespace solver { - -std::optional parse_inputs(std::string str) { - auto maybe_state = do_parse(str); - if (!maybe_state.has_value()) { - return std::nullopt; - } - return maybe_state.value().info; -} -} // namespace solver diff --git a/src/inputs/solver.cpp b/src/inputs/solver.cpp deleted file mode 100644 index 8576946d5b158b60f4e9f42d5ec29db1f29cbaa5..0000000000000000000000000000000000000000 --- a/src/inputs/solver.cpp +++ /dev/null @@ -1,90 +0,0 @@ -#include - -#include "solver.hpp" -#include "solver_impl.hpp" - -namespace solver { - -void add_missing_msg(std::string key, std::vector &messages, - Array defaults) { - std::ostringstream oss; - - oss << key << " is missing; using defaults: "; - if (auto sarray = std::get_if(&defaults)) { - for (auto def : *sarray) { - oss << def << " "; - } - } else if (auto narray = std::get_if(&defaults)) { - for (auto def : *narray) { - oss << def << " "; - } - } - messages.push_back(InputsMessage{oss.str()}); -} - -void add_msg(std::string key, std::vector &messages, - Array defaults) { - std::ostringstream oss; - std::ostringstream defs; - int size = 0; - - if (auto sarray = std::get_if(&defaults)) { - size = sarray->size(); - for (auto def : *sarray) { - defs << def << " "; - } - } else if (auto narray = std::get_if(&defaults)) { - size = narray->size(); - for (auto def : *narray) { - defs << def << " "; - } - } - - if (size == 1) { - oss << key << " should be a scalar; using defaults: "; - } else { - oss << key << " should have " << size << " elements; using defaults"; - } - oss << defs.str(); - messages.push_back(InputsMessage{oss.str()}); -} - -std::pair> -make_solver(solver::InputInfo ii) { - solver::SolverSettings ss; - auto [geometry, msgs] = make_geometry(ii); - auto [mesh, msgs2] = make_mesh(ii); - auto [time, msgs3] = make_time(ii); - ss.geometry = geometry; - ss.mesh = mesh; - ss.time = time; - std::vector messages; - for (auto msgz : - std::vector>{msgs, msgs2, msgs3}) { - for (auto msg : msgz) { - messages.push_back(msg); - } - } - return std::make_pair(ss, messages); -} - -std::string serialize(solver::SolverSettings settings) { - - std::stringstream buffer; - - auto [xx, yy, zz] = settings.geometry.axes; - buffer << std::endl; - buffer << " geometry.is_periodic = " << xx.periodic << " " << yy.periodic - << " " << zz.periodic << std::endl; - buffer << " geometry.prob_lo = " << xx.low << " " << yy.low << " " - << zz.low << std::endl; - buffer << " geometry.prob_hi = " << xx.high << " " << yy.high << " " - << zz.high << std::endl; - - auto [mx, my, mz] = settings.mesh.axes; - buffer << " amr.n_cell = " << mx.n_cell << " " << my.n_cell << " " - << mz.n_cell; - return buffer.str(); -} - -} // namespace solver diff --git a/src/inputs/tests/meson.build b/src/inputs/tests/meson.build deleted file mode 100644 index 68dfcaf0e2114b326b92b73141a58e93fb6ca936..0000000000000000000000000000000000000000 --- a/src/inputs/tests/meson.build +++ /dev/null @@ -1,10 +0,0 @@ -test_inputs = executable( - 'unit_tests_inputs', - 'parser.t.cpp', - 'solver.t.cpp', - 'unit_tests_inputs.main.cpp', - include_directories: [parser_inc], - dependencies: [catch2], - link_with: lib_inputs_parser -) -test('unit_test_inputs', test_inputs) diff --git a/src/inputs/tests/parser.t.cpp b/src/inputs/tests/parser.t.cpp deleted file mode 100644 index 2d6860efaa3b8f024e51b324fae3ac0874e69c43..0000000000000000000000000000000000000000 --- a/src/inputs/tests/parser.t.cpp +++ /dev/null @@ -1,349 +0,0 @@ -#include "catch2/catch.hpp" - -#include - -TEST_CASE("comment", "[]") { - auto maybe_st = solver::parse_inputs(R"( -# this is a comment -)"); - CHECK(maybe_st.has_value()); -} - -TEST_CASE("integer", "[]") { - auto maybe_st = solver::parse_inputs(R"( -mfix.max_step = 100 -)"); - REQUIRE(maybe_st.has_value()); - auto info = maybe_st.value(); - auto value = info["mfix.max_step"]; - auto aa = std::get(value); - CHECK(aa.size() == 1); - CHECK(aa[0] == 100); -} - -TEST_CASE("double", "[]") { - auto maybe_st = solver::parse_inputs(R"( -mfix.stop_time = 0.20 -)"); - REQUIRE(maybe_st.has_value()); - auto info = maybe_st.value(); - auto value = info["mfix.stop_time"]; - auto aa = std::get(value); - CHECK(aa.size() == 1); - CHECK(aa[0] == 0.2); -} - -TEST_CASE("string", "[]") { - auto maybe_st = solver::parse_inputs(R"( - mfix.particle_init_type = "Auto" -)"); - REQUIRE(maybe_st.has_value()); - auto info = maybe_st.value(); - auto value = info["mfix.particle_init_type"]; - auto ss = std::get(value); - CHECK(ss.size() == 1); - CHECK(ss[0] == "Auto"); -} - -TEST_CASE("implicit string", "[]") { - auto maybe_st = solver::parse_inputs(R"( -fluid.solve = fluid -)"); - REQUIRE(maybe_st.has_value()); - auto info = maybe_st.value(); - auto value = info["fluid.solve"]; - auto ss = std::get(value); - CHECK(ss.size() == 1); - CHECK(ss[0] == "fluid"); -} - -TEST_CASE("tabbed array", "[]") { - auto maybe_st = solver::parse_inputs(R"( - amr.avg_vel_p = 0 0 0 -)"); - - REQUIRE(maybe_st.has_value()); - auto info = maybe_st.value(); - auto value = info["amr.avg_vel_p"]; - auto aa = std::get(value); - CHECK(aa.size() == 3); - CHECK(aa[0] == 0.0); - CHECK(aa[1] == 0.0); - CHECK(aa[2] == 0.0); -} - -TEST_CASE("double array", "[]") { - auto maybe_st = solver::parse_inputs(R"( - mfix.gravity = -9.81 0.0 0.0 -)"); - - REQUIRE(maybe_st.has_value()); - auto info = maybe_st.value(); - auto value = info["mfix.gravity"]; - auto aa = std::get(value); - CHECK(aa.size() == 3); - CHECK(aa[0] == -9.81); - CHECK(aa[1] == 0.0); - CHECK(aa[2] == 0.0); -} - -TEST_CASE("string array", "[]") { - auto maybe_st = solver::parse_inputs(R"( - mfix.regions = abc ijk xyz -)"); - - REQUIRE(maybe_st.has_value()); - auto info = maybe_st.value(); - auto value = info["mfix.regions"]; - auto aa = std::get(value); - CHECK(aa.size() == 3); - CHECK(aa[0] == "abc"); - CHECK(aa[1] == "ijk"); - CHECK(aa[2] == "xyz"); -} - -TEST_CASE("multiple arrays", "[]") { - auto maybe_st = solver::parse_inputs(R"( -geometry.prob_lo = -4 -1 -2 -geometry.prob_hi = 0.004 0.001 0.001 -geometry.is_periodic = 1 0 1 -)"); - - REQUIRE(maybe_st.has_value()); - auto info = maybe_st.value(); - CHECK(info.count("geometry.prob_hi")); - CHECK(info.count("geometry.prob_lo")); - CHECK(info.count("geometry.is_periodic")); - - auto highs = info["geometry.prob_lo"]; - auto aa = std::get(highs); - CHECK(aa.size() == 3); - CHECK(aa[0] == -4); - CHECK(aa[1] == -1); - CHECK(aa[2] == -2); - - auto lows = info["geometry.prob_hi"]; - auto bb = std::get(lows); - CHECK(bb.size() == 3); - CHECK(bb[0] == 0.004); - CHECK(bb[1] == 0.001); - CHECK(bb[2] == 0.001); - - auto pers = info["geometry.is_periodic"]; - auto cc = std::get(pers); - CHECK(cc.size() == 3); - CHECK(cc[0] == 1); - CHECK(cc[1] == 0); - CHECK(cc[2] == 1); -} - -TEST_CASE("whole_file", "[]") { - auto maybe_st = solver::parse_inputs(R"( - -#_______________________________________________________________________ -# Solver settings - -#amrex.fpe_trap_invalid = 1 - -#! Fluid solver -#!-----------------------------------------------------------// -mfix.cfl = 0.5 - -mfix.max_step = 100 -#mfix.stop_time = 0.20 - -mfix.particle_init_type = "Auto" - -mfix.gravity = -9.81 0.0 0.0 - -mfix.drag_type = "BVK2" - -mac_proj.verbose = 0 -nodal_proj.verbose = 1 - -amr.blocking_factor = 1 - -#_______________________________________________________________________ -# Geometry / grids / tiles - -# Maximum level in hierarchy (for now must be 0, i.e., one level in total) -amr.max_level = 0 - -geometry.coord_sys = 0 # 0: Cartesian -geometry.is_periodic = 0 0 0 # Is periodic in each direction? -geometry.prob_lo = 0. 0. 0. # lo corner of physical domain -geometry.prob_hi = 0.004 0.001 0.001 # hi corner of physical domain - -# Number of grid cells in each direction at the coarsest level -amr.n_cell = 20 5 5 - -#! Grids -#!-----------------------------------------------------------// -# Maximum allowable size of each fluid subdomain in the problem domain; - -# Fluid -amr.max_grid_size_x = 1024 -amr.max_grid_size_y = 1024 -amr.max_grid_size_z = 1024 - -# Particles (not with KDTree) -#particles.max_grid_size_x = 32 -#particles.max_grid_size_y = 32 -#particles.max_grid_size_z = 32 - -#! Tiles -#!-----------------------------------------------------------// - -# Fluid: Maximum tile size within each grid -fabarray.mfiter_tile_size = 1024 1024 1024 - -# Particles: Maximum particle title size -particles.tile_size = 1024 1024 1024 - - -#! EB settings -#!-----------------------------------------------------------// - -# Level-set refinement and padding -mfix.levelset__refinement = 4 # levelset resolution - -mfix.write_eb_surface = true # Needed to output eb-surfaces - - -#_______________________________________________________________________ -# Particle load balancing - -#mfix.load_balance_type = "KnapSack" - -amr.dual_grid = 0 -amr.regrid_int = -1 - -#! KnapSack settings -#!-----------------------------------------------------------// -#default is "RunTimeCosts"; options include RunTimeCosts or NumParticles -#this option is only relevant if load_balance_type = KnapSack - -#mfix.knapsack_weight_type = "NumParticles" -#mfix.knapsack_weight_type = "RunTimeCosts" - -#_______________________________________________________________________ -# IO / Checkpointing - -amr.par_ascii_int = -1 -amr.par_ascii_file ="vis" - -amr.plot_int = -1 -amr.plot_file ="plt" - -amr.check_int = -1 -amr.check_file ="chk" - -#! Restart from checkpoint -#!-----------------------------------------------------------// -#amr.restart ="chk00100" - - -#_______________________________________________________________________ -# Fluid model settings -# -fluid.solve = fluid - -fluid.density = constant -fluid.density.constant = 1.0 - -fluid.viscosity = constant -fluid.viscosity.constant = 2.0e-5 - - -#_______________________________________________________________________ -# DEM model settings -# -dem.solve = solid0 - -dem.friction_coeff.pp = 0.0 -dem.friction_coeff.pw = 0.0 - -dem.spring_const.pp = 10.0 -dem.spring_const.pw = 10.0 - -dem.restitution_coeff.solid0.solid0 = 0.8 -dem.restitution_coeff.solid0.wall = 1.0 - -dem.spring_tang_fac.pp = 0.285714285 -dem.spring_tang_fac.pw = 0.285714285 - -dem.damping_tang_fac.pp = 0.5 -dem.damping_tang_fac.pw = 0.5 - - -#_______________________________________________________________________ -# EB geometry -# -mfix.geometry = "cylinder" - -cylinder.internal_flow = true - -cylinder.radius = 0.00045 -cylinder.height = -1.0 - -cylinder.direction = 0 -cylinder.center = 0.0020 0.0005 0.0005 - - -#_______________________________________________________________________ -# Regions for defining ICs and BCs -# -mfix.regions = full-domain bed inflow outflow - -regions.full-domain.lo = 0.0000 0.0000 0.0000 -regions.full-domain.hi = 0.0040 0.0010 0.0010 - -regions.bed.lo = 0.0003 0.0000 0.0000 -regions.bed.hi = 0.0032 0.0010 0.0010 - -regions.inflow.lo = 0.0000 0.0000 0.0000 -regions.inflow.hi = 0.0000 0.0010 0.0010 - -regions.outflow.lo = 0.0040 0.0000 0.0000 -regions.outflow.hi = 0.0040 0.0010 0.0010 - -#_______________________________________________________________________ -# Initial Conditions -# -ic.regions = full-domain bed - -ic.full-domain.fluid.volfrac = 1.0 -ic.full-domain.fluid.velocity = 0.015 0.0 0.0 - -ic.bed.fluid.volfrac = 0.725 -ic.bed.fluid.velocity = 0.00 0.00 0.00 - -ic.bed.solids = solid0 -ic.bed.packing = random - -ic.bed.solid0.volfrac = 0.275 -ic.bed.solid0.velocity = 0.00 0.00 0.00 - -ic.bed.solid0.diameter = constant -ic.bed.solid0.density = constant - -ic.bed.solid0.diameter.constant = 100.0e-6 -ic.bed.solid0.density.constant = 1000.0 - - -#_______________________________________________________________________ -# Boundary Conditions -# -bc.regions = inflow outflow - -bc.inflow = mi -bc.inflow.fluid.volfrac = 1.0 -bc.inflow.fluid.velocity = 0.015 0.0 0.0 - - -bc.outflow = po -bc.outflow.fluid.pressure = 0.0 - -)"); - CHECK(maybe_st.has_value()); -} diff --git a/src/inputs/tests/solver.t.cpp b/src/inputs/tests/solver.t.cpp deleted file mode 100644 index 8797121abf9ff07e873266c2af857990eaaa999b..0000000000000000000000000000000000000000 --- a/src/inputs/tests/solver.t.cpp +++ /dev/null @@ -1,121 +0,0 @@ -#include "catch2/catch.hpp" - -#include -#include - -TEST_CASE("GeometrySettings", "[]") { - solver::InputInfo ii; - - ii[PROB_LO] = std::vector({-4, -5, -6}); - ii[PROB_HI] = solver::NumberArray({0.004, 0.001, 0.001}); - ii[PERIODIC] = solver::NumberArray({1, 0, 0}); - ii[CSG_FILENAME] = solver::StringArray({ - "geometry.csg", - }); - - auto [geo, messages] = solver::make_geometry(ii); - - auto [xx, yy, zz] = geo.axes; - CHECK(xx.high == 0.004); - CHECK(xx.low == -4); - CHECK(yy.high == 0.001); - CHECK(yy.low == -5); - CHECK(zz.high == 0.001); - CHECK(zz.low == -6); - CHECK(xx.periodic); - CHECK_FALSE(yy.periodic); - CHECK_FALSE(zz.periodic); - CHECK(geo.csg_filename == "geometry.csg"); -} - -TEST_CASE("MeshSettings", "[]") { - solver::InputInfo ii; - - // Mesh - ii[N_CELL] = solver::NumberArray({11, 22, 33}); - ii[BLOCKING_FACTOR] = solver::NumberArray({222}); - ii[SMALL_VOLFRAC] = solver::NumberArray({0.000999}); - ii[FABARRAY_TILE_SZ] = solver::NumberArray({1234, 4567, 7890}); - ii[PARTICLE_TILE_SZ] = solver::NumberArray({333, 444, 555}); - ii[GRID_SIZE_X] = solver::NumberArray({24}); - ii[GRID_SIZE_Y] = solver::NumberArray({25}); - ii[GRID_SIZE_Z] = solver::NumberArray({26}); - ii[PARTICLE_GRID_SIZE_X] = solver::NumberArray({94}); - ii[PARTICLE_GRID_SIZE_Y] = solver::NumberArray({95}); - ii[PARTICLE_GRID_SIZE_Z] = solver::NumberArray({96}); - - auto [mesh, messages] = solver::make_mesh(ii); - - SECTION(" Mesh fields ") { - CHECK(mesh.blocking_factor == 222); - auto [mx, my, mz] = mesh.axes; - CHECK(mx.n_cell == 11); - CHECK(my.n_cell == 22); - CHECK(mz.n_cell == 33); - CHECK(mx.max_grid_size == 24); - CHECK(my.max_grid_size == 25); - CHECK(mz.max_grid_size == 26); - CHECK(mx.particle_max_grid_size == 94); - CHECK(my.particle_max_grid_size == 95); - CHECK(mz.particle_max_grid_size == 96); - CHECK(mx.particle_max_tile_size == 333); - CHECK(my.particle_max_tile_size == 444); - CHECK(mz.particle_max_tile_size == 555); - CHECK(mx.fluid_max_tile_size == 1234); - CHECK(my.fluid_max_tile_size == 4567); - CHECK(mz.fluid_max_tile_size == 7890); - } -} - -TEST_CASE("TimeSettings", "[]") { - solver::InputInfo ii; - - // Time - ii[DT_MAX] = solver::NumberArray({99.99}); - ii[DT_MIN] = solver::NumberArray({0.001}); - ii[MAXSTEP] = solver::NumberArray({39}); - ii[TSTOP] = solver::NumberArray({3.14}); - ii[FIXED_DT] = solver::NumberArray({1}); - ii[CFL] = solver::NumberArray({0.77}); - ii[TCOLL_RATIO] = solver::NumberArray({49.2}); - - auto [time, messages] = solver::make_time(ii); - - SECTION(" Time fields ") { - CHECK(time.dt_max == 99.99); - CHECK(time.dt_min == 0.001); - CHECK(time.max_step == 39); - CHECK(time.tstop == 3.14); - CHECK(time.fixed_dt); - CHECK(time.cfl == 0.77); - CHECK(time.tcoll_ratio == 49.2); - } -} - -TEST_CASE("serialize", "[]") { - solver::SolverSettings ss; - - std::get<0>(ss.geometry.axes).periodic = 0; - std::get<1>(ss.geometry.axes).periodic = 1; - std::get<2>(ss.geometry.axes).periodic = 0; - - std::get<0>(ss.geometry.axes).low = 0; - std::get<1>(ss.geometry.axes).low = 0; - std::get<2>(ss.geometry.axes).low = 0; - - std::get<0>(ss.geometry.axes).high = 0.004; - std::get<1>(ss.geometry.axes).high = 0.001; - std::get<2>(ss.geometry.axes).high = 0.001; - - std::get<0>(ss.mesh.axes).n_cell = 11; - std::get<1>(ss.mesh.axes).n_cell = 22; - std::get<2>(ss.mesh.axes).n_cell = 33; - - auto inputs_str = serialize(ss); - - CHECK(inputs_str == R"( - geometry.is_periodic = 0 1 0 - geometry.prob_lo = 0 0 0 - geometry.prob_hi = 0.004 0.001 0.001 - amr.n_cell = 11 22 33)"); -} diff --git a/src/inputs/tests/unit_tests_inputs.main.cpp b/src/inputs/tests/unit_tests_inputs.main.cpp deleted file mode 100644 index fc72584f1b1bd7c8bc9414ccee5fd417b547cae5..0000000000000000000000000000000000000000 --- a/src/inputs/tests/unit_tests_inputs.main.cpp +++ /dev/null @@ -1,2 +0,0 @@ -#define CATCH_CONFIG_MAIN // Catch main() - only add to one cpp file -#include "catch2/catch.hpp" diff --git a/src/inputs/time.cpp b/src/inputs/time.cpp deleted file mode 100644 index 000dda197e02b54954841320fb1f9587a0fa23ed..0000000000000000000000000000000000000000 --- a/src/inputs/time.cpp +++ /dev/null @@ -1,64 +0,0 @@ -#include "solver_impl.hpp" - -namespace solver { - -std::pair> -make_time(solver::InputInfo ii) { - std::vector messages; - solver::TimeSettings time; - - auto dt_max = std::get(ii[DT_MAX]); - if (dt_max.size() != 1) { - add_msg(DT_MAX, messages, std::vector{0}); - } else { - time.dt_max = dt_max[0]; - } - - auto dt_min = std::get(ii[DT_MIN]); - if (dt_min.size() != 1) { - add_msg(DT_MIN, messages, std::vector{0}); - } else { - time.dt_min = dt_min[0]; - } - - auto maxstep = std::get(ii[MAXSTEP]); - if (maxstep.size() != 1) { - add_msg(MAXSTEP, messages, std::vector{0}); - } else { - time.max_step = maxstep[0]; - } - - if (!ii.count(TSTOP)) { - add_msg(TSTOP, messages, std::vector{0}); - } - auto tstop = std::get(ii[TSTOP]); - if (tstop.size() != 1) { - add_msg(TSTOP, messages, std::vector{0}); - } else { - time.tstop = tstop[0]; - } - - auto fixed_dt = std::get(ii[FIXED_DT]); - if (fixed_dt.size() != 1) { - add_msg(FIXED_DT, messages, std::vector{0}); - } else { - time.fixed_dt = (fixed_dt[0] != 0); - } - - auto cfl = std::get(ii[CFL]); - if (cfl.size() != 1) { - add_msg(CFL, messages, std::vector{0}); - } else { - time.cfl = cfl[0]; - } - - auto tcoll_ratio = std::get(ii[TCOLL_RATIO]); - if (tcoll_ratio.size() != 1) { - add_msg(TCOLL_RATIO, messages, std::vector{0}); - } else { - time.tcoll_ratio = tcoll_ratio[0]; - } - - return std::make_pair(time, messages); -} -} // namespace solver