cs_saddle_itsol.h

Go to the documentation of this file.

#ifndef __CS_SADDLE_ITSOL_H__
#define __CS_SADDLE_ITSOL_H__
 
/*============================================================================
 * In-house iterative solvers defined by blocks and associated to CDO
 * discretizations for saddle-point system
 *============================================================================*/
 
/*
  This file is part of code_saturne, a general-purpose CFD tool.
 
  Copyright (C) 1998-2023 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.
*/
 
/*----------------------------------------------------------------------------*/
 
#include "cs_defs.h"
 
/*----------------------------------------------------------------------------
 * Standard C library headers
 *----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------
 *  Local headers
 *----------------------------------------------------------------------------*/
 
#include "cs_iter_algo.h"
#include "cs_matrix.h"
#include "cs_mesh_adjacencies.h"
#include "cs_param_sles.h"
#include "cs_range_set.h"
#include "cs_sles.h"
 
/*----------------------------------------------------------------------------*/
 
BEGIN_C_DECLS
 
/*============================================================================
 * Macro definitions
 *============================================================================*/
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
typedef struct {
 
  /*
   * A hybrid storage is used to represent the system described below
   *
   *      | M11 | M12 | | x1 |   |rhs1 |
   *  M = |-----------| |----| = |-----|
   *      | M21 |  0  | | x2 |   |rhs2 |
   *
   *  One assumes that M12 = M21^T
   */
 
  int              n_m11_matrices; /* 1, 3, 6 or 9 is expected */
  cs_matrix_t    **m11_matrices;
  cs_lnum_t        x1_size;        /* scatter view */
  cs_lnum_t        max_x1_size;    /* max(x1_size, n_m11_cols) */
 
  cs_real_t       *rhs1;
 
  cs_lnum_t        x2_size;        /* scatter view */
  cs_lnum_t        max_x2_size;    /* max(x2_size, n_m22_cols) */
  cs_real_t       *rhs2;
 
  cs_real_t       *m21_unassembled;
  int              m21_stride;
 
  /* Indexed list used to scan the unassembled m21 operator */
 
  const cs_adjacency_t  *m21_adjacency;
 
  /* Structure used for synchronisation (parallel or periodic). Enable to
     switch from a scatter view (the mesh view) to a gather view (the algebraic
     view). This structure is shared. */
 
  const cs_range_set_t  *rset;
 
} cs_saddle_system_t;
 
/* Structure handling the block preconditioning */
 
typedef struct {
 
  /* Parameters */
 
  cs_param_precond_block_t     block_type;
  cs_param_schur_approx_t      schur_type;
 
  /* Block 11 settings (mandatory) */
 
  cs_param_sles_t   *m11_slesp;
  cs_sles_t         *m11_sles;
 
  /* Schur complement settings (optional) */
 
  cs_matrix_t       *schur_matrix;
  cs_param_sles_t   *schur_slesp;
  cs_sles_t         *schur_sles;
  double             schur_scaling;
 
  /* Native arrays for the Schur matrix (optional) */
 
  cs_real_t         *schur_diag;
  cs_real_t         *schur_xtra;
 
  /* Diagonal approximations of block matrices (optional) */
 
  cs_real_t         *m11_inv_diag;
  cs_real_t         *mass22_diag;
 
} cs_saddle_block_precond_t;
 
/*============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_saddle_block_precond_t *
cs_saddle_block_precond_create(cs_param_precond_block_t    block_type,
                               cs_param_schur_approx_t     schur_type,
                               cs_param_sles_t            *m11_slesp,
                               cs_sles_t                  *m11_sles);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_saddle_block_precond_free(cs_saddle_block_precond_t  **p_sbp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_saddle_minres(cs_saddle_system_t          *ssys,
                 cs_saddle_block_precond_t   *sbp,
                 cs_real_t                   *x1,
                 cs_real_t                   *x2,
                 cs_iter_algo_t              *algo);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_saddle_gcr(int                          restart,
              cs_saddle_system_t          *ssys,
              cs_saddle_block_precond_t   *sbp,
              cs_real_t                   *x1,
              cs_real_t                   *x2,
              cs_iter_algo_t              *algo);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_matrix_vector_multiply_gs_allocated(const cs_range_set_t      *rset,
                                       const cs_matrix_t         *mat,
                                       cs_real_t                 *vec,
                                       cs_real_t                 *matvec);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_matrix_vector_multiply_gs(const cs_range_set_t      *rset,
                             const cs_matrix_t         *mat,
                             cs_lnum_t                  vec_len,
                             cs_real_t                 *vec,
                             cs_real_t                **p_matvec);
 
/*----------------------------------------------------------------------------*/
 
END_C_DECLS
 
#endif /* __CS_SADDLE_ITSOL_H__ */