Classifies mesh elements into inside, outside, and optionally intercepted subdomains based on an analytical signed distance function expression. More...

#include <SubdomainInterceptedGenerator.h>

Inheritance diagram for SubdomainInterceptedGenerator:

[legend]

Public Types
typedef DataFileName	DataFileParameterType

typedef GenericSymFunction< is_ad >	SymFunction

typedef std::shared_ptr< SymFunction >	SymFunctionPtr

Public Member Functions
	SubdomainInterceptedGenerator (const InputParameters &parameters)

std::unique_ptr< libMesh::MeshBase >	generate () override

std::unique_ptr< CSG::CSGBase >	generateInternalCSG ()

std::unique_ptr< MeshBase >	generateInternal ()

const std::set< MeshGeneratorName > &	getRequestedMeshGenerators () const

const std::set< MeshGeneratorName > &	getRequestedMeshGeneratorsForSub () const

void	addParentMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)

void	addChildMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)

const std::set< const MeshGenerator *, Comparator > &	getParentMeshGenerators () const

const std::set< const MeshGenerator *, Comparator > &	getChildMeshGenerators () const

const std::set< const MeshGenerator *, Comparator > &	getSubMeshGenerators () const

bool	isParentMeshGenerator (const MeshGeneratorName &name, const bool direct=true) const

bool	isChildMeshGenerator (const MeshGeneratorName &name, const bool direct=true) const

bool	isNullMeshName (const MeshGeneratorName &name) const

bool	hasSaveMesh () const

bool	hasOutput () const

const std::string &	getSavedMeshName () const

bool	hasGenerateData () const

bool	hasGenerateCSG () const

bool	isDataOnly () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &name) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const

void	mooseError (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecatedNoTrace (Args &&... args) const

void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

void	setParserFeatureFlags (SymFunctionPtr &) const

Static Public Member Functions
static InputParameters	validParams ()

static bool	hasGenerateData (const InputParameters &params)

static bool	hasGenerateCSG (const InputParameters &params)

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

static void	setHasGenerateData (InputParameters &params)

static void	setHasGenerateCSG (InputParameters &params)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	data_only_param

static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Types
enum	FailureMethod

Protected Member Functions
	usingFunctionParserUtilsMembers (false)

virtual void	generateData ()

virtual std::unique_ptr< CSG::CSGBase >	generateCSG ()

T &	copyMeshProperty (const std::string &target_data_name, const std::string &source_data_name, const std::string &source_mesh)

T &	copyMeshProperty (const std::string &source_data_name, const std::string &source_mesh)

std::unique_ptr< MeshBase > &	getMesh (const std::string &param_name, const bool allow_invalid=false)

std::vector< std::unique_ptr< MeshBase > * >	getMeshes (const std::string &param_name)

std::unique_ptr< MeshBase > &	getMeshByName (const MeshGeneratorName &mesh_generator_name)

std::vector< std::unique_ptr< MeshBase > * >	getMeshesByName (const std::vector< MeshGeneratorName > &mesh_generator_names)

std::unique_ptr< CSG::CSGBase > &	getCSGBase (const std::string &param_name)

std::unique_ptr< CSG::CSGBase > &	getCSGBaseByName (const MeshGeneratorName &mesh_generator_name)

std::vector< std::unique_ptr< CSG::CSGBase > * >	getCSGBases (const std::string &param_name)

std::vector< std::unique_ptr< CSG::CSGBase > * >	getCSGBasesByName (const std::vector< MeshGeneratorName > &mesh_generator_names)

void	declareMeshForSub (const std::string &param_name)

void	declareMeshesForSub (const std::string &param_name)

void	declareMeshForSubByName (const MeshGeneratorName &mesh_generator_name)

void	declareMeshesForSubByName (const std::vector< MeshGeneratorName > &mesh_generator_names)

std::unique_ptr< MeshBase >	buildMeshBaseObject (unsigned int dim=libMesh::invalid_uint)

std::unique_ptr< ReplicatedMesh >	buildReplicatedMesh (unsigned int dim=libMesh::invalid_uint)

std::unique_ptr< DistributedMesh >	buildDistributedMesh (unsigned int dim=libMesh::invalid_uint)

void	addMeshSubgenerator (const std::string &type, const std::string &name, Ts... extra_input_parameters)

void	addMeshSubgenerator (const std::string &type, const std::string &name, InputParameters params)

void	declareNullMeshName (const MeshGeneratorName &name)

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)

