libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor Struct Reference

#include <generic_projector.h>

Inheritance diagram for libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor:

Public Member Functions
	SubFunctor (GenericProjector &p)
void	find_dofs_to_send (const Node &node, const Elem &elem, unsigned short node_num, const var_set &vars)
template<typename InsertInput , typename std::enable_if< std::is_same< typename ProjectionAction::InsertInput, InsertInput >::value, int >::type = 0>
void	insert_id (dof_id_type id, const InsertInput &val, processor_id_type pid)
template<typename InsertInput , typename std::enable_if< !std::is_same< typename ProjectionAction::InsertInput, InsertInput >::value, int >::type = 0>
void	insert_id (dof_id_type id, const InsertInput &val, processor_id_type pid)
template<typename InsertInput , typename std::enable_if< std::is_same< typename ProjectionAction::InsertInput, InsertInput >::value, int >::type = 0>
void	insert_ids (const std::vector< dof_id_type > &ids, const std::vector< InsertInput > &vals, processor_id_type pid)
template<typename InsertInput , typename std::enable_if< !std::is_same< typename ProjectionAction::InsertInput, InsertInput >::value, int >::type = 0>
void	insert_ids (const std::vector< dof_id_type > &ids, const std::vector< InsertInput > &vals, processor_id_type pid)
void	join (const SubFunctor &other)

Public Attributes
GenericProjector &	projector
std::unordered_map< dof_id_type, std::pair< typename FFunctor::ValuePushType, processor_id_type > >	new_ids_to_push
std::unordered_map< dof_id_type, typename FFunctor::ValuePushType >	new_ids_to_save

Protected Attributes
ProjectionAction	action
FFunctor	f
FEMContext	context
std::vector< FEContinuity >	conts
std::vector< FEFieldType >	field_types
const System &	system

Detailed Description

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

Definition at line 169 of file generic_projector.h.

Constructor & Destructor Documentation

SubFunctor()

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

libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor

(

GenericProjector &

p

)

Definition at line 1286 of file generic_projector.h.

References libMesh::C_ONE, dim, libMesh::FEType::family, libMesh::FEInterface::field_type(), libMesh::FEAbstract::get_continuity(), libMesh::FEAbstract::get_fe_type(), libMesh::FEAbstract::get_JxW(), libMesh::FEAbstract::get_xyz(), libMesh::FEAbstract::request_dphi(), libMesh::FEAbstract::request_phi(), and libMesh::SCALAR.

                         :
  projector(p),
  action(p.master_action),
  f(p.master_f),
  context(p.system, &p.variables, /* allocate_local_matrices= */ false),
  conts(p.system.n_vars()),
  field_types(p.system.n_vars()), system(p.system)
{
  // Loop over all the variables we've been requested to project, to
  // pre-request
  for (const auto & var : this->projector.variables)
    {
      // FIXME: Need to generalize this to vector-valued elements. [PB]
      FEAbstract * fe = nullptr;
      FEAbstract * side_fe = nullptr;
      FEAbstract * edge_fe = nullptr;

      const std::set<unsigned char> & elem_dims =
        context.elem_dimensions();

      for (const auto & dim : elem_dims)
        {
          context.get_element_fe( var, fe, dim );
          if (fe->get_fe_type().family == SCALAR)
            continue;
          if (dim > 1)
            context.get_side_fe( var, side_fe, dim );
          if (dim > 2)
            context.get_edge_fe( var, edge_fe );

          fe->get_JxW();
          fe->get_xyz();
          fe->get_JxW();

          fe->request_phi();
          if (dim > 1)
            {
              side_fe->get_JxW();
              side_fe->get_xyz();
              side_fe->request_phi();
            }
          if (dim > 2)
            {
              edge_fe->get_JxW();
              edge_fe->get_xyz();
              edge_fe->request_phi();
            }

          const FEContinuity cont = fe->get_continuity();
          this->conts[var] = cont;
          if (cont == C_ONE)
            {
              fe->request_dphi();
              if (dim > 1)
                side_fe->request_dphi();
              if (dim > 2)
                edge_fe->request_dphi();
            }

          this->field_types[var] = FEInterface::field_type(fe->get_fe_type());
        }
    }

  // Now initialize any user requested shape functions, xyz vals, etc
  f.init_context(context);
}

Member Function Documentation

find_dofs_to_send()

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

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send	(	const Node &	node,
		const Elem &	elem,
		unsigned short	node_num,
		const var_set &	vars
	)

Definition at line 2845 of file generic_projector.h.

