#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
template <int dim, typename NumberType>
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
template <int dim, typename NumberType>
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
template <int dim, typename NumberType>
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
template <int dim, typename NumberType>
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
#include "../tests.h"
namespace Step44
{
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
namespace Parameters
{
#include "../tests.h"
namespace Step44
{
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
namespace Parameters
{
#include "../tests.h"
namespace Step44
{
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
namespace Parameters
{
#include "../tests.h"
namespace Step44
{
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
namespace Parameters
{
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
template <int dim, typename NumberType>
#include <iostream>
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
double
#include <iostream>
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
double
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
template <int dim, typename NumberType>
#include "../tests.h"
-using namespace dealii;
namespace AD = Differentiation::AD;
int
#include "../tests.h"
-using namespace dealii;
namespace AD = Differentiation::AD;
template <typename NumberTraitsType>
#include "../tests.h"
-using namespace dealii;
namespace AD = Differentiation::AD;
template <typename NumberTraitsType>
#include "../tests.h"
-using namespace dealii;
namespace AD = Differentiation::AD;
template <typename ADNumber>
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
#include "../tests.h"
-using namespace dealii;
namespace AD = dealii::Differentiation::AD;
// Function and its derivatives
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
#include "../tests.h"
namespace Step44
{
- using namespace dealii;
namespace Parameters
{
struct FESystem
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
using namespace Step44;
try
{
#include "../tests.h"
-using namespace dealii;
template <int dim,
typename number_t,
#include "../tests.h"
-using namespace dealii;
template <int dim,
typename number_t,
// test computing square root of 2 with newton's method
-using namespace dealii;
class SquareRoot : public Subscriptor
{
// verify that all debug vectors have the correct size
-using namespace dealii;
using namespace Algorithms;
template <typename VectorType, int dim>
#include "../tests.h"
-using namespace dealii;
using namespace Algorithms;
/// to generate random numbers
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
template <int dim>
{
try
{
- using namespace dealii;
-
initlog();
const unsigned int dim = 2; // run in 2d to save time
-using namespace dealii;
const double eps = 1e-10;
namespace Step36
{
- using namespace dealii;
-
-
template <int dim>
class EigenvalueProblem
{
{
try
{
- using namespace dealii;
using namespace Step36;
initlog();
namespace Step36
{
- using namespace dealii;
-
-
template <int dim>
class EigenvalueProblem
{
{
try
{
- using namespace dealii;
using namespace Step36;
initlog();
namespace Step36
{
- using namespace dealii;
-
-
template <int dim>
class EigenvalueProblem
{
{
try
{
- using namespace dealii;
using namespace Step36;
initlog();
const unsigned int dim = 2;
-using namespace dealii;
const double eps = 1e-10;
const unsigned int dim = 2;
-using namespace dealii;
const double eps = 1e-10;
const unsigned int dim = 2;
-using namespace dealii;
const double eps = 1e-10;
const unsigned int dim = 2; // run in 2d to save time
-using namespace dealii;
const double eps = 1e-10;
#include "../tests.h"
-using namespace dealii;
template <int dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class MyFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class MyFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
void
test(const MPI_Comm &comm)
#include "../tests.h"
-using namespace dealii;
using namespace dealii::GeometricUtilities::Coordinates;
template <unsigned int dim, typename T>
#include "../tests.h"
-using namespace dealii;
//
// Test GeometryInfo<dim>::face_to_cell_vertices
#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(const MPI_Comm comm,
#include "../tests.h"
-using namespace dealii;
int
#include "../tests.h"
-using namespace dealii;
template <typename quadrature_type, unsigned short startn>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class MyFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class MyFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class MyFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
using MaterialBase = TransferableQuadraturePointData;
using QuadratureStorage =
#include "../tests.h"
-using namespace dealii;
std::vector<std::string>
split_string(const std::string &text, const char delim = '|')
#include "../tests.h"
-using namespace dealii;
-
void
#include "../tests.h"
-using namespace dealii;
-
void
#include "../tests.h"
-using namespace dealii;
-
void
#include "../tests.h"
-using namespace dealii;
-
template <int N, int dim>
void
#include "../tests.h"
-using namespace dealii;
-
template <int N, int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int N>
#include "../tests.h"
-using namespace dealii;
void
check(const std::string &input, const std::string &expected)
#include "../tests.h"
-using namespace dealii;
void
test()
#include "../tests.h"
-using namespace dealii;
void create_coarse_grid(Triangulation<2> &coarse_grid)
#include "../tests.h"
-using namespace dealii;
void
test()
#include "../tests.h"
-using namespace dealii;
void
test()
// Finally, this is as in previous
// programs:
-using namespace dealii;
// @sect3{The <code>LaplaceProblem</code> class template}
#include "../tests.h"
-using namespace dealii;
class Deal2PeriodicBug
{
#include "../tests.h"
-using namespace dealii;
AffineConstraints<double>
make_constraint_matrix(const DoFHandler<2> &dof_handler, int version)
#include "../tests.h"
-using namespace dealii;
AffineConstraints<double>
make_constraint_matrix(const DoFHandler<3> &dof_handler, int version)
namespace Step51
{
- using namespace dealii;
-
template <int dim>
class SolutionBase
{
namespace Step51
{
- using namespace dealii;
-
template <int dim>
class SolutionBase
{
namespace Step38
{
- using namespace dealii;
-
template <int spacedim>
class Extract_Mesh_Test
{
initlog();
{
- using namespace dealii;
using namespace Step38;
Extract_Mesh_Test<2> Test;
#include "../tests.h"
-using namespace dealii;
template <int spacedim>
void
-using namespace dealii;
-
-
int
main()
{
#include "../base/simplex.h"
using namespace std;
-using namespace dealii;
int
main()
#include "../base/simplex.h"
using namespace std;
-using namespace dealii;
// We test the integration of singular kernels with a singularity of kind 1/R
// We multiply this function with a polynomial up to degree 6.
#include "../tests.h"
-using namespace dealii;
void
#include "../tests.h"
-using namespace dealii;
-
int
main()
#include <vector>
#include "../tests.h"
-using namespace dealii;
// this is copied from GridGenerator
namespace Step8
{
- using namespace dealii;
-
-
template <int dim>
class ElasticProblem
{
#include "../tests.h"
-using namespace dealii;
-
template <int dim>
#include "../tests.h"
-using namespace dealii;
// Purpose of this test:
// Demonstrate that mesh smoothing option limit_level_difference_at_vertices
#include "../tests.h"
-using namespace dealii;
// Purpose of this test:
// Demonstrate that mesh smoothing option limit_level_difference_at_vertices
#include "../tests.h"
-using namespace dealii;
void
std::ofstream logfile("output");
-using namespace dealii;
//
// Test
std::ofstream logfile("output");
-using namespace dealii;
-
/*
std::ofstream logfile("output");
-using namespace dealii;
-
/*
std::ofstream logfile("output");
-using namespace dealii;
-
/*
std::ofstream logfile("output");
-using namespace dealii;
//
// Test
#include "../tests.h"
-using namespace dealii;
/*
* Call the version of make_flux_sparsity_pattern that takes both cell and face
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
-
template <int dim>
#include "../tests.h"
-using namespace dealii;
template <typename MATRIX>
#include "../tests.h"
-using namespace dealii;
void
value_rank_0(TrilinosWrappers::SparseMatrix &a)
namespace Step56
{
- using namespace dealii;
-
// In order to make it easy to switch between the different solvers that are
// being used, we declare an enum that can be passed as an argument to the
// constructor of the main class.
{
try
{
- using namespace dealii;
using namespace Step56;
const int degree = 1;
// Finally, this is as in previous
// programs:
-using namespace dealii;
template <int dim>
class LaplaceProblem
#include "../tests.h"
-using namespace dealii;
template <int dim>
class MaxwellProblem
{
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
class EnrichmentFunction : public Function<dim>
// argument for build_patches()
const unsigned int patches = 10;
-using namespace dealii;
// uncomment when debugging
// #define DATA_OUT_FE_ENRICHED
#include "../tests.h"
-using namespace dealii;
template <int dim>
class EnrichmentFunction : public Function<dim>
// argument for build_patches()
const unsigned int patches = 10;
-using namespace dealii;
// uncomment when debugging
// #define DATA_OUT_FE_ENRICHED
// argument for build_patches()
const unsigned int patches = 10;
-using namespace dealii;
// uncomment when debugging
// #define DATA_OUT_FE_ENRICHED
// argument for build_patches()
const unsigned int patches = 10;
-using namespace dealii;
// uncomment when debugging
// #define DATA_OUT_FE_ENRICHED
// argument for build_patches()
const unsigned int patches = 10;
-using namespace dealii;
// uncomment when debugging
// #define DATA_OUT_FE_ENRICHED
// argument for build_patches()
const unsigned int patches = 10;
-using namespace dealii;
// uncomment when debugging
// #define DATA_OUT_FE_ENRICHED
const double eps = 1e-10;
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
/*
* Construct a class template which finds if a cell
// in the same way for FE_System and FEEnriched.
const unsigned int patches = 10;
-using namespace dealii;
template <int dim>
class EnrichmentFunction : public Function<dim>
// functions.
const unsigned int patches = 10;
-using namespace dealii;
template <int dim>
class EnrichmentFunction : public Function<dim>
const unsigned int dim = 3;
-using namespace dealii;
/**
* Coulomb potential
const unsigned int dim = 3;
-using namespace dealii;
/**
* Coulomb potential
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
namespace nedelec_singularity
{
#include "../tests.h"
-using namespace dealii;
namespace nedelec_singularity
{
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
namespace polytest
{
namespace Maxwell
{
- using namespace dealii;
-
// Dirichlet BCs / exact solution:.
template <int dim>
class ExactSolution : public Function<dim>
* Alexander Grayver
*/
-using namespace dealii;
static const Point<2> vertices_nonaffine[] = {
Point<2>(-1., -1.),
* Alexander Grayver, Maien Hamed
*/
-using namespace dealii;
static const Point<3> vertices_affine[] = {
Point<3>(-1., -1., -1.), Point<3>(0., -1., -1.), Point<3>(1., -1., -1.),
#include "../tests.h"
-using namespace dealii;
template <int dim>
class BubbleFunction : public Function<dim>
namespace Step22
{
- using namespace dealii;
-
template <int dim>
struct InnerPreconditioner;
int
main()
{
- using namespace dealii;
using namespace Step22;
initlog();
#include "../tests.h"
-using namespace dealii;
void
test_1d()
#include "../tests.h"
-using namespace dealii;
/**
* A 1D function given by input legendre coefficients
#include "../tests.h"
-using namespace dealii;
std::pair<bool, unsigned int>
pred_ind(const TableIndices<2> &ind)
#include "../tests.h"
-using namespace dealii;
template <int dim>
class LegendreFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class LegendreFunction : public Function<dim>
#include "../tests.h"
-using namespace dealii;
void
test_2d()
#include "../tests.h"
-using namespace dealii;
std::pair<bool, unsigned int>
pred_ind(const TableIndices<2> &ind)
#include "../tests.h"
-using namespace dealii;
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
// error causes the Laplace solver to converge at order 2 instead of order 5,
// resulting in much higher L2 errors when the grid is refined.
-using namespace dealii;
static const unsigned int fe_order = 4;
static const dealii::types::boundary_id boundary_id = 0;
#include "../tests.h"
-using namespace dealii;
template <int dim>
class MixedElastoPlasticity
#include "../tests.h"
-using namespace dealii;
template <int dim>
class MixedElastoPlasticity
#include "../tests.h"
-using namespace dealii;
template <int dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class MixedElastoPlasticity
#include "../tests.h"
-using namespace dealii;
template <int dim>
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>
void
#include "../tests.h"
-using namespace dealii;
namespace polytest
{
namespace Maxwell
{
- using namespace dealii;
-
// Dirichlet BCs / exact solution:.
template <int dim>
class ExactSolution : public Function<dim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
namespace Step12
{
- using namespace dealii;
-
-
-
template <int dim>
struct ScratchData
{
#include "full_matrix_common.h"
-using namespace dealii;
-
template <typename number>
void
#include "full_matrix_common.h"
-using namespace dealii;
-
template <typename number>
void
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
#include "../tests.h"
-using namespace dealii;
namespace bg = boost::geometry;
namespace bgi = boost::geometry::index;
#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
test()
{
- using namespace dealii;
-
Triangulation<dim> triangulation(
Triangulation<dim>::limit_level_difference_at_vertices);
int
main()
{
- using namespace dealii;
-
initlog();
deallog.push("1d");
#include "../tests.h"
-using namespace dealii;
void
test()
#include "../tests.h"
-using namespace dealii;
Triangulation<2, 2>
create_grid()
// Check SVG output with a GridGenerator function.
-using namespace dealii;
Triangulation<2, 2>
create_grid()
#include "../tests.h"
-using namespace dealii;
Triangulation<2, 2>
create_grid()
#include "../tests.h"
-using namespace dealii;
/*
* The parameters left, right, refinements follow the hyper-rectangle
#include "../tests.h"
-using namespace dealii;
namespace bg = boost::geometry;
namespace bgi = boost::geometry::index;
#include "../tests.h"
-using namespace dealii;
template <int dim>
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
using namespace std;
template <int dim>
#include "../grid/mesh_3d.h"
-using namespace dealii;
using namespace std;
template <int dim>
#include "../tests.h"
-using namespace dealii;
using namespace std;
template <int dim>
#include "../tests.h"
-using namespace dealii;
-
-
template <int dim>
bool
#include "../tests.h"
-using namespace dealii;
-
-
void
test()
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
int
main()
{
- using namespace dealii;
initlog();
// test the internal cross derivative function: the stencil should be order 2.
#include "../tests.h"
-using namespace dealii;
int
main(int argc, const char *argv[])
#include "../tests.h"
-using namespace dealii;
int
main(int argc, const char *argv[])
#include "../tests.h"
-using namespace dealii;
int
main(int argc, const char *argv[])
initlog();
deallog << std::boolalpha;
- using namespace dealii;
Triangulation<1> triangulation;
GridGenerator::hyper_cube(triangulation);
#include "../tests.h"
-using namespace dealii;
-
-
template <int dim>
void
// Finally, this is as in previous
// programs:
-using namespace dealii;
template <int dim>
class LaplaceProblem
// Finally, this is as in previous
// programs:
-using namespace dealii;
template <int dim>
class LaplaceProblem
namespace Step
{
- using namespace dealii;
-
template <int dim>
class Problem : public Subscriptor
{
void
test()
{
- using namespace dealii;
using namespace Step;
Problem<dim> problem;
#include "../tests.h"
-using namespace dealii;
static const types::manifold_id circular_manifold_id = 1;
static const types::manifold_id straight_manifold_id = 3;
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
const double eps = 1e-10;
-using namespace dealii;
template <int dim>
void
const double eps = 1e-10;
-using namespace dealii;
template <int dim>
struct less_than_key
//#define FEQH_DEBUG_OUTPUT
-using namespace dealii;
template <int dim>
void
namespace Step27
{
- using namespace dealii;
-
template <int dim>
class MixedFECollection
{
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
#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>
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
template <class DOFINFO, typename MatrixType>
void
#include "../tests.h"
-using namespace dealii;
template <class DOFINFO, typename MatrixType>
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 <typename number>
void
#include "../tests.h"
-using namespace dealii;
template <typename number>
void
#include "../tests.h"
-using namespace dealii;
template <typename number>
void
#include "../tests.h"
-using namespace dealii;
template <typename number>
void
#include "../tests.h"
-using namespace dealii;
template <class DOFINFO, typename MatrixType>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <typename number>
void
#include "../tests.h"
-using namespace dealii;
using namespace LocalIntegrators;
#include "../tests.h"
-using namespace dealii;
-
/*
* Right hand side
#include "empty_info.h"
-using namespace dealii;
// Define a class that fills all available entries in the info objects
#include "empty_info.h"
-using namespace dealii;
// Define a class that fills all available entries in the info objects
#include "../tests.h"
-using namespace dealii;
using namespace LocalIntegrators::Maxwell;
template <int dim>
#include "../tests.h"
-using namespace dealii;
// Define a class that fills all available entries in the info objects
#include "../tests.h"
-using namespace dealii;
-
// Use local matrices for Laplacian / interior penalty DG
template <int dim>
#include "../tests.h"
-using namespace dealii;
// Local integrators fill every matrix entry with 10*block_row + block_col
template <int dim>
#include "../tests.h"
-using namespace dealii;
//! Solve the advection equation: \dot{u} + \div{\mathbf{c} u} = 0.0,
namespace Advection
{
- using namespace dealii;
-
/********************************************
* ADVECTION PROBLEM
********************************************/
#include "../tests.h"
-using namespace dealii;
// Define a class that fills all available entries in the info objects
deallog << "[block " << i << " ] " << var.block(i);
-using namespace dealii;
int
main()
deallog << "[block " << i << " ] " << var.block(i);
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
deallog << "[block " << i << " ] " << var.block(i);
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main(int argc, char *argv[])
deallog << "[block " << i << " ] " << var.block(i);
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
template <int dim>
class Step6
#include "../tests.h"
-using namespace dealii;
int
main()
// (2) the case that all entries of the local matrix
// are zero while a dof is constrained.
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
-
void
#include "../tests.h"
-using namespace dealii;
void
test()
std::ofstream logfile("output");
-using namespace dealii;
template <int dim>
class LaplaceProblem
std::ofstream logfile("output");
-using namespace dealii;
void
test(bool use_inhomogeneity_for_rhs)
std::ofstream logfile("output");
-using namespace dealii;
void
test(bool use_inhomogeneity_for_rhs)
std::ofstream logfile("output");
-using namespace dealii;
void
test(bool use_constraint_matrix)
std::ofstream logfile("output");
-using namespace dealii;
template <int dim>
class AdvectionProblem
std::ofstream logfile("output");
-using namespace dealii;
template <int dim>
class AdvectionProblem
std::ofstream logfile("output");
-using namespace dealii;
template <int dim>
class LaplaceProblem
#include "../tests.h"
-using namespace dealii;
// Dummy vectors with different, non convertible types:
#include "../tests.h"
-using namespace dealii;
// Dummy vectors with different, non convertible types:
#define PRINTME(name, var) \
deallog << "Solution vector: " << name << ": " << var;
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
<< var.block(1) << std::endl;
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main(int argc, char *argv[])
#include "../tests.h"
-using namespace dealii;
int
main(int argc, char *argv[])
}
};
-using namespace dealii;
int
main()
deallog << "[block " << i << " ] " << var.block(i);
-using namespace dealii;
int
main()
deallog << "[block " << i << " ] " << var.block(i);
-using namespace dealii;
int
main()
# include <deal.II/lac/sparse_direct.h>
#endif
-using namespace dealii;
template <class PRECONDITIONER,
#include <deal.II/lac/petsc_block_vector.h>
-using namespace dealii;
int
main(int argc, char *argv[])
#include "../tests.h"
-using namespace dealii;
template <typename VECTOR>
void
#include "../tests.h"
-using namespace dealii;
template <typename VECTOR>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
class Step4
#include "../tests.h"
-using namespace dealii;
template <int dim>
class Step4
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../testmatrix.h"
-using namespace dealii;
int
main(int argc, char *argv[])
#include "../testmatrix.h"
-using namespace dealii;
int
main(int argc, char *argv[])
#include "../tests.h"
-using namespace dealii;
-
int
main()
#include "../tests.h"
-using namespace dealii;
-
int
main()
#include "../tests.h"
-using namespace dealii;
void
#include "../tests.h"
-using namespace dealii;
void
#include <deal.II/numerics/matrix_tools.h>
-using namespace dealii;
void
#define PRINTME(name, var) \
deallog << "Solution vector: " << name << ": " << var;
-using namespace dealii;
int
#define PRINTME(name, var) deallog << "RHS vector: " << name << ": " << var;
-using namespace dealii;
int
namespace Step22
{
- using namespace dealii;
template <int dim>
class StokesProblem
{
deallog << "RHS vector: " << name << ": " << str << std::endl; \
}
-using namespace dealii;
int
const unsigned int dim = 2;
-using namespace dealii;
const double eps = 1e-10;
#include "../tests.h"
-using namespace dealii;
template <typename VectorType>
void
#include "../tests.h"
-using namespace dealii;
struct MappingEnum
{
void
test(MappingEnum::type mapping_name, unsigned int refinements = 1)
{
- using namespace dealii;
-
deallog.depth_console(0);
const unsigned int degree = 2; // Degree of shape functions
#include "../tests.h"
-using namespace dealii;
void
test(const double R)
}
-using namespace dealii;
int
main(int argc, char *argv[])
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
template <typename Stream, int dim>
void
<< std::endl;
}
-using namespace dealii;
int
main()
{
<< "Linfty=" << map_vector.linfty_norm() << std::endl;
}
-using namespace dealii;
int
main(int argc, char *argv[])
{
deallog << "OK" << std::endl;
}
-using namespace dealii;
int
main()
{
deallog << "OK" << std::endl;
}
-using namespace dealii;
int
main()
{
deallog << "OK" << std::endl;
}
-using namespace dealii;
int
main(int argc, char **argv)
{
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
#include "../tests.h"
-using namespace dealii;
void
dim2_grid()
{
// transform_unit_to_real_cell, we lost nearly all digits of precision due to
// roundoff.
-using namespace dealii;
class RefineTest
{
#include "../tests.h"
-using namespace dealii;
template <int dim>
// In addition to checking the L2 errors of a projection, this test also
// verifies that there is no loss in convergence order.
-using namespace dealii;
// Like FESeries::linear_regression. Included here so that this test can also
// be run with older versions of deal.II.
double
#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>
-using namespace dealii;
-
-
template <int dim>
class Displacement : public Function<dim>
{
-using namespace dealii;
-
-
template <int dim>
class Displacement : public Function<dim>
{
<< std::endl;
}
-using namespace dealii;
int
main()
{
#include "../tests.h"
-using namespace dealii;
-
template <int dim>
class Displacement : public Function<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;
int
#include "../tests.h"
-using namespace dealii;
double
zvalue(const double x, const double y)
#include "../tests.h"
-using namespace dealii;
double
f_x(double x_m)
int
main(int argc, char **argv)
{
- using namespace dealii;
-
Utilities::MPI::MPI_InitFinalize mpi(argc, argv, 1);
MPILogInitAll log;
-using namespace dealii;
-
-
template <int dim>
class SimpleField : public Function<dim>
{
#include "../tests.h"
-using namespace dealii;
template <int dim,
typename Number = double,
#include "../tests.h"
-using namespace dealii;
template <int dim, int degree_p, typename BlockVectorType>
class MatrixFreeTest : public MatrixFreeOperators::Base<dim, BlockVectorType>
#include "../tests.h"
-using namespace dealii;
template <int dim,
typename Number = double,
#include "../tests.h"
-using namespace dealii;
template <int dim,
typename Number = double,
#include "../tests.h"
-using namespace dealii;
template <int dim,
typename Number = double,
namespace Step37
{
- using namespace dealii;
-
const unsigned int degree_finite_element = 2;
template <int dim>
namespace Step37
{
- using namespace dealii;
-
const unsigned int degree_finite_element = 2;
namespace Step48
{
- using namespace dealii;
-
const unsigned int dimension = 2;
const unsigned int fe_degree = 4;
namespace Step48
{
- using namespace dealii;
-
const unsigned int fe_degree = 4;
namespace Step48
{
- using namespace dealii;
-
const unsigned int dimension = 2;
const unsigned int fe_degree = 4;
namespace StokesClass
{
- using namespace dealii;
class QuietException
{};
#include "../tests.h"
-using namespace dealii;
template <int dim, int spacedim>
class TestIntegrator : public MeshWorker::LocalIntegrator<dim, spacedim>
// The last step is as in all previous programs:
namespace Step11
{
- using namespace dealii;
-
// Then we declare a class which represents the solution of a Laplace
// problem. As this example program is based on step-5, the class looks
// rather the same, with the sole structural difference that the functions
namespace Step50
{
- using namespace dealii;
-
-
template <int dim>
struct ScratchData
{
try
{
- using namespace dealii;
using namespace Step50;
LaplaceProblem<2> laplace_problem(1 /*degree*/);
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
test()
namespace pdd
{
- using namespace dealii;
-
// @sect3{The <code>PDDProblem</code> class template}
template <int dim>
namespace LinearAdvectionTest
{
- using namespace dealii;
-
template <int dim>
class AdvectionProblem
{
int
main(int argc, char **argv)
{
- using namespace dealii;
initlog();
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
namespace Step39
{
- using namespace dealii;
-
template <int dim>
class InteriorPenaltyProblem
{
int
main(int argc, char *argv[])
{
- using namespace dealii;
using namespace Step39;
Utilities::MPI::MPI_InitFinalize mpi_initialization(
#include "../tests.h"
-using namespace dealii;
//#define DISTRIBUTED
namespace Step4
{
- using namespace dealii;
-
template <int dim>
class Step4
{
namespace Step40
{
- using namespace dealii;
-
-
template <int dim>
class LaplaceProblem
{
{
try
{
- using namespace dealii;
using namespace Step40;
namespace Step40
{
- using namespace dealii;
-
-
template <int dim>
class LaplaceProblem
{
{
try
{
- using namespace dealii;
using namespace Step40;
// test VectorTools::interpolate_to_different_mesh in parallel
-using namespace dealii;
namespace LA
{
// this is a slightly modified version from the example by Sam Cox from the
// mailing
-using namespace dealii;
namespace LA
{
#include "../tests.h"
-using namespace dealii;
-
template <int dim>
class myIntegrator : public dealii::MeshWorker::LocalIntegrator<dim>
#include "../tests.h"
-using namespace dealii;
-
template <int dim>
class myIntegrator : public dealii::MeshWorker::LocalIntegrator<dim>
#include "../tests.h"
-using namespace dealii;
-
template <int dim>
class myIntegrator : public dealii::MeshWorker::LocalIntegrator<dim>
#include "../tests.h"
-using namespace dealii;
-
template <int dim>
class myIntegrator : public dealii::MeshWorker::LocalIntegrator<dim>
#include "../tests.h"
-using namespace dealii;
-
template <int dim>
class myIntegrator : public dealii::MeshWorker::LocalIntegrator<dim>
#include "../tests.h"
-using namespace dealii;
// Define a class that fills all available entries in the info objects
int
main(int argc, char *argv[])
{
- using namespace dealii;
-
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
MPILogInitAll log;
int
main(int argc, char *argv[])
{
- using namespace dealii;
-
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
MPILogInitAll log;
int
main(int argc, char *argv[])
{
- using namespace dealii;
-
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
MPILogInitAll log;
int
main(int argc, char *argv[])
{
- using namespace dealii;
-
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
MPILogInitAll log;
namespace Step22
{
- using namespace dealii;
-
template <int dim>
class StokesProblem
{
{
try
{
- using namespace dealii;
using namespace Step22;
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
namespace Step50
{
- using namespace dealii;
-
template <int dim>
class LaplaceProblem
{
int
main(int argc, char *argv[])
{
- using namespace dealii;
using namespace Step50;
Utilities::MPI::MPI_InitFinalize mpi_initialization(
namespace Step50
{
- using namespace dealii;
-
template <int dim>
class LaplaceProblem
{
int
main(int argc, char *argv[])
{
- using namespace dealii;
using namespace Step50;
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
int
main(int argc, char **argv)
{
- using namespace dealii;
-
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
MPILogInitAll log;
int
main(int argc, char **argv)
{
- using namespace dealii;
-
Utilities::MPI::MPI_InitFinalize init(argc, argv, 1);
MPILogInitAll log;
#include "../tests.h"
-using namespace dealii;
template <int dim>
struct periodicity_tests
namespace Step40
{
- using namespace dealii;
-
template <int dim>
class LaplaceProblem
{
{
try
{
- using namespace dealii;
using namespace Step40;
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
namespace Step22
{
- using namespace dealii;
-
template <int dim>
class StokesProblem
{
{
try
{
- using namespace dealii;
using namespace Step22;
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
namespace Step22
{
- using namespace dealii;
-
template <int dim>
class StokesProblem
{
{
try
{
- using namespace dealii;
using namespace Step22;
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
{
try
{
- using namespace dealii;
-
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
MPILogInitAll log;
namespace Step27
{
- using namespace dealii;
-
-
template <int dim>
class LaplaceProblem
{
{
try
{
- using namespace dealii;
using namespace Step27;
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
namespace ResFlow
{
- using namespace dealii;
-
-
template <int dim>
class FluxBoundaryValues : public Function<dim>
{
try
{
- using namespace dealii;
using namespace ResFlow;
Assert(dim == 2 || dim == 3, ExcNotImplemented());
namespace Step39
{
- using namespace dealii;
-
Functions::SlitSingularityFunction<2> exact_solution;
int
main(int argc, char *argv[])
{
- using namespace dealii;
using namespace Step39;
Utilities::MPI::MPI_InitFinalize mpi_initialization(
namespace Step39
{
- using namespace dealii;
-
Functions::SlitSingularityFunction<2> exact_solution;
int
main(int argc, char *argv[])
{
- using namespace dealii;
using namespace Step39;
Utilities::MPI::MPI_InitFinalize mpi_initialization(
namespace Step40
{
- using namespace dealii;
-
-
template <int dim>
class LaplaceProblem
{
{
try
{
- using namespace dealii;
using namespace Step40;
namespace Step40
{
- using namespace dealii;
-
-
template <int dim>
class LaplaceProblem
{
{
try
{
- using namespace dealii;
using namespace Step40;
namespace Step40
{
- using namespace dealii;
-
-
template <int dim>
class LaplaceProblem
{
{
try
{
- using namespace dealii;
using namespace Step40;
namespace Step40
{
- using namespace dealii;
-
-
template <int dim>
class LaplaceProblem
{
{
try
{
- using namespace dealii;
using namespace Step40;
int
main(int argc, char *argv[])
{
- using namespace dealii;
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
MPILogInitAll log;
namespace Step27
{
- using namespace dealii;
-
-
template <int dim>
class LaplaceProblem
{
{
try
{
- using namespace dealii;
using namespace Step27;
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
namespace Step50
{
- using namespace dealii;
-
template <int dim>
class LaplaceProblem
{
{
deallog.depth_console(5);
- using namespace dealii;
using namespace Step50;
LaplaceProblem<2> laplace_problem(3 /*degree*/);
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
namespace Step50
{
- using namespace dealii;
-
template <int dim>
class LaplaceProblem
{
{
deallog.depth_console(5);
- using namespace dealii;
using namespace Step50;
LaplaceProblem<2> laplace_problem(3 /*degree*/);
#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, typename number, int spacedim>
#include "../tests.h"
-using namespace dealii;
template <int dim, typename number, int spacedim>
#include "../tests.h"
-using namespace dealii;
template <int dim, typename number, int spacedim>
#include "../tests.h"
-using namespace dealii;
using namespace LocalIntegrators;
template <int dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class LaplaceProblem
#include "../tests.h"
-using namespace dealii;
template <int dim>
class LaplaceProblem
#include "../tests.h"
-using namespace dealii;
template <int dim>
class LaplaceProblem
#include "../tests.h"
-using namespace dealii;
template <int dim>
class LaplaceProblem
#include "../tests.h"
-using namespace dealii;
template <int dim>
class LaplaceProblem
namespace Step50
{
- using namespace dealii;
-
-
-
template <int dim>
class LaplaceProblem
{
try
{
- using namespace dealii;
using namespace Step50;
LaplaceProblem<2> laplace_problem(1 /*degree*/);
namespace Step50
{
- using namespace dealii;
-
-
-
template <int dim>
class LaplaceProblem
{
try
{
- using namespace dealii;
using namespace Step50;
LaplaceProblem<2> laplace_problem(1 /*degree*/);
namespace Step50
{
- using namespace dealii;
-
-
-
template <int dim>
class LaplaceProblem
{
try
{
- using namespace dealii;
using namespace Step50;
LaplaceProblem<2> laplace_problem(1 /*degree*/);
#include "../tests.h"
-using namespace dealii;
template <int dim>
class LaplaceProblem
#include "../tests.h"
-using namespace dealii;
using namespace LocalIntegrators;
template <int dim>
#include "../tests.h"
-using namespace dealii;
template <int dim>
class LaplaceProblem
namespace Step39
{
- using namespace dealii;
-
Functions::SlitSingularityFunction<2> exact_solution;
{
try
{
- using namespace dealii;
using namespace Step39;
initlog(__FILE__);
namespace Step39
{
- using namespace dealii;
-
Functions::SlitSingularityFunction<2> exact_solution;
{
try
{
- using namespace dealii;
using namespace Step39;
initlog(__FILE__);
namespace Step39
{
- using namespace dealii;
-
Functions::SlitSingularityFunction<2> exact_solution;
{
try
{
- using namespace dealii;
using namespace Step39;
initlog(__FILE__);
namespace Step39
{
- using namespace dealii;
-
Functions::SlitSingularityFunction<2> exact_solution;
{
try
{
- using namespace dealii;
using namespace Step39;
initlog(__FILE__);
namespace Step50
{
- using namespace dealii;
-
template <int dim>
class LaplaceProblem
{
try
{
- using namespace dealii;
using namespace Step50;
LaplaceProblem<2> laplace_problem(1 /*degree*/);
namespace Step50
{
- using namespace dealii;
-
-
-
template <int dim>
class LaplaceProblem
{
try
{
- using namespace dealii;
using namespace Step50;
LaplaceProblem<2> laplace_problem(1 /*degree*/);
#include "../tests.h"
-using namespace dealii;
// Test that a coupling matrix can be constructed for each pair of dimension and
// immersed dimension, and check that constants are projected correctly.
#include "../tests.h"
-using namespace dealii;
// Test that a coupling matrix can be constructed for each pair of dimension and
// immersed dimension, with a non trivial component selection in the space_dh,
#include "../tests.h"
-using namespace dealii;
// Test that a coupling matrix can be constructed for each pair of dimension
// and immersed dimension, with a non trivial component selection in both
#include "../tests.h"
-using namespace dealii;
// Test that a coupling matrix can be constructed for each pair of dimension
// and immersed dimension, and check that quadratic functions are correctly
#include "../tests.h"
-using namespace dealii;
// Test that a coupling matrix can be constructed for each pair of dimension
// and immersed dimension, and check that quadratic functions are correctly
#include "../tests.h"
-using namespace dealii;
// Test that a coupling matrix can be constructed for each pair of dimension
// and immersed dimension, and check that quadratic functions are correctly
#include "../tests.h"
-using namespace dealii;
// Test that a coupling matrix can be constructed for each pair of dimension and
// immersed dimension, and check that constants are projected correctly.
#include "../tests.h"
-using namespace dealii;
// Test that a coupling matrix can be constructed for each pair of dimension and
// immersed dimension, and check that constants are projected correctly
#include "../tests.h"
-using namespace dealii;
// Test that an ImmersedSurfaceQuadrature can be constructed for each dimension
// and that quadrature points can be added to it.
#include "../tests.h"
-using namespace dealii;
namespace Assembly
#include "../tests.h"
-using namespace dealii;
namespace Assembly
#include "../tests.h"
-using namespace dealii;
namespace Assembly
#include "../tests.h"
-using namespace dealii;
namespace Assembly
// c++
#include <iostream>
-using namespace dealii;
template <int dim>
class MyFunction : public dealii::Function<dim>
// c++
#include <iostream>
-using namespace dealii;
template <int dim>
class MyFunction : public dealii::Function<dim, std::complex<double>>
#include "../tests.h"
using namespace std;
-using namespace dealii;
template <int spacedim>
class F1 : public Function<spacedim>
#include "../tests.h"
using namespace std;
-using namespace dealii;
template <int spacedim>
class F1 : public Function<spacedim>
#include "../tests.h"
using namespace std;
-using namespace dealii;
template <unsigned int spacedim>
void
#include "../tests.h"
using namespace std;
-using namespace dealii;
template <unsigned int spacedim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
-
-
template <int dim>
class TestPointValueHistory
#include "../tests.h"
-using namespace dealii;
-
template <int dim>
class Postprocess : public DataPostprocessor<dim>
#include "../tests.h"
-using namespace dealii;
-
template <int dim>
class Postprocess : public DataPostprocessor<dim>
#include "../tests.h"
-using namespace dealii;
int
main(int argc, char **argv)
#include "../tests.h"
-using namespace dealii;
void
test()
#include "../tests.h"
-using namespace dealii;
void
test()
#include <iostream>
#include "../tests.h"
-using namespace dealii;
/*
* MWE in Maxima
#include <iostream>
#include "../tests.h"
-using namespace dealii;
/*
* MWE in Maxima
#include <iostream>
#include "../tests.h"
-using namespace dealii;
/*
* MWE in Maxima
#include <iostream>
#include "../tests.h"
-using namespace dealii;
/*
* MWE in Maxima
#include <iostream>
#include "../tests.h"
-using namespace dealii;
void
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
using namespace Step44;
try
{
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
using namespace Step44;
try
{
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
using namespace Step44;
try
{
#include "../tests.h"
-using namespace dealii;
void
test()
#include "../tests.h"
-using namespace dealii;
using namespace Patterns::Tools;
// Try conversion on elementary types
#include "../tests.h"
-using namespace dealii;
using namespace Patterns::Tools;
// Try conversion on non elementary types
#include "../tests.h"
-using namespace dealii;
using namespace Patterns::Tools;
// Try conversion on container types
#include "../tests.h"
-using namespace dealii;
using namespace Patterns::Tools;
// Try conversion on map types
#include "../tests.h"
-using namespace dealii;
using namespace Patterns::Tools;
// Try conversion on complex map types
#include "../tests.h"
-using namespace dealii;
using namespace Patterns::Tools;
// Try conversion on complex map types
#include "../tests.h"
-using namespace dealii;
using namespace Patterns::Tools;
// Try conversion on arbitrary container types
#include "../tests.h"
-using namespace dealii;
using namespace Patterns::Tools;
// Try conversion on elementary types
#include "../tests.h"
-using namespace dealii;
int
main()
#include "../tests.h"
-using namespace dealii;
using namespace Patterns::Tools;
int
int
main(int argc, char **argv)
{
- using namespace dealii;
-
Utilities::MPI::MPI_InitFinalize mpi_context(argc, argv, 1);
MPILogInitAll mpi_log;
#include "../tests.h"
-using namespace dealii;
int
main(int argc, char **argv)
int
main(int argc, char **argv)
{
- using namespace dealii;
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
initlog();
#include "../tests.h"
-using namespace dealii;
static const unsigned int dim = 2;
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
using namespace dealii::Physics;
using namespace dealii::Physics::Elasticity;
#include "../tests.h"
-using namespace dealii;
using namespace dealii::Physics;
using namespace dealii::Physics::Elasticity;
#include "../tests.h"
-using namespace dealii;
using namespace dealii::Physics;
template <int dim, typename Number>
#include "../tests.h"
-using namespace dealii;
using namespace dealii::Physics;
template <int dim, typename Number>
#include "../tests.h"
-using namespace dealii;
using namespace dealii::Physics;
template <int dim, typename Number>
#include "../tests.h"
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);
TopLevel<3> elastic_problem;
#include "../tests.h"
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);
TopLevel<3> elastic_problem;
#include "../tests.h"
namespace Step44
{
- using namespace dealii;
namespace Parameters
{
struct FESystem
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
using namespace Step44;
try
{
#include "../tests.h"
namespace Step44
{
- using namespace dealii;
namespace Parameters
{
struct FESystem
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
using namespace Step44;
try
{
#include "../tests.h"
namespace Step44
{
- using namespace dealii;
namespace Parameters
{
struct FESystem
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
using namespace Step44;
try
{
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
using namespace dealii::Physics;
#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 <typename VectorType>
void
#include "../tests.h"
-using namespace dealii;
// Taken from deal.II's test: parallel_vector_07
template <typename VectorType>
#include "../tests.h"
-using namespace dealii;
// Taken from deal.II's test: parallel_vector_07
template <typename VectorType>
#include "../tests.h"
-using namespace dealii;
// Vectors are prepared similar to deal.II's test: parallel_vector_07
template <typename VectorType>
#include <fstream>
#include <iomanip>
-using namespace dealii;
namespace AD = Differentiation::AD;
int
#include "../tests.h"
-using namespace dealii;
namespace AD = Differentiation::AD;
template <typename NumberTraitsType>
#include "../tests.h"
-using namespace dealii;
namespace AD = Differentiation::AD;
template <typename NumberTraitsType>
#include "../tests.h"
-using namespace dealii;
namespace AD = Differentiation::AD;
template <typename NumberTraitsType>
#include "../tests.h"
-using namespace dealii;
namespace AD = Differentiation::AD;
template <typename NumberTraitsType>
#include "../tests.h"
-using namespace dealii;
namespace AD = Differentiation::AD;
template <typename NumberTraitsType>
#include "../tests.h"
-using namespace dealii;
namespace AD = Differentiation::AD;
template <typename Number>
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
Utilities::MPI::MPI_InitFinalize mpi_initialization(
argc, argv, testing_max_num_threads());
- using namespace dealii;
namespace AD = dealii::Differentiation::AD;
using namespace Step44;
try
#include <fstream>
#include <iomanip>
-using namespace dealii;
namespace SE = SymEngine;
SE::RCP<const SE::Number>
#include <fstream>
#include <iomanip>
-using namespace dealii;
namespace SE = SymEngine;
SE::RCP<const SE::Number>
#include <fstream>
#include <iomanip>
-using namespace dealii;
namespace SE = SymEngine;
SE::RCP<const SE::Number>
#include <iostream>
#include <vector>
-using namespace dealii;
namespace SE = SymEngine;
int
#include <iostream>
#include <vector>
-using namespace dealii;
namespace SE = SymEngine;
int
#include <iostream>
#include <vector>
-using namespace dealii;
namespace SE = SymEngine;
int
#include <iostream>
#include <vector>
-using namespace dealii;
namespace SE = SymEngine;
int
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
int
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
int
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
namespace SE = ::SymEngine;
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
namespace SE = ::SymEngine;
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
namespace SE = ::SymEngine;
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
namespace SE = ::SymEngine;
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
namespace SE = ::SymEngine;
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
namespace SE = ::SymEngine;
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
namespace SE = ::SymEngine;
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
namespace SE = ::SymEngine;
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
namespace SE = ::SymEngine;
#include "../serialization/serialization.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
namespace SE = ::SymEngine;
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
namespace SE = SymEngine;
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
int
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
template <typename Number1, typename Number2>
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
template <int dim, typename NumberType>
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
// Function and its derivatives
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
using SD_number_t = SD::Expression;
#include "../tests.h"
-using namespace dealii;
namespace SD = Differentiation::SD;
void
check_2()
{
- using namespace dealii;
Testing::rand(true, 42);
SymmetricTensor<2, dim> change_with_brackets;
void
check_4()
{
- using namespace dealii;
Testing::rand(true, 42);
SymmetricTensor<4, dim> change_with_brackets;
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
std::ofstream logfile("output");
-using namespace dealii;
namespace Assembly
std::ofstream logfile("output");
-using namespace dealii;
namespace Assembly
std::ofstream logfile("output");
-using namespace dealii;
namespace Assembly
std::ofstream logfile("output");
-using namespace dealii;
namespace Assembly
std::ofstream logfile("output");
-using namespace dealii;
namespace Assembly
std::ofstream logfile("output");
-using namespace dealii;
namespace Assembly
std::ofstream logfile("output");
-using namespace dealii;
namespace Assembly
#include "../tests.h"
-using namespace dealii;
template <int dim>
class Step4
#include "../tests.h"
-using namespace dealii;
template <int dim>
class Step4
namespace LinearAdvectionTest
{
- using namespace dealii;
-
template <int dim>
class AdvectionProblem
{
int
main(int argc, char **argv)
{
- using namespace dealii;
initlog();
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
#include "../tests.h"
-using namespace dealii;
class Test
{
namespace LA = dealii::LinearAlgebraTrilinos;
-using namespace dealii;
class Test_Solver_Output
{
namespace Step22
{
- using namespace dealii;
-
template <int dim>
class StokesProblem
{
{
try
{
- using namespace dealii;
using namespace Step22;
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
int
main(int argc, char **argv)
{
- using namespace dealii;
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
initlog();
#include "../tests.h"
-using namespace dealii;
static const unsigned int dim = 2;
#include "../tests.h"
-using namespace dealii;
void
test()
#include "../tests.h"
-using namespace dealii;
-
// x+y(+z), x^2+y^2 (, z+xy)
// div = 1+2y (+1)
#include "../tests.h"
-using namespace dealii;
// x+y(+z), x^2+y^2 (, z+xy)
#include "../tests.h"
-using namespace dealii;
// x+y(+z), x^2+y^2 (, z+xy) times i
#include "../tests.h"
-using namespace dealii;
// x+y(+z), x^2+y^2 (, z+xy) times (1+i)/sqrt(2)
#include "../tests.h"
-using namespace dealii;
// x+y(+z), x^2+y^2 (, z+xy) times (1+i)/sqrt(2)
#include "../tests.h"
-using namespace dealii;
// x+y+z, x^2+y^2, z+xy
#include "../tests.h"
-using namespace dealii;
template <int dim>
#include "../tests.h"
-using namespace dealii;
// x+y+z, x^2+y^2, z+xy
#include "../tests.h"
-using namespace dealii;
// x+y+z, x^2+y^2, z+xy
#include "../tests.h"
-using namespace dealii;
// x+y+z, x^2+y^2, z+xy
#include "../tests.h"
-using namespace dealii;
// x+y+z, x^2+y^2, z+xy
#include "../tests.h"
-using namespace dealii;
// First dim components:
// f_x = x^2+y(+z), f_y = x^2+y^2, f_z = z+xy
namespace PhaseField
{
- using namespace dealii;
-
typedef Vector<double> vectorType;
#include "../tests.h"
-using namespace dealii;
template <int dim>
void
#include "../tests.h"
-using namespace dealii;
// Test to check whether Zoltan PHG throws warning because
// PHG_EDGE_SIZE_THRESHOLD value is low.
projects / dealii.git / commitdiff