#include <hHybridMesh.h>


Public Types | |
| typedef StaticPool< Elem, ElemPrism::nVerts > | ElemPool |
| typedef StaticPool< Face, Face4::nVerts > | FacePool |
| typedef StaticPool< Edge, Edge::nVerts > | EdgePool |
| typedef StaticPool< Vertex, Vertex::nVerts > | VertexPool |
| typedef ElemPool::Iterator < ElemPool::notBroken > | Iterator |
| typedef ElemPool::constIterator < ElemPool::notBroken > | constIterator |
| typedef ElemPool::Iterator | allIterator |
| typedef ElemPool::constIterator | allConstIterator |
Public Member Functions | |
| hHybridMesh (MeshWrite::IMeshWriter *defaultWriter=NULL, MeshRead::IMeshReader *defaultReader=NULL) | |
| ~hHybridMesh () | |
| bool | read (MeshRead::IMeshReader &reader) |
| bool | read (MeshRead::IMeshReader *readers[], const int noReaders) |
| bool | write (MeshWrite::IMeshWriter &writer) const |
| bool | free () |
| virtual bool | normalizationProcessor () |
| bool | printSetup () |
| bool | checkUniqueness () const |
| bool | checkGeometry () const |
| bool | checkTypes () const |
| bool | checkAll () const |
| bool | createBoundaryLayer (const double thicknessProc=0.1, const int nLayers=1, const bool quadraticDistribution=false, const double *vecIgnoreNormal=NULL) |
| bool | initRefine () |
| bool | refine () |
| bool | refineElem (hObj &el) |
| bool | refineElem (const int elemID) |
| bool | rRefine (const int BC_id, void(*reallocation_func)(double *x, double *y, double *z)) |
| bool | derefine () |
| bool | derefineElem (hObj &elx) |
| bool | derefineElem (const int elemID) |
| bool | finalRef () |
| Assume that: no more than one-level_adaptation is done in one REFINEMENT. | |
| bool | isRefining () const |
| Edge & | edge (const uTind v0, const uTind v1) |
| hObj & | face (const uTind v0, const uTind v1, const uTind v2, const uTind v3=UNKNOWN) |
| const hObj & | face (const uTind v0, const uTind v1, const uTind v2, const uTind v3=UNKNOWN) const |
| hObj & | element (const uTind v0, const uTind v1, const uTind v2, const uTind v3, const uTind v4=UNKNOWN, const uTind v5=UNKNOWN) |
| Edge & | edge (const uTind *v) |
| hObj & | face (const uTind v[4]) |
| const hObj & | face (const uTind v[4]) const |
| ID | faceVertex (const hObj &face, const Tind vertNo) const |
| ID | elemVertex (const hObj &elem, const Tind vertNo) const |
| ID | elemNeigh (const hObj &elem, const Tind neighNo) const |
| int | whichNeighAmI (const hObj &elem, const hObj &otherElem) const |
| int | whichFaceAmI (const hObj &face, const hObj &elem) const |
| int | whichNodeAmI (const hObj &node, const hObj &elem) const |
| eElemFlag | normalizeElem (hObj &elem) |
| eFaceFlag | normalizeFace (hObj &face, hObj &elem) |
| double | elemHSize (const hObj &elem) |
| void | faceNormal (IN const hObj &face, OUT double vecNorm[3], OUT double *area) const |
| eFaceFlag | faceDirection (const hObj &face, const hObj &elem) const |
| Iterator | begin () |
| constIterator | begin () const |
| size_t | totalSize () const |
| bool | test () const |
| void | findEdgeElems () |
| void | computeDist2Bound (const int BCs[], const int nBCs) |
| void | print () const |
Public Attributes | |
| const int | meshId_ |
| VertexPool | vertices_ |
| EdgePool | edges_ |
| FacePool | faces_ |
| ElemPool | elements_ |
| std::string | name_ |
| int | gen_ |
| int | maxGen_ |
| int | maxGenDiff_ |
| int | maxEdgesPerVertex_ |
| int | maxFacesPerVertex_ |
| MeshWrite::IMeshWriter * | defaultWriter_ |
| MeshRead::IMeshReader * | defaultReader_ |
| std::vector< std::vector< uTind > > | edge_elems |
| bool | wasNormalized_ |
Protected Member Functions | |
| hHybridMesh (const hHybridMesh &other) | |
| hHybridMesh & | operator= (const hHybridMesh &other) |
| bool | actualRefine () |
| bool | actualDerefine () |
| bool | actualDelete () |
Protected Attributes | |
| bool | isRefining_ |
Friends | |
| std::ofstream & | operator<< (std::ofstream &stream, const hHybridMesh &mesh) |
| typedef ElemPool::constIterator hHybridMesh::allConstIterator |
| typedef ElemPool::Iterator hHybridMesh::allIterator |
| typedef ElemPool::constIterator<ElemPool::notBroken> hHybridMesh::constIterator |
| typedef StaticPool<Edge, Edge::nVerts> hHybridMesh::EdgePool |
| typedef StaticPool<Elem, ElemPrism::nVerts> hHybridMesh::ElemPool |
| typedef StaticPool<Face, Face4::nVerts> hHybridMesh::FacePool |
| typedef ElemPool::Iterator<ElemPool::notBroken> hHybridMesh::Iterator |
| typedef StaticPool<Vertex, Vertex::nVerts> hHybridMesh::VertexPool |
| hHybridMesh::hHybridMesh | ( | MeshWrite::IMeshWriter * | defaultWriter = NULL, |
|
| MeshRead::IMeshReader * | defaultReader = NULL | |||
| ) |

