dune-fem  2.4.1-rc
discontinuousgalerkin/localrestrictprolong.hh
Go to the documentation of this file.
1 #ifndef DUNE_FEM_SPACE_DISCONTINUOUSGALERKIN_LOCALRESTRICTPROLONG_HH_
2 #define DUNE_FEM_SPACE_DISCONTINUOUSGALERKIN_LOCALRESTRICTPROLONG_HH_
3 
4 // dune-fem includes
9 
10 // local includes
11 #include "declaration.hh"
12 #include "localdgmassmatrix.hh"
13 
14 
15 namespace Dune
16 {
17 
18  namespace Fem
19  {
20 
26  // DiscontinuousGalerkinLocalRestrictProlong
27  // -----------------------------------------
28 
29  template< class DiscreteFunctionSpace, bool applyInverse >
31  {
33 
34  public:
36 
37  typedef typename DiscreteFunctionSpaceType::DomainFieldType DomainFieldType;
40 
42 
44 
46 
47  DiscontinuousGalerkinLocalRestrictProlong ( const DiscreteFunctionSpaceType& space )
48  : localMassMatrix_( space, space.order() * 2 ),
49  weight_( -1 ),
50  temp_( space )
51  {}
52 
53  void setFatherChildWeight ( const DomainFieldType &weight )
54  {
55  weight_ = weight;
56  }
57 
59  template< class LFFather, class LFSon, class LocalGeometry >
60  void restrictLocal ( LFFather &lfFather, const LFSon &lfSon,
61  const LocalGeometry &geometryInFather, bool initialize ) const
62  {
63  typedef ConstantLocalRestrictProlong< DiscreteFunctionSpaceType > ConstantLocalRestrictProlongType;
64  const DomainFieldType weight = (weight_ < DomainFieldType( 0 ) ? ConstantLocalRestrictProlongType::calcWeight( lfFather.entity(), lfSon.entity() ) : weight_);
65 
66  assert( weight > 0.0 );
67 
68  if( initialize )
69  lfFather.clear();
70 
71  if( applyInverse )
72  {
73  temp_.init( lfFather.entity() );
74  temp_.clear();
75  }
76 
77  typedef typename LFSon :: EntityType EntityType ;
78  typedef typename EntityType :: Geometry Geometry;
79  const EntityType& sonEntity = lfSon.entity();
80  const Geometry sonGeo = sonEntity.geometry();
81 
82  QuadratureType quad( sonEntity, 2*lfFather.order()+1 );
83  const int nop = quad.nop();
84  for( int qp = 0; qp < nop; ++qp )
85  {
86  RangeFieldType quadWeight = quad.weight( qp );
87 
88  // in case of non-orthonormal basis we have to
89  // apply the integration element and the
90  // inverse mass matrix later
91  if( applyInverse )
92  {
93  quadWeight *= sonGeo.integrationElement( quad.point(qp) );
94  }
95  else
96  quadWeight *= weight ;
97 
98  RangeType value;
99  lfSon.evaluate( quad[ qp ], value );
100  value *= quadWeight;
101 
102  if( applyInverse )
103  temp_.axpy( geometryInFather.global( quad.point( qp ) ), value );
104  else
105  lfFather.axpy( geometryInFather.global( quad.point( qp ) ), value );
106  }
107 
108  if( applyInverse )
109  {
111  lfFather += temp_;
112  }
113  }
114 
115  template< class LFFather, class LFSon, class LocalGeometry >
116  void prolongLocal ( const LFFather &lfFather, LFSon &lfSon,
117  const LocalGeometry &geometryInFather, bool initialize ) const
118  {
119  lfSon.clear();
120 
121  typedef typename LFSon :: EntityType EntityType ;
122  typedef typename EntityType :: Geometry Geometry;
123  const EntityType& sonEntity = lfSon.entity();
124  const Geometry sonGeo = sonEntity.geometry();
125 
126  QuadratureType quad( sonEntity, 2*lfSon.order()+1 );
127  const int nop = quad.nop();
128  for( int qp = 0; qp < nop; ++qp )
129  {
130  RangeFieldType quadWeight = quad.weight( qp );
131 
132  // in case of non-orthonormal basis we have to
133  // apply the integration element and the
134  // inverse mass matrix later
135  if( applyInverse )
136  {
137  quadWeight *= sonGeo.integrationElement( quad.point(qp) );
138  }
139 
140  RangeType value;
141  lfFather.evaluate( geometryInFather.global( quad.point( qp ) ), value );
142  value *= quadWeight;
143  lfSon.axpy( quad[ qp ], value );
144  }
145 
146  if( applyInverse )
147  {
148  localMassMatrix_.applyInverse( sonEntity, lfSon );
149  }
150  }
151 
152  bool needCommunication () const { return true; }
153 
154  protected:
155  LocalMassMatrixType localMassMatrix_;
156  DomainFieldType weight_;
158  };
159 
160 
161 
162  // DefaultLocalRestrictProlong for DiscontinuousGalerkinSpace
163  // ----------------------------------------------------------
164 
165  template< class FunctionSpaceImp, class GridPartImp, int polOrd, template< class > class StorageImp >
166  class DefaultLocalRestrictProlong< DiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, StorageImp > >
167  : public DiscontinuousGalerkinLocalRestrictProlong< DiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, StorageImp >, false >
168  {
169  public:
171  FunctionSpaceImp, GridPartImp, polOrd, StorageImp >, false > BaseType;
173  : BaseType( space )
174  {}
175  };
176 
177  template< class FunctionSpaceImp, class GridPartImp, template< class > class StorageImp >
178  class DefaultLocalRestrictProlong< DiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, 0, StorageImp > >
179  : public ConstantLocalRestrictProlong< DiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, 0, StorageImp > >
180  {
181  public:
183  {}
184  };
185 
186 
187 
188  // DefaultLocalRestrictProlong for LegendreDiscontinuousGalerkinSpace
189  // ------------------------------------------------------------------
190 
191  template< class FunctionSpaceImp, class GridPartImp, int polOrd, template< class > class StorageImp >
192  class DefaultLocalRestrictProlong< LegendreDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, StorageImp > >
193  : public DiscontinuousGalerkinLocalRestrictProlong< LegendreDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, StorageImp >, false >
194  {
195  public:
199  : BaseType( space )
200  {}
201  };
202 
203  template< class FunctionSpaceImp, class GridPartImp, template< class > class StorageImp >
204  class DefaultLocalRestrictProlong< LegendreDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, 0, StorageImp > >
205  : public ConstantLocalRestrictProlong< LegendreDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, 0, StorageImp > >
206  {
207  public:
209  {}
210  };
211 
212 
213 
214  // DefaultLocalRestrictProlong for HierarchicLegendreDiscontinuousGalerkinSpace
215  // ----------------------------------------------------------------------------
216 
217  template< class FunctionSpaceImp, class GridPartImp, int polOrd, template< class > class StorageImp >
218  class DefaultLocalRestrictProlong< HierarchicLegendreDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, StorageImp > >
219  : public DiscontinuousGalerkinLocalRestrictProlong< HierarchicLegendreDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, StorageImp >, false >
220  {
221  public:
225  : BaseType( space )
226  {}
227  };
228 
229  template< class FunctionSpaceImp, class GridPartImp, template< class > class StorageImp >
230  class DefaultLocalRestrictProlong< HierarchicLegendreDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, 0, StorageImp > >
231  : public ConstantLocalRestrictProlong< HierarchicLegendreDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, 0, StorageImp > >
232  {
233  public:
235  {}
236  };
237 
238 
239 
240  // DefaultLocalRestrictProlong for LagrangeDiscontinuousGalerkinSpace
241  // ------------------------------------------------------------------
242 
243  template< class FunctionSpaceImp, class GridPartImp, int polOrd, template< class > class StorageImp >
244  class DefaultLocalRestrictProlong< LagrangeDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, StorageImp > >
245  : public DiscontinuousGalerkinLocalRestrictProlong< LagrangeDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, StorageImp >, true >
246  {
247  public:
250  : BaseType( space )
251  {}
252  };
253 
254  template< class FunctionSpaceImp, class GridPartImp, template< class > class StorageImp >
255  class DefaultLocalRestrictProlong< LagrangeDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, 0, StorageImp > >
256  : public ConstantLocalRestrictProlong< LagrangeDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, 0, StorageImp > >
257  {
258  public:
260  {}
261  };
262 
264 
265  } // namespace Fem
266 
267 } // namespace Dune
268 
269 #endif // #ifndef DUNE_FEM_SPACE_DISCONTINUOUSGALERKIN_LOCALRESTRICTPROLONG_HH_
DiscontinuousGalerkinLocalRestrictProlong< LagrangeDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, StorageImp >, true > BaseType
Definition: discontinuousgalerkin/localrestrictprolong.hh:248
DiscontinuousGalerkinLocalRestrictProlong< LegendreDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, StorageImp >, false > BaseType
Definition: discontinuousgalerkin/localrestrictprolong.hh:197
VectorSpaceTraits< DomainField, RangeField, dimD, dimR >::RangeFieldType RangeFieldType
Intrinsic type used for values in the range field (usually a double)
Definition: functionspaceinterface.hh:62
Definition: space/discontinuousgalerkin/declaration.hh:15
DiscreteFunctionSpace DiscreteFunctionSpaceType
Definition: discontinuousgalerkin/localrestrictprolong.hh:35
DefaultLocalRestrictProlong(const LegendreDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, StorageImp > &space)
Definition: discontinuousgalerkin/localrestrictprolong.hh:198
Definition: space/discontinuousgalerkin/declaration.hh:22
void prolongLocal(const LFFather &lfFather, LFSon &lfSon, const LocalGeometry &geometryInFather, bool initialize) const
Definition: discontinuousgalerkin/localrestrictprolong.hh:116
DiscreteFunctionSpaceType::RangeFieldType RangeFieldType
Definition: discontinuousgalerkin/localrestrictprolong.hh:38
DefaultLocalRestrictProlong(const LagrangeDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, 0, StorageImp > &)
Definition: discontinuousgalerkin/localrestrictprolong.hh:259
DiscontinuousGalerkinLocalRestrictProlong(const DiscreteFunctionSpaceType &space)
Definition: discontinuousgalerkin/localrestrictprolong.hh:47
CachingQuadrature< GridPartType, 0 > QuadratureType
Definition: discontinuousgalerkin/localrestrictprolong.hh:43
DiscreteFunctionSpaceType::GridPartType GridPartType
Definition: discontinuousgalerkin/localrestrictprolong.hh:41
Definition: discontinuousgalerkin/localrestrictprolong.hh:30
LocalMassMatrixType localMassMatrix_
Definition: discontinuousgalerkin/localrestrictprolong.hh:155
void restrictLocal(LFFather &lfFather, const LFSon &lfSon, const LocalGeometry &geometryInFather, bool initialize) const
restrict data to father
Definition: discontinuousgalerkin/localrestrictprolong.hh:60
void applyInverse(MassCaller &caller, const EntityType &entity, LocalFunction &lf) const
Definition: localmassmatrix.hh:231
bool needCommunication() const
Definition: discontinuousgalerkin/localrestrictprolong.hh:152
void init(const EntityType &entity)
initialize the local function for an entity
Definition: temporary.hh:115
DiscontinuousGalerkinLocalRestrictProlong< DiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, StorageImp >, false > BaseType
Definition: discontinuousgalerkin/localrestrictprolong.hh:171
Definition: common/localrestrictprolong.hh:24
DefaultLocalRestrictProlong(const LagrangeDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, StorageImp > &space)
Definition: discontinuousgalerkin/localrestrictprolong.hh:249
Definition: space/discontinuousgalerkin/declaration.hh:36
DefaultLocalRestrictProlong(const HierarchicLegendreDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, 0, StorageImp > &)
Definition: discontinuousgalerkin/localrestrictprolong.hh:234
Definition: coordinate.hh:4
DefaultLocalRestrictProlong(const DiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, 0, StorageImp > &)
Definition: discontinuousgalerkin/localrestrictprolong.hh:182
Definition: space/discontinuousgalerkin/declaration.hh:29
void clear()
set all DoFs to zero
Definition: localfunction.hh:170
LocalMassMatrix< DiscreteFunctionSpaceType, QuadratureType > LocalMassMatrixType
Definition: discontinuousgalerkin/localrestrictprolong.hh:45
DiscontinuousGalerkinLocalRestrictProlong< HierarchicLegendreDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, StorageImp >, false > BaseType
Definition: discontinuousgalerkin/localrestrictprolong.hh:223
DefaultLocalRestrictProlong(const LegendreDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, 0, StorageImp > &)
Definition: discontinuousgalerkin/localrestrictprolong.hh:208
TemporaryLocalFunction< DiscreteFunctionSpace > temp_
Definition: discontinuousgalerkin/localrestrictprolong.hh:157
void setFatherChildWeight(const DomainFieldType &weight)
Definition: discontinuousgalerkin/localrestrictprolong.hh:53
DomainFieldType weight_
Definition: discontinuousgalerkin/localrestrictprolong.hh:156
DiscreteFunctionSpaceType::DomainFieldType DomainFieldType
Definition: discontinuousgalerkin/localrestrictprolong.hh:37
DefaultLocalRestrictProlong(const HierarchicLegendreDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, StorageImp > &space)
Definition: discontinuousgalerkin/localrestrictprolong.hh:224
DefaultLocalRestrictProlong(const DiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, StorageImp > &space)
Definition: discontinuousgalerkin/localrestrictprolong.hh:172
discrete function space
VectorSpaceTraits< DomainField, RangeField, dimD, dimR >::RangeType RangeType
Type of range vector (using type of range field) has a Dune::FieldVector type interface.
Definition: functionspaceinterface.hh:70
Definition: common/localrestrictprolong.hh:16
ThisType & axpy(const RangeFieldType s, const LocalFunction< BasisFunctionSet, T > &other)
add a multiple of another local function to this one
Definition: localfunction.hh:202
DiscreteFunctionSpaceType::RangeType RangeType
Definition: discontinuousgalerkin/localrestrictprolong.hh:39