Salome HOME
Correct some memory leaks
[modules/smesh.git] / src / DriverMED / DriverMED_W_SMESHDS_Mesh.cxx
1 //  SMESH DriverMED : driver to read and write 'med' files
2 //
3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
5 // 
6 //  This library is free software; you can redistribute it and/or 
7 //  modify it under the terms of the GNU Lesser General Public 
8 //  License as published by the Free Software Foundation; either 
9 //  version 2.1 of the License. 
10 // 
11 //  This library is distributed in the hope that it will be useful, 
12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of 
13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
14 //  Lesser General Public License for more details. 
15 // 
16 //  You should have received a copy of the GNU Lesser General Public 
17 //  License along with this library; if not, write to the Free Software 
18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
19 // 
20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
21 //
22 //
23 //
24 //  File   : DriverMED_W_SMESHDS_Mesh.cxx
25 //  Module : SMESH
26
27 using namespace std;
28 #include "DriverMED_W_SMESHDS_Mesh.h"
29 #include "DriverMED_W_SMDS_Mesh.h"
30 #include "SMDS_MeshElement.hxx"
31 #include "SMDS_MeshNode.hxx"
32 #include <TopExp.hxx>
33 #include <vector>
34 #include "utilities.h"
35
36 DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh()
37 {
38         ;
39 }
40
41 DriverMED_W_SMESHDS_Mesh::~DriverMED_W_SMESHDS_Mesh()
42 {
43         ;
44 }
45
46 void DriverMED_W_SMESHDS_Mesh::SetMesh(SMDS_Mesh * aMesh)
47 {
48         myMesh = aMesh;
49 }
50
51 void DriverMED_W_SMESHDS_Mesh::SetFile(string aFile)
52 {
53         myFile = aFile;
54 }
55
56 void DriverMED_W_SMESHDS_Mesh::SetFileId(med_idt aFileId)
57 {
58         myFileId = aFileId;
59 }
60
61 void DriverMED_W_SMESHDS_Mesh::SetMeshId(int aMeshId)
62 {
63         myMeshId = aMeshId;
64 }
65
66 void DriverMED_W_SMESHDS_Mesh::Write()
67 {
68
69         string myClass = string("SMDS_Mesh");
70         string myExtension = string("MED");
71
72         DriverMED_W_SMDS_Mesh *myWriter = new DriverMED_W_SMDS_Mesh;
73
74         myWriter->SetMesh(myMesh);
75         //  myWriter->SetFile(myFile);
76         myWriter->SetMeshId(myMeshId);
77         myWriter->SetFileId(myFileId);
78
79         myWriter->Write();
80
81 }
82
83 void DriverMED_W_SMESHDS_Mesh::Add()
84 {
85
86         med_err ret = 0;
87         int i, j, k, l;
88         int numero;
89         char message[200];
90         bool ok;
91         /* nombre d'objets MED */
92         char nom_universel[MED_TAILLE_LNOM + 1];
93         med_int long_fichier_en_tete;
94         char *fichier_en_tete;
95         char version_hdf[10];
96         char version_med[10];
97         med_int nmaa, mdim, nnoe;
98         med_int nmai[MED_NBR_GEOMETRIE_MAILLE], nfac[MED_NBR_GEOMETRIE_FACE];
99         med_int nare[MED_NBR_GEOMETRIE_ARETE];
100         /* nom du maillage */
101         char nommaa[MED_TAILLE_NOM + 1];
102         /* noeuds */
103         med_float *coo;
104         // PN : Initilialisation de nomcoo et unicoo pour lisibilite du maillage
105         char nomcoo[3 * MED_TAILLE_PNOM + 1] = "x       y        z      ";
106         char unicoo[3 * MED_TAILLE_PNOM + 1] = "m       m        m     ";
107         char *nomnoe;
108         med_int *numnoe;
109         med_int *nufano;
110         med_repere rep;
111         med_booleen inonoe, inunoe;
112         med_mode_switch mode_coo;
113         char str[MED_TAILLE_PNOM + 1];
114         med_int nbNodes;
115         /* elements */
116         med_int nsup;
117         med_int edim;
118         med_int taille;
119         med_int elem_id, myId;
120         med_int *connectivite;
121         char *nomele;
122         med_int *numele;
123         med_int *nufael;
124         med_booleen inoele, inuele;
125         med_connectivite typ_con;
126         med_geometrie_element typgeo;
127         med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE] =
128                 { MED_POINT1, MED_SEG2,
129                 MED_SEG3, MED_TRIA3,
130                 MED_TRIA6, MED_QUAD4,
131                 MED_QUAD8, MED_TETRA4,
132                 MED_TETRA10, MED_HEXA8,
133                 MED_HEXA20, MED_PENTA6,
134                 MED_PENTA15, MED_PYRA5,
135                 MED_PYRA13
136         };
137         med_int desmai[MED_NBR_GEOMETRIE_MAILLE] =
138                 { 0, 2, 3, 3, 3, 4, 4, 4, 4, 6, 6, 5, 5, 5, 5 };
139         med_int nmailles[MED_NBR_GEOMETRIE_MAILLE];
140         char nommai[MED_NBR_GEOMETRIE_MAILLE][MED_TAILLE_NOM + 1] = { "MED_POINT1",
141                 "MED_SEG2",
142                 "MED_SEG3",
143                 "MED_TRIA3",
144                 "MED_TRIA6",
145                 "MED_QUAD4",
146                 "MED_QUAD8",
147                 "MED_TETRA4",
148                 "MED_TETRA10",
149                 "MED_HEXA8",
150                 "MED_HEXA20",
151                 "MED_PENTA6",
152                 "MED_PENTA15",
153                 "MED_PYRA5",
154                 "MED_PYRA13"
155         };
156         med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE] =
157                 { MED_TRIA3, MED_TRIA6,
158                 MED_QUAD4, MED_QUAD8
159         };
160         med_int desfac[MED_NBR_GEOMETRIE_FACE] = { 3, 3, 4, 4 };
161         med_int nfaces[MED_NBR_GEOMETRIE_FACE];
162         char nomfac[MED_NBR_GEOMETRIE_FACE][MED_TAILLE_NOM + 1] =
163                 { "MED_TRIA3", "MED_TRIA6",
164                 "MED_QUAD4", "MED_QUAD8"
165         };
166         med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] =
167                 { MED_SEG2, MED_SEG3 };
168         med_int desare[MED_NBR_GEOMETRIE_ARETE] = { 2, 3 };
169         med_int naretes[MED_NBR_GEOMETRIE_ARETE];
170         char nomare[MED_NBR_GEOMETRIE_ARETE][MED_TAILLE_NOM + 1] =
171                 { "MED_SEG2", "MED_SEG3" };
172
173         typ_con = MED_NOD;
174         mode_coo = MED_FULL_INTERLACE;
175         numero = myMeshId;
176
177         //---- provisoire : switch pour ecrire les familles de mailles
178         int besoinfamilledemaille = 1;
179         //---- provisoire : switch pour ecrire les familles de mailles
180
181   /****************************************************************************
182    *                      OUVERTURE DU FICHIER EN ECRITURE                    *
183    ****************************************************************************/
184         char *file2Read = (char *)myFile.c_str();
185
186         MESSAGE(" file2Read " << file2Read)
187                 myFileId = MEDouvrir(file2Read, MED_REMP);
188         if (myFileId < 0)
189         {
190                 fprintf(stderr, ">> ERREUR : ouverture du fichier %s \n", file2Read);
191                 exit(EXIT_FAILURE);
192         }
193
194   /****************************************************************************
195    *                       NOMBRES D'OBJETS MED                               *
196    ****************************************************************************/
197         MESSAGE("(****************************)");
198         MESSAGE("(* INFORMATIONS GENERALES : *)");
199         MESSAGE("(****************************)");
200
201         /* calcul de la dimension */
202         mdim = 2;
203         double epsilon = 0.00001;
204         double nodeRefX;
205         double nodeRefY;
206         double nodeRefZ;
207
208         bool dimX = true;
209         bool dimY = true;
210         bool dimZ = true;
211
212         int inode = 0;
213         SMDS_Iterator<const SMDS_MeshNode *> * myItNodes=myMesh->nodesIterator();
214         while(myItNodes->more())
215         {
216                 const SMDS_MeshNode * node = myItNodes->next();
217                 if (inode == 0)
218                 {
219                         nodeRefX = fabs(node->X());
220                         nodeRefY = fabs(node->Y());
221                         nodeRefZ = fabs(node->Z());
222                 }
223                 SCRUTE(inode);
224                 SCRUTE(nodeRefX);
225                 SCRUTE(nodeRefY);
226                 SCRUTE(nodeRefZ);
227
228                 if (inode != 0)
229                 {
230                         if ((fabs(fabs(node->X()) - nodeRefX) > epsilon) && dimX)
231                                 dimX = false;
232                         if ((fabs(fabs(node->Y()) - nodeRefY) > epsilon) && dimY)
233                                 dimY = false;
234                         if ((fabs(fabs(node->Z()) - nodeRefZ) > epsilon) && dimZ)
235                                 dimZ = false;
236                 }
237                 if (!dimX && !dimY && !dimZ)
238                 {
239                         mdim = 3;
240                         break;
241                 }
242                 inode++;
243         }
244
245         if (mdim != 3)
246         {
247                 if (dimX && dimY && dimZ)
248                         mdim = 0;
249                 else if (!dimX)
250                 {
251                         if (dimY && dimZ)
252                                 mdim = 1;
253                         else if ((dimY && !dimZ) || (!dimY && dimZ))
254                                 mdim = 2;
255                 }
256                 else if (!dimY)
257                 {
258                         if (dimX && dimZ)
259                                 mdim = 1;
260                         else if ((dimX && !dimZ) || (!dimX && dimZ))
261                                 mdim = 2;
262                 }
263                 else if (!dimZ)
264                 {
265                         if (dimY && dimX)
266                                 mdim = 1;
267                         else if ((dimY && !dimX) || (!dimY && dimX))
268                                 mdim = 2;
269                 }
270         }
271
272         MESSAGE(" mdim " << mdim);
273
274         /* creation du maillage */
275         //mdim=3;
276         sprintf(nommaa, "Mesh %d", numero);
277         SCRUTE(nommaa);
278         ret = MEDmaaCr(myFileId, nommaa, mdim);
279
280         ASSERT(ret == 0);
281         SCRUTE(ret);
282
283         /* Combien de noeuds ? */
284         nnoe = myMesh->NbNodes();
285         //SCRUTE(nnoe);
286         /* Combien de mailles, faces ou aretes ? */
287         for (i = 0; i < MED_NBR_GEOMETRIE_MAILLE; i++)
288                 nmailles[i] = 0;
289
290         int nb_of_nodes, nb_of_faces, nb_of_edges;
291         vector < int >elem_Id[MED_NBR_GEOMETRIE_MAILLE];
292
293         nb_of_edges = myMesh->NbEdges();
294         SMDS_Iterator<const SMDS_MeshEdge *> * itEdges=myMesh->edgesIterator();
295         while(itEdges->more())
296         {
297                 const SMDS_MeshEdge * elem = itEdges->next();
298
299                 nb_of_nodes = elem->NbNodes();
300
301                 switch (nb_of_nodes)
302                 {
303                 case 2:
304                 {
305                         elem_Id[1].push_back(elem->GetID());
306                         nmailles[1]++;
307                         break;
308                 }
309                 case 3:
310                 {
311                         elem_Id[2].push_back(elem->GetID());
312                         nmailles[2]++;
313                         break;
314                 }
315                 }
316         }
317
318         nb_of_faces = myMesh->NbFaces();
319         SMDS_Iterator<const SMDS_MeshFace *> * itFaces=myMesh->facesIterator();
320         while(itFaces->more())
321         {
322                 const SMDS_MeshElement * elem = itFaces->next();
323
324                 nb_of_nodes = elem->NbNodes();
325
326                 switch (nb_of_nodes)
327                 {
328                 case 3:
329                 {
330                         elem_Id[3].push_back(elem->GetID());
331                         nmailles[3]++;
332                         break;
333                 }
334                 case 4:
335                 {
336                         elem_Id[5].push_back(elem->GetID());
337                         nmailles[5]++;
338                         break;
339                 }
340                 case 6:
341                 {
342                         elem_Id[4].push_back(elem->GetID());
343                         nmailles[4]++;
344                         break;
345                 }
346                 }
347
348         }
349
350         SMDS_Iterator<const SMDS_MeshVolume *> * itVolumes=myMesh->volumesIterator();
351         while(itVolumes->more())
352         {
353                 const SMDS_MeshElement * elem = itVolumes->next();
354
355                 nb_of_nodes = elem->NbNodes();
356                 switch (nb_of_nodes)
357                 {
358                 case 8:
359                 {
360                         elem_Id[9].push_back(elem->GetID());
361                         nmailles[9]++;
362                         break;
363                 }
364                 }
365         }
366
367   /****************************************************************************
368    *                       ECRITURE DES NOEUDS                                *
369    ****************************************************************************/
370         MESSAGE("(************************)");
371         MESSAGE("(* NOEUDS DU MAILLAGE : *)");
372         MESSAGE("(************************)");
373
374         /* Allocations memoires */
375         /* table des coordonnees
376          * profil : (dimension * nombre de noeuds ) */
377         coo = (med_float *) malloc(sizeof(med_float) * nnoe * mdim);
378         /* table  des numeros, des numeros de familles des noeuds
379          * profil : (nombre de noeuds) */
380         numnoe = (med_int *) malloc(sizeof(med_int) * nnoe);
381         nufano = (med_int *) malloc(sizeof(med_int) * nnoe);
382         /* table des noms des noeuds
383          * profil : (nnoe*MED_TAILLE_PNOM+1) */
384         nomnoe = "";
385
386         /* PN  pour aster, il faut une famille 0 pour les noeuds et une autre pour les elements */
387         /* PN : Creation de la famille 0 */
388         char *nomfam = "FAMILLE_0";
389         char *attdes = "";
390         char *gro = 0;
391         med_int ngro = 0;
392         med_int natt = 1;
393         med_int attide = 0;
394         med_int attval = 0;
395         med_int numfam = 0;
396         med_int attvalabs = 1;
397         ret =
398                 MEDfamCr(myFileId, nommaa, nomfam, numfam, &attide, &attval, attdes,
399                 natt, gro, ngro);
400         ASSERT(ret == 0);
401
402         /* PN : FIN Creation de la famille 0 */
403
404         map < int, int >mapNoeud;
405         typedef pair < set < int >::iterator, bool > IsFamily;
406         int nbFamillesNoeud;
407
408         i = 0;
409         set < int >FamilySet;
410         nbFamillesNoeud = 0;
411         int verifienbnoeuds = 0;
412         med_int *rien = 0;
413
414         SMDS_Iterator<const SMDS_MeshNode *> * itNodes=myMesh->nodesIterator();
415         while(itNodes->more())
416         {
417                 const SMDS_MeshNode * node = itNodes->next();
418
419                 if (mdim == 3)
420                 {
421                         coo[i * 3] = node->X();
422                         coo[i * 3 + 1] = node->Y();
423                         coo[i * 3 + 2] = node->Z();
424                 }
425                 else if (mdim == 2)
426                 {
427                         if (dimX)
428                         {
429                                 coo[i * 2] = node->Y();
430                                 coo[i * 2 + 1] = node->Z();
431                         }
432                         if (dimY)
433                         {
434                                 coo[i * 2] = node->X();
435                                 coo[i * 2 + 1] = node->Z();
436                         }
437                         if (dimZ)
438                         {
439                                 coo[i * 2] = node->X();
440                                 coo[i * 2 + 1] = node->Y();
441                         }
442                 }
443                 else
444                 {
445                         if (dimX)
446                         {
447                                 coo[i * 2] = node->Y();
448                                 coo[i * 2 + 1] = node->Z();
449                         }
450                         if (dimY)
451                         {
452                                 coo[i * 2] = node->X();
453                                 coo[i * 2 + 1] = node->Z();
454                         }
455                         if (dimZ)
456                         {
457                                 coo[i * 2] = node->X();
458                                 coo[i * 2 + 1] = node->Y();
459                         }
460                 }
461                 mapNoeud[node->GetID()] = i + 1;
462
463                 // renvoie 0 pour les noeuds internes du volume
464                 int numfamille = node->GetPosition()->GetShapeId();
465                 nufano[i] = numfamille;
466
467                 //SCRUTE(i);
468                 //SCRUTE(nufano[i]);
469                 //SCRUTE(coo[i*3]);
470                 //SCRUTE(coo[i*3+1]);
471                 //SCRUTE(coo[i*3+2]);
472                 if (nufano[i] != 0)
473                 {
474                         IsFamily deja = FamilySet.insert(nufano[i]);    // insert if new, or gives existant
475                         if (deja.second)        // actually inserted
476                         {
477                                 char famille[MED_TAILLE_NOM + 1];
478                                 sprintf(famille, "F%d", nufano[i]);
479                                 //          CreateFamily(strdup(nommaa),strdup(famille),nufano[i],attvalabs++);
480                                 attvalabs++;
481                                 CreateFamily(strdup(nommaa), strdup(famille), nufano[i],
482                                         numfamille);
483                                 //MESSAGE("---famille-noeud--- "<<nbFamillesNoeud<<" "<<nufano[i]);
484                                 nbFamillesNoeud++;
485                         }
486                 }
487
488                 i++;
489                 verifienbnoeuds++;
490         }
491         ret = MEDnoeudsEcr(myFileId, nommaa, mdim, coo, mode_coo, MED_CART,
492                 nomcoo, unicoo, nomnoe, MED_FAUX, rien, MED_FAUX,
493                 nufano, nnoe, MED_REMP);
494         ASSERT(ret == 0);
495         MESSAGE("--- Creation de " << verifienbnoeuds << " noeuds");
496         ASSERT(verifienbnoeuds == nnoe);
497         MESSAGE("--- Creation de " << nbFamillesNoeud << " familles de noeuds");
498
499         /* liberation memoire */
500         free(coo);
501         free(numnoe);
502         free(nufano);
503
504   /****************************************************************************
505    *                       ECRITURE DES ELEMENTS                              *
506    ****************************************************************************/
507         MESSAGE("(**************************)");
508         MESSAGE("(* ELEMENTS DU MAILLAGE : *)");
509         MESSAGE("(**************************)");
510
511         /* Ecriture des connectivites, noms, numeros des mailles */
512
513         if (ret == 0)
514         {
515                 int nbFamillesElts = 0;
516                 SMESHDS_Mesh * mySMESHDSMesh = dynamic_cast<SMESHDS_Mesh *>(myMesh);
517                 TopTools_IndexedMapOfShape myIndexToShape;
518                 TopExp::MapShapes(mySMESHDSMesh->ShapeToMesh(), myIndexToShape);
519
520                 map<int,int> mapFamille;
521
522                 if (besoinfamilledemaille == 1)
523                 {
524                         int t;
525                         for (t = 1; t <= myIndexToShape.Extent(); t++)
526                         {
527                                 const TopoDS_Shape S = myIndexToShape(t);
528                                 if (mySMESHDSMesh->HasMeshElements(S))
529                                 {
530                                         //MESSAGE ("********* Traitement de la Famille "<<-t);
531
532                                         SMESHDS_SubMesh * SM = mySMESHDSMesh->MeshElements(S);
533                                         SMDS_Iterator<const SMDS_MeshElement*> * ite=SM->GetElements();
534                                         bool plein = false;
535                                         while(ite->more())
536                                         {
537                                                 mapFamille[ite->next()->GetID()] = -t;
538                                                 plein = true;
539                                         }
540                                         if (plein)
541                                         {
542                                                 nbFamillesElts++;
543                                                 char famille[MED_TAILLE_NOM + 1];
544                                                 sprintf(famille, "E%d", t);
545                                                 CreateFamily(strdup(nommaa), strdup(famille), -t,
546                                                         attvalabs++);
547                                         }
548                                 }
549                         }
550                 }
551
552                 int indice = 1;
553                 for (i = 0; i < MED_NBR_GEOMETRIE_MAILLE; i++)
554                 {
555                         if (nmailles[i] > 0 && ret == 0)
556                         {
557                                 MESSAGE(" Start " << typmai[i]);
558
559                                 /* dimension de la maille */
560                                 edim = typmai[i] / 100;
561                                 nsup = 0;
562                                 if (mdim == 2 || mdim == 3)
563                                         if (edim == 1)
564                                                 nsup = 1;
565                                 if (mdim == 3)
566                                         if (edim == 2)
567                                                 nsup = 1;
568                                 //SCRUTE(nsup);
569
570                                 taille = nsup + typmai[i] % 100;
571                                 //SCRUTE(taille);
572
573                                 /* allocation memoire */
574                                 connectivite =
575                                         (med_int *) malloc(sizeof(med_int) * taille * nmailles[i]);
576                                 /* nomele =
577                                         (char *)malloc(sizeof(char) * MED_TAILLE_PNOM *
578                                         nmailles[i] + 1);*/
579                                 nomele = "";
580                                 numele = (med_int *) malloc(sizeof(med_int) * nmailles[i]);
581                                 nufael = (med_int *) malloc(sizeof(med_int) * nmailles[i]);
582                                 nbNodes = typmai[i] % 100;
583
584                                 for (j = 0; j < nmailles[i]; j++)
585                                 {
586                                         myId = elem_Id[i][j];
587                                         const SMDS_MeshElement * elem =
588                                                 myMesh->FindElement(myId);
589                                         //*(numele+j) = myId;
590                                         *(numele + j) = indice++;
591
592                                         SMDS_Iterator<const SMDS_MeshElement *> * itk=elem->nodesIterator();
593                                         for (k = 0; itk->more(); k++)
594                                         {
595                                                 *(connectivite + j * taille + k) =
596                                                         mapNoeud[itk->next()->GetID()];
597                                         }
598                                         delete itk;
599
600                                         if (nsup)
601                                                 *(connectivite + j * taille + nbNodes) = 0;
602
603                                         if (besoinfamilledemaille == 1)
604                                         {
605                                                 if (mapFamille.find(myId) != mapFamille.end())
606                                                 {
607                                                         nufael[j] = mapFamille[myId];
608                                                 }
609                                                 else
610                                                 {
611                                                         nufael[j] = 0;
612                                                 }
613                                         }
614                                         else
615                                         {
616                                                 nufael[j] = 0;
617                                         }
618
619                                         //SCRUTE(myId);
620                                         //SCRUTE(j);
621                                         //SCRUTE(nufael[j]);
622                                 }
623
624                                 /* ecriture des donn√©es */
625
626                                 med_int *rien = 0;
627                                 ret =
628                                         MEDelementsEcr(myFileId, nommaa, mdim, connectivite,
629                                         mode_coo, nomele, MED_FAUX, numele, MED_VRAI, nufael,
630                                         nmailles[i], MED_MAILLE, typmai[i], typ_con, MED_REMP);
631                                 ASSERT(ret == 0);
632                                 //SCRUTE(ret);
633
634                                 if (ret < 0)
635                                         MESSAGE(">> ERREUR : ecriture des mailles \n");
636
637                                 /* liberation memoire */
638                                 free(connectivite);
639                                 free(numele);
640                                 free(nufael);
641                                 MESSAGE(" End " << typmai[i]);
642                         }
643                 };
644                 MESSAGE("--- Creation de " << nbFamillesElts << " familles d elements");
645
646         }
647
648           /****************************************************************************
649       *                      FERMETURE DU FICHIER                                *
650       ****************************************************************************/
651
652         ret = MEDfermer(myFileId);
653
654         if (ret != 0)
655                 fprintf(stderr, ">> ERREUR : erreur a la fermeture du fichier %s\n",
656                         file2Read);
657         MESSAGE("fichier ferme");
658
659 }
660
661 void DriverMED_W_SMESHDS_Mesh::CreateFamily(char *nommaa, char *famille, int i,
662         med_int k)
663 {
664
665         med_int ngro = 0;
666         med_int natt;
667
668         natt = 1;
669         char attdes[MED_TAILLE_DESC + 1];
670         char gro[MED_TAILLE_LNOM + 1];
671         char fam2[MED_TAILLE_LNOM + 1];
672
673         strcpy(attdes, "");
674         strcpy(gro, "");
675         strcpy(fam2, famille);
676
677         med_int *attide = new med_int[1];
678         med_int *attval = new med_int[1];
679         attide[0] = k;
680         attval[0] = k;
681
682         //MESSAGE("-------- Creation de la Famille : "<< famille << "numero " << i << " --------------");
683         med_int ret =
684                 MEDfamCr(myFileId, nommaa, fam2, i, attide, attval, attdes, natt, gro,
685                 ngro);
686         ASSERT(ret == 0);
687         delete[]attide;
688         delete[]attval;
689
690 }