libMesh::InterMeshProjection Class Reference

This class implements inter mesh projection, i.e. More...

#include <inter_mesh_projection.h>

Public Member Functions
	InterMeshProjection (System &_from_system, System &_to_mesh)
void	project_system_vectors ()

Static Public Member Functions
static Number	fptr (const Point &p, const Parameters &, const std::string &libmesh_dbg_var(sys_name), const std::string &unknown_name)
static Gradient	gptr (const Point &p, const Parameters &, const std::string &libmesh_dbg_var(sys_name), const std::string &unknown_name)

Private Attributes
System &	from_system
System &	to_system

Detailed Description

This class implements inter mesh projection, i.e.

projection of vectors defined on a given mesh (from_mesh associated with from_system) to another mesh (to_mesh of to_system).

Definition at line 48 of file inter_mesh_projection.h.

Constructor & Destructor Documentation

InterMeshProjection()

libMesh::InterMeshProjection::InterMeshProjection	(	System &	_from_system,
		System &	_to_mesh
	)

Definition at line 36 of file inter_mesh_projection.C.

                                                                                   :
  from_system(_from_system),
  to_system(_to_system)
{
  libmesh_experimental();
}

Member Function Documentation

fptr()

static Number libMesh::InterMeshProjection::fptr ( const Point &  p, const Parameters &  , const std::string &  libmesh_dbg_varsys_name, const std::string &  unknown_name  )

static

gptr()

static Gradient libMesh::InterMeshProjection::gptr ( const Point &  p, const Parameters &  , const std::string &  libmesh_dbg_varsys_name, const std::string &  unknown_name  )

static

Referenced by project_system_vectors().

project_system_vectors()

void libMesh::InterMeshProjection::project_system_vectors

(

)

Definition at line 43 of file inter_mesh_projection.C.

References libMesh::NumericVector< T >::build(), libMesh::ParallelObject::comm(), from_system, libMesh::System::get_dof_map(), libMesh::System::get_equation_systems(), libMesh::System::get_vector(), gptr(), libMesh::GradientMeshFunction::init(), libMesh::MeshFunction::init(), libMesh::NumericVector< T >::localize(), n_vars, libMesh::System::n_vars(), libMesh::System::n_vectors(), libMesh::System::project_vector(), libMesh::SERIAL, libMesh::NumericVector< T >::size(), libMesh::System::solution, to_system, libMesh::System::update_global_solution(), libMesh::System::variable_name(), libMesh::System::vector_is_adjoint(), libMesh::System::vectors_begin(), and libMesh::System::vectors_end().

{
  // Number of vectors to be projected
  libmesh_assert_equal_to (to_system.n_vectors(), from_system.n_vectors());

  // Number of variable components in each vector
  unsigned int n_vars = from_system.n_vars();
  libmesh_assert_equal_to (to_system.n_vars(), n_vars);

  // We are going to use the multi-variable MeshFunction, so we can pass
  // a single vector of variables rather than have a MeshFunction for each variable
  std::vector<unsigned int> variables_vector;

  for (unsigned int j = 0; j != n_vars; ++j)
    {
      libmesh_assert_equal_to (to_system.variable_name(j), from_system.variable_name(j));
      variables_vector.push_back(j);
    }

  // Any system holds the solution along with the other vectors system.vectors
  // We will first project the solution and then move to the system.vectors

  // Construct local version of the current system vector
  // This has to be a serial vector
  // Roy's FIXME: Technically it just has to be a ghosted vector whose algebraically
  // ghosted values cover a domain which is a superset of the to-system's domain ...
  // that's hard to do and we can skip it until the poor scalability bites someone.
  std::unique_ptr<NumericVector<Number>> solution_vector_serial = NumericVector<Number>::build(from_system.comm());
  solution_vector_serial->init(from_system.solution->size(), true, SERIAL);

  std::vector<Number> solution_vector;
  from_system.update_global_solution(solution_vector);
  (*solution_vector_serial) = solution_vector;

  // Construct a MeshFunction for the solution
  MeshFunction mesh_func_solution(from_system.get_equation_systems(), *solution_vector_serial, from_system.get_dof_map(), variables_vector);

  mesh_func_solution.init();

  // For some element types (say C1) we also need to pass a gradient evaluation MeshFunction
  // To do this evaluate, a new shim class GradientMeshFunction has been added which redirects
  // gptr::operator evaluations inside projection methods into MeshFunction::gradient calls.
  GradientMeshFunction gptr_solution(mesh_func_solution);
  gptr_solution.init();

  to_system.project_vector(*to_system.solution, &mesh_func_solution, &gptr_solution);

  // Now loop over the vectors in system.vectors (includes old_nonlin_sol, rhs, adjoints, adjoint_rhs, sensitivity_rhs)
  for (System::vectors_iterator vec = from_system.vectors_begin(), vec_end = from_system.vectors_end(); vec != vec_end; ++vec)
    {
      // The name of this vector
      const std::string & vec_name = vec->first;

      // Construct local version of the current system vector
      // This has to be a serial vector
      // Roy's FIXME: Technically it just has to be a ghosted vector whose algebraically
      // ghosted values cover a domain which is a superset of the to-system's domain ...
      // that's hard to do and we can skip it until the poor scalability bites someone.
      std::unique_ptr<NumericVector<Number>> current_vector_proxy = NumericVector<Number>::build(from_system.comm());
      current_vector_proxy->init(from_system.get_vector(vec_name).size(), true, SERIAL);

      from_system.get_vector(vec_name).localize(*current_vector_proxy);

      // Construct a MeshFunction for the current component
      MeshFunction mesh_func(from_system.get_equation_systems(), *current_vector_proxy, from_system.get_dof_map(), variables_vector);
      mesh_func.init();

      // Project the current system vector, you need to check if this vector is an adjoint to pass
      // the right options to project_vector
      GradientMeshFunction gptr(mesh_func);
      gptr.init();

      // The fourth argument here is whether the vector is an adjoint solution or not, we will be getting that information
      // via the from_system instead of the to_system in case the user has not set the System::_vector_is_adjoint map to true.
      to_system.project_vector(to_system.get_vector(vec_name), &mesh_func, &gptr, from_system.vector_is_adjoint(vec_name));

    }
  // End loop over the vectors in the system

}

Member Data Documentation

from_system

System& libMesh::InterMeshProjection::from_system

private

Definition at line 66 of file inter_mesh_projection.h.

Referenced by project_system_vectors().

to_system

System& libMesh::InterMeshProjection::to_system

private

Definition at line 69 of file inter_mesh_projection.h.

Referenced by project_system_vectors().

---

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

• include/systems/inter_mesh_projection.h
• src/systems/inter_mesh_projection.C