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
50namespace Dune {
51
52namespace Fem {
53class HasLocalFunction;
54}
55
56template < class Model, class DiscreteFunctionSpace >
58{
59public:
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
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
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
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
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
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
286protected:
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
409protected:
410 // detect all DoFs on the Dirichlet boundary
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
534template < class Model, class Space >
536 : public CommDataHandleIF< DirichletBuilder, int >
537{
538public:
539 typedef Space SpaceType;
540 typedef typename SpaceType::BlockMapperType MapperType;
541
542 enum { nCodim = SpaceType :: GridType :: dimension + 1 };
543
544public:
545 typedef int DataType;
546
547 const int myRank_;
548 const int mySize_;
549
552
555
556 static const int blockSize = SpaceType::localBlockSize;
557
558public:
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
typename Impl::ConstLocalFunction< GridFunction >::Type ConstLocalFunction
Definition: const.hh:517
static const Point & coordinate(const Point &x)
Definition: coordinate.hh:14
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
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
const DirichletBlockVector & dirichletBlocks() const
Definition: dirichletconstraints.hh:280
bool hasDirichletDofs_
Definition: dirichletconstraints.hh:528
const DiscreteFunctionSpaceType & space_
Definition: dirichletconstraints.hh:526
std::vector< DirichletBlock > DirichletBlockVector
Definition: dirichletconstraints.hh:79
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
DiscreteFunctionSpaceType::GridType GridType
type of grid
Definition: dirichletconstraints.hh:71
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