Global.h 15.3 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
#endif

Praetorius, Simon's avatar
Praetorius, Simon committed
40
41
#include <boost/config.hpp>

42
43
// TODO: better c++11 test!
#if (defined BOOST_NO_CXX11_OVERRIDE) || __cplusplus <= 199711L || ((defined _MSC_VER) && _MSC_VER < 1100)
44
45
  #define override 
#endif
Praetorius, Simon's avatar
Praetorius, Simon committed
46
47
#if (defined BOOST_NO_CXX11_NULLPTR) || __cplusplus <= 199711L
  #define nullptr NULL
48
49
#endif

50
/** \brief current AMDiS version */
51
52
53
#ifndef AMDIS_VERSION
#define AMDIS_VERSION  "AMDiS: Version 0.9.1"
#endif
54
55
56

#include <string>
#include <vector>
57
#include <set>
58
59
60
61
62
63
#include <fstream>
#include <math.h>
#include <iostream>
#include <stdio.h>
#include <functional>
#include <float.h>
64
#include <time.h>
65

66
67
68
69
70
71
#ifdef _WIN32
#include <io.h>
#else
#include <unistd.h>
#endif

72
#if HAVE_PARALLEL_DOMAIN_AMDIS
73
#include <mpi.h>
74
75
#endif

76
#include <boost/algorithm/string.hpp>
Praetorius, Simon's avatar
Praetorius, Simon committed
77
#include <boost/algorithm/string/trim.hpp>
Praetorius, Simon's avatar
Praetorius, Simon committed
78
#include <boost/math/special_functions/fpclassify.hpp>
79
#include "boost/tuple/tuple.hpp"
80
#include "AMDiS_fwd.h"
Thomas Witkowski's avatar
Blub  
Thomas Witkowski committed
81
#include "OpenMP.h"
82

83
namespace AMDiS {
84
85
86

  extern const char *funcName;

87
  const int amdisRevisionNumber = 1700;
88

89
  /// Used by matrix vector multiplication
90
91
92
93
  typedef enum { NoTranspose,
		 Transpose,
		 ConjugateTranspose } MatrixTranspose;

94
  /// Speciefies the norm used by Estimator.
95
96
97
  typedef enum { NO_NORM = 0, 
		 H1_NORM = 1, 
		 L2_NORM = 2 } Norm;
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
  
  // may be used in the future
  struct DofIndex 
  {
    typedef signed int size_type;
    
    DofIndex() : idx(0) {}
    DofIndex(size_type i) : idx(i) {}
    
    DofIndex& operator=(const size_type &rhs) 
    {
      idx = rhs;
      return *this;
    }
    
    operator size_type() const
    {
      return idx;
    }
    
    size_type idx;
  };
  
  std::ostream& operator<<(std::ostream& os, const DofIndex& di);  
  std::istream& operator>>(std::istream& is, DofIndex& di);
123

124
  /// Datatype for degrees of freedom 
125
126
//   typedef signed int DegreeOfFreedom;
  typedef DofIndex::size_type DegreeOfFreedom;
127

128
  /// Defines type for a vector of DOF pointers.
129
  typedef std::vector<const DegreeOfFreedom*> DofContainer;
130

131
132
  typedef std::set<const DegreeOfFreedom*> DofContainerSet;

133
  /// Defines a type for global edge identification via its DOFs.
134
  typedef std::pair<DegreeOfFreedom, DegreeOfFreedom> DofEdge;
135
136
137

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

139

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

143
  /// Returns the dimension of GeoIndex ind for dimension dim
144
145
#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
146
147
148
149

#if SUPPRESS_OUTPUT
#define PRINT_LINE(stream, line)
#else
150
#if HAVE_PARALLEL_DOMAIN_AMDIS
151
#define PRINT_LINE(stream, line) stream << "[" << MPI::COMM_WORLD.Get_rank() << "] " << line
152
#else
153
#define PRINT_LINE(stream, line) stream << line
Thomas Witkowski's avatar
Blub  
Thomas Witkowski committed
154
#endif
155
156
#endif

157
  /// Calculates factorial of i
158
159
  int fac(int i);

160
161
  void waitSec(int seconds);

162
  void processMemUsage(double& vm_usage, double& resident_set, bool inMegaByte = true);
163

164
  /// Content comparision of two pointers. Used e.g. for find_if
165
  template<typename T>
166
  struct comparePtrContents : public std::binary_function<T*, T*, bool>
167
  {
168
    /// Overrides binary_function::operator()
169
170
    bool operator()(T* a, T* b) const 
    {
171
      return (*a == *b);
172
    }
173
174
  };

175
  
Praetorius, Simon's avatar
Praetorius, Simon committed
176
177
178
  /// check for file existence
  inline bool file_exists(const std::string filename)
  {
179
180
181
#ifdef _WIN32
    return _access(filename.c_str(), 0) == 0;
#else
Praetorius, Simon's avatar
Praetorius, Simon committed
182
    return access(filename.c_str(), F_OK) == 0;
183
#endif
184
  }
Praetorius, Simon's avatar
Praetorius, Simon committed
185
186
187
188
189
190
  
