ProblemStat.h 19.4 KB
Newer Older
1
2
3
4
// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
5
// ==  http://www.amdis-fem.org                                              ==
6
7
// ==                                                                        ==
// ============================================================================
8
9
10
11
12
13
14
15
16
17
18
19
//
// Software License for AMDiS
//
// Copyright (c) 2010 Dresden University of Technology 
// All rights reserved.
// Authors: Simon Vey, Thomas Witkowski et al.
//
// This file is part of AMDiS
//
// See also license.opensource.txt in the distribution.


20

21
/** \file ProblemStat.h */
22

23
24
#ifndef AMDIS_PROBLEM_STAT_H
#define AMDIS_PROBLEM_STAT_H
25

Thomas Witkowski's avatar
Thomas Witkowski committed
26
27
#include <vector>
#include <list>
28
#include "AMDiS_fwd.h"
29
#include "ProblemStatBase.h"
30
#include "Initfile.h"
31
32
33
#include "Boundary.h"
#include "MatrixVector.h"
#include "StandardProblemIteration.h"
34
#include "io/ElementFileWriter.h"
Thomas Witkowski's avatar
Thomas Witkowski committed
35
#include "ComponentTraverseInfo.h"
36
37
#include "AbstractFunction.h"
#include "SolverMatrix.h"
38
#include "SystemVector.h"
39
40
41

