AdaptInfo.h 19.5 KB
Newer Older
1
2
3
4
5
6
// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
7
// ==  TU Dresden                                                            ==
8
// ==                                                                        ==
9
10
11
// ==  Institut fr Wissenschaftliches Rechnen                               ==
// ==  Zellescher Weg 12-14                                                  ==
// ==  01069 Dresden                                                         ==
12
13
14
15
// ==  germany                                                               ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
16
// ==  https://gforge.zih.tu-dresden.de/projects/amdis/                      ==
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// ==                                                                        ==
// ============================================================================

/** \file AdaptInfo.h */

#ifndef AMDIS_ADAPTINFO_H
#define AMDIS_ADAPTINFO_H

#include "MatrixVector.h"
#include "Parameters.h"
#include "Serializable.h"

namespace AMDiS {

  /**
   * \ingroup Adaption
   * 
   * \brief
   * Holds adapt parameters and infos about the problem. Base class
   * for AdaptInfoScal and AdaptInfoVec.
   */
  class AdaptInfo : public Serializable
  {
  protected:
    /** \brief
     * Stores adapt infos for a scalar problem or for one component of a 
     * vector valued problem.
     */
    class ScalContent {
    public:
47
      /// Constructor.
Thomas Witkowski's avatar
Thomas Witkowski committed
48
      ScalContent(std::string prefix) 
49
	: est_sum(0.0),
50
51
52
53
54
55
56
57
58
59
60
61
	  est_t_sum(0.0),
	  est_max(0.0),
	  est_t_max(0.0),
	  fac_max(0.0),
	  fac_sum(1.0),
	  spaceTolerance(0.0),
	  timeTolerance(0.0),
	  timeErrLow(0.0),
	  coarsenAllowed(0),
	  refinementAllowed(1),
	  refineBisections(1),
	  coarseBisections(1)	  	
62
63
64
      {
	double timeTheta2 = 0.3;

65
66
67
68
	// TODO: obsolete parameters timeTheta2, relTimeErr, relSpaceErr

	GET_PARAMETER(0, prefix + "->tolerance", "%f", &spaceTolerance);
	GET_PARAMETER(0, prefix + "->time tolerance", "%f", &timeTolerance);
69
70
71
72
73
	GET_PARAMETER(0, prefix + "->time theta 2", "%f", &timeTheta2);
	GET_PARAMETER(0, prefix + "->coarsen allowed", "%d", &coarsenAllowed);
	GET_PARAMETER(0, prefix + "->refinement allowed", "%d", &refinementAllowed);
	GET_PARAMETER(0, prefix + "->refine bisections", "%d", &refineBisections);
	GET_PARAMETER(0, prefix + "->coarsen bisections", "%d", &coarseBisections);
74
75
	GET_PARAMETER(0, prefix + "->sum factor", "%f", &fac_sum);
	GET_PARAMETER(0, prefix + "->max factor", "%f", &fac_max);
76

77
	timeErrLow = timeTolerance * timeTheta2;
78
      }
79

80
      /// Sum of all error estimates
81
82
      double est_sum;

83
      /// Sum of all time error estimates
84
85
      double est_t_sum;

86
      /// maximal local error estimate.
87
88
      double est_max;

89
      /// Maximum of all time error estimates
90
      double est_t_max;
91
92
93
      
      /// factors to combine max and integral time estimate
      double fac_max, fac_sum;
94

95
      /// Tolerance for the (absolute or relative) error
96
97
      double spaceTolerance;

98
      /// Time tolerance.
99
100
      double timeTolerance;

101
      /// Lower bound for the time error.
102
103
      double timeErrLow;

104
      /// true if coarsening is allowed, false otherwise.
105
106
      int coarsenAllowed;

107
      /// true if refinement is allowed, false otherwise.
108
109
110
111
112
113
114
      int refinementAllowed;

      /** \brief
       * parameter to tell the marking strategy how many bisections should be 
       * performed when an element is marked for refinement; usually the value is
       * 1 or DIM
       */
115
      int refineBisections;
116
117
118
119
120
121

      /** \brief
       * parameter to tell the marking strategy how many bisections should
       * be undone when an element is marked for coarsening; usually the value is 
       * 1 or DIM
       */                          
122
      int coarseBisections;    
123
124
125
    };

