Global.h 13.9 KB
Newer Older
1
2
3
4
5
6
// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
7
// ==  TU Dresden                                                            ==
8
// ==                                                                        ==
9
10
11
// ==  Institut fr Wissenschaftliches Rechnen                               ==
// ==  Zellescher Weg 12-14                                                  ==
// ==  01069 Dresden                                                         ==
12
13
14
15
// ==  germany                                                               ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
16
// ==  https://gforge.zih.tu-dresden.de/projects/amdis/                      ==
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// ==                                                                        ==
// ============================================================================

/** \file Global.h */

/** \mainpage AMDiS
 * @{ <img src="vis.png"> @}
 */

/** \defgroup Common Common
 */

#ifndef AMDIS_GLOBAL_H
#define AMDIS_GLOBAL_H

#if (__GNUC__) && (__GNUC__ > 2) 
33
#define OPENMODE std::ios::openmode
34
#else
35
#define OPENMODE std::ios::open_mode
36
37
38
39
40
41
42
43
44
45
46
47
48
#endif

/** \brief current AMDiS version */
#define AMDIS_VERSION  "AMDiS: Version 0.100"

#include <string>
#include <vector>
#include <fstream>
#include <math.h>
#include <iostream>
#include <stdio.h>
#include <functional>
#include <float.h>
49
#include <time.h>
50

51
52
53
54
#if HAVE_PARALLEL_DOMAIN_AMDIS
#include "mpi.h"
#endif

55
#include "boost/tuple/tuple.hpp"
56
#include "AMDiS_fwd.h"
57

58
namespace AMDiS {
59
60
61
62
63
64
65

  extern const char *funcName;

  // ============================================================================
  // ===== definitions ==========================================================
  // ============================================================================

66
  /// used by matrix vector multiplication
67
68
69
70
  typedef enum { NoTranspose,
		 Transpose,
		 ConjugateTranspose } MatrixTranspose;

71
  /// speciefies the norm used by Estimator.
72
73
74
  typedef enum { NO_NORM = 0, 
		 H1_NORM = 1, 
		 L2_NORM = 2 } Norm;
75

76
  /// datatype for degrees of freedom 
77
78
  typedef signed int DegreeOfFreedom;

79
80
81
  /// Defines type for a vector of DOF pointers.
  typedef std::vector<const DegreeOfFreedom*> DofContainer;

82
83
84
85
86
  /// Defines a type for global edge identification via its DOFs.
  typedef std::pair<DegreeOfFreedom, DegreeOfFreedom> DofEdge;

  /// Defines a tzpe for global face identiication via its DOFs.
  typedef boost::tuple<DegreeOfFreedom, DegreeOfFreedom, DegreeOfFreedom> DofFace;
87

88
  /// returns the GeoIndex of d for dimension dim.
89
90
#define INDEX_OF_DIM(d, dim) (static_cast<GeoIndex>((d == dim) ? CENTER : d + 1))

91
  /// returns the dimension of GeoIndex ind for dimension dim
92
93
#define DIM_OF_INDEX(ind, dim) ((static_cast<int>(ind) == 0) ? dim : static_cast<int>(ind) - 1)

94
#if HAVE_PARALLEL_DOMAIN_AMDIS
95
#define PRINT_LINE(stream, line) stream << "[" << MPI::COMM_WORLD.Get_rank() << "] " << line
96
#else
97
#define PRINT_LINE(stream, line) stream << line
98
99
#endif

100
  /// Calculates factorial of i
101
102
  int fac(int i);

103
104
  void waitSec(int seconds);

105
  /// Content comparision of two pointers. Used e.g. for std::find_if
106
  template<typename T>
107
  struct comparePtrContents : public std::binary_function<T*, T*, bool>
108
  {
109
    /// Overrides binary_function::operator()
110
111
    bool operator()(T* a, T* b) const 
    {
112
      return (*a == *b);
113
    }
114
115
116
117
  };

