Back to index

salome-med  6.5.0
MEDfam2groA.cxx
Go to the documentation of this file.
00001 /*************************************************************************
00002 * COPYRIGHT (C) 1999 - 2002  EDF R&D
00003 * THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
00004 * IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
00005 * AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
00006 * EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
00007 *  
00008 * THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
00009 * WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
00010 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
00011 * LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
00012 *
00013 * YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
00014 * ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
00015 * INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
00016 *
00017 *************************************************************************/
00018 
00019 #include <stdio.h>
00020 #include <stdlib.h>
00021 #include <string.h>
00022 #include "med.hxx"
00023 
00024 
00025 /***********************************************************************
00026  * FONCTION MEDfam2groA
00027  * 
00028  * - DESCRIPTION : 1ere etape dans la conversion des familles de groupes
00029  *      MED en goupes de noeuds et d'elements.
00030  *      Calcul des tailles des tableaux a allouer pour stocker les
00031  *      groupes que l'on veut creer.
00032  *      Les parametres renvoyes sont :
00033  *      1 - le nombre de groupes de noeuds a creer (ngn)
00034  *      2 - le nombre de groupes d'elements (nge)
00035  *      3 - le nombre total de noeuds composant l'ensemble des groupes
00036  *          de noeuds (nindn)
00037  *      4 - le nombre total d'elements composant l'ensemble des groupes
00038  *          d'elements (ninde)
00039  *      Ces parametres doivent permettre de creer les tables suivantes :
00040  *      1 - une table de taille (nindn) contenant pour chaque groupe
00041  *          de noeuds la liste des noeuds le composant. Cette table
00042  *          sera indexee par une table de taille (ngn) qui contiendra
00043  *          pour chaque noeud un numero d'indice. Une table de taille
00044  *          (ngn) qui contiendra la liste des noms des differents
00045  *          groupes de noeuds.
00046  *      2 - idem pour les elements
00047  *      Le remplissage de ces tables est realise par la fonction 
00048  *      MEDfam2groB().
00049  *
00050  * - PARAMETRES :
00051  *   NOM            .E/S. TYPE    .  DESCRIPTION
00052  *   ------------------------------------------------------------------- 
00053  *   nfam           .E  . med_int . nombre de familles
00054  *   numfam         .E  . med_int*. table des numeros de familles
00055  *   numfamnoe      .E  . med_int*. table des numeros de familles
00056  *                  .   .         . des noeuds
00057  *   nnoeuds        .E  . med_int . nombre de noeuds
00058  *   numfamele      .E  . med_int*. table des numeros de familles
00059  *                  .   .         . des elements
00060  *   nelememts      .E  .         . nombre total d'elements
00061  *   grofam         .E  . char*   . liste des groupes de familles
00062  *   indfamgro      .E  . int*    . liste des indices des groupes
00063  *                  .   .         . de familles dans grofam
00064  *   ngn            .  S. med_int*. nombre de groupes de noeuds a
00065  *                  .             . creer
00066  *   nge            .  S. med_int*. nombre de groupes d'elements a
00067  *                  .             . creer
00068  *   nindn          .  S. med_int*. taille de la table
00069  *                  .             . des groupes de noeuds a creer
00070  *   ninde          .  S. med_int*. taille de la table
00071  *                  .             . des groupes d'elements
00072  *
00073  * - RESULTAT : 0 si succes et -1 sinon
00074  * 
00075  ***********************************************************************/
00076 
00077 namespace med_2_1{
00078 
00079 med_err 
00080 MEDfam2groA (med_int nfam,med_int *numfam,med_int *numfamnoe, 
00081              med_int nnoeuds,med_int *numfamele,med_int nelements, 
00082              char *grofam,int *indfamgro, 
00083              med_int *ngn,med_int *nge,med_int *nindn,med_int *ninde)
00084 {
00085   int i,j,k;
00086   char groupe[MED_TAILLE_LNOM];
00087   char *nomgronoe,*nomgroele,*tmp;
00088   med_int numc;
00089   int nnoe = 0,nele = 0;
00090   int flag = 0;
00091 
00092   *ngn = 0;
00093   *nge = 0;
00094   *nindn = 0;
00095   *ninde = 0;
00096   
00097   tmp = NULL;
00098   nomgronoe = NULL;
00099   nomgroele = NULL;
00100 
00101   /* Pour chaque famille, on regarde s'il y a de nouveaux groupes
00102      de noeuds ou d'elements a creer. Pour chaque nouveau groupe,
00103      on compte le nombre de noeuds ou d'elements qui devront lui etre
00104      rataches */
00105   for (i=1;i<=nfam;i++)
00106     if ((*(indfamgro+i)-*(indfamgro+i-1))/MED_TAILLE_LNOM > 0) 
00107       {
00108         /* on releve le numero de la famille courante */
00109         numc = *(numfam+i-1);
00110         nnoe = 0;
00111         nele = 0;
00112         /* si c'est une famille de noeuds, on compte le nombre de
00113            noeuds qui y sont rattaches */
00114         if (numc > 0)
00115           for (j=0;j<nnoeuds;j++)
00116             if (*(numfamnoe+j) == numc)
00117               nnoe++;
00118         /* si c'est une famille d'elements, on compte le nombre d'elements
00119            qui y sont rattaches */
00120         if (numc < 0)
00121           for (j=0;j<nelements;j++)
00122             if (*(numfamele+j) == numc)
00123               nele++;     
00124         /* on parcourt la liste des groupes de la famille et pour chaque
00125            groupe :
00126            1 - on met a jour les compteurs nindn et ninde ;
00127            2 - on verifie s'il s'agit d'un groupe deja repertorie.
00128                Si c'est le cas on ne fait rien, sinon on met a jour les
00129                compteurs ngn ou nge */
00130         for (j=0;j<(*(indfamgro+i)-*(indfamgro+i-1))/MED_TAILLE_LNOM;j++)
00131           {
00132             strncpy(groupe,grofam+*(indfamgro+i-1)+j*MED_TAILLE_LNOM,
00133                     MED_TAILLE_LNOM);
00134             if (numc > 0)
00135               {
00136                 *nindn = *nindn+nnoe;
00137                 if (*ngn == 0)
00138                   {
00139                     *ngn = 1;
00140                     if ((nomgronoe=(char*)malloc(sizeof(char)*MED_TAILLE_LNOM))
00141                          == NULL)
00142                       return -1;
00143                     strncpy(nomgronoe,groupe,MED_TAILLE_LNOM);
00144                   }
00145                 else
00146                   { 
00147                     flag = 0;
00148                     for (k=0;k<(*ngn);k++)
00149                       if (strncmp(groupe,nomgronoe+k*MED_TAILLE_LNOM,
00150                                   MED_TAILLE_LNOM) == 0)
00151                         flag = 1;
00152                     if (flag == 0)
00153                       { 
00154                         *ngn = *ngn + 1;
00155                         if ((tmp=(char*)malloc(sizeof(char)*
00156                                                MED_TAILLE_LNOM**ngn)) == NULL)
00157                           return -1;
00158                         strncpy(tmp,nomgronoe,MED_TAILLE_LNOM*(*ngn-1));
00159                         strncpy(tmp+MED_TAILLE_LNOM*(*ngn-1),groupe, 
00160                                 MED_TAILLE_LNOM);
00161                         free(nomgronoe); 
00162                         nomgronoe = tmp;
00163                       }
00164                   } 
00165               } 
00166             if (numc < 0)
00167               {
00168                 *ninde = *ninde+nele;
00169                 if (*nge == 0)
00170                   {
00171                     *nge = 1;
00172                     if ((nomgroele=(char *)malloc(sizeof(char)*
00173                                                   MED_TAILLE_LNOM)) == NULL)
00174                       return -1;
00175                     strncpy(nomgroele,groupe,MED_TAILLE_LNOM);
00176                   }
00177                 else
00178                   { 
00179                     flag = 0;
00180                     for (k=0;k<(*nge);k++)
00181                       if (strncmp(groupe,nomgroele+k*MED_TAILLE_LNOM, 
00182                                   MED_TAILLE_LNOM) == 0)
00183                         flag = 1;
00184                     if (flag == 0)
00185                       {
00186                         *nge = *nge + 1;
00187                         if ((tmp = (char*) malloc(sizeof(char)*MED_TAILLE_LNOM*
00188                                                   *nge)) == NULL)
00189                           return -1;
00190                         strncpy(tmp,nomgroele,MED_TAILLE_LNOM*(*nge-1));
00191                         strncpy(tmp+MED_TAILLE_LNOM*(*nge-1), groupe, 
00192                                 MED_TAILLE_LNOM);
00193                         free(nomgroele);
00194                         nomgroele = tmp;
00195                       }
00196                   }
00197               } 
00198           } 
00199       }
00200 
00201   /* nettoyage memoire */
00202   free(nomgronoe);
00203   free(nomgroele);
00204   
00205   return 0;
00206 }
00207 
00208 }