Dune Core Modules (2.4.1)

grapedatadisplay.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_GRAPE_DATA_DISPLAY_HH
4 #define DUNE_GRAPE_DATA_DISPLAY_HH
5 
6 //- system includes
7 #include <vector>
8 #include <limits>
9 
10 //- local includes
11 #include "grapegriddisplay.hh"
12 
19 namespace Dune
20 {
21 
22  // Forward Declarations
23  // --------------------
24 
25  template< class ctype, int dim, int dimworld, int polOrd >
26  class GrapeLagrangePoints;
27 
28 
29 
30  // GrapeFunction
31  // -------------
32 
33  template< class GV, int dimR, int polOrd >
34  struct GrapeFunction
35  {
36  typedef GV GridView;
37 
38  static const int dimDomain = GridView::Grid::dimension;
39  static const int dimRange = dimR;
40 
41  typedef FieldVector< typename GridView::Grid::ctype, dimDomain > DomainVector;
42  typedef FieldVector< typename GridView::Grid::ctype, dimRange > RangeVector;
43 
44  typedef typename GridView::template Codim< 0 >::Entity Entity;
45 
46  virtual ~GrapeFunction ()
47  {}
48 
49  virtual void evaluate ( const Entity &entity, const DomainVector &x, RangeVector &y ) const = 0;
50 
51  virtual const GridView &gridView () const = 0;
52 
53  virtual std::string name () const = 0;
54  };
55 
56 
57 #if HAVE_GRAPE
58 
59  // EvalFunctionData
60  // ----------------
61 
62  template <class EvalImpTraits>
63  struct EvalFunctionData
64  {
65  typedef typename EvalImpTraits :: GridType GridType;
66  typedef typename EvalImpTraits :: EvalImp EvalImp;
67 
68  typedef typename GridType :: template Codim<0> :: Entity EntityType;
69  enum { dim = GridType::dimension };
70  enum { dimworld = GridType::dimensionworld };
71 
72  typedef typename GridType :: ctype ctype;
73 
74  typedef typename GrapeInterface<dim,dimworld>::DUNE_ELEM DUNE_ELEM;
75  typedef typename GrapeInterface<dim,dimworld>::DUNE_FDATA DUNE_FDATA;
76 
77  // for the data visualization, call implementations evalCoordNow
78  inline static void evalCoordNow (const EntityType &en, DUNE_FDATA *fdata, const double *coord, double * val)
79  {
80  EvalImp::evalCoordNow(en,fdata,coord,val);
81  }
82 
83  // for the data visualization, call implementations evalDofNow
84  inline static void evalDofNow (const EntityType &en, int geomType, DUNE_FDATA *fdata , int localNum, double * val)
85  {
86  EvalImp::evalDofNow(en,geomType,fdata,localNum,val);
87  }
88 
89  // evaluate at given local coord
90  inline static void evalCoord (DUNE_ELEM *he, DUNE_FDATA *df,
91  const double *coord, double * val);
92 
93  // evaluate at dof
94  inline static void evalDof (DUNE_ELEM *he, DUNE_FDATA *df, int localNum, double * val);
95 
96  // get min and max value for colorbar
97  inline static void getMinMaxValues(DUNE_FDATA *df, double* min, double* max );
98  };
99 
100  template <class GridImp, class DiscreteFunctionType>
101  struct EvalDiscreteFunctions;
102 
103  template <class GridImp, class DiscreteFunctionType>
104  struct EvalDiscreteFunctionsTraits
105  {
106  typedef GridImp GridType;
107  typedef EvalDiscreteFunctions <GridImp, DiscreteFunctionType > EvalImp;
108  };
109 
110  template <class GridImp, class DiscreteFunctionType>
111  struct EvalDiscreteFunctions
112  : public EvalFunctionData< EvalDiscreteFunctionsTraits <GridImp, DiscreteFunctionType > >
113  {
114  typedef GridImp GridType;
115  typedef typename GridType :: template Codim<0> :: Entity EntityType;
116  enum { dim = GridType::dimension };
117  enum { dimworld = GridType::dimensionworld };
118 
119  typedef typename GridType :: ctype ctype;
120 
121  typedef typename DiscreteFunctionType :: LocalFunctionType LocalFunctionType;
122  typedef typename DiscreteFunctionType :: DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
123 
124  typedef typename DiscreteFunctionSpaceType :: RangeType RangeType;
125  typedef typename DiscreteFunctionSpaceType :: DomainType DomainType;
126 
127  typedef typename GrapeInterface<dim,dimworld>::DUNE_ELEM DUNE_ELEM;
128  typedef typename GrapeInterface<dim,dimworld>::DUNE_FDATA DUNE_FDATA;
129 
130  // for the data visualization
131  inline static void evalCoordNow (const EntityType &en, DUNE_FDATA *fdata, const double *coord, double * val);
132 
133  // for the data visualization
134  inline static void evalDofNow (const EntityType &en, int geomType, DUNE_FDATA *fdata , int localNum, double * val);
135 
136  // for the data visualization
137  inline static void evalScalar (const EntityType &en, int geomType,
138  DiscreteFunctionType & func, LocalFunctionType &lf,
139  const int * comp , int localNum, double * val);
140 
141  // for the data visualization
142  inline static void evalVector (const EntityType &en, int geomType,
143  DiscreteFunctionType & func, LocalFunctionType &lf,
144  const int * comp, int vend, int localNum, double * val);
145 
146  // calculate min and max value of function
147  inline static void calcMinMax(DUNE_FDATA * df);
148  };
149 
150 
151 
152  // EvalGrapeFunction
153  // -----------------
154 
155  template< class GV, int dimR, int polOrd >
156  struct EvalGrapeFunction;
157 
158  template< class GV, int dimR, int polOrd >
159  struct EvalGrapeFunctionTraits
160  {
161  typedef typename GV::Grid GridType;
162  typedef EvalGrapeFunction< GV, dimR, polOrd > EvalImp;
163  };
164 
165  template< class GV, int dimR, int polOrd >
166  struct EvalGrapeFunction
167  : public EvalFunctionData< EvalGrapeFunctionTraits< GV, dimR, polOrd > >
168  {
169  typedef GV GridView;
170 
171  typedef Dune::GrapeFunction< GV, dimR, polOrd > GrapeFunction;
172 
173  static const int dimDomain = GrapeFunction::dimDomain;
174  static const int dimRange = GrapeFunction::dimRange;
175  static const int dimWorld = GridView::Grid::dimensionworld;
176 
177  typedef typename GrapeFunction::DomainVector DomainVector;
178  typedef typename GrapeFunction::RangeVector RangeVector;
179 
180  typedef typename GridView::template Codim< 0 >::Entity Entity;
181 
182  typedef typename GrapeInterface< dimDomain, dimWorld >::DUNE_ELEM DUNE_ELEM;
183  typedef typename GrapeInterface< dimDomain, dimWorld >::DUNE_FDATA DUNE_FDATA;
184 
185  // for the data visualization
186  static void evalCoordNow ( const Entity &entity, DUNE_FDATA *fdata, const double *coord, double *val );
187 
188  // for the data visualization
189  static void evalDofNow ( const Entity &entity, int geomType, DUNE_FDATA *fdata, int localNum, double *val );
190 
191  // calculate min and max value of function
192  static void calcMinMax ( DUNE_FDATA *fdata );
193  };
194 
195 
196 
197  // EvalVectorData
198  // --------------
199 
200  template <class GridImp, class VectorType, class IndexSetImp >
201  struct EvalVectorData;
202 
203  template <class GridImp, class VectorType , class IndexSetImp >
204  struct EvalVectorDataTraits
205  {
206  typedef GridImp GridType;
207  typedef EvalVectorData <GridImp, VectorType, IndexSetImp > EvalImp;
208  };
209 
210  template <class GridImp, class VectorType, class IndexSetImp >
211  struct EvalVectorData
212  : public EvalFunctionData< EvalVectorDataTraits <GridImp, VectorType, IndexSetImp > >
213  {
214  typedef GridImp GridType;
215  typedef typename GridType :: template Codim<0> :: Entity EntityType;
216  enum { dim = GridType::dimension };
217  enum { dimworld = GridType::dimensionworld };
218 
219  typedef typename GridType :: ctype ctype;
220 
221  typedef typename GrapeInterface<dim,dimworld>::DUNE_ELEM DUNE_ELEM;
222  typedef typename GrapeInterface<dim,dimworld>::DUNE_FDATA DUNE_FDATA;
223 
224  // for the data visualization
225  inline static void evalCoordNow (const EntityType &en, DUNE_FDATA *fdata, const double *coord, double * val);
226 
227  // for the data visualization
228  inline static void evalDofNow (const EntityType &en, int geomType, DUNE_FDATA *fdata , int localNum, double * val);
229 
230  // for the data visualization, evaluate linear funcs
231  static void evalVectorLinear ( const EntityType &entity, int geomType,
232  VectorType & func, const IndexSetImp &indexSet,
233  const int *comp, int vend, int localNum, double *val );
234 
235  // for the data visualization, evaluate const funcs
236  static void evalVectorConst ( const EntityType &entity, int geomType,
237  VectorType & func, const IndexSetImp &indexSet,
238  const int * comp, int vend, int localNum, double * val);
239 
240  // calculate min and max value of function
241  inline static void calcMinMax(DUNE_FDATA * df);
242  };
243 #endif
244 
248  template<class GridType>
249  class GrapeDataDisplay : public GrapeGridDisplay < GridType >
250  {
251  typedef GrapeDataDisplay < GridType > MyDisplayType;
252 
253  typedef GrapeGridDisplay < GridType > BaseType;
254 
255  enum { dim = GridType::dimension };
256  enum { dimworld = GridType::dimensionworld };
257 
258  typedef typename GridType :: ctype ctype;
259 
260 #if HAVE_GRAPE
261  typedef typename GrapeInterface<dim,dimworld>::DUNE_ELEM DUNE_ELEM;
262  typedef typename GrapeInterface<dim,dimworld>::DUNE_FDATA DUNE_FDATA;
263  typedef typename GrapeInterface<dim,dimworld>::DUNE_DAT DUNE_DAT;
264  typedef typename GrapeInterface<dim,dimworld>::F_DATA F_DATA;
265 #endif
266 
267  public:
268  typedef GridType MyGridType;
269 
271  inline GrapeDataDisplay(const GridType &grid, const int myrank = -1);
272 
274  template <class GridPartType>
275  inline GrapeDataDisplay(const GridPartType & gridPart, const int myrank = -1);
276 
278  inline ~GrapeDataDisplay();
279 
289  template< class VectorType, class IndexSetType >
290  inline void displayVector ( const std::string name,
291  const VectorType &data,
292  const IndexSetType &indexSet,
293  const int polOrd,
294  const unsigned int dimRange,
295  bool continuous = false );
296 
299  template <class DiscFuncType>
300  inline void dataDisplay(const DiscFuncType &func, bool vector = false);
301 
303  inline void display();
304 
306  template <class DiscFuncType>
307  inline void addData(const DiscFuncType &func, double time = 0.0, bool vector = false );
308 
310  template <class DiscFuncType>
311  inline void addData(const DiscFuncType &func, std::string name , double time , bool vector = false );
312 
313  template< class GV, int dimR, int polOrd >
314  void addData ( const GrapeFunction< GV, dimR, polOrd > &function );
315 
316 #if HAVE_GRAPE
318  template <class DiscFuncType>
319  inline void addData(const DiscFuncType &func, const DATAINFO * , double time );
320 
321  // retrun whether we have data or not
322  bool hasData () { return (vecFdata_.size() > 0); }
323 
324  // return vector for copying in combined display
325  std::vector < DUNE_FDATA * > & getFdataVec () { return vecFdata_; }
326 
336  template<class VectorType, class IndexSetType >
337  inline void addVector(const std::string name,
338  const VectorType & data, const IndexSetType & indexSet,
339  const double time , const int polOrd ,
340  const int dimRange, bool continuous );
341 
352  template<class VectorType, class IndexSetType >
353  inline void addVector(const VectorType & data, const IndexSetType & indexSet,
354  const DATAINFO * dinf, double time ,
355  const int polOrd , const int dimRange, bool continuous );
356 
357  private:
359  std::vector < DUNE_FDATA * > vecFdata_;
360 
361  enum { polynomialOrder = 1 };
362  // store lagrange points for evaluation
363  GrapeLagrangePoints<ctype,dim,dimworld,polynomialOrder> lagrangePoints_;
364 
365  typedef typename GridType :: template Codim<0> :: Entity EntityCodim0Type;
366  typedef void evalCoord_t (EntityCodim0Type &, DUNE_FDATA *, const double *, double * );
367  typedef void evalDof_t (EntityCodim0Type &,int , DUNE_FDATA * , int , double * );
368 
369  public:
370  // create object DUNE_FDATA
371  static DUNE_FDATA * createDuneFunc ();
372  // delete object DUNE_FDATA
373  static void deleteDuneFunc (DUNE_FDATA *);
374 #endif
375  };
376 
377  template <typename ctype, int dim, int dimworld, int polOrd>
378  class GrapeLagrangePoints
379  {
380 #if HAVE_GRAPE
381  enum { maxPoints = 20 };
382  enum { numberOfTypes = (dim == 2) ? 2 : 6 };
383 
384  std::vector < FieldMatrix<ctype,maxPoints,dim> > points_;
385  GrapeLagrangePoints ( const GrapeLagrangePoints& );
386  public:
388  GrapeLagrangePoints () : points_()
389  {
390  GrapeInterface_two_two::setupReferenceElements();
391  GrapeInterface_two_three::setupReferenceElements();
392  GrapeInterface_three_three::setupReferenceElements();
393 
394  for(int type=0; type<numberOfTypes; ++type)
395  {
396  FieldMatrix<ctype,maxPoints,dim> coords( ctype(0) );
397  const int nvx = numberOfVertices(type);
398 
399  for(int i=0; i<nvx; ++i)
400  {
401  const double * p = getCoordinate(type,i);
402  for(int j=0; j<dimworld; ++j)
403  {
404  assert( p );
405  coords[i][j] = p[j];
406  }
407  }
408  points_.push_back( coords );
409  }
410  }
411 
414  const FieldVector<ctype,dim> &
415  getPoint (const int geomType, const int polyOrder , const int localNum ) const
416  {
417  assert( polOrd == polyOrder );
418  assert( geomType >= 0 );
419  assert( geomType < numberOfTypes );
420  return points_[geomType][localNum];
421  }
422 
423  private:
424  static int numberOfVertices( const int type )
425  {
426  if(type < GrapeInterface_three_three::gr_tetrahedron)
427  return GrapeInterface_two_two::getElementDescription(type)->number_of_vertices;
428  else
429  return GrapeInterface_three_three::getElementDescription(type)->number_of_vertices;
430  }
431 
432  static const double * getCoordinate( const int type, const int i )
433  {
434  if(type < GrapeInterface_three_three::gr_tetrahedron)
435  {
436  return GrapeInterface_two_two::getElementDescription(type)->coord[i];
437  }
438  else
439  return GrapeInterface_three_three::getElementDescription(type)->coord[i];
440  }
441 #endif
442  };
443 
444 } // end namespace Dune
445 
446 #include "grape/grapedatadisplay.cc"
447 #endif
Dune::Entity
Wrapper class for entities.
Definition: entity.hh:62
Dune::GrapeDataDisplay
Definition: grapedatadisplay.hh:250
Dune::GrapeDataDisplay::GrapeDataDisplay
GrapeDataDisplay(const GridType &grid, const int myrank=-1)
Constructor, make a GrapeDataDisplay for given grid.
Definition: grapedatadisplay.cc:446
Dune::GrapeDataDisplay::display
void display()
display grid and data without grid mode
Definition: grapedatadisplay.cc:547
Dune::GrapeDataDisplay::displayVector
void displayVector(const std::string name, const VectorType &data, const IndexSetType &indexSet, const int polOrd, const unsigned int dimRange, bool continuous=false)
Definition: grapedatadisplay.cc:720
Dune::GrapeDataDisplay::~GrapeDataDisplay
~GrapeDataDisplay()
Desctructor.
Definition: grapedatadisplay.cc:464
Dune::GrapeDataDisplay::dataDisplay
void dataDisplay(const DiscFuncType &func, bool vector=false)
Definition: grapedatadisplay.cc:533
Dune::GrapeDataDisplay::addData
void addData(const DiscFuncType &func, double time=0.0, bool vector=false)
add discrete function to display
Definition: grapedatadisplay.cc:559
Dune::GrapeGridDisplay
Definition: grapegriddisplay.hh:55
grapegriddisplay.hh
Provides a GridDisplay class using the GRAPE-HMesh Interface.
Dune
Dune namespace.
Definition: alignment.hh:10
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.80.0 (May 16, 22:29, 2024)