Commit 33e561c3 authored by Jakub Klinkovský's avatar Jakub Klinkovský
Browse files

Removed the code for entity orientations in the unstructured mesh 

It was unused, untested and unnecessarily complicated. We will deal with
entity orientations when it is actually needed.

I think that the implementation based on storing the whole permutations
of subentity indices is not appropriate anyway - it induces huge memory
consumption, while e.g. for faces we are interested only in the
orientation of the outward normal vector with respect to the two
adjacent cells, which can be stored as one bit per face-cell pair, or it
can be deduced from the entity indices if we enforce a suitable
convention (e.g. all normal vectors could be outward with respect to the
adjacent cell with the smallest index). I think OpenFOAM uses a similar
convention for normal vectors. As for the orientation of edges in 3D, I
have no idea where it could be useful...
parent d1dab838

src/TNL/Meshes/DefaultConfig.h

+0 −10
Original line number Diff line number Diff line
@@ -51,16 +51,6 @@ struct DefaultConfig 
      //return SubentityDimension == 0;

   }



   /****

    * Storage of subentity orientations of mesh entities.

    * It must be false for vertices and cells.

    */

   template< typename EntityTopology >

   static constexpr bool subentityOrientationStorage( EntityTopology, int SubentityDimension )

   {

      return SubentityDimension > 0 && SubentityDimension < meshDimension;

   }



   /****

    * Storage of superentities of mesh entities.

    */

src/TNL/Meshes/MeshDetails/ConfigValidator.h

+1 −9
Original line number Diff line number Diff line
@@ -34,18 +34,12 @@ class ConfigValidatorSubtopologyLayer 
   static_assert( ! MeshConfig::subentityStorage( EntityTopology(), DimensionTag::value ) ||

                    MeshConfig::subentityStorage( EntityTopology(), 0 ),

                  "entities that are stored as subentities must store their subvertices" );

   static_assert( ! MeshConfig::subentityOrientationStorage( EntityTopology(), DimensionTag::value ) ||

                    MeshConfig::subentityStorage( EntityTopology(), DimensionTag::value ),

                  "orientation can be stored only for subentities that are stored");

};



template< typename MeshConfig,

          typename EntityTopology >

class ConfigValidatorSubtopologyLayer< MeshConfig, EntityTopology, DimensionTag< 0 > >

{

   static_assert( ! MeshConfig::subentityOrientationStorage( EntityTopology(), 0 ),

                  "storage of vertex orientation does not make sense" );

};

{};





template< typename MeshConfig,
@@ -95,8 +89,6 @@ class ConfigValidatorLayerCell 


   static_assert( MeshConfig::subentityStorage( CellTopology(), 0 ),

                  "subvertices of cells must be stored" );

   static_assert( ! MeshConfig::subentityOrientationStorage( CellTopology(), 0 ),

                  "storage of cell orientation does not make sense" );

};



template< typename MeshConfig >

src/TNL/Meshes/MeshDetails/MeshEntityOrientation.h

deleted100644 → 0
+0 −51
Original line number Diff line number Diff line 
/***************************************************************************

                          MeshEntityOrientation.h  -  description

                             -------------------

    begin                : Aug 25, 2015

    copyright            : (C) 2015 by Tomas Oberhuber et al.

    email                : tomas.oberhuber@fjfi.cvut.cz

 ***************************************************************************/



/* See Copyright Notice in tnl/Copyright */



/***

 * Authors:

 * Oberhuber Tomas, tomas.oberhuber@fjfi.cvut.cz

 * Zabka Vitezslav, zabkav@gmail.com

 */



#pragma once



#include <TNL/Meshes/MeshDetails/traits/MeshTraits.h>



namespace TNL {

namespace Meshes {



template< typename MeshConfig,

          typename EntityTopology>

class MeshEntityOrientation

{

   template< typename, typename>

   friend class MeshEntityReferenceOrientation;



   public:

      using LocalIndexType = typename MeshTraits< MeshConfig >::LocalIndexType;

      using IdPermutationArrayType = typename MeshTraits< MeshConfig >::template SubentityTraits< EntityTopology, 0 >::IdPermutationArrayType;



      const IdPermutationArrayType& getSubvertexPermutation() const

      {

         return subvertexPermutation;

      }



   private:

      void setPermutationValue( LocalIndexType index, LocalIndexType value )

      {

         this->subvertexPermutation[ index ] = value;

      }



      IdPermutationArrayType subvertexPermutation;

};



} // namespace Meshes

} // namespace TNL

src/TNL/Meshes/MeshDetails/MeshEntityReferenceOrientation.h

deleted100644 → 0
+0 −67
Original line number Diff line number Diff line 
/***************************************************************************

                          MeshEntityReferenceOrientation.h  -  description

                             -------------------

    begin                : Aug 25, 2015

    copyright            : (C) 2015 by Tomas Oberhuber et al.

    email                : tomas.oberhuber@fjfi.cvut.cz

 ***************************************************************************/



