Créer un champ de résultat
Lire un champ de résultats
Créer des séquences de calcul dans un champ de résultats
Lire un champ de résultats avec des séquences de calcul
Créer un champ de résultat
La routine MEDfieldCr / mfdcre permet de créer un champ de résultat dans un fichier MED. Un champ est identifié par son nom qui est une chaîne de MED_NAME_SIZE caractères. Un champ de résultat est constitué d'une ou plusieurs composantes scalaires. A un champ est associé un type et les valeurs correspondant aux différentes composantes sont toutes du même type qui peut être MED_FLOAT64 (réel), MED_INT (entier). Chaque composante se voit attribuer un nom et une unité. Les valeurs du champ sont associée aux entités d'un seul maillage.
La routine MEDfieldValueWr / mfdrvw mfdivw permet d'écrire dans un champ des valeurs correspondant à un résultat portant sur un type d'entité géométrique d'un maillage donné. Si le champ porte sur plusieurs types d'entité, il faut donc appeler cette routine autant de fois qu'il y a de types différents. Les valeurs du champ peuvent porter sur les noeuds, les éléments, les points de Gauss des éléments, les noeuds par élément. Nous ne traitons dans un premier temps que les champs aux noeuds et aux éléments.
Le cas d'utilisation suivant permet de créer un champ Température à une composante. Les résultats de ce champ portent sur les noeuds et les éléments du maillage. A noter que le maillage se trouvant dans un fichier différent de celui du champ, il est possible d'indiquer le nom et le chemin d'accès au fichier contenant le maillage en créant un lien avec la routine MEDlinkWr / mlnliw. Le lien porte alors le nom du maillage.
#define MESGERR 1
#include <string.h>
int main (
int argc,
char **argv) {
const med_float verticesvalues[15] = { 0., 100., 200., 300., 400.,
500., 600., 700., 800., 900,
1000., 1100, 1200., 1300., 1500. };
const med_float tria3values[8] = {1000., 2000., 3000., 4000.,
5000., 6000., 7000., 8000.};
const med_float quad4values[4] = {10000., 20000., 30000., 4000.};
int ret=-1;
if (fid < 0) {
MESSAGE(
"ERROR : file creation ...");
goto ERROR;
}
if (
MEDlinkWr(fid,meshname,
"./UsesCase_MEDmesh_1.med") < 0) {
MESSAGE(
"ERROR : create mesh link ...");
goto ERROR;
}
ncomponent, componentname, componentunit,"",
meshname) < 0) {
goto ERROR;
}
nnodes,(unsigned char*) verticesvalues) < 0) {
MESSAGE(
"ERROR : write field values on vertices");
goto ERROR;
}
ntria3, (unsigned char*) tria3values) < 0) {
MESSAGE(
"ERROR : write field values on MED_TRIA3");
goto ERROR;
}
nquad4, (unsigned char*) quad4values) < 0) {
MESSAGE(
"ERROR : write field values on MED_QUAD4 ");
goto ERROR;
}
ret=0;
ERROR :
ret = -1;
}
return ret;
}
Lire un champ de résultats
Comme pour les maillages, l'accès aux champs stockés dans un fichier se fait via deux approches possibles : accès par le nom ou via un itérateur. La routine MEDfieldInfoByName / mfdfin permet de lire les informations relatives à un champ dont on connaît le nom. Les informations lues correspondent à celles écrites par la routine MEDfieldCr / mfdcre.
Il est ensuite nécessaire pour chaque type d'entité présent dans le maillage de connaître le nombre de valeurs à lire avec la routine MEDfieldnValue / mfdnva. Le nombre de valeurs ainsi obtenu, permet de calculer la zône mémoire à allouer en vue de lire ces données (à savoir le nombre de valeurs * nombre de composantes du champ). Enfin la routine MEDfieldValueRd / mfdrvr mfdivr permet de lire les valeurs associées à un type d'entité donné.
Le cas d'utilisation suivant montre comment lire les données du champ écrites dans le cas d'utilisation précédent.
#define MESGERR 1
#include <string.h>
int main (
int argc,
char **argv) {
int ret=-1;
if (fid < 0) {
goto ERROR;
}
componentname, componentunit, dtunit, &nstep) < 0) {
MESSAGE(
"ERROR : Field info by name ...");
goto ERROR;
}
MESSAGE(
"ERROR : read number of values ...");
goto ERROR;
}
if ((verticesvalues = (
med_float *) malloc(
sizeof(
med_float)*nvalues*ncomponent)) == NULL) {
MESSAGE(
"ERROR : memory allocation ...");
goto ERROR;
}
MESSAGE(
"ERROR : read fields values on vertices ...");
free(verticesvalues);
goto ERROR;
}
free(verticesvalues);
MESSAGE(
"ERROR : read number of values ...");
goto ERROR;
}
MESSAGE(
"ERROR : memory allocation ...");
goto ERROR;
}
MESSAGE(
"ERROR : read fields values for MED_TRIA3 cells ...");
free(tria3values);
goto ERROR;
}
free(tria3values);
MESSAGE(
"ERROR : read number of values ...");
goto ERROR;
}
MESSAGE(
"ERROR : memory allocation ...");
goto ERROR;
}
MESSAGE(
"ERROR : read fields values for MED_QUAD4 cells ...");
free(quad4values);
goto ERROR;
}
free(quad4values);
ret=0;
ERROR:
ret=-1;
}
return ret;
}
Une approche plus générique dans la lecture d'un champ est donnée dans l'exemple suivant. La routine MEDnField / mfdnfd va lire le nombre de champ dans le fichier. Il s'agit ensuite d'itérer sur ces champs. La routine MEDfieldInfo / mfdfdi permet de lire les informations relatives à un champ à partir d'un itérateur. La routine MEDfieldnComponent / mfdnfc permet de récupérer le nombre de composante du champ en vue de dimensionner la taille des paramètres utiles à la routine MEDfieldInfo.
Une fois les informations générales du champ connues, il est nécessaire pour chaque type d'entité présent dans le maillage de connaître le nombre de valeurs à lire avec la routine MEDfieldnValue / mfdnva. Le nombre de valeurs ainsi obtenu, permet de calculer la zône mémoire à allouer en vue de lire ces données (à savoir le nombre de valeurs * nombre de composantes du champ). Enfin la routine MEDfieldValueRd / mfdrvr mfdivr permet de lire les valeurs associées à un type d'entité donné. Pour les mailles et le cas échéant les faces et les arêtes, il est possible d'itérer sur le nombre de type géométrique pré-défini dans le modèle. Par exemple pour les mailles, cette valeur est fixée par le paramètre constant MED_N_CELL_FIXED_GEO.
#define MESGERR 1
#include <string.h>
#define MESGERR 1
#include <string.h>
int main (
int argc,
char **argv) {
char *componentname = NULL;
char *componentunit = NULL;
int ret=-1;
if (fid < 0) {
goto ERROR;
}
MESSAGE(
"ERROR : How many fields in the file ...");
goto ERROR;
}
for (i=0; i<nfield; i++) {
MESSAGE(
"ERROR : number of field component ...");
goto ERROR;
}
if ((componentname = (
char *) malloc(ncomponent*
MED_SNAME_SIZE+1)) == NULL) {
MESSAGE(
"ERROR : memory allocation ...");
goto ERROR;
}
if ((componentunit = (
char *) malloc(ncomponent*
MED_SNAME_SIZE+1)) == NULL) {
MESSAGE(
"ERROR : memory allocation ...");
goto ERROR;
}
if (
MEDfieldInfo(fid, i+1, fieldname, meshname, &localmesh, &fieldtype,
componentname, componentunit, dtunit, &nstep) < 0) {
free(componentname); free(componentunit);
goto ERROR;
}
free(componentname); free(componentunit);
MESSAGE(
"ERROR : read number of values ...");
goto ERROR;
}
if (nvalues) {
MESSAGE(
"ERROR : memory allocation ...");
goto ERROR;
}
MESSAGE(
"ERROR : read fields values defined on vertices ...");
free(values);
goto ERROR;
}
free(values);
}
geotype = geotypes[j];
geotype)) < 0) {
MESSAGE(
"ERROR : read number of values ...");
goto ERROR;
}
if (nvalues) {
MESSAGE(
"ERROR : memory allocation ...");
goto ERROR;
}
MESSAGE(
"ERROR : read fields values for cells ...");
free(values);
goto ERROR;
}
free(values);
}
}
}
ret=0;
ERROR:
ret=-1;
}
return ret;
}
Créer des séquences de calcul dans un champ de résultats
Une séquence de calcul correspond à une date (pas de temps) et/ou une étape itérative (numéro d'ordre). Les valeurs d'un champ peuvent porter sur une séquence de calcul autre que la séquence initiale (MED_NO_DT, MED_NO_IT) utilisée par défaut. La définition de la séquence de calcul se fait lors de la l'écriture des valeurs du champ avec la routine MEDfieldValueWr / mfdrvw mfdivw qui prend en paramètres le pas de temps et le numéro d'ordre.
Il est possible de référencer l'étape d'évolution d'un maillage à laquelle l'étape de calcul correspond le cas échéant avec la routine MEDfieldComputingStepMeshWr / mfdcmw. Par défaut les valeurs du champ se rapportent au maillage initial (MED_NO_DT, MED_NO_IT).
#define MESGERR 1
#include <string.h>
int main (
int argc,
char **argv) {
const med_float tria3values_step1[8] = {1000., 2000., 3000., 4000.,
5000., 6000., 7000., 8000.};
const med_float quad4values_step1[4] = {10000., 20000., 30000., 4000.};
const med_float tria3values_step2[8] = {1500., 2500., 3500., 4500.,
5500., 6500., 7500., 8500.};
const med_float quad4values_step2[4] = {15000., 25000., 35000., 45000.};
int ret=-1;
if (fid < 0) {
MESSAGE(
"ERROR : file creation ...");
goto ERROR;
}
if (
MEDlinkWr(fid,meshname,
"./UsesCase_MEDmesh_1.med") < 0) {
MESSAGE(
"ERROR : create mesh link ...");
goto ERROR;
}
ncomponent, componentname, componentunit,"ms", meshname) < 0) {
goto ERROR;
}
MESSAGE(
"ERROR : write field values on MED_TRIA3");
goto ERROR;
}
MESSAGE(
"ERROR : write field values on MED_QUAD4 ");
goto ERROR;
}
MESSAGE(
"ERROR : write field values on MED_TRIA3");
goto ERROR;
}
MESSAGE(
"ERROR : write field values on MED_QUAD4 ");
goto ERROR;
}
1, 3 ) < 0 ) {
MESSAGE(
"ERROR : write field mesh computation step error ");
goto ERROR;
}
ret=0;
ERROR:
ret=-1;
}
return ret;
}
Lire un champ de résultats avec des séquences de calcul
A la lecture, le nombre de séquence de calcul du champ peut est récupéré par les routines MEDfieldInfoByName / mfdfin et MEDfieldInfo / mfdfdi. Il s'agit ensuite d'itérer sur ce nombre de séquence afin de lire les valeurs portant sur les entités du maillage. La routine MEDfieldComputingStepMeshInfo / mfdcmi permet de récupérer les informations relatives à la séquence de calcul (pas de temps et numéro d'ordre), ainsi que l'étape d'évolution du maillage correspondante. La routine MEDfieldComputingStepInfo / mfdcsi permet de récupérer les informations relatives à la séquence de calcul sans se préoccuper du maillage dans le cas d'un maillage non évolutif.
#define MESGERR 1
#include <string.h>
int main (
int argc,
char **argv) {
med_int csit, numit, numdt, meshnumit, meshnumdt, it;
int ret=-1;
if (fid < 0) {
goto ERROR;
}
componentname, componentunit, dtunit, &nstep) < 0) {
MESSAGE(
"ERROR : Field info by name ...");
goto ERROR;
}
for (csit=0; csit<nstep; csit++) {
&meshnumdt, &meshnumit) < 0) {
MESSAGE(
"ERROR : Computing step info ...");
goto ERROR;
}
geotype = geotypes[it];
MESSAGE(
"ERROR : read number of values ...");
goto ERROR;
}
if (nvalues) {
MESSAGE(
"ERROR : memory allocation ...");
goto ERROR;
}
MESSAGE(
"ERROR : read fields values for cells ...");
free(values);
goto ERROR;
}
free(values);
}
}
}
ret=0;
ERROR:
ret=-1;
}
return ret;
}
Le cas d'utilisation suivant fournit une approche générique pour lire les valeurs portant sur les mailles du maillage pour toutes les séquences de calcul de tous les champs d'un fichier MED.
#define MESGERR 1
#include <string.h>
#define MESGERR 1
#include <string.h>
int main (
int argc,
char **argv) {
char *componentname = NULL;
char *componentunit = NULL;
med_int csit, numit, numdt, meshnumit, meshnumdt, it;
int k;
int ret=-1;
if (fid < 0) {
goto ERROR;
}
MESSAGE(
"ERROR : How many fields in the file ...");
goto ERROR;
}
for (i=0; i<nfield; i++) {
MESSAGE(
"ERROR : number of field component ...");
goto ERROR;
}
if ((componentname = (
char *) malloc(ncomponent*
MED_SNAME_SIZE+1)) == NULL) {
MESSAGE(
"ERROR : memory allocation ...");
goto ERROR;
}
if ((componentunit = (
char *) malloc(ncomponent*
MED_SNAME_SIZE+1)) == NULL) {
MESSAGE(
"ERROR : memory allocation ...");
goto ERROR;
}
if (
MEDfieldInfo(fid, i+1, fieldname, meshname, &localmesh, &fieldtype,
componentname, componentunit, dtunit, &nstep) < 0) {
free(componentname);
free(componentunit);
goto ERROR;
}
free(componentname);
free(componentunit);
for (csit=0; csit<nstep; csit++) {
&meshnumdt, &meshnumit) < 0) {
MESSAGE(
"ERROR : Computing step info ...");
goto ERROR;
}
geotype = geotypes[it];
MESSAGE(
"ERROR : read number of values ...");
goto ERROR;
}
if (nvalues) {
MESSAGE(
"ERROR : memory allocation ...");
goto ERROR;
}
MESSAGE(
"ERROR : read fields values for cells ...");
free(values);
goto ERROR;
}
free(values);
}
}
}
}
ret=0;
ERROR:
ret=-1;
}
return ret;
}