dune-pdelab  2.7-git
pdelab/boilerplate/pdelab.hh
Go to the documentation of this file.
1 // -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2 // vi: set et ts=4 sw=4 sts=4:
3 #ifndef DUNE_PDELAB_BOILERPLATE_PDELAB_HH
4 #define DUNE_PDELAB_BOILERPLATE_PDELAB_HH
5 
16 // first of all we include a lot of dune grids and pdelab files
17 #include <array>
18 #include <iostream>
19 #include <memory>
20 
21 #include <dune/common/parallel/mpihelper.hh> // include mpi helper class
22 #include <dune/common/parametertreeparser.hh>
23 #include <dune/common/classname.hh>
24 #include <dune/common/exceptions.hh>
25 #include <dune/common/filledarray.hh>
26 #include <dune/common/fvector.hh>
27 
28 #include <dune/geometry/type.hh>
29 #include <dune/geometry/quadraturerules.hh>
30 
31 #include <dune/grid/onedgrid.hh>
32 #include <dune/grid/io/file/vtk.hh>
33 #include <dune/grid/yaspgrid.hh>
34 #if HAVE_UG
35 #include <dune/grid/uggrid.hh>
36 #endif
37 #if HAVE_ALBERTA
38 #include<dune/grid/albertagrid.hh>
39 #include <dune/grid/albertagrid/dgfparser.hh>
40 #endif
41 #if HAVE_UG
42 #include<dune/grid/uggrid.hh>
43 #endif
44 #if HAVE_DUNE_ALUGRID
45 #include<dune/alugrid/grid.hh>
46 #include <dune/alugrid/dgf.hh>
47 #endif
48 #include <dune/grid/utility/structuredgridfactory.hh>
49 #include <dune/grid/io/file/gmshreader.hh>
50 
51 #include <dune/istl/bvector.hh>
52 #include <dune/istl/operators.hh>
53 #include <dune/istl/solvers.hh>
54 #include <dune/istl/solvercategory.hh>
55 #include <dune/istl/preconditioners.hh>
56 #include <dune/istl/io.hh>
57 
58 #include <dune/istl/paamg/amg.hh>
83 
84 namespace Dune {
85  namespace PDELab {
86 
87  // make grids
88  template<typename T>
90  {
91  public:
92  // export types
93  typedef T Grid;
94  typedef typename T::ctype ctype;
95  static const int dim = T::dimension;
96  static const int dimworld = T::dimensionworld;
97 
98  // constructors
99  StructuredGrid (Dune::GeometryType::BasicType meshtype, unsigned int cells)
100  {
101  FieldVector<ctype,dimworld> lowerLeft(0.0);
102  FieldVector<ctype,dimworld> upperRight(1.0);
103  std::array<unsigned int,dim> elements; elements.fill(cells);
104 
105  StructuredGridFactory<T> factory;
106 
107  if (meshtype==Dune::GeometryType::cube)
108  gridp = factory.createCubeGrid(lowerLeft,upperRight,elements);
109  else if (meshtype==Dune::GeometryType::simplex)
110  gridp = factory.createSimplexGrid(lowerLeft,upperRight,elements);
111  else
112  {
113  DUNE_THROW(GridError, className<StructuredGrid>()
114  << "::StructuredGrid(): grid type must be simplex or cube ");
115  }
116  }
117 
118 
119  StructuredGrid (Dune::GeometryType::BasicType meshtype,
120  std::array<double,dimworld> lower_left, std::array<double,dimworld> upper_right,
121  std::array<unsigned int,dim> cells)
122  {
123  FieldVector<ctype,dimworld> lowerLeft;
124  FieldVector<ctype,dimworld> upperRight;
125  std::array<unsigned int,dim> elements;
126 
127  // copy data to correct types for StructuredGridFactory
128  for (size_t i=0; i<dimworld; i++)
129  {
130  lowerLeft[i] = lower_left[i];
131  upperRight[i] = upper_right[i];
132  }
133  for (size_t i=0; i<dim; i++)
134  {
135  elements[i] = cells[i];
136  }
137 
138  StructuredGridFactory<T> factory;
139 
140  if (meshtype==Dune::GeometryType::cube)
141  gridp = factory.createCubeGrid(lowerLeft,upperRight,elements);
142  else if (meshtype==Dune::GeometryType::simplex)
143  gridp = factory.createSimplexGrid(lowerLeft,upperRight,elements);
144  else
145  {
146  DUNE_THROW(GridError, className<StructuredGrid>()
147  << "::StructuredGrid(): grid type must be simplex or cube ");
148  }
149  }
150 
151  // return shared pointer
152  std::shared_ptr<T> getSharedPtr ()
153  {
154  return gridp;
155  }
156 
157  // return grid reference
158  T& getGrid ()
159  {
160  return *gridp;
161  }
162 
163  // return grid reference const version
164  const T& getGrid () const
165  {
166  return *gridp;
167  }
168 
170  {
171  return *gridp;
172  }
173 
175  {
176  return gridp.operator->();
177  }
178 
179  const T& operator*() const
180  {
181  return *gridp;
182  }
183 
184  const T* operator->() const
185  {
186  return gridp.operator->();
187  }
188 
189 
190  private:
191  std::shared_ptr<T> gridp; // hold a shared pointer to a grid
192  };
193 
194  // specialization for yaspgrid; treats paralle case right
195  template<int dim>
196  class StructuredGrid<YaspGrid<dim> >
197  {
198  public:
199 
200  // export types
201  typedef YaspGrid<dim> Grid;
202  typedef typename Grid::ctype ctype;
203  static const int dimworld = Grid::dimensionworld;
204 
205  // simple constructor for the unit cube
206  StructuredGrid (Dune::GeometryType::BasicType meshtype, unsigned int cells, int overlap=1)
207  {
208  // check element type
209  if (meshtype!=Dune::GeometryType::cube)
210  std::cout << "StructuredGrid(): element type " << meshtype << " is ignored" << std::endl;
211 
212  // copy data to correct types for YaspGrid
213  Dune::FieldVector<double,dimworld> L(1.0);
214  std::array<int,dimworld> N(Dune::filledArray<dimworld, int>(cells));
215  std::bitset<dimworld> B(false);
216 
217  // instantiate the grid
218  gridp = std::shared_ptr<Grid>(new Grid(L,N,B,overlap,Dune::MPIHelper::getCollectiveCommunication()));
219  }
220 
221  // constructor with sizes given
222  StructuredGrid (Dune::GeometryType::BasicType meshtype,
223  std::array<double,dimworld> lower_left, std::array<double,dimworld> upper_right,
224  std::array<unsigned int,dim> cells, int overlap=1)
225  {
226  // check that lower right corner is the origin
227  for(int d = 0; d < dimworld; ++d)
228  if(std::abs(lower_left[d]) > std::abs(upper_right[d])*1e-10)
229  DUNE_THROW(GridError, className<StructuredGrid>()
230  << "::createCubeGrid(): The lower coordinates "
231  "must be at the origin for YaspGrid.");
232 
233  // check element type
234  if (meshtype!=Dune::GeometryType::cube)
235  std::cout << "StructuredGrid(): element type " << meshtype << " is ignored" << std::endl;
236 
237  // copy data to correct types for YaspGrid
238  Dune::FieldVector<double,dimworld> L;
239  std::array<int,dimworld> N;
240  std::bitset<dimworld> B(false);
241  for (size_t i=0; i<dimworld; i++)
242  {
243  L[i] = upper_right[i];
244  N[i] = cells[i];
245  }
246 
247  // instantiate the grid
248  gridp = std::shared_ptr<Grid>(new Grid(L,N,B,overlap,Dune::MPIHelper::getCollectiveCommunication()));
249  }
250 
251  // constructor with periodicity argument
252  StructuredGrid (Dune::GeometryType::BasicType meshtype,
253  std::array<double,dimworld> lower_left, std::array<double,dimworld> upper_right,
254  std::array<unsigned int,dim> cells, std::array<bool,dim> periodic, int overlap=1)
255  {
256  // check that lower right corner is the origin
257  for(int d = 0; d < dimworld; ++d)
258  if(std::abs(lower_left[d]) > std::abs(upper_right[d])*1e-10)
259  DUNE_THROW(GridError, className<StructuredGrid>()
260  << "::createCubeGrid(): The lower coordinates "
261  "must be at the origin for YaspGrid.");
262 
263  // check element type
264  if (meshtype!=Dune::GeometryType::cube)
265  std::cout << "StructuredGrid(): element type " << meshtype << " is ignored" << std::endl;
266 
267  // copy data to correct types for YaspGrid
268  Dune::FieldVector<double,dimworld> L;
269  std::array<int,dimworld> N;
270  std::bitset<dimworld> B(false);
271  for (size_t i=0; i<dimworld; i++)
272  {
273  L[i] = upper_right[i];
274  N[i] = cells[i];
275  B[i] = periodic[i];
276  }
277 
278  // instantiate the grid
279  gridp = std::shared_ptr<Grid>(new Grid(L,N,B,overlap,Dune::MPIHelper::getCollectiveCommunication()));
280  }
281 
282  // return shared pointer
283  std::shared_ptr<Grid> getSharedPtr ()
284  {
285  return gridp;
286  }
287 
288  // return grid reference
290  {
291  return *gridp;
292  }
293 
294  // return grid reference const version
295  const Grid& getGrid () const
296  {
297  return *gridp;
298  }
299 
301  {
302  return *gridp;
303  }
304 
306  {
307  return gridp.operator->();
308  }
309 
310  const Grid& operator*() const
311  {
312  return *gridp;
313  }
314 
315  const Grid* operator->() const
316  {
317  return gridp.operator->();
318  }
319 
320  private:
321  std::shared_ptr<Grid> gridp; // hold a shared pointer to a grid
322  };
323 
324  // unstructured grid read from gmsh file
325  template<typename T>
327  {
328  public:
329  // export types
330  typedef T Grid;
331  typedef typename T::ctype ctype;
332  static const int dim = T::dimension;
333  static const int dimworld = T::dimensionworld;
334 
335  // constructors
336  UnstructuredGrid (std::string filename, bool verbose = true, bool insert_boundary_segments=true)
337  {
338  Dune::GridFactory<T> factory;
339  Dune::GmshReader<T>::read(factory,filename,verbose,insert_boundary_segments);
340  gridp = std::shared_ptr<T>(factory.createGrid());
341  }
342 
343  // return shared pointer
344  std::shared_ptr<T> getSharedPtr ()
345  {
346  return gridp;
347  }
348 
349  // return grid reference
350  T& getGrid ()
351  {
352  return *gridp;
353  }
354 
355  // return grid reference const version
356  const T& getGrid () const
357  {
358  return *gridp;
359  }
360 
362  {
363  return *gridp;
364  }
365 
367  {
368  return gridp.operator->();
369  }
370 
371  const T& operator*() const
372  {
373  return *gridp;
374  }
375 
376  const T* operator->() const
377  {
378  return gridp.operator->();
379  }
380 
381  private:
382  std::shared_ptr<T> gridp; // hold a shared pointer to a grid
383  };
384 
385 
386  //============================================================================
387  // Continuous Lagrange Finite Element Space
388  //============================================================================
389 
390  // finite element map base template
391  template<typename GV, typename C, typename R, unsigned int degree, unsigned int dim, Dune::GeometryType::BasicType gt>
392  class CGFEMBase
393  {};
394 
395  template<typename GV, typename C, typename R, unsigned int degree, unsigned int dim>
396  class CGFEMBase<GV,C,R,degree,dim,Dune::GeometryType::simplex>
397  {
398  public:
400 
401  CGFEMBase (const GV& gridview)
402  {
403  femp = std::shared_ptr<FEM>(new FEM(gridview));
404  }
405 
406  FEM& getFEM() {return *femp;}
407  const FEM& getFEM() const {return *femp;}
408 
409  private:
410  std::shared_ptr<FEM> femp;
411  };
412 
413  template<typename GV, typename C, typename R, unsigned int degree, unsigned int dim>
414  class CGFEMBase<GV,C,R,degree,dim,Dune::GeometryType::cube>
415  {
416  public:
418 
419  CGFEMBase (const GV& gridview)
420  {
421  femp = std::shared_ptr<FEM>(new FEM(gridview));
422  }
423 
424  FEM& getFEM() {return *femp;}
425  const FEM& getFEM() const {return *femp;}
426 
427  private:
428  std::shared_ptr<FEM> femp;
429  };
430 
431  //============================================================================
432 
433  // define enumeration type that differentiate conforming and nonconforming meshes
434  enum MeshType {
437  };
438 
439  // constraints base template
440  template<typename Grid, unsigned int degree, Dune::GeometryType::BasicType gt, MeshType mt, SolverCategory::Category st, typename BCType, typename GV = typename Grid::LeafGridView>
441  class CGCONBase
442  {};
443 
444  template<typename Grid, typename BCType, typename GV>
445  class CGCONBase<Grid,1,Dune::GeometryType::simplex,MeshType::nonconforming,SolverCategory::sequential,BCType,GV>
446  {
447  public:
449 
450  CGCONBase (Grid& grid, const BCType& bctype, const GV& gv)
451  {
452  conp = std::shared_ptr<CON>(new CON(grid,true,bctype));
453  }
454 
455  CGCONBase (Grid& grid, const BCType& bctype)
456  {
457  conp = std::shared_ptr<CON>(new CON(grid,true,bctype));
458  }
459 
460  template<typename GFS>
461  void postGFSHook (const GFS& gfs) {}
462  CON& getCON() {return *conp;}
463  const CON& getCON() const {return *conp;}
464  template<typename GFS, typename DOF>
465  void make_consistent (const GFS& gfs, DOF& x) const {}
466  private:
467  std::shared_ptr<CON> conp;
468  };
469 
470  template<typename Grid, typename BCType, typename GV>
471  class CGCONBase<Grid,1,Dune::GeometryType::cube,MeshType::nonconforming,SolverCategory::sequential,BCType,GV>
472  {
473  public:
475 
476  CGCONBase (Grid& grid, const BCType& bctype, const GV& gv)
477  {
478  conp = std::shared_ptr<CON>(new CON(grid,true,bctype));
479  }
480 
481  CGCONBase (Grid& grid, const BCType& bctype)
482  {
483  conp = std::shared_ptr<CON>(new CON(grid,true,bctype));
484  }
485 
486  template<typename GFS>
487  void postGFSHook (const GFS& gfs) {}
488  CON& getCON() {return *conp;}
489  const CON& getCON() const {return *conp;}
490  template<typename GFS, typename DOF>
491  void make_consistent (const GFS& gfs, DOF& x) const {}
492  private:
493  std::shared_ptr<CON> conp;
494  };
495 
496  template<typename Grid, unsigned int degree, Dune::GeometryType::BasicType gt,typename BCType, typename GV>
497  class CGCONBase<Grid,degree,gt,MeshType::conforming,SolverCategory::sequential,BCType,GV>
498  {
499  public:
501 
502  CGCONBase (Grid& grid, const BCType& bctype, const GV& gv)
503  {
504  conp = std::shared_ptr<CON>(new CON());
505  }
506 
507  CGCONBase (Grid& grid, const BCType& bctype)
508  {
509  conp = std::shared_ptr<CON>(new CON());
510  }
511 
512  template<typename GFS>
513  void postGFSHook (const GFS& gfs) {}
514  CON& getCON() {return *conp;}
515  const CON& getCON() const {return *conp;}
516  template<typename GFS, typename DOF>
517  void make_consistent (const GFS& gfs, DOF& x) const {}
518  private:
519  std::shared_ptr<CON> conp;
520  };
521 
522  template<typename Grid, unsigned int degree, Dune::GeometryType::BasicType gt,typename BCType, typename GV>
523  class CGCONBase<Grid,degree,gt,MeshType::conforming,SolverCategory::overlapping,BCType,GV>
524  {
525  public:
527 
528  CGCONBase (Grid& grid, const BCType& bctype, const GV& gv)
529  {
530  conp = std::shared_ptr<CON>(new CON());
531  }
532 
533  CGCONBase (Grid& grid, const BCType& bctype)
534  {
535  conp = std::shared_ptr<CON>(new CON());
536  }
537 
538  template<typename GFS>
539  void postGFSHook (const GFS& gfs) {}
540  CON& getCON() {return *conp;}
541  const CON& getCON() const {return *conp;}
542  template<typename GFS, typename DOF>
543  void make_consistent (const GFS& gfs, DOF& x) const
544  {
545  // make vector consistent; this is needed for all overlapping solvers
546  ISTL::ParallelHelper<GFS> helper(gfs);
547  helper.maskForeignDOFs(Backend::native(x));
549  if (gfs.gridView().comm().size()>1)
550  gfs.gridView().communicate(adddh,Dune::InteriorBorder_All_Interface,Dune::ForwardCommunication);
551  }
552  private:
553  std::shared_ptr<CON> conp;
554  };
555 
556  template<typename Grid, unsigned int degree, Dune::GeometryType::BasicType gt,typename BCType, typename GV>
557  class CGCONBase<Grid,degree,gt,MeshType::conforming,SolverCategory::nonoverlapping,BCType,GV>
558  {
559  public:
561  CGCONBase (Grid& grid, const BCType& bctype)
562  {
563  conp = std::shared_ptr<CON>(new CON);
564  }
565 
566  template<typename GFS>
567  CON& getCON() {return *conp;}
568  const CON& getCON() const {return *conp;}
569  template<typename GFS, typename DOF>
570  void make_consistent (const GFS& gfs, DOF& x) const {}
571  private:
572  std::shared_ptr<CON> conp;
573  };
574 
575 
576  // continuous Lagrange finite elements
577  template<typename T, typename N, unsigned int degree, typename BCType,
578  Dune::GeometryType::BasicType gt, MeshType mt, SolverCategory::Category st = SolverCategory::sequential,
579  typename VBET=ISTL::VectorBackend<> >
580  class CGSpace {
581  public:
582 
583  // export types
584  typedef T Grid;
585  typedef typename T::LeafGridView GV;
586  typedef typename T::ctype ctype;
587  static const int dim = T::dimension;
588  static const int dimworld = T::dimensionworld;
589 
592 
593  typedef typename FEMB::FEM FEM;
594  typedef typename CONB::CON CON;
595 
596  typedef VBET VBE;
598 
599  typedef N NT;
602  typedef typename GFS::template ConstraintsContainer<N>::Type CC;
604 
605  // constructor making the grid function space an all that is needed
606  CGSpace (Grid& grid, const BCType& bctype)
607  : gv(grid.leafGridView()), femb(gv), conb(grid,bctype)
608  {
609  gfsp = std::shared_ptr<GFS>(new GFS(gv,femb.getFEM(),conb.getCON()));
610  gfsp->name("cgspace");
611  // initialize ordering
612  gfsp->update();
613  conb.postGFSHook(*gfsp);
614  ccp = std::shared_ptr<CC>(new CC());
615  }
616 
618  {
619  return femb.getFEM();
620  }
621 
622  const FEM& getFEM() const
623  {
624  return femb.getFEM();
625  }
626 
627  // return gfs reference
629  {
630  return *gfsp;
631  }
632 
633  // return gfs reference const version
634  const GFS& getGFS () const
635  {
636  return *gfsp;
637  }
638 
639  // return gfs reference
640  CC& getCC ()
641  {
642  return *ccp;
643  }
644 
645  // return gfs reference const version
646  const CC& getCC () const
647  {
648  return *ccp;
649  }
650 
651  void assembleConstraints (const BCType& bctype)
652  {
653  ccp->clear();
654  constraints(bctype,*gfsp,*ccp);
655  }
656 
658  {
659  ccp->clear();
660  }
661 
662  void setConstrainedDOFS (DOF& x, NT nt) const
663  {
664  set_constrained_dofs(*ccp,nt,x);
665  conb.make_consistent(*gfsp,x);
666  }
667 
668  void setNonConstrainedDOFS (DOF& x, NT nt) const
669  {
670  set_nonconstrained_dofs(*ccp,nt,x);
671  conb.make_consistent(*gfsp,x);
672  }
673 
674  void copyConstrainedDOFS (const DOF& xin, DOF& xout) const
675  {
676  copy_constrained_dofs(*ccp,xin,xout);
677  conb.make_consistent(*gfsp,xout);
678  }
679 
680  void copyNonConstrainedDOFS (const DOF& xin, DOF& xout) const
681  {
682  copy_nonconstrained_dofs(*ccp,xin,xout);
683  conb.make_consistent(*gfsp,xout);
684  }
685 
686  private:
687  GV gv; // need this object here because FEM and GFS store a const reference !!
688  FEMB femb;
689  CONB conb;
690  std::shared_ptr<GFS> gfsp;
691  std::shared_ptr<CC> ccp;
692  };
693 
694  // template specialization for nonoverlapping case
695  template<typename T, typename N, unsigned int degree, typename BCType,
696  Dune::GeometryType::BasicType gt, MeshType mt,
697  typename VBET>
698  class CGSpace<T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET> {
699  public:
700 
701  // export types
702  typedef T Grid;
703  typedef typename T::LeafGridView GV;
704  typedef typename T::ctype ctype;
706  static const int dim = T::dimension;
707  static const int dimworld = T::dimensionworld;
708 
711 
712  typedef typename FEMB::FEM FEM;
713  typedef typename CONB::CON CON;
714 
715  typedef VBET VBE;
717 
718  typedef N NT;
721  typedef typename GFS::template ConstraintsContainer<N>::Type CC;
723 
724  // constructor making the grid function space an all that is needed
725  CGSpace (Grid& grid, const BCType& bctype)
726  : gv(grid.leafGridView()), es(gv), femb(es), conb(grid,bctype)
727  {
728  gfsp = std::shared_ptr<GFS>(new GFS(es,femb.getFEM(),conb.getCON()));
729  gfsp->name("cgspace");
730  // initialize ordering
731  gfsp->update();
732  // conb.postGFSHook(*gfsp);
733  ccp = std::shared_ptr<CC>(new CC());
734  }
735 
737  {
738  return femb.getFEM();
739  }
740 
741  const FEM& getFEM() const
742  {
743  return femb.getFEM();
744  }
745 
746  // return gfs reference
748  {
749  return *gfsp;
750  }
751 
752  // return gfs reference const version
753  const GFS& getGFS () const
754  {
755  return *gfsp;
756  }
757 
758  // return gfs reference
759  CC& getCC ()
760  {
761  return *ccp;
762  }
763 
764  // return gfs reference const version
765  const CC& getCC () const
766  {
767  return *ccp;
768  }
769 
770  void assembleConstraints (const BCType& bctype)
771  {
772  ccp->clear();
773  constraints(bctype,*gfsp,*ccp);
774  }
775 
777  {
778  ccp->clear();
779  }
780 
781  void setConstrainedDOFS (DOF& x, NT nt) const
782  {
783  set_constrained_dofs(*ccp,nt,x);
784  conb.make_consistent(*gfsp,x);
785  }
786 
787  void setNonConstrainedDOFS (DOF& x, NT nt) const
788  {
789  set_nonconstrained_dofs(*ccp,nt,x);
790  conb.make_consistent(*gfsp,x);
791  }
792 
793  void copyConstrainedDOFS (const DOF& xin, DOF& xout) const
794  {
795  copy_constrained_dofs(*ccp,xin,xout);
796  conb.make_consistent(*gfsp,xout);
797  }
798 
799  void copyNonConstrainedDOFS (const DOF& xin, DOF& xout) const
800  {
801  copy_nonconstrained_dofs(*ccp,xin,xout);
802  conb.make_consistent(*gfsp,xout);
803  }
804 
805  private:
806  GV gv; // need this object here because FEM and GFS store a const reference !!
807  ES es;
808  FEMB femb;
809  CONB conb;
810  std::shared_ptr<GFS> gfsp;
811  std::shared_ptr<CC> ccp;
812  };
813 
814 
815 
816  //============================================================================
817  // Discontinuous Finite Element Space
818  //============================================================================
819 
820  // constraints base template
821  template<SolverCategory::Category st>
822  class DGCONBase
823  {};
824 
825  template<>
826  class DGCONBase<SolverCategory::sequential>
827  {
828  public:
831  {
832  conp = std::shared_ptr<CON>(new CON());
833  }
834  CON& getCON() {return *conp;}
835  const CON& getCON() const {return *conp;}
836  template<typename GFS, typename DOF>
837  void make_consistent (const GFS& gfs, DOF& x) const {}
838  private:
839  std::shared_ptr<CON> conp;
840  };
841 
842  template<>
843  class DGCONBase<SolverCategory::nonoverlapping>
844  {
845  public:
848  {
849  conp = std::shared_ptr<CON>(new CON());
850  }
851  CON& getCON() {return *conp;}
852  const CON& getCON() const {return *conp;}
853  template<typename GFS, typename DOF>
854  void make_consistent (const GFS& gfs, DOF& x) const {}
855  private:
856  std::shared_ptr<CON> conp;
857  };
858 
859  template<>
860  class DGCONBase<SolverCategory::overlapping>
861  {
862  public:
865  {
866  conp = std::shared_ptr<CON>(new CON());
867  }
868  CON& getCON() {return *conp;}
869  const CON& getCON() const {return *conp;}
870  template<typename GFS, typename DOF>
871  void make_consistent (const GFS& gfs, DOF& x) const
872  {
873  // make vector consistent; this is needed for all overlapping solvers
874  ISTL::ParallelHelper<GFS> helper(gfs);
875  helper.maskForeignDOFs(Backend::native(x));
877  if (gfs.gridView().comm().size()>1)
878  gfs.gridView().communicate(adddh,Dune::InteriorBorder_All_Interface,Dune::ForwardCommunication);
879  }
880  private:
881  std::shared_ptr<CON> conp;
882  };
883 
884  // Discontinuous space
885  // default implementation, use only specializations below
886  template<typename T, typename N, unsigned int degree,
887  Dune::GeometryType::BasicType gt, SolverCategory::Category st = SolverCategory::sequential,
889  class DGPkSpace
890  {
891  public:
892 
893  // export types
894  typedef T Grid;
895  typedef typename T::LeafGridView GV;
896  typedef typename T::ctype ctype;
897  static const int dim = T::dimension;
898  static const int dimworld = T::dimensionworld;
899  typedef N NT;
900 #if HAVE_GMP
902 #else
904 #endif
906  typedef typename CONB::CON CON;
907  typedef VBET VBE;
911  typedef typename GFS::template ConstraintsContainer<N>::Type CC;
913 
914  // constructor making the grid function space an all that is needed
915  DGPkSpace (const GV& gridview) : gv(gridview), conb()
916  {
917  femp = std::shared_ptr<FEM>(new FEM());
918  gfsp = std::shared_ptr<GFS>(new GFS(gv,*femp));
919  // initialize ordering
920  gfsp->update();
921  ccp = std::shared_ptr<CC>(new CC());
922  }
923 
924  FEM& getFEM() { return *femp; }
925  const FEM& getFEM() const { return *femp; }
926 
927  // return gfs reference
928  GFS& getGFS () { return *gfsp; }
929 
930  // return gfs reference const version
931  const GFS& getGFS () const {return *gfsp;}
932 
933  // return gfs reference
934  CC& getCC () { return *ccp;}
935 
936  // return gfs reference const version
937  const CC& getCC () const { return *ccp;}
938 
939  template<class BCTYPE>
940  void assembleConstraints (const BCTYPE& bctype)
941  {
942  ccp->clear();
943  constraints(bctype,*gfsp,*ccp);
944  }
945 
947  {
948  ccp->clear();
949  }
950 
951  void setConstrainedDOFS (DOF& x, NT nt) const
952  {
953  set_constrained_dofs(*ccp,nt,x);
954  conb.make_consistent(*gfsp,x);
955  }
956 
957  void setNonConstrainedDOFS (DOF& x, NT nt) const
958  {
959  set_nonconstrained_dofs(*ccp,nt,x);
960  conb.make_consistent(*gfsp,x);
961  }
962 
963  void copyConstrainedDOFS (const DOF& xin, DOF& xout) const
964  {
965  copy_constrained_dofs(*ccp,xin,xout);
966  conb.make_consistent(*gfsp,xout);
967  }
968 
969  void copyNonConstrainedDOFS (const DOF& xin, DOF& xout) const
970  {
971  copy_nonconstrained_dofs(*ccp,xin,xout);
972  conb.make_consistent(*gfsp,xout);
973  }
974 
975  private:
976  GV gv; // need this object here because FEM and GFS store a const reference !!
977  CONB conb;
978  std::shared_ptr<FEM> femp;
979  std::shared_ptr<GFS> gfsp;
980  std::shared_ptr<CC> ccp;
981  };
982 
983  // Discontinuous space
984  // default implementation, use only specializations below
985  template<typename T, typename N, unsigned int degree,
986  Dune::GeometryType::BasicType gt, SolverCategory::Category st = SolverCategory::sequential,
987  //typename VBET=ISTL::VectorBackend<ISTL::Blocking::fixed,Dune::PB::PkSize<degree,T::dimension>::value> >
988  typename VBET=ISTL::VectorBackend<> >
990  {
991  public:
992 
993  // export types
994  typedef T Grid;
995  typedef typename T::LeafGridView GV;
996  typedef typename T::ctype ctype;
997  static const int dim = T::dimension;
998  static const int dimworld = T::dimensionworld;
999  typedef N NT;
1000 #if HAVE_GMP
1002 #else
1004 #endif
1006  typedef typename CONB::CON CON;
1007  typedef VBET VBE;
1011  typedef typename GFS::template ConstraintsContainer<N>::Type CC;
1013 
1014  // constructor making the grid function space an all that is needed
1015  DGQkOPBSpace (const GV& gridview) : gv(gridview), conb()
1016  {
1017  femp = std::shared_ptr<FEM>(new FEM());
1018  gfsp = std::shared_ptr<GFS>(new GFS(gv,*femp));
1019  // initialize ordering
1020  gfsp->update();
1021  ccp = std::shared_ptr<CC>(new CC());
1022  }
1023 
1024  FEM& getFEM() { return *femp; }
1025  const FEM& getFEM() const { return *femp; }
1026 
1027  // return gfs reference
1028  GFS& getGFS () { return *gfsp; }
1029 
1030  // return gfs reference const version
1031  const GFS& getGFS () const {return *gfsp;}
1032 
1033  // return gfs reference
1034  CC& getCC () { return *ccp;}
1035 
1036  // return gfs reference const version
1037  const CC& getCC () const { return *ccp;}
1038 
1039  template<class BCTYPE>
1040  void assembleConstraints (const BCTYPE& bctype)
1041  {
1042  ccp->clear();
1043  constraints(bctype,*gfsp,*ccp);
1044  }
1045 
1047  {
1048  ccp->clear();
1049  }
1050 
1051  void setConstrainedDOFS (DOF& x, NT nt) const
1052  {
1053  set_constrained_dofs(*ccp,nt,x);
1054  conb.make_consistent(*gfsp,x);
1055  }
1056 
1057  void setNonConstrainedDOFS (DOF& x, NT nt) const
1058  {
1059  set_nonconstrained_dofs(*ccp,nt,x);
1060  conb.make_consistent(*gfsp,x);
1061  }
1062 
1063  void copyConstrainedDOFS (const DOF& xin, DOF& xout) const
1064  {
1065  copy_constrained_dofs(*ccp,xin,xout);
1066  conb.make_consistent(*gfsp,xout);
1067  }
1068 
1069  void copyNonConstrainedDOFS (const DOF& xin, DOF& xout) const
1070  {
1071  copy_nonconstrained_dofs(*ccp,xin,xout);
1072  conb.make_consistent(*gfsp,xout);
1073  }
1074 
1075  private:
1076  GV gv; // need this object here because FEM and GFS store a const reference !!
1077  CONB conb;
1078  std::shared_ptr<FEM> femp;
1079  std::shared_ptr<GFS> gfsp;
1080  std::shared_ptr<CC> ccp;
1081  };
1082 
1083  // Discontinuous space
1084  // default implementation, use only specializations below
1085  template<typename T, typename N, unsigned int degree,
1086  Dune::GeometryType::BasicType gt, SolverCategory::Category st = SolverCategory::sequential,
1089  {
1090  public:
1091 
1092  // export types
1093  typedef T Grid;
1094  typedef typename T::LeafGridView GV;
1095  typedef typename T::ctype ctype;
1096  static const int dim = T::dimension;
1097  static const int dimworld = T::dimensionworld;
1098  typedef N NT;
1099  typedef QkDGLocalFiniteElementMap<ctype,NT,degree,dim> FEM;
1101  typedef typename CONB::CON CON;
1102  typedef VBET VBE;
1106  typedef typename GFS::template ConstraintsContainer<N>::Type CC;
1108 
1109  // constructor making the grid function space an all that is needed
1110  DGQkSpace (const GV& gridview) : gv(gridview), conb()
1111  {
1112  femp = std::shared_ptr<FEM>(new FEM());
1113  gfsp = std::shared_ptr<GFS>(new GFS(gv,*femp));
1114  // initialize ordering
1115  gfsp->update();
1116  ccp = std::shared_ptr<CC>(new CC());
1117  }
1118 
1119  FEM& getFEM() { return *femp; }
1120  const FEM& getFEM() const { return *femp; }
1121 
1122  // return gfs reference
1123  GFS& getGFS () { return *gfsp; }
1124 
1125  // return gfs reference const version
1126  const GFS& getGFS () const {return *gfsp;}
1127 
1128  // return gfs reference
1129  CC& getCC () { return *ccp;}
1130 
1131  // return gfs reference const version
1132  const CC& getCC () const { return *ccp;}
1133 
1134  template<class BCTYPE>
1135  void assembleConstraints (const BCTYPE& bctype)
1136  {
1137  ccp->clear();
1138  constraints(bctype,*gfsp,*ccp);
1139  }
1140 
1142  {
1143  ccp->clear();
1144  }
1145 
1146  void setConstrainedDOFS (DOF& x, NT nt) const
1147  {
1148  set_constrained_dofs(*ccp,nt,x);
1149  conb.make_consistent(*gfsp,x);
1150  }
1151 
1152  void setNonConstrainedDOFS (DOF& x, NT nt) const
1153  {
1154  set_nonconstrained_dofs(*ccp,nt,x);
1155  conb.make_consistent(*gfsp,x);
1156  }
1157 
1158  void copyConstrainedDOFS (const DOF& xin, DOF& xout) const
1159  {
1160  copy_constrained_dofs(*ccp,xin,xout);
1161  conb.make_consistent(*gfsp,xout);
1162  }
1163 
1164  void copyNonConstrainedDOFS (const DOF& xin, DOF& xout) const
1165  {
1166  copy_nonconstrained_dofs(*ccp,xin,xout);
1167  conb.make_consistent(*gfsp,xout);
1168  }
1169 
1170  private:
1171  GV gv; // need this object here because FEM and GFS store a const reference !!
1172  CONB conb;
1173  std::shared_ptr<FEM> femp;
1174  std::shared_ptr<GFS> gfsp;
1175  std::shared_ptr<CC> ccp;
1176  };
1177 
1178 
1179  // Discontinuous space using QK with Gauss Lobatto points (use only for cube elements)
1180  template<typename T, typename N, unsigned int degree,
1181  Dune::GeometryType::BasicType gt, SolverCategory::Category st = SolverCategory::sequential,
1182  //typename VBET=ISTL::VectorBackend<ISTL::Blocking::fixed,Dune::QkStuff::QkSize<degree,T::dimension>::value> >
1183  typename VBET=ISTL::VectorBackend<> >
1185  {
1186  public:
1187 
1188  // export types
1189  typedef T Grid;
1190  typedef typename T::LeafGridView GV;
1191  typedef typename T::ctype ctype;
1192  static const int dim = T::dimension;
1193  static const int dimworld = T::dimensionworld;
1194  typedef N NT;
1195  typedef QkDGLocalFiniteElementMap<ctype,NT,degree,dim,QkDGBasisPolynomial::lobatto> FEM;
1197  typedef typename CONB::CON CON;
1198  typedef VBET VBE;
1202  typedef typename GFS::template ConstraintsContainer<N>::Type CC;
1204 
1205  // constructor making the grid function space an all that is needed
1206  DGQkGLSpace (const GV& gridview) : gv(gridview), conb()
1207  {
1208  femp = std::shared_ptr<FEM>(new FEM());
1209  gfsp = std::shared_ptr<GFS>(new GFS(gv,*femp));
1210  // initialize ordering
1211  gfsp->update();
1212  ccp = std::shared_ptr<CC>(new CC());
1213  }
1214 
1215  FEM& getFEM() { return *femp; }
1216  const FEM& getFEM() const { return *femp; }
1217 
1218  // return gfs reference
1219  GFS& getGFS () { return *gfsp; }
1220 
1221  // return gfs reference const version
1222  const GFS& getGFS () const {return *gfsp;}
1223 
1224  // return gfs reference
1225  CC& getCC () { return *ccp;}
1226 
1227  // return gfs reference const version
1228  const CC& getCC () const { return *ccp;}
1229 
1230  template<class BCTYPE>
1231  void assembleConstraints (const BCTYPE& bctype)
1232  {
1233  ccp->clear();
1234  constraints(bctype,*gfsp,*ccp);
1235  }
1236 
1238  {
1239  ccp->clear();
1240  }
1241 
1242  void setConstrainedDOFS (DOF& x, NT nt) const
1243  {
1244  set_constrained_dofs(*ccp,nt,x);
1245  conb.make_consistent(*gfsp,x);
1246  }
1247 
1248  void setNonConstrainedDOFS (DOF& x, NT nt) const
1249  {
1250  set_nonconstrained_dofs(*ccp,nt,x);
1251  conb.make_consistent(*gfsp,x);
1252  }
1253 
1254  void copyConstrainedDOFS (const DOF& xin, DOF& xout) const
1255  {
1256  copy_constrained_dofs(*ccp,xin,xout);
1257  conb.make_consistent(*gfsp,xout);
1258  }
1259 
1260  void copyNonConstrainedDOFS (const DOF& xin, DOF& xout) const
1261  {
1262  copy_nonconstrained_dofs(*ccp,xin,xout);
1263  conb.make_consistent(*gfsp,xout);
1264  }
1265 
1266  private:
1267  GV gv; // need this object here because FEM and GFS store a const reference !!
1268  CONB conb;
1269  std::shared_ptr<FEM> femp;
1270  std::shared_ptr<GFS> gfsp;
1271  std::shared_ptr<CC> ccp;
1272  };
1273 
1274 
1275  // Discontinuous space using Legendre polynomials (use only for cube elements)
1276  template<typename T, typename N, unsigned int degree,
1277  Dune::GeometryType::BasicType gt, SolverCategory::Category st = SolverCategory::sequential,
1278  //typename VBET=ISTL::VectorBackend<ISTL::Blocking::fixed,Dune::QkStuff::QkSize<degree,T::dimension>::value> >
1279  typename VBET=ISTL::VectorBackend<> >
1281  {
1282  public:
1283 
1284  // export types
1285  typedef T Grid;
1286  typedef typename T::LeafGridView GV;
1287  typedef typename T::ctype ctype;
1288  static const int dim = T::dimension;
1289  static const int dimworld = T::dimensionworld;
1290  typedef N NT;
1291  typedef QkDGLocalFiniteElementMap<ctype,NT,degree,dim,QkDGBasisPolynomial::legendre> FEM;
1293  typedef typename CONB::CON CON;
1294  typedef VBET VBE;
1298  typedef typename GFS::template ConstraintsContainer<N>::Type CC;
1300 
1301  // constructor making the grid function space an all that is needed
1302  DGLegendreSpace (const GV& gridview) : gv(gridview), conb()
1303  {
1304  femp = std::shared_ptr<FEM>(new FEM());
1305  gfsp = std::shared_ptr<GFS>(new GFS(gv,*femp));
1306  // initialize ordering
1307  gfsp->update();
1308  ccp = std::shared_ptr<CC>(new CC());
1309  }
1310 
1311  FEM& getFEM() { return *femp; }
1312  const FEM& getFEM() const { return *femp; }
1313 
1314  // return gfs reference
1315  GFS& getGFS () { return *gfsp; }
1316 
1317  // return gfs reference const version
1318  const GFS& getGFS () const {return *gfsp;}
1319 
1320  // return gfs reference
1321  CC& getCC () { return *ccp;}
1322 
1323  // return gfs reference const version
1324  const CC& getCC () const { return *ccp;}
1325 
1326  template<class BCTYPE>
1327  void assembleConstraints (const BCTYPE& bctype)
1328  {
1329  ccp->clear();
1330  constraints(bctype,*gfsp,*ccp);
1331  }
1332 
1334  {
1335  ccp->clear();
1336  }
1337 
1338  void setConstrainedDOFS (DOF& x, NT nt) const
1339  {
1340  set_constrained_dofs(*ccp,nt,x);
1341  conb.make_consistent(*gfsp,x);
1342  }
1343 
1344  void setNonConstrainedDOFS (DOF& x, NT nt) const
1345  {
1346  set_nonconstrained_dofs(*ccp,nt,x);
1347  conb.make_consistent(*gfsp,x);
1348  }
1349 
1350  void copyConstrainedDOFS (const DOF& xin, DOF& xout) const
1351  {
1352  copy_constrained_dofs(*ccp,xin,xout);
1353  conb.make_consistent(*gfsp,xout);
1354  }
1355 
1356  void copyNonConstrainedDOFS (const DOF& xin, DOF& xout) const
1357  {
1358  copy_nonconstrained_dofs(*ccp,xin,xout);
1359  conb.make_consistent(*gfsp,xout);
1360  }
1361 
1362  private:
1363  GV gv; // need this object here because FEM and GFS store a const reference !!
1364  CONB conb;
1365  std::shared_ptr<FEM> femp;
1366  std::shared_ptr<GFS> gfsp;
1367  std::shared_ptr<CC> ccp;
1368  };
1369 
1370 
1371  // Discontinuous P0 space
1372  template<typename T, typename N,
1373  Dune::GeometryType::BasicType gt, SolverCategory::Category st = SolverCategory::sequential,
1374  typename VBET=ISTL::VectorBackend<> >
1375  class P0Space
1376  {
1377  public:
1378 
1379  // export types
1380  typedef T Grid;
1381  typedef typename T::LeafGridView GV;
1382  typedef typename T::ctype ctype;
1383  static const int dim = T::dimension;
1384  static const int dimworld = T::dimensionworld;
1385  typedef N NT;
1388  typedef typename CONB::CON CON;
1389  typedef VBET VBE;
1393  typedef typename GFS::template ConstraintsContainer<N>::Type CC;
1395 
1396  // constructor making the grid function space an all that is needed
1397  P0Space (const GV& gridview) : gv(gridview), conb()
1398  {
1399  femp = std::shared_ptr<FEM>(new FEM(Dune::GeometryType(gt,dim)));
1400  gfsp = std::shared_ptr<GFS>(new GFS(gv,*femp));
1401  // initialize ordering
1402  gfsp->update();
1403  ccp = std::shared_ptr<CC>(new CC());
1404  }
1405 
1406  FEM& getFEM() { return *femp; }
1407  const FEM& getFEM() const { return *femp; }
1408 
1409  // return gfs reference
1410  GFS& getGFS () { return *gfsp; }
1411 
1412  // return gfs reference const version
1413  const GFS& getGFS () const {return *gfsp;}
1414 
1415  // return gfs reference
1416  CC& getCC () { return *ccp;}
1417 
1418  // return gfs reference const version
1419  const CC& getCC () const { return *ccp;}
1420 
1421  template<class BCTYPE>
1422  void assembleConstraints (const BCTYPE& bctype)
1423  {
1424  ccp->clear();
1425  constraints(bctype,*gfsp,*ccp);
1426  }
1427 
1429  {
1430  ccp->clear();
1431  }
1432 
1433  void setConstrainedDOFS (DOF& x, NT nt) const
1434  {
1435  set_constrained_dofs(*ccp,nt,x);
1436  conb.make_consistent(*gfsp,x);
1437  }
1438 
1439  void setNonConstrainedDOFS (DOF& x, NT nt) const
1440  {
1441  set_nonconstrained_dofs(*ccp,nt,x);
1442  conb.make_consistent(*gfsp,x);
1443  }
1444 
1445  void copyConstrainedDOFS (const DOF& xin, DOF& xout) const
1446  {
1447  copy_constrained_dofs(*ccp,xin,xout);
1448  conb.make_consistent(*gfsp,xout);
1449  }
1450 
1451  void copyNonConstrainedDOFS (const DOF& xin, DOF& xout) const
1452  {
1453  copy_nonconstrained_dofs(*ccp,xin,xout);
1454  conb.make_consistent(*gfsp,xout);
1455  }
1456 
1457  private:
1458  GV gv; // need this object here because FEM and GFS store a const reference !!
1459  CONB conb;
1460  std::shared_ptr<FEM> femp;
1461  std::shared_ptr<GFS> gfsp;
1462  std::shared_ptr<CC> ccp;
1463  };
1464 
1465 
1466  // how can we most easily specify a grid function
1467  // pass a function space as parameter
1468  template<typename FS, typename Functor>
1470  : public GridFunctionBase<GridFunctionTraits<typename FS::GV, typename FS::NT,
1471  1,FieldVector<typename FS::NT,1> >
1472  ,UserFunction<FS,Functor> >
1473  {
1474  public:
1475  typedef GridFunctionTraits<typename FS::GV, typename FS::NT,
1476  1,FieldVector<typename FS::NT,1> > Traits;
1477 
1479  UserFunction (const FS& fs_, const Functor& f_)
1480  : fs(fs_), f(f_)
1481  {}
1482 
1484  inline void evaluate (const typename Traits::ElementType& e,
1485  const typename Traits::DomainType& x,
1486  typename Traits::RangeType& y) const
1487  {
1488  typename Traits::DomainType x_ = e.geometry().global(x);
1489  std::vector<double> x__(x.size());
1490  for (size_t i=0; i<x.size(); ++i) x__[i]=x_[i];
1491  y = f(x__);
1492  }
1493 
1494  inline const typename FS::GV& getGridView () const
1495  {
1496  return fs.getGFS().gridView();
1497  }
1498 
1499  private:
1500  const FS fs; // store a copy of the function space
1501  const Functor f;
1502  };
1503 
1504 
1505  template<typename FS, typename LOP, SolverCategory::Category st = SolverCategory::sequential>
1507  {
1508  public:
1509  // export types
1511  typedef Dune::PDELab::GridOperator<typename FS::GFS,typename FS::GFS,LOP,MBE,
1512  typename FS::NT,typename FS::NT,typename FS::NT,
1513  typename FS::CC,typename FS::CC> GO;
1514  typedef typename GO::Jacobian MAT;
1515 
1516  GalerkinGlobalAssembler (const FS& fs, LOP& lop, const std::size_t nonzeros)
1517  {
1518  gop = std::shared_ptr<GO>(new GO(fs.getGFS(),fs.getCC(),fs.getGFS(),fs.getCC(),lop,MBE(nonzeros)));
1519  }
1520 
1521  // return grid reference
1522  GO& getGO ()
1523  {
1524  return *gop;
1525  }
1526 
1527  // return grid reference const version
1528  const GO& getGO () const
1529  {
1530  return *gop;
1531  }
1532 
1534  {
1535  return *gop;
1536  }
1537 
1539  {
1540  return gop.operator->();
1541  }
1542 
1543  const GO& operator*() const
1544  {
1545  return *gop;
1546  }
1547 
1548  const GO* operator->() const
1549  {
1550  return gop.operator->();
1551  }
1552 
1553  private:
1554  std::shared_ptr<GO> gop;
1555  };
1556 
1557 
1558  template<typename FS, typename LOP, SolverCategory::Category st = SolverCategory::sequential>
1560  {
1561  public:
1562  // export types
1564  typedef Dune::PDELab::GridOperator<typename FS::GFS,typename FS::GFS,LOP,MBE,
1565  typename FS::NT,typename FS::NT,typename FS::NT,
1566  typename FS::CC,typename FS::CC> GO;
1567  typedef typename GO::Jacobian MAT;
1568 
1569  GalerkinGlobalAssemblerNewBackend (const FS& fs, LOP& lop, const MBE& mbe)
1570  {
1571  gop = std::shared_ptr<GO>(new GO(fs.getGFS(),fs.getCC(),fs.getGFS(),fs.getCC(),lop,mbe));
1572  }
1573 
1574  // return grid reference
1575  GO& getGO ()
1576  {
1577  return *gop;
1578  }
1579 
1580  // return grid reference const version
1581  const GO& getGO () const
1582  {
1583  return *gop;
1584  }
1585 
1587  {
1588  return *gop;
1589  }
1590 
1592  {
1593  return gop.operator->();
1594  }
1595 
1596  const GO& operator*() const
1597  {
1598  return *gop;
1599  }
1600 
1601  const GO* operator->() const
1602  {
1603  return gop.operator->();
1604  }
1605 
1606  private:
1607  std::shared_ptr<GO> gop;
1608  };
1609 
1610 
1611  // variant with two different function spaces
1612  template<typename FSU, typename FSV, typename LOP, SolverCategory::Category st>
1614  {
1615  public:
1616  // export types
1618  typedef Dune::PDELab::GridOperator<typename FSU::GFS,typename FSV::GFS,LOP,MBE,
1619  typename FSU::NT,typename FSU::NT,typename FSU::NT,
1620  typename FSU::CC,typename FSV::CC> GO;
1621  typedef typename GO::Jacobian MAT;
1622 
1623  GlobalAssembler (const FSU& fsu, const FSV& fsv, LOP& lop, const std::size_t nonzeros)
1624  {
1625  gop = std::shared_ptr<GO>(new GO(fsu.getGFS(),fsu.getCC(),fsv.getGFS(),fsv.getCC(),lop,MBE(nonzeros)));
1626  }
1627 
1628  // return grid reference
1629  GO& getGO ()
1630  {
1631  return *gop;
1632  }
1633 
1634  // return grid reference const version
1635  const GO& getGO () const
1636  {
1637  return *gop;
1638  }
1639 
1641  {
1642  return *gop;
1643  }
1644 
1646  {
1647  return gop.operator->();
1648  }
1649 
1650  const GO& operator*() const
1651  {
1652  return *gop;
1653  }
1654 
1655  const GO* operator->() const
1656  {
1657  return gop.operator->();
1658  }
1659 
1660  private:
1661  std::shared_ptr<GO> gop;
1662  };
1663 
1664 
1665  template<typename GO1, typename GO2, bool implicit = true>
1667  {
1668  public:
1669  // export types
1672  typedef typename GO::Jacobian MAT;
1673 
1674  OneStepGlobalAssembler (GO1& go1, GO2& go2)
1675  {
1676  gop = std::shared_ptr<GO>(new GO(*go1,*go2));
1677  }
1678 
1679  // return grid reference
1680  GO& getGO ()
1681  {
1682  return *gop;
1683  }
1684 
1685  // return grid reference const version
1686  const GO& getGO () const
1687  {
1688  return *gop;
1689  }
1690 
1692  {
1693  return *gop;
1694  }
1695 
1697  {
1698  return gop.operator->();
1699  }
1700 
1701  const GO& operator*() const
1702  {
1703  return *gop;
1704  }
1705 
1706  const GO* operator->() const
1707  {
1708  return gop.operator->();
1709  }
1710 
1711  private:
1712  std::shared_ptr<GO> gop;
1713  };
1714 
1715 
1716  // packaging of the CG_AMG_SSOR solver: default version is sequential
1717  template<typename FS, typename ASS, SolverCategory::Category st = SolverCategory::sequential>
1719  {
1720  public:
1721  // types exported
1723 
1724  ISTLSolverBackend_CG_AMG_SSOR (const FS& fs, const ASS& ass, unsigned maxiter_=5000,
1725  int verbose_=1, bool reuse_=false, bool usesuperlu_=true)
1726  {
1727  lsp = std::shared_ptr<LS>(new LS(maxiter_,verbose_,reuse_,usesuperlu_));
1728  }
1729 
1730  LS& getLS () {return *lsp;}
1731  const LS& getLS () const { return *lsp;}
1732  LS& operator*(){return *lsp;}
1733  LS* operator->() { return lsp.operator->(); }
1734  const LS& operator*() const{return *lsp;}
1735  const LS* operator->() const{ return lsp.operator->();}
1736 
1737  private:
1738  std::shared_ptr<LS> lsp;
1739  };
1740 
1741  // packaging of the CG_AMG_SSOR solver: nonoverlapping version
1742  template<typename FS, typename ASS>
1743  class ISTLSolverBackend_CG_AMG_SSOR<FS,ASS, SolverCategory::nonoverlapping>
1744  {
1745  public:
1746  // types exported
1748 
1749  ISTLSolverBackend_CG_AMG_SSOR (const FS& fs, const ASS& ass, unsigned maxiter_=5000,
1750  int verbose_=1, bool reuse_=false, bool usesuperlu_=true)
1751  {
1752  lsp = std::shared_ptr<LS>(new LS(fs.getGFS(),maxiter_,verbose_,reuse_,usesuperlu_));
1753  }
1754 
1755  LS& getLS () {return *lsp;}
1756  const LS& getLS () const { return *lsp;}
1757  LS& operator*(){return *lsp;}
1758  LS* operator->() { return lsp.operator->(); }
1759  const LS& operator*() const{return *lsp;}
1760  const LS* operator->() const{ return lsp.operator->();}
1761 
1762  private:
1763  std::shared_ptr<LS> lsp;
1764  };
1765 
1766  // packaging of the CG_AMG_SSOR solver: overlapping version
1767  template<typename FS, typename ASS>
1768  class ISTLSolverBackend_CG_AMG_SSOR<FS,ASS, SolverCategory::overlapping>
1769  {
1770  public:
1771  // types exported
1773 
1774  ISTLSolverBackend_CG_AMG_SSOR (const FS& fs, const ASS& ass, unsigned maxiter_=5000,
1775  int verbose_=1, bool reuse_=false, bool usesuperlu_=true)
1776  {
1777  lsp = std::shared_ptr<LS>(new LS(fs.getGFS(),maxiter_,verbose_,reuse_,usesuperlu_));
1778  }
1779 
1780  LS& getLS () {return *lsp;}
1781  const LS& getLS () const { return *lsp;}
1782  LS& operator*(){return *lsp;}
1783  LS* operator->() { return lsp.operator->(); }
1784  const LS& operator*() const{return *lsp;}
1785  const LS* operator->() const{ return lsp.operator->();}
1786 
1787  private:
1788  std::shared_ptr<LS> lsp;
1789  };
1790 
1791  // packaging of the CG_SSOR solver: default version is sequential
1792  template<typename FS, typename ASS, SolverCategory::Category st = SolverCategory::sequential>
1794  {
1795  public:
1796  // types exported
1798 
1799  ISTLSolverBackend_CG_SSOR (const FS& fs, const ASS& ass, unsigned maxiter_=5000,
1800  int steps_=5, int verbose_=1)
1801  {
1802  lsp = std::shared_ptr<LS>(new LS(maxiter_,verbose_));
1803  }
1804 
1805  LS& getLS () {return *lsp;}
1806  const LS& getLS () const { return *lsp;}
1807  LS& operator*(){return *lsp;}
1808  LS* operator->() { return lsp.operator->(); }
1809  const LS& operator*() const{return *lsp;}
1810  const LS* operator->() const{ return lsp.operator->();}
1811 
1812  private:
1813  std::shared_ptr<LS> lsp;
1814  };
1815 
1816  // packaging of the CG_SSOR solver: nonoverlapping version
1817  template<typename FS, typename ASS>
1818  class ISTLSolverBackend_CG_SSOR<FS,ASS,SolverCategory::nonoverlapping>
1819  {
1820  public:
1821  // types exported
1823 
1824  ISTLSolverBackend_CG_SSOR (const FS& fs, const ASS& ass, unsigned maxiter_=5000,
1825  int steps_=5, int verbose_=1)
1826  {
1827  lsp = std::shared_ptr<LS>(new LS(fs.getGFS(),maxiter_,steps_,verbose_));
1828  }
1829 
1830  LS& getLS () {return *lsp;}
1831  const LS& getLS () const { return *lsp;}
1832  LS& operator*(){return *lsp;}
1833  LS* operator->() { return lsp.operator->(); }
1834  const LS& operator*() const{return *lsp;}
1835  const LS* operator->() const{ return lsp.operator->();}
1836 
1837  private:
1838  std::shared_ptr<LS> lsp;
1839  };
1840 
1841  // packaging of the CG_SSOR solver: overlapping version
1842  template<typename FS, typename ASS>
1843  class ISTLSolverBackend_CG_SSOR<FS,ASS,SolverCategory::overlapping>
1844  {
1845  public:
1846  // types exported
1848 
1849  ISTLSolverBackend_CG_SSOR (const FS& fs, const ASS& ass, unsigned maxiter_=5000,
1850  int steps_=5, int verbose_=1)
1851  {
1852  lsp = std::shared_ptr<LS>(new LS(fs.getGFS(),fs.getCC(),maxiter_,steps_,verbose_));
1853  }
1854 
1855  LS& getLS () {return *lsp;}
1856  const LS& getLS () const { return *lsp;}
1857  LS& operator*(){return *lsp;}
1858  LS* operator->() { return lsp.operator->(); }
1859  const LS& operator*() const{return *lsp;}
1860  const LS* operator->() const{ return lsp.operator->();}
1861 
1862  private:
1863  std::shared_ptr<LS> lsp;
1864  };
1865 
1866 
1867  // packaging of a default solver that should always work
1868  // in the sequential case : BCGS SSOR
1869  template<typename FS, typename ASS, SolverCategory::Category st = SolverCategory::sequential>
1871  {
1872  public:
1873  // types exported
1875 
1876  ISTLSolverBackend_IterativeDefault (const FS& fs, const ASS& ass, unsigned maxiter_=5000, int verbose_=1)
1877  {
1878  lsp = std::shared_ptr<LS>(new LS(maxiter_,verbose_));
1879  }
1880 
1881  LS& getLS () {return *lsp;}
1882  const LS& getLS () const { return *lsp;}
1883  LS& operator*(){return *lsp;}
1884  LS* operator->() { return lsp.operator->(); }
1885  const LS& operator*() const{return *lsp;}
1886  const LS* operator->() const{ return lsp.operator->();}
1887 
1888  private:
1889  std::shared_ptr<LS> lsp;
1890  };
1891 
1892  // in the nonoverlapping case : BCGS SSORk
1893  template<typename FS, typename ASS>
1894  class ISTLSolverBackend_IterativeDefault<FS,ASS,SolverCategory::nonoverlapping>
1895  {
1896  public:
1897  // types exported
1899 
1900  ISTLSolverBackend_IterativeDefault (const FS& fs, const ASS& ass, unsigned maxiter_=5000, int verbose_=1)
1901  {
1902  lsp = std::shared_ptr<LS>(new LS(ass.getGO(),maxiter_,3,verbose_));
1903  }
1904 
1905  LS& getLS () {return *lsp;}
1906  const LS& getLS () const { return *lsp;}
1907  LS& operator*(){return *lsp;}
1908  LS* operator->() { return lsp.operator->(); }
1909  const LS& operator*() const{return *lsp;}
1910  const LS* operator->() const{ return lsp.operator->();}
1911 
1912  private:
1913  std::shared_ptr<LS> lsp;
1914  };
1915 
1916  // in the overlapping case : BCGS SSORk
1917  template<typename FS, typename ASS>
1918  class ISTLSolverBackend_IterativeDefault<FS,ASS,SolverCategory::overlapping>
1919  {
1920  public:
1921  // types exported
1923 
1924  ISTLSolverBackend_IterativeDefault (const FS& fs, const ASS& ass, unsigned maxiter_=5000, int verbose_=1)
1925  {
1926  lsp = std::shared_ptr<LS>(new LS(fs.getGFS(),fs.getCC(),maxiter_,3,verbose_));
1927  }
1928 
1929  LS& getLS () {return *lsp;}
1930  const LS& getLS () const { return *lsp;}
1931  LS& operator*(){return *lsp;}
1932  LS* operator->() { return lsp.operator->(); }
1933  const LS& operator*() const{return *lsp;}
1934  const LS* operator->() const{ return lsp.operator->();}
1935 
1936  private:
1937  std::shared_ptr<LS> lsp;
1938  };
1939 
1940  // packaging of a default solver that should always work
1941  // in the sequential case : BCGS SSOR
1942  template<typename FS, typename ASS, SolverCategory::Category st = SolverCategory::sequential>
1944  {
1945  public:
1946  // types exported
1948 
1949  ISTLSolverBackend_ExplicitDiagonal (const FS& fs, const ASS& ass, unsigned maxiter_=5000, int verbose_=1)
1950  {
1951  lsp = std::shared_ptr<LS>(new LS());
1952  }
1953 
1954  LS& getLS () {return *lsp;}
1955  const LS& getLS () const { return *lsp;}
1956  LS& operator*(){return *lsp;}
1957  LS* operator->() { return lsp.operator->(); }
1958  const LS& operator*() const{return *lsp;}
1959  const LS* operator->() const{ return lsp.operator->();}
1960 
1961  private:
1962  std::shared_ptr<LS> lsp;
1963  };
1964 
1965  // packaging of a default solver that should always work
1966  // in the sequential case : BCGS SSOR
1967  template<typename FS, typename ASS>
1968  class ISTLSolverBackend_ExplicitDiagonal<FS,ASS,SolverCategory::overlapping>
1969  {
1970  public:
1971  // types exported
1973 
1974  ISTLSolverBackend_ExplicitDiagonal (const FS& fs, const ASS& ass, unsigned maxiter_=5000, int verbose_=1)
1975  {
1976  lsp = std::shared_ptr<LS>(new LS(fs.getGFS()));
1977  }
1978 
1979  LS& getLS () {return *lsp;}
1980  const LS& getLS () const { return *lsp;}
1981  LS& operator*(){return *lsp;}
1982  LS* operator->() { return lsp.operator->(); }
1983  const LS& operator*() const{return *lsp;}
1984  const LS* operator->() const{ return lsp.operator->();}
1985 
1986  private:
1987  std::shared_ptr<LS> lsp;
1988  };
1989 
1990  // packaging of a default solver that should always work
1991  // in the sequential case : BCGS SSOR
1992  template<typename FS, typename ASS>
1993  class ISTLSolverBackend_ExplicitDiagonal<FS,ASS,SolverCategory::nonoverlapping>
1994  {
1995  public:
1996  // types exported
1998 
1999  ISTLSolverBackend_ExplicitDiagonal (const FS& fs, const ASS& ass, unsigned maxiter_=5000, int verbose_=1)
2000  {
2001  lsp = std::shared_ptr<LS>(new LS(fs.getGFS()));
2002  }
2003 
2004  LS& getLS () {return *lsp;}
2005  const LS& getLS () const { return *lsp;}
2006  LS& operator*(){return *lsp;}
2007  LS* operator->() { return lsp.operator->(); }
2008  const LS& operator*() const{return *lsp;}
2009  const LS* operator->() const{ return lsp.operator->();}
2010 
2011  private:
2012  std::shared_ptr<LS> lsp;
2013  };
2014 
2015 
2016 } // end namespace PDELab
2017  } // end namespace Dune
2018 
2019 #endif // DUNE_PDELAB_BOILERPLATE_PDELAB_HH
Dune::PDELab::UnstructuredGrid::getSharedPtr
std::shared_ptr< T > getSharedPtr()
Definition: pdelab/boilerplate/pdelab.hh:344
Dune::PDELab::StructuredGrid::operator->
T * operator->()
Definition: pdelab/boilerplate/pdelab.hh:174
Dune::PDELab::DGPkSpace::setConstrainedDOFS
void setConstrainedDOFS(DOF &x, NT nt) const
Definition: pdelab/boilerplate/pdelab.hh:951
onestep.hh
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::ctype
T::ctype ctype
Definition: pdelab/boilerplate/pdelab.hh:704
Dune::PDELab::DGQkSpace::setNonConstrainedDOFS
void setNonConstrainedDOFS(DOF &x, NT nt) const
Definition: pdelab/boilerplate/pdelab.hh:1152
Dune::PDELab::DGQkSpace::DOF
Backend::Vector< GFS, N > DOF
Definition: pdelab/boilerplate/pdelab.hh:1104
Dune::PDELab::DGQkOPBSpace::GV
T::LeafGridView GV
Definition: pdelab/boilerplate/pdelab.hh:995
Dune::PDELab::CGCONBase< Grid, 1, Dune::GeometryType::cube, MeshType::nonconforming, SolverCategory::sequential, BCType, GV >::make_consistent
void make_consistent(const GFS &gfs, DOF &x) const
Definition: pdelab/boilerplate/pdelab.hh:491
function.hh
Dune::PDELab::DGLegendreSpace::getCC
const CC & getCC() const
Definition: pdelab/boilerplate/pdelab.hh:1324
Dune::PDELab::ISTLSolverBackend_CG_SSOR< FS, ASS, SolverCategory::nonoverlapping >::operator->
const LS * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:1835
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::VBE
VBET VBE
Definition: pdelab/boilerplate/pdelab.hh:715
Dune::PDELab::DGLegendreSpace::GFS
GridFunctionSpace< GV, FEM, CON, VBE > GFS
Definition: pdelab/boilerplate/pdelab.hh:1295
Dune::PDELab::DGLegendreSpace::NT
N NT
Definition: pdelab/boilerplate/pdelab.hh:1290
Dune::PDELab::DGLegendreSpace::ctype
T::ctype ctype
Definition: pdelab/boilerplate/pdelab.hh:1287
Dune::PDELab::DGQkOPBSpace::VBE
VBET VBE
Definition: pdelab/boilerplate/pdelab.hh:1007
Dune::PDELab::ISTLSolverBackend_CG_SSOR< FS, ASS, SolverCategory::nonoverlapping >::operator*
LS & operator*()
Definition: pdelab/boilerplate/pdelab.hh:1832
Dune::PDELab::StructuredGrid< YaspGrid< dim > >::operator->
const Grid * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:315
Dune::PDELab::DGCONBase< SolverCategory::nonoverlapping >::make_consistent
void make_consistent(const GFS &gfs, DOF &x) const
Definition: pdelab/boilerplate/pdelab.hh:854
Dune::PDELab::StructuredGrid::getGrid
T & getGrid()
Definition: pdelab/boilerplate/pdelab.hh:158
Dune::PDELab::DGQkSpace::clearConstraints
void clearConstraints()
Definition: pdelab/boilerplate/pdelab.hh:1141
Dune::PDELab::GridOperator
Standard grid operator implementation.
Definition: gridoperator.hh:35
Dune::PDELab::ISTLSolverBackend_IterativeDefault< FS, ASS, SolverCategory::nonoverlapping >::getLS
LS & getLS()
Definition: pdelab/boilerplate/pdelab.hh:1905
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal::getLS
LS & getLS()
Definition: pdelab/boilerplate/pdelab.hh:1954
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::sequential, BCType, GV >::CON
ConformingDirichletConstraints CON
Definition: pdelab/boilerplate/pdelab.hh:500
opbfem.hh
Dune::PDELab::UnstructuredGrid::UnstructuredGrid
UnstructuredGrid(std::string filename, bool verbose=true, bool insert_boundary_segments=true)
Definition: pdelab/boilerplate/pdelab.hh:336
Dune::PDELab::DGPkSpace::DGPkSpace
DGPkSpace(const GV &gridview)
Definition: pdelab/boilerplate/pdelab.hh:915
Dune::PDELab::DGQkGLSpace::Grid
T Grid
Definition: pdelab/boilerplate/pdelab.hh:1189
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::DOF
Backend::Vector< GFS, N > DOF
Definition: pdelab/boilerplate/pdelab.hh:719
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR< FS, ASS, SolverCategory::nonoverlapping >::getLS
LS & getLS()
Definition: pdelab/boilerplate/pdelab.hh:1755
Dune::PDELab::GalerkinGlobalAssemblerNewBackend::MAT
GO::Jacobian MAT
Definition: pdelab/boilerplate/pdelab.hh:1567
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR::operator*
LS & operator*()
Definition: pdelab/boilerplate/pdelab.hh:1732
Dune::PDELab::StructuredGrid::Grid
T Grid
Definition: pdelab/boilerplate/pdelab.hh:93
Dune::PDELab::P0Space::dimworld
static const int dimworld
Definition: pdelab/boilerplate/pdelab.hh:1384
Dune::PDELab::DGCONBase< SolverCategory::sequential >::getCON
CON & getCON()
Definition: pdelab/boilerplate/pdelab.hh:834
Dune::PDELab::ISTLSolverBackend_CG_SSOR::operator->
LS * operator->()
Definition: pdelab/boilerplate/pdelab.hh:1808
Dune::PDELab::P0Space::CC
GFS::template ConstraintsContainer< N >::Type CC
Definition: pdelab/boilerplate/pdelab.hh:1393
Dune::PDELab::DGLegendreSpace::DGF
Dune::PDELab::DiscreteGridFunction< GFS, DOF > DGF
Definition: pdelab/boilerplate/pdelab.hh:1297
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal::ISTLSolverBackend_ExplicitDiagonal
ISTLSolverBackend_ExplicitDiagonal(const FS &fs, const ASS &ass, unsigned maxiter_=5000, int verbose_=1)
Definition: pdelab/boilerplate/pdelab.hh:1949
Dune::PDELab::CGCONBase< Grid, 1, Dune::GeometryType::cube, MeshType::nonconforming, SolverCategory::sequential, BCType, GV >::getCON
CON & getCON()
Definition: pdelab/boilerplate/pdelab.hh:488
Dune::PDELab::ISTLBackend_SEQ_ExplicitDiagonal
Solver to be used for explicit time-steppers with (block-)diagonal mass matrix.
Definition: seqistlsolverbackend.hh:659
Dune::PDELab::PartitionViewEntitySet
Definition: partitionviewentityset.hh:34
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::overlapping, BCType, GV >::postGFSHook
void postGFSHook(const GFS &gfs)
Definition: pdelab/boilerplate/pdelab.hh:539
Dune::PDELab::DGLegendreSpace::getCC
CC & getCC()
Definition: pdelab/boilerplate/pdelab.hh:1321
Dune::PDELab::P0Space::ctype
T::ctype ctype
Definition: pdelab/boilerplate/pdelab.hh:1382
Dune::PDELab::DGPkSpace::CC
GFS::template ConstraintsContainer< N >::Type CC
Definition: pdelab/boilerplate/pdelab.hh:911
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal::operator*
const LS & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:1958
Dune::PDELab::GalerkinGlobalAssemblerNewBackend::getGO
const GO & getGO() const
Definition: pdelab/boilerplate/pdelab.hh:1581
Dune::PDELab::Backend::Vector
typename impl::BackendVectorSelector< GridFunctionSpace, FieldType >::Type Vector
alias of the return type of BackendVectorSelector
Definition: backend/interface.hh:106
Dune::PDELab::UserFunction::UserFunction
UserFunction(const FS &fs_, const Functor &f_)
constructor
Definition: pdelab/boilerplate/pdelab.hh:1479
Dune::PDELab::DGCONBase
Definition: pdelab/boilerplate/pdelab.hh:822
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal< FS, ASS, SolverCategory::nonoverlapping >::getLS
LS & getLS()
Definition: pdelab/boilerplate/pdelab.hh:2004
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal< FS, ASS, SolverCategory::overlapping >::getLS
LS & getLS()
Definition: pdelab/boilerplate/pdelab.hh:1979
Dune::PDELab::CGFEMBase< GV, C, R, degree, dim, Dune::GeometryType::simplex >::FEM
PkLocalFiniteElementMap< GV, C, R, degree > FEM
Definition: pdelab/boilerplate/pdelab.hh:399
Dune::PDELab::GalerkinGlobalAssemblerNewBackend::operator->
GO * operator->()
Definition: pdelab/boilerplate/pdelab.hh:1591
Dune::PDELab::ConformingDirichletConstraints
Dirichlet Constraints construction.
Definition: conforming.hh:36
Dune::PDELab::ISTLSolverBackend_IterativeDefault::ISTLSolverBackend_IterativeDefault
ISTLSolverBackend_IterativeDefault(const FS &fs, const ASS &ass, unsigned maxiter_=5000, int verbose_=1)
Definition: pdelab/boilerplate/pdelab.hh:1876
Dune::PDELab::DGLegendreSpace::FEM
QkDGLocalFiniteElementMap< ctype, NT, degree, dim, QkDGBasisPolynomial::legendre > FEM
Definition: pdelab/boilerplate/pdelab.hh:1291
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::Grid
T Grid
Definition: pdelab/boilerplate/pdelab.hh:702
Dune::PDELab::ISTLSolverBackend_IterativeDefault::operator->
LS * operator->()
Definition: pdelab/boilerplate/pdelab.hh:1884
Dune::PDELab::UnstructuredGrid::dimworld
static const int dimworld
Definition: pdelab/boilerplate/pdelab.hh:333
Dune::PDELab::DGQkSpace::setConstrainedDOFS
void setConstrainedDOFS(DOF &x, NT nt) const
Definition: pdelab/boilerplate/pdelab.hh:1146
Dune::PDELab::CGSpace::Grid
T Grid
Definition: pdelab/boilerplate/pdelab.hh:584
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::getFEM
FEM & getFEM()
Definition: pdelab/boilerplate/pdelab.hh:736
Dune::PDELab::CGSpace::CONB
CGCONBase< Grid, degree, gt, mt, st, BCType > CONB
Definition: pdelab/boilerplate/pdelab.hh:591
Dune::PDELab::ISTLSolverBackend_IterativeDefault< FS, ASS, SolverCategory::nonoverlapping >::operator->
LS * operator->()
Definition: pdelab/boilerplate/pdelab.hh:1908
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal< FS, ASS, SolverCategory::nonoverlapping >::operator*
const LS & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:2008
Dune::PDELab::StructuredGrid< YaspGrid< dim > >::StructuredGrid
StructuredGrid(Dune::GeometryType::BasicType meshtype, std::array< double, dimworld > lower_left, std::array< double, dimworld > upper_right, std::array< unsigned int, dim > cells, int overlap=1)
Definition: pdelab/boilerplate/pdelab.hh:222
Dune::PDELab::CGCONBase< Grid, 1, Dune::GeometryType::simplex, MeshType::nonconforming, SolverCategory::sequential, BCType, GV >::CGCONBase
CGCONBase(Grid &grid, const BCType &bctype)
Definition: pdelab/boilerplate/pdelab.hh:455
Dune::PDELab::OneStepGlobalAssembler::operator*
GO & operator*()
Definition: pdelab/boilerplate/pdelab.hh:1691
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR< FS, ASS, SolverCategory::overlapping >::operator->
LS * operator->()
Definition: pdelab/boilerplate/pdelab.hh:1783
Dune::PDELab::P0Space::VTKF
VTKGridFunctionAdapter< DGF > VTKF
Definition: pdelab/boilerplate/pdelab.hh:1394
Dune::PDELab::copy_nonconstrained_dofs
void copy_nonconstrained_dofs(const CG &cg, const XG &xgin, XG &xgout)
Definition: constraints.hh:987
Dune::PDELab::GlobalAssembler::getGO
GO & getGO()
Definition: pdelab/boilerplate/pdelab.hh:1629
Dune::PDELab::CGFEMBase< GV, C, R, degree, dim, Dune::GeometryType::cube >::FEM
QkLocalFiniteElementMap< GV, C, R, degree > FEM
Definition: pdelab/boilerplate/pdelab.hh:417
Dune::PDELab::DGQkSpace::getGFS
const GFS & getGFS() const
Definition: pdelab/boilerplate/pdelab.hh:1126
Dune::PDELab::ISTLBackend_OVLP_BCGS_SSORk
Overlapping parallel BiCGStab solver with SSOR preconditioner.
Definition: ovlpistlsolverbackend.hh:659
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal< FS, ASS, SolverCategory::overlapping >::operator*
LS & operator*()
Definition: pdelab/boilerplate/pdelab.hh:1981
instationaryfilenamehelper.hh
Dune::PDELab::ISTLSolverBackend_IterativeDefault::operator*
const LS & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:1885
Dune::PDELab::DGPkSpace::VBE
VBET VBE
Definition: pdelab/boilerplate/pdelab.hh:907
Dune::PDELab::StructuredGrid< YaspGrid< dim > >::operator*
Grid & operator*()
Definition: pdelab/boilerplate/pdelab.hh:300
Dune::PDELab::CGSpace::assembleConstraints
void assembleConstraints(const BCType &bctype)
Definition: pdelab/boilerplate/pdelab.hh:651
Dune::PDELab::DGQkOPBSpace::setNonConstrainedDOFS
void setNonConstrainedDOFS(DOF &x, NT nt) const
Definition: pdelab/boilerplate/pdelab.hh:1057
Dune::PDELab::OneStepGlobalAssembler
Definition: pdelab/boilerplate/pdelab.hh:1666
gridfunctionspaceutilities.hh
vtkexport.hh
Dune::PDELab::CGFEMBase
Definition: pdelab/boilerplate/pdelab.hh:392
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::overlapping, BCType, GV >::CON
OverlappingConformingDirichletConstraints CON
Definition: pdelab/boilerplate/pdelab.hh:526
Dune::PDELab::ISTLSolverBackend_CG_SSOR< FS, ASS, SolverCategory::nonoverlapping >::operator*
const LS & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:1834
Dune::PDELab::CGSpace
Definition: pdelab/boilerplate/pdelab.hh:580
Dune::PDELab::GridFunctionBase
leaf of a function tree
Definition: function.hh:299
Dune::PDELab::ISTLBackend_SEQ_CG_SSOR
Backend for sequential conjugate gradient solver with SSOR preconditioner.
Definition: seqistlsolverbackend.hh:504
Dune::PDELab::DGQkGLSpace::clearConstraints
void clearConstraints()
Definition: pdelab/boilerplate/pdelab.hh:1237
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal::operator->
LS * operator->()
Definition: pdelab/boilerplate/pdelab.hh:1957
Dune::PDELab::ISTLBackend_NOVLP_CG_SSORk
Nonoverlapping parallel CG solver preconditioned by block SSOR.
Definition: novlpistlsolverbackend.hh:860
Dune::PDELab::ISTLSolverBackend_IterativeDefault::getLS
LS & getLS()
Definition: pdelab/boilerplate/pdelab.hh:1881
Dune::PDELab::CGFEMBase< GV, C, R, degree, dim, Dune::GeometryType::simplex >::getFEM
FEM & getFEM()
Definition: pdelab/boilerplate/pdelab.hh:406
Dune::PDELab::CGSpace::FEM
FEMB::FEM FEM
Definition: pdelab/boilerplate/pdelab.hh:593
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::ES
Dune::PDELab::NonOverlappingEntitySet< GV > ES
Definition: pdelab/boilerplate/pdelab.hh:705
Dune::PDELab::DGQkGLSpace::DOF
Backend::Vector< GFS, N > DOF
Definition: pdelab/boilerplate/pdelab.hh:1200
Dune::PDELab::DGQkGLSpace::CC
GFS::template ConstraintsContainer< N >::Type CC
Definition: pdelab/boilerplate/pdelab.hh:1202
Dune::PDELab::ISTLSolverBackend_CG_SSOR::operator*
LS & operator*()
Definition: pdelab/boilerplate/pdelab.hh:1807
Dune::PDELab::DGPkSpace::CONB
DGCONBase< st > CONB
Definition: pdelab/boilerplate/pdelab.hh:905
Dune::PDELab::UserFunction::getGridView
const FS::GV & getGridView() const
Definition: pdelab/boilerplate/pdelab.hh:1494
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::sequential, BCType, GV >::CGCONBase
CGCONBase(Grid &grid, const BCType &bctype, const GV &gv)
Definition: pdelab/boilerplate/pdelab.hh:502
Dune::PDELab::DiscreteGridFunction
convert a grid function space and a coefficient vector into a grid function
Definition: gridfunctionspaceutilities.hh:54
Dune::PDELab::CGSpace::FEMB
CGFEMBase< GV, ctype, N, degree, dim, gt > FEMB
Definition: pdelab/boilerplate/pdelab.hh:590
Dune::PDELab::DGCONBase< SolverCategory::sequential >::DGCONBase
DGCONBase()
Definition: pdelab/boilerplate/pdelab.hh:830
Dune::PDELab::DGQkOPBSpace::CC
GFS::template ConstraintsContainer< N >::Type CC
Definition: pdelab/boilerplate/pdelab.hh:1011
Dune::PDELab::StructuredGrid::StructuredGrid
StructuredGrid(Dune::GeometryType::BasicType meshtype, unsigned int cells)
Definition: pdelab/boilerplate/pdelab.hh:99
Dune::PDELab::DGPkSpace::DOF
Backend::Vector< GFS, N > DOF
Definition: pdelab/boilerplate/pdelab.hh:909
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal< FS, ASS, SolverCategory::overlapping >::ISTLSolverBackend_ExplicitDiagonal
ISTLSolverBackend_ExplicitDiagonal(const FS &fs, const ASS &ass, unsigned maxiter_=5000, int verbose_=1)
Definition: pdelab/boilerplate/pdelab.hh:1974
Dune::PDELab::CGCONBase< Grid, 1, Dune::GeometryType::cube, MeshType::nonconforming, SolverCategory::sequential, BCType, GV >::CON
HangingNodesDirichletConstraints< Grid, HangingNodesConstraintsAssemblers::CubeGridQ1Assembler, BCType > CON
Definition: pdelab/boilerplate/pdelab.hh:474
Dune::PDELab::ISTLSolverBackend_IterativeDefault< FS, ASS, SolverCategory::overlapping >::getLS
const LS & getLS() const
Definition: pdelab/boilerplate/pdelab.hh:1930
Dune::PDELab::P0Space::DOF
Backend::Vector< GFS, N > DOF
Definition: pdelab/boilerplate/pdelab.hh:1391
Dune::PDELab::CGCONBase< Grid, 1, Dune::GeometryType::cube, MeshType::nonconforming, SolverCategory::sequential, BCType, GV >::postGFSHook
void postGFSHook(const GFS &gfs)
Definition: pdelab/boilerplate/pdelab.hh:487
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::sequential, BCType, GV >::postGFSHook
void postGFSHook(const GFS &gfs)
Definition: pdelab/boilerplate/pdelab.hh:513
Dune::PDELab::QkLocalFiniteElementMap
Definition: qkfem.hh:18
Dune::PDELab::PowerCompositeGridFunctionTraits::ElementType
GV::Traits::template Codim< 0 >::Entity ElementType
codim 0 entity
Definition: function.hh:119
Dune::PDELab::DGPkSpace::dimworld
static const int dimworld
Definition: pdelab/boilerplate/pdelab.hh:898
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR< FS, ASS, SolverCategory::nonoverlapping >::operator->
LS * operator->()
Definition: pdelab/boilerplate/pdelab.hh:1758
Dune::PDELab::ISTLSolverBackend_CG_SSOR< FS, ASS, SolverCategory::overlapping >::ISTLSolverBackend_CG_SSOR
ISTLSolverBackend_CG_SSOR(const FS &fs, const ASS &ass, unsigned maxiter_=5000, int steps_=5, int verbose_=1)
Definition: pdelab/boilerplate/pdelab.hh:1849
Dune::PDELab::DGQkOPBSpace::getGFS
GFS & getGFS()
Definition: pdelab/boilerplate/pdelab.hh:1028
Dune::PDELab::OneStepGlobalAssembler::MAT
GO::Jacobian MAT
Definition: pdelab/boilerplate/pdelab.hh:1672
Dune::PDELab::DGPkSpace::setNonConstrainedDOFS
void setNonConstrainedDOFS(DOF &x, NT nt) const
Definition: pdelab/boilerplate/pdelab.hh:957
Dune::PDELab::CGCONBase< Grid, 1, Dune::GeometryType::simplex, MeshType::nonconforming, SolverCategory::sequential, BCType, GV >::CGCONBase
CGCONBase(Grid &grid, const BCType &bctype, const GV &gv)
Definition: pdelab/boilerplate/pdelab.hh:450
Dune::PDELab::P0Space
Definition: pdelab/boilerplate/pdelab.hh:1375
Dune::PDELab::CGSpace::ctype
T::ctype ctype
Definition: pdelab/boilerplate/pdelab.hh:586
Dune::PDELab::CGSpace::GV
T::LeafGridView GV
Definition: pdelab/boilerplate/pdelab.hh:585
qkdg.hh
Dune::PDELab::GridOperator::Jacobian
Dune::PDELab::Backend::Matrix< MB, Domain, Range, JF > Jacobian
The type of the jacobian.
Definition: gridoperator.hh:47
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR< FS, ASS, SolverCategory::nonoverlapping >::ISTLSolverBackend_CG_AMG_SSOR
ISTLSolverBackend_CG_AMG_SSOR(const FS &fs, const ASS &ass, unsigned maxiter_=5000, int verbose_=1, bool reuse_=false, bool usesuperlu_=true)
Definition: pdelab/boilerplate/pdelab.hh:1749
Dune::PDELab::DGPkSpace::NT
N NT
Definition: pdelab/boilerplate/pdelab.hh:899
Dune::PDELab::GridFunctionTraits
traits class holding the function signature, same as in local function
Definition: function.hh:177
Dune::PDELab::ISTLBackend_SEQ_BCGS_SSOR
Backend for sequential BiCGSTAB solver with SSOR preconditioner.
Definition: seqistlsolverbackend.hh:417
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::overlapping, BCType, GV >::CGCONBase
CGCONBase(Grid &grid, const BCType &bctype, const GV &gv)
Definition: pdelab/boilerplate/pdelab.hh:528
Dune::PDELab::DGQkGLSpace::getFEM
const FEM & getFEM() const
Definition: pdelab/boilerplate/pdelab.hh:1216
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::getFEM
const FEM & getFEM() const
Definition: pdelab/boilerplate/pdelab.hh:741
Dune
For backward compatibility – Do not use this!
Definition: adaptivity.hh:28
Dune::PDELab::P0Space::copyNonConstrainedDOFS
void copyNonConstrainedDOFS(const DOF &xin, DOF &xout) const
Definition: pdelab/boilerplate/pdelab.hh:1451
Dune::PDELab::ISTLSolverBackend_CG_SSOR
Definition: pdelab/boilerplate/pdelab.hh:1793
Dune::PDELab::CGSpace::getCC
const CC & getCC() const
Definition: pdelab/boilerplate/pdelab.hh:646
Dune::PDELab::P0Space::getFEM
const FEM & getFEM() const
Definition: pdelab/boilerplate/pdelab.hh:1407
Dune::PDELab::UnstructuredGrid::ctype
T::ctype ctype
Definition: pdelab/boilerplate/pdelab.hh:331
Dune::PDELab::DGLegendreSpace::copyNonConstrainedDOFS
void copyNonConstrainedDOFS(const DOF &xin, DOF &xout) const
Definition: pdelab/boilerplate/pdelab.hh:1356
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal< FS, ASS, SolverCategory::nonoverlapping >::getLS
const LS & getLS() const
Definition: pdelab/boilerplate/pdelab.hh:2005
Dune::PDELab::OneStepGlobalAssembler::getGO
const GO & getGO() const
Definition: pdelab/boilerplate/pdelab.hh:1686
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::FEM
FEMB::FEM FEM
Definition: pdelab/boilerplate/pdelab.hh:712
Dune::PDELab::DGQkSpace::CON
CONB::CON CON
Definition: pdelab/boilerplate/pdelab.hh:1101
Dune::PDELab::GlobalAssembler::operator*
const GO & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:1650
Dune::PDELab::CGSpace::VTKF
VTKGridFunctionAdapter< DGF > VTKF
Definition: pdelab/boilerplate/pdelab.hh:603
Dune::PDELab::ISTLBackend_NOVLP_CG_AMG_SSOR
Nonoverlapping parallel CG solver preconditioned with AMG smoothed by SSOR.
Definition: novlpistlsolverbackend.hh:1073
Dune::PDELab::DGLegendreSpace::CONB
DGCONBase< st > CONB
Definition: pdelab/boilerplate/pdelab.hh:1292
Dune::PDELab::StructuredGrid::dim
static const int dim
Definition: pdelab/boilerplate/pdelab.hh:95
Dune::PDELab::DGQkOPBSpace::NT
N NT
Definition: pdelab/boilerplate/pdelab.hh:999
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal< FS, ASS, SolverCategory::nonoverlapping >::operator->
LS * operator->()
Definition: pdelab/boilerplate/pdelab.hh:2007
Dune::PDELab::DGQkGLSpace::DGQkGLSpace
DGQkGLSpace(const GV &gridview)
Definition: pdelab/boilerplate/pdelab.hh:1206
Dune::PDELab::ISTLSolverBackend_CG_SSOR< FS, ASS, SolverCategory::overlapping >::getLS
const LS & getLS() const
Definition: pdelab/boilerplate/pdelab.hh:1856
Dune::PDELab::StructuredGrid< YaspGrid< dim > >::getSharedPtr
std::shared_ptr< Grid > getSharedPtr()
Definition: pdelab/boilerplate/pdelab.hh:283
Dune::PDELab::DGQkGLSpace::CONB
DGCONBase< st > CONB
Definition: pdelab/boilerplate/pdelab.hh:1196
Dune::PDELab::DGQkSpace::getFEM
FEM & getFEM()
Definition: pdelab/boilerplate/pdelab.hh:1119
Dune::PDELab::CGCONBase< Grid, 1, Dune::GeometryType::simplex, MeshType::nonconforming, SolverCategory::sequential, BCType, GV >::getCON
CON & getCON()
Definition: pdelab/boilerplate/pdelab.hh:462
Dune::PDELab::IntersectionType::periodic
@ periodic
periodic boundary intersection (neighbor() == true && boundary() == true)
Dune::PDELab::ISTLSolverBackend_CG_SSOR< FS, ASS, SolverCategory::overlapping >::LS
ISTLBackend_OVLP_CG_SSORk< typename FS::GFS, typename FS::CC > LS
Definition: pdelab/boilerplate/pdelab.hh:1847
Dune::PDELab::constraints
void constraints(const GFS &gfs, CG &cg, const bool verbose=false)
construct constraints
Definition: constraints.hh:749
Dune::PDELab::CGCONBase< Grid, 1, Dune::GeometryType::simplex, MeshType::nonconforming, SolverCategory::sequential, BCType, GV >::getCON
const CON & getCON() const
Definition: pdelab/boilerplate/pdelab.hh:463
Dune::PDELab::ISTLSolverBackend_IterativeDefault::LS
ISTLBackend_SEQ_BCGS_SSOR LS
Definition: pdelab/boilerplate/pdelab.hh:1874
Dune::PDELab::CGSpace::dimworld
static const int dimworld
Definition: pdelab/boilerplate/pdelab.hh:588
Dune::PDELab::GalerkinGlobalAssembler::operator*
GO & operator*()
Definition: pdelab/boilerplate/pdelab.hh:1533
onestep.hh
Dune::PDELab::CGSpace::setConstrainedDOFS
void setConstrainedDOFS(DOF &x, NT nt) const
Definition: pdelab/boilerplate/pdelab.hh:662
Dune::PDELab::OneStepGridOperator
Definition: gridoperator/onestep.hh:18
Dune::PDELab::Backend::native
std::enable_if< std::is_base_of< impl::WrapperBase, T >::value, Native< T > & >::type native(T &t)
Definition: backend/interface.hh:192
Dune::PDELab::ISTLSolverBackend_IterativeDefault< FS, ASS, SolverCategory::overlapping >::operator*
LS & operator*()
Definition: pdelab/boilerplate/pdelab.hh:1931
Dune::PDELab::GalerkinGlobalAssembler::GO
Dune::PDELab::GridOperator< typename FS::GFS, typename FS::GFS, LOP, MBE, typename FS::NT, typename FS::NT, typename FS::NT, typename FS::CC, typename FS::CC > GO
Definition: pdelab/boilerplate/pdelab.hh:1513
Dune::PDELab::DGQkOPBSpace::dim
static const int dim
Definition: pdelab/boilerplate/pdelab.hh:997
Dune::PDELab::ISTLSolverBackend_CG_SSOR< FS, ASS, SolverCategory::nonoverlapping >::LS
ISTLBackend_NOVLP_CG_SSORk< typename ASS::GO > LS
Definition: pdelab/boilerplate/pdelab.hh:1822
Dune::PDELab::ISTL::ParallelHelper
Definition: parallelhelper.hh:50
Dune::PDELab::DGQkGLSpace::dimworld
static const int dimworld
Definition: pdelab/boilerplate/pdelab.hh:1193
Dune::PDELab::OneStepGlobalAssembler::operator*
const GO & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:1701
Dune::PDELab::DGPkSpace
Definition: pdelab/boilerplate/pdelab.hh:889
Dune::PDELab::DGQkSpace::VTKF
VTKGridFunctionAdapter< DGF > VTKF
Definition: pdelab/boilerplate/pdelab.hh:1107
Dune::PDELab::DGQkOPBSpace::Grid
T Grid
Definition: pdelab/boilerplate/pdelab.hh:994
Dune::PDELab::ISTL::BCRSMatrixBackend
Backend using (possibly nested) ISTL BCRSMatrices.
Definition: bcrsmatrixbackend.hh:187
Dune::PDELab::CGSpace::copyNonConstrainedDOFS
void copyNonConstrainedDOFS(const DOF &xin, DOF &xout) const
Definition: pdelab/boilerplate/pdelab.hh:680
Dune::PDELab::DGQkOPBSpace::ctype
T::ctype ctype
Definition: pdelab/boilerplate/pdelab.hh:996
Dune::PDELab::DGPkSpace::ctype
T::ctype ctype
Definition: pdelab/boilerplate/pdelab.hh:896
Dune::PDELab::DGLegendreSpace::assembleConstraints
void assembleConstraints(const BCTYPE &bctype)
Definition: pdelab/boilerplate/pdelab.hh:1327
Dune::PDELab::copy_constrained_dofs
void copy_constrained_dofs(const CG &cg, const XG &xgin, XG &xgout)
Definition: constraints.hh:936
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR< FS, ASS, SolverCategory::nonoverlapping >::LS
Dune::PDELab::ISTLBackend_NOVLP_CG_AMG_SSOR< typename ASS::GO > LS
Definition: pdelab/boilerplate/pdelab.hh:1747
adaptivity.hh
Dune::PDELab::DGPkSpace::getGFS
const GFS & getGFS() const
Definition: pdelab/boilerplate/pdelab.hh:931
Dune::PDELab::DGQkSpace::getGFS
GFS & getGFS()
Definition: pdelab/boilerplate/pdelab.hh:1123
Dune::PDELab::DGQkGLSpace::setConstrainedDOFS
void setConstrainedDOFS(DOF &x, NT nt) const
Definition: pdelab/boilerplate/pdelab.hh:1242
Dune::PDELab::UnstructuredGrid::dim
static const int dim
Definition: pdelab/boilerplate/pdelab.hh:332
Dune::PDELab::DGQkOPBSpace::FEM
OPBLocalFiniteElementMap< ctype, NT, degree, dim, gt, N, Dune::PB::BasisType::Qk > FEM
Definition: pdelab/boilerplate/pdelab.hh:1003
Dune::PDELab::GalerkinGlobalAssembler
Definition: pdelab/boilerplate/pdelab.hh:1506
Dune::PDELab::StructuredGrid
Definition: pdelab/boilerplate/pdelab.hh:89
Dune::PDELab::DGQkGLSpace::VTKF
VTKGridFunctionAdapter< DGF > VTKF
Definition: pdelab/boilerplate/pdelab.hh:1203
Dune::PDELab::P0Space::getCC
const CC & getCC() const
Definition: pdelab/boilerplate/pdelab.hh:1419
Dune::PDELab::NoConstraints
Definition: noconstraints.hh:18
Dune::PDELab::CGSpace::DOF
Backend::Vector< GFS, N > DOF
Definition: pdelab/boilerplate/pdelab.hh:600
Dune::PDELab::UnstructuredGrid::getGrid
T & getGrid()
Definition: pdelab/boilerplate/pdelab.hh:350
Dune::PDELab::StructuredGrid::operator->
const T * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:184
Dune::PDELab::ISTLBackend_NOVLP_ExplicitDiagonal
Solver to be used for explicit time-steppers with (block-)diagonal mass matrix.
Definition: novlpistlsolverbackend.hh:635
Dune::PDELab::P0Space::P0Space
P0Space(const GV &gridview)
Definition: pdelab/boilerplate/pdelab.hh:1397
Dune::PDELab::ISTLBackend_OVLP_CG_SSORk
Overlapping parallel CGS solver with SSOR preconditioner.
Definition: ovlpistlsolverbackend.hh:725
Dune::PDELab::OPBLocalFiniteElementMap
Definition: opbfem.hh:18
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal::LS
Dune::PDELab::ISTLBackend_SEQ_ExplicitDiagonal LS
Definition: pdelab/boilerplate/pdelab.hh:1947
Dune::PDELab::CGCONBase< Grid, 1, Dune::GeometryType::cube, MeshType::nonconforming, SolverCategory::sequential, BCType, GV >::CGCONBase
CGCONBase(Grid &grid, const BCType &bctype)
Definition: pdelab/boilerplate/pdelab.hh:481
Dune::PDELab::CGCONBase
Definition: pdelab/boilerplate/pdelab.hh:441
Dune::PDELab::StructuredGrid< YaspGrid< dim > >::operator*
const Grid & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:310
Dune::PDELab::DGPkSpace::getCC
const CC & getCC() const
Definition: pdelab/boilerplate/pdelab.hh:937
Dune::PDELab::DGPkSpace::FEM
OPBLocalFiniteElementMap< ctype, NT, degree, dim, gt > FEM
Definition: pdelab/boilerplate/pdelab.hh:903
e
const Entity & e
Definition: localfunctionspace.hh:121
Dune::PDELab::DGQkOPBSpace::CON
CONB::CON CON
Definition: pdelab/boilerplate/pdelab.hh:1006
Dune::PDELab::P0Space::clearConstraints
void clearConstraints()
Definition: pdelab/boilerplate/pdelab.hh:1428
Dune::PDELab::DGPkSpace::getGFS
GFS & getGFS()
Definition: pdelab/boilerplate/pdelab.hh:928
Dune::PDELab::DGQkGLSpace::getCC
CC & getCC()
Definition: pdelab/boilerplate/pdelab.hh:1225
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::overlapping, BCType, GV >::getCON
CON & getCON()
Definition: pdelab/boilerplate/pdelab.hh:540
Dune::PDELab::ISTLSolverBackend_IterativeDefault< FS, ASS, SolverCategory::nonoverlapping >::operator*
LS & operator*()
Definition: pdelab/boilerplate/pdelab.hh:1907
Dune::PDELab::DGQkGLSpace::setNonConstrainedDOFS
void setNonConstrainedDOFS(DOF &x, NT nt) const
Definition: pdelab/boilerplate/pdelab.hh:1248
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::nonoverlapping, BCType, GV >::make_consistent
void make_consistent(const GFS &gfs, DOF &x) const
Definition: pdelab/boilerplate/pdelab.hh:570
Dune::PDELab::UserFunction::evaluate
void evaluate(const typename Traits::ElementType &e, const typename Traits::DomainType &x, typename Traits::RangeType &y) const
Evaluate the GridFunction at given position.
Definition: pdelab/boilerplate/pdelab.hh:1484
Dune::PDELab::ISTLSolverBackend_CG_SSOR< FS, ASS, SolverCategory::nonoverlapping >::operator->
LS * operator->()
Definition: pdelab/boilerplate/pdelab.hh:1833
p0ghost.hh
Dune::PDELab::DGPkSpace::copyConstrainedDOFS
void copyConstrainedDOFS(const DOF &xin, DOF &xout) const
Definition: pdelab/boilerplate/pdelab.hh:963
Dune::PDELab::DGQkSpace::getFEM
const FEM & getFEM() const
Definition: pdelab/boilerplate/pdelab.hh:1120
Dune::PDELab::set_constrained_dofs
void set_constrained_dofs(const CG &cg, typename XG::ElementType x, XG &xg)
construct constraints from given boundary condition function
Definition: constraints.hh:796
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR< FS, ASS, SolverCategory::overlapping >::operator->
const LS * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:1785
Dune::PDELab::ISTLSolverBackend_IterativeDefault::getLS
const LS & getLS() const
Definition: pdelab/boilerplate/pdelab.hh:1882
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::FEMB
CGFEMBase< ES, ctype, N, degree, dim, gt > FEMB
Definition: pdelab/boilerplate/pdelab.hh:709
value
static const unsigned int value
Definition: gridfunctionspace/tags.hh:139
Dune::PDELab::DGCONBase< SolverCategory::overlapping >::DGCONBase
DGCONBase()
Definition: pdelab/boilerplate/pdelab.hh:864
hangingnode.hh
Dune::PDELab::DGQkOPBSpace::GFS
GridFunctionSpace< GV, FEM, CON, VBE > GFS
Definition: pdelab/boilerplate/pdelab.hh:1008
Dune::PDELab::ISTLSolverBackend_CG_SSOR< FS, ASS, SolverCategory::overlapping >::operator*
LS & operator*()
Definition: pdelab/boilerplate/pdelab.hh:1857
Dune::PDELab::DGLegendreSpace::GV
T::LeafGridView GV
Definition: pdelab/boilerplate/pdelab.hh:1286
Dune::PDELab::StructuredGrid< YaspGrid< dim > >::ctype
Grid::ctype ctype
Definition: pdelab/boilerplate/pdelab.hh:202
Dune::PB::Qk
@ Qk
Definition: l2orthonormal.hh:155
Dune::PDELab::DGQkSpace::assembleConstraints
void assembleConstraints(const BCTYPE &bctype)
Definition: pdelab/boilerplate/pdelab.hh:1135
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR< FS, ASS, SolverCategory::nonoverlapping >::getLS
const LS & getLS() const
Definition: pdelab/boilerplate/pdelab.hh:1756
Dune::PDELab::DGCONBase< SolverCategory::overlapping >::make_consistent
void make_consistent(const GFS &gfs, DOF &x) const
Definition: pdelab/boilerplate/pdelab.hh:871
Dune::PDELab::DGQkOPBSpace::clearConstraints
void clearConstraints()
Definition: pdelab/boilerplate/pdelab.hh:1046
Dune::PDELab::DGLegendreSpace::clearConstraints
void clearConstraints()
Definition: pdelab/boilerplate/pdelab.hh:1333
Dune::PDELab::DGPkSpace::dim
static const int dim
Definition: pdelab/boilerplate/pdelab.hh:897
Dune::PDELab::CGSpace::setNonConstrainedDOFS
void setNonConstrainedDOFS(DOF &x, NT nt) const
Definition: pdelab/boilerplate/pdelab.hh:668
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::CGSpace
CGSpace(Grid &grid, const BCType &bctype)
Definition: pdelab/boilerplate/pdelab.hh:725
Dune::PDELab::DGQkSpace
Definition: pdelab/boilerplate/pdelab.hh:1088
Dune::PDELab::DGCONBase< SolverCategory::nonoverlapping >::getCON
CON & getCON()
Definition: pdelab/boilerplate/pdelab.hh:851
Dune::PDELab::ISTLSolverBackend_CG_SSOR< FS, ASS, SolverCategory::overlapping >::getLS
LS & getLS()
Definition: pdelab/boilerplate/pdelab.hh:1855
Dune::PDELab::ISTLBackend_SEQ_CG_AMG_SSOR
Sequential conjugate gradient solver preconditioned with AMG smoothed by SSOR.
Definition: seqistlsolverbackend.hh:854
Dune::PDELab::GlobalAssembler::GO
Dune::PDELab::GridOperator< typename FSU::GFS, typename FSV::GFS, LOP, MBE, typename FSU::NT, typename FSU::NT, typename FSU::NT, typename FSU::CC, typename FSV::CC > GO
Definition: pdelab/boilerplate/pdelab.hh:1620
Dune::PDELab::GlobalAssembler::MBE
ISTL::BCRSMatrixBackend MBE
Definition: pdelab/boilerplate/pdelab.hh:1617
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR::operator->
const LS * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:1735
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR::operator->
LS * operator->()
Definition: pdelab/boilerplate/pdelab.hh:1733
Dune::PDELab::ISTLSolverBackend_CG_SSOR::LS
ISTLBackend_SEQ_CG_SSOR LS
Definition: pdelab/boilerplate/pdelab.hh:1797
Dune::PDELab::DGLegendreSpace::getGFS
const GFS & getGFS() const
Definition: pdelab/boilerplate/pdelab.hh:1318
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::sequential, BCType, GV >::getCON
const CON & getCON() const
Definition: pdelab/boilerplate/pdelab.hh:515
Dune::PDELab::DGQkOPBSpace::getFEM
const FEM & getFEM() const
Definition: pdelab/boilerplate/pdelab.hh:1025
Dune::PDELab::ISTLSolverBackend_IterativeDefault< FS, ASS, SolverCategory::nonoverlapping >::ISTLSolverBackend_IterativeDefault
ISTLSolverBackend_IterativeDefault(const FS &fs, const ASS &ass, unsigned maxiter_=5000, int verbose_=1)
Definition: pdelab/boilerplate/pdelab.hh:1900
Dune::PDELab::DGQkOPBSpace::getFEM
FEM & getFEM()
Definition: pdelab/boilerplate/pdelab.hh:1024
Dune::PDELab::DGPkSpace::Grid
T Grid
Definition: pdelab/boilerplate/pdelab.hh:894
Dune::PDELab::DGLegendreSpace::getGFS
GFS & getGFS()
Definition: pdelab/boilerplate/pdelab.hh:1315
Dune::PDELab::GlobalAssembler::operator->
GO * operator->()
Definition: pdelab/boilerplate/pdelab.hh:1645
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::NT
N NT
Definition: pdelab/boilerplate/pdelab.hh:718
Dune::PDELab::DGLegendreSpace::setNonConstrainedDOFS
void setNonConstrainedDOFS(DOF &x, NT nt) const
Definition: pdelab/boilerplate/pdelab.hh:1344
Dune::PDELab::GridFunctionSpace
A grid function space.
Definition: gridfunctionspace.hh:178
Dune::PDELab::ISTLSolverBackend_IterativeDefault< FS, ASS, SolverCategory::nonoverlapping >::operator->
const LS * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:1910
Dune::PDELab::DGLegendreSpace::CC
GFS::template ConstraintsContainer< N >::Type CC
Definition: pdelab/boilerplate/pdelab.hh:1298
Dune::PDELab::DGQkSpace::DGQkSpace
DGQkSpace(const GV &gridview)
Definition: pdelab/boilerplate/pdelab.hh:1110
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::setNonConstrainedDOFS
void setNonConstrainedDOFS(DOF &x, NT nt) const
Definition: pdelab/boilerplate/pdelab.hh:787
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::copyConstrainedDOFS
void copyConstrainedDOFS(const DOF &xin, DOF &xout) const
Definition: pdelab/boilerplate/pdelab.hh:793
Dune::PDELab::DGQkSpace::Grid
T Grid
Definition: pdelab/boilerplate/pdelab.hh:1093
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal< FS, ASS, SolverCategory::nonoverlapping >::LS
Dune::PDELab::ISTLBackend_NOVLP_ExplicitDiagonal< typename FS::GFS > LS
Definition: pdelab/boilerplate/pdelab.hh:1997
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal< FS, ASS, SolverCategory::nonoverlapping >::operator->
const LS * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:2009
Dune::PDELab::DGQkGLSpace::DGF
Dune::PDELab::DiscreteGridFunction< GFS, DOF > DGF
Definition: pdelab/boilerplate/pdelab.hh:1201
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal::operator->
const LS * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:1959
Dune::PDELab::CGFEMBase< GV, C, R, degree, dim, Dune::GeometryType::simplex >::CGFEMBase
CGFEMBase(const GV &gridview)
Definition: pdelab/boilerplate/pdelab.hh:401
Dune::PDELab::GlobalAssembler::MAT
GO::Jacobian MAT
Definition: pdelab/boilerplate/pdelab.hh:1621
Dune::PDELab::ISTLSolverBackend_CG_SSOR< FS, ASS, SolverCategory::overlapping >::operator*
const LS & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:1859
Dune::PDELab::StructuredGrid< YaspGrid< dim > >::StructuredGrid
StructuredGrid(Dune::GeometryType::BasicType meshtype, unsigned int cells, int overlap=1)
Definition: pdelab/boilerplate/pdelab.hh:206
Dune::PDELab::DGLegendreSpace::dim
static const int dim
Definition: pdelab/boilerplate/pdelab.hh:1288
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::sequential, BCType, GV >::CGCONBase
CGCONBase(Grid &grid, const BCType &bctype)
Definition: pdelab/boilerplate/pdelab.hh:507
Dune::PDELab::DGLegendreSpace::copyConstrainedDOFS
void copyConstrainedDOFS(const DOF &xin, DOF &xout) const
Definition: pdelab/boilerplate/pdelab.hh:1350
Dune::PDELab::GalerkinGlobalAssembler::MBE
ISTL::BCRSMatrixBackend MBE
Definition: pdelab/boilerplate/pdelab.hh:1510
Dune::PDELab::DGCONBase< SolverCategory::sequential >::CON
NoConstraints CON
Definition: pdelab/boilerplate/pdelab.hh:829
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal< FS, ASS, SolverCategory::overlapping >::operator*
const LS & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:1983
Dune::PDELab::CGSpace::getCC
CC & getCC()
Definition: pdelab/boilerplate/pdelab.hh:640
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::copyNonConstrainedDOFS
void copyNonConstrainedDOFS(const DOF &xin, DOF &xout) const
Definition: pdelab/boilerplate/pdelab.hh:799
Dune::PDELab::DGQkSpace::VBE
VBET VBE
Definition: pdelab/boilerplate/pdelab.hh:1102
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal::getLS
const LS & getLS() const
Definition: pdelab/boilerplate/pdelab.hh:1955
Dune::PDELab::DGQkGLSpace::getFEM
FEM & getFEM()
Definition: pdelab/boilerplate/pdelab.hh:1215
Dune::PDELab::UserFunction::Traits
GridFunctionTraits< typename FS::GV, typename FS::NT, 1, FieldVector< typename FS::NT, 1 > > Traits
Definition: pdelab/boilerplate/pdelab.hh:1476
Dune::PDELab::DGLegendreSpace::getFEM
FEM & getFEM()
Definition: pdelab/boilerplate/pdelab.hh:1311
Dune::PDELab::GalerkinGlobalAssembler::MAT
GO::Jacobian MAT
Definition: pdelab/boilerplate/pdelab.hh:1514
Dune::PDELab::DGLegendreSpace::Grid
T Grid
Definition: pdelab/boilerplate/pdelab.hh:1285
Dune::PDELab::CGCONBase< Grid, 1, Dune::GeometryType::simplex, MeshType::nonconforming, SolverCategory::sequential, BCType, GV >::CON
HangingNodesDirichletConstraints< Grid, HangingNodesConstraintsAssemblers::SimplexGridP1Assembler, BCType > CON
Definition: pdelab/boilerplate/pdelab.hh:448
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal< FS, ASS, SolverCategory::nonoverlapping >::operator*
LS & operator*()
Definition: pdelab/boilerplate/pdelab.hh:2006
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR
Definition: pdelab/boilerplate/pdelab.hh:1718
Dune::PDELab::DGPkSpace::GV
T::LeafGridView GV
Definition: pdelab/boilerplate/pdelab.hh:895
Dune::PDELab::PkLocalFiniteElementMap
Definition: pkfem.hh:288
Dune::PDELab::ISTLSolverBackend_IterativeDefault< FS, ASS, SolverCategory::overlapping >::LS
ISTLBackend_OVLP_BCGS_SSORk< typename FS::GFS, typename FS::CC > LS
Definition: pdelab/boilerplate/pdelab.hh:1922
Dune::PDELab::CGSpace::getGFS
const GFS & getGFS() const
Definition: pdelab/boilerplate/pdelab.hh:634
Dune::PDELab::VTKGridFunctionAdapter
wrap a GridFunction so it can be used with the VTKWriter from dune-grid.
Definition: vtkexport.hh:23
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::CON
CONB::CON CON
Definition: pdelab/boilerplate/pdelab.hh:713
Dune::PDELab::DGQkOPBSpace::assembleConstraints
void assembleConstraints(const BCTYPE &bctype)
Definition: pdelab/boilerplate/pdelab.hh:1040
Dune::PDELab::DGQkOPBSpace::getGFS
const GFS & getGFS() const
Definition: pdelab/boilerplate/pdelab.hh:1031
Dune::PDELab::StructuredGrid::ctype
T::ctype ctype
Definition: pdelab/boilerplate/pdelab.hh:94
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal< FS, ASS, SolverCategory::overlapping >::getLS
const LS & getLS() const
Definition: pdelab/boilerplate/pdelab.hh:1980
Dune::PDELab::DGQkSpace::GV
T::LeafGridView GV
Definition: pdelab/boilerplate/pdelab.hh:1094
Dune::PDELab::ISTL::ParallelHelper::maskForeignDOFs
void maskForeignDOFs(X &x) const
Mask out all DOFs not owned by the current process with 0.
Definition: parallelhelper.hh:126
Dune::PDELab::CGCONBase< Grid, 1, Dune::GeometryType::cube, MeshType::nonconforming, SolverCategory::sequential, BCType, GV >::CGCONBase
CGCONBase(Grid &grid, const BCType &bctype, const GV &gv)
Definition: pdelab/boilerplate/pdelab.hh:476
Dune::PDELab::ISTLSolverBackend_CG_SSOR::ISTLSolverBackend_CG_SSOR
ISTLSolverBackend_CG_SSOR(const FS &fs, const ASS &ass, unsigned maxiter_=5000, int steps_=5, int verbose_=1)
Definition: pdelab/boilerplate/pdelab.hh:1799
Dune::PDELab::DGPkSpace::copyNonConstrainedDOFS
void copyNonConstrainedDOFS(const DOF &xin, DOF &xout) const
Definition: pdelab/boilerplate/pdelab.hh:969
Dune::PDELab::CGSpace::NT
N NT
Definition: pdelab/boilerplate/pdelab.hh:599
Dune::PDELab::DGCONBase< SolverCategory::nonoverlapping >::CON
P0ParallelGhostConstraints CON
Definition: pdelab/boilerplate/pdelab.hh:846
Dune::PDELab::ISTLSolverBackend_CG_SSOR::getLS
LS & getLS()
Definition: pdelab/boilerplate/pdelab.hh:1805
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal< FS, ASS, SolverCategory::nonoverlapping >::ISTLSolverBackend_ExplicitDiagonal
ISTLSolverBackend_ExplicitDiagonal(const FS &fs, const ASS &ass, unsigned maxiter_=5000, int verbose_=1)
Definition: pdelab/boilerplate/pdelab.hh:1999
Dune::PDELab::DGCONBase< SolverCategory::overlapping >::getCON
CON & getCON()
Definition: pdelab/boilerplate/pdelab.hh:868
Dune::PDELab::DGQkSpace::getCC
CC & getCC()
Definition: pdelab/boilerplate/pdelab.hh:1129
Dune::PDELab::MeshType
MeshType
Definition: pdelab/boilerplate/pdelab.hh:434
Dune::PDELab::DGCONBase< SolverCategory::sequential >::make_consistent
void make_consistent(const GFS &gfs, DOF &x) const
Definition: pdelab/boilerplate/pdelab.hh:837
Dune::PDELab::ISTLSolverBackend_IterativeDefault< FS, ASS, SolverCategory::nonoverlapping >::getLS
const LS & getLS() const
Definition: pdelab/boilerplate/pdelab.hh:1906
Dune::PDELab::DGQkSpace::CONB
DGCONBase< st > CONB
Definition: pdelab/boilerplate/pdelab.hh:1100
Dune::PDELab::CGFEMBase< GV, C, R, degree, dim, Dune::GeometryType::cube >::getFEM
FEM & getFEM()
Definition: pdelab/boilerplate/pdelab.hh:424
Dune::PDELab::GalerkinGlobalAssembler::operator->
GO * operator->()
Definition: pdelab/boilerplate/pdelab.hh:1538
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::GV
T::LeafGridView GV
Definition: pdelab/boilerplate/pdelab.hh:703
Dune::PDELab::DGPkSpace::DGF
Dune::PDELab::DiscreteGridFunction< GFS, DOF > DGF
Definition: pdelab/boilerplate/pdelab.hh:910
Dune::PDELab::StructuredGrid::operator*
T & operator*()
Definition: pdelab/boilerplate/pdelab.hh:169
Dune::PDELab::DGQkOPBSpace::getCC
const CC & getCC() const
Definition: pdelab/boilerplate/pdelab.hh:1037
Dune::PDELab::conforming
@ conforming
Definition: pdelab/boilerplate/pdelab.hh:435
Dune::PDELab::FunctionTraits< GV::Grid::ctype, GV::dimension, Dune::FieldVector< GV::Grid::ctype, GV::dimension >, RF, m, R >::RangeType
R RangeType
range type
Definition: function.hh:62
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR< FS, ASS, SolverCategory::overlapping >::getLS
LS & getLS()
Definition: pdelab/boilerplate/pdelab.hh:1780
Dune::PDELab::ISTLSolverBackend_IterativeDefault< FS, ASS, SolverCategory::overlapping >::getLS
LS & getLS()
Definition: pdelab/boilerplate/pdelab.hh:1929
Dune::PDELab::DGCONBase< SolverCategory::nonoverlapping >::getCON
const CON & getCON() const
Definition: pdelab/boilerplate/pdelab.hh:852
Dune::PDELab::CGSpace::CGSpace
CGSpace(Grid &grid, const BCType &bctype)
Definition: pdelab/boilerplate/pdelab.hh:606
Dune::PDELab::GalerkinGlobalAssemblerNewBackend::operator->
const GO * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:1601
Dune::PDELab::P0Space::setNonConstrainedDOFS
void setNonConstrainedDOFS(DOF &x, NT nt) const
Definition: pdelab/boilerplate/pdelab.hh:1439
Dune::PDELab::GalerkinGlobalAssemblerNewBackend::GO
Dune::PDELab::GridOperator< typename FS::GFS, typename FS::GFS, LOP, MBE, typename FS::NT, typename FS::NT, typename FS::NT, typename FS::CC, typename FS::CC > GO
Definition: pdelab/boilerplate/pdelab.hh:1566
Dune::PDELab::GalerkinGlobalAssembler::operator->
const GO * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:1548
Dune::PDELab::DGCONBase< SolverCategory::nonoverlapping >::DGCONBase
DGCONBase()
Definition: pdelab/boilerplate/pdelab.hh:847
Dune::PDELab::DGQkOPBSpace::DGQkOPBSpace
DGQkOPBSpace(const GV &gridview)
Definition: pdelab/boilerplate/pdelab.hh:1015
Dune::PDELab::DGLegendreSpace::DOF
Backend::Vector< GFS, N > DOF
Definition: pdelab/boilerplate/pdelab.hh:1296
Dune::PDELab::DGLegendreSpace::setConstrainedDOFS
void setConstrainedDOFS(DOF &x, NT nt) const
Definition: pdelab/boilerplate/pdelab.hh:1338
Dune::PDELab::CGCONBase< Grid, 1, Dune::GeometryType::simplex, MeshType::nonconforming, SolverCategory::sequential, BCType, GV >::make_consistent
void make_consistent(const GFS &gfs, DOF &x) const
Definition: pdelab/boilerplate/pdelab.hh:465
Dune::PDELab::DGQkSpace::GFS
GridFunctionSpace< GV, FEM, CON, VBE > GFS
Definition: pdelab/boilerplate/pdelab.hh:1103
Dune::PDELab::P0Space::Grid
T Grid
Definition: pdelab/boilerplate/pdelab.hh:1380
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR< FS, ASS, SolverCategory::overlapping >::operator*
const LS & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:1784
Dune::PDELab::UnstructuredGrid::Grid
T Grid
Definition: pdelab/boilerplate/pdelab.hh:330
Dune::PDELab::ISTLSolverBackend_CG_SSOR< FS, ASS, SolverCategory::overlapping >::operator->
LS * operator->()
Definition: pdelab/boilerplate/pdelab.hh:1858
Dune::PDELab::DGLegendreSpace::CON
CONB::CON CON
Definition: pdelab/boilerplate/pdelab.hh:1293
Dune::PDELab::DGPkSpace::CON
CONB::CON CON
Definition: pdelab/boilerplate/pdelab.hh:906
Dune::PDELab::GlobalAssembler
Definition: pdelab/boilerplate/pdelab.hh:1613
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR::getLS
LS & getLS()
Definition: pdelab/boilerplate/pdelab.hh:1730
Dune::PDELab::UnstructuredGrid
Definition: pdelab/boilerplate/pdelab.hh:326
Dune::PDELab::DGQkOPBSpace::VTKF
VTKGridFunctionAdapter< DGF > VTKF
Definition: pdelab/boilerplate/pdelab.hh:1012
interpolate.hh
Dune::PDELab::P0Space::DGF
Dune::PDELab::DiscreteGridFunction< GFS, DOF > DGF
Definition: pdelab/boilerplate/pdelab.hh:1392
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal< FS, ASS, SolverCategory::overlapping >::LS
Dune::PDELab::ISTLBackend_OVLP_ExplicitDiagonal< typename FS::GFS > LS
Definition: pdelab/boilerplate/pdelab.hh:1972
Dune::PDELab::P0ParallelGhostConstraints
Parallel P0 constraints for nonoverlapping grids with ghosts.
Definition: p0ghost.hh:18
Dune::PDELab::nonconforming
@ nonconforming
Definition: pdelab/boilerplate/pdelab.hh:436
Dune::PDELab::StructuredGrid< YaspGrid< dim > >::getGrid
const Grid & getGrid() const
Definition: pdelab/boilerplate/pdelab.hh:295
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::sequential, BCType, GV >::make_consistent
void make_consistent(const GFS &gfs, DOF &x) const
Definition: pdelab/boilerplate/pdelab.hh:517
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::VTKF
VTKGridFunctionAdapter< DGF > VTKF
Definition: pdelab/boilerplate/pdelab.hh:722
Dune::PDELab::UserFunction
Definition: pdelab/boilerplate/pdelab.hh:1469
Dune::PDELab::ISTLBackend_OVLP_ExplicitDiagonal
Solver to be used for explicit time-steppers with (block-)diagonal mass matrix.
Definition: ovlpistlsolverbackend.hh:1008
Dune::PDELab::CGSpace::copyConstrainedDOFS
void copyConstrainedDOFS(const DOF &xin, DOF &xout) const
Definition: pdelab/boilerplate/pdelab.hh:674
Dune::PDELab::P0Space::getFEM
FEM & getFEM()
Definition: pdelab/boilerplate/pdelab.hh:1406
Dune::PDELab::DGQkGLSpace::copyNonConstrainedDOFS
void copyNonConstrainedDOFS(const DOF &xin, DOF &xout) const
Definition: pdelab/boilerplate/pdelab.hh:1260
Dune::PDELab::DGPkSpace::assembleConstraints
void assembleConstraints(const BCTYPE &bctype)
Definition: pdelab/boilerplate/pdelab.hh:940
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal< FS, ASS, SolverCategory::overlapping >::operator->
LS * operator->()
Definition: pdelab/boilerplate/pdelab.hh:1982
Dune::PDELab::DGQkSpace::ctype
T::ctype ctype
Definition: pdelab/boilerplate/pdelab.hh:1095
Dune::PDELab::DGPkSpace::GFS
GridFunctionSpace< GV, FEM, CON, VBE > GFS
Definition: pdelab/boilerplate/pdelab.hh:908
functionutilities.hh
Dune::PDELab::DGQkOPBSpace::copyNonConstrainedDOFS
void copyNonConstrainedDOFS(const DOF &xin, DOF &xout) const
Definition: pdelab/boilerplate/pdelab.hh:1069
Dune::PDELab::ISTLSolverBackend_CG_SSOR< FS, ASS, SolverCategory::overlapping >::operator->
const LS * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:1860
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal< FS, ASS, SolverCategory::overlapping >::operator->
const LS * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:1984
Dune::PDELab::GalerkinGlobalAssembler::getGO
GO & getGO()
Definition: pdelab/boilerplate/pdelab.hh:1522
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal
Definition: pdelab/boilerplate/pdelab.hh:1943
Dune::PDELab::DGPkSpace::VTKF
VTKGridFunctionAdapter< DGF > VTKF
Definition: pdelab/boilerplate/pdelab.hh:912
Dune::PDELab::DGLegendreSpace::dimworld
static const int dimworld
Definition: pdelab/boilerplate/pdelab.hh:1289
Dune::PDELab::DGQkOPBSpace::setConstrainedDOFS
void setConstrainedDOFS(DOF &x, NT nt) const
Definition: pdelab/boilerplate/pdelab.hh:1051
Dune::PDELab::DGQkGLSpace::getCC
const CC & getCC() const
Definition: pdelab/boilerplate/pdelab.hh:1228
Dune::PDELab::GalerkinGlobalAssembler::getGO
const GO & getGO() const
Definition: pdelab/boilerplate/pdelab.hh:1528
Dune::PDELab::P0Space::CONB
DGCONBase< st > CONB
Definition: pdelab/boilerplate/pdelab.hh:1387
p0fem.hh
Dune::PDELab::GlobalAssembler::operator*
GO & operator*()
Definition: pdelab/boilerplate/pdelab.hh:1640
Dune::PDELab::OneStepGlobalAssembler::operator->
const GO * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:1706
Dune::PDELab::DGQkOPBSpace::copyConstrainedDOFS
void copyConstrainedDOFS(const DOF &xin, DOF &xout) const
Definition: pdelab/boilerplate/pdelab.hh:1063
Dune::PDELab::StructuredGrid::getGrid
const T & getGrid() const
Definition: pdelab/boilerplate/pdelab.hh:164
Dune::PDELab::HangingNodesDirichletConstraints
Hanging Node constraints construction.
Definition: hangingnode.hh:310
Dune::PDELab::OneStepGlobalAssembler::getGO
GO & getGO()
Definition: pdelab/boilerplate/pdelab.hh:1680
Dune::PDELab::ISTLSolverBackend_IterativeDefault< FS, ASS, SolverCategory::overlapping >::operator->
LS * operator->()
Definition: pdelab/boilerplate/pdelab.hh:1932
Dune::PDELab::UnstructuredGrid::operator->
const T * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:376
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::CONB
CGCONBase< Grid, degree, gt, mt, SolverCategory::nonoverlapping, BCType > CONB
Definition: pdelab/boilerplate/pdelab.hh:710
istl.hh
newton.hh
Dune::PDELab::DGPkSpace::getFEM
const FEM & getFEM() const
Definition: pdelab/boilerplate/pdelab.hh:925
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::nonoverlapping, BCType, GV >::CGCONBase
CGCONBase(Grid &grid, const BCType &bctype)
Definition: pdelab/boilerplate/pdelab.hh:561
Dune::PDELab::P0Space::assembleConstraints
void assembleConstraints(const BCTYPE &bctype)
Definition: pdelab/boilerplate/pdelab.hh:1422
Dune::PDELab::DGLegendreSpace
Definition: pdelab/boilerplate/pdelab.hh:1280
Dune::PDELab::GalerkinGlobalAssembler::GalerkinGlobalAssembler
GalerkinGlobalAssembler(const FS &fs, LOP &lop, const std::size_t nonzeros)
Definition: pdelab/boilerplate/pdelab.hh:1516
Dune::PDELab::DGQkGLSpace::VBE
VBET VBE
Definition: pdelab/boilerplate/pdelab.hh:1198
Dune::PDELab::CGSpace::VBE
VBET VBE
Definition: pdelab/boilerplate/pdelab.hh:596
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::sequential, BCType, GV >::getCON
CON & getCON()
Definition: pdelab/boilerplate/pdelab.hh:514
qkfem.hh
Dune::PDELab::DGQkGLSpace::copyConstrainedDOFS
void copyConstrainedDOFS(const DOF &xin, DOF &xout) const
Definition: pdelab/boilerplate/pdelab.hh:1254
Dune::PDELab::P0Space::getGFS
GFS & getGFS()
Definition: pdelab/boilerplate/pdelab.hh:1410
Dune::PDELab::DGQkGLSpace::getGFS
GFS & getGFS()
Definition: pdelab/boilerplate/pdelab.hh:1219
Dune::PDELab::P0Space::getGFS
const GFS & getGFS() const
Definition: pdelab/boilerplate/pdelab.hh:1413
Dune::PDELab::DGQkOPBSpace
Definition: pdelab/boilerplate/pdelab.hh:989
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::getGFS
const GFS & getGFS() const
Definition: pdelab/boilerplate/pdelab.hh:753
Dune::PDELab::GalerkinGlobalAssemblerNewBackend::GalerkinGlobalAssemblerNewBackend
GalerkinGlobalAssemblerNewBackend(const FS &fs, LOP &lop, const MBE &mbe)
Definition: pdelab/boilerplate/pdelab.hh:1569
Dune::PDELab::ISTLBackend_NOVLP_BCGS_SSORk
Nonoverlapping parallel BiCGSTAB solver preconditioned by block SSOR.
Definition: novlpistlsolverbackend.hh:835
pkfem.hh
p0.hh
Dune::PDELab::CGFEMBase< GV, C, R, degree, dim, Dune::GeometryType::simplex >::getFEM
const FEM & getFEM() const
Definition: pdelab/boilerplate/pdelab.hh:407
Dune::PDELab::GalerkinGlobalAssemblerNewBackend
Definition: pdelab/boilerplate/pdelab.hh:1559
Dune::PDELab::ISTLSolverBackend_IterativeDefault::operator*
LS & operator*()
Definition: pdelab/boilerplate/pdelab.hh:1883
Dune::PDELab::DGQkOPBSpace::dimworld
static const int dimworld
Definition: pdelab/boilerplate/pdelab.hh:998
Dune::PDELab::ISTLBackend_CG_AMG_SSOR
Overlapping parallel conjugate gradient solver preconditioned with AMG smoothed by SSOR.
Definition: ovlpistlsolverbackend.hh:1256
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::overlapping, BCType, GV >::make_consistent
void make_consistent(const GFS &gfs, DOF &x) const
Definition: pdelab/boilerplate/pdelab.hh:543
Dune::PDELab::CGSpace::DGF
Dune::PDELab::DiscreteGridFunction< GFS, DOF > DGF
Definition: pdelab/boilerplate/pdelab.hh:601
Dune::PDELab::ISTLSolverBackend_CG_SSOR::operator*
const LS & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:1809
Dune::PDELab::P0ParallelConstraints
Parallel P0 constraints for overlapping grids.
Definition: p0.hh:16
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR::operator*
const LS & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:1734
Dune::PDELab::DGQkSpace::copyConstrainedDOFS
void copyConstrainedDOFS(const DOF &xin, DOF &xout) const
Definition: pdelab/boilerplate/pdelab.hh:1158
Dune::PDELab::StructuredGrid< YaspGrid< dim > >::operator->
Grid * operator->()
Definition: pdelab/boilerplate/pdelab.hh:305
Dune::PDELab::P0LocalFiniteElementMap
Definition: p0fem.hh:16
Dune::PDELab::ISTLSolverBackend_CG_SSOR< FS, ASS, SolverCategory::nonoverlapping >::getLS
LS & getLS()
Definition: pdelab/boilerplate/pdelab.hh:1830
Dune::PDELab::FunctionTraits< GV::Grid::ctype, GV::dimension, Dune::FieldVector< GV::Grid::ctype, GV::dimension >, RF, m, R >::DomainType
Dune::FieldVector< GV::Grid::ctype, GV::dimension > DomainType
domain type in dim-size coordinates
Definition: function.hh:50
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR< FS, ASS, SolverCategory::overlapping >::ISTLSolverBackend_CG_AMG_SSOR
ISTLSolverBackend_CG_AMG_SSOR(const FS &fs, const ASS &ass, unsigned maxiter_=5000, int verbose_=1, bool reuse_=false, bool usesuperlu_=true)
Definition: pdelab/boilerplate/pdelab.hh:1774
constraints.hh
Dune::PDELab::OverlappingConformingDirichletConstraints
extend conforming constraints class by processor boundary
Definition: conforming.hh:97
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR::ISTLSolverBackend_CG_AMG_SSOR
ISTLSolverBackend_CG_AMG_SSOR(const FS &fs, const ASS &ass, unsigned maxiter_=5000, int verbose_=1, bool reuse_=false, bool usesuperlu_=true)
Definition: pdelab/boilerplate/pdelab.hh:1724
Dune::PDELab::ISTLSolverBackend_ExplicitDiagonal::operator*
LS & operator*()
Definition: pdelab/boilerplate/pdelab.hh:1956
Dune::PDELab::DGQkGLSpace::CON
CONB::CON CON
Definition: pdelab/boilerplate/pdelab.hh:1197
Dune::PDELab::CGFEMBase< GV, C, R, degree, dim, Dune::GeometryType::cube >::getFEM
const FEM & getFEM() const
Definition: pdelab/boilerplate/pdelab.hh:425
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR< FS, ASS, SolverCategory::overlapping >::LS
Dune::PDELab::ISTLBackend_CG_AMG_SSOR< typename ASS::GO > LS
Definition: pdelab/boilerplate/pdelab.hh:1772
Dune::PDELab::CGSpace::CC
GFS::template ConstraintsContainer< N >::Type CC
Definition: pdelab/boilerplate/pdelab.hh:602
Dune::PDELab::OneStepGlobalAssembler::MBE
ISTL::BCRSMatrixBackend MBE
Definition: pdelab/boilerplate/pdelab.hh:1670
Dune::PDELab::AddDataHandle
Definition: genericdatahandle.hh:665
Dune::PDELab::DGQkSpace::dimworld
static const int dimworld
Definition: pdelab/boilerplate/pdelab.hh:1097
Dune::PDELab::DGQkGLSpace::ctype
T::ctype ctype
Definition: pdelab/boilerplate/pdelab.hh:1191
Dune::PDELab::CGSpace::getFEM
FEM & getFEM()
Definition: pdelab/boilerplate/pdelab.hh:617
Dune::PDELab::ISTLSolverBackend_IterativeDefault< FS, ASS, SolverCategory::nonoverlapping >::operator*
const LS & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:1909
Dune::PDELab::OneStepGlobalAssembler::operator->
GO * operator->()
Definition: pdelab/boilerplate/pdelab.hh:1696
Dune::PDELab::GalerkinGlobalAssemblerNewBackend::operator*
GO & operator*()
Definition: pdelab/boilerplate/pdelab.hh:1586
gridoperator.hh
Dune::PDELab::ISTLSolverBackend_IterativeDefault< FS, ASS, SolverCategory::overlapping >::operator->
const LS * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:1934
Dune::PDELab::GlobalAssembler::operator->
const GO * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:1655
Dune::PDELab::P0Space::GV
T::LeafGridView GV
Definition: pdelab/boilerplate/pdelab.hh:1381
Dune::PDELab::P0Space::setConstrainedDOFS
void setConstrainedDOFS(DOF &x, NT nt) const
Definition: pdelab/boilerplate/pdelab.hh:1433
Dune::PDELab::P0Space::getCC
CC & getCC()
Definition: pdelab/boilerplate/pdelab.hh:1416
Dune::PDELab::DGCONBase< SolverCategory::sequential >::getCON
const CON & getCON() const
Definition: pdelab/boilerplate/pdelab.hh:835
Dune::PDELab::DGPkSpace::getCC
CC & getCC()
Definition: pdelab/boilerplate/pdelab.hh:934
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR< FS, ASS, SolverCategory::nonoverlapping >::operator*
LS & operator*()
Definition: pdelab/boilerplate/pdelab.hh:1757
Dune::PDELab::CGCONBase< Grid, 1, Dune::GeometryType::simplex, MeshType::nonconforming, SolverCategory::sequential, BCType, GV >::postGFSHook
void postGFSHook(const GFS &gfs)
Definition: pdelab/boilerplate/pdelab.hh:461
Dune::PDELab::CGSpace::dim
static const int dim
Definition: pdelab/boilerplate/pdelab.hh:587
Dune::PDELab::DGQkSpace::NT
N NT
Definition: pdelab/boilerplate/pdelab.hh:1098
Dune::PDELab::DGPkSpace::getFEM
FEM & getFEM()
Definition: pdelab/boilerplate/pdelab.hh:924
Dune::PDELab::P0Space::dim
static const int dim
Definition: pdelab/boilerplate/pdelab.hh:1383
Dune::PDELab::ISTLSolverBackend_IterativeDefault< FS, ASS, SolverCategory::overlapping >::operator*
const LS & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:1933
Dune::PDELab::StructuredGrid::dimworld
static const int dimworld
Definition: pdelab/boilerplate/pdelab.hh:96
Dune::PDELab::GalerkinGlobalAssemblerNewBackend::getGO
GO & getGO()
Definition: pdelab/boilerplate/pdelab.hh:1575
Dune::PDELab::GlobalAssembler::getGO
const GO & getGO() const
Definition: pdelab/boilerplate/pdelab.hh:1635
Dune::PDELab::DGLegendreSpace::getFEM
const FEM & getFEM() const
Definition: pdelab/boilerplate/pdelab.hh:1312
Dune::PDELab::DGCONBase< SolverCategory::overlapping >::CON
P0ParallelConstraints CON
Definition: pdelab/boilerplate/pdelab.hh:863
gridfunctionspace.hh
Dune::PDELab::StructuredGrid< YaspGrid< dim > >::StructuredGrid
StructuredGrid(Dune::GeometryType::BasicType meshtype, std::array< double, dimworld > lower_left, std::array< double, dimworld > upper_right, std::array< unsigned int, dim > cells, std::array< bool, dim > periodic, int overlap=1)
Definition: pdelab/boilerplate/pdelab.hh:252
Dune::PDELab::P0Space::copyConstrainedDOFS
void copyConstrainedDOFS(const DOF &xin, DOF &xout) const
Definition: pdelab/boilerplate/pdelab.hh:1445
Dune::PDELab::DGQkGLSpace::GFS
GridFunctionSpace< GV, FEM, CON, VBE > GFS
Definition: pdelab/boilerplate/pdelab.hh:1199
Dune::PDELab::DGQkGLSpace::GV
T::LeafGridView GV
Definition: pdelab/boilerplate/pdelab.hh:1190
Dune::PDELab::CGSpace::getFEM
const FEM & getFEM() const
Definition: pdelab/boilerplate/pdelab.hh:622
Dune::PDELab::UnstructuredGrid::operator*
T & operator*()
Definition: pdelab/boilerplate/pdelab.hh:361
Dune::PDELab::DGQkSpace::getCC
const CC & getCC() const
Definition: pdelab/boilerplate/pdelab.hh:1132
linearproblem.hh
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::assembleConstraints
void assembleConstraints(const BCType &bctype)
Definition: pdelab/boilerplate/pdelab.hh:770
Dune::PDELab::ISTLSolverBackend_CG_SSOR< FS, ASS, SolverCategory::nonoverlapping >::ISTLSolverBackend_CG_SSOR
ISTLSolverBackend_CG_SSOR(const FS &fs, const ASS &ass, unsigned maxiter_=5000, int steps_=5, int verbose_=1)
Definition: pdelab/boilerplate/pdelab.hh:1824
Dune::PDELab::DGQkGLSpace
Definition: pdelab/boilerplate/pdelab.hh:1184
Dune::PDELab::GalerkinGlobalAssembler::operator*
const GO & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:1543
Dune::PDELab::DGQkGLSpace::NT
N NT
Definition: pdelab/boilerplate/pdelab.hh:1194
Dune::PDELab::DGQkOPBSpace::CONB
DGCONBase< st > CONB
Definition: pdelab/boilerplate/pdelab.hh:1005
Dune::PDELab::DGQkOPBSpace::DGF
Dune::PDELab::DiscreteGridFunction< GFS, DOF > DGF
Definition: pdelab/boilerplate/pdelab.hh:1010
Dune::PDELab::DGPkSpace::clearConstraints
void clearConstraints()
Definition: pdelab/boilerplate/pdelab.hh:946
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::getCC
CC & getCC()
Definition: pdelab/boilerplate/pdelab.hh:759
Dune::PDELab::ISTLSolverBackend_CG_SSOR< FS, ASS, SolverCategory::nonoverlapping >::getLS
const LS & getLS() const
Definition: pdelab/boilerplate/pdelab.hh:1831
Dune::PDELab::DGQkOPBSpace::getCC
CC & getCC()
Definition: pdelab/boilerplate/pdelab.hh:1034
Dune::PDELab::P0Space::FEM
Dune::PDELab::P0LocalFiniteElementMap< ctype, NT, dim > FEM
Definition: pdelab/boilerplate/pdelab.hh:1386
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::clearConstraints
void clearConstraints()
Definition: pdelab/boilerplate/pdelab.hh:776
Dune::PDELab::ISTLSolverBackend_IterativeDefault
Definition: pdelab/boilerplate/pdelab.hh:1870
Dune::PDELab::DGQkGLSpace::dim
static const int dim
Definition: pdelab/boilerplate/pdelab.hh:1192
Dune::PDELab::CGSpace::getGFS
GFS & getGFS()
Definition: pdelab/boilerplate/pdelab.hh:628
Dune::PDELab::DGQkGLSpace::getGFS
const GFS & getGFS() const
Definition: pdelab/boilerplate/pdelab.hh:1222
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR< FS, ASS, SolverCategory::nonoverlapping >::operator*
const LS & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:1759
Dune::PDELab::CGSpace::CON
CONB::CON CON
Definition: pdelab/boilerplate/pdelab.hh:594
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::GFS
GridFunctionSpace< ES, FEM, CON, VBE > GFS
Definition: pdelab/boilerplate/pdelab.hh:716
Dune::PB::Pk
@ Pk
Definition: l2orthonormal.hh:155
dim
static const int dim
Definition: adaptivity.hh:84
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR< FS, ASS, SolverCategory::overlapping >::getLS
const LS & getLS() const
Definition: pdelab/boilerplate/pdelab.hh:1781
Dune::PDELab::OneStepGridOperator::Jacobian
Traits::Jacobian Jacobian
Definition: gridoperator/onestep.hh:57
Dune::PDELab::StructuredGrid< YaspGrid< dim > >::Grid
YaspGrid< dim > Grid
Definition: pdelab/boilerplate/pdelab.hh:201
Dune::PDELab::ISTLSolverBackend_IterativeDefault< FS, ASS, SolverCategory::overlapping >::ISTLSolverBackend_IterativeDefault
ISTLSolverBackend_IterativeDefault(const FS &fs, const ASS &ass, unsigned maxiter_=5000, int verbose_=1)
Definition: pdelab/boilerplate/pdelab.hh:1924
Dune::PDELab::DGQkGLSpace::FEM
QkDGLocalFiniteElementMap< ctype, NT, degree, dim, QkDGBasisPolynomial::lobatto > FEM
Definition: pdelab/boilerplate/pdelab.hh:1195
Dune::PDELab::StructuredGrid< YaspGrid< dim > >::getGrid
Grid & getGrid()
Definition: pdelab/boilerplate/pdelab.hh:289
Dune::PDELab::CGSpace::clearConstraints
void clearConstraints()
Definition: pdelab/boilerplate/pdelab.hh:657
Dune::PDELab::DGQkSpace::copyNonConstrainedDOFS
void copyNonConstrainedDOFS(const DOF &xin, DOF &xout) const
Definition: pdelab/boilerplate/pdelab.hh:1164
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::nonoverlapping, BCType, GV >::getCON
const CON & getCON() const
Definition: pdelab/boilerplate/pdelab.hh:568
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::DGF
Dune::PDELab::DiscreteGridFunction< GFS, DOF > DGF
Definition: pdelab/boilerplate/pdelab.hh:720
Dune::PDELab::DGCONBase< SolverCategory::overlapping >::getCON
const CON & getCON() const
Definition: pdelab/boilerplate/pdelab.hh:869
Dune::PDELab::ISTLSolverBackend_CG_SSOR::operator->
const LS * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:1810
Dune::PDELab::DGQkSpace::CC
GFS::template ConstraintsContainer< N >::Type CC
Definition: pdelab/boilerplate/pdelab.hh:1106
conforming.hh
Dune::PDELab::CGFEMBase< GV, C, R, degree, dim, Dune::GeometryType::cube >::CGFEMBase
CGFEMBase(const GV &gridview)
Definition: pdelab/boilerplate/pdelab.hh:419
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR< FS, ASS, SolverCategory::overlapping >::operator*
LS & operator*()
Definition: pdelab/boilerplate/pdelab.hh:1782
Dune::PDELab::GalerkinGlobalAssemblerNewBackend::MBE
Dune::PDELab::ISTL::BCRSMatrixBackend MBE
Definition: pdelab/boilerplate/pdelab.hh:1563
Dune::PDELab::UnstructuredGrid::operator->
T * operator->()
Definition: pdelab/boilerplate/pdelab.hh:366
Dune::PDELab::UnstructuredGrid::getGrid
const T & getGrid() const
Definition: pdelab/boilerplate/pdelab.hh:356
Dune::PDELab::StructuredGrid::getSharedPtr
std::shared_ptr< T > getSharedPtr()
Definition: pdelab/boilerplate/pdelab.hh:152
Dune::PDELab::StructuredGrid::StructuredGrid
StructuredGrid(Dune::GeometryType::BasicType meshtype, std::array< double, dimworld > lower_left, std::array< double, dimworld > upper_right, std::array< unsigned int, dim > cells)
Definition: pdelab/boilerplate/pdelab.hh:119
Dune::PDELab::DGLegendreSpace::VTKF
VTKGridFunctionAdapter< DGF > VTKF
Definition: pdelab/boilerplate/pdelab.hh:1299
Dune::PDELab::DGLegendreSpace::DGLegendreSpace
DGLegendreSpace(const GV &gridview)
Definition: pdelab/boilerplate/pdelab.hh:1302
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::CC
GFS::template ConstraintsContainer< N >::Type CC
Definition: pdelab/boilerplate/pdelab.hh:721
Dune::PDELab::P0Space::GFS
GridFunctionSpace< GV, FEM, CON, VBE > GFS
Definition: pdelab/boilerplate/pdelab.hh:1390
Dune::PDELab::ISTLSolverBackend_IterativeDefault::operator->
const LS * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:1886
Dune::PDELab::StructuredGrid::operator*
const T & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:179
Dune::PDELab::DGQkSpace::FEM
QkDGLocalFiniteElementMap< ctype, NT, degree, dim > FEM
Definition: pdelab/boilerplate/pdelab.hh:1099
Dune::PDELab::DGQkOPBSpace::DOF
Backend::Vector< GFS, N > DOF
Definition: pdelab/boilerplate/pdelab.hh:1009
Dune::PDELab::P0Space::CON
CONB::CON CON
Definition: pdelab/boilerplate/pdelab.hh:1388
Dune::PDELab::CGCONBase< Grid, 1, Dune::GeometryType::cube, MeshType::nonconforming, SolverCategory::sequential, BCType, GV >::getCON
const CON & getCON() const
Definition: pdelab/boilerplate/pdelab.hh:489
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR::LS
Dune::PDELab::ISTLBackend_SEQ_CG_AMG_SSOR< typename ASS::GO > LS
Definition: pdelab/boilerplate/pdelab.hh:1722
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR< FS, ASS, SolverCategory::nonoverlapping >::operator->
const LS * operator->() const
Definition: pdelab/boilerplate/pdelab.hh:1760
Dune::PDELab::UnstructuredGrid::operator*
const T & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:371
Dune::PDELab::GalerkinGlobalAssemblerNewBackend::operator*
const GO & operator*() const
Definition: pdelab/boilerplate/pdelab.hh:1596
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::getCC
const CC & getCC() const
Definition: pdelab/boilerplate/pdelab.hh:765
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::getGFS
GFS & getGFS()
Definition: pdelab/boilerplate/pdelab.hh:747
Dune::PDELab::CGSpace::GFS
GridFunctionSpace< GV, FEM, CON, VBE > GFS
Definition: pdelab/boilerplate/pdelab.hh:597
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::overlapping, BCType, GV >::getCON
const CON & getCON() const
Definition: pdelab/boilerplate/pdelab.hh:541
Dune::PDELab::OneStepGlobalAssembler::OneStepGlobalAssembler
OneStepGlobalAssembler(GO1 &go1, GO2 &go2)
Definition: pdelab/boilerplate/pdelab.hh:1674
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::overlapping, BCType, GV >::CGCONBase
CGCONBase(Grid &grid, const BCType &bctype)
Definition: pdelab/boilerplate/pdelab.hh:533
Dune::PDELab::ISTLSolverBackend_CG_AMG_SSOR::getLS
const LS & getLS() const
Definition: pdelab/boilerplate/pdelab.hh:1731
Dune::PDELab::GlobalAssembler::GlobalAssembler
GlobalAssembler(const FSU &fsu, const FSV &fsv, LOP &lop, const std::size_t nonzeros)
Definition: pdelab/boilerplate/pdelab.hh:1623
Dune::PDELab::DGQkGLSpace::assembleConstraints
void assembleConstraints(const BCTYPE &bctype)
Definition: pdelab/boilerplate/pdelab.hh:1231
Dune::PDELab::ISTLSolverBackend_IterativeDefault< FS, ASS, SolverCategory::nonoverlapping >::LS
Dune::PDELab::ISTLBackend_NOVLP_BCGS_SSORk< typename ASS::GO > LS
Definition: pdelab/boilerplate/pdelab.hh:1898
Dune::PDELab::CGCONBase< Grid, degree, gt, MeshType::conforming, SolverCategory::nonoverlapping, BCType, GV >::getCON
CON & getCON()
Definition: pdelab/boilerplate/pdelab.hh:567
Dune::PDELab::DGLegendreSpace::VBE
VBET VBE
Definition: pdelab/boilerplate/pdelab.hh:1294
Dune::PDELab::DGQkSpace::dim
static const int dim
Definition: pdelab/boilerplate/pdelab.hh:1096
Dune::PDELab::set_nonconstrained_dofs
void set_nonconstrained_dofs(const CG &cg, typename XG::ElementType x, XG &xg)
Definition: constraints.hh:960
Dune::PDELab::DGQkSpace::DGF
Dune::PDELab::DiscreteGridFunction< GFS, DOF > DGF
Definition: pdelab/boilerplate/pdelab.hh:1105
Dune::PDELab::P0Space::VBE
VBET VBE
Definition: pdelab/boilerplate/pdelab.hh:1389
Dune::PDELab::P0Space::NT
N NT
Definition: pdelab/boilerplate/pdelab.hh:1385
Dune::PDELab::ISTLSolverBackend_CG_SSOR::getLS
const LS & getLS() const
Definition: pdelab/boilerplate/pdelab.hh:1806
Dune::PDELab::CGSpace< T, N, degree, BCType, gt, mt, SolverCategory::nonoverlapping, VBET >::setConstrainedDOFS
void setConstrainedDOFS(DOF &x, NT nt) const
Definition: pdelab/boilerplate/pdelab.hh:781
Dune::PDELab::OneStepGlobalAssembler::GO
Dune::PDELab::OneStepGridOperator< typename GO1::GO, typename GO2::GO, implicit > GO
Definition: pdelab/boilerplate/pdelab.hh:1671