Logo Search packages:      
Sourcecode: ecs version File versions  Download package

ecs_vec_def.h

#ifndef _ECS_VEC_DEF_H_
#define _ECS_VEC_DEF_H_

/*============================================================================
 *  Prototypes des fonctions
 *   associées aux structures `ecs_vec_int_t' et `ecs_vec_real_t' décrivant
 *   les vecteurs indexes entier et réel
 *   et propres aux vecteurs indexes
 *      lies aux champs principaux de type "définition"
 *============================================================================*/

/*
  This file is part of the Code_Saturne Preprocessor, element of the
  Code_Saturne CFD tool.

  Copyright (C) 1999-2007 EDF S.A., France

  contact: saturne-support@edf.fr

  The Code_Saturne Preprocessor 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.

  The Code_Saturne Preprocessor 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 the Code_Saturne Preprocessor; if not, write to the
  Free Software Foundation, Inc.,
  51 Franklin St, Fifth Floor,
  Boston, MA  02110-1301  USA
*/


/*============================================================================
 *                                 Visibilité
 *============================================================================*/


/*----------------------------------------------------------------------------
 *  Fichiers `include' librairie standard C
 *----------------------------------------------------------------------------*/


/*----------------------------------------------------------------------------
 *  Fichiers `include' publics  du  paquetage global "Utilitaire"
 *----------------------------------------------------------------------------*/

#include "ecs_def.h"
#include "ecs_tab_glob.h"


/*----------------------------------------------------------------------------
 *  Fichiers `include' publics  des paquetages visibles
 *----------------------------------------------------------------------------*/



/*----------------------------------------------------------------------------
 *  Fichiers `include' publics  du  paquetage courant
 *----------------------------------------------------------------------------*/

#include "ecs_param_perio_glob.h"
#include "ecs_vec_int_publ.h"
#include "ecs_vec_real_publ.h"



/*============================================================================
 *                       Prototypes de fonctions publiques
 *============================================================================*/

/*----------------------------------------------------------------------------
 *  Fonction réalisant la décomposition des cellules en faces
 *   sur les vecteurs `ecs_vec_int_t' associés aux champs principaux
 *----------------------------------------------------------------------------*/

void ecs_vec_def__decompose_cel
(
 ecs_vec_int_t **vec_def_fac,        /* <-- Définitions des faces             */
 ecs_vec_int_t **vec_cel_def_fac,    /* <-- Définitions des cellules par face */
 ecs_vec_int_t  *vec_def_cel         /* --> Définitions des cellules          */
) ;


/*----------------------------------------------------------------------------
 *  Fonction réalisant la décomposition des faces en arêtes
 *   sur les vecteurs `ecs_vec_int_t' associés aux champs principaux
 *----------------------------------------------------------------------------*/

void ecs_vec_def__decompose_fac
(
 ecs_vec_int_t **vec_def_are,        /* <-- Définitions des arêtes            */
 ecs_vec_int_t **vec_fac_def_are,    /* <-- Définitions des faces par arêtes  */
 ecs_vec_int_t  *vec_def_fac         /* --> Définitions des faces             */
) ;


/*----------------------------------------------------------------------------
 *  Fonction qui réalise la fusion des définitions des éléments
 *
 *  Les valeurs absolues sont triées si `bool_abs' est a `ECS_TRUE'
 *----------------------------------------------------------------------------*/

ecs_tab_int_t ecs_vec_def__fusionne
(
 ecs_vec_int_t * *const this_vec_def_int,
 ecs_tab_int_t   *      signe_elt
) ;


/*----------------------------------------------------------------------------
 *  Suppression des sommets ne participant pas à la connectivité
 *   (renvoie le vecteur de renumérotation des sommets, ou NULL si aucune
 *   renumérotation n'a été nécessaire).
 *----------------------------------------------------------------------------*/

ecs_vec_int_t * ecs_vec_def__nettoie_nodal
(
       ecs_vec_real_t  *const vec_def_som,
 const ecs_vec_int_t   *const vec_def_are,
 const ecs_vec_int_t   *const vec_def_fac,
 const ecs_vec_int_t   *const vec_def_cel
) ;


/*----------------------------------------------------------------------------
 *  Correction si nécessaire de l'orientation des éléments en
 *   connectivité nodale.
 *----------------------------------------------------------------------------*/

void ecs_vec_def__orient_nodal
(
       ecs_vec_real_t  *const vec_def_som,    /*  -> Déf. sommets             */
 const ecs_vec_int_t   *const vec_def_fac,    /*  -> Déf. faces               */
 const ecs_vec_int_t   *const vec_def_cel,    /*  -> Déf. cellules            */
       ecs_tab_int_t   *const liste_cel_err,  /* <-  Cellules avec erreur     */
       ecs_tab_int_t   *const liste_cel_cor,  /* <-  Cellules corrigées       */
 const ecs_bool_t             correc_orient   /*  -> Correction ou non        */
) ;


