Mesh.h 22.2 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
// ==  crystal growth group                                                  ==
// ==                                                                        ==
// ==  Stiftung caesar                                                       ==
// ==  Ludwig-Erhard-Allee 2                                                 ==
// ==  53175 Bonn                                                            ==
// ==  germany                                                               ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
// ==  http://www.caesar.de/cg/AMDiS                                         ==
// ==                                                                        ==
// ============================================================================

/** \file Mesh.h */

/** \defgroup Triangulation Triangulation module
 * @{ <img src="triangulation.png"> @}
 *
 * Example:
 *
 * @{ <img src="hierarchicalMesh.png"> @}
 *
 * \brief
 * Contains all triangulation classes.
 */

#ifndef AMDIS_MESH_H
#define AMDIS_MESH_H

#include "DOFAdmin.h"
#include "Line.h"
#include "Triangle.h"
#include "Tetrahedron.h"
#include "Element.h"
#include "ElInfo.h"
#include "FixVec.h"
#include "MemoryManager.h"
#include "Serializable.h"
#include "BoundaryCondition.h"
#include <deque>
#include <set>
#include <stdio.h>

namespace AMDiS {

  template <typename T> class DimVec; 
  template <typename T> class VectorOfFixVecs;
  class Boundary;
  class Projection;
  class ElInfo;
  class Element;
  class MacroElement;
  class DOFAdmin;
  class MacroInfo;
  template<typename T> class WorldVector;
  class Quadrature;
  class Parametric;
  class PeriodicBC;
  class DOFVectorDOF;
  class VertexVector;

  /** \ingroup Triangulation 
   * \brief
   * A Mesh holds all information about a triangulation. 
   */
  class Mesh : public Serializable
  {
  public:
    MEMORY_MANAGED(Mesh);

Thomas Witkowski's avatar
Thomas Witkowski committed
77
    /// Creates a mesh with the given name of dimension dim
78
    Mesh(const std::string& name, int dim);
79

Thomas Witkowski's avatar
Thomas Witkowski committed
80
    /// Destructor
81
82
    virtual ~Mesh();

Thomas Witkowski's avatar
Thomas Witkowski committed
83
    /// Reads macro triangulation.
84
85
    void initialize();

Thomas Witkowski's avatar
Thomas Witkowski committed
86
    /// Assignment operator
87
88
89
90
91
92
    Mesh& operator=(const Mesh&);

    /** \name static methods used while mesh traversal 
     * \{
     */

Thomas Witkowski's avatar
Thomas Witkowski committed
93
    /// Used while dof compress
94
95
    static int newDOFFct1(ElInfo* e);

Thomas Witkowski's avatar
Thomas Witkowski committed
96
    /// Used while dof compress
97
98
99
100
101
102
103
104
105
106
107
108
109
    static int newDOFFct2(ElInfo* e);
    /** \} */

    /** \name getting methods
     * \{
     */

