viennagrid/mesh/mesh_operations.hpp

Go to the documentation of this file.

#ifndef VIENNAGRID_MESH_OPERATIONS_HPP
#define VIENNAGRID_MESH_OPERATIONS_HPP

/* =======================================================================
   Copyright (c) 2011-2014, Institute for Microelectronics,
                            Institute for Analysis and Scientific Computing,
                            TU Wien.

                            -----------------
                     ViennaGrid - The Vienna Grid Library
                            -----------------

   License:      MIT (X11), see file LICENSE in the base directory
======================================================================= */

#include "viennagrid/forwards.hpp"
#include "viennagrid/mesh/mesh.hpp"
#include "viennagrid/mesh/segmentation.hpp"
#include "viennagrid/mesh/element_creation.hpp"
#include "viennagrid/mesh/coboundary_iteration.hpp"
#include "viennagrid/functors.hpp"

namespace viennagrid
{

  template<typename SrcMeshT, typename DstMeshT>
  class vertex_copy_map
  {
  public:
    vertex_copy_map( DstMeshT & dst_mesh_ ) : dst_mesh(dst_mesh_) {}

    typedef typename viennagrid::result_of::coord<DstMeshT>::type DstNumericType;

    typedef typename viennagrid::result_of::vertex<SrcMeshT>::type SrcVertexType;
    typedef typename viennagrid::result_of::vertex_id<SrcMeshT>::type SrcVertexIDType;

    typedef typename viennagrid::result_of::vertex<DstMeshT>::type DstVertexType;
    typedef typename viennagrid::result_of::vertex_handle<DstMeshT>::type DstVertexHandleType;

    DstVertexHandleType operator()( SrcVertexType const & src_vertex, DstNumericType tolerance = 0.0 )
    {
      typename std::map<SrcVertexIDType, DstVertexHandleType>::iterator vit = vertex_map.find( src_vertex.id() );
      if (vit != vertex_map.end())
        return vit->second;
      else
      {
        DstVertexHandleType vh = viennagrid::make_unique_vertex( dst_mesh, viennagrid::point(src_vertex), tolerance );
        vertex_map[src_vertex.id()] = vh;
        return vh;
      }
    }

    template<typename ElementTagT, typename WrappedConfigT>
    typename viennagrid::result_of::handle<DstMeshT, ElementTagT>::type copy_element( element<ElementTagT, WrappedConfigT> const & el, DstNumericType tolerance = 0.0 )
    {
      typedef element<ElementTagT, WrappedConfigT> ElementType;
      typedef typename viennagrid::result_of::const_vertex_range<ElementType>::type ConstVerticesOnElementRangeType;
      typedef typename viennagrid::result_of::iterator<ConstVerticesOnElementRangeType>::type ConstVerticesOnElementIteratorType;

      std::vector<DstVertexHandleType> vertex_handles;

      ConstVerticesOnElementRangeType vertices(el);
      for (ConstVerticesOnElementIteratorType vit = vertices.begin(); vit != vertices.end(); ++vit)
        vertex_handles.push_back( (*this)(*vit, tolerance) );

      return viennagrid::make_element<ElementTagT>( dst_mesh, vertex_handles.begin(), vertex_handles.end() );
    }

  private:

    DstMeshT & dst_mesh;
    std::map<SrcVertexIDType, DstVertexHandleType> vertex_map;
  };




  template<typename SrcMeshT, typename DstMeshT, typename ToCopyFunctorT>
  void copy(SrcMeshT const & src_mesh, DstMeshT & dst_mesh, ToCopyFunctorT functor)
  {
    dst_mesh.clear();

    viennagrid::vertex_copy_map<SrcMeshT, DstMeshT> vertex_map(dst_mesh);

    //typedef typename viennagrid::result_of::cell<SrcMeshT>::type CellType;
    //typedef typename viennagrid::result_of::coord<SrcMeshT>::type NumericType;

    typedef typename viennagrid::result_of::const_cell_range<SrcMeshT>::type ConstCellRangeType;
    typedef typename viennagrid::result_of::iterator<ConstCellRangeType>::type ConstCellIteratorType;

    //typedef typename viennagrid::result_of::cell_handle<DstMeshT>::type CellHandleType;

    ConstCellRangeType cells(src_mesh);
    for (ConstCellIteratorType cit = cells.begin(); cit != cells.end(); ++cit)
    {
      if ( functor(*cit) )
        vertex_map.copy_element(*cit );
    }
  }

