file_io_vtu.h

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2015:  G-CSC, Goethe University Frankfurt
 * Author: Sebastian Reiter
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */
 
#ifndef __H__LIB_GRID__FILE_IO_VTU__
#define __H__LIB_GRID__FILE_IO_VTU__
 
#include <iostream>
#include <vector>
#include <utility>
#include "common/parser/rapidxml/rapidxml.hpp"
#include "lib_grid/grid/grid.h"
#include "lib_grid/multi_grid.h"
#include "lib_grid/tools/subset_handler_interface.h"
#include "lib_grid/tools/selector_interface.h"
#include "lib_grid/common_attachments.h"
#include "lib_grid/grid_objects/grid_objects.h"
#include "lib_grid/callbacks/basic_callbacks.h"
 
namespace ug
{
 
 
template <class TAPosition>
bool LoadGridFromVTU(Grid& grid, ISubsetHandler& sh,
          const char* filename, APosition& aPos);
 
 
bool LoadGridFromVTU(Grid& grid, ISubsetHandler& sh,
          const char* filename);
          
 
template <class TAPosition>
bool SaveGridToVTU(Grid& grid, ISubsetHandler* psh, const char* filename,
           TAPosition& aPos);
 
 
 
class GridWriterVTU
{
  public:
    GridWriterVTU();
 
    GridWriterVTU(std::ostream* out);
 
    virtual ~GridWriterVTU();
 
 
    void set_stream(std::ostream* out);
 
    void finish();
 
    template <class TPositionAttachment>
    bool new_piece(Grid& grid, ISubsetHandler* psh,
             TPositionAttachment& aPos);
 
 
    void add_subset_handler(ISubsetHandler& sh, const std::string& name);
 
    void begin_point_data();
    //...
    void end_point_data();
 
    void begin_cell_data();
    void end_cell_data();
 
  protected:
    typedef Grid::VertexAttachmentAccessor<AInt> AAVrtIndex;
    typedef Grid::EdgeAttachmentAccessor<AInt> AAEdgeIndex;
    typedef Grid::FaceAttachmentAccessor<AInt> AAFaceIndex;
    typedef Grid::VolumeAttachmentAccessor<AInt> AAVolIndex;
 
    inline std::ostream& out_stream();
 
    void write_data_array_header(const char* type, const char* name,
                   int numberOfComponents);
 
    void write_data_array_footer();
 
    template <class TElem, class TAttachment>
    void write_vector_data(Grid& grid,
                 TAttachment aData,
                 const char* name = "",
                 typename Grid::traits<TElem>::callback consider_elem =
                    ConsiderAll());
 
    template <class TElem>
    void collect_cells(std::vector<GridObject*>& cellsOut,
               Grid& grid,
               typename Grid::traits<TElem>::callback consider_elem =
                    ConsiderAll());
 
    void write_cells(std::vector<GridObject*>& cells, Grid& grid,
             AAVrtIndex aaInd);
 
    void end_piece();
    
 
    enum Mode{
      NONE,
      OPEN,
      CLOSED
    };
 
    std::ostream* m_pout;
    Mode      m_pieceMode;
    Mode      m_pointDataMode;
    Mode      m_cellDataMode;
 
    Grid*     m_curGrid;
    ISubsetHandler* m_curSH;
        
    std::vector<GridObject*>    m_cells;
    std::vector<std::pair<ISubsetHandler*, std::string> > m_pieceSubsetHandlers;
};
 
 
 
 
class GridReaderVTU
{
  public:
    GridReaderVTU();
    virtual ~GridReaderVTU();
 
    bool parse_file(const char* filename);
 
    size_t num_grids() const  {return m_entries.size();}
 
 
    template <class TPositionAttachment>
    bool grid(Grid& gridOut, size_t index, TPositionAttachment& aPos);
 
    const char* get_grid_name(size_t index) const;
 
    size_t num_subset_handlers(size_t refGridIndex) const;
 
    const char* get_subset_handler_name(size_t refGridIndex,
                      size_t subsetHandlerIndex) const;
 
    bool subset_handler(ISubsetHandler& shOut,
              size_t refGridIndex,
              size_t subsetHandlerIndex);
 
    static std::string const getRegionOfInterestIdentifyer()
    { return m_regionOfInterest; }
 
    static void setRegionOfInterestIdentifier( std::string const & regOfInt )
    { m_regionOfInterest = regOfInt; }
 
  protected:
    struct SubsetHandlerEntry
    {
      SubsetHandlerEntry(rapidxml::xml_node<>* n) : node(n), sh(NULL) {}
 
      rapidxml::xml_node<>*   node;
      ISubsetHandler*     sh;
    };
 
    struct GridEntry
    {
      GridEntry(rapidxml::xml_node<>* n) : node(n), grid(NULL), mg(NULL)  {}
 
      rapidxml::xml_node<>*   node;
      Grid*           grid;
      MultiGrid*        mg;
      std::vector<SubsetHandlerEntry> subsetHandlerEntries;
      std::vector<Vertex*>      vertices;
      std::vector<GridObject*>    cells;
    };
 
  protected:
 
    virtual bool new_document_parsed();
 
 
    template <class TAAPos>
    bool create_vertices(std::vector<Vertex*>& vrtsOut, Grid& grid,
              rapidxml::xml_node<>* vrtNode, TAAPos aaPos);
 
    bool create_cells(std::vector<GridObject*>& cellsOut,
              Grid& grid,
              rapidxml::xml_node<>* node,
              std::vector<Vertex*> vertices,
              size_t pieceVrtOffset);
 
    template <class T>
    void read_scalar_data(std::vector<T>& dataOut,
                rapidxml::xml_node<>* dataNode,
                bool clearData = true);
 
    void trafoDblVec2Int( std::vector<double> const & dblVec, std::vector<int> & intVec );
 
    template <class T>
    void check_indices(std::vector<T>& inds, size_t first, size_t num, size_t max);
 
    rapidxml::xml_node<>* find_child_node_by_argument_value(
                          rapidxml::xml_node<>* parent,
                          const char* nodeName,
                          const char* argName,
                          const char* argValue);
  protected:
    std::string         m_filename;
 
    rapidxml::xml_document<>  m_doc;
 
    std::vector<GridEntry>    m_entries;
 
 
 
    static std::string m_regionOfInterest; // ProMesh standard = "regions", in Braunschweig case  often "Material Id", but not always
 
};
 
}// end of namespace
 
//  include implementation
#include "file_io_vtu_impl.h"
 
#endif