namespace AMDiS {

42
43
  using namespace std;

44
45
46
47
48
49
  struct OperatorPos 
  {
    int row, col;
    double *factor, *estFactor;
  };

50

51
52
53
  /// This class defines the stationary problem definition in sequential
  /// computations. For parallel computations, see 
  /// \ref ParallelProblemStatBase.
54
55
  class ProblemStatSeq : public ProblemStatBase,
			 public StandardProblemIteration
56
  {
57
  protected:
58
    // Defines a mapping type from dof indices to world coordinates.
59
    typedef map<DegreeOfFreedom, WorldVector<double> > DofToCoord;
60
61

    // Defines a mapping type from dof indices to world coordinates.
62
    typedef map<WorldVector<double>, DegreeOfFreedom> CoordToDof;
63

64
  public:
Thomas Witkowski's avatar
Thomas Witkowski committed
65
    /// Constructor
66
    ProblemStatSeq(string nameStr,
67
		   ProblemIterationInterface *problemIteration = NULL);
68

Thomas Witkowski's avatar
Thomas Witkowski committed
69
    /// Destructor
Thomas Witkowski's avatar
Thomas Witkowski committed
70
    virtual ~ProblemStatSeq();
71

Thomas Witkowski's avatar
Thomas Witkowski committed
72
    /// Initialisation of the problem.
73
    virtual void initialize(Flag initFlag,
74
			    ProblemStatSeq *adoptProblem = NULL,
75
76
			    Flag adoptFlag = INIT_NOTHING);

Thomas Witkowski's avatar
Thomas Witkowski committed
77
    /// Used in \ref initialize().
78
79
    virtual void createMesh();

80
81
82
    /// Used in \ref initialize().
    virtual void createRefCoarseManager();

Thomas Witkowski's avatar
Thomas Witkowski committed
83
    /// Used in \ref initialize().
84
    virtual void createFeSpace(DOFAdmin *admin);
85

Thomas Witkowski's avatar
Thomas Witkowski committed
86
    /// Used in \ref initialize().
87
88
    virtual void createMatricesAndVectors();

Thomas Witkowski's avatar
Thomas Witkowski committed
89
    /// Used in \ref initialize().
90
91
    virtual void createSolver();

Thomas Witkowski's avatar
Thomas Witkowski committed
92
    /// Used in \ref initialize().
93
94
    virtual void createEstimator();

Thomas Witkowski's avatar
Thomas Witkowski committed
95
    /// Used in \ref initialize().
96
97
    virtual void createMarker();

Thomas Witkowski's avatar
Thomas Witkowski committed
98
    /// Used in \ref initialize().
99
100
    virtual void createFileWriter();

101
102
    /// Used in \ref initialize(). This function is deprecated and should not 
    /// be used anymore. There is no guarantee that it will work in the future.
103
104
    virtual void doOtherStuff();

105
106
    /// Implementation of ProblemStatBase::solve(). Deligates the solving
    /// of problems system to \ref solver.
107
108
109
    void solve(AdaptInfo *adaptInfo,
	       bool createMatrixData = true,
	       bool storeMatrixData = false);
110

111
112
    /// Implementation of ProblemStatBase::estimate(). Deligates the estimation
    /// to \ref estimator.
113
114
    virtual void estimate(AdaptInfo *adaptInfo);

115
116
    /// Implementation of ProblemStatBase::markElements().
    /// Deligated to \ref adapt.
117
118
    virtual Flag markElements(AdaptInfo *adaptInfo);

119
120
    /// Implementation of ProblemStatBase::refineMesh(). Deligated to the
    /// RefinementManager of \ref adapt.
121
122
    virtual Flag refineMesh(AdaptInfo *adaptInfo);

123
124
    /// Implementation of ProblemStatBase::coarsenMesh(). Deligated to the
    /// CoarseningManager of \ref adapt.
125
126
    virtual Flag coarsenMesh(AdaptInfo *adaptInfo);

127
128
    /// Implementation of ProblemStatBase::buildBeforeRefine().
    /// Does nothing here.
Thomas Witkowski's avatar
Thomas Witkowski committed
129
    virtual void buildBeforeRefine(AdaptInfo *adaptInfo, Flag) {}
130

131
132
    /// Implementation of ProblemStatBase::buildBeforeCoarsen().
    /// Does nothing here.
Thomas Witkowski's avatar
Thomas Witkowski committed
133
    virtual void buildBeforeCoarsen(AdaptInfo *adaptInfo, Flag) {}
134

135
136
137
    /// Implementation of ProblemStatBase::buildAfterCoarsen().
    /// Assembles \ref A and \ref rhs. With the last two parameters, assembling
    /// can be restricted to matrices or vectors only.
138
139
140
    virtual void buildAfterCoarsen(AdaptInfo *adaptInfo, Flag flag,
				   bool assembleMatrix = true,
				   bool assembleVector = true);
141

142
143
    bool dualMeshTraverseRequired();

144
145
    void dualAssemble(AdaptInfo *adaptInfo, Flag flag, 
		      bool asmMatrix = true, bool asmVector = true);
146

147
148
149
    /// Determines the execution order of the single adaption steps. If adapt is
    /// true, mesh adaption will be performed. This allows to avoid mesh adaption,
    /// e.g. in timestep adaption loops of timestep adaptive strategies.
150
151
    virtual Flag oneIteration(AdaptInfo *adaptInfo, Flag toDo = FULL_ITERATION);

Thomas Witkowski's avatar
Thomas Witkowski committed
152
    /// Returns number of managed problems
153
154
    virtual int getNumProblems() 
    { 
155
      return 1; 
Thomas Witkowski's avatar
Thomas Witkowski committed
156
    }
157

Thomas Witkowski's avatar
Thomas Witkowski committed
158
    /// Implementation of ProblemStatBase::getNumComponents()
159
160
    virtual int getNumComponents() 
    { 
161
      return nComponents; 
Thomas Witkowski's avatar
Thomas Witkowski committed
162
    }
163

164
165
    /// Returns the problem with the given number. If only one problem
    /// is managed by this master problem, the number hasn't to be given.
166
167
    virtual ProblemStatBase *getProblem(int number = 0) 
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
168
      return this; 
Thomas Witkowski's avatar
Thomas Witkowski committed
169
    }
170

171
    /// Writes output files. TODO: Make obsolete.
172
173
    void writeFiles(AdaptInfo *adaptInfo, bool force);

174
175
176
    /// Writes output files.
    void writeFiles(AdaptInfo &adaptInfo, bool force);

Thomas Witkowski's avatar
Thomas Witkowski committed
177
    /// Interpolates fct to \ref solution.
178
    void interpolInitialSolution(vector<AbstractFunction<double, WorldVector<double> >*> *fct);
179

180
    /// Adds an operator to \ref A.
181
    void addMatrixOperator(Operator *op, int i, int j,
182
183
			   double *factor = NULL, double *estFactor = NULL);

184
    /// Adds an operator to \ref A.
185
186
    void addMatrixOperator(Operator &op, int i, int j,
			   double *factor = NULL, double *estFactor = NULL);
187

188
    /// Adds an operator to \ref rhs.
189
    void addVectorOperator(Operator *op, int i,
190
191
			   double *factor = NULL, double *estFactor = NULL);

192
    /// Adds an operator to \ref rhs.
193
194
    void addVectorOperator(Operator &op, int i,
			   double *factor = NULL, double *estFactor = NULL);
195

196
197
    /// Adds a Dirichlet boundary condition, where the rhs is given by an 
    /// abstract function.
198
    virtual void addDirichletBC(BoundaryType type, int row, int col,
199
200
				AbstractFunction<double, WorldVector<double> > *b);

201
202
    /// Adds a Dirichlet boundary condition, where the rhs is given by a DOF
    /// vector.
203
204
205
    virtual void addDirichletBC(BoundaryType type, int row, int col,
				DOFVector<double> *vec);

206
207
    /// Adds a Neumann boundary condition, where the rhs is given by an
    /// abstract function.
208
209
210
    virtual void addNeumannBC(BoundaryType type, int row, int col, 
			      AbstractFunction<double, WorldVector<double> > *n);

211
212
213
214
215
216
    /// Adds a Neumann boundary condition, where the rhs is given by an DOF
    /// vector.
    virtual void addNeumannBC(BoundaryType type, int row, int col, 
			      DOFVector<double> *n);

