BaseProblem.h 4.41 KB
Newer Older
1
2
3
4
5
6
7
8
/** \file BaseProblem.h */

#ifndef BASE_PROBLEM_H
#define BASE_PROBLEM_H

#include "AMDiS.h"
#include "time/RosenbrockStationary.h"
#include "CouplingTimeInterface.h"
9
#include "VtuReader.h"
10
#include "pugixml.hpp"
11
12
13
14
15
16

using namespace AMDiS;

const Flag MESH_ADOPTED = 1<<2;
const Flag DATA_ADOPTED = 1<<3;

17
template<typename ProblemType=ProblemStat, bool safeguard = false>
18
19
20
21
class BaseProblem : public ProblemIterationInterface,
		    public ProblemInstatBase
{
public:
22
  
23
  BaseProblem(const std::string &name_, bool createProblem = true);
24
25
  ~BaseProblem()
  {
26
27
    if (prob)
      delete prob;
28
  }
29
  
30
  /// Initialisation of the problem.
31
32
33
34
  void initialize(Flag initFlag,
		  ProblemStat *adoptProblem = NULL,
		  Flag adoptFlag = INIT_NOTHING);
  
35
36
37
  /// Initialisation of DOFVectors and AbstractFunctions,
  /// is called in \ref initTimeInteface after feSpace and mesh are initialized
  virtual void initData() {};
38
  
39
40
  /// calls \ref initData, \ref fillOperators and \ref fillBoundaryConditions in this ordering
  virtual void initTimeInterface()
41
  { 
42
43
44
    initData();
    fillOperators();
    fillBoundaryConditions();
45
46
  }
  
47
  /// read solution DOFVectors from .arh, .dat or .vtu files
48
  virtual Flag initDataFromFile(AdaptInfo *adaptInfo);
49
  
50
51
  /// calls \ref initDataFromFile
  virtual void solveInitialProblem(AdaptInfo *adaptInfo)
52
  { 
53
    Flag initFlag = initDataFromFile(adaptInfo);
54
  }
55
56
57

  /// calls \ref writeFiles
  virtual void transferInitialSolution(AdaptInfo *adaptInfo)
58
  { 
59
60
    oldMeshChangeIdx = getMesh()->getChangeIndex();
    writeFiles(adaptInfo, false);
61
  }
62
63

  /// This method is called before \ref beginIteration, \ref oneIteration and \ref endIteration.
64
65
  virtual void initTimestep(AdaptInfo *adaptInfo) 
  {}
66
67
68
69
70
71
72
73
74
75

  /// calls \ref writeFiles
  virtual void closeTimestep(AdaptInfo *adaptInfo);

  virtual void beginIteration(AdaptInfo *adaptInfo);
  virtual Flag oneIteration(AdaptInfo *adaptInfo, Flag toDo = FULL_ITERATION);
  virtual void endIteration(AdaptInfo *adaptInfo);

  /// Calls writeFiles of the problem
  virtual void writeFiles(AdaptInfo *adaptInfo, bool force)
76
  { 
77
    prob->writeFiles(adaptInfo, force);
78
  }
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
  
  // getting methods

  /// pointer to the solution of the problem
  SystemVector *getSolution()
  {
    return prob->getSolution();
  }

  /// pointer to the mesh of the problem
  inline Mesh* getMesh(int comp = 0) 
  {
    return prob->getMesh(comp); 
  }

  /// pointer to the feSpace of the problem
Thomas Witkowski's avatar
Thomas Witkowski committed
95
  inline const FiniteElemSpace* getFeSpace(int comp = 0) 
96
97
98
99
100
101
102
103
  {
    return prob->getFeSpace(comp); 
  }

  /// name of the baseBroblem
  std::string getName()
  {
    return name;
104
  }
105
106
107
108

  int getNumProblems() 
  {
    return 1;
109
  }
110
111
112
113
  
  int getNumComponents()
  {
    return prob->getNumComponents();
114
  }
115

116
  ProblemType *getProblem(int number = 0)
117
  {
118
    if (number < 0 || number >= getNumProblems())
119
      throw(std::runtime_error("problem with given number does not exist"));
120

121
122
    if (number == 0)
      return prob;
123
124
125

    return NULL;
  }
126
127
128
129
130
131
132

  ProblemType *getProblem(std::string name)
  {
    if (name == "prob")
      return prob;
    else
      throw(std::runtime_error("problem with given name '" + name + "' does not exist"));
133
  }
134
135
136
137
138
139
140
141
142
143
144
145
146

  // setting methods

  void setAssembleMatrixOnlyOnce_butTimestepChange(int i, int j)
  {
    fixedMatrixTimestep.push_back(std::make_pair(i,j));
  }

  void setNumberOfTimesteps(int nTimesteps_)
  {
    nTimesteps= nTimesteps_;
  }

147
148
149
150
151
  void serialize(std::ostream&) 
  {}

  void deserialize(std::istream&) 
  {}
152
153

  /// method where operators are added to the problem
154
155
  virtual void fillOperators()
  {}
156
157
  
  /// method where boundary conditions are added to the problem
158
159
  virtual void fillBoundaryConditions() 
  {}
160
161
162
163
164
165
166

  /// classical backward-euler time-discretization
  void addTimeOperator(ProblemStat *prob, int i, int j);
  
  /// for rosenbrock-problems a special time-operator can be added
  void addTimeOperator(RosenbrockStationary *prob, int i, int j);
  
167
168
169
  template<typename T>
  static void initFileWriterFromFile(AdaptInfo* adaptInfo, FileWriterTemplated<T>& fileWriter, bool keep_all = false);
  
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
protected:

  ProblemType *prob;

  /// dimension of the mesh (set in \ref initialize(...) )
  unsigned dim;
  
  /// dimension of world (set in constructur)
  unsigned dow;

  int nTimesteps;
  int oldMeshChangeIdx;

  double oldTimestep;

private:

  std::vector<std::pair<int,int> > fixedMatrixTimestep;

};

#include "BaseProblem.hh"

typedef BaseProblem<ProblemStat> StandardBaseProblem;

#endif // BASE_PROBLEM_H