    /** \brief
     * Returns geometric information about this mesh. With GeoIndex p it is 
     * specifiedm which information is requested.
     */
    inline int getGeo(GeoIndex p) const { 
      return Global::getGeo(p, dim); 
110
    }
111

Thomas Witkowski's avatar
Thomas Witkowski committed
112
    /// Returns \ref name of the mesh
113
    inline const std::string& getName() const { 
114
      return name; 
115
    }
116

Thomas Witkowski's avatar
Thomas Witkowski committed
117
    /// Returns \ref dim of the mesh
118
119
    inline int getDim() const { 
      return dim; 
120
    }
121

Thomas Witkowski's avatar
Thomas Witkowski committed
122
    /// Returns \ref nDOFEl of the mesh
123
124
    inline const int getNumberOfAllDOFs() const { 
      return nDOFEl; 
125
    }
126

Thomas Witkowski's avatar
Thomas Witkowski committed
127
    /// Returns \ref nNodeEl of the mesh
128
129
    inline const int getNumberOfNodes() const { 
      return nNodeEl; 
130
    }
131

Thomas Witkowski's avatar
Thomas Witkowski committed
132
    /// Returns \ref nVertices of the mesh
133
134
    inline const int getNumberOfVertices() const { 
      return nVertices; 
135
    }
136

Thomas Witkowski's avatar
Thomas Witkowski committed
137
    /// Returns \ref nEdges of the mesh 
138
139
    inline const int getNumberOfEdges() const { 
      return nEdges; 
140
    }
141

Thomas Witkowski's avatar
Thomas Witkowski committed
142
    /// Returns \ref nFaces of the mesh 
143
144
    inline const int getNumberOfFaces() const { 
      return nFaces; 
145
    }
146

Thomas Witkowski's avatar
Thomas Witkowski committed
147
    /// Returns \ref nLeaves of the mesh 
148
149
    inline const int getNumberOfLeaves() const { 
      return nLeaves; 
150
    }
151

Thomas Witkowski's avatar
Thomas Witkowski committed
152
    /// Returns \ref nElements of the mesh
153
154
    inline const int getNumberOfElements() const { 
      return nElements; 
155
    }
156

Thomas Witkowski's avatar
Thomas Witkowski committed
157
    /// Returns \ref maxEdgeNeigh of the mesh
158
159
    inline const int getMaxEdgeNeigh() const { 
      return maxEdgeNeigh; 
160
    }
161

Thomas Witkowski's avatar
Thomas Witkowski committed
162
    /// Returns \ref parametric of the mesh
163
164
    inline Parametric *getParametric() const { 
      return parametric; 
165
    }
166

Thomas Witkowski's avatar
Thomas Witkowski committed
167
    /// Returns \ref diam of the mesh
168
169
    inline const WorldVector<double>& getDiameter() const { 
      return diam; 
170
    }
171

Thomas Witkowski's avatar
Thomas Witkowski committed
172
    /// Returns nDOF[i] of the mesh
173
174
    inline const int getNumberOfDOFs(int i) const { 
      return nDOF[i]; 
175
    }
176

Thomas Witkowski's avatar
Thomas Witkowski committed
177
    /// Returns \ref elementPrototype of the mesh
178
179
    inline Element* getElementPrototype() { 
      return elementPrototype; 
180
    }
181

Thomas Witkowski's avatar
Thomas Witkowski committed
182
    /// Returns \ref leafDataPrototype of the mesh
183
184
    inline ElementData* getElementDataPrototype() { 
      return elementDataPrototype; 
185
    }
186

Thomas Witkowski's avatar
Thomas Witkowski committed
187
    /// Returns node[i] of the mesh 
188
189
    inline int getNode(int i) const { 
      return node[i]; 
190
    }
191
192
193
194
195
196
197
198
199

    /** \brief
     * Allocates the number of DOFs needed at position and registers the DOFs
     * at the DOFAdmins. The number of needed DOFs is the sum over the needed
     * DOFs of all DOFAdmin objects belonging to this mesh. 
     * The return value is a pointer to the first allocated DOF. 
     */
    DegreeOfFreedom *getDOF(GeoIndex position);

Thomas Witkowski's avatar
Thomas Witkowski committed
200
    /// Returns *(\ref admin[i]) of the mesh
201
202
    inline const DOFAdmin& getDOFAdmin(int i) const {
      return *(admin[i]);
203
    }
204
205
206
207
208
209

    /** \brief
     * Creates a DOFAdmin with name lname. nDOF specifies how many DOFs 
     * are needed at the different positions (see \ref DOFAdmin::nrDOF).
     * A pointer to the created DOFAdmin is returned.
     */
210
    const DOFAdmin* createDOFAdmin(const std::string& lname, DimVec<int> nDOF);
211
212
213
214
215

    /** \brief
     * Returns the size of \ref admin which is the number of the DOFAdmins
     * belonging to this mesh
     */
216
217
    const int getNumberOfDOFAdmin() const {
      return admin.size();
218
    }
219
220
221
222
223

