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

ecs_connect.c

/*============================================================================
 *  Définitions des fonctions de base
 *   associées à la structure `ecs_connect_t' décrivant une connectivité
 *============================================================================*/

/*
  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
 *----------------------------------------------------------------------------*/

#include <assert.h>


/*----------------------------------------------------------------------------
 *  Fichiers `include' systeme ou BFT
 *----------------------------------------------------------------------------*/

#include <bft_file.h>
#include <bft_mem.h>


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

#include "ecs_def.h"
#include "ecs_fic.h"


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

#include "ecs_entmail_pcp.h"
#include "ecs_entmail.h"


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


/*----------------------------------------------------------------------------
 *  Fichier  `include' du  paquetage courant associé au fichier courant
 *----------------------------------------------------------------------------*/

#include "ecs_connect.h"


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

#include "ecs_connect_priv.h"


/*============================================================================
 *                       Prototypes de fonctions privées
 *============================================================================*/


/*============================================================================
 *                             Fonctions publiques
 *============================================================================*/

/*----------------------------------------------------------------------------
 *  Fonction qui crée une structure `ecs_connect_t'
 *----------------------------------------------------------------------------*/

ecs_connect_t * ecs_connect__cree
(                                    /* <-- Référence sur la connect. créée   */
 ecs_entmail_t     * entmail       , /* --> Pointeur sur éléments du maillage */
 ecs_entmail_t     * entmail_inf   , /* --> Pointeur sur éléments `fils'      */
 ECS_CONNECT_NAT_E   connect_nat_e   /* --> Type de connect. entre entités    */
)
{

  ecs_connect_t *this_connect ;


  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/


  assert(entmail != NULL && entmail_inf != NULL) ;


  BFT_MALLOC(this_connect, 1, ecs_connect_t);

  this_connect->entmail       = entmail       ;
  this_connect->entmail_inf   = entmail_inf   ;

  this_connect->connect_nat_e = connect_nat_e ;


  return this_connect ;


}


/*----------------------------------------------------------------------------
 *  Fonction libérant une structure `ecs_connect_t' donnée en argument
 *  Elle renvoie un pointeur NULL
 *----------------------------------------------------------------------------*/

ecs_connect_t * ecs_connect__detruit
(
 ecs_connect_t *this_connect
)
{

  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/


  assert(this_connect != NULL) ;


  /* Libération de la structure de type `ecs_connect_t' */
  /*================================================*/


  BFT_FREE(this_connect) ;


  /* Retourne `NULL' */

  return this_connect ;


}


/*----------------------------------------------------------------------------
 *  Fonction imprimant le contenu d'une structure `ecs_connect_t' donnée
 *   sur le flux décrit par la structure `bft_file_t'
 *----------------------------------------------------------------------------*/

void ecs_connect__imprime
(
 const ecs_connect_t *const this_connect ,      /* --> Structure à imprimer   */
       ecs_int_t            imp_col      ,
       bft_file_t    *const fic_imp             /* --> Descripteur du fichier */
)
{


#define ECS_FCT_IMP_CONNECT_ENTMAIL      "entmail"
#define ECS_FCT_IMP_CONNECT_ENTMAIL_INF  "entmail_inf"
#define ECS_FCT_IMP_CONNECT_CONNECT_NAT  "connect_nat_e"


  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/


  assert(this_connect != NULL) ;


  imp_col++ ;


  /* Impression des pointeurs contenus dans la structure `ecs_connect_t' */

  ecs_fic__imprime_val(fic_imp, imp_col, ECS_FCT_IMP_CONNECT_ENTMAIL,
                       ECS_TYPE_void, this_connect->entmail) ;

  ecs_fic__imprime_val(fic_imp, imp_col, ECS_FCT_IMP_CONNECT_ENTMAIL_INF,
                       ECS_TYPE_void, this_connect->entmail_inf) ;

  ecs_fic__imprime_val(fic_imp, imp_col, ECS_FCT_IMP_CONNECT_CONNECT_NAT,
                       ECS_TYPE_ecs_int_t, &this_connect->connect_nat_e) ;

}


/*----------------------------------------------------------------------------
 *  Fonction qui renvoie la taille en octets d'une structure `ecs_connect_t'
 *----------------------------------------------------------------------------*/

