LocalMeshData.h

// Copyright (C) 2008 Ola Skavhaug
//
// This file is part of DOLFIN.
//
// DOLFIN is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// DOLFIN is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with DOLFIN. If not, see <http://www.gnu.org/licenses/>.
//
// Modified by Anders Logg, 2008-2009.
//
// First added:  2008-11-28
// Last changed: 2013-02-18
//
// Modified by Anders Logg, 2008-2009.
// Modified by Kent-Andre Mardal, 2011.

#ifndef __LOCAL_MESH_DATA_H
#define __LOCAL_MESH_DATA_H

#include <cstdint>
#include <map>
#include <vector>
#include <boost/multi_array.hpp>
#include <dolfin/common/MPI.h>
#include <dolfin/common/Variable.h>
#include "CellType.h"

namespace dolfin
{

  class Mesh;



  class LocalMeshData : public Variable
  {
  public:

    explicit LocalMeshData(const MPI_Comm mpi_comm);

    explicit LocalMeshData(const Mesh& mesh);

    ~LocalMeshData();

    void check() const;

    std::string str(bool verbose) const;

    void clear();

    void extract_mesh_data(const Mesh& mesh);

    void broadcast_mesh_data(const MPI_Comm mpi_comm);

    void receive_mesh_data(const MPI_Comm mpi_comm);

    void reorder();

    struct Geometry
    {
      Geometry() : dim(-1), num_global_vertices(-1) {}

      int dim;

      std::int64_t num_global_vertices;

      boost::multi_array<double, 2> vertex_coordinates;

      std::vector<std::int64_t> vertex_indices;

      void clear()
      {
        dim = -1;
        num_global_vertices = -1;
        vertex_coordinates.resize(boost::extents[0][0]);
        vertex_indices.clear();
      }

      void unpack_vertex_coordinates(const std::vector<double>& values);
    };

    Geometry geometry;

    struct Topology
    {
      Topology() : dim(-1), num_global_cells(-1) {}

      int dim;

      std::int64_t num_global_cells;

      int num_vertices_per_cell;

      boost::multi_array<std::int64_t, 2> cell_vertices;

      std::vector<std::int64_t> global_cell_indices;

      std::vector<int> cell_partition;

      std::vector<std::size_t> cell_weight;

      // FIXME: this should replace the need for num_vertices_per_cell
      //        and tdim
      CellType::Type cell_type;

      void clear()
      {
        dim = -1;
        num_global_cells = -1;
        num_vertices_per_cell = -1;
        cell_vertices.resize(boost::extents[0][0]);
        global_cell_indices.clear();
        cell_partition.clear();
        cell_weight.clear();
      }

      void unpack_cell_vertices(const std::vector<std::int64_t>& values);

    };

    Topology topology;

    std::map<std::size_t, std::vector<std::pair<std::pair<std::size_t,
      std::size_t>, std::size_t>>> domain_data;

    MPI_Comm mpi_comm() const
    { return _mpi_comm.comm(); }

  private:

    // MPI communicator
    dolfin::MPI::Comm _mpi_comm;

  };

}

#endif