FileWriter.cc 7.9 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
#include "FileWriter.h"
#include "SystemVector.h"
#include "Parameters.h"
#include "TecPlotWriter.h"
#include "ValueWriter.h"
#include "MacroWriter.h"
#include "VtkWriter.h"
#include "FiniteElemSpace.h"
#include "AdaptInfo.h"
#include "Flag.h"
#include "ElInfo.h"
#include "Mesh.h"
13
#include "OpenMP.h"
14
15
16

namespace AMDiS {

17
  FileWriter::FileWriter(const std::string &name_, 
18
19
20
21
22
			 Mesh *mesh_,
			 DOFVector<double> *vec)
    : name(name_),
      mesh(mesh_)
  {
23
24
25
    FUNCNAME("FileWriter::FileWriter()");

    initialize();
26
27
28
29
30
31
32

    feSpace = vec->getFESpace();

    solutionVecs_.resize(1);
    solutionVecs_[0] = vec;
  }

33

34
  FileWriter::FileWriter(const std::string &name_, 
35
			 Mesh *mesh_,
36
			 std::vector< DOFVector<double>* > vecs)
37
38
39
40
41
    : name(name_),
      mesh(mesh_)
  {
    FUNCNAME("FileWriter::FileWriter()");

42
    initialize();
43
44
45
46
47
48
49
50
51
52

    for (int i = 0; i < static_cast<int>(vecs.size()); i++) {
      TEST_EXIT(vecs[0]->getFESpace() == vecs[i]->getFESpace())
	("All FESpace have to be equal!\n");
    }

    feSpace = vecs[0]->getFESpace();
    solutionVecs_ = vecs;
  }

53

54
  FileWriter::FileWriter(const std::string &name_, 
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
			 Mesh *mesh_,
			 DOFVector< WorldVector<double> > *vec)
    : name(name_),
      mesh(mesh_)
  {
    FUNCNAME("FileWriter::FileWriter()");

    initialize();
    
    // Create the temporal DOFVectors for all components of WorldVector.
    nTmpSolutions_ = (*vec)[0].getSize();
    solutionVecs_.resize(nTmpSolutions_);
    for (int i = 0; i < nTmpSolutions_; i++) {
      solutionVecs_[i] = NEW DOFVector<double>(vec->getFESpace(), "");
    } 

    // Copy the components of the WorldVectors to different DOFVectors
    // of double values.
    DOFVector< WorldVector<double> >::Iterator it(vec, USED_DOFS);
    int counter = 0;
    for (it.reset(); !it.end(); ++it, counter++) {
      for (int i = 0; i < nTmpSolutions_; i++) {
	(*solutionVecs_[i])[counter] = (*it)[i];
      }
    }

    feSpace = vec->getFESpace();
  }


  FileWriter::~FileWriter()
  {
    // Do not forget to delete temporal solution vector, if there have been
    // some created in the constructor.
    if (nTmpSolutions_ > 0) {
      for (int i = 0; i < nTmpSolutions_; i++) {
        DELETE solutionVecs_[i]; 
      }
    }
  }
  

