src/MEDMEM/INTERPOLATION/create_mesh_interpolation.c

   1 #include <med.h>
   2 #include <string.h>
   3
   4 #define MED_NOPG   1                   /* -> pas de point de Gauss                    */
   5 #define MED_NOPFL  ""                  /* -> pas de profils utilisateur               */
   6 #define MED_NOPFLi "                                "  /* Variable Interne                      */
   7 #define MED_NOPF   0                   /* -> pas de profils pour _MEDdataseNnumEcrire */
   8 #define MED_NOPDT -1                   /* rem: pas de pas de temps negatifs           */
   9 #define MED_NONOR -1                   /* rem: pas de n°ordre negatif                 */
  10 #define MED_DIM1   1                   /* PAS */
  11
  12 #define MED_ALL    0
  13
  14 /*****************************************************************************************************/
  15
  16 void affiche_noeuds(med_float * nodes,int nnpl)
  17         {
  18         int nbr_nodes=nnpl*nnpl*nnpl;
  19         int i;
  20
  21         for (i=0;i<nbr_nodes;i++) printf("Noeud %d : ( %4.5f ; %4.5f ; %4.5f )\n",i,nodes[3*i],nodes[3*i+1],nodes[3*i+2]);
  22
  23         }
  24
  25
  26 void cree_nodes(med_float * coord_nodes,int nnpl, int flag)
  27         {
  28         int i,j,k;
  29         int nbr_nodes=nnpl*nnpl*nnpl;
  30         int num_noeud;
  31         int diviseur=nnpl-1+flag;
  32
  33         /*coord_nodes=(med_float *) malloc(3*nbr_nodes*sizeof(med_float));*/
  34
  35         for (i=0;i<nnpl;i++) for (j=0;j<nnpl;j++) for (k=0;k<nnpl;k++)
  36                 {
  37                 num_noeud=i+nnpl*j+nnpl*nnpl*k;
  38
  39                 if (3*num_noeud  >=3*nbr_nodes) {printf("%d : OUT OF RANGE REQUEST\n",num_noeud);exit(-1);}
  40                 if (3*num_noeud+1>=3*nbr_nodes) {printf("%d : OUT OF RANGE REQUEST\n",num_noeud);exit(-1);}
  41                 if (3*num_noeud+2>=3*nbr_nodes) {printf("%d : OUT OF RANGE REQUEST\n",num_noeud);exit(-1);}
  42
  43                 coord_nodes[3*num_noeud  ]= (double) (i+flag)/diviseur;
  44                 coord_nodes[3*num_noeud+1]= (double) (j+flag)/diviseur;
  45                 coord_nodes[3*num_noeud+2]= (double) (k+flag)/diviseur;
  46                 }
  47
  48         affiche_noeuds(coord_nodes,nnpl);
  49
  50         }
  51 void cree_num_nodes(med_int * num_nodes,int nnpl)
  52         {
  53         int nbr_nodes=nnpl*nnpl*nnpl;
  54         int i;
  55         /*num_nodes=(med_int *) malloc(nbr_nodes*sizeof(med_int));*/
  56         for (i=0;i<nbr_nodes;i++) num_nodes[i]=i+1;//nbr_nodes+i;
  57         }
  58 void cree_Hexa8(med_int * conn_hexa8, int nnpl,med_int * num_nodes)
  59         {
  60         int i,j,k;
  61         int i0,j0,k0,i1,j1,k1;
  62         int nbr_nodes=nnpl*nnpl*nnpl;
  63         int nbr_hexa8=(nnpl-1)*(nnpl-1)*(nnpl-1);
  64         int num_hexa8;
  65
  66         /*conn_hexa8=(med_int *) malloc(8*nbr_hexa8*sizeof(med_int));*/
  67
  68         for (i=0;i<nnpl-1;i++) for (j=0;j<nnpl-1;j++) for (k=0;k<nnpl-1;k++)
  69                 {
  70                 i0=i;j0=j;k0=k;
  71                 i1=i+1;j1=j+1;k1=k+1;
  72
  73                 num_hexa8=i+(nnpl-1)*j+(nnpl-1)*(nnpl-1)*k;
  74
  75                 if (8*num_hexa8  >=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
  76                 if (8*num_hexa8+1>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
  77                 if (8*num_hexa8+2>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
  78                 if (8*num_hexa8+3>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
  79                 if (8*num_hexa8+4>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
  80                 if (8*num_hexa8+5>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
  81                 if (8*num_hexa8+6>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
  82                 if (8*num_hexa8+7>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
  83
  84                 conn_hexa8[8*num_hexa8  ] = num_nodes[ i0+nnpl*j1+nnpl*nnpl*k1 ];
  85                 conn_hexa8[8*num_hexa8+1] = num_nodes[ i0+nnpl*j0+nnpl*nnpl*k1 ];
  86                 conn_hexa8[8*num_hexa8+2] = num_nodes[ i1+nnpl*j0+nnpl*nnpl*k1 ];
  87                 conn_hexa8[8*num_hexa8+3] = num_nodes[ i1+nnpl*j1+nnpl*nnpl*k1 ];
  88                 conn_hexa8[8*num_hexa8+4] = num_nodes[ i0+nnpl*j1+nnpl*nnpl*k0 ];
  89                 conn_hexa8[8*num_hexa8+5] = num_nodes[ i0+nnpl*j0+nnpl*nnpl*k0 ];
  90                 conn_hexa8[8*num_hexa8+6] = num_nodes[ i1+nnpl*j0+nnpl*nnpl*k0 ];
  91                 conn_hexa8[8*num_hexa8+7] = num_nodes[ i1+nnpl*j1+nnpl*nnpl*k0 ];
  92
  93
  94                 }
  95
  96         for (num_hexa8=0;num_hexa8<nbr_hexa8;num_hexa8++)
  97                 {
  98                 printf("Maille numéro %4d :",num_hexa8);
  99                 printf("%4d ",conn_hexa8[8*num_hexa8  ]);
 100                 printf("%4d ",conn_hexa8[8*num_hexa8+1]);
 101                 printf("%4d ",conn_hexa8[8*num_hexa8+2]);
 102                 printf("%4d ",conn_hexa8[8*num_hexa8+3]);
 103                 printf("%4d ",conn_hexa8[8*num_hexa8+4]);
 104                 printf("%4d ",conn_hexa8[8*num_hexa8+5]);
 105                 printf("%4d ",conn_hexa8[8*num_hexa8+6]);
 106                 printf("%4d ",conn_hexa8[8*num_hexa8+7]);
 107                 printf("\n");
 108                 }
 109         }
 110 void cree_noms_mailles(char * noms, int nnpl)
 111         {
 112         int nbr_hexa8=(nnpl-1)*(nnpl-1)*(nnpl-1);
 113         int i;
 114         char pnom[MED_TAILLE_PNOM+1]="hexa    ";
 115
 116         /*noms=(char *) malloc((nbr_hexa8*MED_TAILLE_PNOM+1)*sizeof(char));*/
 117
 118         for (i=0;i<nbr_hexa8;i++) strncpy(&noms[i*MED_TAILLE_PNOM],pnom,MED_TAILLE_PNOM);
 119
 120         noms[nbr_hexa8*MED_TAILLE_PNOM]='\n';
 121
 122         }
 123 void cree_num_mailles(med_int * num_mailles,int nnpl)
 124         {
 125         int nbr_hexa8=(nnpl-1)*(nnpl-1)*(nnpl-1);
 126         int i;
 127
 128         /*num_mailles=(med_int *) malloc(nbr_hexa8*sizeof(med_int));*/
 129
 130         for (i=0;i<nbr_hexa8;i++) num_mailles[i]=i+1;
 131         }
 132 void cree_fam_nodes(med_int * fam,int nnpl)
 133         {
 134         int nbr_nodes=nnpl*nnpl*nnpl;
 135         int i;
 136
 137         /*fam=(med_int *) malloc(nbr_nodes*sizeof(med_int));*/
 138
 139         for (i=0;i<nbr_nodes;i++) fam[i]=0;
 140         }
 141 void cree_fam_mailles(med_int * fam,int nnpl)
 142         {
 143         int nbr_hexa8=(nnpl-1)*(nnpl-1)*(nnpl-1);
 144         int i;
 145
 146         /*fam=(med_int *) malloc(nbr_hexa8*sizeof(med_int));*/
 147
 148         for (i=0;i<nbr_hexa8;i++) fam[i]=0;
 149         }
 150 void cree_valeurs_champ_node(med_float * val,int nnpl)
 151         {
 152         int i,j,k;
 153         int nbr_nodes=nnpl*nnpl*nnpl;
 154         int num_noeud;
 155         int diviseur=3*(nnpl-1);
 156
 157         /*val=(med_float *) malloc(nbr_nodes*sizeof(med_float));*/
 158
 159         for (i=0;i<nnpl;i++) for (j=0;j<nnpl;j++) for (k=0;k<nnpl;k++)
 160                 {
 161                 num_noeud=i+nnpl*j+nnpl*nnpl*k;
 162                 val[num_noeud] = (med_float) (i+j+k)/diviseur;
 163                 }
 164         for (num_noeud=0;num_noeud<nbr_nodes;num_noeud++) printf("Valeur Scalaire noeud %5d : %4.5f\n",num_noeud,val[num_noeud]);
 165         }
 166 void cree_valeurs_champ_vector_node(med_float * val,int nnpl)
 167         {
 168         int i,j,k;
 169         int nbr_nodes=nnpl*nnpl*nnpl;
 170         int num_noeud;
 171
 172         /*val=(med_float *) malloc(nbr_nodes*sizeof(med_float));*/
 173
 174         for (i=0;i<nnpl;i++) for (j=0;j<nnpl;j++) for (k=0;k<nnpl;k++)
 175                 {
 176                 num_noeud=i+nnpl*j+nnpl*nnpl*k;
 177                 val[3*num_noeud  ] = (med_float) 0;
 178                 val[3*num_noeud+1] = (med_float) 1;
 179                 val[3*num_noeud+2] = (med_float) 2;
 180                 }
 181         for (num_noeud=0;num_noeud<nbr_nodes;num_noeud++) printf("Valeur Vectorielle noeud %5d : %4.5f %4.5f %4.5f \n ",num_noeud,val[3*num_noeud],val[3*num_noeud+1],val[3*num_noeud+2]);
 182         }
 183 void cree_valeurs_champ_cell(med_float * val,int nnpl)
 184         {
 185         int i,j,k;
 186         int nbr_cells=(nnpl-1)*(nnpl-1)*(nnpl-1);
 187         int num_cell;
 188
 189         med_float diviseur=3*(nnpl-2);
 190
 191         /*val=(med_float *) malloc(3*nbr_cells*sizeof(med_float));*/
 192
 193         for (i=0;i<nnpl-1;i++) for (j=0;j<nnpl-1;j++) for (k=0;k<nnpl-1;k++)
 194                 {
 195                 num_cell=i+(nnpl-1)*j+(nnpl-1)*(nnpl-1)*k;
 196                 val[num_cell  ] =  (med_float) (i+j+k)/diviseur;
 197                 }
 198         for (num_cell=0;num_cell<nbr_cells;num_cell++) printf("Valeur scalaire maille %5d : %4.5f\n ",num_cell,val[num_cell]);
 199         }
 200 void cree_valeurs_champ_vector_cell(med_float * val,int nnpl)
 201         {
 202         int i,j,k;
 203         int nbr_cells=(nnpl-1)*(nnpl-1)*(nnpl-1);
 204         int num_cell;
 205
 206         /*val=(med_float *) malloc(3*nbr_cells*sizeof(med_float));*/
 207
 208         for (i=0;i<nnpl-1;i++) for (j=0;j<nnpl-1;j++) for (k=0;k<nnpl-1;k++)
 209                 {
 210                 num_cell=i+(nnpl-1)*j+(nnpl-1)*(nnpl-1)*k;
 211                 val[3*num_cell  ] = (med_float) 0;
 212                 val[3*num_cell+1] = (med_float) 1;
 213                 val[3*num_cell+2] = (med_float) 2;
 214                 }
 215         for (num_cell=0;num_cell<nbr_cells;num_cell++) printf("Valeur Vectorielle maille %5d : %4.5f %4.5f %4.5f \n ",num_cell,val[3*num_cell],val[3*num_cell+1],val[3*num_cell+2]);
 216         }
 217
 218
 219 /*****************************************************************************************************/
 220
 221 int main (int argc, char **argv)
 222         {
 223
 224         int i,j,k;
 225
 226         int nnpl;
 227
 228         int nbr_nodes, nbr_hexa8;
 229
 230         med_err ret;
 231         med_idt fromfid;
 232         med_idt tofid;
 233         char frommaa[MED_TAILLE_NOM+1] = "fromMesh";
 234         char tomaa[MED_TAILLE_NOM+1]   = "toMesh";
 235         const med_int mdim = 3;
 236         med_int fromnnoe;
 237         med_int   tonnoe;
 238
 239         med_float * tocoo;
 240         med_float * fromcoo;
 241
 242         char nomcoo[3*MED_TAILLE_PNOM+1] = "x       y       z       ";
 243         char unicoo[3*MED_TAILLE_PNOM+1] = "cm      cm      cm      ";
 244
 245         char * nomnoe = NULL ;
 246
 247         med_int  * fromnumnoe;
 248         med_int  * fromnufano;
 249
 250         med_int  * tonumnoe;
 251         med_int  * tonufano;
 252
 253         med_int fromnhexa8;
 254         med_int  * fromhexa8;
 255
 256         med_int tonhexa8;
 257         med_int  * tohexa8;
 258
 259
 260         char  * fromnomhexa8;
 261         med_int * fromnumhexa8;
 262         med_int * fromnufahexa8;
 263
 264         char  * tonomhexa8;
 265         med_int * tonumhexa8;
 266         med_int * tonufahexa8;
 267
 268 /*****************************************************************************************************/
 269
 270         char nomfam[MED_TAILLE_NOM+1];
 271         med_int numfam;
 272         char attdes[MED_TAILLE_DESC+1];
 273         med_int natt;
 274         med_int attide;
 275         med_int attval;
 276         med_int ngro;
 277         char gro[MED_TAILLE_LNOM+1];
 278         char gro2[MED_TAILLE_LNOM*2+1];
 279         char gro3[MED_TAILLE_LNOM*3+1];
 280         int nfame = 1;
 281         int nfamn = 1;
 282
 283 /*****************************************************************************************************/
 284
 285         /* Some fields : one on nodes : double , one on cells : double */
 286
 287         char champnode[MED_TAILLE_NOM+1]="fieldnodedouble" ;
 288         char champnode_comp[MED_TAILLE_PNOM+1]="X+Y+Z   " ;
 289         char champnode_unit[MED_TAILLE_PNOM+1]="X+Y+Z   " ;
 290         med_float   * fieldnodedouble;
 291
 292         char champnodevector[MED_TAILLE_NOM+1]="fieldnodedoublevector" ;
 293         char champnodevector_comp[MED_TAILLE_PNOM*3+1]="0       1       2       " ;
 294         char champnodevector_unit[MED_TAILLE_PNOM*3+1]="O       1       2       " ;
 295         med_float   * fieldnodedoublevector;
 296
 297         char champcellscalar[MED_TAILLE_NOM+1]="fieldcelldouble" ;
 298         char champcellscalar_comp[MED_TAILLE_PNOM+1]="X+Y+Z   " ;
 299         char champcellscalar_unit[MED_TAILLE_PNOM+1]="X+Y+Z   " ;
 300         med_float   * fieldcelldouble;
 301
 302         char champcell[MED_TAILLE_NOM+1]="fieldcelldoublevector" ;
 303         char champcell_comp[MED_TAILLE_PNOM*3+1]="0       1       2       " ;
 304         char champcell_unit[MED_TAILLE_PNOM*3+1]="0       1       2       " ;
 305         med_float   * fieldcelldoublevector;
 306
 307 /*****************************************************************************************************/
 308
 309
 310         if (argc!=2)
 311                 {
 312                 printf("Il manque un paramètre : le nombre de point par ligne\n");
 313                 exit(-1);
 314                 }
 315
 316         sscanf(argv[1],"%d",&nnpl);
 317
 318         printf("VERSION 2.0\n");
 319         printf("Traitement avec %d noeuds par ligne\n",nnpl);
 320
 321         fromnnoe   = nnpl*nnpl*nnpl             ;
 322         fromnhexa8 = (nnpl-1)*(nnpl-1)*(nnpl-1) ;
 323         tonnoe     = (nnpl-1)*(nnpl-1)*(nnpl-1) ;
 324         tonhexa8   = (nnpl-2)*(nnpl-2)*(nnpl-2) ;
 325
 326
 327
 328         nbr_nodes=nnpl*nnpl*nnpl;
 329         nbr_hexa8=(nnpl-1)*(nnpl-1)*(nnpl-1);
 330
 331         fromcoo       = (med_float *) malloc(3*nbr_nodes*sizeof(med_float));              cree_nodes        ( fromcoo       , nnpl, 0 );
 332         fromnumnoe    = (med_int *)   malloc(nbr_nodes*sizeof(med_int));                  cree_num_nodes    ( fromnumnoe    , nnpl );
 333         fromnufano    = (med_int *)   malloc(nbr_nodes*sizeof(med_int));                  cree_fam_nodes    ( fromnufano    , nnpl );
 334         fromhexa8     = (med_int *)   malloc(8*nbr_hexa8*sizeof(med_int));                cree_Hexa8        ( fromhexa8     , nnpl ,fromnumnoe);
 335         fromnomhexa8  = (char *)      malloc((nbr_hexa8*MED_TAILLE_PNOM+1)*sizeof(char)); cree_noms_mailles ( fromnomhexa8  , nnpl );
 336         fromnumhexa8  = (med_int *)   malloc(nbr_hexa8*sizeof(med_int));                  cree_num_mailles  ( fromnumhexa8  , nnpl );
 337         fromnufahexa8 = (med_int *)   malloc(nbr_hexa8*sizeof(med_int));                  cree_fam_mailles  ( fromnufahexa8 , nnpl );
 338
 339         fieldnodedouble       = (med_float *) malloc(nbr_nodes*sizeof(med_float));          cree_valeurs_champ_node        ( fieldnodedouble       , nnpl );
 340         fieldnodedoublevector = (med_float *) malloc(3*nbr_nodes*sizeof(med_float));        cree_valeurs_champ_vector_node ( fieldnodedoublevector , nnpl );
 341         fieldcelldouble       = (med_float *) malloc(nbr_hexa8*sizeof(med_float));          cree_valeurs_champ_cell        ( fieldcelldouble       , nnpl );
 342         fieldcelldoublevector = (med_float *) malloc(3*nbr_hexa8*sizeof(med_float));        cree_valeurs_champ_vector_cell ( fieldcelldoublevector , nnpl );
 343
 344
 345         nbr_nodes=(nnpl-1)*(nnpl-1)*(nnpl-1);
 346         nbr_hexa8=(nnpl-2)*(nnpl-2)*(nnpl-2);
 347
 348         tocoo       = (med_float *) malloc(3*nbr_nodes*sizeof(med_float));              cree_nodes        ( tocoo       , nnpl-1, 1 );
 349         tonumnoe    = (med_int *)   malloc(nbr_nodes*sizeof(med_int));                  cree_num_nodes    ( tonumnoe    , nnpl-1 );
 350         tonufano    = (med_int *)   malloc(nbr_nodes*sizeof(med_int));                  cree_fam_nodes    ( tonufano    , nnpl-1 );
 351         tohexa8     = (med_int *)   malloc(8*nbr_hexa8*sizeof(med_int));                cree_Hexa8        ( tohexa8     , nnpl-1 ,tonumnoe);
 352         tonomhexa8  = (char *)      malloc((nbr_hexa8*MED_TAILLE_PNOM+1)*sizeof(char)); cree_noms_mailles ( tonomhexa8  , nnpl-1 );
 353         tonumhexa8  = (med_int *)   malloc(nbr_hexa8*sizeof(med_int));                  cree_num_mailles  ( tonumhexa8  , nnpl-1 );
 354         tonufahexa8 = (med_int *)   malloc(nbr_hexa8*sizeof(med_int));                  cree_fam_mailles  ( tonufahexa8 , nnpl-1 );
 355
 356
 357 /*****************************************************************************************************/
 358         fromfid = MEDouvrir("fromMesh.med",MED_REMP);
 359         if (fromfid < 0)
 360                 ret = -1;
 361         else
 362                 ret = 0;
 363         printf("MEDouvrir : %d\n",ret);
 364
 365 /*****************************************************************************************************/
 366         tofid = MEDouvrir("toMesh.med",MED_REMP);
 367         if (tofid < 0)
 368                 ret = -1;
 369         else
 370                 ret = 0;
 371         printf("MEDouvrir : %d\n",ret);
 372 /*****************************************************************************************************/
 373         if (ret == 0)
 374                 ret = MEDmaaCr(fromfid,frommaa,mdim);
 375         printf("MEDmaaCr : %d\n",ret);
 376
 377 /*****************************************************************************************************/
 378
 379         if (ret == 0)
 380                 ret = MEDmaaCr(tofid,tomaa,mdim);
 381         printf("MEDmaaCr : %d\n",ret);
 382
 383 /*****************************************************************************************************/
 384         if (ret == 0)
 385                 ret = MEDnoeudsEcr(fromfid,frommaa,mdim,fromcoo,MED_FULL_INTERLACE,MED_CART,
 386                                      // nomcoo,unicoo,nomnoe,MED_FAUX,fromnumnoe,MED_VRAI,
 387                                      nomcoo,unicoo,nomnoe,MED_FAUX,fromnumnoe,MED_FAUX,
 388                                      fromnufano,fromnnoe,MED_ECRI);
 389         printf("MEDnoeudsEcr : %d\n",ret);
 390 /*****************************************************************************************************/
 391
 392         if (ret == 0)
 393                 ret = MEDnoeudsEcr(tofid,tomaa,mdim,tocoo,MED_FULL_INTERLACE,MED_CART,
 394                                      //nomcoo,unicoo,nomnoe,MED_FAUX,tonumnoe,MED_VRAI,
 395                                      nomcoo,unicoo,nomnoe,MED_FAUX,tonumnoe,MED_FAUX,
 396                                      tonufano,tonnoe,MED_ECRI);
 397         printf("MEDnoeudsEcr : %d\n",ret);
 398
 399
 400 /*****************************************************************************************************/
 401 /* ecriture des mailles MED_HEXA8 :
 402    - connectivite
 403    - noms (optionnel)
 404    - numeros (optionnel)
 405    - numeros des familles */
 406         if (ret == 0)
 407                 ret = MEDelementsEcr(fromfid,frommaa,mdim,fromhexa8,MED_FULL_INTERLACE,
 408                                         fromnomhexa8,MED_FAUX,fromnumhexa8,MED_VRAI,fromnufahexa8,fromnhexa8,
 409                                         MED_MAILLE,MED_HEXA8,MED_NOD,MED_ECRI);
 410         printf("MEDelementsEcr : %d \n",ret);
 411
 412 /*****************************************************************************************************/
 413 /* ecriture des mailles MED_HEXA8 :
 414    - connectivite
 415    - noms (optionnel)
 416    - numeros (optionnel)
 417    - numeros des familles */
 418
 419         if (ret == 0)
 420                 ret = MEDelementsEcr(tofid,tomaa,mdim,tohexa8,MED_FULL_INTERLACE,
 421                                         tonomhexa8,MED_FAUX,tonumhexa8,MED_VRAI,tonufahexa8,tonhexa8,
 422                                         MED_MAILLE,MED_HEXA8,MED_NOD,MED_ECRI);
 423         printf("MEDelementsEcr : %d \n",ret);
 424
 425 /*****************************************************************************************************/
 426 /* ecriture des familles */
 427 /* Conventions :
 428    - toujours creer une famille de numero 0 ne comportant aucun attribut
 429      ni groupe (famille de reference pour les noeuds ou les elements
 430      qui ne sont rattaches a aucun groupe ni attribut)
 431    - les numeros de familles de noeuds sont > 0
 432    - les numeros de familles des elements sont < 0
 433    - rien d'imposer sur les noms de familles
 434  */
 435
 436 /* la famille 0 */
 437         if (ret == 0)
 438                 {
 439                 strcpy(nomfam,"FAMILLE_0");
 440                 numfam = 0;
 441                 ret = MEDfamCr(fromfid,frommaa,nomfam,numfam,&attide,&attval,attdes,0,gro,0);
 442                 }
 443         printf("MEDfamCr : %d \n",ret);
 444 /*****************************************************************************************************/
 445
 446         if (ret == 0)
 447                 {
 448                 strcpy(nomfam,"FAMILLE_0");
 449                 numfam = 0;
 450                 ret = MEDfamCr(tofid,tomaa,nomfam,numfam,&attide,&attval,attdes,0,gro,0);
 451                 }
 452         printf("MEDfamCr : %d \n",ret);
 453
 454 /*****************************************************************************************************/
 455 /* Les champs */
 456
 457         if (ret == 0)
 458                 {
 459                 ret = MEDchampCr(fromfid,champnode,MED_REEL64,champnode_comp,champnode_unit,1);
 460                 printf("MEDchampCr : %d \n",ret);
 461                 if (ret == 0)
 462                         {
 463                         ret = MEDchampEcr(fromfid, frommaa, champnode, (unsigned char *)fieldnodedouble,
 464                                                 MED_FULL_INTERLACE, fromnnoe,
 465                                                 MED_NOPG, MED_ALL, MED_NOPFL, MED_ECRI, MED_NOEUD,
 466                                                 0, MED_NOPDT,"        ", 0. , MED_NONOR);
 467                         printf("MEDchampEcr : %d \n",ret);
 468                         }
 469                 }
 470
 471         if (ret == 0)
 472                 {
 473                 ret = MEDchampCr(fromfid,champcell,MED_REEL64,champcell_comp,champcell_unit,3);
 474                 printf("MEDchampCr : %d \n",ret);
 475                 if (ret == 0)
 476                         {
 477                         ret = MEDchampEcr(fromfid, frommaa, champcell, (unsigned char *)fieldcelldoublevector,
 478                                                 MED_FULL_INTERLACE, fromnhexa8,
 479                                                 MED_NOPG, MED_ALL, MED_NOPFL, MED_ECRI, MED_MAILLE,
 480                                                 MED_HEXA8, MED_NOPDT,"        ", 0., MED_NONOR);
 481                         printf("MEDchampEcr : %d \n",ret);
 482                         }
 483                 }
 484
 485         if (ret == 0)
 486                 {
 487                 ret = MEDchampCr(fromfid,champcellscalar,MED_REEL64,champcellscalar_comp,champcellscalar_unit,1);
 488                 printf("MEDchampCr : %d \n",ret);
 489                 if (ret == 0)
 490                         {
 491                         ret = MEDchampEcr(fromfid, frommaa, champcellscalar, (unsigned char *)fieldcelldouble,
 492                                                 MED_FULL_INTERLACE, fromnhexa8,
 493                                                 MED_NOPG, MED_ALL, MED_NOPFL, MED_ECRI, MED_MAILLE,
 494                                                 MED_HEXA8, MED_NOPDT,"        ", 0., MED_NONOR);
 495                         printf("MEDchampEcr : %d \n",ret);
 496                         }
 497                 }
 498
 499         if (ret == 0)
 500                 {
 501                 ret = MEDchampCr(fromfid,champnodevector,MED_REEL64,champnodevector_comp,champnodevector_unit,3);
 502                 printf("MEDchampCr : %d \n",ret);
 503                 if (ret == 0)
 504                         {
 505                         ret = MEDchampEcr(fromfid, frommaa, champnodevector, (unsigned char *)fieldnodedoublevector,
 506                                                 MED_FULL_INTERLACE, fromnnoe,
 507                                                 MED_NOPG, MED_ALL, MED_NOPFL, MED_ECRI, MED_NOEUD,
 508                                                 0, MED_NOPDT,"        ", 0. , MED_NONOR);
 509                         printf("MEDchampEcr : %d \n",ret);
 510                         }
 511                 }
 512
 513
 514 /***************************************************************************/
 515 ret = MEDfermer(fromfid);
 516 printf("MEDfermer : %d\n",ret);
 517 /***************************************************************************/
 518 ret = MEDfermer(tofid);
 519 printf("MEDfermer : %d\n",ret);
 520
 521 return 0;
 522 }
 523