congruency_mapping.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/geometry/intern/congruency_sampler.hpp>
 
// includes, system
#include <algorithm>
 
namespace FEAT
{
  namespace Geometry
  {
    namespace Intern
    {
      template<
        typename Shape_,
        int face_dim_>
#ifndef DOXYGEN
      class CongruencyMapping;
#else
      class CongruencyMapping
      {
      public:
        static int map(int orient, int idx);
 
        template<typename IdxTuple_>
        static void flip(IdxTuple_& idx);
      };
#endif // DOXYGEN
 
      template<>
      class CongruencyMapping<Shape::Simplex<1>, 0>
      {
      public:
        static int map(int orient, int idx)
        {
          static const int indices[2][2] =
          {
            {0, 1},
            {1, 0}
          };
 
          return indices[orient][idx];
        }
 
        template<typename IdxTuple_>
        static void flip(IdxTuple_& idx)
        {
          // swap vertex 0 and 1
          std::swap(idx[0], idx[1]);
        }
      };
 
      template<>
      class CongruencyMapping<Shape::Simplex<2>, 0>
      {
      public:
        static int map(int orient, int idx)
        {
          static const int indices[7][3] =
          {
            {0, 1, 2},
            {1, 2, 0},
            {2, 0, 1},
            {0, 0, 0}, // unused
            {0, 2, 1},
            {1, 0, 2},
            {2, 1, 0}
          };
 
          return indices[orient][idx];
        }
 
        template<typename IdxTuple_>
        static void flip(IdxTuple_& idx)
        {
          // 2          1
          // |'\.   --> |'\.
          // 0---1      0---2
          std::swap(idx[1], idx[2]);
        }
      };
 
      template<>
      class CongruencyMapping<Shape::Simplex<2>, 1>
      {
      public:
        static int map(int orient, int idx)
        {
          static const int indices[7][3] =
          {
            {0, 1, 2},
            {1, 2, 0},
            {2, 0, 1},
            {0, 0, 0}, // unused
            {0, 2, 1},
            {1, 0, 2},
            {2, 1, 0}
          };
 
          return indices[orient][idx];
        }
 
        template<typename IdxTuple_>
        static void flip(IdxTuple_& idx)
        {
          // 2          1
          // |'\.   --> |'\.
          // 0---1      0---2
          //
          // X          X
          // 2'1.   --> 0'1.
          // X-0-X      X-2-X
          //
          // swap edge 0 and 2
          std::swap(idx[0], idx[2]);
        }
      };
 
      template<>
      class CongruencyMapping<Shape::Hypercube<1>, 0>
      {
      public:
        static int map(int orient, int idx)
        {
          static const int indices[2][2] =
          {
            {0, 1},
            {1, 0}
          };
 
          return indices[orient][idx];
        }
 
        template<typename IdxTuple_>
        static void flip(IdxTuple_& idx)
        {
          // swap vertex 0 and 1
          std::swap(idx[0], idx[1]);
        }
      };
 
      template<>
      class CongruencyMapping<Shape::Hypercube<2>, 0>
      {
      public:
        static int map(int orient, int idx)
        {
          static const int indices[8][4] =
          {
            {0, 1, 2, 3},
            {1, 3, 0, 2},
            {2, 0, 3, 1},
            {3, 2, 1, 0},
            {0, 2, 1, 3},
            {1, 0, 3, 2},
            {2, 3, 0, 1},
            {3, 1, 2, 0}
          };
 
          return indices[orient][idx];
        }
 
        template<typename IdxTuple_>
        static void flip(IdxTuple_& idx)
        {
          // 2---3      0---1
          // |   |  --> |   |
          // 0---1      2---3
          std::swap(idx[0], idx[2]);
          std::swap(idx[1], idx[3]);
        }
      };
 
      template<>
      class CongruencyMapping<Shape::Hypercube<2>, 1>
      {
      public:
        static int map(int orient, int idx)
        {
          static const int indices[8][4] =
          {
            {0, 1, 2, 3},
            {3, 2, 0, 1},
            {2, 3, 1, 0},
            {1, 0, 3, 2},
            {2, 3, 0, 1},
            {0, 1, 3, 2},
            {1, 0, 2, 3},
            {3, 2, 1, 0}
          };
 
          return indices[orient][idx];
        }
 
        template<typename IdxTuple_>
        static void flip(IdxTuple_& idx)
        {
          // 2---3      0---1
          // |   |  --> |   |
          // 0---1      2---3
          //
          // X-1-X      X-0-X
          // 2   3  --> 2   3
          // X-0-X      X-1-X
          //
          // swap edge 0 and 1
          std::swap(idx[0], idx[1]);
        }
      };
    } // namespace Intern
  } // namespace Geometry
} // namespace FEAT