Mesh.h

// Copyright (C) 2006-2016 Anders Logg
//
// 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 Johan Hoffman 2007
// Modified by Magnus Vikstrøm 2007
// Modified by Garth N. Wells 2007-2015
// Modified by Niclas Jansson 2008
// Modified by Kristoffer Selim 2008
// Modified by Andre Massing 2009-2010
// Modified by Marie E. Rognes 2012
// Modified by Mikael Mortensen 2012
// Modified by Jan Blechta 2013
 
#ifndef __MESH_H
#define __MESH_H
 
#include <memory>
#include <string>
#include <utility>
 
#include <dolfin/common/Hierarchical.h>
#include <dolfin/common/MPI.h>
#include <dolfin/common/Variable.h>
#include "MeshData.h"
#include "MeshDomains.h"
#include "MeshGeometry.h"
#include "MeshConnectivity.h"
#include "MeshTopology.h"
 
namespace dolfin
{
  class BoundaryMesh;
  class CellType;
  class Expression;
  class GenericFunction;
  class LocalMeshData;
  class MeshEntity;
  class Point;
  class SubDomain;
  class BoundingBoxTree;

 
  class Mesh : public Variable, public Hierarchical<Mesh>
  {
  public:

    Mesh();

    Mesh(MPI_Comm comm);

    Mesh(const Mesh& mesh);

    explicit Mesh(std::string filename);

    Mesh(MPI_Comm comm, std::string filename);

    Mesh(MPI_Comm comm, LocalMeshData& local_mesh_data);

    ~Mesh();

    const Mesh& operator=(const Mesh& mesh);

    std::size_t num_vertices() const
    { return _topology.size(0); }

    std::size_t num_edges() const
    { return _topology.size(1); }

    std::size_t num_faces() const
    { return _topology.size(2); }

    std::size_t num_facets() const
    { return _topology.size(_topology.dim() - 1); }

    std::size_t num_cells() const
    { return _topology.size(_topology.dim()); }

    std::size_t num_entities(std::size_t d) const
    { return _topology.size(d); }

    std::vector<double>& coordinates()
    { return _geometry.x(); }

    const std::vector<double>& coordinates() const
    { return _geometry.x(); }

    const std::vector<unsigned int>& cells() const
    { return _topology(_topology.dim(), 0)(); }

    std::size_t num_entities_global(std::size_t dim) const
    { return _topology.size_global(dim); }

    MeshTopology& topology()
    { return _topology; }

    const MeshTopology& topology() const
    { return _topology; }

    MeshGeometry& geometry()
    { return _geometry; }

    const MeshGeometry& geometry() const
    { return _geometry; }

    MeshDomains& domains()
    { return _domains; }

    const MeshDomains& domains() const
    { return _domains; }

    std::shared_ptr<BoundingBoxTree> bounding_box_tree() const;

    MeshData& data();

    const MeshData& data() const;

    CellType& type()
    { dolfin_assert(_cell_type); return *_cell_type; }

    const CellType& type() const
    { dolfin_assert(_cell_type); return *_cell_type; }

    std::size_t init(std::size_t dim) const;

    void init(std::size_t d0, std::size_t d1) const;

    void init() const;

    void init_global(std::size_t dim) const;

    void clean();

    void order();

    bool ordered() const;

    Mesh renumber_by_color() const;

    void scale(double factor);

    void translate(const Point& point);

    void rotate(double angle, std::size_t axis=2);

    void rotate(double angle, std::size_t axis, const Point& point);

    void smooth(std::size_t num_iterations=1);

    void smooth_boundary(std::size_t num_iterations=1,
                         bool harmonic_smoothing=true);

    void snap_boundary(const SubDomain& sub_domain,
                       bool harmonic_smoothing=true);

    const std::vector<std::size_t>& color(std::string coloring_type) const;

    const std::vector<std::size_t>&
    color(std::vector<std::size_t> coloring_type) const;

    double hmin() const;

    double hmax() const;

    double rmin() const;

    double rmax() const;

    std::size_t hash() const;

    std::string str(bool verbose) const;

    const std::vector<int>& cell_orientations() const;

    void init_cell_orientations(const Expression& global_normal);

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

    std::string ghost_mode() const;
 
    // Friend in fem_utils.h
    friend Mesh create_mesh(Function& coordinates);
 
  private:
 
    // Friends
    friend class MeshEditor;
    friend class TopologyComputation;
    friend class MeshPartitioning;
 
    // Mesh topology
    MeshTopology _topology;
 
    // Mesh geometry
    MeshGeometry _geometry;
 
    // Mesh domains
    MeshDomains _domains;
 
    // Auxiliary mesh data
    MeshData _data;
 
    // Bounding box tree used to compute collisions between the mesh
    // and other objects. The tree is initialized to a zero pointer
    // and is allocated and built when bounding_box_tree() is called.
    mutable std::shared_ptr<BoundingBoxTree> _tree;
 
    // Cell type
    std::unique_ptr<CellType> _cell_type;
 
    // True if mesh has been ordered
    mutable bool _ordered;
 
    // Orientation of cells relative to a global direction
    std::vector<int> _cell_orientations;
 
    // MPI communicator
    dolfin::MPI::Comm _mpi_comm;
 
    // Ghost mode used for partitioning
    std::string _ghost_mode;
 
  };
}
 
#endif