00001 #ifndef VIENNAGRID_IO_VTK_WRITER_GUARD
00002 #define VIENNAGRID_IO_VTK_WRITER_GUARD
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <fstream>
00023 #include <sstream>
00024 #include <iostream>
00025 #include "viennagrid/domain.hpp"
00026 #include "viennagrid/forwards.h"
00027 #include "viennagrid/iterators.hpp"
00028 #include "viennagrid/io/helper.hpp"
00029 #include "viennagrid/io/vtk_common.hpp"
00030 #include "viennagrid/io/data_accessor.hpp"
00031
00032 #include "viennadata/api.hpp"
00033
00038 namespace viennagrid
00039 {
00040 namespace io
00041 {
00042
00044
00045
00046
00047
00052 template < typename DomainType >
00053 class vtk_writer
00054 {
00055 public:
00056
00057 protected:
00058
00059 typedef typename DomainType::config_type DomainConfiguration;
00060
00061 typedef typename DomainConfiguration::numeric_type CoordType;
00062 typedef typename DomainConfiguration::coordinate_system_tag CoordinateSystemTag;
00063 typedef typename DomainConfiguration::cell_tag CellTag;
00064
00065 typedef typename result_of::point<DomainConfiguration>::type PointType;
00066 typedef typename result_of::ncell<DomainConfiguration, 0>::type VertexType;
00067 typedef typename result_of::ncell<DomainConfiguration, CellTag::dim>::type CellType;
00068
00069 protected:
00070
00072 void writeHeader(std::ofstream & writer)
00073 {
00074 writer << "<?xml version=\"1.0\"?>" << std::endl;
00075 writer << "<VTKFile type=\"UnstructuredGrid\" version=\"0.1\" byte_order=\"LittleEndian\">" << std::endl;
00076 writer << " <UnstructuredGrid>" << std::endl;
00077 }
00078
00080 template <typename SegmentType>
00081 void writePoints(SegmentType const & segment, std::ofstream & writer)
00082 {
00083 typedef typename viennagrid::result_of::const_ncell_range<SegmentType, 0>::type VertexRange;
00084 typedef typename viennagrid::result_of::iterator<VertexRange>::type VertexIterator;
00085
00086 writer << " <Points>" << std::endl;
00087 writer << " <DataArray type=\"Float32\" NumberOfComponents=\"3\" format=\"ascii\">" << std::endl;
00088
00089 VertexRange vertices = viennagrid::ncells<0>(segment);
00090 for (VertexIterator vit = vertices.begin();
00091 vit != vertices.end();
00092 ++vit)
00093 {
00094 PointWriter<CoordinateSystemTag::dim>::write(writer, vit->point());
00095
00096
00097 if (CoordinateSystemTag::dim == 2)
00098 writer << " " << 0;
00099 if(CoordinateSystemTag::dim == 1)
00100 writer << " " << 0 << " " << 0;
00101
00102 writer << std::endl;
00103 }
00104 writer << std::endl;
00105 writer << " </DataArray>" << std::endl;
00106 writer << " </Points> " << std::endl;
00107 }
00108
00110 template <typename DomainSegmentType>
00111 void writeCells(DomainSegmentType const & domseg, std::ofstream & writer)
00112 {
00113 typedef typename viennagrid::result_of::const_ncell_range<DomainSegmentType, CellTag::dim>::type CellRange;
00114 typedef typename viennagrid::result_of::iterator<CellRange>::type CellIterator;
00115
00116 typedef typename viennagrid::result_of::const_ncell_range<CellType, 0>::type VertexOnCellRange;
00117 typedef typename viennagrid::result_of::iterator<VertexOnCellRange>::type VertexOnCellIterator;
00118
00119 vtk_vertex_id_repository<DomainSegmentType> vertex_ids(domseg);
00120
00121 writer << " <Cells> " << std::endl;
00122 writer << " <DataArray type=\"Int32\" Name=\"connectivity\" format=\"ascii\">" << std::endl;
00123 CellRange cells = viennagrid::ncells<CellTag::dim>(domseg);
00124 for (CellIterator cit = cells.begin();
00125 cit != cells.end();
00126 ++cit)
00127 {
00128
00129 std::vector<VertexType const *> viennagrid_vertices(viennagrid::topology::bndcells<CellTag, 0>::num);
00130 VertexOnCellRange vertices_on_cell = viennagrid::ncells<0>(*cit);
00131 std::size_t j = 0;
00132 for (VertexOnCellIterator vocit = vertices_on_cell.begin();
00133 vocit != vertices_on_cell.end();
00134 ++vocit, ++j)
00135 {
00136 viennagrid_vertices[j] = &(*vocit);
00137 }
00138
00139
00140 viennagrid_to_vtk_orientations<CellTag> reorderer;
00141 for (std::size_t i=0; i<viennagrid_vertices.size(); ++i)
00142 {
00143 writer << vertex_ids(*(viennagrid_vertices[reorderer(static_cast<long>(i))]),
00144 domseg) << " ";
00145 }
00146
00147
00148 writer << std::endl;
00149 }
00150 writer << std::endl;
00151 writer << " </DataArray>" << std::endl;
00152
00153 writer << " <DataArray type=\"Int32\" Name=\"offsets\" format=\"ascii\">" << std::endl;
00154 for (std::size_t offsets = 1;
00155 offsets <= viennagrid::ncells<CellTag::dim>(domseg).size();
00156 ++offsets)
00157 {
00158 writer << ( offsets * viennagrid::topology::bndcells<CellTag, 0>::num) << " ";
00159 }
00160 writer << std::endl;
00161 writer << " </DataArray>" << std::endl;
00162
00163 writer << " <DataArray type=\"UInt8\" Name=\"types\" format=\"ascii\">" << std::endl;
00164 for (std::size_t offsets = 1;
00165 offsets <= viennagrid::ncells<CellTag::dim>(domseg).size();
00166 ++offsets)
00167 {
00168 writer << ELEMENT_TAG_TO_VTK_TYPE<CellTag>::value << " ";
00169 }
00170 writer << std::endl;
00171 writer << " </DataArray>" << std::endl;
00172 writer << " </Cells>" << std::endl;
00173 }
00174
00176 template <typename SegmentType>
00177 void writePointDataScalar(SegmentType const & segment, std::ofstream & writer, std::size_t seg_id = 0)
00178 {
00179 typedef typename viennagrid::result_of::const_ncell_range<SegmentType, 0>::type VertexRange;
00180 typedef typename viennagrid::result_of::iterator<VertexRange>::type VertexIterator;
00181
00182 if (vertex_data_scalar.size() > 0)
00183 {
00184 for (size_t i=0; i<vertex_data_scalar.size(); ++i)
00185 {
00186 writer << " <DataArray type=\"Float32\" Name=\"" << vertex_data_scalar_names[i] << "\" format=\"ascii\">" << std::endl;
00187
00188 VertexRange vertices = viennagrid::ncells<0>(segment);
00189 for (VertexIterator vit = vertices.begin();
00190 vit != vertices.end();
00191 ++vit)
00192 {
00193 writer << vertex_data_scalar[i](*vit, seg_id) << " ";
00194 }
00195 writer << std::endl;
00196 writer << " </DataArray>" << std::endl;
00197 }
00198 }
00199 }
00200
00202 template <typename SegmentType>
00203 void writePointDataVector(SegmentType const & segment, std::ofstream & writer, std::size_t seg_id = 0)
00204 {
00205 typedef typename viennagrid::result_of::const_ncell_range<SegmentType, 0>::type VertexRange;
00206 typedef typename viennagrid::result_of::iterator<VertexRange>::type VertexIterator;
00207
00208 if (vertex_data_vector.size() > 0)
00209 {
00210 for (size_t i=0; i<vertex_data_vector.size(); ++i)
00211 {
00212 writer << " <DataArray type=\"Float32\" Name=\"" << vertex_data_vector_names[i] << "\" NumberOfComponents=\"3\" format=\"ascii\">" << std::endl;
00213
00214 VertexRange vertices = viennagrid::ncells<0>(segment);
00215 for (VertexIterator vit = vertices.begin();
00216 vit != vertices.end();
00217 ++vit)
00218 {
00219 writer << vertex_data_vector[i](*vit, seg_id) << " ";
00220 }
00221 writer << std::endl;
00222 writer << " </DataArray>" << std::endl;
00223 }
00224 }
00225 }
00226
00227
00229 template <typename SegmentType>
00230 void writePointDataNormal(SegmentType const & segment, std::ofstream & writer, std::size_t seg_id = 0)
00231 {
00232 typedef typename viennagrid::result_of::const_ncell_range<SegmentType, 0>::type VertexRange;
00233 typedef typename viennagrid::result_of::iterator<VertexRange>::type VertexIterator;
00234
00235 if (vertex_data_normal.size() > 0)
00236 {
00237 for (size_t i=0; i<vertex_data_normal.size(); ++i)
00238 {
00239 writer << " <DataArray type=\"Float32\" Name=\"" << vertex_data_normal_names[i] << "\" NumberOfComponents=\"3\" format=\"ascii\">" << std::endl;
00240
00241 VertexRange vertices = viennagrid::ncells<0>(segment);
00242 for (VertexIterator vit = vertices.begin();
00243 vit != vertices.end();
00244 ++vit)
00245 {
00246 writer << vertex_data_normal[i](*vit, seg_id) << " ";
00247 }
00248 writer << std::endl;
00249 writer << " </DataArray>" << std::endl;
00250 }
00251 }
00252 }
00253
00254
00255
00257
00259 template <typename SegmentType>
00260 void writeCellDataScalar(SegmentType const & segment, std::ofstream & writer, std::size_t seg_id = 0)
00261 {
00262 typedef typename viennagrid::result_of::const_ncell_range<SegmentType, CellTag::dim>::type CellRange;
00263 typedef typename viennagrid::result_of::iterator<CellRange>::type CellIterator;
00264
00265 if (cell_data_scalar.size() > 0)
00266 {
00267 for (size_t i=0; i<cell_data_scalar.size(); ++i)
00268 {
00269 writer << " <DataArray type=\"Float32\" Name=\"" << cell_data_scalar_names[i] << "\" format=\"ascii\">" << std::endl;
00270
00271 CellRange cells = viennagrid::ncells(segment);
00272 for (CellIterator cit = cells.begin();
00273 cit != cells.end();
00274 ++cit)
00275 {
00276 writer << cell_data_scalar[i](*cit, seg_id) << " ";
00277 }
00278 writer << std::endl;
00279 writer << " </DataArray>" << std::endl;
00280 }
00281 }
00282 }
00283
00285 template <typename SegmentType>
00286 void writeCellDataVector(SegmentType const & segment, std::ofstream & writer, std::size_t seg_id = 0)
00287 {
00288 typedef typename viennagrid::result_of::const_ncell_range<SegmentType, CellTag::dim>::type CellRange;
00289 typedef typename viennagrid::result_of::iterator<CellRange>::type CellIterator;
00290
00291 if (cell_data_vector.size() > 0)
00292 {
00293 for (size_t i=0; i<cell_data_vector.size(); ++i)
00294 {
00295 writer << " <DataArray type=\"Float32\" Name=\"" << cell_data_vector_names[i] << "\" NumberOfComponents=\"3\" format=\"ascii\">" << std::endl;
00296
00297 CellRange cells = viennagrid::ncells(segment);
00298 for (CellIterator cit = cells.begin();
00299 cit != cells.end();
00300 ++cit)
00301 {
00302 writer << cell_data_vector[i](*cit, seg_id) << " ";
00303 }
00304 writer << std::endl;
00305 writer << " </DataArray>" << std::endl;
00306 }
00307 }
00308 }
00309
00311 template <typename SegmentType>
00312 void writeCellDataNormals(SegmentType const & segment,
00313 std::ofstream & writer,
00314 std::size_t seg_id = 0)
00315 {
00316 typedef typename viennagrid::result_of::const_ncell_range<SegmentType, CellTag::dim>::type CellRange;
00317 typedef typename viennagrid::result_of::iterator<CellRange>::type CellIterator;
00318
00319 if (cell_data_normal.size() > 0)
00320 {
00321 for (size_t i=0; i<cell_data_normal.size(); ++i)
00322 {
00323 writer << " <DataArray type=\"Float32\" Name=\"" << cell_data_normal_names[i] << "\" NumberOfComponents=\"3\" format=\"ascii\">" << std::endl;
00324
00325 CellRange cells = viennagrid::ncells<CellTag::dim>(segment);
00326 for (CellIterator cit = cells.begin();
00327 cit != cells.end();
00328 ++cit)
00329 {
00330
00331
00332
00333
00334
00335
00336 writer << cell_data_normal[i](*cit, seg_id) << std::endl;
00337 }
00338 writer << " </DataArray>" << std::endl;
00339 }
00340 }
00341 }
00342
00344 void writeFooter(std::ofstream & writer)
00345 {
00346 writer << " </UnstructuredGrid>" << std::endl;
00347 writer << "</VTKFile>" << std::endl;
00348 }
00349
00350 public:
00351
00357 int operator()(DomainType const & domain, std::string const & filename)
00358 {
00359
00360 long segment_num = domain.segments().size();
00361 if (segment_num > 0)
00362 {
00363
00364
00365
00366 {
00367 std::stringstream ss;
00368 ss << filename << "_main.pvd";
00369 std::ofstream writer(ss.str().c_str());
00370
00371 std::string short_filename = filename;
00372 std::string::size_type pos = filename.rfind("/");
00373 if (pos == std::string::npos)
00374 pos = filename.rfind("\\");
00375
00376 if (pos != std::string::npos)
00377 short_filename = filename.substr(pos+1, filename.size());
00378
00379 if (!writer){
00380 throw cannot_open_file_exception(filename);
00381 return EXIT_FAILURE;
00382 }
00383
00384 writer << "<?xml version=\"1.0\"?>" << std::endl;
00385 writer << "<VTKFile type=\"Collection\" version=\"0.1\" byte_order=\"LittleEndian\" compressor=\"vtkZLibDataCompressor\">" << std::endl;
00386 writer << "<Collection>" << std::endl;
00387
00388
00389 for (long i = 0; i<segment_num; ++i)
00390 writer << " <DataSet part=\"" << i << "\" file=\"" << short_filename << "_" << i << ".vtu\" name=\"Segment_" << i << "\"/>" << std::endl;
00391
00392
00393 writer << " </Collection>" << std::endl;
00394 writer << "</VTKFile>" << std::endl;
00395 writer.close();
00396 }
00397
00398
00399
00400
00401
00402 for (long i = 0; i<segment_num; ++i)
00403 {
00404 std::stringstream ss;
00405 ss << filename << "_" << i << ".vtu";
00406 std::ofstream writer(ss.str().c_str());
00407 writeHeader(writer);
00408
00409 if (!writer)
00410 {
00411 throw cannot_open_file_exception(ss.str());
00412 return EXIT_FAILURE;
00413 }
00414
00415 typedef typename DomainType::segment_type SegmentType;
00416 typedef typename viennagrid::result_of::const_ncell_range<SegmentType, 0>::type VertexRange;
00417 typedef typename viennagrid::result_of::iterator<VertexRange>::type VertexIterator;
00418
00419
00420
00421 SegmentType const & seg = domain.segments()[i];
00422
00423
00424 long current_id = 0;
00425 VertexRange vertices = viennagrid::ncells<0>(seg);
00426 for (VertexIterator vit = vertices.begin();
00427 vit != vertices.end();
00428 ++vit)
00429 {
00430 viennadata::access<segment_mapping_key<SegmentType>, long>(seg)(*vit) = current_id++;
00431 }
00432
00433 writer << " <Piece NumberOfPoints=\""
00434 << viennagrid::ncells<0>(seg).size()
00435 << "\" NumberOfCells=\""
00436 << viennagrid::ncells<CellTag::dim>(seg).size()
00437 << "\">" << std::endl;
00438
00439
00440 writePoints(seg, writer);
00441
00442 if (vertex_data_scalar.size() + vertex_data_vector.size() + vertex_data_normal.size() > 0)
00443 {
00444 writer << " <PointData ";
00445 if (vertex_data_scalar.size() > 0)
00446 writer << "Scalars=\"" << vertex_data_scalar_names[0] << "\" ";
00447 if (vertex_data_vector.size() > 0)
00448 writer << "Vectors=\"" << vertex_data_vector_names[0] << "\" ";
00449 if (vertex_data_normal.size() > 0)
00450 writer << "Normals=\"" << vertex_data_normal_names[0] << "\" ";
00451 writer << ">" << std::endl;
00452 writePointDataScalar(seg, writer, i);
00453 writePointDataVector(seg, writer, i);
00454 writePointDataNormal(seg, writer, i);
00455 writer << " </PointData>" << std::endl;
00456 }
00457
00458 writeCells(seg, writer);
00459 if (cell_data_scalar.size() + cell_data_vector.size() + cell_data_normal.size() > 0)
00460 {
00461 writer << " <CellData ";
00462 if (cell_data_scalar.size() > 0)
00463 writer << "Scalars=\"" << cell_data_scalar_names[0] << "\" ";
00464 if (cell_data_vector.size() > 0)
00465 writer << "Vectors=\"" << cell_data_vector_names[0] << "\" ";
00466 if (cell_data_normal.size() > 0)
00467 writer << "Normals=\"" << cell_data_normal_names[0] << "\" ";
00468 writer << ">" << std::endl;
00469 writeCellDataScalar(seg, writer, i);
00470 writeCellDataVector(seg, writer, i);
00471 writeCellDataNormals(seg, writer, i);
00472 writer << " </CellData>" << std::endl;
00473 }
00474
00475 writer << " </Piece>" << std::endl;
00476 writeFooter(writer);
00477 writer.close();
00478 }
00479 }
00480 else
00481 {
00482 std::stringstream ss;
00483 ss << filename << ".vtu";
00484 std::ofstream writer(ss.str().c_str());
00485 writeHeader(writer);
00486
00487 writer << " <Piece NumberOfPoints=\""
00488 << viennagrid::ncells<0>(domain).size()
00489 << "\" NumberOfCells=\""
00490 << viennagrid::ncells<CellTag::dim>(domain).size()
00491 << "\">" << std::endl;
00492
00493
00494 writePoints(domain, writer);
00495
00496 if (vertex_data_scalar.size() + vertex_data_vector.size() + vertex_data_normal.size() > 0)
00497 {
00498 writer << " <PointData ";
00499 if (vertex_data_scalar.size() > 0)
00500 writer << "Scalars=\"" << vertex_data_scalar_names[0] << "\" ";
00501 if (vertex_data_vector.size() > 0)
00502 writer << "Vectors=\"" << vertex_data_vector_names[0] << "\" ";
00503 if (vertex_data_normal.size() > 0)
00504 writer << "Normals=\"" << vertex_data_normal_names[0] << "\" ";
00505 writer << ">" << std::endl;
00506 writePointDataScalar(domain, writer);
00507 writePointDataVector(domain, writer);
00508 writePointDataNormal(domain, writer);
00509 writer << " </PointData>" << std::endl;
00510 }
00511
00512 writeCells(domain, writer);
00513 if (cell_data_scalar.size() + cell_data_vector.size() + cell_data_normal.size() > 0)
00514 {
00515 writer << " <CellData ";
00516 if (cell_data_scalar.size() > 0)
00517 writer << "Scalars=\"" << cell_data_scalar_names[0] << "\" ";
00518 if (cell_data_vector.size() > 0)
00519 writer << "Vectors=\"" << cell_data_vector_names[0] << "\" ";
00520 if (cell_data_normal.size() > 0)
00521 writer << "Normals=\"" << cell_data_normal_names[0] << "\" ";
00522 writer << ">" << std::endl;
00523 writeCellDataScalar(domain, writer);
00524 writeCellDataVector(domain, writer);
00525 writeCellDataNormals(domain, writer);
00526 writer << " </CellData>" << std::endl;
00527 }
00528
00529 writer << " </Piece>" << std::endl;
00530 writeFooter(writer);
00531
00532 }
00533
00534 return EXIT_SUCCESS;
00535 }
00536
00537
00544 template <typename T>
00545 void add_scalar_data_on_vertices(T const & accessor, std::string name)
00546 {
00547 data_accessor_wrapper<VertexType> wrapper(accessor.clone());
00548 vertex_data_scalar.push_back(wrapper);
00549 vertex_data_scalar_names.push_back(name);
00550 }
00551
00558 template <typename T>
00559 void add_vector_data_on_vertices(T const & accessor, std::string name)
00560 {
00561 data_accessor_wrapper<VertexType> wrapper(accessor.clone());
00562 vertex_data_vector.push_back(wrapper);
00563 vertex_data_vector_names.push_back(name);
00564 }
00565
00572 template <typename T>
00573 void add_normal_data_on_vertices(T const & accessor, std::string name)
00574 {
00575 data_accessor_wrapper<VertexType> wrapper(accessor.clone());
00576 vertex_data_normal.push_back(wrapper);
00577 vertex_data_normal_names.push_back(name);
00578 }
00579
00580
00587 template <typename T>
00588 void add_scalar_data_on_cells(T const & accessor, std::string name)
00589 {
00590 data_accessor_wrapper<CellType> wrapper(accessor.clone());
00591 cell_data_scalar.push_back(wrapper);
00592 cell_data_scalar_names.push_back(name);
00593 }
00594
00601 template <typename T>
00602 void add_vector_data_on_cells(T const & accessor, std::string name)
00603 {
00604 data_accessor_wrapper<CellType> wrapper(accessor.clone());
00605 cell_data_vector.push_back(wrapper);
00606 cell_data_vector_names.push_back(name);
00607 }
00608
00609
00616 template <typename T>
00617 void add_normal_data_on_cells(T const & accessor, std::string name)
00618 {
00619 data_accessor_wrapper<CellType> wrapper(accessor.clone());
00620 cell_data_normal.push_back(wrapper);
00621 cell_data_normal_names.push_back(name);
00622 }
00623
00624 private:
00625 std::vector< data_accessor_wrapper<VertexType> > vertex_data_scalar;
00626 std::vector< std::string > vertex_data_scalar_names;
00627
00628 std::vector< data_accessor_wrapper<VertexType> > vertex_data_vector;
00629 std::vector< std::string > vertex_data_vector_names;
00630
00631 std::vector< data_accessor_wrapper<VertexType> > vertex_data_normal;
00632 std::vector< std::string > vertex_data_normal_names;
00633
00634 std::vector< data_accessor_wrapper<CellType> > cell_data_scalar;
00635 std::vector< std::string > cell_data_scalar_names;
00636
00637 std::vector< data_accessor_wrapper<CellType> > cell_data_vector;
00638 std::vector< std::string > cell_data_vector_names;
00639
00640 std::vector< data_accessor_wrapper<CellType> > cell_data_normal;
00641 std::vector< std::string > cell_data_normal_names;
00642
00643 };
00644
00646 template < typename DomainType >
00647 int export_vtk(DomainType const& domain, std::string const & filename)
00648 {
00649 vtk_writer<DomainType> vtk_writer;
00650 return vtk_writer(domain, filename);
00651 }
00652
00653
00654
00655
00656
00657
00658
00668 template <typename KeyType, typename DataType, typename DomainType>
00669 vtk_writer<DomainType> & add_scalar_data_on_vertices(vtk_writer<DomainType> & writer,
00670 KeyType const & key,
00671 std::string quantity_name)
00672 {
00673 typedef typename DomainType::config_type DomainConfiguration;
00674 typedef typename result_of::ncell<DomainConfiguration, 0>::type VertexType;
00675
00676 data_accessor_wrapper<VertexType> wrapper(new global_scalar_data_accessor<VertexType, KeyType, DataType>(key));
00677 writer.add_scalar_data_on_vertices(wrapper, quantity_name);
00678 return writer;
00679 }
00680
00690 template <typename KeyType, typename DataType, typename DomainType>
00691 vtk_writer<DomainType> & add_scalar_data_on_vertices_per_segment(vtk_writer<DomainType> & writer,
00692 KeyType const & key,
00693 std::string quantity_name)
00694 {
00695 typedef typename DomainType::config_type DomainConfiguration;
00696 typedef typename result_of::ncell<DomainConfiguration, 0>::type VertexType;
00697
00698 data_accessor_wrapper<VertexType> wrapper(new segment_scalar_data_accessor<VertexType, KeyType, DataType>(key));
00699 writer.add_scalar_data_on_vertices(wrapper, quantity_name);
00700 return writer;
00701 }
00702
00712 template <typename KeyType, typename DataType, typename DomainType>
00713 vtk_writer<DomainType> & add_vector_data_on_vertices(vtk_writer<DomainType> & writer,
00714 KeyType const & key,
00715 std::string quantity_name)
00716 {
00717 typedef typename DomainType::config_type DomainConfiguration;
00718 typedef typename result_of::ncell<DomainConfiguration, 0>::type VertexType;
00719
00720 data_accessor_wrapper<VertexType> wrapper(new global_vector_data_accessor<VertexType, KeyType, DataType>(key));
00721 writer.add_vector_data_on_vertices(wrapper, quantity_name);
00722 return writer;
00723 }
00724
00734 template <typename KeyType, typename DataType, typename DomainType>
00735 vtk_writer<DomainType> & add_vector_data_on_vertices_per_segment(vtk_writer<DomainType> & writer,
00736 KeyType const & key,
00737 std::string quantity_name)
00738 {
00739 typedef typename DomainType::config_type DomainConfiguration;
00740 typedef typename result_of::ncell<DomainConfiguration, 0>::type VertexType;
00741
00742 data_accessor_wrapper<VertexType> wrapper(new segment_vector_data_accessor<VertexType, KeyType, DataType>(key));
00743 writer.add_vector_data_on_vertices(wrapper, quantity_name);
00744 return writer;
00745 }
00746
00747
00757 template <typename KeyType, typename DataType, typename DomainType>
00758 vtk_writer<DomainType> & add_normal_data_on_vertices(vtk_writer<DomainType> & writer,
00759 KeyType const & key,
00760 std::string quantity_name)
00761 {
00762 typedef typename DomainType::config_type DomainConfiguration;
00763 typedef typename result_of::ncell<DomainConfiguration, 0>::type VertexType;
00764
00765 data_accessor_wrapper<VertexType> wrapper(new global_vector_data_accessor<VertexType, KeyType, DataType>(key));
00766 writer.add_normal_data_on_vertices(wrapper, quantity_name);
00767 return writer;
00768 }
00769
00779 template <typename KeyType, typename DataType, typename DomainType>
00780 vtk_writer<DomainType> & add_normal_data_on_vertices_per_segment(vtk_writer<DomainType> & writer,
00781 KeyType const & key,
00782 std::string quantity_name)
00783 {
00784 typedef typename DomainType::config_type DomainConfiguration;
00785 typedef typename result_of::ncell<DomainConfiguration, 0>::type VertexType;
00786
00787 data_accessor_wrapper<VertexType> wrapper(new segment_vector_data_accessor<VertexType, KeyType, DataType>(key));
00788 writer.add_normal_data_on_vertices(wrapper, quantity_name);
00789 return writer;
00790 }
00791
00792
00793
00794
00795
00796
00797
00798
00799
00809 template <typename KeyType, typename DataType, typename DomainType>
00810 vtk_writer<DomainType> & add_scalar_data_on_cells(vtk_writer<DomainType> & writer,
00811 KeyType const & key,
00812 std::string quantity_name)
00813 {
00814 typedef typename DomainType::config_type DomainConfiguration;
00815 typedef typename DomainConfiguration::cell_tag CellTag;
00816 typedef typename result_of::ncell<DomainConfiguration, CellTag::dim>::type CellType;
00817
00818 data_accessor_wrapper<CellType> wrapper(new global_scalar_data_accessor<CellType, KeyType, DataType>(key));
00819 writer.add_scalar_data_on_cells(wrapper, quantity_name);
00820 return writer;
00821 }
00822
00832 template <typename KeyType, typename DataType, typename DomainType>
00833 vtk_writer<DomainType> & add_scalar_data_on_cells_per_segment(vtk_writer<DomainType> & writer,
00834 KeyType const & key,
00835 std::string quantity_name)
00836 {
00837 typedef typename DomainType::config_type DomainConfiguration;
00838 typedef typename DomainConfiguration::cell_tag CellTag;
00839 typedef typename result_of::ncell<DomainConfiguration, CellTag::dim>::type CellType;
00840
00841 data_accessor_wrapper<CellType> wrapper(new segment_scalar_data_accessor<CellType, KeyType, DataType>(key));
00842 writer.add_scalar_data_on_cells(wrapper, quantity_name);
00843 return writer;
00844 }
00845
00846
00856 template <typename KeyType, typename DataType, typename DomainType>
00857 vtk_writer<DomainType> & add_vector_data_on_cells(vtk_writer<DomainType> & writer,
00858 KeyType const & key,
00859 std::string quantity_name)
00860 {
00861 typedef typename DomainType::config_type DomainConfiguration;
00862 typedef typename DomainConfiguration::cell_tag CellTag;
00863 typedef typename result_of::ncell<DomainConfiguration, CellTag::dim>::type CellType;
00864
00865 data_accessor_wrapper<CellType> wrapper(new global_vector_data_accessor<CellType, KeyType, DataType>(key));
00866 writer.add_vector_data_on_cells(wrapper, quantity_name);
00867 return writer;
00868 }
00869
00879 template <typename KeyType, typename DataType, typename DomainType>
00880 vtk_writer<DomainType> & add_vector_data_on_cells_per_segment(vtk_writer<DomainType> & writer,
00881 KeyType const & key,
00882 std::string quantity_name)
00883 {
00884 typedef typename DomainType::config_type DomainConfiguration;
00885 typedef typename DomainConfiguration::cell_tag CellTag;
00886 typedef typename result_of::ncell<DomainConfiguration, CellTag::dim>::type CellType;
00887
00888 data_accessor_wrapper<CellType> wrapper(new segment_vector_data_accessor<CellType, KeyType, DataType>(key));
00889 writer.add_vector_data_on_cells(wrapper, quantity_name);
00890 return writer;
00891 }
00892
00893
00903 template <typename KeyType, typename DataType, typename DomainType>
00904 vtk_writer<DomainType> & add_normal_data_on_cells(vtk_writer<DomainType> & writer,
00905 KeyType const & key,
00906 std::string quantity_name)
00907 {
00908 typedef typename DomainType::config_type DomainConfiguration;
00909 typedef typename DomainConfiguration::cell_tag CellTag;
00910 typedef typename result_of::ncell<DomainConfiguration, CellTag::dim>::type CellType;
00911
00912 data_accessor_wrapper<CellType> wrapper(new global_vector_data_accessor<CellType, KeyType, DataType>(key));
00913 writer.add_normal_data_on_cells(wrapper, quantity_name);
00914 return writer;
00915 }
00916
00926 template <typename KeyType, typename DataType, typename DomainType>
00927 vtk_writer<DomainType> & add_normal_data_on_cells_per_segment(vtk_writer<DomainType> & writer,
00928 KeyType const & key,
00929 std::string quantity_name)
00930 {
00931 typedef typename DomainType::config_type DomainConfiguration;
00932 typedef typename DomainConfiguration::cell_tag CellTag;
00933 typedef typename result_of::ncell<DomainConfiguration, CellTag::dim>::type CellType;
00934
00935 data_accessor_wrapper<CellType> wrapper(new segment_vector_data_accessor<CellType, KeyType, DataType>(key));
00936 writer.add_normal_data_on_cells(wrapper, quantity_name);
00937 return writer;
00938 }
00939
00940
00941
00942
00943
00944 }
00945 }
00946
00947 #endif