• Main Page
  • Namespaces
  • Data Structures
  • Files
  • File List
  • Globals

/export/development/ViennaGrid/release/ViennaGrid-1.0.0/viennagrid/io/vtk_writer.hpp

Go to the documentation of this file.
00001 #ifndef VIENNAGRID_IO_VTK_WRITER_GUARD
00002 #define VIENNAGRID_IO_VTK_WRITER_GUARD
00003 
00004 /* =======================================================================
00005    Copyright (c) 2011, Institute for Microelectronics,
00006                        Institute for Analysis and Scientific Computing,
00007                        TU Wien.
00008 
00009                             -----------------
00010                      ViennaGrid - The Vienna Grid Library
00011                             -----------------
00012 
00013    Authors:      Karl Rupp                           rupp@iue.tuwien.ac.at
00014                  Josef Weinbub                    weinbub@iue.tuwien.ac.at
00015                
00016    (A list of additional contributors can be found in the PDF manual)
00017 
00018    License:      MIT (X11), see file LICENSE in the base directory
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 //#include "viennagrid/algorithm/cell_normals.hpp"
00032 #include "viennadata/api.hpp"
00033 
00038 namespace viennagrid
00039 {
00040   namespace io
00041   {
00042     
00044 
00045     //helper: translate element tags to VTK-element types
00046     // (see: http://www.vtk.org/VTK/img/file-formats.pdf, page 9)
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             // add 0's for less than three dimensions
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         } //writePoints()
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               //step 1: Write vertex indices in ViennaGrid orientation to array:
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               //Step 2: Write the transformed connectivities:
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))]), //convert between different orientations used within VTK and ViennaGrid
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         } //writePointDataScalar
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         } //writePointDataScalar
00226 
00227         // Write normal point data:
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         } //writePointDataScalar
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         } //writeCellDataScalar
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         } //writeCellDataVector
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                  //std::cout << "josef: " << cell_data_normal[i](*cit, seg_id) << std::endl;
00331                  //std::cout << cell_data_normal[i](*cit, seg_id) << std::endl;
00332                  //viennagrid::io::PointWriter<3>::write(writer, cell_data_normal[i](*cit, seg_id));
00333                  //viennautils::print()(cell_data_normal[i](*cit, seg_id), writer);
00334                  //viennautils::dumptype(cell_data_normal[i](*cit, seg_id));
00335                  //writer << std::endl;
00336                  writer << cell_data_normal[i](*cit, seg_id) << std::endl;
00337               }
00338               writer << "    </DataArray>" << std::endl;
00339             }
00340           }
00341         } //writeCellData
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             // Step 1: Write meta information
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("\\");   //A tribute to Windows
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             // Step 2: Write segments to individual files
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               //std::cout << "Writing segment" << std::endl;
00419               //Segment & curSeg = *segit;
00420 
00421               SegmentType const & seg = domain.segments()[i];
00422               
00423               //setting local segment numbering on vertices:
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     // Convenience functions for adding vertex-based data
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     // Convenience functions for adding cell-based data
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     // vector data
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     // cell data
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   } //namespace io
00945 } //namespace viennagrid
00946 
00947 #endif

Generated on Wed Sep 14 2011 19:21:30 for ViennaGrid by  doxygen 1.7.1