Poisson< dim > Class Template Reference

Solve the Poisson problem, with Dirichlet or Neumann boundary conditions, on all geometries that can be generated by the functions in the GridGenerator namespace. More...

#include <poisson.h>

Inheritance diagram for Poisson< dim >:

Public Types
using	CopyData = MeshWorker::CopyData< 1, 1, 1 >
using	ScratchData = MeshWorker::ScratchData< dim >

Public Member Functions
	Poisson ()
void	run ()
	Poisson ()
void	run ()
void	initialize (const std::string &filename)
void	parse_string (const std::string &par)
	Poisson ()
	Constructor. More...
void	print_system_info ()
void	run ()
void	initialize (const std::string &filename)
void	parse_string (const std::string &par)

Protected Member Functions
void	make_grid ()
void	setup_system ()
void	assemble_system ()
void	solve ()
void	output_results () const
void	make_grid ()
void	refine_grid ()
void	setup_system ()
void	assemble_system ()
void	solve ()
void	output_results (const unsigned cycle) const
void	assemble_system_one_cell (const typename DoFHandler< dim >::active_cell_iterator &cell, ScratchData &scratch, CopyData &copy)
void	copy_one_cell (const CopyData &copy)
void	make_grid ()
void	refine_grid ()
void	setup_system ()
void	assemble_system ()
void	assemble_system_on_range (const typename DoFHandler< dim >::active_cell_iterator &begin, const typename DoFHandler< dim >::active_cell_iterator &end)
void	solve ()
void	estimate ()
void	mark ()
void	output_results (const unsigned cycle) const

Protected Attributes
Triangulation< 2 >	triangulation
FE_Q< 2 >	fe
DoFHandler< 2 >	dof_handler
SparsityPattern	sparsity_pattern
SparseMatrix< double >	system_matrix
Vector< double >	solution
Vector< double >	system_rhs
Triangulation< dim >	triangulation
std::unique_ptr< FE_Q< dim > >	fe
DoFHandler< dim >	dof_handler
AffineConstraints< double >	constraints
FunctionParser< dim >	forcing_term
FunctionParser< dim >	dirichlet_boundary_condition
FunctionParser< dim >	neumann_boundary_condition
unsigned int	fe_degree = 1
unsigned int	n_refinements = 4
unsigned int	n_refinement_cycles = 1
std::string	output_filename = "poisson"
std::set< types::boundary_id >	dirichlet_ids = {0}
std::set< types::boundary_id >	neumann_ids
std::string	forcing_term_expression = "1"
std::string	dirichlet_boundary_conditions_expression = "0"
std::string	neumann_boundary_conditions_expression = "0"
std::map< std::string, double >	constants
std::string	grid_generator_function = "hyper_cube"
std::string	grid_generator_arguments = "0: 1: false"
ParsedConvergenceTable	error_table
MPI_Comm	mpi_communicator
ConditionalOStream	pcout
TimerOutput	timer
parallel::distributed::Triangulation< dim >	triangulation
std::unique_ptr< MappingQGeneric< dim > >	mapping
IndexSet	locally_owned_dofs
IndexSet	locally_relevant_dofs
LA::MPI::SparseMatrix	system_matrix
LA::MPI::Vector	locally_relevant_solution
LA::MPI::Vector	solution
LA::MPI::Vector	system_rhs
Vector< float >	error_per_cell
std::string	estimator_type = "exact"
std::string	marking_strategy = "global"
std::pair< double, double >	coarsening_and_refinement_factors = {0.03, 0.3}
FunctionParser< dim >	coefficient
FunctionParser< dim >	exact_solution
FunctionParser< dim >	pre_refinement
unsigned int	mapping_degree = 1
int	number_of_threads = -1
std::string	coefficient_expression = "1"
std::string	exact_solution_expression = "0"
std::string	pre_refinement_expression = "0"
bool	use_direct_solver = true
ParameterAcceptorProxy< ReductionControl >	solver_control

Friends
class	PoissonTester

Detailed Description

template<int dim>
class Poisson< dim >

Solve the Poisson problem, with Dirichlet or Neumann boundary conditions, on all geometries that can be generated by the functions in the GridGenerator namespace.

Definition at line 55 of file poisson.h.

Member Typedef Documentation

CopyData

template<int dim>

using Poisson< dim >::CopyData = MeshWorker::CopyData<1, 1, 1>

Definition at line 113 of file poisson.h.

ScratchData

template<int dim>

using Poisson< dim >::ScratchData = MeshWorker::ScratchData<dim>

Definition at line 114 of file poisson.h.

Constructor & Destructor Documentation

Poisson() [1/3]

template<int dim>

Poisson< dim >::Poisson

Definition at line 24 of file poisson.cc.

  : fe(1)
  , dof_handler(triangulation)
{}

Poisson() [2/3]

template<int dim>

Poisson< dim >::Poisson

(

)

Poisson() [3/3]

template<int dim>

Poisson< dim >::Poisson

(

)

Constructor.

Initialize all parameters, and make sure the class is ready to run.

Member Function Documentation

run() [1/3]

template<int dim>

void Poisson< dim >::run

Definition at line 133 of file poisson.cc.

{
  make_grid();
  setup_system();
  assemble_system();
  solve();
  output_results();
}

make_grid() [1/3]

template<int dim>

void Poisson< dim >::make_grid

protected

Definition at line 32 of file poisson.cc.

{
  GridGenerator::hyper_cube(triangulation, -1, 1);
  triangulation.refine_global(5);
  std::cout << "Number of active cells: " << triangulation.n_active_cells()
            << std::endl;
}

setup_system() [1/3]

template<int dim>

void Poisson< dim >::setup_system

protected

Definition at line 43 of file poisson.cc.

{
  dof_handler.distribute_dofs(fe);
  std::cout << "Number of degrees of freedom: " << dof_handler.n_dofs()
            << std::endl;
  DynamicSparsityPattern dsp(dof_handler.n_dofs());
  DoFTools::make_sparsity_pattern(dof_handler, dsp);
  sparsity_pattern.copy_from(dsp);
  system_matrix.reinit(sparsity_pattern);
  solution.reinit(dof_handler.n_dofs());
  system_rhs.reinit(dof_handler.n_dofs());
}

assemble_system() [1/3]

template<int dim>

void Poisson< dim >::assemble_system

protected

Definition at line 59 of file poisson.cc.

{
  QGauss<2>          quadrature_formula(fe.degree + 1);
  FEValues<2>        fe_values(fe,
                        quadrature_formula,
                        update_values | update_gradients | update_JxW_values);
  const unsigned int dofs_per_cell = fe.n_dofs_per_cell();
  FullMatrix<double> cell_matrix(dofs_per_cell, dofs_per_cell);
  Vector<double>     cell_rhs(dofs_per_cell);
  std::vector<types::global_dof_index> local_dof_indices(dofs_per_cell);
  for (const auto &cell : dof_handler.active_cell_iterators())
    {
      fe_values.reinit(cell);
      cell_matrix = 0;
      cell_rhs    = 0;
      for (const unsigned int q_index : fe_values.quadrature_point_indices())
        {
          for (const unsigned int i : fe_values.dof_indices())
            for (const unsigned int j : fe_values.dof_indices())
              cell_matrix(i, j) +=
                (fe_values.shape_grad(i, q_index) * // grad phi_i(x_q)
                 fe_values.shape_grad(j, q_index) * // grad phi_j(x_q)
                 fe_values.JxW(q_index));           // dx
          for (const unsigned int i : fe_values.dof_indices())
            cell_rhs(i) += (fe_values.shape_value(i, q_index) * // phi_i(x_q)
                            1. *                                // f(x_q)
                            fe_values.JxW(q_index));            // dx
        }
      cell->get_dof_indices(local_dof_indices);
      for (const unsigned int i : fe_values.dof_indices())
        for (const unsigned int j : fe_values.dof_indices())
          system_matrix.add(local_dof_indices[i],
                            local_dof_indices[j],
                            cell_matrix(i, j));
      for (const unsigned int i : fe_values.dof_indices())
        system_rhs(local_dof_indices[i]) += cell_rhs(i);
    }
  std::map<types::global_dof_index, double> boundary_values;
  VectorTools::interpolate_boundary_values(dof_handler,
                                           0,
                                           Functions::ZeroFunction<2>(),
                                           boundary_values);
  MatrixTools::apply_boundary_values(boundary_values,
                                     system_matrix,
                                     solution,
                                     system_rhs);
}

