Global.h 13.4 KB
Newer Older
1
2
3
4
// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
5
// ==  http://www.amdis-fem.org                                              ==
6
7
// ==                                                                        ==
// ============================================================================
8
9
10
11
12
13
14
15
16
17
18
19
//
// Software License for AMDiS
//
// Copyright (c) 2010 Dresden University of Technology 
// All rights reserved.
// Authors: Simon Vey, Thomas Witkowski et al.
//
// This file is part of AMDiS
//
// See also license.opensource.txt in the distribution.


20
21
22
23
24
25
26
27
28
29
30
31
32
33

/** \file Global.h */

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

/** \defgroup Common Common
 */

#ifndef AMDIS_GLOBAL_H
#define AMDIS_GLOBAL_H

#if (__GNUC__) && (__GNUC__ > 2) 
34
#define OPENMODE std::ios::openmode
35
#else
36
#define OPENMODE std::ios::open_mode
37
38
39
#endif

/** \brief current AMDiS version */
40
41
42
#ifndef AMDIS_VERSION
#define AMDIS_VERSION  "AMDiS: Version 0.9.1"
#endif
43
44
45

#include <string>
#include <vector>
46
#include <set>
47
48
49
50
51
52
#include <fstream>
#include <math.h>
#include <iostream>
#include <stdio.h>
#include <functional>
#include <float.h>
53
#include <time.h>
54

55
#if HAVE_PARALLEL_DOMAIN_AMDIS
56
#include <mpi.h>
57
58
#endif

59
#include <boost/algorithm/string.hpp>
60
#include "boost/tuple/tuple.hpp"
61
#include "AMDiS_fwd.h"
62

