lagrange_enforced_flow_preconditioner.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_LAGRANGE_ENFORCED_FLOW_PRECONDITIONERS_HEADER
#define OOMPH_LAGRANGE_ENFORCED_FLOW_PRECONDITIONERS_HEADER
 
 
// Config header generated by autoconfig
#ifdef HAVE_CONFIG_H
#include <oomph-lib-config.h>
#endif
 
// oomphlib headers
#include "../generic/matrices.h"
#include "../generic/assembly_handler.h"
#include "../generic/problem.h"
#include "../generic/block_preconditioner.h"
#include "../generic/preconditioner.h"
#include "../generic/SuperLU_preconditioner.h"
#include "../generic/matrix_vector_product.h"
#include "../generic/general_purpose_preconditioners.h"
#include "../generic/general_purpose_block_preconditioners.h"
#ifdef OOMPH_HAS_HYPRE
#include "../generic/hypre_solver.h"
#endif
#ifdef OOMPH_HAS_TRILINOS
#include "../generic/trilinos_solver.h"
#endif
 
namespace oomph
{
  //==========================================================================
  //==========================================================================
  namespace Lagrange_Enforced_Flow_Preconditioner_Subsidiary_Operator_Helper
  {
    extern Preconditioner* get_w_cg_preconditioner();
 
    extern Preconditioner* boomer_amg_for_2D_momentum_simple_visc();
 
    extern Preconditioner* boomer_amg_for_2D_momentum_stressdiv_visc();
 
    extern Preconditioner* boomer_amg_for_3D_momentum();
 
    extern Preconditioner* boomer_amg2v22_for_3D_momentum();
 
    extern Preconditioner* boomer_amg_for_2D_poisson_problem();
 
    extern Preconditioner* boomer_amg_for_3D_poisson_problem();
 
  } // namespace
    // Lagrange_Enforced_Flow_Preconditioner_Subsidiary_Operator_Helper
 
 
  //==========================================================================
  //==========================================================================
  class LagrangeEnforcedFlowPreconditioner
    : public BlockPreconditioner<CRDoubleMatrix>
  {
  public:
    typedef Preconditioner* (*SubsidiaryPreconditionerFctPt)();
 
    LagrangeEnforcedFlowPreconditioner() : BlockPreconditioner<CRDoubleMatrix>()
    {
      // The null pointer.
      Navier_stokes_preconditioner_pt = 0;
 
      // By default, the linear systems associated with the diagonal blocks
      // are solved "exactly" using SuperLU (in its incarnation as an exact
      // preconditioner. This is not a block preconditioner.
      Navier_stokes_preconditioner_is_block_preconditioner = false;
 
      // Flag to indicate to use SuperLU or not.
      Using_superlu_ns_preconditioner = true;
 
      // Empty vector of meshes and set the number of meshes to zero.
      My_mesh_pt.resize(0, 0);
      My_nmesh = 0;
 
      // The number of DOF types within the meshes.
      My_ndof_types_in_mesh.resize(0, 0);
 
      // Initialise other variables.
      Use_norm_f_for_scaling_sigma = true;
      Scaling_sigma = 0.0;
      N_lagrange_doftypes = 0;
      N_fluid_doftypes = 0;
      N_velocity_doftypes = 0;
      Preconditioner_has_been_setup = false;
    } // constructor
 
    virtual ~LagrangeEnforcedFlowPreconditioner()
    {
      this->clean_up_memory();
    }
 
    LagrangeEnforcedFlowPreconditioner(
      const LagrangeEnforcedFlowPreconditioner&) = delete;
 
    void operator=(const LagrangeEnforcedFlowPreconditioner&) = delete;
 
    void setup();
 
    void preconditioner_solve(const DoubleVector& r, DoubleVector& z);
 
    void set_meshes(const Vector<Mesh*>& mesh_pt);
 
    void use_norm_f_for_scaling_sigma()
    {
      Use_norm_f_for_scaling_sigma = true;
    }
 
    void set_scaling_sigma(const double& scaling_sigma)
    {
      // Check if scaling sigma is zero or positive.
#ifdef PARANOID
      if (scaling_sigma == 0.0)
      {
        std::ostringstream warning_stream;
        warning_stream << "WARNING: \n"
                       << "Setting scaling_sigma = 0.0 may cause values.\n";
        OomphLibWarning(warning_stream.str(),
                        OOMPH_CURRENT_FUNCTION,
                        OOMPH_EXCEPTION_LOCATION);
      }
      if (scaling_sigma > 0.0)
      {
        std::ostringstream warning_stream;
        warning_stream << "WARNING: " << std::endl
                       << "The scaling (scaling_sigma) is positive: "
                       << Scaling_sigma << "\n"
                       << "Performance may be degraded.\n";
        OomphLibWarning(warning_stream.str(),
                        OOMPH_CURRENT_FUNCTION,
                        OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
      Scaling_sigma = scaling_sigma;
      Use_norm_f_for_scaling_sigma = false;
    }
 
    double scaling_sigma() const
    {
      return Scaling_sigma;
    }
 
    void set_navier_stokes_preconditioner(
      Preconditioner* new_ns_preconditioner_pt = 0);
 
    void set_superlu_for_navier_stokes_preconditioner()
    {
      if (!Using_superlu_ns_preconditioner)
      {
        delete Navier_stokes_preconditioner_pt;
        Navier_stokes_preconditioner_pt = new SuperLUPreconditioner;
        Using_superlu_ns_preconditioner = true;
      }
    }
 
    void clean_up_memory();
 
  private:
    bool Preconditioner_has_been_setup;
 
    double Scaling_sigma;
 
    bool Use_norm_f_for_scaling_sigma;
 
    Vector<Vector<double>> Inv_w_diag_values;
 
    Preconditioner* Navier_stokes_preconditioner_pt;
 
    bool Navier_stokes_preconditioner_is_block_preconditioner;
 
    bool Using_superlu_ns_preconditioner;
 
    Vector<Mesh*> My_mesh_pt;
 
    Vector<unsigned> My_ndof_types_in_mesh;
 
    unsigned My_nmesh;
 
    unsigned N_lagrange_doftypes;
 
    unsigned N_fluid_doftypes;
 
    unsigned N_velocity_doftypes;
 
  }; // end of LagrangeEnforcedFlowPreconditioner class
 
} // namespace oomph
#endif