libMesh::VariationalMeshSmoother Class Reference

This is an implementation of Larisa Branets' smoothing algorithms. More...

#include <mesh_smoother_vsmoother.h>

Inheritance diagram for libMesh::VariationalMeshSmoother:

Public Member Functions
	VariationalMeshSmoother (UnstructuredMesh &mesh, Real dilation_weight=0.5, const bool preserve_subdomain_boundaries=true)
	Simple constructor to use for smoothing purposes. More...
virtual	~VariationalMeshSmoother ()=default
	Destructor. More...
virtual void	setup ()
	Setup method that creates equation systems, system, and constraints, to be called just prior to smoothing. More...
virtual void	smooth () override
	Redefinition of the smooth function from the base class. More...
void	smooth (unsigned int n_iterations)
	The actual smoothing function, gets called whenever the user specifies an actual number of smoothing iterations. More...
const MeshQualityInfo &	get_mesh_info () const
	Getter for the _system's _mesh_info attribute. More...

Protected Attributes
UnstructuredMesh &	_mesh

Private Member Functions
VariationalSmootherSystem *	system () const
	Getter for _system to protect against dangling pointers. More...

Private Attributes
const Real	_dilation_weight
	Smoother control variables. More...
const bool	_preserve_subdomain_boundaries
	Whether subdomain boundaries are subject to change via smoothing. More...
std::unique_ptr< DistributedMesh >	_mesh_copy
	Mesh copy to avoid multiple EquationSystems. More...
std::unique_ptr< EquationSystems >	_equation_systems
	EquationsSystems object associated with the smoother. More...
VariationalSmootherSystem *	_system
std::unique_ptr< VariationalSmootherConstraint >	_constraint
	Constraints imposed on the smoothing process. More...
bool	_setup_called
	Attribute the keep track of whether the setup method has been called. More...

Detailed Description

This is an implementation of Larisa Branets' smoothing algorithms.

The initial implementation was done by her, the adaptation to libmesh was completed by Derek Gaston. The code was heavily refactored into something more closely resembling C++ by John Peterson in 2014. The code eventually fell out of use and stopped functioning. Patrick Behne reimplemented the smoother in 2025.

Here are the relevant publications: 1) L. Branets, G. Carey, "Extension of a mesh quality metric for elements with a curved boundary edge or surface", Journal of Computing and Information Science in Engineering, vol. 5(4), pp.302-308, 2005.

2) L. Branets, G. Carey, "A local cell quality metric and variational grid smoothing algorithm", Engineering with Computers, vol. 21, pp.19-28, 2005.

3) L. Branets, "A variational grid optimization algorithm based on a local cell quality metric", Ph.D. thesis, The University of Texas at Austin, 2005.

Notes:

1) The smoother supports tangled meshes. However, not all untangling solves converge. In other words, we are able to untangle SOME tangled meshes, but not ANY tangled mesh.

Author

Derek R. Gaston

Date

2006

Definition at line 75 of file mesh_smoother_vsmoother.h.

Constructor & Destructor Documentation

VariationalMeshSmoother()

libMesh::VariationalMeshSmoother::VariationalMeshSmoother	(	UnstructuredMesh &	mesh,
		Real	dilation_weight = 0.5,
		const bool	preserve_subdomain_boundaries = true
	)

Simple constructor to use for smoothing purposes.

Definition at line 51 of file mesh_smoother_vsmoother.C.

  : MeshSmoother(mesh),
    _dilation_weight(dilation_weight),
    _preserve_subdomain_boundaries(preserve_subdomain_boundaries),
    _setup_called(false)
{}

~VariationalMeshSmoother()

virtual libMesh::VariationalMeshSmoother::~VariationalMeshSmoother ( )

virtualdefault

Destructor.

Member Function Documentation

get_mesh_info()

const MeshQualityInfo & libMesh::VariationalMeshSmoother::get_mesh_info

(

)

const

Getter for the _system's _mesh_info attribute.

Definition at line 157 of file mesh_smoother_vsmoother.C.

References _setup_called, _system, and libMesh::VariationalSmootherSystem::get_mesh_info().

Referenced by MeshSmootherTest::testVariationalSmoother().