  // ===== some simple template functions ====================================== 

118
  ///  template<typename T> T max(T a,T b ) {return  ((a) > (b) ? (a) : (b));}
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
  template<typename T,typename S> inline T max(T a,S b )
  {
    return  ((a) > (b) ? (a) : (b));
  }

  template<typename T> inline T min(T a,T b) 
  {
    return  ((a) < (b)) ? (a) : (b);
  }

  template<typename T> inline T abs(T a) 
  {
    return  ((a) >= 0 ? (a) : -(a));
  }

  template<typename T> inline T sqr(T a) 
  {
    return  ((a)*(a));
  }

  // ===== some predefined values ===============================================
  const double m_e = 		2.7182818284590452354;
  const double m_log2e = 		1.4426950408889634074;
  const double m_log10e = 	0.43429448190325182765;
  const double m_ln2 = 		0.69314718055994530942;
  const double m_ln10 = 		2.30258509299404568402;
  const double m_pi = 		3.14159265358979323846;
  const double m_pi_2 = 		1.57079632679489661923;
  const double m_pi_4 = 		0.78539816339744830962;
  const double m_1_pi = 		0.31830988618379067154;
  const double m_2_pi = 		0.63661977236758134308;
  const double m_2_sqrtpi = 	1.12837916709551257390;
  const double m_sqrt2 = 		1.41421356237309504880;
  const double m_sqrt1_2 = 	0.70710678118654752440;

  // ===== tolerance for floating point comparison ==============================
#define DBL_TOL DBL_EPSILON
#define FLT_TOL FLT_EPSILON


  /** \brief
   * Manages the output of messages, warnings, errors, ...
   * Used by the macros FUNCNAME, ERROR, ERROR_EXIT, WARNING, TEST, MSG, INFO,
   * PRINT_INFO, WAIT, WAIT_REALLY.
   * Don't use this class directly but only via these macros!
   */
  class Msg
  {
  public:
168
    /// Prints a formated message to the message stream
169
170
    static void print(const char *format, ...);

171
    /// Prints a formated message to the error stream
172
173
    static void print_error(const char *format, ...);

174
    /// Prints a formated message to the error stream and exits 
175
176
    static void print_error_exit(const char *format, ...);

177
178
    ///
    static void catch_error_exit(const char *format, ...) {}
179

180
    /// Prints an error message with funcname, file, and line to the error stream
181
182
183
184
    static void print_error_funcname(const char *funcname,
				     const char *file, 
				     int line);

185
    /// Prints a warning to the message stream
186
187
    static void print_warn(const char *format, ...);

188
    /// Prints a warning with funcname, file, and line to the message stream
189
190
191
192
    static void print_warn_funcname(const char *funcname,
				    const char *file, 
				    int line);

193
    /// Prints the funcname to the message stream
194
195
    static void print_funcname(const char *funcname);

196
    /// Changes the message stream
197
    static void change_out(std::ostream*);
198

199
    /// Changes the error stream 
200
    static void change_error_out(std::ofstream *fp);
201

202
    /// Creates a filestream and sets the error stream to this filestream
203
204
    static void open_error_file(const char *filename, OPENMODE);

205
    /// Sets \ref msgInfo
206
207
208
209
    static void setMsgInfo(int info) 
    { 
      msgInfo = info; 
    }
210

211
    /// Returns \ref msgInfo
212
213
214
215
    static int  getMsgInfo() 
    { 
      return msgInfo; 
    }
216

217
    /// Sets \ref msgWait
218
219
220
221
    static void setMsgWait(bool wait) 
    { 
      msgWait = wait; 
    }
222

223
    /// Returns \ref msgWait
224
225
226
227
    static bool getMsgWait() 
    { 
      return msgWait; 
    }
228

229
    /// Waits for enter if w is true
230
231
    static void wait(bool w);

232
    /// Returns \ref out
233
234
235
236
    static std::ostream *getOutStream() 
    { 
      return out; 
    }
237

238
    /// Returns \ref error
239
240
241
242
    static std::ostream *getErrorStream() 
    { 
      return error; 
    }
243
244

