Skip to content
Snippets Groups Projects
Commit 11431e7d authored by Christoph Grüninger's avatar Christoph Grüninger
Browse files

Move geometrytype.hh and geometrytypeindex.hh from dune-common to 

dune-geometry.

[[Imported from SVN: r6796]]
parent 50f10eb1
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
dune/common/Makefile.am
+ 0
− 2
View file @ 11431e7d
......@@ -46,8 +46,6 @@ commoninclude_HEADERS = \
fvector.hh \
gcd.hh \
genericiterator.hh \
geometrytype.hh \
geometrytypeindex.hh \
gmpfield.hh \
indent.hh \
interfaces.hh \
......
dune/common/geometrytype.hh deleted 100644 → 0
+ 0
− 395
View file @ 50f10eb1
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DISABLE_GEOMETRYTYPE_DEPRECATION_WARNING
#warning #include <dune/common/geometrytype.hh> is deprecated. Use
#warning #include <dune/geometry/type.hh> instead. You may need the new
#warning Dune-Geometry core module.
#endif // DISABLE_GEOMETRYTYPE_DEPRECATION_WARNING
#ifndef DUNE_COMMON_GEOMETRYTYPE_HH
#define DUNE_COMMON_GEOMETRYTYPE_HH
#include <cassert>
/** \file
\brief A unique label for each type of element that can occur in a grid
\deprecated This header has been moved to \<dune/geometry/type.hh\>,
you may need the new Dune-Geometry core module.
*/
#include <dune/common/exceptions.hh>
#include <dune/common/deprecated.hh>
namespace Dune {
/** \brief Unique label for each type of entities that can occur in DUNE grids
This class has to be extended if a grid implementation with new entity types
is added to DUNE.
\deprecated The location of this class has been moved to \<dune/geometry/type.hh\>,
you may need the new Dune-Geometry core module.
\ingroup COGeometryType
*/
class GeometryType
{
public:
/** \brief Each entity can be tagged by one of these basic types
plus its space dimension */
enum BasicType {
simplex, //!< Simplicial element in any nonnegative dimension
cube, //!< Cube element in any nonnegative dimension
pyramid, //!< Four sided pyramid in three dimensions
prism, //!< Prism element in three dimensions
extended, //!< Other, more general geometry, representable as topologyId
none //!< Generic element in any nonnegative dimension
};
/** \brief A few binary constants */
enum Binary {
b0001 = 1,
b0011 = 3,
b0101 = 5,
b0111 = 7
};
private:
/** \brief Topology Id element */
unsigned int topologyId_;
/** \brief Dimension of the element */
unsigned char dim_ : 7;
/** \brief bool if this is none-type */
bool none_ : 1;
public:
/** \brief Default constructor, not initializing anything */
GeometryType ()
: topologyId_(0), dim_(0), none_(true)
{}
/** \brief Constructor */
GeometryType(BasicType basicType, unsigned int dim)
: topologyId_(0), dim_(dim), none_(false)
{
if (dim < 2)
return;
switch( basicType )
{
case GeometryType::simplex :
makeSimplex(dim);
break;
case GeometryType::cube :
makeCube(dim);
break;
case GeometryType::pyramid :
if (dim == 3)
makePyramid();
break;
case GeometryType::prism :
if (dim == 3)
makePrism();
break;
case GeometryType::none :
makeNone(dim);
break;
default :
DUNE_THROW( RangeError,
"Invalid basic geometry type: " << basicType << " for dimension " << dim << "." );
}
}
/** \brief Constructor */
GeometryType(unsigned int topologyId, unsigned int dim)
: topologyId_(topologyId), dim_(dim), none_(false)
{}
/** \brief Constructor from static TopologyType class
*
* Constructs the GeometryType object from a static topology representation.
*
* \tparam TopologyType A class providing public static unsigned int members
* TopologyType::dimension and TopologyType::id.
* You can e.g. use the Point, Prism and Pyramid structs from
* topologytypes.hh in dune-grid.
* \param t Any object of type TopologyType. The object t itself is ignored.
*/
template<class TopologyType>
explicit GeometryType(TopologyType t)
: topologyId_(TopologyType::id), dim_(TopologyType::dimension), none_(false)
{}
/** \brief Constructor for vertices and segments */
explicit GeometryType(unsigned int dim)
: topologyId_(0), dim_(dim), none_(false)
{
assert(dim < 2);
}
/** \brief Constructor for vertices and segments */
// We need this constructor for "int" and "unsigned int",
// because otherwise GeometryType(int) would try to call the
// generic GeometryType(TopologyType) constructor
explicit GeometryType(int dim)
: topologyId_(0), dim_(dim), none_(false)
{
assert(dim < 2);
}
/** @name Setup Methods */
/*@{*/
/** \brief Make a vertex */
void makeVertex() {
none_ = false;
dim_ = 0;
topologyId_ = 0;
}
/** \brief Make a line segment */
void makeLine() {
none_ = false;
dim_ = 1;
topologyId_ = 0;
}
/** \brief Make a triangle */
void makeTriangle() {
makeSimplex(2);
}
/** \brief Make a quadrilateral */
void makeQuadrilateral() {
makeCube(2);
}
/** \brief Make a tetrahedron */
void makeTetrahedron() {
makeSimplex(3);
}
/** \brief Make a pyramid */
void makePyramid() {
none_ = false;
dim_ = 3;
topologyId_ = b0011;
}
/** \brief Make a prism */
void makePrism() {
none_ = false;
dim_ = 3;
topologyId_ = b0101; // (1 << (dim_-1)) - 1;
}
/** \brief Make a hexahedron */
void makeHexahedron() {
makeCube(3);
}
/** \brief Make a simplex of given dimension */
void makeSimplex(unsigned int dim) {
none_ = false;
dim_ = dim;
topologyId_ = 0;
}
/** \brief Make a hypercube of given dimension */
void makeCube(unsigned int dim) {
none_ = false;
dim_ = dim;
topologyId_ = ((dim>1) ? ((1 << dim) - 1) : 0);
}
/** \brief Make a singular of given dimension */
void makeNone(unsigned int dim) {
none_ = true;
dim_ = dim;
topologyId_ = 0;
}
/*@}*/
/** @name Query Methods */
/*@{*/
/** \brief Return true if entity is a vertex */
bool isVertex() const {
return dim_==0;
}
/** \brief Return true if entity is a line segment */
bool isLine() const {
return dim_==1;
}
/** \brief Return true if entity is a triangle */
bool isTriangle() const {
return ! none_ && dim_==2 && (topologyId_ | 1) == b0001;
}
/** \brief Return true if entity is a quadrilateral */
bool isQuadrilateral() const {
return ! none_ && dim_==2 && (topologyId_ | 1) == b0011;
}
/** \brief Return true if entity is a tetrahedron */
bool isTetrahedron() const {
return ! none_ && dim_==3 && (topologyId_ | 1) == b0001;
}
/** \brief Return true if entity is a pyramid */
bool isPyramid() const {
return ! none_ && dim_==3 && (topologyId_ | 1) == b0011;
}
/** \brief Return true if entity is a prism */
bool isPrism() const {
return ! none_ && dim_==3 && (topologyId_ | 1) == b0101;
}
/** \brief Return true if entity is a hexahedron */
bool isHexahedron() const {
return ! none_ && dim_==3 && (topologyId_ | 1) == b0111;
}
/** \brief Return true if entity is a simplex of any dimension */
bool isSimplex() const {
return ! none_ && (topologyId_ | 1) == 1;
}
/** \brief Return true if entity is a cube of any dimension */
bool isCube() const {
return ! none_ && ((topologyId_ ^ ((1 << dim_)-1)) >> 1 == 0);
}
/** \brief Return true if entity is a singular of any dimension */
bool isNone() const {
return none_;
}
/** \brief Return dimension of the type */
unsigned int dim() const {
return dim_;
}
/** \brief Return the basic type of the type */
BasicType basicType() const DUNE_DEPRECATED {
if (isSimplex())
return GeometryType::simplex;
if (isCube())
return GeometryType::cube;
if (isPyramid())
return GeometryType::pyramid;
if (isPrism())
return GeometryType::prism;
if (isNone())
return GeometryType::none;
return GeometryType::extended;
}
/** \brief Return the topology id the type */
unsigned int id() const {
return topologyId_;
}
/*@}*/
/** \brief Check for equality. This method knows that in dimension 0 and 1
all BasicTypes are equal.
*/
bool operator==(const GeometryType& other) const {
return ( ( none_ == other.none_ )
&& ( ( none_ == true )
|| ( ( dim_ == other.dim_ )
&& ( (topologyId_ >> 1) == (other.topologyId_ >> 1) )
)
)
);
}
/** \brief Check for inequality */
bool operator!=(const GeometryType& other) const {
return ! ((*this)==other);
}
/** \brief less-than operation for use with maps */
bool operator < (const GeometryType& other) const {
return ( ( none_ < other.none_ )
|| ( !( other.none_ < none_ )
&& ( ( dim_ < other.dim_ )
|| ( (other.dim_ == dim_)
&& ((topologyId_ >> 1) < (other.topologyId_ >> 1) )
)
)
)
);
}
};
/** \brief Prints the type to an output stream */
inline std::ostream& operator<< (std::ostream& s, const GeometryType& a)
{
if (a.isSimplex())
{
s << "(simplex, " << a.dim() << ")";
return s;
}
if (a.isCube())
{
s << "(cube, " << a.dim() << ")";
return s;
}
if (a.isPyramid())
{
s << "(pyramid, 3)";
return s;
}
if (a.isPrism())
{
s << "(prism, 3)";
return s;
}
if (a.isNone())
{
s << "(none, " << a.dim() << ")";
return s;
}
s << "(other [" << a.id() << "], " << a.dim() << ")";
return s;
}
/** \brief Prints a GeometryType::BasicType to an output stream */
inline std::ostream& operator<< (std::ostream& s, GeometryType::BasicType type)
{
switch (type) {
case GeometryType::simplex :
s << "simplex";
break;
case GeometryType::cube :
s << "cube";
break;
case GeometryType::pyramid :
s << "pyramid";
break;
case GeometryType::prism :
s << "prism";
break;
case GeometryType::extended :
s << "other";
case GeometryType::none :
s << "none";
break;
default :
DUNE_THROW(Exception, "invalid GeometryType::BasicType");
}
return s;
}
}
#endif // DUNE_COMMON_GEOMETRYTYPE_HH
dune/common/geometrytypeindex.hh deleted 100644 → 0
+ 0
− 129
View file @ 50f10eb1
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DISABLE_GEOMETRYTYPEINDEX_DEPRECATION_WARNING
#warning #include <dune/common/geometrytypeindex.hh> is deprecated. Use
#warning #include <dune/geometry/typeindex.hh> instead. You may need the new
#warning Dune-Geometry core module.
#warning NOTE: <dune/common/geometrytypeindex.hh> was never part of a release,
#warning so this compatibility mechanism should be removed before the 2.2
#warning release.
#endif // DISABLE_GEOMETRYTYPEINDEX_DEPRECATION_WARNING
#ifndef DUNE_COMMON_GEOMETRYTYPEINDEX_HH
#define DUNE_COMMON_GEOMETRYTYPEINDEX_HH
/** \file
* \brief Helper classes to provide indices for geometrytypes for use in a
* vector
*/
#include <cstddef>
#define DISABLE_GEOMETRYTYPE_DEPRECATION_WARNING
#include <dune/common/geometrytype.hh>
#undef DISABLE_GEOMETRYTYPE_DEPRECATION_WARNING
namespace Dune {
//! Compute per-dimension indices for geometry types
class LocalGeometryTypeIndex {
//! compute the number of regular geometry types for the given dimension
/**
* Regular geometry type are those which have a topologyId, i.e. "None" is
* not a regular geometry type.
*/
inline static std::size_t regular_size(std::size_t dim) {
// The following expression is derived from the expression for
// GlobalGeometryTypeIndex::regular_base(). Substracting
// regular_base(dim+1)-regular_base(dim) we get:
//
// ((1 << dim+1) >> 1) - ((1 << dim) >> 1)
//
// We always have
//
// dim >= 0,
//
// so
//
// (1 << dim+1) >= 2 and (1 << dim+2) % 2 == 0.
//
// So if we apply a single right-shift to that, we will never lose any
// set bits, thus
//
// ((1 << dim+1) >> 1) == (1 << dim)
return (1 << dim) - ((1 << dim) >> 1);
}
public:
//! compute total number of geometry types for the given dimension
/**
* This includes irregular geometry types such as "None".
*/
inline static std::size_t size(std::size_t dim) {
// one for "none"
return regular_size(dim) + 1;
}
//! compute the index for the given geometry type within its dimension
/**
* Geometry types from different dimensions my get the same index. If
* that is not what you want, maybe you should look at
* GlobalGeometryTypeIndex.
*/
inline static std::size_t index(const GeometryType &gt) {
if(gt.isNone())
return regular_size(gt.dim());
else
return gt.id() >> 1;
}
};
//! Compute indices for geometry types, taking the dimension into account
class GlobalGeometryTypeIndex {
//! \brief Compute the starting index for a given dimension ignoring
//! irregular geometry types
/**
* This ignores irregular geometry types so it is not useful in itself.
* Have a look at base() which does include the irregular geometry types.
*/
inline static std::size_t regular_base(std::size_t dim) {
// The number of regular geometry types in a given dimension is
// 2^(dim-1). For dim==0 this would yield 1/2 geometry types (which is
// obviously bogus, dim==0 has one regular geometry type, the point).
// The following expression relies on 1 >> 1 == 0 to treat dim==0
// specially.
return (1 << dim) >> 1;
}
//! \brief Compute the starting index for a given dimension including
//! irregular geometry types
inline static std::size_t base(std::size_t dim) {
// dim times "none"
return regular_base(dim) + dim;
}
public:
//! \brief Compute total number of geometry types up to and including the
//! given dimension
/**
* This includes irregular geometry types such as "None".
*/
inline static std::size_t size(std::size_t maxdim)
{ return base(maxdim+1); }
//! compute the index for the given geometry type over all dimensions
/**
* Geometry types from different dimensions will get different indices,
* and lower dimensions will always have lower indices than higher
* dimensions. If that is not what you want, maybe you should look at
* LocalGeometryTypeIndex.
*/
inline static std::size_t index(const GeometryType &gt) {
return base(gt.dim()) + LocalGeometryTypeIndex::index(gt);
}
};
} // namespace Dune
#endif // DUNE_COMMON_GEOMETRYTYPEINDEX_HH
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment