Assigns grain subdomain IDs to a volume mesh based on watertight closed boundaries in an external boundary mesh, using ray casting accelerated by a k-d tree. More...

#include <SubdomainGrainIDGenerator.h>

Inheritance diagram for SubdomainGrainIDGenerator:

[legend]

Classes
struct	SubdomainCheckerEntry
	Cache of bounding box and checker pointers for fast spatial queries. More...

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	SubdomainGrainIDGenerator (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

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 Member Functions
void	buildSubdomainGroupedData ()
	build the data structure grouping by different subdomains

void	buildInOutTesters ()
	Build the IN-OUT testers for each subdomain.

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)

Static Protected Member Functions
static bool	boundingBoxesIntersect (const BoundingBox &lhs, const BoundingBox &rhs, const Real tolerance)
	Check whether two bounding boxes overlap within a small tolerance.

static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
std::unique_ptr< libMesh::MeshBase > &	_boundary_mesh
	Reference to the external boundary mesh defining grain boundaries.

std::unordered_map< SubdomainID, std::vector< Point > >	_centroids_by_subdomain
	The centroids of the boundary elements grouped by subdomains.

std::unordered_map< SubdomainID, std::vector< std::unique_ptr< SurfaceElement > > >	_boundary_elements_by_subdomain
	The boundary elements grouped by subdomains.

std::unordered_map< SubdomainID, BoundingBox >	_bboxes_by_subdomain
	The bounding boxes of the boundary elements grouped by subdomains.

std::unordered_map< SubdomainID, std::unique_ptr< AdaptiveRayContainmentCheck > >	_subdomain_id_checkers
	The IN-OUT testers for each subdomain.

std::vector< SubdomainCheckerEntry >	_checker_entries
	Cache contiguous checker metadata for faster per-element scans.

Point	_ray_direction
	Ray shooting direction in Point format.

Real	_eps
	eps for intersection or on surface checking

unsigned int	_leaf_max_size
	Maximum number of boundary-element centroids in a leaf node of the k-d tree.

std::unique_ptr< libMesh::MeshBase >	_boundary_owned
	The boundary mesh to use for identifying grain 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.

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

Assigns grain subdomain IDs to a volume mesh based on watertight closed boundaries in an external boundary mesh, using ray casting accelerated by a k-d tree.

Definition at line 23 of file SubdomainGrainIDGenerator.h.

Constructor & Destructor Documentation

◆ SubdomainGrainIDGenerator()

SubdomainGrainIDGenerator::SubdomainGrainIDGenerator ( const InputParameters & parameters )

Definition at line 52 of file SubdomainGrainIDGenerator.C.

  : SBMSubdomainGeneratorBase(parameters),
    _boundary_mesh(getMesh("boundary_mesh")),
    _ray_direction(getParam<Point>("ray_direction")),
    _eps(getParam<Real>("eps")),
    _leaf_max_size(getParam<unsigned int>("leaf_max_size"))
{
}

Member Function Documentation

◆ boundingBoxesIntersect()

bool SubdomainGrainIDGenerator::boundingBoxesIntersect	(	const BoundingBox &	lhs,
		const BoundingBox &	rhs,
		const Real	tolerance
	)

staticprotected

Check whether two bounding boxes overlap within a small tolerance.

Definition at line 234 of file SubdomainGrainIDGenerator.C.

{
  const Point lhs_min = lhs.min();
  const Point lhs_max = lhs.max();
  const Point rhs_min = rhs.min();
  const Point rhs_max = rhs.max();
 
  for (const auto d : make_range(LIBMESH_DIM))
    if (lhs_max(d) + tolerance < rhs_min(d) || rhs_max(d) + tolerance < lhs_min(d))
      return false;
 
  return true;
}

Referenced by generate().

◆ buildInOutTesters()

void SubdomainGrainIDGenerator::buildInOutTesters ( )

protected

Build the IN-OUT testers for each subdomain.

Definition at line 210 of file SubdomainGrainIDGenerator.C.