  /// check for inf and nan values
  inline bool isNumber(double val)
  {
    return !boost::math::isnan(val) && !boost::math::isinf(val);
  }
Praetorius, Simon's avatar
Praetorius, Simon committed
191

192
  
Praetorius, Simon's avatar
Praetorius, Simon committed
193
194
195
196
197
198
  /// trim std::string
  inline std::string trim(const std::string& oldStr)
  {
    std::string swap(oldStr);
    boost::algorithm::trim(swap);
    return swap;
199
  }
Praetorius, Simon's avatar
Praetorius, Simon committed
200

201
202
203
204
205
206
207
208
209
210
211
212
  // ===== 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));
  }

213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
  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)
  {
234
235
236
237
238
239
240
    T null; nullify(null);
    a = null;
  }

  template<typename T> inline void nullify(WorldMatrix<T> &a)
  {
    T null; nullify(null);
241
242
243
    a = null;
  }

244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
  // ===== 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:
273
    /// Prints a formated message to the message stream
274
275
    static void print(const char *format, ...);

276
    /// Prints a formated message to the error stream
277
278
    static void print_error(const char *format, ...);

279
    /// Prints a formated message to the error stream and exits 
280
281
    static void print_error_exit(const char *format, ...);

282
283
    ///
    static void catch_error_exit(const char *format, ...) {}
284

285
    /// Prints an error message with funcname, file, and line to the error stream
286
287
288
289
    static void print_error_funcname(const char *funcname,
				     const char *file, 
				     int line);

290
    /// Prints a warning to the message stream
291
292
    static void print_warn(const char *format, ...);

293
    /// Prints a warning with funcname, file, and line to the message stream
294
295
296
297
    static void print_warn_funcname(const char *funcname,
				    const char *file, 
				    int line);

298
    /// Prints the funcname to the message stream
299
300
    static void print_funcname(const char *funcname);

301
    /// Changes the message stream
302
    static void change_out(std::ostream*);
303

304
    /// Changes the error stream 
305
    static void change_error_out(std::ofstream *fp);
306

307
    /// Creates a filestream and sets the error stream to this filestream
308
309
    static void open_error_file(const char *filename, OPENMODE);

310
    /// Sets \ref msgInfo
311
312
313
314
    static void setMsgInfo(int info) 
    { 
      msgInfo = info; 
    }
315

316
    /// Returns \ref msgInfo
317
318
319
320
    static int  getMsgInfo() 
    { 
      return msgInfo; 
    }
321

322
    /// Sets \ref msgWait
323
324
325
326
    static void setMsgWait(bool wait) 
    { 
      msgWait = wait; 
    }
327

328
    /// Returns \ref msgWait
329
330
331
332
    static bool getMsgWait() 
    { 
      return msgWait; 
    }
333

334
    /// Waits for enter if w is true
335
336
    static void wait(bool w);

337
    /// Returns \ref out
338
    static std::ostream *getOutStream() 
339
340
341
    { 
      return out; 
    }
342

343
    /// Returns \ref error
344
    static std::ostream *getErrorStream() 
345
346
347
    { 
      return error; 
    }
348

349
350
351
352
353
354
355
356
  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

357
  protected:
358
    /// Message stram
359
    static std::ostream *out;
360

361
    /// Error stream
362
    static std::ostream *error;
363

Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
364
365
    /// Remember funcName to avoid multiple output of funcName within the same
    /// function call
Thomas Witkowski's avatar
Blub  
Thomas Witkowski committed
366
    static ThreadPrivate<const char*> oldFuncName;
367

368
    /// Global info level
369
370
    static int msgInfo;

371
    /// Spezifies whether to wait when WAIT is called
372
373
374
    static bool msgWait;
  };

Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
375
376
377
  // ===========================================================================
  // ===== message macros ======================================================
  // ===========================================================================
378

Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
379
380
  /// Should be the first call in every functions. It defines the current 
  /// function name nn for message output via MSG, WARNING, ...
381
#define FUNCNAME(nn) const char *funcName; funcName = nn;
382
383
384
385
386
387
  
#if (DEBUG == 0) 
  #define FUNCNAME_DBG(nn)
#else
  #define FUNCNAME_DBG(nn) const char *funcName; funcName = nn;
#endif
388

389
  /// prints an error message 