  public:
126
    /// Constructor.
Thomas Witkowski's avatar
Thomas Witkowski committed
127
    AdaptInfo(std::string name_, int size = 1) 
128
129
130
131
132
133
134
135
136
137
138
      : name(name_), 
	spaceIteration(-1),
	maxSpaceIteration(-1),
	timestepIteration(0),
	maxTimestepIteration(30),
	timeIteration(0),
	maxTimeIteration(30),
	time(0.0),
	startTime(0.0),
	endTime(1.0),
	timestep(0.0),
139
	lastProcessedTimestep(0.0),
140
141
142
	minTimestep(0.0),
	maxTimestep(1.0),
	timestepNumber(0),
Thomas Witkowski's avatar
* Bla    
Thomas Witkowski committed
143
	nTimesteps(0),
144
145
146
147
	solverIterations(0),
	maxSolverIterations(0),
	solverTolerance(1e-8),
	solverResidual(0.0),
148
        scalContents(size),
149
150
	deserialized(false),
	rosenbrockMode(false)
151
152
153
154
155
156
157
158
159
160
161
162
    {
      GET_PARAMETER(0, name_ + "->start time", "%f", &startTime);
      time = startTime;
      GET_PARAMETER(0, name_ + "->timestep", "%f", &timestep);
      GET_PARAMETER(0, name_ + "->end time", "%f", &endTime);
      GET_PARAMETER(0, name_ + "->max iteration", "%d", &maxSpaceIteration);
      GET_PARAMETER(0, name_ + "->max timestep iteration", "%d", &maxTimestepIteration);
      GET_PARAMETER(0, name_ + "->max time iteration", "%d", &maxTimeIteration);

      GET_PARAMETER(0, name_ + "->min timestep", "%f", &minTimestep);
      GET_PARAMETER(0, name_ + "->max timestep", "%f", &maxTimestep);

Thomas Witkowski's avatar
* Bla    
Thomas Witkowski committed
163
164
      GET_PARAMETER(0, name_ + "->number of timesteps", "%d", &nTimesteps);

165
166
167
168
169
170
      if (size == 1) {
	scalContents[0] = new ScalContent(name); 
      } else {
	char number[5];
	for (int i = 0; i < size; i++) {
	  sprintf(number, "[%d]", i);
Thomas Witkowski's avatar
Thomas Witkowski committed
171
	  scalContents[i] = new ScalContent(name + std::string(number)); 
172
173
	}
      }
174
    }
175

176
    /// Destructor.
Thomas Witkowski's avatar
Thomas Witkowski committed
177
178
179
    virtual ~AdaptInfo() 
    {
      for (unsigned int i = 0;  i < scalContents.size(); i++)
180
	delete scalContents[i];
181
    }
182
183
184
185
186
187
188
189
190
191
192

