VtkWriter.cc 7.03 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
//
// 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.


13
#include <stdio.h>
14
15
#include <string>
#include <fstream>
Thomas Witkowski's avatar
Thomas Witkowski committed
16
#include <sstream>
Peter Gottschling's avatar
Peter Gottschling committed
17
#include <cmath>
18
19
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/convenience.hpp>
Thomas Witkowski's avatar
Thomas Witkowski committed
20
#include <boost/lexical_cast.hpp>
21

Thomas Witkowski's avatar
Thomas Witkowski committed
22
23
24
#ifdef HAVE_PARALLEL_DOMAIN_AMDIS
#include <mpi.h>
#endif
Thomas Witkowski's avatar
Thomas Witkowski committed
25

26
27
28
29
30
31
32
33
#include "VtkWriter.h"
#include "DataCollector.h"
#include "DOFVector.h"
#include "SurfaceRegion_ED.h"
#include "ElementRegion_ED.h"

namespace AMDiS { 

Thomas Witkowski's avatar
Thomas Witkowski committed
34
  int VtkWriter::writeFile(std::string name)
35
  {
36
    FUNCNAME("VtkWriter::writeFile()");
37
    
38
39
40
41
    boost::iostreams::filtering_ostream file;
    switch (compress) {
    case GZIP:
      file.push(boost::iostreams::gzip_compressor());
42
      name.append(".gz");
43
44
45
      break;
    case BZIP2:
      file.push(boost::iostreams::bzip2_compressor());
46
      name.append(".bz2");
47
48
49
      break;
    default:
      break;
50
    }
51

52
53
    {
      std::ofstream swapfile(name.c_str(), std::ios::out | std::ios::trunc);
54
55
      TEST_EXIT(swapfile.is_open())
	("Cannot open file %s for writing!\n", name.c_str());
56
57
      swapfile.close();
    }
58

59
    file.push(boost::iostreams::file_descriptor_sink(name, std::ios::trunc));
60
    writeFileToStream(file);
61

62
    return 0;
63
64
  }

Thomas Witkowski's avatar
Thomas Witkowski committed
65
66
67
68

  void VtkWriter::writeParallelFile(std::string name, int nRanks,
				    std::string fnPrefix, std::string fnPostfix)
  {
69
70
    FUNCNAME("VtkWriter::writeParallelFile()");

71
72
73
    boost::iostreams::filtering_ostream file;
    {
      std::ofstream swapfile(name.c_str(), std::ios::out | std::ios::trunc);
74
75
      TEST_EXIT(swapfile.is_open())
	("Cannot open file %s for writing!\n", name.c_str());
76
77
78
      swapfile.close();
    }
    file.push(boost::iostreams::file_descriptor_sink(name, std::ios::trunc)); 
Thomas Witkowski's avatar
Thomas Witkowski committed
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
107
108
109
110
111
112
113

    file << "<?xml version=\"1.0\"?>\n";
    file << "<VTKFile type=\"PUnstructuredGrid\">\n";
    file << "  <PUnstructuredGrid GhostLevel=\"0\">\n";
    file << "    <PPoints>\n"
	 << "      <PDataArray type=\"Float32\" NumberOfComponents=\"3\" format=\"ascii\"/>\n"
	 << "    </PPoints>\n";
    file << "    <PCells>\n"
	 << "      <PDataArray type=\"Int32\" Name=\"offsets\"/>\n"
	 << "      <PDataArray type=\"UInt8\" Name=\"types\"/>\n"
	 << "      <PDataArray type=\"Int32\" Name=\"connectivity\"/>\n"
	 << "    </PCells>\n";
    file << "    <PPointData>\n";

    for (int i = 0; i < static_cast<int>(dataCollector->size()); i++)
      file << "      <PDataArray type=\"Float32\" Name=\"value" 
	   << i << "\" format=\"ascii\"/>\n";

    file << "    </PPointData>\n";

    for (int i = 0; i < nRanks; i++) {
      std::stringstream oss;
      oss << fnPrefix << "-p" << i << "-" << fnPostfix;
      boost::filesystem::path filepath(oss.str());
      file << "    <Piece Source=\"" 
	   << boost::filesystem::basename(filepath)
	   << boost::filesystem::extension(filepath) << "\"/>\n";
      
    }

    file << "  </PUnstructuredGrid>\n";
    file << "</VTKFile>\n";
  }


Thomas Witkowski's avatar
Thomas Witkowski committed
114
115
  int VtkWriter::updateAnimationFile(std::string valueFilename,
				     std::vector< std::string > *paraViewAnimationFrames,
116
				     std::string animationFilename)
117
  {
118
119
    FUNCNAME("VtkWriter::updateAnimationFile()");

120
121
122
    size_t found = valueFilename.find_last_of("/\\");
    paraViewAnimationFrames->push_back(valueFilename.substr(found + 1));

123
124
    boost::iostreams::filtering_ostream file;
    {
125
126
127
128
      std::ofstream swapfile(animationFilename.c_str(), 
			     std::ios::out | std::ios::trunc);
      TEST_EXIT(swapfile.is_open())
	("Cannot open file %s for writing!\n", animationFilename.c_str());
129
130
      swapfile.close();
    }
131
132
    file.push(boost::iostreams::file_descriptor_sink(animationFilename, 
						     std::ios::trunc)); 
133

Thomas Witkowski's avatar
Thomas Witkowski committed
134
135
136
    file << "<?xml version=\"1.0\"?>\n";
    file << "<VTKFile type=\"Collection\" version=\"0.1\" >"  << "\n";
    file << "<Collection>\n";
137
138

    int counter = 0;
Thomas Witkowski's avatar
Thomas Witkowski committed
139
    std::vector< std::string >::iterator it;
140
141
142
143
    for (it = paraViewAnimationFrames->begin(); 
	 it < paraViewAnimationFrames->end(); 
	 ++it, counter++) {
      file << "<DataSet timestep=\"" << counter
Thomas Witkowski's avatar
Thomas Witkowski committed
144
	   << "\" part=\"0\" file=\"" << (*it) << "\"/>\n";      
145
146
    }

Thomas Witkowski's avatar
Thomas Witkowski committed
147
148
    file << "</Collection>\n";
    file << "</VTKFile>\n";
149
150
151

    return 0;
  }
152

153

154
  void VtkWriter::writeFile(DOFVector<double> *values, 
155
156
			    std::string filename,
			    bool writeParallel)
157
  {
158
159
160
161
162
    FUNCNAME("VtkWriter::writeFile()");

    DataCollector dc(values->getFeSpace(), values);
    std::vector<DataCollector*> dcList(0);
    dcList.push_back(&dc);
163
    writeFile(dcList, filename, writeParallel);
164
165
  }

166
167

