src/MEDWrapper/V2_1/Core/MEDfam2groB.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 #include <string.h>
  23 #include "med.hxx"
  24
  25 /***********************************************************************
  26  * FONCTION MEDfam2groB
  27  *
  28  * - DESCRIPTION : 2e etape dans la conversion des familles MED en
  29  *      groupes de noeuds et d'elements. Les tables allouees a partir
  30  *      des parametres calcules par MEDfam2groA() sont passees en argument
  31  *      a MEDfam2groB et remplies par cette derniere fonction.
  32  *      Il s'agit de :
  33  *      1 - la table des noms de groupes de noeuds, chaque nom ayant
  34  *          une taille de MED_TAILLE_LNOM
  35  *      2 - la table des noms des groupes d'elements
  36  *      3 - la table des groupes de noeuds -i.e. pour chaque groupe
  37  *          la liste des numeros des noeuds qui le composent
  38  *      4 - la table d'indexation de la table des groupes de noeuds
  39  *      5 - la table des groupes d'elements
  40  *      6 - la table d'indexation de la table des groupes d'elements
  41  *
  42  * - PARAMETRES :
  43  *   NOM            .E/S. TYPE    . DESCRIPTION
  44  *   -------------------------------------------------------------------
  45  *   nfam           .E  . med_int . nombre de familles
  46  *   numfam         .E  . med_int*. table des numeros de familles
  47  *   numfamnoe      .E  . med_int*. table des numeros de familles
  48  *                  .   .         . des noeuds
  49  *   nnoeuds        .E  . med_int . nombre de noeuds
  50  *   numfamele      .E  . med_int*. table des numeros de familles
  51  *                  .   .         . des elements
  52  *   nelememts      .E  . med_int . nombre total d'elements
  53  *   grofam         .E  . char*   . liste des groupes de familles
  54  *   indfamgro      .E  . int*    . liste des indices des groupes
  55  *                  .   .         . de familles dans indfamgro
  56  *   numnoeuds      .E  . med_int*. numeros des noeuds
  57  *   numele         .E  . med_int*. numeros des elements
  58  *   ngn            .E  . med_int . nombre de groupes de noeuds
  59  *   nge            .E  . med_int . nombre de groupes d'elements
  60  *   nindn          .E  . med_int . nombre d'indices dans la table
  61  *                  .             . des groupes de noeuds a creer
  62  *   ninde          .E  . med_int . nombre d'indices dans la table
  63  *                  .             . des groupes d'elements
  64  *   nomgronoe      .  S. char*   . noms des groupes de noeuds
  65  *   nomgroele      .  S. char*   . noms des groupes d'elements
  66  *   indgronoe      .  S. int*    . indices des groupes de noeuds
  67  *   indgroele      .  S. int*    . indices des groupes d'elements
  68  *   tabgronoe      .  S. med_int*. table des groupes de noeuds
  69  *   tabgroele      .  S. med_int*. table des groupes d'elements
  70  *
  71  * - RESULTAT : 0
  72  *
  73  ***********************************************************************/
  74
  75 namespace med_2_1{
  76
  77 med_err
  78 MEDfam2groB(med_int nfam,med_int *numfam,med_int *numfamnoe,
  79             med_int nnoeuds,med_int *numfamele,med_int nelements,
  80             char *grofam,int *indfamgro,med_int *numnoeuds,
  81             med_int *numele,med_int ngn,med_int nge,med_int nindn,
  82             med_int ninde,char *nomgronoe,char *nomgroele,
  83             int *indgronoe,int *indgroele,
  84             med_int *tabgronoe,med_int *tabgroele)
  85 {
  86   int i,j,k;
  87   char groupe[MED_TAILLE_LNOM];
  88   med_int numc;
  89   int nnoe = 0, nele = 0;
  90   int flag = 0;
  91   int nn = 0, ne = 0;
  92   int pos, cpt;
  93
  94   /* initialisations */
  95   for (i=0;i<=ngn;i++)
  96     *(indgronoe+i) = 0;
  97   for (i=0;i<=nge;i++)
  98     *(indgroele+i) = 0;
  99
 100   /* 1ere passe : on passe en revue toutes les familles :
 101      1 - on etablit dans (nomgronoe) et dans (nomgroele) les listes
 102      des noms de groupes de noeuds et d'elements
 103      2 - on place dans les tables d'index (indgronoe) et (indgroele)
 104      le nombre de noeuds ou d'elements que chaque groupe se verra
 105      attribuer */
 106   for (i=1;i<=nfam;i++)
 107       {
 108         numc = *(numfam+i-1);
 109         nnoe = 0;
 110         nele = 0;
 111         if (numc > 0)
 112             for (j=0;j<nnoeuds;j++)
 113               if (*(numfamnoe+j) == numc)
 114                 nnoe++;
 115         if (numc < 0)
 116           for (j=0;j<nelements;j++)
 117             if (*(numfamele+j) == numc)
 118               nele++;
 119         for (j=0;j<(*(indfamgro+i)-*(indfamgro+i-1))/MED_TAILLE_LNOM; j++)
 120           {
 121             strncpy(groupe, grofam+*(indfamgro+i-1)+j*MED_TAILLE_LNOM,
 122                     MED_TAILLE_LNOM);
 123             if (numc > 0)
 124               {
 125                 if (nn == 0)
 126                   {
 127                     strncpy(nomgronoe,groupe,MED_TAILLE_LNOM);
 128                     nn = 1;
 129                     pos = 1;
 130                   }
 131                 else
 132                   {
 133                     flag = 0;
 134                     for (k=0; k<nn;k++)
 135                       if (strncmp(groupe,nomgronoe+k*MED_TAILLE_LNOM,
 136                                   MED_TAILLE_LNOM) == 0)
 137                         {
 138                           flag = 1;
 139                           pos = k+1;
 140                         }
 141                     if (flag == 0)
 142                       {
 143                         strncpy(nomgronoe+nn*MED_TAILLE_LNOM,groupe,
 144                                 MED_TAILLE_LNOM);
 145                         pos = nn + 1;
 146                         nn = nn + 1;
 147                       }
 148                   }
 149                 *(indgronoe+pos) = *(indgronoe+pos) + nnoe;
 150               }
 151             if (numc < 0)
 152               {
 153                 if (ne == 0)
 154                   {
 155                     strncpy(nomgroele,groupe,MED_TAILLE_LNOM);
 156                     ne = 1;
 157                     pos = 1;
 158                   }
 159                 else
 160                   {
 161                     flag = 0;
 162                     for (k=0; k<ne;k++)
 163                       if (strncmp(groupe,nomgroele+k*MED_TAILLE_LNOM,
 164                                   MED_TAILLE_LNOM) == 0)
 165                         {
 166                           flag = 1;
 167                           pos = k + 1;
 168                         }
 169                     if (flag == 0)
 170                       {
 171                         strncpy(nomgroele+ne*MED_TAILLE_LNOM,groupe,
 172                                 MED_TAILLE_LNOM);
 173                         pos = ne + 1;
 174                         ne = ne + 1;
 175                       }
 176                   }
 177                 *(indgroele+pos) = *(indgroele+pos) + nele;
 178               }
 179           }
 180       }
 181   *(nomgronoe+ngn*MED_TAILLE_LNOM) = '\0';
 182   *(nomgroele+nge*MED_TAILLE_LNOM) = '\0';
 183
 184   /* 2e passe : on construit les listes des index ainsi que les
 185      les tables des groupes */
 186   for (i=1;i<=ngn;i++)
 187     {
 188       cpt = 0;
 189       *(indgronoe+i) = *(indgronoe+i-1) + *(indgronoe+i);
 190       strncpy(groupe,nomgronoe+(i-1)*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
 191       for (j=1;j<=nfam;j++)
 192           {
 193             numc = *(numfam+j-1);
 194             if (numc > 0)
 195               {
 196                 flag = 0;
 197                 for (k=0;k<(*(indfamgro+j)-*(indfamgro+j-1))/MED_TAILLE_LNOM;
 198                      k++)
 199                   if (! strncmp(groupe,
 200                                 grofam+*(indfamgro+j-1)+k*MED_TAILLE_LNOM,
 201                                 MED_TAILLE_LNOM))
 202                     flag = 1;
 203                 if (flag == 1)
 204                   for (k=0;k<nnoeuds;k++)
 205                     if (*(numfamnoe+k) == numc)
 206                       {
 207                         *(tabgronoe+*(indgronoe+i-1)+cpt) = *(numnoeuds+k);
 208                         cpt++;
 209                       }
 210               }
 211           }
 212     }
 213
 214   for (i=1;i<=nge;i++)
 215     {
 216       cpt = 0;
 217       *(indgroele+i) = *(indgroele+i-1) + *(indgroele+i);
 218       strncpy(groupe,nomgroele+(i-1)*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
 219       for (j=1;j<=nfam;j++)
 220           {
 221             numc = *(numfam+j-1);
 222             if (numc < 0)
 223               {
 224                 flag = 0;
 225                 for (k=0;k<(*(indfamgro+j)-*(indfamgro+j-1))/MED_TAILLE_LNOM;
 226                      k++)
 227                   if (! strncmp(groupe,
 228                                 grofam+*(indfamgro+j-1)+k*MED_TAILLE_LNOM,
 229                                 MED_TAILLE_LNOM))
 230                     flag = 1;
 231                 if (flag == 1)
 232                   for (k=0;k<nelements;k++)
 233                     if (*(numfamele+k) == numc)
 234                       {
 235                         *(tabgroele+*(indgroele+i-1)+cpt) = *(numele+k);
 236                         cpt++;
 237                       }
 238               }
 239           }
 240     }
 241
 242   return 0;
 243 }
 244
 245 }