    /// Adds Robin boundary condition.
217
218
219
220
    virtual void addRobinBC(BoundaryType type, int row, int col, 
			    AbstractFunction<double, WorldVector<double> > *n,
			    AbstractFunction<double, WorldVector<double> > *r);

221
222
223
224
225
226
227
228
229
230
    /// Adds Robin boundary condition.
    virtual void addRobinBC(BoundaryType type, int row, int col, 
			    DOFVector<double> *n,
			    DOFVector<double> *r);

    /// Adds Robin boundary condition.
    virtual void addRobinBC(BoundaryType type, int row, int col, 
			    Operator *n,
			    Operator *r);

231
    /// Adds a periodic boundary condition.
232
233
    virtual void addPeriodicBC(BoundaryType type, int row, int col);

234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
    /// add boundary operator to matrix side
    virtual void addBoundaryMatrixOperator(BoundaryType type, 
          Operator *op, int row, int col);

    virtual void addBoundaryMatrixOperator(BoundaryType type, 
          Operator &op, int row, int col)
    {
      addBoundaryMatrixOperator(type, &op, row, col);
    }

    /// add boundary operator to rhs (vector) side
    virtual void addBoundaryVectorOperator(BoundaryType type, 
          Operator *op, int row);

    virtual void addBoundaryVectorOperator(BoundaryType type, 
          Operator &op, int row)
    {
      addBoundaryVectorOperator(type, &op, row);
    }

254
255
    /// This function assembles a DOFMatrix and a DOFVector for the case,
    /// the meshes from row and col FE-space are equal.
256
    void assembleOnOneMesh(const FiniteElemSpace *feSpace, 
Thomas Witkowski's avatar
Thomas Witkowski committed
257
			   Flag assembleFlag,
Thomas Witkowski's avatar
Thomas Witkowski committed
258
259
			   DOFMatrix *matrix, DOFVector<double> *vector);

Thomas Witkowski's avatar
Thomas Witkowski committed
260
261

    ///
262
263
264
265
    void assembleBoundaryConditions(DOFVector<double> *rhs,
				    DOFVector<double> *solution,
				    Mesh *mesh,
				    Flag assembleFlag);
266
267

 
268
269
270
271
    /** \name getting methods
     * \{ 
     */

Thomas Witkowski's avatar
Thomas Witkowski committed
272
    /// Returns \ref solution.
273
274
    inline SystemVector* getSolution() 
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
275
276
      return solution; 
    }
277

278
    inline DOFVector<double>* getSolution(int i)
279
280
281
282
    {
      return solution->getDOFVector(i);
    }

Thomas Witkowski's avatar
Thomas Witkowski committed
283
    /// Returns \ref rhs.
