libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction > Class Template Reference

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::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, const FFunctor &f_in, const GFunctor *g_in, const ProjectionAction &act_in, const std::vector< unsigned int > &variables_in, std::unordered_map< dof_id_type, std::vector< dof_id_type >> *nodes_to_elem_in=nullptr)
	GenericProjector (const GenericProjector &in)
	~GenericProjector ()
void	project (const ConstElemRange &range)
	Function definitions. More...
void	send_and_insert_dof_values (std::unordered_map< dof_id_type, std::pair< FValue, processor_id_type >> &ids_to_push, ProjectionAction &action) const

Public Attributes
std::unordered_map< dof_id_type, FValue >	ids_to_save

Private Attributes
const System &	system
const FFunctor &	master_f
const GFunctor *	master_g
bool	g_was_copied
bool	map_was_created
const ProjectionAction &	master_action
const std::vector< unsigned int > &	variables
std::unordered_map< dof_id_type, std::vector< dof_id_type > > *	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 80 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 327 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 208 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 211 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 149 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, const FFunctor &  f_in, const GFunctor *  g_in, const ProjectionAction &  act_in, const std::vector< unsigned int > &  variables_in, std::unordered_map< dof_id_type, std::vector< dof_id_type >> *  nodes_to_elem_in = nullptr  )

inline

Definition at line 96 of file generic_projector.h.

                                                  :
    system(system_in),
    master_f(f_in),
    master_g(g_in),
    g_was_copied(false),
    map_was_created(!nodes_to_elem_in),
    master_action(act_in),
    variables(variables_in),
    nodes_to_elem(nodes_to_elem_in)
  {
    if (map_was_created) // past tense misnomer here
      {
        nodes_to_elem = new
          std::unordered_map<dof_id_type, std::vector<dof_id_type>>;
        MeshTools::build_nodes_to_elem_map (system.get_mesh(), *nodes_to_elem);
      }
  }

References libMesh::MeshTools::build_nodes_to_elem_map(), libMesh::System::get_mesh(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::map_was_created, libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::nodes_to_elem, 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 120 of file generic_projector.h.

                                                 :
    system(in.system),
    master_f(in.master_f),
    master_g(in.master_g ? new GFunctor(*in.master_g) : nullptr),
    g_was_copied(in.master_g),
    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 ( )

inline

Definition at line 130 of file generic_projector.h.

  {
    if (g_was_copied)
      delete master_g;
    if (map_was_created)
      delete nodes_to_elem;
  }

References libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::g_was_copied, libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::map_was_created, libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::master_g, and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::nodes_to_elem.

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 951 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<FValue, 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();
  system.comm().max(done_saving_ids);
 
  {
    ProjectVertices project_vertices(*this);
    Threads::parallel_reduce (node_range(&vertices), project_vertices);
    ids_to_push.insert(project_vertices.new_ids_to_push.begin(),
                       project_vertices.new_ids_to_push.end());
    ids_to_save.insert(project_vertices.new_ids_to_save.begin(),
                       project_vertices.new_ids_to_save.end());
  }
 
  done_saving_ids = sort_work.sides.empty() && sort_work.interiors.empty();
  system.comm().max(done_saving_ids);
 
  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);
    ids_to_push.insert(project_edges.new_ids_to_push.begin(),
                       project_edges.new_ids_to_push.end());
    ids_to_save.insert(project_edges.new_ids_to_save.begin(),
                       project_edges.new_ids_to_save.end());
  }
 
  done_saving_ids = sort_work.interiors.empty();
  system.comm().max(done_saving_ids);
 
  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);
    ids_to_push.insert(project_sides.new_ids_to_push.begin(),
                       project_sides.new_ids_to_push.end());
    ids_to_save.insert(project_sides.new_ids_to_save.begin(),
                       project_sides.new_ids_to_save.end());
  }
 
  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::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 >

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

Definition at line 2405 of file generic_projector.h.

{
  // 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<FValue>::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)
            {
              FValue 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<FValue>::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)
            {
              FValue 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::convert_from_receive(), libMesh::convert_to_send(), data, libMesh::DofObject::invalid_processor_id, and libMesh::libmesh_assert().

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 93 of file generic_projector.h.

g_was_copied

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

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

private

Definition at line 89 of file generic_projector.h.

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

ids_to_save

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

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

Definition at line 145 of file generic_projector.h.

map_was_created

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

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

private

Definition at line 89 of file generic_projector.h.

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

master_action

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

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

private

Definition at line 90 of file generic_projector.h.

master_f

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

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

private

Definition at line 87 of file generic_projector.h.

master_g

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

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

private

Definition at line 88 of file generic_projector.h.

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

nodes_to_elem

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

std::unordered_map<dof_id_type, std::vector<dof_id_type> >* libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::nodes_to_elem

private

Definition at line 92 of file generic_projector.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::GenericProjector(), and 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 83 of file generic_projector.h.

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

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 91 of file generic_projector.h.

---

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

• include/systems/generic_projector.h