    inline void reset() 
    {
      spaceIteration = -1;
      timestepIteration = 0;
      timeIteration = 0;
      time = 0.0;
      timestep = 0.0;
      timestepNumber = 0;
      solverIterations = 0;
      solverResidual = 0.0;
193
194

      GET_PARAMETER(0, name + "->timestep", "%f", &timestep);
195
      lastProcessedTimestep=timestep;
196
    }
197

198
    /// Returns whether space tolerance is reached.
199
200
    virtual bool spaceToleranceReached() 
    {
Thomas Witkowski's avatar
Thomas Witkowski committed
201
202
203
204
      for (unsigned int i = 0; i < scalContents.size(); i++) {
	std::cout << "est_sum:" <<scalContents[i]->est_sum 
		  << " spaceTol: " << scalContents[i]->spaceTolerance 
		  << std::endl;
205
	if (!(scalContents[i]->est_sum < scalContents[i]->spaceTolerance))
206
	  return false;
207
      }
208

209
      return true;
210
    }
211

212
    /// Returns whether space tolerance of component i is reached.
213
214
    virtual bool spaceToleranceReached(int i) 
    {
215
      if (!(scalContents[i]->est_sum < scalContents[i]->spaceTolerance))
216
	return false;
217
      else
218
	return true;
219
    }
220

221
    /// Returns whether time tolerance is reached.
222
223
    virtual bool timeToleranceReached() 
    {
Thomas Witkowski's avatar
Thomas Witkowski committed
224
      for (unsigned int i = 0; i < scalContents.size(); i++)
225
	if (!(getTimeEstCombined(i) < scalContents[i]->timeTolerance))
226
	  return false;
227

228
      return true;
229
    }
230

231
    /// Returns whether time tolerance of component i is reached.
232
233
    virtual bool timeToleranceReached(int i) 
    {
234
      if (!(getTimeEstCombined(i) < scalContents[i]->timeTolerance))
235
	return false;
236
      else
237
	return true;
238
    }
239

240
    /// Returns whether time error is under its lower bound.
241
242
    virtual bool timeErrorLow() 
    {
Thomas Witkowski's avatar
Thomas Witkowski committed
243
      for (unsigned int i = 0; i < scalContents.size(); i++)
244
	if (!(getTimeEstCombined(i) < scalContents[i]->timeErrLow))
245
	  return false;
246

247
      return true;
248
    }
249
250
251
252
253
254
255
256
    /// Returns the time estimation as a combination 
    /// of maximal and integral time error 
    double getTimeEstCombined(unsigned i) const 
    { 
      return scalContents[i]->est_t_max*scalContents[i]->fac_max
	+scalContents[i]->est_t_sum*scalContents[i]->fac_sum; 
    }

257

258
    /// Print debug information about time error and its bound.
259
260
    void printTimeErrorLowInfo() 
    {
261
262
263
264
      for (unsigned int i = 0; i < scalContents.size(); i++){
	std::cout << "    Time error estimate  = " << getTimeEstCombined(i)
		  << "    Time error estimate sum = " << scalContents[i]->est_t_sum 
		  << "    Time error estimate max = " << scalContents[i]->est_t_max 
265
266
		  << "    Time error low bound = " << scalContents[i]->timeErrLow  
		  << "    Time error high bound = " << scalContents[i]->timeTolerance << "\n";
267
      }
268
    }
269

270
    /// Returns \ref spaceIteration.
271
272
    inline int getSpaceIteration() 
    { 
273
      return spaceIteration; 
274
    }
275

276
    /// Sets \ref spaceIteration.
277
278
    inline void setSpaceIteration(int it) 
    { 
279
      spaceIteration = it; 
280
    }
281
  
282
    /// Returns \ref maxSpaceIteration.
283
284
    inline int getMaxSpaceIteration() 
    { 
285
      return maxSpaceIteration;
286
    }
287

288
    /// Sets \ref maxSpaceIteration.
289
290
    inline void setMaxSpaceIteration(int it) 
    { 
291
      maxSpaceIteration = it; 
292
    }
293
  
294
    /// Increments \ref spaceIteration by 1;
295
296
    inline void incSpaceIteration() 
    { 
297
      spaceIteration++; 
298
    }
299

300
    /// Sets \ref timestepIteration.
301
302
    inline void setTimestepIteration(int it) 
    { 
303
      timestepIteration = it; 
304
    }
305
  
306
    /// Returns \ref timestepIteration.
307
308
    inline int getTimestepIteration() 
    { 
309
      return timestepIteration; 
310
    }
311

312
    /// Increments \ref timestepIteration by 1;
313
314
    inline void incTimestepIteration() 
    { 
315
      timestepIteration++; 
316
    }
317

318
    /// Returns \ref maxTimestepIteration.
319
320
    inline int getMaxTimestepIteration() 
    { 
321
      return maxTimestepIteration; 
322
    }
323

324
    /// Sets \ref maxTimestepIteration.
325
326
    inline void setMaxTimestepIteration(int it) 
    { 
327
      maxTimestepIteration = it; 
328
    }
329
  
330
    /// Sets \ref timeIteration.
331
332
    inline void setTimeIteration(int it) 
    { 
333
      timeIteration = it; 
334
    }
335
  
336
    /// Returns \ref timeIteration.
337
338
    inline int getTimeIteration() 
    { 
339
      return timeIteration; 
340
    }
341

342
    /// Increments \ref timesIteration by 1;
343
344
    inline void incTimeIteration() 
    { 
345
      timeIteration++; 
346
    }
347

348
    /// Returns \ref maxTimeIteration.
349
350
    inline int getMaxTimeIteration() 
    { 
351
      return maxTimeIteration; 
352
    }
353

354
    /// Sets \ref maxTimeIteration.
355
356
    inline void setMaxTimeIteration(int it) 
    { 
357
      maxTimeIteration = it; 
358
    }
359
  
360
    /// Returns \ref timestepNumber.
361
362
    inline int getTimestepNumber() 
    { 
363
      return timestepNumber; 
364
    }
365

366
367
368
369
370
371
    /// Sets \ref timestepNumber.
    inline void setTimestepNumber(int num) 
    {
      timestepNumber = AMDiS::min(nTimesteps,num);
    }
    
Thomas Witkowski's avatar
* Bla    
Thomas Witkowski committed
372
    /// Returns \ref nTimesteps.
373
374
    inline int getNumberOfTimesteps() 
    {
Thomas Witkowski's avatar
* Bla    
Thomas Witkowski committed
375
376
377
      return nTimesteps;
    }

378
379
380
    /// Sets \ref nTimesteps.
    inline void setNumberOfTimesteps(int num) 
    {
381
      nTimesteps = AMDiS::max(0,num);
382
383
    }

384
    /// Increments \ref timestepNumber by 1;
385
386
    inline void incTimestepNumber() 
    { 
387
      timestepNumber++; 
388
    }
389

390
    /// Sets \ref est_sum.
391
392
    inline void setEstSum(double e, int index) 
    {
393
      scalContents[index]->est_sum = e;
394
    }
395

396
    /// Sets \ref est_max.
397
398
    inline void setEstMax(double e, int index) 
    {
399
      scalContents[index]->est_max = e;
400
    }
401

402
    /// Sets \ref est_max.
403
404
    inline void setTimeEstMax(double e, int index) 
    {
405
      scalContents[index]->est_t_max = e;
406
    }
407

408
    /// Sets \ref est_t_sum.
409
410
    inline void setTimeEstSum(double e, int index) 
    {
411
      scalContents[index]->est_t_sum = e;
412
    }
413

414
    /// Returns \ref est_sum.
415
416
    inline double getEstSum(int index) 
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
417
418
419
420
421
      FUNCNAME("AdaptInfo::getEstSum()");

