cs_cdo_system.h

Go to the documentation of this file.

#ifndef CS_CDO_SYSTEM_H
#define CS_CDO_SYSTEM_H
 
/*============================================================================
 * Structure and functions used to manipulate elementary structures related to
 * the definition/usage of linear systems (objects manipulated with this
 * structure are matrices, matrix strcutures and assemblers, range set and
 * interface set for parallel synchronization/operations)
 *============================================================================*/
 
/*
  This file is part of code_saturne, a general-purpose CFD tool.
 
  Copyright (C) 1998-2026 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 "base/cs_defs.h"
 
/*----------------------------------------------------------------------------
 * Standard C library headers
 *----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------
 *  Local headers
 *----------------------------------------------------------------------------*/
 
#include "alge/cs_matrix.h"
#include "alge/cs_matrix_assembler.h"
#include "base/cs_param_types.h"
#include "base/cs_range_set.h"
#include "cdo/cs_cdo_assembly.h"
#include "cdo/cs_cdo_connect.h"
 
/*============================================================================
 * Macro definitions
 *============================================================================*/
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
typedef enum {
 
  CS_CDO_SYSTEM_DEFAULT,      
  CS_CDO_SYSTEM_COUPLED,      
  CS_CDO_SYSTEM_SADDLE_POINT, 
} cs_cdo_system_type_t;
 
typedef enum {
 
  CS_CDO_SYSTEM_BLOCK_DEFAULT,
  CS_CDO_SYSTEM_BLOCK_NESTED,
  CS_CDO_SYSTEM_BLOCK_UNASS,
  CS_CDO_SYSTEM_BLOCK_EXTERN,
 
  CS_CDO_SYSTEM_N_BLOCK_TYPES
 
} cs_cdo_system_block_type_t;
 
typedef enum {
 
  CS_CDO_SYSTEM_MATRIX_NONE,
  CS_CDO_SYSTEM_MATRIX_CS,
  CS_CDO_SYSTEM_MATRIX_PETSC,
  CS_CDO_SYSTEM_MATRIX_HYPRE,
 
  CS_CDO_SYSTEM_N_MATRIX_CLASSES
 
} cs_cdo_system_matrix_class_t;
 
 
typedef struct {
 
  /* If the block is associated to one or several matrices, one keeps
   * the information about the class of the matrix
   */
 
  cs_cdo_system_matrix_class_t    matrix_class;
 
  /* An element is for instance a vertex, edge, face or cell */
 
  cs_flag_t   location;    
  cs_lnum_t   n_elements;  
  int         stride;      
  /* Description how is stored the matrix values for this block.
   *
   * When stride > 1, there are several options to store the matrix
   * (all possibilities are not available up to now)
   *
   * unrolled: True means that a vector-valued DoF for instance is treated as
   * a scalar-valued DoF which is three times larger.
   *
   * interlaced: True means that a vector-valued DoF is stored as follows:
   * U0x U0y U0z U1x U1y U1z ... UNx UNy UNz
   * false means that its representation is as follows:
   * U0x U1x ... UNx U0y U1y ... UNy U0z U1z ... UNz
   */
 
  bool        unrolled;
  bool        interlaced;
 
} cs_cdo_system_block_info_t;
 
 
typedef struct {
 
  /*
   * \var matrix
   *      matrix of the system to solve
   *
   * \var matrix_class
   *      class of the matrix
   *
   * \var mav
   *      structure to manage the assembly of matrix values
   *
   * \var assembly_func
   *      function pointer to operate the assembly stage
   *
   * \var slave_assembly_func
   *      function pointer to operate the assembly stage when the system helper
   *      is declared as slave (this is the same for all matrices). Useful for
   *      coupled systems.
   */
 
  cs_matrix_t                    *matrix;
  cs_matrix_assembler_values_t   *mav;
  cs_cdo_assembly_func_t         *assembly_func;
  cs_cdo_assembly_func_t         *slave_assembly_func;
 
  /* The following structures can be shared if the same block configuration
     is requested */
 
  cs_range_set_t                 *range_set;
  cs_interface_set_t             *interface_set;
  cs_matrix_assembler_t          *matrix_assembler;
  cs_matrix_structure_t          *matrix_structure;
 
} cs_cdo_system_dblock_t;
 
 
typedef struct {
 
  /*
   * \var n_matrices
   *      number of matrices to consider
   *
   * \var matrices
   *      matrix of the system to solve (the matrix id in the list of matrices
   *      corresponding to the matrix at row i and column j is i*n_matrices+j)
   *
   * \var mav_array
   *      array of structures to manage the assembly of matrix values
   *
   * \var assembly_func
   *      function pointer to operate the assembly stage (this is the same for
   *      all matrices)
   *
   * \var slave_assembly_func
   *      function pointer to operate the assembly stage when the system helper
   *      is declared as slave (this is the same for all matrices)
   */
 
  int                             n_matrices;
  cs_matrix_t                   **matrices;
  cs_matrix_assembler_values_t  **mav_array;
  cs_cdo_assembly_func_t         *assembly_func;
  cs_cdo_assembly_func_t         *slave_assembly_func;
 
  /* The two following structures are always shared. They correspond to the
     scalar-valued version. */
 
  cs_range_set_t                 *range_set;
  cs_interface_set_t             *interface_set;
 
  bool                            matrix_struct_ownership;
  cs_matrix_assembler_t          *matrix_assembler;
  cs_matrix_structure_t          *matrix_structure;
 
} cs_cdo_system_nblock_t;
 
