src/MEDWrapper/V2_1/Core/MEDgro2famB.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  * FONCTION MEDgro2famB
  26  *
  27  * - DESCRIPTION : 2eme etape dans la conversion des groupes de noeuds
  28  *      et d'elements en familles MED
  29  *      Mise a jour des tables suivantes passees en parametres :
  30  *      1 - les nouveaux numeros des familles a creer
  31  *      2 - les nouveaux numeros des familles des elements
  32  *      3 - les nouveaux numeros des familles des noeuds
  33  *      4 - les noms des groupes composant ces familles
  34  *      5 - les index de la table des groupes
  35  *
  36  * - PARAMETRES :
  37  *   NOM            .E/S. TYPE    .  DESCRIPTION
  38  *   -------------------------------------------------------------------
  39  *   nnoe           .E  . med_int . nombre de noeuds
  40  *   nele           .E  . med_int . nombre d'elements
  41  *   numnoe         .E  . med_int*. numeros des noeuds
  42  *   numele         .E  . med_int*. numeros des elements
  43  *   ngn            .E  . med_int . nombre de groupes de noeuds
  44  *   nge            .E  . med_int . nombre de groupes d'elements
  45  *   nindn          .E  . med_int . nombre d'indices dans la table
  46  *                  .   .         . des groupes de noeuds
  47  *   ninde          .E  . med_int . nombre d'indices dans la table
  48  *                  .   .         . de groupes d'elements
  49  *   nomgronoe      .E  . char*   . noms des groupes de noeuds
  50  *   nomgroele      .E  . char*   . noms des groupes d'elements
  51  *   indgronoe      .E  . int*    . table index de la table des groupes
  52  *                  .   .         . de noeuds
  53  *   indgroele      .E  . int*    . table index de la table des groupes
  54  *                  .   .         . d'elements
  55  *   tabgronoe      .E  . int*    . table des groupes de noeuds
  56  *   tabgroele      .E  . int*    . table des groupes d'elements
  57  *   nfamg          .E  . med_int . nombre de familles MED a creer
  58  *   nidnf          .E  . med_int . nombre de noms groupes associes a
  59  *                  .   .         . l'ensemble des familles MED
  60  *   newnumfam      .  S. med_int*. nouveaux numeros de familles
  61  *   newnumfamele   .  S. med_int*. nouveaux numeros de familles des
  62  *                  .   .         . elements
  63  *   newnumfamnoe   .  S. med_int*. nouveaux numeros de familles des
  64  *                  .   .         . noeuds
  65  *   newindfamgro   .  S. int*    . table des index de la table des
  66  *                  .   .         . noms de groupes associes aux familles
  67  *   newfamgro      .   . char*   . table des noms des groupes des
  68  *                  .   .         . familles
  69  *
  70  * - RESULTAT : 0
  71  *
  72  ***********************************************************************/
  73
  74 namespace med_2_1{
  75
  76 med_err
  77 MEDgro2famB (med_int nnoe,med_int nele,med_int *numnoe,med_int *numele,
  78              med_int ngn,med_int nge,med_int nindn,
  79              med_int ninde, char *nomgronoe,char *nomgroele,
  80              int *indgronoe,int *indgroele,med_int *tabgronoe,
  81              med_int *tabgroele,med_int nfamg,med_int nindf,
  82              med_int *newnumfam,med_int *newnumfamele,
  83              med_int *newnumfamnoe,int *newindfamgro,
  84              char *newfamgro)
  85 {
  86   int i,j,k;
  87
  88   med_int *famnoe, *famele, *tmp;
  89   med_int *p;
  90   med_int num;
  91   int flag,exist;
  92   int nfamn, nfame;
  93   int estfam0 = 1;
  94   int newnumnoe, newnumele;
  95   int tmp1;
  96   int existfam0 = 0;
  97   // int ind = 0;
  98
  99   famnoe = NULL;
 100   famele = NULL;
 101
 102   nfamn = 0;
 103   nfame = 0;
 104   newnumnoe = 0;
 105   newnumele = 0;
 106
 107   *newindfamgro = 0;
 108
 109   if (nfamg > 1)
 110     {
 111       /* pour chaque noeud :
 112          1 - on dresse la liste des groupes de noeuds auquel il appartient
 113          2 - en la comparant avec les listes pre-existantes, on
 114          estime s'il est necessaire de creer une nouvelle famille de noeuds.
 115          Si oui => - on cree le numero de famille que l'on reporte
 116                      dans newnumfam
 117                    - on reporte ce numero dans newnumnoe
 118                    - on met a jour la table des noms des groupes des familles
 119                      ainsi que sa table d'index
 120          Si non => on ne fait rien
 121          ATTENTION : pour la famille 0, on ne met a jour que les numeros */
 122       for (i=0;i<nnoe;i++)
 123         {
 124           if ((tmp = (med_int*) malloc(sizeof(med_int)*ngn)) == NULL)
 125             return -1;
 126           num = *(numnoe+i);
 127           for (j=0;j<ngn;j++)
 128             {
 129               flag = 0;
 130               /* on regarde si le noeud appartient au groupe */
 131               for (k=0;k<*(indgronoe+j+1)-*(indgronoe+j);k++)
 132                 if (num == *(tabgronoe+*(indgronoe+j)+k))
 133                   flag = 1;
 134               /* on met le flag a jour dans tmp */
 135               *(tmp+j) = flag;
 136             }
 137           /* on regarde si le numero de famille est 0 */
 138           estfam0 = 0;
 139           flag = 1;
 140           for (j=0;j<ngn;j++)
 141             if (*(tmp+j) == 1)
 142               flag = 0;
 143           if (flag == 1)
 144             {
 145               estfam0 = 1;
 146               *(newnumfamnoe+i) = 0;
 147             }
 148           if (flag == 1 && existfam0 == 0)
 149             existfam0 = 1;
 150           /* faut-il creer une nouvelle famille ? */
 151           if (famnoe == NULL)
 152             {
 153               exist = 0;
 154               if ((famnoe = (med_int *) malloc (sizeof(med_int)*ngn)) == NULL)
 155                 return -1;
 156               /* on met a jour la table d'indices */
 157               nfamn = 1;
 158               *(newindfamgro+nfamn) = *(newindfamgro+nfamn-1);
 159               for (j=0;j<ngn;j++)
 160                 {
 161                   tmp1 = *(tmp+j);
 162                   *(famnoe+j) = tmp1;
 163                   if (tmp1 == 1)
 164                     {
 165                       strncpy(newfamgro+*(newindfamgro+nfamn),
 166                               nomgronoe+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
 167                       *(newindfamgro+nfamn) = *(newindfamgro+nfamn) +
 168                         MED_TAILLE_LNOM;
 169                     }
 170                 }
 171               if (estfam0 == 0)
 172                 {
 173                   newnumnoe = 1;
 174                   *newnumfamnoe = newnumnoe;
 175                   *newnumfam = newnumnoe;
 176                 }
 177               else
 178                 *newnumfam = 0;
 179             }
 180           else
 181             {
 182               for (j=0;j<nfamn;j++)
 183                 {
 184                   p = famnoe + ngn*j;
 185                   for (k=0;k<ngn;k++)
 186                     {
 187                       if (*(p+k) != *(tmp+k))
 188                         {
 189                           exist = 0;
 190                           break;
 191                         }
 192                       else
 193                         exist = 1;
 194                     }
 195                   if (exist == 1)
 196                     {
 197                       if (estfam0 == 0)
 198                         *(newnumfamnoe+i) = *(newnumfam+j);
 199                       break;
 200                     }
 201                 }
 202               if (exist == 0)
 203                 {
 204                   nfamn = nfamn + 1;
 205                   *(newindfamgro+nfamn) = *(newindfamgro+nfamn-1);
 206                   p = famnoe;
 207                   if ((famnoe = (med_int*) malloc(sizeof(med_int)*ngn*nfamn))
 208                       == NULL)
 209                     return -1;
 210                   for (j=0;j<nfamn-1;j++)
 211                     for (k=0;k<ngn;k++)
 212                       *(famnoe+j*ngn+k) = *(p+j*ngn+k);
 213                   free(p);
 214                   p = famnoe+(nfamn-1)*ngn;
 215                   for (j=0;j<ngn;j++)
 216                     {
 217                       tmp1 = *(tmp+j);
 218                       *(p+j) = tmp1;
 219                       if (tmp1 == 1)
 220                         {
 221                           strncpy(newfamgro+*(newindfamgro+nfamn),
 222                                   nomgronoe+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
 223                       *(newindfamgro+nfamn) = *(newindfamgro + nfamn)
 224                         + MED_TAILLE_LNOM;
 225                         }
 226                     }
 227                   if (estfam0 == 0)
 228                     {
 229                       newnumnoe = newnumnoe + 1;
 230                       *(newnumfamnoe+i) = newnumnoe;
 231                       *(newnumfam+nfamn-1) = newnumnoe;
 232                     }
 233                   else
 234                     *(newnumfam+nfamn-1) = 0;
 235                 }
 236             }
 237           free(tmp);
 238         }
 239
 240       /* pour chaque element :
 241          1 - on dresse la liste des groupes de noeuds auquel il appartient
 242          2 - en la comparant avec les listes pre-existantes, on
 243          estime s'il est necessaire de creer une nouvelle famille d'elements.
 244          Si oui => - on cree le numero de famille que l'on reporte
 245                      dans newnumfam
 246                    - on reporte ce numero dans newnumele
 247                    - on met a jour la table des noms des groupes des familles
 248                      ainsi que sa table d'index
 249          Si non => on ne fait rien
 250          ATTENTION : pour la famille 0, on ne met a jour que les numeros */
 251       for (i=0;i<nele;i++)
 252         {
 253           if ((tmp = (med_int*) malloc(sizeof(med_int)*nge)) == NULL)
 254             return -1;
 255           num = *(numele+i);
 256           for (j=0;j<nge;j++)
 257             {
 258               flag = 0;
 259               /* on regarde si l'element appartient au groupe */
 260               for (k=0;k<*(indgroele+j+1)-*(indgroele+j);k++)
 261                 if (num == *(tabgroele+*(indgroele+j)+k))
 262                   flag = 1;
 263               /* on met le flag a jour dans tmp */
 264               *(tmp+j) = flag;
 265             }
 266           /* on regarde si le numero de famille est 0 */
 267           estfam0 = 0;
 268           flag = 1;
 269           for (j=0;j<nge;j++)
 270             if (*(tmp+j) == 1)
 271               flag = 0;
 272           if (flag == 1)
 273             {
 274               estfam0 = 1;
 275               *(newnumfamele+i) = 0;
 276             }
 277           /* faut-il creer une nouvelle famille ? */
 278           if (famele == NULL)
 279             {
 280               if (!(estfam0&&existfam0))
 281                 {
 282                   exist = 0;
 283                   if ((famele = (med_int *) malloc (sizeof(med_int)*nge))
 284                       == NULL)
 285                     return -1;
 286                   nfame = 1;
 287                   *(newindfamgro+nfamn+nfame) = *(newindfamgro+nfamn+nfame-1);
 288                   for (j=0;j<nge;j++)
 289                     {
 290                       tmp1 = *(tmp+j);
 291                       *(famele+j) = tmp1;
 292                       if (tmp1 == 1)
 293                         {
 294                           strncpy(newfamgro+*(newindfamgro+nfamn+nfame),
 295                                   nomgroele+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
 296                           *(newindfamgro+nfamn+nfame) = *(newindfamgro+nfamn+nfame)
 297                             + MED_TAILLE_LNOM;
 298                         }
 299                     }
 300                   if (estfam0 == 0)
 301                     {
 302                       newnumele = -1;
 303                       *(newnumfamele+i) = newnumele;
 304                       *(newnumfam+nfamn+nfame-1) = newnumele;
 305                     }
 306                   else
 307                     {
 308                       newnumele = 0;
 309                       *(newnumfam+nfamn+nfame-1) = newnumele;
 310                       existfam0 = 1;
 311                     }
 312                 }
 313             }
 314           else
 315             {
 316               for (j=0;j<nfame;j++)
 317                 {
 318                   p = famele + nge*j;
 319                   for (k=0;k<nge;k++)
 320                     {
 321                       if (*(p+k) != *(tmp+k))
 322                         {
 323                           exist = 0;
 324                           break;
 325                         }
 326                       else
 327                         exist = 1;
 328                     }
 329                   if (exist == 1)
 330                     {
 331                       if (estfam0 == 0)
 332                         *(newnumfamele+i) = *(newnumfam+nfamn+j);
 333                       break;
 334                     }
 335                 }
 336               if (exist == 0 && !(estfam0 && existfam0))
 337                 /* on cree une nouvelle famille */
 338                 {
 339                   nfame = nfame + 1;
 340                   *(newindfamgro+nfamn+nfame) = *(newindfamgro+nfamn+nfame-1);
 341                   p = famele;
 342                   if ((famele = (med_int*) malloc(sizeof(med_int)*nge*nfame))
 343                       == NULL)
 344                     return -1;
 345                   for (j=0;j<nfame-1;j++)
 346                     for (k=0;k<nge;k++)
 347                       *(famele+j*nge+k) = *(p+j*nge+k);
 348                   free(p);
 349                   p = famele+(nfame-1)*nge;
 350                   for (j=0;j<nge;j++)
 351                     {
 352                       tmp1 = *(tmp+j);
 353                       *(p+j) = tmp1;
 354                       if (tmp1 == 1)
 355                         {
 356                           strncpy((newfamgro+*(newindfamgro+nfamn+nfame)),
 357                                   nomgroele+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
 358                           *(newindfamgro+nfamn+nfame) =
 359                             *(newindfamgro+nfamn+nfame) + MED_TAILLE_LNOM;
 360                         }
 361                     }
 362                   if (estfam0 == 0)
 363                     {
 364                       newnumele = newnumele - 1;
 365                       *(newnumfamele+i) = newnumele;
 366                       *(newnumfam+nfamn+nfame-1) = newnumele;
 367                     }
 368                   else
 369                     if (existfam0 == 0)
 370                       {
 371                         *(newnumfam+nfamn+nfame-1) = 0;
 372                         existfam0 =1;
 373                       }
 374                 }
 375             }
 376           free(tmp);
 377         }
 378
 379       *(newfamgro+MED_TAILLE_LNOM*nindf) = '\0';
 380
 381       free(famnoe);
 382       free(famele);
 383     }
 384   else
 385     {
 386       *newnumfam = 0;
 387       for (i=0;i<nele;i++)
 388         *(newnumfamele+i) = 0;
 389       for (i=0;i<nnoe;i++)
 390         *(newnumfamnoe+i) = 0;
 391     }
 392
 393   return 0;
 394 }
 395
 396 }