Global.h 14.2 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/******************************************************************************
 *
 * AMDiS - Adaptive multidimensional simulations
 *
 * Copyright (C) 2013 Dresden University of Technology. All Rights Reserved.
 * Web: https://fusionforge.zih.tu-dresden.de/projects/amdis
 *
 * Authors: 
 * Simon Vey, Thomas Witkowski, Andreas Naumann, Simon Praetorius, et al.
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *
 * 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
34

/** \file Global.h */

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

/** \defgroup Common Common
 */

#ifndef AMDIS_GLOBAL_H
#define AMDIS_GLOBAL_H

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

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

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

56
57
58
59
60
61
#ifdef _WIN32
#include <io.h>
#else
#include <unistd.h>
#endif

62
#if HAVE_PARALLEL_DOMAIN_AMDIS
63
#include <mpi.h>
64
65
#endif

66
#include <boost/algorithm/string.hpp>
Praetorius, Simon's avatar
Praetorius, Simon committed
67
#include <boost/algorithm/string/trim.hpp>
68
#include "boost/tuple/tuple.hpp"
69
#include "AMDiS_fwd.h"
Thomas Witkowski's avatar
Blub  
Thomas Witkowski committed
70
#include "OpenMP.h"
71

72
namespace AMDiS {
73

74
75
  using namespace std;

76
77
  extern const char *funcName;

78
  const int amdisRevisionNumber = 1700;
79

80
  /// Used by matrix vector multiplication
81
82
83
84
  typedef enum { NoTranspose,
		 Transpose,
		 ConjugateTranspose } MatrixTranspose;

85
  /// Speciefies the norm used by Estimator.
86
87
88
  typedef enum { NO_NORM = 0, 
		 H1_NORM = 1, 
		 L2_NORM = 2 } Norm;
89

90
  /// Datatype for degrees of freedom 
91
92
  typedef signed int DegreeOfFreedom;

93
  /// Defines type for a vector of DOF pointers.
94
  typedef vector<const DegreeOfFreedom*> DofContainer;
95

96
97
  typedef std::set<const DegreeOfFreedom*> DofContainerSet;

98
  /// Defines a type for global edge identification via its DOFs.
99
  typedef pair<DegreeOfFreedom, DegreeOfFreedom> DofEdge;
100
101
102

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

104

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

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

Thomas Witkowski's avatar
Blub  
Thomas Witkowski committed
111
112
113
114

#if SUPPRESS_OUTPUT
#define PRINT_LINE(stream, line)
#else
115
#if HAVE_PARALLEL_DOMAIN_AMDIS
116
#define PRINT_LINE(stream, line) stream << "[" << MPI::COMM_WORLD.Get_rank() << "] " << line
117
#else
118
#define PRINT_LINE(stream, line) stream << line
Thomas Witkowski's avatar
Blub  
Thomas Witkowski committed
119
#endif
120
121
#endif

122
  /// Calculates factorial of i
123
124
  int fac(int i);

125
126
  void waitSec(int seconds);

127
  void processMemUsage(double& vm_usage, double& resident_set, bool inMegaByte = true);
128

129
  /// Content comparision of two pointers. Used e.g. for find_if
130
  template<typename T>
131
  struct comparePtrContents : public binary_function<T*, T*, bool>
132
  {
133
    /// Overrides binary_function::operator()
134
135
    bool operator()(T* a, T* b) const 
    {
136
      return (*a == *b);
137
    }
138
139
  };

140
  
Praetorius, Simon's avatar
Praetorius, Simon committed
141
142
143
  /// check for file existence
  inline bool file_exists(const std::string filename)
  {
144
145
146
#ifdef _WIN32
    return _access(filename.c_str(), 0) == 0;
#else
Praetorius, Simon's avatar
Praetorius, Simon committed
147
    return access(filename.c_str(), F_OK) == 0;
148
#endif
149
  }
Praetorius, Simon's avatar
Praetorius, Simon committed
150

151
  
Praetorius, Simon's avatar
Praetorius, Simon committed
152
153
154
155
156
157
  /// trim std::string
  inline std::string trim(const std::string& oldStr)
  {
    std::string swap(oldStr);
    boost::algorithm::trim(swap);
    return swap;
158
  }
Praetorius, Simon's avatar
Praetorius, Simon committed
159

160
161
162
163
164
165
166
167
168
169
170
171
  // ===== 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));
  }

