Global.h 13.6 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
// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
// ==  crystal growth group                                                  ==
// ==                                                                        ==
// ==  Stiftung caesar                                                       ==
// ==  Ludwig-Erhard-Allee 2                                                 ==
// ==  53175 Bonn                                                            ==
// ==  germany                                                               ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
// ==  http://www.caesar.de/cg/AMDiS                                         ==
// ==                                                                        ==
// ============================================================================

/** \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
49
#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>

50
#include "AMDiS_fwd.h"
51

52
namespace AMDiS {
53
54
55
56
57
58
59

  extern const char *funcName;

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

60
  /// used by matrix vector multiplication
61
62
63
64
  typedef enum { NoTranspose,
		 Transpose,
		 ConjugateTranspose } MatrixTranspose;

65
  /// speciefies the norm used by Estimator.
66
67
68
  typedef enum { NO_NORM = 0, 
		 H1_NORM = 1, 
		 L2_NORM = 2 } Norm;
69

70
  /// datatype for degrees of freedom 
71
72
  typedef signed int DegreeOfFreedom;

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

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

79
  /// Calculates factorial of i
80
81
  int fac(int i);

82
  /// Content comparision of two pointers. Used e.g. for std::find_if
83
  template<typename T>
84
  struct comparePtrContents : public std::binary_function<T*, T*, bool>
85
  {
86
    /// Overrides binary_function::operator()
87
88
    bool operator()(T* a, T* b) const {
      return (*a == *b);
89
    }
90
91
92
93
  };

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

94
  ///  template<typename T> T max(T a,T b ) {return  ((a) > (b) ? (a) : (b));}
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
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
  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:
144
    /// Prints a formated message to the message stream
145
146
    static void print(const char *format, ...);

147
    /// Prints a formated message to the error stream
148
149
    static void print_error(const char *format, ...);

150
    /// Prints a formated message to the error stream and exits 
151
152
    static void print_error_exit(const char *format, ...);

153
154
    ///
    static void catch_error_exit(const char *format, ...) {}
155

156
    /// Prints an error message with funcname, file, and line to the error stream
157
158
159
160
    static void print_error_funcname(const char *funcname,
				     const char *file, 
				     int line);

161
    /// Prints a warning to the message stream
162
163
    static void print_warn(const char *format, ...);

164
    /// Prints a warning with funcname, file, and line to the message stream
165
166
167
168
    static void print_warn_funcname(const char *funcname,
				    const char *file, 
				    int line);

169
    /// Prints the funcname to the message stream
170
171
    static void print_funcname(const char *funcname);

172
    /// Changes the message stream
173
    static void change_out(std::ostream*);
174

175
    /// Creates a filestream and sets the message stream to this filestream
176
177
    static void open_file(const char *filename, OPENMODE);

178
    /// Changes the error stream 
179
    static void change_error_out(std::ofstream *fp);
180

181
    /// Creates a filestream and sets the error stream to this filestream
182
183
    static void open_error_file(const char *filename, OPENMODE);

184
    /// Generates a filename from path, file and ntime
185
186
    static const char *generate_filename(const char *path, 
					 const char *file, 
187
					 int ntime);
188

189
190
    /// Sets \ref msgInfo
    static void setMsgInfo(int info) { msgInfo = info; }
191

192
193
    /// Returns \ref msgInfo
    static int  getMsgInfo() { return msgInfo; }
194

195
196
    /// Sets \ref msgWait
    static void setMsgWait(bool wait) { msgWait = wait; }
197

198
199
    /// Returns \ref msgWait
    static bool getMsgWait() { return msgWait; }
200

201
    /// Waits for enter if w is true
202
203
    static void wait(bool w);

204
205
    /// Returns \ref out
    static std::ostream *getOutStream() { return out; }
206

207
208
    /// Returns \ref error
    static std::ostream *getErrorStream() { return error; }
209
210

  protected:
211
    /// Message stram
212
    static std::ostream *out;
213

214
    /// Error stream
215
    static std::ostream *error;
216
217
218
219
220
221
222

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

223
    /// Global info level
224
225
    static int msgInfo;

226
    /// Spezifies whether to wait when WAIT is called
227
228
229
230
231
232
233
234
235
236
237
238
239
240
    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;

241
  /// prints an error message 
242
243
244
#define ERROR Msg::print_error_funcname(funcName,__FILE__, __LINE__),	\
    Msg::print_error

245
  /// prints an error message and exits 
246
247
248
#define ERROR_EXIT Msg::print_error_funcname(funcName,__FILE__, __LINE__), \
    Msg::print_error_exit

249
  /// prints a warning
250
251
252
#define WARNING Msg::print_warn_funcname(funcName,__FILE__, __LINE__),	\
    Msg::print_warn

253
  /// if test is false, an error message is printed
254
255
#define TEST(test) if ((test));else ERROR

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

259
  /// In debug mode, it corresponds to ERROR_EXIT, otherwise it is noop.
260
261
#if (DEBUG == 0) 
  #define TEST_EXIT_DBG(test) if (false) Msg::catch_error_exit
262
  #define DBG_VAR(var)
263
264
#else
#define TEST_EXIT_DBG(test) if ((test));else ERROR_EXIT
265
  #define DBG_VAR(var) var
266
#endif
267

268
  /// prints a message
269
270
#define MSG Msg::print_funcname(funcName), Msg::print

271
  /// prints a message, if min(Msg::msgInfo, info) >= noinfo
272
#define INFO(info,noinfo)						\
273
  if (Msg::getMsgInfo()&&(std::min(Msg::getMsgInfo(),(info))>=(noinfo))) MSG
274

275
  /// prints a message, if min(Msg::msgInfo, info) >= noinfo
276
#define PRINT_INFO(info,noinfo)						\
277
  if (Msg::getMsgInfo()&&(std::min(Msg::getMsgInfo(),(info))>=(noinfo))) Msg::print
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
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


  /** \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)

#include <time.h>
#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.
     */
    static const Element *getReferenceElement(int dim) {
345
      FUNCNAME("Global::getReferenceElement()");
346
      TEST_EXIT((dim > 0) && (dim < 4))("invalid dim: %d\n", dim);
347
      return referenceElement[dim];
348
    }