const T &	getMeshProperty (const std::string &data_name)

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name) const

bool	hasMeshProperty (const std::string &data_name) const

std::string	meshPropertyName (const std::string &data_name) const

T &	declareMeshProperty (const std::string &data_name, Args &&... args)

T &	declareMeshProperty (const std::string &data_name, const T &data_value)

T &	declareMeshProperty (const std::string &data_name, Args &&... args)

T &	declareMeshProperty (const std::string &data_name, const T &data_value)

T &	setMeshProperty (const std::string &data_name, Args &&... args)

T &	setMeshProperty (const std::string &data_name, const T &data_value)

T &	setMeshProperty (const std::string &data_name, Args &&... args)

T &	setMeshProperty (const std::string &data_name, const T &data_value)

GenericReal< is_ad >	evaluate (SymFunctionPtr &, const std::string &object_name="")

GenericReal< is_ad >	evaluate (SymFunctionPtr &, const std::vector< GenericReal< is_ad > > &, const std::string &object_name="")

void	addFParserConstants (SymFunctionPtr &parser, const std::vector< std::string > &constant_names, const std::vector< std::string > &constant_expressions) const

virtual void	functionsOptimize (SymFunctionPtr &parsed_function)

void	functionsOptimize (SymFunctionPtr &parsed_function)

void	functionsOptimize (SymFunctionPtr &parsed_function)

void	parsedFunctionSetup (SymFunctionPtr &function, const std::string &expression, const std::string &variables, const std::vector< std::string > &constant_names, const std::vector< std::string > &constant_expressions, const libMesh::Parallel::Communicator &comm) const

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
SymFunctionPtr	_parsed_function
	Parsed function.

SubdomainID	_subdomain_id_inside
	Subdomain ID assigned to elements categorized inside the domain.

SubdomainID	_subdomain_id_outside
	Subdomain ID assigned to elements categorized outside the domain.

Real	_threshold
	Level-set threshold value defining the interface boundary.

bool	_is_domain_inside_surface
	Whether the inside domain corresponds to the negative signed distance region (< threshold)

bool	_multi_geo
	Whether multi-geometry handling is enabled to skip previously assigned elements.

bool	_keep_inside_as_inside
	If multi_geo is true, whether to keep elements already matching subdomain_id_inside.

bool	_keep_outside_as_outside
	If multi_geo is true, whether to keep elements already matching subdomain_id_outside.

bool	_modify_outside_only
	If true, only modify outside elements; inside elements retain their existing subdomain IDs.

bool	_modify_inside_only
	If true, only modify inside elements; outside elements retain their existing subdomain IDs.

std::unique_ptr< libMesh::MeshBase > &	_input
	The input mesh to modify.

MooseMesh *const	_mesh

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

const Parallel::Communicator &	_communicator

const Real	_lambda
	Threshold applied to the fraction outside the retained domain for a partial element.

const Order	_qrule_order
	Quadrature order used to estimate the retained-domain fraction.

const SBMUtils::InterceptedSubdomainPolicy	_intercepted_subdomain_policy
	Policy for assigning partial elements to a dedicated intercepted subdomain.

enum FunctionParserUtils::FailureMethod	_evalerror_behavior

const Real	_quiet_nan

std::vector< GenericReal< is_ad > >	_func_params

const Real	_epsilon

bool	_enable_jit

bool	_enable_ad_cache

bool	_disable_fpoptimizer

bool	_enable_auto_optimize

Static Protected Attributes
static const char *	_eval_error_msg []

Private Member Functions
virtual std::string	meshPropertyPrefix (const std::string &) const override final

void	checkGetMesh (const MeshGeneratorName &mesh_generator_name, const std::string &param_name) const

