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

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

Go to the documentation of this file.
00001 #ifndef VIENNAGRID_IO_NETGEN_READER_GUARD
00002 #define VIENNAGRID_IO_NETGEN_READER_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 <iostream>
00024 #include <assert.h>
00025 #include "viennagrid/forwards.h"
00026 #include "viennagrid/io/helper.hpp"
00027 #include "viennagrid/iterators.hpp"
00028 
00033 namespace viennagrid
00034 {
00035   namespace io
00036   {
00037 
00039     struct netgen_reader
00040     {
00046       template <typename DomainType>
00047       int operator()(DomainType & domain, std::string const & filename) const
00048       {
00049         typedef typename DomainType::config_type                         ConfigType;
00050 
00051         typedef typename ConfigType::numeric_type                        CoordType;
00052         typedef typename ConfigType::coordinate_system_tag               CoordinateSystemTag;
00053         typedef typename ConfigType::cell_tag                            CellTag;
00054 
00055         typedef typename result_of::point<ConfigType>::type                              PointType;
00056         typedef typename result_of::ncell<ConfigType, 0>::type                           VertexType;
00057         typedef typename result_of::ncell<ConfigType, CellTag::dim>::type     CellType;
00058 
00059         typedef typename viennagrid::result_of::ncell_range<DomainType, 0>::type   VertexRange;
00060         typedef typename viennagrid::result_of::iterator<VertexRange>::type        VertexIterator;
00061             
00062         typedef typename viennagrid::result_of::ncell_range<DomainType, 1>::type   EdgeRange;
00063         typedef typename viennagrid::result_of::iterator<EdgeRange>::type          EdgeIterator;
00064 
00065         typedef typename viennagrid::result_of::ncell_range<DomainType, CellTag::dim-1>::type   FacetRange;
00066         typedef typename viennagrid::result_of::iterator<FacetRange>::type                                 FacetIterator;
00067 
00068         typedef typename viennagrid::result_of::ncell_range<DomainType, CellTag::dim>::type     CellRange;
00069         typedef typename viennagrid::result_of::iterator<CellRange>::type                                  CellIterator;
00070         
00071         std::ifstream reader(filename.c_str());
00072         
00073         typedef typename DomainType::segment_container      SegmentContainer;
00074 
00075         //Segment & segment = *(domain.begin());
00076         SegmentContainer & segments = domain.segments();
00077 
00078         #if defined VIENNAGRID_DEBUG_STATUS || defined VIENNAGRID_DEBUG_IO
00079         std::cout << "* netgen_reader::operator(): Reading file " << filename << std::endl;
00080         #endif
00081 
00082         if (!reader)
00083         {
00084           throw cannot_open_file_exception(filename);
00085           return EXIT_FAILURE;
00086         }
00087 
00088         std::string token;
00089         long node_num = 0;
00090         long cell_num = 0;
00091       
00092         if (!reader.good())
00093           throw bad_file_format_exception(filename, "File is empty.");
00094         
00095         //
00096         // Read vertices:
00097         //
00098         reader >> node_num;
00099         assert(node_num > 0);
00100         
00101         #if defined VIENNAGRID_DEBUG_STATUS || defined VIENNAGRID_DEBUG_IO
00102         std::cout << "* netgen_reader::operator(): Reading " << node_num << " vertices... " << std::endl;  
00103         #endif
00104 
00105         VertexType vertex;
00106     
00107         for (int i=0; i<node_num; i++)
00108         {
00109           if (!reader.good())
00110             throw bad_file_format_exception(filename, "EOF encountered while reading vertices.");
00111           
00112           for (int j=0; j<CoordinateSystemTag::dim; j++)
00113             reader >> vertex.point()[j];
00114           
00115           vertex.id(i);
00116           domain.push_back(vertex);
00117         }
00118     
00119         //std::cout << "DONE" << std::endl;
00120         if (!reader.good())
00121           throw bad_file_format_exception(filename, "EOF encountered when reading number of cells.");
00122           
00123 
00124         //
00125         // Read cells:
00126         //
00127         reader >> cell_num;
00128         //domain.reserve_cells(cell_num);
00129         
00130         #if defined VIENNAGRID_DEBUG_STATUS || defined VIENNAGRID_DEBUG_IO
00131         std::cout << "* netgen_reader::operator(): Reading " << cell_num << " cells... " << std::endl;  
00132         #endif
00133         
00134         CellType cell;
00135         //std::cout << "Filling " << cell_num << " cells:" << std::endl;
00136     
00137         for (int i=0; i<cell_num; ++i)
00138         {
00139           long vertex_num;
00140           VertexType *vertices[topology::bndcells<CellTag, 0>::num];
00141 
00142           if (!reader.good())
00143             throw bad_file_format_exception(filename, "EOF encountered while reading cells (segment index expected).");
00144           
00145           std::size_t segment_index;
00146           reader >> segment_index;
00147     
00148           for (int j=0; j<topology::bndcells<CellTag, 0>::num; ++j)
00149           {
00150             if (!reader.good())
00151               throw bad_file_format_exception(filename, "EOF encountered while reading cells (cell ID expected).");
00152             
00153             reader >> vertex_num;
00154             vertices[j] = &(viennagrid::ncells<0>(domain)[vertex_num - 1]);  //Note that Netgen uses vertex indices with base 1
00155           }
00156     
00157           //std::cout << std::endl << "Adding cell: " << &cell << " at " << i << std::endl;
00158           cell.vertices(&(vertices[0]));
00159           cell.id(i);
00160           if (segments.size() < segment_index) //not that segment_index is 1-based
00161             segments.resize(segment_index);
00162           
00163           segments[segment_index - 1].push_back(cell);  //note that Netgen uses a 1-based indexing scheme, while ViennaGrid uses a zero-based one
00164     
00165           //progress info:
00166           //if (i % 50000 == 0 && i > 0)
00167           //  std::cout << "* netgen_reader::operator(): " << i << " out of " << cell_num << " cells read." << std::endl;
00168         }
00169         
00170         //std::cout << "All done!" << std::endl;
00171         
00172         return EXIT_SUCCESS;
00173       } //operator()
00174       
00175     }; //class netgen_reader
00176   
00177   } //namespace io
00178 } //namespace viennagrid
00179 
00180 #endif

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