dune-grid  2.6-git
dgfug.hh
Go to the documentation of this file.
1 // -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 // vi: set et ts=4 sw=2 sts=2:
3 #ifndef DUNE_GRID_IO_FILE_DGFPARSER_DGFUG_HH
4 #define DUNE_GRID_IO_FILE_DGFPARSER_DGFUG_HH
5 
6 //- C++ includes
7 #include <fstream>
8 #include <istream>
9 #include <string>
10 #include <vector>
11 
12 //- dune-common includes
13 #include <dune/common/exceptions.hh>
14 #include <dune/common/fvector.hh>
15 #include <dune/common/parallel/mpihelper.hh>
16 
17 //- dune-grid includes
19 #include <dune/grid/uggrid.hh>
20 
21 //- local includes
22 #include "dgfparser.hh"
23 #include "blocks/gridparameter.hh"
24 
25 
26 namespace Dune
27 {
28 
29  namespace dgf
30  {
31 
32  // UGGridParameterBlock
33  // --------------------
34 
36  : public GridParameterBlock
37  {
39  explicit UGGridParameterBlock ( std::istream &input );
40 
42  bool noClosure () const { return noClosure_; }
44  bool noCopy () const { return noCopy_; }
46  size_t heapSize () const { return heapSize_; }
47 
48  protected:
49  bool noClosure_; // no closure for UGGrid
50  bool noCopy_; // no copies for UGGrid
51  size_t heapSize_; // heap size for UGGrid
52  };
53 
54  } // namespace dgf
55 
56 
57 
58 #if ENABLE_UG
59  template< int dim >
60  struct DGFGridInfo< UGGrid< dim > >
61  {
62  static int refineStepsForHalf ()
63  {
64  return 1;
65  }
66 
67  static double refineWeight ()
68  {
69  return -1.;
70  }
71  };
72 
73 
74 
75  // DGFGridFactory< UGGrid< dim > >
76  // -------------------------------
77 
78  template< int dim >
79  struct DGFGridFactory< UGGrid< dim > >
80  {
82  typedef UGGrid< dim > Grid;
84  static const int dimension = dim;
86  typedef MPIHelper::MPICommunicator MPICommunicatorType;
87 
89  explicit DGFGridFactory ( std::istream &input,
90  MPICommunicatorType comm = MPIHelper::getCommunicator() )
91  : grid_( 0 ),
92  factory_(),
93  dgf_( rank( comm ), size( comm ) )
94  {
95  generate( input );
96  }
97 
99  explicit DGFGridFactory ( const std::string &filename,
100  MPICommunicatorType comm = MPIHelper::getCommunicator() )
101  : grid_( 0 ),
102  factory_(),
103  dgf_( rank( comm ), size( comm ) )
104  {
105  std::ifstream input( filename.c_str() );
106  if ( !input )
107  DUNE_THROW( DGFException, "Error: Macrofile " << filename << " not found" );
108  generate( input );
109  }
110 
112  Grid *grid ()
113  {
114  return grid_;
115  }
116 
118  template< class GG, class II >
119  bool wasInserted ( const Dune::Intersection< GG, II > &intersection ) const
120  {
121  return factory_.wasInserted( intersection );
122  }
123 
125  template< class GG, class II >
126  int boundaryId ( const Dune::Intersection< GG, II > &intersection ) const
127  {
128  return intersection.boundarySegmentIndex();
129  }
130 
132  template< int codim >
133  int numParameters () const
134  {
135  if( codim == 0 )
136  return dgf_.nofelparams;
137  else if( codim == dimension )
138  return dgf_.nofvtxparams;
139  else
140  return 0;
141  }
142 
144  template< class Entity >
145  int numParameters ( const Entity & ) const
146  {
147  return numParameters< Entity::codimension >();
148  }
149 
151  std::vector< double > &parameter ( const typename Grid::template Codim< 0 >::Entity &element )
152  {
153  if( numParameters< 0 >() <= 0 )
154  {
155  DUNE_THROW( InvalidStateException,
156  "Calling DGFGridFactory::parameter is only allowed if there are parameters." );
157  }
158  return dgf_.elParams[ factory_.insertionIndex( element ) ];
159  }
160 
162  std::vector< double > &parameter ( const typename Grid::template Codim< dimension >::Entity &vertex )
163  {
164  if( numParameters< dimension >() <= 0 )
165  {
166  DUNE_THROW( InvalidStateException,
167  "Calling DGFGridFactory::parameter is only allowed if there are parameters." );
168  }
169  return dgf_.vtxParams[ factory_.insertionIndex( vertex ) ];
170  }
171 
173  bool haveBoundaryParameters () const
174  {
175  return dgf_.haveBndParameters;
176  }
177 
179  template< class GG, class II >
180  const DGFBoundaryParameter::type &boundaryParameter ( const Dune::Intersection< GG, II > &intersection ) const
181  {
183  typename Intersection::Entity entity = intersection.inside();
184  const int face = intersection.indexInInside();
185 
186  auto refElem = referenceElement< double, dimension >( entity.type() );
187  int corners = refElem.size( face, 1, dimension );
188  std::vector< unsigned int > bound( corners );
189  for( int i = 0; i < corners; ++i )
190  {
191  const int k = refElem.subEntity( face, 1, i, dimension );
192  bound[ i ] = factory_.insertionIndex( entity.template subEntity< dimension >( k ) );
193  }
194 
195  DuneGridFormatParser::facemap_t::key_type key( bound, false );
196  const DuneGridFormatParser::facemap_t::const_iterator pos = dgf_.facemap.find( key );
197  if( pos != dgf_.facemap.end() )
198  return dgf_.facemap.find( key )->second.second;
199  else
201  }
202 
203  private:
204  // create grid
205  void generate ( std::istream &input );
206 
207  // return rank
208  static int rank( MPICommunicatorType MPICOMM )
209  {
210  int rank = 0;
211 #if HAVE_MPI
212  MPI_Comm_rank( MPICOMM, &rank );
213 #endif
214  return rank;
215  }
216 
217  // return size
218  static int size( MPICommunicatorType MPICOMM )
219  {
220  int size = 1;
221 #if HAVE_MPI
222  MPI_Comm_size( MPICOMM, &size );
223 #endif
224  return size;
225  }
226 
227  Grid *grid_;
228  GridFactory< UGGrid< dim > > factory_;
230  };
231 #endif // #if ENABLE_UG
232 
233 } // namespace Dune
234 
235 #endif // #ifndef DUNE_GRID_IO_FILE_DGFPARSER_DGFUG_HH
Definition: dgfug.hh:35
bool noCopy_
Definition: dgfug.hh:50
Common Grid parametersFor each grid implementation there is a set of parameters that can be passed vi...
Definition: gridparameter.hh:31
GridImp::template Codim< 0 >::Entity Entity
Type of entity that this Intersection belongs to.
Definition: common/intersection.hh:190
Some simple static information for a given GridType.
Definition: io/file/dgfparser/dgfparser.hh:50
Grid abstract base classThis class is the base class for all grid implementations. Although no virtual functions are used we call it abstract since its methods do not contain an implementation but forward to the methods of the derived class via the Barton-Nackman trick.
Definition: common/grid.hh:373
exception class for IO errors in the DGF parser
Definition: dgfexception.hh:12
Wrapper class for entities.
Definition: common/entity.hh:63
size_t heapSize() const
returns heap size used on construction of the grid
Definition: dgfug.hh:46
The DuneGridFormatParser class: reads a DGF file and stores build information in vector structures us...
Definition: parser.hh:44
Provide a generic factory class for unstructured grids.
Definition: common/gridfactory.hh:263
Front-end for the grid manager of the finite element toolbox UG.
Definition: uggrid.hh:230
Entity inside() const
return Entity on the inside of this intersection. That is the Entity where we started this...
Definition: common/intersection.hh:260
bool noCopy() const
returns true if no copies are made for UGGrid elements
Definition: dgfug.hh:44
bool noClosure() const
returns true if no closure should be used for UGGrid
Definition: dgfug.hh:42
std::string type
type of additional boundary parameters
Definition: parser.hh:23
Intersection of a mesh entity of codimension 0 ("element") with a "neighboring" element or with the d...
Definition: albertagrid/dgfparser.hh:26
size_t boundarySegmentIndex() const
index of the boundary segment within the macro grid
Definition: common/intersection.hh:246
The UGGrid class.
Definition: common.hh:179
UGGridParameterBlock(std::istream &input)
constructor taking istream
Definition: dgfug.cc:18
Definition: agrid.hh:65
bool noClosure_
Definition: dgfug.hh:49
size_t heapSize_
Definition: dgfug.hh:51
int indexInInside() const
Local index of codim 1 entity in the inside() entity where intersection is contained in...
Definition: common/intersection.hh:356
static const type & defaultValue()
default constructor
Definition: parser.hh:26
Include standard header files.
Definition: agrid.hh:58