MPI_Migration.h

浏览该文件的文档。

#ifndef __MPI_Migration_h__
#define __MPI_Migration_h__

#include <mpi.h>
#include <boost/program_options.hpp>
#include <AFEPack/Migration.details.h>
#include <AFEPack/mpi/MPI_HGeometry.h>
#include <AFEPack/FEMSpace.h>

namespace Migration {

  namespace details {

    template <int DOW> void
      clear_data_buffer(HGeometry<0,DOW>& geo) {
      geo.buffer.clear();
    }
    template <int DOW> void
      clear_data_buffer(HGeometry<1,DOW>& geo) {
      geo.buffer.clear();
      for (u_int i = 0;i < geo.n_vertex;++ i) {
        clear_data_buffer(*geo.vertex[i]);
      }
      if (geo.isRefined()) {
        for (u_int i = 0;i < geo.n_child;++ i) {
          clear_data_buffer(*geo.child[i]);
        }
      }
    }
    template <class GEO> void
      clear_data_buffer(GEO& geo) {
      geo.buffer.clear();
      for (u_int i = 0;i < geo.n_boundary;++ i) {
        clear_data_buffer(*geo.boundary[i]);
      }
      if (geo.isRefined()) {
        for (u_int i = 0;i < geo.n_child;++ i) {
          clear_data_buffer(*geo.child[i]);
        }
      }
    }
  }

  template <class HTREE> void
    clear_data_buffer(HTREE& tree) {
    typename HTREE::RootIterator 
      the_ele = tree.beginRootElement(),
      end_ele = tree.endRootElement();
    for (;the_ele != end_ele;++ the_ele) {
      details::clear_data_buffer(*the_ele);
    }
  }

  void initialize(MPI_Comm comm); 
  data_id_t register_data_name(const data_name_t& dn); 
  void load_config(const std::string& filename); 
  void save_config(const std::string& filename); 

  template <class FUNC>
    void export_fe_func(const FUNC& fun,
                        const data_id_t& data_id) {
    typedef FUNC fe_func_t;
    typedef typename fe_func_t::fe_space_t fe_space_t;
    typedef typename fe_space_t::dof_info_t dof_info_t;
    typedef RegularMesh<fe_space_t::dim,fe_space_t::dow> mesh_t;
    const fe_space_t& sp = fun.femSpace();
    const mesh_t& mesh = dynamic_cast<const mesh_t&>(sp.mesh());
    AFEPack::ostream<> os;
    u_int n_dof = sp.n_dof();
    for (u_int i = 0;i < n_dof;++ i) {
      const dof_info_t& di = sp.dofInfo(i);
      const DOFIndex& dof_idx = sp.dofIndex(i);
      get_export_stream(mesh,
                        data_id,
                        dof_idx.dimension,
                        dof_idx.geometry_index,
                        os);
      os << di.identity
         << di.interp_point 
         << fun(i);
    }
  }
  template <class FUNC>
    void export_fe_func(const std::vector<FUNC>& fun,
                        const data_id_t& data_id) {
    typedef FUNC fe_func_t;
    typedef typename fe_func_t::fe_space_t fe_space_t;
    typedef typename fe_space_t::dof_info_t dof_info_t;
    typedef RegularMesh<fe_space_t::dim,fe_space_t::dow> mesh_t;
    const fe_space_t& sp = fun[0].femSpace();
    const mesh_t& mesh = dynamic_cast<const mesh_t&>(sp.mesh());
    AFEPack::ostream<> os;
    u_int n_dof = sp.n_dof();
    for (u_int i = 0;i < n_dof;++ i) {
      const dof_info_t& di = sp.dofInfo(i);
      const DOFIndex& dof_idx = sp.dofIndex(i);
      get_export_stream(mesh,
                        data_id,
                        dof_idx.dimension,
                        dof_idx.geometry_index,
                        os);
      os << di.identity
         << di.interp_point;
      for(u_int j=0; j<fun.size(); j++)
        os<< fun[j](i);
    }
  }

  template <class FUNC>
    void import_fe_func(FUNC& fun,
                        const data_id_t& data_id) {
    typedef FUNC fe_func_t;
    typedef typename fe_func_t::fe_space_t fe_space_t;
    typedef typename fe_space_t::dof_info_t dof_info_t;
    typedef RegularMesh<fe_space_t::dim,fe_space_t::dow> mesh_t;
    const fe_space_t& sp = fun.femSpace();
    const mesh_t& mesh = dynamic_cast<const mesh_t&>(sp.mesh());
    AFEPack::istream<> is;
    u_int n_dof = sp.n_dof();
    for (u_int i = 0;i < n_dof;++ i) {
      const dof_info_t& di = sp.dofInfo(i);
      const DOFIndex& dof_idx = sp.dofIndex(i);
      double D = di.interp_point.length();
      get_import_stream(mesh,
                        data_id,
                        dof_idx.dimension,
                        dof_idx.geometry_index,
                        is);
      do {
        dof_info_t dof_info;
        is >> dof_info.identity
           >> dof_info.interp_point 
           >> fun(i);
        if (!(dof_info.identity == di.identity)) continue;
        double D1 = dof_info.interp_point.length() + D;
        if (distance(dof_info.interp_point, 
                     di.interp_point) <= 1.0e-08*D1) break;
      } while (1);
    }
  }

  template <class FUNC>
    void import_fe_func(std::vector<FUNC> & fun,
                        const data_id_t& data_id) {
    typedef FUNC fe_func_t;
    typedef typename fe_func_t::fe_space_t fe_space_t;
    typedef typename fe_space_t::dof_info_t dof_info_t;
    typedef RegularMesh<fe_space_t::dim,fe_space_t::dow> mesh_t;
    const fe_space_t& sp = fun[0].femSpace();
    const mesh_t& mesh = dynamic_cast<const mesh_t&>(sp.mesh());
    AFEPack::istream<> is;
    u_int n_dof = sp.n_dof();
    for (u_int i = 0;i < n_dof;++ i) {
      const dof_info_t& di = sp.dofInfo(i);
      const DOFIndex& dof_idx = sp.dofIndex(i);
      double D = di.interp_point.length();
      get_import_stream(mesh,
                        data_id,
                        dof_idx.dimension,
                        dof_idx.geometry_index,
                        is);
      do {
        dof_info_t dof_info;
        is >> dof_info.identity
           >> dof_info.interp_point;
        for(u_int j=0; j<fun.size(); j++)
          is >> fun[j](i);
        if (!(dof_info.identity == di.identity)) continue;
        double D1 = dof_info.interp_point.length() + D;
        if (distance(dof_info.interp_point, 
                     di.interp_point) <= 1.0e-08*D1) break;
      } while (1);
    }
  }


}

#endif // __MPI_Migration_h__