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.
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#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;
}
int main(int argc, char **argv)
#define MED_ALL_CONSTITUENT
MEDC_EXPORT med_err MEDfieldCr(const med_idt fid, const char *const fieldname, const med_field_type fieldtype, const med_int ncomponent, const char *const componentname, const char *const componentunit, const char *const dtunit, const char *const meshname)
Cette fonction crée un champ dans un fichier.
MEDC_EXPORT med_err MEDfieldValueWr(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit, const med_float dt, const med_entity_type entitype, const med_geometry_type geotype, const med_switch_mode switchmode, const med_int componentselect, const med_int nentity, const unsigned char *const value)
Cette fonction permet d'écrire les valeurs d'un champ définies sur des entités d'un maillage pour une...
MEDC_EXPORT med_err MEDfileClose(med_idt fid)
Fermeture d'un fichier MED.
MEDC_EXPORT med_idt MEDfileOpen(const char *const filename, const med_access_mode accessmode)
Ouverture d'un fichier MED.
MEDC_EXPORT med_err MEDlinkWr(const med_idt fid, const char *const meshname, const char *const link)
Cette routine permet d'écrire un lien dans un fichier MED.
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.
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#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;
}
MEDC_EXPORT med_err MEDfieldValueRd(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, const med_switch_mode switchmode, const med_int componentselect, unsigned char *const value)
Cette fonction permet de lire les valeurs d'un champ définies sur des entités d'un maillage pour une ...
MEDC_EXPORT med_err MEDfieldInfoByName(const med_idt fid, const char *const fieldname, char *const meshname, med_bool *const localmesh, med_field_type *const fieldtype, char *const componentname, char *const componentunit, char *const dtunit, med_int *const ncstp)
Cette fonction permet de lire les informations concernant le champ de nom fieldname.
MEDC_EXPORT med_int MEDfieldnValue(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype)
Cette fonction permet de lire le nombre de valeurs dans un champ pour une étape de calcul,...
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.
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#include <string.h>
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#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;
}
#define MED_N_CELL_FIXED_GEO
MEDC_EXPORT med_geometry_type MED_GET_CELL_GEOMETRY_TYPE[MED_N_CELL_FIXED_GEO+2]
MEDC_EXPORT med_int MEDnField(const med_idt fid)
Cette fonction permet de lire le nombre de champs dans un fichier.
MEDC_EXPORT med_int MEDfieldnComponent(const med_idt fid, const int ind)
Cette fonction lit le nombre de composantes d'un champ.
MEDC_EXPORT med_err MEDfieldInfo(const med_idt fid, const int ind, char *const fieldname, char *const meshname, med_bool *const localmesh, med_field_type *const fieldtype, char *const componentname, char *const componentunit, char *const dtunit, med_int *const ncstp)
Cette fonction permet de lire les informations concernant le champ d'indice ind .
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).
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#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;
}
MEDC_EXPORT med_err MEDfieldComputingStepMeshWr(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit, const med_int meshnumdt, const med_int meshnumit)
Cette fonction permet de définir l'étape de calcul ( meshnumdit , meshnumit ) à utiliser pour le mail...
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.
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#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;
}
MEDC_EXPORT med_err MEDfieldComputingStepMeshInfo(const med_idt fid, const char *const fieldname, const int csit, med_int *const numdt, med_int *const numit, med_float *const dt, med_int *const meshnumdt, med_int *const meshnumit)
Cette fonction permet de lire les informations caractérisant une étape de calcul : numéro de pas de t...
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.
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#include <string.h>
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#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;
}