172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
  template<typename T> inline void nullify(T &a)
  {
    a = 0.0;
  }

  template<typename T> inline void nullify(std::vector<T> &a)
  {
    typename std::vector<T>::iterator it;
    for (it = a.begin(); it != a.end(); it++)
      nullify(*it);
  }

  template<typename T> inline void nullify(mtl::dense_vector<T> &a)
  {
    T null;
    nullify(null);
    a = null;
  }

  template<typename T> inline void nullify(WorldVector<T> &a)
  {
    T null;
    nullify(null);
    a = null;
  }

198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
  // ===== 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:
227
    /// Prints a formated message to the message stream
228
229
    static void print(const char *format, ...);

230
    /// Prints a formated message to the error stream
231
232
    static void print_error(const char *format, ...);

233
    /// Prints a formated message to the error stream and exits 
234
235
    static void print_error_exit(const char *format, ...);

236
237
    ///
    static void catch_error_exit(const char *format, ...) {}
238

239
    /// Prints an error message with funcname, file, and line to the error stream
240
241
242
243
    static void print_error_funcname(const char *funcname,
				     const char *file, 
				     int line);

244
    /// Prints a warning to the message stream
245
246
    static void print_warn(const char *format, ...);

247
    /// Prints a warning with funcname, file, and line to the message stream
248
249
250
251
    static void print_warn_funcname(const char *funcname,
				    const char *file, 
				    int line);

252
    /// Prints the funcname to the message stream
253
254
    static void print_funcname(const char *funcname);

255
    /// Changes the message stream
256
    static void change_out(ostream*);
257

258
    /// Changes the error stream 
259
    static void change_error_out(ofstream *fp);
260

261
    /// Creates a filestream and sets the error stream to this filestream
262
263
    static void open_error_file(const char *filename, OPENMODE);

264
    /// Sets \ref msgInfo
265
266
267
268
    static void setMsgInfo(int info) 
    { 
      msgInfo = info; 
    }
269

270
    /// Returns \ref msgInfo
271
272
273
274
    static int  getMsgInfo() 
    { 
      return msgInfo; 
    }
275

276
    /// Sets \ref msgWait
277
278
279
280
    static void setMsgWait(bool wait) 
    { 
      msgWait = wait; 
    }
281

282
    /// Returns \ref msgWait
283
284
285
286
    static bool getMsgWait() 
    { 
      return msgWait; 
    }
287

288
    /// Waits for enter if w is true
289
290
    static void wait(bool w);

291
    /// Returns \ref out
292
    static ostream *getOutStream() 
293
294
295
    { 
      return out; 
    }
296

297
    /// Returns \ref error
298
    static ostream *getErrorStream() 
299
300
301
    { 
      return error; 
    }
302

303
304
305
306
307
308
309
310
  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

311
  protected:
312
    /// Message stram
313
    static ostream *out;
314

315
    /// Error stream
316
    static ostream *error;
317

Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
318
319
    /// Remember funcName to avoid multiple output of funcName within the same
    /// function call
Thomas Witkowski's avatar
Blub  
Thomas Witkowski committed
320
    static ThreadPrivate<const char*> oldFuncName;
321

322
    /// Global info level
323
324
    static int msgInfo;

325
    /// Spezifies whether to wait when WAIT is called
326
327
328
    static bool msgWait;
  };

Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
329
330
331
  // ===========================================================================
  // ===== message macros ======================================================
  // ===========================================================================
332

Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
333
334
  /// Should be the first call in every functions. It defines the current 
  /// function name nn for message output via MSG, WARNING, ...
335
#define FUNCNAME(nn) const char *funcName; funcName = nn;
336
337
338
339
340
341
  
#if (DEBUG == 0) 
  #define FUNCNAME_DBG(nn)
#else
  #define FUNCNAME_DBG(nn) const char *funcName; funcName = nn;
#endif
342

343
  /// prints an error message 
344
345
346
#define ERROR Msg::print_error_funcname(funcName,__FILE__, __LINE__),	\
    Msg::print_error

347
  /// prints an error message and exits 
348
349
350
#define ERROR_EXIT Msg::print_error_funcname(funcName,__FILE__, __LINE__), \
    Msg::print_error_exit

351
  /// prints a warning
