Back to index

salome-med  6.5.0
MEDgro2famB.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  * FONCTION MEDgro2famB
00026  * 
00027  * - DESCRIPTION : 2eme etape dans la conversion des groupes de noeuds
00028  *      et d'elements en familles MED
00029  *      Mise a jour des tables suivantes passees en parametres :
00030  *      1 - les nouveaux numeros des familles a creer
00031  *      2 - les nouveaux numeros des familles des elements
00032  *      3 - les nouveaux numeros des familles des noeuds
00033  *      4 - les noms des groupes composant ces familles
00034  *      5 - les index de la table des groupes 
00035  *
00036  * - PARAMETRES :
00037  *   NOM            .E/S. TYPE    .  DESCRIPTION
00038  *   ------------------------------------------------------------------- 
00039  *   nnoe           .E  . med_int . nombre de noeuds 
00040  *   nele           .E  . med_int . nombre d'elements 
00041  *   numnoe         .E  . med_int*. numeros des noeuds
00042  *   numele         .E  . med_int*. numeros des elements
00043  *   ngn            .E  . med_int . nombre de groupes de noeuds
00044  *   nge            .E  . med_int . nombre de groupes d'elements
00045  *   nindn          .E  . med_int . nombre d'indices dans la table
00046  *                  .   .         . des groupes de noeuds
00047  *   ninde          .E  . med_int . nombre d'indices dans la table
00048  *                  .   .         . de groupes d'elements
00049  *   nomgronoe      .E  . char*   . noms des groupes de noeuds
00050  *   nomgroele      .E  . char*   . noms des groupes d'elements
00051  *   indgronoe      .E  . int*    . table index de la table des groupes
00052  *                  .   .         . de noeuds
00053  *   indgroele      .E  . int*    . table index de la table des groupes
00054  *                  .   .         . d'elements
00055  *   tabgronoe      .E  . int*    . table des groupes de noeuds
00056  *   tabgroele      .E  . int*    . table des groupes d'elements
00057  *   nfamg          .E  . med_int . nombre de familles MED a creer
00058  *   nidnf          .E  . med_int . nombre de noms groupes associes a 
00059  *                  .   .         . l'ensemble des familles MED
00060  *   newnumfam      .  S. med_int*. nouveaux numeros de familles
00061  *   newnumfamele   .  S. med_int*. nouveaux numeros de familles des
00062  *                  .   .         . elements
00063  *   newnumfamnoe   .  S. med_int*. nouveaux numeros de familles des
00064  *                  .   .         . noeuds
00065  *   newindfamgro   .  S. int*    . table des index de la table des
00066  *                  .   .         . noms de groupes associes aux familles
00067  *   newfamgro      .   . char*   . table des noms des groupes des 
00068  *                  .   .         . familles 
00069  *
00070  * - RESULTAT : 0
00071  * 
00072  ***********************************************************************/
00073 
00074 namespace med_2_1{
00075 
00076 med_err 
00077 MEDgro2famB (med_int nnoe,med_int nele,med_int *numnoe,med_int *numele,
00078              med_int ngn,med_int nge,med_int nindn,
00079              med_int ninde, char *nomgronoe,char *nomgroele, 
00080              int *indgronoe,int *indgroele,med_int *tabgronoe, 
00081              med_int *tabgroele,med_int nfamg,med_int nindf,
00082              med_int *newnumfam,med_int *newnumfamele, 
00083              med_int *newnumfamnoe,int *newindfamgro,
00084              char *newfamgro)
00085 {
00086   int i,j,k;
00087 
00088   med_int *famnoe, *famele, *tmp;
00089   med_int *p;
00090   med_int num;
00091   int flag,exist;
00092   int nfamn, nfame;
00093   int estfam0 = 1;
00094   int newnumnoe, newnumele;
00095   int tmp1;
00096   int existfam0 = 0;
00097   // int ind = 0;
00098 
00099   famnoe = NULL;
00100   famele = NULL;
00101 
00102   nfamn = 0;
00103   nfame = 0;
00104   newnumnoe = 0;
00105   newnumele = 0;
00106 
00107   *newindfamgro = 0;
00108 
00109   if (nfamg > 1)
00110     {
00111       /* pour chaque noeud :
00112          1 - on dresse la liste des groupes de noeuds auquel il appartient
00113          2 - en la comparant avec les listes pre-existantes, on
00114          estime s'il est necessaire de creer une nouvelle famille de noeuds.
00115          Si oui => - on cree le numero de famille que l'on reporte 
00116                      dans newnumfam
00117                    - on reporte ce numero dans newnumnoe
00118                    - on met a jour la table des noms des groupes des familles
00119                      ainsi que sa table d'index  
00120          Si non => on ne fait rien 
00121          ATTENTION : pour la famille 0, on ne met a jour que les numeros */
00122       for (i=0;i<nnoe;i++)
00123         {
00124           if ((tmp = (med_int*) malloc(sizeof(med_int)*ngn)) == NULL)
00125             return -1;
00126           num = *(numnoe+i);
00127           for (j=0;j<ngn;j++)
00128             {
00129               flag = 0;
00130               /* on regarde si le noeud appartient au groupe */
00131               for (k=0;k<*(indgronoe+j+1)-*(indgronoe+j);k++)
00132                 if (num == *(tabgronoe+*(indgronoe+j)+k))
00133                   flag = 1;
00134               /* on met le flag a jour dans tmp */
00135               *(tmp+j) = flag;
00136             }
00137           /* on regarde si le numero de famille est 0 */
00138           estfam0 = 0;
00139           flag = 1;
00140           for (j=0;j<ngn;j++)
00141             if (*(tmp+j) == 1)
00142               flag = 0;
00143           if (flag == 1)
00144             {
00145               estfam0 = 1;
00146               *(newnumfamnoe+i) = 0;
00147             }
00148           if (flag == 1 && existfam0 == 0)
00149             existfam0 = 1;
00150           /* faut-il creer une nouvelle famille ? */
00151           if (famnoe == NULL)
00152             {
00153               exist = 0;
00154               if ((famnoe = (med_int *) malloc (sizeof(med_int)*ngn)) == NULL)
00155                 return -1;
00156               /* on met a jour la table d'indices */
00157               nfamn = 1;
00158               *(newindfamgro+nfamn) = *(newindfamgro+nfamn-1);
00159               for (j=0;j<ngn;j++)
00160                 {
00161                   tmp1 = *(tmp+j);
00162                   *(famnoe+j) = tmp1;
00163                   if (tmp1 == 1)
00164                     {
00165                       strncpy(newfamgro+*(newindfamgro+nfamn),
00166                               nomgronoe+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
00167                       *(newindfamgro+nfamn) = *(newindfamgro+nfamn) + 
00168                         MED_TAILLE_LNOM;
00169                     }
00170                 }
00171               if (estfam0 == 0)
00172                 {
00173                   newnumnoe = 1;
00174                   *newnumfamnoe = newnumnoe;
00175                   *newnumfam = newnumnoe;
00176                 }
00177               else
00178                 *newnumfam = 0;
00179             }
00180           else
00181             {
00182               for (j=0;j<nfamn;j++)
00183                 {
00184                   p = famnoe + ngn*j;
00185                   for (k=0;k<ngn;k++)
00186                     {
00187                       if (*(p+k) != *(tmp+k))
00188                         {
00189                           exist = 0;
00190                           break;
00191                         }
00192                       else
00193                         exist = 1;
00194                     }
00195                   if (exist == 1)
00196                     {
00197                       if (estfam0 == 0)
00198                         *(newnumfamnoe+i) = *(newnumfam+j);
00199                       break;
00200                     }
00201                 }
00202               if (exist == 0)
00203                 {
00204                   nfamn = nfamn + 1;
00205                   *(newindfamgro+nfamn) = *(newindfamgro+nfamn-1);
00206                   p = famnoe;
00207                   if ((famnoe = (med_int*) malloc(sizeof(med_int)*ngn*nfamn))
00208                       == NULL)
00209                     return -1;
00210                   for (j=0;j<nfamn-1;j++)
00211                     for (k=0;k<ngn;k++)
00212                       *(famnoe+j*ngn+k) = *(p+j*ngn+k);
00213                   free(p);
00214                   p = famnoe+(nfamn-1)*ngn;
00215                   for (j=0;j<ngn;j++)
00216                     {
00217                       tmp1 = *(tmp+j);
00218                       *(p+j) = tmp1;
00219                       if (tmp1 == 1)
00220                         {
00221                           strncpy(newfamgro+*(newindfamgro+nfamn), 
00222                                   nomgronoe+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
00223                       *(newindfamgro+nfamn) = *(newindfamgro + nfamn) 
00224                         + MED_TAILLE_LNOM;
00225                         }
00226                     }
00227                   if (estfam0 == 0)
00228                     {
00229                       newnumnoe = newnumnoe + 1;
00230                       *(newnumfamnoe+i) = newnumnoe;
00231                       *(newnumfam+nfamn-1) = newnumnoe;
00232                     }
00233                   else
00234                     *(newnumfam+nfamn-1) = 0;
00235                 }
00236             }
00237           free(tmp);
00238         }
00239       
00240       /* pour chaque element :
00241          1 - on dresse la liste des groupes de noeuds auquel il appartient
00242          2 - en la comparant avec les listes pre-existantes, on
00243          estime s'il est necessaire de creer une nouvelle famille d'elements.
00244          Si oui => - on cree le numero de famille que l'on reporte 
00245                      dans newnumfam
00246                    - on reporte ce numero dans newnumele
00247                    - on met a jour la table des noms des groupes des familles
00248                      ainsi que sa table d'index  
00249          Si non => on ne fait rien 
00250          ATTENTION : pour la famille 0, on ne met a jour que les numeros */
00251       for (i=0;i<nele;i++)
00252         {
00253           if ((tmp = (med_int*) malloc(sizeof(med_int)*nge)) == NULL)
00254             return -1;
00255           num = *(numele+i);
00256           for (j=0;j<nge;j++)
00257             {
00258               flag = 0;
00259               /* on regarde si l'element appartient au groupe */
00260               for (k=0;k<*(indgroele+j+1)-*(indgroele+j);k++)
00261                 if (num == *(tabgroele+*(indgroele+j)+k))
00262                   flag = 1;
00263               /* on met le flag a jour dans tmp */
00264               *(tmp+j) = flag;
00265             }
00266           /* on regarde si le numero de famille est 0 */
00267           estfam0 = 0;
00268           flag = 1;
00269           for (j=0;j<nge;j++)
00270             if (*(tmp+j) == 1)
00271               flag = 0;
00272           if (flag == 1)
00273             {
00274               estfam0 = 1;
00275               *(newnumfamele+i) = 0;
00276             }
00277           /* faut-il creer une nouvelle famille ? */
00278           if (famele == NULL)
00279             {
00280               if (!(estfam0&&existfam0))
00281                 {
00282                   exist = 0;
00283                   if ((famele = (med_int *) malloc (sizeof(med_int)*nge))
00284                       == NULL)
00285                     return -1;
00286                   nfame = 1;
00287                   *(newindfamgro+nfamn+nfame) = *(newindfamgro+nfamn+nfame-1);
00288                   for (j=0;j<nge;j++)
00289                     {
00290                       tmp1 = *(tmp+j);
00291                       *(famele+j) = tmp1;
00292                       if (tmp1 == 1)
00293                         {
00294                           strncpy(newfamgro+*(newindfamgro+nfamn+nfame),
00295                                   nomgroele+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
00296                           *(newindfamgro+nfamn+nfame) = *(newindfamgro+nfamn+nfame)
00297                             + MED_TAILLE_LNOM;
00298                         }
00299                     }
00300                   if (estfam0 == 0)
00301                     {
00302                       newnumele = -1;
00303                       *(newnumfamele+i) = newnumele;
00304                       *(newnumfam+nfamn+nfame-1) = newnumele;
00305                     }
00306                   else
00307                     {
00308                       newnumele = 0;
00309                       *(newnumfam+nfamn+nfame-1) = newnumele;
00310                       existfam0 = 1;
00311                     }
00312                 }
00313             }
00314           else
00315             {
00316               for (j=0;j<nfame;j++)
00317                 {
00318                   p = famele + nge*j;
00319                   for (k=0;k<nge;k++)
00320                     {
00321                       if (*(p+k) != *(tmp+k))
00322                         {
00323                           exist = 0;
00324                           break;
00325                         }
00326                       else
00327                         exist = 1;
00328                     }
00329                   if (exist == 1)
00330                     {
00331                       if (estfam0 == 0)
00332                         *(newnumfamele+i) = *(newnumfam+nfamn+j);
00333                       break;
00334                     }
00335                 }
00336               if (exist == 0 && !(estfam0 && existfam0))
00337                 /* on cree une nouvelle famille */
00338                 {
00339                   nfame = nfame + 1;
00340                   *(newindfamgro+nfamn+nfame) = *(newindfamgro+nfamn+nfame-1);
00341                   p = famele;
00342                   if ((famele = (med_int*) malloc(sizeof(med_int)*nge*nfame))
00343                       == NULL)
00344                     return -1;
00345                   for (j=0;j<nfame-1;j++)
00346                     for (k=0;k<nge;k++)
00347                       *(famele+j*nge+k) = *(p+j*nge+k);
00348                   free(p);
00349                   p = famele+(nfame-1)*nge;
00350                   for (j=0;j<nge;j++)
00351                     {
00352                       tmp1 = *(tmp+j);
00353                       *(p+j) = tmp1;
00354                       if (tmp1 == 1)
00355                         {
00356                           strncpy((newfamgro+*(newindfamgro+nfamn+nfame)), 
00357                                   nomgroele+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
00358                           *(newindfamgro+nfamn+nfame) =
00359                             *(newindfamgro+nfamn+nfame) + MED_TAILLE_LNOM;
00360                         }
00361                     }
00362                   if (estfam0 == 0)
00363                     {
00364                       newnumele = newnumele - 1;
00365                       *(newnumfamele+i) = newnumele;
00366                       *(newnumfam+nfamn+nfame-1) = newnumele;
00367                     }
00368                   else
00369                     if (existfam0 == 0)
00370                       {
00371                         *(newnumfam+nfamn+nfame-1) = 0;
00372                         existfam0 =1;
00373                       }
00374                 }
00375             }
00376           free(tmp);
00377         }
00378       
00379       *(newfamgro+MED_TAILLE_LNOM*nindf) = '\0';
00380 
00381       free(famnoe);
00382       free(famele);
00383     }
00384   else
00385     {
00386       *newnumfam = 0;
00387       for (i=0;i<nele;i++)
00388         *(newnumfamele+i) = 0;
00389       for (i=0;i<nnoe;i++)
00390         *(newnumfamnoe+i) = 0;
00391     }
00392   
00393   return 0;
00394 }
00395 
00396 }