src/MEDWrapper/V2_1/Core/MEDgro2famA.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
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22
  23 #include "med.hxx"
  24
  25 /***********************************************************************
  26  * FONCTION MEDgro2famA
  27  *
  28  * - DESCRIPTION : 1ere etape dans la conversion des groupes de noeuds
  29  *      et d'elements en familles MED.
  30  *      Calcul des tailles des tableaux que l'on devra allouer pour
  31  *      stocker les familles qui seront construites par MEDgro2famB().
  32  *      Les parametres renvoyes sont :
  33  *      1 - le nombre de familles MED a creer (nfamg)
  34  *      2 - le nombre de noms groupes associes a l'ensemble des familles
  35  *      MED (nindf)
  36  *      Ces parametres doivent permettre a l'appelant de creer les tables
  37  *      suivantes :
  38  *      1 - une table des noms des groupes propres a chaque famille,
  39  *      de taille : nindf*MED_TAILLE_LNOM+1
  40  *      2 - une table d'index donnant pour chaque famille son numero d'indice
  41  *      dans la table des noms, de taille : nfamg+1
  42  *      3 - une table destinee a contenir la liste des numeros de familles
  43  *          a creer, de taille : nfamg
  44  *
  45  * - PARAMETRES :
  46  *   NOM            .E/S. TYPE    .  DESCRIPTION
  47  *   -------------------------------------------------------------------
  48  *   nnoe           .E  . med_int . nombre de noeuds
  49  *   nele           .E  . med_int . nombre d'elements
  50  *   numnoe         .E  . med_int*. numeros des noeuds
  51  *   numele         .E  . med_int*. numeros des elements
  52  *   ngn            .E  . med_int . nombre de groupes de noeuds
  53  *   nge            .E  . med_int . nombre de groupes d'elements
  54  *   nindn          .E  . med_int . nombre d'indices dans la table
  55  *                  .   .         . des groupes de noeuds
  56  *   ninde          .E  . med_int . nombre d'indices dans la table
  57  *                  .   .         . de groupes d'elements
  58  *   indgronoe      .E  . int*    . table index de la table des groupes
  59  *                  .   .         . de noeuds
  60  *   indgroele      .E  . int*    . table index de la table des groupes
  61  *                  .   .         . d'elements
  62  *   tabgronoe      .E  . med_int*. table des groupes de noeuds
  63  *   tabgroele      .E  . med_int*. table des groupes d'elements
  64  *   nfamg          .  S. med_int*. nombre de familles MED a creer
  65  *   nidnf          .  S. med_int*. nombre de noms groupes associes a
  66  *                  .   .         . l'ensemble des familles MED
  67  *
  68  * - RESULTAT : 0 si succes, -1 sinon
  69  *
  70  ***********************************************************************/
  71
  72 namespace med_2_1{
  73
  74 med_err
  75 MEDgro2famA (med_int nnoe,med_int nele,med_int *numnoe,med_int *numele,
  76              med_int ngn,med_int nge,med_int nindn,
  77              med_int ninde,int *indgronoe,int *indgroele,med_int *tabgronoe,
  78              med_int *tabgroele,med_int *nfamg,med_int *nindf)
  79 {
  80   int i,j,k;
  81   int *famnoe,*famele,*tmp;
  82   int *p;
  83   int flag, num,exist;
  84   int nfamn, nfame;
  85   int fam01 = 0;
  86   int fam02 = 0;
  87
  88   /* initialisations */
  89   famnoe = NULL;
  90   famele = NULL;
  91
  92   *nfamg = 0;
  93   *nindf = 0;
  94   nfamn = 0;
  95   nfame = 0;
  96
  97   if ((ngn > 0) || (nge > 0))
  98     {
  99       /* pour chaque noeud :
 100          1 - on dresse la liste des groupes de noeuds auquel il appartient
 101          2 - en la comparant avec les listes pre-existantes, on
 102          estime s'il est necessaire de creer une nouvelle famille de noeuds.
 103          Si oui => on incremente le compteur local nfamn (nombre de familles
 104                    de noeuds)
 105                    on incremente le parametre nindf du nombre de groupes
 106                    que devra compter cette famille de noeuds
 107          Si non => on ne fait rien */
 108       for (i=0;i<nnoe;i++)
 109         {
 110           if ((tmp = (int*) malloc(sizeof(int)*ngn)) == NULL)
 111             return -1;
 112           num = *(numnoe+i);
 113           for (j=0;j<ngn;j++)
 114             {
 115               flag = 0;
 116               /* on regarde si le noeud appartient au groupe */
 117               for (k=0;k<*(indgronoe+j+1)-*(indgronoe+j);k++)
 118                 if (num == *(tabgronoe+*(indgronoe+j)+k))
 119                   flag = 1;
 120               /* on met le flag a jour dans tmp */
 121               *(tmp+j) = flag;
 122             }
 123           /* on note la creation de la famille 0 */
 124           if (fam01 == 0)
 125             {
 126               flag = 1;
 127               for (j=0;j<ngn;j++)
 128                 if (*(tmp+j) == 1)
 129                   flag = 0;
 130               if (flag == 1)
 131                 fam01 = 1;
 132             }
 133           /* faut-il creer une nouvelle famille ? */
 134           if (famnoe == NULL)
 135             {
 136               exist = 0;
 137               if ((famnoe = (int *) malloc (sizeof(int)*ngn)) == NULL)
 138                 return -1;
 139               for (j=0;j<ngn;j++)
 140                 {
 141                   *(famnoe+j) = *(tmp+j);
 142                   if (*(famnoe+j) == 1)
 143                     *nindf = *nindf + 1;
 144                 }
 145               nfamn = 1;
 146             }
 147           else
 148             {
 149               for (j=0;j<nfamn;j++)
 150                 {
 151                   p = famnoe + ngn*j;
 152                   for (k=0;k<ngn;k++)
 153                     {
 154                       if (*(p+k) != *(tmp+k))
 155                         {
 156                           exist = 0;
 157                           break;
 158                         }
 159                       else
 160                         exist = 1;
 161                     }
 162                   if (exist == 1)
 163                     break;
 164                 }
 165               if (exist == 0)
 166                 {
 167                   nfamn = nfamn + 1;
 168                   p = famnoe;
 169                   if ((famnoe = (int*) malloc(sizeof(int)*ngn*nfamn)) == NULL)
 170                     return -1;
 171                   for (j=0;j<nfamn-1;j++)
 172                     for (k=0;k<ngn;k++)
 173                       *(famnoe+j*ngn+k) = *(p+j*ngn+k);
 174                   free(p);
 175                   p = famnoe+(nfamn-1)*ngn;
 176                   for (j=0;j<ngn;j++)
 177                     {
 178                       *(p+j) = *(tmp+j);
 179                       if (*(p+j) == 1)
 180                         *nindf = *nindf + 1;
 181                     }
 182                 }
 183             }
 184           free(tmp);
 185         }
 186
 187       /* pour chaque element : idem que pour les noeuds */
 188       for (i=0;i<nele;i++)
 189         {
 190           if ((tmp = (int*) malloc(sizeof(int)*nge)) == NULL)
 191             return -1;
 192           num = *(numele+i);
 193           for (j=0;j<nge;j++)
 194             {
 195               flag = 0;
 196               /* on regarde si l'element appartient au groupe */
 197               for (k=0;k<*(indgroele+j+1)-*(indgroele+j);k++)
 198                 if (num == *(tabgroele+*(indgroele+j)+k))
 199                   flag = 1;
 200               /* on met le flag a jour dans tmp */
 201               *(tmp+j) = flag;
 202             }
 203           /* on note la creation de la famille 0 */
 204           if (fam02 == 0)
 205             {
 206               flag = 1;
 207               for (j=0;j<nge;j++)
 208                 if (*(tmp+j) == 1)
 209                   flag = 0;
 210               if (flag == 1)
 211                 fam02 = 1;
 212             }
 213           /* faut-il creer une nouvelle famille ? */
 214           if (famele == NULL)
 215             {
 216               exist = 0;
 217               if ((famele = (int *) malloc (sizeof(int)*nge)) == NULL)
 218                 return -1;
 219               for (j=0;j<nge;j++)
 220                 {
 221                   *(famele+j) = *(tmp+j);
 222                   if (*(famele+j) == 1)
 223                     *nindf = *nindf + 1;
 224                 }
 225               nfame = 1;
 226             }
 227           else
 228             {
 229               for (j=0;j<nfame;j++)
 230                 {
 231                   p = famele + nge*j;
 232                   for (k=0;k<nge;k++)
 233                     {
 234                       if (*(p+k) != *(tmp+k))
 235                         {
 236                           exist = 0;
 237                           break;
 238                         }
 239                       else
 240                         exist = 1;
 241                     }
 242                   if (exist == 1)
 243                     break;
 244                 }
 245               if (exist == 0)
 246                 {
 247                   nfame = nfame + 1;
 248                   p = famele;
 249                   if ((famele = (int*) malloc(sizeof(int)*nge*nfame)) == NULL)
 250                     return -1;
 251                   for (j=0;j<nfame-1;j++)
 252                     for (k=0;k<nge;k++)
 253                       *(famele+j*nge+k) = *(p+j*nge+k);
 254                   free(p);
 255                   p = famele+(nfame-1)*nge;
 256                   for (j=0;j<nge;j++)
 257                     {
 258                       *(p+j) = *(tmp+j);
 259                       if (*(p+j) == 1)
 260                         *nindf = *nindf + 1;
 261                     }
 262                 }
 263             }
 264           free(tmp);
 265         }
 266
 267       /* la famille 0 existe pour les noeuds et les elements, on
 268          ne la compte qu'une fois */
 269       if (fam01 && fam02)
 270         nfamn = nfamn - 1;
 271
 272       /* le nombre de familles a creer est egal au nombre de familles
 273          de noeuds + nombre de familles d'elements */
 274       *nfamg = nfamn + nfame;
 275
 276
 277       /* Nettoyage memoire */
 278       free(famnoe);
 279       free(famele);
 280     }
 281   else
 282     {
 283       /* on a aucun groupes de noeuds ou d'elements */
 284       *nfamg = 1; /* on a au moins la famille 0 */
 285       *nindf = 0;
 286     }
 287
 288   return 0;
 289 }
 290
 291 }