{
  libmesh_error_msg_if(!_setup_called, "Need to first call the setup() method of "
      << "this VariationalMeshSmoother object, then call get_mesh_info() prior "
      << "to calling smooth().");
  return _system->get_mesh_info();
}

setup()

void libMesh::VariationalMeshSmoother::setup ( )

virtual

Setup method that creates equation systems, system, and constraints, to be called just prior to smoothing.

Definition at line 60 of file mesh_smoother_vsmoother.C.

References _constraint, _dilation_weight, _equation_systems, libMesh::MeshSmoother::_mesh, _mesh_copy, _preserve_subdomain_boundaries, _setup_called, _system, libMesh::System::attach_constraint_object(), libMesh::MeshBase::elem_dimensions(), libMesh::VariationalSmootherSystem::get_dilation_weight(), system(), libMesh::DifferentiableSystem::time_solver, and libMesh::TOLERANCE.

Referenced by smooth(), and MeshSmootherTest::testVariationalSmoother().

{
  // Check for multiple dimensions
  if (_mesh.elem_dimensions().size() > 1)
    libmesh_not_implemented_msg("Meshes containing elements of differing dimension are not yet supported.");

  /*
  Ideally we'd want to update _mesh directly even if it already has an
  EquationSystems attached and doing work on it ... and that's thwarted by the
  problems:

  1. We can't easily tell if there's already an EquationSystems attached.
  2. We can't attach a second EquationSystems safely (if it already has a system 0)
     because the DoF indexing will need to be overwritten by our system.
  3. The destructor of es won't even clean up after itself (we generally expect
     a mesh to go unused after its EquationSystems is destroyed), much less know
     how to restore anything from a previous EquationSystems.

  To avoid these issues, we'll just construct a new DistributedMesh _mesh_copy
  from _mesh, then do the solve on _mesh_copy, then copy its node locations back
  to _mesh after the solve is done. That'll be slightly less memory-efficient
  and somewhat more CPU-efficient in the case where _mesh is serial, though
  it'll be significantly less memory-efficient when _mesh is already distributed,
  but either way the robustness is probably worth it.
  */

  // Create a new mesh, EquationSystems, and System
  _mesh_copy = std::make_unique<DistributedMesh>(_mesh);
  _equation_systems = std::make_unique<EquationSystems>(*_mesh_copy);
  _system =
      &(_equation_systems->add_system<VariationalSmootherSystem>("variational_smoother_system"));

  // Set this to something > 0 to add more quadrature points than the default
  // rule that integrates order 2 * fe_order + 1 polynomials exactly.
  // Using higher quadrature orders has not had a significant effect on observed solutions.
  //system()->extra_quadrature_order = 0;

  // Uncomment these to debug
  //system()->print_element_solutions=true;
  //system()->print_element_residuals=true;
  //system()->print_element_jacobians=true;

  // Add boundary node and hanging node constraints
  _constraint =
      std::make_unique<VariationalSmootherConstraint>(*_system, _preserve_subdomain_boundaries);
  system()->attach_constraint_object(*_constraint);

  // Set system parameters
  system()->get_dilation_weight() = _dilation_weight;

  // Set up solver
  system()->time_solver = std::make_unique<SteadySolver>(*_system);

  // Uncomment this line and use -snes_test_jacobian and -snes_test_jacobian_view
  // flags to compare the hand-coded jacobian in VariationalSmootherSystem
  // to finite difference jacobians.
  //system()->time_solver->diff_solver() = std::make_unique<PetscDiffSolver>(*_system);

  _equation_systems->init();

  // More debugging options
  // DiffSolver & solver = *(system()->time_solver->diff_solver().get());
  // solver.quiet = false;
  // solver.verbose = true;

  system()->time_solver->diff_solver()->relative_residual_tolerance = TOLERANCE * TOLERANCE;
  system()->time_solver->diff_solver()->absolute_residual_tolerance = TOLERANCE * TOLERANCE;

  _setup_called = true;
}

smooth() [1/2]

virtual void libMesh::VariationalMeshSmoother::smooth ( )

inlineoverridevirtual

Redefinition of the smooth function from the base class.

All this does is call the smooth function in this class which takes an int, using a default value of 1.

Implements libMesh::MeshSmoother.

Definition at line 103 of file mesh_smoother_vsmoother.h.

References smooth().