solve() [1/3]

template<int dim>

void Poisson< dim >::solve

protected

Definition at line 110 of file poisson.cc.

{
  SolverControl            solver_control(1000, 1e-12);
  SolverCG<Vector<double>> solver(solver_control);
  solver.solve(system_matrix, solution, system_rhs, PreconditionIdentity());
}

output_results() [1/3]

template<int dim>

void Poisson< dim >::output_results ( ) const

protected

Definition at line 120 of file poisson.cc.

{
  DataOut<2> data_out;
  data_out.attach_dof_handler(dof_handler);
  data_out.add_data_vector(solution, "solution");
  data_out.build_patches();
  std::ofstream output("solution.vtk");
  data_out.write_vtk(output);
}

run() [2/3]

template<int dim>

void Poisson< dim >::run

(

)

initialize() [1/2]

template<int dim>

void Poisson< dim >::initialize

(

const std::string &

filename

)

Definition at line 53 of file poisson.cc.

{
  ParameterAcceptor::initialize(filename);
}

parse_string() [1/2]

template<int dim>

void Poisson< dim >::parse_string

(

const std::string &

par

)

Definition at line 62 of file poisson.cc.

{
  ParameterAcceptor::prm.parse_input_from_string(parameters);
  ParameterAcceptor::parse_all_parameters();
}

make_grid() [2/3]

template<int dim>

void Poisson< dim >::make_grid ( )

protected

refine_grid() [1/2]

template<int dim>

void Poisson< dim >::refine_grid

protected

Definition at line 86 of file poisson.cc.

{
  triangulation.refine_global(1);
}

setup_system() [2/3]

template<int dim>

void Poisson< dim >::setup_system ( )

protected

assemble_system() [2/3]

template<int dim>

void Poisson< dim >::assemble_system ( )

protected

solve() [2/3]

template<int dim>

void Poisson< dim >::solve ( )

protected

output_results() [2/3]

template<int dim>

void Poisson< dim >::output_results ( const unsigned  cycle ) const

protected

Definition at line 223 of file poisson.cc.

{
  DataOut<dim> data_out;
  data_out.attach_dof_handler(dof_handler);
  data_out.add_data_vector(solution, "solution");
  data_out.build_patches();
  std::string   fname = output_filename + "_" + std::to_string(cycle) + ".vtu";
  std::ofstream output(fname);
  data_out.write_vtu(output);
}

print_system_info()

template<int dim>

void Poisson< dim >::print_system_info

Definition at line 550 of file poisson.cc.

{
  if (number_of_threads != -1 && number_of_threads > 0)
    MultithreadInfo::set_thread_limit(
      static_cast<unsigned int>(number_of_threads));
 
  std::cout << "Number of cores  : " << MultithreadInfo::n_cores() << std::endl
            << "Number of threads: " << MultithreadInfo::n_threads()
            << std::endl;
}

run() [3/3]

template<int dim>

void Poisson< dim >::run

(

)

initialize() [2/2]

template<int dim>

void Poisson< dim >::initialize

(

const std::string &

filename

)

parse_string() [2/2]

template<int dim>

void Poisson< dim >::parse_string

(

const std::string &

par

)

assemble_system_one_cell()

template<int dim>

void Poisson< dim >::assemble_system_one_cell ( const typename DoFHandler< dim >::active_cell_iterator &  cell, ScratchData &  scratch, CopyData &  copy  )

protected

Definition at line 226 of file poisson.cc.

