parser.hh

// SPDX-FileCopyrightText: Copyright (C) DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_DGF_DUNEGRIDFORMATPARSER_HH
#define DUNE_DGF_DUNEGRIDFORMATPARSER_HH
 
#include <iostream>
#include <string>
#include <vector>
#include <map>
 
#include <dune/grid/io/file/dgfparser/entitykey.hh>
 
namespace Dune
{
 
  class DGFPrintInfo;
 
  struct DGFBoundaryParameter
  {
    typedef std::string type;
 
    static const type &defaultValue ()
    {
      static type value;
      return value;
    }
 
    static type convert ( const std::string & parameter )
    {
      return parameter;
    }
 
    static const char delimiter = ':';
  };
 
  class DuneGridFormatParser
  {
  public:
    typedef enum {Simplex,Cube,General} element_t;
 
    typedef enum {counterclockwise=1,clockwise=-1} orientation_t;
 
    DuneGridFormatParser ( int rank, int size );
 
    static bool isDuneGridFormat ( std::istream &input );
 
    static bool isDuneGridFormat ( const std::string &filename );
 
    bool readDuneGrid( std::istream &input, int dimG, int dimW );
 
    void writeTetgenPoly ( const std::string &, std::string &, std::string & );
 
    void writeTetgenPoly ( std::ostream & out, const bool writeSegments = true );
 
  protected:
    void generateBoundaries ( std::istream &, bool );
 
    // call to tetgen/triangle
    void generateSimplexGrid ( std::istream & );
    void readTetgenTriangle ( const std::string & );
 
    // helper methods
    void removeCopies ();
 
    void setOrientation ( int use1, int use2,
                          orientation_t orientation=counterclockwise );
 
    void setRefinement ( int use1, int use2, int is1=-1, int is2=-1 );
 
    double testTriang ( int snr );
 
    std::vector< double > & getElParam ( int i, std::vector< double > & coord );
 
    std::vector< double > & getVtxParam ( int i, std::vector< double > & coord );
 
    static std::string temporaryFileName ();
 
    // dimension of world and problem: set through the readDuneGrid() method
    int dimw, dimgrid;
 
    // vector of vertex coordinates
    std::vector < std::vector < double > > vtx;
 
    int nofvtx;
 
    int vtxoffset;
 
    double minVertexDistance; // min. L^1 distance of distinct points
 
    // vector of elements
    std :: vector< std :: vector< unsigned int > > elements;
 
    int nofelements;
 
    // vector of boundary segments + identifier
    std::vector < std::vector < int > > bound;
 
    int nofbound;
 
    // map to generate and find boundary segments
    typedef DGFBoundaryParameter::type BoundaryParameter;
    typedef std::pair < int, BoundaryParameter > BndParam;
    typedef std::map< DGFEntityKey< unsigned int >, BndParam > facemap_t;
    facemap_t facemap;
 
    // true if parameters on a boundary found
    bool haveBndParameters;
 
    // set by generator depending on element type wanted
    element_t element;
 
    // set by the readDuneGrid method depending
    // on what type the elements were generated
    bool simplexgrid;
 
    // true if grid is generated using the intervall Block
    bool cube2simplex;
 
    // parameters on elements
    int nofvtxparams,nofelparams;
 
    std::vector< std::vector< double > > vtxParams,elParams;
 
    // write information about generation process
    DGFPrintInfo * info;
 
    std::vector < double > emptyParam_;
 
 
  private:
    int rank_;
    int size_;
 
    template< class GridType >
    friend struct DGFGridFactory;
 
    template< class GridType >
    friend struct DGFBaseFactory;
 
  };
 
} // end namespace Dune
 
#endif