diff --git a/.gitignore b/.gitignore index b9ec77d5..1f4be394 100644 --- a/.gitignore +++ b/.gitignore @@ -148,12 +148,19 @@ moose/include/base/Precompiled.h.gch # clang .clangd +# direnv +.envrc + # OpenFOAM mesh object files test/**/*.obj # downloaded mesh tarballs test/tests/**/*.tar.gz +# OpenFOAM build files +test/OpenFOAM/**/lnInclude +test/OpenFOAM/**/linux* + framework/contrib/exodiff/exodiff # Mac garbage diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index c24d3f5f..fdb7c938 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -31,3 +31,4 @@ repos: hooks: - id: remove-crlf - id: forbid-tabs + exclude: '.*\.mk$' diff --git a/Makefile b/Makefile index 5211c653..c809995e 100644 --- a/Makefile +++ b/Makefile @@ -60,3 +60,8 @@ include $(FRAMEWORK_DIR)/app.mk ############################################################################### # Additional special case targets should be added here + +# Add foam modules +# TODO: Reorganise build: consider single mk for all OpenFOAM modules +# as they are written. +include test/OpenFOAM/foam_modules.mk diff --git a/doc/content/step_by_step.md b/doc/content/step_by_step.md index b5772589..f999fc12 100644 --- a/doc/content/step_by_step.md +++ b/doc/content/step_by_step.md @@ -68,6 +68,19 @@ For more info on the OpenFOAM case structure, see the ## Write a MOOSE Input File for the OpenFOAM Case +### Problem + +First, we define the `Problem` block, which tells Hippo we are running an OpenFOAM case +and provides the functionality to couple OpenFOAM into the MOOSE framework. + +```toml +# fluid.i + +[Problem] + type = FoamProblem +[] +``` + ### Mesh The first block to define is the mesh block. @@ -95,72 +108,54 @@ $ hippo-opt -i fluid.i --mesh-only $ paraview fluid_in.e ``` -### Auxiliary Variables +### Transferring data from OpenFOAM to MOOSE -To transfer quantities between the OpenFOAM and MOOSE solves, -you must use MOOSE's -[AuxVariable system](https://mooseframework.inl.gov/syntax/AuxVariables/). -For this problem we need two variables, -one for the solid heat flux and one for the fluid wall temperature. +To access OpenFOAM variables from MOOSE, Hippo provides the `FoamVariable` system, +which allows you to shadow OpenFOAM volume fields and function objects with MOOSE variables, +which are automatically updated after each OpenFOAM solve. For this problem, +the fluid temperature is required by MOOSE. In OpenFOAM, the temperature is stored +in the `volScalarField` named `T`: -At present, all AuxVariables used for these transfers must -be constant and monomial. ```toml # fluid.i -[AuxVariables] +[FoamVariables] [fluid_wall_temp] - family = MONOMIAL - order = CONSTANT - initial_condition = 300 - [] - [solid_heat_flux] - family = MONOMIAL - order = CONSTANT - initial_condition = 0 + type = FoamVariableField + foam_variable = T [] [] ``` +Internally, Hippo creates `AuxVariable`s which can use MOOSE's transfer system +and so can be transferred between MOOSE apps. -> +Note:+ *To save on memory, you could actually define a single AuxVariable -> and transfer the heat flux one way and temperature the other in the same -> variable. However, for clarity, we use separate variables here.* - -### Problem - -Next we define the 'Problem' block. -Hippo provides the `FoamProblem` class to run the OpenFOAM case -provided in the `[Mesh]` block. +### Imposing boundary conditions on OpenFOAM from MOOSE -`FoamProblem` has a set of parameters that defines which quantities are -copied to and from OpenFOAM: - -- `foam_heat_flux` - - the name of the AuxVariable to copy OpenFOAM's heat flux into. -- `foam_temp` - - the name of the AuxVariable to copy OpenFOAM's wall temperature into. -- `temp` - - the name of an AuxVariable whose values will be used to set - a Dirichlet boundary condition on the OpenFOAM solve. -- `heat_flux` - the name of an AuxVariable whose values will be used to set - a Neumann boundary condition on the OpenFOAM solve. - -In our example, we'll need to set `heat_flux` and `foam_temp`. +Hippo also implements the `FoamBC` system that allows you to impose boundary conditions +on OpenFOAM from the Hippo input file. In this case, we wish to impose a heat flux BC +on the temperature field. This requires the `FoamFixedGradientBC`, which mirrors OpenFOAM's +`fixedGradient` BC type. As in this case, we provide a heat flux, we must also provide the +thermal conductivity, which is specified as the `diffusivity_coefficient`. +`kappa` is the name of the thermal conductivity variable in OpenFOAM. ```toml # fluid.i -[Problem] - type = FoamProblem - # Take the heat flux from MOOSE and set it on the OpenFOAM mesh. - heat_flux = solid_heat_flux - # Take the boundary temperature from OpenFOAM and set it on the MOOSE mesh. - foam_temp = fluid_wall_temp +[FoamBCs] + [solid_heat_flux] + type = FoamFixedGradientBC + foam_variable = T + diffusivity_coefficient = kappa + [] [] ``` +Similar to `FoamVariable`, this creates an `AuxVariable` with name `solid_heat_flux` +under the hood. +MOOSE's transfers system can be used to set the values in the `AuxVariable`, +that are then imposed on the OpenFOAM solver's boundary. + ### Executioner Set the time step settings in the `Executioner` block. @@ -372,6 +367,7 @@ To couple the solves we're going to: [Transfers] # Copy the wall temperature from the fluid into an AuxVariable. + # This was stored in the FoamVariable fluid_wall_temp [wall_temperature_from_fluid] type = MultiAppGeometricInterpolationTransfer source_variable = fluid_wall_temp @@ -381,9 +377,7 @@ To couple the solves we're going to: [] # Copy the heat flux from the 'wall_heat_flux' aux variable into the - # multiapp. - # Remember we marked the 'solid_heat_flux' variable in 'fluid.i' to be - # used as a heat flux boundary condition on the OpenFOAM solve. + # 'solid_heat_flux' FoamBC in the multiapp. [heat_flux_to_fluid] type = MultiAppGeometricInterpolationTransfer source_variable = wall_heat_flux diff --git a/include/actions/AddFoamBCAction.h b/include/actions/AddFoamBCAction.h new file mode 100644 index 00000000..cc90072b --- /dev/null +++ b/include/actions/AddFoamBCAction.h @@ -0,0 +1,18 @@ +#pragma once + +#include "InputParameters.h" +#include "MooseObjectAction.h" + +class AddFoamBCAction : public MooseObjectAction +{ +public: + static InputParameters validParams(); + + AddFoamBCAction(const InputParameters & parameters); + + virtual void act() override; + +protected: + // Create AuxVariable associated with new-style BCs + void createAuxVariable(); +}; diff --git a/include/actions/AddFoamVariableAction.h b/include/actions/AddFoamVariableAction.h new file mode 100644 index 00000000..36e1e2ae --- /dev/null +++ b/include/actions/AddFoamVariableAction.h @@ -0,0 +1,18 @@ +#pragma once + +#include "InputParameters.h" +#include "MooseObjectAction.h" + +class AddFoamVariableAction : public MooseObjectAction +{ +public: + static InputParameters validParams(); + + AddFoamVariableAction(const InputParameters & parameters); + + virtual void act() override; + +protected: + // Create AuxVariable associated with new-style variable shadowing + void createAuxVariable(); +}; diff --git a/include/base/FoamSolver.h b/include/base/FoamSolver.h index 0bb132f9..ee42cca0 100644 --- a/include/base/FoamSolver.h +++ b/include/base/FoamSolver.h @@ -44,18 +44,8 @@ class FoamSolver // Run a timestep of the OpenFOAM solver. void run(); - - // Append temperature values from the OpenFOAM patch (boundary) to the end of - // the given vector. - std::size_t appendPatchTemperatures(int patch_id, std::vector & foam_t); // Return the number of faces in the given patch (boundary). std::size_t patchSize(int patch_id); - // Set the temperature values of the OpenFOAM patch (boundary). - void setPatchTemperatures(int patch_id, const std::vector & moose_t); - // Set the negative heat flux values on the OpenFOAM patch (boundary). - void setPatchNegativeHeatFlux(int patch_id, std::vector & negative_hf); - // Get or calculate the wall heat flux for the given patch. - std::size_t wallHeatFlux(int patch_id, std::vector & fill_vector); // Set the solver's time step size. void setTimeDelta(double dt) { runTime().setDeltaTNoAdjust(dt); } // Set the solver to the given time. diff --git a/include/bcs/FoamBCBase.h b/include/bcs/FoamBCBase.h new file mode 100644 index 00000000..11b865ee --- /dev/null +++ b/include/bcs/FoamBCBase.h @@ -0,0 +1,50 @@ +#pragma once + +#include "FoamMesh.h" + +#include +#include +#include +#include +#include + +class FoamBCBase : public MooseObject, public Coupleable +{ +public: + static InputParameters validParams(); + + explicit FoamBCBase(const InputParameters & params); + + virtual void imposeBoundaryCondition() = 0; + + // returns foam variable BC applies to + std::string foamVariable() const { return _foam_variable; }; + + // returns the moose AuxVariable imposed on OpenFOAM + AuxVariableName mooseVariable() const { return _moose_var->name(); } + + // returns the name of the foam boundaries the BC applies to + std::vector boundary() const { return _boundary; }; + + virtual void initialSetup(); + +protected: + // OpenFOAM variable which this BC is to be imposed on + std::string _foam_variable; + + // Get the value of the MOOSE variable at an element + Real variableValueAtElement(const libMesh::Elem * elem); + + // Get the data vector of the MOOSE field on a subdomain + std::vector getMooseVariableArray(int subdomain_id); + + // Pointer to Moose variable used to impose BC + MooseVariableFieldBase * _moose_var; + + // Pointer to the FoamMesh object + FoamMesh * _mesh; + + // Boundaries that this object applies to + // TODO: Replace with inherited from BoundaryRestricted once FoamMesh is updated + std::vector _boundary; +}; diff --git a/include/bcs/FoamFixedGradientBC.h b/include/bcs/FoamFixedGradientBC.h new file mode 100644 index 00000000..97041d43 --- /dev/null +++ b/include/bcs/FoamFixedGradientBC.h @@ -0,0 +1,21 @@ +#pragma once + +#include "FoamBCBase.h" +#include "InputParameters.h" + +class FoamFixedGradientBC : public FoamBCBase +{ +public: + // Validate input file parameters + static InputParameters validParams(); + + // Constructor + explicit FoamFixedGradientBC(const InputParameters & parameters); + + // Impose boundary conditions (to be called from FoamProblem class) + virtual void imposeBoundaryCondition() override; + +protected: + // name of diffusivity coefficient used to divide flux + std::string _diffusivity_coefficient; +}; diff --git a/include/bcs/FoamFixedValueBC.h b/include/bcs/FoamFixedValueBC.h new file mode 100644 index 00000000..70a9f865 --- /dev/null +++ b/include/bcs/FoamFixedValueBC.h @@ -0,0 +1,17 @@ +#pragma once + +#include "FoamBCBase.h" +#include "InputParameters.h" + +class FoamFixedValueBC : public FoamBCBase +{ +public: + // Validate input file parameters + static InputParameters validParams(); + + // Constructor + explicit FoamFixedValueBC(const InputParameters & parameters); + + // Impose boundary conditions (to be called from FoamProblem class) + virtual void imposeBoundaryCondition() override; +}; diff --git a/include/mesh/FoamMesh.h b/include/mesh/FoamMesh.h index 41463cca..cb912f6a 100644 --- a/include/mesh/FoamMesh.h +++ b/include/mesh/FoamMesh.h @@ -1,12 +1,17 @@ #pragma once #include "FoamRuntime.h" -#include "libmesh/elem.h" #include "Foam2MooseMeshGen.h" +#include +#include +#include +#include +#include +#include +#include #include #include -#include #include @@ -31,7 +36,7 @@ class FoamMesh : public MooseMesh ~FoamMesh() = default; virtual std::unique_ptr safeClone() const override; virtual void buildMesh() override; - std::vector & getSubdomainList(); + std::vector & getSubdomainList(); bool isSerial() const { return _serial; } libMesh::Elem * getElemPtr(int local) const; Foam::fvMesh & fvMesh() { return _foam_mesh; } @@ -39,6 +44,8 @@ class FoamMesh : public MooseMesh std::unique_ptr createElement(Hippo::Foam2MooseMeshAdapter * mesh_adapter, const Hippo::FoamFace & face); + int64_t getPatchCount(int subdomain_id) const { return _patch_counts.at(subdomain_id); }; + int64_t getPatchOffset(int subdomain_id) const { return _patch_offsets.at(subdomain_id); }; std::vector n_faces{0}; // The index offset into the MOOSE element array, for the current rank. // This can be used with `getElemPtr` like so: @@ -46,13 +53,31 @@ class FoamMesh : public MooseMesh // to get the i-th element owned by the current rank from the mesh. size_t rank_element_offset{0}; + // Check if Foam mesh object has object of type T called name + template + bool foamHasObject(Foam::word const & name) + { + return _foam_mesh.foundObject(name); + } + + // Returns the gradient BC array for field and subdomain + template + Foam::Field & getGradientBCField(SubdomainID subdomain, Foam::word const & field) + { + auto & var = const_cast &>( + _foam_mesh.boundary()[subdomain].lookupPatchField(field)); + return Foam::refCast>(var).gradient(); + } + protected: std::vector _foam_patch; Hippo::FoamRuntime _foam_runtime; Foam::fvMesh _foam_mesh; std::vector _patch_id; - std::vector _subdomain_list; + std::vector _subdomain_list; bool _serial = true; + std::map _patch_counts; + std::map _patch_offsets; }; // Local Variables: // mode: c++ diff --git a/include/problems/FoamProblem.h b/include/problems/FoamProblem.h index b83590e4..73390d69 100644 --- a/include/problems/FoamProblem.h +++ b/include/problems/FoamProblem.h @@ -2,6 +2,8 @@ #include "FoamMesh.h" #include "FoamSolver.h" +#include "FoamVariableField.h" +#include "FoamBCBase.h" #include #include @@ -18,6 +20,7 @@ class FoamProblem : public ExternalProblem virtual void syncSolutions(Direction /* dir */) override; virtual bool converged(const unsigned int /* nl_sys_num */) override { return true; } virtual void addExternalVariables() override {}; + virtual void initialSetup() override; using ExternalProblem::mesh; virtual FoamMesh const & mesh() const override { return *_foam_mesh; } @@ -30,18 +33,17 @@ class FoamProblem : public ExternalProblem Both }; - template - void syncFromOpenFoam(); - - template - void syncToOpenFoam(); - - MooseVariableFieldBase * - getConstantMonomialVariableFromParameters(const std::string & parameter_name); - Hippo::FoamSolver & solver() { return _solver; } protected: + // check FoamVariables and print summarising table + void verifyFoamVariables(); + + // check FoamBCs and print summarising table + void verifyFoamBCs(); + FoamMesh * _foam_mesh = nullptr; Hippo::FoamSolver _solver; + std::vector _foam_variables; + std::vector _foam_bcs; }; diff --git a/include/util/hippoUtils.h b/include/util/hippoUtils.h new file mode 100644 index 00000000..de43b41d --- /dev/null +++ b/include/util/hippoUtils.h @@ -0,0 +1,17 @@ +#pragma once + +#include + +namespace Hippo +{ +namespace internal +{ +template +inline void +copyParamFromParam(InputParameters & dst, const InputParameters & src, const std::string & name_in) +{ + if (src.isParamValid(name_in)) + dst.set(name_in) = src.get(name_in); +} +} +} diff --git a/include/variables/FoamFunctionObject.h b/include/variables/FoamFunctionObject.h new file mode 100644 index 00000000..7421659f --- /dev/null +++ b/include/variables/FoamFunctionObject.h @@ -0,0 +1,27 @@ +#pragma once + +#include "FoamVariableField.h" +#include "functionObject.H" + +#include + +// Class for mirroring functionObjects +class FoamFunctionObject : public FoamVariableField +{ +public: + explicit FoamFunctionObject(const InputParameters & params); + + // function that executes functionObject and transfers variable from + // OpenFOAM variable to MOOSE + virtual void transferVariable(); + + // Destroys functionObject pointer + ~FoamFunctionObject() { delete _shadow_fo; }; + +private: + // function to construct the functionObject + Foam::functionObject * _getFunctionObject(Foam::dictionary fo_dict); + + // The function object pointer + Foam::functionObject * _shadow_fo; +}; diff --git a/include/variables/FoamVariableField.h b/include/variables/FoamVariableField.h new file mode 100644 index 00000000..a7bf91cc --- /dev/null +++ b/include/variables/FoamVariableField.h @@ -0,0 +1,25 @@ +#pragma once + +#include "MooseObject.h" +#include "FoamMesh.h" + +class FoamVariableField : public MooseObject +{ +public: + static InputParameters validParams(); + + explicit FoamVariableField(const InputParameters & params); + + // transfer variable from OpenFOAM field to MOOSE variable + virtual void transferVariable(); + + // returns the name of the foam variable this object shadows + std::string foamVariable() const { return _foam_variable; }; + +protected: + // variable name or functionObject to be shadowed + std::string _foam_variable; + + // Pointer to the FoamMesh object + FoamMesh * _mesh; +}; diff --git a/src/actions/AddFoamBCAction.C b/src/actions/AddFoamBCAction.C new file mode 100644 index 00000000..f2ffce49 --- /dev/null +++ b/src/actions/AddFoamBCAction.C @@ -0,0 +1,58 @@ +#include "AddFoamBCAction.h" +#include "FoamProblem.h" +#include "hippoUtils.h" + +#include +#include + +registerMooseAction("hippoApp", AddFoamBCAction, "add_foam_bc"); + +InputParameters +AddFoamBCAction::validParams() +{ + return MooseObjectAction::validParams(); +} + +AddFoamBCAction::AddFoamBCAction(const InputParameters & params) : MooseObjectAction(params) {} + +void +AddFoamBCAction::act() +{ + auto foam_problem = dynamic_cast(_problem.get()); + + // Adding BCs using [FoamBC] syntax + if (_current_task == "add_foam_bc") + { + if (!foam_problem) + mooseError("FoamBCs system can only be used with FoamProblem."); + + // Do not create aux variable if variable provided. + if (!_moose_object_pars.isParamSetByUser("v")) + createAuxVariable(); + + foam_problem->addObject(_type, _name, _moose_object_pars, false); + } +} + +void +AddFoamBCAction::createAuxVariable() +{ + // Use AddAuxVariableAction to create AuxVariable that also allows additional + // parameters such as initial conditions to be set + const std::string class_name = "AddAuxVariableAction"; + + InputParameters action_params = _action_factory.getValidParams(class_name); + action_params.set("task") = "add_aux_variable"; + + // The MOOSE variable has to be constant monomial + action_params.set("order") = "CONSTANT"; + action_params.set("family") = "MONOMIAL"; + + // Copy desired parameters from FoamBC action + Hippo::internal::copyParamFromParam>( + action_params, _moose_object_pars, "initial_condition"); + + std::shared_ptr action = + std::static_pointer_cast(_action_factory.create(class_name, name(), action_params)); + _awh.addActionBlock(action); +} diff --git a/src/actions/AddFoamVariableAction.C b/src/actions/AddFoamVariableAction.C new file mode 100644 index 00000000..11426112 --- /dev/null +++ b/src/actions/AddFoamVariableAction.C @@ -0,0 +1,63 @@ +#include "AddFoamVariableAction.h" +#include "FoamProblem.h" +#include "FoamVariableField.h" +#include "hippoUtils.h" + +#include "InputParameters.h" +#include "MooseObjectAction.h" +#include "Registry.h" + +registerMooseAction("hippoApp", AddFoamVariableAction, "add_foam_variable"); + +InputParameters +AddFoamVariableAction::validParams() +{ + auto params = MooseObjectAction::validParams(); + params.addClassDescription("Adds a FoamVariable that shadows an OpenFOAM scalar field."); + return params; +} + +AddFoamVariableAction::AddFoamVariableAction(const InputParameters & parameters) + : MooseObjectAction(parameters) +{ +} + +void +AddFoamVariableAction::act() +{ + auto * foam_problem = dynamic_cast(_problem.get()); + + // Add variable through [FoamVariables] block + if (_current_task == "add_foam_variable") + { + if (!foam_problem) + mooseError("FoamVariables system can only be used with FoamProblem."); + + createAuxVariable(); + + foam_problem->addObject(_type, _name, _moose_object_pars, false); + } +} + +void +AddFoamVariableAction::createAuxVariable() +{ + // Use AddAuxVariableAction to create AuxVariable that also allows additional + // parameters such as initial conditions to be set + const std::string class_name = "AddAuxVariableAction"; + + InputParameters action_params = _action_factory.getValidParams(class_name); + action_params.set("task") = "add_aux_variable"; + + // The MOOSE variable has to be constant monomial + action_params.set("order") = "CONSTANT"; + action_params.set("family") = "MONOMIAL"; + + // Copy desired parameters from FoamVariable action + Hippo::internal::copyParamFromParam>( + action_params, _moose_object_pars, "initial_condition"); + + std::shared_ptr action = + std::static_pointer_cast(_action_factory.create(class_name, name(), action_params)); + _awh.addActionBlock(action); +} diff --git a/src/base/FoamSolver.C b/src/base/FoamSolver.C index 37735b9e..11eb9b5e 100644 --- a/src/base/FoamSolver.C +++ b/src/base/FoamSolver.C @@ -128,19 +128,6 @@ FoamSolver::run() << std::endl; } -std::size_t -FoamSolver::appendPatchTemperatures(const int patch_id, std::vector & foam_t) -{ - if (!_solver) - { - return 0; - } - auto & mesh = _solver->mesh; - auto & temp = mesh.boundary()[patch_id].lookupPatchField("T"); - std::copy(temp.begin(), temp.end(), std::back_inserter(foam_t)); - return temp.size(); -} - std::size_t FoamSolver::patchSize(int patch_id) { @@ -152,68 +139,6 @@ FoamSolver::patchSize(int patch_id) return mesh.boundary()[patch_id].size(); } -void -FoamSolver::setPatchTemperatures(const int patch_id, const std::vector & moose_t) -{ - if (!_solver) - { - return; - } - auto & mesh = _solver->mesh; - auto & temp = const_cast &>( - mesh.boundary()[patch_id].lookupPatchField("T")); - assert(moose_t.size() == static_cast(temp.size())); - std::copy(moose_t.begin(), moose_t.end(), temp.begin()); -} - -void -FoamSolver::setPatchNegativeHeatFlux(const int patch_id, std::vector & negative_hf) -{ - if (!_solver) - { - return; - } - auto & mesh = _solver->mesh; - auto & temp = const_cast &>( - mesh.boundary()[patch_id].lookupPatchField("T")); - Foam::scalarField & temp_gradient( - Foam::refCast(temp).gradient()); - auto & thermal_conductivity = - mesh.boundary()[patch_id].lookupPatchField("kappa"); - assert(temp_gradient.size() == thermal_conductivity.size()); - for (auto i = 0; i < temp_gradient.size(); ++i) - { - temp_gradient[i] = negative_hf[i] / thermal_conductivity[i]; - } -} - -std::size_t -FoamSolver::wallHeatFlux(const int patch_id, std::vector & fill_vector) -{ - if (!_solver) - { - return 0; - } - - static const Foam::word WALL_HEAT_FLUX = "wallHeatFlux"; - - auto whf_dict = - _solver->runTime.controlDict().lookupOrDefault(WALL_HEAT_FLUX, Foam::dictionary()); - auto patch = _solver->mesh.boundaryMesh()[patch_id]; - whf_dict.set("patches", Foam::wordList({patch.name()})); - whf_dict.set("writeToFile", false); - Foam::functionObjects::wallHeatFlux whf_func(WALL_HEAT_FLUX, _solver->runTime, whf_dict); - whf_func.execute(); - - auto wall_heat_flux = _solver->mesh.lookupObject(WALL_HEAT_FLUX); - auto & whf_boundary = wall_heat_flux.boundaryField()[patch.index()]; - for (const auto value : whf_boundary) - { - fill_vector.emplace_back(value); - } - return whf_boundary.size(); -} - void FoamSolver::preSolve() { diff --git a/src/base/hippoApp.C b/src/base/hippoApp.C index 565416d9..e89b6314 100644 --- a/src/base/hippoApp.C +++ b/src/base/hippoApp.C @@ -1,3 +1,4 @@ +#include "ActionFactory.h" #include "hippoApp.h" #include @@ -32,6 +33,16 @@ hippoApp::registerAll(Factory & f, ActionFactory & af, Syntax & syntax) Registry::registerActionsTo(af, {"hippoApp"}); /* register custom execute flags, action syntax, etc. here */ + + // Add input file syntax for the [FoamVariables] block + registerSyntaxTask("AddFoamVariableAction", "FoamVariables/*", "add_foam_variable"); + registerMooseObjectTask("add_foam_variable", FoamVariable, false); + addTaskDependency("add_aux_variable", "add_foam_variable"); + + // Add input file syntax for the [FoamBCs] block + registerSyntaxTask("AddFoamBCAction", "FoamBCs/*", "add_foam_bc"); + registerMooseObjectTask("add_foam_bc", FoamBC, false); + addTaskDependency("add_aux_variable", "add_foam_bc"); } void diff --git a/src/bcs/FoamBCBase.C b/src/bcs/FoamBCBase.C new file mode 100644 index 00000000..b2879f11 --- /dev/null +++ b/src/bcs/FoamBCBase.C @@ -0,0 +1,119 @@ + +#include "FoamBCBase.h" +#include "FoamProblem.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +namespace +{ +// Private function to check if variables are constant monomials +inline bool +is_constant_monomial(const MooseVariableFieldBase & var) +{ + return var.order() == libMesh::Order::CONSTANT && var.feType().family == FEFamily::MONOMIAL; +} +} + +InputParameters +FoamBCBase::validParams() +{ + InputParameters params = MooseObject::validParams(); + params.addRequiredParam("foam_variable", + "Name of a Foam field. e.g. T (temperature) U (velocity)."); + params.addParam>("boundary", + "Boundaries that the boundary condition applies to."); + + params.addParam( + "v", + "Optional variable to use in BC. This allows existing AuxVariables to be" + " used rather than creating a new one under the hood."); + // Get desired parameters from Variable objects + params.transferParam>(MooseVariable::validParams(), "initial_condition"); + + params.registerSystemAttributeName("FoamBC"); + params.registerBase("FoamBC"); + + return params; +} + +FoamBCBase::FoamBCBase(const InputParameters & params) + : MooseObject(params), + Coupleable(this, false), + _foam_variable(params.get("foam_variable")), + _moose_var(nullptr), + _boundary(params.get>("boundary")) +{ + auto * problem = dynamic_cast(&_c_fe_problem); + if (!problem) + mooseError("FoamBC system can only be used with FoamProblem"); + + _mesh = &problem->mesh(); + + // check that the foam variable exists + if (!_mesh->foamHasObject(_foam_variable)) + mooseError("There is no OpenFOAM field named '", _foam_variable, "'"); + + // check that the boundary is in the FoamMesh + auto all_subdomain_names = _mesh->getSubdomainNames(_mesh->getSubdomainList()); + for (auto subdomain : _boundary) + { + auto it = std::find(all_subdomain_names.begin(), all_subdomain_names.end(), subdomain); + if (it == all_subdomain_names.end()) + mooseError("Boundary '", subdomain, "' not found in FoamMesh"); + } + + if (_boundary.empty()) + _boundary = all_subdomain_names; +} + +void +FoamBCBase::initialSetup() +{ + // Check variable exists + auto var_name = parameters().isParamValid("v") ? parameters().get("v") : _name; + if (!_c_fe_problem.hasVariable(var_name)) + mooseError("Variable '", var_name, "' doesn't exist"); + + THREAD_ID tid = parameters().get("_tid"); + _moose_var = &_c_fe_problem.getVariable(tid, var_name); + + // Check variable is constant monomial in case it is provided. + if (!is_constant_monomial(*_moose_var)) + mooseError("Variable '", var_name, "' must be a constant monomial."); +} + +Real +FoamBCBase::variableValueAtElement(const libMesh::Elem * elem) +{ + auto & sys = _moose_var->sys(); + auto dof = elem->dof_number(sys.number(), _moose_var->number(), 0); + return sys.solution()(dof); +} + +std::vector +FoamBCBase::getMooseVariableArray(int subdomain_id) +{ + size_t patch_count = _mesh->getPatchCount(subdomain_id); + size_t patch_offset = _mesh->getPatchOffset(subdomain_id); + + std::vector var_array(patch_count); + for (size_t j = 0; j < patch_count; ++j) + { + auto elem = patch_offset + j; + auto elem_ptr = _mesh->getElemPtr(elem + _mesh->rank_element_offset); + assert(elem_ptr); + var_array[j] = variableValueAtElement(elem_ptr); + } + + return var_array; +} diff --git a/src/bcs/FoamFixedGradientBC.C b/src/bcs/FoamFixedGradientBC.C new file mode 100644 index 00000000..7434d077 --- /dev/null +++ b/src/bcs/FoamFixedGradientBC.C @@ -0,0 +1,70 @@ +#include "FoamFixedGradientBC.h" + +#include +#include +#include +#include + +registerMooseObject("hippoApp", FoamFixedGradientBC); + +InputParameters +FoamFixedGradientBC::validParams() +{ + auto params = FoamBCBase::validParams(); + params.addClassDescription("A FoamBC that imposes a fixed gradient dirichlet boundary condition " + "on the OpenFOAM simulation"); + params.addParam("diffusivity_coefficient", + "OpenFOAM scalar field name to be specified if 'v' is " + "a flux rather than a gradient"); + return params; +} + +FoamFixedGradientBC::FoamFixedGradientBC(const InputParameters & parameters) + : FoamBCBase(parameters), + _diffusivity_coefficient(parameters.get("diffusivity_coefficient")) +{ + // check that the diffusivity coefficient is a OpenFOAM scalar field + if (!_diffusivity_coefficient.empty() && + !_mesh->foamHasObject(_diffusivity_coefficient)) + mooseError( + "Diffusivity coefficient '", _diffusivity_coefficient, "' not a Foam volScalarField"); +} + +void +FoamFixedGradientBC::imposeBoundaryCondition() +{ + auto & foam_mesh = _mesh->fvMesh(); + + // Get subdomains this FoamBC acts on + // TODO: replace with BoundaryRestriction member functions once FoamMesh is updated + auto subdomains = _mesh->getSubdomainIDs(_boundary); + for (auto subdomain : subdomains) + { + std::vector && grad_array = getMooseVariableArray(subdomain); + + // Get the gradient associated with the field + auto & foam_gradient = + _mesh->getGradientBCField(subdomain, _foam_variable); + assert(grad_array.size() == static_cast(foam_gradient.size())); + + // If diffusivity_coefficient is specified grad array is a flux, so result + // must be divided by it + if (!_diffusivity_coefficient.empty()) + { + // Get the underlying diffusivity field + auto & coeff = foam_mesh.boundary()[subdomain].lookupPatchField( + _diffusivity_coefficient); + + assert(foam_gradient.size() == coeff.size()); + // set gradient + for (auto i = 0; i < foam_gradient.size(); ++i) + { + foam_gradient[i] = grad_array[i] / coeff[i]; + } + } + else // if no diffusivity coefficient grad_array is just the gradient so copy + { + std::copy(grad_array.begin(), grad_array.end(), foam_gradient.begin()); + } + } +} diff --git a/src/bcs/FoamFixedValueBC.C b/src/bcs/FoamFixedValueBC.C new file mode 100644 index 00000000..11c74268 --- /dev/null +++ b/src/bcs/FoamFixedValueBC.C @@ -0,0 +1,39 @@ +#include "FoamFixedValueBC.h" +#include "InputParameters.h" +#include "MooseTypes.h" + +registerMooseObject("hippoApp", FoamFixedValueBC); + +InputParameters +FoamFixedValueBC::validParams() +{ + auto params = FoamBCBase::validParams(); + params.addClassDescription("A FoamBC that imposes a fixed value dirichlet boundary condition " + "on the OpenFOAM simulation"); + return params; +} + +FoamFixedValueBC::FoamFixedValueBC(const InputParameters & parameters) : FoamBCBase(parameters) {} + +void +FoamFixedValueBC::imposeBoundaryCondition() +{ + auto & foam_mesh = _mesh->fvMesh(); + + // Get subdomains this FoamBC acts on + // TODO: replace with BoundaryRestriction member functions once FoamMesh is updated + auto subdomains = _mesh->getSubdomainIDs(_boundary); + for (auto subdomain : subdomains) + { + std::vector && var_array = getMooseVariableArray(subdomain); + + // Get underlying field from OpenFOAM boundary patch + auto & foam_var = const_cast &>( + foam_mesh.boundary()[subdomain].lookupPatchField( + _foam_variable)); + + assert(var_array.size() == static_cast(foam_var.size())); + + std::copy(var_array.begin(), var_array.end(), foam_var.begin()); + } +} diff --git a/src/mesh/FoamMesh.C b/src/mesh/FoamMesh.C index 18648536..7592ef31 100644 --- a/src/mesh/FoamMesh.C +++ b/src/mesh/FoamMesh.C @@ -1,14 +1,15 @@ #include "FoamMesh.h" #include "Foam2MooseMeshGen.h" -#include "libmesh/elem.h" -#include "libmesh/enum_elem_type.h" -#include "libmesh/face_quad4.h" -#include "libmesh/face_c0polygon.h" -#include "libmesh/face_tri3.h" -#include "libmesh/point.h" + +#include +#include +#include +#include +#include +#include +#include #include -#include #include #include #include @@ -44,7 +45,9 @@ FoamMesh::FoamMesh(InputParameters const & params) : MooseMesh(params), _foam_patch(params.get>("foam_patch")), _foam_runtime(params.get("case"), _communicator.get()), - _foam_mesh(read_polymesh(_foam_runtime.runTime())) + _foam_mesh(read_polymesh(_foam_runtime.runTime())), + _patch_counts(), + _patch_offsets() { int size = 1; MPI_Comm_size(_communicator.get(), &size); @@ -68,7 +71,7 @@ FoamMesh::safeClone() const return std::make_unique(*this); } -std::vector & +std::vector & FoamMesh::getSubdomainList() { return _subdomain_list; @@ -191,6 +194,15 @@ FoamMesh::buildMesh() _mesh->recalculate_n_partitions(); libMesh::Partitioner::set_node_processor_ids(*_mesh); _mesh->prepare_for_use(); + + auto count = 0; + for (auto i = 0U; i < _subdomain_list.size(); ++i) + { + auto tmp = _foam_mesh.boundary()[_subdomain_list[i]].size(); + _patch_counts[_subdomain_list[i]] = tmp; + _patch_offsets[_subdomain_list[i]] = count; + count += tmp; + } } libMesh::Elem * diff --git a/src/problems/FoamProblem.C b/src/problems/FoamProblem.C index bcad5938..25168701 100644 --- a/src/problems/FoamProblem.C +++ b/src/problems/FoamProblem.C @@ -1,110 +1,81 @@ +#include "ExternalProblem.h" #include "FoamMesh.h" #include "FoamProblem.h" #include "FoamSolver.h" +#include "VariadicTable.h" +#include "word.H" #include #include #include #include +#include +#include "FoamVariableField.h" +#include "InputParameters.h" +#include "VariadicTable.h" #include #include #include #include +#include registerMooseObject("hippoApp", FoamProblem); namespace { -constexpr auto PARAM_VAR_FOAM_HF = "foam_heat_flux"; -constexpr auto PARAM_VAR_FOAM_T = "foam_temp"; -constexpr auto PARAM_VAR_T = "temp"; -constexpr auto PARAM_VAR_HF = "heat_flux"; - -bool -is_constant_monomial(const MooseVariableFieldBase & var) +// Create comma separated list from vector +template +inline std::string +listFromVector(std::vector vec, StrType sep = ", ") { - return var.order() == libMesh::Order::CONSTANT && var.feType().family == FEFamily::MONOMIAL; + if (vec.size() == 0) + return std::string(); + else if (vec.size() == 1) + return vec.at(0); + + std::string str; + auto binary_op = [&](const std::string & acc, const std::string & it) { return acc + sep + it; }; + std::accumulate(vec.begin(), vec.end(), str, binary_op); + return str; } - -Real -variableValueAtElement(const libMesh::Elem * element, MooseVariableFieldBase * variable) -{ - auto & sys = variable->sys(); - auto dof = element->dof_number(sys.number(), variable->number(), 0); - return sys.solution()(dof); } -} // namespace InputParameters FoamProblem::validParams() { auto params = ExternalProblem::validParams(); - - // Parameters to set variables to read from/write to. - // Note that these can be omitted or point to the same variable to save - // memory. - params.addParam(PARAM_VAR_FOAM_HF, - "The name of the aux variable to write the " - "OpenFOAM wall heat flux into."); - params.addParam(PARAM_VAR_FOAM_T, - "The name of the aux variable to write the " - "OpenFOAM boundary temperature into."); - params.addParam( - PARAM_VAR_HF, "The name of the aux variable to set the OpenFOAM wall heat flux from."); - params.addParam(PARAM_VAR_T, - "The name of the aux variable to set the " - "OpenFOAM boundary temperature from."); return params; } FoamProblem::FoamProblem(InputParameters const & params) : ExternalProblem(params), _foam_mesh(dynamic_cast(&this->ExternalProblem::mesh())), - _solver(Foam::solver::New("fluid", _foam_mesh->fvMesh()).ptr()) + _solver(Foam::solver::New(_foam_mesh->fvMesh().time().controlDict().lookupOrDefault( + "solver", "fluid"), + _foam_mesh->fvMesh()) + .ptr()), + _foam_variables(), + _foam_bcs() { assert(_foam_mesh); +} - auto t_var_name = params.get(PARAM_VAR_T); - auto hf_var_name = params.get(PARAM_VAR_HF); - if (t_var_name.empty() && hf_var_name.empty()) - { - mooseWarning("Neither parameters '", - PARAM_VAR_T, - "' or '", - PARAM_VAR_HF, - "' are set. No quantities are being transferred to OpenFOAM."); - } - else if (t_var_name == hf_var_name) - { - mooseError("Parameters '", - PARAM_VAR_T, - "' and '", - PARAM_VAR_HF, - "' cannot refer to the same variable: '", - t_var_name, - "'."); - } +void +FoamProblem::initialSetup() +{ + ExternalProblem::initialSetup(); - auto foam_t_var_name = params.get(PARAM_VAR_FOAM_T); - auto foam_hf_var_name = params.get(PARAM_VAR_FOAM_HF); - if (foam_t_var_name.empty() && foam_hf_var_name.empty()) - { - mooseWarning("Neither parameters '", - PARAM_VAR_FOAM_T, - "', or '", - PARAM_VAR_FOAM_HF, - "' are set. No quantities are being copied from OpenFOAM."); - } - else if (foam_t_var_name == foam_hf_var_name) - { - mooseError("Parameters '", - PARAM_VAR_FOAM_T, - "' and '", - PARAM_VAR_FOAM_HF, - "' cannot refer to the same variable: '", - foam_t_var_name, - "'."); - } + // Get FoamVariables created by the action AddFoamVariableAction + TheWarehouse::Query query_vars = theWarehouse().query().condition("FoamVariable"); + query_vars.queryInto(_foam_variables); + + verifyFoamVariables(); + + // Get FoamBCs created by the action AddFoamBCAction + TheWarehouse::Query query_bcs = theWarehouse().query().condition("FoamBC"); + query_bcs.queryInto(_foam_bcs); + + verifyFoamBCs(); } void @@ -121,213 +92,103 @@ void FoamProblem::syncSolutions(Direction dir) { if (!parameters().get("solve")) - { return; - } + if (dir == ExternalProblem::Direction::FROM_EXTERNAL_APP) { - auto transfer_wall_temp = !parameters().get(PARAM_VAR_FOAM_T).empty(); - auto transfer_wall_heat_flux = !parameters().get(PARAM_VAR_FOAM_HF).empty(); - if (transfer_wall_temp) - { - if (transfer_wall_heat_flux) - { - syncFromOpenFoam(); - } - else - { - syncFromOpenFoam(); - } - } - else if (transfer_wall_heat_flux) + // Loop of shadowed variables and perform transfer + for (auto & var : _foam_variables) { - syncFromOpenFoam(); + var->transferVariable(); } } else if (dir == ExternalProblem::Direction::TO_EXTERNAL_APP) { - auto transfer_wall_temp = !parameters().get(PARAM_VAR_T).empty(); - auto transfer_wall_heat_flux = !parameters().get(PARAM_VAR_HF).empty(); - if (transfer_wall_temp) - { - if (transfer_wall_heat_flux) - { - syncToOpenFoam(); - } - else - { - syncToOpenFoam(); - } - } - else if (transfer_wall_heat_flux) + for (auto & foam_bc : _foam_bcs) { - syncToOpenFoam(); + foam_bc->imposeBoundaryCondition(); } } } -template void -FoamProblem::syncFromOpenFoam() +FoamProblem::verifyFoamVariables() { - constexpr bool transfer_wall_temp = - (sync_vars == SyncVariables::WallTemperature) || (sync_vars == SyncVariables::Both); - constexpr bool transfer_wall_heat_flux = - (sync_vars == SyncVariables::WallHeatFlux) || (sync_vars == SyncVariables::Both); - - // Find the relevant MOOSE variables to transfer values into. - MooseVariableFieldBase * wall_temp_var; - if constexpr (transfer_wall_temp) - { - wall_temp_var = getConstantMonomialVariableFromParameters(PARAM_VAR_FOAM_T); - } - MooseVariableFieldBase * wall_heat_flux_var; - if constexpr (transfer_wall_heat_flux) - { - wall_heat_flux_var = getConstantMonomialVariableFromParameters(PARAM_VAR_FOAM_HF); - } - - auto & mesh = this->mesh(); - auto subdomains = mesh.getSubdomainList(); - // Vectors to copy OpenFOAM quantities into. - std::vector wall_temp; - std::vector wall_heat_flux; - - // The number of elements in each subdomain of the mesh - // Allocate an extra element as we'll accumulate these counts later - std::vector patch_counts(subdomains.size() + 1, 0); - for (auto i = 0U; i < subdomains.size(); ++i) + // Create table summarising FoamVariables + VariadicTable vt({ + "FoamVariable name", + "Type", + "Foam variable", + }); + for (auto & var : _foam_variables) { - if constexpr (transfer_wall_temp) - { - auto n_added = _solver.appendPatchTemperatures(subdomains[i], wall_temp); - patch_counts[i] = n_added; - } - if constexpr (transfer_wall_heat_flux) - { - auto n_added = _solver.wallHeatFlux(subdomains[i], wall_heat_flux); - patch_counts[i] = n_added; - } - } - std::exclusive_scan(patch_counts.begin(), patch_counts.end(), patch_counts.begin(), 0); - - int rank; - MPI_Comm_rank(MPI_COMM_WORLD, &rank); - for (auto i = 0U; i < subdomains.size(); ++i) - { - // Set the face temperatures on the MOOSE mesh - for (auto elem = patch_counts[i]; elem < patch_counts[i + 1]; ++elem) - { - auto elem_ptr = mesh.getElemPtr(elem + mesh.rank_element_offset); - assert(elem_ptr); - if constexpr (transfer_wall_temp) - { - auto & sys = wall_temp_var->sys(); - auto dof_t = elem_ptr->dof_number(sys.number(), wall_temp_var->number(), 0); - sys.solution().set(dof_t, wall_temp[elem]); - } - if constexpr (transfer_wall_heat_flux) - { - auto & sys = wall_heat_flux_var->sys(); - auto dof_dt = elem_ptr->dof_number(sys.number(), wall_heat_flux_var->number(), 0); - sys.solution().set(dof_dt, wall_heat_flux[elem]); - } - } - } - if constexpr (transfer_wall_temp) - { - wall_temp_var->sys().solution().close(); - } - if constexpr (transfer_wall_heat_flux) - { - wall_heat_flux_var->sys().solution().close(); + vt.addRow(var->name(), var->type(), var->foamVariable()); } + vt.print(_console); } -template void -FoamProblem::syncToOpenFoam() +FoamProblem::verifyFoamBCs() { - constexpr bool transfer_wall_temp = - (sync_vars == SyncVariables::WallTemperature) || (sync_vars == SyncVariables::Both); - constexpr bool transfer_wall_heat_flux = - (sync_vars == SyncVariables::WallHeatFlux) || (sync_vars == SyncVariables::Both); - - // Vectors to copy MOOSE quantities into. - std::vector wall_temp; - std::vector wall_heat_flux; - - // Find the relevant MOOSE variables to transfer values from. - MooseVariableFieldBase * wall_temp_var; - if constexpr (transfer_wall_temp) - { - wall_temp_var = getConstantMonomialVariableFromParameters(PARAM_VAR_T); - } - MooseVariableFieldBase * wall_heat_flux_var; - if constexpr (transfer_wall_heat_flux) - { - wall_heat_flux_var = getConstantMonomialVariableFromParameters(PARAM_VAR_HF); - } - - auto & mesh = this->mesh(); - auto subdomains = mesh.getSubdomainList(); - - // The number of elements in each subdomain of the mesh - // Allocate an extra element as we'll accumulate these counts later - std::vector patch_counts(subdomains.size() + 1, 0); - for (auto i = 0U; i < subdomains.size(); ++i) - { - patch_counts[i] = _solver.patchSize(subdomains[i]); - } - std::exclusive_scan(patch_counts.begin(), patch_counts.end(), patch_counts.begin(), 0); - - // Retrieve the values from MOOSE for each boundary we're transferring across. - int rank; - MPI_Comm_rank(MPI_COMM_WORLD, &rank); - for (auto i = 0U; i < subdomains.size(); ++i) - { - // Vectors to hold quantities copied from MOOSE mesh. - std::vector moose_T; - std::vector moose_hf; - - // Set the face temperatures on the OpenFOAM mesh. - for (size_t elem = patch_counts[i]; elem < patch_counts[i + 1]; ++elem) + // Check BC + for (auto & bc : _foam_bcs) + bc->initialSetup(); + + // Get list of all variables used by all BCs + std::set unique_vars; + for (const auto & bc : _foam_bcs) + unique_vars.insert(bc->foamVariable()); + + // Create table for printing BC information + VariadicTable vt({ + "FoamBC name", + "Type", + "Foam variable", + "Moose variable", + "Boundaries", + }); + + for (auto var : unique_vars) + { + if (var.empty()) + continue; + + // create list of all boundaries where bc has been applied for var + std::vector used_bcs; + for (auto & bc : _foam_bcs) { - auto elem_ptr = mesh.getElemPtr(elem + mesh.rank_element_offset); - assert(elem_ptr); - if constexpr (transfer_wall_temp) + if (bc->foamVariable() == var) { - moose_T.emplace_back(variableValueAtElement(elem_ptr, wall_temp_var)); - } - if constexpr (transfer_wall_heat_flux) - { - moose_hf.emplace_back(variableValueAtElement(elem_ptr, wall_heat_flux_var)); + auto && boundary = bc->boundary(); + used_bcs.insert(used_bcs.end(), boundary.begin(), boundary.end()); + // List info about BC + vt.addRow(bc->name(), + bc->type(), + bc->foamVariable(), + bc->mooseVariable(), + listFromVector(boundary)); } } - // Copy the values from the MOOSE temperature vector into OpenFOAM's - if constexpr (transfer_wall_temp) - { - _solver.setPatchTemperatures(subdomains[i], moose_T); - } - if constexpr (transfer_wall_heat_flux) + + // Find duplicates + auto unique_bc = std::unique(used_bcs.begin(), used_bcs.end()); + if (unique_bc != used_bcs.end()) + mooseError("Imposed FoamBC has duplicated boundary '", + *unique_bc, + "' for foam variable '", + var, + "'"); + + // Add table entry for boundaries which do not have a BC for variable + std::vector unused_bcs; + for (auto bc : _mesh.getSubdomainNames(_foam_mesh->getSubdomainList())) { - _solver.setPatchNegativeHeatFlux(subdomains[i], moose_hf); + auto it = std::find(used_bcs.begin(), used_bcs.end(), bc); + if (it == used_bcs.end()) + unused_bcs.push_back(bc); } + if (unused_bcs.size() > 0) + vt.addRow("", "UnusedBoundaries", "", "", listFromVector(unused_bcs)); } -} - -MooseVariableFieldBase * -FoamProblem::getConstantMonomialVariableFromParameters(const std::string & parameter_name) -{ - auto variable_name = parameters().get(parameter_name); - auto * var = &getVariable(0, variable_name); - if (!is_constant_monomial(*var)) - { - mooseError("variable assigned to parameter '", - parameter_name, - "' must have:\n" - " family = MONOMIAL\n" - " order = CONSTANT\n"); - } - return var; + vt.print(_console); } diff --git a/src/variables/FoamFunctionObject.C b/src/variables/FoamFunctionObject.C new file mode 100644 index 00000000..6542b7d8 --- /dev/null +++ b/src/variables/FoamFunctionObject.C @@ -0,0 +1,57 @@ +#include "FoamVariableField.h" +#include "FoamFunctionObject.h" +#include "InputParameters.h" +#include "Registry.h" +#include "SystemBase.h" +#include "dictionary.H" +#include "functionObject.H" +#include + +registerMooseObject("hippoApp", FoamFunctionObject); + +FoamFunctionObject::FoamFunctionObject(const InputParameters & params) : FoamVariableField(params) +{ + auto & mesh = _mesh->fvMesh(); + + // construct input Foam dictionary for the functionObject + auto fo_dict = mesh.time().controlDict().lookupOrDefault(_foam_variable, Foam::dictionary()); + + // create patch names where functionObject applies + // TODO: when volumetric mirror is implemented some of this may need to be + // put in the _getFunctionObject function. + auto patch_ids{_mesh->getSubdomainList()}; + Foam::wordList patch_names; + for (auto id : patch_ids) + patch_names.append(mesh.boundaryMesh()[id].name()); + + fo_dict.set("patches", patch_names); + fo_dict.set("writeToFile", false); + + // construct functionObject and execute + _shadow_fo = _getFunctionObject(fo_dict); + _shadow_fo->execute(); +} + +Foam::functionObject * +FoamFunctionObject::_getFunctionObject(Foam::dictionary fo_dict) +{ + // Create polymorphic pointer to each type of valid functionObject + if (_foam_variable == "wallHeatFlux") + { + Foam::functionObjects::wallHeatFlux * whf_func = + new Foam::functionObjects::wallHeatFlux("wallHeatFlux", _mesh->fvMesh().time(), fo_dict); + return static_cast(whf_func); + } + else + { + mooseError("Only wallHeatFlux functionObject is currently supported"); + } +} + +void +FoamFunctionObject::transferVariable() +{ + // execute functionObject before transfer + _shadow_fo->execute(); + FoamVariableField::transferVariable(); +} diff --git a/src/variables/FoamVariableField.C b/src/variables/FoamVariableField.C new file mode 100644 index 00000000..655eaa70 --- /dev/null +++ b/src/variables/FoamVariableField.C @@ -0,0 +1,65 @@ +#include "FoamVariableField.h" +#include "FoamProblem.h" +#include "InputParameters.h" +#include "MooseObject.h" +#include "MooseTypes.h" +#include "MooseVariableFieldBase.h" +#include "MooseVariableFieldBase.h" + +registerMooseObject("hippoApp", FoamVariableField); + +InputParameters +FoamVariableField::validParams() +{ + auto params = MooseObject::validParams(); + + params.addRequiredParam("foam_variable", + "OpenFOAM variable or functionObject to be shadowed"); + params.addRequiredParam("foam_variable", + "OpenFOAM variable or functionObject to be shadowed"); + + // Get desired parameters from Variable objects + params.transferParam>(MooseVariable::validParams(), "initial_condition"); + + params.registerBase("FoamVariable"); + params.registerSystemAttributeName("FoamVariable"); + return params; +} + +FoamVariableField::FoamVariableField(const InputParameters & params) + : MooseObject(params), _foam_variable(params.get("foam_variable")) +{ + auto * problem = dynamic_cast(&getMooseApp().feProblem()); + if (!problem) + mooseError("This Variable can only be used with FoamProblem"); + + _mesh = &problem->mesh(); +} + +void +FoamVariableField::transferVariable() +{ + THREAD_ID tid = parameters().get("_tid"); + auto & moose_var = getMooseApp().feProblem().getVariable(tid, _name); + + // Loop through subdomains extracting foam_variable and setting on libMesh elements + auto & foam_mesh = _mesh->fvMesh(); + for (auto subdomain : _mesh->getSubdomainList()) + { + size_t patch_count = _mesh->getPatchCount(subdomain); + size_t patch_offset = _mesh->getPatchOffset(subdomain); + + auto & var = foam_mesh.boundary()[subdomain].lookupPatchField( + _foam_variable); + for (size_t j = 0; j < patch_count; ++j) + { + auto elem = patch_offset + j; + auto elem_ptr = _mesh->getElemPtr(elem + _mesh->rank_element_offset); + assert(elem_ptr); + auto dof_t = elem_ptr->dof_number(moose_var.sys().number(), moose_var.number(), 0); + moose_var.sys().solution().set(dof_t, var[j]); + } + } + + moose_var.sys().solution().close(); +} diff --git a/test/OpenFOAM/foam_modules.mk b/test/OpenFOAM/foam_modules.mk new file mode 100644 index 00000000..78d846a8 --- /dev/null +++ b/test/OpenFOAM/foam_modules.mk @@ -0,0 +1,8 @@ +# Build custom OpenFOAM source files: this should be improved in future +all: build_foam_tests + +MAKE=wmake +build_foam_tests: + $(info Building Hippo's OpenFOAM test modules) + @$(MAKE) -j $(MOOSE_JOBS) test/OpenFOAM/modules/transferTestSolver/ 1>/dev/null + @$(MAKE) -j $(MOOSE_JOBS) test/OpenFOAM/modules/bcTestSolver/ 1>/dev/null diff --git a/test/OpenFOAM/modules/bcTestSolver/Make/files b/test/OpenFOAM/modules/bcTestSolver/Make/files new file mode 100644 index 00000000..7c00c607 --- /dev/null +++ b/test/OpenFOAM/modules/bcTestSolver/Make/files @@ -0,0 +1,3 @@ +SOURCE += bcTestSolver.C + +LIB = $(FOAM_USER_LIBBIN)/libbcTestSolver diff --git a/test/OpenFOAM/modules/bcTestSolver/Make/options b/test/OpenFOAM/modules/bcTestSolver/Make/options new file mode 100644 index 00000000..cc845ca8 --- /dev/null +++ b/test/OpenFOAM/modules/bcTestSolver/Make/options @@ -0,0 +1,20 @@ +EXE_INC = \ + -I$(LIB_SRC)/physicalProperties/lnInclude \ + -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \ + -I$(LIB_SRC)/thermophysicalModels/solidThermo/lnInclude \ + -I$(LIB_SRC)/ThermophysicalTransportModels/thermophysicalTransportModel/lnInclude \ + -I$(LIB_SRC)/ThermophysicalTransportModels/solid/lnInclude \ + -I$(LIB_SRC)/finiteVolume/lnInclude \ + -I$(LIB_SRC)/meshTools/lnInclude \ + -I$(LIB_SRC)/sampling/lnInclude + +LIB_LIBS = \ + -lsolidThermo \ + -lsolidThermophysicalTransportModels \ + -lcoupledThermophysicalTransportModels \ + -lspecie \ + -lfiniteVolume \ + -lmeshTools \ + -lsampling \ + -lfvModels \ + -lfvConstraints diff --git a/test/OpenFOAM/modules/bcTestSolver/bcTestSolver.C b/test/OpenFOAM/modules/bcTestSolver/bcTestSolver.C new file mode 100644 index 00000000..ea39ebd8 --- /dev/null +++ b/test/OpenFOAM/modules/bcTestSolver/bcTestSolver.C @@ -0,0 +1,168 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Copyright (C) 2022-2024 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "dimensionSets.H" +#include "fvMesh.H" +#include "bcTestSolver.H" +#include "fvMeshMover.H" +#include "addToRunTimeSelectionTable.H" +#include "fvConstraints.H" +#include "fvmLaplacian.H" + +// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // + +namespace Foam +{ +namespace solvers +{ +defineTypeNameAndDebug(bcTestSolver, 0); +addToRunTimeSelectionTable(solver, bcTestSolver, fvMesh); +} +} + +// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // + +// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * // + +bool +Foam::solvers::bcTestSolver::dependenciesModified() const +{ + return runTime.controlDict().modified(); +} + +bool +Foam::solvers::bcTestSolver::read() +{ + solver::read(); + + maxDeltaT_ = runTime.controlDict().found("maxDeltaT") + ? runTime.controlDict().lookup("maxDeltaT", runTime.userUnits()) + : vGreat; + + return true; +} + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // +// Solver based on solid.C module +Foam::solvers::bcTestSolver::bcTestSolver(fvMesh & mesh, autoPtr thermoPtr) + : solver(mesh), + + thermoPtr_(thermoPtr), + thermo_(thermoPtr_()), + + T_(IOobject("T", mesh.time().name(), mesh, IOobject::NO_READ, IOobject::AUTO_WRITE), mesh), + + thermophysicalTransport(solidThermophysicalTransportModel::New(thermo_)), + thermo(thermo_), + T(T_) +{ + thermo.validate("solid", "h", "e"); +} + +Foam::solvers::bcTestSolver::bcTestSolver(fvMesh & mesh) + : bcTestSolver(mesh, solidThermo::New(mesh)) +{ + // Read the controls + read(); +} + +// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // + +Foam::solvers::bcTestSolver::~bcTestSolver() {} + +// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * // + +Foam::scalar +Foam::solvers::bcTestSolver::maxDeltaT() const +{ + return min(fvModels().maxDeltaT(), maxDeltaT_); +} + +void +Foam::solvers::bcTestSolver::preSolve() +{ + fvModels().preUpdateMesh(); + + // Update the mesh for topology change, mesh to mesh mapping + mesh_.update(); +} + +void +Foam::solvers::bcTestSolver::moveMesh() +{ + if (pimple.firstIter() || pimple.moveMeshOuterCorrectors()) + { + if (!mesh_.mover().solidBody()) + { + FatalErrorInFunction << "Region " << name() << " of type " << type() + << " does not support non-solid body mesh motion" << exit(FatalError); + } + + mesh_.move(); + } +} + +void +Foam::solvers::bcTestSolver::motionCorrector() +{ +} + +void +Foam::solvers::bcTestSolver::prePredictor() +{ +} + +void +Foam::solvers::bcTestSolver::momentumPredictor() +{ +} + +void +Foam::solvers::bcTestSolver::thermophysicalPredictor() +{ + fvScalarMatrix eEqn(fvm::laplacian(thermo_.kappa(), thermo.he())); + + eEqn.solve(); + + thermo.he().write(); + thermo_.correct(); +} + +void +Foam::solvers::bcTestSolver::pressureCorrector() +{ +} + +void +Foam::solvers::bcTestSolver::postCorrector() +{ +} + +void +Foam::solvers::bcTestSolver::postSolve() +{ +} + +// ************************************************************************* // diff --git a/test/OpenFOAM/modules/bcTestSolver/bcTestSolver.H b/test/OpenFOAM/modules/bcTestSolver/bcTestSolver.H new file mode 100644 index 00000000..e9a3d626 --- /dev/null +++ b/test/OpenFOAM/modules/bcTestSolver/bcTestSolver.H @@ -0,0 +1,147 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Copyright (C) 2022-2023 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +Class + Foam::solvers::bcTestSolver + +Description + Solver module for to test imposition of OpenFOAM boundary conditions using Moose input file + syntax. Based on Solid solver + +SourceFiles + bcTestSolver.C + +\*---------------------------------------------------------------------------*/ + +#pragma once + +#include "solver.H" +#include "solidThermophysicalTransportModel.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +namespace Foam +{ +namespace solvers +{ + +/*---------------------------------------------------------------------------*\ + Class bcTestSolver Declaration +\*---------------------------------------------------------------------------*/ + +class bcTestSolver : public solver +{ + +protected: + // Control parameters + scalar maxDeltaT_; + + // Thermophysical properties + autoPtr thermoPtr_; + + solidThermo & thermo_; + + volScalarField T_; + + autoPtr thermophysicalTransport; + + // Protected Member Functions + + //- Return true if the solver's dependencies have been modified + virtual bool dependenciesModified() const; + + //- Read controls + virtual bool read(); + +public: + // Public Data + // reference to thermophysical properties + const solidThermo & thermo; + + //- Reference to the temperature field + const volScalarField & T; + + //- Runtime type information + TypeName("bcTestSolver"); + + // Constructors + + //- Construct from region mesh + bcTestSolver(fvMesh & mesh, autoPtr thermoPtr); + + bcTestSolver(fvMesh & mesh); + + //- Disallow default bitwise copy construction + bcTestSolver(const bcTestSolver &) = delete; + + //- Destructor + virtual ~bcTestSolver(); + + // Member Functions + + //- Return the current maximum time-step for stable solution + virtual scalar maxDeltaT() const; + + //- Called at the start of the time-step, before the PIMPLE loop + virtual void preSolve(); + + //- Called at the start of the PIMPLE loop to move the mesh + virtual void moveMesh(); + + //- Corrections that follow mesh motion + virtual void motionCorrector(); + + //- Called at the beginning of the PIMPLE loop + virtual void prePredictor(); + + //- Construct and optionally solve the momentum equation + virtual void momentumPredictor(); + + //- Construct and solve the energy equation, + // convert to temperature + // and update thermophysical and transport properties + virtual void thermophysicalPredictor(); + + //- Construct and solve the pressure equation in the PISO loop + virtual void pressureCorrector(); + + //- Correct the thermophysical transport modelling + virtual void postCorrector(); + + //- Called after the PIMPLE loop at the end of the time-step + virtual void postSolve(); + + // Member Operators + + //- Disallow default bitwise assignment + void operator=(const bcTestSolver &) = delete; +}; + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +} // End namespace solvers +} // End namespace Foam + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +// ************************************************************************* // diff --git a/test/OpenFOAM/modules/transferTestSolver/Make/files b/test/OpenFOAM/modules/transferTestSolver/Make/files new file mode 100644 index 00000000..4d6d664f --- /dev/null +++ b/test/OpenFOAM/modules/transferTestSolver/Make/files @@ -0,0 +1,3 @@ +SOURCE += transferTestSolver.C + +LIB = $(FOAM_USER_LIBBIN)/libtransferTestSolver diff --git a/test/OpenFOAM/modules/transferTestSolver/Make/options b/test/OpenFOAM/modules/transferTestSolver/Make/options new file mode 100644 index 00000000..cc845ca8 --- /dev/null +++ b/test/OpenFOAM/modules/transferTestSolver/Make/options @@ -0,0 +1,20 @@ +EXE_INC = \ + -I$(LIB_SRC)/physicalProperties/lnInclude \ + -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \ + -I$(LIB_SRC)/thermophysicalModels/solidThermo/lnInclude \ + -I$(LIB_SRC)/ThermophysicalTransportModels/thermophysicalTransportModel/lnInclude \ + -I$(LIB_SRC)/ThermophysicalTransportModels/solid/lnInclude \ + -I$(LIB_SRC)/finiteVolume/lnInclude \ + -I$(LIB_SRC)/meshTools/lnInclude \ + -I$(LIB_SRC)/sampling/lnInclude + +LIB_LIBS = \ + -lsolidThermo \ + -lsolidThermophysicalTransportModels \ + -lcoupledThermophysicalTransportModels \ + -lspecie \ + -lfiniteVolume \ + -lmeshTools \ + -lsampling \ + -lfvModels \ + -lfvConstraints diff --git a/test/OpenFOAM/modules/transferTestSolver/transferTestSolver.C b/test/OpenFOAM/modules/transferTestSolver/transferTestSolver.C new file mode 100644 index 00000000..80adcbae --- /dev/null +++ b/test/OpenFOAM/modules/transferTestSolver/transferTestSolver.C @@ -0,0 +1,178 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Copyright (C) 2022-2024 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "dimensionSets.H" +#include "fvMesh.H" +#include "transferTestSolver.H" +#include "fvMeshMover.H" +#include "addToRunTimeSelectionTable.H" + +// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // + +namespace Foam +{ +namespace solvers +{ +defineTypeNameAndDebug(transferTestSolver, 0); +addToRunTimeSelectionTable(solver, transferTestSolver, fvMesh); +} +} + +// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // + +// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * // + +bool +Foam::solvers::transferTestSolver::dependenciesModified() const +{ + return runTime.controlDict().modified(); +} + +bool +Foam::solvers::transferTestSolver::read() +{ + solver::read(); + + maxDeltaT_ = runTime.controlDict().found("maxDeltaT") + ? runTime.controlDict().lookup("maxDeltaT", runTime.userUnits()) + : vGreat; + + return true; +} + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // +// Solver based on solid.C module +Foam::solvers::transferTestSolver::transferTestSolver(fvMesh & mesh, autoPtr thermoPtr) + : solver(mesh), + + thermoPtr_(thermoPtr), + thermo_(thermoPtr_()), + + T_(IOobject("T", mesh.time().name(), mesh, IOobject::NO_READ, IOobject::AUTO_WRITE), mesh), + + thermophysicalTransport(solidThermophysicalTransportModel::New(thermo_)), + thermo(thermo_), + T(T_) +{ + thermo.validate("solid", "h", "e"); +} + +Foam::solvers::transferTestSolver::transferTestSolver(fvMesh & mesh) + : transferTestSolver(mesh, solidThermo::New(mesh)) +{ + // Read the controls + read(); +} + +// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // + +Foam::solvers::transferTestSolver::~transferTestSolver() {} + +// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * // + +Foam::scalar +Foam::solvers::transferTestSolver::maxDeltaT() const +{ + return min(fvModels().maxDeltaT(), maxDeltaT_); +} + +void +Foam::solvers::transferTestSolver::preSolve() +{ + fvModels().preUpdateMesh(); + + // Update the mesh for topology change, mesh to mesh mapping + mesh_.update(); +} + +void +Foam::solvers::transferTestSolver::moveMesh() +{ + if (pimple.firstIter() || pimple.moveMeshOuterCorrectors()) + { + if (!mesh_.mover().solidBody()) + { + FatalErrorInFunction << "Region " << name() << " of type " << type() + << " does not support non-solid body mesh motion" << exit(FatalError); + } + + mesh_.move(); + } +} + +void +Foam::solvers::transferTestSolver::motionCorrector() +{ +} + +void +Foam::solvers::transferTestSolver::prePredictor() +{ +} + +void +Foam::solvers::transferTestSolver::momentumPredictor() +{ +} + +void +Foam::solvers::transferTestSolver::thermophysicalPredictor() +{ + // To set temperature for testing, internal energy must be set. The + // thermo_.correct() call calculates Temperature. + + // Get e and Cv + volScalarField & e = thermo_.he(); + const volScalarField & Cv = thermo_.Cv(); + + // Set e to Cv*(xy + yz + xz)t which gives a non-uniform be first order value of wall heat flux at + // all boundaries. + dimensioned t( + "t", T_.dimensions() / (dimLength * dimLength), mesh_.time().userTimeValue()); + auto & coords = mesh_.C(); + e = Cv * (dimensionedScalar(T.dimensions(), 0.01) + + (coords.component(0) * coords.component(1) + coords.component(1) * coords.component(2) + + coords.component(2) * coords.component(0)) * + t); + + thermo_.correct(); +} + +void +Foam::solvers::transferTestSolver::pressureCorrector() +{ +} + +void +Foam::solvers::transferTestSolver::postCorrector() +{ +} + +void +Foam::solvers::transferTestSolver::postSolve() +{ +} + +// ************************************************************************* // diff --git a/test/OpenFOAM/modules/transferTestSolver/transferTestSolver.H b/test/OpenFOAM/modules/transferTestSolver/transferTestSolver.H new file mode 100644 index 00000000..f15ecd66 --- /dev/null +++ b/test/OpenFOAM/modules/transferTestSolver/transferTestSolver.H @@ -0,0 +1,147 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Copyright (C) 2022-2023 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +Class + Foam::solvers::transferTestSolver + +Description + Solver module for to test transfers between OpenFOAM and MOOSE. Based on Solid + solver + +SourceFiles + transferTestSolver.C + +\*---------------------------------------------------------------------------*/ + +#pragma once + +#include "solver.H" +#include "solidThermophysicalTransportModel.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +namespace Foam +{ +namespace solvers +{ + +/*---------------------------------------------------------------------------*\ + Class transferTestSolver Declaration +\*---------------------------------------------------------------------------*/ + +class transferTestSolver : public solver +{ + +protected: + // Control parameters + scalar maxDeltaT_; + + // Thermophysical properties + autoPtr thermoPtr_; + + solidThermo & thermo_; + + volScalarField T_; + + autoPtr thermophysicalTransport; + + // Protected Member Functions + + //- Return true if the solver's dependencies have been modified + virtual bool dependenciesModified() const; + + //- Read controls + virtual bool read(); + +public: + // Public Data + // reference to thermophysical properties + const solidThermo & thermo; + + //- Reference to the temperature field + const volScalarField & T; + + //- Runtime type information + TypeName("transferTestSolver"); + + // Constructors + + //- Construct from region mesh + transferTestSolver(fvMesh & mesh, autoPtr thermoPtr); + + transferTestSolver(fvMesh & mesh); + + //- Disallow default bitwise copy construction + transferTestSolver(const transferTestSolver &) = delete; + + //- Destructor + virtual ~transferTestSolver(); + + // Member Functions + + //- Return the current maximum time-step for stable solution + virtual scalar maxDeltaT() const; + + //- Called at the start of the time-step, before the PIMPLE loop + virtual void preSolve(); + + //- Called at the start of the PIMPLE loop to move the mesh + virtual void moveMesh(); + + //- Corrections that follow mesh motion + virtual void motionCorrector(); + + //- Called at the beginning of the PIMPLE loop + virtual void prePredictor(); + + //- Construct and optionally solve the momentum equation + virtual void momentumPredictor(); + + //- Construct and solve the energy equation, + // convert to temperature + // and update thermophysical and transport properties + virtual void thermophysicalPredictor(); + + //- Construct and solve the pressure equation in the PISO loop + virtual void pressureCorrector(); + + //- Correct the thermophysical transport modelling + virtual void postCorrector(); + + //- Called after the PIMPLE loop at the end of the time-step + virtual void postSolve(); + + // Member Operators + + //- Disallow default bitwise assignment + void operator=(const transferTestSolver &) = delete; +}; + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +} // End namespace solvers +} // End namespace Foam + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +// ************************************************************************* // diff --git a/test/include/bcs/FoamTestBC.h b/test/include/bcs/FoamTestBC.h new file mode 100644 index 00000000..28cd2a91 --- /dev/null +++ b/test/include/bcs/FoamTestBC.h @@ -0,0 +1,10 @@ +#include "FoamBCBase.h" +#include "InputParameters.h" + +class FoamTestBC : public FoamBCBase +{ +public: + explicit FoamTestBC(const InputParameters & params) : FoamBCBase(params) {}; + + void imposeBoundaryCondition() {}; +}; diff --git a/test/python/read_hippo_data.py b/test/python/read_hippo_data.py index 8c586b23..592cb1fa 100644 --- a/test/python/read_hippo_data.py +++ b/test/python/read_hippo_data.py @@ -1,14 +1,75 @@ +"""Helper functions for reading OpenFOAM and MOOSE exodus data +""" + +import os +import re from pathlib import Path from typing import Literal + import numpy as np import pyvista as pv -def read_moose_exodus_data(exo_file, - time, - variable, - block: int | str=0): +def get_exodus_times(exo_file: Path | str | bytes) -> list[float]: + """Get the times from the exodus file. + + Parameters + ---------- + exo_file : Path | str | bytes + Exodus II file name/path + + Returns + ------- + list[float] + List of times + """ + reader: pv.ExodusIIReader = pv.get_reader(exo_file) + return reader.time_values + +def get_foam_times(case_dir: str | bytes) -> list[str]: + """Get the times from the foam case directory + Parameters + ---------- + case_dir : str | bytes + Case directory + + Returns + ------- + list[str] + Sorted list of times + """ + return sorted(folder + for folder in os.listdir(case_dir) + if re.match(r"[-+]?([0-9]*\.[0-9]+|[0-9]+)", folder)) + +def read_moose_exodus_data(exo_file: Path | str | bytes, + time: float, + variable: str, + block: int | str=0) -> tuple[dict[str, np.ndarray], np.ndarray]: + """Read Exodus file and return coordinate and variable data + + Parameters + ---------- + exo_file : Path | str | bytes + Exodus II file name + time : float + Time value + variable : str + Name of variable + block : int | str, optional + Block of Exodus II file to read, by default 0 (Element Blocks) + + Returns + ------- + tuple[dict[str, np.ndarray], np.ndarray] + Dictionary of coordinates and variable array + + Raises + ------ + KeyError + If variable is not found in Exodus file + """ reader: pv.ExodusIIReader = pv.get_reader(exo_file) reader.set_active_time_value(time) @@ -38,8 +99,27 @@ def read_openfoam_data(case_dir: Path | str | bytes, variable: str, block: str = 'internalMesh', case_type: Literal['decomposed', 'reconstructed'] = 'reconstructed' - ) -> tuple[np.ndarray, np.ndarray]: + ) -> tuple[dict[str, np.ndarray], np.ndarray]: + """Read OpenFOAM data file and return coordinate and variable data + + Parameters + ---------- + case_dir : Path | str | bytes + OpenFOAM results directory + time : float + time + variable : str + Name of variable + block : str, optional + Which part of the mesh to read, by default 'internalMesh' + case_type : Literal[decomposed, reconstructed], optional + Whether data has been reconstructed or not, by default 'reconstructed' + Returns + ------- + tuple[dict[str, np.ndarray], np.ndarray] + Dictionary of coordinates and variable array + """ file_name = Path(case_dir) / "case.foam" file_name.touch() diff --git a/test/src/bcs/FoamTestBC.C b/test/src/bcs/FoamTestBC.C new file mode 100644 index 00000000..e4cb541e --- /dev/null +++ b/test/src/bcs/FoamTestBC.C @@ -0,0 +1,3 @@ +#include "FoamTestBC.h" + +registerMooseObject("hippoApp", FoamTestBC); diff --git a/test/tests/input_errors/foam_mesh/0/T b/test/tests/actions/foam_bc/foam/0/T similarity index 74% rename from test/tests/input_errors/foam_mesh/0/T rename to test/tests/actions/foam_bc/foam/0/T index d66e2ef8..6da637de 100644 --- a/test/tests/input_errors/foam_mesh/0/T +++ b/test/tests/actions/foam_bc/foam/0/T @@ -16,27 +16,35 @@ FoamFile dimensions [0 0 0 1 0 0 0]; -internalField uniform 293; +internalField uniform 0.; boundaryField { - topAndBottom + left + { + type fixedValue; + value uniform 0.; + } + right + { + type fixedGradient; + gradient uniform 1.; + } + top { type zeroGradient; } - frontAndBack + front { type zeroGradient; } - hot + bottom { - type fixedValue; - value uniform 307.75; + type zeroGradient; } - cold + back { - type fixedValue; - value uniform 288.15; + type zeroGradient; } } diff --git a/test/tests/actions/foam_bc/foam/constant/physicalProperties b/test/tests/actions/foam_bc/foam/constant/physicalProperties new file mode 100644 index 00000000..6dab7b1c --- /dev/null +++ b/test/tests/actions/foam_bc/foam/constant/physicalProperties @@ -0,0 +1,51 @@ +/*--------------------------------*- C++ -*----------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Version: 10 + \\/ M anipulation | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + format ascii; + class dictionary; + location "constant"; + object physicalProperties; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +thermoType +{ + type heSolidThermo; + mixture pureMixture; + transport constIsoSolid; + thermo eConst; + equationOfState rhoConst; + specie specie; + energy sensibleInternalEnergy; +} + +mixture +{ + specie + { + molWeight 1; + } + thermodynamics + { + Cv 1; // Specific heat capacity [J/(kg·K)] + Hf 1; // Heat of formation [J/kg] + Tref 0; + } + transport + { + kappa 2.; // Thermal conductivity [W/(m·K)] + } + equationOfState + { + rho 1; // Density [kg/m^3] + } +} + + +// ************************************************************************* // diff --git a/test/tests/actions/foam_bc/foam/system/blockMeshDict b/test/tests/actions/foam_bc/foam/system/blockMeshDict new file mode 100644 index 00000000..face9ea6 --- /dev/null +++ b/test/tests/actions/foam_bc/foam/system/blockMeshDict @@ -0,0 +1,85 @@ +FoamFile +{ + version 2.0; + format ascii; + class dictionary; + object blockMeshDict; +} + +vertices +( + ( 0.0 0.0 0.0 ) + ( 10.0 0.0 0.0 ) + ( 10.0 1.0 0.0 ) + ( 0.0 1.0 0.0 ) + + ( 0.0 0.0 1.0) + ( 10.0 0.0 1.0) + ( 10.0 1.0 1.0) + ( 0.0 1.0 1.0) +); + +blocks +( + hex (0 1 2 3 4 5 6 7) (50 1 1) simpleGrading (25 1 1) +); + +boundary +( + + // interface + left + { + type wall; + faces + ( + (4 7 3 0) + ); + } + + right + { + type wall; + faces + ( + (6 5 1 2) + ); + } + + top + { + type wall; + faces + ( + (2 3 7 6) + ); + } + + front + { + type wall; + faces + ( + (3 2 1 0) + ); + } + + bottom + { + type wall; + faces + ( + (0 1 5 4) + ); + } + + back + { + type wall; + faces + ( + (4 5 6 7) + ); + } + +); diff --git a/test/tests/input_errors/foam_mesh/system/controlDict b/test/tests/actions/foam_bc/foam/system/controlDict similarity index 87% rename from test/tests/input_errors/foam_mesh/system/controlDict rename to test/tests/actions/foam_bc/foam/system/controlDict index 9652bc17..89301ab0 100644 --- a/test/tests/input_errors/foam_mesh/system/controlDict +++ b/test/tests/actions/foam_bc/foam/system/controlDict @@ -13,7 +13,7 @@ FoamFile } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // -application buoyantFoam; +solver bcTestSolver; startFrom startTime; @@ -21,27 +21,24 @@ startTime 0; stopAt endTime; -endTime 1; +endTime 32.; -deltaT 1; +deltaT 1.; writeControl timeStep; writeInterval 1; -purgeWrite 0; - writeFormat ascii; -writePrecision 15; +writePrecision 20; writeCompression off; timeFormat general; -timePrecision 6; +timePrecision 20; runTimeModifiable true; - // ************************************************************************* // diff --git a/test/tests/actions/foam_bc/foam/system/fvSchemes b/test/tests/actions/foam_bc/foam/system/fvSchemes new file mode 100644 index 00000000..a24aaf80 --- /dev/null +++ b/test/tests/actions/foam_bc/foam/system/fvSchemes @@ -0,0 +1,46 @@ +/*--------------------------------*- C++ -*----------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Version: 12 + \\/ M anipulation | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + format ascii; + class dictionary; + object fvSchemes; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +ddtSchemes +{ + default Euler; +} + +gradSchemes +{ + default Gauss linear; +} + +divSchemes +{ + default Gauss linear; +} + +laplacianSchemes +{ + default Gauss linear corrected; +} + +interpolationSchemes +{ + default linear; +} + +snGradSchemes +{ + default corrected; +} + +// ************************************************************************* // diff --git a/test/tests/actions/foam_bc/foam/system/fvSolution b/test/tests/actions/foam_bc/foam/system/fvSolution new file mode 100644 index 00000000..639b272d --- /dev/null +++ b/test/tests/actions/foam_bc/foam/system/fvSolution @@ -0,0 +1,49 @@ +/*--------------------------------*- C++ -*----------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Version: 12 + \\/ M anipulation | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + format ascii; + class dictionary; + object fvSolution; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +solvers +{ + rho + { + solver diagonal; + } + + rhoFinal + { + $rho; + } + + + e + { + solver PBiCGStab; + preconditioner DIC; + tolerance 1e-15; + relTol 1e-15; + } + + eFinal + { + $e; + tolerance 1e-15; + relTol 1e-15; + } +} + +PIMPLE +{ +} + +// ************************************************************************* // diff --git a/test/tests/actions/foam_bc/main.i b/test/tests/actions/foam_bc/main.i new file mode 100644 index 00000000..6c8680b8 --- /dev/null +++ b/test/tests/actions/foam_bc/main.i @@ -0,0 +1,54 @@ +[Mesh] + type = FoamMesh + case = 'foam' + foam_patch = 'left right' +[] + +[Variables] + [dummy] + family = MONOMIAL + order = CONSTANT + initial_condition = 999 + [] +[] + +[FoamBCs] + [temp] + type=FoamTestBC + foam_variable = T + v = T_value + boundary = 'left' + [] + [temp_r] + type=FoamTestBC + foam_variable = T + v = T_value + boundary = 'right' + [] +[] + +[AuxVariables] + [T_value] + family = MONOMIAL + order = CONSTANT + initial_condition = 0. + [] +[] + +[Problem] + type = FoamProblem +[] + +[Executioner] + type = Transient + end_time = 1 + [TimeSteppers] + [foam] + type = FoamControlledTimeStepper + [] + [] +[] + +[Outputs] + exodus = true +[] diff --git a/test/tests/input_errors/order_of_t_is_not_constant.i b/test/tests/actions/foam_bc/order_of_t_is_not_constant.i similarity index 74% rename from test/tests/input_errors/order_of_t_is_not_constant.i rename to test/tests/actions/foam_bc/order_of_t_is_not_constant.i index 07fcf2aa..c60af677 100644 --- a/test/tests/input_errors/order_of_t_is_not_constant.i +++ b/test/tests/actions/foam_bc/order_of_t_is_not_constant.i @@ -1,13 +1,22 @@ [Mesh] type = FoamMesh - case = './foam_mesh' - foam_patch = 'topAndBottom frontAndBack' + case = './foam' + foam_patch = 'left right' +[] + +[FoamBCs] + [T] + type = FoamFixedValueBC + foam_variable = T + v = T + [] [] [AuxVariables] [T] initial_condition = 111 family = MONOMIAL + order = CONSTANT [] [foam_T] initial_condition = 999 @@ -23,9 +32,6 @@ [Problem] type=FoamProblem - temp = T - foam_temp = foam_T - foam_heat_flux = foam_hf [] [Executioner] diff --git a/test/tests/actions/foam_bc/test.py b/test/tests/actions/foam_bc/test.py new file mode 100644 index 00000000..fa525ab2 --- /dev/null +++ b/test/tests/actions/foam_bc/test.py @@ -0,0 +1,27 @@ +"""Tests for imposing BCs in OpenFOAM using MOOSE input file syntax +""" + +import unittest +import fluidfoam as ff +import numpy as np + +from read_hippo_data import get_foam_times + +class TestFoamBCFixedGradient(unittest.TestCase): + """Test class for imposing fixed gradient BCs in Hippo.""" + def test_fixed_gradient_x(self): + """Test case for imposing fixed gradient.""" + case_dir = 'foam/' + times = get_foam_times(case_dir)[1:] + + for time in times: + coords = dict(zip(('x','y','z'),ff.readof.readmesh(case_dir))) + + temp = ff.readof.readscalar(case_dir, time, "T") + + temp_ref = coords['x']*np.float64(time) + + temp_diff_max = np.argmax(abs(temp-temp_ref)) + assert np.allclose(temp_ref, temp, rtol=1e-7, atol=1e-12),\ + (f"Max diff ({time}): {abs(temp-temp_ref).max()} " + f"{temp[temp_diff_max]} {temp_ref[temp_diff_max]}") diff --git a/test/tests/actions/foam_bc/tests b/test/tests/actions/foam_bc/tests new file mode 100644 index 00000000..26416e43 --- /dev/null +++ b/test/tests/actions/foam_bc/tests @@ -0,0 +1,58 @@ +[Tests] + [foam_bc_action] + [setup] + type = RunCommand + command = 'bash -c "foamCleanCase -case foam && blockMesh -case foam"' + [] + [check_foam_bc_input_syntax] + type = RunApp + input = main.i + prereq = foam_bc_action/setup + allow_warnings = true + [] + [foam_var_error] + type = RunException + input = main.i + prereq = foam_bc_action/setup + expect_err = "There is no OpenFOAM field named 'T1'" + cli_args = 'FoamBCs/temp/foam_variable=T1' + allow_warnings = true + [] + [foam_boundary_error] + type = RunException + input = main.i + prereq = foam_bc_action/setup + expect_err = "Boundary 'left1' not found in FoamMesh" + cli_args = 'FoamBCs/temp/boundary=left1' + allow_warnings = true + [] + [foam_duplicated_boundary_error] + type = RunException + input = main.i + prereq = foam_bc_action/setup + expect_err = "Imposed FoamBC has duplicated boundary 'left' for foam variable 'T'" + cli_args = 'FoamBCs/temp_r/boundary=left' + allow_warnings = true + [] + [] + [check_variable_family_order_exist] + [order_of_t_is_not_constant] + type = RunException + input = order_of_t_is_not_constant.i + expect_err = "must be a constant monomial" + cli_args = "AuxVariables/T/order=FIRST" + [] + [order_of_t_is_not_monomial] + type = RunException + input = order_of_t_is_not_constant.i + expect_err = "must be a constant monomial" + cli_args = "AuxVariables/T/family=LAGRANGE AuxVariables/T/order=FIRST" + [] + [v_doesnt_exist] + type = RunException + input = order_of_t_is_not_constant.i + expect_err = "Variable 'T1' doesn't exist" + cli_args = "FoamBCs/T/v=T1" + [] + [] +[] diff --git a/test/tests/input_errors/foam_mesh/0/p b/test/tests/actions/foam_variable/foam/0/T similarity index 65% rename from test/tests/input_errors/foam_mesh/0/p rename to test/tests/actions/foam_variable/foam/0/T index f2e57d0e..f8312bb2 100644 --- a/test/tests/input_errors/foam_mesh/0/p +++ b/test/tests/actions/foam_variable/foam/0/T @@ -10,35 +10,45 @@ FoamFile format ascii; class volScalarField; location "0"; - object p; + object T; } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // -dimensions [1 -1 -2 0 0 0 0]; +dimensions [0 0 0 1 0 0 0]; -internalField uniform 100000; +internalField uniform 0.1; boundaryField { - topAndBottom + left { type calculated; - value uniform 100000; + value uniform 0.; } - frontAndBack + right { type calculated; - value uniform 100000; + value uniform 0.; } - hot + top { type calculated; - value uniform 100000; + value uniform 0.; } - cold + bottom { type calculated; - value uniform 100000; + value uniform 0.; + } + back + { + type calculated; + value uniform 0.; + } + front + { + type calculated; + value uniform 0.; } } diff --git a/test/tests/input_errors/foam_mesh/constant/physicalProperties b/test/tests/actions/foam_variable/foam/constant/physicalProperties similarity index 62% rename from test/tests/input_errors/foam_mesh/constant/physicalProperties rename to test/tests/actions/foam_variable/foam/constant/physicalProperties index 6005622f..96a14c15 100644 --- a/test/tests/input_errors/foam_mesh/constant/physicalProperties +++ b/test/tests/actions/foam_variable/foam/constant/physicalProperties @@ -16,30 +16,34 @@ FoamFile thermoType { - type heRhoThermo; + type heSolidThermo; mixture pureMixture; - transport const; - thermo hConst; - equationOfState perfectGas; + transport constIsoSolid; + thermo eConst; + equationOfState rhoConst; specie specie; - energy sensibleEnthalpy; + energy sensibleInternalEnergy; } mixture { specie { - molWeight 28.96; + molWeight 1; } thermodynamics { - Cp 1004.4; - Hf 0; + Cv 1; // Specific heat capacity [J/(kg·K)] + Hf 1; // Heat of formation [J/kg] + Tref 0; } transport { - mu 1.831e-05; - Pr 0.705; + kappa 1; // Thermal conductivity [W/(m·K)] + } + equationOfState + { + rho 1; // Density [kg/m^3] } } diff --git a/test/tests/actions/foam_variable/foam/system/blockMeshDict b/test/tests/actions/foam_variable/foam/system/blockMeshDict new file mode 100644 index 00000000..face9ea6 --- /dev/null +++ b/test/tests/actions/foam_variable/foam/system/blockMeshDict @@ -0,0 +1,85 @@ +FoamFile +{ + version 2.0; + format ascii; + class dictionary; + object blockMeshDict; +} + +vertices +( + ( 0.0 0.0 0.0 ) + ( 10.0 0.0 0.0 ) + ( 10.0 1.0 0.0 ) + ( 0.0 1.0 0.0 ) + + ( 0.0 0.0 1.0) + ( 10.0 0.0 1.0) + ( 10.0 1.0 1.0) + ( 0.0 1.0 1.0) +); + +blocks +( + hex (0 1 2 3 4 5 6 7) (50 1 1) simpleGrading (25 1 1) +); + +boundary +( + + // interface + left + { + type wall; + faces + ( + (4 7 3 0) + ); + } + + right + { + type wall; + faces + ( + (6 5 1 2) + ); + } + + top + { + type wall; + faces + ( + (2 3 7 6) + ); + } + + front + { + type wall; + faces + ( + (3 2 1 0) + ); + } + + bottom + { + type wall; + faces + ( + (0 1 5 4) + ); + } + + back + { + type wall; + faces + ( + (4 5 6 7) + ); + } + +); diff --git a/test/tests/input_errors/foam_mesh/constant/g b/test/tests/actions/foam_variable/foam/system/controlDict similarity index 59% rename from test/tests/input_errors/foam_mesh/constant/g rename to test/tests/actions/foam_variable/foam/system/controlDict index 72d18dc9..0383dd23 100644 --- a/test/tests/input_errors/foam_mesh/constant/g +++ b/test/tests/actions/foam_variable/foam/system/controlDict @@ -8,14 +8,37 @@ FoamFile { format ascii; - class uniformDimensionedVectorField; - location "constant"; - object g; + class dictionary; + object controlDict; } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // -dimensions [0 1 -2 0 0 0 0]; -value (0 -9.81 0); +solver transferTestSolver; +startFrom startTime; + +startTime 0; + +stopAt endTime; + +endTime 0.32; + +deltaT 0.01; + +writeControl timeStep; + +writeInterval 1; + +writeFormat ascii; + +writePrecision 20; + +writeCompression off; + +timeFormat general; + +timePrecision 20; + +runTimeModifiable true; // ************************************************************************* // diff --git a/test/tests/input_errors/foam_mesh/system/fvSchemes b/test/tests/actions/foam_variable/foam/system/fvSchemes similarity index 63% rename from test/tests/input_errors/foam_mesh/system/fvSchemes rename to test/tests/actions/foam_variable/foam/system/fvSchemes index dad97318..787f3b83 100644 --- a/test/tests/input_errors/foam_mesh/system/fvSchemes +++ b/test/tests/actions/foam_variable/foam/system/fvSchemes @@ -2,7 +2,7 @@ ========= | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / O peration | Website: https://openfoam.org - \\ / A nd | Version: 10 + \\ / A nd | Version: 12 \\/ M anipulation | \*---------------------------------------------------------------------------*/ FoamFile @@ -15,7 +15,7 @@ FoamFile ddtSchemes { - default steadyState; + default Euler; } gradSchemes @@ -27,18 +27,15 @@ divSchemes { default none; - div(phi,U) bounded Gauss limitedLinear 0.2; - div(phi,K) bounded Gauss limitedLinear 0.2; - div(phi,h) bounded Gauss limitedLinear 0.2; - div(phi,k) bounded Gauss limitedLinear 0.2; - div(phi,epsilon) bounded Gauss limitedLinear 0.2; - div(phi,omega) bounded Gauss limitedLinear 0.2; + div(phi,U) Gauss linear; + div(phi,K) Gauss linear; + div(phi,h) Gauss linear; div(((rho*nuEff)*dev2(T(grad(U))))) Gauss linear; } laplacianSchemes { - default Gauss linear orthogonal; + default Gauss linear corrected; } interpolationSchemes @@ -48,13 +45,7 @@ interpolationSchemes snGradSchemes { - default orthogonal; + default corrected; } -wallDist -{ - method meshWave; -} - - // ************************************************************************* // diff --git a/test/tests/actions/foam_variable/foam/system/fvSolution b/test/tests/actions/foam_variable/foam/system/fvSolution new file mode 100644 index 00000000..61143b21 --- /dev/null +++ b/test/tests/actions/foam_variable/foam/system/fvSolution @@ -0,0 +1,61 @@ +/*--------------------------------*- C++ -*----------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Version: 12 + \\/ M anipulation | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + format ascii; + class dictionary; + object fvSolution; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +solvers +{ + rho + { + solver diagonal; + } + + rhoFinal + { + $rho; + } + + + "(U|h|p_rgh)" + { + solver PBiCGStab; + preconditioner DILU; + tolerance 1e-8; + relTol 1e-8; + } + + "(U|h|p_rgh)Final" + { + $U; + tolerance 1e-8; + relTol 1e-8; + } +} + +PIMPLE +{ + momentumPredictor yes; + pRefCell 0; + pRefValue 0; +} + +relaxationFactors +{ + equations + { + h 1; + U 1; + } +} + +// ************************************************************************* // diff --git a/test/tests/actions/foam_variable/main.i b/test/tests/actions/foam_variable/main.i new file mode 100644 index 00000000..ab7e7313 --- /dev/null +++ b/test/tests/actions/foam_variable/main.i @@ -0,0 +1,38 @@ +[Mesh] + type = FoamMesh + case = 'foam' + foam_patch = 'left right bottom top back front' +[] + +[Variables] + [dummy] + family = MONOMIAL + order = CONSTANT + initial_condition = 999 + [] +[] + +[FoamVariables] + [T_shadow] + type = FoamVariableField + foam_variable = 'T' + [] +[] +[Problem] + type = FoamProblem + # Take the boundary temperature from OpenFOAM and set it on the MOOSE mesh. +[] + +[Executioner] + type = Transient + end_time = 0.32 + [TimeSteppers] + [foam] + type = FoamControlledTimeStepper + [] + [] +[] + +[Outputs] + exodus = true +[] diff --git a/test/tests/actions/foam_variable/tests b/test/tests/actions/foam_variable/tests new file mode 100644 index 00000000..c7e7fa3b --- /dev/null +++ b/test/tests/actions/foam_variable/tests @@ -0,0 +1,22 @@ +[Tests] + [transfer_test] + [setup] + type = RunCommand + command = 'bash -c "foamCleanCase -case foam && blockMesh -case foam"' + [] + [run] + type = RunApp + input = main.i + prereq = transfer_test/setup + allow_warnings = true + [] + [err_problem] + type = RunException + input = main.i + prereq = transfer_test/setup + expect_err = "can only be used with FoamProblem" + cli_args = "Problem/type=FEProblem" + allow_warnings = true + [] + [] +[] diff --git a/test/tests/input_errors/foam_mesh/0/epsilon b/test/tests/bcs/fixed_value/foam/0/T similarity index 54% rename from test/tests/input_errors/foam_mesh/0/epsilon rename to test/tests/bcs/fixed_value/foam/0/T index 888eefc9..65a14be8 100644 --- a/test/tests/input_errors/foam_mesh/0/epsilon +++ b/test/tests/bcs/fixed_value/foam/0/T @@ -10,35 +10,45 @@ FoamFile format ascii; class volScalarField; location "0"; - object epsilon; + object T; } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // -dimensions [0 2 -3 0 0 0 0]; +dimensions [0 0 0 1 0 0 0]; -internalField uniform 4e-06; +internalField uniform 0.1; boundaryField { - frontAndBack + left { - type epsilonWallFunction; - value uniform 4e-06; + type fixedValue; + value uniform 0.; } - topAndBottom + right { - type epsilonWallFunction; - value uniform 4e-06; + type fixedValue; + value uniform 0.; } - hot + top { - type epsilonWallFunction; - value uniform 4e-06; + type fixedValue; + value uniform 0.; } - cold + bottom { - type epsilonWallFunction; - value uniform 4e-06; + type fixedValue; + value uniform 0.; + } + back + { + type fixedValue; + value uniform 0.; + } + front + { + type fixedValue; + value uniform 0.; } } diff --git a/test/tests/bcs/fixed_value/foam/constant/physicalProperties b/test/tests/bcs/fixed_value/foam/constant/physicalProperties new file mode 100644 index 00000000..96a14c15 --- /dev/null +++ b/test/tests/bcs/fixed_value/foam/constant/physicalProperties @@ -0,0 +1,51 @@ +/*--------------------------------*- C++ -*----------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Version: 10 + \\/ M anipulation | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + format ascii; + class dictionary; + location "constant"; + object physicalProperties; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +thermoType +{ + type heSolidThermo; + mixture pureMixture; + transport constIsoSolid; + thermo eConst; + equationOfState rhoConst; + specie specie; + energy sensibleInternalEnergy; +} + +mixture +{ + specie + { + molWeight 1; + } + thermodynamics + { + Cv 1; // Specific heat capacity [J/(kg·K)] + Hf 1; // Heat of formation [J/kg] + Tref 0; + } + transport + { + kappa 1; // Thermal conductivity [W/(m·K)] + } + equationOfState + { + rho 1; // Density [kg/m^3] + } +} + + +// ************************************************************************* // diff --git a/test/tests/bcs/fixed_value/foam/system/blockMeshDict b/test/tests/bcs/fixed_value/foam/system/blockMeshDict new file mode 100644 index 00000000..face9ea6 --- /dev/null +++ b/test/tests/bcs/fixed_value/foam/system/blockMeshDict @@ -0,0 +1,85 @@ +FoamFile +{ + version 2.0; + format ascii; + class dictionary; + object blockMeshDict; +} + +vertices +( + ( 0.0 0.0 0.0 ) + ( 10.0 0.0 0.0 ) + ( 10.0 1.0 0.0 ) + ( 0.0 1.0 0.0 ) + + ( 0.0 0.0 1.0) + ( 10.0 0.0 1.0) + ( 10.0 1.0 1.0) + ( 0.0 1.0 1.0) +); + +blocks +( + hex (0 1 2 3 4 5 6 7) (50 1 1) simpleGrading (25 1 1) +); + +boundary +( + + // interface + left + { + type wall; + faces + ( + (4 7 3 0) + ); + } + + right + { + type wall; + faces + ( + (6 5 1 2) + ); + } + + top + { + type wall; + faces + ( + (2 3 7 6) + ); + } + + front + { + type wall; + faces + ( + (3 2 1 0) + ); + } + + bottom + { + type wall; + faces + ( + (0 1 5 4) + ); + } + + back + { + type wall; + faces + ( + (4 5 6 7) + ); + } + +); diff --git a/test/tests/input_errors/foam_mesh/0/U b/test/tests/bcs/fixed_value/foam/system/controlDict similarity index 60% rename from test/tests/input_errors/foam_mesh/0/U rename to test/tests/bcs/fixed_value/foam/system/controlDict index 5d3b392b..cb155c26 100644 --- a/test/tests/input_errors/foam_mesh/0/U +++ b/test/tests/bcs/fixed_value/foam/system/controlDict @@ -8,35 +8,37 @@ FoamFile { format ascii; - class volVectorField; - location "0"; - object U; + class dictionary; + object controlDict; } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // -dimensions [0 1 -1 0 0 0 0]; +solver bcTestSolver; -internalField uniform (0 0 0); +startFrom startTime; -boundaryField -{ - topAndBottom - { - type noSlip; - } - frontAndBack - { - type noSlip; - } - hot - { - type noSlip; - } - cold - { - type noSlip; - } -} +startTime 0; + +stopAt endTime; + +endTime 0.32; + +deltaT 0.01; + +writeControl timeStep; + +writeInterval 1; + +writeFormat ascii; + +writePrecision 20; + +writeCompression off; + +timeFormat general; + +timePrecision 20; +runTimeModifiable true; // ************************************************************************* // diff --git a/test/tests/bcs/fixed_value/foam/system/fvSchemes b/test/tests/bcs/fixed_value/foam/system/fvSchemes new file mode 100644 index 00000000..0e534821 --- /dev/null +++ b/test/tests/bcs/fixed_value/foam/system/fvSchemes @@ -0,0 +1,46 @@ +/*--------------------------------*- C++ -*----------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Version: 12 + \\/ M anipulation | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + format ascii; + class dictionary; + object fvSchemes; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +ddtSchemes +{ + default Euler; +} + +gradSchemes +{ + default Gauss linear; +} + +divSchemes +{ + default Gauss linear; +} + +laplacianSchemes +{ + default Gauss linear corrected; +} + +interpolationSchemes +{ + default linear; +} + +snGradSchemes +{ + default corrected; +} + +// ************************************************************************* // diff --git a/test/tests/bcs/fixed_value/foam/system/fvSolution b/test/tests/bcs/fixed_value/foam/system/fvSolution new file mode 100644 index 00000000..59db6a2a --- /dev/null +++ b/test/tests/bcs/fixed_value/foam/system/fvSolution @@ -0,0 +1,61 @@ +/*--------------------------------*- C++ -*----------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Version: 12 + \\/ M anipulation | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + format ascii; + class dictionary; + object fvSolution; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +solvers +{ + rho + { + solver diagonal; + } + + rhoFinal + { + $rho; + } + + + e + { + solver PBiCGStab; + preconditioner DIC; + tolerance 1e-8; + relTol 1e-8; + } + + eFinal + { + $e; + tolerance 1e-8; + relTol 1e-8; + } +} + +PIMPLE +{ + momentumPredictor yes; + pRefCell 0; + pRefValue 0; +} + +relaxationFactors +{ + equations + { + h 1; + U 1; + } +} + +// ************************************************************************* // diff --git a/test/tests/bcs/fixed_value/main.i b/test/tests/bcs/fixed_value/main.i new file mode 100644 index 00000000..4a7c81b1 --- /dev/null +++ b/test/tests/bcs/fixed_value/main.i @@ -0,0 +1,76 @@ +[Mesh] + type = FoamMesh + case = 'foam' + foam_patch = 'left right bottom top back front' +[] + +[Variables] + [dummy] + family = MONOMIAL + order = CONSTANT + initial_condition = 999 + [] +[] + +[FoamBCs] + [temp1] + type=FoamFixedValueBC + foam_variable = T + boundary = 'left right top' # test boundary restrictions + [] + [temp2] + type=FoamFixedValueBC + foam_variable = T + boundary = 'bottom front back' # test boundary restrictions + [] +[] + +[FoamVariables] + [T_shadow] + type = FoamVariableField + foam_variable = 'T' + [] + [e_shadow] + type = FoamVariableField + foam_variable = 'e' + [] + [whf_shadow] + type = FoamFunctionObject + foam_variable = 'wallHeatFlux' + [] +[] + +[AuxKernels] + [T_bc1] + type=ParsedAux + variable = temp1 + expression = '0.05 + (x + y + z)*t' + use_xyzt = true + execute_on='TIMESTEP_BEGIN INITIAL' + [] + [T_bc2] + type=ParsedAux + variable = temp2 + expression = '0.05 + 2*(x + y + z)*t' + use_xyzt = true + execute_on='TIMESTEP_BEGIN INITIAL' + [] +[] +[Problem] + type = FoamProblem + # Take the boundary temperature from OpenFOAM and set it on the MOOSE mesh. +[] + +[Executioner] + type = Transient + end_time = 0.32 + [TimeSteppers] + [foam] + type = FoamControlledTimeStepper + [] + [] +[] + +[Outputs] + exodus = true +[] diff --git a/test/tests/bcs/fixed_value/test.py b/test/tests/bcs/fixed_value/test.py new file mode 100644 index 00000000..b31cac20 --- /dev/null +++ b/test/tests/bcs/fixed_value/test.py @@ -0,0 +1,30 @@ +"""Tests for imposing BCs in OpenFOAM using MOOSE input file syntax +""" + +import unittest +import fluidfoam as ff +import numpy as np + +from read_hippo_data import get_foam_times #pylint: disable=E0401 + +class TestFoamBCFixedValue(unittest.TestCase): + """Test class for imposing fixed value BCs in Hippo.""" + def test_fixed_value(self): + """Test case for imposing fixed value.""" + case_dir = 'foam/' + boundaries = ['top', 'bottom', 'front', 'back', 'left', 'right'] + times = get_foam_times(case_dir)[1:] + + for time in times: + for boundary in boundaries: + coords = dict(zip(('x','y','z'),ff.readof.readmesh(case_dir, boundary=boundary))) + + temp = ff.readof.readscalar(case_dir, time, "T", boundary=boundary) + + scale = 1. if boundary in ('left', 'right', 'top') else 2. + temp_ref = 0.05 + scale*(coords['x'] + coords['y'] + coords['z'])*np.float64(time) + + temp_diff_max = np.argmax(abs(temp-temp_ref)) + assert np.allclose(temp_ref, temp, rtol=1e-7, atol=1e-12),\ + (f"Max diff {boundary} ({time}): {abs(temp-temp_ref).max()} " + f"{temp[temp_diff_max]} {temp_ref[temp_diff_max]}") diff --git a/test/tests/bcs/fixed_value/tests b/test/tests/bcs/fixed_value/tests new file mode 100644 index 00000000..002cd453 --- /dev/null +++ b/test/tests/bcs/fixed_value/tests @@ -0,0 +1,19 @@ +[Tests] + [foam_bc_action_test] + [setup] + type = RunCommand + command = 'bash -c "foamCleanCase -case foam && blockMesh -case foam"' + [] + [run] + type = RunApp + input = main.i + prereq = foam_bc_action_test/setup + allow_warnings = true + [] + [verify] + type = PythonUnitTest + input = test.py + prereq = foam_bc_action_test/run + [] + [] +[] diff --git a/test/tests/input_errors/foam_mesh/0/k b/test/tests/bcs/laplace_fixed_gradient/foam/0/T similarity index 60% rename from test/tests/input_errors/foam_mesh/0/k rename to test/tests/bcs/laplace_fixed_gradient/foam/0/T index 1c8e8236..6da637de 100644 --- a/test/tests/input_errors/foam_mesh/0/k +++ b/test/tests/bcs/laplace_fixed_gradient/foam/0/T @@ -10,35 +10,41 @@ FoamFile format ascii; class volScalarField; location "0"; - object k; + object T; } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // -dimensions [0 2 -2 0 0 0 0]; +dimensions [0 0 0 1 0 0 0]; -internalField uniform 0.000375; +internalField uniform 0.; boundaryField { - topAndBottom + left { - type kqRWallFunction; - value uniform 0.000375; + type fixedValue; + value uniform 0.; } - frontAndBack + right { - type kqRWallFunction; - value uniform 0.000375; + type fixedGradient; + gradient uniform 1.; } - hot + top { - type kqRWallFunction; - value uniform 0.000375; + type zeroGradient; } - cold + front { - type kqRWallFunction; - value uniform 0.000375; + type zeroGradient; + } + bottom + { + type zeroGradient; + } + back + { + type zeroGradient; } } diff --git a/test/tests/bcs/laplace_fixed_gradient/foam/constant/physicalProperties b/test/tests/bcs/laplace_fixed_gradient/foam/constant/physicalProperties new file mode 100644 index 00000000..6dab7b1c --- /dev/null +++ b/test/tests/bcs/laplace_fixed_gradient/foam/constant/physicalProperties @@ -0,0 +1,51 @@ +/*--------------------------------*- C++ -*----------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Version: 10 + \\/ M anipulation | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + format ascii; + class dictionary; + location "constant"; + object physicalProperties; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +thermoType +{ + type heSolidThermo; + mixture pureMixture; + transport constIsoSolid; + thermo eConst; + equationOfState rhoConst; + specie specie; + energy sensibleInternalEnergy; +} + +mixture +{ + specie + { + molWeight 1; + } + thermodynamics + { + Cv 1; // Specific heat capacity [J/(kg·K)] + Hf 1; // Heat of formation [J/kg] + Tref 0; + } + transport + { + kappa 2.; // Thermal conductivity [W/(m·K)] + } + equationOfState + { + rho 1; // Density [kg/m^3] + } +} + + +// ************************************************************************* // diff --git a/test/tests/bcs/laplace_fixed_gradient/foam/system/blockMeshDict b/test/tests/bcs/laplace_fixed_gradient/foam/system/blockMeshDict new file mode 100644 index 00000000..face9ea6 --- /dev/null +++ b/test/tests/bcs/laplace_fixed_gradient/foam/system/blockMeshDict @@ -0,0 +1,85 @@ +FoamFile +{ + version 2.0; + format ascii; + class dictionary; + object blockMeshDict; +} + +vertices +( + ( 0.0 0.0 0.0 ) + ( 10.0 0.0 0.0 ) + ( 10.0 1.0 0.0 ) + ( 0.0 1.0 0.0 ) + + ( 0.0 0.0 1.0) + ( 10.0 0.0 1.0) + ( 10.0 1.0 1.0) + ( 0.0 1.0 1.0) +); + +blocks +( + hex (0 1 2 3 4 5 6 7) (50 1 1) simpleGrading (25 1 1) +); + +boundary +( + + // interface + left + { + type wall; + faces + ( + (4 7 3 0) + ); + } + + right + { + type wall; + faces + ( + (6 5 1 2) + ); + } + + top + { + type wall; + faces + ( + (2 3 7 6) + ); + } + + front + { + type wall; + faces + ( + (3 2 1 0) + ); + } + + bottom + { + type wall; + faces + ( + (0 1 5 4) + ); + } + + back + { + type wall; + faces + ( + (4 5 6 7) + ); + } + +); diff --git a/test/tests/input_errors/foam_mesh/constant/momentumTransport b/test/tests/bcs/laplace_fixed_gradient/foam/system/controlDict similarity index 63% rename from test/tests/input_errors/foam_mesh/constant/momentumTransport rename to test/tests/bcs/laplace_fixed_gradient/foam/system/controlDict index 55c2d61e..89301ab0 100644 --- a/test/tests/input_errors/foam_mesh/constant/momentumTransport +++ b/test/tests/bcs/laplace_fixed_gradient/foam/system/controlDict @@ -9,20 +9,36 @@ FoamFile { format ascii; class dictionary; - object RASProperties; + object controlDict; } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // -simulationType RAS; +solver bcTestSolver; -RAS -{ - model kOmegaSST; +startFrom startTime; - turbulence on; +startTime 0; - printCoeffs on; -} +stopAt endTime; + +endTime 32.; + +deltaT 1.; + +writeControl timeStep; + +writeInterval 1; + +writeFormat ascii; + +writePrecision 20; + +writeCompression off; + +timeFormat general; + +timePrecision 20; +runTimeModifiable true; // ************************************************************************* // diff --git a/test/tests/bcs/laplace_fixed_gradient/foam/system/fvSchemes b/test/tests/bcs/laplace_fixed_gradient/foam/system/fvSchemes new file mode 100644 index 00000000..a24aaf80 --- /dev/null +++ b/test/tests/bcs/laplace_fixed_gradient/foam/system/fvSchemes @@ -0,0 +1,46 @@ +/*--------------------------------*- C++ -*----------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Version: 12 + \\/ M anipulation | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + format ascii; + class dictionary; + object fvSchemes; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +ddtSchemes +{ + default Euler; +} + +gradSchemes +{ + default Gauss linear; +} + +divSchemes +{ + default Gauss linear; +} + +laplacianSchemes +{ + default Gauss linear corrected; +} + +interpolationSchemes +{ + default linear; +} + +snGradSchemes +{ + default corrected; +} + +// ************************************************************************* // diff --git a/test/tests/bcs/laplace_fixed_gradient/foam/system/fvSolution b/test/tests/bcs/laplace_fixed_gradient/foam/system/fvSolution new file mode 100644 index 00000000..639b272d --- /dev/null +++ b/test/tests/bcs/laplace_fixed_gradient/foam/system/fvSolution @@ -0,0 +1,49 @@ +/*--------------------------------*- C++ -*----------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Version: 12 + \\/ M anipulation | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + format ascii; + class dictionary; + object fvSolution; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +solvers +{ + rho + { + solver diagonal; + } + + rhoFinal + { + $rho; + } + + + e + { + solver PBiCGStab; + preconditioner DIC; + tolerance 1e-15; + relTol 1e-15; + } + + eFinal + { + $e; + tolerance 1e-15; + relTol 1e-15; + } +} + +PIMPLE +{ +} + +// ************************************************************************* // diff --git a/test/tests/bcs/laplace_fixed_gradient/main.i b/test/tests/bcs/laplace_fixed_gradient/main.i new file mode 100644 index 00000000..0ff81c11 --- /dev/null +++ b/test/tests/bcs/laplace_fixed_gradient/main.i @@ -0,0 +1,56 @@ +[Mesh] + type = FoamMesh + case = 'foam' + foam_patch = 'left right' +[] + +[Variables] + [dummy] + family = MONOMIAL + order = CONSTANT + initial_condition = 999 + [] +[] + +[FoamBCs] + [T_value] + type=FoamFixedValueBC + foam_variable = T + initial_condition = 0. + boundary = 'left' + [] + [T_flux] + type=FoamFixedGradientBC + foam_variable = T + boundary = 'right' + diffusivity_coefficient = kappa + [] +[] + +[AuxKernels] + [T_flux] + type = ParsedAux + variable = T_flux + expression = '2*t' + use_xyzt = true + execute_on = 'INITIAL TIMESTEP_BEGIN' + [] +[] + +[Problem] + type = FoamProblem +[] + +[Executioner] + type = Transient + end_time = 32 + [TimeSteppers] + [foam] + type = FoamControlledTimeStepper + [] + [] +[] + +[Outputs] + exodus = true +[] diff --git a/test/tests/bcs/laplace_fixed_gradient/test.py b/test/tests/bcs/laplace_fixed_gradient/test.py new file mode 100644 index 00000000..5c89a6fc --- /dev/null +++ b/test/tests/bcs/laplace_fixed_gradient/test.py @@ -0,0 +1,27 @@ +"""Tests for imposing BCs in OpenFOAM using MOOSE input file syntax +""" + +import unittest +import fluidfoam as ff +import numpy as np + +from read_hippo_data import get_foam_times #pylint: disable=E0401 + +class TestFoamBCFixedGradient(unittest.TestCase): + """Test class for imposing fixed value BCs in Hippo.""" + def test_fixed_gradient_x(self): + """Test case for imposing fixed value.""" + case_dir = 'foam/' + times = get_foam_times(case_dir)[1:] + + for time in times: + coords = dict(zip(('x','y','z'),ff.readof.readmesh(case_dir))) + + temp = ff.readof.readscalar(case_dir, time, "T") + + temp_ref = coords['x']*np.float64(time) + + temp_diff_max = np.argmax(abs(temp-temp_ref)) + assert np.allclose(temp_ref, temp, rtol=1e-7, atol=1e-12),\ + (f"Max diff ({time}): {abs(temp-temp_ref).max()} " + f"{temp[temp_diff_max]} {temp_ref[temp_diff_max]}") diff --git a/test/tests/bcs/laplace_fixed_gradient/tests b/test/tests/bcs/laplace_fixed_gradient/tests new file mode 100644 index 00000000..ab7bf175 --- /dev/null +++ b/test/tests/bcs/laplace_fixed_gradient/tests @@ -0,0 +1,27 @@ +[Tests] + [foam_bc_fixed_gradient] + [setup] + type = RunCommand + command = 'bash -c "foamCleanCase -case foam && blockMesh -case foam"' + [] + [diffusivity_coeff_err] + type = RunException + input = main.i + prereq = foam_bc_fixed_gradient/setup + expect_err = "Diffusivity coefficient 'kappa1' not a Foam volScalarField" + cli_args = 'FoamBCs/T_flux/diffusivity_coefficient=kappa1' + allow_warnings = true + [] + [run] + type = RunApp + input = main.i + prereq = foam_bc_fixed_gradient/setup + allow_warnings = true + [] + [verify] + type = PythonUnitTest + input = test.py + prereq = foam_bc_fixed_gradient/run + [] + [] +[] diff --git a/test/tests/input_errors/foam_mesh/0/alphat b/test/tests/input_errors/foam_mesh/0/alphat deleted file mode 100644 index 51fc3869..00000000 --- a/test/tests/input_errors/foam_mesh/0/alphat +++ /dev/null @@ -1,50 +0,0 @@ -/*--------------------------------*- C++ -*----------------------------------*\ - ========= | - \\ / F ield | OpenFOAM: The Open Source CFD Toolbox - \\ / O peration | Website: https://openfoam.org - \\ / A nd | Version: 10 - \\/ M anipulation | -\*---------------------------------------------------------------------------*/ -FoamFile -{ - format ascii; - class volScalarField; - location "0"; - object alphat; -} -// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // - -dimensions [1 -1 -1 0 0 0 0]; - -internalField uniform 0; - -boundaryField -{ - topAndBottom - { - type compressible::alphatWallFunction; - Prt 0.85; - value uniform 0; - } - frontAndBack - { - type compressible::alphatWallFunction; - Prt 0.85; - value uniform 0; - } - hot - { - type compressible::alphatWallFunction; - Prt 0.85; - value uniform 0; - } - cold - { - type compressible::alphatWallFunction; - Prt 0.85; - value uniform 0; - } -} - - -// ************************************************************************* // diff --git a/test/tests/input_errors/foam_mesh/0/nut b/test/tests/input_errors/foam_mesh/0/nut deleted file mode 100644 index f10bb671..00000000 --- a/test/tests/input_errors/foam_mesh/0/nut +++ /dev/null @@ -1,58 +0,0 @@ -/*--------------------------------*- C++ -*----------------------------------*\ - ========= | - \\ / F ield | OpenFOAM: The Open Source CFD Toolbox - \\ / O peration | Website: https://openfoam.org - \\ / A nd | Version: 10 - \\/ M anipulation | -\*---------------------------------------------------------------------------*/ -FoamFile -{ - format ascii; - class volScalarField; - location "0"; - object nut; -} -// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // - -dimensions [0 2 -1 0 0 0 0]; - -internalField uniform 0.003125; - -boundaryField -{ - topAndBottom - { - type nutUWallFunction; - Cmu 0.09; - kappa 0.41; - E 9.8; - value uniform 0; - } - frontAndBack - { - type nutUWallFunction; - Cmu 0.09; - kappa 0.41; - E 9.8; - value uniform 0; - } - hot - { - type nutUWallFunction; - Cmu 0.09; - kappa 0.41; - E 9.8; - value uniform 0; - } - cold - { - type nutUWallFunction; - Cmu 0.09; - kappa 0.41; - E 9.8; - value uniform 0; - } -} - - -// ************************************************************************* // diff --git a/test/tests/input_errors/foam_mesh/0/omega b/test/tests/input_errors/foam_mesh/0/omega deleted file mode 100644 index d7dd3f10..00000000 --- a/test/tests/input_errors/foam_mesh/0/omega +++ /dev/null @@ -1,54 +0,0 @@ -/*--------------------------------*- C++ -*----------------------------------*\ - ========= | - \\ / F ield | OpenFOAM: The Open Source CFD Toolbox - \\ / O peration | Website: https://openfoam.org - \\ / A nd | Version: 10 - \\/ M anipulation | -\*---------------------------------------------------------------------------*/ -FoamFile -{ - format ascii; - class volScalarField; - location "0"; - object omega; -} -// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // - -dimensions [0 0 -1 0 0 0 0]; - -internalField uniform 0.12; - -boundaryField -{ - topAndBottom - { - beta1 0.075; - blended 0; - type omegaWallFunction; - value uniform 0.12; - } - frontAndBack - { - beta1 0.075; - blended 0; - type omegaWallFunction; - value uniform 0.12; - } - hot - { - beta1 0.075; - blended 0; - type omegaWallFunction; - value uniform 0.12; - } - cold - { - beta1 0.075; - blended 0; - type omegaWallFunction; - value uniform 0.12; - } -} - - -// ************************************************************************* // diff --git a/test/tests/input_errors/foam_mesh/0/p_rgh b/test/tests/input_errors/foam_mesh/0/p_rgh deleted file mode 100644 index 8c91dd23..00000000 --- a/test/tests/input_errors/foam_mesh/0/p_rgh +++ /dev/null @@ -1,1342 +0,0 @@ -/*--------------------------------*- C++ -*----------------------------------*\ - ========= | - \\ / F ield | OpenFOAM: The Open Source CFD Toolbox - \\ / O peration | Website: https://openfoam.org - \\ / A nd | Version: 10 - \\/ M anipulation | -\*---------------------------------------------------------------------------*/ -FoamFile -{ - format ascii; - class volScalarField; - location "0"; - object p_rgh; -} -// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // - -dimensions [1 -1 -2 0 0 0 0]; - -internalField nonuniform List -630 -( -0.423711853436544 -0.423711853436544 -0.423711853436544 -0.423711853436544 -0.423711853436544 -0.423711853436544 -0.423711853436544 -1.27113556029508 -1.27113556029508 -1.27113556029508 -1.27113556029508 -1.27113556029508 -1.27113556029508 -1.27113556029508 -2.11855926715361 -2.11855926715361 -2.11855926715361 -2.11855926715361 -2.11855926715361 -2.11855926715361 -2.11855926715361 -2.9659829740267 -2.9659829740267 -2.9659829740267 -2.9659829740267 -2.9659829740267 -2.9659829740267 -2.9659829740267 -3.81340668088524 -3.81340668088524 -3.81340668088524 -3.81340668088524 -3.81340668088524 -3.81340668088524 -3.81340668088524 -4.66083038775832 -4.66083038775832 -4.66083038775832 -4.66083038775832 -4.66083038775832 -4.66083038775832 -4.66083038775832 -5.50825409461686 -5.50825409461686 -5.50825409461686 -5.50825409461686 -5.50825409461686 -5.50825409461686 -5.50825409461686 -6.35567780147539 -6.35567780147539 -6.35567780147539 -6.35567780147539 -6.35567780147539 -6.35567780147539 -6.35567780147539 -7.20310150834848 -7.20310150834848 -7.20310150834848 -7.20310150834848 -7.20310150834848 -7.20310150834848 -7.20310150834848 -8.05052521520702 -8.05052521520702 -8.05052521520702 -8.05052521520702 -8.05052521520702 -8.05052521520702 -8.05052521520702 -8.8979489220801 -8.8979489220801 -8.8979489220801 -8.8979489220801 -8.8979489220801 -8.8979489220801 -8.8979489220801 -9.74537262893864 -9.74537262893864 -9.74537262893864 -9.74537262893864 -9.74537262893864 -9.74537262893864 -9.74537262893864 -10.5927963357972 -10.5927963357972 -10.5927963357972 -10.5927963357972 -10.5927963357972 -10.5927963357972 -10.5927963357972 -11.4402200426703 -11.4402200426703 -11.4402200426703 -11.4402200426703 -11.4402200426703 -11.4402200426703 -11.4402200426703 -12.2876437495288 -12.2876437495288 -12.2876437495288 -12.2876437495288 -12.2876437495288 -12.2876437495288 -12.2876437495288 -13.1350674563873 -13.1350674563873 -13.1350674563873 -13.1350674563873 -13.1350674563873 -13.1350674563873 -13.1350674563873 -13.9824911632604 -13.9824911632604 -13.9824911632604 -13.9824911632604 -13.9824911632604 -13.9824911632604 -13.9824911632604 -14.829914870119 -14.829914870119 -14.829914870119 -14.829914870119 -14.829914870119 -14.829914870119 -14.829914870119 -15.677338576992 -15.677338576992 -15.677338576992 -15.677338576992 -15.677338576992 -15.677338576992 -15.677338576992 -16.5247622838506 -16.5247622838506 -16.5247622838506 -16.5247622838506 -16.5247622838506 -16.5247622838506 -16.5247622838506 -17.3721859907091 -17.3721859907091 -17.3721859907091 -17.3721859907091 -17.3721859907091 -17.3721859907091 -17.3721859907091 -18.2196096975822 -18.2196096975822 -18.2196096975822 -18.2196096975822 -18.2196096975822 -18.2196096975822 -18.2196096975822 -19.0670334044407 -19.0670334044407 -19.0670334044407 -19.0670334044407 -19.0670334044407 -19.0670334044407 -19.0670334044407 -19.9144571112993 -19.9144571112993 -19.9144571112993 -19.9144571112993 -19.9144571112993 -19.9144571112993 -19.9144571112993 -20.7618808181724 -20.7618808181724 -20.7618808181724 -20.7618808181724 -20.7618808181724 -20.7618808181724 -20.7618808181724 -21.6093045250309 -21.6093045250309 -21.6093045250309 -21.6093045250309 -21.6093045250309 -21.6093045250309 -21.6093045250309 -22.456728231904 -22.456728231904 -22.456728231904 -22.456728231904 -22.456728231904 -22.456728231904 -22.456728231904 -23.3041519387625 -23.3041519387625 -23.3041519387625 -23.3041519387625 -23.3041519387625 -23.3041519387625 -23.3041519387625 -24.1515756456211 -24.1515756456211 -24.1515756456211 -24.1515756456211 -24.1515756456211 -24.1515756456211 -24.1515756456211 -24.9989993524941 -24.9989993524941 -24.9989993524941 -24.9989993524941 -24.9989993524941 -24.9989993524941 -24.9989993524941 -0.423711853436544 -0.423711853436544 -0.423711853436544 -0.423711853436544 -0.423711853436544 -0.423711853436544 -0.423711853436544 -1.27113556029508 -1.27113556029508 -1.27113556029508 -1.27113556029508 -1.27113556029508 -1.27113556029508 -1.27113556029508 -2.11855926715361 -2.11855926715361 -2.11855926715361 -2.11855926715361 -2.11855926715361 -2.11855926715361 -2.11855926715361 -2.9659829740267 -2.9659829740267 -2.9659829740267 -2.9659829740267 -2.9659829740267 -2.9659829740267 -2.9659829740267 -3.81340668088524 -3.81340668088524 -3.81340668088524 -3.81340668088524 -3.81340668088524 -3.81340668088524 -3.81340668088524 -4.66083038775832 -4.66083038775832 -4.66083038775832 -4.66083038775832 -4.66083038775832 -4.66083038775832 -4.66083038775832 -5.50825409461686 -5.50825409461686 -5.50825409461686 -5.50825409461686 -5.50825409461686 -5.50825409461686 -5.50825409461686 -6.35567780147539 -6.35567780147539 -6.35567780147539 -6.35567780147539 -6.35567780147539 -6.35567780147539 -6.35567780147539 -7.20310150834848 -7.20310150834848 -7.20310150834848 -7.20310150834848 -7.20310150834848 -7.20310150834848 -7.20310150834848 -8.05052521520702 -8.05052521520702 -8.05052521520702 -8.05052521520702 -8.05052521520702 -8.05052521520702 -8.05052521520702 -8.8979489220801 -8.8979489220801 -8.8979489220801 -8.8979489220801 -8.8979489220801 -8.8979489220801 -8.8979489220801 -9.74537262893864 -9.74537262893864 -9.74537262893864 -9.74537262893864 -9.74537262893864 -9.74537262893864 -9.74537262893864 -10.5927963357972 -10.5927963357972 -10.5927963357972 -10.5927963357972 -10.5927963357972 -10.5927963357972 -10.5927963357972 -11.4402200426703 -11.4402200426703 -11.4402200426703 -11.4402200426703 -11.4402200426703 -11.4402200426703 -11.4402200426703 -12.2876437495288 -12.2876437495288 -12.2876437495288 -12.2876437495288 -12.2876437495288 -12.2876437495288 -12.2876437495288 -13.1350674563873 -13.1350674563873 -13.1350674563873 -13.1350674563873 -13.1350674563873 -13.1350674563873 -13.1350674563873 -13.9824911632604 -13.9824911632604 -13.9824911632604 -13.9824911632604 -13.9824911632604 -13.9824911632604 -13.9824911632604 -14.829914870119 -14.829914870119 -14.829914870119 -14.829914870119 -14.829914870119 -14.829914870119 -14.829914870119 -15.677338576992 -15.677338576992 -15.677338576992 -15.677338576992 -15.677338576992 -15.677338576992 -15.677338576992 -16.5247622838506 -16.5247622838506 -16.5247622838506 -16.5247622838506 -16.5247622838506 -16.5247622838506 -16.5247622838506 -17.3721859907091 -17.3721859907091 -17.3721859907091 -17.3721859907091 -17.3721859907091 -17.3721859907091 -17.3721859907091 -18.2196096975822 -18.2196096975822 -18.2196096975822 -18.2196096975822 -18.2196096975822 -18.2196096975822 -18.2196096975822 -19.0670334044407 -19.0670334044407 -19.0670334044407 -19.0670334044407 -19.0670334044407 -19.0670334044407 -19.0670334044407 -19.9144571112993 -19.9144571112993 -19.9144571112993 -19.9144571112993 -19.9144571112993 -19.9144571112993 -19.9144571112993 -20.7618808181724 -20.7618808181724 -20.7618808181724 -20.7618808181724 -20.7618808181724 -20.7618808181724 -20.7618808181724 -21.6093045250309 -21.6093045250309 -21.6093045250309 -21.6093045250309 -21.6093045250309 -21.6093045250309 -21.6093045250309 -22.456728231904 -22.456728231904 -22.456728231904 -22.456728231904 -22.456728231904 -22.456728231904 -22.456728231904 -23.3041519387625 -23.3041519387625 -23.3041519387625 -23.3041519387625 -23.3041519387625 -23.3041519387625 -23.3041519387625 -24.1515756456211 -24.1515756456211 -24.1515756456211 -24.1515756456211 -24.1515756456211 -24.1515756456211 -24.1515756456211 -24.9989993524941 -24.9989993524941 -24.9989993524941 -24.9989993524941 -24.9989993524941 -24.9989993524941 -24.9989993524941 -0.423711853436544 -0.423711853436544 -0.423711853436544 -0.423711853436544 -0.423711853436544 -0.423711853436544 -0.423711853436544 -1.27113556029508 -1.27113556029508 -1.27113556029508 -1.27113556029508 -1.27113556029508 -1.27113556029508 -1.27113556029508 -2.11855926715361 -2.11855926715361 -2.11855926715361 -2.11855926715361 -2.11855926715361 -2.11855926715361 -2.11855926715361 -2.9659829740267 -2.9659829740267 -2.9659829740267 -2.9659829740267 -2.9659829740267 -2.9659829740267 -2.9659829740267 -3.81340668088524 -3.81340668088524 -3.81340668088524 -3.81340668088524 -3.81340668088524 -3.81340668088524 -3.81340668088524 -4.66083038775832 -4.66083038775832 -4.66083038775832 -4.66083038775832 -4.66083038775832 -4.66083038775832 -4.66083038775832 -5.50825409461686 -5.50825409461686 -5.50825409461686 -5.50825409461686 -5.50825409461686 -5.50825409461686 -5.50825409461686 -6.35567780147539 -6.35567780147539 -6.35567780147539 -6.35567780147539 -6.35567780147539 -6.35567780147539 -6.35567780147539 -7.20310150834848 -7.20310150834848 -7.20310150834848 -7.20310150834848 -7.20310150834848 -7.20310150834848 -7.20310150834848 -8.05052521520702 -8.05052521520702 -8.05052521520702 -8.05052521520702 -8.05052521520702 -8.05052521520702 -8.05052521520702 -8.8979489220801 -8.8979489220801 -8.8979489220801 -8.8979489220801 -8.8979489220801 -8.8979489220801 -8.8979489220801 -9.74537262893864 -9.74537262893864 -9.74537262893864 -9.74537262893864 -9.74537262893864 -9.74537262893864 -9.74537262893864 -10.5927963357972 -10.5927963357972 -10.5927963357972 -10.5927963357972 -10.5927963357972 -10.5927963357972 -10.5927963357972 -11.4402200426703 -11.4402200426703 -11.4402200426703 -11.4402200426703 -11.4402200426703 -11.4402200426703 -11.4402200426703 -12.2876437495288 -12.2876437495288 -12.2876437495288 -12.2876437495288 -12.2876437495288 -12.2876437495288 -12.2876437495288 -13.1350674563873 -13.1350674563873 -13.1350674563873 -13.1350674563873 -13.1350674563873 -13.1350674563873 -13.1350674563873 -13.9824911632604 -13.9824911632604 -13.9824911632604 -13.9824911632604 -13.9824911632604 -13.9824911632604 -13.9824911632604 -14.829914870119 -14.829914870119 -14.829914870119 -14.829914870119 -14.829914870119 -14.829914870119 -14.829914870119 -15.677338576992 -15.677338576992 -15.677338576992 -15.677338576992 -15.677338576992 -15.677338576992 -15.677338576992 -16.5247622838506 -16.5247622838506 -16.5247622838506 -16.5247622838506 -16.5247622838506 -16.5247622838506 -16.5247622838506 -17.3721859907091 -17.3721859907091 -17.3721859907091 -17.3721859907091 -17.3721859907091 -17.3721859907091 -17.3721859907091 -18.2196096975822 -18.2196096975822 -18.2196096975822 -18.2196096975822 -18.2196096975822 -18.2196096975822 -18.2196096975822 -19.0670334044407 -19.0670334044407 -19.0670334044407 -19.0670334044407 -19.0670334044407 -19.0670334044407 -19.0670334044407 -19.9144571112993 -19.9144571112993 -19.9144571112993 -19.9144571112993 -19.9144571112993 -19.9144571112993 -19.9144571112993 -20.7618808181724 -20.7618808181724 -20.7618808181724 -20.7618808181724 -20.7618808181724 -20.7618808181724 -20.7618808181724 -21.6093045250309 -21.6093045250309 -21.6093045250309 -21.6093045250309 -21.6093045250309 -21.6093045250309 -21.6093045250309 -22.456728231904 -22.456728231904 -22.456728231904 -22.456728231904 -22.456728231904 -22.456728231904 -22.456728231904 -23.3041519387625 -23.3041519387625 -23.3041519387625 -23.3041519387625 -23.3041519387625 -23.3041519387625 -23.3041519387625 -24.1515756456211 -24.1515756456211 -24.1515756456211 -24.1515756456211 -24.1515756456211 -24.1515756456211 -24.1515756456211 -24.9989993524941 -24.9989993524941 -24.9989993524941 -24.9989993524941 -24.9989993524941 -24.9989993524941 -24.9989993524941 -) -; - -boundaryField -{ - topAndBottom - { - type fixedFluxPressure; - gradient uniform 0; - value nonuniform List -42 -( -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -25.4227112059161 -) -; - } - frontAndBack - { - type fixedFluxPressure; - gradient uniform 0; - value nonuniform List -420 -( -0.423711853436544 -1.27113556029508 -2.11855926715361 -2.9659829740267 -3.81340668088524 -4.66083038775832 -5.50825409461686 -6.35567780147539 -7.20310150834848 -8.05052521520702 -8.8979489220801 -9.74537262893864 -10.5927963357972 -11.4402200426703 -12.2876437495288 -13.1350674563873 -13.9824911632604 -14.829914870119 -15.677338576992 -16.5247622838506 -17.3721859907091 -18.2196096975822 -19.0670334044407 -19.9144571112993 -20.7618808181724 -21.6093045250309 -22.456728231904 -23.3041519387625 -24.1515756456211 -24.9989993524941 -0.423711853436544 -1.27113556029508 -2.11855926715361 -2.9659829740267 -3.81340668088524 -4.66083038775832 -5.50825409461686 -6.35567780147539 -7.20310150834848 -8.05052521520702 -8.8979489220801 -9.74537262893864 -10.5927963357972 -11.4402200426703 -12.2876437495288 -13.1350674563873 -13.9824911632604 -14.829914870119 -15.677338576992 -16.5247622838506 -17.3721859907091 -18.2196096975822 -19.0670334044407 -19.9144571112993 -20.7618808181724 -21.6093045250309 -22.456728231904 -23.3041519387625 -24.1515756456211 -24.9989993524941 -0.423711853436544 -1.27113556029508 -2.11855926715361 -2.9659829740267 -3.81340668088524 -4.66083038775832 -5.50825409461686 -6.35567780147539 -7.20310150834848 -8.05052521520702 -8.8979489220801 -9.74537262893864 -10.5927963357972 -11.4402200426703 -12.2876437495288 -13.1350674563873 -13.9824911632604 -14.829914870119 -15.677338576992 -16.5247622838506 -17.3721859907091 -18.2196096975822 -19.0670334044407 -19.9144571112993 -20.7618808181724 -21.6093045250309 -22.456728231904 -23.3041519387625 -24.1515756456211 -24.9989993524941 -0.423711853436544 -1.27113556029508 -2.11855926715361 -2.9659829740267 -3.81340668088524 -4.66083038775832 -5.50825409461686 -6.35567780147539 -7.20310150834848 -8.05052521520702 -8.8979489220801 -9.74537262893864 -10.5927963357972 -11.4402200426703 -12.2876437495288 -13.1350674563873 -13.9824911632604 -14.829914870119 -15.677338576992 -16.5247622838506 -17.3721859907091 -18.2196096975822 -19.0670334044407 -19.9144571112993 -20.7618808181724 -21.6093045250309 -22.456728231904 -23.3041519387625 -24.1515756456211 -24.9989993524941 -0.423711853436544 -1.27113556029508 -2.11855926715361 -2.9659829740267 -3.81340668088524 -4.66083038775832 -5.50825409461686 -6.35567780147539 -7.20310150834848 -8.05052521520702 -8.8979489220801 -9.74537262893864 -10.5927963357972 -11.4402200426703 -12.2876437495288 -13.1350674563873 -13.9824911632604 -14.829914870119 -15.677338576992 -16.5247622838506 -17.3721859907091 -18.2196096975822 -19.0670334044407 -19.9144571112993 -20.7618808181724 -21.6093045250309 -22.456728231904 -23.3041519387625 -24.1515756456211 -24.9989993524941 -0.423711853436544 -1.27113556029508 -2.11855926715361 -2.9659829740267 -3.81340668088524 -4.66083038775832 -5.50825409461686 -6.35567780147539 -7.20310150834848 -8.05052521520702 -8.8979489220801 -9.74537262893864 -10.5927963357972 -11.4402200426703 -12.2876437495288 -13.1350674563873 -13.9824911632604 -14.829914870119 -15.677338576992 -16.5247622838506 -17.3721859907091 -18.2196096975822 -19.0670334044407 -19.9144571112993 -20.7618808181724 -21.6093045250309 -22.456728231904 -23.3041519387625 -24.1515756456211 -24.9989993524941 -0.423711853436544 -1.27113556029508 -2.11855926715361 -2.9659829740267 -3.81340668088524 -4.66083038775832 -5.50825409461686 -6.35567780147539 -7.20310150834848 -8.05052521520702 -8.8979489220801 -9.74537262893864 -10.5927963357972 -11.4402200426703 -12.2876437495288 -13.1350674563873 -13.9824911632604 -14.829914870119 -15.677338576992 -16.5247622838506 -17.3721859907091 -18.2196096975822 -19.0670334044407 -19.9144571112993 -20.7618808181724 -21.6093045250309 -22.456728231904 -23.3041519387625 -24.1515756456211 -24.9989993524941 -0.423711853436544 -1.27113556029508 -2.11855926715361 -2.9659829740267 -3.81340668088524 -4.66083038775832 -5.50825409461686 -6.35567780147539 -7.20310150834848 -8.05052521520702 -8.8979489220801 -9.74537262893864 -10.5927963357972 -11.4402200426703 -12.2876437495288 -13.1350674563873 -13.9824911632604 -14.829914870119 -15.677338576992 -16.5247622838506 -17.3721859907091 -18.2196096975822 -19.0670334044407 -19.9144571112993 -20.7618808181724 -21.6093045250309 -22.456728231904 -23.3041519387625 -24.1515756456211 -24.9989993524941 -0.423711853436544 -1.27113556029508 -2.11855926715361 -2.9659829740267 -3.81340668088524 -4.66083038775832 -5.50825409461686 -6.35567780147539 -7.20310150834848 -8.05052521520702 -8.8979489220801 -9.74537262893864 -10.5927963357972 -11.4402200426703 -12.2876437495288 -13.1350674563873 -13.9824911632604 -14.829914870119 -15.677338576992 -16.5247622838506 -17.3721859907091 -18.2196096975822 -19.0670334044407 -19.9144571112993 -20.7618808181724 -21.6093045250309 -22.456728231904 -23.3041519387625 -24.1515756456211 -24.9989993524941 -0.423711853436544 -1.27113556029508 -2.11855926715361 -2.9659829740267 -3.81340668088524 -4.66083038775832 -5.50825409461686 -6.35567780147539 -7.20310150834848 -8.05052521520702 -8.8979489220801 -9.74537262893864 -10.5927963357972 -11.4402200426703 -12.2876437495288 -13.1350674563873 -13.9824911632604 -14.829914870119 -15.677338576992 -16.5247622838506 -17.3721859907091 -18.2196096975822 -19.0670334044407 -19.9144571112993 -20.7618808181724 -21.6093045250309 -22.456728231904 -23.3041519387625 -24.1515756456211 -24.9989993524941 -0.423711853436544 -1.27113556029508 -2.11855926715361 -2.9659829740267 -3.81340668088524 -4.66083038775832 -5.50825409461686 -6.35567780147539 -7.20310150834848 -8.05052521520702 -8.8979489220801 -9.74537262893864 -10.5927963357972 -11.4402200426703 -12.2876437495288 -13.1350674563873 -13.9824911632604 -14.829914870119 -15.677338576992 -16.5247622838506 -17.3721859907091 -18.2196096975822 -19.0670334044407 -19.9144571112993 -20.7618808181724 -21.6093045250309 -22.456728231904 -23.3041519387625 -24.1515756456211 -24.9989993524941 -0.423711853436544 -1.27113556029508 -2.11855926715361 -2.9659829740267 -3.81340668088524 -4.66083038775832 -5.50825409461686 -6.35567780147539 -7.20310150834848 -8.05052521520702 -8.8979489220801 -9.74537262893864 -10.5927963357972 -11.4402200426703 -12.2876437495288 -13.1350674563873 -13.9824911632604 -14.829914870119 -15.677338576992 -16.5247622838506 -17.3721859907091 -18.2196096975822 -19.0670334044407 -19.9144571112993 -20.7618808181724 -21.6093045250309 -22.456728231904 -23.3041519387625 -24.1515756456211 -24.9989993524941 -0.423711853436544 -1.27113556029508 -2.11855926715361 -2.9659829740267 -3.81340668088524 -4.66083038775832 -5.50825409461686 -6.35567780147539 -7.20310150834848 -8.05052521520702 -8.8979489220801 -9.74537262893864 -10.5927963357972 -11.4402200426703 -12.2876437495288 -13.1350674563873 -13.9824911632604 -14.829914870119 -15.677338576992 -16.5247622838506 -17.3721859907091 -18.2196096975822 -19.0670334044407 -19.9144571112993 -20.7618808181724 -21.6093045250309 -22.456728231904 -23.3041519387625 -24.1515756456211 -24.9989993524941 -0.423711853436544 -1.27113556029508 -2.11855926715361 -2.9659829740267 -3.81340668088524 -4.66083038775832 -5.50825409461686 -6.35567780147539 -7.20310150834848 -8.05052521520702 -8.8979489220801 -9.74537262893864 -10.5927963357972 -11.4402200426703 -12.2876437495288 -13.1350674563873 -13.9824911632604 -14.829914870119 -15.677338576992 -16.5247622838506 -17.3721859907091 -18.2196096975822 -19.0670334044407 -19.9144571112993 -20.7618808181724 -21.6093045250309 -22.456728231904 -23.3041519387625 -24.1515756456211 -24.9989993524941 -) -; - } - hot - { - type fixedFluxPressure; - gradient uniform 0; - value nonuniform List -90 -( -0.403403974181856 -1.21021192256012 -2.01701987092383 -2.8238278193021 -3.63063576766581 -4.43744371604407 -5.24425166440778 -6.05105961278605 -6.85786756114976 -7.66467550952802 -8.47148345789174 -9.27829140627 -10.0850993546337 -10.891907303012 -11.6987152513757 -12.505523199754 -13.3123311481177 -14.1191390964959 -14.9259470448596 -15.7327549932379 -16.5395629416016 -17.3463708899799 -18.1531788383436 -18.9599867867219 -19.7667947350856 -20.5736026834638 -21.3804106318275 -22.1872185802058 -22.9940265285695 -23.8008344769478 -0.403403974181856 -1.21021192256012 -2.01701987092383 -2.8238278193021 -3.63063576766581 -4.43744371604407 -5.24425166440778 -6.05105961278605 -6.85786756114976 -7.66467550952802 -8.47148345789174 -9.27829140627 -10.0850993546337 -10.891907303012 -11.6987152513757 -12.505523199754 -13.3123311481177 -14.1191390964959 -14.9259470448596 -15.7327549932379 -16.5395629416016 -17.3463708899799 -18.1531788383436 -18.9599867867219 -19.7667947350856 -20.5736026834638 -21.3804106318275 -22.1872185802058 -22.9940265285695 -23.8008344769478 -0.403403974181856 -1.21021192256012 -2.01701987092383 -2.8238278193021 -3.63063576766581 -4.43744371604407 -5.24425166440778 -6.05105961278605 -6.85786756114976 -7.66467550952802 -8.47148345789174 -9.27829140627 -10.0850993546337 -10.891907303012 -11.6987152513757 -12.505523199754 -13.3123311481177 -14.1191390964959 -14.9259470448596 -15.7327549932379 -16.5395629416016 -17.3463708899799 -18.1531788383436 -18.9599867867219 -19.7667947350856 -20.5736026834638 -21.3804106318275 -22.1872185802058 -22.9940265285695 -23.8008344769478 -) -; - } - cold - { - type fixedFluxPressure; - gradient uniform 0; - value nonuniform List -90 -( -0.430843564303359 -1.29253069292463 -2.1542178215459 -3.01590495016717 -3.87759207877389 -4.73927920739516 -5.60096633601643 -6.4626534646377 -7.32434059324441 -8.18602772186568 -9.04771485048695 -9.90940197910822 -10.7710891077149 -11.6327762363362 -12.4944633649575 -13.3561504935788 -14.2178376221855 -15.0795247508067 -15.941211879428 -16.8028990080493 -17.664586136656 -18.5262732652773 -19.3879603938985 -20.2496475225198 -21.1113346511265 -21.9730217797478 -22.8347089083691 -23.6963960369903 -24.5580831655971 -25.4197702942183 -0.430843564303359 -1.29253069292463 -2.1542178215459 -3.01590495016717 -3.87759207877389 -4.73927920739516 -5.60096633601643 -6.4626534646377 -7.32434059324441 -8.18602772186568 -9.04771485048695 -9.90940197910822 -10.7710891077149 -11.6327762363362 -12.4944633649575 -13.3561504935788 -14.2178376221855 -15.0795247508067 -15.941211879428 -16.8028990080493 -17.664586136656 -18.5262732652773 -19.3879603938985 -20.2496475225198 -21.1113346511265 -21.9730217797478 -22.8347089083691 -23.6963960369903 -24.5580831655971 -25.4197702942183 -0.430843564303359 -1.29253069292463 -2.1542178215459 -3.01590495016717 -3.87759207877389 -4.73927920739516 -5.60096633601643 -6.4626534646377 -7.32434059324441 -8.18602772186568 -9.04771485048695 -9.90940197910822 -10.7710891077149 -11.6327762363362 -12.4944633649575 -13.3561504935788 -14.2178376221855 -15.0795247508067 -15.941211879428 -16.8028990080493 -17.664586136656 -18.5262732652773 -19.3879603938985 -20.2496475225198 -21.1113346511265 -21.9730217797478 -22.8347089083691 -23.6963960369903 -24.5580831655971 -25.4197702942183 -) -; - } -} - - -// ************************************************************************* // diff --git a/test/tests/input_errors/foam_mesh/constant/pRef b/test/tests/input_errors/foam_mesh/constant/pRef deleted file mode 100644 index fc25cd80..00000000 --- a/test/tests/input_errors/foam_mesh/constant/pRef +++ /dev/null @@ -1,20 +0,0 @@ -/*--------------------------------*- C++ -*----------------------------------*\ - ========= | - \\ / F ield | OpenFOAM: The Open Source CFD Toolbox - \\ / O peration | Website: https://openfoam.org - \\ / A nd | Version: 10 - \\/ M anipulation | -\*---------------------------------------------------------------------------*/ -FoamFile -{ - format ascii; - class uniformDimensionedScalarField; - location "constant"; - object pRef; -} -// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // - -dimensions [1 -1 -2 0 0 0 0]; -value 1e5; - -// ************************************************************************* // diff --git a/test/tests/input_errors/foam_mesh/constant/polyMesh/boundary b/test/tests/input_errors/foam_mesh/constant/polyMesh/boundary deleted file mode 100644 index 5cdd893a..00000000 --- a/test/tests/input_errors/foam_mesh/constant/polyMesh/boundary +++ /dev/null @@ -1,49 +0,0 @@ -/*--------------------------------*- C++ -*----------------------------------*\ - ========= | - \\ / F ield | OpenFOAM: The Open Source CFD Toolbox - \\ / O peration | Website: https://openfoam.org - \\ / A nd | Version: 10 - \\/ M anipulation | -\*---------------------------------------------------------------------------*/ -FoamFile -{ - format ascii; - class polyBoundaryMesh; - location "constant/polyMesh"; - object boundary; -} -// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // - -4 -( - topAndBottom - { - type wall; - inGroups List 1(wall); - nFaces 42; - startFace 1569; - } - frontAndBack - { - type wall; - inGroups List 1(wall); - nFaces 420; - startFace 1611; - } - hot - { - type wall; - inGroups List 1(wall); - nFaces 90; - startFace 2031; - } - cold - { - type wall; - inGroups List 1(wall); - nFaces 90; - startFace 2121; - } -) - -// ************************************************************************* // diff --git a/test/tests/input_errors/foam_mesh/constant/polyMesh/faces b/test/tests/input_errors/foam_mesh/constant/polyMesh/faces deleted file mode 100644 index 8e074076..00000000 --- a/test/tests/input_errors/foam_mesh/constant/polyMesh/faces +++ /dev/null @@ -1,2234 +0,0 @@ -/*--------------------------------*- C++ -*----------------------------------*\ - ========= | - \\ / F ield | OpenFOAM: The Open Source CFD Toolbox - \\ / O peration | Website: https://openfoam.org - \\ / A nd | Version: 10 - \\/ M anipulation | -\*---------------------------------------------------------------------------*/ -FoamFile -{ - format ascii; - class faceList; - location "constant/polyMesh"; - object faces; -} -// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // - - -2211 -( -4(1 9 257 249) -4(8 256 257 9) -4(248 249 257 256) -4(2 10 258 250) -4(9 257 258 10) -4(249 250 258 257) -4(3 11 259 251) -4(10 258 259 11) -4(250 251 259 258) -4(4 12 260 252) -4(11 259 260 12) -4(251 252 260 259) -4(5 13 261 253) -4(12 260 261 13) -4(252 253 261 260) -4(6 14 262 254) -4(13 261 262 14) -4(253 254 262 261) -4(14 262 263 15) -4(254 255 263 262) -4(9 17 265 257) -4(16 264 265 17) -4(256 257 265 264) -4(10 18 266 258) -4(17 265 266 18) -4(257 258 266 265) -4(11 19 267 259) -4(18 266 267 19) -4(258 259 267 266) -4(12 20 268 260) -4(19 267 268 20) -4(259 260 268 267) -4(13 21 269 261) -4(20 268 269 21) -4(260 261 269 268) -4(14 22 270 262) -4(21 269 270 22) -4(261 262 270 269) -4(22 270 271 23) -4(262 263 271 270) -4(17 25 273 265) -4(24 272 273 25) -4(264 265 273 272) -4(18 26 274 266) -4(25 273 274 26) -4(265 266 274 273) -4(19 27 275 267) -4(26 274 275 27) -4(266 267 275 274) -4(20 28 276 268) -4(27 275 276 28) -4(267 268 276 275) -4(21 29 277 269) -4(28 276 277 29) -4(268 269 277 276) -4(22 30 278 270) -4(29 277 278 30) -4(269 270 278 277) -4(30 278 279 31) -4(270 271 279 278) -4(25 33 281 273) -4(32 280 281 33) -4(272 273 281 280) -4(26 34 282 274) -4(33 281 282 34) -4(273 274 282 281) -4(27 35 283 275) -4(34 282 283 35) -4(274 275 283 282) -4(28 36 284 276) -4(35 283 284 36) -4(275 276 284 283) -4(29 37 285 277) -4(36 284 285 37) -4(276 277 285 284) -4(30 38 286 278) -4(37 285 286 38) -4(277 278 286 285) -4(38 286 287 39) -4(278 279 287 286) -4(33 41 289 281) -4(40 288 289 41) -4(280 281 289 288) -4(34 42 290 282) -4(41 289 290 42) -4(281 282 290 289) -4(35 43 291 283) -4(42 290 291 43) -4(282 283 291 290) -4(36 44 292 284) -4(43 291 292 44) -4(283 284 292 291) -4(37 45 293 285) -4(44 292 293 45) -4(284 285 293 292) -4(38 46 294 286) -4(45 293 294 46) -4(285 286 294 293) -4(46 294 295 47) -4(286 287 295 294) -4(41 49 297 289) -4(48 296 297 49) -4(288 289 297 296) -4(42 50 298 290) -4(49 297 298 50) -4(289 290 298 297) -4(43 51 299 291) -4(50 298 299 51) -4(290 291 299 298) -4(44 52 300 292) -4(51 299 300 52) -4(291 292 300 299) -4(45 53 301 293) -4(52 300 301 53) -4(292 293 301 300) -4(46 54 302 294) -4(53 301 302 54) -4(293 294 302 301) -4(54 302 303 55) -4(294 295 303 302) -4(49 57 305 297) -4(56 304 305 57) -4(296 297 305 304) -4(50 58 306 298) -4(57 305 306 58) -4(297 298 306 305) -4(51 59 307 299) -4(58 306 307 59) -4(298 299 307 306) -4(52 60 308 300) -4(59 307 308 60) -4(299 300 308 307) -4(53 61 309 301) -4(60 308 309 61) -4(300 301 309 308) -4(54 62 310 302) -4(61 309 310 62) -4(301 302 310 309) -4(62 310 311 63) -4(302 303 311 310) -4(57 65 313 305) -4(64 312 313 65) -4(304 305 313 312) -4(58 66 314 306) -4(65 313 314 66) -4(305 306 314 313) -4(59 67 315 307) -4(66 314 315 67) -4(306 307 315 314) -4(60 68 316 308) -4(67 315 316 68) -4(307 308 316 315) -4(61 69 317 309) -4(68 316 317 69) -4(308 309 317 316) -4(62 70 318 310) -4(69 317 318 70) -4(309 310 318 317) -4(70 318 319 71) -4(310 311 319 318) -4(65 73 321 313) -4(72 320 321 73) -4(312 313 321 320) -4(66 74 322 314) -4(73 321 322 74) -4(313 314 322 321) -4(67 75 323 315) -4(74 322 323 75) -4(314 315 323 322) -4(68 76 324 316) -4(75 323 324 76) -4(315 316 324 323) -4(69 77 325 317) -4(76 324 325 77) -4(316 317 325 324) -4(70 78 326 318) -4(77 325 326 78) -4(317 318 326 325) -4(78 326 327 79) -4(318 319 327 326) -4(73 81 329 321) -4(80 328 329 81) -4(320 321 329 328) -4(74 82 330 322) -4(81 329 330 82) -4(321 322 330 329) -4(75 83 331 323) -4(82 330 331 83) -4(322 323 331 330) -4(76 84 332 324) -4(83 331 332 84) -4(323 324 332 331) -4(77 85 333 325) -4(84 332 333 85) -4(324 325 333 332) -4(78 86 334 326) -4(85 333 334 86) -4(325 326 334 333) -4(86 334 335 87) -4(326 327 335 334) -4(81 89 337 329) -4(88 336 337 89) -4(328 329 337 336) -4(82 90 338 330) -4(89 337 338 90) -4(329 330 338 337) -4(83 91 339 331) -4(90 338 339 91) -4(330 331 339 338) -4(84 92 340 332) -4(91 339 340 92) -4(331 332 340 339) -4(85 93 341 333) -4(92 340 341 93) -4(332 333 341 340) -4(86 94 342 334) -4(93 341 342 94) -4(333 334 342 341) -4(94 342 343 95) -4(334 335 343 342) -4(89 97 345 337) -4(96 344 345 97) -4(336 337 345 344) -4(90 98 346 338) -4(97 345 346 98) -4(337 338 346 345) -4(91 99 347 339) -4(98 346 347 99) -4(338 339 347 346) -4(92 100 348 340) -4(99 347 348 100) -4(339 340 348 347) -4(93 101 349 341) -4(100 348 349 101) -4(340 341 349 348) -4(94 102 350 342) -4(101 349 350 102) -4(341 342 350 349) -4(102 350 351 103) -4(342 343 351 350) -4(97 105 353 345) -4(104 352 353 105) -4(344 345 353 352) -4(98 106 354 346) -4(105 353 354 106) -4(345 346 354 353) -4(99 107 355 347) -4(106 354 355 107) -4(346 347 355 354) -4(100 108 356 348) -4(107 355 356 108) -4(347 348 356 355) -4(101 109 357 349) -4(108 356 357 109) -4(348 349 357 356) -4(102 110 358 350) -4(109 357 358 110) -4(349 350 358 357) -4(110 358 359 111) -4(350 351 359 358) -4(105 113 361 353) -4(112 360 361 113) -4(352 353 361 360) -4(106 114 362 354) -4(113 361 362 114) -4(353 354 362 361) -4(107 115 363 355) -4(114 362 363 115) -4(354 355 363 362) -4(108 116 364 356) -4(115 363 364 116) -4(355 356 364 363) -4(109 117 365 357) -4(116 364 365 117) -4(356 357 365 364) -4(110 118 366 358) -4(117 365 366 118) -4(357 358 366 365) -4(118 366 367 119) -4(358 359 367 366) -4(113 121 369 361) -4(120 368 369 121) -4(360 361 369 368) -4(114 122 370 362) -4(121 369 370 122) -4(361 362 370 369) -4(115 123 371 363) -4(122 370 371 123) -4(362 363 371 370) -4(116 124 372 364) -4(123 371 372 124) -4(363 364 372 371) -4(117 125 373 365) -4(124 372 373 125) -4(364 365 373 372) -4(118 126 374 366) -4(125 373 374 126) -4(365 366 374 373) -4(126 374 375 127) -4(366 367 375 374) -4(121 129 377 369) -4(128 376 377 129) -4(368 369 377 376) -4(122 130 378 370) -4(129 377 378 130) -4(369 370 378 377) -4(123 131 379 371) -4(130 378 379 131) -4(370 371 379 378) -4(124 132 380 372) -4(131 379 380 132) -4(371 372 380 379) -4(125 133 381 373) -4(132 380 381 133) -4(372 373 381 380) -4(126 134 382 374) -4(133 381 382 134) -4(373 374 382 381) -4(134 382 383 135) -4(374 375 383 382) -4(129 137 385 377) -4(136 384 385 137) -4(376 377 385 384) -4(130 138 386 378) -4(137 385 386 138) -4(377 378 386 385) -4(131 139 387 379) -4(138 386 387 139) -4(378 379 387 386) -4(132 140 388 380) -4(139 387 388 140) -4(379 380 388 387) -4(133 141 389 381) -4(140 388 389 141) -4(380 381 389 388) -4(134 142 390 382) -4(141 389 390 142) -4(381 382 390 389) -4(142 390 391 143) -4(382 383 391 390) -4(137 145 393 385) -4(144 392 393 145) -4(384 385 393 392) -4(138 146 394 386) -4(145 393 394 146) -4(385 386 394 393) -4(139 147 395 387) -4(146 394 395 147) -4(386 387 395 394) -4(140 148 396 388) -4(147 395 396 148) -4(387 388 396 395) -4(141 149 397 389) -4(148 396 397 149) -4(388 389 397 396) -4(142 150 398 390) -4(149 397 398 150) -4(389 390 398 397) -4(150 398 399 151) -4(390 391 399 398) -4(145 153 401 393) -4(152 400 401 153) -4(392 393 401 400) -4(146 154 402 394) -4(153 401 402 154) -4(393 394 402 401) -4(147 155 403 395) -4(154 402 403 155) -4(394 395 403 402) -4(148 156 404 396) -4(155 403 404 156) -4(395 396 404 403) -4(149 157 405 397) -4(156 404 405 157) -4(396 397 405 404) -4(150 158 406 398) -4(157 405 406 158) -4(397 398 406 405) -4(158 406 407 159) -4(398 399 407 406) -4(153 161 409 401) -4(160 408 409 161) -4(400 401 409 408) -4(154 162 410 402) -4(161 409 410 162) -4(401 402 410 409) -4(155 163 411 403) -4(162 410 411 163) -4(402 403 411 410) -4(156 164 412 404) -4(163 411 412 164) -4(403 404 412 411) -4(157 165 413 405) -4(164 412 413 165) -4(404 405 413 412) -4(158 166 414 406) -4(165 413 414 166) -4(405 406 414 413) -4(166 414 415 167) -4(406 407 415 414) -4(161 169 417 409) -4(168 416 417 169) -4(408 409 417 416) -4(162 170 418 410) -4(169 417 418 170) -4(409 410 418 417) -4(163 171 419 411) -4(170 418 419 171) -4(410 411 419 418) -4(164 172 420 412) -4(171 419 420 172) -4(411 412 420 419) -4(165 173 421 413) -4(172 420 421 173) -4(412 413 421 420) -4(166 174 422 414) -4(173 421 422 174) -4(413 414 422 421) -4(174 422 423 175) -4(414 415 423 422) -4(169 177 425 417) -4(176 424 425 177) -4(416 417 425 424) -4(170 178 426 418) -4(177 425 426 178) -4(417 418 426 425) -4(171 179 427 419) -4(178 426 427 179) -4(418 419 427 426) -4(172 180 428 420) -4(179 427 428 180) -4(419 420 428 427) -4(173 181 429 421) -4(180 428 429 181) -4(420 421 429 428) -4(174 182 430 422) -4(181 429 430 182) -4(421 422 430 429) -4(182 430 431 183) -4(422 423 431 430) -4(177 185 433 425) -4(184 432 433 185) -4(424 425 433 432) -4(178 186 434 426) -4(185 433 434 186) -4(425 426 434 433) -4(179 187 435 427) -4(186 434 435 187) -4(426 427 435 434) -4(180 188 436 428) -4(187 435 436 188) -4(427 428 436 435) -4(181 189 437 429) -4(188 436 437 189) -4(428 429 437 436) -4(182 190 438 430) -4(189 437 438 190) -4(429 430 438 437) -4(190 438 439 191) -4(430 431 439 438) -4(185 193 441 433) -4(192 440 441 193) -4(432 433 441 440) -4(186 194 442 434) -4(193 441 442 194) -4(433 434 442 441) -4(187 195 443 435) -4(194 442 443 195) -4(434 435 443 442) -4(188 196 444 436) -4(195 443 444 196) -4(435 436 444 443) -4(189 197 445 437) -4(196 444 445 197) -4(436 437 445 444) -4(190 198 446 438) -4(197 445 446 198) -4(437 438 446 445) -4(198 446 447 199) -4(438 439 447 446) -4(193 201 449 441) -4(200 448 449 201) -4(440 441 449 448) -4(194 202 450 442) -4(201 449 450 202) -4(441 442 450 449) -4(195 203 451 443) -4(202 450 451 203) -4(442 443 451 450) -4(196 204 452 444) -4(203 451 452 204) -4(443 444 452 451) -4(197 205 453 445) -4(204 452 453 205) -4(444 445 453 452) -4(198 206 454 446) -4(205 453 454 206) -4(445 446 454 453) -4(206 454 455 207) -4(446 447 455 454) -4(201 209 457 449) -4(208 456 457 209) -4(448 449 457 456) -4(202 210 458 450) -4(209 457 458 210) -4(449 450 458 457) -4(203 211 459 451) -4(210 458 459 211) -4(450 451 459 458) -4(204 212 460 452) -4(211 459 460 212) -4(451 452 460 459) -4(205 213 461 453) -4(212 460 461 213) -4(452 453 461 460) -4(206 214 462 454) -4(213 461 462 214) -4(453 454 462 461) -4(214 462 463 215) -4(454 455 463 462) -4(209 217 465 457) -4(216 464 465 217) -4(456 457 465 464) -4(210 218 466 458) -4(217 465 466 218) -4(457 458 466 465) -4(211 219 467 459) -4(218 466 467 219) -4(458 459 467 466) -4(212 220 468 460) -4(219 467 468 220) -4(459 460 468 467) -4(213 221 469 461) -4(220 468 469 221) -4(460 461 469 468) -4(214 222 470 462) -4(221 469 470 222) -4(461 462 470 469) -4(222 470 471 223) -4(462 463 471 470) -4(217 225 473 465) -4(224 472 473 225) -4(464 465 473 472) -4(218 226 474 466) -4(225 473 474 226) -4(465 466 474 473) -4(219 227 475 467) -4(226 474 475 227) -4(466 467 475 474) -4(220 228 476 468) -4(227 475 476 228) -4(467 468 476 475) -4(221 229 477 469) -4(228 476 477 229) -4(468 469 477 476) -4(222 230 478 470) -4(229 477 478 230) -4(469 470 478 477) -4(230 478 479 231) -4(470 471 479 478) -4(225 233 481 473) -4(232 480 481 233) -4(472 473 481 480) -4(226 234 482 474) -4(233 481 482 234) -4(473 474 482 481) -4(227 235 483 475) -4(234 482 483 235) -4(474 475 483 482) -4(228 236 484 476) -4(235 483 484 236) -4(475 476 484 483) -4(229 237 485 477) -4(236 484 485 237) -4(476 477 485 484) -4(230 238 486 478) -4(237 485 486 238) -4(477 478 486 485) -4(238 486 487 239) -4(478 479 487 486) -4(233 241 489 481) -4(480 481 489 488) -4(234 242 490 482) -4(481 482 490 489) -4(235 243 491 483) -4(482 483 491 490) -4(236 244 492 484) -4(483 484 492 491) -4(237 245 493 485) -4(484 485 493 492) -4(238 246 494 486) -4(485 486 494 493) -4(486 487 495 494) -4(249 257 505 497) -4(256 504 505 257) -4(496 497 505 504) -4(250 258 506 498) -4(257 505 506 258) -4(497 498 506 505) -4(251 259 507 499) -4(258 506 507 259) -4(498 499 507 506) -4(252 260 508 500) -4(259 507 508 260) -4(499 500 508 507) -4(253 261 509 501) -4(260 508 509 261) -4(500 501 509 508) -4(254 262 510 502) -4(261 509 510 262) -4(501 502 510 509) -4(262 510 511 263) -4(502 503 511 510) -4(257 265 513 505) -4(264 512 513 265) -4(504 505 513 512) -4(258 266 514 506) -4(265 513 514 266) -4(505 506 514 513) -4(259 267 515 507) -4(266 514 515 267) -4(506 507 515 514) -4(260 268 516 508) -4(267 515 516 268) -4(507 508 516 515) -4(261 269 517 509) -4(268 516 517 269) -4(508 509 517 516) -4(262 270 518 510) -4(269 517 518 270) -4(509 510 518 517) -4(270 518 519 271) -4(510 511 519 518) -4(265 273 521 513) -4(272 520 521 273) -4(512 513 521 520) -4(266 274 522 514) -4(273 521 522 274) -4(513 514 522 521) -4(267 275 523 515) -4(274 522 523 275) -4(514 515 523 522) -4(268 276 524 516) -4(275 523 524 276) -4(515 516 524 523) -4(269 277 525 517) -4(276 524 525 277) -4(516 517 525 524) -4(270 278 526 518) -4(277 525 526 278) -4(517 518 526 525) -4(278 526 527 279) -4(518 519 527 526) -4(273 281 529 521) -4(280 528 529 281) -4(520 521 529 528) -4(274 282 530 522) -4(281 529 530 282) -4(521 522 530 529) -4(275 283 531 523) -4(282 530 531 283) -4(522 523 531 530) -4(276 284 532 524) -4(283 531 532 284) -4(523 524 532 531) -4(277 285 533 525) -4(284 532 533 285) -4(524 525 533 532) -4(278 286 534 526) -4(285 533 534 286) -4(525 526 534 533) -4(286 534 535 287) -4(526 527 535 534) -4(281 289 537 529) -4(288 536 537 289) -4(528 529 537 536) -4(282 290 538 530) -4(289 537 538 290) -4(529 530 538 537) -4(283 291 539 531) -4(290 538 539 291) -4(530 531 539 538) -4(284 292 540 532) -4(291 539 540 292) -4(531 532 540 539) -4(285 293 541 533) -4(292 540 541 293) -4(532 533 541 540) -4(286 294 542 534) -4(293 541 542 294) -4(533 534 542 541) -4(294 542 543 295) -4(534 535 543 542) -4(289 297 545 537) -4(296 544 545 297) -4(536 537 545 544) -4(290 298 546 538) -4(297 545 546 298) -4(537 538 546 545) -4(291 299 547 539) -4(298 546 547 299) -4(538 539 547 546) -4(292 300 548 540) -4(299 547 548 300) -4(539 540 548 547) -4(293 301 549 541) -4(300 548 549 301) -4(540 541 549 548) -4(294 302 550 542) -4(301 549 550 302) -4(541 542 550 549) -4(302 550 551 303) -4(542 543 551 550) -4(297 305 553 545) -4(304 552 553 305) -4(544 545 553 552) -4(298 306 554 546) -4(305 553 554 306) -4(545 546 554 553) -4(299 307 555 547) -4(306 554 555 307) -4(546 547 555 554) -4(300 308 556 548) -4(307 555 556 308) -4(547 548 556 555) -4(301 309 557 549) -4(308 556 557 309) -4(548 549 557 556) -4(302 310 558 550) -4(309 557 558 310) -4(549 550 558 557) -4(310 558 559 311) -4(550 551 559 558) -4(305 313 561 553) -4(312 560 561 313) -4(552 553 561 560) -4(306 314 562 554) -4(313 561 562 314) -4(553 554 562 561) -4(307 315 563 555) -4(314 562 563 315) -4(554 555 563 562) -4(308 316 564 556) -4(315 563 564 316) -4(555 556 564 563) -4(309 317 565 557) -4(316 564 565 317) -4(556 557 565 564) -4(310 318 566 558) -4(317 565 566 318) -4(557 558 566 565) -4(318 566 567 319) -4(558 559 567 566) -4(313 321 569 561) -4(320 568 569 321) -4(560 561 569 568) -4(314 322 570 562) -4(321 569 570 322) -4(561 562 570 569) -4(315 323 571 563) -4(322 570 571 323) -4(562 563 571 570) -4(316 324 572 564) -4(323 571 572 324) -4(563 564 572 571) -4(317 325 573 565) -4(324 572 573 325) -4(564 565 573 572) -4(318 326 574 566) -4(325 573 574 326) -4(565 566 574 573) -4(326 574 575 327) -4(566 567 575 574) -4(321 329 577 569) -4(328 576 577 329) -4(568 569 577 576) -4(322 330 578 570) -4(329 577 578 330) -4(569 570 578 577) -4(323 331 579 571) -4(330 578 579 331) -4(570 571 579 578) -4(324 332 580 572) -4(331 579 580 332) -4(571 572 580 579) -4(325 333 581 573) -4(332 580 581 333) -4(572 573 581 580) -4(326 334 582 574) -4(333 581 582 334) -4(573 574 582 581) -4(334 582 583 335) -4(574 575 583 582) -4(329 337 585 577) -4(336 584 585 337) -4(576 577 585 584) -4(330 338 586 578) -4(337 585 586 338) -4(577 578 586 585) -4(331 339 587 579) -4(338 586 587 339) -4(578 579 587 586) -4(332 340 588 580) -4(339 587 588 340) -4(579 580 588 587) -4(333 341 589 581) -4(340 588 589 341) -4(580 581 589 588) -4(334 342 590 582) -4(341 589 590 342) -4(581 582 590 589) -4(342 590 591 343) -4(582 583 591 590) -4(337 345 593 585) -4(344 592 593 345) -4(584 585 593 592) -4(338 346 594 586) -4(345 593 594 346) -4(585 586 594 593) -4(339 347 595 587) -4(346 594 595 347) -4(586 587 595 594) -4(340 348 596 588) -4(347 595 596 348) -4(587 588 596 595) -4(341 349 597 589) -4(348 596 597 349) -4(588 589 597 596) -4(342 350 598 590) -4(349 597 598 350) -4(589 590 598 597) -4(350 598 599 351) -4(590 591 599 598) -4(345 353 601 593) -4(352 600 601 353) -4(592 593 601 600) -4(346 354 602 594) -4(353 601 602 354) -4(593 594 602 601) -4(347 355 603 595) -4(354 602 603 355) -4(594 595 603 602) -4(348 356 604 596) -4(355 603 604 356) -4(595 596 604 603) -4(349 357 605 597) -4(356 604 605 357) -4(596 597 605 604) -4(350 358 606 598) -4(357 605 606 358) -4(597 598 606 605) -4(358 606 607 359) -4(598 599 607 606) -4(353 361 609 601) -4(360 608 609 361) -4(600 601 609 608) -4(354 362 610 602) -4(361 609 610 362) -4(601 602 610 609) -4(355 363 611 603) -4(362 610 611 363) -4(602 603 611 610) -4(356 364 612 604) -4(363 611 612 364) -4(603 604 612 611) -4(357 365 613 605) -4(364 612 613 365) -4(604 605 613 612) -4(358 366 614 606) -4(365 613 614 366) -4(605 606 614 613) -4(366 614 615 367) -4(606 607 615 614) -4(361 369 617 609) -4(368 616 617 369) -4(608 609 617 616) -4(362 370 618 610) -4(369 617 618 370) -4(609 610 618 617) -4(363 371 619 611) -4(370 618 619 371) -4(610 611 619 618) -4(364 372 620 612) -4(371 619 620 372) -4(611 612 620 619) -4(365 373 621 613) -4(372 620 621 373) -4(612 613 621 620) -4(366 374 622 614) -4(373 621 622 374) -4(613 614 622 621) -4(374 622 623 375) -4(614 615 623 622) -4(369 377 625 617) -4(376 624 625 377) -4(616 617 625 624) -4(370 378 626 618) -4(377 625 626 378) -4(617 618 626 625) -4(371 379 627 619) -4(378 626 627 379) -4(618 619 627 626) -4(372 380 628 620) -4(379 627 628 380) -4(619 620 628 627) -4(373 381 629 621) -4(380 628 629 381) -4(620 621 629 628) -4(374 382 630 622) -4(381 629 630 382) -4(621 622 630 629) -4(382 630 631 383) -4(622 623 631 630) -4(377 385 633 625) -4(384 632 633 385) -4(624 625 633 632) -4(378 386 634 626) -4(385 633 634 386) -4(625 626 634 633) -4(379 387 635 627) -4(386 634 635 387) -4(626 627 635 634) -4(380 388 636 628) -4(387 635 636 388) -4(627 628 636 635) -4(381 389 637 629) -4(388 636 637 389) -4(628 629 637 636) -4(382 390 638 630) -4(389 637 638 390) -4(629 630 638 637) -4(390 638 639 391) -4(630 631 639 638) -4(385 393 641 633) -4(392 640 641 393) -4(632 633 641 640) -4(386 394 642 634) -4(393 641 642 394) -4(633 634 642 641) -4(387 395 643 635) -4(394 642 643 395) -4(634 635 643 642) -4(388 396 644 636) -4(395 643 644 396) -4(635 636 644 643) -4(389 397 645 637) -4(396 644 645 397) -4(636 637 645 644) -4(390 398 646 638) -4(397 645 646 398) -4(637 638 646 645) -4(398 646 647 399) -4(638 639 647 646) -4(393 401 649 641) -4(400 648 649 401) -4(640 641 649 648) -4(394 402 650 642) -4(401 649 650 402) -4(641 642 650 649) -4(395 403 651 643) -4(402 650 651 403) -4(642 643 651 650) -4(396 404 652 644) -4(403 651 652 404) -4(643 644 652 651) -4(397 405 653 645) -4(404 652 653 405) -4(644 645 653 652) -4(398 406 654 646) -4(405 653 654 406) -4(645 646 654 653) -4(406 654 655 407) -4(646 647 655 654) -4(401 409 657 649) -4(408 656 657 409) -4(648 649 657 656) -4(402 410 658 650) -4(409 657 658 410) -4(649 650 658 657) -4(403 411 659 651) -4(410 658 659 411) -4(650 651 659 658) -4(404 412 660 652) -4(411 659 660 412) -4(651 652 660 659) -4(405 413 661 653) -4(412 660 661 413) -4(652 653 661 660) -4(406 414 662 654) -4(413 661 662 414) -4(653 654 662 661) -4(414 662 663 415) -4(654 655 663 662) -4(409 417 665 657) -4(416 664 665 417) -4(656 657 665 664) -4(410 418 666 658) -4(417 665 666 418) -4(657 658 666 665) -4(411 419 667 659) -4(418 666 667 419) -4(658 659 667 666) -4(412 420 668 660) -4(419 667 668 420) -4(659 660 668 667) -4(413 421 669 661) -4(420 668 669 421) -4(660 661 669 668) -4(414 422 670 662) -4(421 669 670 422) -4(661 662 670 669) -4(422 670 671 423) -4(662 663 671 670) -4(417 425 673 665) -4(424 672 673 425) -4(664 665 673 672) -4(418 426 674 666) -4(425 673 674 426) -4(665 666 674 673) -4(419 427 675 667) -4(426 674 675 427) -4(666 667 675 674) -4(420 428 676 668) -4(427 675 676 428) -4(667 668 676 675) -4(421 429 677 669) -4(428 676 677 429) -4(668 669 677 676) -4(422 430 678 670) -4(429 677 678 430) -4(669 670 678 677) -4(430 678 679 431) -4(670 671 679 678) -4(425 433 681 673) -4(432 680 681 433) -4(672 673 681 680) -4(426 434 682 674) -4(433 681 682 434) -4(673 674 682 681) -4(427 435 683 675) -4(434 682 683 435) -4(674 675 683 682) -4(428 436 684 676) -4(435 683 684 436) -4(675 676 684 683) -4(429 437 685 677) -4(436 684 685 437) -4(676 677 685 684) -4(430 438 686 678) -4(437 685 686 438) -4(677 678 686 685) -4(438 686 687 439) -4(678 679 687 686) -4(433 441 689 681) -4(440 688 689 441) -4(680 681 689 688) -4(434 442 690 682) -4(441 689 690 442) -4(681 682 690 689) -4(435 443 691 683) -4(442 690 691 443) -4(682 683 691 690) -4(436 444 692 684) -4(443 691 692 444) -4(683 684 692 691) -4(437 445 693 685) -4(444 692 693 445) -4(684 685 693 692) -4(438 446 694 686) -4(445 693 694 446) -4(685 686 694 693) -4(446 694 695 447) -4(686 687 695 694) -4(441 449 697 689) -4(448 696 697 449) -4(688 689 697 696) -4(442 450 698 690) -4(449 697 698 450) -4(689 690 698 697) -4(443 451 699 691) -4(450 698 699 451) -4(690 691 699 698) -4(444 452 700 692) -4(451 699 700 452) -4(691 692 700 699) -4(445 453 701 693) -4(452 700 701 453) -4(692 693 701 700) -4(446 454 702 694) -4(453 701 702 454) -4(693 694 702 701) -4(454 702 703 455) -4(694 695 703 702) -4(449 457 705 697) -4(456 704 705 457) -4(696 697 705 704) -4(450 458 706 698) -4(457 705 706 458) -4(697 698 706 705) -4(451 459 707 699) -4(458 706 707 459) -4(698 699 707 706) -4(452 460 708 700) -4(459 707 708 460) -4(699 700 708 707) -4(453 461 709 701) -4(460 708 709 461) -4(700 701 709 708) -4(454 462 710 702) -4(461 709 710 462) -4(701 702 710 709) -4(462 710 711 463) -4(702 703 711 710) -4(457 465 713 705) -4(464 712 713 465) -4(704 705 713 712) -4(458 466 714 706) -4(465 713 714 466) -4(705 706 714 713) -4(459 467 715 707) -4(466 714 715 467) -4(706 707 715 714) -4(460 468 716 708) -4(467 715 716 468) -4(707 708 716 715) -4(461 469 717 709) -4(468 716 717 469) -4(708 709 717 716) -4(462 470 718 710) -4(469 717 718 470) -4(709 710 718 717) -4(470 718 719 471) -4(710 711 719 718) -4(465 473 721 713) -4(472 720 721 473) -4(712 713 721 720) -4(466 474 722 714) -4(473 721 722 474) -4(713 714 722 721) -4(467 475 723 715) -4(474 722 723 475) -4(714 715 723 722) -4(468 476 724 716) -4(475 723 724 476) -4(715 716 724 723) -4(469 477 725 717) -4(476 724 725 477) -4(716 717 725 724) -4(470 478 726 718) -4(477 725 726 478) -4(717 718 726 725) -4(478 726 727 479) -4(718 719 727 726) -4(473 481 729 721) -4(480 728 729 481) -4(720 721 729 728) -4(474 482 730 722) -4(481 729 730 482) -4(721 722 730 729) -4(475 483 731 723) -4(482 730 731 483) -4(722 723 731 730) -4(476 484 732 724) -4(483 731 732 484) -4(723 724 732 731) -4(477 485 733 725) -4(484 732 733 485) -4(724 725 733 732) -4(478 486 734 726) -4(485 733 734 486) -4(725 726 734 733) -4(486 734 735 487) -4(726 727 735 734) -4(481 489 737 729) -4(728 729 737 736) -4(482 490 738 730) -4(729 730 738 737) -4(483 491 739 731) -4(730 731 739 738) -4(484 492 740 732) -4(731 732 740 739) -4(485 493 741 733) -4(732 733 741 740) -4(486 494 742 734) -4(733 734 742 741) -4(734 735 743 742) -4(497 505 753 745) -4(504 752 753 505) -4(498 506 754 746) -4(505 753 754 506) -4(499 507 755 747) -4(506 754 755 507) -4(500 508 756 748) -4(507 755 756 508) -4(501 509 757 749) -4(508 756 757 509) -4(502 510 758 750) -4(509 757 758 510) -4(510 758 759 511) -4(505 513 761 753) -4(512 760 761 513) -4(506 514 762 754) -4(513 761 762 514) -4(507 515 763 755) -4(514 762 763 515) -4(508 516 764 756) -4(515 763 764 516) -4(509 517 765 757) -4(516 764 765 517) -4(510 518 766 758) -4(517 765 766 518) -4(518 766 767 519) -4(513 521 769 761) -4(520 768 769 521) -4(514 522 770 762) -4(521 769 770 522) -4(515 523 771 763) -4(522 770 771 523) -4(516 524 772 764) -4(523 771 772 524) -4(517 525 773 765) -4(524 772 773 525) -4(518 526 774 766) -4(525 773 774 526) -4(526 774 775 527) -4(521 529 777 769) -4(528 776 777 529) -4(522 530 778 770) -4(529 777 778 530) -4(523 531 779 771) -4(530 778 779 531) -4(524 532 780 772) -4(531 779 780 532) -4(525 533 781 773) -4(532 780 781 533) -4(526 534 782 774) -4(533 781 782 534) -4(534 782 783 535) -4(529 537 785 777) -4(536 784 785 537) -4(530 538 786 778) -4(537 785 786 538) -4(531 539 787 779) -4(538 786 787 539) -4(532 540 788 780) -4(539 787 788 540) -4(533 541 789 781) -4(540 788 789 541) -4(534 542 790 782) -4(541 789 790 542) -4(542 790 791 543) -4(537 545 793 785) -4(544 792 793 545) -4(538 546 794 786) -4(545 793 794 546) -4(539 547 795 787) -4(546 794 795 547) -4(540 548 796 788) -4(547 795 796 548) -4(541 549 797 789) -4(548 796 797 549) -4(542 550 798 790) -4(549 797 798 550) -4(550 798 799 551) -4(545 553 801 793) -4(552 800 801 553) -4(546 554 802 794) -4(553 801 802 554) -4(547 555 803 795) -4(554 802 803 555) -4(548 556 804 796) -4(555 803 804 556) -4(549 557 805 797) -4(556 804 805 557) -4(550 558 806 798) -4(557 805 806 558) -4(558 806 807 559) -4(553 561 809 801) -4(560 808 809 561) -4(554 562 810 802) -4(561 809 810 562) -4(555 563 811 803) -4(562 810 811 563) -4(556 564 812 804) -4(563 811 812 564) -4(557 565 813 805) -4(564 812 813 565) -4(558 566 814 806) -4(565 813 814 566) -4(566 814 815 567) -4(561 569 817 809) -4(568 816 817 569) -4(562 570 818 810) -4(569 817 818 570) -4(563 571 819 811) -4(570 818 819 571) -4(564 572 820 812) -4(571 819 820 572) -4(565 573 821 813) -4(572 820 821 573) -4(566 574 822 814) -4(573 821 822 574) -4(574 822 823 575) -4(569 577 825 817) -4(576 824 825 577) -4(570 578 826 818) -4(577 825 826 578) -4(571 579 827 819) -4(578 826 827 579) -4(572 580 828 820) -4(579 827 828 580) -4(573 581 829 821) -4(580 828 829 581) -4(574 582 830 822) -4(581 829 830 582) -4(582 830 831 583) -4(577 585 833 825) -4(584 832 833 585) -4(578 586 834 826) -4(585 833 834 586) -4(579 587 835 827) -4(586 834 835 587) -4(580 588 836 828) -4(587 835 836 588) -4(581 589 837 829) -4(588 836 837 589) -4(582 590 838 830) -4(589 837 838 590) -4(590 838 839 591) -4(585 593 841 833) -4(592 840 841 593) -4(586 594 842 834) -4(593 841 842 594) -4(587 595 843 835) -4(594 842 843 595) -4(588 596 844 836) -4(595 843 844 596) -4(589 597 845 837) -4(596 844 845 597) -4(590 598 846 838) -4(597 845 846 598) -4(598 846 847 599) -4(593 601 849 841) -4(600 848 849 601) -4(594 602 850 842) -4(601 849 850 602) -4(595 603 851 843) -4(602 850 851 603) -4(596 604 852 844) -4(603 851 852 604) -4(597 605 853 845) -4(604 852 853 605) -4(598 606 854 846) -4(605 853 854 606) -4(606 854 855 607) -4(601 609 857 849) -4(608 856 857 609) -4(602 610 858 850) -4(609 857 858 610) -4(603 611 859 851) -4(610 858 859 611) -4(604 612 860 852) -4(611 859 860 612) -4(605 613 861 853) -4(612 860 861 613) -4(606 614 862 854) -4(613 861 862 614) -4(614 862 863 615) -4(609 617 865 857) -4(616 864 865 617) -4(610 618 866 858) -4(617 865 866 618) -4(611 619 867 859) -4(618 866 867 619) -4(612 620 868 860) -4(619 867 868 620) -4(613 621 869 861) -4(620 868 869 621) -4(614 622 870 862) -4(621 869 870 622) -4(622 870 871 623) -4(617 625 873 865) -4(624 872 873 625) -4(618 626 874 866) -4(625 873 874 626) -4(619 627 875 867) -4(626 874 875 627) -4(620 628 876 868) -4(627 875 876 628) -4(621 629 877 869) -4(628 876 877 629) -4(622 630 878 870) -4(629 877 878 630) -4(630 878 879 631) -4(625 633 881 873) -4(632 880 881 633) -4(626 634 882 874) -4(633 881 882 634) -4(627 635 883 875) -4(634 882 883 635) -4(628 636 884 876) -4(635 883 884 636) -4(629 637 885 877) -4(636 884 885 637) -4(630 638 886 878) -4(637 885 886 638) -4(638 886 887 639) -4(633 641 889 881) -4(640 888 889 641) -4(634 642 890 882) -4(641 889 890 642) -4(635 643 891 883) -4(642 890 891 643) -4(636 644 892 884) -4(643 891 892 644) -4(637 645 893 885) -4(644 892 893 645) -4(638 646 894 886) -4(645 893 894 646) -4(646 894 895 647) -4(641 649 897 889) -4(648 896 897 649) -4(642 650 898 890) -4(649 897 898 650) -4(643 651 899 891) -4(650 898 899 651) -4(644 652 900 892) -4(651 899 900 652) -4(645 653 901 893) -4(652 900 901 653) -4(646 654 902 894) -4(653 901 902 654) -4(654 902 903 655) -4(649 657 905 897) -4(656 904 905 657) -4(650 658 906 898) -4(657 905 906 658) -4(651 659 907 899) -4(658 906 907 659) -4(652 660 908 900) -4(659 907 908 660) -4(653 661 909 901) -4(660 908 909 661) -4(654 662 910 902) -4(661 909 910 662) -4(662 910 911 663) -4(657 665 913 905) -4(664 912 913 665) -4(658 666 914 906) -4(665 913 914 666) -4(659 667 915 907) -4(666 914 915 667) -4(660 668 916 908) -4(667 915 916 668) -4(661 669 917 909) -4(668 916 917 669) -4(662 670 918 910) -4(669 917 918 670) -4(670 918 919 671) -4(665 673 921 913) -4(672 920 921 673) -4(666 674 922 914) -4(673 921 922 674) -4(667 675 923 915) -4(674 922 923 675) -4(668 676 924 916) -4(675 923 924 676) -4(669 677 925 917) -4(676 924 925 677) -4(670 678 926 918) -4(677 925 926 678) -4(678 926 927 679) -4(673 681 929 921) -4(680 928 929 681) -4(674 682 930 922) -4(681 929 930 682) -4(675 683 931 923) -4(682 930 931 683) -4(676 684 932 924) -4(683 931 932 684) -4(677 685 933 925) -4(684 932 933 685) -4(678 686 934 926) -4(685 933 934 686) -4(686 934 935 687) -4(681 689 937 929) -4(688 936 937 689) -4(682 690 938 930) -4(689 937 938 690) -4(683 691 939 931) -4(690 938 939 691) -4(684 692 940 932) -4(691 939 940 692) -4(685 693 941 933) -4(692 940 941 693) -4(686 694 942 934) -4(693 941 942 694) -4(694 942 943 695) -4(689 697 945 937) -4(696 944 945 697) -4(690 698 946 938) -4(697 945 946 698) -4(691 699 947 939) -4(698 946 947 699) -4(692 700 948 940) -4(699 947 948 700) -4(693 701 949 941) -4(700 948 949 701) -4(694 702 950 942) -4(701 949 950 702) -4(702 950 951 703) -4(697 705 953 945) -4(704 952 953 705) -4(698 706 954 946) -4(705 953 954 706) -4(699 707 955 947) -4(706 954 955 707) -4(700 708 956 948) -4(707 955 956 708) -4(701 709 957 949) -4(708 956 957 709) -4(702 710 958 950) -4(709 957 958 710) -4(710 958 959 711) -4(705 713 961 953) -4(712 960 961 713) -4(706 714 962 954) -4(713 961 962 714) -4(707 715 963 955) -4(714 962 963 715) -4(708 716 964 956) -4(715 963 964 716) -4(709 717 965 957) -4(716 964 965 717) -4(710 718 966 958) -4(717 965 966 718) -4(718 966 967 719) -4(713 721 969 961) -4(720 968 969 721) -4(714 722 970 962) -4(721 969 970 722) -4(715 723 971 963) -4(722 970 971 723) -4(716 724 972 964) -4(723 971 972 724) -4(717 725 973 965) -4(724 972 973 725) -4(718 726 974 966) -4(725 973 974 726) -4(726 974 975 727) -4(721 729 977 969) -4(728 976 977 729) -4(722 730 978 970) -4(729 977 978 730) -4(723 731 979 971) -4(730 978 979 731) -4(724 732 980 972) -4(731 979 980 732) -4(725 733 981 973) -4(732 980 981 733) -4(726 734 982 974) -4(733 981 982 734) -4(734 982 983 735) -4(729 737 985 977) -4(730 738 986 978) -4(731 739 987 979) -4(732 740 988 980) -4(733 741 989 981) -4(734 742 990 982) -4(0 1 249 248) -4(248 249 497 496) -4(496 497 745 744) -4(1 2 250 249) -4(249 250 498 497) -4(497 498 746 745) -4(2 3 251 250) -4(250 251 499 498) -4(498 499 747 746) -4(3 4 252 251) -4(251 252 500 499) -4(499 500 748 747) -4(4 5 253 252) -4(252 253 501 500) -4(500 501 749 748) -4(5 6 254 253) -4(253 254 502 501) -4(501 502 750 749) -4(6 7 255 254) -4(254 255 503 502) -4(502 503 751 750) -4(240 488 489 241) -4(488 736 737 489) -4(736 984 985 737) -4(241 489 490 242) -4(489 737 738 490) -4(737 985 986 738) -4(242 490 491 243) -4(490 738 739 491) -4(738 986 987 739) -4(243 491 492 244) -4(491 739 740 492) -4(739 987 988 740) -4(244 492 493 245) -4(492 740 741 493) -4(740 988 989 741) -4(245 493 494 246) -4(493 741 742 494) -4(741 989 990 742) -4(246 494 495 247) -4(494 742 743 495) -4(742 990 991 743) -4(744 745 753 752) -4(752 753 761 760) -4(760 761 769 768) -4(768 769 777 776) -4(776 777 785 784) -4(784 785 793 792) -4(792 793 801 800) -4(800 801 809 808) -4(808 809 817 816) -4(816 817 825 824) -4(824 825 833 832) -4(832 833 841 840) -4(840 841 849 848) -4(848 849 857 856) -4(856 857 865 864) -4(864 865 873 872) -4(872 873 881 880) -4(880 881 889 888) -4(888 889 897 896) -4(896 897 905 904) -4(904 905 913 912) -4(912 913 921 920) -4(920 921 929 928) -4(928 929 937 936) -4(936 937 945 944) -4(944 945 953 952) -4(952 953 961 960) -4(960 961 969 968) -4(968 969 977 976) -4(976 977 985 984) -4(745 746 754 753) -4(753 754 762 761) -4(761 762 770 769) -4(769 770 778 777) -4(777 778 786 785) -4(785 786 794 793) -4(793 794 802 801) -4(801 802 810 809) -4(809 810 818 817) -4(817 818 826 825) -4(825 826 834 833) -4(833 834 842 841) -4(841 842 850 849) -4(849 850 858 857) -4(857 858 866 865) -4(865 866 874 873) -4(873 874 882 881) -4(881 882 890 889) -4(889 890 898 897) -4(897 898 906 905) -4(905 906 914 913) -4(913 914 922 921) -4(921 922 930 929) -4(929 930 938 937) -4(937 938 946 945) -4(945 946 954 953) -4(953 954 962 961) -4(961 962 970 969) -4(969 970 978 977) -4(977 978 986 985) -4(746 747 755 754) -4(754 755 763 762) -4(762 763 771 770) -4(770 771 779 778) -4(778 779 787 786) -4(786 787 795 794) -4(794 795 803 802) -4(802 803 811 810) -4(810 811 819 818) -4(818 819 827 826) -4(826 827 835 834) -4(834 835 843 842) -4(842 843 851 850) -4(850 851 859 858) -4(858 859 867 866) -4(866 867 875 874) -4(874 875 883 882) -4(882 883 891 890) -4(890 891 899 898) -4(898 899 907 906) -4(906 907 915 914) -4(914 915 923 922) -4(922 923 931 930) -4(930 931 939 938) -4(938 939 947 946) -4(946 947 955 954) -4(954 955 963 962) -4(962 963 971 970) -4(970 971 979 978) -4(978 979 987 986) -4(747 748 756 755) -4(755 756 764 763) -4(763 764 772 771) -4(771 772 780 779) -4(779 780 788 787) -4(787 788 796 795) -4(795 796 804 803) -4(803 804 812 811) -4(811 812 820 819) -4(819 820 828 827) -4(827 828 836 835) -4(835 836 844 843) -4(843 844 852 851) -4(851 852 860 859) -4(859 860 868 867) -4(867 868 876 875) -4(875 876 884 883) -4(883 884 892 891) -4(891 892 900 899) -4(899 900 908 907) -4(907 908 916 915) -4(915 916 924 923) -4(923 924 932 931) -4(931 932 940 939) -4(939 940 948 947) -4(947 948 956 955) -4(955 956 964 963) -4(963 964 972 971) -4(971 972 980 979) -4(979 980 988 987) -4(748 749 757 756) -4(756 757 765 764) -4(764 765 773 772) -4(772 773 781 780) -4(780 781 789 788) -4(788 789 797 796) -4(796 797 805 804) -4(804 805 813 812) -4(812 813 821 820) -4(820 821 829 828) -4(828 829 837 836) -4(836 837 845 844) -4(844 845 853 852) -4(852 853 861 860) -4(860 861 869 868) -4(868 869 877 876) -4(876 877 885 884) -4(884 885 893 892) -4(892 893 901 900) -4(900 901 909 908) -4(908 909 917 916) -4(916 917 925 924) -4(924 925 933 932) -4(932 933 941 940) -4(940 941 949 948) -4(948 949 957 956) -4(956 957 965 964) -4(964 965 973 972) -4(972 973 981 980) -4(980 981 989 988) -4(749 750 758 757) -4(757 758 766 765) -4(765 766 774 773) -4(773 774 782 781) -4(781 782 790 789) -4(789 790 798 797) -4(797 798 806 805) -4(805 806 814 813) -4(813 814 822 821) -4(821 822 830 829) -4(829 830 838 837) -4(837 838 846 845) -4(845 846 854 853) -4(853 854 862 861) -4(861 862 870 869) -4(869 870 878 877) -4(877 878 886 885) -4(885 886 894 893) -4(893 894 902 901) -4(901 902 910 909) -4(909 910 918 917) -4(917 918 926 925) -4(925 926 934 933) -4(933 934 942 941) -4(941 942 950 949) -4(949 950 958 957) -4(957 958 966 965) -4(965 966 974 973) -4(973 974 982 981) -4(981 982 990 989) -4(750 751 759 758) -4(758 759 767 766) -4(766 767 775 774) -4(774 775 783 782) -4(782 783 791 790) -4(790 791 799 798) -4(798 799 807 806) -4(806 807 815 814) -4(814 815 823 822) -4(822 823 831 830) -4(830 831 839 838) -4(838 839 847 846) -4(846 847 855 854) -4(854 855 863 862) -4(862 863 871 870) -4(870 871 879 878) -4(878 879 887 886) -4(886 887 895 894) -4(894 895 903 902) -4(902 903 911 910) -4(910 911 919 918) -4(918 919 927 926) -4(926 927 935 934) -4(934 935 943 942) -4(942 943 951 950) -4(950 951 959 958) -4(958 959 967 966) -4(966 967 975 974) -4(974 975 983 982) -4(982 983 991 990) -4(0 8 9 1) -4(8 16 17 9) -4(16 24 25 17) -4(24 32 33 25) -4(32 40 41 33) -4(40 48 49 41) -4(48 56 57 49) -4(56 64 65 57) -4(64 72 73 65) -4(72 80 81 73) -4(80 88 89 81) -4(88 96 97 89) -4(96 104 105 97) -4(104 112 113 105) -4(112 120 121 113) -4(120 128 129 121) -4(128 136 137 129) -4(136 144 145 137) -4(144 152 153 145) -4(152 160 161 153) -4(160 168 169 161) -4(168 176 177 169) -4(176 184 185 177) -4(184 192 193 185) -4(192 200 201 193) -4(200 208 209 201) -4(208 216 217 209) -4(216 224 225 217) -4(224 232 233 225) -4(232 240 241 233) -4(1 9 10 2) -4(9 17 18 10) -4(17 25 26 18) -4(25 33 34 26) -4(33 41 42 34) -4(41 49 50 42) -4(49 57 58 50) -4(57 65 66 58) -4(65 73 74 66) -4(73 81 82 74) -4(81 89 90 82) -4(89 97 98 90) -4(97 105 106 98) -4(105 113 114 106) -4(113 121 122 114) -4(121 129 130 122) -4(129 137 138 130) -4(137 145 146 138) -4(145 153 154 146) -4(153 161 162 154) -4(161 169 170 162) -4(169 177 178 170) -4(177 185 186 178) -4(185 193 194 186) -4(193 201 202 194) -4(201 209 210 202) -4(209 217 218 210) -4(217 225 226 218) -4(225 233 234 226) -4(233 241 242 234) -4(2 10 11 3) -4(10 18 19 11) -4(18 26 27 19) -4(26 34 35 27) -4(34 42 43 35) -4(42 50 51 43) -4(50 58 59 51) -4(58 66 67 59) -4(66 74 75 67) -4(74 82 83 75) -4(82 90 91 83) -4(90 98 99 91) -4(98 106 107 99) -4(106 114 115 107) -4(114 122 123 115) -4(122 130 131 123) -4(130 138 139 131) -4(138 146 147 139) -4(146 154 155 147) -4(154 162 163 155) -4(162 170 171 163) -4(170 178 179 171) -4(178 186 187 179) -4(186 194 195 187) -4(194 202 203 195) -4(202 210 211 203) -4(210 218 219 211) -4(218 226 227 219) -4(226 234 235 227) -4(234 242 243 235) -4(3 11 12 4) -4(11 19 20 12) -4(19 27 28 20) -4(27 35 36 28) -4(35 43 44 36) -4(43 51 52 44) -4(51 59 60 52) -4(59 67 68 60) -4(67 75 76 68) -4(75 83 84 76) -4(83 91 92 84) -4(91 99 100 92) -4(99 107 108 100) -4(107 115 116 108) -4(115 123 124 116) -4(123 131 132 124) -4(131 139 140 132) -4(139 147 148 140) -4(147 155 156 148) -4(155 163 164 156) -4(163 171 172 164) -4(171 179 180 172) -4(179 187 188 180) -4(187 195 196 188) -4(195 203 204 196) -4(203 211 212 204) -4(211 219 220 212) -4(219 227 228 220) -4(227 235 236 228) -4(235 243 244 236) -4(4 12 13 5) -4(12 20 21 13) -4(20 28 29 21) -4(28 36 37 29) -4(36 44 45 37) -4(44 52 53 45) -4(52 60 61 53) -4(60 68 69 61) -4(68 76 77 69) -4(76 84 85 77) -4(84 92 93 85) -4(92 100 101 93) -4(100 108 109 101) -4(108 116 117 109) -4(116 124 125 117) -4(124 132 133 125) -4(132 140 141 133) -4(140 148 149 141) -4(148 156 157 149) -4(156 164 165 157) -4(164 172 173 165) -4(172 180 181 173) -4(180 188 189 181) -4(188 196 197 189) -4(196 204 205 197) -4(204 212 213 205) -4(212 220 221 213) -4(220 228 229 221) -4(228 236 237 229) -4(236 244 245 237) -4(5 13 14 6) -4(13 21 22 14) -4(21 29 30 22) -4(29 37 38 30) -4(37 45 46 38) -4(45 53 54 46) -4(53 61 62 54) -4(61 69 70 62) -4(69 77 78 70) -4(77 85 86 78) -4(85 93 94 86) -4(93 101 102 94) -4(101 109 110 102) -4(109 117 118 110) -4(117 125 126 118) -4(125 133 134 126) -4(133 141 142 134) -4(141 149 150 142) -4(149 157 158 150) -4(157 165 166 158) -4(165 173 174 166) -4(173 181 182 174) -4(181 189 190 182) -4(189 197 198 190) -4(197 205 206 198) -4(205 213 214 206) -4(213 221 222 214) -4(221 229 230 222) -4(229 237 238 230) -4(237 245 246 238) -4(6 14 15 7) -4(14 22 23 15) -4(22 30 31 23) -4(30 38 39 31) -4(38 46 47 39) -4(46 54 55 47) -4(54 62 63 55) -4(62 70 71 63) -4(70 78 79 71) -4(78 86 87 79) -4(86 94 95 87) -4(94 102 103 95) -4(102 110 111 103) -4(110 118 119 111) -4(118 126 127 119) -4(126 134 135 127) -4(134 142 143 135) -4(142 150 151 143) -4(150 158 159 151) -4(158 166 167 159) -4(166 174 175 167) -4(174 182 183 175) -4(182 190 191 183) -4(190 198 199 191) -4(198 206 207 199) -4(206 214 215 207) -4(214 222 223 215) -4(222 230 231 223) -4(230 238 239 231) -4(238 246 247 239) -4(7 15 263 255) -4(15 23 271 263) -4(23 31 279 271) -4(31 39 287 279) -4(39 47 295 287) -4(47 55 303 295) -4(55 63 311 303) -4(63 71 319 311) -4(71 79 327 319) -4(79 87 335 327) -4(87 95 343 335) -4(95 103 351 343) -4(103 111 359 351) -4(111 119 367 359) -4(119 127 375 367) -4(127 135 383 375) -4(135 143 391 383) -4(143 151 399 391) -4(151 159 407 399) -4(159 167 415 407) -4(167 175 423 415) -4(175 183 431 423) -4(183 191 439 431) -4(191 199 447 439) -4(199 207 455 447) -4(207 215 463 455) -4(215 223 471 463) -4(223 231 479 471) -4(231 239 487 479) -4(239 247 495 487) -4(255 263 511 503) -4(263 271 519 511) -4(271 279 527 519) -4(279 287 535 527) -4(287 295 543 535) -4(295 303 551 543) -4(303 311 559 551) -4(311 319 567 559) -4(319 327 575 567) -4(327 335 583 575) -4(335 343 591 583) -4(343 351 599 591) -4(351 359 607 599) -4(359 367 615 607) -4(367 375 623 615) -4(375 383 631 623) -4(383 391 639 631) -4(391 399 647 639) -4(399 407 655 647) -4(407 415 663 655) -4(415 423 671 663) -4(423 431 679 671) -4(431 439 687 679) -4(439 447 695 687) -4(447 455 703 695) -4(455 463 711 703) -4(463 471 719 711) -4(471 479 727 719) -4(479 487 735 727) -4(487 495 743 735) -4(503 511 759 751) -4(511 519 767 759) -4(519 527 775 767) -4(527 535 783 775) -4(535 543 791 783) -4(543 551 799 791) -4(551 559 807 799) -4(559 567 815 807) -4(567 575 823 815) -4(575 583 831 823) -4(583 591 839 831) -4(591 599 847 839) -4(599 607 855 847) -4(607 615 863 855) -4(615 623 871 863) -4(623 631 879 871) -4(631 639 887 879) -4(639 647 895 887) -4(647 655 903 895) -4(655 663 911 903) -4(663 671 919 911) -4(671 679 927 919) -4(679 687 935 927) -4(687 695 943 935) -4(695 703 951 943) -4(703 711 959 951) -4(711 719 967 959) -4(719 727 975 967) -4(727 735 983 975) -4(735 743 991 983) -4(0 248 256 8) -4(8 256 264 16) -4(16 264 272 24) -4(24 272 280 32) -4(32 280 288 40) -4(40 288 296 48) -4(48 296 304 56) -4(56 304 312 64) -4(64 312 320 72) -4(72 320 328 80) -4(80 328 336 88) -4(88 336 344 96) -4(96 344 352 104) -4(104 352 360 112) -4(112 360 368 120) -4(120 368 376 128) -4(128 376 384 136) -4(136 384 392 144) -4(144 392 400 152) -4(152 400 408 160) -4(160 408 416 168) -4(168 416 424 176) -4(176 424 432 184) -4(184 432 440 192) -4(192 440 448 200) -4(200 448 456 208) -4(208 456 464 216) -4(216 464 472 224) -4(224 472 480 232) -4(232 480 488 240) -4(248 496 504 256) -4(256 504 512 264) -4(264 512 520 272) -4(272 520 528 280) -4(280 528 536 288) -4(288 536 544 296) -4(296 544 552 304) -4(304 552 560 312) -4(312 560 568 320) -4(320 568 576 328) -4(328 576 584 336) -4(336 584 592 344) -4(344 592 600 352) -4(352 600 608 360) -4(360 608 616 368) -4(368 616 624 376) -4(376 624 632 384) -4(384 632 640 392) -4(392 640 648 400) -4(400 648 656 408) -4(408 656 664 416) -4(416 664 672 424) -4(424 672 680 432) -4(432 680 688 440) -4(440 688 696 448) -4(448 696 704 456) -4(456 704 712 464) -4(464 712 720 472) -4(472 720 728 480) -4(480 728 736 488) -4(496 744 752 504) -4(504 752 760 512) -4(512 760 768 520) -4(520 768 776 528) -4(528 776 784 536) -4(536 784 792 544) -4(544 792 800 552) -4(552 800 808 560) -4(560 808 816 568) -4(568 816 824 576) -4(576 824 832 584) -4(584 832 840 592) -4(592 840 848 600) -4(600 848 856 608) -4(608 856 864 616) -4(616 864 872 624) -4(624 872 880 632) -4(632 880 888 640) -4(640 888 896 648) -4(648 896 904 656) -4(656 904 912 664) -4(664 912 920 672) -4(672 920 928 680) -4(680 928 936 688) -4(688 936 944 696) -4(696 944 952 704) -4(704 952 960 712) -4(712 960 968 720) -4(720 968 976 728) -4(728 976 984 736) -) - - -// ************************************************************************* // diff --git a/test/tests/input_errors/foam_mesh/constant/polyMesh/neighbour b/test/tests/input_errors/foam_mesh/constant/polyMesh/neighbour deleted file mode 100644 index dab6afe5..00000000 --- a/test/tests/input_errors/foam_mesh/constant/polyMesh/neighbour +++ /dev/null @@ -1,1593 +0,0 @@ -/*--------------------------------*- C++ -*----------------------------------*\ - ========= | - \\ / F ield | OpenFOAM: The Open Source CFD Toolbox - \\ / O peration | Website: https://openfoam.org - \\ / A nd | Version: 10 - \\/ M anipulation | -\*---------------------------------------------------------------------------*/ -FoamFile -{ - format ascii; - class labelList; - note "nPoints: 992 nCells: 630 nFaces: 2211 nInternalFaces: 1569"; - location "constant/polyMesh"; - object neighbour; -} -// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // - - -1569 -( -1 -7 -210 -2 -8 -211 -3 -9 -212 -4 -10 -213 -5 -11 -214 -6 -12 -215 -13 -216 -8 -14 -217 -9 -15 -218 -10 -16 -219 -11 -17 -220 -12 -18 -221 -13 -19 -222 -20 -223 -15 -21 -224 -16 -22 -225 -17 -23 -226 -18 -24 -227 -19 -25 -228 -20 -26 -229 -27 -230 -22 -28 -231 -23 -29 -232 -24 -30 -233 -25 -31 -234 -26 -32 -235 -27 -33 -236 -34 -237 -29 -35 -238 -30 -36 -239 -31 -37 -240 -32 -38 -241 -33 -39 -242 -34 -40 -243 -41 -244 -36 -42 -245 -37 -43 -246 -38 -44 -247 -39 -45 -248 -40 -46 -249 -41 -47 -250 -48 -251 -43 -49 -252 -44 -50 -253 -45 -51 -254 -46 -52 -255 -47 -53 -256 -48 -54 -257 -55 -258 -50 -56 -259 -51 -57 -260 -52 -58 -261 -53 -59 -262 -54 -60 -263 -55 -61 -264 -62 -265 -57 -63 -266 -58 -64 -267 -59 -65 -268 -60 -66 -269 -61 -67 -270 -62 -68 -271 -69 -272 -64 -70 -273 -65 -71 -274 -66 -72 -275 -67 -73 -276 -68 -74 -277 -69 -75 -278 -76 -279 -71 -77 -280 -72 -78 -281 -73 -79 -282 -74 -80 -283 -75 -81 -284 -76 -82 -285 -83 -286 -78 -84 -287 -79 -85 -288 -80 -86 -289 -81 -87 -290 -82 -88 -291 -83 -89 -292 -90 -293 -85 -91 -294 -86 -92 -295 -87 -93 -296 -88 -94 -297 -89 -95 -298 -90 -96 -299 -97 -300 -92 -98 -301 -93 -99 -302 -94 -100 -303 -95 -101 -304 -96 -102 -305 -97 -103 -306 -104 -307 -99 -105 -308 -100 -106 -309 -101 -107 -310 -102 -108 -311 -103 -109 -312 -104 -110 -313 -111 -314 -106 -112 -315 -107 -113 -316 -108 -114 -317 -109 -115 -318 -110 -116 -319 -111 -117 -320 -118 -321 -113 -119 -322 -114 -120 -323 -115 -121 -324 -116 -122 -325 -117 -123 -326 -118 -124 -327 -125 -328 -120 -126 -329 -121 -127 -330 -122 -128 -331 -123 -129 -332 -124 -130 -333 -125 -131 -334 -132 -335 -127 -133 -336 -128 -134 -337 -129 -135 -338 -130 -136 -339 -131 -137 -340 -132 -138 -341 -139 -342 -134 -140 -343 -135 -141 -344 -136 -142 -345 -137 -143 -346 -138 -144 -347 -139 -145 -348 -146 -349 -141 -147 -350 -142 -148 -351 -143 -149 -352 -144 -150 -353 -145 -151 -354 -146 -152 -355 -153 -356 -148 -154 -357 -149 -155 -358 -150 -156 -359 -151 -157 -360 -152 -158 -361 -153 -159 -362 -160 -363 -155 -161 -364 -156 -162 -365 -157 -163 -366 -158 -164 -367 -159 -165 -368 -160 -166 -369 -167 -370 -162 -168 -371 -163 -169 -372 -164 -170 -373 -165 -171 -374 -166 -172 -375 -167 -173 -376 -174 -377 -169 -175 -378 -170 -176 -379 -171 -177 -380 -172 -178 -381 -173 -179 -382 -174 -180 -383 -181 -384 -176 -182 -385 -177 -183 -386 -178 -184 -387 -179 -185 -388 -180 -186 -389 -181 -187 -390 -188 -391 -183 -189 -392 -184 -190 -393 -185 -191 -394 -186 -192 -395 -187 -193 -396 -188 -194 -397 -195 -398 -190 -196 -399 -191 -197 -400 -192 -198 -401 -193 -199 -402 -194 -200 -403 -195 -201 -404 -202 -405 -197 -203 -406 -198 -204 -407 -199 -205 -408 -200 -206 -409 -201 -207 -410 -202 -208 -411 -209 -412 -204 -413 -205 -414 -206 -415 -207 -416 -208 -417 -209 -418 -419 -211 -217 -420 -212 -218 -421 -213 -219 -422 -214 -220 -423 -215 -221 -424 -216 -222 -425 -223 -426 -218 -224 -427 -219 -225 -428 -220 -226 -429 -221 -227 -430 -222 -228 -431 -223 -229 -432 -230 -433 -225 -231 -434 -226 -232 -435 -227 -233 -436 -228 -234 -437 -229 -235 -438 -230 -236 -439 -237 -440 -232 -238 -441 -233 -239 -442 -234 -240 -443 -235 -241 -444 -236 -242 -445 -237 -243 -446 -244 -447 -239 -245 -448 -240 -246 -449 -241 -247 -450 -242 -248 -451 -243 -249 -452 -244 -250 -453 -251 -454 -246 -252 -455 -247 -253 -456 -248 -254 -457 -249 -255 -458 -250 -256 -459 -251 -257 -460 -258 -461 -253 -259 -462 -254 -260 -463 -255 -261 -464 -256 -262 -465 -257 -263 -466 -258 -264 -467 -265 -468 -260 -266 -469 -261 -267 -470 -262 -268 -471 -263 -269 -472 -264 -270 -473 -265 -271 -474 -272 -475 -267 -273 -476 -268 -274 -477 -269 -275 -478 -270 -276 -479 -271 -277 -480 -272 -278 -481 -279 -482 -274 -280 -483 -275 -281 -484 -276 -282 -485 -277 -283 -486 -278 -284 -487 -279 -285 -488 -286 -489 -281 -287 -490 -282 -288 -491 -283 -289 -492 -284 -290 -493 -285 -291 -494 -286 -292 -495 -293 -496 -288 -294 -497 -289 -295 -498 -290 -296 -499 -291 -297 -500 -292 -298 -501 -293 -299 -502 -300 -503 -295 -301 -504 -296 -302 -505 -297 -303 -506 -298 -304 -507 -299 -305 -508 -300 -306 -509 -307 -510 -302 -308 -511 -303 -309 -512 -304 -310 -513 -305 -311 -514 -306 -312 -515 -307 -313 -516 -314 -517 -309 -315 -518 -310 -316 -519 -311 -317 -520 -312 -318 -521 -313 -319 -522 -314 -320 -523 -321 -524 -316 -322 -525 -317 -323 -526 -318 -324 -527 -319 -325 -528 -320 -326 -529 -321 -327 -530 -328 -531 -323 -329 -532 -324 -330 -533 -325 -331 -534 -326 -332 -535 -327 -333 -536 -328 -334 -537 -335 -538 -330 -336 -539 -331 -337 -540 -332 -338 -541 -333 -339 -542 -334 -340 -543 -335 -341 -544 -342 -545 -337 -343 -546 -338 -344 -547 -339 -345 -548 -340 -346 -549 -341 -347 -550 -342 -348 -551 -349 -552 -344 -350 -553 -345 -351 -554 -346 -352 -555 -347 -353 -556 -348 -354 -557 -349 -355 -558 -356 -559 -351 -357 -560 -352 -358 -561 -353 -359 -562 -354 -360 -563 -355 -361 -564 -356 -362 -565 -363 -566 -358 -364 -567 -359 -365 -568 -360 -366 -569 -361 -367 -570 -362 -368 -571 -363 -369 -572 -370 -573 -365 -371 -574 -366 -372 -575 -367 -373 -576 -368 -374 -577 -369 -375 -578 -370 -376 -579 -377 -580 -372 -378 -581 -373 -379 -582 -374 -380 -583 -375 -381 -584 -376 -382 -585 -377 -383 -586 -384 -587 -379 -385 -588 -380 -386 -589 -381 -387 -590 -382 -388 -591 -383 -389 -592 -384 -390 -593 -391 -594 -386 -392 -595 -387 -393 -596 -388 -394 -597 -389 -395 -598 -390 -396 -599 -391 -397 -600 -398 -601 -393 -399 -602 -394 -400 -603 -395 -401 -604 -396 -402 -605 -397 -403 -606 -398 -404 -607 -405 -608 -400 -406 -609 -401 -407 -610 -402 -408 -611 -403 -409 -612 -404 -410 -613 -405 -411 -614 -412 -615 -407 -413 -616 -408 -414 -617 -409 -415 -618 -410 -416 -619 -411 -417 -620 -412 -418 -621 -419 -622 -414 -623 -415 -624 -416 -625 -417 -626 -418 -627 -419 -628 -629 -421 -427 -422 -428 -423 -429 -424 -430 -425 -431 -426 -432 -433 -428 -434 -429 -435 -430 -436 -431 -437 -432 -438 -433 -439 -440 -435 -441 -436 -442 -437 -443 -438 -444 -439 -445 -440 -446 -447 -442 -448 -443 -449 -444 -450 -445 -451 -446 -452 -447 -453 -454 -449 -455 -450 -456 -451 -457 -452 -458 -453 -459 -454 -460 -461 -456 -462 -457 -463 -458 -464 -459 -465 -460 -466 -461 -467 -468 -463 -469 -464 -470 -465 -471 -466 -472 -467 -473 -468 -474 -475 -470 -476 -471 -477 -472 -478 -473 -479 -474 -480 -475 -481 -482 -477 -483 -478 -484 -479 -485 -480 -486 -481 -487 -482 -488 -489 -484 -490 -485 -491 -486 -492 -487 -493 -488 -494 -489 -495 -496 -491 -497 -492 -498 -493 -499 -494 -500 -495 -501 -496 -502 -503 -498 -504 -499 -505 -500 -506 -501 -507 -502 -508 -503 -509 -510 -505 -511 -506 -512 -507 -513 -508 -514 -509 -515 -510 -516 -517 -512 -518 -513 -519 -514 -520 -515 -521 -516 -522 -517 -523 -524 -519 -525 -520 -526 -521 -527 -522 -528 -523 -529 -524 -530 -531 -526 -532 -527 -533 -528 -534 -529 -535 -530 -536 -531 -537 -538 -533 -539 -534 -540 -535 -541 -536 -542 -537 -543 -538 -544 -545 -540 -546 -541 -547 -542 -548 -543 -549 -544 -550 -545 -551 -552 -547 -553 -548 -554 -549 -555 -550 -556 -551 -557 -552 -558 -559 -554 -560 -555 -561 -556 -562 -557 -563 -558 -564 -559 -565 -566 -561 -567 -562 -568 -563 -569 -564 -570 -565 -571 -566 -572 -573 -568 -574 -569 -575 -570 -576 -571 -577 -572 -578 -573 -579 -580 -575 -581 -576 -582 -577 -583 -578 -584 -579 -585 -580 -586 -587 -582 -588 -583 -589 -584 -590 -585 -591 -586 -592 -587 -593 -594 -589 -595 -590 -596 -591 -597 -592 -598 -593 -599 -594 -600 -601 -596 -602 -597 -603 -598 -604 -599 -605 -600 -606 -601 -607 -608 -603 -609 -604 -610 -605 -611 -606 -612 -607 -613 -608 -614 -615 -610 -616 -611 -617 -612 -618 -613 -619 -614 -620 -615 -621 -622 -617 -623 -618 -624 -619 -625 -620 -626 -621 -627 -622 -628 -629 -624 -625 -626 -627 -628 -629 -) - - -// ************************************************************************* // diff --git a/test/tests/input_errors/foam_mesh/constant/polyMesh/owner b/test/tests/input_errors/foam_mesh/constant/polyMesh/owner deleted file mode 100644 index 1155980b..00000000 --- a/test/tests/input_errors/foam_mesh/constant/polyMesh/owner +++ /dev/null @@ -1,2235 +0,0 @@ -/*--------------------------------*- C++ -*----------------------------------*\ - ========= | - \\ / F ield | OpenFOAM: The Open Source CFD Toolbox - \\ / O peration | Website: https://openfoam.org - \\ / A nd | Version: 10 - \\/ M anipulation | -\*---------------------------------------------------------------------------*/ -FoamFile -{ - format ascii; - class labelList; - note "nPoints: 992 nCells: 630 nFaces: 2211 nInternalFaces: 1569"; - location "constant/polyMesh"; - object owner; -} -// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // - - -2211 -( -0 -0 -0 -1 -1 -1 -2 -2 -2 -3 -3 -3 -4 -4 -4 -5 -5 -5 -6 -6 -7 -7 -7 -8 -8 -8 -9 -9 -9 -10 -10 -10 -11 -11 -11 -12 -12 -12 -13 -13 -14 -14 -14 -15 -15 -15 -16 -16 -16 -17 -17 -17 -18 -18 -18 -19 -19 -19 -20 -20 -21 -21 -21 -22 -22 -22 -23 -23 -23 -24 -24 -24 -25 -25 -25 -26 -26 -26 -27 -27 -28 -28 -28 -29 -29 -29 -30 -30 -30 -31 -31 -31 -32 -32 -32 -33 -33 -33 -34 -34 -35 -35 -35 -36 -36 -36 -37 -37 -37 -38 -38 -38 -39 -39 -39 -40 -40 -40 -41 -41 -42 -42 -42 -43 -43 -43 -44 -44 -44 -45 -45 -45 -46 -46 -46 -47 -47 -47 -48 -48 -49 -49 -49 -50 -50 -50 -51 -51 -51 -52 -52 -52 -53 -53 -53 -54 -54 -54 -55 -55 -56 -56 -56 -57 -57 -57 -58 -58 -58 -59 -59 -59 -60 -60 -60 -61 -61 -61 -62 -62 -63 -63 -63 -64 -64 -64 -65 -65 -65 -66 -66 -66 -67 -67 -67 -68 -68 -68 -69 -69 -70 -70 -70 -71 -71 -71 -72 -72 -72 -73 -73 -73 -74 -74 -74 -75 -75 -75 -76 -76 -77 -77 -77 -78 -78 -78 -79 -79 -79 -80 -80 -80 -81 -81 -81 -82 -82 -82 -83 -83 -84 -84 -84 -85 -85 -85 -86 -86 -86 -87 -87 -87 -88 -88 -88 -89 -89 -89 -90 -90 -91 -91 -91 -92 -92 -92 -93 -93 -93 -94 -94 -94 -95 -95 -95 -96 -96 -96 -97 -97 -98 -98 -98 -99 -99 -99 -100 -100 -100 -101 -101 -101 -102 -102 -102 -103 -103 -103 -104 -104 -105 -105 -105 -106 -106 -106 -107 -107 -107 -108 -108 -108 -109 -109 -109 -110 -110 -110 -111 -111 -112 -112 -112 -113 -113 -113 -114 -114 -114 -115 -115 -115 -116 -116 -116 -117 -117 -117 -118 -118 -119 -119 -119 -120 -120 -120 -121 -121 -121 -122 -122 -122 -123 -123 -123 -124 -124 -124 -125 -125 -126 -126 -126 -127 -127 -127 -128 -128 -128 -129 -129 -129 -130 -130 -130 -131 -131 -131 -132 -132 -133 -133 -133 -134 -134 -134 -135 -135 -135 -136 -136 -136 -137 -137 -137 -138 -138 -138 -139 -139 -140 -140 -140 -141 -141 -141 -142 -142 -142 -143 -143 -143 -144 -144 -144 -145 -145 -145 -146 -146 -147 -147 -147 -148 -148 -148 -149 -149 -149 -150 -150 -150 -151 -151 -151 -152 -152 -152 -153 -153 -154 -154 -154 -155 -155 -155 -156 -156 -156 -157 -157 -157 -158 -158 -158 -159 -159 -159 -160 -160 -161 -161 -161 -162 -162 -162 -163 -163 -163 -164 -164 -164 -165 -165 -165 -166 -166 -166 -167 -167 -168 -168 -168 -169 -169 -169 -170 -170 -170 -171 -171 -171 -172 -172 -172 -173 -173 -173 -174 -174 -175 -175 -175 -176 -176 -176 -177 -177 -177 -178 -178 -178 -179 -179 -179 -180 -180 -180 -181 -181 -182 -182 -182 -183 -183 -183 -184 -184 -184 -185 -185 -185 -186 -186 -186 -187 -187 -187 -188 -188 -189 -189 -189 -190 -190 -190 -191 -191 -191 -192 -192 -192 -193 -193 -193 -194 -194 -194 -195 -195 -196 -196 -196 -197 -197 -197 -198 -198 -198 -199 -199 -199 -200 -200 -200 -201 -201 -201 -202 -202 -203 -203 -204 -204 -205 -205 -206 -206 -207 -207 -208 -208 -209 -210 -210 -210 -211 -211 -211 -212 -212 -212 -213 -213 -213 -214 -214 -214 -215 -215 -215 -216 -216 -217 -217 -217 -218 -218 -218 -219 -219 -219 -220 -220 -220 -221 -221 -221 -222 -222 -222 -223 -223 -224 -224 -224 -225 -225 -225 -226 -226 -226 -227 -227 -227 -228 -228 -228 -229 -229 -229 -230 -230 -231 -231 -231 -232 -232 -232 -233 -233 -233 -234 -234 -234 -235 -235 -235 -236 -236 -236 -237 -237 -238 -238 -238 -239 -239 -239 -240 -240 -240 -241 -241 -241 -242 -242 -242 -243 -243 -243 -244 -244 -245 -245 -245 -246 -246 -246 -247 -247 -247 -248 -248 -248 -249 -249 -249 -250 -250 -250 -251 -251 -252 -252 -252 -253 -253 -253 -254 -254 -254 -255 -255 -255 -256 -256 -256 -257 -257 -257 -258 -258 -259 -259 -259 -260 -260 -260 -261 -261 -261 -262 -262 -262 -263 -263 -263 -264 -264 -264 -265 -265 -266 -266 -266 -267 -267 -267 -268 -268 -268 -269 -269 -269 -270 -270 -270 -271 -271 -271 -272 -272 -273 -273 -273 -274 -274 -274 -275 -275 -275 -276 -276 -276 -277 -277 -277 -278 -278 -278 -279 -279 -280 -280 -280 -281 -281 -281 -282 -282 -282 -283 -283 -283 -284 -284 -284 -285 -285 -285 -286 -286 -287 -287 -287 -288 -288 -288 -289 -289 -289 -290 -290 -290 -291 -291 -291 -292 -292 -292 -293 -293 -294 -294 -294 -295 -295 -295 -296 -296 -296 -297 -297 -297 -298 -298 -298 -299 -299 -299 -300 -300 -301 -301 -301 -302 -302 -302 -303 -303 -303 -304 -304 -304 -305 -305 -305 -306 -306 -306 -307 -307 -308 -308 -308 -309 -309 -309 -310 -310 -310 -311 -311 -311 -312 -312 -312 -313 -313 -313 -314 -314 -315 -315 -315 -316 -316 -316 -317 -317 -317 -318 -318 -318 -319 -319 -319 -320 -320 -320 -321 -321 -322 -322 -322 -323 -323 -323 -324 -324 -324 -325 -325 -325 -326 -326 -326 -327 -327 -327 -328 -328 -329 -329 -329 -330 -330 -330 -331 -331 -331 -332 -332 -332 -333 -333 -333 -334 -334 -334 -335 -335 -336 -336 -336 -337 -337 -337 -338 -338 -338 -339 -339 -339 -340 -340 -340 -341 -341 -341 -342 -342 -343 -343 -343 -344 -344 -344 -345 -345 -345 -346 -346 -346 -347 -347 -347 -348 -348 -348 -349 -349 -350 -350 -350 -351 -351 -351 -352 -352 -352 -353 -353 -353 -354 -354 -354 -355 -355 -355 -356 -356 -357 -357 -357 -358 -358 -358 -359 -359 -359 -360 -360 -360 -361 -361 -361 -362 -362 -362 -363 -363 -364 -364 -364 -365 -365 -365 -366 -366 -366 -367 -367 -367 -368 -368 -368 -369 -369 -369 -370 -370 -371 -371 -371 -372 -372 -372 -373 -373 -373 -374 -374 -374 -375 -375 -375 -376 -376 -376 -377 -377 -378 -378 -378 -379 -379 -379 -380 -380 -380 -381 -381 -381 -382 -382 -382 -383 -383 -383 -384 -384 -385 -385 -385 -386 -386 -386 -387 -387 -387 -388 -388 -388 -389 -389 -389 -390 -390 -390 -391 -391 -392 -392 -392 -393 -393 -393 -394 -394 -394 -395 -395 -395 -396 -396 -396 -397 -397 -397 -398 -398 -399 -399 -399 -400 -400 -400 -401 -401 -401 -402 -402 -402 -403 -403 -403 -404 -404 -404 -405 -405 -406 -406 -406 -407 -407 -407 -408 -408 -408 -409 -409 -409 -410 -410 -410 -411 -411 -411 -412 -412 -413 -413 -414 -414 -415 -415 -416 -416 -417 -417 -418 -418 -419 -420 -420 -421 -421 -422 -422 -423 -423 -424 -424 -425 -425 -426 -427 -427 -428 -428 -429 -429 -430 -430 -431 -431 -432 -432 -433 -434 -434 -435 -435 -436 -436 -437 -437 -438 -438 -439 -439 -440 -441 -441 -442 -442 -443 -443 -444 -444 -445 -445 -446 -446 -447 -448 -448 -449 -449 -450 -450 -451 -451 -452 -452 -453 -453 -454 -455 -455 -456 -456 -457 -457 -458 -458 -459 -459 -460 -460 -461 -462 -462 -463 -463 -464 -464 -465 -465 -466 -466 -467 -467 -468 -469 -469 -470 -470 -471 -471 -472 -472 -473 -473 -474 -474 -475 -476 -476 -477 -477 -478 -478 -479 -479 -480 -480 -481 -481 -482 -483 -483 -484 -484 -485 -485 -486 -486 -487 -487 -488 -488 -489 -490 -490 -491 -491 -492 -492 -493 -493 -494 -494 -495 -495 -496 -497 -497 -498 -498 -499 -499 -500 -500 -501 -501 -502 -502 -503 -504 -504 -505 -505 -506 -506 -507 -507 -508 -508 -509 -509 -510 -511 -511 -512 -512 -513 -513 -514 -514 -515 -515 -516 -516 -517 -518 -518 -519 -519 -520 -520 -521 -521 -522 -522 -523 -523 -524 -525 -525 -526 -526 -527 -527 -528 -528 -529 -529 -530 -530 -531 -532 -532 -533 -533 -534 -534 -535 -535 -536 -536 -537 -537 -538 -539 -539 -540 -540 -541 -541 -542 -542 -543 -543 -544 -544 -545 -546 -546 -547 -547 -548 -548 -549 -549 -550 -550 -551 -551 -552 -553 -553 -554 -554 -555 -555 -556 -556 -557 -557 -558 -558 -559 -560 -560 -561 -561 -562 -562 -563 -563 -564 -564 -565 -565 -566 -567 -567 -568 -568 -569 -569 -570 -570 -571 -571 -572 -572 -573 -574 -574 -575 -575 -576 -576 -577 -577 -578 -578 -579 -579 -580 -581 -581 -582 -582 -583 -583 -584 -584 -585 -585 -586 -586 -587 -588 -588 -589 -589 -590 -590 -591 -591 -592 -592 -593 -593 -594 -595 -595 -596 -596 -597 -597 -598 -598 -599 -599 -600 -600 -601 -602 -602 -603 -603 -604 -604 -605 -605 -606 -606 -607 -607 -608 -609 -609 -610 -610 -611 -611 -612 -612 -613 -613 -614 -614 -615 -616 -616 -617 -617 -618 -618 -619 -619 -620 -620 -621 -621 -622 -623 -624 -625 -626 -627 -628 -0 -210 -420 -1 -211 -421 -2 -212 -422 -3 -213 -423 -4 -214 -424 -5 -215 -425 -6 -216 -426 -203 -413 -623 -204 -414 -624 -205 -415 -625 -206 -416 -626 -207 -417 -627 -208 -418 -628 -209 -419 -629 -420 -427 -434 -441 -448 -455 -462 -469 -476 -483 -490 -497 -504 -511 -518 -525 -532 -539 -546 -553 -560 -567 -574 -581 -588 -595 -602 -609 -616 -623 -421 -428 -435 -442 -449 -456 -463 -470 -477 -484 -491 -498 -505 -512 -519 -526 -533 -540 -547 -554 -561 -568 -575 -582 -589 -596 -603 -610 -617 -624 -422 -429 -436 -443 -450 -457 -464 -471 -478 -485 -492 -499 -506 -513 -520 -527 -534 -541 -548 -555 -562 -569 -576 -583 -590 -597 -604 -611 -618 -625 -423 -430 -437 -444 -451 -458 -465 -472 -479 -486 -493 -500 -507 -514 -521 -528 -535 -542 -549 -556 -563 -570 -577 -584 -591 -598 -605 -612 -619 -626 -424 -431 -438 -445 -452 -459 -466 -473 -480 -487 -494 -501 -508 -515 -522 -529 -536 -543 -550 -557 -564 -571 -578 -585 -592 -599 -606 -613 -620 -627 -425 -432 -439 -446 -453 -460 -467 -474 -481 -488 -495 -502 -509 -516 -523 -530 -537 -544 -551 -558 -565 -572 -579 -586 -593 -600 -607 -614 -621 -628 -426 -433 -440 -447 -454 -461 -468 -475 -482 -489 -496 -503 -510 -517 -524 -531 -538 -545 -552 -559 -566 -573 -580 -587 -594 -601 -608 -615 -622 -629 -0 -7 -14 -21 -28 -35 -42 -49 -56 -63 -70 -77 -84 -91 -98 -105 -112 -119 -126 -133 -140 -147 -154 -161 -168 -175 -182 -189 -196 -203 -1 -8 -15 -22 -29 -36 -43 -50 -57 -64 -71 -78 -85 -92 -99 -106 -113 -120 -127 -134 -141 -148 -155 -162 -169 -176 -183 -190 -197 -204 -2 -9 -16 -23 -30 -37 -44 -51 -58 -65 -72 -79 -86 -93 -100 -107 -114 -121 -128 -135 -142 -149 -156 -163 -170 -177 -184 -191 -198 -205 -3 -10 -17 -24 -31 -38 -45 -52 -59 -66 -73 -80 -87 -94 -101 -108 -115 -122 -129 -136 -143 -150 -157 -164 -171 -178 -185 -192 -199 -206 -4 -11 -18 -25 -32 -39 -46 -53 -60 -67 -74 -81 -88 -95 -102 -109 -116 -123 -130 -137 -144 -151 -158 -165 -172 -179 -186 -193 -200 -207 -5 -12 -19 -26 -33 -40 -47 -54 -61 -68 -75 -82 -89 -96 -103 -110 -117 -124 -131 -138 -145 -152 -159 -166 -173 -180 -187 -194 -201 -208 -6 -13 -20 -27 -34 -41 -48 -55 -62 -69 -76 -83 -90 -97 -104 -111 -118 -125 -132 -139 -146 -153 -160 -167 -174 -181 -188 -195 -202 -209 -6 -13 -20 -27 -34 -41 -48 -55 -62 -69 -76 -83 -90 -97 -104 -111 -118 -125 -132 -139 -146 -153 -160 -167 -174 -181 -188 -195 -202 -209 -216 -223 -230 -237 -244 -251 -258 -265 -272 -279 -286 -293 -300 -307 -314 -321 -328 -335 -342 -349 -356 -363 -370 -377 -384 -391 -398 -405 -412 -419 -426 -433 -440 -447 -454 -461 -468 -475 -482 -489 -496 -503 -510 -517 -524 -531 -538 -545 -552 -559 -566 -573 -580 -587 -594 -601 -608 -615 -622 -629 -0 -7 -14 -21 -28 -35 -42 -49 -56 -63 -70 -77 -84 -91 -98 -105 -112 -119 -126 -133 -140 -147 -154 -161 -168 -175 -182 -189 -196 -203 -210 -217 -224 -231 -238 -245 -252 -259 -266 -273 -280 -287 -294 -301 -308 -315 -322 -329 -336 -343 -350 -357 -364 -371 -378 -385 -392 -399 -406 -413 -420 -427 -434 -441 -448 -455 -462 -469 -476 -483 -490 -497 -504 -511 -518 -525 -532 -539 -546 -553 -560 -567 -574 -581 -588 -595 -602 -609 -616 -623 -) - - -// ************************************************************************* // diff --git a/test/tests/input_errors/foam_mesh/constant/polyMesh/points b/test/tests/input_errors/foam_mesh/constant/polyMesh/points deleted file mode 100644 index 7e72f513..00000000 --- a/test/tests/input_errors/foam_mesh/constant/polyMesh/points +++ /dev/null @@ -1,1015 +0,0 @@ -/*--------------------------------*- C++ -*----------------------------------*\ - ========= | - \\ / F ield | OpenFOAM: The Open Source CFD Toolbox - \\ / O peration | Website: https://openfoam.org - \\ / A nd | Version: 10 - \\/ M anipulation | -\*---------------------------------------------------------------------------*/ -FoamFile -{ - format ascii; - class vectorField; - location "constant/polyMesh"; - object points; -} -// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // - - -992 -( -(0 0 -0.26) -(0.0108571428571429 0 -0.26) -(0.0217142857142857 0 -0.26) -(0.0325714285714286 0 -0.26) -(0.0434285714285714 0 -0.26) -(0.0542857142857143 0 -0.26) -(0.0651428571428571 0 -0.26) -(0.076 0 -0.26) -(0 0.0726666666666667 -0.26) -(0.0108571428571429 0.0726666666666667 -0.26) -(0.0217142857142857 0.0726666666666667 -0.26) -(0.0325714285714286 0.0726666666666667 -0.26) -(0.0434285714285714 0.0726666666666667 -0.26) -(0.0542857142857143 0.0726666666666667 -0.26) -(0.0651428571428571 0.0726666666666667 -0.26) -(0.076 0.0726666666666667 -0.26) -(0 0.145333333333333 -0.26) -(0.0108571428571429 0.145333333333333 -0.26) -(0.0217142857142857 0.145333333333333 -0.26) -(0.0325714285714286 0.145333333333333 -0.26) -(0.0434285714285714 0.145333333333333 -0.26) -(0.0542857142857143 0.145333333333333 -0.26) -(0.0651428571428572 0.145333333333333 -0.26) -(0.076 0.145333333333333 -0.26) -(0 0.218 -0.26) -(0.0108571428571429 0.218 -0.26) -(0.0217142857142857 0.218 -0.26) -(0.0325714285714286 0.218 -0.26) -(0.0434285714285714 0.218 -0.26) -(0.0542857142857143 0.218 -0.26) -(0.0651428571428571 0.218 -0.26) -(0.076 0.218 -0.26) -(0 0.290666666666667 -0.26) -(0.0108571428571429 0.290666666666667 -0.26) -(0.0217142857142857 0.290666666666667 -0.26) -(0.0325714285714286 0.290666666666667 -0.26) -(0.0434285714285714 0.290666666666667 -0.26) -(0.0542857142857143 0.290666666666667 -0.26) -(0.0651428571428571 0.290666666666667 -0.26) -(0.076 0.290666666666667 -0.26) -(0 0.363333333333333 -0.26) -(0.0108571428571429 0.363333333333333 -0.26) -(0.0217142857142857 0.363333333333333 -0.26) -(0.0325714285714286 0.363333333333333 -0.26) -(0.0434285714285714 0.363333333333333 -0.26) -(0.0542857142857143 0.363333333333333 -0.26) -(0.0651428571428571 0.363333333333333 -0.26) -(0.076 0.363333333333333 -0.26) -(0 0.436 -0.26) -(0.0108571428571429 0.436 -0.26) -(0.0217142857142857 0.436 -0.26) -(0.0325714285714286 0.436 -0.26) -(0.0434285714285714 0.436 -0.26) -(0.0542857142857143 0.436 -0.26) -(0.0651428571428571 0.436 -0.26) -(0.076 0.436 -0.26) -(0 0.508666666666667 -0.26) -(0.0108571428571429 0.508666666666667 -0.26) -(0.0217142857142857 0.508666666666667 -0.26) -(0.0325714285714286 0.508666666666667 -0.26) -(0.0434285714285714 0.508666666666667 -0.26) -(0.0542857142857143 0.508666666666667 -0.26) -(0.0651428571428571 0.508666666666667 -0.26) -(0.076 0.508666666666667 -0.26) -(0 0.581333333333333 -0.26) -(0.0108571428571429 0.581333333333333 -0.26) -(0.0217142857142857 0.581333333333333 -0.26) -(0.0325714285714286 0.581333333333333 -0.26) -(0.0434285714285714 0.581333333333333 -0.26) -(0.0542857142857143 0.581333333333333 -0.26) -(0.0651428571428571 0.581333333333333 -0.26) -(0.076 0.581333333333333 -0.26) -(0 0.654 -0.26) -(0.0108571428571429 0.654 -0.26) -(0.0217142857142857 0.654 -0.26) -(0.0325714285714286 0.654 -0.26) -(0.0434285714285714 0.654 -0.26) -(0.0542857142857143 0.654 -0.26) -(0.0651428571428571 0.654 -0.26) -(0.076 0.654 -0.26) -(0 0.726666666666667 -0.26) -(0.0108571428571429 0.726666666666667 -0.26) -(0.0217142857142857 0.726666666666667 -0.26) -(0.0325714285714286 0.726666666666667 -0.26) -(0.0434285714285714 0.726666666666667 -0.26) -(0.0542857142857143 0.726666666666667 -0.26) -(0.0651428571428572 0.726666666666667 -0.26) -(0.076 0.726666666666667 -0.26) -(0 0.799333333333333 -0.26) -(0.0108571428571429 0.799333333333333 -0.26) -(0.0217142857142857 0.799333333333333 -0.26) -(0.0325714285714286 0.799333333333333 -0.26) -(0.0434285714285714 0.799333333333333 -0.26) -(0.0542857142857143 0.799333333333333 -0.26) -(0.0651428571428571 0.799333333333333 -0.26) -(0.076 0.799333333333333 -0.26) -(0 0.872 -0.26) -(0.0108571428571429 0.872 -0.26) -(0.0217142857142857 0.872 -0.26) -(0.0325714285714286 0.872 -0.26) -(0.0434285714285714 0.872 -0.26) -(0.0542857142857143 0.872 -0.26) -(0.0651428571428571 0.872 -0.26) -(0.076 0.872 -0.26) -(0 0.944666666666667 -0.26) -(0.0108571428571429 0.944666666666667 -0.26) -(0.0217142857142857 0.944666666666667 -0.26) -(0.0325714285714286 0.944666666666667 -0.26) -(0.0434285714285714 0.944666666666667 -0.26) -(0.0542857142857143 0.944666666666667 -0.26) -(0.0651428571428571 0.944666666666667 -0.26) -(0.076 0.944666666666667 -0.26) -(0 1.01733333333333 -0.26) -(0.0108571428571429 1.01733333333333 -0.26) -(0.0217142857142857 1.01733333333333 -0.26) -(0.0325714285714286 1.01733333333333 -0.26) -(0.0434285714285714 1.01733333333333 -0.26) -(0.0542857142857143 1.01733333333333 -0.26) -(0.0651428571428571 1.01733333333333 -0.26) -(0.076 1.01733333333333 -0.26) -(0 1.09 -0.26) -(0.0108571428571429 1.09 -0.26) -(0.0217142857142857 1.09 -0.26) -(0.0325714285714286 1.09 -0.26) -(0.0434285714285714 1.09 -0.26) -(0.0542857142857143 1.09 -0.26) -(0.0651428571428571 1.09 -0.26) -(0.076 1.09 -0.26) -(0 1.16266666666667 -0.26) -(0.0108571428571429 1.16266666666667 -0.26) -(0.0217142857142857 1.16266666666667 -0.26) -(0.0325714285714286 1.16266666666667 -0.26) -(0.0434285714285714 1.16266666666667 -0.26) -(0.0542857142857143 1.16266666666667 -0.26) -(0.0651428571428571 1.16266666666667 -0.26) -(0.076 1.16266666666667 -0.26) -(0 1.23533333333333 -0.26) -(0.0108571428571429 1.23533333333333 -0.26) -(0.0217142857142857 1.23533333333333 -0.26) -(0.0325714285714286 1.23533333333333 -0.26) -(0.0434285714285714 1.23533333333333 -0.26) -(0.0542857142857143 1.23533333333333 -0.26) -(0.0651428571428571 1.23533333333333 -0.26) -(0.076 1.23533333333333 -0.26) -(0 1.308 -0.26) -(0.0108571428571429 1.308 -0.26) -(0.0217142857142857 1.308 -0.26) -(0.0325714285714286 1.308 -0.26) -(0.0434285714285714 1.308 -0.26) -(0.0542857142857143 1.308 -0.26) -(0.0651428571428571 1.308 -0.26) -(0.076 1.308 -0.26) -(0 1.38066666666667 -0.26) -(0.0108571428571429 1.38066666666667 -0.26) -(0.0217142857142857 1.38066666666667 -0.26) -(0.0325714285714286 1.38066666666667 -0.26) -(0.0434285714285714 1.38066666666667 -0.26) -(0.0542857142857143 1.38066666666667 -0.26) -(0.0651428571428572 1.38066666666667 -0.26) -(0.076 1.38066666666667 -0.26) -(0 1.45333333333333 -0.26) -(0.0108571428571429 1.45333333333333 -0.26) -(0.0217142857142857 1.45333333333333 -0.26) -(0.0325714285714286 1.45333333333333 -0.26) -(0.0434285714285714 1.45333333333333 -0.26) -(0.0542857142857143 1.45333333333333 -0.26) -(0.0651428571428571 1.45333333333333 -0.26) -(0.076 1.45333333333333 -0.26) -(0 1.526 -0.26) -(0.0108571428571429 1.526 -0.26) -(0.0217142857142857 1.526 -0.26) -(0.0325714285714286 1.526 -0.26) -(0.0434285714285714 1.526 -0.26) -(0.0542857142857143 1.526 -0.26) -(0.0651428571428571 1.526 -0.26) -(0.076 1.526 -0.26) -(0 1.59866666666667 -0.26) -(0.0108571428571429 1.59866666666667 -0.26) -(0.0217142857142857 1.59866666666667 -0.26) -(0.0325714285714286 1.59866666666667 -0.26) -(0.0434285714285714 1.59866666666667 -0.26) -(0.0542857142857143 1.59866666666667 -0.26) -(0.0651428571428571 1.59866666666667 -0.26) -(0.076 1.59866666666667 -0.26) -(0 1.67133333333333 -0.26) -(0.0108571428571429 1.67133333333333 -0.26) -(0.0217142857142857 1.67133333333333 -0.26) -(0.0325714285714286 1.67133333333333 -0.26) -(0.0434285714285714 1.67133333333333 -0.26) -(0.0542857142857143 1.67133333333333 -0.26) -(0.0651428571428571 1.67133333333333 -0.26) -(0.076 1.67133333333333 -0.26) -(0 1.744 -0.26) -(0.0108571428571429 1.744 -0.26) -(0.0217142857142857 1.744 -0.26) -(0.0325714285714286 1.744 -0.26) -(0.0434285714285714 1.744 -0.26) -(0.0542857142857143 1.744 -0.26) -(0.0651428571428571 1.744 -0.26) -(0.076 1.744 -0.26) -(0 1.81666666666667 -0.26) -(0.0108571428571429 1.81666666666667 -0.26) -(0.0217142857142857 1.81666666666667 -0.26) -(0.0325714285714286 1.81666666666667 -0.26) -(0.0434285714285714 1.81666666666667 -0.26) -(0.0542857142857143 1.81666666666667 -0.26) -(0.0651428571428571 1.81666666666667 -0.26) -(0.076 1.81666666666667 -0.26) -(0 1.88933333333333 -0.26) -(0.0108571428571429 1.88933333333333 -0.26) -(0.0217142857142857 1.88933333333333 -0.26) -(0.0325714285714286 1.88933333333333 -0.26) -(0.0434285714285714 1.88933333333333 -0.26) -(0.0542857142857143 1.88933333333333 -0.26) -(0.0651428571428571 1.88933333333333 -0.26) -(0.076 1.88933333333333 -0.26) -(0 1.962 -0.26) -(0.0108571428571429 1.962 -0.26) -(0.0217142857142857 1.962 -0.26) -(0.0325714285714286 1.962 -0.26) -(0.0434285714285714 1.962 -0.26) -(0.0542857142857143 1.962 -0.26) -(0.0651428571428571 1.962 -0.26) -(0.076 1.962 -0.26) -(0 2.03466666666667 -0.26) -(0.0108571428571429 2.03466666666667 -0.26) -(0.0217142857142857 2.03466666666667 -0.26) -(0.0325714285714286 2.03466666666667 -0.26) -(0.0434285714285714 2.03466666666667 -0.26) -(0.0542857142857143 2.03466666666667 -0.26) -(0.0651428571428572 2.03466666666667 -0.26) -(0.076 2.03466666666667 -0.26) -(0 2.10733333333333 -0.26) -(0.0108571428571429 2.10733333333333 -0.26) -(0.0217142857142857 2.10733333333333 -0.26) -(0.0325714285714286 2.10733333333333 -0.26) -(0.0434285714285714 2.10733333333333 -0.26) -(0.0542857142857143 2.10733333333333 -0.26) -(0.0651428571428571 2.10733333333333 -0.26) -(0.076 2.10733333333333 -0.26) -(0 2.18 -0.26) -(0.0108571428571429 2.18 -0.26) -(0.0217142857142857 2.18 -0.26) -(0.0325714285714286 2.18 -0.26) -(0.0434285714285714 2.18 -0.26) -(0.0542857142857143 2.18 -0.26) -(0.0651428571428571 2.18 -0.26) -(0.076 2.18 -0.26) -(0 0 -0.0866666666666667) -(0.0108571428571429 0 -0.0866666666666667) -(0.0217142857142857 0 -0.0866666666666667) -(0.0325714285714286 0 -0.0866666666666667) -(0.0434285714285714 0 -0.0866666666666667) -(0.0542857142857143 0 -0.0866666666666667) -(0.0651428571428572 0 -0.0866666666666667) -(0.076 0 -0.0866666666666667) -(0 0.0726666666666667 -0.0866666666666667) -(0.0108571428571429 0.0726666666666667 -0.0866666666666667) -(0.0217142857142857 0.0726666666666667 -0.0866666666666667) -(0.0325714285714286 0.0726666666666667 -0.0866666666666667) -(0.0434285714285714 0.0726666666666667 -0.0866666666666667) -(0.0542857142857143 0.0726666666666667 -0.0866666666666667) -(0.0651428571428572 0.0726666666666667 -0.0866666666666667) -(0.076 0.0726666666666667 -0.0866666666666667) -(0 0.145333333333333 -0.0866666666666667) -(0.0108571428571429 0.145333333333333 -0.0866666666666667) -(0.0217142857142857 0.145333333333333 -0.0866666666666667) -(0.0325714285714286 0.145333333333333 -0.0866666666666667) -(0.0434285714285714 0.145333333333333 -0.0866666666666667) -(0.0542857142857143 0.145333333333333 -0.0866666666666667) -(0.0651428571428572 0.145333333333333 -0.0866666666666667) -(0.076 0.145333333333333 -0.0866666666666667) -(0 0.218 -0.0866666666666667) -(0.0108571428571429 0.218 -0.0866666666666667) -(0.0217142857142857 0.218 -0.0866666666666667) -(0.0325714285714286 0.218 -0.0866666666666667) -(0.0434285714285714 0.218 -0.0866666666666667) -(0.0542857142857143 0.218 -0.0866666666666667) -(0.0651428571428571 0.218 -0.0866666666666667) -(0.076 0.218 -0.0866666666666667) -(0 0.290666666666667 -0.0866666666666667) -(0.0108571428571429 0.290666666666667 -0.0866666666666667) -(0.0217142857142857 0.290666666666667 -0.0866666666666667) -(0.0325714285714286 0.290666666666667 -0.0866666666666667) -(0.0434285714285714 0.290666666666667 -0.0866666666666667) -(0.0542857142857143 0.290666666666667 -0.0866666666666667) -(0.0651428571428572 0.290666666666667 -0.0866666666666667) -(0.076 0.290666666666667 -0.0866666666666667) -(0 0.363333333333333 -0.0866666666666667) -(0.0108571428571429 0.363333333333333 -0.0866666666666667) -(0.0217142857142857 0.363333333333333 -0.0866666666666667) -(0.0325714285714286 0.363333333333333 -0.0866666666666667) -(0.0434285714285714 0.363333333333333 -0.0866666666666667) -(0.0542857142857143 0.363333333333333 -0.0866666666666667) -(0.0651428571428572 0.363333333333333 -0.0866666666666667) -(0.076 0.363333333333333 -0.0866666666666667) -(0 0.436 -0.0866666666666667) -(0.0108571428571429 0.436 -0.0866666666666667) -(0.0217142857142857 0.436 -0.0866666666666667) -(0.0325714285714286 0.436 -0.0866666666666667) -(0.0434285714285714 0.436 -0.0866666666666667) -(0.0542857142857143 0.436 -0.0866666666666667) -(0.0651428571428572 0.436 -0.0866666666666667) -(0.076 0.436 -0.0866666666666667) -(0 0.508666666666667 -0.0866666666666667) -(0.0108571428571429 0.508666666666667 -0.0866666666666667) -(0.0217142857142857 0.508666666666667 -0.0866666666666667) -(0.0325714285714286 0.508666666666667 -0.0866666666666667) -(0.0434285714285714 0.508666666666667 -0.0866666666666667) -(0.0542857142857143 0.508666666666667 -0.0866666666666667) -(0.0651428571428571 0.508666666666667 -0.0866666666666667) -(0.076 0.508666666666667 -0.0866666666666667) -(0 0.581333333333333 -0.0866666666666667) -(0.0108571428571429 0.581333333333333 -0.0866666666666667) -(0.0217142857142857 0.581333333333333 -0.0866666666666667) -(0.0325714285714286 0.581333333333333 -0.0866666666666667) -(0.0434285714285714 0.581333333333333 -0.0866666666666667) -(0.0542857142857143 0.581333333333333 -0.0866666666666667) -(0.0651428571428572 0.581333333333333 -0.0866666666666667) -(0.076 0.581333333333333 -0.0866666666666667) -(0 0.654 -0.0866666666666667) -(0.0108571428571429 0.654 -0.0866666666666667) -(0.0217142857142857 0.654 -0.0866666666666667) -(0.0325714285714286 0.654 -0.0866666666666667) -(0.0434285714285714 0.654 -0.0866666666666667) -(0.0542857142857143 0.654 -0.0866666666666667) -(0.0651428571428571 0.654 -0.0866666666666667) -(0.076 0.654 -0.0866666666666667) -(0 0.726666666666667 -0.0866666666666667) -(0.0108571428571429 0.726666666666667 -0.0866666666666667) -(0.0217142857142857 0.726666666666667 -0.0866666666666667) -(0.0325714285714286 0.726666666666667 -0.0866666666666667) -(0.0434285714285714 0.726666666666667 -0.0866666666666667) -(0.0542857142857143 0.726666666666667 -0.0866666666666667) -(0.0651428571428572 0.726666666666667 -0.0866666666666667) -(0.076 0.726666666666667 -0.0866666666666667) -(0 0.799333333333333 -0.0866666666666667) -(0.0108571428571429 0.799333333333333 -0.0866666666666667) -(0.0217142857142857 0.799333333333333 -0.0866666666666667) -(0.0325714285714286 0.799333333333333 -0.0866666666666667) -(0.0434285714285714 0.799333333333333 -0.0866666666666667) -(0.0542857142857143 0.799333333333333 -0.0866666666666667) -(0.0651428571428572 0.799333333333333 -0.0866666666666667) -(0.076 0.799333333333333 -0.0866666666666667) -(0 0.872 -0.0866666666666667) -(0.0108571428571429 0.872 -0.0866666666666667) -(0.0217142857142857 0.872 -0.0866666666666667) -(0.0325714285714286 0.872 -0.0866666666666667) -(0.0434285714285714 0.872 -0.0866666666666667) -(0.0542857142857143 0.872 -0.0866666666666667) -(0.0651428571428571 0.872 -0.0866666666666667) -(0.076 0.872 -0.0866666666666667) -(0 0.944666666666667 -0.0866666666666667) -(0.0108571428571429 0.944666666666667 -0.0866666666666667) -(0.0217142857142857 0.944666666666667 -0.0866666666666667) -(0.0325714285714286 0.944666666666667 -0.0866666666666667) -(0.0434285714285714 0.944666666666667 -0.0866666666666667) -(0.0542857142857143 0.944666666666667 -0.0866666666666667) -(0.0651428571428572 0.944666666666667 -0.0866666666666667) -(0.076 0.944666666666667 -0.0866666666666667) -(0 1.01733333333333 -0.0866666666666667) -(0.0108571428571429 1.01733333333333 -0.0866666666666667) -(0.0217142857142857 1.01733333333333 -0.0866666666666667) -(0.0325714285714286 1.01733333333333 -0.0866666666666667) -(0.0434285714285714 1.01733333333333 -0.0866666666666667) -(0.0542857142857143 1.01733333333333 -0.0866666666666667) -(0.0651428571428571 1.01733333333333 -0.0866666666666667) -(0.076 1.01733333333333 -0.0866666666666667) -(0 1.09 -0.0866666666666667) -(0.0108571428571429 1.09 -0.0866666666666667) -(0.0217142857142857 1.09 -0.0866666666666667) -(0.0325714285714286 1.09 -0.0866666666666667) -(0.0434285714285714 1.09 -0.0866666666666667) -(0.0542857142857143 1.09 -0.0866666666666667) -(0.0651428571428572 1.09 -0.0866666666666667) -(0.076 1.09 -0.0866666666666667) -(0 1.16266666666667 -0.0866666666666667) -(0.0108571428571429 1.16266666666667 -0.0866666666666667) -(0.0217142857142857 1.16266666666667 -0.0866666666666667) -(0.0325714285714286 1.16266666666667 -0.0866666666666667) -(0.0434285714285714 1.16266666666667 -0.0866666666666667) -(0.0542857142857143 1.16266666666667 -0.0866666666666667) -(0.0651428571428572 1.16266666666667 -0.0866666666666667) -(0.076 1.16266666666667 -0.0866666666666667) -(0 1.23533333333333 -0.0866666666666667) -(0.0108571428571429 1.23533333333333 -0.0866666666666667) -(0.0217142857142857 1.23533333333333 -0.0866666666666667) -(0.0325714285714286 1.23533333333333 -0.0866666666666667) -(0.0434285714285714 1.23533333333333 -0.0866666666666667) -(0.0542857142857143 1.23533333333333 -0.0866666666666667) -(0.0651428571428572 1.23533333333333 -0.0866666666666667) -(0.076 1.23533333333333 -0.0866666666666667) -(0 1.308 -0.0866666666666667) -(0.0108571428571429 1.308 -0.0866666666666667) -(0.0217142857142857 1.308 -0.0866666666666667) -(0.0325714285714286 1.308 -0.0866666666666667) -(0.0434285714285714 1.308 -0.0866666666666667) -(0.0542857142857143 1.308 -0.0866666666666667) -(0.0651428571428571 1.308 -0.0866666666666667) -(0.076 1.308 -0.0866666666666667) -(0 1.38066666666667 -0.0866666666666667) -(0.0108571428571429 1.38066666666667 -0.0866666666666667) -(0.0217142857142857 1.38066666666667 -0.0866666666666667) -(0.0325714285714286 1.38066666666667 -0.0866666666666667) -(0.0434285714285714 1.38066666666667 -0.0866666666666667) -(0.0542857142857143 1.38066666666667 -0.0866666666666667) -(0.0651428571428572 1.38066666666667 -0.0866666666666667) -(0.076 1.38066666666667 -0.0866666666666667) -(0 1.45333333333333 -0.0866666666666667) -(0.0108571428571429 1.45333333333333 -0.0866666666666667) -(0.0217142857142857 1.45333333333333 -0.0866666666666667) -(0.0325714285714286 1.45333333333333 -0.0866666666666667) -(0.0434285714285714 1.45333333333333 -0.0866666666666667) -(0.0542857142857143 1.45333333333333 -0.0866666666666667) -(0.0651428571428572 1.45333333333333 -0.0866666666666667) -(0.076 1.45333333333333 -0.0866666666666667) -(0 1.526 -0.0866666666666667) -(0.0108571428571429 1.526 -0.0866666666666667) -(0.0217142857142857 1.526 -0.0866666666666667) -(0.0325714285714286 1.526 -0.0866666666666667) -(0.0434285714285714 1.526 -0.0866666666666667) -(0.0542857142857143 1.526 -0.0866666666666667) -(0.0651428571428572 1.526 -0.0866666666666667) -(0.076 1.526 -0.0866666666666667) -(0 1.59866666666667 -0.0866666666666667) -(0.0108571428571429 1.59866666666667 -0.0866666666666667) -(0.0217142857142857 1.59866666666667 -0.0866666666666667) -(0.0325714285714286 1.59866666666667 -0.0866666666666667) -(0.0434285714285714 1.59866666666667 -0.0866666666666667) -(0.0542857142857143 1.59866666666667 -0.0866666666666667) -(0.0651428571428571 1.59866666666667 -0.0866666666666667) -(0.076 1.59866666666667 -0.0866666666666667) -(0 1.67133333333333 -0.0866666666666667) -(0.0108571428571429 1.67133333333333 -0.0866666666666667) -(0.0217142857142857 1.67133333333333 -0.0866666666666667) -(0.0325714285714286 1.67133333333333 -0.0866666666666667) -(0.0434285714285714 1.67133333333333 -0.0866666666666667) -(0.0542857142857143 1.67133333333333 -0.0866666666666667) -(0.0651428571428572 1.67133333333333 -0.0866666666666667) -(0.076 1.67133333333333 -0.0866666666666667) -(0 1.744 -0.0866666666666667) -(0.0108571428571429 1.744 -0.0866666666666667) -(0.0217142857142857 1.744 -0.0866666666666667) -(0.0325714285714286 1.744 -0.0866666666666667) -(0.0434285714285714 1.744 -0.0866666666666667) -(0.0542857142857143 1.744 -0.0866666666666667) -(0.0651428571428572 1.744 -0.0866666666666667) -(0.076 1.744 -0.0866666666666667) -(0 1.81666666666667 -0.0866666666666667) -(0.0108571428571429 1.81666666666667 -0.0866666666666667) -(0.0217142857142857 1.81666666666667 -0.0866666666666667) -(0.0325714285714286 1.81666666666667 -0.0866666666666667) -(0.0434285714285714 1.81666666666667 -0.0866666666666667) -(0.0542857142857143 1.81666666666667 -0.0866666666666667) -(0.0651428571428572 1.81666666666667 -0.0866666666666667) -(0.076 1.81666666666667 -0.0866666666666667) -(0 1.88933333333333 -0.0866666666666667) -(0.0108571428571429 1.88933333333333 -0.0866666666666667) -(0.0217142857142857 1.88933333333333 -0.0866666666666667) -(0.0325714285714286 1.88933333333333 -0.0866666666666667) -(0.0434285714285714 1.88933333333333 -0.0866666666666667) -(0.0542857142857143 1.88933333333333 -0.0866666666666667) -(0.0651428571428572 1.88933333333333 -0.0866666666666667) -(0.076 1.88933333333333 -0.0866666666666667) -(0 1.962 -0.0866666666666667) -(0.0108571428571429 1.962 -0.0866666666666667) -(0.0217142857142857 1.962 -0.0866666666666667) -(0.0325714285714286 1.962 -0.0866666666666667) -(0.0434285714285714 1.962 -0.0866666666666667) -(0.0542857142857143 1.962 -0.0866666666666667) -(0.0651428571428572 1.962 -0.0866666666666667) -(0.076 1.962 -0.0866666666666667) -(0 2.03466666666667 -0.0866666666666667) -(0.0108571428571429 2.03466666666667 -0.0866666666666667) -(0.0217142857142857 2.03466666666667 -0.0866666666666667) -(0.0325714285714286 2.03466666666667 -0.0866666666666667) -(0.0434285714285714 2.03466666666667 -0.0866666666666667) -(0.0542857142857143 2.03466666666667 -0.0866666666666667) -(0.0651428571428572 2.03466666666667 -0.0866666666666667) -(0.076 2.03466666666667 -0.0866666666666667) -(0 2.10733333333333 -0.0866666666666667) -(0.0108571428571429 2.10733333333333 -0.0866666666666667) -(0.0217142857142857 2.10733333333333 -0.0866666666666667) -(0.0325714285714286 2.10733333333333 -0.0866666666666667) -(0.0434285714285714 2.10733333333333 -0.0866666666666667) -(0.0542857142857143 2.10733333333333 -0.0866666666666667) -(0.0651428571428572 2.10733333333333 -0.0866666666666667) -(0.076 2.10733333333333 -0.0866666666666667) -(0 2.18 -0.0866666666666667) -(0.0108571428571429 2.18 -0.0866666666666667) -(0.0217142857142857 2.18 -0.0866666666666667) -(0.0325714285714286 2.18 -0.0866666666666667) -(0.0434285714285714 2.18 -0.0866666666666667) -(0.0542857142857143 2.18 -0.0866666666666667) -(0.0651428571428572 2.18 -0.0866666666666667) -(0.076 2.18 -0.0866666666666667) -(0 0 0.0866666666666666) -(0.0108571428571429 0 0.0866666666666666) -(0.0217142857142857 0 0.0866666666666666) -(0.0325714285714286 0 0.0866666666666666) -(0.0434285714285714 0 0.0866666666666666) -(0.0542857142857143 0 0.0866666666666666) -(0.0651428571428572 0 0.0866666666666666) -(0.076 0 0.0866666666666666) -(0 0.0726666666666667 0.0866666666666666) -(0.0108571428571429 0.0726666666666667 0.0866666666666666) -(0.0217142857142857 0.0726666666666667 0.0866666666666666) -(0.0325714285714286 0.0726666666666667 0.0866666666666666) -(0.0434285714285714 0.0726666666666667 0.0866666666666666) -(0.0542857142857143 0.0726666666666667 0.0866666666666666) -(0.0651428571428571 0.0726666666666667 0.0866666666666666) -(0.076 0.0726666666666667 0.0866666666666666) -(0 0.145333333333333 0.0866666666666666) -(0.0108571428571429 0.145333333333333 0.0866666666666666) -(0.0217142857142857 0.145333333333333 0.0866666666666666) -(0.0325714285714286 0.145333333333333 0.0866666666666666) -(0.0434285714285714 0.145333333333333 0.0866666666666666) -(0.0542857142857143 0.145333333333333 0.0866666666666666) -(0.0651428571428572 0.145333333333333 0.0866666666666666) -(0.076 0.145333333333333 0.0866666666666666) -(0 0.218 0.0866666666666666) -(0.0108571428571429 0.218 0.0866666666666666) -(0.0217142857142857 0.218 0.0866666666666666) -(0.0325714285714286 0.218 0.0866666666666666) -(0.0434285714285714 0.218 0.0866666666666666) -(0.0542857142857143 0.218 0.0866666666666666) -(0.0651428571428571 0.218 0.0866666666666666) -(0.076 0.218 0.0866666666666666) -(0 0.290666666666667 0.0866666666666666) -(0.0108571428571429 0.290666666666667 0.0866666666666666) -(0.0217142857142857 0.290666666666667 0.0866666666666666) -(0.0325714285714286 0.290666666666667 0.0866666666666666) -(0.0434285714285714 0.290666666666667 0.0866666666666666) -(0.0542857142857143 0.290666666666667 0.0866666666666666) -(0.0651428571428571 0.290666666666667 0.0866666666666667) -(0.076 0.290666666666667 0.0866666666666666) -(0 0.363333333333333 0.0866666666666666) -(0.0108571428571429 0.363333333333333 0.0866666666666666) -(0.0217142857142857 0.363333333333333 0.0866666666666666) -(0.0325714285714286 0.363333333333333 0.0866666666666666) -(0.0434285714285714 0.363333333333333 0.0866666666666666) -(0.0542857142857143 0.363333333333333 0.0866666666666666) -(0.0651428571428571 0.363333333333333 0.0866666666666666) -(0.076 0.363333333333333 0.0866666666666666) -(0 0.436 0.0866666666666666) -(0.0108571428571429 0.436 0.0866666666666666) -(0.0217142857142857 0.436 0.0866666666666666) -(0.0325714285714286 0.436 0.0866666666666666) -(0.0434285714285714 0.436 0.0866666666666666) -(0.0542857142857143 0.436 0.0866666666666666) -(0.0651428571428571 0.436 0.0866666666666666) -(0.076 0.436 0.0866666666666666) -(0 0.508666666666667 0.0866666666666666) -(0.0108571428571429 0.508666666666667 0.0866666666666666) -(0.0217142857142857 0.508666666666667 0.0866666666666666) -(0.0325714285714286 0.508666666666667 0.0866666666666666) -(0.0434285714285714 0.508666666666667 0.0866666666666666) -(0.0542857142857143 0.508666666666667 0.0866666666666666) -(0.0651428571428571 0.508666666666667 0.0866666666666666) -(0.076 0.508666666666667 0.0866666666666666) -(0 0.581333333333333 0.0866666666666666) -(0.0108571428571429 0.581333333333333 0.0866666666666666) -(0.0217142857142857 0.581333333333333 0.0866666666666666) -(0.0325714285714286 0.581333333333333 0.0866666666666666) -(0.0434285714285714 0.581333333333333 0.0866666666666666) -(0.0542857142857143 0.581333333333333 0.0866666666666666) -(0.0651428571428571 0.581333333333333 0.0866666666666666) -(0.076 0.581333333333333 0.0866666666666666) -(0 0.654 0.0866666666666666) -(0.0108571428571429 0.654 0.0866666666666666) -(0.0217142857142857 0.654 0.0866666666666666) -(0.0325714285714286 0.654 0.0866666666666666) -(0.0434285714285714 0.654 0.0866666666666666) -(0.0542857142857143 0.654 0.0866666666666666) -(0.0651428571428572 0.654 0.0866666666666666) -(0.076 0.654 0.0866666666666666) -(0 0.726666666666667 0.0866666666666666) -(0.0108571428571429 0.726666666666667 0.0866666666666666) -(0.0217142857142857 0.726666666666667 0.0866666666666666) -(0.0325714285714286 0.726666666666667 0.0866666666666666) -(0.0434285714285714 0.726666666666667 0.0866666666666666) -(0.0542857142857143 0.726666666666667 0.0866666666666666) -(0.0651428571428572 0.726666666666667 0.0866666666666667) -(0.076 0.726666666666667 0.0866666666666666) -(0 0.799333333333333 0.0866666666666666) -(0.0108571428571429 0.799333333333333 0.0866666666666666) -(0.0217142857142857 0.799333333333333 0.0866666666666666) -(0.0325714285714286 0.799333333333333 0.0866666666666666) -(0.0434285714285714 0.799333333333333 0.0866666666666666) -(0.0542857142857143 0.799333333333333 0.0866666666666666) -(0.0651428571428572 0.799333333333333 0.0866666666666666) -(0.076 0.799333333333333 0.0866666666666666) -(0 0.872 0.0866666666666666) -(0.0108571428571429 0.872 0.0866666666666666) -(0.0217142857142857 0.872 0.0866666666666666) -(0.0325714285714286 0.872 0.0866666666666666) -(0.0434285714285714 0.872 0.0866666666666666) -(0.0542857142857143 0.872 0.0866666666666666) -(0.0651428571428571 0.872 0.0866666666666666) -(0.076 0.872 0.0866666666666666) -(0 0.944666666666667 0.0866666666666666) -(0.0108571428571429 0.944666666666667 0.0866666666666666) -(0.0217142857142857 0.944666666666667 0.0866666666666666) -(0.0325714285714286 0.944666666666667 0.0866666666666666) -(0.0434285714285714 0.944666666666667 0.0866666666666666) -(0.0542857142857143 0.944666666666667 0.0866666666666666) -(0.0651428571428571 0.944666666666667 0.0866666666666666) -(0.076 0.944666666666667 0.0866666666666666) -(0 1.01733333333333 0.0866666666666666) -(0.0108571428571429 1.01733333333333 0.0866666666666666) -(0.0217142857142857 1.01733333333333 0.0866666666666666) -(0.0325714285714286 1.01733333333333 0.0866666666666666) -(0.0434285714285714 1.01733333333333 0.0866666666666666) -(0.0542857142857143 1.01733333333333 0.0866666666666666) -(0.0651428571428571 1.01733333333333 0.0866666666666666) -(0.076 1.01733333333333 0.0866666666666666) -(0 1.09 0.0866666666666666) -(0.0108571428571429 1.09 0.0866666666666666) -(0.0217142857142857 1.09 0.0866666666666666) -(0.0325714285714286 1.09 0.0866666666666666) -(0.0434285714285714 1.09 0.0866666666666666) -(0.0542857142857143 1.09 0.0866666666666666) -(0.0651428571428572 1.09 0.0866666666666666) -(0.076 1.09 0.0866666666666666) -(0 1.16266666666667 0.0866666666666666) -(0.0108571428571429 1.16266666666667 0.0866666666666666) -(0.0217142857142857 1.16266666666667 0.0866666666666666) -(0.0325714285714286 1.16266666666667 0.0866666666666666) -(0.0434285714285714 1.16266666666667 0.0866666666666666) -(0.0542857142857143 1.16266666666667 0.0866666666666666) -(0.0651428571428571 1.16266666666667 0.0866666666666666) -(0.076 1.16266666666667 0.0866666666666666) -(0 1.23533333333333 0.0866666666666666) -(0.0108571428571429 1.23533333333333 0.0866666666666666) -(0.0217142857142857 1.23533333333333 0.0866666666666666) -(0.0325714285714286 1.23533333333333 0.0866666666666666) -(0.0434285714285714 1.23533333333333 0.0866666666666666) -(0.0542857142857143 1.23533333333333 0.0866666666666666) -(0.0651428571428571 1.23533333333333 0.0866666666666666) -(0.076 1.23533333333333 0.0866666666666666) -(0 1.308 0.0866666666666666) -(0.0108571428571429 1.308 0.0866666666666666) -(0.0217142857142857 1.308 0.0866666666666666) -(0.0325714285714286 1.308 0.0866666666666666) -(0.0434285714285714 1.308 0.0866666666666666) -(0.0542857142857143 1.308 0.0866666666666666) -(0.0651428571428571 1.308 0.0866666666666666) -(0.076 1.308 0.0866666666666666) -(0 1.38066666666667 0.0866666666666666) -(0.0108571428571429 1.38066666666667 0.0866666666666666) -(0.0217142857142857 1.38066666666667 0.0866666666666666) -(0.0325714285714286 1.38066666666667 0.0866666666666666) -(0.0434285714285714 1.38066666666667 0.0866666666666666) -(0.0542857142857143 1.38066666666667 0.0866666666666666) -(0.0651428571428572 1.38066666666667 0.0866666666666666) -(0.076 1.38066666666667 0.0866666666666666) -(0 1.45333333333333 0.0866666666666666) -(0.0108571428571429 1.45333333333333 0.0866666666666666) -(0.0217142857142857 1.45333333333333 0.0866666666666666) -(0.0325714285714286 1.45333333333333 0.0866666666666666) -(0.0434285714285714 1.45333333333333 0.0866666666666666) -(0.0542857142857143 1.45333333333333 0.0866666666666666) -(0.0651428571428571 1.45333333333333 0.0866666666666666) -(0.076 1.45333333333333 0.0866666666666666) -(0 1.526 0.0866666666666666) -(0.0108571428571429 1.526 0.0866666666666666) -(0.0217142857142857 1.526 0.0866666666666666) -(0.0325714285714286 1.526 0.0866666666666666) -(0.0434285714285714 1.526 0.0866666666666666) -(0.0542857142857143 1.526 0.0866666666666666) -(0.0651428571428571 1.526 0.0866666666666666) -(0.076 1.526 0.0866666666666666) -(0 1.59866666666667 0.0866666666666666) -(0.0108571428571429 1.59866666666667 0.0866666666666666) -(0.0217142857142857 1.59866666666667 0.0866666666666666) -(0.0325714285714286 1.59866666666667 0.0866666666666666) -(0.0434285714285714 1.59866666666667 0.0866666666666666) -(0.0542857142857143 1.59866666666667 0.0866666666666666) -(0.0651428571428571 1.59866666666667 0.0866666666666666) -(0.076 1.59866666666667 0.0866666666666666) -(0 1.67133333333333 0.0866666666666666) -(0.0108571428571429 1.67133333333333 0.0866666666666666) -(0.0217142857142857 1.67133333333333 0.0866666666666666) -(0.0325714285714286 1.67133333333333 0.0866666666666666) -(0.0434285714285714 1.67133333333333 0.0866666666666666) -(0.0542857142857143 1.67133333333333 0.0866666666666666) -(0.0651428571428571 1.67133333333333 0.0866666666666666) -(0.076 1.67133333333333 0.0866666666666666) -(0 1.744 0.0866666666666666) -(0.0108571428571429 1.744 0.0866666666666666) -(0.0217142857142857 1.744 0.0866666666666666) -(0.0325714285714286 1.744 0.0866666666666666) -(0.0434285714285714 1.744 0.0866666666666666) -(0.0542857142857143 1.744 0.0866666666666666) -(0.0651428571428572 1.744 0.0866666666666667) -(0.076 1.744 0.0866666666666666) -(0 1.81666666666667 0.0866666666666666) -(0.0108571428571429 1.81666666666667 0.0866666666666666) -(0.0217142857142857 1.81666666666667 0.0866666666666666) -(0.0325714285714286 1.81666666666667 0.0866666666666666) -(0.0434285714285714 1.81666666666667 0.0866666666666666) -(0.0542857142857143 1.81666666666667 0.0866666666666666) -(0.0651428571428571 1.81666666666667 0.0866666666666666) -(0.076 1.81666666666667 0.0866666666666666) -(0 1.88933333333333 0.0866666666666666) -(0.0108571428571429 1.88933333333333 0.0866666666666666) -(0.0217142857142857 1.88933333333333 0.0866666666666666) -(0.0325714285714286 1.88933333333333 0.0866666666666666) -(0.0434285714285714 1.88933333333333 0.0866666666666666) -(0.0542857142857143 1.88933333333333 0.0866666666666666) -(0.0651428571428571 1.88933333333333 0.0866666666666666) -(0.076 1.88933333333333 0.0866666666666666) -(0 1.962 0.0866666666666666) -(0.0108571428571429 1.962 0.0866666666666666) -(0.0217142857142857 1.962 0.0866666666666666) -(0.0325714285714286 1.962 0.0866666666666666) -(0.0434285714285714 1.962 0.0866666666666666) -(0.0542857142857143 1.962 0.0866666666666666) -(0.0651428571428571 1.962 0.0866666666666666) -(0.076 1.962 0.0866666666666666) -(0 2.03466666666667 0.0866666666666666) -(0.0108571428571429 2.03466666666667 0.0866666666666666) -(0.0217142857142857 2.03466666666667 0.0866666666666666) -(0.0325714285714286 2.03466666666667 0.0866666666666666) -(0.0434285714285714 2.03466666666667 0.0866666666666666) -(0.0542857142857143 2.03466666666667 0.0866666666666666) -(0.0651428571428572 2.03466666666667 0.0866666666666666) -(0.076 2.03466666666667 0.0866666666666666) -(0 2.10733333333333 0.0866666666666666) -(0.0108571428571429 2.10733333333333 0.0866666666666666) -(0.0217142857142857 2.10733333333333 0.0866666666666666) -(0.0325714285714286 2.10733333333333 0.0866666666666666) -(0.0434285714285714 2.10733333333333 0.0866666666666666) -(0.0542857142857143 2.10733333333333 0.0866666666666666) -(0.0651428571428571 2.10733333333333 0.0866666666666666) -(0.076 2.10733333333333 0.0866666666666666) -(0 2.18 0.0866666666666666) -(0.0108571428571429 2.18 0.0866666666666666) -(0.0217142857142857 2.18 0.0866666666666666) -(0.0325714285714286 2.18 0.0866666666666666) -(0.0434285714285714 2.18 0.0866666666666666) -(0.0542857142857143 2.18 0.0866666666666666) -(0.0651428571428572 2.18 0.0866666666666666) -(0.076 2.18 0.0866666666666666) -(0 0 0.26) -(0.0108571428571429 0 0.26) -(0.0217142857142857 0 0.26) -(0.0325714285714286 0 0.26) -(0.0434285714285714 0 0.26) -(0.0542857142857143 0 0.26) -(0.0651428571428571 0 0.26) -(0.076 0 0.26) -(0 0.0726666666666667 0.26) -(0.0108571428571429 0.0726666666666667 0.26) -(0.0217142857142857 0.0726666666666667 0.26) -(0.0325714285714286 0.0726666666666667 0.26) -(0.0434285714285714 0.0726666666666667 0.26) -(0.0542857142857143 0.0726666666666667 0.26) -(0.0651428571428571 0.0726666666666667 0.26) -(0.076 0.0726666666666667 0.26) -(0 0.145333333333333 0.26) -(0.0108571428571429 0.145333333333333 0.26) -(0.0217142857142857 0.145333333333333 0.26) -(0.0325714285714286 0.145333333333333 0.26) -(0.0434285714285714 0.145333333333333 0.26) -(0.0542857142857143 0.145333333333333 0.26) -(0.0651428571428572 0.145333333333333 0.26) -(0.076 0.145333333333333 0.26) -(0 0.218 0.26) -(0.0108571428571429 0.218 0.26) -(0.0217142857142857 0.218 0.26) -(0.0325714285714286 0.218 0.26) -(0.0434285714285714 0.218 0.26) -(0.0542857142857143 0.218 0.26) -(0.0651428571428571 0.218 0.26) -(0.076 0.218 0.26) -(0 0.290666666666667 0.26) -(0.0108571428571429 0.290666666666667 0.26) -(0.0217142857142857 0.290666666666667 0.26) -(0.0325714285714286 0.290666666666667 0.26) -(0.0434285714285714 0.290666666666667 0.26) -(0.0542857142857143 0.290666666666667 0.26) -(0.0651428571428571 0.290666666666667 0.26) -(0.076 0.290666666666667 0.26) -(0 0.363333333333333 0.26) -(0.0108571428571429 0.363333333333333 0.26) -(0.0217142857142857 0.363333333333333 0.26) -(0.0325714285714286 0.363333333333333 0.26) -(0.0434285714285714 0.363333333333333 0.26) -(0.0542857142857143 0.363333333333333 0.26) -(0.0651428571428571 0.363333333333333 0.26) -(0.076 0.363333333333333 0.26) -(0 0.436 0.26) -(0.0108571428571429 0.436 0.26) -(0.0217142857142857 0.436 0.26) -(0.0325714285714286 0.436 0.26) -(0.0434285714285714 0.436 0.26) -(0.0542857142857143 0.436 0.26) -(0.0651428571428571 0.436 0.26) -(0.076 0.436 0.26) -(0 0.508666666666667 0.26) -(0.0108571428571429 0.508666666666667 0.26) -(0.0217142857142857 0.508666666666667 0.26) -(0.0325714285714286 0.508666666666667 0.26) -(0.0434285714285714 0.508666666666667 0.26) -(0.0542857142857143 0.508666666666667 0.26) -(0.0651428571428571 0.508666666666667 0.26) -(0.076 0.508666666666667 0.26) -(0 0.581333333333333 0.26) -(0.0108571428571429 0.581333333333333 0.26) -(0.0217142857142857 0.581333333333333 0.26) -(0.0325714285714286 0.581333333333333 0.26) -(0.0434285714285714 0.581333333333333 0.26) -(0.0542857142857143 0.581333333333333 0.26) -(0.0651428571428571 0.581333333333333 0.26) -(0.076 0.581333333333333 0.26) -(0 0.654 0.26) -(0.0108571428571429 0.654 0.26) -(0.0217142857142857 0.654 0.26) -(0.0325714285714286 0.654 0.26) -(0.0434285714285714 0.654 0.26) -(0.0542857142857143 0.654 0.26) -(0.0651428571428571 0.654 0.26) -(0.076 0.654 0.26) -(0 0.726666666666667 0.26) -(0.0108571428571429 0.726666666666667 0.26) -(0.0217142857142857 0.726666666666667 0.26) -(0.0325714285714286 0.726666666666667 0.26) -(0.0434285714285714 0.726666666666667 0.26) -(0.0542857142857143 0.726666666666667 0.26) -(0.0651428571428572 0.726666666666667 0.26) -(0.076 0.726666666666667 0.26) -(0 0.799333333333333 0.26) -(0.0108571428571429 0.799333333333333 0.26) -(0.0217142857142857 0.799333333333333 0.26) -(0.0325714285714286 0.799333333333333 0.26) -(0.0434285714285714 0.799333333333333 0.26) -(0.0542857142857143 0.799333333333333 0.26) -(0.0651428571428571 0.799333333333333 0.26) -(0.076 0.799333333333333 0.26) -(0 0.872 0.26) -(0.0108571428571429 0.872 0.26) -(0.0217142857142857 0.872 0.26) -(0.0325714285714286 0.872 0.26) -(0.0434285714285714 0.872 0.26) -(0.0542857142857143 0.872 0.26) -(0.0651428571428571 0.872 0.26) -(0.076 0.872 0.26) -(0 0.944666666666667 0.26) -(0.0108571428571429 0.944666666666667 0.26) -(0.0217142857142857 0.944666666666667 0.26) -(0.0325714285714286 0.944666666666667 0.26) -(0.0434285714285714 0.944666666666667 0.26) -(0.0542857142857143 0.944666666666667 0.26) -(0.0651428571428571 0.944666666666667 0.26) -(0.076 0.944666666666667 0.26) -(0 1.01733333333333 0.26) -(0.0108571428571429 1.01733333333333 0.26) -(0.0217142857142857 1.01733333333333 0.26) -(0.0325714285714286 1.01733333333333 0.26) -(0.0434285714285714 1.01733333333333 0.26) -(0.0542857142857143 1.01733333333333 0.26) -(0.0651428571428571 1.01733333333333 0.26) -(0.076 1.01733333333333 0.26) -(0 1.09 0.26) -(0.0108571428571429 1.09 0.26) -(0.0217142857142857 1.09 0.26) -(0.0325714285714286 1.09 0.26) -(0.0434285714285714 1.09 0.26) -(0.0542857142857143 1.09 0.26) -(0.0651428571428571 1.09 0.26) -(0.076 1.09 0.26) -(0 1.16266666666667 0.26) -(0.0108571428571429 1.16266666666667 0.26) -(0.0217142857142857 1.16266666666667 0.26) -(0.0325714285714286 1.16266666666667 0.26) -(0.0434285714285714 1.16266666666667 0.26) -(0.0542857142857143 1.16266666666667 0.26) -(0.0651428571428571 1.16266666666667 0.26) -(0.076 1.16266666666667 0.26) -(0 1.23533333333333 0.26) -(0.0108571428571429 1.23533333333333 0.26) -(0.0217142857142857 1.23533333333333 0.26) -(0.0325714285714286 1.23533333333333 0.26) -(0.0434285714285714 1.23533333333333 0.26) -(0.0542857142857143 1.23533333333333 0.26) -(0.0651428571428571 1.23533333333333 0.26) -(0.076 1.23533333333333 0.26) -(0 1.308 0.26) -(0.0108571428571429 1.308 0.26) -(0.0217142857142857 1.308 0.26) -(0.0325714285714286 1.308 0.26) -(0.0434285714285714 1.308 0.26) -(0.0542857142857143 1.308 0.26) -(0.0651428571428571 1.308 0.26) -(0.076 1.308 0.26) -(0 1.38066666666667 0.26) -(0.0108571428571429 1.38066666666667 0.26) -(0.0217142857142857 1.38066666666667 0.26) -(0.0325714285714286 1.38066666666667 0.26) -(0.0434285714285714 1.38066666666667 0.26) -(0.0542857142857143 1.38066666666667 0.26) -(0.0651428571428572 1.38066666666667 0.26) -(0.076 1.38066666666667 0.26) -(0 1.45333333333333 0.26) -(0.0108571428571429 1.45333333333333 0.26) -(0.0217142857142857 1.45333333333333 0.26) -(0.0325714285714286 1.45333333333333 0.26) -(0.0434285714285714 1.45333333333333 0.26) -(0.0542857142857143 1.45333333333333 0.26) -(0.0651428571428571 1.45333333333333 0.26) -(0.076 1.45333333333333 0.26) -(0 1.526 0.26) -(0.0108571428571429 1.526 0.26) -(0.0217142857142857 1.526 0.26) -(0.0325714285714286 1.526 0.26) -(0.0434285714285714 1.526 0.26) -(0.0542857142857143 1.526 0.26) -(0.0651428571428571 1.526 0.26) -(0.076 1.526 0.26) -(0 1.59866666666667 0.26) -(0.0108571428571429 1.59866666666667 0.26) -(0.0217142857142857 1.59866666666667 0.26) -(0.0325714285714286 1.59866666666667 0.26) -(0.0434285714285714 1.59866666666667 0.26) -(0.0542857142857143 1.59866666666667 0.26) -(0.0651428571428571 1.59866666666667 0.26) -(0.076 1.59866666666667 0.26) -(0 1.67133333333333 0.26) -(0.0108571428571429 1.67133333333333 0.26) -(0.0217142857142857 1.67133333333333 0.26) -(0.0325714285714286 1.67133333333333 0.26) -(0.0434285714285714 1.67133333333333 0.26) -(0.0542857142857143 1.67133333333333 0.26) -(0.0651428571428571 1.67133333333333 0.26) -(0.076 1.67133333333333 0.26) -(0 1.744 0.26) -(0.0108571428571429 1.744 0.26) -(0.0217142857142857 1.744 0.26) -(0.0325714285714286 1.744 0.26) -(0.0434285714285714 1.744 0.26) -(0.0542857142857143 1.744 0.26) -(0.0651428571428571 1.744 0.26) -(0.076 1.744 0.26) -(0 1.81666666666667 0.26) -(0.0108571428571429 1.81666666666667 0.26) -(0.0217142857142857 1.81666666666667 0.26) -(0.0325714285714286 1.81666666666667 0.26) -(0.0434285714285714 1.81666666666667 0.26) -(0.0542857142857143 1.81666666666667 0.26) -(0.0651428571428571 1.81666666666667 0.26) -(0.076 1.81666666666667 0.26) -(0 1.88933333333333 0.26) -(0.0108571428571429 1.88933333333333 0.26) -(0.0217142857142857 1.88933333333333 0.26) -(0.0325714285714286 1.88933333333333 0.26) -(0.0434285714285714 1.88933333333333 0.26) -(0.0542857142857143 1.88933333333333 0.26) -(0.0651428571428571 1.88933333333333 0.26) -(0.076 1.88933333333333 0.26) -(0 1.962 0.26) -(0.0108571428571429 1.962 0.26) -(0.0217142857142857 1.962 0.26) -(0.0325714285714286 1.962 0.26) -(0.0434285714285714 1.962 0.26) -(0.0542857142857143 1.962 0.26) -(0.0651428571428571 1.962 0.26) -(0.076 1.962 0.26) -(0 2.03466666666667 0.26) -(0.0108571428571429 2.03466666666667 0.26) -(0.0217142857142857 2.03466666666667 0.26) -(0.0325714285714286 2.03466666666667 0.26) -(0.0434285714285714 2.03466666666667 0.26) -(0.0542857142857143 2.03466666666667 0.26) -(0.0651428571428572 2.03466666666667 0.26) -(0.076 2.03466666666667 0.26) -(0 2.10733333333333 0.26) -(0.0108571428571429 2.10733333333333 0.26) -(0.0217142857142857 2.10733333333333 0.26) -(0.0325714285714286 2.10733333333333 0.26) -(0.0434285714285714 2.10733333333333 0.26) -(0.0542857142857143 2.10733333333333 0.26) -(0.0651428571428571 2.10733333333333 0.26) -(0.076 2.10733333333333 0.26) -(0 2.18 0.26) -(0.0108571428571429 2.18 0.26) -(0.0217142857142857 2.18 0.26) -(0.0325714285714286 2.18 0.26) -(0.0434285714285714 2.18 0.26) -(0.0542857142857143 2.18 0.26) -(0.0651428571428571 2.18 0.26) -(0.076 2.18 0.26) -) - - -// ************************************************************************* // diff --git a/test/tests/input_errors/foam_mesh/system/blockMeshDict b/test/tests/input_errors/foam_mesh/system/blockMeshDict deleted file mode 100644 index 6b76c4b7..00000000 --- a/test/tests/input_errors/foam_mesh/system/blockMeshDict +++ /dev/null @@ -1,76 +0,0 @@ -/*--------------------------------*- C++ -*----------------------------------*\ - ========= | - \\ / F ield | OpenFOAM: The Open Source CFD Toolbox - \\ / O peration | Website: https://openfoam.org - \\ / A nd | Version: 10 - \\/ M anipulation | -\*---------------------------------------------------------------------------*/ -FoamFile -{ - format ascii; - class dictionary; - object blockMeshDict; -} -// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // - -convertToMeters 0.001; - -vertices -( - ( 0 0 -260) - (76 0 -260) - (76 2180 -260) - ( 0 2180 -260) - ( 0 0 260) - (76 0 260) - (76 2180 260) - ( 0 2180 260) -); - -blocks -( - hex (0 1 2 3 4 5 6 7) (7 30 3) simpleGrading (1 1 1) -); - -boundary -( - topAndBottom - { - type wall; - faces - ( - (0 1 5 4) - (2 3 7 6) - ); - } - - frontAndBack - { - type wall; - faces - ( - (4 5 6 7) - (3 2 1 0) - ); - } - - hot - { - type wall; - faces - ( - (6 5 1 2) - ); - } - - cold - { - type wall; - faces - ( - (4 7 3 0) - ); - } -); - -// ************************************************************************* // diff --git a/test/tests/input_errors/foam_mesh/system/fvSolution b/test/tests/input_errors/foam_mesh/system/fvSolution deleted file mode 100644 index f94499f3..00000000 --- a/test/tests/input_errors/foam_mesh/system/fvSolution +++ /dev/null @@ -1,72 +0,0 @@ -/*--------------------------------*- C++ -*----------------------------------*\ - ========= | - \\ / F ield | OpenFOAM: The Open Source CFD Toolbox - \\ / O peration | Website: https://openfoam.org - \\ / A nd | Version: 10 - \\/ M anipulation | -\*---------------------------------------------------------------------------*/ -FoamFile -{ - format ascii; - class dictionary; - location "system"; - object fvSolution; -} -// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // - -solvers -{ - p_rgh - { - solver GAMG; - tolerance 1e-7; - relTol 0.01; - - smoother DICGaussSeidel; - - } - - "(U|h|k|epsilon|omega)" - { - solver PBiCGStab; - preconditioner DILU; - tolerance 1e-8; - relTol 0.1; - } -} - -PIMPLE -{ - momentumPredictor no; - nNonOrthogonalCorrectors 0; - pRefCell 0; - pRefValue 0; - - residualControl - { - p_rgh 1e-4; - U 1e-4; - h 1e-4; - - // possibly check turbulence fields - "(k|epsilon|omega)" 1e-3; - } -} - -relaxationFactors -{ - fields - { - rho 1.0; - p_rgh 0.7; - } - equations - { - U 0.3; - h 0.3; - "(k|epsilon|omega)" 0.7; - } -} - - -// ************************************************************************* // diff --git a/test/tests/input_errors/foam_mesh/system/sample b/test/tests/input_errors/foam_mesh/system/sample deleted file mode 100644 index fdfd92cc..00000000 --- a/test/tests/input_errors/foam_mesh/system/sample +++ /dev/null @@ -1,99 +0,0 @@ -/*--------------------------------*- C++ -*----------------------------------*\ - ========= | - \\ / F ield | OpenFOAM: The Open Source CFD Toolbox - \\ / O peration | Website: https://openfoam.org - \\ / A nd | Version: 10 - \\/ M anipulation | -\*---------------------------------------------------------------------------*/ -FoamFile -{ - format ascii; - class dictionary; - location "system"; - object sample; -} - -// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // - -type sets; -libs ("libsampling.so"); - -interpolationScheme cellPointFace; - -setFormat raw; - -sets -( - y0.1 - { - type lineFace; - axis x; - start (-1 0.218 0); - end (1 0.218 0); - } - y0.2 - { - type lineFace; - axis x; - start (-1 0.436 0); - end (1 0.436 0); - } - y0.3 - { - type lineFace; - axis x; - start (-1 0.654 0); - end (1 0.654 0); - } - y0.4 - { - type lineFace; - axis x; - start (-1 0.872 0); - end (1 0.872 0); - } - y0.5 - { - type lineFace; - axis x; - start (-1 1.09 0); - end (1 1.09 0); - } - y0.6 - { - type lineFace; - axis x; - start (-1 1.308 0); - end (1 1.308 0); - } - y0.7 - { - type lineFace; - axis x; - start (-1 1.526 0); - end (1 1.526 0); - } - y0.8 - { - type lineFace; - axis x; - start (-1 1.744 0); - end (1 1.744 0); - } - y0.9 - { - type lineFace; - axis x; - start (-1 1.962 0); - end (1 1.962 0); - } -); - -fields -( - T - U -); - - -// ************************************************************************* // diff --git a/test/tests/input_errors/order_of_foam_t_is_not_constant.i b/test/tests/input_errors/order_of_foam_t_is_not_constant.i deleted file mode 100644 index cc47d773..00000000 --- a/test/tests/input_errors/order_of_foam_t_is_not_constant.i +++ /dev/null @@ -1,39 +0,0 @@ -[Mesh] - type = FoamMesh - case = './foam_mesh' - foam_patch = 'topAndBottom frontAndBack' -[] - -[AuxVariables] - [T] - initial_condition = 111 - family = MONOMIAL - order = CONSTANT - [] - [foam_T] - initial_condition = 999 - family = MONOMIAL - [] - [foam_hf] - initial_condition = 999 - family = MONOMIAL - [] -[] - -[Problem] - type=FoamProblem - temp = T - foam_temp = foam_T - foam_heat_flux = foam_hf -[] - -[Executioner] - type = Transient - start_time = 0 - end_time = 1 - dt = 1 - - [TimeStepper] - type = FoamTimeStepper - [] -[] diff --git a/test/tests/input_errors/same_foam_t_and_hf_variable.i b/test/tests/input_errors/same_foam_t_and_hf_variable.i deleted file mode 100644 index ad9396c2..00000000 --- a/test/tests/input_errors/same_foam_t_and_hf_variable.i +++ /dev/null @@ -1,41 +0,0 @@ -[Mesh] - type = FoamMesh - case = './foam_mesh' - foam_patch = 'topAndBottom frontAndBack' -[] - -[AuxVariables] - [T] - initial_condition = 999 - family = MONOMIAL - order = CONSTANT - [] - [foam_T] - initial_condition = 999 - family = MONOMIAL - order = CONSTANT - [] - [foam_hf] - initial_condition = 999 - family = MONOMIAL - order = CONSTANT - [] -[] - -[Problem] - type=FoamProblem - temp = T - foam_temp = foam_T - foam_heat_flux = foam_T -[] - -[Executioner] - type = Transient - start_time = 0 - end_time = 1 - dt = 1 - - [TimeStepper] - type = FoamTimeStepper - [] -[] diff --git a/test/tests/input_errors/tests b/test/tests/input_errors/tests deleted file mode 100644 index b63b2004..00000000 --- a/test/tests/input_errors/tests +++ /dev/null @@ -1,22 +0,0 @@ -[Tests] - [test] - [same_foam_t_and_hf_variable] - type = RunException - input = same_foam_t_and_hf_variable.i - group = 'input_errors' - expect_err = "cannot refer to the same variable: " - [] - [order_of_foam_t_is_not_constant] - type = RunException - input = order_of_foam_t_is_not_constant.i - group = 'input_errors' - expect_err = "order = CONSTANT" - [] - [order_of_t_is_not_constant] - type = RunException - input = order_of_t_is_not_constant.i - group = 'input_errors' - expect_err = "order = CONSTANT" - [] - [] -[] diff --git a/test/tests/mesh/cube_slice/cube_in/run.i.in b/test/tests/mesh/cube_slice/cube_in/run.i.in index 3787b451..917c8d33 100644 --- a/test/tests/mesh/cube_slice/cube_in/run.i.in +++ b/test/tests/mesh/cube_slice/cube_in/run.i.in @@ -4,20 +4,30 @@ foam_patch = '' dim=2 [] -[Variables] + +[FoamVariables] [T] - initial_condition = 1.0 + type = FoamVariableField + foam_variable = T [] [hf] - initial_condition = 1.0 + type = FoamFunctionObject + foam_variable = wallHeatFlux [] [] + +[FoamBCs] + [T] + type = FoamFixedValueBC + foam_variable = T + v = T + [] +[] + [Problem] type=FoamProblem - temp = T - foam_temp = T - foam_heat_flux = hf [] + [Executioner] type = Transient start_time = 0.0 diff --git a/test/tests/mesh/cube_slice/test_1/run.i b/test/tests/mesh/cube_slice/test_1/run.i index 29fe2eaf..b4197d1a 100644 --- a/test/tests/mesh/cube_slice/test_1/run.i +++ b/test/tests/mesh/cube_slice/test_1/run.i @@ -3,24 +3,27 @@ case = 'foaminput' foam_patch = ' Wall-2 Wall-3 Wall-4 Wall-5' [] -[Variables] +[FoamVariables] [T] - initial_condition = 1.0 - family = MONOMIAL - order = CONSTANT + type = FoamVariableField + foam_variable = T [] [hf] - initial_condition = 1.0 - family = MONOMIAL - order = CONSTANT + type = FoamFunctionObject + foam_variable = wallHeatFlux + [] +[] + +[FoamBCs] + [T] + type = FoamFixedValueBC + foam_variable = T + v = T [] [] [Problem] type = FoamProblem solve = false - temp = T - foam_temp = T - foam_heat_flux = hf [] [Executioner] type = Transient diff --git a/test/tests/mesh/cube_slice/test_10/run.i b/test/tests/mesh/cube_slice/test_10/run.i index dcaf0dfa..9f0bfd5e 100644 --- a/test/tests/mesh/cube_slice/test_10/run.i +++ b/test/tests/mesh/cube_slice/test_10/run.i @@ -3,20 +3,27 @@ case = 'foaminput' foam_patch = ' Wall-0 Wall-3 Wall-5' [] -[Variables] +[FoamVariables] [T] - initial_condition = 1.0 + type = FoamVariableField + foam_variable = T [] [hf] - initial_condition = 1.0 + type = FoamFunctionObject + foam_variable = wallHeatFlux + [] +[] + +[FoamBCs] + [T] + type = FoamFixedValueBC + foam_variable = T + v = T [] [] [Problem] type = FoamProblem solve = false - temp = T - foam_temp = T - foam_heat_flux = hf [] [Executioner] type = Transient diff --git a/test/tests/mesh/cube_slice/test_2/run.i b/test/tests/mesh/cube_slice/test_2/run.i index dcaf0dfa..9f0bfd5e 100644 --- a/test/tests/mesh/cube_slice/test_2/run.i +++ b/test/tests/mesh/cube_slice/test_2/run.i @@ -3,20 +3,27 @@ case = 'foaminput' foam_patch = ' Wall-0 Wall-3 Wall-5' [] -[Variables] +[FoamVariables] [T] - initial_condition = 1.0 + type = FoamVariableField + foam_variable = T [] [hf] - initial_condition = 1.0 + type = FoamFunctionObject + foam_variable = wallHeatFlux + [] +[] + +[FoamBCs] + [T] + type = FoamFixedValueBC + foam_variable = T + v = T [] [] [Problem] type = FoamProblem solve = false - temp = T - foam_temp = T - foam_heat_flux = hf [] [Executioner] type = Transient diff --git a/test/tests/mesh/cube_slice/test_3/run.i b/test/tests/mesh/cube_slice/test_3/run.i index dcaf0dfa..9f0bfd5e 100644 --- a/test/tests/mesh/cube_slice/test_3/run.i +++ b/test/tests/mesh/cube_slice/test_3/run.i @@ -3,20 +3,27 @@ case = 'foaminput' foam_patch = ' Wall-0 Wall-3 Wall-5' [] -[Variables] +[FoamVariables] [T] - initial_condition = 1.0 + type = FoamVariableField + foam_variable = T [] [hf] - initial_condition = 1.0 + type = FoamFunctionObject + foam_variable = wallHeatFlux + [] +[] + +[FoamBCs] + [T] + type = FoamFixedValueBC + foam_variable = T + v = T [] [] [Problem] type = FoamProblem solve = false - temp = T - foam_temp = T - foam_heat_flux = hf [] [Executioner] type = Transient diff --git a/test/tests/mesh/cube_slice/test_4/run.i b/test/tests/mesh/cube_slice/test_4/run.i index b3a99bfc..9a27af2d 100644 --- a/test/tests/mesh/cube_slice/test_4/run.i +++ b/test/tests/mesh/cube_slice/test_4/run.i @@ -3,20 +3,27 @@ case = 'foaminput' foam_patch = ' Wall-2 Wall-4 Wall-5' [] -[Variables] +[FoamVariables] [T] - initial_condition = 1.0 + type = FoamVariableField + foam_variable = T [] [hf] - initial_condition = 1.0 + type = FoamFunctionObject + foam_variable = wallHeatFlux + [] +[] + +[FoamBCs] + [T] + type = FoamFixedValueBC + foam_variable = T + v = T [] [] [Problem] type = FoamProblem solve = false - temp = T - foam_temp = T - foam_heat_flux = hf [] [Executioner] type = Transient diff --git a/test/tests/mesh/cube_slice/test_5/run.i b/test/tests/mesh/cube_slice/test_5/run.i index 2c1cde4a..f1cb8b4b 100644 --- a/test/tests/mesh/cube_slice/test_5/run.i +++ b/test/tests/mesh/cube_slice/test_5/run.i @@ -3,20 +3,27 @@ case = 'foaminput' foam_patch = ' Wall-0 Wall-2 Wall-4' [] -[Variables] +[FoamVariables] [T] - initial_condition = 1.0 + type = FoamVariableField + foam_variable = T [] [hf] - initial_condition = 1.0 + type = FoamFunctionObject + foam_variable = wallHeatFlux + [] +[] + +[FoamBCs] + [T] + type = FoamFixedValueBC + foam_variable = T + v = T [] [] [Problem] type = FoamProblem solve = false - temp = T - foam_temp = T - foam_heat_flux = hf [] [Executioner] type = Transient diff --git a/test/tests/mesh/cube_slice/test_6/run.i b/test/tests/mesh/cube_slice/test_6/run.i index fa18fd49..36d66d5f 100644 --- a/test/tests/mesh/cube_slice/test_6/run.i +++ b/test/tests/mesh/cube_slice/test_6/run.i @@ -3,20 +3,27 @@ case = 'foaminput' foam_patch = ' Wall-3' [] -[Variables] +[FoamVariables] [T] - initial_condition = 1.0 + type = FoamVariableField + foam_variable = T [] [hf] - initial_condition = 1.0 + type = FoamFunctionObject + foam_variable = wallHeatFlux + [] +[] + +[FoamBCs] + [T] + type = FoamFixedValueBC + foam_variable = T + v = T [] [] [Problem] type = FoamProblem solve = false - temp = T - foam_temp = T - foam_heat_flux = hf [] [Executioner] type = Transient diff --git a/test/tests/mesh/cube_slice/test_7/run.i b/test/tests/mesh/cube_slice/test_7/run.i index be142186..898a9700 100644 --- a/test/tests/mesh/cube_slice/test_7/run.i +++ b/test/tests/mesh/cube_slice/test_7/run.i @@ -3,20 +3,27 @@ case = 'foaminput' foam_patch = ' Wall-0 Wall-1 Wall-2 Wall-3 Wall-4 Wall-5' [] -[Variables] +[FoamVariables] [T] - initial_condition = 1.0 + type = FoamVariableField + foam_variable = T [] [hf] - initial_condition = 1.0 + type = FoamFunctionObject + foam_variable = wallHeatFlux + [] +[] + +[FoamBCs] + [T] + type = FoamFixedValueBC + foam_variable = T + v = T [] [] [Problem] type = FoamProblem solve = false - temp = T - foam_temp = T - foam_heat_flux = hf [] [Executioner] type = Transient diff --git a/test/tests/mesh/cube_slice/test_8/run.i b/test/tests/mesh/cube_slice/test_8/run.i index 97c2ed93..5b2440e8 100644 --- a/test/tests/mesh/cube_slice/test_8/run.i +++ b/test/tests/mesh/cube_slice/test_8/run.i @@ -3,20 +3,27 @@ case = 'foaminput' foam_patch = ' Wall-1 Wall-3' [] -[Variables] +[FoamVariables] [T] - initial_condition = 1.0 + type = FoamVariableField + foam_variable = T [] [hf] - initial_condition = 1.0 + type = FoamFunctionObject + foam_variable = wallHeatFlux + [] +[] + +[FoamBCs] + [T] + type = FoamFixedValueBC + foam_variable = T + v = T [] [] [Problem] type = FoamProblem solve = false - temp = T - foam_temp = T - foam_heat_flux = hf [] [Executioner] type = Transient diff --git a/test/tests/mesh/cube_slice/test_9/run.i b/test/tests/mesh/cube_slice/test_9/run.i index a2eb605f..3be58c43 100644 --- a/test/tests/mesh/cube_slice/test_9/run.i +++ b/test/tests/mesh/cube_slice/test_9/run.i @@ -3,20 +3,27 @@ case = 'foaminput' foam_patch = ' Wall-0 Wall-2 Wall-4 Wall-5' [] -[Variables] +[FoamVariables] [T] - initial_condition = 1.0 + type = FoamVariableField + foam_variable = T [] [hf] - initial_condition = 1.0 + type = FoamFunctionObject + foam_variable = wallHeatFlux + [] +[] + +[FoamBCs] + [T] + type = FoamFixedValueBC + foam_variable = T + v = T [] [] [Problem] type = FoamProblem solve = false - temp = T - foam_temp = T - foam_heat_flux = hf [] [Executioner] type = Transient diff --git a/test/tests/mesh/polygonal/fluid-openfoam.i b/test/tests/mesh/polygonal/fluid-openfoam.i index e9dd2518..df47e23e 100644 --- a/test/tests/mesh/polygonal/fluid-openfoam.i +++ b/test/tests/mesh/polygonal/fluid-openfoam.i @@ -12,25 +12,24 @@ [] [] -[AuxVariables] - [fluid_wall_temp] - family = MONOMIAL - order = CONSTANT - initial_condition = 0.075 - [] +[FoamBCs] [solid_heat_flux] - family = MONOMIAL - order = CONSTANT + type = FoamFixedGradientBC + foam_variable = T initial_condition = 0 + diffusivity_coefficient = kappa + [] +[] + +[FoamVariables] + [fluid_wall_temp] + type = FoamVariableField + foam_variable = T [] [] [Problem] type = FoamProblem - # Take the heat flux from MOOSE and set it on the OpenFOAM mesh. - heat_flux = solid_heat_flux - # Take the boundary temperature from OpenFOAM and set it on the MOOSE mesh. - foam_temp = fluid_wall_temp [] [Executioner] diff --git a/test/tests/mesh/quadrilateral/fluid-openfoam.i b/test/tests/mesh/quadrilateral/fluid-openfoam.i index 7b993ab9..30df6206 100644 --- a/test/tests/mesh/quadrilateral/fluid-openfoam.i +++ b/test/tests/mesh/quadrilateral/fluid-openfoam.i @@ -12,25 +12,25 @@ [] [] -[AuxVariables] - [fluid_wall_temp] - family = MONOMIAL - order = CONSTANT - initial_condition = 0.075 - [] + +[FoamBCs] [solid_heat_flux] - family = MONOMIAL - order = CONSTANT + type = FoamFixedGradientBC + foam_variable = T initial_condition = 0 + diffusivity_coefficient = kappa + [] +[] + +[FoamVariables] + [fluid_wall_temp] + type = FoamVariableField + foam_variable = T [] [] [Problem] type = FoamProblem - # Take the heat flux from MOOSE and set it on the OpenFOAM mesh. - heat_flux = solid_heat_flux - # Take the boundary temperature from OpenFOAM and set it on the MOOSE mesh. - foam_temp = fluid_wall_temp [] [Executioner] diff --git a/test/tests/mesh/triangular/fluid-openfoam.i b/test/tests/mesh/triangular/fluid-openfoam.i index 7b993ab9..4af1f206 100644 --- a/test/tests/mesh/triangular/fluid-openfoam.i +++ b/test/tests/mesh/triangular/fluid-openfoam.i @@ -12,25 +12,24 @@ [] [] -[AuxVariables] - [fluid_wall_temp] - family = MONOMIAL - order = CONSTANT - initial_condition = 0.075 - [] +[FoamBCs] [solid_heat_flux] - family = MONOMIAL - order = CONSTANT + type = FoamFixedGradientBC + foam_variable = T initial_condition = 0 + diffusivity_coefficient = kappa + [] +[] + +[FoamVariables] + [fluid_wall_temp] + type = FoamVariableField + foam_variable = T [] [] [Problem] type = FoamProblem - # Take the heat flux from MOOSE and set it on the OpenFOAM mesh. - heat_flux = solid_heat_flux - # Take the boundary temperature from OpenFOAM and set it on the MOOSE mesh. - foam_temp = fluid_wall_temp [] [Executioner] diff --git a/test/tests/multiapps/flow_over_heated_plate/fluid.i b/test/tests/multiapps/flow_over_heated_plate/fluid.i index 9b373fa5..47ab7f00 100644 --- a/test/tests/multiapps/flow_over_heated_plate/fluid.i +++ b/test/tests/multiapps/flow_over_heated_plate/fluid.i @@ -12,25 +12,25 @@ [] [] -[AuxVariables] - [fluid_wall_temp] - family = MONOMIAL - order = CONSTANT - initial_condition = 300 - [] +[FoamBCs] [solid_heat_flux] - family = MONOMIAL - order = CONSTANT + type = FoamFixedGradientBC + foam_variable = T initial_condition = 0 + diffusivity_coefficient = kappa + [] +[] + +[FoamVariables] + [fluid_wall_temp] + type = FoamVariableField + foam_variable = T + initial_condition = 300 [] [] [Problem] type = FoamProblem - # Take the heat flux from MOOSE and set it on the OpenFOAM mesh. - heat_flux = solid_heat_flux - # Take the boundary temperature from OpenFOAM and set it on the MOOSE mesh. - foam_temp = fluid_wall_temp [] [Executioner] diff --git a/test/tests/multiapps/shell_tube_heat_exchanger/README.md b/test/tests/multiapps/shell_tube_heat_exchanger/README.md index 1fc34ab8..99787a74 100644 --- a/test/tests/multiapps/shell_tube_heat_exchanger/README.md +++ b/test/tests/multiapps/shell_tube_heat_exchanger/README.md @@ -1,11 +1,22 @@ # Shell and tube heat exchanger -Here we solve the preCICE [shell and tube heat exchanger](https://precice.org/tutorials-heat-exchanger.html) problem using Hippo. +Here we solve the preCICE [shell and tube heat exchanger](https://precice.org/tutorials-heat-exchanger.html) +problem using Hippo. ![Shell and tube heat exchanger](https://precice.org/images/tutorials-heat-exchanger-visualization.png) -The fluid and solid meshes are copied from the tutorial with the solid mesh already converted to the Exodus II format for MOOSE. The case is run using FFTB (heat flux from fluid to solid, wall temperature from solid to fluid) coupling, meaning the solid is run transient. To speed up convergence, the $c_p$ is decreased initially. +The inner and outer fluid cases have been adapted from the preCICE tutorial +found [here](https://github.com/precice/tutorials/tree/develop/heat-exchanger). +In particular, the mesh tar files, `fluid_inner_mesh.tar.gz` and `fluid_outer_mesh.tar.gz`, +have been downloaded using the `download-meshes.sh` script in that repository, +which is distributed under the LGPL v3.0 license and redistributed here under the +GPL v3.0 license. The solid mesh has already been converted to the Exodus II format +for MOOSE. The case is run using FFTB (heat flux from fluid to solid, wall temperature + from solid to fluid) coupling, meaning the solid is run transient. + To speed up convergence, the $c_p$ is decreased initially. `prep.sh` cleans the case, downloads and decompresses the meshes, and partitions the case. -The regression test runs for 10 seconds, but to get a mostly converged solution, it is recommended that simulation the end time is changed to 500 by modifying `solid.i` and the `controlDict` files in `fluid_inner` and `fluid_outer`. +The regression test runs for 10 seconds, but to get a mostly converged solution, +it is recommended that simulation the end time is changed to 500 by modifying +`solid.i` and the `controlDict` files in `fluid_inner` and `fluid_outer`. diff --git a/test/tests/multiapps/shell_tube_heat_exchanger/fluid_inner_mesh.tar.gz b/test/tests/multiapps/shell_tube_heat_exchanger/fluid_inner_mesh.tar.gz new file mode 100644 index 00000000..143f69f4 Binary files /dev/null and b/test/tests/multiapps/shell_tube_heat_exchanger/fluid_inner_mesh.tar.gz differ diff --git a/test/tests/multiapps/shell_tube_heat_exchanger/fluid_outer_mesh.tar.gz b/test/tests/multiapps/shell_tube_heat_exchanger/fluid_outer_mesh.tar.gz new file mode 100644 index 00000000..25194582 Binary files /dev/null and b/test/tests/multiapps/shell_tube_heat_exchanger/fluid_outer_mesh.tar.gz differ diff --git a/test/tests/multiapps/shell_tube_heat_exchanger/inner.i b/test/tests/multiapps/shell_tube_heat_exchanger/inner.i index 661f105e..fcddf078 100644 --- a/test/tests/multiapps/shell_tube_heat_exchanger/inner.i +++ b/test/tests/multiapps/shell_tube_heat_exchanger/inner.i @@ -12,25 +12,24 @@ [] [] -[AuxVariables] +[FoamBCs] [solid_wall_temp] - family = MONOMIAL - order = CONSTANT + type = FoamFixedValueBC + foam_variable = T initial_condition = 300 [] +[] + +[FoamVariables] [fluid_heat_flux] - family = MONOMIAL - order = CONSTANT - initial_condition = 0 + type = FoamFunctionObject + foam_variable = wallHeatFlux [] [] + [Problem] type = FoamProblem - # Assign heat flux computed in OpenFOAM to a MOOSE variable for imposition as BC in MOOSE. - foam_heat_flux = fluid_heat_flux - # Take the boundary temperature from MOOSE and set it in OpenFOAM. - temp = solid_wall_temp [] [Executioner] diff --git a/test/tests/multiapps/shell_tube_heat_exchanger/outer.i b/test/tests/multiapps/shell_tube_heat_exchanger/outer.i index 93453982..a63d8ac0 100644 --- a/test/tests/multiapps/shell_tube_heat_exchanger/outer.i +++ b/test/tests/multiapps/shell_tube_heat_exchanger/outer.i @@ -12,25 +12,23 @@ [] [] -[AuxVariables] +[FoamBCs] [solid_wall_temp] - family = MONOMIAL - order = CONSTANT + type = FoamFixedValueBC + foam_variable = T initial_condition = 300 [] +[] + +[FoamVariables] [fluid_heat_flux] - family = MONOMIAL - order = CONSTANT - initial_condition = 0 + type = FoamFunctionObject + foam_variable = wallHeatFlux [] [] [Problem] type = FoamProblem - # Assign heat flux computed in OpenFOAM to a MOOSE variable for imposition as BC in MOOSE. - foam_heat_flux = fluid_heat_flux - # Take the boundary temperature from MOOSE and set it in OpenFOAM. - temp = solid_wall_temp [] [Executioner] diff --git a/test/tests/multiapps/shell_tube_heat_exchanger/prep.sh b/test/tests/multiapps/shell_tube_heat_exchanger/prep.sh index 34605454..afafeb9d 100755 --- a/test/tests/multiapps/shell_tube_heat_exchanger/prep.sh +++ b/test/tests/multiapps/shell_tube_heat_exchanger/prep.sh @@ -2,49 +2,21 @@ set -e -u -o pipefail -# Downloads mesh file and check the hash against known reference -downloadMesh() -{ - DIRECTORY=$1 - URL=$2 - HASH=$3 - FILE=${DIRECTORY}_mesh.tar.gz - - if [ ! -f $FILE ]; then - wget -O $FILE -nv ${URL} - fi - - if [ $? -ne 0 ]; then - echo "Download failed" - exit 1 - fi - echo "$HASH $FILE" | sha256sum -c --status - if [ $? -ne 0 ]; then - echo "checksum $HASH failed" - exit 1 - fi - - tar -xvf $FILE - mv polyMesh.org $DIRECTORY/constant/polyMesh - gzip -d -q $DIRECTORY/constant/polyMesh/* -} - foamCleanCase -case fluid_inner foamCleanCase -case fluid_outer -echo "Downloading and extracting the Inner-Fluid mesh..." +echo "Extracting the Inner-Fluid mesh..." -#download file and check hash of files before extracting and decompressing them -inner_mesh_url=https://syncandshare.lrz.de/dl/fiNsYGC1DKzgio4jS5NhsXg7/polyMesh.org.tar.gz -inner_mesh_hash="cb367fb24caf5de07da5610fd01e492995ef040c6f684ed1b5e3f6139dd5a39c" -downloadMesh fluid_inner $inner_mesh_url "$inner_mesh_hash" +tar -xvf fluid_inner_mesh.tar.gz +mv polyMesh.org fluid_inner/constant/polyMesh +gzip -d -q fluid_inner/constant/polyMesh/* -echo "Downloading and extracting the Outer-Fluid mesh..." +echo "Extracting the Outer-Fluid mesh..." # repeat for outer mesh -outer_mesh_url=https://syncandshare.lrz.de/dl/fiEZRQ8rcVWRkoyZvANim1R1/polyMesh.org.tar.gz -outer_mesh_hash="aed51e0f4e198fed716694dc3e74231fdd6a9a10fbac530fb3ff4ac41895cc12" -downloadMesh fluid_outer $outer_mesh_url "$outer_mesh_hash" +tar -xvf fluid_outer_mesh.tar.gz +mv polyMesh.org fluid_outer/constant/polyMesh +gzip -d -q fluid_outer/constant/polyMesh/* #Update boundary types as original mesh is for preCICE tutorial echo "Update boundary type" diff --git a/test/tests/multiapps/simplified_heat_exchanger/fluid-bottom.i b/test/tests/multiapps/simplified_heat_exchanger/fluid-bottom.i index bda57b00..7efc43dd 100644 --- a/test/tests/multiapps/simplified_heat_exchanger/fluid-bottom.i +++ b/test/tests/multiapps/simplified_heat_exchanger/fluid-bottom.i @@ -4,25 +4,24 @@ foam_patch = 'interface' [] -[AuxVariables] - [fluid_wall_temp] - family = MONOMIAL - order = CONSTANT - initial_condition = 310 - [] +[FoamBCs] [solid_heat_flux] - family = MONOMIAL - order = CONSTANT + type = FoamFixedGradientBC + foam_variable = T initial_condition = 0 + diffusivity_coefficient = kappa + [] +[] + +[FoamVariables] + [fluid_wall_temp] + type = FoamVariableField + foam_variable = T [] [] [Problem] type = FoamProblem - # Take the heat flux from MOOSE and set it on the OpenFOAM mesh. - heat_flux = solid_heat_flux - # Take the boundary temperature from OpenFOAM and set it on the MOOSE mesh. - foam_temp = fluid_wall_temp [] [Executioner] diff --git a/test/tests/multiapps/simplified_heat_exchanger/fluid-top.i b/test/tests/multiapps/simplified_heat_exchanger/fluid-top.i index 109f70b9..110c369a 100644 --- a/test/tests/multiapps/simplified_heat_exchanger/fluid-top.i +++ b/test/tests/multiapps/simplified_heat_exchanger/fluid-top.i @@ -4,25 +4,24 @@ foam_patch = 'interface' [] -[AuxVariables] - [fluid_wall_temp] - family = MONOMIAL - order = CONSTANT - initial_condition = 300 - [] +[FoamBCs] [solid_heat_flux] - family = MONOMIAL - order = CONSTANT + type = FoamFixedGradientBC + foam_variable = T initial_condition = 3 + diffusivity_coefficient = kappa + [] +[] + +[FoamVariables] + [fluid_wall_temp] + type = FoamVariableField + foam_variable = T [] [] [Problem] type = FoamProblem - # Take the heat flux from MOOSE and set it on the OpenFOAM mesh. - heat_flux = solid_heat_flux - # Take the boundary temperature from OpenFOAM and set it on the MOOSE mesh. - foam_temp = fluid_wall_temp [] [Executioner] diff --git a/test/tests/multiapps/temperature_set_on_openfoam_boundary/fluid.i b/test/tests/multiapps/temperature_set_on_openfoam_boundary/fluid.i index 298756aa..6c852c96 100644 --- a/test/tests/multiapps/temperature_set_on_openfoam_boundary/fluid.i +++ b/test/tests/multiapps/temperature_set_on_openfoam_boundary/fluid.i @@ -10,29 +10,27 @@ [] [] -[AuxVariables] +[FoamBCs] [T] + type = FoamFixedValueBC + foam_variable = T initial_condition = 111 - family = MONOMIAL - order = CONSTANT [] +[] + +[FoamVariables] [foam_T] - initial_condition = 999 - family = MONOMIAL - order = CONSTANT + type = FoamVariableField + foam_variable = T [] [foam_hf] - initial_condition = -999 - family = MONOMIAL - order = CONSTANT + type = FoamFunctionObject + foam_variable = wallHeatFlux [] [] [Problem] type=FoamProblem - temp = T - foam_temp = foam_T - foam_heat_flux = foam_hf [] [Executioner] diff --git a/test/tests/multiapps/unsteady_heat_conduction_in_infinite_system/fluid-openfoam.i b/test/tests/multiapps/unsteady_heat_conduction_in_infinite_system/fluid-openfoam.i index 7b993ab9..4af1f206 100644 --- a/test/tests/multiapps/unsteady_heat_conduction_in_infinite_system/fluid-openfoam.i +++ b/test/tests/multiapps/unsteady_heat_conduction_in_infinite_system/fluid-openfoam.i @@ -12,25 +12,24 @@ [] [] -[AuxVariables] - [fluid_wall_temp] - family = MONOMIAL - order = CONSTANT - initial_condition = 0.075 - [] +[FoamBCs] [solid_heat_flux] - family = MONOMIAL - order = CONSTANT + type = FoamFixedGradientBC + foam_variable = T initial_condition = 0 + diffusivity_coefficient = kappa + [] +[] + +[FoamVariables] + [fluid_wall_temp] + type = FoamVariableField + foam_variable = T [] [] [Problem] type = FoamProblem - # Take the heat flux from MOOSE and set it on the OpenFOAM mesh. - heat_flux = solid_heat_flux - # Take the boundary temperature from OpenFOAM and set it on the MOOSE mesh. - foam_temp = fluid_wall_temp [] [Executioner] diff --git a/test/tests/problems/foam_problem/copies_values_from_openfoam_boundary/buoyantFoam_par/run.i b/test/tests/problems/foam_problem/copies_values_from_openfoam_boundary/buoyantFoam_par/run.i index 8a8f4efe..3baad5cc 100644 --- a/test/tests/problems/foam_problem/copies_values_from_openfoam_boundary/buoyantFoam_par/run.i +++ b/test/tests/problems/foam_problem/copies_values_from_openfoam_boundary/buoyantFoam_par/run.i @@ -10,29 +10,29 @@ [] [] -[AuxVariables] - [T] - initial_condition = 111 - family = MONOMIAL - order = CONSTANT - [] +[FoamVariables] [foam_T] + type = FoamVariableField + foam_variable = T initial_condition = 999 - family = MONOMIAL - order = CONSTANT [] [foam_hf] + type = FoamFunctionObject + foam_variable = wallHeatFlux initial_condition = -999 - family = MONOMIAL - order = CONSTANT + [] +[] + +[FoamBCs] + [T] + type = FoamFixedValueBC + foam_variable = T + initial_condition = 111 [] [] [Problem] type=FoamProblem - temp = T - foam_temp = foam_T - foam_heat_flux = foam_hf [] [Executioner] diff --git a/test/tests/problems/foam_problem/copies_values_from_openfoam_boundary/buoyantFoam_serial/run.i b/test/tests/problems/foam_problem/copies_values_from_openfoam_boundary/buoyantFoam_serial/run.i index 8a8f4efe..3baad5cc 100644 --- a/test/tests/problems/foam_problem/copies_values_from_openfoam_boundary/buoyantFoam_serial/run.i +++ b/test/tests/problems/foam_problem/copies_values_from_openfoam_boundary/buoyantFoam_serial/run.i @@ -10,29 +10,29 @@ [] [] -[AuxVariables] - [T] - initial_condition = 111 - family = MONOMIAL - order = CONSTANT - [] +[FoamVariables] [foam_T] + type = FoamVariableField + foam_variable = T initial_condition = 999 - family = MONOMIAL - order = CONSTANT [] [foam_hf] + type = FoamFunctionObject + foam_variable = wallHeatFlux initial_condition = -999 - family = MONOMIAL - order = CONSTANT + [] +[] + +[FoamBCs] + [T] + type = FoamFixedValueBC + foam_variable = T + initial_condition = 111 [] [] [Problem] type=FoamProblem - temp = T - foam_temp = foam_T - foam_heat_flux = foam_hf [] [Executioner] diff --git a/test/tests/timesteppers/foam_controlled_tstep_cfl_insert/fluid.i b/test/tests/timesteppers/foam_controlled_tstep_cfl_insert/fluid.i index e725fdc2..28e4449e 100644 --- a/test/tests/timesteppers/foam_controlled_tstep_cfl_insert/fluid.i +++ b/test/tests/timesteppers/foam_controlled_tstep_cfl_insert/fluid.i @@ -10,29 +10,27 @@ [] [] -[AuxVariables] +[FoamBCs] [T] + type = FoamFixedValueBC + foam_variable = T initial_condition = 111 - family = MONOMIAL - order = CONSTANT [] +[] + +[FoamVariables] [foam_T] - initial_condition = 999 - family = MONOMIAL - order = CONSTANT + type = FoamVariableField + foam_variable = T [] [foam_hf] - initial_condition = -999 - family = MONOMIAL - order = CONSTANT + type = FoamFunctionObject + foam_variable = wallHeatFlux [] [] [Problem] type=FoamProblem - temp = T - foam_temp = foam_T - foam_heat_flux = foam_hf [] [Executioner] diff --git a/test/tests/timesteppers/foam_controlled_tstep_insert/fluid.i b/test/tests/timesteppers/foam_controlled_tstep_insert/fluid.i index c2c98d50..40a621ae 100644 --- a/test/tests/timesteppers/foam_controlled_tstep_insert/fluid.i +++ b/test/tests/timesteppers/foam_controlled_tstep_insert/fluid.i @@ -10,29 +10,27 @@ [] [] -[AuxVariables] +[FoamBCs] [T] + type = FoamFixedValueBC + foam_variable = T initial_condition = 111 - family = MONOMIAL - order = CONSTANT [] +[] + +[FoamVariables] [foam_T] - initial_condition = 999 - family = MONOMIAL - order = CONSTANT + type = FoamVariableField + foam_variable = T [] [foam_hf] - initial_condition = -999 - family = MONOMIAL - order = CONSTANT + type = FoamFunctionObject + foam_variable = wallHeatFlux [] [] [Problem] type=FoamProblem - temp = T - foam_temp = foam_T - foam_heat_flux = foam_hf [] [Executioner] diff --git a/test/tests/timesteppers/foam_timestepper_sets_foam_dt/run.i b/test/tests/timesteppers/foam_timestepper_sets_foam_dt/run.i index c16d84fa..5cdd35b7 100644 --- a/test/tests/timesteppers/foam_timestepper_sets_foam_dt/run.i +++ b/test/tests/timesteppers/foam_timestepper_sets_foam_dt/run.i @@ -10,29 +10,27 @@ [] [] -[AuxVariables] +[FoamBCs] [T] + type = FoamFixedValueBC + foam_variable = T initial_condition = 111 - family = MONOMIAL - order = CONSTANT [] +[] + +[FoamVariables] [foam_T] - initial_condition = 999 - family = MONOMIAL - order = CONSTANT + type = FoamVariableField + foam_variable = T [] [foam_hf] - initial_condition = -999 - family = MONOMIAL - order = CONSTANT + type = FoamFunctionObject + foam_variable = wallHeatFlux [] [] [Problem] type=FoamProblem - temp = T - foam_temp = foam_T - foam_heat_flux = foam_hf [] [Executioner] diff --git a/test/tests/input_errors/foam_mesh/0/phi b/test/tests/variables/foam_variable/foam/0/T similarity index 63% rename from test/tests/input_errors/foam_mesh/0/phi rename to test/tests/variables/foam_variable/foam/0/T index 5657a15b..f8312bb2 100644 --- a/test/tests/input_errors/foam_mesh/0/phi +++ b/test/tests/variables/foam_variable/foam/0/T @@ -8,37 +8,47 @@ FoamFile { format ascii; - class surfaceScalarField; + class volScalarField; location "0"; - object phi; + object T; } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // -dimensions [1 0 -1 0 0 0 0]; +dimensions [0 0 0 1 0 0 0]; -internalField uniform 0; +internalField uniform 0.1; boundaryField { - topAndBottom + left { type calculated; - value uniform 0; + value uniform 0.; } - frontAndBack + right { type calculated; - value uniform 0; + value uniform 0.; } - hot + top { type calculated; - value uniform 0; + value uniform 0.; } - cold + bottom { type calculated; - value uniform 0; + value uniform 0.; + } + back + { + type calculated; + value uniform 0.; + } + front + { + type calculated; + value uniform 0.; } } diff --git a/test/tests/variables/foam_variable/foam/constant/physicalProperties b/test/tests/variables/foam_variable/foam/constant/physicalProperties new file mode 100644 index 00000000..96a14c15 --- /dev/null +++ b/test/tests/variables/foam_variable/foam/constant/physicalProperties @@ -0,0 +1,51 @@ +/*--------------------------------*- C++ -*----------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Version: 10 + \\/ M anipulation | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + format ascii; + class dictionary; + location "constant"; + object physicalProperties; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +thermoType +{ + type heSolidThermo; + mixture pureMixture; + transport constIsoSolid; + thermo eConst; + equationOfState rhoConst; + specie specie; + energy sensibleInternalEnergy; +} + +mixture +{ + specie + { + molWeight 1; + } + thermodynamics + { + Cv 1; // Specific heat capacity [J/(kg·K)] + Hf 1; // Heat of formation [J/kg] + Tref 0; + } + transport + { + kappa 1; // Thermal conductivity [W/(m·K)] + } + equationOfState + { + rho 1; // Density [kg/m^3] + } +} + + +// ************************************************************************* // diff --git a/test/tests/variables/foam_variable/foam/system/blockMeshDict b/test/tests/variables/foam_variable/foam/system/blockMeshDict new file mode 100644 index 00000000..face9ea6 --- /dev/null +++ b/test/tests/variables/foam_variable/foam/system/blockMeshDict @@ -0,0 +1,85 @@ +FoamFile +{ + version 2.0; + format ascii; + class dictionary; + object blockMeshDict; +} + +vertices +( + ( 0.0 0.0 0.0 ) + ( 10.0 0.0 0.0 ) + ( 10.0 1.0 0.0 ) + ( 0.0 1.0 0.0 ) + + ( 0.0 0.0 1.0) + ( 10.0 0.0 1.0) + ( 10.0 1.0 1.0) + ( 0.0 1.0 1.0) +); + +blocks +( + hex (0 1 2 3 4 5 6 7) (50 1 1) simpleGrading (25 1 1) +); + +boundary +( + + // interface + left + { + type wall; + faces + ( + (4 7 3 0) + ); + } + + right + { + type wall; + faces + ( + (6 5 1 2) + ); + } + + top + { + type wall; + faces + ( + (2 3 7 6) + ); + } + + front + { + type wall; + faces + ( + (3 2 1 0) + ); + } + + bottom + { + type wall; + faces + ( + (0 1 5 4) + ); + } + + back + { + type wall; + faces + ( + (4 5 6 7) + ); + } + +); diff --git a/test/tests/variables/foam_variable/foam/system/controlDict b/test/tests/variables/foam_variable/foam/system/controlDict new file mode 100644 index 00000000..0383dd23 --- /dev/null +++ b/test/tests/variables/foam_variable/foam/system/controlDict @@ -0,0 +1,44 @@ +/*--------------------------------*- C++ -*----------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Version: 10 + \\/ M anipulation | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + format ascii; + class dictionary; + object controlDict; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +solver transferTestSolver; + +startFrom startTime; + +startTime 0; + +stopAt endTime; + +endTime 0.32; + +deltaT 0.01; + +writeControl timeStep; + +writeInterval 1; + +writeFormat ascii; + +writePrecision 20; + +writeCompression off; + +timeFormat general; + +timePrecision 20; + +runTimeModifiable true; + +// ************************************************************************* // diff --git a/test/tests/variables/foam_variable/foam/system/fvSchemes b/test/tests/variables/foam_variable/foam/system/fvSchemes new file mode 100644 index 00000000..787f3b83 --- /dev/null +++ b/test/tests/variables/foam_variable/foam/system/fvSchemes @@ -0,0 +1,51 @@ +/*--------------------------------*- C++ -*----------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Version: 12 + \\/ M anipulation | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + format ascii; + class dictionary; + object fvSchemes; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +ddtSchemes +{ + default Euler; +} + +gradSchemes +{ + default Gauss linear; +} + +divSchemes +{ + default none; + + div(phi,U) Gauss linear; + div(phi,K) Gauss linear; + div(phi,h) Gauss linear; + div(((rho*nuEff)*dev2(T(grad(U))))) Gauss linear; +} + +laplacianSchemes +{ + default Gauss linear corrected; +} + +interpolationSchemes +{ + default linear; +} + +snGradSchemes +{ + default corrected; +} + +// ************************************************************************* // diff --git a/test/tests/variables/foam_variable/foam/system/fvSolution b/test/tests/variables/foam_variable/foam/system/fvSolution new file mode 100644 index 00000000..61143b21 --- /dev/null +++ b/test/tests/variables/foam_variable/foam/system/fvSolution @@ -0,0 +1,61 @@ +/*--------------------------------*- C++ -*----------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | Website: https://openfoam.org + \\ / A nd | Version: 12 + \\/ M anipulation | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + format ascii; + class dictionary; + object fvSolution; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +solvers +{ + rho + { + solver diagonal; + } + + rhoFinal + { + $rho; + } + + + "(U|h|p_rgh)" + { + solver PBiCGStab; + preconditioner DILU; + tolerance 1e-8; + relTol 1e-8; + } + + "(U|h|p_rgh)Final" + { + $U; + tolerance 1e-8; + relTol 1e-8; + } +} + +PIMPLE +{ + momentumPredictor yes; + pRefCell 0; + pRefValue 0; +} + +relaxationFactors +{ + equations + { + h 1; + U 1; + } +} + +// ************************************************************************* // diff --git a/test/tests/variables/foam_variable/main.i b/test/tests/variables/foam_variable/main.i new file mode 100644 index 00000000..f40c6b10 --- /dev/null +++ b/test/tests/variables/foam_variable/main.i @@ -0,0 +1,46 @@ +[Mesh] + type = FoamMesh + case = 'foam' + foam_patch = 'left right bottom top back front' +[] + +[Variables] + [dummy] + family = MONOMIAL + order = CONSTANT + initial_condition = 999 + [] +[] + +[FoamVariables] + [T_shadow] + type = FoamVariableField + foam_variable = 'T' + [] + [e_shadow] + type = FoamVariableField + foam_variable = 'e' + [] + [whf_shadow] + type = FoamFunctionObject + foam_variable = 'wallHeatFlux' + [] +[] + +[Problem] + type = FoamProblem +[] + +[Executioner] + type = Transient + end_time = 0.32 + [TimeSteppers] + [foam] + type = FoamControlledTimeStepper + [] + [] +[] + +[Outputs] + exodus = true +[] diff --git a/test/tests/variables/foam_variable/test.py b/test/tests/variables/foam_variable/test.py new file mode 100644 index 00000000..0155c86e --- /dev/null +++ b/test/tests/variables/foam_variable/test.py @@ -0,0 +1,50 @@ +"""Tests for shadowing scalar variables and function objects using MOOSE +""" + +import unittest + +import numpy as np + +from read_hippo_data import read_moose_exodus_data, get_exodus_times #pylint: disable=E0401 + +class TestFoamVariableTransfer(unittest.TestCase): + """Test class for shadowing scalar fields in Hippo.""" + def test_variable_transfer(self): + """Test case for shadowing a volScalarField.""" + + times = get_exodus_times("main_out.e")[1:] + for time in times: + coords, temp = read_moose_exodus_data('main_out.e', + time, + variable="T_shadow") + + temp_ref = 0.01 + (coords['x']*coords['y'] + coords['z']*coords['y'] + + coords['z']*coords['x'])*time + temp_diff_max = np.argmax(abs(temp-temp_ref)) + assert np.allclose(temp_ref, temp, rtol=1e-7, atol=1e-12),\ + (f"Max diff ({time}): {abs(temp-temp_ref).max()} " + f"{temp[temp_diff_max]} {temp_ref[temp_diff_max]}") + + def test_wall_heat_flux_transfer(self): + """Test case for shadowing the output of the wallHeatFlux functionObject.""" + times = get_exodus_times("main_out.e")[1:] + for time in times: + coords, whf = read_moose_exodus_data('main_out.e', + time, + variable="whf_shadow") + + sum_ = 0 + whf_ref = np.zeros_like(whf) + for comp in ('x', 'y', 'z'): + low = coords[comp](coords[comp].max()-1e-6) + sum_ += np.sum(low) + np.sum(high) + c = ('y', 'z') if comp == 'x' else ('z', 'x') if comp == 'y' else ('x', 'y') + whf_ref[low] = -time*(coords[c[0]][low] + coords[c[1]][low]) + whf_ref[high] = time*(coords[c[0]][high] + coords[c[1]][high]) + + assert sum_ == whf.size, f"{sum_} {whf.size}" + + whf_diff_max = np.argmax(abs(whf-whf_ref)) + assert np.allclose(whf_ref, whf, rtol=1e-7, atol=1e-12),\ + f"Max diff ({time}): {abs(whf-whf_ref)[whf_diff_max]} {whf[whf_diff_max]}" diff --git a/test/tests/variables/foam_variable/tests b/test/tests/variables/foam_variable/tests new file mode 100644 index 00000000..9ff41bcf --- /dev/null +++ b/test/tests/variables/foam_variable/tests @@ -0,0 +1,19 @@ +[Tests] + [transfer_test] + [setup] + type = RunCommand + command = 'bash -c "foamCleanCase -case foam && blockMesh -case foam"' + [] + [run] + type = RunApp + input = main.i + prereq = transfer_test/setup + allow_warnings = true + [] + [verify] + type = PythonUnitTest + input = test.py + prereq = transfer_test/run + [] + [] +[]