{
  auto &cell_matrix = copy.matrices[0];
  auto &cell_rhs    = copy.vectors[0];
 
  cell->get_dof_indices(copy.local_dof_indices[0]);
 
  const auto &fe_values = scratch.reinit(cell);
  cell_matrix           = 0;
  cell_rhs              = 0;
 
  for (const unsigned int q_index : fe_values.quadrature_point_indices())
    {
      for (const unsigned int i : fe_values.dof_indices())
        for (const unsigned int j : fe_values.dof_indices())
          cell_matrix(i, j) +=
            (coefficient.value(fe_values.quadrature_point(q_index)) * // a(x_q)
             fe_values.shape_grad(i, q_index) * // grad phi_i(x_q)
             fe_values.shape_grad(j, q_index) * // grad phi_j(x_q)
             fe_values.JxW(q_index));           // dx
      for (const unsigned int i : fe_values.dof_indices())
        cell_rhs(i) +=
          (fe_values.shape_value(i, q_index) * // phi_i(x_q)
           forcing_term.value(fe_values.quadrature_point(q_index)) * // f(x_q)
           fe_values.JxW(q_index));                                  // dx
    }
 
  if (cell->at_boundary())
    //  for(const auto face: cell->face_indices())
    for (unsigned int f = 0; f < GeometryInfo<dim>::faces_per_cell; ++f)
      if (neumann_ids.find(cell->face(f)->boundary_id()) != neumann_ids.end())
        {
          auto &fe_face_values = scratch.reinit(cell, f);
          for (const unsigned int q_index :
               fe_face_values.quadrature_point_indices())
            for (const unsigned int i : fe_face_values.dof_indices())
              cell_rhs(i) += fe_face_values.shape_value(i, q_index) *
                             neumann_boundary_condition.value(
                               fe_face_values.quadrature_point(q_index)) *
                             fe_face_values.JxW(q_index);
        }
}

copy_one_cell()

template<int dim>

void Poisson< dim >::copy_one_cell ( const CopyData &  copy )

protected

Definition at line 276 of file poisson.cc.

{
  constraints.distribute_local_to_global(copy.matrices[0],
                                         copy.vectors[0],
                                         copy.local_dof_indices[0],
                                         system_matrix,
                                         system_rhs);
}

make_grid() [3/3]

template<int dim>

void Poisson< dim >::make_grid ( )

protected

refine_grid() [2/2]

template<int dim>

void Poisson< dim >::refine_grid ( )

protected

setup_system() [3/3]

template<int dim>

void Poisson< dim >::setup_system ( )

protected

assemble_system() [3/3]

template<int dim>

void Poisson< dim >::assemble_system ( )

protected

assemble_system_on_range()

template<int dim>

void Poisson< dim >::assemble_system_on_range ( const typename DoFHandler< dim >::active_cell_iterator &  begin, const typename DoFHandler< dim >::active_cell_iterator &  end  )

protected

Definition at line 289 of file poisson.cc.

{
  QGauss<dim>     quadrature_formula(fe->degree + 1);
  QGauss<dim - 1> face_quadrature_formula(fe->degree + 1);
 
  ScratchData scratch(*mapping,
                      *fe,
                      quadrature_formula,
                      update_values | update_gradients |
                        update_quadrature_points | update_JxW_values,
                      face_quadrature_formula,
                      update_values | update_quadrature_points |
                        update_JxW_values);
 
  CopyData copy(fe->n_dofs_per_cell());
 
  static Threads::Mutex assemble_mutex;
 
  for (auto cell = begin; cell != end; ++cell)
    {
      assemble_system_one_cell(cell, scratch, copy);
      assemble_mutex.lock();
      copy_one_cell(copy);
      assemble_mutex.unlock();
    }
}

solve() [3/3]

template<int dim>

void Poisson< dim >::solve ( )

protected

estimate()

template<int dim>

void Poisson< dim >::estimate

protected

Definition at line 380 of file poisson.cc.