390
391
392
#define ERROR Msg::print_error_funcname(funcName,__FILE__, __LINE__),	\
    Msg::print_error

393
  /// prints an error message and exits 
394
395
396
#define ERROR_EXIT Msg::print_error_funcname(funcName,__FILE__, __LINE__), \
    Msg::print_error_exit

397
  /// prints a warning
398
399
400
#define WARNING Msg::print_warn_funcname(funcName,__FILE__, __LINE__),	\
    Msg::print_warn

401
  /// if test is false, an error message is printed
402
403
#define TEST(test) if ((test));else ERROR

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

407
  /// In debug mode, it corresponds to ERROR_EXIT, otherwise it is noop.
408
409
#if (DEBUG == 0) 
  #define TEST_EXIT_DBG(test) if (false) Msg::catch_error_exit
410
  #define DBG_VAR(var)
411
412
#else
#define TEST_EXIT_DBG(test) if ((test));else ERROR_EXIT
413
  #define DBG_VAR(var) var
414
#endif
415

416
  /// prints a message
417
418
#define MSG Msg::print_funcname(funcName), Msg::print

419
420
421
422
423
424
#if (DEBUG == 0) 
  #define MSG_DBG
#else
  #define MSG_DBG Msg::print_funcname(funcName), Msg::print
#endif

425
  /// prints a message, if min(Msg::msgInfo, info) >= noinfo
426
#define INFO(info,noinfo)						\
427
  if (Msg::getMsgInfo() && (std::min(Msg::getMsgInfo(), (info)) >= (noinfo))) MSG
428

429
  /// prints a message, if min(Msg::msgInfo, info) >= noinfo
430
#define PRINT_INFO(info,noinfo)						\
431
  if (Msg::getMsgInfo() && (std::min(Msg::getMsgInfo(), (info)) >= (noinfo))) Msg::print
432
433


Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
434
435
436
  /// 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.
437
438
#define WAIT Msg::wait(Msg::getMsgWait())

Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
439
440
  /// produces the message 'wait for <enter> ...' and will continue after
  /// pressing the return or enter key.
441
442
#define WAIT_REALLY Msg::wait(true)

Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
443
444
  /// internal used indices to represent the different geometrical objects.
  /// Used as parameter for getGeo() and as template parameter for FixVec. 
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
  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
485
486
    /// returns a pointer to \ref referenceElement [dim]. With this pointer you
    /// can get information about the element via Element's getGeo method.
487
488
    static const Element *getReferenceElement(int dim) 
    {
489
      FUNCNAME("Global::getReferenceElement()");
490
      TEST_EXIT(dim > 0 && dim < 4)("invalid dim: %d\n", dim);
491
      return referenceElement[dim];
492
    }
493

494
    /// returns geometrical information. Currently this is only dimOfWorld.
495
496
    static inline int getGeo(GeoIndex p) 
    {
497
498
499
      if (WORLD == p) 
	return dimOfWorld; 

500
      ERROR_EXIT("Illegal request for geometry data: part = %d!\n", p);
501
      return 0;
502
    }
503

Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
504
505
    /// Returns geometrical information about elements of the dimension dim.
    /// getGeo(VERTEX, 3) returns 4 because a Tetrahedron has 4 vertices.
506
507
    static inline int getGeo(GeoIndex p, int dim) 
    {
508
      TEST_EXIT_DBG(p >= MINPART && p <= MAXPART)
509
	("Calling for invalid geometry value %d\n",p);
510
      TEST_EXIT_DBG(dim >= 0 && dim < 4)
511
512
513
514
515
516
	("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];
    }
517

518
    /// Inits the Global class with the help of Parameters.
519
520
    static void init();

521
522
    static void clear();

Thomas Witkowski's avatar
Thomas Witkowski committed
523
  private:
Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
524
525
    /// Global is a pure static class. So the constructor is private to avoid
    /// instantiation.
Thomas Witkowski's avatar
Thomas Witkowski committed
526
    Global();
527
528

  private:
529
    /// Dimension of the simulated world
530
531
    static int dimOfWorld;

Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
532
533
534
535
536
    /// 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.
537
    static Element *referenceElement[4];
538

539
    /// Stores the precalculated results that should be returned by Global::getGeo.
540
    static std::vector<std::vector<int> > geoIndexTable;
541
542
543
544
545
546
  };

#define COMMA ,

  const int RescheduleErrorCode = 23;

547
548
549
550
551
552
553
554
555
  /**
   * \ingroup Assembler
   * \brief
   * Specifies the type of a FirstOrderTerm 
   */
  enum FirstOrderType {
    GRD_PSI,
    GRD_PHI
  };
556

557
558
559
560
}

#endif // AMDIS_GLOBAL_H