segregated_fsi_solver.h

Go to the documentation of this file.

// LIC// ====================================================================
// LIC// This file forms part of oomph-lib, the object-oriented,
// LIC// multi-physics finite-element library, available
// LIC// at http://www.oomph-lib.org.
// LIC//
// LIC// Copyright (C) 2006-2022 Matthias Heil and Andrew Hazel
// LIC//
// LIC// This library is free software; you can redistribute it and/or
// LIC// modify it under the terms of the GNU Lesser General Public
// LIC// License as published by the Free Software Foundation; either
// LIC// version 2.1 of the License, or (at your option) any later version.
// LIC//
// LIC// This library is distributed in the hope that it will be useful,
// LIC// but WITHOUT ANY WARRANTY; without even the implied warranty of
// LIC// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// LIC// Lesser General Public License for more details.
// LIC//
// LIC// You should have received a copy of the GNU Lesser General Public
// LIC// License along with this library; if not, write to the Free Software
// LIC// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// LIC// 02110-1301  USA.
// LIC//
// LIC// The authors may be contacted at oomph-lib@maths.man.ac.uk.
// LIC//
// LIC//====================================================================
#ifndef OOMPH_SEGREGATED_FSI_SOLVER
#define OOMPH_SEGREGATED_FSI_SOLVER
 
 
#include "../generic/problem.h"
#include "../generic/geom_objects.h"
#include "../generic/mesh.h"
 
namespace oomph
{
  //===============================================================
  //===============================================================
  class PicardConvergenceData
  {
  public:
    PicardConvergenceData()
      : Niter(0),
        CPU_total(0.0),
        Essential_cpu_total(0.0),
        CPU_for_global_residual(0.0),
        Tol_achieved(0.0),
        Has_converged(false)
    {
    }
 
    ~PicardConvergenceData(){};
 
    unsigned& niter()
    {
      return Niter;
    }
 
    double& cpu_total()
    {
      return CPU_total;
    }
 
    double& essential_cpu_total()
    {
      return Essential_cpu_total;
    }
 
    double& cpu_for_global_residual()
    {
      return CPU_for_global_residual;
    }
 
    double& tol_achieved()
    {
      return Tol_achieved;
    }
 
    bool has_converged() const
    {
      return Has_converged;
    }
 
    void set_solver_converged()
    {
      Has_converged = true;
    }
 
    void set_solver_not_converged()
    {
      Has_converged = false;
    }
 
  private:
    unsigned Niter;
 
    double CPU_total;
 
    double Essential_cpu_total;
 
    double CPU_for_global_residual;
 
    double Tol_achieved;
 
    bool Has_converged;
  };
 
 
 
 
  //=======================================================================
  //=======================================================================
  class SegregatedSolverError
  {
  public:
    SegregatedSolverError(const bool& ran_out_of_iterations = false)
    {
      Ran_out_of_iterations = ran_out_of_iterations;
    }
 
    bool Ran_out_of_iterations;
  };
 
 
 
 
  //===============================================================
  //===============================================================
  class SegregatableFSIProblem : public virtual Problem
  {
  protected:
    virtual void actions_before_segregated_solve() {}
 
    virtual void actions_after_segregated_solve() {}
 
    virtual void actions_before_segregated_convergence_check() {}
 
  public:
    SegregatableFSIProblem()
    {
      // Use pointwise Aitken extrapolation?
      Use_pointwise_aitken = false;
 
      // Default: No under-relaxation
      Omega_relax = 1.0;
 
      // Don't use of Irons and Tuck's extrapolation for solid values
      Use_irons_and_tuck_extrapolation = false;
 
      // Start using pointwise Aitken immediately
      Pointwise_aitken_start = 0;
 
      // By default we don't recheck convergence
      Recheck_convergence_after_pointwise_aitken = false;
 
      // Default solve type is full solve
      Solve_type = Full_solve;
 
      // Convergence criterion
      Convergence_criterion = Assess_convergence_based_on_max_global_residual;
 
      // Convergence tolerance (as in global Newton solver)
      Convergence_tolerance = Problem::Newton_solver_tolerance;
 
      // Doc max. global residual during iteration?
      Doc_max_global_residual = false;
 
      // Max. number of Picard iterations
      Max_picard = 50;
 
      // Pointer to Mesh containing only fluid elements -- the elements in this
      // Mesh will be excluded from the assembly process when
      // the solid problem is solved
      Fluid_mesh_pt = 0;
 
      // Pointer to Mesh containing only solid elements -- the elements in this
      // mesh will be excluded from the assembly process when
      // the fluid problem is solved
      Solid_mesh_pt = 0;
 
      // Initialise timer that allows doc of iteration/cpu time
      T_ref = clock();
      T_spent_on_actual_solve = 0.0;
 
      Timer_has_been_halted = false;
    }
 
    virtual ~SegregatableFSIProblem() {}
 
    virtual void identify_fluid_and_solid_dofs(Vector<Data*>& fluid_data_pt,
                                               Vector<Data*>& solid_data_pt,
                                               Mesh*& fluid_mesh_pt,
                                               Mesh*& solid_mesh_pt) = 0;
 