float ecs_connect__ret_taille
(
 const ecs_connect_t *const this_connect
)
{

  float         taille ;


  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/


  assert(this_connect != NULL) ;


  taille = sizeof(*this_connect) ;


  return taille ;


}


/*----------------------------------------------------------------------------
 *  Fonction réalisant, pour une connectivité donnée,
 *   une transformation entre ses 2 entités de maillage membres
 *----------------------------------------------------------------------------*/

void ecs_connect__cree_indice
(
 ecs_connect_t     *this_connect /* <-> Connectivité concernée par la transf. */
)
{

  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/


  if (this_connect->connect_nat_e == ECS_CONNECT_NAT_LABEL) {

    ecs_entmail_pcp__cree_indice(this_connect->entmail    ,
                                 this_connect->entmail_inf ) ;

    this_connect->connect_nat_e = ECS_CONNECT_NAT_INDEX ;

  }

}


/*----------------------------------------------------------------------------
 *  Fonction réalisant la transformation d'une connectivité donnée
 *   en une "sous-connectivité"
 *
 *  Elle renvoie la nouvelle connectivité associant
 *   l'entité de maillage des éléments      avec
 *   l'entité de maillage des sous-éléments
 *
 *  La connectivité donnée met en jeu des éléments définis
 *   par des éléments d'une entité de maillage élémentaire
 *  La "sous-connectivité" correspondante met en jeu les sous-éléments définis
 *   par des éléments de  l'entité de maillage élémentaire
 *
 *  Exemple :
 *  -------
 *
 * connectivité donnée                : Cellule->Sommet (ECS_CONNECT_CEL_SOM)
 *                           Éléments : cellules
 *     Entité de maillage élémentaire : Sommet
 *
 * "sous-connectivité" correspondante : Face->Sommet    (ECS_CONNECT_FAC_SOM)
 *                      Sous-éléments : faces
 *----------------------------------------------------------------------------*/

ecs_connect_t * ecs_connect__cree_sous_connect
(                                 /* <-- Nouvelle connectivité associant      */
                                  /*      les éléments à leurs sous-éléments  */
 ecs_connect_t   * this_connect , /* --> Connectivité donnée à transformer    */
 ecs_connect_t  ** sous_connect , /* <-> Sous-connectivité                    */
 ecs_entmail_t  ** ent_sous_elt , /* <-- Entité de maillage des sous-éléments */
 ECS_CONNECT_E     connect_typ    /* --> Type de connectivité de départ       */
)
{

  ecs_int_t     ient ;

  ecs_connect_t * connect_elt_sselt ;

  ecs_entmail_t * entmail_sselt_dec ;
  ecs_entmail_t * liste_entmail_connect[ECS_ENTMAIL_FIN] ;


  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/


  assert(this_connect != NULL) ;


  liste_entmail_connect[0] = this_connect->entmail ;
  for (ient = 1 ; ient < ECS_ENTMAIL_FIN ; ient++) {
    liste_entmail_connect[ient] = NULL ;
  }


  /* Décomposition des éléments en leurs sous-éléments */
  /*---------------------------------------------------*/

  assert(   connect_typ == ECS_CONNECT_CEL_SOM
         || connect_typ == ECS_CONNECT_FAC_SOM) ;

  if (connect_typ == ECS_CONNECT_CEL_SOM)
    entmail_sselt_dec = ecs_entmail_pcp__decompose_cel(this_connect->entmail) ;

  else if (connect_typ == ECS_CONNECT_FAC_SOM)
    entmail_sselt_dec = ecs_entmail_pcp__decompose_fac(this_connect->entmail) ;

  else
    entmail_sselt_dec = NULL ;


  /* Concaténation, dans la même entité de maillage, des sous-éléments crées, */
  /*  avec les sous-éléments de même entité déjà existants (s'ils existent !) */
  /*--------------------------------------------------------------------------*/

  if (*sous_connect != NULL) {

    ecs_entmail_pcp__concatene(*ent_sous_elt,
                               entmail_sselt_dec,
                               liste_entmail_connect) ;

    entmail_sselt_dec = ecs_entmail__detruit(entmail_sselt_dec) ;

  }
  else {

    *ent_sous_elt = entmail_sselt_dec ;

    *sous_connect = ecs_connect__cree(*ent_sous_elt,
                                      this_connect->entmail_inf,
                                      ECS_CONNECT_NAT_INDEX) ;

  }


  (*sous_connect)->entmail = *ent_sous_elt ;


  /* Fusion des sous-éléments ayant la même définition topologique */
  /*---------------------------------------------------------------*/

  ecs_entmail_pcp__fusionne((*sous_connect)->entmail,
                            liste_entmail_connect) ;


  /* Création de la nouvelle connectivité associant */
  /*  l'entité de maillage des éléments avec        */
  /*  l'entité de maillage des sous-éléments        */
  /*------------------------------------------------*/

  connect_elt_sselt = ecs_connect__cree(this_connect->entmail   ,
                                        (*sous_connect)->entmail,
                                        ECS_CONNECT_NAT_INDEX        ) ;


  /* Renvoi de la nouvelle connectivité */
  /*------------------------------------*/

  return connect_elt_sselt ;

}


