poisson_nitsche_interface.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2022 by Luca Heltai
//
// This file is part of the FSI-suite platform, based on the deal.II library.
//
// The FSI-suite platform is free software; you can use it, redistribute it,
// and/or modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 3.0 of the License,
// or (at your option) any later version. The full text of the license can be
// found in the file LICENSE at the top level of the FSI-suite platform
// distribution.
//
// ---------------------------------------------------------------------
 
 
#ifndef pdes_serial_poisson_nitsche_h
#define pdes_serial_poisson_nitsche_h
 
#include <deal.II/base/function.h>
#include <deal.II/base/parameter_acceptor.h>
#include <deal.II/base/parsed_convergence_table.h>
#include <deal.II/base/quadrature_lib.h>
#include <deal.II/base/timer.h>
 
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_tools.h>
 
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_values.h>
 
#include <deal.II/grid/filtered_iterator.h>
#include <deal.II/grid/grid_generator.h>
#include <deal.II/grid/grid_tools.h>
#include <deal.II/grid/grid_tools_cache.h>
#include <deal.II/grid/tria.h>
 
#include <deal.II/lac/affine_constraints.h>
#include <deal.II/lac/dynamic_sparsity_pattern.h>
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/precondition.h>
#include <deal.II/lac/solver_cg.h>
#include <deal.II/lac/sparse_matrix.h>
#include <deal.II/lac/vector.h>
 
#include <deal.II/numerics/data_out.h>
#include <deal.II/numerics/matrix_tools.h>
#include <deal.II/numerics/vector_tools.h>
 
#include <fstream>
#include <iostream>
 
#include "assemble_nitsche_with_exact_intersections.h"
#include "create_coupling_sparsity_pattern_with_exact_intersections.h"
#include "create_nitsche_rhs_with_exact_intersections.h"
#include "parsed_lac/amg.h"
#include "parsed_lac/inverse_operator.h"
#include "parsed_tools/boundary_conditions.h"
#include "parsed_tools/constants.h"
#include "parsed_tools/convergence_table.h"
#include "parsed_tools/data_out.h"
#include "parsed_tools/finite_element.h"
#include "parsed_tools/function.h"
#include "parsed_tools/grid_generator.h"
#include "parsed_tools/grid_refinement.h"
 
namespace PDEs
{
  using namespace dealii;
 
  namespace Serial
  {
    template <int dim, int spacedim = dim>
    class PoissonNitscheInterface : public ParameterAcceptor
    {
    public:
      PoissonNitscheInterface();
 
 
      void
      run();
 
    protected:
      void
      generate_grids();
 
 
      void
 
      setup_system();
 
 
      void
      assemble_system();
 
 
      void
      solve();
 
 
      void
      output_results(const unsigned cycle) const;
 
 
      const std::string component_names = "u";
 
 
      ParsedTools::GridGenerator<spacedim, spacedim> grid_generator;
 
      ParsedTools::GridGenerator<dim, spacedim> embedded_grid_generator;
 
      ParsedTools::GridRefinement grid_refinement;
 
      Triangulation<spacedim, spacedim> space_triangulation;
      Triangulation<dim, spacedim>      embedded_triangulation;
 
      std::unique_ptr<GridTools::Cache<spacedim, spacedim>> space_cache;
      std::unique_ptr<GridTools::Cache<dim, spacedim>>      embedded_cache;
 
      std::vector<std::tuple<
        typename dealii::Triangulation<spacedim, spacedim>::cell_iterator,
        typename dealii::Triangulation<dim, spacedim>::cell_iterator,
        dealii::Quadrature<spacedim>>>
        cells_and_quads;
 
 
      ParsedTools::FiniteElement<spacedim, spacedim> space_fe;
 
      DoFHandler<spacedim, spacedim> space_dh;
 
      std::unique_ptr<Mapping<spacedim, spacedim>> mapping;
      AffineConstraints<double>    space_constraints;
      SparsityPattern              sparsity_pattern;
      SparseMatrix<double>         system_matrix;
      Vector<double>               solution;
      Vector<double>               system_rhs;
      ParsedLAC::InverseOperator   inverse_operator;
      ParsedLAC::AMGPreconditioner preconditioner;
      ParsedTools::Constants constants;
 
      ParsedTools::Function<spacedim> forcing_term;
 
 
      ParsedTools::Function<spacedim> embedded_value;
 
 
      ParsedTools::Function<spacedim> nitsche_coefficient;
 
      ParsedTools::Function<spacedim> exact_solution;
 
 
      ParsedTools::BoundaryConditions<spacedim> boundary_conditions;
 
      mutable TimerOutput timer;
 
 
      ParsedTools::ConvergenceTable error_table;
 
 
 
      mutable ParsedTools::DataOut<spacedim, spacedim> data_out;
 
      unsigned int console_level = 1;
 
 
 
      double penalty = 100.0;
 
 
 
    };
  } // namespace Serial
} // namespace PDEs
#endif