  protected:
245
    /// Message stram
246
    static std::ostream *out;
247

248
    /// Error stream
249
    static std::ostream *error;
250
251
252
253
254
255
256

    /** \brief
     * Remember funcName to avoid multiple output of funcName within the same
     * function call
     */
    static const char *oldFuncName;

257
    /// Global info level
258
259
    static int msgInfo;

260
    /// Spezifies whether to wait when WAIT is called
261
262
263
264
265
266
267
268
269
270
271
272
273
274
    static bool msgWait;
  };

  // ============================================================================
  // ===== message macros =======================================================
  // ============================================================================

  /** \brief 
   * Should be the first call in every functions. It defines the current function
   * name nn for message output via MSG, WARNING, ...
   */

#define FUNCNAME(nn) const char *funcName; funcName = nn;

275
  /// prints an error message 
276
277
278
#define ERROR Msg::print_error_funcname(funcName,__FILE__, __LINE__),	\
    Msg::print_error

279
  /// prints an error message and exits 
280
281
282
#define ERROR_EXIT Msg::print_error_funcname(funcName,__FILE__, __LINE__), \
    Msg::print_error_exit

283
  /// prints a warning
284
285
286
#define WARNING Msg::print_warn_funcname(funcName,__FILE__, __LINE__),	\
    Msg::print_warn

287
  /// if test is false, an error message is printed
288
289
#define TEST(test) if ((test));else ERROR

290
  /// if test is false, an error message is printed and the program exits
Thomas Witkowski's avatar
Thomas Witkowski committed
291
#define TEST_EXIT(test) if ((test));else ERROR_EXIT
292

293
  /// In debug mode, it corresponds to ERROR_EXIT, otherwise it is noop.
294
295
#if (DEBUG == 0) 
  #define TEST_EXIT_DBG(test) if (false) Msg::catch_error_exit
296
  #define DBG_VAR(var)
297
298
#else
#define TEST_EXIT_DBG(test) if ((test));else ERROR_EXIT
299
  #define DBG_VAR(var) var
300
#endif
301

302
  /// prints a message
303
304
#define MSG Msg::print_funcname(funcName), Msg::print

305
  /// prints a message, if min(Msg::msgInfo, info) >= noinfo
306
#define INFO(info,noinfo)						\
307
  if (Msg::getMsgInfo()&&(std::min(Msg::getMsgInfo(),(info))>=(noinfo))) MSG
308

309
  /// prints a message, if min(Msg::msgInfo, info) >= noinfo
310
#define PRINT_INFO(info,noinfo)						\
311
  if (Msg::getMsgInfo()&&(std::min(Msg::getMsgInfo(),(info))>=(noinfo))) Msg::print
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376


  /** \brief 
   * If the value of Msg::wait is not zero the macro will produce the message 
   * 'wait for <enter> ...' and will continue after pressing the return or enter
   * key. Otherwise the program continues without a message.
   */
#define WAIT Msg::wait(Msg::getMsgWait())

  /** \brief
   * produces the message 'wait for <enter> ...' and will continue after pressing
   * the return or enter key.
   */
#define WAIT_REALLY Msg::wait(true)

#define TIME_USED(f,s) ((double)((s)-(f))/(double)CLOCKS_PER_SEC)