284
    inline SystemVector* getRhs() 
285
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
286
287
      return rhs; 
    }
288

289
    inline DOFVector<double>* getRhsVector(int i = 0)
290
291
292
293
    {
      return rhs->getDOFVector(i);
    }

Thomas Witkowski's avatar
Thomas Witkowski committed
294
    /// Returns \ref systemMatrix.
295
296
    inline Matrix<DOFMatrix*> *getSystemMatrix() 
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
297
298
      return systemMatrix; 
    }
299

Thomas Witkowski's avatar
Thomas Witkowski committed
300
    /// Returns a pointer to the corresponding DOFMatrix.
301
302
    inline DOFMatrix* getSystemMatrix(int row, int col) 
    {
Thomas Witkowski's avatar
Thomas Witkowski committed
303
304
305
306
      return (*systemMatrix)[row][col];
    }

    /// Returns mesh of given component
307
    inline Mesh* getMesh(int comp = 0) 
308
    {
309
      FUNCNAME("ProblemStatSeq::getMesh()");
Thomas Witkowski's avatar
Thomas Witkowski committed
310
      TEST_EXIT(comp < static_cast<int>(componentMeshes.size()) && comp >= 0)
311
	("invalid component number\n");
Thomas Witkowski's avatar
Thomas Witkowski committed
312
      return componentMeshes[comp]; 
Thomas Witkowski's avatar
Thomas Witkowski committed
313
    }
314

Thomas Witkowski's avatar
Thomas Witkowski committed
315
    /// Returns \ref meshes
316
    inline vector<Mesh*> getMeshes() 
317
    {
Thomas Witkowski's avatar
Thomas Witkowski committed
318
319
      return meshes; 
    }
320

Thomas Witkowski's avatar
Thomas Witkowski committed
321
    /// Returns \ref feSpace_.
322
    inline const FiniteElemSpace* getFeSpace(int comp = 0) 
323
    { 
324
      FUNCNAME("ProblemStatSeq::getFeSpace()");
325
      TEST_EXIT(comp < static_cast<int>(componentSpaces.size()) && comp >= 0)
326
	("invalid component number\n");
327
      return componentSpaces[comp]; 
Thomas Witkowski's avatar
Thomas Witkowski committed
328
    }
329

Thomas Witkowski's avatar
Thomas Witkowski committed
330
    /// Returns \ref feSpaces.
331
    inline vector<const FiniteElemSpace*>& getFeSpaces() 
332
    { 
333
      return feSpaces; 
Thomas Witkowski's avatar
Thomas Witkowski committed
334
    }
335

Thomas Witkowski's avatar
Thomas Witkowski committed
336
    /// Returns \ref componentSpaces;
337
    inline vector<const FiniteElemSpace*>& getComponentSpaces() 
338
    {
339
      return componentSpaces;
340
341
    }

Thomas Witkowski's avatar
Thomas Witkowski committed
342
    /// Returns \ref estimator.
343
    inline vector<Estimator*> getEstimators() 
344
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
345
346
      return estimator; 
    }
347

Thomas Witkowski's avatar
Thomas Witkowski committed
348
    /// Returns \ref estimator.
349
    inline Estimator* getEstimator(int comp = 0) 
350
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
351
352
      return estimator[comp]; 
    }
353

Thomas Witkowski's avatar
Thomas Witkowski committed
354
    /// Returns \ref refinementManager.
355
    inline RefinementManager* getRefinementManager(int comp = 0) 
356
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
357
358
      return refinementManager; 
    }
359

Thomas Witkowski's avatar
Thomas Witkowski committed
360
    /// Returns \ref refinementManager.
361
    inline CoarseningManager* getCoarseningManager(int comp = 0) 
362
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
363
364
      return coarseningManager; 
    }
365

Thomas Witkowski's avatar
Thomas Witkowski committed
366
    /// Returns \ref solver.
367
368
    inline OEMSolver* getSolver() 
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
369
370
      return solver; 
    }
371

Thomas Witkowski's avatar
Thomas Witkowski committed
372
    /// Returns \ref marker.
373
    inline Marker *getMarker(int comp = 0) 
