The GenericProjector class implements the core of other projection operations, using two input functors to read values to be projected and an output functor to set degrees of freedom in the result. More...

#include <generic_projector.h>

Classes
struct	ProjectEdges

struct	ProjectInteriors

struct	ProjectSides

struct	ProjectVertices

struct	SortAndCopy

struct	SubFunctor

struct	SubProjector

Public Types
typedef std::unordered_map< dof_id_type, std::vector< dof_id_type > >	NodesToElemMap
	Convenience typedef for the Node-to-attached-Elem mapping that may be passed in to the constructor.

typedef std::set< unsigned int >	var_set

typedef std::pair< const Node , std::tuple< const Elem , unsigned short, var_set > >	node_projection

typedef StoredRange< std::vector< node_projection >::const_iterator, node_projection >	node_range

typedef StoredRange< std::vector< const Elem * >::const_iterator, const Elem * >	interior_range

Public Member Functions
	GenericProjector (const System &system_in, FFunctor &f_in, GFunctor g_in, ProjectionAction &act_in, const std::vector< unsigned int > &variables_in, NodesToElemMap nodes_to_elem_in=nullptr)

	GenericProjector (const GenericProjector &in)

	~GenericProjector ()=default

void	project (const ConstElemRange &range)
	Function definitions.

template<typename Value >
void	send_and_insert_dof_values (std::unordered_map< dof_id_type, std::pair< Value, processor_id_type > > &ids_to_push, ProjectionAction &action) const

Public Attributes
std::unordered_map< dof_id_type, typename FFunctor::ValuePushType >	ids_to_save

Private Attributes
const System &	system

FFunctor &	master_f

std::unique_ptr< GFunctor >	master_g_deepcopy
	Needed for C1 type elements only.

GFunctor *	master_g

ProjectionAction &	master_action

const std::vector< unsigned int > &	variables

NodesToElemMap	nodes_to_elem_ourcopy
	nodes_to_elem is either a shallow copy of a map passed in to the constructor, or points to nodes_to_elem_ourcopy, if no such map was provided.

NodesToElemMap *	nodes_to_elem

bool	done_saving_ids

Detailed Description

template<typename FFunctor, typename GFunctor, typename FValue, typename ProjectionAction>
class libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >

The GenericProjector class implements the core of other projection operations, using two input functors to read values to be projected and an output functor to set degrees of freedom in the result.

This may be executed in parallel on multiple threads.

Author: Roy H. Stogner

Date: 2016

Definition at line 83 of file generic_projector.h.

Member Typedef Documentation

◆ interior_range

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

typedef StoredRange<std::vector<const Elem *>::const_iterator, const Elem *> libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::interior_range

Definition at line 367 of file generic_projector.h.

◆ node_projection

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

typedef std::pair<const Node *, std::tuple<const Elem *, unsigned short, var_set> > libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::node_projection

Definition at line 247 of file generic_projector.h.

◆ node_range

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

typedef StoredRange<std::vector<node_projection>::const_iterator, node_projection> libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::node_range

Definition at line 250 of file generic_projector.h.

◆ NodesToElemMap

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

typedef std::unordered_map<dof_id_type, std::vector<dof_id_type> > libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::NodesToElemMap

Convenience typedef for the Node-to-attached-Elem mapping that may be passed in to the constructor.

Definition at line 90 of file generic_projector.h.

◆ var_set

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

typedef std::set<unsigned int> libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::var_set

Definition at line 165 of file generic_projector.h.

Constructor & Destructor Documentation

◆ GenericProjector() [1/2]

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::GenericProjector	(	const System &	system_in,
		FFunctor &	f_in,
		GFunctor *	g_in,
		ProjectionAction &	act_in,
		const std::vector< unsigned int > &	variables_in,
		NodesToElemMap *	nodes_to_elem_in = `nullptr`
	)

inline

Definition at line 122 of file generic_projector.h.

                                                                 :
    system(system_in),
    master_f(f_in),
    master_g(g_in),
    master_action(act_in),
    variables(variables_in),
    nodes_to_elem(nodes_to_elem_in)
  {
    if (!nodes_to_elem_in)
      {
        MeshTools::build_nodes_to_elem_map (system.get_mesh(), nodes_to_elem_ourcopy);
        nodes_to_elem = &nodes_to_elem_ourcopy;
      }
  }

