VtkWriter.cc 7 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
54
55
56
    }
    {
      //boost::iostreams seems not to truncate the file
      std::ofstream swapfile(name.c_str(), std::ios::out | std::ios::trunc);
      swapfile.close();
    }
    file.push(boost::iostreams::file_descriptor_sink(name, std::ios::trunc)); 
57
    writeFileToStream(file);
58

59
60
61
62
63
64
65
66
67
68
#if 0

    std::ofstream file;
    file.open(name.c_str());
    TEST_EXIT(file.is_open())("Cannot open file %s for writing\n", name.c_str());
    writeFileToStream(file);    
    file.close();

#endif
      
69
    return 0;
70
71
  }

Thomas Witkowski's avatar
Thomas Witkowski committed
72
73
74
75

  void VtkWriter::writeParallelFile(std::string name, int nRanks,
				    std::string fnPrefix, std::string fnPostfix)
  {
76
77
78
79
80
81
82
    boost::iostreams::filtering_ostream file;
    {
      //boost::iostreams seems not to truncate the file
      std::ofstream swapfile(name.c_str(), std::ios::out | std::ios::trunc);
      swapfile.close();
    }
    file.push(boost::iostreams::file_descriptor_sink(name, std::ios::trunc)); 
Thomas Witkowski's avatar
Thomas Witkowski committed
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
114
115
116
117

    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
118
119
  int VtkWriter::updateAnimationFile(std::string valueFilename,
				     std::vector< std::string > *paraViewAnimationFrames,
120
				     std::string animationFilename)
121
122
123
124
  {
    size_t found = valueFilename.find_last_of("/\\");
    paraViewAnimationFrames->push_back(valueFilename.substr(found + 1));

125
126
127
128
129
130
131
    boost::iostreams::filtering_ostream file;
    {
      //boost::iostreams seems not to truncate the file
      std::ofstream swapfile(animationFilename.c_str(), std::ios::out | std::ios::trunc);
      swapfile.close();
    }
    file.push(boost::iostreams::file_descriptor_sink(animationFilename, std::ios::trunc)); 
132

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

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

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

    return 0;
  }
151

152

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

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

165
166

  void VtkWriter::writeFile(std::vector<DOFVector<double>* > &values,
167
168
			    std::string filename,
			    bool writeParallel)
169
  {
170
171
172
173
174
175
176
177
    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];	
  }

178

179
  void VtkWriter::writeFile(WorldVector<DOFVector<double>* > &values,
180
181
			    std::string filename,
			    bool writeParallel)
182
  {
183
184
185
186
187
188
189
190
    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];	
  }

191
192

  void VtkWriter::writeFile(DOFVector<WorldVector<double> > *values,
193
194
			    std::string filename,
			    bool writeParallel)
195
  {
196
197
198
199
200
201
202
203
    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];
  }
204

205
  
206
  void VtkWriter::writeFile(SystemVector *values, 
207
208
			    std::string filename,
			    bool writeParallel)
209
  {
210
211
212
213
214
215
216
217
218
219
    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];    
  }
  
  
220
  void VtkWriter::writeFile(std::vector<DataCollector*> &dcList,
221
222
			    std::string filename,
			    bool writeParallel)
223
  {
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
    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);
  }
242
}