374
    { 
375
      return marker[comp]; 
Thomas Witkowski's avatar
Thomas Witkowski committed
376
    }
377

Thomas Witkowski's avatar
Thomas Witkowski committed
378
    /// Returns \ref marker.
379
    inline vector<Marker*> getMarkers() 
380
    { 
381
      return marker; 
Thomas Witkowski's avatar
Thomas Witkowski committed
382
    }
383

Thomas Witkowski's avatar
Thomas Witkowski committed
384
    /// Returns the name of the problem
385
    inline virtual string getName() 
386
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
387
388
      return name; 
    }
389

Praetorius, Simon's avatar
Praetorius, Simon committed
390
391
392
393
394
395
396
397
    /// Returns the name of the problem
    inline string getComponentName(int comp = 0)
    {
      TEST_EXIT(comp < static_cast<int>(componentNames.size()) && comp >= 0)
	("invalid component number\n");
      return componentNames[comp];
    }

Thomas Witkowski's avatar
Thomas Witkowski committed
398
    /// Returns \ref useGetBound.
399
400
    inline bool getBoundUsed() 
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
401
402
      return useGetBound; 
    }
403

404
405
406
407
408
409
    /// Returns \ref info.
    int getInfo()
    {
      return info;
    }

410
411
412
413
414
415
    /// Returns \ref deserialized;
    bool isDeserialized()
    {
      return deserialized;
    }

416
417
418
419
420
421
    /** \} */

    /** \name setting methods
     * \{ 
     */

Thomas Witkowski's avatar
Thomas Witkowski committed
422
    /// Sets \ref estimator.
423
    inline void setEstimator(vector<Estimator*> est) 
424
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
425
426
      estimator = est; 
    }
427

Thomas Witkowski's avatar
Thomas Witkowski committed
428
    /// Sets the FE space for the given component.
429
    inline void setFeSpace(const FiniteElemSpace *feSpace, int comp = 0) 
430
    {
431
      feSpaces[comp] = feSpace;
Thomas Witkowski's avatar
Thomas Witkowski committed
432
    }
433

434
    void setComponentSpace(int comp, const FiniteElemSpace *feSpace)
435
436
437
438
439
440
441
442
443
    {
      if (static_cast<int>(componentSpaces.size()) < nComponents)
        componentSpaces.resize(nComponents);
      TEST_EXIT(comp >= 0 && comp < nComponents)
        ("Component number not in feasable range!");

      componentSpaces[comp] = feSpace;
    }
    
Thomas Witkowski's avatar
Thomas Witkowski committed
444
    /// Sets \ref estimator.
445
    inline void setEstimator(Estimator* est, int comp = 0) 
446
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
447
448
      estimator[comp] = est; 
    }
449

Thomas Witkowski's avatar
Thomas Witkowski committed
450
    /// Sets \ref marker.
451
    inline void setMarker(Marker* mark, int comp = 0) 
452
    { 
453
      marker[comp] = mark; 
Thomas Witkowski's avatar
Thomas Witkowski committed
454
    }
455

Thomas Witkowski's avatar
Thomas Witkowski committed
456
    /// Sets \ref solver.
457
458
    inline void setSolver(OEMSolver* sol) 
    { 
Thomas Witkowski's avatar
Thomas Witkowski committed
459
460
      solver = sol; 
    }
461

462
463
464
465
466
    void setSolverMatrix(SolverMatrix<Matrix<DOFMatrix*> >& solverMatrix_)
    {
      solverMatrix.setMatrix(*solverMatrix_.getOriginalMat());
    }

Thomas Witkowski's avatar
Thomas Witkowski committed
467
    ///
468
    inline void setAssembleMatrixOnlyOnce(int i = 0, int j = 0, bool value = true) 
469
    {
Thomas Witkowski's avatar
Thomas Witkowski committed
470
      assembleMatrixOnlyOnce[i][j] = value;
471
472
    }

Thomas Witkowski's avatar
Thomas Witkowski committed
473
    ///
474
    void setExactSolutionFct(AbstractFunction<double, WorldVector<double> > *fct,
475
476
			     int component) 
    {
477
478
479
      exactSolutionFcts[component] = fct;
    }

