mesh_worker_loop.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//    $Id: mesh_worker_loop.h 1348 2013-08-16 00:45:07Z secanell $
//
//    Copyright (C) 2006, 2007, 2008, 2009 by Guido Kanschat
//
//    This file is subject to QPL and may not be  distributed
//    without copyright and license information. Please refer
//    to the file deal.II/doc/license.html for the  text  and
//    further information on this license.
//
//---------------------------------------------------------------------------

#ifndef __deal2__mesh_worker_loop_h
#define __deal2__mesh_worker_loop_h

namespace MeshWorker
{
  namespace internal
  {
    template <class DI>
    bool is_active_iterator(const DI&)
    {
      return false;
    }

    template <class Accessor>
    bool is_active_iterator(const TriaActiveIterator<Accessor>&)
    {
      return true;
    }
  }
  

  template<class ITERATOR, class ENDITERATOR, class CELLINFO, class FACEINFO, class LOCALWORKER>
  void loop(ITERATOR begin, ENDITERATOR end,
            CELLINFO& cellinfo, FACEINFO& bdryinfo,
            FACEINFO& faceinfo, FACEINFO& subfaceinfo, FACEINFO& ngbrinfo,
            LOCALWORKER& localworker,
            bool cells_first = true)
  {
    const_cast<Triangulation<ITERATOR::AccessorType::Container::dimension>&>(
      begin->get_triangulation()).clear_user_flags();
    
                                     // Loop over all cells
    for (ITERATOR cell = begin; cell != end; ++cell)
      {
                                         // Execute this, if cells
                                         // have to be dealt with
                                         // before faces
        if (cells_first)
          {
            cellinfo.reinit(cell);
            localworker.cell(cellinfo);
          }
        

        if (localworker.interior_fluxes || localworker.boundary_fluxes)
          for (unsigned int face_no=0; face_no < GeometryInfo<ITERATOR::AccessorType::Container::dimension>::faces_per_cell; ++face_no)
            {
              typename ITERATOR::AccessorType::Container::face_iterator face = cell->face(face_no);
                                               // Treat every face only once
              if (face->user_flag_set ()) continue;
              
              if (cell->at_boundary(face_no))
                {
                  if (localworker.boundary_fluxes)
                    {
                      bdryinfo.reinit(cell, face, face_no);
                      localworker.bdry(bdryinfo);
                    }
                }
              else if (localworker.interior_fluxes)
                {
                  if (face->user_flag_set ()) continue;
                  face->set_user_flag ();
                                                   // Interior face
                  typename ITERATOR::AccessorType::Container::cell_iterator
                    neighbor = cell->neighbor(face_no);
                  
                                                   // Deal with
                                                   // refinement edges
                                                   // from the refined
                                                   // side. Assuming
                                                   // one-irregular
                                                   // meshes, this
                                                   // situation should
                                                   // only occur if
                                                   // both cells are
                                                   // active.
                  if (neighbor->level() < cell->level())
                    {
                      Assert(!cell->has_children(), ExcInternalError());
                      Assert(!neighbor->has_children(), ExcInternalError());
                      
                      std::pair<unsigned int, unsigned int> neighbor_face_no
                        = cell->neighbor_of_coarser_neighbor(face_no);
                      typename ITERATOR::AccessorType::Container::face_iterator nface
                        = neighbor->face(neighbor_face_no.first);
                      faceinfo.reinit(cell, face, face_no);
                      subfaceinfo.reinit(neighbor, nface, neighbor_face_no.first, neighbor_face_no.second);
                                                       // Neighbor
                                                       // first to
                                                       // conform to
                                                       // old version
                      localworker.face(faceinfo, subfaceinfo);
                    }
                  else
                    {
                                                       // Neighbor is
                                                       // on same
                                                       // level

                                                       // If iterator
                                                       // is active
                                                       // and neighbor
                                                       // is refined,
                                                       // skip
                                                       // internal face.
                      if (internal::is_active_iterator(cell) && neighbor->has_children())
                        continue;
                      
                      unsigned int neighbor_face_no = cell->neighbor_of_neighbor(face_no);
                      Assert (neighbor->face(neighbor_face_no) == face, ExcInternalError());
                                                       // Regular interior face
                      faceinfo.reinit(cell, face, face_no);
                      ngbrinfo.reinit(neighbor, neighbor->face(neighbor_face_no),
                                      neighbor_face_no);
                      
                      localworker.face(faceinfo, ngbrinfo);
                      neighbor->face(neighbor_face_no)->set_user_flag ();
                    }
                  
                }
            } // faces
                                         // Execute this, if faces
                                         // have to be handled first
        if (!cells_first)
          {
            cellinfo.reinit(cell);
            localworker.cell(cellinfo);
          }
      }
  }

  template<int dim, class ITERATOR, class ENDITERATOR, class LOCALWORKER>
  void integration_loop(ITERATOR begin, ENDITERATOR end,
                        InfoObjects::IntegrationInfoBox<dim>& box,
                        LOCALWORKER& localworker,
                        bool cells_first = true)
  {
    loop(begin, end, box.cell_info, box.bdry_info,
         box.face_info, box.subface_info, box.neighbor_info,
         localworker, cells_first);
  }
}

#endif