      TEST_EXIT_DBG(static_cast<unsigned int>(index) < scalContents.size())
	("Wrong index for adaptInfo!\n");

422
      return scalContents[index]->est_sum; 
423
    }
424

425
    /// Returns \ref est_t_sum.
426
427
    inline double getEstTSum(int index) 
    { 
428
      return scalContents[index]->est_t_sum; 
429
    }
430

431
    /// Returns \ref est_max.
432
433
    inline double getEstMax(int index) 
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
434
435
436
437
438
      FUNCNAME("AdaptInfo::getEstSum()");

      TEST_EXIT_DBG(static_cast<unsigned int>(index) < scalContents.size())
	("Wrong index for adaptInfo!\n");

439
      return scalContents[index]->est_max; 
440
    }
441

442
    /// Returns \ref est_max.
443
444
    inline double getTimeEstMax(int index) 
    { 
445
      return scalContents[index]->est_t_max; 
446
    }
447

448
    /// Returns \ref est_t_sum.
449
450
    inline double getTimeEstSum(int index) 
    { 
451
      return scalContents[index]->est_t_sum; 
452
    }
453

454
    /// Returns \ref spaceTolerance.
455
456
    inline double getSpaceTolerance(int index) 
    { 
457
      return scalContents[index]->spaceTolerance; 
458
    }  
459

460
    /// Sets \ref spaceTolerance.
461
462
    inline void setSpaceTolerance(int index, double tol) 
    { 
463
      scalContents[index]->spaceTolerance = tol; 
464
    }  
465

466
    /// Returns \ref timeTolerance.
467
468
    inline double getTimeTolerance(int index) 
    { 
469
      return scalContents[index]->timeTolerance; 
470
    }  
471

472
    /// Sets \ref time
473
474
    inline double setTime(double t) 
    { 
475
      time = t; 
476
477
478
479
480
      if (time > endTime) 
	time = endTime;
      if (time < startTime) 
	time = startTime;

481
      return time;
482
    }
483

484
    /// Gets \ref time
485
486
    inline double getTime() 
    { 
487
      return time; 
488
    }  
489

490
    /// Gets \ref &time
