cs_param_saddle.h

Go to the documentation of this file.

#ifndef __CS_PARAM_SADDLE_H__
#define __CS_PARAM_SADDLE_H__
 
/*============================================================================
 * Routines to handle the SLES settings
 *============================================================================*/
 
/*
  This file is part of code_saturne, a general-purpose CFD tool.
 
  Copyright (C) 1998-2025 EDF S.A.
 
  This program is free software; you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
  Foundation; either version 2 of the License, or (at your option) any later
  version.
 
  This program is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  details.
 
  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
  Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
 
/*----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------
 *  Local headers
 *----------------------------------------------------------------------------*/
 
#include "alge/cs_param_sles.h"
 
/*----------------------------------------------------------------------------*/
 
BEGIN_C_DECLS

 
/*============================================================================
 * Macro definitions
 *============================================================================*/
 
/*============================================================================
 * Type definitions
 *============================================================================*/

 
typedef enum {
 
  CS_PARAM_SADDLE_PRECOND_NONE,
  CS_PARAM_SADDLE_PRECOND_DIAG,
  CS_PARAM_SADDLE_PRECOND_LOWER,
  CS_PARAM_SADDLE_PRECOND_SGS,
  CS_PARAM_SADDLE_PRECOND_UPPER,
  CS_PARAM_SADDLE_PRECOND_UZAWA,
 
  CS_PARAM_SADDLE_N_PRECOND
 
} cs_param_saddle_precond_t;

 
typedef enum {
 
  CS_PARAM_SADDLE_SOLVER_NONE,
 
  CS_PARAM_SADDLE_SOLVER_ALU,
  CS_PARAM_SADDLE_SOLVER_FGMRES,
  CS_PARAM_SADDLE_SOLVER_GCR,
  CS_PARAM_SADDLE_SOLVER_GKB,
  CS_PARAM_SADDLE_SOLVER_MINRES,
  CS_PARAM_SADDLE_SOLVER_MUMPS,
  CS_PARAM_SADDLE_SOLVER_NOTAY_TRANSFORM,
  CS_PARAM_SADDLE_SOLVER_SIMPLE,
  CS_PARAM_SADDLE_SOLVER_UZAWA_CG,
 
  CS_PARAM_SADDLE_N_SOLVERS
 
} cs_param_saddle_solver_t;

 
typedef enum {
 
  CS_PARAM_SADDLE_SCHUR_NONE,
 
  CS_PARAM_SADDLE_SCHUR_DIAG_INVERSE,
  CS_PARAM_SADDLE_SCHUR_IDENTITY,
  CS_PARAM_SADDLE_SCHUR_LUMPED_INVERSE,
  CS_PARAM_SADDLE_SCHUR_MASS_SCALED,
  CS_PARAM_SADDLE_SCHUR_MASS_SCALED_DIAG_INVERSE,
  CS_PARAM_SADDLE_SCHUR_MASS_SCALED_LUMPED_INVERSE,
 
  CS_PARAM_SADDLE_N_SCHUR_APPROX
 
} cs_param_saddle_schur_approx_t;

 
typedef struct {

 
  int                         verbosity;

 
  char                       *name;



 
  cs_param_solver_class_t     solver_class;

 
  cs_param_saddle_solver_t    solver;

 
  cs_param_saddle_precond_t   precond;

 
  cs_param_convergence_t      cvg_param;


 
  const cs_param_sles_t      *block11_sles_param;


 
  cs_param_saddle_schur_approx_t  schur_approx;

 
  cs_param_sles_t                *schur_sles_param;

 
  /* Additional parameters which are advanced/developper settings */
 
  void                           *context;
 
} cs_param_saddle_t;
 
 
/* Set of advanced settings according to the type of saddle-point solver */
/* ===================================================================== */
 
/* Augmented Lagrangian Uzawa algorithm */
/* ------------------------------------ */
 
typedef struct {

 
  double            augmentation_scaling;
 
  /* \var dedicated_init_sles
   * Define an additional SLES to perform the resolution associated to the
   * transformation of the right-hand side. By default, this is false in order
   * to not compute two setup steps in one call. */
 
  bool              dedicated_init_sles;

 
  cs_param_sles_t  *init_sles_param;
 
} cs_param_saddle_context_alu_t;
 
 
/* Block preconditioner algorithm with a Krylov solver */
/* --------------------------------------------------- */
 
