Back to index

salome-med  6.5.0
MEDgro2famA.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 
00020 #include <stdio.h>
00021 #include <stdlib.h>
00022 
00023 #include "med.hxx"
00024 
00025 /***********************************************************************
00026  * FONCTION MEDgro2famA
00027  * 
00028  * - DESCRIPTION : 1ere etape dans la conversion des groupes de noeuds
00029  *      et d'elements en familles MED. 
00030  *      Calcul des tailles des tableaux que l'on devra allouer pour
00031  *      stocker les familles qui seront construites par MEDgro2famB().
00032  *      Les parametres renvoyes sont :
00033  *      1 - le nombre de familles MED a creer (nfamg)
00034  *      2 - le nombre de noms groupes associes a l'ensemble des familles
00035  *      MED (nindf)
00036  *      Ces parametres doivent permettre a l'appelant de creer les tables
00037  *      suivantes : 
00038  *      1 - une table des noms des groupes propres a chaque famille,
00039  *      de taille : nindf*MED_TAILLE_LNOM+1
00040  *      2 - une table d'index donnant pour chaque famille son numero d'indice
00041  *      dans la table des noms, de taille : nfamg+1
00042  *      3 - une table destinee a contenir la liste des numeros de familles
00043  *          a creer, de taille : nfamg
00044  *
00045  * - PARAMETRES :
00046  *   NOM            .E/S. TYPE    .  DESCRIPTION
00047  *   ------------------------------------------------------------------- 
00048  *   nnoe           .E  . med_int . nombre de noeuds 
00049  *   nele           .E  . med_int . nombre d'elements 
00050  *   numnoe         .E  . med_int*. numeros des noeuds
00051  *   numele         .E  . med_int*. numeros des elements
00052  *   ngn            .E  . med_int . nombre de groupes de noeuds
00053  *   nge            .E  . med_int . nombre de groupes d'elements
00054  *   nindn          .E  . med_int . nombre d'indices dans la table
00055  *                  .   .         . des groupes de noeuds
00056  *   ninde          .E  . med_int . nombre d'indices dans la table
00057  *                  .   .         . de groupes d'elements
00058  *   indgronoe      .E  . int*    . table index de la table des groupes
00059  *                  .   .         . de noeuds
00060  *   indgroele      .E  . int*    . table index de la table des groupes
00061  *                  .   .         . d'elements
00062  *   tabgronoe      .E  . med_int*. table des groupes de noeuds
00063  *   tabgroele      .E  . med_int*. table des groupes d'elements
00064  *   nfamg          .  S. med_int*. nombre de familles MED a creer
00065  *   nidnf          .  S. med_int*. nombre de noms groupes associes a 
00066  *                  .   .         . l'ensemble des familles MED
00067  *
00068  * - RESULTAT : 0 si succes, -1 sinon
00069  * 
00070  ***********************************************************************/
00071 
00072 namespace med_2_1{
00073 
00074 med_err 
00075 MEDgro2famA (med_int nnoe,med_int nele,med_int *numnoe,med_int *numele,
00076              med_int ngn,med_int nge,med_int nindn, 
00077              med_int ninde,int *indgronoe,int *indgroele,med_int *tabgronoe, 
00078              med_int *tabgroele,med_int *nfamg,med_int *nindf)
00079 {
00080   int i,j,k;
00081   int *famnoe,*famele,*tmp;
00082   int *p;
00083   int flag, num,exist;
00084   int nfamn, nfame;
00085   int fam01 = 0;
00086   int fam02 = 0;
00087 
00088   /* initialisations */
00089   famnoe = NULL;
00090   famele = NULL;
00091 
00092   *nfamg = 0;
00093   *nindf = 0;
00094   nfamn = 0;
00095   nfame = 0;
00096 
00097   if ((ngn > 0) || (nge > 0))
00098     {
00099       /* pour chaque noeud :
00100          1 - on dresse la liste des groupes de noeuds auquel il appartient
00101          2 - en la comparant avec les listes pre-existantes, on
00102          estime s'il est necessaire de creer une nouvelle famille de noeuds.
00103          Si oui => on incremente le compteur local nfamn (nombre de familles
00104                    de noeuds)
00105                    on incremente le parametre nindf du nombre de groupes
00106                    que devra compter cette famille de noeuds
00107          Si non => on ne fait rien */
00108       for (i=0;i<nnoe;i++)
00109         {
00110           if ((tmp = (int*) malloc(sizeof(int)*ngn)) == NULL)
00111             return -1;
00112           num = *(numnoe+i);
00113           for (j=0;j<ngn;j++)
00114             {
00115               flag = 0;
00116               /* on regarde si le noeud appartient au groupe */
00117               for (k=0;k<*(indgronoe+j+1)-*(indgronoe+j);k++)
00118                 if (num == *(tabgronoe+*(indgronoe+j)+k))
00119                   flag = 1;
00120               /* on met le flag a jour dans tmp */
00121               *(tmp+j) = flag;
00122             }
00123           /* on note la creation de la famille 0 */
00124           if (fam01 == 0)
00125             {
00126               flag = 1;
00127               for (j=0;j<ngn;j++)
00128                 if (*(tmp+j) == 1)
00129                   flag = 0;
00130               if (flag == 1)
00131                 fam01 = 1;
00132             }
00133           /* faut-il creer une nouvelle famille ? */
00134           if (famnoe == NULL)
00135             {
00136               exist = 0;
00137               if ((famnoe = (int *) malloc (sizeof(int)*ngn)) == NULL)
00138                 return -1;
00139               for (j=0;j<ngn;j++)
00140                 {
00141                   *(famnoe+j) = *(tmp+j);
00142                   if (*(famnoe+j) == 1)
00143                     *nindf = *nindf + 1;
00144                 }
00145               nfamn = 1;
00146             }
00147           else
00148             {
00149               for (j=0;j<nfamn;j++)
00150                 {
00151                   p = famnoe + ngn*j;
00152                   for (k=0;k<ngn;k++)
00153                     {
00154                       if (*(p+k) != *(tmp+k))
00155                         {
00156                           exist = 0;
00157                           break;
00158                         }
00159                       else
00160                         exist = 1;
00161                     }
00162                   if (exist == 1)
00163                     break;
00164                 }
00165               if (exist == 0)
00166                 {
00167                   nfamn = nfamn + 1;
00168                   p = famnoe;
00169                   if ((famnoe = (int*) malloc(sizeof(int)*ngn*nfamn)) == NULL)
00170                     return -1;
00171                   for (j=0;j<nfamn-1;j++)
00172                     for (k=0;k<ngn;k++)
00173                       *(famnoe+j*ngn+k) = *(p+j*ngn+k);
00174                   free(p);
00175                   p = famnoe+(nfamn-1)*ngn;
00176                   for (j=0;j<ngn;j++)
00177                     {
00178                       *(p+j) = *(tmp+j);
00179                       if (*(p+j) == 1)
00180                         *nindf = *nindf + 1;
00181                     }
00182                 }
00183             }
00184           free(tmp);
00185         }
00186       
00187       /* pour chaque element : idem que pour les noeuds */
00188       for (i=0;i<nele;i++)
00189         {
00190           if ((tmp = (int*) malloc(sizeof(int)*nge)) == NULL)
00191             return -1;
00192           num = *(numele+i);
00193           for (j=0;j<nge;j++)
00194             {
00195               flag = 0;
00196               /* on regarde si l'element appartient au groupe */
00197               for (k=0;k<*(indgroele+j+1)-*(indgroele+j);k++)
00198                 if (num == *(tabgroele+*(indgroele+j)+k))
00199                   flag = 1;
00200               /* on met le flag a jour dans tmp */
00201               *(tmp+j) = flag;
00202             }
00203           /* on note la creation de la famille 0 */
00204           if (fam02 == 0)
00205             {
00206               flag = 1;
00207               for (j=0;j<nge;j++)
00208                 if (*(tmp+j) == 1)
00209                   flag = 0;
00210               if (flag == 1)
00211                 fam02 = 1;
00212             }
00213           /* faut-il creer une nouvelle famille ? */
00214           if (famele == NULL)
00215             {
00216               exist = 0;
00217               if ((famele = (int *) malloc (sizeof(int)*nge)) == NULL)
00218                 return -1;
00219               for (j=0;j<nge;j++)
00220                 {
00221                   *(famele+j) = *(tmp+j);
00222                   if (*(famele+j) == 1)
00223                     *nindf = *nindf + 1;
00224                 }
00225               nfame = 1;
00226             }
00227           else
00228             {
00229               for (j=0;j<nfame;j++)
00230                 {
00231                   p = famele + nge*j;
00232                   for (k=0;k<nge;k++)
00233                     {
00234                       if (*(p+k) != *(tmp+k))
00235                         {
00236                           exist = 0;
00237                           break;
00238                         }
00239                       else
00240                         exist = 1;
00241                     }
00242                   if (exist == 1)
00243                     break;
00244                 }
00245               if (exist == 0)
00246                 {
00247                   nfame = nfame + 1;
00248                   p = famele;
00249                   if ((famele = (int*) malloc(sizeof(int)*nge*nfame)) == NULL)
00250                     return -1;
00251                   for (j=0;j<nfame-1;j++)
00252                     for (k=0;k<nge;k++)
00253                       *(famele+j*nge+k) = *(p+j*nge+k);
00254                   free(p);
00255                   p = famele+(nfame-1)*nge;
00256                   for (j=0;j<nge;j++)
00257                     {
00258                       *(p+j) = *(tmp+j);
00259                       if (*(p+j) == 1)
00260                         *nindf = *nindf + 1;
00261                     }
00262                 }
00263             }
00264           free(tmp);
00265         }
00266       
00267       /* la famille 0 existe pour les noeuds et les elements, on 
00268          ne la compte qu'une fois */
00269       if (fam01 && fam02)
00270         nfamn = nfamn - 1;
00271       
00272       /* le nombre de familles a creer est egal au nombre de familles
00273          de noeuds + nombre de familles d'elements */
00274       *nfamg = nfamn + nfame;
00275       
00276       
00277       /* Nettoyage memoire */
00278       free(famnoe);
00279       free(famele);
00280     }  
00281   else
00282     {
00283       /* on a aucun groupes de noeuds ou d'elements */
00284       *nfamg = 1; /* on a au moins la famille 0 */
00285       *nindf = 0;
00286     }
00287 
00288   return 0;
00289 }
00290 
00291 }