References libMesh::Elem::active(), libMesh::Variable::active_on_subdomain(), libMesh::DofMap::dof_indices(), libMesh::System::get_dof_map(), libMesh::System::get_mesh(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), mesh, libMesh::Elem::node_ptr(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::Elem::subdomain_id(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::system, and libMesh::System::variable().

{
  libmesh_assert (&node == elem.node_ptr(node_num));

  // Any ghosted node in our range might have an owner who needs our
  // data
  const processor_id_type owner = node.processor_id();
  if (owner != system.processor_id())
    {
      const MeshBase & mesh = system.get_mesh();
      const DofMap & dof_map = system.get_dof_map();

      // But let's check and see if we can be certain the owner can
      // compute any or all of its own dof coefficients on that node.
      std::vector<dof_id_type> node_dof_ids, patch_dof_ids;
      for (const auto & var : vars)
        {
          const Variable & variable = system.variable(var);

          if (!variable.active_on_subdomain(elem.subdomain_id()))
            continue;

          dof_map.dof_indices(elem, node_num, node_dof_ids, var);
        }
      libmesh_assert(std::is_sorted(node_dof_ids.begin(),
                                    node_dof_ids.end()));
      const std::vector<dof_id_type> & patch =
        (*this->projector.nodes_to_elem)[node.id()];
      for (const auto & elem_id : patch)
        {
          const Elem & patch_elem = mesh.elem_ref(elem_id);
          if (!patch_elem.active() || owner != patch_elem.processor_id())
            continue;
          dof_map.dof_indices(&patch_elem, patch_dof_ids);
          std::sort(patch_dof_ids.begin(), patch_dof_ids.end());

          // Remove any node_dof_ids that we see can be calculated on
          // this element
          std::vector<dof_id_type> diff_ids(node_dof_ids.size());
          auto it = std::set_difference(node_dof_ids.begin(), node_dof_ids.end(),
                                        patch_dof_ids.begin(), patch_dof_ids.end(), diff_ids.begin());
          diff_ids.resize(it-diff_ids.begin());
          node_dof_ids.swap(diff_ids);
          if (node_dof_ids.empty())
            break;
        }

      // Give ids_to_push default invalid pid: not yet computed
      for (auto id : node_dof_ids)
        new_ids_to_push[id].second = DofObject::invalid_processor_id;
    }
}

insert_id() [1/2]

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

template<typename InsertInput , typename std::enable_if< std::is_same< typename ProjectionAction::InsertInput, InsertInput >::value, int >::type >

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::insert_id	(	dof_id_type	id,
		const InsertInput &	val,
		processor_id_type	pid
	)

Definition at line 1378 of file generic_projector.h.

{
  libmesh_error_msg("ID insertion should only occur when the provided input matches that "
                    "expected by the ProjectionAction");
}

insert_id() [2/2]

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

template<typename InsertInput , typename std::enable_if< !std::is_same< typename ProjectionAction::InsertInput, InsertInput >::value, int >::type = 0>

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::insert_id	(	dof_id_type	id,
		const InsertInput &	val,
		processor_id_type	pid
	)

insert_ids() [1/2]

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

template<typename InsertInput , typename std::enable_if< std::is_same< typename ProjectionAction::InsertInput, InsertInput >::value, int >::type >

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::insert_ids	(	const std::vector< dof_id_type > &	ids,
		const std::vector< InsertInput > &	vals,
		processor_id_type	pid
	)

Definition at line 1420 of file generic_projector.h.

{
  libmesh_error_msg("ID insertion should only occur when the provided input matches that "
                    "expected by the ProjectionAction");
}

insert_ids() [2/2]

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

template<typename InsertInput , typename std::enable_if< !std::is_same< typename ProjectionAction::InsertInput, InsertInput >::value, int >::type = 0>

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::insert_ids	(	const std::vector< dof_id_type > &	ids,
		const std::vector< InsertInput > &	vals,
		processor_id_type	pid
	)

join()

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

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::join

(

const SubFunctor &

other

)

Definition at line 1471 of file generic_projector.h.

References libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::new_ids_to_push, and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::new_ids_to_save.

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

{
  new_ids_to_push.insert(other.new_ids_to_push.begin(), other.new_ids_to_push.end());
  new_ids_to_save.insert(other.new_ids_to_save.begin(), other.new_ids_to_save.end());
}

Member Data Documentation

action

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

ProjectionAction libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::action

protected

Definition at line 231 of file generic_projector.h.

context

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

FEMContext libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::context

protected

Definition at line 236 of file generic_projector.h.

conts

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

std::vector<FEContinuity> libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::conts

protected

Definition at line 239 of file generic_projector.h.

f

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

FFunctor libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::f

protected

Definition at line 232 of file generic_projector.h.

field_types

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

std::vector<FEFieldType> libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::field_types

protected

Definition at line 240 of file generic_projector.h.

new_ids_to_push

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

std::unordered_map<dof_id_type, std::pair<typename FFunctor::ValuePushType, processor_id_type> > libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::new_ids_to_push

Definition at line 183 of file generic_projector.h.

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

new_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 >::SubFunctor::new_ids_to_save

Definition at line 187 of file generic_projector.h.

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

projector

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

GenericProjector& libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::projector

Definition at line 170 of file generic_projector.h.

system

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

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

protected

Definition at line 242 of file generic_projector.h.

---

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

• include/systems/generic_projector.h