/***************************************************************************
tnlMeshInitializer.h - description
-------------------
begin : Feb 23, 2014
copyright : (C) 2014 by Tomas Oberhuber
email : tomas.oberhuber@fjfi.cvut.cz
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef TNLMESHINITIALIZER_H_
#define TNLMESHINITIALIZER_H_
#include <mesh/tnlDimensionsTag.h>
#include <mesh/traits/tnlMeshEntityTraits.h>
#include <mesh/traits/tnlMeshSubentityTraits.h>
#include <mesh/traits/tnlMeshSuperentityTraits.h>
#include <mesh/initializer/tnlMeshEntityInitializer.h>
#include <mesh/tnlMesh.h>
#include <mesh/initializer/tnlMeshSubentitySeedCreator.h>
#include <mesh/initializer/tnlMeshSuperentityStorageInitializer.h>
#include <mesh/tnlMeshEntityReferenceOrientation.h>
#include <mesh/initializer/tnlMeshEntitySeed.h>
#include <mesh/initializer/tnlMeshEntitySeedKey.h>
template< typename MeshConfig >
class tnlMesh;
template< typename MeshConfig,
typename DimensionsTag,
bool EntityStorage =
tnlMeshEntityTraits< MeshConfig, DimensionsTag::value >::storageEnabled,
bool EntityReferenceOrientationStorage =
tnlMeshTraits< MeshConfig >::template EntityTraits< DimensionsTag::value >::orientationNeeded >
class tnlMeshInitializerLayer;
template< typename MeshConfig,
typename EntityTopology>
class tnlMeshEntityInitializer;
template< typename MeshConfig >
class tnlMeshInitializer
: public tnlMeshInitializerLayer< MeshConfig,
typename tnlMeshTraits< MeshConfig >::DimensionsTag >
{
public:
typedef tnlMesh< MeshConfig > MeshType;
typedef tnlMeshTraits< MeshConfig > MeshTraits;
static const int Dimensions = MeshTraits::meshDimensions;
typedef tnlDimensionsTag< Dimensions > DimensionsTag;
typedef tnlMeshInitializerLayer< MeshConfig, DimensionsTag > BaseType;
typedef typename MeshTraits::PointArrayType PointArrayType;
typedef typename MeshTraits::CellSeedArrayType CellSeedArrayType;
typedef typename MeshTraits::GlobalIndexType GlobalIndexType;
tnlMeshInitializer()
: verbose( false ), mesh( 0 )
{}
void setVerbose( bool verbose )
{
this->verbose = verbose;
}
bool createMesh( const PointArrayType& points,
const CellSeedArrayType& cellSeeds,
MeshType& mesh )
{
cout << "======= Starting mesh initiation ========" << endl;
this->mesh = &mesh;
cout << "========= Creating entity seeds =============" << endl;
BaseType::createEntitySeedsFromCellSeeds( cellSeeds );
cout << "========= Creating entity reference orientations =============" << endl;
BaseType::createEntityReferenceOrientations();
cout << "====== Initiating entities ==============" << endl;
BaseType::initEntities( *this, points, cellSeeds );
return true;
}
template<typename SubDimensionsTag, typename EntityType >
static typename MeshTraits::template SubentityTraits< typename EntityType::EntityTopology, SubDimensionsTag::value >::IdArrayType&
subentityIdsArray( EntityType& entity )
{
return entity.template subentityIdsArray< SubDimensionsTag::value >();
}
template< typename SuperDimensionsTag, typename MeshEntity>
static typename MeshTraits::IdArrayAccessorType&
superentityIdsArray( MeshEntity& entity )
{
return entity.template superentityIdsArray< SuperDimensionsTag::value >();
}
template<typename SubDimensionsTag, typename MeshEntity >
static typename MeshTraits::template SubentityTraits< typename MeshEntity::EntityTopology, SubDimensionsTag::value >::OrientationArrayType&
subentityOrientationsArray( MeshEntity &entity )
{
return entity.template subentityOrientationsArray< SubDimensionsTag::value >();
}
template< typename DimensionsTag >
typename MeshTraits::template EntityTraits< DimensionsTag::value >::StorageArrayType&
meshEntitiesArray()
{
return mesh->template entitiesArray< DimensionsTag >();
}
template< typename DimensionsTag, typename SuperDimensionsTag >
typename MeshTraits::GlobalIdArrayType&
meshSuperentityIdsArray()
{
return mesh->template superentityIdsArray< DimensionsTag, SuperDimensionsTag >();
}
static void
setVertexPoint( typename MeshType::VertexType& vertex, const typename MeshType::PointType& point )
{
vertex.setPoint( point );
}
template< typename DimensionsTag >
tnlMeshSuperentityStorageInitializer< MeshConfig, typename MeshTraits::template EntityTraits< DimensionsTag::value >::EntityTopology >&
getSuperentityInitializer()
{
return BaseType::getSuperentityInitializer( DimensionsTag() );
}
template< typename DimensionsTag >
const tnlMeshEntityReferenceOrientation< MeshConfig, typename MeshTraits::template EntityTraits< DimensionsTag::value >::EntityTopology >&
getReferenceOrientation( GlobalIndexType index) const
{
return BaseType::getReferenceOrientation( DimensionsTag(), index);
}
protected:
bool verbose;
MeshType* mesh;
};
/****
* Mesh initializer layer for cells
* - entities storage must turned on (cells must always be stored )
* - entities orientation does not make sense for cells => it is turned off
*/
template< typename MeshConfig >
class tnlMeshInitializerLayer< MeshConfig,
typename tnlMeshTraits< MeshConfig >::DimensionsTag,
true,
false >
: public tnlMeshInitializerLayer< MeshConfig,
typename tnlMeshTraits< MeshConfig >::DimensionsTag::Decrement >
{
typedef tnlMeshTraits< MeshConfig > MeshTraits;
static const int Dimensions = MeshTraits::meshDimensions;
typedef tnlDimensionsTag< Dimensions > DimensionsTag;
typedef tnlMeshInitializerLayer< MeshConfig, typename DimensionsTag::Decrement > BaseType;
typedef tnlMesh< MeshConfig > MeshType;
typedef typename MeshTraits::template EntityTraits< Dimensions > EntityTraits;
typedef typename EntityTraits::EntityTopology EntityTopology;
typedef typename MeshTraits::GlobalIndexType GlobalIndexType;
typedef typename MeshTraits::CellTopology CellTopology;
typedef typename EntityTraits::StorageArrayType StorageArrayType;
typedef tnlMeshInitializer< MeshConfig > InitializerType;
typedef tnlMeshEntityInitializer< MeshConfig, EntityTopology > EntityInitializerType;
typedef tnlMeshEntityInitializer< MeshConfig, EntityTopology > CellInitializerType;
typedef tnlArray< CellInitializerType, tnlHost, GlobalIndexType > CellInitializerContainerType;
typedef typename MeshTraits::CellSeedArrayType CellSeedArrayType;
typedef typename MeshTraits::LocalIndexType LocalIndexType;
typedef typename MeshTraits::PointArrayType PointArrayType;
typedef tnlMeshEntitySeed< MeshConfig, CellTopology > SeedType;
typedef tnlMeshSuperentityStorageInitializer< MeshConfig, EntityTopology > SuperentityInitializerType;
public:
void createEntitySeedsFromCellSeeds( const CellSeedArrayType& cellSeeds )
{
BaseType::createEntitySeedsFromCellSeeds( cellSeeds );
}
void initEntities( InitializerType &initializer, const PointArrayType &points, const CellSeedArrayType &cellSeeds)
{
StorageArrayType &entityArray = initializer.template meshEntitiesArray< DimensionsTag >();
//cout << " Initiating entities with " << DimensionsTag::value << " dimensions ... " << endl;
entityArray.setSize( cellSeeds.getSize() );
for( GlobalIndexType i = 0; i < entityArray.getSize(); i++ )
{
//cout << " Initiating entity " << i << endl;
EntityInitializerType::initEntity( entityArray[i], i, cellSeeds[i], initializer );
}
/***
* There are no superentities in this layer storing mesh cells.
*/
BaseType::initEntities( initializer, points );
}
using BaseType::findEntitySeedIndex;
GlobalIndexType findEntitySeedIndex( const SeedType& seed ) const
{
return this->seedsIndexedSet.find( seed );
}
using BaseType::getSuperentityInitializer;
SuperentityInitializerType& getSuperentityInitializer( DimensionsTag )
{
return this->superentityInitializer;
}
bool checkCells()
{
typedef typename tnlMeshEntity< MeshConfig, EntityTopology >::template SubentitiesTraits< 0 >::LocalIndexType LocalIndexType;
const GlobalIndexType numberOfVertices( this->getMesh().getNumberOfVertices() );
for( GlobalIndexType cell = 0;
cell < this->getMesh().getNumberOfCells();
cell++ )
for( LocalIndexType i = 0;
i < this->getMesh().getCell( cell ).getNumberOfVertices();
i++ )
{
if( this->getMesh().getCell( cell ).getVerticesIndices()[ i ] == - 1 )
{
cerr << "The cell number " << cell << " does not have properly set vertex index number " << i << "." << endl;
return false;
}
if( this->getMesh().getCell( cell ).getVerticesIndices()[ i ] >= numberOfVertices )
{
cerr << "The cell number " << cell << " does not have properly set vertex index number " << i
<< ". The index " << this->getMesh().getCell( cell ).getVerticesIndices()[ i ]
<< "is higher than the number of all vertices ( " << numberOfVertices
<< " )." << endl;
return false;
}
}
return true;
}
private:
typedef typename tnlMeshEntityTraits< MeshConfig, DimensionsTag::value >::SeedIndexedSetType SeedIndexedSet;
SeedIndexedSet seedsIndexedSet;
SuperentityInitializerType superentityInitializer;
};
/****
* Mesh initializer layer for other mesh entities than cells
* - entities storage is turned on
* - entities orientation storage is turned off
*/
template< typename MeshConfig,
typename DimensionsTag >
class tnlMeshInitializerLayer< MeshConfig,
DimensionsTag,
true,
false >
: public tnlMeshInitializerLayer< MeshConfig,
typename DimensionsTag::Decrement >
{
typedef tnlMeshTraits< MeshConfig > MeshTraits;
static const int Dimensions = DimensionsTag::value;
typedef tnlMeshInitializerLayer< MeshConfig, typename DimensionsTag::Decrement > BaseType;
typedef tnlMesh< MeshConfig > MeshType;
typedef typename MeshTraits::template EntityTraits< Dimensions > EntityTraits;
typedef typename EntityTraits::EntityTopology EntityTopology;
typedef typename MeshTraits::GlobalIndexType GlobalIndexType;
typedef typename MeshTraits::CellTopology CellTopology;
typedef typename EntityTraits::StorageArrayType StorageArrayType;
typedef tnlMeshInitializer< MeshConfig > InitializerType;
typedef tnlMeshEntityInitializer< MeshConfig, EntityTopology > EntityInitializerType;
typedef tnlMeshEntityInitializer< MeshConfig, EntityTopology > CellInitializerType;
typedef tnlArray< CellInitializerType, tnlHost, GlobalIndexType > CellInitializerContainerType;
typedef typename EntityTraits::SeedArrayType EntitySeedArrayType;
typedef typename MeshTraits::CellSeedArrayType CellSeedArrayType;
typedef typename MeshTraits::LocalIndexType LocalIndexType;
typedef typename MeshTraits::PointArrayType PointArrayType;
typedef tnlMeshEntitySeed< MeshConfig, EntityTopology > SeedType;
typedef tnlMeshSuperentityStorageInitializer< MeshConfig, EntityTopology > SuperentityInitializerType;
typedef typename
tnlMeshSubentityTraits< MeshConfig,
typename MeshConfig::CellTopology,
DimensionsTag::value >::SubentityContainerType SubentitiesContainerType;
public:
using BaseType::getEntityInitializer;
EntityInitializerType& getEntityInitializer( DimensionsTag, GlobalIndexType index )
{
//return entityInitializerContainer[ index ];
}
void createEntitySeedsFromCellSeeds( const CellSeedArrayType& cellSeeds )
{
typedef tnlMeshSubentitySeedsCreator< MeshConfig, CellTopology, DimensionsTag > SubentitySeedsCreator;
//cout << " Creating mesh entities with " << DimensionsTag::value << " dimensions ... " << endl;
for( GlobalIndexType i = 0; i < cellSeeds.getSize(); i++ )
{
//cout << " Creating mesh entities from cell number " << i << " : " << cellSeeds[ i ] << endl;
typedef typename SubentitySeedsCreator::SubentitySeedArray SubentitySeedArray;
SubentitySeedArray subentytiSeeds( SubentitySeedsCreator::create( cellSeeds[ i ] ) );
for( LocalIndexType j = 0; j < subentytiSeeds.getSize(); j++ )
{
//cout << "Creating subentity seed no. " << j << " : " << subentytiSeeds[ j ] << endl;
//tnlMeshEntitySeed< tnlMeshConfigBase< CellTopology >, EntityTopology >& entitySeed = subentytiSeeds[ j ];
this->seedsIndexedSet.insert( subentytiSeeds[ j ] );
}
}
BaseType::createEntitySeedsFromCellSeeds( cellSeeds );
}
using BaseType::findEntitySeedIndex;
GlobalIndexType findEntitySeedIndex( const SeedType& seed ) const
{
GlobalIndexType index;
this->seedsIndexedSet.find( seed, index );
return index;
}
using BaseType::getSuperentityInitializer;
SuperentityInitializerType& getSuperentityInitializer( DimensionsTag )
{
return this->superentityInitializer;
}
void initEntities( InitializerType& initializer, const PointArrayType& points )
{
StorageArrayType &entityArray = initializer.template meshEntitiesArray< DimensionsTag >();
//cout << " Initiating entities with " << DimensionsTag::value << " dimensions ... " << endl;
entityArray.setSize( this->seedsIndexedSet.getSize() );
EntitySeedArrayType seedsArray;
seedsArray.setSize( this->seedsIndexedSet.getSize() );
this->seedsIndexedSet.toArray( seedsArray );
for( GlobalIndexType i = 0; i < this->seedsIndexedSet.getSize(); i++ )
{
//cout << " Initiating entity " << i << endl;
EntityInitializerType::initEntity( entityArray[ i ], i, seedsArray[ i ], initializer );
}
this->seedsIndexedSet.reset();
this->superentityInitializer.initSuperentities( initializer );
BaseType::initEntities(initializer, points);
}
void createEntityReferenceOrientations() const {}
private:
typedef typename tnlMeshEntityTraits< MeshConfig, DimensionsTag::value >::SeedIndexedSetType SeedIndexedSet;
SeedIndexedSet seedsIndexedSet;
SuperentityInitializerType superentityInitializer;
};
/****
* Mesh initializer layer for other mesh entities than cells
* - entities storage is turned on
* - entities orientation storage is turned on
*/
template< typename MeshConfig,
typename DimensionsTag >
class tnlMeshInitializerLayer< MeshConfig,
DimensionsTag,
true,
true >
: public tnlMeshInitializerLayer< MeshConfig,
typename DimensionsTag::Decrement >
{
typedef tnlMeshInitializerLayer< MeshConfig,
typename DimensionsTag::Decrement > BaseType;
typedef tnlMesh< MeshConfig > MeshType;
typedef typename MeshType::MeshTraits MeshTraits;
typedef typename MeshType::template EntityTraits< DimensionsTag::value > EntityTraits;
typedef typename EntityTraits::EntityTopology EntityTopology;
typedef typename EntityTraits::EntityType EntityType;
typedef typename EntityTraits::StorageArrayType ContainerType;
typedef typename EntityTraits::UniqueContainerType UniqueContainerType;
typedef typename ContainerType::IndexType GlobalIndexType;
typedef typename MeshTraits::CellTopology CellTopology;
typedef tnlMeshInitializer< MeshConfig > InitializerType;
typedef tnlMeshEntityInitializer< MeshConfig, CellTopology > CellInitializerType;
typedef tnlMeshEntityInitializer< MeshConfig, EntityTopology > EntityInitializerType;
typedef tnlArray< EntityInitializerType, tnlHost, GlobalIndexType > EntityInitializerContainerType;
typedef typename MeshTraits::CellSeedArrayType CellSeedArrayType;
typedef typename MeshTraits::LocalIndexType LocalIndexType;
typedef typename MeshTraits::PointArrayType PointArrayType;
typedef typename EntityTraits::StorageArrayType EntityArrayType;
typedef typename EntityTraits::SeedArrayType SeedArrayType;
typedef tnlMeshEntitySeed< MeshConfig, EntityTopology > SeedType;
typedef tnlMeshSuperentityStorageInitializer< MeshConfig, EntityTopology > SuperentityInitializerType;
typedef typename EntityTraits::ReferenceOrientationType ReferenceOrientationType;
typedef typename EntityTraits::ReferenceOrientationArrayType ReferenceOrientationArrayType;
typedef typename
tnlMeshSubentityTraits< MeshConfig,
typename MeshConfig::CellTopology,
DimensionsTag::value >::SubentityContainerType SubentitiesContainerType;
public:
using BaseType::getEntityInitializer;
EntityInitializerType& getEntityInitializer( DimensionsTag, GlobalIndexType index )
{
//return entityInitializerContainer[ index ];
}
void createEntitySeedsFromCellSeeds( const CellSeedArrayType& cellSeeds )
{
typedef tnlMeshSubentitySeedsCreator< MeshConfig, CellTopology, DimensionsTag > SubentitySeedsCreator;
//cout << " Creating mesh entities with " << DimensionsTag::value << " dimensions ... " << endl;
for( GlobalIndexType i = 0; i < cellSeeds.getSize(); i++ )
{
//cout << " Creating mesh entities from cell number " << i << " : " << cellSeeds[ i ] << endl;
typedef typename SubentitySeedsCreator::SubentitySeedArray SubentitySeedArray;
SubentitySeedArray subentytiSeeds( SubentitySeedsCreator::create( cellSeeds[ i ] ) );
for( LocalIndexType j = 0; j < subentytiSeeds.getSize(); j++ )
{
//cout << "Creating subentity seed no. " << j << " : " << subentytiSeeds[ j ] << endl;
//tnlMeshEntitySeed< tnlMeshConfigBase< CellTopology >, EntityTopology >& entitySeed = subentytiSeeds[ j ];
this->seedsIndexedSet.insert( subentytiSeeds[ j ] );
}
}
BaseType::createEntitySeedsFromCellSeeds( cellSeeds );
}
using BaseType::findEntitySeedIndex;
GlobalIndexType findEntitySeedIndex( const SeedType& seed ) const
{
GlobalIndexType index;
this->seedsIndexedSet.find( seed, index );
return index;
}
using BaseType::getSuperentityInitializer;
SuperentityInitializerType& getSuperentityInitializer( DimensionsTag )
{
return this->superentityInitializer;
}
void initEntities( InitializerType& initializer, const PointArrayType& points )
{
EntityArrayType &entityArray = initializer.template meshEntitiesArray< DimensionsTag >();
//cout << " Initiating entities with " << DimensionsTag::value << " dimensions ... " << endl;
entityArray.setSize( this->seedsIndexedSet.getSize() );
SeedArrayType seedsArray;
seedsArray.setSize( this->seedsIndexedSet.getSize() );
this->seedsIndexedSet.toArray( seedsArray );
for( GlobalIndexType i = 0; i < this->seedsIndexedSet.getSize(); i++ )
{
//cout << " Initiating entity " << i << endl;
EntityInitializerType::initEntity( entityArray[ i ], i, seedsArray[ i ], initializer );
}
this->seedsIndexedSet.reset();
this->superentityInitializer.initSuperentities( initializer );
BaseType::initEntities(initializer, points);
}
using BaseType::getReferenceOrientation;
const ReferenceOrientationType& getReferenceOrientation( DimensionsTag, GlobalIndexType index) const
{
return this->referenceOrientations[ index ];
}
void createEntityReferenceOrientations()
{
//cout << " Creating entity reference orientations with " << DimensionsTag::value << " dimensions ... " << endl;
SeedArrayType seedsArray;
seedsArray.setSize( this->seedsIndexedSet.getSize() );
this->seedsIndexedSet.toArray( seedsArray );
this->referenceOrientations.setSize( seedsArray.getSize() );
for( GlobalIndexType i = 0; i < seedsArray.getSize(); i++ )
{
//cout << " Creating reference orientation for entity " << i << endl;
this->referenceOrientations[ i ] = ReferenceOrientationType( seedsArray[ i ] );
}
BaseType::createEntityReferenceOrientations();
}
private:
typedef typename tnlMeshEntityTraits< MeshConfig, DimensionsTag::value >::SeedIndexedSetType SeedIndexedSet;
SeedIndexedSet seedsIndexedSet;
SuperentityInitializerType superentityInitializer;
ReferenceOrientationArrayType referenceOrientations;
};
/****
* Mesh initializer layer for entities not being stored
*/
template< typename MeshConfig,
typename DimensionsTag >
class tnlMeshInitializerLayer< MeshConfig,
DimensionsTag,
false,
false >
: public tnlMeshInitializerLayer< MeshConfig,
typename DimensionsTag::Decrement >
{};
/****
* Mesh initializer layer for vertices
* - vertices must always be stored
* - their orientation does not make sense
*/
template< typename MeshConfig >
class tnlMeshInitializerLayer< MeshConfig,
tnlDimensionsTag< 0 >,
true,
false >
{
typedef tnlMesh< MeshConfig > MeshType;
typedef typename MeshType::MeshTraits MeshTraits;
typedef tnlDimensionsTag< 0 > DimensionsTag;
typedef typename MeshType::template EntityTraits< DimensionsTag::value > EntityTraits;
typedef typename EntityTraits::EntityTopology EntityTopology;
typedef typename EntityTraits::StorageArrayType ContainerType;
typedef typename EntityTraits::AccessArrayType SharedContainerType;
typedef typename ContainerType::IndexType GlobalIndexType;
typedef typename MeshTraits::CellTopology CellTopology;
typedef tnlMeshInitializer< MeshConfig > InitializerType;
typedef tnlMeshEntityInitializer< MeshConfig, CellTopology > CellInitializerType;
typedef tnlMeshEntityInitializer< MeshConfig, EntityTopology > VertexInitializerType;
typedef tnlArray< VertexInitializerType, tnlHost, GlobalIndexType > VertexInitializerContainerType;
typedef typename tnlMeshTraits< MeshConfig >::CellSeedArrayType CellSeedArrayType;
typedef typename tnlMeshTraits< MeshConfig >::LocalIndexType LocalIndexType;
typedef typename tnlMeshTraits< MeshConfig >::PointArrayType PointArrayType;
typedef typename EntityTraits::StorageArrayType EntityArrayType;
typedef tnlMeshEntityInitializer< MeshConfig, EntityTopology > EntityInitializerType;
typedef tnlMeshSuperentityStorageInitializer< MeshConfig, EntityTopology > SuperentityInitializerType;
public:
void setMesh( MeshType& mesh )
{
this->mesh = &mesh;
}
MeshType& getMesh()
{
tnlAssert( this->mesh, );
return *( this->mesh );
}
VertexInitializerType& getEntityInitializer( DimensionsTag, GlobalIndexType index )
{
tnlAssert( index >= 0 && index < vertexInitializerContainer.getSize(),
cerr << " index = " << index
<< " vertexInitializerContainer.getSize() = " << vertexInitializerContainer.getSize() << endl; );
return vertexInitializerContainer[ index ];
}
void createEntitySeedsFromCellSeeds( const CellSeedArrayType& cellSeeds ){};
void initEntities( InitializerType& initializer, const PointArrayType& points )
{
EntityArrayType &vertexArray = initializer.template meshEntitiesArray< DimensionsTag >();
vertexArray.setSize( points.getSize() );
for( GlobalIndexType i = 0; i < vertexArray.getSize(); i++ )
EntityInitializerType::setVertexPoint( vertexArray[i], points[i], initializer );
superentityInitializer.initSuperentities( initializer );
}
void findEntitySeedIndex() const {} // This method is due to 'using BaseType::findEntityIndex;' in the derived class.
void createEntityInitializers()
{
vertexInitializerContainer.setSize( this->getMesh().template getNumberOfEntities< DimensionsTag::value >() );
}
SuperentityInitializerType& getSuperentityInitializer( DimensionsTag )
{
return this->superentityInitializer;
}
void createEntityReferenceOrientations() const {}
void getReferenceOrientation() const {}
private:
SuperentityInitializerType superentityInitializer;
VertexInitializerContainerType vertexInitializerContainer;
MeshType* mesh;
};
#endif /* TNLMESHINITIALIZER_H_ */