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+1,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;
  57         }
  58 void cree_Hexa8(med_int * conn_hexa8, int nnpl)
  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                 printf("Maille numéro %4d :",num_hexa8);
  76
  77                 if (8*num_hexa8  >=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
  78                 if (8*num_hexa8+1>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
  79                 if (8*num_hexa8+2>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
  80                 if (8*num_hexa8+3>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
  81                 if (8*num_hexa8+4>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
  82                 if (8*num_hexa8+5>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
  83                 if (8*num_hexa8+6>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
  84                 if (8*num_hexa8+7>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
  85
  86                 conn_hexa8[8*num_hexa8  ] = 1 + i0+nnpl*j1+nnpl*nnpl*k1 ; printf("%4d ",1+i0+nnpl*j1+nnpl*nnpl*k1);
  87                 conn_hexa8[8*num_hexa8+1] = 1 + i0+nnpl*j0+nnpl*nnpl*k1 ; printf("%4d ",1+i0+nnpl*j0+nnpl*nnpl*k1);
  88                 conn_hexa8[8*num_hexa8+2] = 1 + i1+nnpl*j0+nnpl*nnpl*k1 ; printf("%4d ",1+i1+nnpl*j0+nnpl*nnpl*k1);
  89                 conn_hexa8[8*num_hexa8+3] = 1 + i1+nnpl*j1+nnpl*nnpl*k1 ; printf("%4d ",1+i1+nnpl*j1+nnpl*nnpl*k1);
  90                 conn_hexa8[8*num_hexa8+4] = 1 + i0+nnpl*j1+nnpl*nnpl*k0 ; printf("%4d ",1+i0+nnpl*j1+nnpl*nnpl*k0);
  91                 conn_hexa8[8*num_hexa8+5] = 1 + i0+nnpl*j0+nnpl*nnpl*k0 ; printf("%4d ",1+i0+nnpl*j0+nnpl*nnpl*k0);
  92                 conn_hexa8[8*num_hexa8+6] = 1 + i1+nnpl*j0+nnpl*nnpl*k0 ; printf("%4d ",1+i1+nnpl*j0+nnpl*nnpl*k0);
  93                 conn_hexa8[8*num_hexa8+7] = 1 + i1+nnpl*j1+nnpl*nnpl*k0 ; printf("%4d ",1+i1+nnpl*j1+nnpl*nnpl*k0);
  94
  95                 printf("\n");
  96                 }
  97         }
  98 void cree_noms_mailles(char * noms, int nnpl)
  99         {
 100         int nbr_hexa8=(nnpl-1)*(nnpl-1)*(nnpl-1);
 101         int i;
 102         char pnom[MED_TAILLE_PNOM+1]="hexa    ";
 103
 104         /*noms=(char *) malloc((nbr_hexa8*MED_TAILLE_PNOM+1)*sizeof(char));*/
 105
 106         for (i=0;i<nbr_hexa8;i++) strncpy(&noms[i*MED_TAILLE_PNOM],pnom,MED_TAILLE_PNOM);
 107
 108         noms[nbr_hexa8*MED_TAILLE_PNOM]='\n';
 109
 110         }
 111 void cree_num_mailles(med_int * num_mailles,int nnpl)
 112         {
 113         int nbr_hexa8=(nnpl-1)*(nnpl-1)*(nnpl-1);
 114         int i;
 115
 116         /*num_mailles=(med_int *) malloc(nbr_hexa8*sizeof(med_int));*/
 117
 118         for (i=0;i<nbr_hexa8;i++) num_mailles[i]=i+1;
 119         }
 120 void cree_fam_nodes(med_int * fam,int nnpl)
 121         {
 122         int nbr_nodes=nnpl*nnpl*nnpl;
 123         int i;
 124
 125         /*fam=(med_int *) malloc(nbr_nodes*sizeof(med_int));*/
 126
 127         for (i=0;i<nbr_nodes;i++) fam[i]=0;
 128         }
 129 void cree_fam_mailles(med_int * fam,int nnpl)
 130         {
 131         int nbr_hexa8=(nnpl-1)*(nnpl-1)*(nnpl-1);
 132         int i;
 133
 134         /*fam=(med_int *) malloc(nbr_hexa8*sizeof(med_int));*/
 135
 136         for (i=0;i<nbr_hexa8;i++) fam[i]=0;
 137         }
 138 void cree_valeurs_champ_node(med_float * val,int nnpl)
 139         {
 140         int i,j,k;
 141         int nbr_nodes=nnpl*nnpl*nnpl;
 142         int num_noeud;
 143         int diviseur=nnpl-1;
 144
 145         /*val=(med_float *) malloc(nbr_nodes*sizeof(med_float));*/
 146
 147         for (i=0;i<nnpl;i++) for (j=0;j<nnpl;j++) for (k=0;k<nnpl;k++)
 148                 {
 149                 num_noeud=i+nnpl*j+nnpl*nnpl*k;
 150                 val[num_noeud] = (med_float) (i+j+k)/diviseur;
 151                 }
 152         }
 153 void cree_valeurs_champ_vector_cell(med_float * val,int nnpl)
 154         {
 155         int i,j,k;
 156         int nbr_cells=(nnpl-1)*(nnpl-1)*(nnpl-1);
 157         int num_cell;
 158
 159         int diviseur=nnpl-1;
 160
 161         /*val=(med_float *) malloc(3*nbr_cells*sizeof(med_float));*/
 162
 163         for (i=0;i<nnpl-1;i++) for (j=0;j<nnpl-1;j++) for (k=0;k<nnpl-1;k++)
 164                 {
 165                 num_cell=i+(nnpl-1)*j+(nnpl-1)*(nnpl-1)*k;
 166                 val[3*num_cell  ] = (med_float) i/diviseur;
 167                 val[3*num_cell+1] = (med_float) j/diviseur;
 168                 val[3*num_cell+2] = (med_float) k/diviseur;
 169                 }
 170         }
 171
 172
 173 /*****************************************************************************************************/
 174
 175 int main (int argc, char **argv)
 176         {
 177
 178         int i,j,k;
 179
 180         int nnpl;
 181
 182         int nbr_nodes, nbr_hexa8;
 183
 184         med_err ret;
 185         med_idt fromfid;
 186         med_idt tofid;
 187         char frommaa[MED_TAILLE_NOM+1] = "fromMesh";
 188         char tomaa[MED_TAILLE_NOM+1]   = "toMesh";
 189         const med_int mdim = 3;
 190         med_int fromnnoe;
 191         med_int   tonnoe;
 192
 193         med_float * tocoo;
 194         med_float * fromcoo;
 195
 196         char nomcoo[3*MED_TAILLE_PNOM+1] = "x       y       z       ";
 197         char unicoo[3*MED_TAILLE_PNOM+1] = "cm      cm      cm      ";
 198
 199         char * nomnoe = NULL ;
 200
 201         med_int  * fromnumnoe;
 202         med_int  * fromnufano;
 203
 204         med_int  * tonumnoe;
 205         med_int  * tonufano;
 206
 207         med_int fromnhexa8;
 208         med_int  * fromhexa8;
 209
 210         med_int tonhexa8;
 211         med_int  * tohexa8;
 212
 213
 214         char  * fromnomhexa8;
 215         med_int * fromnumhexa8;
 216         med_int * fromnufahexa8;
 217
 218         char  * tonomhexa8;
 219         med_int * tonumhexa8;
 220         med_int * tonufahexa8;
 221
 222 /*****************************************************************************************************/
 223
 224         char nomfam[MED_TAILLE_NOM+1];
 225         med_int numfam;
 226         char attdes[MED_TAILLE_DESC+1];
 227         med_int natt;
 228         med_int attide;
 229         med_int attval;
 230         med_int ngro;
 231         char gro[MED_TAILLE_LNOM+1];
 232         char gro2[MED_TAILLE_LNOM*2+1];
 233         char gro3[MED_TAILLE_LNOM*3+1];
 234         int nfame = 1;
 235         int nfamn = 1;
 236
 237 /*****************************************************************************************************/
 238
 239         /* Some fields : one on nodes : double , one on cells : double */
 240
 241         char champnode[MED_TAILLE_NOM+1]="fieldnodedouble" ;
 242         char champnode_comp[MED_TAILLE_PNOM+1]="comp1   " ;
 243         char champnode_unit[MED_TAILLE_PNOM+1]="J       " ;
 244         med_float   * fieldnodedouble;
 245
 246         char champcell[MED_TAILLE_NOM+1]="fieldcelldoublevector" ;
 247         char champcell_comp[MED_TAILLE_PNOM*3+1]="comp1   comp2   comp3   " ;
 248         char champcell_unit[MED_TAILLE_PNOM*3+1]="m/s     m/s     m/s     " ;
 249         med_float   * fieldcelldoublevector;
 250
 251 /*****************************************************************************************************/
 252
 253
 254         if (argc!=2)
 255                 {
 256                 printf("Il manque un paramètre : le nombre de point par ligne\n");
 257                 exit(-1);
 258                 }
 259
 260         sscanf(argv[1],"%d",&nnpl);
 261
 262         printf("Traitement avec %d noeuds par ligne\n",nnpl);
 263
 264         fromnnoe   = nnpl*nnpl*nnpl             ;
 265         fromnhexa8 = (nnpl-1)*(nnpl-1)*(nnpl-1) ;
 266         tonnoe     = (nnpl-1)*(nnpl-1)*(nnpl-1) ;
 267         tonhexa8   = (nnpl-2)*(nnpl-2)*(nnpl-2) ;
 268
 269
 270
 271         nbr_nodes=nnpl*nnpl*nnpl;
 272         nbr_hexa8=(nnpl-1)*(nnpl-1)*(nnpl-1);
 273
 274         fromcoo       = (med_float *) malloc(3*nbr_nodes*sizeof(med_float));              cree_nodes        ( fromcoo       , nnpl, 0 );
 275         fromnumnoe    = (med_int *)   malloc(nbr_nodes*sizeof(med_int));                  cree_num_nodes    ( fromnumnoe    , nnpl );
 276         fromnufano    = (med_int *)   malloc(nbr_nodes*sizeof(med_int));                  cree_fam_nodes    ( fromnufano    , nnpl );
 277         fromhexa8     = (med_int *)   malloc(8*nbr_hexa8*sizeof(med_int));                cree_Hexa8        ( fromhexa8     , nnpl );
 278         fromnomhexa8  = (char *)      malloc((nbr_hexa8*MED_TAILLE_PNOM+1)*sizeof(char)); cree_noms_mailles ( fromnomhexa8  , nnpl );
 279         fromnumhexa8  = (med_int *)   malloc(nbr_hexa8*sizeof(med_int));                  cree_num_mailles  ( fromnumhexa8  , nnpl );
 280         fromnufahexa8 = (med_int *)   malloc(nbr_hexa8*sizeof(med_int));                  cree_fam_mailles  ( fromnufahexa8 , nnpl );
 281
 282         fieldnodedouble       = (med_float *) malloc(nbr_nodes*sizeof(med_float));          cree_valeurs_champ_node        ( fieldnodedouble       , nnpl );
 283         fieldcelldoublevector = (med_float *) malloc(3*nbr_hexa8*sizeof(med_float));        cree_valeurs_champ_vector_cell ( fieldcelldoublevector , nnpl );
 284
 285         nbr_nodes=(nnpl-1)*(nnpl-1)*(nnpl-1);
 286         nbr_hexa8=(nnpl-2)*(nnpl-2)*(nnpl-2);
 287
 288         tocoo       = (med_float *) malloc(3*nbr_nodes*sizeof(med_float));              cree_nodes        ( tocoo       , nnpl-1, 1 );
 289         tonumnoe    = (med_int *)   malloc(nbr_nodes*sizeof(med_int));                  cree_num_nodes    ( tonumnoe    , nnpl-1 );
 290         tonufano    = (med_int *)   malloc(nbr_nodes*sizeof(med_int));                  cree_fam_nodes    ( tonufano    , nnpl-1 );
 291         tohexa8     = (med_int *)   malloc(8*nbr_hexa8*sizeof(med_int));                cree_Hexa8        ( tohexa8     , nnpl-1 );
 292         tonomhexa8  = (char *)      malloc((nbr_hexa8*MED_TAILLE_PNOM+1)*sizeof(char)); cree_noms_mailles ( tonomhexa8  , nnpl-1 );
 293         tonumhexa8  = (med_int *)   malloc(nbr_hexa8*sizeof(med_int));                  cree_num_mailles  ( tonumhexa8  , nnpl-1 );
 294         tonufahexa8 = (med_int *)   malloc(nbr_hexa8*sizeof(med_int));                  cree_fam_mailles  ( tonufahexa8 , nnpl-1 );
 295
 296
 297 /*****************************************************************************************************/
 298         fromfid = MEDouvrir("fromMesh.med",MED_REMP);
 299         if (fromfid < 0)
 300                 ret = -1;
 301         else
 302                 ret = 0;
 303         printf("MEDouvrir : %d\n",ret);
 304
 305 /*****************************************************************************************************/
 306         tofid = MEDouvrir("toMesh.med",MED_REMP);
 307         if (tofid < 0)
 308                 ret = -1;
 309         else
 310                 ret = 0;
 311         printf("MEDouvrir : %d\n",ret);
 312 /*****************************************************************************************************/
 313         if (ret == 0)
 314                 ret = MEDmaaCr(fromfid,frommaa,mdim);
 315         printf("MEDmaaCr : %d\n",ret);
 316
 317 /*****************************************************************************************************/
 318
 319         if (ret == 0)
 320                 ret = MEDmaaCr(tofid,tomaa,mdim);
 321         printf("MEDmaaCr : %d\n",ret);
 322
 323 /*****************************************************************************************************/
 324         if (ret == 0)
 325                 ret = MEDnoeudsEcr(fromfid,frommaa,mdim,fromcoo,MED_FULL_INTERLACE,MED_CART,
 326                                      nomcoo,unicoo,nomnoe,MED_FAUX,fromnumnoe,MED_VRAI,
 327                                      fromnufano,fromnnoe,MED_ECRI);
 328         printf("MEDnoeudsEcr : %d\n",ret);
 329 /*****************************************************************************************************/
 330
 331         if (ret == 0)
 332                 ret = MEDnoeudsEcr(tofid,tomaa,mdim,tocoo,MED_FULL_INTERLACE,MED_CART,
 333                                      nomcoo,unicoo,nomnoe,MED_FAUX,tonumnoe,MED_VRAI,
 334                                      tonufano,tonnoe,MED_ECRI);
 335         printf("MEDnoeudsEcr : %d\n",ret);
 336
 337
 338 /*****************************************************************************************************/
 339 /* ecriture des mailles MED_HEXA8 :
 340    - connectivite
 341    - noms (optionnel)
 342    - numeros (optionnel)
 343    - numeros des familles */
 344         if (ret == 0)
 345                 ret = MEDelementsEcr(fromfid,frommaa,mdim,fromhexa8,MED_FULL_INTERLACE,
 346                                         fromnomhexa8,MED_FAUX,fromnumhexa8,MED_VRAI,fromnufahexa8,fromnhexa8,
 347                                         MED_MAILLE,MED_HEXA8,MED_NOD,MED_ECRI);
 348         printf("MEDelementsEcr : %d \n",ret);
 349
 350 /*****************************************************************************************************/
 351 /* ecriture des mailles MED_HEXA8 :
 352    - connectivite
 353    - noms (optionnel)
 354    - numeros (optionnel)
 355    - numeros des familles */
 356
 357         if (ret == 0)
 358                 ret = MEDelementsEcr(tofid,tomaa,mdim,tohexa8,MED_FULL_INTERLACE,
 359                                         tonomhexa8,MED_FAUX,tonumhexa8,MED_VRAI,tonufahexa8,tonhexa8,
 360                                         MED_MAILLE,MED_HEXA8,MED_NOD,MED_ECRI);
 361         printf("MEDelementsEcr : %d \n",ret);
 362
 363 /*****************************************************************************************************/
 364 /* ecriture des familles */
 365 /* Conventions :
 366    - toujours creer une famille de numero 0 ne comportant aucun attribut
 367      ni groupe (famille de reference pour les noeuds ou les elements
 368      qui ne sont rattaches a aucun groupe ni attribut)
 369    - les numeros de familles de noeuds sont > 0
 370    - les numeros de familles des elements sont < 0
 371    - rien d'imposer sur les noms de familles
 372  */
 373
 374 /* la famille 0 */
 375         if (ret == 0)
 376                 {
 377                 strcpy(nomfam,"FAMILLE_0");
 378                 numfam = 0;
 379                 ret = MEDfamCr(fromfid,frommaa,nomfam,numfam,&attide,&attval,attdes,0,gro,0);
 380                 }
 381         printf("MEDfamCr : %d \n",ret);
 382 /*****************************************************************************************************/
 383
 384         if (ret == 0)
 385                 {
 386                 strcpy(nomfam,"FAMILLE_0");
 387                 numfam = 0;
 388                 ret = MEDfamCr(tofid,tomaa,nomfam,numfam,&attide,&attval,attdes,0,gro,0);
 389                 }
 390         printf("MEDfamCr : %d \n",ret);
 391
 392 /*****************************************************************************************************/
 393 /* Les champs */
 394
 395         if (ret == 0)
 396                 {
 397                 ret = MEDchampCr(fromfid,champnode,MED_REEL64,champnode_comp,champnode_unit,1);
 398                 printf("MEDchampCr : %d \n",ret);
 399                 if (ret == 0)
 400                         {
 401                         ret = MEDchampEcr(fromfid, frommaa, champnode, (unsigned char *)fieldnodedouble,
 402                                                 MED_NO_INTERLACE, fromnnoe,
 403                                                 MED_NOPG, MED_ALL, MED_NOPFL, MED_ECRI, MED_NOEUD,
 404                                                 0, MED_NOPDT,"        ", 0. , MED_NONOR);
 405                         printf("MEDchampEcr : %d \n",ret);
 406                         }
 407                 }
 408
 409         if (ret == 0)
 410                 {
 411                 ret = MEDchampCr(fromfid,champcell,MED_REEL64,champcell_comp,champcell_unit,3);
 412                 printf("MEDchampCr : %d \n",ret);
 413                 if (ret == 0)
 414                         {
 415                         ret = MEDchampEcr(fromfid, frommaa, champcell, (unsigned char *)fieldcelldoublevector,
 416                                                 MED_NO_INTERLACE, fromnhexa8,
 417                                                 MED_NOPG, MED_ALL, MED_NOPFL, MED_ECRI, MED_MAILLE,
 418                                                 MED_HEXA8, MED_NOPDT,"        ", 0., MED_NONOR);
 419                         printf("MEDchampEcr : %d \n",ret);
 420                         }
 421                 }
 422
 423
 424 /***************************************************************************/
 425 ret = MEDfermer(fromfid);
 426 printf("MEDfermer : %d\n",ret);
 427 /***************************************************************************/
 428 ret = MEDfermer(tofid);
 429 printf("MEDfermer : %d\n",ret);
 430
 431 return 0;
 432 }
 433