References libMesh::MeshTools::build_nodes_to_elem_map(), libMesh::System::get_mesh(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::nodes_to_elem, libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::nodes_to_elem_ourcopy, and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::system.

◆ GenericProjector() [2/2]

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::GenericProjector ( const GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction > & in )

inline

Definition at line 142 of file generic_projector.h.

                                                 :
    system(in.system),
    master_f(in.master_f),
    master_g_deepcopy(in.master_g ? std::make_unique<GFunctor>(*in.master_g) : nullptr),
    master_g(in.master_g ? master_g_deepcopy.get() : nullptr),
    master_action(in.master_action),
    variables(in.variables),
    nodes_to_elem(in.nodes_to_elem)
  {}

◆ ~GenericProjector()

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::~GenericProjector ( )

default

Member Function Documentation

◆ project()

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::project ( const ConstElemRange & range )

Function definitions.

Definition at line 1213 of file generic_projector.h.

{
  LOG_SCOPE ("project", "GenericProjector");
 
  // Unless we split sort and copy into two passes we can't know for
  // sure ahead of time whether we need to save the copied ids
  done_saving_ids = false;
 
  SortAndCopy sort_work(*this);
  Threads::parallel_reduce (range, sort_work);
  ProjectionAction action(master_action);
 
  // Keep track of dof ids and values to send to other ranks
  std::unordered_map<dof_id_type, std::pair<typename FFunctor::ValuePushType, processor_id_type>>
      ids_to_push;
 
  ids_to_push.insert(sort_work.new_ids_to_push.begin(),
                     sort_work.new_ids_to_push.end());
  ids_to_save.insert(sort_work.new_ids_to_save.begin(),
                     sort_work.new_ids_to_save.end());
 
  std::vector<node_projection> vertices(sort_work.vertices.begin(),
                                        sort_work.vertices.end());
 
  done_saving_ids = sort_work.edges.empty() &&
    sort_work.sides.empty() && sort_work.interiors.empty();
 
  {
    ProjectVertices project_vertices(*this);
    Threads::parallel_reduce (node_range(&vertices), project_vertices);
    libmesh_merge_move(ids_to_push, project_vertices.new_ids_to_push);
    libmesh_merge_move(ids_to_save, project_vertices.new_ids_to_save);
  }
 
  done_saving_ids = sort_work.sides.empty() && sort_work.interiors.empty();
 
  this->send_and_insert_dof_values(ids_to_push, action);
 
  {
    std::vector<node_projection> edges(sort_work.edges.begin(), sort_work.edges.end());
    ProjectEdges project_edges(*this);
    Threads::parallel_reduce (node_range(&edges), project_edges);
    libmesh_merge_move(ids_to_push, project_edges.new_ids_to_push);
    libmesh_merge_move(ids_to_save, project_edges.new_ids_to_save);
  }
 
  done_saving_ids = sort_work.interiors.empty();
 
  this->send_and_insert_dof_values(ids_to_push, action);
 
  {
    std::vector<node_projection> sides(sort_work.sides.begin(), sort_work.sides.end());
    ProjectSides project_sides(*this);
    Threads::parallel_reduce (node_range(&sides), project_sides);
    libmesh_merge_move(ids_to_push, project_sides.new_ids_to_push);
    libmesh_merge_move(ids_to_save, project_sides.new_ids_to_save);
  }
 
  done_saving_ids = true;
  this->send_and_insert_dof_values(ids_to_push, action);
 
  // No ids to save or push this time, but we still use a reduce since
  // nominally ProjectInteriors still has non-const operator()
  ProjectInteriors project_interiors(*this);
  Threads::parallel_reduce (interior_range(&sort_work.interiors),
                            project_interiors);
}

References libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::edges, libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::interiors, libMesh::libmesh_merge_move(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::new_ids_to_push, libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::new_ids_to_save, libMesh::Threads::parallel_reduce(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::sides, and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::vertices.

◆ send_and_insert_dof_values()

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

template<typename Value >

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values	(	std::unordered_map< dof_id_type, std::pair< Value, processor_id_type > > &	ids_to_push,
		ProjectionAction &	action
	)		const

Definition at line 2905 of file generic_projector.h.

{
  LOG_SCOPE ("send_and_insert_dof_values", "GenericProjector");
 
  // See if we calculated any ids that need to be pushed; get them
  // ready to push.
  std::unordered_map<processor_id_type, std::vector<dof_id_type>>
    pushed_dof_ids, received_dof_ids;
  std::unordered_map<processor_id_type, std::vector<typename TypeToSend<Value>::type>>
    pushed_dof_values, received_dof_values;
  for (auto & id_val_pid : ids_to_push)
    {
      processor_id_type pid = id_val_pid.second.second;
      if (pid != DofObject::invalid_processor_id)
        {
          pushed_dof_ids[pid].push_back(id_val_pid.first);
          pushed_dof_values[pid].push_back(convert_to_send(id_val_pid.second.first));
        }
    }
 
  // If and when we get ids pushed to us, act on them if we have
  // corresponding values or save them if not
  auto ids_action_functor =
    [&action, &received_dof_ids, &received_dof_values]
    (processor_id_type pid,
     const std::vector<dof_id_type> & data)
    {
      auto iter = received_dof_values.find(pid);
      if (iter == received_dof_values.end())
        {
          libmesh_assert(received_dof_ids.find(pid) ==
                         received_dof_ids.end());
          received_dof_ids[pid] = data;
        }
      else
        {
          auto & vals = iter->second;
          std::size_t vals_size = vals.size();
          libmesh_assert_equal_to(vals_size, data.size());
          for (std::size_t i=0; i != vals_size; ++i)
            {
              Value val;
              convert_from_receive(vals[i], val);
              action.insert(data[i], val);
            }
          received_dof_values.erase(iter);
        }
    };
 
  // If and when we get values pushed to us, act on them if we have
  // corresponding ids or save them if not
  auto values_action_functor =
    [&action, &received_dof_ids, &received_dof_values]
    (processor_id_type pid,
     const std::vector<typename TypeToSend<Value>::type> & data)
    {
      auto iter = received_dof_ids.find(pid);
      if (iter == received_dof_ids.end())
        {
          // We get no more than 1 values vector from anywhere
          libmesh_assert(received_dof_values.find(pid) ==
                         received_dof_values.end());
          received_dof_values[pid] = data;
        }
      else
        {
          auto & ids = iter->second;
          std::size_t ids_size = ids.size();
          libmesh_assert_equal_to(ids_size, data.size());
          for (std::size_t i=0; i != ids_size; ++i)
            {
              Value val;
              convert_from_receive(data[i], val);
              action.insert(ids[i], val);
            }
          received_dof_ids.erase(iter);
        }
    };
 
  Parallel::push_parallel_vector_data
    (system.comm(), pushed_dof_ids, ids_action_functor);
 
  Parallel::push_parallel_vector_data
    (system.comm(), pushed_dof_values, values_action_functor);
 
  // At this point we shouldn't have any unprocessed data left
  libmesh_assert(received_dof_ids.empty());
  libmesh_assert(received_dof_values.empty());
 
}

References libMesh::ParallelObject::comm(), libMesh::convert_from_receive(), libMesh::convert_to_send(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), TIMPI::push_parallel_vector_data(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::system.

Member Data Documentation

◆ done_saving_ids

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

bool libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::done_saving_ids

private

Definition at line 119 of file generic_projector.h.

◆ ids_to_save

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

std::unordered_map<dof_id_type, typename FFunctor::ValuePushType> libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ids_to_save

Definition at line 161 of file generic_projector.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection().

◆ master_action

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

ProjectionAction& libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::master_action

private

Definition at line 108 of file generic_projector.h.

◆ master_f

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

FFunctor& libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::master_f

private

Definition at line 97 of file generic_projector.h.

◆ master_g

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

GFunctor* libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::master_g

private

Definition at line 106 of file generic_projector.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::SubProjector().

◆ master_g_deepcopy

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

std::unique_ptr<GFunctor> libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::master_g_deepcopy

private

Needed for C1 type elements only.

master_g is either a shallow copy of a GFunctor pointer passed to the constructor, or to master_g_deepcopy.get(), depending on which constructor was called.

Definition at line 105 of file generic_projector.h.

◆ nodes_to_elem

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

NodesToElemMap* libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::nodes_to_elem

private

Definition at line 117 of file generic_projector.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::GenericProjector().

◆ nodes_to_elem_ourcopy

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

NodesToElemMap libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::nodes_to_elem_ourcopy

private

nodes_to_elem is either a shallow copy of a map passed in to the constructor, or points to nodes_to_elem_ourcopy, if no such map was provided.

Definition at line 116 of file generic_projector.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::GenericProjector().

◆ system

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

const System& libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::system

private

Definition at line 93 of file generic_projector.h.

◆ variables

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

const std::vector<unsigned int>& libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::variables

private

Definition at line 109 of file generic_projector.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::SubProjector().

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

include/systems/generic_projector.h

Classes

Public Types

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

Member Typedef Documentation

◆ interior_range

◆ node_projection

◆ node_range

◆ NodesToElemMap

◆ var_set

Constructor & Destructor Documentation

◆ GenericProjector() [1/2]

◆ GenericProjector() [2/2]

◆ ~GenericProjector()

Member Function Documentation

◆ project()

◆ send_and_insert_dof_values()

Member Data Documentation

◆ done_saving_ids

◆ ids_to_save

◆ master_action

◆ master_f

◆ master_g

◆ master_g_deepcopy

◆ nodes_to_elem

◆ nodes_to_elem_ourcopy

◆ system

◆ variables