    /** \brief
     * Returns the size of \ref macroElements which is the number of
     * of macro elements of this mesh
     */
224
225
    const int getNumberOfMacros() const {
      return macroElements.size();
226
    }
227

Thomas Witkowski's avatar
Thomas Witkowski committed
228
    /// Returns a DOFAdmin which at least manages vertex DOFs
229
230
    const DOFAdmin* getVertexAdmin() const;

Thomas Witkowski's avatar
Thomas Witkowski committed
231
    /// Allocates a array of DOF pointers. The array holds one pointer for each node.
232
    DegreeOfFreedom **createDOFPtrs();
233

Thomas Witkowski's avatar
Thomas Witkowski committed
234
    /// Returns \ref preserveCoarseDOFs of the mesh
235
236
    inline bool queryCoarseDOFs() const { 
      return preserveCoarseDOFs;
237
    }
238

Thomas Witkowski's avatar
Thomas Witkowski committed
239
    /// Returns an iterator to the begin of \ref macroElements
240
    inline std::deque<MacroElement*>::iterator firstMacroElement() {
241
      return macroElements.begin();
242
    }
243

Thomas Witkowski's avatar
Thomas Witkowski committed
244
    /// Returns macroElements[i].
245
246
    inline MacroElement *getMacroElement(int i) { 
      return macroElements[i]; 
247
    }
248

Thomas Witkowski's avatar
Thomas Witkowski committed
249
    /// Returns an iterator to the end of \ref macroElements
250
    inline std::deque<MacroElement*>::iterator endOfMacroElements() {
251
      return macroElements.end();
252
    }
253
254
255
256
257
258
259

    /** \} */

    /** \name setting methods
     * \{
     */

Thomas Witkowski's avatar
Thomas Witkowski committed
260
    /// Sets \ref name of the mesh
261
    inline void setName(const std::string& aName) { 
262
      name = aName;
263
    }
264

Thomas Witkowski's avatar
Thomas Witkowski committed
265
    /// Sets \ref nVertices of the mesh
266
267
    inline void setNumberOfVertices(int n) { 
      nVertices = n; 
268
    }
269

Thomas Witkowski's avatar
Thomas Witkowski committed
270
    /// Sets \ref nFaces of the mesh
271
272
    inline void setNumberOfFaces(int n) { 
      nFaces = n; 
273
    }
274

Thomas Witkowski's avatar
Thomas Witkowski committed
275
    /// Increments \ref nVertices by inc
276
277
    inline void incrementNumberOfVertices(int inc) { 
      nVertices += inc; 
278
    }
279
 
Thomas Witkowski's avatar
Thomas Witkowski committed
280
    /// Sets \ref nEdges of the mesh
281
282
    inline void setNumberOfEdges(int n) { 
      nEdges = n; 
283
    }
284

Thomas Witkowski's avatar
Thomas Witkowski committed
285
    /// Increments \ref nEdges by inc
286
287
    inline void incrementNumberOfEdges(int inc) { 
      nEdges += inc; 
288
    }
289

Thomas Witkowski's avatar
Thomas Witkowski committed
290
    /// Increments \ref nFaces by inc
291
292
    inline void incrementNumberOfFaces(int inc) { 
      nFaces += inc; 
293
    }
294

Thomas Witkowski's avatar
Thomas Witkowski committed
295
    /// Sets \ref nLeaves of the mesh
296
297
    inline void setNumberOfLeaves(int n) { 
      nLeaves = n; 
298
    }
299

Thomas Witkowski's avatar
Thomas Witkowski committed
300
    /// Increments \ref nLeaves by inc
301
302
    inline void incrementNumberOfLeaves(int inc) { 
      nLeaves += inc; 
303
    }
304

Thomas Witkowski's avatar
Thomas Witkowski committed
305
    /// Sets \ref nElements of the mesh
306
307
    inline void setNumberOfElements(int n) { 
      nElements = n; 
308
    }
309

Thomas Witkowski's avatar
Thomas Witkowski committed
310
    /// Increments \ref nElements by inc
311
312
    inline void incrementNumberOfElements(int inc) { 
      nElements += inc; 
313
    }
314

Thomas Witkowski's avatar
Thomas Witkowski committed
315
    /// Sets *\ref diam to w
316
317
    void setDiameter(const WorldVector<double>& w);

Thomas Witkowski's avatar
Thomas Witkowski committed
318
    /// Sets (*\ref diam)[i] to d
319
320
    void setDiameter(int i, double d);

Thomas Witkowski's avatar
Thomas Witkowski committed
321
    /// Sets \ref preserveCoarseDOFs = true
322
323
    inline void retainCoarseDOFs() {
      preserveCoarseDOFs = true;
324
    }
325

Thomas Witkowski's avatar
Thomas Witkowski committed
326
    /// Sets \ref preserveCoarseDOFs = b
327
328
    inline void setPreserveCoarseDOFs(bool b) {
      preserveCoarseDOFs = b;
329
    }
330

Thomas Witkowski's avatar
Thomas Witkowski committed
331
    /// Sets \ref preserveCoarseDOFs = false
332
333
    inline void noCoarseDOFs() {
      preserveCoarseDOFs = false;
334
    }
335

Thomas Witkowski's avatar
Thomas Witkowski committed
336
    /// Sets \ref elementPrototype of the mesh
337
338
    inline void setElementPrototype(Element* prototype) {
      elementPrototype = prototype;
339
340
    }
    
Thomas Witkowski's avatar
Thomas Witkowski committed
341
    /// Sets \ref elementDataPrototype of the mesh
342
343
    inline void setElementDataPrototype(ElementData* prototype) {
      elementDataPrototype = prototype;
344
    }
345

Thomas Witkowski's avatar
Thomas Witkowski committed
346
    ///
347
348
    inline void setParametric(Parametric *param) {
      parametric = param;
349
    }
350

Thomas Witkowski's avatar
Thomas Witkowski committed
351
    ///
352
353
    inline void setMaxEdgeNeigh(int m) { 
      maxEdgeNeigh = m; 
354
    }
355
356
357
  