/*----------------------------------------------------------------------------
 *  Fonction qui crée la liste des connectivités
 *   dans une représentation du maillage en connectivité nodale
 *   à partir du vecteur des entités de maillage
 *         et de la nature de la connectivité (par étiquette ou par indice)
 *----------------------------------------------------------------------------*/

ecs_connect_t * * ecs_connect__cree_nodal
(
 ecs_entmail_t     * *const vect_entmail  ,
 ECS_CONNECT_NAT_E          connect_nat_e
)
{

  ecs_int_t        iconnect       ; /* Indice de boucle sur les connectivités */

  ecs_connect_t  * * vect_connect ; /* Tableau des connectivités              */


  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/


  BFT_MALLOC(vect_connect, ECS_CONNECT_FIN, ecs_connect_t *) ;


  for (iconnect = ECS_CONNECT_DEB ; iconnect < ECS_CONNECT_FIN ; iconnect++)
    vect_connect[iconnect] = NULL ;

  if (vect_entmail[ECS_ENTMAIL_CEL] != NULL) {

    vect_connect[ECS_CONNECT_CEL_SOM]
      = ecs_connect__cree(vect_entmail[ECS_ENTMAIL_CEL],
                          vect_entmail[ECS_ENTMAIL_SOM],
                          connect_nat_e) ;
  }

  if (vect_entmail[ECS_ENTMAIL_FAC] != NULL) {

    vect_connect[ECS_CONNECT_FAC_SOM]
      = ecs_connect__cree(vect_entmail[ECS_ENTMAIL_FAC],
                          vect_entmail[ECS_ENTMAIL_SOM],
                          connect_nat_e) ;

  }

  if (vect_entmail[ECS_ENTMAIL_ARE] != NULL) {

    vect_connect[ECS_CONNECT_ARE_SOM]
      = ecs_connect__cree(vect_entmail[ECS_ENTMAIL_ARE],
                          vect_entmail[ECS_ENTMAIL_SOM],
                          connect_nat_e) ;
  }


  return vect_connect ;


}


/*----------------------------------------------------------------------------
 *  Fonction qui crée la liste des connectivités
 *   dans une représentation du maillage en connectivité descendante
 *   à partir du vecteur des entités de maillage
 *----------------------------------------------------------------------------*/

ecs_connect_t * * ecs_connect__cree_descendant
(
 ecs_entmail_t * *const vect_entmail
)
{

  ecs_int_t        iconnect       ; /* Indice de boucle sur les connectivités */

  ecs_connect_t  * * vect_connect ; /* Tableau des connectivités              */


  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/


  BFT_MALLOC(vect_connect, ECS_CONNECT_FIN, ecs_connect_t *) ;


  for (iconnect = ECS_CONNECT_DEB ; iconnect < ECS_CONNECT_FIN ; iconnect++)
    vect_connect[iconnect] = NULL ;

  if (vect_entmail[ECS_ENTMAIL_CEL] != NULL) {

    vect_connect[ECS_CONNECT_CEL_FAC]
      = ecs_connect__cree(vect_entmail[ECS_ENTMAIL_CEL],
                          vect_entmail[ECS_ENTMAIL_FAC],
                          ECS_CONNECT_NAT_INDEX) ;
  }

  if (vect_entmail[ECS_ENTMAIL_FAC] != NULL) {

    vect_connect[ECS_CONNECT_FAC_ARE]
      = ecs_connect__cree(vect_entmail[ECS_ENTMAIL_FAC],
                          vect_entmail[ECS_ENTMAIL_ARE],
                          ECS_CONNECT_NAT_INDEX) ;

  }

  if (vect_entmail[ECS_ENTMAIL_ARE] != NULL) {

    vect_connect[ECS_CONNECT_ARE_SOM]
      = ecs_connect__cree(vect_entmail[ECS_ENTMAIL_ARE],
                          vect_entmail[ECS_ENTMAIL_SOM],
                          ECS_CONNECT_NAT_INDEX) ;
  }


  return vect_connect ;


}


