Step40::LaplaceProblem< dim > Class Template Reference

Public Member Functions
	LaplaceProblem ()
void	run ()

Private Member Functions
void	setup_system ()
void	assemble_system ()
void	solve ()
void	refine_grid ()
void	output_results (const unsigned int cycle) const

Private Attributes
MPI_Comm	mpi_communicator
parallel::distributed::Triangulation< dim >	triangulation
FE_Q< dim >	fe
DoFHandler< dim >	dof_handler
IndexSet	locally_owned_dofs
IndexSet	locally_relevant_dofs
AffineConstraints< double >	constraints
LA::MPI::SparseMatrix	system_matrix
LA::MPI::Vector	locally_relevant_solution
LA::MPI::Vector	system_rhs
ConditionalOStream	pcout
TimerOutput	computing_timer

Detailed Description

template<int dim>
class Step40::LaplaceProblem< dim >

Definition at line 77 of file step-40.cc.

Constructor & Destructor Documentation

LaplaceProblem()

template<int dim>

Step40::LaplaceProblem< dim >::LaplaceProblem

Definition at line 120 of file step-40.cc.

    : mpi_communicator(MPI_COMM_WORLD)
    , triangulation(mpi_communicator,
                    typename Triangulation<dim>::MeshSmoothing(
                      Triangulation<dim>::smoothing_on_refinement |
                      Triangulation<dim>::smoothing_on_coarsening))
    , fe(2)
    , dof_handler(triangulation)
    , pcout(std::cout,
            (Utilities::MPI::this_mpi_process(mpi_communicator) == 0))
    , computing_timer(mpi_communicator,
                      pcout,
                      TimerOutput::summary,
                      TimerOutput::wall_times)
  {}

Member Function Documentation

run()

template<int dim>

void Step40::LaplaceProblem< dim >::run

Definition at line 329 of file step-40.cc.

  {
    pcout << "Running with "
#ifdef USE_PETSC_LA
          << "PETSc"
#else
          << "Trilinos"
#endif
          << " on " << Utilities::MPI::n_mpi_processes(mpi_communicator)
          << " MPI rank(s)..." << std::endl;
 
    const unsigned int n_cycles = 8;
    for (unsigned int cycle = 0; cycle < n_cycles; ++cycle)
      {
        pcout << "Cycle " << cycle << ':' << std::endl;
 
        if (cycle == 0)
          {
            GridGenerator::hyper_cube(triangulation);
            triangulation.refine_global(5);
          }
        else
          refine_grid();
 
        setup_system();
 
        pcout << "   Number of active cells:       "
              << triangulation.n_global_active_cells() << std::endl
              << "   Number of degrees of freedom: " << dof_handler.n_dofs()
              << std::endl;
 
        assemble_system();
        solve();
 
        if (Utilities::MPI::n_mpi_processes(mpi_communicator) <= 32)
          {
            TimerOutput::Scope t(computing_timer, "output");
            output_results(cycle);
          }
 
        computing_timer.print_summary();
        computing_timer.reset();
 
        pcout << std::endl;
      }
  }

setup_system()

template<int dim>

void Step40::LaplaceProblem< dim >::setup_system

private

Definition at line 140 of file step-40.cc.

  {
    TimerOutput::Scope t(computing_timer, "setup");
 
    dof_handler.distribute_dofs(fe);
 
    locally_owned_dofs = dof_handler.locally_owned_dofs();
    DoFTools::extract_locally_relevant_dofs(dof_handler, locally_relevant_dofs);
 
    locally_relevant_solution.reinit(locally_owned_dofs,
                                     locally_relevant_dofs,
                                     mpi_communicator);
    system_rhs.reinit(locally_owned_dofs, mpi_communicator);
 
    constraints.clear();
    constraints.reinit(locally_relevant_dofs);
    DoFTools::make_hanging_node_constraints(dof_handler, constraints);
    VectorTools::interpolate_boundary_values(dof_handler,
                                             0,
                                             Functions::ZeroFunction<dim>(),
                                             constraints);
    constraints.close();
 
    DynamicSparsityPattern dsp(locally_relevant_dofs);
 
    DoFTools::make_sparsity_pattern(dof_handler, dsp, constraints, false);
    SparsityTools::distribute_sparsity_pattern(dsp,
                                               dof_handler.locally_owned_dofs(),
                                               mpi_communicator,
                                               locally_relevant_dofs);
 
    system_matrix.reinit(locally_owned_dofs,
                         locally_owned_dofs,
                         dsp,
                         mpi_communicator);
  }

assemble_system()

template<int dim>

void Step40::LaplaceProblem< dim >::assemble_system

private

Definition at line 181 of file step-40.cc.

  {
    TimerOutput::Scope t(computing_timer, "assembly");
 
    const QGauss<dim> quadrature_formula(fe.degree + 1);
 
    FEValues<dim> fe_values(fe,
                            quadrature_formula,
                            update_values | update_gradients |
                              update_quadrature_points | update_JxW_values);
 
    const unsigned int dofs_per_cell = fe.n_dofs_per_cell();
    const unsigned int n_q_points    = quadrature_formula.size();
 
    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())
      if (cell->is_locally_owned())
        {
          cell_matrix = 0.;
          cell_rhs    = 0.;
 
          fe_values.reinit(cell);
 
          for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
            {
              const double rhs_value =
                (fe_values.quadrature_point(q_point)[1] >
                     0.5 +
                       0.25 * std::sin(4.0 * numbers::PI *
                                       fe_values.quadrature_point(q_point)[0]) ?
                   1. :
                   -1.);
 
              for (unsigned int i = 0; i < dofs_per_cell; ++i)
                {
                  for (unsigned int j = 0; j < dofs_per_cell; ++j)
                    cell_matrix(i, j) += fe_values.shape_grad(i, q_point) *
                                         fe_values.shape_grad(j, q_point) *
                                         fe_values.JxW(q_point);
 
                  cell_rhs(i) += rhs_value * fe_values.shape_value(i, q_point) *
                                 fe_values.JxW(q_point);
                }
            }
 
          cell->get_dof_indices(local_dof_indices);
          constraints.distribute_local_to_global(cell_matrix,
                                                 cell_rhs,
                                                 local_dof_indices,
                                                 system_matrix,
                                                 system_rhs);
        }
 
    system_matrix.compress(VectorOperation::add);
    system_rhs.compress(VectorOperation::add);
  }