    /** \} */

Thomas Witkowski's avatar
Thomas Witkowski committed
358
    /// Creates a new Element by cloning \ref elementPrototype
359
360
    Element* createNewElement(Element *parent = NULL);

Thomas Witkowski's avatar
Thomas Witkowski committed
361
    /// Creates a new ElInfo dependent of \ref dim of the mesh
362
363
    ElInfo* createNewElInfo();

Thomas Witkowski's avatar
Thomas Witkowski committed
364
    /// Frees DOFs at the given position pointed by dof 
365
366
    void freeDOF(DegreeOfFreedom* dof, GeoIndex position);

Thomas Witkowski's avatar
Thomas Witkowski committed
367
    /// Frees memory for the given element el
368
369
    void freeElement(Element* el);

Thomas Witkowski's avatar
Thomas Witkowski committed
370
    /// Performs DOF compression for all DOFAdmins (see \ref DOFAdmin::compress)
371
372
    void dofCompress();

Thomas Witkowski's avatar
Thomas Witkowski committed
373
    /// Adds a DOFAdmin to the mesh
374
    virtual void addDOFAdmin(DOFAdmin *admin);
375

376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
    /** \brief
     * Traverses the mesh. The argument level specifies the element level if 
     * CALL_EL_LEVEL or CALL_LEAF_EL_LEVEL, or the multigrid level if 
     * CALL_MG_LEVEL is set. Otherwise this variable is ignored. By the argument
     * fillFlag the elements to be traversed and data to be filled into ElInfo is
     * selected, using bitwise or of one CALL_... flag and several FILL_... 
     * flags. The argument elFct is a pointer to a function which is called on 
     * every element selected by the CALL_... part of fillFlag.
     * It is possible to use the recursive mesh traversal recursively, by calling
     * traverse() from elFct.
     */
    int traverse(int level, 
		 const Flag fillFlag,
		 int (*elFct)(ElInfo*));

391
392
393
    /// Recalculates the number of leave elements.
    void updateNumberOfLeaves();

Thomas Witkowski's avatar
Thomas Witkowski committed
394
    /// Clears \ref macroElements
395
396
    inline void clearMacroElements() { 
      macroElements.clear();
397
    }
398
  
Thomas Witkowski's avatar
Thomas Witkowski committed
399
    /// Adds a macro element to the mesh
400
401
    void addMacroElement(MacroElement* me);

402
    /* \brief
403
404
405
     * Removes a set of macro elements from the mesh. This works only for the case, 
     * that there are no global or local refinements, i.e., all macro elements have 
     * no children.
406
     */
407
    void removeMacroElements(std::vector<MacroElement*>& macros);
408

409
410
411
412
413
414
415
    /* \brief
     * Creates new numbers for all dofs such that the set of dof numbers is a
     * continuous interval of natural numbers starting with 0. The constatnt addC
     * may be added to the numbers.
     */
    void createContinuousDofOrdering(FiniteElemSpace *feSpace, unsigned int addC = 0);

Thomas Witkowski's avatar
Thomas Witkowski committed
416
    /// Frees the array of DOF pointers (see \ref createDOFPtrs)
417
418
    void freeDOFPtrs(DegreeOfFreedom **ptrs);

Thomas Witkowski's avatar
Thomas Witkowski committed
419
    /// Used by \ref findElementAtPoint. 
420
421
422
    bool findElInfoAtPoint(const WorldVector<double>& xy,
			   ElInfo *el_info,
			   DimVec<double>& bary,
423
			   const MacroElement *start_mel,
424
425
			   const WorldVector<double> *xy0,
			   double *sp);
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461