const MeshGeneratorName *	getMeshGeneratorNameFromParam (const std::string &param_name, const bool allow_invalid) const

const std::vector< MeshGeneratorName > &	getMeshGeneratorNamesFromParam (const std::string &param_name) const

RestartableDataValue &	setMeshPropertyHelper (const std::string &data_name)

const RestartableDataValue &	getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const

void	mooseErrorInternal (Args &&... args) const

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

Private Attributes
std::set< MeshGeneratorName >	_requested_mesh_generators

std::set< MeshGeneratorName >	_requested_mesh_generators_for_sub

std::vector< std::pair< std::string, std::unique_ptr< MeshBase > * > >	_requested_meshes

std::vector< std::pair< std::string, std::unique_ptr< CSG::CSGBase > * > >	_requested_csg_bases

std::unique_ptr< MeshBase >	_null_mesh

std::unique_ptr< CSG::CSGBase >	_null_csg_base

std::set< const MeshGenerator *, Comparator >	_parent_mesh_generators

std::set< const MeshGenerator *, Comparator >	_child_mesh_generators

std::set< const MeshGenerator *, Comparator >	_sub_mesh_generators

std::set< std::string >	_null_mesh_names

const std::string &	_save_with_name

const bool	_data_only

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

Detailed Description

Classifies mesh elements into inside, outside, and optionally intercepted subdomains based on an analytical signed distance function expression.

Definition at line 19 of file SubdomainInterceptedGenerator.h.

Constructor & Destructor Documentation

◆ SubdomainInterceptedGenerator()

SubdomainInterceptedGenerator::SubdomainInterceptedGenerator ( const InputParameters & parameters )

Definition at line 73 of file SubdomainInterceptedGenerator.C.

  : SBMSubdomainGeneratorBase(parameters),
    FunctionParserUtils<false>(parameters),
    _parsed_function(std::make_shared<SymFunction>()),
    _subdomain_id_inside(getParam<SubdomainID>("subdomain_id_inside")),
    _subdomain_id_outside(getParam<SubdomainID>("subdomain_id_outside")),
    _threshold(getParam<Real>("threshold")),
    _is_domain_inside_surface(getParam<bool>("is_domain_inside_surface")),
    _multi_geo(getParam<bool>("multi_geo")),
    _keep_inside_as_inside(getParam<bool>("keep_inside_as_inside")),
    _keep_outside_as_outside(getParam<bool>("keep_outside_as_outside")),
    _modify_outside_only(getParam<bool>("modify_outside_only")),
    _modify_inside_only(getParam<bool>("modify_inside_only"))
{
  setParserFeatureFlags(_parsed_function);
 
  if (_parsed_function->Parse(getParam<std::string>("signed_dist_function"), "x,y,z") >= 0)
    mooseError("Invalid function expression provided.");
 
  _func_params.resize(3);
}

Member Function Documentation

◆ generate()

std::unique_ptr< libMesh::MeshBase > SubdomainInterceptedGenerator::generate ( )

overridevirtual

Implements MeshGenerator.

Definition at line 96 of file SubdomainInterceptedGenerator.C.

