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	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...

Protected Attributes
UnstructuredMesh &	_mesh

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...

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.

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.

Author

Derek R. Gaston

Date

2006

Definition at line 65 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 52 of file mesh_smoother_vsmoother.C.

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

~VariationalMeshSmoother()

virtual libMesh::VariationalMeshSmoother::~VariationalMeshSmoother ( )

virtualdefault

Destructor.

Member Function Documentation

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 87 of file mesh_smoother_vsmoother.h.

References smooth().

Referenced by main(), and smooth().

{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 61 of file mesh_smoother_vsmoother.C.

References _dilation_weight, libMesh::MeshSmoother::_mesh, _preserve_subdomain_boundaries, libMesh::EquationSystems::add_system(), libMesh::System::attach_constraint_object(), libMesh::ParallelObject::comm(), libMesh::MeshBase::elem_dimensions(), libMesh::VariationalSmootherSystem::get_dilation_weight(), libMesh::EquationSystems::init(), libMesh::make_range(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::node_ref(), libMesh::FEMSystem::solve(), libMesh::Parallel::sync_dofobject_data_by_id(), libMesh::DifferentiableSystem::time_solver, and libMesh::TOLERANCE.

{
  // 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
  DistributedMesh mesh_copy(_mesh);
  EquationSystems es(mesh_copy);
  VariationalSmootherSystem & sys = es.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.
  //sys.extra_quadrature_order = 0;

  // Uncomment these to debug
  //sys.print_element_solutions=true;
  //sys.print_element_residuals=true;
  //sys.print_element_jacobians=true;

  // Add boundary node and hanging node constraints
  VariationalSmootherConstraint constraint(sys, _preserve_subdomain_boundaries);
  sys.attach_constraint_object(constraint);

  // Set system parameters
  sys.get_dilation_weight() = _dilation_weight;

  // Set up solver
  sys.time_solver =
    std::make_unique<SteadySolver>(sys);

  // 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.
  //sys.time_solver->diff_solver() = std::make_unique<PetscDiffSolver>(sys);

  es.init();

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

  sys.time_solver->diff_solver()->relative_residual_tolerance = TOLERANCE*TOLERANCE;

  sys.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);
}

Member Data Documentation

_dilation_weight

const Real libMesh::VariationalMeshSmoother::_dilation_weight

private

Smoother control variables.

Definition at line 102 of file mesh_smoother_vsmoother.h.

Referenced by 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(), libMesh::LaplaceMeshSmoother::smooth(), 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 105 of file mesh_smoother_vsmoother.h.

Referenced by smooth().

---

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

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