{
  TimerOutput::Scope timer_section(timer, "estimate");
  if (estimator_type == "exact")
    {
      error_per_cell = 0;
      QGauss<dim> quad(fe->degree + 1);
      VectorTools::integrate_difference(*mapping,
                                        dof_handler,
                                        locally_relevant_solution,
                                        exact_solution,
                                        error_per_cell,
                                        quad,
                                        VectorTools::H1_seminorm);
    }
  else if (estimator_type == "kelly")
    {
      std::map<types::boundary_id, const Function<dim> *> neumann;
      for (const auto id : neumann_ids)
        neumann[id] = &neumann_boundary_condition;
 
      QGauss<dim - 1> face_quad(fe->degree + 1);
      KellyErrorEstimator<dim>::estimate(*mapping,
                                         dof_handler,
                                         face_quad,
                                         neumann,
                                         locally_relevant_solution,
                                         error_per_cell,
                                         ComponentMask(),
                                         &coefficient);
    }
  else if (estimator_type == "residual")
    {
      // h_T || f+\Delta u_h ||_0,T
      // + \sum over faces
      // 1/2 (h_F)^{1/2} || [n.\nabla u_h] ||_0,F
 
      QGauss<dim - 1> face_quad(fe->degree + 1);
      QGauss<dim>     quad(fe->degree + 1);
 
      std::map<types::boundary_id, const Function<dim> *> neumann;
      for (const auto id : neumann_ids)
        neumann[id] = &neumann_boundary_condition;
 
      KellyErrorEstimator<dim>::estimate(*mapping,
                                         dof_handler,
                                         face_quad,
                                         neumann,
                                         locally_relevant_solution,
                                         error_per_cell,
                                         ComponentMask(),
                                         &coefficient);
 
      FEValues<dim> fe_values(*mapping,
                              *fe,
                              quad,
                              update_hessians | update_JxW_values |
                                update_quadrature_points);
 
      std::vector<double> local_laplacians(quad.size());
 
 
      double residual_L2_norm = 0;
 
      unsigned int cell_index = 0;
      for (const auto &cell : dof_handler.active_cell_iterators())
        {
          fe_values.reinit(cell);
 
          fe_values.get_function_laplacians(locally_relevant_solution,
                                            local_laplacians);
          residual_L2_norm = 0;
          for (const auto q_index : fe_values.quadrature_point_indices())
            {
              const auto arg =
                (local_laplacians[q_index] +
                 forcing_term.value(fe_values.quadrature_point(q_index)));
              residual_L2_norm += arg * arg * fe_values.JxW(q_index);
            }
          error_per_cell[cell_index] +=
            cell->diameter() * std::sqrt(residual_L2_norm);
 
          ++cell_index;
        }
    }
  else
    {
      AssertThrow(false, ExcNotImplemented());
    }
  auto global_estimator = error_per_cell.l2_norm();
  error_table.add_extra_column("estimator", [global_estimator]() {
    return global_estimator;
  });
  error_table.error_from_exact(*mapping,
                               dof_handler,
                               locally_relevant_solution,
                               exact_solution);
}

mark()

template<int dim>

void Poisson< dim >::mark

protected

Definition at line 483 of file poisson.cc.

{
  TimerOutput::Scope timer_section(timer, "mark");
  if (marking_strategy == "global")
    {
      for (const auto &cell : triangulation.active_cell_iterators())
        cell->set_refine_flag();
    }
  else if (marking_strategy == "fixed_fraction")
    {
      parallel::distributed::GridRefinement::refine_and_coarsen_fixed_fraction(
        triangulation,
        error_per_cell,
        coarsening_and_refinement_factors.second,
        coarsening_and_refinement_factors.first);
    }
  else if (marking_strategy == "fixed_number")
    {
      parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number(
        triangulation,
        error_per_cell,
        coarsening_and_refinement_factors.second,
        coarsening_and_refinement_factors.first);
    }
  else
    {
      Assert(false, ExcInternalError());
    }
}

output_results() [3/3]

template<int dim>

void Poisson< dim >::output_results ( const unsigned  cycle ) const

protected

Friends And Related Function Documentation

PoissonTester

template<typename Integral >

PoissonTester

friend

Definition at line 82 of file poisson.h.

Member Data Documentation

triangulation [1/3]

template<int dim>