    void setup_segregated_solver(
      const bool& full_setup_of_fluid_and_solid_dofs = true);
 
    PicardConvergenceData segregated_solve();
 
    PicardConvergenceData steady_segregated_solve();
 
 
    PicardConvergenceData unsteady_segregated_solve(const double& dt);
 
 
    PicardConvergenceData unsteady_segregated_solve(const double& dt,
                                                    const bool& shift_values);
 
 
    void assess_convergence_based_on_max_global_residual(const double& tol)
    {
      Convergence_criterion = Assess_convergence_based_on_max_global_residual;
      Convergence_tolerance = tol;
    }
 
    void assess_convergence_based_on_max_global_residual()
    {
      assess_convergence_based_on_max_global_residual(
        Problem::Newton_solver_tolerance);
    }
 
    void assess_convergence_based_on_absolute_solid_change(const double& tol)
    {
      Convergence_criterion = Assess_convergence_based_on_absolute_solid_change;
      Convergence_tolerance = tol;
    }
 
    void assess_convergence_based_on_absolute_solid_change()
    {
      assess_convergence_based_on_absolute_solid_change(
        Problem::Newton_solver_tolerance);
    }
 
    void assess_convergence_based_on_relative_solid_change(const double& tol)
    {
      Convergence_criterion = Assess_convergence_based_on_relative_solid_change;
      Convergence_tolerance = tol;
    }
 
    void assess_convergence_based_on_relative_solid_change()
    {
      assess_convergence_based_on_relative_solid_change(
        Problem::Newton_solver_tolerance);
    }
 
 
    void enable_pointwise_aitken(const unsigned& pointwise_aitken_start)
    {
      Pointwise_aitken_start = pointwise_aitken_start;
      Use_pointwise_aitken = true;
    }
 
    void enable_pointwise_aitken()
    {
      Use_pointwise_aitken = true;
    }
 
    void disable_pointwise_aitken()
    {
      Use_pointwise_aitken = false;
    }
 
    void enable_under_relaxation(const double& omega = 1.0)
    {
      Omega_relax = omega;
    }
 
    void enable_irons_and_tuck_extrapolation()
    {
      Use_irons_and_tuck_extrapolation = true;
    }
 
    void disable_irons_and_tuck_extrapolation()
    {
      Use_irons_and_tuck_extrapolation = false;
    }
 
    enum convergence_criteria
    {
      Assess_convergence_based_on_absolute_solid_change,
      Assess_convergence_based_on_relative_solid_change,
      Assess_convergence_based_on_max_global_residual
    };
 
 
    enum solve_type
    {
      Full_solve,
      Fluid_solve,
      Solid_solve
    };
 
    void get_solid_change(double& rms_change,
                          double& max_change,
                          double& rms_norm);
 
    void store_solid_dofs();
 
    void reset_timer()
    {
      T_spent_on_actual_solve = 0.0;
      T_ref = clock();
      Timer_has_been_halted = false;
    }
 
 
    void restart_timer()
    {
      T_ref = clock();
      Timer_has_been_halted = false;
    }
 
 
    void halt_timer()
    {
      if (!Timer_has_been_halted)
      {
        T_spent_on_actual_solve += double(clock() - T_ref) / CLOCKS_PER_SEC;
        Timer_has_been_halted = true;
      }
    }
 
 
    double t_spent_on_actual_solve()
    {
      halt_timer();
      double time = T_spent_on_actual_solve;
      restart_timer();
      return time;
    }
 
 
  protected:
    void rebuild_monolithic_mesh();
 
    int Pointwise_aitken_counter;
 
    bool Use_pointwise_aitken;
 
    unsigned Pointwise_aitken_start;
 
    int Solve_type;
 
    double Convergence_tolerance;
 
    unsigned Max_picard;
 
    bool Doc_max_global_residual;
 
    void restore_fluid_dofs();
 
    void pin_solid_dofs();
 
    void restore_solid_dofs();
 
 
    void pointwise_aitken_extrapolate();
 
    Vector<Data*> Fluid_data_pt;
 
    Vector<std::vector<bool>> Fluid_value_is_pinned;
 
    Vector<Data*> Solid_data_pt;
 
    Vector<std::vector<bool>> Solid_value_is_pinned;
 
    Vector<double> Previous_solid_value;
 
    Mesh* Fluid_mesh_pt;
 
    Mesh* Solid_mesh_pt;
 
    Vector<Mesh*> Orig_sub_mesh_pt;
 
    Vector<double> Del_irons_and_tuck;
 
    double R_irons_and_tuck;
 
    Vector<Vector<double>> Pointwise_aitken_solid_value;
 
    bool Recheck_convergence_after_pointwise_aitken;
 
  private:
    void extrapolate_solid_data();
 
    void under_relax_solid();
 
    void use_only_fluid_elements();
 
    void use_only_solid_elements();
 
    void pin_fluid_dofs();
 
    double Omega_relax;
 
    bool Use_irons_and_tuck_extrapolation;
 
    int Convergence_criterion;
 
    clock_t T_ref;
 
    double T_spent_on_actual_solve;
 
    bool Timer_has_been_halted;
  };
 
} // namespace oomph
 
 
#endif