Thomas Witkowski's avatar
Thomas Witkowski committed
480
    ///
481
    AbstractFunction<double, WorldVector<double> > *getExactSolutionFct(int i = 0) 
482
    {
483
      return exactSolutionFcts[i];
484
485
    }

486
487
488
489
490
491
    ///
    vector< AbstractFunction<double, WorldVector<double> >* > getExactSolutionFcts() 
    {
      return exactSolutionFcts;
    }

Thomas Witkowski's avatar
Thomas Witkowski committed
492
    ///
493
494
    void setComputeExactError(bool v) 
    {
495
496
497
      computeExactError = v;
    }

498
499
500
501
502
503
    /// Sets \ref writeAsmInfo;
    void setWriteAsmInfo(bool b)
    {
      writeAsmInfo = b;
    }

504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
    void setMeshes(vector<Mesh*> meshes_)
    {
      meshes = meshes_;
      nMeshes = static_cast<int>(meshes.size());
    }

    void setComponentMesh(int comp, Mesh* mesh)
    {
      if (static_cast<int>(componentMeshes.size()) < nComponents)
        componentMeshes.resize(nComponents);
      TEST_EXIT(comp >= 0 && comp < nComponents)
        ("Component number not in feasable range!");

      componentMeshes[comp] = mesh;
    }

    void setRefinementManager(RefinementManager *ref)
    {
      refinementManager = ref;
    }

    void setCoarseningManager(CoarseningManager *coarse)
    {
      coarseningManager = coarse;
    }
529
530
    /** \} */

531
532
    /// Outputs the mesh of the given component, but the values are taken from
    /// the residual error estimator. 
533
    void writeResidualMesh(int comp, AdaptInfo *adaptInfo, string name);
534

Thomas Witkowski's avatar
Thomas Witkowski committed
535
    /// Function that implements the serialization procedure.
536
    virtual void serialize(ostream &out);
537

Thomas Witkowski's avatar
Thomas Witkowski committed
538
    /// Function that implements the deserialization procedure.
539
    virtual void deserialize(istream &in);
540

Thomas Witkowski's avatar
Thomas Witkowski committed
541
542

    /// Returns \ref fileWriters.
543
    vector<FileWriterInterface*>& getFileWriterList() 
544
    {
Thomas Witkowski's avatar
Thomas Witkowski committed
545
546
      return fileWriters;
    }
547

Thomas Witkowski's avatar
Thomas Witkowski committed
548
  protected:
549
550
    /// If the exact solution is known, the problem can compute the exact
    /// error instead of the error estimation. This is done in this function.
Thomas Witkowski's avatar
Thomas Witkowski committed
551
552
    void computeError(AdaptInfo *adaptInfo);

553
  protected:
Thomas Witkowski's avatar
Thomas Witkowski committed
554
555
    
    /// Name of this problem.
556
    string name;
557

Thomas Witkowski's avatar
Thomas Witkowski committed
558
    /// Number of problem components
559
    int nComponents;
560

561
562
563
564
    /// Stores the names for all components. Is used for naming the solution
    /// vectors, \ref solution.
    vector<string> componentNames;

565
566
567
    /// Number of problem meshes. If all components are defined on the same mesh,
    /// this number is 1. Otherwise, this variable is the number of different meshes
    /// within the problem.
Thomas Witkowski's avatar
Thomas Witkowski committed
568
569
570
    int nMeshes;

    /// FE spaces of this problem.
571
    vector<const FiniteElemSpace*> feSpaces;
572

Thomas Witkowski's avatar
Thomas Witkowski committed
573
    /// Meshes of this problem.
574
    vector<Mesh*> meshes;
575

Thomas Witkowski's avatar
Thomas Witkowski committed
576
    /// Pointer to the fe spaces for the different problem components
577
    vector<const FiniteElemSpace*> componentSpaces;
578

Thomas Witkowski's avatar
Thomas Witkowski committed
579
    /// Pointer to the meshes for the different problem components
580
    vector<Mesh*> componentMeshes;
581

582
583
584
    /// Stores information about which meshes must be traversed to assemble the
    /// specific components. I.e., it was implemented to make use of different
    /// meshes for different components.