{
  _subdomain_id_checkers.clear();
  _subdomain_id_checkers.reserve(_boundary_elements_by_subdomain.size());
  _checker_entries.clear();
  _checker_entries.reserve(_boundary_elements_by_subdomain.size());
 
  const SurfaceGeometry::RayDirectionOptions ray_options{
      _ray_direction.norm_sq() == 0 ? SurfaceGeometry::RayDirectionMode::AUTO_PCA
                                    : SurfaceGeometry::RayDirectionMode::USER_SPECIFIED,
      _ray_direction};
 
  for (const auto & [subdomain_id, elements] : _boundary_elements_by_subdomain)
  {
    auto checker = std::make_unique<AdaptiveRayContainmentCheck>(
        elements, _centroids_by_subdomain.at(subdomain_id), ray_options, _eps, _leaf_max_size);
 
    auto * checker_ptr = checker.get();
    _subdomain_id_checkers[subdomain_id] = std::move(checker);
    _checker_entries.push_back({subdomain_id, _bboxes_by_subdomain.at(subdomain_id), checker_ptr});
  }
}

Referenced by generate().

◆ buildSubdomainGroupedData()

void SubdomainGrainIDGenerator::buildSubdomainGroupedData ( )

protected

build the data structure grouping by different subdomains

Definition at line 122 of file SubdomainGrainIDGenerator.C.

{
  struct SubdomainBuildBucket
  {
    SubdomainID subdomain_id;
    std::size_t count = 0;
    BoundingBox bbox;
    bool has_bbox = false;
    std::vector<Point> centroids;
    std::vector<std::unique_ptr<SurfaceElement>> boundary_elements;
  };
 
  _boundary_owned = std::move(_boundary_mesh);
  _centroids_by_subdomain.clear();
  _boundary_elements_by_subdomain.clear();
  _bboxes_by_subdomain.clear();
 
  libMesh::MeshBase * boundary_mesh = _boundary_owned.get();
  const auto estimated_subdomains = boundary_mesh->n_subdomains();
 
  std::unordered_map<SubdomainID, std::size_t> bucket_index_by_subdomain;
  bucket_index_by_subdomain.reserve(estimated_subdomains);
 
  std::vector<SubdomainBuildBucket> buckets;
  buckets.reserve(estimated_subdomains);
 
  auto get_or_create_bucket = [&](const SubdomainID sid) -> SubdomainBuildBucket &
  {
    const auto [it, inserted] = bucket_index_by_subdomain.emplace(sid, buckets.size());
    if (inserted)
      buckets.push_back({sid, 0, {}, false, {}, {}});
    return buckets[it->second];
  };
 
  for (const auto & elem : boundary_mesh->active_element_ptr_range())
  {
    const auto sid = elem->subdomain_id();
    auto & bucket = get_or_create_bucket(sid);
    ++bucket.count;
 
    const auto elem_bbox = elem->loose_bounding_box();
    if (!bucket.has_bbox)
    {
      bucket.bbox = elem_bbox;
      bucket.has_bbox = true;
    }
    else
      bucket.bbox.union_with(elem_bbox);
  }
 
  _centroids_by_subdomain.reserve(buckets.size());
  _boundary_elements_by_subdomain.reserve(buckets.size());
  _bboxes_by_subdomain.reserve(buckets.size());
 
  for (auto & bucket : buckets)
  {
    bucket.centroids.reserve(bucket.count);
    bucket.boundary_elements.reserve(bucket.count);
    _bboxes_by_subdomain.emplace(bucket.subdomain_id, bucket.bbox);
  }
 
  for (const auto & elem : boundary_mesh->active_element_ptr_range())
  {
    const auto sid = elem->subdomain_id();
    auto & bucket = buckets[bucket_index_by_subdomain.at(sid)];
 
    bucket.centroids.emplace_back(elem->vertex_average());
 
    std::unique_ptr<SurfaceElement> bnd_elem;
    if (elem->type() == EDGE2)
      bnd_elem = std::make_unique<SurfaceEdge2>(elem);
    else if (elem->type() == TRI3)
      bnd_elem = std::make_unique<SurfaceTri3>(elem);
    else
      mooseError("Unsupported element type in SubdomainGrainIDGenerator");
 
    bucket.boundary_elements.emplace_back(std::move(bnd_elem));
  }
 
  for (auto & bucket : buckets)
  {
    _centroids_by_subdomain.emplace(bucket.subdomain_id, std::move(bucket.centroids));
    _boundary_elements_by_subdomain.emplace(bucket.subdomain_id,
                                            std::move(bucket.boundary_elements));
  }
}

