VtkWriter.cc 6.8 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

    return 0;
60
61
  }

Thomas Witkowski's avatar
Thomas Witkowski committed
62
63
64
65

  void VtkWriter::writeParallelFile(std::string name, int nRanks,
				    std::string fnPrefix, std::string fnPostfix)
  {
66
67
68
69
70
71
72
    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
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
107

    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
108
109
  int VtkWriter::updateAnimationFile(std::string valueFilename,
				     std::vector< std::string > *paraViewAnimationFrames,
110
				     std::string animationFilename)
111
112
113
114
  {
    size_t found = valueFilename.find_last_of("/\\");
    paraViewAnimationFrames->push_back(valueFilename.substr(found + 1));

115
116
117
118
119
120
121
    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)); 
122

Thomas Witkowski's avatar
Thomas Witkowski committed
123
124
125
    file << "<?xml version=\"1.0\"?>\n";
    file << "<VTKFile type=\"Collection\" version=\"0.1\" >"  << "\n";
    file << "<Collection>\n";
126
127

    int counter = 0;
Thomas Witkowski's avatar
Thomas Witkowski committed
128
    std::vector< std::string >::iterator it;
129
130
131
132
    for (it = paraViewAnimationFrames->begin(); 
	 it < paraViewAnimationFrames->end(); 
	 ++it, counter++) {
      file << "<DataSet timestep=\"" << counter
Thomas Witkowski's avatar
Thomas Witkowski committed
133
	   << "\" part=\"0\" file=\"" << (*it) << "\"/>\n";      
134
135
    }

Thomas Witkowski's avatar
Thomas Witkowski committed
136
137
    file << "</Collection>\n";
    file << "</VTKFile>\n";
138
139
140

    return 0;
  }
141

142

143
  void VtkWriter::writeFile(DOFVector<double> *values, 
144
145
			    std::string filename,
			    bool writeParallel)
146
  {
147
148
149
150
151
    FUNCNAME("VtkWriter::writeFile()");

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

155
156

  void VtkWriter::writeFile(std::vector<DOFVector<double>* > &values,
157
158
			    std::string filename,
			    bool writeParallel)
159
  {
160
161
162
163
164
165
166
167
    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];	
  }

168

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

181
182

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

195
  
196
  void VtkWriter::writeFile(SystemVector *values, 
197
198
			    std::string filename,
			    bool writeParallel)
199
  {
200
201
202
203
204
205
206
207
208
209
    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];    
  }
  
  
210
  void VtkWriter::writeFile(std::vector<DataCollector*> &dcList,
211
212
			    std::string filename,
			    bool writeParallel)
213
  {
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
    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);
  }
232
}