    /** \brief
     * Access to an element at world coordinates xy. Some applications need the 
     * access to elements at a special location in world coordinates. Examples 
     * are characteristic methods for convection problems, or the implementation
     * of a special right hand side like point evaluations or curve integrals.
     * For such purposes, a routine is available which returns an element pointer
     * and corresponding barycentric coordinates.
     *
     * \param xy world coordinates of point
     * \param elp return address for a pointer to the element at xy
     * \param pary returns barycentric coordinates of xy
     * \param start_mel initial guess for the macro element containing xy or NULL
     * \param xy0 start point from a characteristic method, see below, or NULL
     * \param sp return address for relative distance to domain boundary in a 
     *        characteristic method, see below, or NULL
     * \return true is xy is inside the domain , false otherwise
     * 
     * For a characteristic method, where \f$ xy = xy_0 - V\tau \f$, it may be 
     * convenient to know the point on the domain's boundary which lies on the 
     * line segment between the old point xy0 and the new point xy, in case that 
     * xy is outside the domain. Such information is returned when xy0 and a 
     * pointer sp!=NULL are supplied: *sp is set to the value s such that 
     * \f$ xy_0 +s (xy -xy_0) \in \partial Domain \f$, and the element and local 
     * coordinates corresponding to that boundary point will be returned via elp 
     * and bary.
     *
     * The implementation of findElementAtPoint() is based on the transformation 
     * from world to local coordinates, available via the routine worldToCoord(),
     * At the moment, findElementAtPoint() works correctly only for domains with 
     * non-curved boundary. This is due to the fact that the implementation first
     * looks for the macro-element containing xy and then finds its path through 
     * the corresponding element tree based on the macro barycentric coordinates.
     * For non-convex domains, it is possible that in some cases a point inside
     * the domain is considered as external.
     */
462
463
464
    bool findElementAtPoint(const WorldVector<double>& xy,
			    Element **elp, 
			    DimVec<double>& bary,
465
			    const MacroElement *start_mel,
466
467
			    const WorldVector<double> *xy0,
			    double *sp);
468
469


Thomas Witkowski's avatar
Thomas Witkowski committed
470
    /// Returns FILL_ANY_?D
471
    inline static const Flag& getFillAnyFlag(int dim) {
472
      switch (dim) {
473
474
475
476
477
478
479
480
481
482
483
484
485
      case 1:
	return FILL_ANY_1D;
	break;
      case 2:
	return FILL_ANY_2D;
	break;
      case 3:
	return FILL_ANY_3D;
	break;
      default:
	ERROR_EXIT("invalid dim\n");
	return FILL_ANY_1D;
      }
486
    }
487

Thomas Witkowski's avatar
Thomas Witkowski committed
488
    /// Serialize the mesh to a file.
489
    void serialize(std::ostream &out);
490

Thomas Witkowski's avatar
Thomas Witkowski committed
491
    /// Deserialize a mesh from a file.
492
    void deserialize(std::istream &in);
493

Thomas Witkowski's avatar
Thomas Witkowski committed
494
    /// Returns \ref elementIndex and increments it by 1.
495
496
    inline int getNextElementIndex() { 
      return elementIndex++; 
497
    }
498

Thomas Witkowski's avatar
Thomas Witkowski committed
499
    /// Returns \ref initialized.
500
501
502
    inline bool isInitialized() {
      return initialized; 
    }
503
  
Thomas Witkowski's avatar
Thomas Witkowski committed
504
    ///
505
    inline std::map<BoundaryType, VertexVector*>& getPeriodicAssociations() {
506
      return periodicAssociations;
507
    }
508

Thomas Witkowski's avatar
Thomas Witkowski committed
509
    ///
510
511
    bool associated(DegreeOfFreedom dof1, DegreeOfFreedom dof2);

Thomas Witkowski's avatar
Thomas Witkowski committed
512
    ///
513
514
    bool indirectlyAssociated(DegreeOfFreedom dof1, DegreeOfFreedom dof2);

Thomas Witkowski's avatar
Thomas Witkowski committed
515
    /// Returns \macroFileInfo
516
    inline MacroInfo* getMacroFileInfo() { 
517
      return macroFileInfo;
518
    }
519

Thomas Witkowski's avatar
Thomas Witkowski committed
520
    ///
521
522
    void clearMacroFileInfo();

Thomas Witkowski's avatar
Thomas Witkowski committed
523
    ///
524
525
    int calcMemoryUsage();

526
  public:
Thomas Witkowski's avatar
Thomas Witkowski committed
527
    ///
528
529
    static const Flag FILL_NOTHING;

Thomas Witkowski's avatar
Thomas Witkowski committed
530
    ///
531
    static const Flag FILL_COORDS; 
532

Thomas Witkowski's avatar
Thomas Witkowski committed
533
    ///
534
    static const Flag FILL_BOUND; 
535

Thomas Witkowski's avatar
Thomas Witkowski committed
536
    ///
537
    static const Flag FILL_NEIGH; 
538

Thomas Witkowski's avatar
Thomas Witkowski committed
539
    ///
540
    static const Flag FILL_OPP_COORDS; 
541

Thomas Witkowski's avatar
Thomas Witkowski committed
542
    ///
543
544
    static const Flag FILL_ORIENTATION; 

Thomas Witkowski's avatar
Thomas Witkowski committed
545
    ///
546
    static const Flag FILL_ADD_ALL; 
547
  
Thomas Witkowski's avatar
Thomas Witkowski committed
548
    ///
549
    static const Flag FILL_ANY_1D; 
550

Thomas Witkowski's avatar
Thomas Witkowski committed
551
    ///
552
    static const Flag FILL_ANY_2D; 
553

Thomas Witkowski's avatar
Thomas Witkowski committed
554
    ///
555
    static const Flag FILL_ANY_3D; 
556

Thomas Witkowski's avatar
Thomas Witkowski committed
557
    ///
558
    static const Flag FILL_DET;
559

Thomas Witkowski's avatar
Thomas Witkowski committed
560
    ///
561
562
563
564
565
566
    static const Flag FILL_GRD_LAMBDA;