Triangulation<2> Poisson< dim >::triangulation

protected

Definition at line 74 of file poisson.h.

fe [1/2]

template<int dim>

std::unique_ptr< FE_Q< dim > > Poisson< dim >::fe

protected

Definition at line 75 of file poisson.h.

dof_handler [1/2]

template<int dim>

DoFHandler< dim > Poisson< dim >::dof_handler

protected

Definition at line 76 of file poisson.h.

sparsity_pattern

template<int dim>

SparsityPattern Poisson< dim >::sparsity_pattern

protected

Definition at line 77 of file poisson.h.

system_matrix [1/2]

template<int dim>

SparseMatrix< double > Poisson< dim >::system_matrix

protected

Definition at line 78 of file poisson.h.

solution [1/2]

template<int dim>

Vector< double > Poisson< dim >::solution

protected

Definition at line 79 of file poisson.h.

system_rhs [1/2]

template<int dim>

Vector< double > Poisson< dim >::system_rhs

protected

Definition at line 80 of file poisson.h.

triangulation [2/3]

template<int dim>

Triangulation<dim> Poisson< dim >::triangulation

protected

Definition at line 89 of file poisson.h.

fe [2/2]

template<int dim>

std::unique_ptr<FE_Q<dim> > Poisson< dim >::fe

protected

Definition at line 90 of file poisson.h.

dof_handler [2/2]

template<int dim>

DoFHandler<dim> Poisson< dim >::dof_handler

protected

Definition at line 91 of file poisson.h.

constraints

template<int dim>

AffineConstraints< double > Poisson< dim >::constraints

protected

Definition at line 92 of file poisson.h.

forcing_term

template<int dim>

FunctionParser< dim > Poisson< dim >::forcing_term

protected

Definition at line 98 of file poisson.h.

dirichlet_boundary_condition

template<int dim>

FunctionParser< dim > Poisson< dim >::dirichlet_boundary_condition

protected

Definition at line 99 of file poisson.h.

neumann_boundary_condition

template<int dim>

FunctionParser< dim > Poisson< dim >::neumann_boundary_condition

protected

Definition at line 100 of file poisson.h.

fe_degree

template<int dim>

unsigned int Poisson< dim >::fe_degree = 1

protected

Definition at line 103 of file poisson.h.

n_refinements

template<int dim>

unsigned int Poisson< dim >::n_refinements = 4

protected

Definition at line 104 of file poisson.h.

n_refinement_cycles

template<int dim>

unsigned int Poisson< dim >::n_refinement_cycles = 1

protected

Definition at line 105 of file poisson.h.

output_filename

template<int dim>

std::string Poisson< dim >::output_filename = "poisson"

protected

Definition at line 106 of file poisson.h.

dirichlet_ids

template<int dim>

std::set< types::boundary_id > Poisson< dim >::dirichlet_ids = {0}

protected

Definition at line 108 of file poisson.h.

neumann_ids

template<int dim>

std::set< types::boundary_id > Poisson< dim >::neumann_ids

protected

Definition at line 109 of file poisson.h.

forcing_term_expression

template<int dim>

std::string Poisson< dim >::forcing_term_expression = "1"

protected

Definition at line 111 of file poisson.h.

dirichlet_boundary_conditions_expression

template<int dim>

std::string Poisson< dim >::dirichlet_boundary_conditions_expression = "0"

protected

Definition at line 112 of file poisson.h.

neumann_boundary_conditions_expression

template<int dim>

std::string Poisson< dim >::neumann_boundary_conditions_expression = "0"

protected

Definition at line 113 of file poisson.h.

constants

template<int dim>

std::map< std::string, double > Poisson< dim >::constants

protected

Definition at line 114 of file poisson.h.

grid_generator_function

template<int dim>

std::string Poisson< dim >::grid_generator_function = "hyper_cube"

protected

Definition at line 116 of file poisson.h.

grid_generator_arguments

template<int dim>

std::string Poisson< dim >::grid_generator_arguments = "0: 1: false"

protected

Definition at line 117 of file poisson.h.

error_table

template<int dim>

