src/MEDWrapper/V2_1/MEDfam2groA.cxx

   1 /*************************************************************************
   2 * COPYRIGHT (C) 1999 - 2002  EDF R&D
   3 * THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   4 * IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE
   5 * AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION;
   6 * EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
   7 *
   8 * THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
   9 * WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  10 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  11 * LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  12 *
  13 * YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
  14 * ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
  15 * INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
  16 *
  17 *************************************************************************/
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include "med.hxx"
  23
  24
  25 /***********************************************************************
  26  * FONCTION MEDfam2groA
  27  *
  28  * - DESCRIPTION : 1ere etape dans la conversion des familles de groupes
  29  *      MED en goupes de noeuds et d'elements.
  30  *      Calcul des tailles des tableaux a allouer pour stocker les
  31  *      groupes que l'on veut creer.
  32  *      Les parametres renvoyes sont :
  33  *      1 - le nombre de groupes de noeuds a creer (ngn)
  34  *      2 - le nombre de groupes d'elements (nge)
  35  *      3 - le nombre total de noeuds composant l'ensemble des groupes
  36  *          de noeuds (nindn)
  37  *      4 - le nombre total d'elements composant l'ensemble des groupes
  38  *          d'elements (ninde)
  39  *      Ces parametres doivent permettre de creer les tables suivantes :
  40  *      1 - une table de taille (nindn) contenant pour chaque groupe
  41  *          de noeuds la liste des noeuds le composant. Cette table
  42  *          sera indexee par une table de taille (ngn) qui contiendra
  43  *          pour chaque noeud un numero d'indice. Une table de taille
  44  *          (ngn) qui contiendra la liste des noms des differents
  45  *          groupes de noeuds.
  46  *      2 - idem pour les elements
  47  *      Le remplissage de ces tables est realise par la fonction
  48  *      MEDfam2groB().
  49  *
  50  * - PARAMETRES :
  51  *   NOM            .E/S. TYPE    .  DESCRIPTION
  52  *   -------------------------------------------------------------------
  53  *   nfam           .E  . med_int . nombre de familles
  54  *   numfam         .E  . med_int*. table des numeros de familles
  55  *   numfamnoe      .E  . med_int*. table des numeros de familles
  56  *                  .   .         . des noeuds
  57  *   nnoeuds        .E  . med_int . nombre de noeuds
  58  *   numfamele      .E  . med_int*. table des numeros de familles
  59  *                  .   .         . des elements
  60  *   nelememts      .E  .         . nombre total d'elements
  61  *   grofam         .E  . char*   . liste des groupes de familles
  62  *   indfamgro      .E  . int*    . liste des indices des groupes
  63  *                  .   .         . de familles dans grofam
  64  *   ngn            .  S. med_int*. nombre de groupes de noeuds a
  65  *                  .             . creer
  66  *   nge            .  S. med_int*. nombre de groupes d'elements a
  67  *                  .             . creer
  68  *   nindn          .  S. med_int*. taille de la table
  69  *                  .             . des groupes de noeuds a creer
  70  *   ninde          .  S. med_int*. taille de la table
  71  *                  .             . des groupes d'elements
  72  *
  73  * - RESULTAT : 0 si succes et -1 sinon
  74  *
  75  ***********************************************************************/
  76
  77 namespace med_2_1{
  78
  79 med_err
  80 MEDfam2groA (med_int nfam,med_int *numfam,med_int *numfamnoe,
  81              med_int nnoeuds,med_int *numfamele,med_int nelements,
  82              char *grofam,int *indfamgro,
  83              med_int *ngn,med_int *nge,med_int *nindn,med_int *ninde)
  84 {
  85   int i,j,k;
  86   char groupe[MED_TAILLE_LNOM];
  87   char *nomgronoe,*nomgroele,*tmp;
  88   med_int numc;
  89   int nnoe = 0,nele = 0;
  90   int flag = 0;
  91
  92   *ngn = 0;
  93   *nge = 0;
  94   *nindn = 0;
  95   *ninde = 0;
  96
  97   tmp = NULL;
  98   nomgronoe = NULL;
  99   nomgroele = NULL;
 100
 101   /* Pour chaque famille, on regarde s'il y a de nouveaux groupes
 102      de noeuds ou d'elements a creer. Pour chaque nouveau groupe,
 103      on compte le nombre de noeuds ou d'elements qui devront lui etre
 104      rataches */
 105   for (i=1;i<=nfam;i++)
 106     if ((*(indfamgro+i)-*(indfamgro+i-1))/MED_TAILLE_LNOM > 0)
 107       {
 108         /* on releve le numero de la famille courante */
 109         numc = *(numfam+i-1);
 110         nnoe = 0;
 111         nele = 0;
 112         /* si c'est une famille de noeuds, on compte le nombre de
 113            noeuds qui y sont rattaches */
 114         if (numc > 0)
 115           for (j=0;j<nnoeuds;j++)
 116             if (*(numfamnoe+j) == numc)
 117               nnoe++;
 118         /* si c'est une famille d'elements, on compte le nombre d'elements
 119            qui y sont rattaches */
 120         if (numc < 0)
 121           for (j=0;j<nelements;j++)
 122             if (*(numfamele+j) == numc)
 123               nele++;
 124         /* on parcourt la liste des groupes de la famille et pour chaque
 125            groupe :
 126            1 - on met a jour les compteurs nindn et ninde ;
 127            2 - on verifie s'il s'agit d'un groupe deja repertorie.
 128                Si c'est le cas on ne fait rien, sinon on met a jour les
 129                compteurs ngn ou nge */
 130         for (j=0;j<(*(indfamgro+i)-*(indfamgro+i-1))/MED_TAILLE_LNOM;j++)
 131           {
 132             strncpy(groupe,grofam+*(indfamgro+i-1)+j*MED_TAILLE_LNOM,
 133                     MED_TAILLE_LNOM);
 134             if (numc > 0)
 135               {
 136                 *nindn = *nindn+nnoe;
 137                 if (*ngn == 0)
 138                   {
 139                     *ngn = 1;
 140                     if ((nomgronoe=(char*)malloc(sizeof(char)*MED_TAILLE_LNOM))
 141                          == NULL)
 142                       return -1;
 143                     strncpy(nomgronoe,groupe,MED_TAILLE_LNOM);
 144                   }
 145                 else
 146                   {
 147                     flag = 0;
 148                     for (k=0;k<(*ngn);k++)
 149                       if (strncmp(groupe,nomgronoe+k*MED_TAILLE_LNOM,
 150                                   MED_TAILLE_LNOM) == 0)
 151                         flag = 1;
 152                     if (flag == 0)
 153                       {
 154                         *ngn = *ngn + 1;
 155                         if ((tmp=(char*)malloc(sizeof(char)*
 156                                                MED_TAILLE_LNOM**ngn)) == NULL)
 157                           return -1;
 158                         strncpy(tmp,nomgronoe,MED_TAILLE_LNOM*(*ngn-1));
 159                         strncpy(tmp+MED_TAILLE_LNOM*(*ngn-1),groupe,
 160                                 MED_TAILLE_LNOM);
 161                         free(nomgronoe);
 162                         nomgronoe = tmp;
 163                       }
 164                   }
 165               }
 166             if (numc < 0)
 167               {
 168                 *ninde = *ninde+nele;
 169                 if (*nge == 0)
 170                   {
 171                     *nge = 1;
 172                     if ((nomgroele=(char *)malloc(sizeof(char)*
 173                                                   MED_TAILLE_LNOM)) == NULL)
 174                       return -1;
 175                     strncpy(nomgroele,groupe,MED_TAILLE_LNOM);
 176                   }
 177                 else
 178                   {
 179                     flag = 0;
 180                     for (k=0;k<(*nge);k++)
 181                       if (strncmp(groupe,nomgroele+k*MED_TAILLE_LNOM,
 182                                   MED_TAILLE_LNOM) == 0)
 183                         flag = 1;
 184                     if (flag == 0)
 185                       {
 186                         *nge = *nge + 1;
 187                         if ((tmp = (char*) malloc(sizeof(char)*MED_TAILLE_LNOM*
 188                                                   *nge)) == NULL)
 189                           return -1;
 190                         strncpy(tmp,nomgroele,MED_TAILLE_LNOM*(*nge-1));
 191                         strncpy(tmp+MED_TAILLE_LNOM*(*nge-1), groupe,
 192                                 MED_TAILLE_LNOM);
 193                         free(nomgroele);
 194                         nomgroele = tmp;
 195                       }
 196                   }
 197               }
 198           }
 199       }
 200
 201   /* nettoyage memoire */
 202   free(nomgronoe);
 203   free(nomgroele);
 204
 205   return 0;
 206 }
 207
 208 }