Thomas Witkowski's avatar
Thomas Witkowski committed
585
586
587
    ComponentTraverseInfo traverseInfo;
    
    /// Responsible for element marking.
588
    vector<Marker*> marker;
589

Thomas Witkowski's avatar
Thomas Witkowski committed
590
    /// Estimator of this problem. Used in \ref estimate().
591
    vector<Estimator*> estimator;
592

Thomas Witkowski's avatar
Thomas Witkowski committed
593
    /// Linear solver of this problem. Used in \ref solve().
594
    OEMSolver *solver;
595

Thomas Witkowski's avatar
Thomas Witkowski committed
596
597
    /// System vector  storing the calculated solution of the problem.
    SystemVector *solution;
598

Thomas Witkowski's avatar
Thomas Witkowski committed
599
600
    /// System vector for the right hand side 
    SystemVector *rhs;
601

Thomas Witkowski's avatar
Thomas Witkowski committed
602
603
    /// System matrix
    Matrix<DOFMatrix*> *systemMatrix;
604

605
606
607
    /// Composed system matrix
    SolverMatrix<Matrix<DOFMatrix*> > solverMatrix;

608
609
610
611
612
    /// Some DOFMatrices of the systemMatrix may be assembled only once (for
    /// example if they are independent of the time or older solutions). If
    /// [i][j] of this field is set to true, the corresponding DOFMatrix will
    /// be assembled only once. All other matrices will be assembled at every
    /// time step.
613
    vector<vector<bool> > assembleMatrixOnlyOnce;
614

615
616
617
618
    /// If [i][j] of this field is set to true, the corresponding DOFMatrix of
    /// the systemMatrix has been assembled at least once. This field is used
    /// to determine, if assembling of a matrix can be ommitted, if it is set
    /// to be assembled only once.
619
    vector<vector<bool> > assembledMatrix;
620

Thomas Witkowski's avatar
Thomas Witkowski committed
621
622
    /// Determines whether domain boundaries should be considered at assembling.
    bool useGetBound;
623

Thomas Witkowski's avatar
Thomas Witkowski committed
624
    /// Writes the meshes and solution after the adaption loop.
625
    vector<FileWriterInterface*> fileWriters;
626

627
628
629
    /// All actions of mesh refinement are performed by refinementManager.
    /// If new refinement algorithms should be realized, one has to override
    /// RefinementManager and give one instance of it to AdaptStationary.
Thomas Witkowski's avatar
Thomas Witkowski committed
630
    RefinementManager *refinementManager;
631

632
633
634
    /// All actions of mesh coarsening are performed by coarseningManager.
    /// If new coarsening algorithms should be realized, one has to override
    /// CoarseningManager and give one instance of it to AdaptStationary.
Thomas Witkowski's avatar
Thomas Witkowski committed
635
    CoarseningManager *coarseningManager;
636
  
Thomas Witkowski's avatar
Thomas Witkowski committed
637
638
    /// Info level.
    int info;
639

640
641
    /// If true, the stationary problem was deserialized from some serialization
    /// file.
642
643
    bool deserialized;

644
645
646
    /// This vectors stores pointers to functions defining the exact solution of
    /// the problem. This may be used to compute the real error of the computed
    /// solution.
647
    vector<AbstractFunction<double, WorldVector<double> >*> exactSolutionFcts;
648

649
650
    /// If true, the error is not estimated but computed from the exact solution
    /// defined by \ref exactSolutionFcts.
651
    bool computeExactError;
652
    
653
654
655
656
    /// If at least on boundary condition is set, this variable is true. It is 
    /// used to ensure that no operators are added after boundary condition were
    /// set. If this would happen, boundary conditions could set wrong on off 
    /// diagonal matrices.
657
    bool boundaryConditionSet;
658

659
660
    /// If true, AMDiS prints information about the assembling procedure to 
    /// the screen.
661
    bool writeAsmInfo;
662

663
    map<Operator*, vector<OperatorPos> > operators;
664
  };
665
666
667
668

#ifndef HAVE_PARALLEL_DOMAIN_AMDIS
  typedef ProblemStatSeq ProblemStat;
#endif
669
670
671
}

#endif