352
353
354
#define WARNING Msg::print_warn_funcname(funcName,__FILE__, __LINE__),	\
    Msg::print_warn

355
  /// if test is false, an error message is printed
356
357
#define TEST(test) if ((test));else ERROR

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

361
  /// In debug mode, it corresponds to ERROR_EXIT, otherwise it is noop.
362
363
#if (DEBUG == 0) 
  #define TEST_EXIT_DBG(test) if (false) Msg::catch_error_exit
364
  #define DBG_VAR(var)
365
366
#else
#define TEST_EXIT_DBG(test) if ((test));else ERROR_EXIT
367
  #define DBG_VAR(var) var
368
#endif
369

370
  /// prints a message
371
372
#define MSG Msg::print_funcname(funcName), Msg::print

373
374
375
376
377
378
#if (DEBUG == 0) 
  #define MSG_DBG
#else
  #define MSG_DBG Msg::print_funcname(funcName), Msg::print
#endif

379
  /// prints a message, if min(Msg::msgInfo, info) >= noinfo
380
#define INFO(info,noinfo)						\
381
  if (Msg::getMsgInfo() && (std::min(Msg::getMsgInfo(), (info)) >= (noinfo))) MSG
382

383
  /// prints a message, if min(Msg::msgInfo, info) >= noinfo
384
#define PRINT_INFO(info,noinfo)						\
385
  if (Msg::getMsgInfo() && (std::min(Msg::getMsgInfo(), (info)) >= (noinfo))) Msg::print
386
387


Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
388
389
390
  /// 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.
391
392
#define WAIT Msg::wait(Msg::getMsgWait())

Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
393
394
  /// produces the message 'wait for <enter> ...' and will continue after
  /// pressing the return or enter key.
395
396
397
398
#define WAIT_REALLY Msg::wait(true)

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

Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
399
400
  /// internal used indices to represent the different geometrical objects.
  /// Used as parameter for getGeo() and as template parameter for FixVec. 
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
  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:
Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
441
442
    /// returns a pointer to \ref referenceElement [dim]. With this pointer you
    /// can get information about the element via Element's getGeo method.
443
444
    static const Element *getReferenceElement(int dim) 
    {
445
      FUNCNAME("Global::getReferenceElement()");
446
      TEST_EXIT(dim > 0 && dim < 4)("invalid dim: %d\n", dim);
447
      return referenceElement[dim];
448
    }
449

450
    /// returns geometrical information. Currently this is only dimOfWorld.
451
452
    static inline int getGeo(GeoIndex p) 
    {
453
454
455
      if (WORLD == p) 
	return dimOfWorld; 

456
      ERROR_EXIT("Illegal request for geometry data: part = %d!\n", p);
457
      return 0;
458
    }
459

Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
460
461
    /// Returns geometrical information about elements of the dimension dim.
    /// getGeo(VERTEX, 3) returns 4 because a Tetrahedron has 4 vertices.
462
463
    static inline int getGeo(GeoIndex p, int dim) 
    {
464
      TEST_EXIT_DBG(p >= MINPART && p <= MAXPART)
465
	("Calling for invalid geometry value %d\n",p);
466
      TEST_EXIT_DBG(dim >= 0 && dim < 4)
467
468
469
470
471
472
	("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];
    }
473

474
    /// Inits the Global class with the help of Parameters.
475
476
    static void init();

477
478
    static void clear();

Thomas Witkowski's avatar
Thomas Witkowski committed
479
  private:
Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
480
481
    /// Global is a pure static class. So the constructor is private to avoid
    /// instantiation.
Thomas Witkowski's avatar
Thomas Witkowski committed
482
    Global();
483
484

  private:
485
    /// Dimension of the simulated world
486
487
    static int dimOfWorld;

Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
488
489
490
491
492
    /// 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.
493
    static Element *referenceElement[4];
494

495
    /// Stores the precalculated results that should be returned by Global::getGeo.
496
    static vector<vector<int> > geoIndexTable;
497
498
499
500
501
502
  };

#define COMMA ,

  const int RescheduleErrorCode = 23;

503
504
505
506
507
508
509
510
511
  /**
   * \ingroup Assembler
   * \brief
   * Specifies the type of a FirstOrderTerm 
   */
  enum FirstOrderType {
    GRD_PSI,
    GRD_PHI
  };
512

513
514
515
516
}

#endif // AMDIS_GLOBAL_H