typedef struct {

 
  double            augmentation_scaling;

 
  int               n_stored_directions;

 
  cs_param_sles_t  *xtra_sles_param;
 
} cs_param_saddle_context_block_krylov_t;
 
 
/* GKB algorithm */
/* ------------- */
 
typedef struct {

 
  double            augmentation_scaling;

 
  int               truncation_threshold;
 
  /* \var dedicated_init_sles
   * Define an additional SLES to perform the resolution associated to the
   * transformation of the right-hand side. By default, this is false in order
   * to not compute two setup steps in one call. */
 
  bool              dedicated_init_sles;

 
  cs_param_sles_t  *init_sles_param;
 
} cs_param_saddle_context_gkb_t;
 
 
/* Notay's algebraic transformation */
/* -------------------------------- */
 
typedef struct {
 
  /* \var scaling_coef
   * This coefficient is used in Notay's transformation devised in "Algebraic
   * multigrid for Stokes equations" SIAM J. Sci. Comput. Vol. 39 (5), 2017
   */
 
  double  scaling_coef;
 
} cs_param_saddle_context_notay_t;
 
/* Uzawa-CG algorithm */
/* ------------------ */
 
typedef struct {
 
  /* \var dedicated_init_sles
   * Define an additional SLES to perform the initial resolution. By default,
   * this is false in order to not compute two setup steps in one call. */
 
  bool              dedicated_init_sles;

 
  cs_param_sles_t  *init_sles_param;

 
  cs_param_sles_t  *xtra_sles_param;
 
} cs_param_saddle_context_uzacg_t;
 
/* SIMPLE-like algorithm */
/* --------------------- */
 
typedef struct {
 
  /* \var dedicated_init_sles
   * Define an additional SLES to perform the initial resolution. By default,
   * this is false in order to not compute two setup steps in one call. */
 
  bool              dedicated_init_sles;

 
  cs_param_sles_t  *init_sles_param;

 
  cs_param_sles_t  *xtra_sles_param;
 
} cs_param_saddle_context_simple_t;
 
/*============================================================================
 * Global variables
 *============================================================================*/
 
/*============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_saddle_set_restart_range(cs_param_saddle_t  *saddlep,
                                  int                 restart_range);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_saddle_set_notay_scaling(cs_param_saddle_t  *saddlep,
                                  double              scaling_coef);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_saddle_set_augmentation_coef(cs_param_saddle_t  *saddlep,
                                      double              coef);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
double
cs_param_saddle_get_augmentation_coef(const cs_param_saddle_t  *saddlep);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_saddle_get_type_name(cs_param_saddle_solver_t  type);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_saddle_t *
cs_param_saddle_create(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_saddle_free(cs_param_saddle_t  **p_saddlep);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_saddle_get_name(const cs_param_saddle_t  *saddlep);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_saddle_set_name(const char         *name,
                         cs_param_saddle_t  *saddlep);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_saddle_set_block11_sles_param(cs_param_saddle_t      *saddlep,
                                       const cs_param_sles_t  *block11_slesp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_param_saddle_set_precond(const char          *keyval,
                            cs_param_saddle_t   *saddlep);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_param_saddle_set_schur_approx(const char          *keyval,
                                 cs_param_saddle_t   *saddlep);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_param_saddle_set_solver_class(const char          *keyval,
                                 cs_param_saddle_t   *saddlep);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_param_saddle_set_solver(const char          *keyval,
                           cs_param_saddle_t   *saddlep);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_saddle_try_init_schur_sles_param(cs_param_saddle_t  *saddlep);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_sles_t *
cs_param_saddle_get_schur_sles_param(const cs_param_saddle_t  *saddlep);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_sles_t *
cs_param_saddle_get_xtra_sles_param(const cs_param_saddle_t  *saddlep);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_sles_t *
cs_param_saddle_get_init_sles_param(const cs_param_saddle_t  *saddlep);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_saddle_copy(const cs_param_saddle_t  *ref,
                     cs_param_saddle_t        *dest);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_saddle_log(const cs_param_saddle_t  *saddlep);
 
/*----------------------------------------------------------------------------*/
 
END_C_DECLS
 
#endif /* __CS_PARAM_SADDLE_H__ */