    //**************************************************************************
    //  flags for Mesh traversal                                                
    //**************************************************************************

Thomas Witkowski's avatar
Thomas Witkowski committed
567
    ///
568
569
    static const Flag CALL_EVERY_EL_PREORDER;      

Thomas Witkowski's avatar
Thomas Witkowski committed
570
    ///
571
572
    static const Flag CALL_EVERY_EL_INORDER;     

Thomas Witkowski's avatar
Thomas Witkowski committed
573
    ///
574
575
    static const Flag CALL_EVERY_EL_POSTORDER;    

Thomas Witkowski's avatar
Thomas Witkowski committed
576
    ///
577
578
    static const Flag CALL_LEAF_EL;   

Thomas Witkowski's avatar
Thomas Witkowski committed
579
    ///
580
581
    static const Flag CALL_LEAF_EL_LEVEL;  

Thomas Witkowski's avatar
Thomas Witkowski committed
582
    ///
583
584
    static const Flag CALL_EL_LEVEL; 

Thomas Witkowski's avatar
Thomas Witkowski committed
585
    ///
586
587
588
    static const Flag CALL_MG_LEVEL;

  protected:
Thomas Witkowski's avatar
Thomas Witkowski committed
589
    ///
590
    bool findElementAtPointRecursive(ElInfo *elinfo,
591
				     const DimVec<double>& lambda,
592
				     int outside,
593
594
595
				     ElInfo *final_el_info);

