-D DEAL_II_CXX_FLAGS='-Werror' \
-D DEAL_II_EARLY_DEPRECATIONS=ON \
-D DEAL_II_WITH_MPI="ON" \
- -D DEAL_II_WITH_SIMPLEX_SUPPORT="ON" \
-D DEAL_II_WITH_TRILINOS="ON" \
-D DEAL_II_WITH_PETSC="ON" \
-D DEAL_II_WITH_METIS="ON" \
)
LIST(APPEND DEAL_II_FEATURES 64BIT_INDICES)
-OPTION(DEAL_II_WITH_SIMPLEX_SUPPORT
- "If set to ON, triangulations with triangle and tetrahedron cells are supported in addition to quadrilateral- and hexahedra-only triangulations."
- OFF
- )
-LIST(APPEND DEAL_II_FEATURES SIMPLEX_SUPPORT)
-
OPTION(DEAL_II_WITH_COMPLEX_VALUES
"If set to OFF, the classes that take a number type are not explicitly instantiated for std::complex<float> and std::complex<double>. This effectively disables the support for computing with complex values. If PETSc is built with complex scalar type, this option must be ON."
ON
-DDEAL_II_COMPILE_EXAMPLES=OFF \
-DDEAL_II_COMPONENT_PYTHON_BINDINGS=ON \
-DDEAL_II_WITH_MPI=ON \
- -DDEAL_II_WITH_SIMPLEX_SUPPORT=ON \
-DCMAKE_CXX_FLAGS="-std=c++17" \
.. \
&& ninja install \
DEAL_II_WITH_P4EST
DEAL_II_WITH_PETSC
DEAL_II_WITH_SCALAPACK
-DEAL_II_WITH_SIMPLEX_SUPPORT
DEAL_II_WITH_SLEPC
DEAL_II_WITH_SUNDIALS
DEAL_II_WITH_SYMENGINE
#cmakedefine DEAL_II_WITH_P4EST
#cmakedefine DEAL_II_WITH_PETSC
#cmakedefine DEAL_II_WITH_SCALAPACK
-#cmakedefine DEAL_II_WITH_SIMPLEX_SUPPORT
#cmakedefine DEAL_II_WITH_SLEPC
#cmakedefine DEAL_II_WITH_SUNDIALS
#cmakedefine DEAL_II_WITH_SYMENGINE
"You are attempting to use functionality that is only available "
"if deal.II was configured to use MPI.");
- /**
- * This function requires simplex support.
- */
- DeclExceptionMsg(
- ExcNeedsSimplexSupport,
- "You are attempting to use functionality that is only available "
- "if deal.II was configured with DEAL_II_WITH_SIMPLEX_SUPPORT enabled.");
-
/**
* This function requires support for the FunctionParser library.
*/
if (flag == false)
{
-#ifdef DEAL_II_WITH_SIMPLEX_SUPPORT
cell_data[my_q].descriptor[hpq].initialize(quad[my_q][hpq],
update_default);
const auto quad_face =
reference_cell_types[my_q][hpq] =
face_quadrature_collection.first;
-#else
- Assert(false, ExcNotImplemented());
-#endif
}
else
{
reference_cell == dealii::ReferenceCells::get_hypercube<dim>()) ==
false)
{
-#ifdef DEAL_II_WITH_SIMPLEX_SUPPORT
return index;
-#else
- Assert(false, ExcNotImplemented());
-#endif
}
if (dim == 3)
for (unsigned int my_q = 0; my_q < mapping_info.face_data.size();
++my_q)
{
-#ifndef DEAL_II_WITH_SIMPLEX_SUPPORT
- // currently only non-hp-case...
- AssertDimension(mapping_in.size(), 1);
-#endif
-
// We assume that we have the faces sorted by the active FE
// indices so that the active FE index of the interior side of the
// face batch is the same as the FE index of the interior side of
{
const FE_Poly<dim, spacedim> *fe_poly_ptr =
dynamic_cast<const FE_Poly<dim, spacedim> *>(fe_ptr);
-#ifdef DEAL_II_WITH_SIMPLEX_SUPPORT
// Simplices are a special case since the polynomial family is not
// indicative of their support
if (dynamic_cast<const FE_SimplexP<dim> *>(fe_poly_ptr) ||
dynamic_cast<const FE_WedgeP<dim> *>(fe_poly_ptr) ||
dynamic_cast<const FE_PyramidP<dim> *>(fe_poly_ptr))
return true;
-#endif
if (dynamic_cast<const TensorProductPolynomials<dim> *>(
&fe_poly_ptr->get_poly_space()) == nullptr &&
const FiniteElement<dim> &fe_in,
const unsigned int base_element_number)
{
-#ifdef DEAL_II_WITH_SIMPLEX_SUPPORT
if (quad_in.is_tensor_product() == false ||
dynamic_cast<const FE_SimplexP<dim> *>(
&fe_in.base_element(base_element_number)) ||
return;
}
-#else
- Assert(quad_in.is_tensor_product(), ExcNotImplemented());
-#endif
const auto quad = quad_in.get_tensor_basis()[0];
const Point<dim> & p2,
const bool colorize)
{
-# ifndef DEAL_II_WITH_SIMPLEX_SUPPORT
- Assert(false, ExcNeedsSimplexSupport());
-# endif
AssertDimension(dim, spacedim);
AssertThrow(colorize == false, ExcNotImplemented());
}
else
{
-#ifndef DEAL_II_WITH_SIMPLEX_SUPPORT
- Assert(false, ExcNeedsSimplexSupport());
-#endif
-
this->policy =
std::make_unique<internal::TriangulationImplementation::PolicyWrapper<
dim,
+++ /dev/null
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2020 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-
-
-// Dummy simplex test.
-
-#include "../tests.h"
-
-int
-main()
-{
- initlog();
-
-#ifdef DEAL_II_WITH_SIMPLEX_SUPPORT
- deallog << "deal.II is configured with simplex support." << std::endl;
-#else
- deallog << "deal.II is configured without simplex support." << std::endl;
-#endif
-}
+++ /dev/null
-
-DEAL::deal.II is configured with simplex support.
quads,
VectorTools::NormType::L2_norm);
- return {reduction_control.last_step(),
- reduction_control.last_value(),
- x.linfty_norm(),
- VectorTools::compute_global_error(tria,
- difference,
- VectorTools::NormType::L2_norm)};
+ std::tuple<unsigned int, double, double, double> result(
+ reduction_control.last_step(),
+ reduction_control.last_value(),
+ x.linfty_norm(),
+ VectorTools::compute_global_error(tria,
+ difference,
+ VectorTools::NormType::L2_norm));
+
+ return result;
};
const auto mf_algo = [&]() {
matrix_free.initialize_dof_vector(vec);
}
+ Tensor<1, dim, VectorizedArray<double>>
+ beta(const Point<dim, VectorizedArray<double>> &points) const
+ {
+ Tensor<1, dim, VectorizedArray<double>> betas;
+
+ for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
+ {
+ Point<dim, double> p;
+ Tensor<1, dim, double> beta;
+
+ for (int d = 0; d < dim; ++d)
+ p[d] = points[d][v];
+
+ beta[0] = -p[1];
+ beta[1] = +p[0];
+
+ if (beta.norm() > 1e-10)
+ beta /= beta.norm();
+
+ for (int d = 0; d < dim; ++d)
+ betas[d][v] = beta[d];
+ }
+
+ return betas;
+ }
+
+ VectorizedArray<double>
+ boundary_values(const Point<dim, VectorizedArray<double>> &points) const
+ {
+ VectorizedArray<double> betas;
+
+ for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
+ betas[v] = (points[0][v] < 0.5) ? 1.0 : 0.0;
+
+ return betas;
+ }
+
void
rhs(VectorType &vec) const
{
phi.reinit(face);
for (unsigned int q = 0; q < phi.n_q_points; ++q)
{
- const auto beta_n =
- beta(phi.quadrature_point(q)) * phi.get_normal_vector(q);
+ const auto beta_n = this->beta(phi.quadrature_point(q)) *
+ phi.get_normal_vector(q);
const auto beta_n_m = (-std::abs(beta_n) + beta_n) * 0.5;
- phi.submit_value(-beta_n_m *
- boundary_values(phi.quadrature_point(q)),
+ phi.submit_value(-beta_n_m * this->boundary_values(
+ phi.quadrature_point(q)),
q);
}
phi.reinit(cell);
phi.gather_evaluate(src, true, false);
for (unsigned int q = 0; q < phi.n_q_points; ++q)
- phi.submit_gradient(-beta(phi.quadrature_point(q)) *
+ phi.submit_gradient(-this->beta(phi.quadrature_point(q)) *
phi.get_value(q),
q);
phi.integrate_scatter(false, true, dst);
phi_p.gather_evaluate(src, true, false);
for (unsigned int q = 0; q < phi_m.n_q_points; ++q)
{
- const auto beta_n =
- beta(phi_m.quadrature_point(q)) * phi_m.get_normal_vector(q);
+ const auto beta_n = this->beta(phi_m.quadrature_point(q)) *
+ phi_m.get_normal_vector(q);
const auto u_m = phi_m.get_value(q);
const auto u_p = phi_p.get_value(q);
phi.gather_evaluate(src, true, false);
for (unsigned int q = 0; q < phi.n_q_points; ++q)
{
- const auto beta_n =
- beta(phi.quadrature_point(q)) * phi.get_normal_vector(q);
+ const auto beta_n = this->beta(phi.quadrature_point(q)) *
+ phi.get_normal_vector(q);
const auto beta_n_p = (std::abs(beta_n) + beta_n) * 0.5;
phi.submit_value(beta_n_p * phi.get_value(q), q);
}
true);
}
- Tensor<1, dim, VectorizedArray<double>>
- beta(const Point<dim, VectorizedArray<double>> &points) const
- {
- Tensor<1, dim, VectorizedArray<double>> betas;
-
- for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
- {
- Point<dim, double> p;
- Tensor<1, dim, double> beta;
-
- for (int d = 0; d < dim; ++d)
- p[d] = points[d][v];
-
- beta[0] = -p[1];
- beta[1] = +p[0];
-
- if (beta.norm() > 1e-10)
- beta /= beta.norm();
-
- for (int d = 0; d < dim; ++d)
- betas[d][v] = beta[d];
- }
-
- return betas;
- }
-
- VectorizedArray<double>
- boundary_values(const Point<dim, VectorizedArray<double>> &points) const
- {
- VectorizedArray<double> betas;
-
- for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
- betas[v] = (points[0][v] < 0.5) ? 1.0 : 0.0;
-
- return betas;
- }
-
private:
const MatrixFree<dim, double> &matrix_free;
};
projects / dealii.git / commitdiff