/*----------------------------------------------------------------------------
 *  Fonction qui calcule les coordonnées minimales et maximales
 *----------------------------------------------------------------------------*/

void ecs_vec_def__calc_coo_ext
(
 ecs_vec_real_t * vec_som
) ;


/*----------------------------------------------------------------------------
 *  Fonction qui modifie les coordonnées du maillage
 *----------------------------------------------------------------------------*/

void ecs_vec_def__transf_coo
(
 ecs_vec_real_t  * vec_som,
 const double      matrice[3][4]
) ;


/*----------------------------------------------------------------------------
 *  Fonction qui réalise la fusion des définitions des éléments
 *----------------------------------------------------------------------------*/

ecs_tab_int_t ecs_vec_real_def__fusionne
(
 ecs_vec_real_t * *const this_vec_def_real
) ;


/*----------------------------------------------------------------------------
 *  Fonction qui fusionne des sommets équivalents
 *  Le pointeur sur un tableau de tolérances peut être à NULL, dans quel cas
 *  on prendra le même poids pour tous les sommets.
 *  Le pointeur sur le tableau liste_som_new peut aussi être à NULL, si l'on
 *  n'est pas intéressé par la liste des sommets fusionnés.
 *
 *  Remarque : le tableau d'équivalence (fusion) des sommets est construit de
 *             manière à ce qu'à un sommet ne comportant pas d'équivalent
 *             où de plus petit indice parmi ses équivalents corresponde la
 *             valeur -1, alors qu'un un sommet possédant des équivalents de
 *             plus petit indice corresponde le plus grand indice parmi ces
 *             équivalents (ce qui constitue une sorte de liste chaînée).
 *----------------------------------------------------------------------------*/

ecs_vec_int_t * ecs_vec_def__fusion_som
(
       ecs_vec_int_t     *const vec_def_are,    /* <-> Déf. arêtes            */
       ecs_vec_real_t    *const vec_def_som,    /* <-> Déf. sommets           */
       ecs_tab_int_t     *const tab_equiv_som,  /* <-> Fusions de sommets     */
 const ecs_tab_real_t    *const dist_max_som,   /*  -> Tolérances             */
       ecs_tab_int_t     *const liste_som_new   /* <-  Liste sommets modifiés */
) ;


/*----------------------------------------------------------------------------
 *  Fonction qui renvoie un tableau associant un type à chaque face, sous
 * forme de masque : 0 pour face isolée, 1 ou 2 pour face de bord (1 si
 * cellule avec cette face normale sortante, 2 si cellule avec cette face
 * normale entrante), 1+2 = 3 pour face interne, et 4 ou plus pour tous
 * les autres cas, correspondant à une erreur de connectivité (+4 pour faces
 * voyant au moins deux cellules avec face normale sortante, +8 pour faces
 * voyant au moins deux cellules avec face normale entrante).
 *
 *  Le type de chaque face pourra être modifié ultérieurement en fonction
 * des informations de périodicité.
 *----------------------------------------------------------------------------*/

ecs_tab_int_t ecs_vec_def__typ_fac_cel
(
 const ecs_vec_int_t  *const vec_def_cel,
       size_t                nbr_fac
) ;


/*----------------------------------------------------------------------------
 *  Fonction qui renvoie un tableau associant à chaque face les
 * numéros des cellules définies par cette face (normale sortante,
 * puis normale entrante). On affecte une valeur 0 lorsqu'il n'y a pas de
 * cellule correspondante directe (la périodicité n'est donc pas prise en
 * compte à ce niveau).
 *
 * On suppose que la cohérence du maillage a déjà été véridifiée et
 * qu'aucune face n'appartient à plus d'une cellule par côté.
 *----------------------------------------------------------------------------*/

ecs_tab_int_t ecs_vec_def__fac_cel
(
 const ecs_vec_int_t  *const vec_def_cel,
       size_t                nbr_fac
) ;


/*----------------------------------------------------------------------------
 *  Fonction qui renvoie un tableau associant à chaque cellule un code
 * en fonction des erreurs de connectivité éventuelles associées à cette
 * cellule (0 si pas d'erreur, 1 si une des faces définissant cette cellule
 * s'appuie sur plusieurs cellules du même côté).
 *----------------------------------------------------------------------------*/

ecs_tab_int_t ecs_vec_def__err_cel_connect
(
 const ecs_vec_int_t  *const vec_def_cel,
 const ecs_tab_int_t  *const typ_fac_cel
) ;


