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-2022 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 "cs_cdo_assembly.h"
#include "cs_cdo_connect.h"
#include "cs_matrix.h"
#include "cs_matrix_assembler.h"
#include "cs_range_set.h"

/*----------------------------------------------------------------------------*/

BEGIN_C_DECLS

/*============================================================================
 * 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_SPLIT,
  CS_CDO_SYSTEM_BLOCK_UNASS,
  CS_CDO_SYSTEM_BLOCK_EXT,

  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_sblock_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;

/*============================================================================
 * 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_sblock(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);

/*----------------------------------------------------------------------------*/

END_C_DECLS

#endif /* __CS_CDO_SYSTEM_H__ */