63
namespace AMDiS {
64

65
66
  using namespace std;

67
68
  extern const char *funcName;

69
  const int amdisRevisionNumber = 1700;
70

71
  /// Used by matrix vector multiplication
72
73
74
75
  typedef enum { NoTranspose,
		 Transpose,
		 ConjugateTranspose } MatrixTranspose;

76
  /// Speciefies the norm used by Estimator.
77
78
79
  typedef enum { NO_NORM = 0, 
		 H1_NORM = 1, 
		 L2_NORM = 2 } Norm;
80

81
  /// Datatype for degrees of freedom 
82
83
  typedef signed int DegreeOfFreedom;

84
  /// Defines type for a vector of DOF pointers.
85
  typedef vector<const DegreeOfFreedom*> DofContainer;
86

87
88
  typedef std::set<const DegreeOfFreedom*> DofContainerSet;

89
  /// Defines a type for global edge identification via its DOFs.
90
  typedef pair<DegreeOfFreedom, DegreeOfFreedom> DofEdge;
91
92
93

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

95

96
  /// Returns the GeoIndex of d for dimension dim.
97
98
#define INDEX_OF_DIM(d, dim) (static_cast<GeoIndex>((d == dim) ? CENTER : d + 1))

99
  /// Returns the dimension of GeoIndex ind for dimension dim
100
101
#define DIM_OF_INDEX(ind, dim) ((static_cast<int>(ind) == 0) ? dim : static_cast<int>(ind) - 1)

102
#if HAVE_PARALLEL_DOMAIN_AMDIS
103
#define PRINT_LINE(stream, line) stream << "[" << MPI::COMM_WORLD.Get_rank() << "] " << line
104
#else
105
#define PRINT_LINE(stream, line) stream << line
106
107
#endif

108
  /// Calculates factorial of i
109
110
  int fac(int i);

111
112
  void waitSec(int seconds);

113
  void processMemUsage(double& vm_usage, double& resident_set, bool inMegaByte = true);
114

115
  /// Content comparision of two pointers. Used e.g. for find_if
116
  template<typename T>
117
  struct comparePtrContents : public binary_function<T*, T*, bool>
118
  {
119
    /// Overrides binary_function::operator()
120
121
    bool operator()(T* a, T* b) const 
    {
122
      return (*a == *b);
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
  };

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

  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:
167
    /// Prints a formated message to the message stream
168
169
    static void print(const char *format, ...);

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

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

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

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

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

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

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

195
    /// Changes the message stream
196
    static void change_out(ostream*);
197

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

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

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

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

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

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

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

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

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

243
244
245
246
247
248
249
250
  public:
#if HAVE_PARALLEL_DOMAIN_AMDIS
    /// In parallel computations, when this variable is true, only the 0 rank will
    /// print messages to the output stream. Error messages and warnings are always
    /// printed from all ranks.
    static bool outputMainRank;
#endif

251
  protected:
252
    /// Message stram
253
    static ostream *out;
254

255
    /// Error stream
256
    static ostream *error;
257
258
259
260
261
262
263

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

264
    /// Global info level
265
266
    static int msgInfo;

267
    /// Spezifies whether to wait when WAIT is called
268
269
270
271
272
273
274
275
276
277
278
279
280
281
    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;

282
  /// prints an error message 
283
284
285
#define ERROR Msg::print_error_funcname(funcName,__FILE__, __LINE__),	\
    Msg::print_error

286
  /// prints an error message and exits 
287
288
289
#define ERROR_EXIT Msg::print_error_funcname(funcName,__FILE__, __LINE__), \
    Msg::print_error_exit

290
  /// prints a warning
291
292
293
#define WARNING Msg::print_warn_funcname(funcName,__FILE__, __LINE__),	\
    Msg::print_warn

294
  /// if test is false, an error message is printed
295
296
#define TEST(test) if ((test));else ERROR

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

300
  /// In debug mode, it corresponds to ERROR_EXIT, otherwise it is noop.
301
302
#if (DEBUG == 0) 
  #define TEST_EXIT_DBG(test) if (false) Msg::catch_error_exit
303
  #define DBG_VAR(var)
304
305
#else
#define TEST_EXIT_DBG(test) if ((test));else ERROR_EXIT
306
  #define DBG_VAR(var) var
307
#endif
308

309
  /// prints a message
310
311
#define MSG Msg::print_funcname(funcName), Msg::print

312
313
314
315
316
317
#if (DEBUG == 0) 
  #define MSG_DBG
#else
  #define MSG_DBG Msg::print_funcname(funcName), Msg::print
#endif

318
  /// prints a message, if min(Msg::msgInfo, info) >= noinfo
319
#define INFO(info,noinfo)						\
320
  if (Msg::getMsgInfo() && (std::min(Msg::getMsgInfo(), (info)) >= (noinfo))) MSG
321

322
  /// prints a message, if min(Msg::msgInfo, info) >= noinfo
323
#define PRINT_INFO(info,noinfo)						\
324
  if (Msg::getMsgInfo() && (std::min(Msg::getMsgInfo(), (info)) >= (noinfo))) Msg::print
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
377
378
379
380
381
382
383
384
385
386
387
388
389


  /** \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.
     */
390
391
    static const Element *getReferenceElement(int dim) 
    {
392
      FUNCNAME("Global::getReferenceElement()");
393
      TEST_EXIT(dim > 0 && dim < 4)("invalid dim: %d\n", dim);
394
      return referenceElement[dim];
395
    }
396

397
    /// returns geometrical information. Currently this is only dimOfWorld.
398
399
    static inline int getGeo(GeoIndex p) 
    {
400
401
402
      if (WORLD == p) 
	return dimOfWorld; 

403
      ERROR_EXIT("Illegal request for geometry data: part = %d!\n", p);
404
      return 0;
405
    }
406
407

    /** \brief
408
     * Returns geometrical information about elements of the dimension dim.
409
410
     * getGeo(VERTEX, 3) returns 4 because a Tetrahedron has 4 vertices.
     */
411
412
    static inline int getGeo(GeoIndex p, int dim) 
    {
413
      TEST_EXIT_DBG(p >= MINPART && p <= MAXPART)
414
	("Calling for invalid geometry value %d\n",p);
415
      TEST_EXIT_DBG(dim >= 0 && dim < 4)
416
417
418
419
420
421
	("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];
    }
422

423
    /// Inits the Global class with the help of Parameters.
424
425
    static void init();

426
427
    static void clear();

Thomas Witkowski's avatar
Thomas Witkowski committed
428
  private:
429
    /** \brief
Thomas Witkowski's avatar
Thomas Witkowski committed
430
431
     * Global is a pure static class. So the constructor is private to avoid
     * instantiation.
432
     */
Thomas Witkowski's avatar
Thomas Witkowski committed
433
    Global();
434
435

  private:
436
    /// Dimension of the simulated world
437
438
439
440
441
442
443
444
445
446
    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];
447

448
    /// Stores the precalculated results that should be returned by Global::getGeo.
449
    static vector<vector<int> > geoIndexTable;
450
451
452
453
454
455
  };

#define COMMA ,

  const int RescheduleErrorCode = 23;

456
457
458
459
460
461
462
463
464
  /**
   * \ingroup Assembler
   * \brief
   * Specifies the type of a FirstOrderTerm 
   */
  enum FirstOrderType {
    GRD_PSI,
    GRD_PHI
  };
465

466
467
468
469
}

#endif // AMDIS_GLOBAL_H