typedef struct {
 
  cs_real_t               *values;
  cs_real_t               *_values;
 
  const cs_adjacency_t    *adjacency;
 
  /* The following structures can be shared if the same block configuration is
     requested. In this case, shared_structures is set to true. By default,
     there is no sharing. */
 
  bool                     shared_structures;
  cs_range_set_t          *range_set;
  cs_interface_set_t      *interface_set;
 
} cs_cdo_system_ublock_t;
 
 
typedef struct {
 
  /*
   * \var matrix
   *      matrix of the system to solve
   *
   * \var mav
   *      structure to manage the assembly of matrix values
   */
 
  cs_matrix_t                    *matrix;
  cs_matrix_assembler_values_t   *mav;
 
  /* Private structures */
 
  cs_range_set_t                 *range_set;
  cs_interface_set_t             *interface_set;
  cs_matrix_assembler_t          *matrix_assembler;
  cs_matrix_structure_t          *matrix_structure;
 
} cs_cdo_system_xblock_t;
 
 
typedef struct {
 
  /* \var info
   *      Set of metadata to describe the block
   */
 
  cs_cdo_system_block_info_t   info;
 
  cs_cdo_system_block_type_t   type;
 
  bool                         owner;
 
  int                          id;
 
  void                        *block_pointer;
 
} cs_cdo_system_block_t;
 
typedef struct {
 
  cs_cdo_system_type_t     type;
 
  int                      n_col_blocks;
  cs_lnum_t               *col_block_sizes;
  cs_lnum_t               *max_col_block_sizes;
 
  cs_lnum_t                full_rhs_size;
  cs_real_t               *rhs;    /* shared */
  cs_real_t               *_rhs;   /* private */
  cs_real_t              **rhs_array;
 
  int                      n_blocks;
  cs_cdo_system_block_t  **blocks;
 
} cs_cdo_system_helper_t;
 
/*============================================================================
 * Inline public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline cs_cdo_system_matrix_class_t
cs_cdo_system_which_matrix_class(cs_param_solver_class_t  solver_class)
{
  switch (solver_class) {
 
  case CS_PARAM_SOLVER_CLASS_CS:
    return CS_CDO_SYSTEM_MATRIX_CS;
    break;
 
  case CS_PARAM_SOLVER_CLASS_HYPRE:
#if defined(HAVE_HYPRE)
    return CS_CDO_SYSTEM_MATRIX_HYPRE;
#else
    return CS_CDO_SYSTEM_MATRIX_CS;
#endif
    break;
 
  default:
    return CS_CDO_SYSTEM_MATRIX_CS;
    break;
 
  }
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline cs_cdo_system_matrix_class_t
cs_cdo_system_get_matrix_class(const cs_cdo_system_helper_t  *sh,
                               int                            block_id)
{
  if (sh == NULL)
    return   CS_CDO_SYSTEM_MATRIX_NONE;
  if (block_id < 0 || block_id >= sh->n_blocks)
    return   CS_CDO_SYSTEM_MATRIX_NONE;
 
  cs_cdo_system_block_t  *b = sh->blocks[block_id];
 
  assert(b != NULL);
  return b->info.matrix_class;
}
 
/*============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_cdo_system_init_sharing(cs_mesh_t           *mesh,
                           cs_cdo_connect_t    *connect);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_cdo_system_helper_t *
cs_cdo_system_helper_create(cs_cdo_system_type_t    type,
                            int                     n_col_blocks,
                            const cs_lnum_t        *col_block_sizes,
                            int                     n_blocks);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_cdo_system_block_t *
cs_cdo_system_add_dblock(cs_cdo_system_helper_t       *sh,
                         int                           block_id,
                         cs_cdo_system_matrix_class_t  matclass,
                         cs_flag_t                     location,
                         cs_lnum_t                     n_elements,
                         int                           stride,
                         bool                          interlaced,
                         bool                          unrolled);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_cdo_system_block_t *
cs_cdo_system_add_nblock(cs_cdo_system_helper_t       *sh,
                         int                           block_id,
                         cs_cdo_system_matrix_class_t  matclass,
                         cs_flag_t                     location,
                         cs_lnum_t                     n_elements,
                         int                           stride);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_cdo_system_block_t *
cs_cdo_system_add_ublock(cs_cdo_system_helper_t   *sh,
                         int                       block_id,
                         const cs_adjacency_t     *adjacency,
                         cs_flag_t                 location,
                         cs_lnum_t                 n_elements,
                         int                       stride,
                         bool                      interlaced);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_cdo_system_block_t *
cs_cdo_system_add_xblock(cs_cdo_system_helper_t   *sh,
                         int                       block_id,
                         cs_lnum_t                 n_dofs);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_range_set_t *
cs_cdo_system_get_range_set(const cs_cdo_system_helper_t  *sh,
                            int                            block_id);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_matrix_t *
cs_cdo_system_get_matrix(const cs_cdo_system_helper_t  *sh,
                         int                            block_id);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_matrix_t *
cs_cdo_system_get_sub_matrix(cs_cdo_system_helper_t  *sh,
                             int                      block_id,
                             int                      sub_id);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_cdo_system_build_block(cs_cdo_system_helper_t  *sh,
                          int                      block_id);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_cdo_system_helper_init_system(cs_cdo_system_helper_t    *sh,
                                 cs_real_t                **p_rhs);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_cdo_system_helper_finalize_assembly(cs_cdo_system_helper_t    *sh);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_cdo_system_helper_reset(cs_cdo_system_helper_t    *sh);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_cdo_system_helper_free(cs_cdo_system_helper_t   **p_helper);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_cdo_system_allocate_assembly(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_cdo_system_destroy_all(void);
 
#endif /* CS_CDO_SYSTEM_H */