  void FileWriter::initialize()
  {
    tecplotExt = ".tec";
    amdisMeshExt = ".mesh";
    amdisDataExt = ".dat";
    paraViewFileExt = ".vtu";
    periodicFileExt = ".per";
    writeTecPlotFormat = 0;
    writeAMDiSFormat = 0;
    writeParaViewFormat = 0;
107
    writeParaViewAnimation = 0;
108
109
110
111
112
113
    writePeriodicFormat = 0;
    appendIndex = 0;
    indexLength = 5;
    indexDecimals = 3;
    tsModulo = 1;
    nTmpSolutions_ = 0;
Thomas Witkowski's avatar
Thomas Witkowski committed
114
115
116
    delayWriting_ = 0;
    writingIsDelayed_ = false;
    delayedFilename_ = "";
117
    paraViewAnimationFrames_.resize(0);
118
    compression = NONE;
119
120

    readParameters();
121
122
  }

123
124
125
126
127
128
129
130
131
132
133
  void FileWriter::readParameters()
  {
    FUNCNAME("FileWriter::readParamters()");

    GET_PARAMETER(0, name + "->filename", &filename);
    GET_PARAMETER(0, name + "->TecPlot format", "%d", &writeTecPlotFormat);
    GET_PARAMETER(0, name + "->TecPlot ext", &tecplotExt);
    GET_PARAMETER(0, name + "->AMDiS format", "%d", &writeAMDiSFormat);
    GET_PARAMETER(0, name + "->AMDiS mesh ext", &amdisMeshExt);
    GET_PARAMETER(0, name + "->AMDiS data ext", &amdisDataExt);
    GET_PARAMETER(0, name + "->ParaView format", "%d", &writeParaViewFormat);
134
135
    GET_PARAMETER(0, name + "->ParaView animation", "%d", &writeParaViewAnimation);
    GET_PARAMETER(0, name + "->ParaView ext", &paraViewFileExt);    
136
137
138
139
140
141
    GET_PARAMETER(0, name + "->Periodic format", "%d", &writePeriodicFormat);
    GET_PARAMETER(0, name + "->Periodic ext", &periodicFileExt);
    GET_PARAMETER(0, name + "->append index", "%d", &appendIndex);
    GET_PARAMETER(0, name + "->index length", "%d", &indexLength);
    GET_PARAMETER(0, name + "->index decimals", "%d", &indexDecimals);
    GET_PARAMETER(0, name + "->write every i-th timestep", "%d", &tsModulo);
Thomas Witkowski's avatar
Thomas Witkowski committed
142
    GET_PARAMETER(0, name + "->delay", "%d", &delayWriting_);
143

144
145
146
147
148
149
150
151
    std::string compressionStr = "";
    GET_PARAMETER(0, name + "->compression", &compressionStr);
    if ((compressionStr == "gzip") || (compressionStr == "gz")) {
      compression = GZIP;
    } else if ((compressionStr == "bzip2") || (compressionStr == "bz2")) {
      compression = BZIP2;
    }

152
153
    TEST_EXIT(!delayWriting_ || amdisHaveOpenMP)
      ("Delayed writing only possible with OpenMP support!\n");
154
155
156
157
158
159
160
161
162
  }

