SBMUtils Namespace Reference

Functions
bool	checkWatertightnessFromRawElems (const std::vector< const Elem *> &bd_elements)
std::vector< const Function * >	buildDistanceFunctions (const std::vector< FunctionName > &function_names, const FunctionInterface &function_provider)
	Build a list of distance functions based on names specified in input. More...
RealVectorValue	distanceVectorFromFunction (const Function *func, const libMesh::Point &pt, Real t)
	Compute the distance vector induced by a distance function. More...
RealVectorValue	trueNormalFromFunction (const Function *func, const libMesh::Point &pt, Real t)
	Compute the true boundary surface normal using a distance function. More...
RealVectorValue	closestDistanceVector (const std::vector< const Function *> &funcs, const libMesh::Point &pt, Real t)
	Scan all distance functions and return the closest distance vector. More...
RealVectorValue	closestTrueNormalVector (const std::vector< const Function *> &funcs, const libMesh::Point &pt, Real t)
	Scan all distance functions and return the corresponding normal vector. More...

Function Documentation

buildDistanceFunctions()

std::vector< const Function * > SBMUtils::buildDistanceFunctions	(	const std::vector< FunctionName > &	function_names,
		const FunctionInterface &	function_provider
	)

Build a list of distance functions based on names specified in input.

Definition at line 33 of file SBMUtils.C.

Referenced by ShortestDistanceToSurface::ShortestDistanceToSurface().

{
  std::vector<const Function *> funcs;
  funcs.reserve(function_names.size());

  for (const auto & name : function_names)
  {
    const Function * func = &function_provider.getFunctionByName(name);
    if (!dynamic_cast<const MooseParsedFunction *>(func) &&
        !dynamic_cast<const UnsignedDistanceToSurfaceMesh *>(func))
    {
      mooseError("SBM distance helpers only support ParsedFunction or "
                 "UnsignedDistanceToSurfaceMesh types. Offending function: ",
                 name);
    }
    funcs.emplace_back(func);
  }

  return funcs;
}

checkWatertightnessFromRawElems()

bool SBMUtils::checkWatertightnessFromRawElems

(

const std::vector< const Elem *> &

bd_elements

)

Definition at line 22 of file SBMUtils.C.

Referenced by SBMSurfaceMeshBuilder::checkWatertightness(), and TEST().

{
  for (const auto * el : bd_elements)
    for (unsigned int s = 0; s < el->n_sides(); ++s)
      if (!el->neighbor_ptr(s))
        return false;

  return true;
}

closestDistanceVector()

RealVectorValue SBMUtils::closestDistanceVector	(	const std::vector< const Function *> &	funcs,
		const libMesh::Point &	pt,
		Real	t
	)

Scan all distance functions and return the closest distance vector.

Definition at line 95 of file SBMUtils.C.

Referenced by ShortestDistanceToSurface::distanceVector().

{
  Real min_dist = std::numeric_limits<Real>::max();
  RealVectorValue closest_dist_vec;

  for (const auto & func : funcs)
  {
    const auto dist_vec = distanceVectorFromFunction(func, pt, t);
    const auto dist = dist_vec.norm();
    if (dist < min_dist)
    {
      min_dist = dist;
      closest_dist_vec = dist_vec;
    }
  }

  return closest_dist_vec;
}

closestTrueNormalVector()

RealVectorValue SBMUtils::closestTrueNormalVector	(	const std::vector< const Function *> &	funcs,
		const libMesh::Point &	pt,
		Real	t
	)

Scan all distance functions and return the corresponding normal vector.

Definition at line 117 of file SBMUtils.C.

Referenced by ShortestDistanceToSurface::trueNormal().

{
  Real min_dist = std::numeric_limits<Real>::max();
  RealVectorValue closest_normal_vec;

  for (const auto & func : funcs)
  {
    const auto dist_vec = distanceVectorFromFunction(func, pt, t);
    const auto dist = dist_vec.norm();
    if (dist < min_dist)
    {
      min_dist = dist;
      closest_normal_vec = trueNormalFromFunction(func, pt, t);
    }
  }

  return closest_normal_vec;
}

distanceVectorFromFunction()

RealVectorValue SBMUtils::distanceVectorFromFunction	(	const Function *	func,
		const libMesh::Point &	pt,
		Real	t
	)

Compute the distance vector induced by a distance function.

The provided function must represent a distance to the true boundary: either a signed distance function (ParsedFunction) or an unsigned distance function provided by UnsignedDistanceToSurfaceMesh.

Definition at line 56 of file SBMUtils.C.

Referenced by closestDistanceVector(), closestTrueNormalVector(), ShortestDistanceToSurface::distanceVectorByFunc(), ShortestDistanceToSurface::distanceVectorByIndex(), and trueNormalFromFunction().

{
  mooseAssert(dynamic_cast<const MooseParsedFunction *>(func) ||
                  dynamic_cast<const UnsignedDistanceToSurfaceMesh *>(func),
              "Function was not a valid distance strategy, the only "
              "supported types are ParsedFunction and "
              "UnsignedDistanceToSurfaceMesh.");

  const Real phi = func->value(t, pt);
  const RealVectorValue grad_phi = func->gradient(t, pt);
  const Real grad_norm = grad_phi.norm();

  if (grad_norm <= libMesh::TOLERANCE)
    return RealVectorValue(0.0, 0.0, 0.0);

  return -(phi / grad_norm) * grad_phi;
}

trueNormalFromFunction()

RealVectorValue SBMUtils::trueNormalFromFunction	(	const Function *	func,
		const libMesh::Point &	pt,
		Real	t
	)

Compute the true boundary surface normal using a distance function.

The query point is first projected onto the true boundary, and the surface normal of the boundary is then evaluated at the projected (closest) point.

Definition at line 75 of file SBMUtils.C.

Referenced by closestTrueNormalVector(), ShortestDistanceToSurface::trueNormalByFunc(), and ShortestDistanceToSurface::trueNormalByIndex().

{
  if (const auto * parsed = dynamic_cast<const MooseParsedFunction *>(func))
  {
    const auto proj_pt = pt + distanceVectorFromFunction(func, pt, t);
    const RealVectorValue grad_phi = parsed->gradient(t, proj_pt);
    const Real grad_norm = grad_phi.norm();
    if (grad_norm <= libMesh::TOLERANCE)
      return RealVectorValue(0.0, 0.0, 0.0);
    return grad_phi / grad_norm;
  }
  else
  {
    const auto * mesh_func = dynamic_cast<const UnsignedDistanceToSurfaceMesh *>(func);
    mooseAssert(mesh_func, "Function was not a valid distance strategy");
    return mesh_func->surfaceNormal(pt);
  }
}