  protected:
Thomas Witkowski's avatar
Thomas Witkowski committed
596
    /// maximal number of DOFs at one position
597
598
    static const int MAX_DOF;

Thomas Witkowski's avatar
Thomas Witkowski committed
599
    /// Name of this Mesh
600
    std::string name;
601

Thomas Witkowski's avatar
Thomas Witkowski committed
602
    /// Dimension of this Mesh. Doesn't have to be equal to dimension of world.
603
604
    int dim;

Thomas Witkowski's avatar
Thomas Witkowski committed
605
    /// Number of vertices in this Mesh
606
607
    int nVertices;

Thomas Witkowski's avatar
Thomas Witkowski committed
608
    /// Number of Edges in this Mesh
609
610
    int nEdges;

Thomas Witkowski's avatar
Thomas Witkowski committed
611
    /// Number of leaf elements in this Mesh
612
613
    int nLeaves;

Thomas Witkowski's avatar
Thomas Witkowski committed
614
    /// Total number of elements in this Mesh
615
616
    int nElements;

Thomas Witkowski's avatar
Thomas Witkowski committed
617
    /// Number of faces in this Mesh
618
619
620
621
622
623
624
625
626
    int nFaces;

    /** \brief
     * Maximal number of elements that share one edge; used to allocate memory 
     * to store pointers to the neighbour at the refinement/coarsening edge 
     * (only 3d);
     */
    int maxEdgeNeigh;

Thomas Witkowski's avatar
Thomas Witkowski committed
627
    /// Diameter of the mesh in the DIM_OF_WORLD directions
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
    WorldVector<double> diam;

    /** \brief
     * Is pointer to NULL if mesh contains no parametric elements else pointer 
     * to a Parametric object containing coefficients of the parameterization 
     * and related information
     */
    Parametric *parametric;

    /** \brief
     * If the value is non zero then preserve all DOFs on all levels (can
     * be used for multigrid, e.g.); otherwise all DOFs on the parent that are 
     * not handed over to a child are removed during refinement and added again 
     * on the parent during coarsening.
     */
    bool preserveCoarseDOFs;

Thomas Witkowski's avatar
Thomas Witkowski committed
645
    /// Number of all DOFs on a single element
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
    int nDOFEl;

    /** \brief
     * Number of DOFs at the different positions VERTEX, EDGE, (FACE,) CENTER on
     * an element:
     *
     * - nDOF[VERTEX]: number of DOFs at a vertex (>= 1)
     *
     * - nDOF[EDGE]: number of DOFs at an edge; if no DOFs are associated to
     *   edges, then this value is 0
     *
     * - nDOF[FACE]: number of DOFs at a face; if no DOFs are associated to
     *   faces, then this value is 0 (only 3d)
     *
     * - nDOF[CENTER]: number of DOFs at the barycenter; if no DOFs are 
     *   associated to the barycenter, then this value is 0
     */
    DimVec<int> nDOF;

    /** \brief
     * Number of nodes on a single element where DOFs are located; needed for 
     * the (de-) allocation of the dof-vector on the element (\ref Element::dof);
     */
    int nNodeEl;

