Method initializeFEData

src/IB/IBFEPatchRecoveryPostProcessor.cpp:195–396

} // ~IBFEPatchRecoveryPostProcessor

void
IBFEPatchRecoveryPostProcessor::initializeFEData(const PeriodicBoundaries* const periodic_boundaries)
{
    d_periodic_boundaries = periodic_boundaries;

    const Parallel::Communicator& comm = d_mesh->comm();
    const int mpi_rank = comm.rank();
    const int mpi_size = comm.size();

    // Active local elements.
    const MeshBase::const_element_iterator el_begin = d_mesh->active_local_elements_begin();
    const MeshBase::const_element_iterator el_end = d_mesh->active_local_elements_end();

    // Determine the element patches associated with each node N, which is
    // defined to be the collection of elements that contain node N.
    //
    // Unlike the standard Z-Z patch recovery algorithm, we use "tight" element
    // patches for non-vertex nodes.
    std::unique_ptr<PointLocatorBase> point_locator = PointLocatorBase::build(TREE, *d_mesh);
    for (MeshBase::const_element_iterator el_it = el_begin; el_it != el_end; ++el_it)
    {
        const Elem* const elem = *el_it;
        for (unsigned int n = 0; n < elem->n_nodes(); ++n)
        {
            // Only set up patches for local nodes.
            const Node* const node = elem->get_node_ptr(n);
            if (node->processor_id() != mpi_rank) continue;

            // Only set up patches once for each node.
            const dof_id_type node_id = node->id();
            if (d_local_elem_patches.find(node_id) != d_local_elem_patches.end()) continue;

            // Find the elements that touch this node.
            ElemPatch& elem_patch = d_local_elem_patches[node_id];
            std::set<const Elem*> elems;
            elem->find_point_neighbors(*node, elems);
            for (std::set<const Elem*>::const_iterator it = elems.begin(); it != elems.end(); ++it)
            {
                elem_patch.insert(boost::make_tuple(*it, CompositePeriodicMapping(), CompositePeriodicMapping()));
            }

            // Account for periodic boundaries.
            bool done = false || !d_periodic_boundaries;
            while (!done)
            {
                ElemPatch periodic_neighbors;
                for (ElemPatch::const_iterator it = elem_patch.begin(); it != elem_patch.end(); ++it)
                {
                    const Elem* const elem = it->get<0>();
                    const CompositePeriodicMapping& forward_mapping = it->get<1>();
                    const CompositePeriodicMapping& inverse_mapping = it->get<2>();
                    const libMesh::Point p = apply_composite_periodic_mapping(forward_mapping, *node);
                    TBOX_ASSERT(elem->contains_point(p));
                    for (unsigned int i = 0; i < elem->n_neighbors(); ++i)
                    {
                        if (!elem->neighbor_ptr(i))
                        {
                            const std::vector<boundary_id_type>& boundary_ids =