491
492
    inline double *getTimePtr() 
    { 
493
      return &time; 
494
    }  
495

496
    /// Sets \ref timestep
497
498
    inline double setTimestep(double t) 
    { 
499
      timestep = t; 
500
      if (timestep > maxTimestep)
501
	timestep = maxTimestep;
502
      if (timestep < minTimestep)
503
	timestep = minTimestep;
504
      if (time + timestep > endTime)
505
506
	timestep = endTime - time;
      
507
      return timestep;
508
    }
509
510
511
512
513
514
515
516
517
518
519
520
521
    /// Gets \ref timestep
    inline double getTimestep() 
    { 
      return timestep; 
    }

    inline void setLastProcessedTimestep(double t){
	lastProcessedTimestep=t;
    } 

    inline double getLastProcessedTimestep(){
	return lastProcessedTimestep;
    } 
522

Thomas Witkowski's avatar
* Bla    
Thomas Witkowski committed
523
524
525
526
    /** \brief
     * Returns true, if the end time is reached and no more timestep
     * computations must be done.
     */
527
528
    inline bool reachedEndTime() 
    {
529
530
531
532
      if (nTimesteps > 0) 
	return !(timestepNumber < nTimesteps);

      return !(time < endTime - DBL_TOL);
Thomas Witkowski's avatar
* Bla    
Thomas Witkowski committed
533
534
    }

535

536
    /// Sets \ref minTimestep
537
538
    inline void setMinTimestep(double t) 
    { 
539
      minTimestep = t; 
540
    }
541

542
    /// Gets \ref minTimestep
543
544
    inline double getMinTimestep() 
    { 
545
      return minTimestep; 
546
    }  
547

548
    /// Sets \ref maxTimestep
549
550
    inline void setMaxTimestep(double t) 
    { 
551
      maxTimestep = t; 
552
    }
553

554
    /// Gets \ref maxTimestep
555
556
    inline double getMaxTimestep() 
    { 
557
      return maxTimestep; 
558
    }  
559
    
560
    /// Gets \ref &timestep
561
562
    inline double *getTimestepPtr() 
    { 
563
      return &timestep; 
564
    }  
565

566
    /// Sets \ref startTime = time
567
568
    inline void setStartTime(double time) 
    { 
569
      startTime = time; 
570
    }
571

572
    /// Sets \ref endTime = time
573
574
    inline void setEndTime(double time) 
    { 
575
      endTime = time; 
576
    }
577

578
    /// Returns \ref startTime
579
580
    inline double getStartTime() 
    { 
581
      return startTime; 
582
    }
583

584
    /// Returns \ref endTime
585
586
    inline double getEndTime() 
    { 
587
      return endTime; 
588
    }
589

590
    /// Returns \ref timeErrLow.
591
592
    inline double getTimeErrLow(int index) 
    { 
593
      return scalContents[index]->timeErrLow; 
594
    }  
595

596
    /// Returns whether coarsening is allowed or not.
597
598
    inline bool isCoarseningAllowed(int index) 
    {
599
      return (scalContents[index]->coarsenAllowed == 1);
600
    }
601

602
    /// Returns whether coarsening is allowed or not.
603
604
    inline bool isRefinementAllowed(int index) 
    {
605
      return (scalContents[index]->refinementAllowed == 1);
606
    }
607

608
    ///
609
610
    inline void allowRefinement(bool allow, int index) 
    {
611
      scalContents[index]->refinementAllowed = allow;
612
    }
613

614
    ///
615
616
    inline void allowCoarsening(bool allow, int index) 
    {
617
      scalContents[index]->coarsenAllowed = allow;
618
    }
619

620
    /// Returns \ref refineBisections
621
622
    inline const int getRefineBisections(int index) const 
    {
623
      return scalContents[index]->refineBisections;
624
    }
625

626
    /// Returns \ref coarseBisections
627
628
    inline const int getCoarseBisections(int index) const 
    {
629
      return scalContents[index]->coarseBisections;
630
    }    
631

632
633
    inline int getSize() 
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
634
      return scalContents.size(); 
635
    }
636

637
638
639
640
641
    inline bool getRosenbrockMode()
    {
      return rosenbrockMode;
    }

642
643
    inline void setSolverIterations(int it) 
    {
644
      solverIterations = it;
645
    }
