From 335d10245b2067df255746a5c01d3f5dbecf9c5a Mon Sep 17 00:00:00 2001 From: dewenyushu Date: Sun, 25 Oct 2020 16:45:19 -0600 Subject: [PATCH] Add ActivateElementsUserObjectBase, ActivateElementsCoupled, and ActivateElementsByPath classes Add methods in FEProblemBase in support of element activation Add tests Refs. issue #15795 --- .../userobject/ActivateElementsByPath.md | 9 + .../userobject/ActivateElementsCoupled.md | 9 + .../ActivateElementsUserObjectBase.md | 5 + framework/include/problems/FEProblemBase.h | 15 + .../userobject/ActivateElementsByPath.h | 32 ++ .../userobject/ActivateElementsCoupled.h | 31 ++ .../ActivateElementsUserObjectBase.h | 96 ++++ framework/src/problems/FEProblemBase.C | 62 +++ .../src/userobject/ActivateElementsByPath.C | 53 ++ .../src/userobject/ActivateElementsCoupled.C | 64 +++ .../ActivateElementsUserObjectBase.C | 463 ++++++++++++++++++ .../check_element_addition.i | 107 ++++ .../check_element_addition_by_variable.i | 149 ++++++ .../check_initial_condition.i | 129 +++++ .../check_stateful_properties.i | 178 +++++++ ...ck_element_addition_by_variable_out.e-s002 | Bin 0 -> 136620 bytes .../gold/check_element_addition_out.e-s002 | Bin 0 -> 61492 bytes .../gold/check_initial_condition_out.e-s002 | Bin 0 -> 61660 bytes .../gold/check_stateful_properties_out.e-s002 | Bin 0 -> 66800 bytes .../test/tests/additive_manufacturing/tests | 32 ++ 20 files changed, 1434 insertions(+) create mode 100644 framework/doc/content/source/userobject/ActivateElementsByPath.md create mode 100644 framework/doc/content/source/userobject/ActivateElementsCoupled.md create mode 100644 framework/doc/content/source/userobject/ActivateElementsUserObjectBase.md create mode 100644 framework/include/userobject/ActivateElementsByPath.h create mode 100644 framework/include/userobject/ActivateElementsCoupled.h create mode 100644 framework/include/userobject/ActivateElementsUserObjectBase.h create mode 100644 framework/src/userobject/ActivateElementsByPath.C create mode 100644 framework/src/userobject/ActivateElementsCoupled.C create mode 100644 framework/src/userobject/ActivateElementsUserObjectBase.C create mode 100644 modules/combined/test/tests/additive_manufacturing/check_element_addition.i create mode 100644 modules/combined/test/tests/additive_manufacturing/check_element_addition_by_variable.i create mode 100644 modules/combined/test/tests/additive_manufacturing/check_initial_condition.i create mode 100644 modules/combined/test/tests/additive_manufacturing/check_stateful_properties.i create mode 100644 modules/combined/test/tests/additive_manufacturing/gold/check_element_addition_by_variable_out.e-s002 create mode 100644 modules/combined/test/tests/additive_manufacturing/gold/check_element_addition_out.e-s002 create mode 100644 modules/combined/test/tests/additive_manufacturing/gold/check_initial_condition_out.e-s002 create mode 100644 modules/combined/test/tests/additive_manufacturing/gold/check_stateful_properties_out.e-s002 create mode 100644 modules/combined/test/tests/additive_manufacturing/tests diff --git a/framework/doc/content/source/userobject/ActivateElementsByPath.md b/framework/doc/content/source/userobject/ActivateElementsByPath.md new file mode 100644 index 000000000000..df8a6cb19ef1 --- /dev/null +++ b/framework/doc/content/source/userobject/ActivateElementsByPath.md @@ -0,0 +1,9 @@ +# ActivateElementsByPath + +This user object uses the +function path+ as the metric to activate (add) an element by moving the element from an "inactive" subdomain to the "active" subdomain. It uses the user provided points $(x(t), y(t), z(t))$ with components defined by the functions specified by the parameters `function_x`, `function_y`, and `function_z` in the input. An element is activated at time $t_0$ if this element is close (distance < `activate_distance`) to the point $(x(t_0), y(t_0), z(t_0))$. + +!syntax parameters /UserObjects/ActivateElementsByPath + +!syntax inputs /UserObjects/ActivateElementsByPath + +!syntax children /UserObjects/ActivateElementsByPath diff --git a/framework/doc/content/source/userobject/ActivateElementsCoupled.md b/framework/doc/content/source/userobject/ActivateElementsCoupled.md new file mode 100644 index 000000000000..2fcde7e96e8c --- /dev/null +++ b/framework/doc/content/source/userobject/ActivateElementsCoupled.md @@ -0,0 +1,9 @@ +# ActivateElementsCoupled + +This user object uses the +coupled variable value+ as the metric to activate (add) an element by moving the element from an "inactive" subdomain to the "active" subdomain. It uses a coupled variable to decide whether to activate an element. The `coupled_var`, `activate_value` and the `activate_type` needs to be provided in the input to form the activation criterion. By default, the element is activated if the averaged value of the coupled variable in the element is `above` the `activate_value`. User can set `activate_type = 'below'` or `'equal'` to activate element when the averaged coupled variable value is below or equal to the `activate_value`. + +!syntax parameters /UserObjects/ActivateElementsCoupled + +!syntax inputs /UserObjects/ActivateElementsCoupled + +!syntax children /UserObjects/ActivateElementsCoupled diff --git a/framework/doc/content/source/userobject/ActivateElementsUserObjectBase.md b/framework/doc/content/source/userobject/ActivateElementsUserObjectBase.md new file mode 100644 index 000000000000..6161b1e1e93f --- /dev/null +++ b/framework/doc/content/source/userobject/ActivateElementsUserObjectBase.md @@ -0,0 +1,5 @@ +# ActivateElementsUserObjectBase + +The `ActivateElementsUserObjectBase` class is for activating (adding) an element by moving the element from an "inactive" subdomain to the "active" subdomain. There are two metrics for activating an element, i.e., by +function path+ and by +coupled variable value+, which are implemented in the classes [ActivateElementsByPath](/ActivateElementsByPath.md) and [ActivateElementsCoupled](/ActivateElementsCoupled.md), respectively. + +This user object updates the boundary information due to the addition of elements across subdomains. User can save this boundary information by passing the changed boundary name to `expand_boundary_name` in the input block. Note that current implementation does not de-activate an element once the element is activated. diff --git a/framework/include/problems/FEProblemBase.h b/framework/include/problems/FEProblemBase.h index 6f0e22ef57c2..6ef952da48e0 100644 --- a/framework/include/problems/FEProblemBase.h +++ b/framework/include/problems/FEProblemBase.h @@ -694,6 +694,14 @@ class FEProblemBase : public SubProblem, public Restartable void projectSolution(); + /** + * Project initial conditions for custom \p elem_range and \p bnd_node_range + * This is needed when elements/boundary nodes are added to a specific subdomain + * at an intermediate step + */ + void projectInitialConditionOnCustomRange(ConstElemRange & elem_range, + ConstBndNodeRange & bnd_node_range); + // Materials ///// virtual void addMaterial(const std::string & kernel_name, const std::string & name, @@ -1450,6 +1458,13 @@ class FEProblemBase : public SubProblem, public Restartable */ void notifyWhenMeshChanges(MeshChangedInterface * mci); + /** + * Initialize stateful properties for elements in a specific \p elem_range + * This is needed when elements/boundary nodes are added to a specific subdomain + * at an intermediate step + */ + void initElementStatefulProps(const ConstElemRange & elem_range); + /** * Method called to perform a series of sanity checks before a simulation is run. This method * doesn't return when errors are found, instead it generally calls mooseError() directly. diff --git a/framework/include/userobject/ActivateElementsByPath.h b/framework/include/userobject/ActivateElementsByPath.h new file mode 100644 index 000000000000..701433cb4d3b --- /dev/null +++ b/framework/include/userobject/ActivateElementsByPath.h @@ -0,0 +1,32 @@ +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/master/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + +#pragma once + +#include "ActivateElementsUserObjectBase.h" +#include "Function.h" + +class ActivateElementsByPath : public ActivateElementsUserObjectBase +{ +public: + static InputParameters validParams(); + + ActivateElementsByPath(const InputParameters & parameters); + + virtual bool isElementActivated() override; + +protected: + /// path of the heat source, x, y, z components + const Function * _function_x; + const Function * _function_y; + const Function * _function_z; + /// define the distance of the element to the point on the path, + /// below which the element will be activated + const Real _activate_distance; +}; diff --git a/framework/include/userobject/ActivateElementsCoupled.h b/framework/include/userobject/ActivateElementsCoupled.h new file mode 100644 index 000000000000..12391e69e606 --- /dev/null +++ b/framework/include/userobject/ActivateElementsCoupled.h @@ -0,0 +1,31 @@ +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/master/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + +#pragma once + +#include "ActivateElementsUserObjectBase.h" +#include "MooseEnum.h" + +class ActivateElementsCoupled : public ActivateElementsUserObjectBase +{ +public: + static InputParameters validParams(); + + ActivateElementsCoupled(const InputParameters & parameters); + + virtual bool isElementActivated() override; + +protected: + /// variable value to decide wether an element whould be activated + const VariableValue & _coupled_var; + /// variable value to decide wether an element whould be activated + const Real _activate_value; + /// type of activation - blow or above + const enum class ActivateType { BELOW, EQUAL, ABOVE } _activate_type; +}; diff --git a/framework/include/userobject/ActivateElementsUserObjectBase.h b/framework/include/userobject/ActivateElementsUserObjectBase.h new file mode 100644 index 000000000000..211df3436e39 --- /dev/null +++ b/framework/include/userobject/ActivateElementsUserObjectBase.h @@ -0,0 +1,96 @@ +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/master/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + +#pragma once + +#include "ElementUserObject.h" +#include "NonlinearSystemBase.h" +#include "AuxiliarySystem.h" + +class ActivateElementsUserObjectBase : public ElementUserObject +{ +public: + static InputParameters validParams(); + + ActivateElementsUserObjectBase(const InputParameters & parameters); + + const std::set & getNewlyActivatedElements() const { return _newly_activated_elem; }; + + BoundaryID getExpandedBoundaryID() + { + mooseAssert(!_boundary_ids.empty(), "Boundary ID is empty"); + return _boundary_ids[0]; + } + + virtual bool isElementActivated() = 0; + + void initialize() override{}; + void execute() override; + void threadJoin(const UserObject & /*uo*/) override{}; + void finalize() override; + +protected: + void setNewBoundayName(); + + void updateBoundaryInfo(MooseMesh & mesh); + + void push_boundary_side_info( + MooseMesh & mesh, + std::unordered_map>> & + elems_to_push); + + void push_boundary_node_info( + MooseMesh & mesh, + std::unordered_map> & nodes_to_push); + /** + * Initialize solutions for the nodes + */ + void initSolutions(ConstElemRange & elem_range, ConstBndNodeRange & bnd_node_range); + /** + * Returns true if all the connected elements are in the _newly_activated_elem + */ + bool isNewlyActivated(const Node * node); + + void getNodesToRemoveFromBnd(std::set & remove_set, std::set & add_set); + + void insertNodeIdsOnSide(const Elem * ele, + const unsigned short int side, + std::set & node_ids); + + /** + * Get ranges for use with threading. + */ + ConstElemRange * getNewlyActivatedElementRange(); + ConstBndNodeRange * getNewlyActivatedBndNodeRange(); + ConstNodeRange * getNewlyActivatedNodeRange(); + + std::set _newly_activated_elem; + std::set _newly_activated_node; + /** + * Somes nodes are to be removed from the boundary + * when adding/removing sides + */ + std::set _node_to_remove_from_bnd; + + /** + * Ranges for use with threading. + */ + std::unique_ptr _activated_elem_range; + std::unique_ptr _activated_bnd_node_range; + std::unique_ptr _activated_node_range; + + /// activate subdomain ID + const subdomain_id_type _active_subdomain_id; + /// inactivate subdomain ID (the subdomain that you want to keep the same) + const subdomain_id_type _inactive_subdomain_id; + /// expanded boundary name + const std::vector _expand_boundary_name; + /// expanded boundary IDs + std::vector _boundary_ids, _disp_boundary_ids; +}; diff --git a/framework/src/problems/FEProblemBase.C b/framework/src/problems/FEProblemBase.C index b3214ea448ce..70d16f3da587 100644 --- a/framework/src/problems/FEProblemBase.C +++ b/framework/src/problems/FEProblemBase.C @@ -2885,6 +2885,54 @@ FEProblemBase::projectSolution() _aux->solution().localize(*_aux->sys().current_local_solution, _aux->dofMap().get_send_list()); } +void +FEProblemBase::projectInitialConditionOnCustomRange(ConstElemRange & elem_range, + ConstBndNodeRange & bnd_nodes) +{ + ComputeInitialConditionThread cic(*this); + Threads::parallel_reduce(elem_range, cic); + + // Need to close the solution vector here so that boundary ICs take precendence + _nl->solution().close(); + _aux->solution().close(); + + ComputeBoundaryInitialConditionThread cbic(*this); + Threads::parallel_reduce(bnd_nodes, cbic); + + _nl->solution().close(); + _aux->solution().close(); + + // Also, load values into the SCALAR dofs + // Note: We assume that all SCALAR dofs are on the + // processor with highest ID + if (processor_id() == (n_processors() - 1) && _scalar_ics.hasActiveObjects()) + { + const auto & ics = _scalar_ics.getActiveObjects(); + for (const auto & ic : ics) + { + MooseVariableScalar & var = ic->variable(); + var.reinit(); + + DenseVector vals(var.order()); + ic->compute(vals); + + const unsigned int n_SCALAR_dofs = var.dofIndices().size(); + for (unsigned int i = 0; i < n_SCALAR_dofs; i++) + { + const dof_id_type global_index = var.dofIndices()[i]; + var.sys().solution().set(global_index, vals(i)); + var.setValue(i, vals(i)); + } + } + } + + _nl->solution().close(); + _nl->solution().localize(*_nl->system().current_local_solution, _nl->dofMap().get_send_list()); + + _aux->solution().close(); + _aux->solution().localize(*_aux->sys().current_local_solution, _aux->dofMap().get_send_list()); +} + std::shared_ptr FEProblemBase::getMaterial(std::string name, Moose::MaterialDataType type, @@ -6182,6 +6230,20 @@ FEProblemBase::notifyWhenMeshChanges(MeshChangedInterface * mci) _notify_when_mesh_changes.push_back(mci); } +void +FEProblemBase::initElementStatefulProps(const ConstElemRange & elem_range) +{ + ComputeMaterialsObjectThread cmt(*this, + _material_data, + _bnd_material_data, + _neighbor_material_data, + _material_props, + _bnd_material_props, + _neighbor_material_props, + _assembly); + cmt(elem_range, true); +} + void FEProblemBase::checkProblemIntegrity() { diff --git a/framework/src/userobject/ActivateElementsByPath.C b/framework/src/userobject/ActivateElementsByPath.C new file mode 100644 index 000000000000..7132f3234f9e --- /dev/null +++ b/framework/src/userobject/ActivateElementsByPath.C @@ -0,0 +1,53 @@ +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/master/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + +#include "ActivateElementsByPath.h" +#include "libmesh/point.h" + +registerMooseObject("MooseApp", ActivateElementsByPath); + +InputParameters +ActivateElementsByPath::validParams() +{ + InputParameters params = ActivateElementsUserObjectBase::validParams(); + + params.addParam( + "function_x", "0", "The x component of the heating spot travel path"); + params.addParam( + "function_y", "0", "The y component of the heating spot travel path"); + params.addParam( + "function_z", "0", "The z component of the heating spot travel path"); + params.addParam("activate_distance", + 1e-4, + "The maximum distance of the activated element to the point on the path."); + return params; +} + +ActivateElementsByPath::ActivateElementsByPath(const InputParameters & parameters) + : ActivateElementsUserObjectBase(parameters), + _function_x(isParamValid("function_x") ? &getFunction("function_x") : nullptr), + _function_y(isParamValid("function_y") ? &getFunction("function_y") : nullptr), + _function_z(isParamValid("function_z") ? &getFunction("function_z") : nullptr), + _activate_distance( + declareRestartableData("activate_distance", getParam("activate_distance"))) +{ +} + +bool +ActivateElementsByPath::isElementActivated() +{ + // activate center (assume position of the activate center is only time dependent) + const static Point dummy; + Real x_t = _function_x ? _function_x->value(_t, dummy) : 0.0; + Real y_t = _function_y ? _function_y->value(_t, dummy) : 0.0; + Real z_t = _function_z ? _function_z->value(_t, dummy) : 0.0; + + // activate element when element is close to the point + return _current_elem->close_to_point(Point(x_t, y_t, z_t), _activate_distance); +} diff --git a/framework/src/userobject/ActivateElementsCoupled.C b/framework/src/userobject/ActivateElementsCoupled.C new file mode 100644 index 000000000000..95fad4687a2c --- /dev/null +++ b/framework/src/userobject/ActivateElementsCoupled.C @@ -0,0 +1,64 @@ +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/master/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + +#include "ActivateElementsCoupled.h" + +registerMooseObject("MooseApp", ActivateElementsCoupled); + +InputParameters +ActivateElementsCoupled::validParams() +{ + InputParameters params = ActivateElementsUserObjectBase::validParams(); + + params.addRequiredParam("activate_value", "The value above which to activate the element"); + params.addRequiredCoupledVar( + "coupled_var", + "The variable value will be used to decide wether an element whould be activated."); + params.addParam("activate_type", + MooseEnum("below equal above", "above"), + "Activate element when below or above the activate_value"); + return params; +} + +ActivateElementsCoupled::ActivateElementsCoupled(const InputParameters & parameters) + : ActivateElementsUserObjectBase(parameters), + _coupled_var(coupledValue("coupled_var")), + _activate_value( + declareRestartableData("activate_value", getParam("activate_value"))), + _activate_type(getParam("activate_type").getEnum()) +{ +} + +bool +ActivateElementsCoupled::isElementActivated() +{ + bool is_activated = false; + Real avg_val = 0.0; + + for (unsigned int qp = 0; qp < _qrule->n_points(); ++qp) + avg_val += _coupled_var[qp]; + avg_val /= _qrule->n_points(); + + switch (_activate_type) + { + case ActivateType::BELOW: + is_activated = (avg_val < _activate_value); + break; + + case ActivateType::EQUAL: + is_activated = MooseUtils::absoluteFuzzyEqual(avg_val - _activate_value, 0.0); + break; + + case ActivateType::ABOVE: + is_activated = (avg_val > _activate_value); + break; + } + + return is_activated; +} diff --git a/framework/src/userobject/ActivateElementsUserObjectBase.C b/framework/src/userobject/ActivateElementsUserObjectBase.C new file mode 100644 index 000000000000..eaa65b8f7d1c --- /dev/null +++ b/framework/src/userobject/ActivateElementsUserObjectBase.C @@ -0,0 +1,463 @@ +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/master/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + +#include "ActivateElementsUserObjectBase.h" +#include "DisplacedProblem.h" + +#include "libmesh/quadrature.h" +#include "libmesh/parallel_algebra.h" +#include "libmesh/parallel.h" +#include "libmesh/point.h" +#include "libmesh/dof_map.h" + +#include "libmesh/parallel_ghost_sync.h" +#include "libmesh/mesh_communication.h" + +InputParameters +ActivateElementsUserObjectBase::validParams() +{ + InputParameters params = ElementUserObject::validParams(); + params.addClassDescription("Determine activated elements."); + params.addRequiredParam("active_subdomain_id", "The active subdomain ID."); + params.addParam( + "inactive_subdomain_id", + libMesh::invalid_uint, + "The inactivate subdomain ID, i.e., the subdomain that you want to keep the same."); + params.addRequiredParam>("expand_boundary_name", + "The expanded boundary name."); + return params; +} + +ActivateElementsUserObjectBase::ActivateElementsUserObjectBase(const InputParameters & parameters) + : ElementUserObject(parameters), + _active_subdomain_id(declareRestartableData( + "active_subdomain_id", getParam("active_subdomain_id"))), + _inactive_subdomain_id(declareRestartableData( + "inactive_subdomain_id", getParam("inactive_subdomain_id"))), + _expand_boundary_name(getParam>("expand_boundary_name")) +{ + setNewBoundayName(); +} + +void +ActivateElementsUserObjectBase::setNewBoundayName() +{ + mooseAssert(!_expand_boundary_name.empty(), "Expanded boundary name is empty"); + // add the new boundary and get its boundary id + _boundary_ids = _mesh.getBoundaryIDs(_expand_boundary_name, true); + mooseAssert(!_boundary_ids.empty(), "Boundary ID is empty."); + _mesh.setBoundaryName(_boundary_ids[0], _expand_boundary_name[0]); + _mesh.getMesh().get_boundary_info().sideset_name(_boundary_ids[0]) = _expand_boundary_name[0]; + _mesh.getMesh().get_boundary_info().nodeset_name(_boundary_ids[0]) = _expand_boundary_name[0]; + + auto displaced_problem = _fe_problem.getDisplacedProblem(); + if (displaced_problem) + { + _disp_boundary_ids = displaced_problem->mesh().getBoundaryIDs(_expand_boundary_name, true); + mooseAssert(!_disp_boundary_ids.empty(), "Boundary ID in the displaced mesh is empty"); + + displaced_problem->mesh().setBoundaryName(_disp_boundary_ids[0], _expand_boundary_name[0]); + displaced_problem->mesh().getMesh().get_boundary_info().sideset_name(_disp_boundary_ids[0]) = + _expand_boundary_name[0]; + displaced_problem->mesh().getMesh().get_boundary_info().nodeset_name(_disp_boundary_ids[0]) = + _expand_boundary_name[0]; + } +} + +void +ActivateElementsUserObjectBase::execute() +{ + if (isElementActivated() && _current_elem->subdomain_id() != _active_subdomain_id && + _current_elem->subdomain_id() != _inactive_subdomain_id) + { + /* + _current_elem subdomain id is not assignable + create a copy of this element from MooseMesh + */ + dof_id_type ele_id = _current_elem->id(); + Elem * ele = _mesh.elemPtr(ele_id); + + // Add element to the activate subdomain + ele->subdomain_id() = _active_subdomain_id; + + // Reassign element in the reference mesh while using a displaced mesh + auto displaced_problem = _fe_problem.getDisplacedProblem(); + if (displaced_problem) + { + Elem * disp_ele = displaced_problem->mesh().elemPtr(ele_id); + disp_ele->subdomain_id() = _active_subdomain_id; + } + + // Save the newly activated element id and node for updating boundary info later + _newly_activated_elem.insert(ele_id); + for (unsigned int i = 0; i < ele->n_nodes(); ++i) + _newly_activated_node.insert(ele->node_id(i)); + } +} + +void +ActivateElementsUserObjectBase::finalize() +{ + /* + Synchronize ghost element subdomain ID + Note: this needs to be done before updating boundary info because + updating boundary requires the updated element subdomain ids + */ + SyncSubdomainIds sync(_mesh.getMesh()); + Parallel::sync_dofobject_data_by_id(_mesh.getMesh().comm(), + _mesh.getMesh().elements_begin(), + _mesh.getMesh().elements_end(), + sync); + // Update boundary info + updateBoundaryInfo(_mesh); + + // Similarly for the displaced mesh + auto displaced_problem = _fe_problem.getDisplacedProblem(); + if (displaced_problem) + { + SyncSubdomainIds sync_mesh(displaced_problem->mesh().getMesh()); + Parallel::sync_dofobject_data_by_id(displaced_problem->mesh().getMesh().comm(), + displaced_problem->mesh().getMesh().elements_begin(), + displaced_problem->mesh().getMesh().elements_end(), + sync_mesh); + updateBoundaryInfo(displaced_problem->mesh()); + } + + // Reinit equation systems + _fe_problem.meshChanged(); + + // Get storage ranges for the newly activated elements and boundary nodes + ConstElemRange & elem_range = *this->getNewlyActivatedElementRange(); + ConstBndNodeRange & bnd_node_range = *this->getNewlyActivatedBndNodeRange(); + + // Apply initial condition for the newly activated elements + initSolutions(elem_range, bnd_node_range); + + // Initialize stateful material properties for the newly activated elements + _fe_problem.initElementStatefulProps(elem_range); + + // Clear the list + _newly_activated_elem.clear(); + _newly_activated_node.clear(); + + _node_to_remove_from_bnd.clear(); +} + +void +ActivateElementsUserObjectBase::getNodesToRemoveFromBnd(std::set & remove_set, + std::set & add_set) +{ + // get the difference between the remove_set and the add_set, + // save the difference in _node_to_remove_from_bnd + int sz = remove_set.size() + add_set.size(); + std::vector v(sz); + std::vector::iterator it = std::set_difference( + remove_set.begin(), remove_set.end(), add_set.begin(), add_set.end(), v.begin()); + v.resize(it - v.begin()); + _node_to_remove_from_bnd.clear(); + for (auto id : v) + _node_to_remove_from_bnd.insert(id); +} + +void +ActivateElementsUserObjectBase::insertNodeIdsOnSide(const Elem * ele, + const unsigned short int side, + std::set & node_ids) +{ + for (unsigned int i = 0; i < ele->side_ptr(side)->n_nodes(); ++i) + node_ids.insert(ele->side_ptr(side)->node_id(i)); +} + +void +ActivateElementsUserObjectBase::updateBoundaryInfo(MooseMesh & mesh) +{ + // save the removed ghost sides and associated nodes to sync across processors + std::unordered_map>> + ghost_sides_to_remove; + std::unordered_map> ghost_nodes_to_remove; + + // save nodes are added and removed + std::set add_nodes, remove_nodes; + + for (auto ele_id : _newly_activated_elem) + { + Elem * ele = mesh.elemPtr(ele_id); + for (auto s : ele->side_index_range()) + { + Elem * neighbor_ele = ele->neighbor_ptr(s); + if (neighbor_ele == nullptr) + { + // add this side to boundary + mesh.getMesh().get_boundary_info().add_side(ele, s, _boundary_ids[0]); + insertNodeIdsOnSide(ele, s, add_nodes); + } + else + { + if (neighbor_ele->subdomain_id() != _active_subdomain_id && + neighbor_ele->subdomain_id() != _inactive_subdomain_id) + { + // add this side to boundary + mesh.getMesh().get_boundary_info().add_side(ele, s, _boundary_ids[0]); + insertNodeIdsOnSide(ele, s, add_nodes); + } + else + { + // remove this side from the boundary + mesh.getMesh().get_boundary_info().remove_side(ele, s); + insertNodeIdsOnSide(ele, s, remove_nodes); + + // remove the neighbor side from the boundary + unsigned int neighbor_s = neighbor_ele->which_neighbor_am_i(ele); + mesh.getMesh().get_boundary_info().remove_side(neighbor_ele, neighbor_s); + insertNodeIdsOnSide(neighbor_ele, neighbor_s, remove_nodes); + + if (neighbor_ele->processor_id() != this->processor_id()) + ghost_sides_to_remove[neighbor_ele->processor_id()].emplace_back(neighbor_ele->id(), + neighbor_s); + } + } + } + } + // make sure to remove nodes that are not in the add list + getNodesToRemoveFromBnd(remove_nodes, add_nodes); + for (auto node_id : _node_to_remove_from_bnd) + mesh.getMesh().get_boundary_info().remove_node(mesh.nodePtr(node_id), _boundary_ids[0]); + + // synchronize boundary information across processors + push_boundary_side_info(mesh, ghost_sides_to_remove); + push_boundary_node_info(mesh, ghost_nodes_to_remove); + mesh.getMesh().get_boundary_info().parallel_sync_side_ids(); + mesh.getMesh().get_boundary_info().parallel_sync_node_ids(); + mesh.update(); +} + +void +ActivateElementsUserObjectBase::push_boundary_side_info( + MooseMesh & mesh, + std::unordered_map>> & + elems_to_push) +{ + auto elem_action_functor = + [&mesh, this](processor_id_type, + const std::vector> & received_elem) { + // remove the side + for (const auto & pr : received_elem) + mesh.getMesh().get_boundary_info().remove_side( + mesh.getMesh().elem_ptr(pr.first), pr.second, this->getExpandedBoundaryID()); + }; + + Parallel::push_parallel_vector_data( + mesh.getMesh().get_boundary_info().comm(), elems_to_push, elem_action_functor); +} + +void +ActivateElementsUserObjectBase::push_boundary_node_info( + MooseMesh & mesh, + std::unordered_map> & nodes_to_push) +{ + auto node_action_functor = [&mesh, this](processor_id_type, + const std::vector & received_nodes) { + for (const auto & pr : received_nodes) + { + // remove the node + mesh.getMesh().get_boundary_info().remove_node(mesh.getMesh().node_ptr(pr), + this->getExpandedBoundaryID()); + } + }; + + Parallel::push_parallel_vector_data( + mesh.getMesh().get_boundary_info().comm(), nodes_to_push, node_action_functor); +} + +ConstElemRange * +ActivateElementsUserObjectBase::getNewlyActivatedElementRange() +{ + // deletes the object first + _activated_elem_range.reset(); + + // create a vector of the newly activated elements + std::vector elems; + for (auto elem_id : _newly_activated_elem) + elems.push_back(_mesh.elemPtr(elem_id)); + + // Make some fake element iterators defining this vector of + // elements + Elem * const * elempp = const_cast(elems.data()); + Elem * const * elemend = elempp + elems.size(); + + const auto elems_begin = + MeshBase::const_element_iterator(elempp, elemend, Predicates::NotNull()); + + const auto elems_end = + MeshBase::const_element_iterator(elemend, elemend, Predicates::NotNull()); + if (!_activated_elem_range) + _activated_elem_range = libmesh_make_unique(elems_begin, elems_end); + + return _activated_elem_range.get(); +} + +ConstBndNodeRange * +ActivateElementsUserObjectBase::getNewlyActivatedBndNodeRange() +{ + // deletes the object first + _activated_bnd_node_range.reset(); + + // create a vector of the newly activated nodes + std::vector nodes; + std::set set_nodes; + ConstBndNodeRange & bnd_nodes = *_mesh.getBoundaryNodeRange(); + for (auto & bnode : bnd_nodes) + { + dof_id_type bnode_id = bnode->_node->id(); + auto it = _newly_activated_node.find(bnode_id); + if (it != _newly_activated_node.end()) + set_nodes.insert(bnode); + } + + nodes.assign(set_nodes.begin(), set_nodes.end()); + + // Make some fake element iterators defining this vector of + // nodes + BndNode * const * nodepp = const_cast(nodes.data()); + BndNode * const * nodeend = nodepp + nodes.size(); + + const auto nodes_begin = + MooseMesh::const_bnd_node_iterator(nodepp, nodeend, Predicates::NotNull()); + + const auto nodes_end = MooseMesh::const_bnd_node_iterator( + nodeend, nodeend, Predicates::NotNull()); + + if (!_activated_bnd_node_range) + _activated_bnd_node_range = libmesh_make_unique(nodes_begin, nodes_end); + + return _activated_bnd_node_range.get(); +} + +ConstNodeRange * +ActivateElementsUserObjectBase::getNewlyActivatedNodeRange() +{ + // deletes the object first + _activated_node_range.reset(); + + // create a vector of the newly activated nodes + std::vector nodes; + for (auto elem_id : _newly_activated_elem) + { + const Node * const * elem_nodes = _mesh.elemPtr(elem_id)->get_nodes(); + unsigned int n_nodes = _mesh.elemPtr(elem_id)->n_nodes(); + for (unsigned int n = 0; n < n_nodes; ++n) + { + // check if all the elements connected to this node are newly activated + const Node * nd = elem_nodes[n]; + if (isNewlyActivated(nd)) + nodes.push_back(nd); + } + } + + // Make some fake node iterators defining this vector of + // nodes + Node * const * nodepp = const_cast(nodes.data()); + Node * const * nodeend = nodepp + nodes.size(); + + const auto nodes_begin = + MeshBase::const_node_iterator(nodepp, nodeend, Predicates::NotNull()); + + const auto nodes_end = + MeshBase::const_node_iterator(nodeend, nodeend, Predicates::NotNull()); + + if (!_activated_node_range) + _activated_node_range = libmesh_make_unique(nodes_begin, nodes_end); + + return _activated_node_range.get(); +} + +bool +ActivateElementsUserObjectBase::isNewlyActivated(const Node * nd) +{ + const auto & node_to_elem_map = _mesh.nodeToElemMap(); + auto node_to_elem_pair = node_to_elem_map.find(nd->id()); + if (node_to_elem_pair != node_to_elem_map.end()) + { + const std::vector & connected_ele_ids = node_to_elem_pair->second; + for (auto connected_ele_id : connected_ele_ids) + { + // check the connected elements + if (_mesh.elemPtr(connected_ele_id)->subdomain_id() == _inactive_subdomain_id) + return false; + if (_mesh.elemPtr(connected_ele_id)->subdomain_id() == _active_subdomain_id && + std::find(_newly_activated_elem.begin(), _newly_activated_elem.end(), connected_ele_id) == + _newly_activated_elem.end()) + return false; + } + } + return true; +} + +void +ActivateElementsUserObjectBase::initSolutions(ConstElemRange & elem_range, + ConstBndNodeRange & bnd_node_range) +{ + // project initial condition to the current solution + _fe_problem.projectInitialConditionOnCustomRange(elem_range, bnd_node_range); + + NumericVector & current_solution = + *_fe_problem.getNonlinearSystemBase().system().current_local_solution; + NumericVector & old_solution = _fe_problem.getNonlinearSystemBase().solutionOld(); + NumericVector & older_solution = _fe_problem.getNonlinearSystemBase().solutionOlder(); + + NumericVector & current_aux_solution = + *_fe_problem.getAuxiliarySystem().system().current_local_solution; + NumericVector & old_aux_solution = _fe_problem.getAuxiliarySystem().solutionOld(); + NumericVector & older_aux_solution = _fe_problem.getAuxiliarySystem().solutionOlder(); + + DofMap & dof_map = _fe_problem.getNonlinearSystemBase().dofMap(); + DofMap & dof_map_aux = _fe_problem.getAuxiliarySystem().dofMap(); + + std::set dofs, dofs_aux; + // get dofs for the newly added elements + for (auto & elem : elem_range) + { + std::vector di, di_aux; + dof_map.dof_indices(elem, di); + dof_map_aux.dof_indices(elem, di_aux); + for (unsigned int i = 0; i < di.size(); ++i) + dofs.insert(di[i]); + for (unsigned int i = 0; i < di_aux.size(); ++i) + dofs_aux.insert(di_aux[i]); + + di.clear(); + di_aux.clear(); + } + + // update solutions + for (auto dof : dofs) + { + old_solution.set(dof, current_solution(dof)); + older_solution.set(dof, current_solution(dof)); + } + // update aux solutions + for (auto dof_aux : dofs_aux) + { + old_aux_solution.set(dof_aux, current_aux_solution(dof_aux)); + older_aux_solution.set(dof_aux, current_aux_solution(dof_aux)); + } + + dofs.clear(); + dofs_aux.clear(); + + current_solution.close(); + old_solution.close(); + older_solution.close(); + + current_aux_solution.close(); + old_aux_solution.close(); + older_aux_solution.close(); + + _fe_problem.restoreSolutions(); +} diff --git a/modules/combined/test/tests/additive_manufacturing/check_element_addition.i b/modules/combined/test/tests/additive_manufacturing/check_element_addition.i new file mode 100644 index 000000000000..36320dd23086 --- /dev/null +++ b/modules/combined/test/tests/additive_manufacturing/check_element_addition.i @@ -0,0 +1,107 @@ +[Problem] + kernel_coverage_check = false +[] + +[Mesh] + [./gen] + type = GeneratedMeshGenerator + dim = 3 + xmin =0 + xmax =10 + ymin =0 + ymax =10 + zmin =0 + zmax =0.5 + nx=20 + ny=20 + nz=1 + [../] + [./left_domain] + input = gen + type = SubdomainBoundingBoxGenerator + bottom_left = '0 0 0' + top_right = '5 10 0.5' + block_id = 1 + [../] + [./right_domain] + input = left_domain + type = SubdomainBoundingBoxGenerator + bottom_left = '5 0 0' + top_right = '10 10 0.5' + block_id = 2 + [../] + [./sidesets] + input = right_domain + type = SideSetsAroundSubdomainGenerator + normal = '1 0 0' + block = 1 + new_boundary = 'moving_interface' + [] +[] + +[Variables] + [./temp] + block = '1' + [../] +[] + +[Functions] + [./fx] + type = ParsedFunction + value= '5.25' + [../] + [./fy] + type = ParsedFunction + value= '2.5*t' + [../] + [./fz] + type = ParsedFunction + value= '0.25' + [../] +[] + +[Preconditioning] + [./smp] + type = SMP + full = true + [../] +[] + + +[Executioner] + type = Transient + + automatic_scaling = true + + solve_type = 'NEWTON' + + petsc_options_iname = '-pc_type' + petsc_options_value = 'lu' + + line_search = 'none' + + l_max_its = 10 + nl_max_its = 20 + nl_rel_tol = 1e-4 + + start_time = 0.0 + end_time = 1.0 + dt = 1e-1 + dtmin = 1e-4 +[] + +[UserObjects] + [./activated_elem_uo] + type = ActivateElementsByPath + execute_on = timestep_begin + function_x= fx + function_y= fy + function_z= fz + active_subdomain_id = 1 + expand_boundary_name = 'moving_interface' + [../] +[] + +[Outputs] + exodus = true +[] diff --git a/modules/combined/test/tests/additive_manufacturing/check_element_addition_by_variable.i b/modules/combined/test/tests/additive_manufacturing/check_element_addition_by_variable.i new file mode 100644 index 000000000000..f438f05c6ca1 --- /dev/null +++ b/modules/combined/test/tests/additive_manufacturing/check_element_addition_by_variable.i @@ -0,0 +1,149 @@ +[Problem] + kernel_coverage_check = false +[] + +[Mesh] + [./gen] + type = GeneratedMeshGenerator + dim = 3 + xmin =0 + xmax =2.0 + ymin =0 + ymax =2.0 + zmin =0 + zmax =2.0 + nx=10 + ny=10 + nz=10 + [../] + [./left_domain] + input = gen + type = SubdomainBoundingBoxGenerator + bottom_left = '0 0 0' + top_right = '2 2 1' + block_id = 1 + [../] + [./right_domain] + input = left_domain + type = SubdomainBoundingBoxGenerator + bottom_left = '0 0 1' + top_right = '2 2 2' + block_id = 2 + [../] + [./sidesets] + input = right_domain + type = SideSetsAroundSubdomainGenerator + normal = '0 0 1' + block = 1 + new_boundary = 'moving_interface' + [] +[] + +[GlobalParams] + displacements = 'disp_x disp_y disp_z' + block = '1 2' +[] + +[Modules/TensorMechanics/Master] + [./all] + # strain = FINITE + add_variables = true + generate_output = 'stress_zz strain_zz' + block = '1 2' + use_automatic_differentiation = true + [../] +[] + +[Materials] + [./elasticity] + type = ADComputeVariableIsotropicElasticityTensor + poissons_ratio = 0.3 + youngs_modulus = 1e3 + block = '1 2' + [../] + [./stress] + type = ADComputeLinearElasticStress + block = '1 2' + [../] +[] + +[Functions] + [./front_pull] + type = PiecewiseLinear + x = '0 1' + y = '0 1' + scale_factor = 0.5 + [../] + [] + +[BCs] + [./disp_front_pull] + type = ADFunctionDirichletBC + variable = disp_z + boundary = front + function = front_pull + [../] + [./uz_back_fix] + type = ADDirichletBC + variable = disp_z + boundary = back + value = 0.0 + [../] + [./u_yz_fix] + type = ADDirichletBC + variable = disp_x + boundary = left + value = 0.0 + [../] + [./u_xz_fix] + type = ADDirichletBC + variable = disp_y + boundary = bottom + value = 0.0 + [../] +[] + +[Preconditioning] + [./smp] + type = SMP + full = true + [../] +[] + + +[Executioner] + type = Transient + + automatic_scaling = true + + solve_type = 'NEWTON' + + petsc_options_iname = '-pc_type' + petsc_options_value = 'lu' + + line_search = 'none' + + l_max_its = 10 + nl_max_its = 20 + nl_rel_tol = 1e-4 + + start_time = 0.0 + end_time = 1.0 + dt = 1e-1 + dtmin = 1e-4 +[] + +[UserObjects] + [./activated_elem_uo] + type = ActivateElementsCoupled + execute_on = timestep_begin + coupled_var = strain_zz + activate_value = 0.05 + active_subdomain_id = 1 + expand_boundary_name = 'moving_interface' + [../] +[] + +[Outputs] + exodus = true +[] diff --git a/modules/combined/test/tests/additive_manufacturing/check_initial_condition.i b/modules/combined/test/tests/additive_manufacturing/check_initial_condition.i new file mode 100644 index 000000000000..a8d4b0f98f04 --- /dev/null +++ b/modules/combined/test/tests/additive_manufacturing/check_initial_condition.i @@ -0,0 +1,129 @@ +[Problem] + kernel_coverage_check = false +[] + +[Mesh] + [./gen] + type = GeneratedMeshGenerator + dim = 3 + xmin =0 + xmax =10 + ymin =0 + ymax =10 + zmin =0 + zmax =0.5 + nx=20 + ny=20 + nz=1 + [../] + [./left_domain] + input = gen + type = SubdomainBoundingBoxGenerator + bottom_left = '0 0 0' + top_right = '2.5 10 0.5' + block_id = 1 + [../] + [./middle_domain] + input = left_domain + type = SubdomainBoundingBoxGenerator + bottom_left = '2.5 0 0' + top_right = '5 10 0.5' + block_id = 2 + [../] + [./right_domain] + input = middle_domain + type = SubdomainBoundingBoxGenerator + bottom_left = '5 0 0' + top_right = '10 10 0.5' + block_id = 3 + [../] + [./sidesets] + input = right_domain + type = SideSetsAroundSubdomainGenerator + normal = '1 0 0' + block = 2 + new_boundary = 'moving_interface' + [] +[] + +[Variables] + [./temp] + block = '1 2' + [../] +[] + +[ICs] + [./temp_block1] + type = ConstantIC + variable = temp + value = 300 + block = 1 + [../] + [./temp_block2] + type = ConstantIC + variable = temp + value = 1000 + block = 2 + [../] +[] + +[Functions] + [./fx] + type = ParsedFunction + value= '5.25' + [../] + [./fy] + type = ParsedFunction + value= '2.5*t' + [../] + [./fz] + type = ParsedFunction + value= '0.25' + [../] +[] + +[Preconditioning] + [./smp] + type = SMP + full = true + [../] +[] + + +[Executioner] + type = Transient + + automatic_scaling = true + + solve_type = 'NEWTON' + + petsc_options_iname = '-pc_type' + petsc_options_value = 'lu' + + line_search = 'none' + + l_max_its = 10 + nl_max_its = 20 + nl_rel_tol = 1e-4 + + start_time = 0.0 + end_time = 1.0 + dt = 1e-1 + dtmin = 1e-4 +[] + +[UserObjects] + [./activated_elem_uo] + type = ActivateElementsByPath + execute_on = timestep_begin + function_x= fx + function_y= fy + function_z= fz + active_subdomain_id = 2 + expand_boundary_name = 'moving_interface' + [../] +[] + +[Outputs] + exodus = true +[] diff --git a/modules/combined/test/tests/additive_manufacturing/check_stateful_properties.i b/modules/combined/test/tests/additive_manufacturing/check_stateful_properties.i new file mode 100644 index 000000000000..84273dc0d342 --- /dev/null +++ b/modules/combined/test/tests/additive_manufacturing/check_stateful_properties.i @@ -0,0 +1,178 @@ +[Problem] + kernel_coverage_check = false + material_coverage_check = false +[] + +[Mesh] + [./gen] + type = GeneratedMeshGenerator + dim = 3 + xmin =0 + xmax =10 + ymin =0 + ymax =10 + zmin =0 + zmax =0.5 + nx=20 + ny=20 + nz=1 + [../] + [./left_domain] + input = gen + type = SubdomainBoundingBoxGenerator + bottom_left = '0 0 0' + top_right = '5 10 0.5' + block_id = 1 + [../] + [./right_domain] + input = left_domain + type = SubdomainBoundingBoxGenerator + bottom_left = '5 0 0' + top_right = '10 10 0.5' + block_id = 2 + [../] + [./sidesets] + input = right_domain + type = SideSetsAroundSubdomainGenerator + normal = '1 0 0' + block = 1 + new_boundary = 'moving_interface' + [] +[] + +[Variables] + [./temp] + initial_condition = 300 + block = '1' + [../] +[] + +# Output aux variables to check if stateful properties +# are initialized properly for newly added elements +[AuxVariables] + [./density_aux] + order = CONSTANT + family = MONOMIAL + block = '1' + [../] + [./specific_heat_aux] + order = CONSTANT + family = MONOMIAL + block = '1' + [../] + [./thermal_conductivity_aux] + order = CONSTANT + family = MONOMIAL + block = '1' + [../] +[] + +[Kernels] + [./null] + type = NullKernel + variable = temp + jacobian_fill = 1e-5 + [../] +[] + +[AuxKernels] + [./density] + type = ADMaterialRealAux + property = density + variable = density_aux + block = 1 + [] + [./specific_heat] + type = ADMaterialRealAux + property = specific_heat + variable = specific_heat_aux + block = 1 + [] + [./thermal_conductivity] + type = ADMaterialRealAux + property = thermal_conductivity + variable = thermal_conductivity_aux + block = 1 + [] +[] + +[Functions] + [./fx] + type = ParsedFunction + value= '5.25' + [../] + [./fy] + type = ParsedFunction + value= '2.5*t' + [../] + [./fz] + type = ParsedFunction + value= '0.25' + [../] +[] + +[Materials] + [./density] + type = ADDensity + density = 4.43e-6 + block = '1' + [../] + [./heat] + type = ADHeatConductionMaterial + specific_heat = 600 + thermal_conductivity = 10e-3 + block = '1' + [../] + [./volumetric_heat] + type = ADGenericConstantMaterial + prop_names = 'volumetric_heat' + prop_values = 100 + block = '1' + [../] +[] + +[Preconditioning] + [./smp] + type = SMP + full = true + [../] +[] + + +[Executioner] + type = Transient + + automatic_scaling = true + + solve_type = 'NEWTON' + + petsc_options_iname = '-pc_type' + petsc_options_value = 'lu' + + line_search = 'none' + + l_max_its = 10 + nl_max_its = 20 + nl_rel_tol = 1e-4 + + start_time = 0.0 + end_time = 1.0 + dt = 1e-1 + dtmin = 1e-4 +[] + +[UserObjects] + [./activated_elem_uo] + type = ActivateElementsByPath + execute_on = timestep_begin + function_x= fx + function_y= fy + function_z= fz + active_subdomain_id = 1 + expand_boundary_name = 'moving_interface' + [../] +[] + +[Outputs] + exodus = true +[] diff --git a/modules/combined/test/tests/additive_manufacturing/gold/check_element_addition_by_variable_out.e-s002 b/modules/combined/test/tests/additive_manufacturing/gold/check_element_addition_by_variable_out.e-s002 new file mode 100644 index 0000000000000000000000000000000000000000..9d128d1d52ac4264f79b1e392ecf0b5861ec52a9 GIT binary patch literal 136620 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 Gmj4F=r&WFc literal 0 HcmV?d00001 diff --git a/modules/combined/test/tests/additive_manufacturing/tests b/modules/combined/test/tests/additive_manufacturing/tests new file mode 100644 index 000000000000..831f393fc470 --- /dev/null +++ b/modules/combined/test/tests/additive_manufacturing/tests @@ -0,0 +1,32 @@ +[Tests] + issues = '#15795' + design = 'ActivateElementsUserObjectBase.md ActivateElementsByPath.md ActivateElementsCoupled.md' + [./check_element_addition] + type = 'Exodiff' + input = 'check_element_addition.i' + exodiff = 'check_element_addition_out.e-s002' + cli_args = "Executioner/end_time=0.5 Outputs/interval=5" + requirement = 'The subdomain 1 should be expanded while subdomain 2 should be contracted via ActivateElementsUserObject. The addition of elements is controlled by a function path.' + [../] + [./check_element_addition_by_variable] + type = 'Exodiff' + input = 'check_element_addition_by_variable.i' + exodiff = 'check_element_addition_by_variable_out.e-s002' + cli_args = "Executioner/end_time=0.5 Outputs/interval=5" + requirement = 'The subdomain 1 should be expanded via ActivateElementsUserObject. The addition of elements is controlled by a coupled variable strain_zz.' + [../] + [./check_stateful_properties] + type = 'Exodiff' + input = 'check_stateful_properties.i' + exodiff = 'check_stateful_properties_out.e-s002' + cli_args = "Executioner/end_time=0.5 Outputs/interval=5" + requirement = 'The newly activated elements should have the stateful material properties for heat conduction as specified in the input.' + [../] + [./check_initial_condition] + type = 'Exodiff' + input = 'check_initial_condition.i' + exodiff = 'check_initial_condition_out.e-s002' + cli_args = "Executioner/end_time=0.5 Outputs/interval=5" + requirement = 'The newly activated elements should have the IC of variables as specified in the input.' + [../] +[]