  void VtkWriter::writeFile(std::vector<DOFVector<double>* > &values,
168
169
			    std::string filename,
			    bool writeParallel)
170
  {
171
172
173
174
175
176
177
178
    std::vector<DataCollector*> dcList(0);
    for (unsigned int i = 0; i < values.size(); i++)
      dcList.push_back(new DataCollector(values[i]->getFeSpace(), values[i]));	
    writeFile(dcList, filename, writeParallel);
    for (unsigned int i = 0; i < values.size(); i++)
      delete dcList[i];	
  }

179

180
  void VtkWriter::writeFile(WorldVector<DOFVector<double>* > &values,
181
182
			    std::string filename,
			    bool writeParallel)
183
  {
184
185
186
187
188
189
190
191
    std::vector<DataCollector*> dcList(0);
    for (int i = 0; i < values.getSize(); i++)
      dcList.push_back(new DataCollector(values[i]->getFeSpace(), values[i]));	
    writeFile(dcList, filename, writeParallel);
    for (int i = 0; i < values.getSize(); i++)
      delete dcList[i];	
  }

192
193

  void VtkWriter::writeFile(DOFVector<WorldVector<double> > *values,
194
195
			    std::string filename,
			    bool writeParallel)
196
  {
197
198
199
200
201
202
203
204
    WorldVector<DOFVector<double>*> valuesWV;
    for (int i =0 ; i < valuesWV.getSize(); i++)
      valuesWV[i] = new DOFVector<double>(values->getFeSpace(), "valuesWV_i");
    transform(values, &valuesWV);
    writeFile(valuesWV, filename, writeParallel);
    for (int i = 0; i < valuesWV.getSize(); i++)
      delete valuesWV[i];
  }
205

206
  
207
  void VtkWriter::writeFile(SystemVector *values, 
208
209
			    std::string filename,
			    bool writeParallel)
210
  {
211
212
213
214
215
216
217
218
219
220
    std::vector<DataCollector*> dcList(0);
    for (int i = 0; i < values->getSize(); i++)
      dcList.push_back(new DataCollector(values->getDOFVector(i)->getFeSpace(), 
					 values->getDOFVector(i)));    
    writeFile(dcList, filename, writeParallel);
    for (unsigned i = 0; i < dcList.size(); i++)
      delete dcList[i];    
  }
  
  
221
  void VtkWriter::writeFile(std::vector<DataCollector*> &dcList,
222
223
			    std::string filename,
			    bool writeParallel)
224
  {
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
    VtkWriter writer(&dcList);
    
#ifdef HAVE_PARALLEL_DOMAIN_AMDIS
    if (writeParallel) {
      using boost::lexical_cast;
      
      int sPos = filename.find(".vtu");
      TEST_EXIT(sPos >= 0)("Failed to find file postfix!\n");
      std::string name = filename.substr(0, sPos);
      
      if (MPI::COMM_WORLD.Get_rank() == 0)
	writer.writeParallelFile(name + ".pvtu", MPI::COMM_WORLD.Get_size(), name, ".vtu");    
      
      filename = name + "-p" + lexical_cast<std::string>(MPI::COMM_WORLD.Get_rank()) + "-.vtu";
    }
#endif
    writer.writeFile(filename);
  }
243
}