/*----------------------------------------------------------------------------
 *  Fonction qui retourne le type de la connectivité :
 *  - connectivité nodale      : ECS_CONNECT_TYP_NODALE
 *  - connectivité descendante : ECS_CONNECT_TYP_DESCENDANTE
 *   associé au tableau des connectivités
 *
 *  Si le maillage ne comporte que des arêtes,
 *   la fonction ne peut pas déterminer le type de la connectivité
 *   et retourne ECS_CONNECT_TYP_NUL
 *----------------------------------------------------------------------------*/

ECS_CONNECT_TYP_E ecs_connect__ret_connect_typ
(
 ecs_connect_t *const liste_connect[] ,
 ecs_entmail_t *const liste_entmail[]
)
{

  ECS_CONNECT_TYP_E    connect_typ_e ;


  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/


  assert(liste_entmail[ECS_ENTMAIL_SOM] != NULL) ;

  if (liste_entmail[ECS_ENTMAIL_ARE] != NULL)
    assert(liste_connect[ECS_CONNECT_ARE_SOM] != NULL) ;


  if (liste_entmail[ECS_ENTMAIL_FAC] != NULL) {

    if      (liste_connect[ECS_CONNECT_FAC_ARE] != NULL &&
             liste_connect[ECS_CONNECT_FAC_SOM] == NULL   )
      connect_typ_e = ECS_CONNECT_TYP_DESCENDANTE ;
    else if (liste_connect[ECS_CONNECT_FAC_SOM] != NULL &&
             liste_connect[ECS_CONNECT_FAC_ARE] == NULL   )
      connect_typ_e = ECS_CONNECT_TYP_NODALE ;
    else
      assert((liste_connect[ECS_CONNECT_FAC_ARE] != NULL &&
              liste_connect[ECS_CONNECT_FAC_SOM] == NULL   ) ||
             (liste_connect[ECS_CONNECT_FAC_SOM] != NULL &&
              liste_connect[ECS_CONNECT_FAC_ARE] == NULL   )   ) ;

  }
  else {

    connect_typ_e = ECS_CONNECT_TYP_NUL ;

  }


  if (liste_entmail[ECS_ENTMAIL_CEL] != NULL) {

    if (connect_typ_e == ECS_CONNECT_TYP_NUL) {

      if      (liste_connect[ECS_CONNECT_CEL_FAC] != NULL &&
               liste_connect[ECS_CONNECT_CEL_SOM] == NULL   )
        connect_typ_e = ECS_CONNECT_TYP_DESCENDANTE ;
      else if (liste_connect[ECS_CONNECT_CEL_SOM] != NULL &&
               liste_connect[ECS_CONNECT_CEL_FAC] == NULL   )
        connect_typ_e = ECS_CONNECT_TYP_NODALE ;
      else
        assert((liste_connect[ECS_CONNECT_CEL_FAC] != NULL &&
                liste_connect[ECS_CONNECT_CEL_SOM] == NULL   ) ||
               (liste_connect[ECS_CONNECT_CEL_SOM] != NULL &&
                liste_connect[ECS_CONNECT_CEL_FAC] == NULL   )   ) ;


    }
    else {

      if      (connect_typ_e == ECS_CONNECT_TYP_DESCENDANTE) {

        assert(liste_connect[ECS_CONNECT_CEL_FAC] != NULL &&
               liste_connect[ECS_CONNECT_CEL_SOM] == NULL   ) ;

      }
      else if (connect_typ_e == ECS_CONNECT_TYP_NODALE) {

        assert(liste_connect[ECS_CONNECT_CEL_SOM] != NULL &&
               liste_connect[ECS_CONNECT_CEL_FAC] == NULL   ) ;

      }

    }

  }


  return connect_typ_e ;


}


Generated by  Doxygen 1.6.0   Back to index