646
  
647
648
    inline int getSolverIterations() 
    {
649
      return solverIterations;
650
    }
651
  
652
653
    inline void setMaxSolverIterations(int it) 
    {
654
      maxSolverIterations = it;
655
    }
656
  
657
658
    inline int getMaxSolverIterations() 
    {
659
      return maxSolverIterations;
660
    }
661
  
662
663
    inline void setSolverTolerance(double tol) 
    {
664
      solverTolerance = tol;
665
    }
666
  
667
668
    inline double getSolverTolerance() 
    {
669
      return solverTolerance;
670
    }
671
  
672
673
    inline void setSolverResidual(double res) 
    {
674
      solverResidual = res;
675
    }
676
  
677
678
    inline double getSolverResidual() 
    {
679
      return solverResidual;
680
    }
681

682
    /// Returns true, if the adaptive procedure was deserialized from a file.
683
684
    const bool isDeserialized() const 
    {
685
      return deserialized;
686
687
    }

688
689
    inline void setIsDeserialized(bool b) 
    {
690
691
692
693
694
695
      deserialized = b;
    }

    inline void setRosenbrockMode(bool b)
    {
      rosenbrockMode = b;
696
697
    }

698
    /// Creates new scalContents with the given size.
699
700
    void setScalContents(int newSize);

701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
    /** \brief
     * Resets timestep, current time and time boundaries without
     * any check. Is used by the parareal algorithm.
     */
    void resetTimeValues(double newTimeStep,
			 double newStartTime,
			 double newEndTime)
    {
      time = newStartTime;
      startTime = newStartTime;
      endTime = newEndTime;
      timestep = newTimeStep;
      timestepNumber = 0;
    }

Thomas Witkowski's avatar
Thomas Witkowski committed
716
    void serialize(std::ostream& out);
717

Thomas Witkowski's avatar
Thomas Witkowski committed
718
    void deserialize(std::istream& in);
719
720

  protected:
721
    /// Name.
Thomas Witkowski's avatar
Thomas Witkowski committed
722
    std::string name;
723

724
    /// Current space iteration
725
726
727
728
729
730
731
732
    int spaceIteration;

    /** \brief
     * maximal allowed number of iterations of the adaptive procedure; if 
     * maxIteration <= 0, no iteration bound is used
     */
    int maxSpaceIteration;

733
    /// Current timestep iteration
734
735
    int timestepIteration;

736
    /// Maximal number of iterations for choosing a timestep
737
738
    int maxTimestepIteration;

739
    /// Current time iteration
740
741
    int timeIteration;

742
    /// Maximal number of time iterations
743
744
    int maxTimeIteration;

745
    /// Actual time, end of time interval for current time step
746
747
    double time;

748
    /// Initial time
749
750
    double startTime;

751
    /// Final time
752
753
    double endTime;

754
    ///Time step size to be used
755
756
    double timestep;

757
758
759
    /// Last processed time step size of finished iteration
    double lastProcessedTimestep;

760
    /// Minimal step size
761
762
    double minTimestep;

763
    /// Maximal step size
764
    double maxTimestep;
765
    
766
    /// Number of current time step
767
    int timestepNumber;
Thomas Witkowski's avatar
* Bla    
Thomas Witkowski committed
768
769
770
771
772
773
774

    /** \brief
     * Per default this value is 0 and not used. If it is set to a non-zero value,
     * the computation of the stationary problem is done nTimesteps times with a
     * fixed timestep.
     */
    int nTimesteps;
775
  
776
    /// number of iterations needed of linear or nonlinear solver
777
778
    int solverIterations;

779
    /// maximal number of iterations needed of linear or nonlinear solver
780
781
    int maxSolverIterations;

782
    ///
783
784
    double solverTolerance;

785
    ///
786
787
    double solverResidual;

788
    /// Scalar adapt infos.
Thomas Witkowski's avatar
Thomas Witkowski committed
789
    std::vector<ScalContent*> scalContents;
790

791
    /// Is true, if the adaptive procedure was deserialized from a file.
792
793
794
795
    bool deserialized;

    /// Is true, if the time adaption is controlled by a Rosenbrock Method.
    bool rosenbrockMode;
796
797
798
799
800
  };

}

#endif //  AMDIS_ADAPTINFO_H