#include "../tests.h"
-using namespace dealii;
// Print the bounds of the incoming box to deallog.
template <int dim>
#include "../tests.h"
-using namespace dealii;
using iota = std_cxx20::ranges::iota_view<unsigned int, unsigned int>;
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
namespace
{
- using namespace dealii;
/*
* A simple test-function which is constant in space, but varies
namespace
{
- using namespace dealii;
// Test the function create_higher_dim_point by making sure that we
// can construct the point (x, y, z),
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
class Container
{
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
namespace
{
- using namespace dealii;
/*
* A simple test-function which is constant in space, but varies
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
namespace
{
namespace
{
- using namespace dealii;
/**
* Returns a bounding box with different side lengths, 2*h_i, in all
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../tests.h"
-using namespace dealii;
namespace bg = boost::geometry;
namespace bgi = boost::geometry::index;
#include "../tests.h"
-using namespace dealii;
template <int dim>
class RightHandSideFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
int
#include "../tests.h"
-using namespace dealii;
int
main(int argc, char **argv)
#include "../tests.h"
-using namespace dealii;
template <int dim, typename Number>
void
// (x0, y0, z0, x1, y1, z1, ...) and solution1 should contain (u0, v0, w0, u1,
// v1, w1, ...). Verify that they match when we interpolate.
-using namespace dealii;
class Test : public Function<2>
{
// This previously crashed with a segmentation fault inside
// DoFHandlerImplementation::Policy::Sequential::renumber_dofs().
-using namespace dealii;
int
main()
{
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
namespace StokesTests
{
- using namespace dealii;
struct CopyDataFace
{
{
try
{
- using namespace dealii;
using namespace StokesTests;
const int dim = 2;
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
int
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim, int spacedim = dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim, int spacedim>
#include "../grid/tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../grid/tests.h"
-using namespace dealii;
MPI_Comm
create_sub_comm(const MPI_Comm comm, const unsigned int size)
#include "../grid/tests.h"
-using namespace dealii;
namespace dealii
{
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim, int spacedim = dim>
#include "../grid/tests.h"
-using namespace dealii;
template <int dim, typename TriangulationType>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
class InterpolationFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
using VectorType = LinearAlgebra::distributed::Vector<double>;
#include "../tests.h"
-using namespace dealii;
using VectorType = LinearAlgebra::distributed::Vector<double>;
// STL
#include <map>
-using namespace dealii;
template <int dim>
void
// STL
#include <map>
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim = dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
#include "../tests.h"
-using namespace dealii;
int
main(int argc, char *argv[])
int
main()
{
- using namespace dealii;
-
initlog();
const unsigned int dim = 2;
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
int
main()
#include "./tests.h"
-using namespace dealii;
template <int dim, typename TriangulationType>
void
#include "./tests.h"
-using namespace dealii;
template <int dim>
class InterpolationFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
/**
* mpirun -np 4 ./constraints_01
#include "../tests.h"
-using namespace dealii;
-
int
namespace Step40
{
- using namespace dealii;
template <int dim>
class LaplaceProblem
namespace Step40
{
- using namespace dealii;
template <int dim>
class LaplaceProblem
namespace Step40
{
- using namespace dealii;
template <int dim>
class LaplaceProblem
namespace Step40
{
- using namespace dealii;
template <int dim>
class LaplaceProblem
namespace Step40
{
- using namespace dealii;
template <int dim>
class LaplaceProblem
namespace Step40
{
- using namespace dealii;
template <int dim>
class LaplaceProblem
#include "../tests.h"
-using namespace dealii;
template <typename VectorType>
void
#include "../tests.h"
-using namespace dealii;
template <typename VectorType>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
class GradingManifold : public ChartManifold<dim>
{
initlog();
- using namespace dealii;
Triangulation<2, 3> tria;
#include "../tests.h"
-using namespace dealii;
template <int dim,
#include "../tests.h"
-using namespace dealii;
int
main()
// Test MatrixFreeTools::ElementActivationAndDeactivationMatrixFree by comparing
// the results with results obtained on fitted mesh.
-using namespace dealii;
template <int dim>
class Fu : public Function<dim>
return {points_shift, weights};
}
-using namespace dealii;
template <int dim,
int fe_degree,
#include "../tests.h"
-using namespace dealii;
using Number = double;
#include "../tests.h"
-using namespace dealii;
using Number = double;
const dealii::Quadrature<dim> &quad,
const dealii::EvaluationFlags::EvaluationFlags evaluation_flags)
{
- using namespace dealii;
using VectorizedArrayType = VectorizedArray<double>;
Triangulation<dim> tria;
void
test_qiterated(dealii::EvaluationFlags::EvaluationFlags evaluation_flags)
{
- using namespace dealii;
deallog << "test_qiterated" << std::endl;
for (unsigned int i = 1; i < 4; ++i)
{
void
test_qgauss(dealii::EvaluationFlags::EvaluationFlags evaluation_flags)
{
- using namespace dealii;
deallog << "test_qgauss" << std::endl;
for (unsigned int i = 1; i < 4; ++i)
{
int
main(int argc, char **argv)
{
- using namespace dealii;
Utilities::MPI::MPI_InitFinalize mpi(argc, argv, 1);
initlog();
const dealii::FE_Poly<dim> &fe,
const dealii::EvaluationFlags::EvaluationFlags evaluation_flags)
{
- using namespace dealii;
using VectorizedArrayType = VectorizedArray<double>;
Triangulation<dim> tria;
const dealii::Quadrature<dim> &quad,
const dealii::EvaluationFlags::EvaluationFlags evaluation_flags)
{
- using namespace dealii;
using VectorizedArrayType = VectorizedArray<double>;
Triangulation<dim> tria;
void
test_qiterated(dealii::EvaluationFlags::EvaluationFlags evaluation_flags)
{
- using namespace dealii;
deallog << "test_qiterated" << std::endl;
for (unsigned int i = 1; i < 3; ++i)
{
void
test_qgauss(dealii::EvaluationFlags::EvaluationFlags evaluation_flags)
{
- using namespace dealii;
deallog << "test_qgauss" << std::endl;
for (unsigned int i = 1; i < 4; ++i)
{
int
main(int argc, char **argv)
{
- using namespace dealii;
Utilities::MPI::MPI_InitFinalize mpi(argc, argv, 1);
initlog();
const dealii::FE_Poly<dim> &fe,
const dealii::EvaluationFlags::EvaluationFlags evaluation_flags)
{
- using namespace dealii;
using VectorizedArrayType = VectorizedArray<double>;
Triangulation<dim> tria;
int
main(int argc, char **argv)
{
- using namespace dealii;
dealii::Utilities::MPI::MPI_InitFinalize mpi(argc, argv, 1);
initlog();
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
void
test()
{
- using namespace dealii;
Triangulation<dim> tria;
GridGenerator::subdivided_hyper_cube(tria, 2, 0, 1);
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
void
test()
{
- using namespace dealii;
Triangulation<dim> tria;
GridGenerator::subdivided_hyper_cube(tria, 2, 0, 1);
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
void
test()
{
- using namespace dealii;
Triangulation<dim> tria;
GridGenerator::subdivided_hyper_cube(tria, 2, 0, 1);
void
test()
{
- using namespace dealii;
Triangulation<dim> tria;
GridGenerator::subdivided_hyper_cube(tria, 2, 0, 1);
void
test()
{
- using namespace dealii;
Triangulation<dim> tria;
GridGenerator::subdivided_hyper_cube(tria, 2, 0, 1);
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
#include "../tests.h"
-using namespace dealii;
template <int dim,
typename Number = double,
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
#include "../tests.h"
-using namespace dealii;
template <int dim>
class AnalyticalFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class AnalyticalFunction : public Function<dim>
void
test(const unsigned int degree)
{
- using namespace dealii;
Triangulation<dim> tria;
if (dim > 1)
#include "../tests.h"
-using namespace dealii;
double
#include "../tests.h"
-using namespace dealii;
template <int dim, typename Number>
void
#include "../tests.h"
-using namespace dealii;
void
test_data_type(const std::uint64_t n_bytes)
#include "../tests.h"
-using namespace dealii;
void
test()
int
main(int argc, char **argv)
{
- using namespace dealii;
-
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
MPILogInitAll log;
#include "../tests.h"
-using namespace dealii;
void
test(const MPI_Comm comm)
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
void
test(
#include "../tests.h"
-using namespace dealii;
void
test()
#include "../tests.h"
-using namespace dealii;
-
template <typename MeshType, typename Number>
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
#include "quadrature_printing.h"
-using namespace dealii;
template <int dim>
class Test
#include "../tests.h"
-using namespace dealii;
using NonMatching::FEImmersedSurfaceValues;
// Set up a triangulation with a single Cartesian cell and a finite element
#include "../tests.h"
-using namespace dealii;
using NonMatching::FEImmersedSurfaceValues;
// Set up a triangulation that we can construct an
#include "../tests.h"
-using namespace dealii;
// Set up a triangulation with 2 elements in a row: |-0-|-1-|, over
// [0,2]x[0,1]^{dim-1}, and a level set function with a cut in the plane
#include "../tests.h"
-using namespace dealii;
template <int dim>
class Test
#include "../tests.h"
-using namespace dealii;
// Assert that the two incoming cells are the same. Throw an exception if not.
template <int dim>
#include "../tests.h"
-using namespace dealii;
using namespace NonMatching::internal::QuadratureGeneratorImplementation;
#include "../tests.h"
-using namespace dealii;
using namespace NonMatching::internal::QuadratureGeneratorImplementation;
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
using namespace NonMatching::internal::QuadratureGeneratorImplementation;
#include "../tests.h"
-using namespace dealii;
/**
* Compute the volume and surface area of a ball/sphere by setting up a
#include "../tests.h"
-using namespace dealii;
using namespace NonMatching::internal::QuadratureGeneratorImplementation;
// Use RootFinder to find the roots of the incoming functions over the interval
namespace Step70
{
- using namespace dealii;
// @sect3{Run-time parameter handling}
main(int argc, char *argv[])
{
using namespace Step70;
- using namespace dealii;
auto init = Utilities::MPI::MPI_InitFinalize(argc, argv, 1);
MPILogInitAll log(true);
#include "quadrature_printing.h"
-using namespace dealii;
using namespace NonMatching::internal::QuadratureGeneratorImplementation;
#include "quadrature_printing.h"
-using namespace dealii;
using namespace NonMatching::internal::QuadratureGeneratorImplementation;
#include "../tests.h"
-using namespace dealii;
template <int dim, typename MatrixType>
void
namespace nonlinear_solver_selector_test
{
- using namespace dealii;
using NLSolve = NonlinearSolverSelector<Vector<double>>;
namespace MPI_nonlinear_solver_selector_test
{
- using namespace dealii;
using NLSolve = NonlinearSolverSelector<LA::MPI::Vector>;
#include "../tests.h"
-using namespace dealii;
-
template <int dim>
class LegendreFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
-
template <int dim>
class PolyFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
template <int dim>
class VelocityField : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class VelocityField : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../tests.h"
-using namespace dealii;
-
// @sect3{Global definitions}
namespace Step68
{
- using namespace dealii;
// @sect3{Velocity profile}
main(int argc, char *argv[])
{
using namespace Step68;
- using namespace dealii;
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
MPILogInitAll all;
namespace Euler_DG
{
- using namespace dealii;
// Similarly to the other matrix-free tutorial programs, we collect all
// parameters that control the execution of the program at the top of the
main(int argc, char **argv)
{
using namespace Euler_DG;
- using namespace dealii;
initlog();
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
{
// Before writing the main class to solve the problem, we define
// shortcuts for the types we are going to use within this tutorial.
- using namespace dealii;
using VectorType = PETScWrappers::MPI::Vector;
using MatrixType = PETScWrappers::MPI::SparseMatrix;
using PreconditionerType = PETScWrappers::PreconditionLU;
void
positive_negative_split_test()
{
- using namespace dealii;
-
SymmetricTensor<2, dim> random_tensor;
srand(time(0));
#include "../tests.h"
-using namespace dealii;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
#include "../tests.h"
-using namespace dealii;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
#include "../tests.h"
-using namespace dealii;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
#include "../tests.h"
-using namespace dealii;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class AnalyticalFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class AnalyticalFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
#include "../tests.h"
-using namespace dealii;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
#include "../tests.h"
-using namespace dealii;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
#include "../tests.h"
-using namespace dealii;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
#include "../tests.h"
-using namespace dealii;
template <int dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
using VectorType = LinearAlgebra::distributed::Vector<double>;
#include "../tests.h"
-using namespace dealii;
using VectorType = LinearAlgebra::distributed::Vector<double>;
#include "../tests.h"
-using namespace dealii;
using VectorType = LinearAlgebra::distributed::Vector<double>;
#include "../tests.h"
-using namespace dealii;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
#include "../tests.h"
-using namespace dealii;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
#include "../tests.h"
-using namespace dealii;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
#include "../tests.h"
-using namespace dealii;
template <int dim>
std::vector<std::vector<BoundingBox<dim>>>
#include "../tests.h"
-using namespace dealii;
namespace dealii
{
#include "../tests.h"
-using namespace dealii;
template <typename MeshType>
MPI_Comm
#include "../tests.h"
-using namespace dealii;
template <typename MeshType>
MPI_Comm
#include "../tests.h"
-using namespace dealii;
template <typename MeshType>
MPI_Comm
#include "../tests.h"
-using namespace dealii;
template <typename MeshType>
MPI_Comm
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
std::shared_ptr<const Utilities::MPI::Partitioner>
#include "../tests.h"
-using namespace dealii;
template <typename MeshType>
MPI_Comm
#include "../grid/tests.h"
#include "serialization.h"
-using namespace dealii;
template <int dim>
void
#include "../grid/tests.h"
-using namespace dealii;
template <int dim>
class InterpolationFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
int
main()
// Create a simplex mesh in the unit cube. Check points distribute to each cell
// via GridTools::compute_point_locations
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
class RightHandSideFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
class RightHandSideFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class RightHandSideFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class RightHandSideFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class RightHandSideFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class RightHandSideFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class RightHandSideFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class RightHandSideFunction : public Function<dim>
#include "./simplex_grids.h"
-using namespace dealii;
template <int dim>
class RightHandSideFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim = dim>
void
#include "simplex_grids.h"
-using namespace dealii;
template <int dim>
class RightHandSideFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class RightHandSideFunction : public Function<dim>
// didn't used to work with MappingFEField since it did not apply the sqrt(2)
// factor in 2D correctly.
-using namespace dealii;
template <int dim, int spacedim = dim>
void
int
main(int argc, char **argv)
{
- using namespace dealii;
initlog();
{
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim = dim>
Quadrature<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
// Check that Triangulation::get_boundary_ids() works for
// simplices. This used to crash.
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
class RightHandSideFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class Position : public Function<dim>
#include "../tests.h"
-using namespace dealii;
void
test(const unsigned int mapping_degree)
#include "../tests.h"
-using namespace dealii;
void
test()
#include "../tests.h"
-using namespace dealii;
template <int dim>
class Solution : public Function<dim>
#include "../tests.h"
-using namespace dealii;
void
make_grid(Triangulation<2> &triangulation)
#include "./simplex_grids.h"
-using namespace dealii;
template <int dim>
#include "./simplex_grids.h"
-using namespace dealii;
template <int dim>
class PoissonOperator
#include "../tests.h"
-using namespace dealii;
const double PENALTY = 8;
#include "./simplex_grids.h"
-using namespace dealii;
double
#include "./simplex_grids.h"
-using namespace dealii;
template <int dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
class ExactSolution : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "simplex_grids.h"
-using namespace dealii;
template <int dim>
struct Parameters
// #define HEX
-using namespace dealii;
template <int dim>
struct ScratchData
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
void
first_grid()
#include "../tests.h"
-using namespace dealii;
void
make_grid(Triangulation<2> &triangulation)
#include "../tests.h"
-using namespace dealii;
template <int dim>
class Step3
#include "../tests.h"
-using namespace dealii;
template <int dim>
class Step4
#include "../tests.h"
-using namespace dealii;
template <int dim>
class Step4
-using namespace dealii;
-
-
template <int dim>
class Step6
{
namespace Step7
{
- using namespace dealii;
template <int dim>
try
{
- using namespace dealii;
using namespace Step7;
{
namespace Step8
{
- using namespace dealii;
template <int dim>
class ElasticProblem
namespace Step12
{
- using namespace dealii;
template <int dim>
class BoundaryValues : public Function<dim>
namespace Step17
{
- using namespace dealii;
template <int dim>
class ElasticProblem
try
{
- using namespace dealii;
using namespace Step17;
ElasticProblem<2> elastic_problem;
namespace Step18
{
- using namespace dealii;
template <int dim>
struct PointHistory
try
{
- using namespace dealii;
using namespace Step18;
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
namespace Step20
{
- using namespace dealii;
template <int dim>
class MixedLaplaceProblem
namespace Step23
{
- using namespace dealii;
template <int dim>
class WaveEquation
try
{
- using namespace dealii;
using namespace Step23;
WaveEquation<2> wave_equation_solver;
namespace Step31
{
- using namespace dealii;
namespace EquationData
{
constexpr double eta = 1;
{
try
{
- using namespace dealii;
using namespace Step31;
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, numbers::invalid_unsigned_int);
namespace Step40
{
- using namespace dealii;
template <int dim>
class LaplaceProblem
try
{
- using namespace dealii;
using namespace Step40;
namespace Step55
{
- using namespace dealii;
// @sect3{Linear solvers and preconditioners}
mpi_initlog();
try
{
- using namespace dealii;
using namespace Step55;
namespace Euler_DG
{
- using namespace dealii;
// Similarly to the other matrix-free tutorial programs, we collect all
// parameters that control the execution of the program at the top of the
main(int argc, char **argv)
{
using namespace Euler_DG;
- using namespace dealii;
// tests.h enables floating point exceptions in debug mode, here we disable
// them to avoid division by zero when some cell lanes might not be occupied
namespace Step68
{
- using namespace dealii;
main(int argc, char *argv[])
{
using namespace Step68;
- using namespace dealii;
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
initlog();
namespace Step74
{
- using namespace dealii;
enum class Test_Case
{
try
{
- using namespace dealii;
using namespace Step74;
Test_Case test_case = Test_Case::l_singularity;
SIPGLaplace<2> problem(test_case);
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
class Fu : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class Fu : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class Fu : public Function<dim>
#include "../tests.h"
-using namespace dealii;
void
test_3()
#include "../tests.h"
-using namespace dealii;
template <int dim>
Triangulation<dim>
namespace Step77
{
- using namespace dealii;
template <int dim>
class MinimalSurfaceProblem
#include "../tests.h"
-using namespace dealii;
namespace SE = SymEngine;
int
#include "../tests.h"
-using namespace dealii;
namespace SE = SymEngine;
int
#include "../tests.h"
-using namespace dealii;
namespace SE = SymEngine;
namespace SD = dealii::Differentiation::SD;
#include "../tests.h"
-using namespace dealii;
namespace SD = dealii::Differentiation::SD;
void
#include "utilities.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
template <typename NumberType,
#include "utilities.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
namespace Diff_Test
#include "serialization.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
template <int dim,
#include "serialization.h"
#include "utilities.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
template <int dim,
#include "utilities.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
template <int dim,
#include "../../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
template <int dim,
#include "utilities.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
template <int dim,
namespace Step44
{
- using namespace dealii;
namespace SD = Differentiation::SD;
template <int dim>
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
using namespace Step44;
try
{
namespace Step44
{
- using namespace dealii;
namespace SD = Differentiation::SD;
template <int dim>
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
using namespace Step44;
try
{
namespace Step44
{
- using namespace dealii;
namespace SD = Differentiation::SD;
template <int dim>
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
using namespace Step44;
try
{
namespace Step77
{
- using namespace dealii;
template <int dim>
class MinimalSurfaceProblem
projects / dealii.git / commitdiff