solve()

template<int dim>

void Step40::LaplaceProblem< dim >::solve

private

Definition at line 246 of file step-40.cc.

  {
    TimerOutput::Scope t(computing_timer, "solve");
    LA::MPI::Vector    completely_distributed_solution(locally_owned_dofs,
                                                    mpi_communicator);
 
    SolverControl solver_control(dof_handler.n_dofs(), 1e-12);
 
#ifdef USE_PETSC_LA
    LA::SolverCG solver(solver_control, mpi_communicator);
#else
    LA::SolverCG solver(solver_control);
#endif
 
    LA::MPI::PreconditionAMG preconditioner;
 
    LA::MPI::PreconditionAMG::AdditionalData data;
 
#ifdef USE_PETSC_LA
    data.symmetric_operator = true;
#else
    /* Trilinos defaults are good */
#endif
    preconditioner.initialize(system_matrix, data);
 
    solver.solve(system_matrix,
                 completely_distributed_solution,
                 system_rhs,
                 preconditioner);
 
    pcout << "   Solved in " << solver_control.last_step() << " iterations."
          << std::endl;
 
    constraints.distribute(completely_distributed_solution);
 
    locally_relevant_solution = completely_distributed_solution;
  }

refine_grid()

template<int dim>

void Step40::LaplaceProblem< dim >::refine_grid

private

Definition at line 288 of file step-40.cc.

  {
    TimerOutput::Scope t(computing_timer, "refine");
 
    Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
    KellyErrorEstimator<dim>::estimate(
      dof_handler,
      QGauss<dim - 1>(fe.degree + 1),
      std::map<types::boundary_id, const Function<dim> *>(),
      locally_relevant_solution,
      estimated_error_per_cell);
    parallel::distributed::GridRefinement::refine_and_coarsen_fixed_number(
      triangulation, estimated_error_per_cell, 0.3, 0.03);
    triangulation.execute_coarsening_and_refinement();
  }

output_results()

template<int dim>

void Step40::LaplaceProblem< dim >::output_results ( const unsigned int  cycle ) const

private

Definition at line 308 of file step-40.cc.

  {
    DataOut<dim> data_out;
    data_out.attach_dof_handler(dof_handler);
    data_out.add_data_vector(locally_relevant_solution, "u");
 
    Vector<float> subdomain(triangulation.n_active_cells());
    for (unsigned int i = 0; i < subdomain.size(); ++i)
      subdomain(i) = triangulation.locally_owned_subdomain();
    data_out.add_data_vector(subdomain, "subdomain");
 
    data_out.build_patches();
 
    data_out.write_vtu_with_pvtu_record(
      "./", "solution", cycle, mpi_communicator, 2, 8);
  }

Member Data Documentation

mpi_communicator

template<int dim>

MPI_Comm Step40::LaplaceProblem< dim >::mpi_communicator

private

Definition at line 97 of file step-40.cc.

triangulation

template<int dim>

parallel::distributed::Triangulation<dim> Step40::LaplaceProblem< dim >::triangulation

private

Definition at line 99 of file step-40.cc.

fe

template<int dim>

FE_Q<dim> Step40::LaplaceProblem< dim >::fe

private

Definition at line 101 of file step-40.cc.

dof_handler

template<int dim>

DoFHandler<dim> Step40::LaplaceProblem< dim >::dof_handler

private

Definition at line 102 of file step-40.cc.

locally_owned_dofs

template<int dim>

IndexSet Step40::LaplaceProblem< dim >::locally_owned_dofs

private

Definition at line 104 of file step-40.cc.

locally_relevant_dofs

template<int dim>

IndexSet Step40::LaplaceProblem< dim >::locally_relevant_dofs

private

Definition at line 105 of file step-40.cc.

constraints

template<int dim>

AffineConstraints<double> Step40::LaplaceProblem< dim >::constraints

private

Definition at line 107 of file step-40.cc.

system_matrix

template<int dim>

LA::MPI::SparseMatrix Step40::LaplaceProblem< dim >::system_matrix

private

Definition at line 109 of file step-40.cc.

locally_relevant_solution

template<int dim>

LA::MPI::Vector Step40::LaplaceProblem< dim >::locally_relevant_solution

private

Definition at line 110 of file step-40.cc.

system_rhs

template<int dim>

LA::MPI::Vector Step40::LaplaceProblem< dim >::system_rhs

private

Definition at line 111 of file step-40.cc.

pcout

template<int dim>

ConditionalOStream Step40::LaplaceProblem< dim >::pcout

private

Definition at line 113 of file step-40.cc.

computing_timer

template<int dim>

TimerOutput Step40::LaplaceProblem< dim >::computing_timer

private

Definition at line 114 of file step-40.cc.

---

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

• labs/lab-06/source/step-40.cc