/* See Copyright Notice in tnl/Copyright */



/***

 * Authors:

 * Oberhuber Tomas, tomas.oberhuber@fjfi.cvut.cz

 * Zabka Vitezslav, zabkav@gmail.com

 */



#pragma once



#include <map>



#include <TNL/Meshes/MeshDetails/MeshEntityOrientation.h>



namespace TNL {

namespace Meshes {



template< typename MeshConfig, typename EntityTopology >

class MeshEntityReferenceOrientation

{

   typedef typename MeshTraits< MeshConfig >::LocalIndexType  LocalIndexType;

   typedef typename MeshTraits< MeshConfig >::GlobalIndexType GlobalIndexType;



   public:

      typedef EntitySeed< MeshConfig, EntityTopology >            SeedType;

      typedef MeshEntityOrientation< MeshConfig, EntityTopology > EntityOrientation;



      MeshEntityReferenceOrientation() = default;



      explicit MeshEntityReferenceOrientation( const SeedType& referenceSeed )

      {

         auto referenceCornerIds = referenceSeed.getCornerIds();

         for( LocalIndexType i = 0; i < referenceCornerIds.getSize(); i++ )

         {

            TNL_ASSERT_TRUE( this->cornerIdsMap.find( referenceCornerIds[ i ] ) == this->cornerIdsMap.end(),

                             "detected duplicate index in the reference seed" );

            this->cornerIdsMap.insert( std::make_pair( referenceCornerIds[i], i ) );

         }

      }



      EntityOrientation createOrientation( const SeedType& seed ) const

      {

         EntityOrientation result;

         auto cornerIds = seed.getCornerIds();

         for( LocalIndexType i = 0; i < cornerIds.getSize(); i++ )

         {

            TNL_ASSERT_TRUE( this->cornerIdsMap.find( cornerIds[ i ] ) != this->cornerIdsMap.end(),

                             "unable to find index for entity orientation" );

            result.setPermutationValue( i, this->cornerIdsMap.find( cornerIds[ i ])->second );

         }

         return result;

      }



   private:

      std::map< GlobalIndexType, LocalIndexType > cornerIdsMap;

};



} // namespace Meshes

} // namespace TNL

src/TNL/Meshes/MeshDetails/initializer/EntityInitializer.h

