struct_num_entities.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/base_header.hpp>
 
namespace FEAT
{
  namespace Geometry
  {
    namespace Intern
    {
      template<
        int shape_dim_,
        int face_dim_>
      struct StructNumEntities DOXY({});
 
      template<int shape_dim_>
      struct StructNumEntities<shape_dim_, shape_dim_>
      {
        static Index compute(const Index num_slices[])
        {
          // compute number of elements
          Index count = num_slices[0];
          for(int i(1); i < shape_dim_; ++i)
            count *= (num_slices[i]);
          return count;
        }
      };
 
      template<int shape_dim_>
      struct StructNumEntities<shape_dim_, 0>
      {
        static Index compute(const Index num_slices[])
        {
          // compute number of vertices
          Index count = num_slices[0] + 1;
          for(int i(1); i < shape_dim_; ++i)
            count *= (num_slices[i] + 1);
          return count;
        }
      };
 
      template<>
      struct StructNumEntities<2, 1>
      {
        static Index compute(const Index num_slices[])
        {
          // compute number of edges in quad mesh
          return
            num_slices[0] * (num_slices[1] + 1) +
            num_slices[1] * (num_slices[0] + 1);
        }
      };
 
      template<>
      struct StructNumEntities<3, 1>
      {
        static Index compute(const Index num_slices[])
        {
          // compute number of edges in hexa mesh
          return
            num_slices[0] * (num_slices[1] + 1) * (num_slices[2] + 1) +
            num_slices[1] * (num_slices[0] + 1) * (num_slices[2] + 1) +
            num_slices[2] * (num_slices[0] + 1) * (num_slices[1] + 1);
        }
      };
 
      template<>
      struct StructNumEntities<3, 2>
      {
        static Index compute(const Index num_slices[])
        {
          // compute number of quads in hexa mesh
          return
            (num_slices[0] + 1) * num_slices[1] * num_slices[2] +
            (num_slices[1] + 1) * num_slices[0] * num_slices[2] +
            (num_slices[2] + 1) * num_slices[0] * num_slices[1];
        }
      };
 
      template<
        int shape_dim_,
        int cell_dim_ = shape_dim_>
      struct StructNumEntitiesWrapper
      {
        static void compute(Index num_entities[], const Index num_slices[])
        {
          StructNumEntitiesWrapper<shape_dim_, cell_dim_ - 1>::compute(num_entities, num_slices);
          num_entities[cell_dim_] = StructNumEntities<shape_dim_, cell_dim_>::compute(num_slices);
        }
      };
 
      template<int shape_dim_>
      struct StructNumEntitiesWrapper<shape_dim_, 0>
      {
        static void compute(Index num_entities[], const Index num_slices[])
        {
          num_entities[0] = StructNumEntities<shape_dim_, 0>::compute(num_slices);
        }
      };
    } // namespace Intern
  } // namespace Geometry
} // namespace FEAT