/*----------------------------------------------------------------------------
 *  Fonction qui construit la liste des cellules attachées à une liste
 *  de faces fournie en argument.
 *----------------------------------------------------------------------------*/

ecs_tab_int_t ecs_vec_def__liste_cel_fac
(
       size_t                nbr_fac,
 const ecs_vec_int_t  *const vec_def_cel,
 const ecs_tab_int_t         liste_fac
) ;


/*----------------------------------------------------------------------------
 *  Fonction qui construit la table de connectivité "faces -> sommets"
 *----------------------------------------------------------------------------*/

ecs_vec_int_t * ecs_vec_def__cree_fac_som
(
 const ecs_vec_int_t *const vec_def_fac,
 const ecs_vec_int_t *const vec_def_are
) ;


/*----------------------------------------------------------------------------
 *  Fonction préparant le découpage des faces polygonales en triangles
 *
 *  Les faces doivent être définies en connectivité nodale.
 *
 *  Si un polygone à n sommets est decoupé en triangles,
 *  on obtient n-2 triangles.
 *----------------------------------------------------------------------------*/

void ecs_vec_def__cpt_poly_tria
(
 const ecs_vec_int_t  *const vec_def_fac,      /*  -> définition des faces    */
       size_t         *const fac_nbr_som_max,  /* <-  nbr max sommets/face    */
       size_t         *const nbr_fac_new,      /* <-  nbr faces decoupées     */
       size_t         *const nbr_fac_val_new   /* <-  dim val faces decoupées */
) ;


/*----------------------------------------------------------------------------
 *  Fonction réalisant le découpage des faces polygonale en triangles
 *
 *  Les faces doivent être définies en connectivité nodale.
 *----------------------------------------------------------------------------*/

ecs_vec_int_t * ecs_vec_def__dec_poly_tria
(
       ecs_vec_int_t      *const vec_def_fac_new,
 const ecs_vec_int_t      *const vec_def_fac,
 const ecs_vec_real_t     *const vec_def_som,
       size_t                    fac_nbr_som_max,
       size_t                    nbr_fac_new
) ;


/*----------------------------------------------------------------------------
 *  Fonction qui renvoie le nombre de faces de type "polygone"
 *  (basée sur la définition de faces par plus de 4 arêtes)
 *----------------------------------------------------------------------------*/

size_t ecs_vec_def__nbr_fac_poly
(
 const ecs_vec_int_t  *const vec_def_fac
) ;


/*----------------------------------------------------------------------------
 *  Fonction qui construit un tableau de booléens conforme a une liste
 *   de sous-éléments
 *  Un sous-élément est a `ECS_TRUE'
 *   s'il intervient dans la définition des éléments
 *----------------------------------------------------------------------------*/

void ecs_vec_def__cree_masque
(
 const ecs_tab_bool_t        bool_sselt_select,
 const ecs_vec_int_t  *const vec_def_elt
) ;


/*----------------------------------------------------------------------------
 *  Fusion des sommets confondus appartenant à des mêmes arêtes.
 *  La connectivité des arêtes est mise à jour.
 *----------------------------------------------------------------------------*/

ecs_vec_int_t * ecs_vec_def__nettoie_som_are
(
 ecs_vec_real_t  *const vec_def_som,
 ecs_vec_int_t   *const vec_def_are
) ;


/*----------------------------------------------------------------------------
 *  Fonction qui supprime les éventuelles arêtes dégénérées
 *----------------------------------------------------------------------------*/

ecs_vec_int_t * ecs_vec_def__nettoie_are
(
 ecs_vec_int_t   *const vec_def_are
) ;


/*----------------------------------------------------------------------------
 *  Fonction qui supprime les éventuelles faces dégénérées
 *----------------------------------------------------------------------------*/

ecs_vec_int_t  * ecs_vec_def__nettoie_fac
(
 ecs_vec_int_t   *const vec_def_fac
) ;


/*----------------------------------------------------------------------------
 *  Fonction qui met à jour le tableau des fusions de sommets
 *
 *  Remarque : le tableau d'équivalence (fusion) des sommets est construit de
 *             manière à ce qu'à un sommet ne comportant pas d'équivalent
 *             où de plus grand indice parmi ses équivalents corresponde la
 *             valeur -1, alors qu'un un sommet possédant des équivalents de
 *             plus grand indice corresponde le plus petit indice parmi ces
 *             équivalents (ce qui constitue une sorte de liste chaînée).
 *----------------------------------------------------------------------------*/

void ecs_vec_def__maj_equiv_som
(
 size_t                ind_som_0,
 size_t                ind_som_1,
 ecs_tab_int_t  *const tab_equiv_som
) ;


#endif /* _ECS_VEC_DEF_H_ */

Generated by  Doxygen 1.6.0   Back to index