this->eigenvectors[dir].reinit(mass_matrices[dir].n_cols(),
mass_matrices[dir].n_rows());
this->eigenvalues[dir].resize(mass_matrices[dir].n_cols());
- internal::TensorProductMatrix ::spectral_assembly<Number>(
+ internal::TensorProductMatrix::spectral_assembly<Number>(
&(mass_matrices[dir](0, 0)),
&(derivative_matrices[dir](0, 0)),
mass_matrices[dir].n_rows(),
Number * eigenvec_begin = eigenvectors_flat.data();
Number * eigenval_begin = eigenvalues_flat.data();
for (unsigned int lane = 0; lane < macro_size; ++lane)
- internal::TensorProductMatrix ::spectral_assembly<Number>(
+ internal::TensorProductMatrix::spectral_assembly<Number>(
mass_cbegin + nm * lane,
deriv_cbegin + nm * lane,
n_rows,
template <typename number>
void
- DoFInfo ::read_dof_indices(
+ DoFInfo::read_dof_indices(
const std::vector<types::global_dof_index> &local_indices,
const std::vector<unsigned int> & lexicographic_inv,
const AffineConstraints<number> & constraints,
void
- DoFInfo ::assign_ghosts(const std::vector<unsigned int> &boundary_cells)
+ DoFInfo::assign_ghosts(const std::vector<unsigned int> &boundary_cells)
{
Assert(boundary_cells.size() < row_starts.size(), ExcInternalError());
void
- DoFInfo ::reorder_cells(
+ DoFInfo::reorder_cells(
const TaskInfo & task_info,
const std::vector<unsigned int> & renumbering,
const std::vector<unsigned int> & constraint_pool_row_index,
void
- DoFInfo ::compute_dof_renumbering(
+ DoFInfo::compute_dof_renumbering(
std::vector<types::global_dof_index> &renumbering)
{
const unsigned int local_size = vector_partitioner->local_size();
typename Number,
typename VectorizedArrayType>
MappingInfoStorage<structdim, spacedim, Number, VectorizedArrayType>::
- QuadratureDescriptor ::QuadratureDescriptor()
+ QuadratureDescriptor::QuadratureDescriptor()
: n_q_points(numbers::invalid_unsigned_int)
{}
typename VectorizedArrayType>
void
MappingInfoStorage<structdim, spacedim, Number, VectorizedArrayType>::
- QuadratureDescriptor ::initialize(
+ QuadratureDescriptor::initialize(
const Quadrature<1> &quadrature_1d,
const UpdateFlags update_flags_inner_faces)
{
typename VectorizedArrayType>
std::size_t
MappingInfoStorage<structdim, spacedim, Number, VectorizedArrayType>::
- QuadratureDescriptor ::memory_consumption() const
+ QuadratureDescriptor::memory_consumption() const
{
std::size_t memory = sizeof(this) + quadrature.memory_consumption() +
quadrature_weights.memory_consumption() +
// get here
reinterpret_cast<
std::vector<Tensor<2,
- DoFHandlerType ::space_dimension,
+ DoFHandlerType::space_dimension,
typename VectorType::value_type>> &>(
patch_hessians));
}
create_hp_boundary_mass_matrix_1(
typename hp::DoFHandler<dim, spacedim>::active_cell_iterator const &cell,
MatrixCreator::internal::AssemblerBoundary::Scratch const &,
- MatrixCreator::internal::AssemblerBoundary ::
+ MatrixCreator::internal::AssemblerBoundary::
CopyData<hp::DoFHandler<dim, spacedim>, number> ©_data,
hp::MappingCollection<dim, spacedim> const & mapping,
hp::FECollection<dim, spacedim> const & fe_collection,
template <int dim, int spacedim, typename number>
void
copy_hp_boundary_mass_matrix_1(
- MatrixCreator::internal::AssemblerBoundary ::
+ MatrixCreator::internal::AssemblerBoundary::
CopyData<hp::DoFHandler<dim, spacedim>, number> const ©_data,
std::map<types::boundary_id, const Function<spacedim, number> *> const
& boundary_functions,
typename hp::DoFHandler<dim, spacedim>::active_cell_iterator const
& cell,
MatrixCreator::internal::AssemblerBoundary::Scratch const &scratch_data,
- MatrixCreator::internal::AssemblerBoundary ::
+ MatrixCreator::internal::AssemblerBoundary::
CopyData<hp::DoFHandler<dim, spacedim>, number> ©_data) {
internal::create_hp_boundary_mass_matrix_1(cell,
scratch_data,
component_mapping);
},
[&boundary_functions, &dof_to_boundary_mapping, &matrix, &rhs_vector](
- MatrixCreator::internal::AssemblerBoundary ::
+ MatrixCreator::internal::AssemblerBoundary::
CopyData<hp::DoFHandler<dim, spacedim>, number> const ©_data) {
internal::copy_hp_boundary_mass_matrix_1(copy_data,
boundary_functions,
const Function<spacedim> * weight,
const double exponent)
{
- internal ::do_integrate_difference(hp::MappingCollection<dim, spacedim>(
- mapping),
- dof,
- fe_function,
- exact_solution,
- difference,
- hp::QCollection<dim>(q),
- norm,
- weight,
- exponent);
+ internal::do_integrate_difference(hp::MappingCollection<dim, spacedim>(
+ mapping),
+ dof,
+ fe_function,
+ exact_solution,
+ difference,
+ hp::QCollection<dim>(q),
+ norm,
+ weight,
+ exponent);
}
template <int dim, class InVector, class OutVector, int spacedim>
const Function<spacedim> * weight,
const double exponent)
{
- internal ::do_integrate_difference(hp::MappingCollection<dim, spacedim>(
- mapping),
- dof,
- fe_function,
- exact_solution,
- difference,
- hp::QCollection<dim>(q),
- norm,
- weight,
- exponent);
+ internal::do_integrate_difference(hp::MappingCollection<dim, spacedim>(
+ mapping),
+ dof,
+ fe_function,
+ exact_solution,
+ difference,
+ hp::QCollection<dim>(q),
+ norm,
+ weight,
+ exponent);
}
const Function<spacedim> * weight,
const double exponent)
{
- internal ::do_integrate_difference(
+ internal::do_integrate_difference(
hp::StaticMappingQ1<dim, spacedim>::mapping_collection,
dof,
fe_function,
const Function<spacedim> * weight,
const double exponent)
{
- internal ::do_integrate_difference(
+ internal::do_integrate_difference(
hp::StaticMappingQ1<dim, spacedim>::mapping_collection,
dof,
fe_function,
const Function<spacedim> * weight,
const double exponent)
{
- internal ::do_integrate_difference(hp::MappingCollection<dim, spacedim>(
- mapping),
- dof,
- fe_function,
- exact_solution,
- difference,
- q,
- norm,
- weight,
- exponent);
+ internal::do_integrate_difference(hp::MappingCollection<dim, spacedim>(
+ mapping),
+ dof,
+ fe_function,
+ exact_solution,
+ difference,
+ q,
+ norm,
+ weight,
+ exponent);
}
template <int dim, class InVector, class OutVector, int spacedim>
const Function<spacedim> * weight,
const double exponent)
{
- internal ::do_integrate_difference(hp::MappingCollection<dim, spacedim>(
- mapping),
- dof,
- fe_function,
- exact_solution,
- difference,
- q,
- norm,
- weight,
- exponent);
+ internal::do_integrate_difference(hp::MappingCollection<dim, spacedim>(
+ mapping),
+ dof,
+ fe_function,
+ exact_solution,
+ difference,
+ q,
+ norm,
+ weight,
+ exponent);
}
const Function<spacedim> * weight,
const double exponent)
{
- internal ::do_integrate_difference(
+ internal::do_integrate_difference(
hp::StaticMappingQ1<dim, spacedim>::mapping_collection,
dof,
fe_function,
const Function<spacedim> * weight,
const double exponent)
{
- internal ::do_integrate_difference(
+ internal::do_integrate_difference(
hp::StaticMappingQ1<dim, spacedim>::mapping_collection,
dof,
fe_function,
return sizeof(unsigned int) +
tree_index.size() * sizeof(unsigned int) +
quadrants.size() *
- sizeof(typename dealii::internal::p4est ::types<
- dim>::quadrant) +
+ sizeof(
+ typename dealii::internal::p4est::types<dim>::quadrant) +
vertex_indices.size() * sizeof(unsigned int) +
vertices.size() * sizeof(dealii::Point<spacedim>);
}
"This function is only valid for a list of cells that "
"have children (i.e., no cell in the list may be active)."));
- internal::FixUpDistortedChildCells ::fix_up_faces(
+ internal::FixUpDistortedChildCells::fix_up_faces(
cell,
std::integral_constant<int, dim>(),
std::integral_constant<int, spacedim>());
++next_free_line;
next_free_line->set(
- internal::TriangulationImplementation ::TriaObject<1>(
+ internal::TriangulationImplementation::TriaObject<1>(
cells[cell].vertices[0], cells[cell].vertices[1]));
next_free_line->set_used_flag();
next_free_line->set_material_id(cells[cell].material_id);
// make the cell out of
// these iterators
- cell->set(internal::TriangulationImplementation ::TriaObject<3>(
+ cell->set(internal::TriangulationImplementation::TriaObject<3>(
face_iterator[0]->index(),
face_iterator[1]->index(),
face_iterator[2]->index(),
cell->set_children(0, first_child->index());
first_child->clear_children();
first_child->set(
- internal::TriangulationImplementation ::TriaObject<1>(
+ internal::TriangulationImplementation::TriaObject<1>(
cell->vertex_index(0), next_unused_vertex));
first_child->set_material_id(cell->material_id());
first_child->set_manifold_id(cell->manifold_id());
// insert second child
second_child->clear_children();
second_child->set(
- internal::TriangulationImplementation ::TriaObject<1>(
+ internal::TriangulationImplementation::TriaObject<1>(
next_unused_vertex, cell->vertex_index(1)));
second_child->set_neighbor(0, first_child);
second_child->set_material_id(cell->material_id());
"Internal error: We want to use a cell during refinement that should be unused, but turns out not to be."));
children[0]->set(
- internal::TriangulationImplementation ::TriaObject<1>(
+ internal::TriangulationImplementation::TriaObject<1>(
line->vertex_index(0), next_unused_vertex));
children[1]->set(
- internal::TriangulationImplementation ::TriaObject<1>(
+ internal::TriangulationImplementation::TriaObject<1>(
next_unused_vertex, line->vertex_index(1)));
children[0]->set_used_flag();
"Internal error: We want to use a cell during refinement that should be unused, but turns out not to be."));
children[0]->set(
- internal::TriangulationImplementation ::TriaObject<1>(
+ internal::TriangulationImplementation::TriaObject<1>(
line->vertex_index(0), next_unused_vertex));
children[1]->set(
- internal::TriangulationImplementation ::TriaObject<1>(
+ internal::TriangulationImplementation::TriaObject<1>(
next_unused_vertex, line->vertex_index(1)));
children[0]->set_used_flag();
if (aniso_quad_ref_case == RefinementCase<dim - 1>::cut_x)
{
new_quads[0]->set(
- internal::TriangulationImplementation ::TriaObject<2>(
+ internal::TriangulationImplementation::TriaObject<2>(
quad->line_index(0),
new_line->index(),
quad->line(2)
->child(index[0][quad->line_orientation(3)])
->index()));
new_quads[1]->set(
- internal::TriangulationImplementation ::TriaObject<2>(
+ internal::TriangulationImplementation::TriaObject<2>(
new_line->index(),
quad->line_index(1),
quad->line(2)
else
{
new_quads[0]->set(
- internal::TriangulationImplementation ::TriaObject<2>(
+ internal::TriangulationImplementation::TriaObject<2>(
quad->line(0)
->child(index[0][quad->line_orientation(0)])
->index(),
quad->line_index(2),
new_line->index()));
new_quads[1]->set(
- internal::TriangulationImplementation ::TriaObject<2>(
+ internal::TriangulationImplementation::TriaObject<2>(
quad->line(0)
->child(index[1][quad->line_orientation(0)])
->index(),
quad->set_children(0, new_quads[0]->index());
quad->set_children(2, new_quads[2]->index());
new_quads[0]->set(
- internal::TriangulationImplementation ::TriaObject<2>(
+ internal::TriangulationImplementation::TriaObject<2>(
line_indices[0],
line_indices[8],
line_indices[4],
quad->set_refinement_case(RefinementCase<2>::cut_xy);
new_quads[0]->set(
- internal::TriangulationImplementation ::TriaObject<2>(
+ internal::TriangulationImplementation::TriaObject<2>(
line_indices[0],
line_indices[8],
line_indices[4],
line_indices[10]));
new_quads[1]->set(
- internal::TriangulationImplementation ::TriaObject<2>(
+ internal::TriangulationImplementation::TriaObject<2>(
line_indices[8],
line_indices[2],
line_indices[5],
line_indices[11]));
new_quads[2]->set(
- internal::TriangulationImplementation ::TriaObject<2>(
+ internal::TriangulationImplementation::TriaObject<2>(
line_indices[1],
line_indices[9],
line_indices[10],
line_indices[6]));
new_quads[3]->set(
- internal::TriangulationImplementation ::TriaObject<2>(
+ internal::TriangulationImplementation::TriaObject<2>(
line_indices[9],
line_indices[3],
line_indices[11],
// set up the new quad, line numbering is as
// indicated above
new_quads[0]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[0],
line_indices[1],
line_indices[2],
};
new_hexes[0]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[1],
quad_indices[0],
quad_indices[3],
quad_indices[7],
quad_indices[9]));
new_hexes[1]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[0],
quad_indices[2],
quad_indices[4],
// set up the new quad, line numbering is as
// indicated above
new_quads[0]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[2],
line_indices[3],
line_indices[0],
};
new_hexes[0]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[1],
quad_indices[3],
quad_indices[5],
quad_indices[7],
quad_indices[9]));
new_hexes[1]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[2],
quad_indices[4],
quad_indices[0],
// set up the new quad, line numbering is as
// indicated above
new_quads[0]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[0],
line_indices[1],
line_indices[2],
};
new_hexes[0]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[1],
quad_indices[3],
quad_indices[5],
quad_indices[9],
quad_indices[0]));
new_hexes[1]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[2],
quad_indices[4],
quad_indices[6],
// *---*---*y *-6-*-7-*
new_quads[0]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[2],
line_indices[12],
line_indices[4],
line_indices[8]));
new_quads[1]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[12],
line_indices[3],
line_indices[5],
line_indices[9]));
new_quads[2]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[6],
line_indices[10],
line_indices[0],
line_indices[12]));
new_quads[3]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[7],
line_indices[11],
line_indices[12],
3, f_or[5], f_fl[5], f_ro[5]))};
new_hexes[0]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[4],
quad_indices[0],
quad_indices[8],
quad_indices[12],
quad_indices[16]));
new_hexes[1]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[0],
quad_indices[6],
quad_indices[9],
quad_indices[13],
quad_indices[17]));
new_hexes[2]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[5],
quad_indices[1],
quad_indices[2],
quad_indices[14],
quad_indices[18]));
new_hexes[3]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[1],
quad_indices[7],
quad_indices[3],
// *----*----*x *--6-*--7-*
new_quads[0]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[0],
line_indices[12],
line_indices[6],
line_indices[10]));
new_quads[1]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[12],
line_indices[1],
line_indices[7],
line_indices[11]));
new_quads[2]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[4],
line_indices[8],
line_indices[2],
line_indices[12]));
new_quads[3]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[5],
line_indices[9],
line_indices[12],
// | 0 | 2 |
// *---*---*
new_hexes[0]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[4],
quad_indices[2],
quad_indices[8],
quad_indices[16],
quad_indices[0]));
new_hexes[1]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[5],
quad_indices[3],
quad_indices[9],
quad_indices[0],
quad_indices[18]));
new_hexes[2]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[2],
quad_indices[6],
quad_indices[10],
quad_indices[17],
quad_indices[1]));
new_hexes[3]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[3],
quad_indices[7],
quad_indices[11],
// *---------*x *----0----*
new_quads[0]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[6],
line_indices[10],
line_indices[0],
line_indices[12]));
new_quads[1]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[7],
line_indices[11],
line_indices[12],
line_indices[1]));
new_quads[2]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[2],
line_indices[12],
line_indices[4],
line_indices[8]));
new_quads[3]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[12],
line_indices[3],
line_indices[5],
1][f_fl[5]][f_ro[5]])};
new_hexes[0]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[4],
quad_indices[8],
quad_indices[12],
quad_indices[16],
quad_indices[0]));
new_hexes[1]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[5],
quad_indices[9],
quad_indices[2],
quad_indices[17],
quad_indices[1]));
new_hexes[2]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[6],
quad_indices[10],
quad_indices[13],
quad_indices[0],
quad_indices[18]));
new_hexes[3]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[7],
quad_indices[11],
quad_indices[3],
// *----*----*x *--8-*--9-*
new_quads[0]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[10],
line_indices[28],
line_indices[16],
line_indices[24]));
new_quads[1]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[28],
line_indices[14],
line_indices[17],
line_indices[25]));
new_quads[2]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[11],
line_indices[29],
line_indices[24],
line_indices[20]));
new_quads[3]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[29],
line_indices[15],
line_indices[25],
line_indices[21]));
new_quads[4]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[18],
line_indices[26],
line_indices[0],
line_indices[28]));
new_quads[5]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[26],
line_indices[22],
line_indices[1],
line_indices[29]));
new_quads[6]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[19],
line_indices[27],
line_indices[28],
line_indices[4]));
new_quads[7]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[27],
line_indices[23],
line_indices[29],
line_indices[5]));
new_quads[8]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[2],
line_indices[24],
line_indices[8],
line_indices[26]));
new_quads[9]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[24],
line_indices[6],
line_indices[9],
line_indices[27]));
new_quads[10]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[3],
line_indices[25],
line_indices[26],
line_indices[12]));
new_quads[11]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
2>(line_indices[25],
line_indices[7],
line_indices[27],
// bottom children
new_hexes[0]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[12],
quad_indices[0],
quad_indices[20],
quad_indices[28],
quad_indices[8]));
new_hexes[1]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[0],
quad_indices[16],
quad_indices[22],
quad_indices[29],
quad_indices[9]));
new_hexes[2]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[13],
quad_indices[1],
quad_indices[4],
quad_indices[30],
quad_indices[10]));
new_hexes[3]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[1],
quad_indices[17],
quad_indices[6],
// top children
new_hexes[4]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[14],
quad_indices[2],
quad_indices[21],
quad_indices[8],
quad_indices[32]));
new_hexes[5]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[2],
quad_indices[18],
quad_indices[23],
quad_indices[9],
quad_indices[33]));
new_hexes[6]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[15],
quad_indices[3],
quad_indices[5],
quad_indices[10],
quad_indices[34]));
new_hexes[7]->set(
- internal::TriangulationImplementation ::TriaObject<
+ internal::TriangulationImplementation::TriaObject<
3>(quad_indices[3],
quad_indices[19],
quad_indices[7],
// update our counts of the various elements of a triangulation, and set
// active_cell_indices of all cells
- internal::TriangulationImplementation::Implementation ::compute_number_cache(
+ internal::TriangulationImplementation::Implementation::compute_number_cache(
*this, levels.size(), number_cache);
reset_active_cell_indices();
// re-compute number of lines
- internal::TriangulationImplementation::Implementation ::compute_number_cache(
+ internal::TriangulationImplementation::Implementation::compute_number_cache(
*this, levels.size(), number_cache);
#ifdef DEBUG
// inform all listeners that cell coarsening is going to happen
signals.pre_coarsening_on_cell(cell);
// use a separate function, since this is dimension specific
- internal::TriangulationImplementation::Implementation ::
+ internal::TriangulationImplementation::Implementation::
delete_children(*this, cell, line_cell_count, quad_cell_count);
}
// re-compute number of lines and quads
- internal::TriangulationImplementation::Implementation ::compute_number_cache(
+ internal::TriangulationImplementation::Implementation::compute_number_cache(
*this, levels.size(), number_cache);
// in principle no user flags should be set any more at this point
void
- TaskInfo ::create_blocks_serial(
+ TaskInfo::create_blocks_serial(
const std::vector<unsigned int> &boundary_cells,
const unsigned int dofs_per_cell,
const std::vector<unsigned int> &cell_vectorization_categories,
void
- TaskInfo ::initial_setup_blocks_tasks(
+ TaskInfo::initial_setup_blocks_tasks(
const std::vector<unsigned int> &boundary_cells,
std::vector<unsigned int> & renumbering,
std::vector<unsigned char> & incompletely_filled_vectorization)
[this](
const std::vector<DataOutBase::Patch<dimension + 1, space_dimension + 1>>
&new_patches) {
- internal::DataOutRotationImplementation ::
+ internal::DataOutRotationImplementation::
append_patch_to_list<dimension, space_dimension>(new_patches,
this->patches);
},
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().degree;
- LocalIntegrators::Laplace ::nitsche_matrix(
+ LocalIntegrators::Laplace::nitsche_matrix(
dinfo.matrix(0, false).matrix,
info.fe_values(0),
LocalIntegrators::Laplace::compute_penalty(dinfo, dinfo, deg, deg));
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
const unsigned int deg = info1.fe_values(0).get_fe().degree;
- LocalIntegrators::Laplace ::ip_matrix(
+ LocalIntegrators::Laplace::ip_matrix(
dinfo1.matrix(0, false).matrix,
dinfo1.matrix(0, true).matrix,
dinfo2.matrix(0, true).matrix,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().degree;
- LocalIntegrators::Laplace ::nitsche_matrix(
+ LocalIntegrators::Laplace::nitsche_matrix(
dinfo.matrix(0, false).matrix,
info.fe_values(0),
LocalIntegrators::Laplace::compute_penalty(dinfo, dinfo, deg, deg));
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
const unsigned int deg = info1.fe_values(0).get_fe().degree;
- LocalIntegrators::Laplace ::ip_matrix(
+ LocalIntegrators::Laplace::ip_matrix(
dinfo1.matrix(0, false).matrix,
dinfo1.matrix(0, true).matrix,
dinfo2.matrix(0, true).matrix,
test()
{
Triangulation<dim> triangulation;
- GridGenerator ::hyper_cube(triangulation, -0.5, 0.5);
+ GridGenerator::hyper_cube(triangulation, -0.5, 0.5);
triangulation.refine_global(4);
hp::FECollection<dim> fe_collection;
info1.fe_values(0).normal_vector(0)));
double penalty = 0.5 * (normal_volume_fraction1 + normal_volume_fraction2) *
std::max(1U, deg) * (deg + 1.0);
- LocalIntegrators::Laplace ::ip_matrix(dinfo1.matrix(0, false).matrix,
- dinfo1.matrix(0, true).matrix,
- dinfo2.matrix(0, true).matrix,
- dinfo2.matrix(0, false).matrix,
- info1.fe_values(0),
- info2.fe_values(0),
- penalty);
+ LocalIntegrators::Laplace::ip_matrix(dinfo1.matrix(0, false).matrix,
+ dinfo1.matrix(0, true).matrix,
+ dinfo2.matrix(0, true).matrix,
+ dinfo2.matrix(0, false).matrix,
+ info1.fe_values(0),
+ info2.fe_values(0),
+ penalty);
}
[GeometryInfo<dim>::unit_normal_direction[dinfo.face_number]] *
info.fe_values(0).normal_vector(0)));
double penalty = normal_volume_fraction * std::max(1U, deg) * (deg + 1.0);
- LocalIntegrators::Laplace ::nitsche_matrix(dinfo.matrix(0, false).matrix,
- info.fe_values(0),
- penalty);
+ LocalIntegrators::Laplace::nitsche_matrix(dinfo.matrix(0, false).matrix,
+ info.fe_values(0),
+ penalty);
}
// 4 cells with the highest error
// have 20+19+18+17=74, for a total
// fraction of 74/210
- parallel::distributed::GridRefinement ::refine_and_coarsen_fixed_fraction(
+ parallel::distributed::GridRefinement::refine_and_coarsen_fixed_fraction(
tr, indicators, 74. / 210 + 1e-5, 10. / 210 - 1e-5);
// now count number of cells
// set the thresholds slightly
// above or below what we'd really
// like
- parallel::distributed::GridRefinement ::refine_and_coarsen_fixed_fraction(
+ parallel::distributed::GridRefinement::refine_and_coarsen_fixed_fraction(
tr,
indicators,
30.00000000001 / total_error * std::pow(2, (double)16),
AssertThrow(my_cell_index == 20, ExcInternalError());
}
- parallel::distributed::GridRefinement ::refine_and_coarsen_fixed_fraction(
+ parallel::distributed::GridRefinement::refine_and_coarsen_fixed_fraction(
tr, indicators, (74. + 0.5) / 210, 0);
// now count number of cells
// use one strategy to compute
// thresholds and obtain those
// thresholds
- parallel::distributed::GridRefinement ::refine_and_coarsen_fixed_fraction(
+ parallel::distributed::GridRefinement::refine_and_coarsen_fixed_fraction(
tr, indicators, 2. / 3, 1. / 6);
{
float coarsen_indicator = min_indicator - 1,
// only works because we are
// working on only a single
// processor
- dealii::GridRefinement ::refine_and_coarsen_fixed_fraction(tr,
- indicators,
- 2. / 3,
- 1. / 6);
+ dealii::GridRefinement::refine_and_coarsen_fixed_fraction(tr,
+ indicators,
+ 2. / 3,
+ 1. / 6);
{
float coarsen_indicator = min_indicator - 1,
refine_indicator = max_indicator + 1;
// use one strategy to compute
// thresholds and obtain those
// thresholds
- parallel::distributed::GridRefinement ::refine_and_coarsen_fixed_fraction(
+ parallel::distributed::GridRefinement::refine_and_coarsen_fixed_fraction(
tr, indicators, 2. / 3, 1. / 6);
{
float coarsen_indicator = min_indicator - 1,
// only works because we are
// working on only a single
// processor
- dealii::GridRefinement ::refine_and_coarsen_fixed_fraction(tr,
- indicators,
- 2. / 3,
- 1. / 6);
+ dealii::GridRefinement::refine_and_coarsen_fixed_fraction(tr,
+ indicators,
+ 2. / 3,
+ 1. / 6);
{
float coarsen_indicator = min_indicator - 1,
refine_indicator = max_indicator + 1;
// use one strategy to compute
// thresholds and obtain those
// thresholds
- parallel::distributed::GridRefinement ::refine_and_coarsen_fixed_fraction(
+ parallel::distributed::GridRefinement::refine_and_coarsen_fixed_fraction(
tr, indicators, 0.6, 0.2);
{
float coarsen_indicator = min_indicator - 1,
// only works because we are
// working on only a single
// processor
- dealii::GridRefinement ::refine_and_coarsen_fixed_fraction(tr,
- indicators,
- 0.6,
- 0.2);
+ dealii::GridRefinement::refine_and_coarsen_fixed_fraction(tr,
+ indicators,
+ 0.6,
+ 0.2);
{
float coarsen_indicator = min_indicator - 1,
refine_indicator = max_indicator + 1;
}
- parallel::distributed::GridRefinement ::refine_and_coarsen_fixed_number(
+ parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number(
tr, indicators, 0.2, 0.2);
// now count number of cells
}
- parallel::distributed::GridRefinement ::refine_and_coarsen_fixed_number(
+ parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number(
tr, indicators, 0.2, 0.2);
// now count number of cells
}
- parallel::distributed::GridRefinement ::refine_and_coarsen_fixed_number(
+ parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number(
tr, indicators, 0.2, 0);
// now count number of cells
// use one strategy to compute
// thresholds and obtain those
// thresholds
- parallel::distributed::GridRefinement ::refine_and_coarsen_fixed_number(
+ parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number(
tr, indicators, 2. / 3, 1. / 6);
{
float coarsen_indicator = min_indicator - 1,
// only works because we are
// working on only a single
// processor
- dealii::GridRefinement ::refine_and_coarsen_fixed_number(tr,
- indicators,
- 2. / 3,
- 1. / 6);
+ dealii::GridRefinement::refine_and_coarsen_fixed_number(tr,
+ indicators,
+ 2. / 3,
+ 1. / 6);
{
float coarsen_indicator = min_indicator - 1,
refine_indicator = max_indicator + 1;
// use one strategy to compute
// thresholds and obtain those
// thresholds
- parallel::distributed::GridRefinement ::refine_and_coarsen_fixed_number(
+ parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number(
tr, indicators, 2. / 3, 1. / 6);
{
float coarsen_indicator = min_indicator - 1,
// only works because we are
// working on only a single
// processor
- dealii::GridRefinement ::refine_and_coarsen_fixed_number(tr,
- indicators,
- 2. / 3,
- 1. / 6);
+ dealii::GridRefinement::refine_and_coarsen_fixed_number(tr,
+ indicators,
+ 2. / 3,
+ 1. / 6);
{
float coarsen_indicator = min_indicator - 1,
refine_indicator = max_indicator + 1;
const auto max_n_cell =
static_cast<unsigned int>(max_n_cell_ratio * tr.n_global_active_cells());
- parallel::distributed::GridRefinement ::refine_and_coarsen_fixed_number(
+ parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number(
tr, indicators, 0.2, 0.2, max_n_cell);
// now count number of cells
Assert(neighbors == ghost_owners, ExcInternalError());
- parallel::distributed::GridRefinement ::refine_and_coarsen_fixed_number(
+ parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number(
tr, indicators, 0.3, 0.0);
tr.execute_coarsening_and_refinement();
if (myid == 0)
Assert(neighbors == ghost_owners, ExcInternalError());
- parallel::distributed::GridRefinement ::refine_and_coarsen_fixed_number(
+ parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number(
tr, indicators, 0.3, 0.0);
tr.execute_coarsening_and_refinement();
if (myid == 0)
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().degree;
- LocalIntegrators::Laplace ::nitsche_matrix(
+ LocalIntegrators::Laplace::nitsche_matrix(
dinfo.matrix(0, false).matrix,
info.fe_values(0),
LocalIntegrators::Laplace::compute_penalty(dinfo, dinfo, deg, deg));
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
const unsigned int deg = info1.fe_values(0).get_fe().degree;
- LocalIntegrators::Laplace ::ip_matrix(
+ LocalIntegrators::Laplace::ip_matrix(
dinfo1.matrix(0, false).matrix,
dinfo1.matrix(0, true).matrix,
dinfo2.matrix(0, true).matrix,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().degree;
- LocalIntegrators::Laplace ::nitsche_matrix(
+ LocalIntegrators::Laplace::nitsche_matrix(
dinfo.matrix(0, false).matrix,
info.fe_values(0),
LocalIntegrators::Laplace::compute_penalty(dinfo, dinfo, deg, deg));
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
const unsigned int deg = info1.fe_values(0).get_fe().degree;
- LocalIntegrators::Laplace ::ip_matrix(
+ LocalIntegrators::Laplace::ip_matrix(
dinfo1.matrix(0, false).matrix,
dinfo1.matrix(0, true).matrix,
dinfo2.matrix(0, true).matrix,
typename MeshWorker::IntegrationInfo<dim> &info) const
{
const unsigned int deg = info.fe_values(0).get_fe().degree;
- LocalIntegrators::Laplace ::nitsche_matrix(
+ LocalIntegrators::Laplace::nitsche_matrix(
dinfo.matrix(0, false).matrix,
info.fe_values(0),
LocalIntegrators::Laplace::compute_penalty(dinfo, dinfo, deg, deg));
typename MeshWorker::IntegrationInfo<dim> &info2) const
{
const unsigned int deg = info1.fe_values(0).get_fe().degree;
- LocalIntegrators::Laplace ::ip_matrix(
+ LocalIntegrators::Laplace::ip_matrix(
dinfo1.matrix(0, false).matrix,
dinfo1.matrix(0, true).matrix,
dinfo2.matrix(0, true).matrix,