{
  // Take ownership of the input mesh (already cloned by getMesh()).
  std::unique_ptr<libMesh::MeshBase> mesh = std::move(_input);
 
  for (const auto & elem : mesh->active_element_ptr_range() /*gen only run rank = 0*/)
  {
    // Skip elements that have already been explicitly assigned by a
    //       previous geometry in a multi-geometry workflow.
    if (_multi_geo)
    {
      if (elem->subdomain_id() == _subdomain_id_inside && _keep_inside_as_inside)
        continue;
      else if (elem->subdomain_id() == _subdomain_id_outside && _keep_outside_as_outside)
        continue;
    }
 
    const auto outside_id = (_modify_inside_only) ? elem->subdomain_id() : _subdomain_id_outside;
    const auto inside_id = (_modify_outside_only) ? elem->subdomain_id() : _subdomain_id_inside;
 
    const auto is_in_domain = [&](const Point & point)
    {
      _func_params = {point(0), point(1), point(2)};
      const Real phi = evaluate(_parsed_function);
      return (_is_domain_inside_surface && phi < _threshold) ||
             (!_is_domain_inside_surface && phi > _threshold);
    };
 
    const auto is_outside_domain = [&](const Point & point)
    {
      _func_params = {point(0), point(1), point(2)};
      const Real phi = evaluate(_parsed_function);
      return (_is_domain_inside_surface && phi > _threshold) ||
             (!_is_domain_inside_surface && phi < _threshold);
    };
 
    // Calculate the element occupancy at nodes and quadrature points according to the domain
    // policy.
    const auto occupancy =
        SBMUtils::elementDomainOccupancy(*elem, _qrule_order, is_in_domain, is_outside_domain);
 
    // The subdomain IDs to assign for inside, outside, and intercepted elements.
    const SBMUtils::ClassificationSubdomains subdomain_id_settings{
        inside_id, outside_id, _intercepted_subdomain_policy.subdomain_id};
 
    // Classify the element based on its occupancy and the intercepted-subdomain policy.
    elem->subdomain_id() = SBMUtils::classifySubdomainFromOccupancy(
        occupancy, subdomain_id_settings, _intercepted_subdomain_policy.mark_intercepted, _lambda);
  }
 
  // Signal that the mesh has been modified and needs preparation.
  mesh->unset_is_prepared();
  return mesh;
}

◆ usingFunctionParserUtilsMembers()

SubdomainInterceptedGenerator::usingFunctionParserUtilsMembers ( false )

protected

◆ validParams()

InputParameters SubdomainInterceptedGenerator::validParams ( )

static

Definition at line 16 of file SubdomainInterceptedGenerator.C.

{
  InputParameters params = SBMSubdomainGeneratorBase::validParams();
  params += FunctionParserUtils<false>::validParams();
 
  params.addRequiredParam<std::string>("signed_dist_function",
                                       "Parsed function expression (in terms of x, y, and z) "
                                       "defining the signed distance function to "
                                       "the interface.");
 
  params.addRequiredParam<SubdomainID>(
      "subdomain_id_inside", "Subdomain ID to assign to elements categorized inside the domain.");
  params.addRequiredParam<SubdomainID>(
      "subdomain_id_outside", "Subdomain ID to assign to elements categorized outside the domain.");
 
  params.addParam<Real>(
      "threshold", 0.0, "Level-set threshold value defining the interface boundary (default 0.0).");
  params.addRequiredParam<bool>(
      "is_domain_inside_surface",
      "Whether the inside domain corresponds to the negative signed distance region (< threshold). "
      "If true, points with signed distance < threshold are categorized as inside and > threshold "
      "as outside. If false, points with signed distance > threshold are categorized as inside.");
  params.addParam<bool>(
      "multi_geo",
      false,
      "Whether to enable multi-geometry handling when chaining generators, allowing elements with "
      "specific existing subdomain IDs to be preserved without reclassification (see "
      "'keep_inside_as_inside' and 'keep_outside_as_outside').");
  params.addParam<bool>("keep_inside_as_inside",
                        false,
                        "When 'multi_geo' is true, elements whose existing subdomain ID matches "
                        "'subdomain_id_inside' "
                        "are skipped, preserving their existing subdomain assignment.");
  params.addParam<bool>(
      "keep_outside_as_outside",
      false,
      "When 'multi_geo' is true, elements whose existing subdomain ID matches "
      "'subdomain_id_outside' are skipped, preserving their existing subdomain assignment.");
 
  params.addParam<bool>(
      "modify_outside_only",
      false,
      "If true, only elements categorized as outside are updated to 'subdomain_id_outside'; "
      "elements categorized as inside retain their existing subdomain IDs.");
  params.addParam<bool>(
      "modify_inside_only",
      false,
      "If true, only elements categorized as inside are updated to 'subdomain_id_inside'; elements "
      "categorized as outside retain their existing subdomain IDs.");
 
  params.addClassDescription("Classifies mesh elements into inside, outside, and optionally "
                             "intercepted subdomains based on an analytical signed distance "
                             "function expression.");
 
  return params;
}