+6 −165
Original line number Diff line number Diff line
@@ -32,10 +32,6 @@ template< typename MeshConfig, 
          bool SubentityStorage =

               MeshConfig::subentityStorage( typename MeshTraits< MeshConfig >::template EntityTraits< SuperdimensionTag::value >::EntityTopology(),

                                             SubdimensionTag::value ),

          bool SubentityOrientationStorage =

               MeshConfig::subentityOrientationStorage( typename MeshTraits< MeshConfig >::template EntityTraits< SuperdimensionTag::value >::EntityTopology(),

                                                        SubdimensionTag::value ) &&

               MeshTraits< MeshConfig >::template EntityTraits< SubdimensionTag::value >::orientationNeeded,

          // storage in the subentity

          bool SuperentityStorage =

               MeshConfig::superentityStorage( typename MeshTraits< MeshConfig >::template EntityTraits< SubdimensionTag::value >::EntityTopology(),
@@ -99,8 +95,8 @@ public: 
/****

 *       Mesh entity initializer layer with specializations

 *

 *  SUBENTITY STORAGE     SUBENTITY ORIENTATION    SUPERENTITY STORAGE

 *      TRUE                    FALSE                    TRUE

 *  SUBENTITY STORAGE     SUPERENTITY STORAGE

 *      TRUE                    TRUE

 */

template< typename MeshConfig,

          typename SubdimensionTag,
@@ -109,7 +105,6 @@ class EntityInitializerLayer< MeshConfig, 
                              SubdimensionTag,

                              SuperdimensionTag,

                              true,

                              false,

                              true,

                              true >

   : public EntityInitializerLayer< MeshConfig,
@@ -183,8 +178,8 @@ public: 
/****

 *       Mesh entity initializer layer with specializations

 *

 *  SUBENTITY STORAGE     SUBENTITY ORIENTATION    SUPERENTITY STORAGE

 *      TRUE                    TRUE                    TRUE

 *  SUBENTITY STORAGE     SUPERENTITY STORAGE

 *      TRUE                   FALSE

 */

template< typename MeshConfig,

          typename SubdimensionTag,
@@ -193,156 +188,6 @@ class EntityInitializerLayer< MeshConfig, 
                              SubdimensionTag,

                              SuperdimensionTag,

                              true,

                              true,

                              true,

                              true >

   : public EntityInitializerLayer< MeshConfig,

                                    SubdimensionTag,

                                    typename SuperdimensionTag::Decrement >

{

   using BaseType = EntityInitializerLayer< MeshConfig,

                                            SubdimensionTag,

                                            typename SuperdimensionTag::Decrement >;

   using InitializerType            = Initializer< MeshConfig >;

   using MeshType                   = typename InitializerType::MeshType;



   using GlobalIndexType            = typename MeshTraits< MeshConfig >::GlobalIndexType;

   using LocalIndexType             = typename MeshTraits< MeshConfig >::LocalIndexType;

   using SubentityTraitsType        = typename MeshTraits< MeshConfig >::template EntityTraits< SubdimensionTag::value >;

   using SubentityTopology          = typename SubentityTraitsType::EntityTopology;

   using SuperentityTraitsType      = typename MeshTraits< MeshConfig >::template EntityTraits< SuperdimensionTag::value >;

   using SuperentityTopology        = typename SuperentityTraitsType::EntityTopology;

   using SubentitySeedsCreatorType  = SubentitySeedsCreator< MeshConfig, SuperdimensionTag, SubdimensionTag >;

   using SuperentityMatrixType      = typename MeshTraits< MeshConfig >::SuperentityMatrixType;



public:

   static void initSuperentities( InitializerType& meshInitializer, MeshType& mesh )

   {

      //std::cout << "   Initiating superentities with dimension " << SuperdimensionTag::value << " for subentities with dimension " << SubdimensionTag::value << " ... " << std::endl;



      const GlobalIndexType subentitiesCount = mesh.template getEntitiesCount< SubdimensionTag::value >();

      const GlobalIndexType superentitiesCount = mesh.template getEntitiesCount< SuperdimensionTag::value >();

      if( SubdimensionTag::value > 0 )

         meshInitializer.template initSubentityMatrix< SuperdimensionTag::value, SubdimensionTag::value >( superentitiesCount, subentitiesCount );



      // counter for superentities of each subentity

      auto& superentitiesCounts = meshInitializer.template getSuperentitiesCountsArray< SubdimensionTag::value, SuperdimensionTag::value >();

      superentitiesCounts.setSize( subentitiesCount );

      superentitiesCounts.setValue( 0 );



      for( GlobalIndexType superentityIndex = 0; superentityIndex < superentitiesCount; superentityIndex++ )

      {

         auto subentitySeeds = SubentitySeedsCreatorType::create( meshInitializer.template getSubvertices< SuperdimensionTag::value >( superentityIndex ) );

         auto& subentityOrientationsArray = meshInitializer.template subentityOrientationsArray< SuperdimensionTag::value, SubdimensionTag::value >( superentityIndex );

         for( LocalIndexType i = 0; i < subentitySeeds.getSize(); i++ )

         {

            const GlobalIndexType subentityIndex = meshInitializer.findEntitySeedIndex( subentitySeeds[ i ] );

            meshInitializer.template setSubentityIndex< SuperdimensionTag::value, SubdimensionTag::value >( superentityIndex, i, subentityIndex );

            superentitiesCounts[ subentityIndex ]++;

            subentityOrientationsArray[ i ] = meshInitializer.template getReferenceOrientation< SubdimensionTag >( subentityIndex ).createOrientation( subentitySeeds[ i ] );

         }

      }



      // allocate superentities storage

      SuperentityMatrixType& matrix = meshInitializer.template getSuperentitiesMatrix< SubdimensionTag::value, SuperdimensionTag::value >();

      matrix.setDimensions( subentitiesCount, superentitiesCount );

      matrix.setRowCapacities( superentitiesCounts );

      superentitiesCounts.setValue( 0 );



      // initialize superentities storage

      for( GlobalIndexType superentityIndex = 0; superentityIndex < superentitiesCount; superentityIndex++ )

      {

         for( LocalIndexType i = 0;

              i < mesh.template getSubentitiesCount< SuperdimensionTag::value, SubdimensionTag::value >( superentityIndex );

              i++ )

         {

            const GlobalIndexType subentityIndex = mesh.template getSubentityIndex< SuperdimensionTag::value, SubdimensionTag::value >( superentityIndex, i );

            auto row = matrix.getRow( subentityIndex );

            row.setElement( superentitiesCounts[ subentityIndex ]++, superentityIndex, true );

         }

      }



      BaseType::initSuperentities( meshInitializer, mesh );

   }

};



/****

 *       Mesh entity initializer layer with specializations

 *

 *  SUBENTITY STORAGE     SUBENTITY ORIENTATION    SUPERENTITY STORAGE

 *      TRUE                    TRUE                    FALSE

 */

template< typename MeshConfig,

          typename SubdimensionTag,

          typename SuperdimensionTag >

class EntityInitializerLayer< MeshConfig,

                              SubdimensionTag,

                              SuperdimensionTag,

                              true,

                              true,

                              false,

                              true >

   : public EntityInitializerLayer< MeshConfig,

                                    SubdimensionTag,

                                    typename SuperdimensionTag::Decrement >

{

   using BaseType = EntityInitializerLayer< MeshConfig,

                                            SubdimensionTag,

                                            typename SuperdimensionTag::Decrement >;

   using InitializerType           = Initializer< MeshConfig >;

   using MeshType                  = typename InitializerType::MeshType;



   using GlobalIndexType           = typename MeshTraits< MeshConfig >::GlobalIndexType;

   using LocalIndexType            = typename MeshTraits< MeshConfig >::LocalIndexType;

   using SuperentityTraitsType     = typename MeshTraits< MeshConfig >::template EntityTraits< SuperdimensionTag::value >;

   using SuperentityTopology       = typename SuperentityTraitsType::EntityTopology;

   using SubentitySeedsCreatorType = SubentitySeedsCreator< MeshConfig, SuperdimensionTag, SubdimensionTag >;



public:

   static void initSuperentities( InitializerType& meshInitializer, MeshType& mesh )

   {

      //std::cout << "   Initiating superentities with dimension " << SuperdimensionTag::value << " for subentities with dimension " << SubdimensionTag::value << " ... " << std::endl;



      const GlobalIndexType subentitiesCount = mesh.template getEntitiesCount< SubdimensionTag::value >();

      const GlobalIndexType superentitiesCount = mesh.template getEntitiesCount< SuperdimensionTag::value >();

      if( SubdimensionTag::value > 0 )

         meshInitializer.template initSubentityMatrix< SuperdimensionTag::value, SubdimensionTag::value >( superentitiesCount, subentitiesCount );



      for( GlobalIndexType superentityIndex = 0;

           superentityIndex < mesh.template getEntitiesCount< SuperdimensionTag::value >();

           superentityIndex++ )

      {

         auto subentitySeeds = SubentitySeedsCreatorType::create( meshInitializer.template getSubvertices< SuperdimensionTag::value >( superentityIndex ) );



         auto& subentityOrientationsArray = meshInitializer.template subentityOrientationsArray< SuperdimensionTag::value, SubdimensionTag::value >( superentityIndex );



         for( LocalIndexType i = 0; i < subentitySeeds.getSize(); i++ )

         {

            const GlobalIndexType subentityIndex = meshInitializer.findEntitySeedIndex( subentitySeeds[ i ] );

            meshInitializer.template setSubentityIndex< SuperdimensionTag::value, SubdimensionTag::value >( superentityIndex, i, subentityIndex );



            subentityOrientationsArray[ i ] = meshInitializer.template getReferenceOrientation< SubdimensionTag >( subentityIndex ).createOrientation( subentitySeeds[ i ] );

         }

      }



      BaseType::initSuperentities( meshInitializer, mesh );

   }

};



/****

 *       Mesh entity initializer layer with specializations

 *

 *  SUBENTITY STORAGE     SUBENTITY ORIENTATION    SUPERENTITY STORAGE

 *      TRUE                    FALSE                   FALSE

 */

template< typename MeshConfig,

          typename SubdimensionTag,

          typename SuperdimensionTag >

class EntityInitializerLayer< MeshConfig,

                              SubdimensionTag,

                              SuperdimensionTag,

                              true,

                              false,

                              false,

                              true >

   : public EntityInitializerLayer< MeshConfig,
@@ -391,8 +236,8 @@ public: 
/****

 *       Mesh entity initializer layer with specializations

 *

 *  SUBENTITY STORAGE     SUBENTITY ORIENTATION    SUPERENTITY STORAGE

 *      FALSE                   FALSE                   TRUE

 *  SUBENTITY STORAGE     SUPERENTITY STORAGE

 *      FALSE                  TRUE

 */

template< typename MeshConfig,

          typename SubdimensionTag,
@@ -401,7 +246,6 @@ class EntityInitializerLayer< MeshConfig, 
                              SubdimensionTag,

                              SuperdimensionTag,

                              false,

                              false,

                              true,

                              true >

   : public EntityInitializerLayer< MeshConfig,
@@ -476,7 +320,6 @@ class EntityInitializerLayer< MeshConfig, 
                              SuperdimensionTag,

                              false,

                              false,

                              false,

                              true >

   : public EntityInitializerLayer< MeshConfig,

                                    SubdimensionTag,
@@ -486,13 +329,11 @@ class EntityInitializerLayer< MeshConfig, 
template< typename MeshConfig,

          typename SubdimensionTag,

          bool SubentityStorage,

          bool SubentityOrientationStorage,

          bool SuperentityStorage >

class EntityInitializerLayer< MeshConfig,

                              SubdimensionTag,

                              SubdimensionTag,

                              SubentityStorage,

                              SubentityOrientationStorage,

                              SuperentityStorage,

                              false >

{