Referenced by generate().

◆ generate()

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

overridevirtual

Implements MeshGenerator.

Definition at line 62 of file SubdomainGrainIDGenerator.C.

{
  // Take ownership of the input mesh (already cloned by getMesh()).
  std::unique_ptr<libMesh::MeshBase> mesh = std::move(_input);
 
  std::set<SubdomainID> boundary_subdomain_ids;
  // Bind a const reference so that we call the non-deprecated const subdomain_name() overload.
  const libMesh::MeshBase & boundary_mesh = *_boundary_mesh;
  boundary_mesh.subdomain_ids(boundary_subdomain_ids);
  for (const auto subdomain_id : boundary_subdomain_ids)
    mesh->set_subdomain_name(subdomain_id, boundary_mesh.subdomain_name(subdomain_id));
 
  // (a) read the boundary mesh to be our own data structure
  buildSubdomainGroupedData();
 
  // (b) build the point-containment checker for each subdomain
  buildInOutTesters();
 
  std::vector<const SubdomainCheckerEntry *> candidate_entries;
  candidate_entries.reserve(_checker_entries.size());
 
  std::vector<SBMUtils::SubdomainOccupancy> candidate_occupancies;
  candidate_occupancies.reserve(_checker_entries.size());
 
  for (const auto & elem : mesh->active_element_ptr_range() /*gen only run rank = 0*/)
  {
    const auto elem_bbox = elem->loose_bounding_box();
    candidate_entries.clear();
    candidate_occupancies.clear();
 
    for (const auto & entry : _checker_entries)
      if (boundingBoxesIntersect(elem_bbox, entry.bbox, _eps))
        candidate_entries.push_back(&entry);
 
    if (candidate_entries.empty())
      for (const auto & entry : _checker_entries)
        candidate_entries.push_back(&entry);
 
    for (const auto * entry : candidate_entries)
    {
      const auto * const checker = entry->checker;
      const auto is_in_domain = [checker](const Point & point)
      { return checker->sideness(point) != SurfaceGeometry::SurfaceSide::OUTSIDE; };
      candidate_occupancies.push_back(
          {entry->subdomain_id,
           SBMUtils::elementDomainOccupancy(*elem, _qrule_order, is_in_domain)});
    }
 
    const auto subdomain = SBMUtils::selectSubdomainFromOccupancies(
        candidate_occupancies, _intercepted_subdomain_policy, _lambda);
    if (subdomain)
      elem->subdomain_id() = *subdomain;
  }
 
  // Signal that the mesh has been modified and needs preparation.
  mesh->unset_is_prepared();
  return mesh;
}

◆ validParams()

InputParameters SubdomainGrainIDGenerator::validParams ( )

static

Definition at line 16 of file SubdomainGrainIDGenerator.C.

{
  InputParameters params = SBMSubdomainGeneratorBase::validParams();
 
  params.addRequiredParam<MeshGeneratorName>("boundary_mesh",
                                             "The boundary mesh to use for identifying grain IDs");
 
  // --- Point-In-Polyhedron checks ---
 
  params.addParam<Point>(
      "ray_direction", Point(0, 0, 0), "The direction of the ray for in-out testing.");
 
  params.addParam<Real>("eps",
                        libMesh::TOLERANCE,
                        "Tolerance value used for intersection or surface proximity checks. "
                        "This parameter determines whether a point is considered on the geometry "
                        "or on the in/out sides of the geometry.");
 
  params.addRangeCheckedParam<unsigned int>(
      "leaf_max_size",
      10,
      "leaf_max_size > 0",
      "Maximum number of boundary-element centroids per leaf node in the k-d tree "
      "used to accelerate ray-casting point-in-grain checks. Tuning this parameter "
      "only affects search performance, not the assigned subdomain IDs.");
 
  params.addClassDescription(
      "Based on the boundary_mesh, which contains distinct grain boundaries as separate "
      "watertight regions, this generator assigns grain IDs (subdomain IDs) to the volume mesh. "
      "Even if the mesh does not perfectly align with the grain boundaries, each element is "
      "assigned the selected grain ID, or retains its input subdomain ID when no grain is "
      "selected.");
 
  return params;
}