  template<typename SrcMeshT, typename SrcSegmentationT, typename DstMeshT, typename DstSegmentationT, typename ToCopyFunctorT>
  void copy(SrcMeshT const & src_mesh, SrcSegmentationT const & src_segmentation,
            DstMeshT       & dst_mesh, DstSegmentationT       & dst_segmentation,
            ToCopyFunctorT functor)
  {
    dst_mesh.clear();
    dst_segmentation.clear();

    viennagrid::vertex_copy_map<SrcMeshT, DstMeshT> vertex_map(dst_mesh);

    //typedef typename viennagrid::result_of::cell<SrcMeshT>::type CellType;
    //typedef typename viennagrid::result_of::coord<SrcMeshT>::type NumericType;

    typedef typename viennagrid::result_of::const_cell_range<SrcMeshT>::type ConstCellRangeType;
    typedef typename viennagrid::result_of::iterator<ConstCellRangeType>::type ConstCellIteratorType;

    typedef typename viennagrid::result_of::cell_handle<DstMeshT>::type CellHandleType;

    ConstCellRangeType cells(src_mesh);
    for (ConstCellIteratorType cit = cells.begin(); cit != cells.end(); ++cit)
    {
      if ( functor(*cit) )
      {
        CellHandleType cell_handle = vertex_map.copy_element(*cit );
        viennagrid::add( dst_segmentation, viennagrid::segment_ids( src_segmentation, *cit ).begin(), viennagrid::segment_ids( src_segmentation, *cit ).end(), cell_handle );
      }
    }
  }

  namespace detail
  {
    template<typename MeshT, typename ToEraseViewT, typename HandleT, typename ReferencingElementTypelist =
        typename viennagrid::result_of::referencing_element_typelist<MeshT, typename viennagrid::detail::result_of::value_type<HandleT>::type >::type >
    struct mark_referencing_elements_impl;

    template<typename MeshT, typename ToEraseViewT, typename HandleT, typename CoboundaryElementT, typename TailT>
    struct mark_referencing_elements_impl<MeshT, ToEraseViewT, HandleT, viennagrid::typelist<CoboundaryElementT, TailT> >
    {
      static void mark(MeshT & mesh_obj, ToEraseViewT & mesh_view, HandleT host_element)
      {
        //typedef viennagrid::typelist<CoboundaryElementT, TailT> ReferencingElementTypelist;
        typedef typename viennagrid::detail::result_of::value_type<HandleT>::type HostElementType;

        //typedef typename viennagrid::result_of::handle<MeshT, CoboundaryElementT>::type CoboundaryElementHandle;
        typedef typename viennagrid::result_of::coboundary_range<MeshT, HostElementType, CoboundaryElementT>::type CoboundaryElementRangeType;
        typedef typename viennagrid::result_of::iterator<CoboundaryElementRangeType>::type CoboundaryElementRangeIterator;

        typedef typename viennagrid::result_of::element_range<ToEraseViewT, CoboundaryElementT>::type CoboundaryElementViewRangeType;

        CoboundaryElementRangeType coboundary_elements = viennagrid::coboundary_elements<HostElementType, CoboundaryElementT>(mesh_obj, host_element);
        for (CoboundaryElementRangeIterator it = coboundary_elements.begin(); it != coboundary_elements.end(); ++it)
        {
          CoboundaryElementViewRangeType view_elements( mesh_view );
          if ( viennagrid::find_by_handle(mesh_view, it.handle()) == view_elements.end() )
          {
            view_elements.insert_unique_handle( it.handle() );
          }
        }

        mark_referencing_elements_impl<MeshT, ToEraseViewT, HandleT, TailT>::mark(mesh_obj, mesh_view, host_element);
      }
    };

    template<typename MeshT, typename ToEraseViewT, typename HandleT>
    struct mark_referencing_elements_impl<MeshT, ToEraseViewT, HandleT, viennagrid::null_type >
    {
      static void mark(MeshT &, ToEraseViewT &, HandleT) {}
    };

  } //namespace detail

  template<typename MeshT, typename MeshViewT, typename HandleT>
  void mark_referencing_elements( MeshT & mesh_obj, MeshViewT & element_view, HandleT host_element )
  {
    detail::mark_referencing_elements_impl<MeshT, MeshViewT, HandleT>::mark(mesh_obj, element_view, host_element);
  }

}

#endif