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

40
41
// TODO: better c++11 test!
#if (defined BOOST_NO_CXX11_OVERRIDE) || __cplusplus <= 199711L || ((defined _MSC_VER) && _MSC_VER < 1100)
42
43
  #define override 
#endif
44
#if (defined BOOST_NO_CXX11_NULLPTR) || __cplusplus <= 199711L
45
46
47
  #define nullptr NULL 
#endif

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

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

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

70
#if HAVE_PARALLEL_DOMAIN_AMDIS
71
#include <mpi.h>
72
73
#endif

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

81
namespace AMDiS {
82
83
84

  extern const char *funcName;

85
  const int amdisRevisionNumber = 1700;
86

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

92
  /// Speciefies the norm used by Estimator.
93
94
95
  typedef enum { NO_NORM = 0, 
		 H1_NORM = 1, 
		 L2_NORM = 2 } Norm;
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
  
  // 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);
121

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

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

129
130
  typedef std::set<const DegreeOfFreedom*> DofContainerSet;

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

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

137

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

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

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

155
  /// Calculates factorial of i
156
157
  int fac(int i);

158
159
  void waitSec(int seconds);

160
  void processMemUsage(double& vm_usage, double& resident_set, bool inMegaByte = true);
161

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

173
  
Praetorius, Simon's avatar
Praetorius, Simon committed
174
175
176
  /// check for file existence
  inline bool file_exists(const std::string filename)
  {
177
178
179
#ifdef _WIN32
    return _access(filename.c_str(), 0) == 0;
#else
Praetorius, Simon's avatar
Praetorius, Simon committed
180
    return access(filename.c_str(), F_OK) == 0;
181
#endif
182
  }
Praetorius, Simon's avatar
Praetorius, Simon committed
183
184
185
186
187
188
  
  /// 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
189

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

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

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

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

242
243
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
  // ===== 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:
271
    /// Prints a formated message to the message stream
272
273
    static void print(const char *format, ...);

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

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

280
281
    ///
    static void catch_error_exit(const char *format, ...) {}
282

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

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

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

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

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

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

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

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

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

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

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

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

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

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

347
348
349
350
351
352
353
354
  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

355
  protected:
356
    /// Message stram
357
    static std::ostream *out;
358

359
    /// Error stream
360
    static std::ostream *error;
361

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

366
    /// Global info level
367
368
    static int msgInfo;

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

Thomas Witkowski's avatar
bla    
Thomas Witkowski committed
373
374
375
  // ===========================================================================
  // ===== message macros ======================================================
  // ===========================================================================
376

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

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

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

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

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

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

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

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

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

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

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


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

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

Thomas Witkowski's avatar
bla    
Thomas Witkowski committed
441
442
  /// internal used indices to represent the different geometrical objects.
  /// Used as parameter for getGeo() and as template parameter for FixVec. 
443
444
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
  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
483
484
    /// returns a pointer to \ref referenceElement [dim]. With this pointer you
    /// can get information about the element via Element's getGeo method.
485
486
    static const Element *getReferenceElement(int dim) 
    {
487
      FUNCNAME("Global::getReferenceElement()");
488
      TEST_EXIT(dim > 0 && dim < 4)("invalid dim: %d\n", dim);
489
      return referenceElement[dim];
490
    }
491

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

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

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

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

519
520
    static void clear();

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

  private:
527
    /// Dimension of the simulated world
528
529
    static int dimOfWorld;

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

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

#define COMMA ,

  const int RescheduleErrorCode = 23;

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

555
556
557
558
}

#endif // AMDIS_GLOBAL_H