ParsedConvergenceTable Poisson< dim >::error_table

protected

Definition at line 119 of file poisson.h.

mpi_communicator

template<int dim>

MPI_Comm Poisson< dim >::mpi_communicator

protected

Definition at line 153 of file poisson.h.

pcout

template<int dim>

ConditionalOStream Poisson< dim >::pcout

protected

Definition at line 155 of file poisson.h.

timer

template<int dim>

TimerOutput Poisson< dim >::timer

mutableprotected

Definition at line 156 of file poisson.h.

triangulation [3/3]

template<int dim>

parallel::distributed::Triangulation<dim> Poisson< dim >::triangulation

protected

Definition at line 158 of file poisson.h.

mapping

template<int dim>

std::unique_ptr<MappingQGeneric<dim> > Poisson< dim >::mapping

protected

Definition at line 160 of file poisson.h.

locally_owned_dofs

template<int dim>

IndexSet Poisson< dim >::locally_owned_dofs

protected

Definition at line 165 of file poisson.h.

locally_relevant_dofs

template<int dim>

IndexSet Poisson< dim >::locally_relevant_dofs

protected

Definition at line 166 of file poisson.h.

system_matrix [2/2]

template<int dim>

LA::MPI::SparseMatrix Poisson< dim >::system_matrix

protected

Definition at line 168 of file poisson.h.

locally_relevant_solution

template<int dim>

LA::MPI::Vector Poisson< dim >::locally_relevant_solution

protected

Definition at line 169 of file poisson.h.

solution [2/2]

template<int dim>

LA::MPI::Vector Poisson< dim >::solution

protected

Definition at line 170 of file poisson.h.

system_rhs [2/2]

template<int dim>

LA::MPI::Vector Poisson< dim >::system_rhs

protected

Definition at line 171 of file poisson.h.

error_per_cell

template<int dim>

Vector<float> Poisson< dim >::error_per_cell

protected

Definition at line 174 of file poisson.h.

estimator_type

template<int dim>

std::string Poisson< dim >::estimator_type = "exact"

protected

Definition at line 175 of file poisson.h.

marking_strategy

template<int dim>

std::string Poisson< dim >::marking_strategy = "global"

protected

Definition at line 176 of file poisson.h.

coarsening_and_refinement_factors

template<int dim>

std::pair<double, double> Poisson< dim >::coarsening_and_refinement_factors = {0.03, 0.3}

protected

Definition at line 177 of file poisson.h.

coefficient

template<int dim>

FunctionParser<dim> Poisson< dim >::coefficient

protected

Definition at line 181 of file poisson.h.

exact_solution

template<int dim>

FunctionParser<dim> Poisson< dim >::exact_solution

protected

Definition at line 182 of file poisson.h.

pre_refinement

template<int dim>

FunctionParser<dim> Poisson< dim >::pre_refinement

protected

Definition at line 185 of file poisson.h.

mapping_degree

template<int dim>

unsigned int Poisson< dim >::mapping_degree = 1

protected

Definition at line 189 of file poisson.h.

number_of_threads

template<int dim>

int Poisson< dim >::number_of_threads = -1

protected

Definition at line 193 of file poisson.h.

coefficient_expression

template<int dim>

std::string Poisson< dim >::coefficient_expression = "1"

protected

Definition at line 199 of file poisson.h.

exact_solution_expression

template<int dim>

std::string Poisson< dim >::exact_solution_expression = "0"

protected

Definition at line 200 of file poisson.h.

pre_refinement_expression

template<int dim>

std::string Poisson< dim >::pre_refinement_expression = "0"

protected

Definition at line 203 of file poisson.h.

use_direct_solver

template<int dim>

bool Poisson< dim >::use_direct_solver = true

protected

Definition at line 211 of file poisson.h.

solver_control

template<int dim>

ParameterAcceptorProxy<ReductionControl> Poisson< dim >::solver_control

protected

Definition at line 213 of file poisson.h.

---

The documentation for this class was generated from the following files:

• labs/lab-04/include/poisson.h
• labs/lab-04/source/poisson.cc