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)
void	insert_id (dof_id_type id, const FValue &val, processor_id_type pid)
void	insert_ids (const std::vector< dof_id_type > &ids, const std::vector< FValue > &vals, processor_id_type pid)
void	join (const SubFunctor &other)

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

Protected Attributes
ProjectionAction	action
FFunctor	f
FEMContext	context
std::vector< FEContinuity >	conts
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 153 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 1031 of file generic_projector.h.

                         :
  projector(p), action(p.master_action), f(p.master_f),
  context(p.system), conts(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]
      FEBase * fe = nullptr;
      FEBase * side_fe = nullptr;
      FEBase * 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->get_phi();
          if (dim > 1)
            {
              side_fe->get_JxW();
              side_fe->get_xyz();
              side_fe->get_phi();
            }
          if (dim > 2)
            {
              edge_fe->get_JxW();
              edge_fe->get_xyz();
              edge_fe->get_phi();
            }
 
          const FEContinuity cont = fe->get_continuity();
          this->conts[var] = cont;
          if (cont == C_ONE)
            {
              fe->get_dphi();
              if (dim > 1)
                side_fe->get_dphi();
              if (dim > 2)
                edge_fe->get_dphi();
            }
        }
    }
 
  // Now initialize any user requested shape functions, xyz vals, etc
  f.init_context(context);
}

References libMesh::C_ONE, dim, libMesh::FEType::family, libMesh::FEAbstract::get_continuity(), libMesh::FEGenericBase< OutputType >::get_dphi(), libMesh::FEAbstract::get_fe_type(), libMesh::FEAbstract::get_JxW(), libMesh::FEGenericBase< OutputType >::get_phi(), libMesh::FEAbstract::get_xyz(), and libMesh::SCALAR.

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

{
  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;
    }
}

References libMesh::Elem::active(), libMesh::Variable::active_on_subdomain(), libMesh::DofMap::dof_indices(), libMesh::MeshBase::elem_ref(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::Parallel::Utils::is_sorted(), libMesh::libmesh_assert(), mesh, libMesh::Elem::node_ptr(), libMesh::DofObject::processor_id(), and libMesh::Elem::subdomain_id().

insert_id()

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

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

Definition at line 1117 of file generic_projector.h.

{
  auto iter = new_ids_to_push.find(id);
  if (iter == new_ids_to_push.end())
    action.insert(id, val);
  else
    {
      libmesh_assert(pid != DofObject::invalid_processor_id);
      iter->second = std::make_pair(val, pid);
    }
  if (!this->projector.done_saving_ids)
    {
      libmesh_assert(!new_ids_to_save.count(id));
      new_ids_to_save[id] = val;
    }
}

References libMesh::DofObject::invalid_processor_id, and libMesh::libmesh_assert().

insert_ids()

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

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

Definition at line 1138 of file generic_projector.h.

{
  libmesh_assert_equal_to(ids.size(), vals.size());
  for (auto i : index_range(ids))
    {
      const dof_id_type id = ids[i];
      const FValue & val = vals[i];
 
      auto iter = new_ids_to_push.find(id);
      if (iter == new_ids_to_push.end())
        action.insert(id, val);
      else
        {
          libmesh_assert(pid != DofObject::invalid_processor_id);
          iter->second = std::make_pair(val, pid);
        }
      if (!this->projector.done_saving_ids)
        {
          libmesh_assert(!new_ids_to_save.count(id));
          new_ids_to_save[id] = val;
        }
    }
}

References libMesh::index_range(), libMesh::DofObject::invalid_processor_id, and libMesh::libmesh_assert().

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

{
  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());
}

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

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 193 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 198 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 201 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 194 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<FValue, processor_id_type> > libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::new_ids_to_push

Definition at line 165 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, FValue> libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::new_ids_to_save

Definition at line 169 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 154 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 203 of file generic_projector.h.

---

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

• include/systems/generic_projector.h