  void FileWriter::writeFiles(AdaptInfo *adaptInfo,
			      bool force,
			      int level,
			      Flag flag,
			      bool (*writeElem)(ElInfo*))
  {
    FUNCNAME("FileWriter::writeFiles()");
Thomas Witkowski's avatar
Thomas Witkowski committed
163
    
164
165
166
    if ((adaptInfo->getTimestepNumber() % tsModulo != 0) && !force) 
      return;

Thomas Witkowski's avatar
Thomas Witkowski committed
167
168
169
170
    if (writingIsDelayed_) {
      ERROR_EXIT("This should not happen!\n");
    }

171
172
173
    // Containers, which store the data to be written;
    std::vector< DataCollector* > dataCollectors(solutionVecs_.size());

Thomas Witkowski's avatar
Thomas Witkowski committed
174
    if (writeElem) {
175
176
177
      for (int i = 0; i < static_cast<int>(dataCollectors.size()); i++) {
	dataCollectors[i] = NEW DataCollector(feSpace, solutionVecs_[i], 
					      level, flag, writeElem);
Thomas Witkowski's avatar
Thomas Witkowski committed
178
179
      }
    } else {
180
181
182
      for (int i = 0; i < static_cast<int>(dataCollectors.size()); i++) {
	dataCollectors[i] = NEW DataCollector(feSpace, solutionVecs_[i], 
					      traverseLevel, flag | traverseFlag, writeElement);
Thomas Witkowski's avatar
Thomas Witkowski committed
183
184
185
      }
    }

186
    std::string fn = filename;
187
188
189
190
191
192
193
194
195

    if (appendIndex) {
      TEST_EXIT(indexLength <= 99)("index lenght > 99\n");
      TEST_EXIT(indexDecimals <= 97)("index decimals > 97\n");
      TEST_EXIT(indexDecimals < indexLength)("index length <= index decimals\n");
    
      char formatStr[9];
      char timeStr[20];

Thomas Witkowski's avatar
Thomas Witkowski committed
196
      sprintf(formatStr, "%%0%d.%df", indexLength, indexDecimals);
197
198
199
200
201
202
      sprintf(timeStr, formatStr, adaptInfo ? adaptInfo->getTime() : 0.0);

      fn += timeStr;
    }


Thomas Witkowski's avatar
Thomas Witkowski committed
203
204
205
    if (delayWriting_) {
      if (writeTecPlotFormat || writeAMDiSFormat || writePeriodicFormat) {
	ERROR_EXIT("Delay writing only supported for ParaView file format!\n");
206
      }
Thomas Witkowski's avatar
Thomas Witkowski committed
207

208
209
      for (int i = 0; i < static_cast<int>(dataCollectors.size()); i++) {
	dataCollectors[i]->fillAllData();
210
211
      }

Thomas Witkowski's avatar
Thomas Witkowski committed
212
213
      writingIsDelayed_ = true;
      delayedFilename_ = fn;
Thomas Witkowski's avatar
Thomas Witkowski committed
214
215
216
      
      MSG("Delayed writing of ParaView file %s\n", (fn + paraViewFileExt).c_str());

Thomas Witkowski's avatar
Thomas Witkowski committed
217
218
219
      return;
    }
 
220
221
222
223
224
225
226
227
228
229
    if (writeTecPlotFormat) {
      TecPlotWriter<DOFVector<double> >::writeValues(solutionVecs_[0], 
						     const_cast<char*>((fn + tecplotExt).c_str()), 
						     solutionVecs_[0]->getName().c_str());
      MSG("TecPlot file written to %s\n", (fn + tecplotExt).c_str());
    }

    if (writeAMDiSFormat) {
      TEST_EXIT(mesh)("no mesh\n");

230
      MacroWriter::writeMacro(dataCollectors[0], 
Thomas Witkowski's avatar
Thomas Witkowski committed
231
			     const_cast<char*>((fn +  amdisMeshExt).c_str()), 
232
233
234
235
			     adaptInfo ? adaptInfo->getTime() : 0.0);
      MSG("macro file written to %s\n", (fn + amdisMeshExt).c_str());


236
      ValueWriter::writeValues(dataCollectors[0],
237
238
239
240
241
242
			       (fn + amdisDataExt).c_str(),
			       adaptInfo ? adaptInfo->getTime() : 0.0);
      MSG("value file written to %s\n", (fn + amdisDataExt).c_str());   
    }

    if (writePeriodicFormat) {
243
      MacroWriter::writePeriodicFile(dataCollectors[0], 
244
245
246
247
248
				     (fn + periodicFileExt).c_str());
      MSG("periodic file written to %s\n", (fn + periodicFileExt).c_str());
    }
    
    if (writeParaViewFormat) {
249
      VtkWriter vtkWriter(&dataCollectors);     
250
251
      vtkWriter.setCompression(compression);
      vtkWriter.writeFile(const_cast<char*>((fn + paraViewFileExt).c_str()));      
Thomas Witkowski's avatar
Thomas Witkowski committed
252

253
254
255
      MSG("ParaView file written to %s\n", (fn + paraViewFileExt).c_str());
    }

256
    if (writeParaViewAnimation) {
257
      VtkWriter vtkWriter(&dataCollectors);
258
259
      vtkWriter.updateAnimationFile(fn + paraViewFileExt, 
				    &paraViewAnimationFrames_, 
Thomas Witkowski's avatar
Thomas Witkowski committed
260
				    const_cast<char*>((filename + ".pvd").c_str()));
261
    }
262
    
263

264
265
    for (int i = 0; i < static_cast<int>(dataCollectors.size()); i++) {
      DELETE dataCollectors[i];
Thomas Witkowski's avatar
Thomas Witkowski committed
266
267
268
269
270
    }
  }

  void FileWriter::writeDelayedFiles()
  {
271
    ERROR_EXIT("no more!\n");
272
273
  }
}