Global.h 15.5 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
46
47
48
#if !((defined BOOST_NO_CXX11_DECLTYPE) || defined(BOOST_NO_DECLTYPE))
  #define HAS_CPP11_DECLTYPE
#endif
49
50
51
#if !((defined BOOST_NO_CXX11_VARIADIC_TEMPLATES) || (defined BOOST_NO_VARIADIC_TEMPLATES)) || (defined BOOST_HAS_VARIADIC_TMPL)
  #define HAS_VARIADIC_TEMPLATES
#endif
52

53
/** \brief current AMDiS version */
54
55
56
#ifndef AMDIS_VERSION
#define AMDIS_VERSION  "AMDiS: Version 0.9.1"
#endif
57
58
59

#include <string>
#include <vector>
60
#include <set>
61
62
63
64
65
66
#include <fstream>
#include <math.h>
#include <iostream>
#include <stdio.h>
#include <functional>
#include <float.h>
67
#include <time.h>
68

69
70
71
72
73
74
#ifdef _WIN32
#include <io.h>
#else
#include <unistd.h>
#endif

75
#if HAVE_PARALLEL_DOMAIN_AMDIS
76
#include <mpi.h>
77
78
#endif

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

86
namespace AMDiS {
87
88
89

  extern const char *funcName;

90
  const int amdisRevisionNumber = 1700;
91

92
  /// Used by matrix vector multiplication
93
94
95
96
  typedef enum { NoTranspose,
		 Transpose,
		 ConjugateTranspose } MatrixTranspose;

97
  /// Speciefies the norm used by Estimator.
98
99
100
  typedef enum { NO_NORM = 0, 
		 H1_NORM = 1, 
		 L2_NORM = 2 } Norm;
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
  
  // 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);
126

127
  /// Datatype for degrees of freedom 
128
129
//   typedef signed int DegreeOfFreedom;
  typedef DofIndex::size_type DegreeOfFreedom;
130

131
  /// Defines type for a vector of DOF pointers.
132
  typedef std::vector<const DegreeOfFreedom*> DofContainer;
133

134
135
  typedef std::set<const DegreeOfFreedom*> DofContainerSet;

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

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

142

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

146
  /// Returns the dimension of GeoIndex ind for dimension dim
147
148
#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
149
150
151
152

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

160
  /// Calculates factorial of i
161
162
  int fac(int i);

163
164
  void waitSec(int seconds);

165
  void processMemUsage(double& vm_usage, double& resident_set, bool inMegaByte = true);
166

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

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

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

204
205
206
207
208
209
210
211
212
213
214
215
  // ===== 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));
  }

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

  template<typename T> inline void nullify(WorldMatrix<T> &a)
  {
    T null; nullify(null);
244
245
246
    a = null;
  }

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
273
274
275
  // ===== 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:
276
    /// Prints a formated message to the message stream
277
278
    static void print(const char *format, ...);

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

282
    /// Prints a formated message to the error stream and exits 
283
284
    static void print_error_exit(const char *format, ...);

285
286
    ///
    static void catch_error_exit(const char *format, ...) {}
287

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

293
    /// Prints a warning to the message stream
294
295
    static void print_warn(const char *format, ...);

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

301
    /// Prints the funcname to the message stream
302
303
    static void print_funcname(const char *funcname);

304
    /// Changes the message stream
305
    static void change_out(std::ostream*);
306

307
    /// Changes the error stream 
308
    static void change_error_out(std::ofstream *fp);
309

310
    /// Creates a filestream and sets the error stream to this filestream
311
312
    static void open_error_file(const char *filename, OPENMODE);

313
    /// Sets \ref msgInfo
314
315
316
317
    static void setMsgInfo(int info) 
    { 
      msgInfo = info; 
    }
318

319
    /// Returns \ref msgInfo
320
321
322
323
    static int  getMsgInfo() 
    { 
      return msgInfo; 
    }
324

325
    /// Sets \ref msgWait
326
327
328
329
    static void setMsgWait(bool wait) 
    { 
      msgWait = wait; 
    }
330

331
    /// Returns \ref msgWait
332
333
334
335
    static bool getMsgWait() 
    { 
      return msgWait; 
    }
336

337
    /// Waits for enter if w is true
338
339
    static void wait(bool w);

340
    /// Returns \ref out
341
    static std::ostream *getOutStream() 
342
343
344
    { 
      return out; 
    }
345

346
    /// Returns \ref error
347
    static std::ostream *getErrorStream() 
348
349
350
    { 
      return error; 
    }
351

352
353
354
355
356
357
358
359
  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

360
  protected:
361
    /// Message stram
362
    static std::ostream *out;
363

364
    /// Error stream
365
    static std::ostream *error;
366

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

371
    /// Global info level
372
373
    static int msgInfo;

374
    /// Spezifies whether to wait when WAIT is called
375
376
377
    static bool msgWait;
  };

Thomas Witkowski's avatar
bla  
Thomas Witkowski committed
378
379
380
  // ===========================================================================
  // ===== message macros ======================================================
  // ===========================================================================
381

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

392
  /// prints an error message 
393
394
395
#define ERROR Msg::print_error_funcname(funcName,__FILE__, __LINE__),	\
    Msg::print_error

396
  /// prints an error message and exits 
397
398
399
#define ERROR_EXIT Msg::print_error_funcname(funcName,__FILE__, __LINE__), \
    Msg::print_error_exit

400
  /// prints a warning
401
402
403
#define WARNING Msg::print_warn_funcname(funcName,__FILE__, __LINE__),	\
    Msg::print_warn

404
  /// if test is false, an error message is printed
405
406
#define TEST(test) if ((test));else ERROR

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

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

419
  /// prints a message
420
421
#define MSG Msg::print_funcname(funcName), Msg::print

422
423
424
425
426
427
#if (DEBUG == 0) 
  #define MSG_DBG
#else
  #define MSG_DBG Msg::print_funcname(funcName), Msg::print
#endif

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

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


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

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

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

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

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

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

521
    /// Inits the Global class with the help of Parameters.
522
523
    static void init();

524
525
    static void clear();

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

  private:
532
    /// Dimension of the simulated world
533
534
    static int dimOfWorld;

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

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

#define COMMA ,

  const int RescheduleErrorCode = 23;

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

560
561
562
563
}

#endif // AMDIS_GLOBAL_H