| hHybridMesh::~hHybridMesh | ( | ) |

| hHybridMesh::hHybridMesh | ( | const hHybridMesh & | other | ) | [protected] |
| bool hHybridMesh::actualDelete | ( | ) | [protected] |
| bool hHybridMesh::actualDerefine | ( | ) | [protected] |
| bool hHybridMesh::actualRefine | ( | ) | [protected] |
| constIterator hHybridMesh::begin | ( | ) | const [inline] |

| Iterator hHybridMesh::begin | ( | ) | [inline] |


| bool hHybridMesh::checkAll | ( | ) | const |


| bool hHybridMesh::checkGeometry | ( | ) | const |

| bool hHybridMesh::checkTypes | ( | ) | const |

| bool hHybridMesh::checkUniqueness | ( | ) | const |

| void hHybridMesh::computeDist2Bound | ( | const int | BCs[], | |
| const int | nBCs | |||
| ) |
| bool hHybridMesh::createBoundaryLayer | ( | const double | thicknessProc = 0.1, |
|
| const int | nLayers = 1, |
|||
| const bool | quadraticDistribution = false, |
|||
| const double * | vecIgnoreNormal = NULL | |||
| ) |
FACE LEVEL


| bool hHybridMesh::derefine | ( | ) |


| bool hHybridMesh::derefineElem | ( | const int | elemID | ) |

| bool hHybridMesh::derefineElem | ( | hObj & | elx | ) |




| hObj & hHybridMesh::element | ( | const uTind | v0, | |
| const uTind | v1, | |||
| const uTind | v2, | |||
| const uTind | v3, | |||
| const uTind | v4 = UNKNOWN, |
|||
| const uTind | v5 = UNKNOWN | |||
| ) |
| double hHybridMesh::elemHSize | ( | const hObj & | elem | ) |
/* compute hsize as third root of volume (computed as mixed produc/





| const hObj & hHybridMesh::face | ( | const uTind | v0, | |
| const uTind | v1, | |||
| const uTind | v2, | |||
| const uTind | v3 = UNKNOWN | |||
| ) | const |

| hObj & hHybridMesh::face | ( | const uTind | v0, | |
| const uTind | v1, | |||
| const uTind | v2, | |||
| const uTind | v3 = UNKNOWN | |||
| ) |

2. Compute "center vector" from face center to existing neigh center. (pointing inside element)
3. Determine angle between normal vector and center vector. If angle < 90(deg) normal vector IS POINTING INSIDE and must points outside, so we mark appr. flag.


| void hHybridMesh::faceNormal | ( | IN const hObj & | face, | |
| OUT double | vecNorm[3], | |||
| OUT double * | area | |||
| ) | const |
switch



| bool hHybridMesh::finalRef | ( | ) |
Assume that: no more than one-level_adaptation is done in one REFINEMENT.


| void hHybridMesh::findEdgeElems | ( | ) |


| bool hHybridMesh::free | ( | ) |


| bool hHybridMesh::initRefine | ( | ) |

| bool hHybridMesh::isRefining | ( | ) | const [inline] |

| bool hHybridMesh::normalizationProcessor | ( | ) | [virtual] |
Reimplemented in hHybridMeshWithContacts.


volume testing
volume testing


switch


| hHybridMesh& hHybridMesh::operator= | ( | const hHybridMesh & | other | ) | [protected] |
| void hHybridMesh::print | ( | ) | const |

| bool hHybridMesh::printSetup | ( | ) |
Marking element types


| bool hHybridMesh::read | ( | MeshRead::IMeshReader * | readers[], | |
| const int | noReaders | |||
| ) |

| bool hHybridMesh::read | ( | MeshRead::IMeshReader & | reader | ) |


| bool hHybridMesh::refine | ( | ) |


| bool hHybridMesh::refineElem | ( | const int | elemID | ) |

| bool hHybridMesh::refineElem | ( | hObj & | el | ) |


| bool hHybridMesh::rRefine | ( | const int | BC_id, | |
| void(*)(double *x, double *y, double *z) | reallocation_func | |||
| ) |


| bool hHybridMesh::test | ( | ) | const |


| size_t hHybridMesh::totalSize | ( | ) | const [inline] |






| bool hHybridMesh::write | ( | MeshWrite::IMeshWriter & | writer | ) | const |


| std::ofstream& operator<< | ( | std::ofstream & | stream, | |
| const hHybridMesh & | mesh | |||
| ) | [friend] |
| std::vector< std::vector<uTind> > hHybridMesh::edge_elems |
bool hHybridMesh::isRefining_ [protected] |
| const int hHybridMesh::meshId_ |
| std::string hHybridMesh::name_ |
1.6.1