src/MEDWrapper/V2_1/MEDgro2famA.cxx

   1 // Copyright (C) 2005  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   2 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   3 //
   4 // This library is free software; you can redistribute it and/or
   5 // modify it under the terms of the GNU Lesser General Public
   6 // License as published by the Free Software Foundation; either
   7 // version 2.1 of the License.
   8 //
   9 // This library is distributed in the hope that it will be useful
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 // Lesser General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Lesser General Public
  15 // License along with this library; if not, write to the Free Software
  16 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 //
  18 // See http://www.salome-platform.org/
  19 //
  20 /*************************************************************************
  21 * COPYRIGHT (C) 1999 - 2002  EDF R&D
  22 * THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
  23 * IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE
  24 * AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION;
  25 * EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
  26 *
  27 * THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  28 * WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  29 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  30 * LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  31 *
  32 * YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
  33 * ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
  34 * INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
  35 *
  36 *************************************************************************/
  37
  38
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41
  42 #include "med.hxx"
  43
  44 /***********************************************************************
  45  * FONCTION MEDgro2famA
  46  *
  47  * - DESCRIPTION : 1ere etape dans la conversion des groupes de noeuds
  48  *      et d'elements en familles MED.
  49  *      Calcul des tailles des tableaux que l'on devra allouer pour
  50  *      stocker les familles qui seront construites par MEDgro2famB().
  51  *      Les parametres renvoyes sont :
  52  *      1 - le nombre de familles MED a creer (nfamg)
  53  *      2 - le nombre de noms groupes associes a l'ensemble des familles
  54  *      MED (nindf)
  55  *      Ces parametres doivent permettre a l'appelant de creer les tables
  56  *      suivantes :
  57  *      1 - une table des noms des groupes propres a chaque famille,
  58  *      de taille : nindf*MED_TAILLE_LNOM+1
  59  *      2 - une table d'index donnant pour chaque famille son numero d'indice
  60  *      dans la table des noms, de taille : nfamg+1
  61  *      3 - une table destinee a contenir la liste des numeros de familles
  62  *          a creer, de taille : nfamg
  63  *
  64  * - PARAMETRES :
  65  *   NOM            .E/S. TYPE    .  DESCRIPTION
  66  *   -------------------------------------------------------------------
  67  *   nnoe           .E  . med_int . nombre de noeuds
  68  *   nele           .E  . med_int . nombre d'elements
  69  *   numnoe         .E  . med_int*. numeros des noeuds
  70  *   numele         .E  . med_int*. numeros des elements
  71  *   ngn            .E  . med_int . nombre de groupes de noeuds
  72  *   nge            .E  . med_int . nombre de groupes d'elements
  73  *   nindn          .E  . med_int . nombre d'indices dans la table
  74  *                  .   .         . des groupes de noeuds
  75  *   ninde          .E  . med_int . nombre d'indices dans la table
  76  *                  .   .         . de groupes d'elements
  77  *   indgronoe      .E  . int*    . table index de la table des groupes
  78  *                  .   .         . de noeuds
  79  *   indgroele      .E  . int*    . table index de la table des groupes
  80  *                  .   .         . d'elements
  81  *   tabgronoe      .E  . med_int*. table des groupes de noeuds
  82  *   tabgroele      .E  . med_int*. table des groupes d'elements
  83  *   nfamg          .  S. med_int*. nombre de familles MED a creer
  84  *   nidnf          .  S. med_int*. nombre de noms groupes associes a
  85  *                  .   .         . l'ensemble des familles MED
  86  *
  87  * - RESULTAT : 0 si succes, -1 sinon
  88  *
  89  ***********************************************************************/
  90
  91 namespace med_2_1{
  92
  93 med_err
  94 MEDgro2famA (med_int nnoe,med_int nele,med_int *numnoe,med_int *numele,
  95              med_int ngn,med_int nge,med_int nindn,
  96              med_int ninde,int *indgronoe,int *indgroele,med_int *tabgronoe,
  97              med_int *tabgroele,med_int *nfamg,med_int *nindf)
  98 {
  99   int i,j,k;
 100   int *famnoe,*famele,*tmp;
 101   int *p;
 102   int flag, num,exist;
 103   int nfamn, nfame;
 104   int fam01 = 0;
 105   int fam02 = 0;
 106
 107   /* initialisations */
 108   famnoe = NULL;
 109   famele = NULL;
 110
 111   *nfamg = 0;
 112   *nindf = 0;
 113   nfamn = 0;
 114   nfame = 0;
 115
 116   if ((ngn > 0) || (nge > 0))
 117     {
 118       /* pour chaque noeud :
 119          1 - on dresse la liste des groupes de noeuds auquel il appartient
 120          2 - en la comparant avec les listes pre-existantes, on
 121          estime s'il est necessaire de creer une nouvelle famille de noeuds.
 122          Si oui => on incremente le compteur local nfamn (nombre de familles
 123                    de noeuds)
 124                    on incremente le parametre nindf du nombre de groupes
 125                    que devra compter cette famille de noeuds
 126          Si non => on ne fait rien */
 127       for (i=0;i<nnoe;i++)
 128         {
 129           if ((tmp = (int*) malloc(sizeof(int)*ngn)) == NULL)
 130             return -1;
 131           num = *(numnoe+i);
 132           for (j=0;j<ngn;j++)
 133             {
 134               flag = 0;
 135               /* on regarde si le noeud appartient au groupe */
 136               for (k=0;k<*(indgronoe+j+1)-*(indgronoe+j);k++)
 137                 if (num == *(tabgronoe+*(indgronoe+j)+k))
 138                   flag = 1;
 139               /* on met le flag a jour dans tmp */
 140               *(tmp+j) = flag;
 141             }
 142           /* on note la creation de la famille 0 */
 143           if (fam01 == 0)
 144             {
 145               flag = 1;
 146               for (j=0;j<ngn;j++)
 147                 if (*(tmp+j) == 1)
 148                   flag = 0;
 149               if (flag == 1)
 150                 fam01 = 1;
 151             }
 152           /* faut-il creer une nouvelle famille ? */
 153           if (famnoe == NULL)
 154             {
 155               exist = 0;
 156               if ((famnoe = (int *) malloc (sizeof(int)*ngn)) == NULL)
 157                 return -1;
 158               for (j=0;j<ngn;j++)
 159                 {
 160                   *(famnoe+j) = *(tmp+j);
 161                   if (*(famnoe+j) == 1)
 162                     *nindf = *nindf + 1;
 163                 }
 164               nfamn = 1;
 165             }
 166           else
 167             {
 168               for (j=0;j<nfamn;j++)
 169                 {
 170                   p = famnoe + ngn*j;
 171                   for (k=0;k<ngn;k++)
 172                     {
 173                       if (*(p+k) != *(tmp+k))
 174                         {
 175                           exist = 0;
 176                           break;
 177                         }
 178                       else
 179                         exist = 1;
 180                     }
 181                   if (exist == 1)
 182                     break;
 183                 }
 184               if (exist == 0)
 185                 {
 186                   nfamn = nfamn + 1;
 187                   p = famnoe;
 188                   if ((famnoe = (int*) malloc(sizeof(int)*ngn*nfamn)) == NULL)
 189                     return -1;
 190                   for (j=0;j<nfamn-1;j++)
 191                     for (k=0;k<ngn;k++)
 192                       *(famnoe+j*ngn+k) = *(p+j*ngn+k);
 193                   free(p);
 194                   p = famnoe+(nfamn-1)*ngn;
 195                   for (j=0;j<ngn;j++)
 196                     {
 197                       *(p+j) = *(tmp+j);
 198                       if (*(p+j) == 1)
 199                         *nindf = *nindf + 1;
 200                     }
 201                 }
 202             }
 203           free(tmp);
 204         }
 205
 206       /* pour chaque element : idem que pour les noeuds */
 207       for (i=0;i<nele;i++)
 208         {
 209           if ((tmp = (int*) malloc(sizeof(int)*nge)) == NULL)
 210             return -1;
 211           num = *(numele+i);
 212           for (j=0;j<nge;j++)
 213             {
 214               flag = 0;
 215               /* on regarde si l'element appartient au groupe */
 216               for (k=0;k<*(indgroele+j+1)-*(indgroele+j);k++)
 217                 if (num == *(tabgroele+*(indgroele+j)+k))
 218                   flag = 1;
 219               /* on met le flag a jour dans tmp */
 220               *(tmp+j) = flag;
 221             }
 222           /* on note la creation de la famille 0 */
 223           if (fam02 == 0)
 224             {
 225               flag = 1;
 226               for (j=0;j<nge;j++)
 227                 if (*(tmp+j) == 1)
 228                   flag = 0;
 229               if (flag == 1)
 230                 fam02 = 1;
 231             }
 232           /* faut-il creer une nouvelle famille ? */
 233           if (famele == NULL)
 234             {
 235               exist = 0;
 236               if ((famele = (int *) malloc (sizeof(int)*nge)) == NULL)
 237                 return -1;
 238               for (j=0;j<nge;j++)
 239                 {
 240                   *(famele+j) = *(tmp+j);
 241                   if (*(famele+j) == 1)
 242                     *nindf = *nindf + 1;
 243                 }
 244               nfame = 1;
 245             }
 246           else
 247             {
 248               for (j=0;j<nfame;j++)
 249                 {
 250                   p = famele + nge*j;
 251                   for (k=0;k<nge;k++)
 252                     {
 253                       if (*(p+k) != *(tmp+k))
 254                         {
 255                           exist = 0;
 256                           break;
 257                         }
 258                       else
 259                         exist = 1;
 260                     }
 261                   if (exist == 1)
 262                     break;
 263                 }
 264               if (exist == 0)
 265                 {
 266                   nfame = nfame + 1;
 267                   p = famele;
 268                   if ((famele = (int*) malloc(sizeof(int)*nge*nfame)) == NULL)
 269                     return -1;
 270                   for (j=0;j<nfame-1;j++)
 271                     for (k=0;k<nge;k++)
 272                       *(famele+j*nge+k) = *(p+j*nge+k);
 273                   free(p);
 274                   p = famele+(nfame-1)*nge;
 275                   for (j=0;j<nge;j++)
 276                     {
 277                       *(p+j) = *(tmp+j);
 278                       if (*(p+j) == 1)
 279                         *nindf = *nindf + 1;
 280                     }
 281                 }
 282             }
 283           free(tmp);
 284         }
 285
 286       /* la famille 0 existe pour les noeuds et les elements, on
 287          ne la compte qu'une fois */
 288       if (fam01 && fam02)
 289         nfamn = nfamn - 1;
 290
 291       /* le nombre de familles a creer est egal au nombre de familles
 292          de noeuds + nombre de familles d'elements */
 293       *nfamg = nfamn + nfame;
 294
 295
 296       /* Nettoyage memoire */
 297       free(famnoe);
 298       free(famele);
 299     }
 300   else
 301     {
 302       /* on a aucun groupes de noeuds ou d'elements */
 303       *nfamg = 1; /* on a au moins la famille 0 */
 304       *nindf = 0;
 305     }
 306
 307   return 0;
 308 }
 309
 310 }