grid_reordering_internal.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2003 - 2016 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, 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 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii__grid_reordering_internal_h
#define dealii__grid_reordering_internal_h


#include <deal.II/base/config.h>
#include <deal.II/grid/tria.h>

#include <map>
#include <vector>

DEAL_II_NAMESPACE_OPEN


namespace internal
{
  namespace GridReordering2d
  {

    bool
    is_consistent (const std::vector<CellData<2> > &cells);


    class ConnectGlobals
    {
    public:
      static const int EdgeToNode[4][2];

      static const int NodeToEdge[4][2];

      static const int DefaultOrientation[4][2];
    };


    class MQuad
    {
    public:
      MQuad (const unsigned int  v0,
             const unsigned int  v1,
             const unsigned int  v2,
             const unsigned int  v3,
             const unsigned int  s0,
             const unsigned int  s1,
             const unsigned int  s2,
             const unsigned int  s3,
             const CellData<2>  &cd);

      unsigned int v[4];
      unsigned int side[4];

      CellData<2>  original_cell_data;
    };

    struct MSide
    {
      MSide (const unsigned int initv0,
             const unsigned int initv1);

      bool operator==(const MSide &s2) const;

      bool operator!=(const MSide &s2) const;

      unsigned int v0;
      unsigned int v1;
      unsigned int Q0;
      unsigned int Q1;

      unsigned int lsn0, lsn1;
      bool Oriented;

      struct SideRectify;

      struct SideSortLess;
    };



    class GridReordering
    {
    public:

      void reorient(std::vector<CellData<2> > &quads);
    private:

      void build_graph (const std::vector<CellData<2> > &inquads);

      void orient();

      void get_quads(std::vector<CellData<2> > &outquads) const;

      void orient_side (const unsigned int quadnum,
                        const unsigned int localsidenum);

      bool is_fully_oriented_quad (const unsigned int quadnum) const;

      bool is_oriented_side (const unsigned int quadnum,
                             const unsigned int lsn) const;

      bool is_side_default_oriented (const unsigned int qnum,
                                     const unsigned int lsn) const;

      bool get_unoriented_quad (unsigned int &UnOrQLoc) const;

      bool get_unoriented_side (const unsigned int quadnum,
                                unsigned int &sidenum) const;

      bool side_hop (unsigned int &qnum,
                     unsigned int &lsn) const;

      std::vector<MSide> sides;
      std::vector<MQuad> mquads;
    };
  }  // namespace GridReordering2d


  namespace GridReordering3d
  {
    struct EdgeOrientation
    {
      char orientation;

      bool operator == (const EdgeOrientation &edge_orientation) const;

      bool operator != (const EdgeOrientation &edge_orientation) const;
    };

    struct CheapEdge
    {
      const unsigned int node0;

      const unsigned int node1;

      CheapEdge (const unsigned int n0,
                 const unsigned int n1);

      bool operator< (const CheapEdge &e2) const;
    };



    struct Edge
    {
      Edge (const unsigned int n0,
            const unsigned int n1);

      unsigned int nodes[2];

      EdgeOrientation orientation_flag;

      unsigned int group;

      std::vector<unsigned int> neighboring_cubes;
    };

    struct Cell
    {
      Cell ();

      unsigned int edges[GeometryInfo<3>::lines_per_cell];

      unsigned int nodes[GeometryInfo<3>::vertices_per_cell];

      EdgeOrientation local_orientation_flags[GeometryInfo<3>::lines_per_cell];

      bool waiting_to_be_processed;
    };


    class Mesh
    {
    public:
      Mesh (const std::vector<CellData<3> > &incubes);

      void
      export_to_deal_format (std::vector<CellData<3> > &outcubes) const;

    private:
      std::vector<Edge> edge_list;

      std::vector<Cell> cell_list;

      void sanity_check() const;

      void build_connectivity ();

      Mesh (const Mesh &);

      Mesh &operator=(const Mesh &);

      void sanity_check_node (const Cell        &cell,
                              const unsigned int local_node_num) const;

      friend class Orienter;
    };


    class Orienter
    {
    public:
      static
      bool
      orient_mesh (std::vector<CellData<3> > &incubes);

    private:
      Mesh mesh;

      unsigned int cur_posn;

      unsigned int marker_cube;

      unsigned int cur_edge_group;

      std::vector<int> sheet_to_process;


      bool edge_orient_array[12];

      Orienter (const std::vector<CellData<3> > &incubes);

      bool orient_edges ();

      void orient_cubes ();

      bool get_next_unoriented_cube ();

      bool is_oriented (const unsigned int cell_num) const;

      bool orient_edges_in_current_cube ();
      bool orient_edge_set_in_current_cube (const unsigned int edge_set);
      bool orient_next_unoriented_edge ();

      bool cell_is_consistent (const unsigned int cell_num) const;


      void get_adjacent_cubes ();
      bool get_next_active_cube ();
    };
  }  // namespace GridReordering3d
}  // namespace internal


DEAL_II_NAMESPACE_CLOSE

#endif