Reference documentation for deal.II version 9.2.0
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
fe_q_bubbles.cc
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2012 - 2020 by the deal.II authors
4 //
5 // This file is part of the deal.II library.
6 //
7 // The deal.II library is free software; you can use it, redistribute
8 // it, and/or modify it under the terms of the GNU Lesser General
9 // Public License as published by the Free Software Foundation; either
10 // version 2.1 of the License, or (at your option) any later version.
11 // The full text of the license can be found in the file LICENSE.md at
12 // the top level directory of deal.II.
13 //
14 // ---------------------------------------------------------------------
15 
16 
22 
25 
26 #include <deal.II/fe/fe_dgq.h>
27 #include <deal.II/fe/fe_nothing.h>
29 #include <deal.II/fe/fe_tools.h>
30 #include <deal.II/fe/fe_values.h>
31 #include <deal.II/fe/mapping_q1.h>
32 
34 #include <deal.II/grid/tria.h>
35 
36 #include <memory>
37 #include <sstream>
38 #include <vector>
39 
41 
42 
43 namespace internal
44 {
45  namespace FE_Q_Bubbles
46  {
47  namespace
48  {
49  template <int dim, int spacedim>
50  inline void
52  const ::FE_Q_Bubbles<dim, spacedim> & fe,
53  std::vector<std::vector<FullMatrix<double>>> &matrices,
54  const bool isotropic_only)
55  {
56  const unsigned int dpc = fe.dofs_per_cell;
57  const unsigned int degree = fe.degree;
58 
59  // Initialize quadrature formula on fine cells
60  std::unique_ptr<Quadrature<dim>> q_fine;
61  Quadrature<1> q_dummy(std::vector<Point<1>>(1),
62  std::vector<double>(1, 1.));
63  switch (dim)
64  {
65  case 1:
66  if (spacedim == 1)
67  q_fine = std_cxx14::make_unique<QGauss<dim>>(degree + 1);
68  else if (spacedim == 2)
69  q_fine = std_cxx14::make_unique<QAnisotropic<dim>>(
70  QGauss<1>(degree + 1), q_dummy);
71  else
72  q_fine = std_cxx14::make_unique<QAnisotropic<dim>>(
73  QGauss<1>(degree + 1), q_dummy, q_dummy);
74  break;
75  case 2:
76  if (spacedim == 2)
77  q_fine = std_cxx14::make_unique<QGauss<dim>>(degree + 1);
78  else
79  q_fine = std_cxx14::make_unique<QAnisotropic<dim>>(
80  QGauss<1>(degree + 1), QGauss<1>(degree + 1), q_dummy);
81  break;
82  case 3:
83  q_fine = std_cxx14::make_unique<QGauss<dim>>(degree + 1);
84  break;
85  default:
86  Assert(false, ExcInternalError());
87  }
88 
89  Assert(q_fine.get() != nullptr, ExcInternalError());
90  const unsigned int nq = q_fine->size();
91 
92  // loop over all possible refinement cases
93  unsigned int ref_case = (isotropic_only) ?
96  for (; ref_case <= RefinementCase<dim>::isotropic_refinement;
97  ++ref_case)
98  {
99  const unsigned int nc =
101 
102  for (unsigned int i = 0; i < nc; ++i)
103  {
104  Assert(matrices[ref_case - 1][i].n() == dpc,
105  ExcDimensionMismatch(matrices[ref_case - 1][i].n(),
106  dpc));
107  Assert(matrices[ref_case - 1][i].m() == dpc,
108  ExcDimensionMismatch(matrices[ref_case - 1][i].m(),
109  dpc));
110  }
111 
112  // create a respective refinement on the triangulation
114  GridGenerator::hyper_cube(tr, 0, 1);
115  tr.begin_active()->set_refine_flag(RefinementCase<dim>(ref_case));
117 
119  dh.distribute_dofs(fe);
120 
123  fe,
124  *q_fine,
126 
127  const unsigned int n_dofs = dh.n_dofs();
128 
129  FullMatrix<double> fine_mass(n_dofs);
130  FullMatrix<double> coarse_rhs_matrix(n_dofs, dpc);
131 
132  std::vector<std::vector<types::global_dof_index>> child_ldi(
133  nc, std::vector<types::global_dof_index>(fe.dofs_per_cell));
134 
135  // now create the mass matrix and all the right_hand sides
136  unsigned int child_no = 0;
137  typename ::DoFHandler<dim>::active_cell_iterator cell =
138  dh.begin_active();
139  for (; cell != dh.end(); ++cell, ++child_no)
140  {
141  fine.reinit(cell);
142  cell->get_dof_indices(child_ldi[child_no]);
143 
144  for (unsigned int q = 0; q < nq; ++q)
145  for (unsigned int i = 0; i < dpc; ++i)
146  for (unsigned int j = 0; j < dpc; ++j)
147  {
148  const unsigned int gdi = child_ldi[child_no][i];
149  const unsigned int gdj = child_ldi[child_no][j];
150  fine_mass(gdi, gdj) += fine.shape_value(i, q) *
151  fine.shape_value(j, q) *
152  fine.JxW(q);
153  Point<dim> quad_tmp;
154  for (unsigned int k = 0; k < dim; ++k)
155  quad_tmp(k) = fine.quadrature_point(q)(k);
156  coarse_rhs_matrix(gdi, j) +=
157  fine.shape_value(i, q) * fe.shape_value(j, quad_tmp) *
158  fine.JxW(q);
159  }
160  }
161 
162  // now solve for all right-hand sides simultaneously
163  ::FullMatrix<double> solution(n_dofs, dpc);
164  fine_mass.gauss_jordan();
165  fine_mass.mmult(solution, coarse_rhs_matrix);
166 
167  // and distribute to the fine cell matrices
168  for (unsigned int child_no = 0; child_no < nc; ++child_no)
169  for (unsigned int i = 0; i < dpc; ++i)
170  for (unsigned int j = 0; j < dpc; ++j)
171  {
172  const unsigned int gdi = child_ldi[child_no][i];
173  // remove small entries
174  if (std::fabs(solution(gdi, j)) > 1.e-12)
175  matrices[ref_case - 1][child_no](i, j) = solution(gdi, j);
176  }
177  }
178  }
179  } // namespace
180  } // namespace FE_Q_Bubbles
181 } // namespace internal
182 
183 
184 template <int dim, int spacedim>
185 FE_Q_Bubbles<dim, spacedim>::FE_Q_Bubbles(const unsigned int q_degree)
186  : FE_Q_Base<TensorProductPolynomialsBubbles<dim>, dim, spacedim>(
189  QGaussLobatto<1>(q_degree + 1).get_points())),
190  FiniteElementData<dim>(get_dpo_vector(q_degree),
191  1,
192  q_degree + 1,
193  FiniteElementData<dim>::H1),
194  get_riaf_vector(q_degree))
195  , n_bubbles((q_degree <= 1) ? 1 : dim)
196 {
197  Assert(q_degree > 0,
198  ExcMessage("This element can only be used for polynomial degrees "
199  "greater than zero"));
200 
201  this->initialize(QGaussLobatto<1>(q_degree + 1).get_points());
202 
203  // adjust unit support point for discontinuous node
205  for (unsigned int d = 0; d < dim; ++d)
206  point[d] = 0.5;
207  for (unsigned int i = 0; i < n_bubbles; ++i)
208  this->unit_support_points.push_back(point);
210 
212  if (dim == spacedim)
213  {
215  this->prolongation,
216  false);
217  // Fill restriction matrices with L2-projection
219  }
220 }
221 
222 
223 
224 template <int dim, int spacedim>
226  : FE_Q_Base<TensorProductPolynomialsBubbles<dim>, dim, spacedim>(
228  Polynomials::generate_complete_Lagrange_basis(points.get_points())),
229  FiniteElementData<dim>(get_dpo_vector(points.size() - 1),
230  1,
231  points.size(),
232  FiniteElementData<dim>::H1),
233  get_riaf_vector(points.size() - 1))
234  , n_bubbles((points.size() - 1 <= 1) ? 1 : dim)
235 {
236  Assert(points.size() > 1,
237  ExcMessage("This element can only be used for polynomial degrees "
238  "at least one"));
239 
240  this->initialize(points.get_points());
241 
242  // adjust unit support point for discontinuous node
244  for (unsigned int d = 0; d < dim; ++d)
245  point[d] = 0.5;
246  for (unsigned int i = 0; i < n_bubbles; ++i)
247  this->unit_support_points.push_back(point);
249 
251  if (dim == spacedim)
252  {
254  this->prolongation,
255  false);
256  // Fill restriction matrices with L2-projection
258  }
259 }
260 
261 
262 
263 template <int dim, int spacedim>
264 std::string
266 {
267  // note that the FETools::get_fe_by_name function depends on the
268  // particular format of the string this function returns, so they have to be
269  // kept in synch
270 
271  std::ostringstream namebuf;
272  bool type = true;
273  const unsigned int n_points = this->degree;
274  std::vector<double> points(n_points);
275  const unsigned int dofs_per_cell = this->dofs_per_cell;
276  const std::vector<Point<dim>> &unit_support_points =
277  this->unit_support_points;
278  unsigned int index = 0;
279 
280  // Decode the support points in one coordinate direction.
281  for (unsigned int j = 0; j < dofs_per_cell; j++)
282  {
283  if ((dim > 1) ? (unit_support_points[j](1) == 0 &&
284  ((dim > 2) ? unit_support_points[j](2) == 0 : true)) :
285  true)
286  {
287  if (index == 0)
288  points[index] = unit_support_points[j](0);
289  else if (index == 1)
290  points[n_points - 1] = unit_support_points[j](0);
291  else
292  points[index - 1] = unit_support_points[j](0);
293 
294  index++;
295  }
296  }
297  // Do not consider the discontinuous node for dimension 1
298  Assert(index == n_points || (dim == 1 && index == n_points + n_bubbles),
299  ExcMessage(
300  "Could not decode support points in one coordinate direction."));
301 
302  // Check whether the support points are equidistant.
303  for (unsigned int j = 0; j < n_points; j++)
304  if (std::fabs(points[j] - static_cast<double>(j) / (this->degree - 1)) >
305  1e-15)
306  {
307  type = false;
308  break;
309  }
310 
311  if (type == true)
312  {
313  if (this->degree > 3)
314  namebuf << "FE_Q_Bubbles<" << Utilities::dim_string(dim, spacedim)
315  << ">(QIterated(QTrapez()," << this->degree - 1 << "))";
316  else
317  namebuf << "FE_Q_Bubbles<" << Utilities::dim_string(dim, spacedim)
318  << ">(" << this->degree - 1 << ")";
319  }
320  else
321  {
322  // Check whether the support points come from QGaussLobatto.
323  const QGaussLobatto<1> points_gl(n_points);
324  type = true;
325  for (unsigned int j = 0; j < n_points; j++)
326  if (points[j] != points_gl.point(j)(0))
327  {
328  type = false;
329  break;
330  }
331  if (type == true)
332  namebuf << "FE_Q_Bubbles<" << dim << ">(" << this->degree - 1 << ")";
333  else
334  namebuf << "FE_Q_Bubbles<" << dim << ">(QUnknownNodes(" << this->degree
335  << "))";
336  }
337  return namebuf.str();
338 }
339 
340 
341 
342 template <int dim, int spacedim>
343 std::unique_ptr<FiniteElement<dim, spacedim>>
345 {
346  return std_cxx14::make_unique<FE_Q_Bubbles<dim, spacedim>>(*this);
347 }
348 
349 
350 
351 template <int dim, int spacedim>
352 void
355  const std::vector<Vector<double>> &support_point_values,
356  std::vector<double> & nodal_values) const
357 {
358  Assert(support_point_values.size() == this->unit_support_points.size(),
359  ExcDimensionMismatch(support_point_values.size(),
360  this->unit_support_points.size()));
361  Assert(nodal_values.size() == this->dofs_per_cell,
362  ExcDimensionMismatch(nodal_values.size(), this->dofs_per_cell));
363  Assert(support_point_values[0].size() == this->n_components(),
364  ExcDimensionMismatch(support_point_values[0].size(),
365  this->n_components()));
366 
367  for (unsigned int i = 0; i < this->dofs_per_cell - 1; ++i)
368  {
369  const std::pair<unsigned int, unsigned int> index =
370  this->system_to_component_index(i);
371  nodal_values[i] = support_point_values[i](index.first);
372  }
373 
374  // We don't use the bubble functions for local interpolation
375  for (unsigned int i = 0; i < n_bubbles; ++i)
376  nodal_values[nodal_values.size() - i - 1] = 0.;
377 }
378 
379 
380 
381 template <int dim, int spacedim>
382 void
384  const FiniteElement<dim, spacedim> &x_source_fe,
385  FullMatrix<double> & interpolation_matrix) const
386 {
387  // We don't know how to do this properly, yet.
388  // However, for SolutionTransfer to work we need to provide an implementation
389  // for the case that the x_source_fe is identical to this FE
390  using FEQBUBBLES = FE_Q_Bubbles<dim, spacedim>;
391 
392  AssertThrow(
393  (x_source_fe.get_name().find("FE_Q_Bubbles<") == 0) ||
394  (dynamic_cast<const FEQBUBBLES *>(&x_source_fe) != nullptr),
396  Assert(interpolation_matrix.m() == this->dofs_per_cell,
397  ExcDimensionMismatch(interpolation_matrix.m(), this->dofs_per_cell));
398  Assert(interpolation_matrix.n() == x_source_fe.dofs_per_cell,
399  ExcDimensionMismatch(interpolation_matrix.m(),
400  x_source_fe.dofs_per_cell));
401 
402  // Provide a short cut in case we are just inquiring the identity
403  auto casted_fe = dynamic_cast<const FEQBUBBLES *>(&x_source_fe);
404  if (casted_fe != nullptr && casted_fe->degree == this->degree)
405  for (unsigned int i = 0; i < interpolation_matrix.m(); ++i)
406  interpolation_matrix.set(i, i, 1.);
407  // else we need to do more...
408  else
409  Assert(
410  false,
411  (typename FiniteElement<dim,
412  spacedim>::ExcInterpolationNotImplemented()));
413 }
414 
415 
416 
417 template <int dim, int spacedim>
418 std::vector<bool>
420 {
421  unsigned int n_cont_dofs = Utilities::fixed_power<dim>(q_deg + 1);
422  const unsigned int n_bubbles = (q_deg <= 1 ? 1 : dim);
423  return std::vector<bool>(n_cont_dofs + n_bubbles, true);
424 }
425 
426 
427 
428 template <int dim, int spacedim>
429 std::vector<unsigned int>
431 {
432  std::vector<unsigned int> dpo(dim + 1, 1U);
433  for (unsigned int i = 1; i < dpo.size(); ++i)
434  dpo[i] = dpo[i - 1] * (q_deg - 1);
435 
436  dpo[dim] +=
437  (q_deg <= 1 ? 1 : dim); // all the bubble functions are discontinuous
438  return dpo;
439 }
440 
441 
442 
443 template <int dim, int spacedim>
444 bool
446  const unsigned int shape_index,
447  const unsigned int face_index) const
448 {
449  // discontinuous functions have no support on faces
450  if (shape_index >= this->n_dofs_per_cell() - n_bubbles)
451  return false;
452  else
453  return FE_Q_Base<TensorProductPolynomialsBubbles<dim>, dim, spacedim>::
454  has_support_on_face(shape_index, face_index);
455 }
456 
457 
458 
459 template <int dim, int spacedim>
460 const FullMatrix<double> &
462  const unsigned int child,
463  const RefinementCase<dim> &refinement_case) const
464 {
465  AssertIndexRange(refinement_case,
467  Assert(refinement_case != RefinementCase<dim>::no_refinement,
468  ExcMessage(
469  "Prolongation matrices are only available for refined cells!"));
470  AssertIndexRange(child, GeometryInfo<dim>::n_children(refinement_case));
471 
472  Assert(this->prolongation[refinement_case - 1][child].n() != 0,
473  ExcMessage("This prolongation matrix has not been computed yet!"));
474  // finally return the matrix
475  return this->prolongation[refinement_case - 1][child];
476 }
477 
478 
479 
480 template <int dim, int spacedim>
481 const FullMatrix<double> &
483  const unsigned int child,
484  const RefinementCase<dim> &refinement_case) const
485 {
486  AssertIndexRange(refinement_case,
488  Assert(refinement_case != RefinementCase<dim>::no_refinement,
489  ExcMessage(
490  "Restriction matrices are only available for refined cells!"));
491  AssertIndexRange(child, GeometryInfo<dim>::n_children(refinement_case));
492 
493  Assert(this->restriction[refinement_case - 1][child].n() != 0,
494  ExcMessage("This restriction matrix has not been computed yet!"));
495 
496  // finally return the matrix
497  return this->restriction[refinement_case - 1][child];
498 }
499 
500 
501 
502 template <int dim, int spacedim>
505  const FiniteElement<dim, spacedim> &fe_other,
506  const unsigned int codim) const
507 {
508  Assert(codim <= dim, ExcImpossibleInDim(dim));
509 
510  // vertex/line/face domination
511  // (if fe_other is derived from FE_DGQ)
512  // ------------------------------------
513  if (codim > 0)
514  if (dynamic_cast<const FE_DGQ<dim, spacedim> *>(&fe_other) != nullptr)
515  // there are no requirements between continuous and discontinuous elements
517 
518  // vertex/line/face domination
519  // (if fe_other is not derived from FE_DGQ)
520  // & cell domination
521  // ----------------------------------------
522  if (const FE_Q_Bubbles<dim, spacedim> *fe_bubbles_other =
523  dynamic_cast<const FE_Q_Bubbles<dim, spacedim> *>(&fe_other))
524  {
525  if (this->degree < fe_bubbles_other->degree)
527  else if (this->degree == fe_bubbles_other->degree)
529  else
531  }
532  else if (const FE_Nothing<dim> *fe_nothing =
533  dynamic_cast<const FE_Nothing<dim> *>(&fe_other))
534  {
535  if (fe_nothing->is_dominating())
537  else
538  // the FE_Nothing has no degrees of freedom and it is typically used
539  // in a context where we don't require any continuity along the
540  // interface
542  }
543 
544  Assert(false, ExcNotImplemented());
546 }
547 
548 
549 // explicit instantiations
550 #include "fe_q_bubbles.inst"
551 
fe_values.h
FE_DGQ
Definition: fe_dgq.h:112
FE_Nothing< dim >
update_quadrature_points
@ update_quadrature_points
Transformed quadrature points.
Definition: fe_update_flags.h:122
GeometryInfo::n_children
static unsigned int n_children(const RefinementCase< dim > &refinement_case)
fe_q_bubbles.h
StaticMappingQ1
Definition: mapping_q1.h:88
Polynomials
Definition: polynomial.h:41
FE_Q_Bubbles::get_prolongation_matrix
virtual const FullMatrix< double > & get_prolongation_matrix(const unsigned int child, const RefinementCase< dim > &refinement_case) const override
Definition: fe_q_bubbles.cc:461
FE_Q_Bubbles::has_support_on_face
virtual bool has_support_on_face(const unsigned int shape_index, const unsigned int face_index) const override
Definition: fe_q_bubbles.cc:445
StandardExceptions::ExcNotImplemented
static ::ExceptionBase & ExcNotImplemented()
Triangulation
Definition: tria.h:1109
tria.h
TensorProductPolynomialsBubbles
Definition: tensor_product_polynomials.h:37
FiniteElementData
Definition: fe_base.h:147
FE_Q_Bubbles::get_name
virtual std::string get_name() const override
Definition: fe_q_bubbles.cc:265
FullMatrix::set
void set(const size_type i, const size_type j, const number value)
FullMatrix::m
size_type m() const
FE_Q_Base
Definition: fe_q_base.h:44
mapping_q1.h
FE_Q_Bubbles::n_bubbles
const unsigned int n_bubbles
Definition: fe_q_bubbles.h:182
FE_Q_Bubbles::convert_generalized_support_point_values_to_dof_values
virtual void convert_generalized_support_point_values_to_dof_values(const std::vector< Vector< double >> &support_point_values, std::vector< double > &nodal_values) const override
Definition: fe_q_bubbles.cc:354
LAPACKSupport::U
static const char U
Definition: lapack_support.h:167
GeometryInfo
Definition: geometry_info.h:1224
FE_Q_Bubbles::compare_for_domination
virtual FiniteElementDomination::Domination compare_for_domination(const FiniteElement< dim, spacedim > &fe_other, const unsigned int codim=0) const override final
Definition: fe_q_bubbles.cc:504
AssertIndexRange
#define AssertIndexRange(index, range)
Definition: exceptions.h:1649
DoFHandler::n_components
unsigned int n_components(const DoFHandler< dim, spacedim > &dh)
Physics::Elasticity::Kinematics::e
SymmetricTensor< 2, dim, Number > e(const Tensor< 2, dim, Number > &F)
FullMatrix::n
size_type n() const
FETools::compute_embedding_matrices
void compute_embedding_matrices(const FiniteElement< dim, spacedim > &fe, std::vector< std::vector< FullMatrix< number >>> &matrices, const bool isotropic_only=false, const double threshold=1.e-12)
FETools::compute_projection_matrices
void compute_projection_matrices(const FiniteElement< dim, spacedim > &fe, std::vector< std::vector< FullMatrix< number >>> &matrices, const bool isotropic_only=false)
update_values
@ update_values
Shape function values.
Definition: fe_update_flags.h:78
Physics::Elasticity::Kinematics::d
SymmetricTensor< 2, dim, Number > d(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
FE_Q_Bubbles::clone
virtual std::unique_ptr< FiniteElement< dim, spacedim > > clone() const override
Definition: fe_q_bubbles.cc:344
DoFHandler
Definition: dof_handler.h:205
quadrature_lib.h
fe_nothing.h
Polynomials::generate_complete_Lagrange_basis
std::vector< Polynomial< double > > generate_complete_Lagrange_basis(const std::vector< Point< 1 >> &points)
Definition: polynomial.cc:834
FiniteElementDomination::either_element_can_dominate
@ either_element_can_dominate
Definition: fe_base.h:100
OpenCASCADE::point
Point< spacedim > point(const gp_Pnt &p, const double tolerance=1e-10)
Definition: utilities.cc:188
DoFHandler::distribute_dofs
virtual void distribute_dofs(const FiniteElement< dim, spacedim > &fe)
Definition: dof_handler.cc:1247
FEValues
Definition: fe.h:38
FE_Q_Bubbles::get_dpo_vector
static std::vector< unsigned int > get_dpo_vector(const unsigned int degree)
Definition: fe_q_bubbles.cc:430
Differentiation::SD::fabs
Expression fabs(const Expression &x)
Definition: symengine_math.cc:273
FiniteElementDomination::no_requirements
@ no_requirements
Definition: fe_base.h:104
Quadrature::point
const Point< dim > & point(const unsigned int i) const
FiniteElementDomination::neither_element_dominates
@ neither_element_dominates
Definition: fe_base.h:96
FiniteElementDomination::other_element_dominates
@ other_element_dominates
Definition: fe_base.h:92
Triangulation::execute_coarsening_and_refinement
virtual void execute_coarsening_and_refinement()
Definition: tria.cc:13385
FE_Q_Base< TensorProductPolynomialsBubbles< dim >, dim, dim >::q_degree
const unsigned int q_degree
Definition: fe_q_base.h:347
FiniteElementDomination::Domination
Domination
Definition: fe_base.h:83
StandardExceptions::ExcMessage
static ::ExceptionBase & ExcMessage(std::string arg1)
Triangulation::begin_active
active_cell_iterator begin_active(const unsigned int level=0) const
Definition: tria.cc:12013
FiniteElementData::dofs_per_cell
const unsigned int dofs_per_cell
Definition: fe_base.h:282
Utilities::dim_string
std::string dim_string(const int dim, const int spacedim)
Definition: utilities.cc:559
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:358
FiniteElement::prolongation
std::vector< std::vector< FullMatrix< double > > > prolongation
Definition: fe.h:2428
RefinementCase
Definition: geometry_info.h:795
FE_Q_Bubbles::get_riaf_vector
static std::vector< bool > get_riaf_vector(const unsigned int degree)
Definition: fe_q_bubbles.cc:419
FEValues::reinit
void reinit(const TriaIterator< DoFCellAccessor< DoFHandlerType< dim, spacedim >, level_dof_access >> &cell)
fe_dgq.h
AssertDimension
#define AssertDimension(dim1, dim2)
Definition: exceptions.h:1579
QGaussLobatto
Definition: quadrature_lib.h:76
FE_Q_Base< TensorProductPolynomialsBubbles< dim >, dim, dim >::initialize
void initialize(const std::vector< Point< 1 >> &support_points_1d)
Definition: fe_q_base.cc:425
FiniteElement
Definition: fe.h:648
QGauss
Definition: quadrature_lib.h:40
DoFHandler::end
cell_iterator end() const
Definition: dof_handler.cc:951
fe_tools.h
FE_Q_Bubbles
Definition: fe_q_bubbles.h:84
FE_Q_Bubbles::get_interpolation_matrix
virtual void get_interpolation_matrix(const FiniteElement< dim, spacedim > &source, FullMatrix< double > &matrix) const override
Definition: fe_q_bubbles.cc:383
FullMatrix::gauss_jordan
void gauss_jordan()
StandardExceptions::ExcInternalError
static ::ExceptionBase & ExcInternalError()
update_JxW_values
@ update_JxW_values
Transformed quadrature weights.
Definition: fe_update_flags.h:129
Assert
#define Assert(cond, exc)
Definition: exceptions.h:1419
GridGenerator::hyper_cube
void hyper_cube(Triangulation< dim, spacedim > &tria, const double left=0., const double right=1., const bool colorize=false)
FiniteElement::restriction
std::vector< std::vector< FullMatrix< double > > > restriction
Definition: fe.h:2414
FE_Q_Bubbles::FE_Q_Bubbles
FE_Q_Bubbles(const unsigned int p)
Definition: fe_q_bubbles.cc:185
StandardExceptions::ExcImpossibleInDim
static ::ExceptionBase & ExcImpossibleInDim(int arg1)
dof_handler.h
dof_accessor.h
FullMatrix::mmult
void mmult(FullMatrix< number2 > &C, const FullMatrix< number2 > &B, const bool adding=false) const
grid_generator.h
StandardExceptions::ExcDimensionMismatch
static ::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
Point
Definition: point.h:111
FiniteElement::get_name
virtual std::string get_name() const =0
quadrature.h
template_constraints.h
FiniteElementDomination::this_element_dominates
@ this_element_dominates
Definition: fe_base.h:88
Quadrature::size
unsigned int size() const
FullMatrix< double >
internal
Definition: aligned_vector.h:369
memory.h
Quadrature::get_points
const std::vector< Point< dim > > & get_points() const
FiniteElement::reinit_restriction_and_prolongation_matrices
void reinit_restriction_and_prolongation_matrices(const bool isotropic_restriction_only=false, const bool isotropic_prolongation_only=false)
Definition: fe.cc:275
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:359
Quadrature< 1 >
DoFHandler::begin_active
active_cell_iterator begin_active(const unsigned int level=0) const
Definition: dof_handler.cc:935
Vector< double >
AssertThrow
#define AssertThrow(cond, exc)
Definition: exceptions.h:1531
FE_Q_Bubbles::get_restriction_matrix
virtual const FullMatrix< double > & get_restriction_matrix(const unsigned int child, const RefinementCase< dim > &refinement_case) const override
Definition: fe_q_bubbles.cc:482
qprojector.h
DoFHandler::n_dofs
types::global_dof_index n_dofs() const
FiniteElement::unit_support_points
std::vector< Point< dim > > unit_support_points
Definition: fe.h:2452