349

350
    /// returns geometrical information. Currently this is only dimOfWorld.
351
    static inline int getGeo(GeoIndex p) {
352
353
354
355
      if (WORLD == p) 
	return dimOfWorld; 

      ERROR_EXIT("Illegal request for geometry data: part=%d!\n", p);
356
      return 0;
357
    }
358
359
360
361
362

    /** \brief
     * returns geometrical information about elements of the dimension dim.
     * getGeo(VERTEX, 3) returns 4 because a Tetrahedron has 4 vertices.
     */
363
364
365
366
367
368
369
370
371
372
    static inline int getGeo(GeoIndex p, int dim) {
      TEST_EXIT_DBG((p >= MINPART) && (p <= MAXPART))
	("Calling for invalid geometry value %d\n",p);
      TEST_EXIT_DBG((dim >= 0) && (dim < 4))
	("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];
    }
373

374
    /// Inits the Global class with the help of Parameters.
375
376
    static void init();

377
378
    static void clear();

Thomas Witkowski's avatar
Thomas Witkowski committed
379
  private:
380
    /** \brief
Thomas Witkowski's avatar
Thomas Witkowski committed
381
382
     * Global is a pure static class. So the constructor is private to avoid
     * instantiation.
383
     */
Thomas Witkowski's avatar
Thomas Witkowski committed
384
    Global();
385
386

  private:
387
    /// Dimension of the simulated world
388
389
390
391
392
393
394
395
396
397
    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];
398

399
    /// Stores the precalculated results that should be returned by Global::getGeo.
400
    static std::vector< std::vector< int > > geoIndexTable;
401
402
403
404
405
406
  };

#define COMMA ,

  const int RescheduleErrorCode = 23;

407
  std::string memSizeStr(int size);
408
409
410
411
412
413
414
415
416
417

  /**
   * \ingroup Assembler
   * \brief
   * Specifies the type of a FirstOrderTerm 
   */
  enum FirstOrderType {
    GRD_PSI,
    GRD_PHI
  };
Thomas Witkowski's avatar
Thomas Witkowski committed
418
419

#define MEMORY_MANAGED(className) ;
Thomas Witkowski's avatar
bugfix    
Thomas Witkowski committed
420
421
#define NEW new
#define DELETE delete
Thomas Witkowski's avatar
Thomas Witkowski committed
422
423
424
#define GET_MEMORY(typename, number) new typename[number]
#define FREE_MEMORY(ptr, typename, number) delete [] ptr

425
426
427
428
}

#endif // AMDIS_GLOBAL_H