libMesh::BuildProjectionList Class Reference

This class builds the send_list of old dof indices whose coefficients are needed to perform a projection. More...

Public Member Functions
	BuildProjectionList (const System &system_in)
	BuildProjectionList (BuildProjectionList &other, Threads::split)
void	unique ()
void	operator() (const ConstElemRange &range)
void	join (const BuildProjectionList &other)

Public Attributes
std::vector< dof_id_type >	send_list

Private Attributes
const System &	system

Detailed Description

This class builds the send_list of old dof indices whose coefficients are needed to perform a projection.

This may be executed in parallel on multiple threads. The end result is a send_list vector which is unsorted and may contain duplicate elements. The unique() method can be used to sort and create a unique list.

Definition at line 162 of file system_projection.C.

Constructor & Destructor Documentation

BuildProjectionList() [1/2]

libMesh::BuildProjectionList::BuildProjectionList ( const System &  system_in )

inline

Definition at line 168 of file system_projection.C.

                                                 :
    system(system_in),
    send_list()
  {}

BuildProjectionList() [2/2]

libMesh::BuildProjectionList::BuildProjectionList ( BuildProjectionList &  other, Threads::split    )

inline

Definition at line 173 of file system_projection.C.

                                                                  :
    system(other.system),
    send_list()
  {}

Member Function Documentation

join()

void libMesh::BuildProjectionList::join

(

const BuildProjectionList &

other

)

Definition at line 1524 of file system_projection.C.

{
  // Joining simply requires I add the dof indices from the other object
  this->send_list.insert(this->send_list.end(),
                         other.send_list.begin(),
                         other.send_list.end());
}

References send_list.

operator()()

void libMesh::BuildProjectionList::operator()

(

const ConstElemRange &

range

)

Definition at line 1407 of file system_projection.C.

{
  // The DofMap for this system
  const DofMap & dof_map = system.get_dof_map();
 
  const dof_id_type first_old_dof = dof_map.first_old_dof();
  const dof_id_type end_old_dof   = dof_map.end_old_dof();
 
  // We can handle all the variables at once.
  // The old global DOF indices
  std::vector<dof_id_type> di;
 
  // Iterate over the elements in the range
  for (const auto & elem : range)
    {
      // If this element doesn't have an old_dof_object with dofs for the
      // current system, then it must be newly added, so the user
      // is responsible for setting the new dofs.
 
      // ... but we need a better way to test for that; the code
      // below breaks on any FE type for which the elem stores no
      // dofs.
      // if (!elem->get_old_dof_object() || !elem->get_old_dof_object()->has_dofs(system.number()))
      //  continue;
 
      // Examining refinement flags instead should distinguish
      // between refinement-added and user-added elements lacking
      // old_dof_object
      const DofObject * old_dof_object = elem->get_old_dof_object();
      if (!old_dof_object &&
          elem->refinement_flag() != Elem::JUST_REFINED &&
          elem->refinement_flag() != Elem::JUST_COARSENED)
        continue;
 
      const Elem * parent = elem->parent();
 
      if (elem->refinement_flag() == Elem::JUST_REFINED)
        {
          libmesh_assert(parent);
 
          // We used to hack_p_level here, but that wasn't thread-safe
          // so now we take p refinement flags into account in
          // old_dof_indices
 
          dof_map.old_dof_indices (parent, di);
 
          for (auto & node : elem->node_ref_range())
            {
              const DofObject * old_dofs = node.get_old_dof_object();
 
              if (old_dofs)
                {
                  const unsigned int sysnum = system.number();
                  const unsigned int nvg = old_dofs->n_var_groups(sysnum);
 
                  for (unsigned int vg=0; vg != nvg; ++vg)
                    {
                      const unsigned int nvig =
                        old_dofs->n_vars(sysnum, vg);
                      for (unsigned int vig=0; vig != nvig; ++vig)
                        {
                          const unsigned int n_comp =
                            old_dofs->n_comp_group(sysnum, vg);
                          for (unsigned int c=0; c != n_comp; ++c)
                            {
                              const dof_id_type old_id =
                                old_dofs->dof_number(sysnum, vg, vig,
                                                     c, n_comp);
 
                              // We should either have no old id
                              // (e.g. on a newly expanded subdomain)
                              // or an id from the old system.
                              libmesh_assert(old_id < dof_map.n_old_dofs() ||
                                             old_id == DofObject::invalid_id);
                              di.push_back(old_id);
                            }
                        }
                    }
                }
            }
 
          std::sort(di.begin(), di.end());
          std::vector<dof_id_type>::iterator new_end =
            std::unique(di.begin(), di.end());
          std::vector<dof_id_type>(di.begin(), new_end).swap(di);
        }
      else if (elem->refinement_flag() == Elem::JUST_COARSENED)
        {
          std::vector<dof_id_type> di_child;
          di.clear();
          for (auto & child : elem->child_ref_range())
            {
              dof_map.old_dof_indices (&child, di_child);
              di.insert(di.end(), di_child.begin(), di_child.end());
            }
        }
      else
        dof_map.old_dof_indices (elem, di);
 
      for (auto di_i : di)
        {
          // If we've just expanded a subdomain for a
          // subdomain-restricted variable, then we may have an
          // old_dof_object that doesn't have an old DoF for every
          // local index.
          if (di_i == DofObject::invalid_id)
            continue;
 
          libmesh_assert_less(di_i, dof_map.n_old_dofs());
          if (di_i < first_old_dof || di_i >= end_old_dof)
            this->send_list.push_back(di_i);
        }
    }  // end elem loop
}

References libMesh::DofObject::dof_number(), libMesh::DofMapBase::end_old_dof(), libMesh::DofMapBase::first_old_dof(), libMesh::DofObject::get_old_dof_object(), libMesh::libmesh_assert(), libMesh::DofObject::n_comp_group(), libMesh::DofMapBase::n_old_dofs(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::n_vars(), libMesh::DofMap::old_dof_indices(), and libMesh::Elem::parent().

unique()

void libMesh::BuildProjectionList::unique

(

)

Definition at line 1387 of file system_projection.C.

{
  // Sort the send list.  After this duplicated
  // elements will be adjacent in the vector
  std::sort(this->send_list.begin(),
            this->send_list.end());
 
  // Now use std::unique to remove duplicate entries
  std::vector<dof_id_type>::iterator new_end =
    std::unique (this->send_list.begin(),
                 this->send_list.end());
 
  // Remove the end of the send_list.  Use the "swap trick"
  // from Effective STL
  std::vector<dof_id_type>
    (this->send_list.begin(), new_end).swap (this->send_list);
}

Referenced by libMesh::System::project_vector().

Member Data Documentation

send_list

std::vector<dof_id_type> libMesh::BuildProjectionList::send_list

Definition at line 181 of file system_projection.C.

Referenced by join(), and libMesh::System::project_vector().

system

const System& libMesh::BuildProjectionList::system

private

Definition at line 165 of file system_projection.C.

---

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

• src/systems/system_projection.C