    /** \brief
     * Gives the index of the first node at vertex, edge, face (only 3d), and 
     * barycenter:
     *
     * - node[VERTEX]: has always value 0; dof[0],...,dof[N_VERTICES-1] are 
     *   always DOFs at the vertices;
     *
     * - node[EDGE]: dof[node[EDGE]],..., dof[node[EDGE]+N_EDGES-1] are the DOFs
     *   at the N_EDGES edges, if DOFs are located at edges;
     *
     * - node[FACE]: dof[node[FACE]],..., dof[node[FACE]+N_FACES-1] are the DOFs
     *   at the N_FACES faces, if DOFs are located at faces (only 3d);
     *
     * - node[CENTER]: dof[node[CENTER]] are the DOFs at the barycenter, if DOFs
     *   are located at the barycenter;
     */
    DimVec<int> node;

Thomas Witkowski's avatar
Thomas Witkowski committed
689
    /// List of all DOFAdmins
690
    std::vector<DOFAdmin*> admin;
691

Thomas Witkowski's avatar
Thomas Witkowski committed
692
    /// List of all MacroElements of this Mesh
693
    std::deque<MacroElement*> macroElements;
694

Thomas Witkowski's avatar
Thomas Witkowski committed
695
    /// Needed during DOF compression (\ref DOFAdmin::compress).
696
    std::vector<DegreeOfFreedom> newDOF;
697

Thomas Witkowski's avatar
Thomas Witkowski committed
698
    /// Needed during DOF compression (\ref DOFAdmin::compress).
699
700
701
702
703
704
705
706
707
    static DOFAdmin *compressAdmin;

    /** \brief
     * Used for recursive mesh traversal. Static pointer to the mesh
     * that should be traversed. This allows access to the mesh even
     * from the static traverse routines
     */
    static Mesh* traversePtr;

Thomas Witkowski's avatar
Thomas Witkowski committed
708
    /// Used by compress- and check functions. Number of the current DOFAdmin
709
710
    static int iadmin;

Thomas Witkowski's avatar
Thomas Witkowski committed
711
    /// Used by check functions
712
    static std::vector<DegreeOfFreedom> dof_used;
713

Thomas Witkowski's avatar
Thomas Witkowski committed
714
    ///
715
    static std::map<DegreeOfFreedom, DegreeOfFreedom*> serializedDOFs;
716
717
718
719
720
721
722
723
724

    /** \brief
     * Used while mesh refinement. To create new elements 
     * elementPrototype->clone() is called, which returns a Element of the
     * same type as elementPrototype. So e.g. Elements of the different
     * dimensions can be created in a uniform way. 
     */
    Element* elementPrototype;

Thomas Witkowski's avatar
Thomas Witkowski committed
725
    /// Prototype for leaf data. Used for creation of new leaf data while refinement.
726
727
    ElementData* elementDataPrototype;

Thomas Witkowski's avatar
Thomas Witkowski committed
728
    /// Used for enumeration of all mesh elements
729
730
    int elementIndex;

Thomas Witkowski's avatar
Thomas Witkowski committed
731
    /// True if the mesh is already initialized, false otherwise.
732
733
    bool initialized;

Thomas Witkowski's avatar
Thomas Witkowski committed
734
    /// Map of managed periodic vertex associations.
735
    std::map<BoundaryType, VertexVector*> periodicAssociations;
736
737
738
739
740

    /** \brief
     * If the mesh has been created by reading a macro file, here 
     * the information are stored about the content of the file.
     */
741
    MacroInfo *macroFileInfo;
742
743

  protected:
Thomas Witkowski's avatar
Thomas Witkowski committed
744
    /// for findElement-Fcts
745
    DimVec<double> final_lambda;
746
747

    /** \brief
748
749
     * Temporary variables that are used in functions \ref fineElInfoatPoint and
     * \ref fineElementAtPointRecursive.
750
     */
751
    const WorldVector<double> *g_xy0, *g_xy;
752
753

    /** \brief
754
755
     * Temporary variable that is used in functions \ref fineElInfoatPoint and
     * \ref fineElementAtPointRecursive.
756
757
     */    
    double *g_sp;
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
   
    friend class MacroInfo;
    friend class MacroReader;
    friend class MacroWriter;
    friend class MacroElement;
    friend class Element;
    friend void Element::newDOFFct1(const DOFAdmin*);
    friend void Element::newDOFFct2(const DOFAdmin*);
  };

}

#endif  // AMDIS_MESH_H