  /** \brief
   * internal used indices to represent the different geometrical objects.
   * Used as parameter for getGeo() and as template parameter for FixVec. 
   */
  typedef enum
    {
      CENTER   = 0, /**< in 1d the center is at the edge, in 2d at the face, in 3d 
		     * at the interior of an element. So a Line has no edge but
		     * only a center, a Triangle has no face but only a center.
		     */
      VERTEX   = 1, /**< index for element vertices.
		     * number of vertices is equal to number of parts and 
		     * neighbours.
		     */
      EDGE     = 2, /**< index for element edges */
      FACE     = 3, /**< index for element faces */
      DIMEN    =-1, /**< index for problem dimension */
      PARTS    =-2, /**< index for parts of an element (vertices in 1d, edges in 2d
		     * , faces in 3d). Number of element parts is equal to number
		     * of vertices and neighbours. 
		     */
      NEIGH    =-3, /**< index for neighbours of an element.
		     * Number of element neighbours is equal to number of 
		     * vertices and parts.
		     */
      WORLD    =-4, /**< index for world dimension */
      BOUNDARY =-5, /**< index for boundary nodes of an element. This could be
		     * vertices, edges or faces.
		     */
      PROJECTION=-6 /**< index for element and boundary projections */
    } GeoIndex;

#define MAXPART FACE
#define MINPART PROJECTION


  /** \ingroup Common
   * \brief
   * Static class wich holds global information about the world and all types of
   * elements.
   */
  class Global
  {
  public:
    /** \brief
     * returns a pointer to \ref referenceElement [dim]. With this pointer you
     * can get information about the element via Element's getGeo method.
     */
377
378
    static const Element *getReferenceElement(int dim) 
    {
379
      FUNCNAME("Global::getReferenceElement()");
380
      TEST_EXIT(dim > 0 && dim < 4)("invalid dim: %d\n", dim);
381
      return referenceElement[dim];
382
    }
383

384
    /// returns geometrical information. Currently this is only dimOfWorld.
385
386
    static inline int getGeo(GeoIndex p) 
    {
387
388
389
      if (WORLD == p) 
	return dimOfWorld; 

390
      ERROR_EXIT("Illegal request for geometry data: part = %d!\n", p);
391
      return 0;
392
    }
393
394

    /** \brief
395
     * Returns geometrical information about elements of the dimension dim.
396
397
     * getGeo(VERTEX, 3) returns 4 because a Tetrahedron has 4 vertices.
     */
398
399
    static inline int getGeo(GeoIndex p, int dim) 
    {
400
      TEST_EXIT_DBG(p >= MINPART && p <= MAXPART)
401
	("Calling for invalid geometry value %d\n",p);
402
      TEST_EXIT_DBG(dim >= 0 && dim < 4)
403
404
405
406
407
408
	("invalid dim: %d\n", dim);
      TEST_EXIT_DBG((dim != 0) || (p == PARTS || p == VERTEX || p == EDGE || p == FACE))
	("dim = 0\n");

      return geoIndexTable[dim][p - MINPART];
    }
409

410
    /// Inits the Global class with the help of Parameters.
411
412
    static void init();

413
414
    static void clear();

Thomas Witkowski's avatar
Thomas Witkowski committed
415
  private:
416
    /** \brief
Thomas Witkowski's avatar
Thomas Witkowski committed
417
418
     * Global is a pure static class. So the constructor is private to avoid
     * instantiation.
419
     */
Thomas Witkowski's avatar
Thomas Witkowski committed
420
    Global();
421
422

  private:
423
    /// Dimension of the simulated world
424
425
426
427
428
429
430
431
432
433
    static int dimOfWorld;

    /** \brief
     * contains a pointer to a Line, a Triangle, and a Tetrahedron.
     * This allows the access to information of the concrete elements via
     * the dimension index.
     * referenceElement[3]->getGeo(VERTEX) gives the number of vertices of a
     * Tetrahedron wich is 4 => no switch statement is necessary.
     */
    static Element *referenceElement[4];
434

435
    /// Stores the precalculated results that should be returned by Global::getGeo.
436
    static std::vector< std::vector< int > > geoIndexTable;
437
438
439
440
441
442
  };

#define COMMA ,

  const int RescheduleErrorCode = 23;

443
  std::string memSizeStr(int size);
444
445
446
447
448
449
450
451
452
453

  /**
   * \ingroup Assembler
   * \brief
   * Specifies the type of a FirstOrderTerm 
   */
  enum FirstOrderType {
    GRD_PSI,
    GRD_PHI
  };
454
455
456
457
}

#endif // AMDIS_GLOBAL_H