dune-fem  2.8-git
dirichletconstraints.hh
Go to the documentation of this file.
1 /**************************************************************************
2 
3  The dune-fem module is a module of DUNE (see www.dune-project.org).
4  It is based on the dune-grid interface library
5  extending the grid interface by a number of discretization algorithms
6  for solving non-linear systems of partial differential equations.
7 
8  Copyright (C) 2003 - 2015 Robert Kloefkorn
9  Copyright (C) 2003 - 2010 Mario Ohlberger
10  Copyright (C) 2004 - 2015 Andreas Dedner
11  Copyright (C) 2005 Adrian Burri
12  Copyright (C) 2005 - 2015 Mirko Kraenkel
13  Copyright (C) 2006 - 2015 Christoph Gersbacher
14  Copyright (C) 2006 - 2015 Martin Nolte
15  Copyright (C) 2011 - 2015 Tobias Malkmus
16  Copyright (C) 2012 - 2015 Stefan Girke
17  Copyright (C) 2013 - 2015 Claus-Justus Heine
18  Copyright (C) 2013 - 2014 Janick Gerstenberger
19  Copyright (C) 2013 Sven Kaulman
20  Copyright (C) 2013 Tom Ranner
21  Copyright (C) 2015 Marco Agnese
22  Copyright (C) 2015 Martin Alkaemper
23 
24 
25  The dune-fem module is free software; you can redistribute it and/or
26  modify it under the terms of the GNU General Public License as
27  published by the Free Software Foundation; either version 2 of
28  the License, or (at your option) any later version.
29 
30  The dune-fem module is distributed in the hope that it will be useful,
31  but WITHOUT ANY WARRANTY; without even the implied warranty of
32  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
33  GNU General Public License for more details.
34 
35  You should have received a copy of the GNU General Public License along
36  with this program; if not, write to the Free Software Foundation, Inc.,
37  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
38 
39 **************************************************************************/
40 #ifndef DUNE_DIRICHLETCONSTRAINTS_HH
41 #define DUNE_DIRICHLETCONSTRAINTS_HH
42 
49 
50 namespace Dune {
51 
52 namespace Fem {
53 class HasLocalFunction;
54 }
55 
56 template < class Model, class DiscreteFunctionSpace >
58 {
59 public:
60  enum Operation { set = 0, sub = 1 };
61  typedef Model ModelType;
63  typedef typename DiscreteFunctionSpaceType::DomainType DomainType;
64  typedef typename DiscreteFunctionSpaceType::RangeType RangeType;
65  typedef typename DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType;
66  typedef typename DiscreteFunctionSpaceType::HessianRangeType HessianRangeType;
67 
69  typedef typename DiscreteFunctionSpaceType :: GridPartType GridPartType;
71  typedef typename DiscreteFunctionSpaceType :: GridType GridType;
72 
73  // types for boundary treatment
74  // ----------------------------
75  static const int localBlockSize = DiscreteFunctionSpaceType :: localBlockSize ;
76  static_assert( localBlockSize == DiscreteFunctionSpaceType::FunctionSpaceType::dimRange,
77  "local block size of the space must be identical to the dimension of the range of the function space.");
78  typedef std::array<int,localBlockSize> DirichletBlock;
79  typedef std::vector< DirichletBlock > DirichletBlockVector;
80  // static_assert( dimD >= localBlockSize,
81  // "local block size of the space must be less or equahl to the dimension of the range of the model.");
82 
84  {
85  const ModelType& impl_;
86  int bndId_;
87  public:
88  typedef typename DiscreteFunctionSpaceType::EntityType EntityType;
89  typedef typename DiscreteFunctionSpaceType::FunctionSpaceType FunctionSpaceType;
90  typedef typename DiscreteFunctionSpaceType::DomainType DomainType;
91  typedef typename DiscreteFunctionSpace::RangeType RangeType;
92  typedef typename DiscreteFunctionSpace::JacobianRangeType JacobianRangeType;
93  typedef typename DiscreteFunctionSpace::HessianRangeType HessianRangeType;
94  static const int dimRange = RangeType::dimension;
95  BoundaryWrapper( const ModelType& impl, int bndId )
96  : impl_( impl ), bndId_(bndId) {}
97  template <class Point>
98  void evaluate( const Point& x, RangeType& ret ) const
99  { impl_.dirichlet(bndId_,Dune::Fem::coordinate(x),ret); }
100  template <class Point>
101  void jacobian( const Point& x, JacobianRangeType& ret ) const
102  { DUNE_THROW(Dune::NotImplemented,"rhs jacobian not implemented"); }
103  };
104 
106  : model_(model),
107  space_( space ),
109  // mark DoFs on the Dirichlet boundary
110  hasDirichletDofs_( false ),
111  sequence_( -1 )
112  {}
113 
121  template < class DiscreteFunctionType >
122  void operator ()( const DiscreteFunctionType& u, DiscreteFunctionType& w ) const
123  {
125 
126  // if Dirichlet Dofs have been found, treat them
127  if( hasDirichletDofs_ )
128  {
129  typedef typename DiscreteFunctionType :: DofIteratorType DofIteratorType ;
130  typedef typename DiscreteFunctionType :: ConstDofIteratorType ConstDofIteratorType ;
131 
132  ConstDofIteratorType uIt = u.dbegin();
133  DofIteratorType wIt = w.dbegin();
134 
135  // loop over all blocks
136  const unsigned int blocks = space_.blockMapper().size();
137  for( unsigned int blockDof = 0; blockDof < blocks ; ++ blockDof )
138  {
139  for( int l = 0; l < localBlockSize ; ++ l, ++ wIt, ++ uIt )
140  {
141  if( dirichletBlocks_[ blockDof ][l] )
142  {
143  // copy dofs of the block
144  assert( uIt != u.dend() );
145  assert( wIt != w.dend() );
146  (*wIt) = (*uIt);
147  }
148  }
149  }
150  }
151  }
159  template < class DiscreteFunctionType >
160  void operator ()( const typename DiscreteFunctionType::RangeType& value, DiscreteFunctionType& w ) const
161  {
163 
164  // if Dirichlet Dofs have been found, treat them
165  if( hasDirichletDofs_ )
166  {
167  typedef typename DiscreteFunctionType :: DofIteratorType DofIteratorType ;
168 
169  DofIteratorType wIt = w.dbegin();
170 
171  // loop over all blocks
172  const unsigned int blocks = space_.blockMapper().size();
173  for( unsigned int blockDof = 0; blockDof < blocks ; ++ blockDof )
174  {
175  for( int l = 0; l < localBlockSize ; ++ l, ++ wIt )
176  {
177  if( dirichletBlocks_[ blockDof ][l] )
178  {
179  // copy dofs of the block
180  assert( wIt != w.dend() );
181  (*wIt) = value[l];
182  }
183  }
184  }
185  }
186  }
187 
195  template < class DiscreteFunctionType >
196  void operator ()( DiscreteFunctionType& w ) const
197  {
199 
200  if( hasDirichletDofs_ )
201  {
202  typedef typename DiscreteFunctionSpaceType :: IteratorType IteratorType;
203  typedef typename IteratorType :: Entity EntityType;
204 
206  for( const EntityType &entity : space_ )
207  {
208  model_.init(entity);
209  auto wGuard = Dune::Fem::bindGuard( wLocal, entity );
210 
211  // interpolate dirichlet dofs
212  dirichletDofTreatment( wLocal );
213  }
214  }
215  }
216  template < class GridFunctionType, class DiscreteFunctionType,
217  typename = std::enable_if_t< std::is_base_of<Dune::Fem::HasLocalFunction, GridFunctionType>::value > >
218  void operator ()( const GridFunctionType &u,
219  DiscreteFunctionType& w, Operation op=Operation::setDF ) const
220  {
222 
223  if( hasDirichletDofs_ )
224  {
227 
228  for( const auto &entity : space_ )
229  {
230  auto guard = Dune::Fem::bindGuard( std::tie(uLocal,wLocal), entity );
231 
232  // interpolate dirichlet dofs
233  if (op == Operation::sub)
234  model_.init(entity);
235  dirichletDofTreatment( uLocal, wLocal, op );
236  }
237  }
238  }
239 
248  template <class LinearOperator>
249  void applyToOperator( LinearOperator& linearOperator ) const
250  {
252 
253  typedef typename DiscreteFunctionSpaceType :: IteratorType IteratorType;
254  typedef typename IteratorType :: Entity EntityType;
255 
256  // if Dirichlet Dofs have been found, treat them
257  if( hasDirichletDofs_ )
258  {
259  typedef typename LinearOperator::DomainSpaceType DomainSpaceType;
260  typedef typename LinearOperator::RangeSpaceType RangeSpaceType;
262  TemporaryLocalMatrixType localMatrix( linearOperator.domainSpace(), linearOperator.rangeSpace() );
263 
264  const IteratorType end = space_.end();
265  for( IteratorType it = space_.begin(); it != end; ++it )
266  {
267  const EntityType &entity = *it;
268  // init localMatrix to entity
269  localMatrix.init( entity, entity );
270  // obtain local matrix values
271  linearOperator.getLocalMatrix( entity, entity, localMatrix );
272  // adjust local matrix
273  dirichletDofsCorrectOnEntity( entity, localMatrix );
274  // write back changed local matrix to linear operator
275  linearOperator.setLocalMatrix( entity, entity, localMatrix );
276  }
277  }
278  }
279 
281  {
283  return dirichletBlocks_;
284  }
285 
286 protected:
287 
296  template< class EntityType, class LocalMatrix >
297  void dirichletDofsCorrectOnEntity ( const EntityType &entity,
298  LocalMatrix& localMatrix ) const
299  {
300  // get auxiliary dof structure (for parallel runs) /*@LST0S@*/
301  const auto &auxiliaryDofs = localMatrix.rangeSpace().auxiliaryDofs();
302 
303  // get number of basis functions
304  const int localBlocks = space_.blockMapper().numDofs( entity );
305 
306  // map local to global dofs
307  std::vector<std::size_t> globalBlockDofs(localBlocks);
308  // obtain all DofBlocks for this element
309  space_.blockMapper().map( entity, globalBlockDofs );
310 
311  // counter for all local dofs (i.e. localBlockDof * localBlockSize + ... )
312  int localDof = 0;
313  // iterate over face dofs and set unit row
314  for( int localBlockDof = 0 ; localBlockDof < localBlocks; ++ localBlockDof )
315  {
316  int global = globalBlockDofs[localBlockDof];
317  for( int l = 0; l < localBlockSize; ++ l, ++ localDof )
318  {
319  if( dirichletBlocks_[global][l] )
320  {
321  // clear all other columns
322  localMatrix.clearRow( localDof );
323 
324  // set diagonal to 1
325  double value = auxiliaryDofs.contains( global )? 0.0 : 1.0;
326  localMatrix.set( localDof, localDof, value );
327  }
328  }
329  }
330  }
331 
333  template< class LocalFunctionType >
334  void dirichletDofTreatment( LocalFunctionType &wLocal ) const
335  {
336  // get entity
337  const typename LocalFunctionType::EntityType &entity = wLocal.entity();
338 
339  // get number of Lagrange Points
340  const int localBlocks = space_.blockMapper().numDofs( entity );
341 
342  // map local to global BlockDofs
343  std::vector<std::size_t> globalBlockDofs(localBlocks);
344  space_.blockMapper().map(entity,globalBlockDofs);
345  std::vector<typename LocalFunctionType::RangeFieldType> values( localBlocks*localBlockSize );
346 
347  int localDof = 0;
348 
349  // iterate over face dofs and set unit row
350  for( int localBlock = 0 ; localBlock < localBlocks; ++ localBlock )
351  {
352  // store result to dof vector
353  int global = globalBlockDofs[localBlock];
354  for( int l = 0; l < localBlockSize ; ++ l, ++localDof )
355  {
356  if( dirichletBlocks_[ global ][l] )
357  {
358  space_.interpolation(entity)
359  (BoundaryWrapper(model_,dirichletBlocks_[global][l]), values);
360  // store result
361  assert( (unsigned int)localDof < wLocal.size() );
362  wLocal[ localDof ] = values[ localDof ];
363  }
364  }
365  }
366  }
367  template< class GridLocalFunctionType, class LocalFunctionType >
368  void dirichletDofTreatment( const GridLocalFunctionType &uLocal,
369  LocalFunctionType &wLocal, Operation op ) const
370  {
371  // get entity
372  const typename LocalFunctionType::EntityType &entity = wLocal.entity();
373 
374  // get number of Lagrange Points
375  const int localBlocks = space_.blockMapper().numDofs( entity );
376 
377  // map local to global BlockDofs
378  std::vector<std::size_t> globalBlockDofs(localBlocks);
379  space_.blockMapper().map(entity,globalBlockDofs);
380  std::vector<double> values( localBlocks*localBlockSize );
381  std::vector<double> valuesModel( localBlocks*localBlockSize );
382  space_.interpolation(entity)(uLocal, values);
383 
384  int localDof = 0;
385 
386  // iterate over face dofs and set unit row
387  for( int localBlock = 0 ; localBlock < localBlocks; ++ localBlock )
388  {
389  // store result to dof vector
390  int global = globalBlockDofs[localBlock];
391  for( int l = 0; l < localBlockSize ; ++ l, ++localDof )
392  {
393  if( dirichletBlocks_[ global ][l] )
394  {
395  if (op == Operation::sub)
396  {
397  space_.interpolation(entity)
398  (BoundaryWrapper(model_,dirichletBlocks_[global][l]), valuesModel);
399  values[ localDof ] -= valuesModel[ localDof ];
400  }
401  // store result
402  assert( (unsigned int)localDof < wLocal.size() );
403  wLocal[ localDof ] = values[ localDof ];
404  }
405  }
406  }
407  }
408 
409 protected:
410  // detect all DoFs on the Dirichlet boundary
411  void updateDirichletDofs() const
412  {
413  if( sequence_ != space_.sequence() )
414  {
415  // only start search if Dirichlet boundary is present
416  if( ! model_.hasDirichletBoundary() )
417  {
418  hasDirichletDofs_ = false ;
419  return ;
420  }
421 
422  // resize flag vector with number of blocks and reset flags
423  const int blocks = space_.blockMapper().size() ;
424  dirichletBlocks_.resize( blocks );
425  for( int i=0; i<blocks; ++i )
426  dirichletBlocks_[ i ].fill(0);
427 
428  typedef typename DiscreteFunctionSpaceType :: IteratorType IteratorType;
429  typedef typename IteratorType :: Entity EntityType;
430 
431  bool hasDirichletBoundary = false;
432  const IteratorType end = space_.end();
433  for( IteratorType it = space_.begin(); it != end; ++it )
434  {
435  const EntityType &entity = *it;
436  // if entity has boundary intersections
437  if( entity.hasBoundaryIntersections() )
438  {
439  hasDirichletBoundary |= searchEntityDirichletDofs( entity, model_ );
440  }
441  }
442 
443  // update sequence number
444  sequence_ = space_.sequence();
445  if( space_.gridPart().comm().size() > 1 )
446  {
447  try
448  {
449  DirichletBuilder handle( *this, space_ , space_.blockMapper() );
450  space_.gridPart().communicate
451  ( handle, GridPartType::indexSetInterfaceType, ForwardCommunication );
452  }
453  // catch possible exceptions here to have a clue where it happend
454  catch( const Exception &e )
455  {
456  std::cerr << e << std::endl;
457  std::cerr << "Exception thrown in: " << __FILE__ << " line:" << __LINE__ << std::endl;
458  abort();
459  }
460  hasDirichletDofs_ = space_.gridPart().grid().comm().max( hasDirichletBoundary );
461  }
462  else
463  {
464  hasDirichletDofs_ = hasDirichletBoundary;
465  }
466  }
467  }
468 
469  // detect all DoFs on the Dirichlet boundary of the given entity
470  template< class EntityType >
471  bool searchEntityDirichletDofs( const EntityType &entity, ModelType& model ) const
472  {
473  typedef typename DiscreteFunctionSpaceType :: GridPartType GridPartType;
474 
475  typedef typename GridPartType :: IntersectionIteratorType
476  IntersectionIteratorType;
477 
478  const GridPartType &gridPart = space_.gridPart();
479 
480  // default is false
481  bool hasDirichletBoundary = false;
482 
483  //map local to global BlockDofs
484  std::vector< size_t> globalBlockDofs(space_.blockMapper().numDofs(entity));
485  space_.blockMapper().map(entity,globalBlockDofs);
486 
487  std::vector< bool> globalBlockDofsFilter(space_.blockMapper().numDofs(entity));
488 
489  IntersectionIteratorType it = gridPart.ibegin( entity );
490  const IntersectionIteratorType endit = gridPart.iend( entity );
491  for( ; it != endit; ++it )
492  {
493  typedef typename IntersectionIteratorType :: Intersection IntersectionType;
494  const IntersectionType& intersection = *it;
495 
496  // if intersection is with boundary, adjust data
497  if( intersection.boundary() )
498  {
499  // get dirichlet information from model
500  DirichletBlock block;
501  block.fill(0);
502  const bool isDirichletIntersection = model.isDirichletIntersection( intersection, block );
503  if (isDirichletIntersection)
504  {
505  // get face number of boundary intersection
506  const int face = intersection.indexInInside();
507  space_.blockMapper().onSubEntity(entity,face,1,globalBlockDofsFilter);
508  for( unsigned int i=0;i<globalBlockDofs.size();++i)
509  {
510  if ( !globalBlockDofsFilter[i] ) continue;
511  // mark global DoF number
512  for(int k = 0; k < localBlockSize; ++k)
513  dirichletBlocks_[globalBlockDofs[ i ] ][k] = block [k];
514 
515  // we have Dirichlet values
516  hasDirichletBoundary = true ;
517  }
518  }
519  }
520  }
521 
522  return hasDirichletBoundary;
523  }
524 
528  mutable bool hasDirichletDofs_ ;
529  mutable int sequence_ ;
530 
531  class DirichletBuilder;
532 };
533 
534 template < class Model, class Space >
535 class DirichletConstraints< Model,Space > :: DirichletBuilder
536  : public CommDataHandleIF< DirichletBuilder, int >
537 {
538 public:
539  typedef Space SpaceType;
540  typedef typename SpaceType::BlockMapperType MapperType;
541 
542  enum { nCodim = SpaceType :: GridType :: dimension + 1 };
543 
544 public:
545  typedef int DataType;
546 
547  const int myRank_;
548  const int mySize_;
549 
552 
555 
556  static const int blockSize = SpaceType::localBlockSize;
557 
558 public:
559  DirichletBuilder( const DirichletType &dirichlet,
560  const SpaceType &space,
561  const MapperType &mapper )
562  : myRank_( space.gridPart().comm().rank() ),
563  mySize_( space.gridPart().comm().size() ),
564  dirichlet_( dirichlet ),
565  space_( space ),
566  mapper_( mapper )
567  {
568  }
569  bool contains ( int dim, int codim ) const
570  {
571  return mapper_.contains( codim );
572  }
573 
574  bool fixedSize ( int dim, int codim ) const
575  {
576  return false;
577  }
578 
580  template< class MessageBuffer, class Entity >
581  inline void gather ( MessageBuffer &buffer,
582  const Entity &entity ) const
583  {
584  unsigned int localBlocks = mapper_.numEntityDofs( entity );
585  std::vector<std::size_t> globalBlockDofs(localBlocks);
586  mapper_.mapEntityDofs( entity, globalBlockDofs );
587  assert( size(entity) == globalBlockDofs.size()*blockSize );
588  for( unsigned int localBlock = 0 ; localBlock < globalBlockDofs.size(); ++ localBlock )
589  {
590  int global = globalBlockDofs[localBlock];
591  for (int r=0;r<blockSize;++r)
592  if (dirichlet_.dirichletBlocks_[ global ][r] )
593  buffer.write( 1 );
594  else
595  buffer.write( 0 );
596  }
597  }
598 
603  template< class MessageBuffer, class EntityType >
604  inline void scatter ( MessageBuffer &buffer,
605  const EntityType &entity,
606  size_t n )
607  {
608  unsigned int localBlocks = mapper_.numEntityDofs( entity );
609  std::vector<std::size_t> globalBlockDofs(localBlocks);
610  mapper_.mapEntityDofs( entity, globalBlockDofs );
611  assert( n == globalBlockDofs.size()*blockSize );
612  assert( n == size(entity) );
613  for( unsigned int localBlock = 0 ; localBlock < globalBlockDofs.size(); ++ localBlock )
614  {
615  int global = globalBlockDofs[localBlock];
616  for (int r=0;r<blockSize;++r)
617  {
618  int val;
619  buffer.read(val);
620  if ( !dirichlet_.dirichletBlocks_[ global ][r] && val == 1)
621  dirichlet_.dirichletBlocks_[ global ][r] = true;
622  }
623  }
624  }
626  template< class Entity >
627  size_t size ( const Entity &entity ) const
628  {
629  return blockSize * mapper_.numEntityDofs( entity );
630  }
631 };
632 
633 } // end namespace Dune
634 #endif
Definition: bindguard.hh:11
static const Point & coordinate(const Point &x)
Definition: coordinate.hh:14
typename Impl::ConstLocalFunction< GridFunction >::Type ConstLocalFunction
Definition: const.hh:517
static auto bindGuard(Object &object, Args &&... args) -> std::enable_if_t< isBindable< Object, Args... >::value, BindGuard< Object > >
Definition: bindguard.hh:67
static constexpr T sub(T a)
Definition: utility.hh:61
Definition: common/localcontribution.hh:14
A local matrix with a small array as storage.
Definition: temporarylocalmatrix.hh:100
Definition: dirichletconstraints.hh:58
std::array< int, localBlockSize > DirichletBlock
Definition: dirichletconstraints.hh:77
DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType
Definition: dirichletconstraints.hh:65
Operation
Definition: dirichletconstraints.hh:60
@ set
Definition: dirichletconstraints.hh:60
@ sub
Definition: dirichletconstraints.hh:60
DirichletBlockVector dirichletBlocks_
Definition: dirichletconstraints.hh:527
DiscreteFunctionSpaceType::DomainType DomainType
Definition: dirichletconstraints.hh:63
DiscreteFunctionSpaceType::RangeType RangeType
Definition: dirichletconstraints.hh:64
static const int localBlockSize
Definition: dirichletconstraints.hh:75
const DirichletBlockVector & dirichletBlocks() const
Definition: dirichletconstraints.hh:280
void dirichletDofTreatment(LocalFunctionType &wLocal) const
set the dirichlet points to exact values
Definition: dirichletconstraints.hh:334
DiscreteFunctionSpaceType ::GridPartType GridPartType
type of grid partition
Definition: dirichletconstraints.hh:69
void updateDirichletDofs() const
Definition: dirichletconstraints.hh:411
Model ModelType
Definition: dirichletconstraints.hh:61
void applyToOperator(LinearOperator &linearOperator) const
Definition: dirichletconstraints.hh:249
bool hasDirichletDofs_
Definition: dirichletconstraints.hh:528
const DiscreteFunctionSpaceType & space_
Definition: dirichletconstraints.hh:526
std::vector< DirichletBlock > DirichletBlockVector
Definition: dirichletconstraints.hh:79
DiscreteFunctionSpaceType ::GridType GridType
type of grid
Definition: dirichletconstraints.hh:71
ModelType & model_
Definition: dirichletconstraints.hh:525
void operator()(const DiscreteFunctionType &u, DiscreteFunctionType &w) const
Definition: dirichletconstraints.hh:122
int sequence_
Definition: dirichletconstraints.hh:529
void dirichletDofsCorrectOnEntity(const EntityType &entity, LocalMatrix &localMatrix) const
Definition: dirichletconstraints.hh:297
DiscreteFunctionSpace DiscreteFunctionSpaceType
Definition: dirichletconstraints.hh:62
DirichletConstraints(ModelType &model, const DiscreteFunctionSpaceType &space)
Definition: dirichletconstraints.hh:105
bool searchEntityDirichletDofs(const EntityType &entity, ModelType &model) const
Definition: dirichletconstraints.hh:471
DiscreteFunctionSpaceType::HessianRangeType HessianRangeType
Definition: dirichletconstraints.hh:66
void dirichletDofTreatment(const GridLocalFunctionType &uLocal, LocalFunctionType &wLocal, Operation op) const
Definition: dirichletconstraints.hh:368
Definition: dirichletconstraints.hh:84
DiscreteFunctionSpaceType::DomainType DomainType
Definition: dirichletconstraints.hh:90
DiscreteFunctionSpace::HessianRangeType HessianRangeType
Definition: dirichletconstraints.hh:93
DiscreteFunctionSpace::JacobianRangeType JacobianRangeType
Definition: dirichletconstraints.hh:92
static const int dimRange
Definition: dirichletconstraints.hh:94
DiscreteFunctionSpaceType::FunctionSpaceType FunctionSpaceType
Definition: dirichletconstraints.hh:89
void jacobian(const Point &x, JacobianRangeType &ret) const
Definition: dirichletconstraints.hh:101
void evaluate(const Point &x, RangeType &ret) const
Definition: dirichletconstraints.hh:98
DiscreteFunctionSpace::RangeType RangeType
Definition: dirichletconstraints.hh:91
DiscreteFunctionSpaceType::EntityType EntityType
Definition: dirichletconstraints.hh:88
BoundaryWrapper(const ModelType &impl, int bndId)
Definition: dirichletconstraints.hh:95
Definition: dirichletconstraints.hh:537
DirichletConstraints< Model, Space > DirichletType
Definition: dirichletconstraints.hh:550
void gather(MessageBuffer &buffer, const Entity &entity) const
read buffer and apply operation
Definition: dirichletconstraints.hh:581
const SpaceType & space_
Definition: dirichletconstraints.hh:553
int DataType
Definition: dirichletconstraints.hh:545
DirichletBuilder(const DirichletType &dirichlet, const SpaceType &space, const MapperType &mapper)
Definition: dirichletconstraints.hh:559
bool contains(int dim, int codim) const
Definition: dirichletconstraints.hh:569
bool fixedSize(int dim, int codim) const
Definition: dirichletconstraints.hh:574
const int mySize_
Definition: dirichletconstraints.hh:548
const int myRank_
Definition: dirichletconstraints.hh:547
void scatter(MessageBuffer &buffer, const EntityType &entity, size_t n)
Definition: dirichletconstraints.hh:604
size_t size(const Entity &entity) const
return local dof size to be communicated
Definition: dirichletconstraints.hh:627
Space SpaceType
Definition: dirichletconstraints.hh:539
const MapperType & mapper_
Definition: dirichletconstraints.hh:554
const DirichletType & dirichlet_
Definition: dirichletconstraints.hh:551
SpaceType::BlockMapperType MapperType
Definition: dirichletconstraints.hh:540
discrete function space