Referenced by main(), smooth(), and MeshSmootherTest::testVariationalSmoother().

{this->smooth(1); }

smooth() [2/2]

void libMesh::VariationalMeshSmoother::smooth

(

unsigned int

n_iterations

)

The actual smoothing function, gets called whenever the user specifies an actual number of smoothing iterations.

Definition at line 131 of file mesh_smoother_vsmoother.C.

References _equation_systems, libMesh::MeshSmoother::_mesh, _mesh_copy, _setup_called, libMesh::ParallelObject::comm(), libMesh::make_range(), libMesh::MeshBase::node_ref(), setup(), libMesh::VariationalSmootherSystem::solve(), libMesh::Parallel::sync_dofobject_data_by_id(), and system().

{
  if (!_setup_called)
    setup();

  system()->solve();

  // Update _mesh from _mesh_copy
  for (auto * node_copy : _mesh_copy->local_node_ptr_range())
    {
      auto & node = _mesh.node_ref(node_copy->id());
      for (const auto d : make_range(_mesh_copy->mesh_dimension()))
        node(d) = (*node_copy)(d);
    }

  SyncNodalPositions sync_object(_mesh);
  Parallel::sync_dofobject_data_by_id (_mesh.comm(), _mesh.nodes_begin(), _mesh.nodes_end(), sync_object);

  // Release memory occupied by _mesh_copy
  // Destruct this before _mesh_copy because it references _mesh_copy
  _equation_systems.reset();
  _mesh_copy.reset();
  // We'll need to call setup again since we'll have to reconstruct _mesh_copy
  _setup_called = false;
}

system()

VariationalSmootherSystem* libMesh::VariationalMeshSmoother::system ( ) const

inlineprivate

Getter for _system to protect against dangling pointers.

Definition at line 156 of file mesh_smoother_vsmoother.h.

References _system, and libMesh::libmesh_assert().

Referenced by setup(), and smooth().

  {
    libmesh_assert(_system);
    return _system;
  }

Member Data Documentation

_constraint

std::unique_ptr<VariationalSmootherConstraint> libMesh::VariationalMeshSmoother::_constraint

private

Constraints imposed on the smoothing process.

Definition at line 166 of file mesh_smoother_vsmoother.h.

Referenced by setup().

_dilation_weight

const Real libMesh::VariationalMeshSmoother::_dilation_weight

private

Smoother control variables.

Definition at line 122 of file mesh_smoother_vsmoother.h.

Referenced by setup().

_equation_systems

std::unique_ptr<EquationSystems> libMesh::VariationalMeshSmoother::_equation_systems

private

EquationsSystems object associated with the smoother.

Definition at line 142 of file mesh_smoother_vsmoother.h.

Referenced by setup(), and smooth().

_mesh

UnstructuredMesh& libMesh::MeshSmoother::_mesh

protectedinherited

Definition at line 61 of file mesh_smoother.h.

Referenced by libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::LaplaceMeshSmoother::init(), setup(), libMesh::LaplaceMeshSmoother::smooth(), and smooth().

_mesh_copy

std::unique_ptr<DistributedMesh> libMesh::VariationalMeshSmoother::_mesh_copy

private

Mesh copy to avoid multiple EquationSystems.

Definition at line 136 of file mesh_smoother_vsmoother.h.

Referenced by setup(), and smooth().

_preserve_subdomain_boundaries

const bool libMesh::VariationalMeshSmoother::_preserve_subdomain_boundaries

private

Whether subdomain boundaries are subject to change via smoothing.

Definition at line 127 of file mesh_smoother_vsmoother.h.

Referenced by setup().

_setup_called

bool libMesh::VariationalMeshSmoother::_setup_called

private

Attribute the keep track of whether the setup method has been called.

Definition at line 171 of file mesh_smoother_vsmoother.h.

Referenced by get_mesh_info(), setup(), and smooth().

_system

VariationalSmootherSystem* libMesh::VariationalMeshSmoother::_system

private

Definition at line 151 of file mesh_smoother_vsmoother.h.

Referenced by get_mesh_info(), setup(), and system().

---

The documentation for this class was generated from the following files:

• include/mesh/mesh_smoother_vsmoother.h
• src/mesh/mesh_smoother_vsmoother.C