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.
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.
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
17 *************************************************************************/
25 /***********************************************************************
26 * FONCTION MEDgro2famA
28 * - DESCRIPTION : 1ere etape dans la conversion des groupes de noeuds
29 * et d'elements en familles MED.
30 * Calcul des tailles des tableaux que l'on devra allouer pour
31 * stocker les familles qui seront construites par MEDgro2famB().
32 * Les parametres renvoyes sont :
33 * 1 - le nombre de familles MED a creer (nfamg)
34 * 2 - le nombre de noms groupes associes a l'ensemble des familles
36 * Ces parametres doivent permettre a l'appelant de creer les tables
38 * 1 - une table des noms des groupes propres a chaque famille,
39 * de taille : nindf*MED_TAILLE_LNOM+1
40 * 2 - une table d'index donnant pour chaque famille son numero d'indice
41 * dans la table des noms, de taille : nfamg+1
42 * 3 - une table destinee a contenir la liste des numeros de familles
43 * a creer, de taille : nfamg
46 * NOM .E/S. TYPE . DESCRIPTION
47 * -------------------------------------------------------------------
48 * nnoe .E . med_int . nombre de noeuds
49 * nele .E . med_int . nombre d'elements
50 * numnoe .E . med_int*. numeros des noeuds
51 * numele .E . med_int*. numeros des elements
52 * ngn .E . med_int . nombre de groupes de noeuds
53 * nge .E . med_int . nombre de groupes d'elements
54 * nindn .E . med_int . nombre d'indices dans la table
55 * . . . des groupes de noeuds
56 * ninde .E . med_int . nombre d'indices dans la table
57 * . . . de groupes d'elements
58 * indgronoe .E . int* . table index de la table des groupes
60 * indgroele .E . int* . table index de la table des groupes
62 * tabgronoe .E . med_int*. table des groupes de noeuds
63 * tabgroele .E . med_int*. table des groupes d'elements
64 * nfamg . S. med_int*. nombre de familles MED a creer
65 * nidnf . S. med_int*. nombre de noms groupes associes a
66 * . . . l'ensemble des familles MED
68 * - RESULTAT : 0 si succes, -1 sinon
70 ***********************************************************************/
75 MEDgro2famA (med_int nnoe,med_int nele,med_int *numnoe,med_int *numele,
76 med_int ngn,med_int nge,med_int nindn,
77 med_int ninde,int *indgronoe,int *indgroele,med_int *tabgronoe,
78 med_int *tabgroele,med_int *nfamg,med_int *nindf)
81 int *famnoe,*famele,*tmp;
97 if ((ngn > 0) || (nge > 0))
99 /* pour chaque noeud :
100 1 - on dresse la liste des groupes de noeuds auquel il appartient
101 2 - en la comparant avec les listes pre-existantes, on
102 estime s'il est necessaire de creer une nouvelle famille de noeuds.
103 Si oui => on incremente le compteur local nfamn (nombre de familles
105 on incremente le parametre nindf du nombre de groupes
106 que devra compter cette famille de noeuds
107 Si non => on ne fait rien */
110 if ((tmp = (int*) malloc(sizeof(int)*ngn)) == NULL)
116 /* on regarde si le noeud appartient au groupe */
117 for (k=0;k<*(indgronoe+j+1)-*(indgronoe+j);k++)
118 if (num == *(tabgronoe+*(indgronoe+j)+k))
120 /* on met le flag a jour dans tmp */
123 /* on note la creation de la famille 0 */
133 /* faut-il creer une nouvelle famille ? */
137 if ((famnoe = (int *) malloc (sizeof(int)*ngn)) == NULL)
141 *(famnoe+j) = *(tmp+j);
142 if (*(famnoe+j) == 1)
149 for (j=0;j<nfamn;j++)
154 if (*(p+k) != *(tmp+k))
169 if ((famnoe = (int*) malloc(sizeof(int)*ngn*nfamn)) == NULL)
171 for (j=0;j<nfamn-1;j++)
173 *(famnoe+j*ngn+k) = *(p+j*ngn+k);
175 p = famnoe+(nfamn-1)*ngn;
187 /* pour chaque element : idem que pour les noeuds */
190 if ((tmp = (int*) malloc(sizeof(int)*nge)) == NULL)
196 /* on regarde si l'element appartient au groupe */
197 for (k=0;k<*(indgroele+j+1)-*(indgroele+j);k++)
198 if (num == *(tabgroele+*(indgroele+j)+k))
200 /* on met le flag a jour dans tmp */
203 /* on note la creation de la famille 0 */
213 /* faut-il creer une nouvelle famille ? */
217 if ((famele = (int *) malloc (sizeof(int)*nge)) == NULL)
221 *(famele+j) = *(tmp+j);
222 if (*(famele+j) == 1)
229 for (j=0;j<nfame;j++)
234 if (*(p+k) != *(tmp+k))
249 if ((famele = (int*) malloc(sizeof(int)*nge*nfame)) == NULL)
251 for (j=0;j<nfame-1;j++)
253 *(famele+j*nge+k) = *(p+j*nge+k);
255 p = famele+(nfame-1)*nge;
267 /* la famille 0 existe pour les noeuds et les elements, on
268 ne la compte qu'une fois */
272 /* le nombre de familles a creer est egal au nombre de familles
273 de noeuds + nombre de familles d'elements */
274 *nfamg = nfamn + nfame;
277 /* Nettoyage memoire */
283 /* on a aucun groupes de noeuds ou d'elements */
284 *nfamg = 1; /* on a au moins la famille 0 */