Concepts et fonctionnalités de base pour créer et lire un paramètre numérique

### Créer un paramètre numérique

L'écriture de paramètres numériques dans un fichier MED est optionnelle : un fichier MED peut en contenir de 0 à plusieurs. Le mode d'écriture pour chaque paramètre consiste à créer le paramètre dont le type peut être entier ou réel comme pour les champs de résultats. La création d'un paramètre numérique se fait via la routine MEDparameterCr / mprcre. Il est possible ensuite d'écrire des valeurs pour un paramètre selon plusieurs séquences de calcul avec la routine MEDparameterValueWr / mprrvw mprivw.

/* This file is part of MED.
*
* COPYRIGHT (C) 1999 - 2021 EDF R&D, CEA/DEN
* MED is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* MED is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with MED. If not, see <http://www.gnu.org/licenses/>.
*/
/******************************************************************************
* - Nom du fichier : test21.c
*
* - Description : ecriture de valeurs scalaires numeriques dans un fichier MED
*
*****************************************************************************/
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#ifdef DEF_LECT_ECR
#define MODE_ACCES MED_ACC_RDWR
#elif DEF_LECT_AJOUT
#define MODE_ACCES MED_ACC_RDEXT
#else
#define MODE_ACCES MED_ACC_CREAT
#endif
int main (int argc, char **argv)
{
med_err ret;
med_idt fid;
char nom_scalaire1[MED_NAME_SIZE+1] = "VariableEntiere";
char description1[MED_COMMENT_SIZE+1] = "Une premiere description";
char nom_scalaire2[MED_NAME_SIZE+1] = "VariableFlottante";
char description2[MED_COMMENT_SIZE+1] = "Une seconde description";
med_int vali1 = 56;
med_int vali2 = -789;
med_float valr1 = 67.98;
/* Creation du fichier test21.med */
if ((fid = MEDfileOpen("test21.med",MODE_ACCES)) < 0) {
MESSAGE("Erreur a la creation du fichier test21.med");
return -1;
}
/* Creation d'un variable scalaire entiere */
if (MEDparameterCr(fid,nom_scalaire1,MED_INT,description1,"ms") < 0) {
MESSAGE("Erreur a la creation d'une variable scalaire enti�re");
return -1;
}
printf("Creation d'une variable scalaire entiere \n");
/* Ecriture d'un valeur sans pas de temps et sans numero d'ordre*/
if (MEDparameterValueWr(fid,nom_scalaire1,MED_NO_DT,MED_NO_IT,MED_UNDEF_DT,(unsigned char*) &vali1) < 0) {
MESSAGE("Erreur a l'ecriture d'une valeur entiere");
return -1;
}
printf("Ecriture d'une valeur entiere sans pas de temps \n");
/* Ecriture d'une valeur entiere avec 1 pas de temps et sans numero d'ordre */
if (MEDparameterValueWr(fid,nom_scalaire1,1,MED_NO_IT,5.5,(unsigned char*) &vali2) < 0) {
MESSAGE("Erreur a l'ecriture d'une valeur entiere");
return -1;
}
printf("Ecriture d'une valeur entiere avec pas de temps \n");
/* Creation d'un variable scalaire flottante */
if (MEDparameterCr(fid,nom_scalaire2,MED_FLOAT64,description2,"ms") < 0) {
MESSAGE("Erreur a la creation d'une variable scalaire flottante");
return -1;
}
printf("Creation d'une variable scalaire flottante \n");
/* Ecriture d'une valeur reelle avec 1 pas de temps et 1 numero d'ordre */
if (MEDparameterValueWr(fid, nom_scalaire2, 1, 2, 5.5, (unsigned char*) &valr1) < 0) {
MESSAGE("Erreur a l'ecriture d'une valeur flottante");
return -1;
}
printf("Ecriture d'une valeur reelle avec pas de temps et numero d'ordre \n");
/* Fermeture du fichier */
if (MEDfileClose(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier");
return -1;
}
return 0;
}

### Lire un paramètre numérique

Le mode de lecture des paramètres numériques se calque sur celui des champs et des maillages. L'accès aux paramètres stockés dans un fichier peut se faire via deux approches possibles : accès par le nom ou via un itérateur. La routine MEDparameterInfoByName / mprpin permet de lire les informations relatives à un paramètre dont on connaît le nom. Les informations lues correspondent à celles écrites par la routine MEDparameterCr / mprcre.

Si on utilise l'approche itérative, il est tout d'abord nécessaire de lire le nombre de paramètre dans le fichier avec la routine MEDnParameter / mprnpr, avant d'itérer sur tous ces paramètres. La routine MEDparameterInfo / mprpri permet de récupérer les informations relative à chaque paramètre dont le nombre de séquence de calcul (au même titre que MEDparameterInfoByName / mprpin). Il s'agit ensuite d'itérer sur chaque séquence de calcul afin d'une part de récupérer les informations relatives à cette séquence avec la routine MEDparameterComputationStepInfo / mprcsi et d'autre part de lire la valeur du paramètre avec la routine MEDparameterValueRd / mprrvr mprivr.

Le cas d'utilisation suivant donne une approche générique pour lire tous les paramètres numériques d'un fichier MED.

/* This file is part of MED.
*
* COPYRIGHT (C) 1999 - 2021 EDF R&D, CEA/DEN
* MED is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* MED is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with MED. If not, see <http://www.gnu.org/licenses/>.
*/
/******************************************************************************
* - Nom du fichier : test22.c
*
* - Description : lecture de valeurs scalaires numeriques crees dans test21.
*
*****************************************************************************/
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#ifdef DEF_LECT_ECR
#define MODE_ACCES MED_ACC_RDWR
#elif DEF_LECT_AJOUT
#define MODE_ACCES MED_ACC_RDEXT
#else
#define MODE_ACCES MED_ACC_CREAT
#endif
int main (int argc, char **argv)
{
med_idt fid;
char nom_scalaire[MED_NAME_SIZE+1];
char description[MED_COMMENT_SIZE+1];
med_int vali;
med_float valr;
med_int i,n,npdt,j;
med_field_type type;
med_int numdt,numo;
med_float dt;
char dt_unit[MED_SNAME_SIZE+1];
/* Ouverture du fichier test21.med en lecture seule */
if ((fid = MEDfileOpen("test21.med",MED_ACC_RDONLY)) < 0) {
MESSAGE("Erreur a l'ouverture du fichier test21.med");
return -1;
}
/* Lecture du nombre de variable scalaire */
n = MEDnParameter(fid);
if (n < 0) {
MESSAGE("Erreur a la lecture du nombre de variable scalaire");
return -1;
}
printf("Nombre de variables scalaires dans test21.med = " IFORMAT "\n",n);
/* Lecture des infos sur les variables (type,description) */
for (i=1;i<=n;i++) {
if (MEDparameterInfo(fid, i, nom_scalaire, &type, description, dt_unit, &npdt) < 0) {
MESSAGE("Erreur a la lecture des infos sur la variable d'indice : ");
ISCRUTE(i);
return -1;
}
printf("- Scalaire n°" IFORMAT " de nom %s \n",i,nom_scalaire);
if (type == MED_FLOAT64)
printf(" Type flottant. \n");
else
printf(" Type entier. \n");
printf(" Description associee : [%s] \n",description);
printf(" Nombre de pas de temps : " IFORMAT " \n",npdt);
for (j=1;j<=npdt;j++) {
if (MEDparameterComputationStepInfo(fid,nom_scalaire,j,&numdt,&numo,&dt) < 0) {
MESSAGE("Erreur a la lecture des informations sur le pas de temps d'indice :");
ISCRUTE(j);
return -1;
}
printf(" Valeur n°" IFORMAT " : \n",j);
if (numdt == MED_NO_DT)
printf(" - Aucun de pas de temps \n");
else
printf(" - Pas de de temps de numero " IFORMAT " de valeur %f [%s] \n",numdt,dt,dt_unit);
if (numo == MED_NO_IT)
printf(" - Aucun numero d'ordre \n");
else
printf(" - Numero d'ordre : " IFORMAT " \n",numo);
/* Lecture de la valeur flottante associee au pas de temps */
if (type == MED_FLOAT64) {
if (MEDparameterValueRd(fid,nom_scalaire,numdt,numo,(unsigned char *) &valr) < 0) {
MESSAGE("Erreur a la lecture de la valeur flottante : ");
SSCRUTE(nom_scalaire); ISCRUTE(numdt);ISCRUTE(numo);
return -1;
}
printf(" - Valeur : %f \n",valr);
} else {
/* Lecture de la valeur scalaire associee au pas de temps */
if (MEDparameterValueRd(fid,nom_scalaire,numdt,numo,(unsigned char *) &vali) < 0) {
MESSAGE("Erreur a la lecture de la valeur entiere : ");
SSCRUTE(nom_scalaire); ISCRUTE(numdt);ISCRUTE(numo);
return -1;
}
printf(" - Valeur : " IFORMAT " \n",vali);
}
}
}
/* Fermeture du fichier */
if (MEDfileClose(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier ");
return -1;
}
return 0;
}
MED_COMMENT_SIZE
#define MED_COMMENT_SIZE
Definition: med.h:79
MEDfileOpen
MEDC_EXPORT med_idt MEDfileOpen(const char *const filename, const med_access_mode accessmode)
Ouverture d'un fichier MED.
Definition: MEDfileOpen.c:42
MED_SNAME_SIZE
#define MED_SNAME_SIZE
Definition: med.h:82
med_idt
hid_t med_idt
Definition: med.h:331
MED_ACC_RDONLY
Definition: med.h:120
med_err
herr_t med_err
Definition: med.h:332
MEDparameterValueRd
MEDC_EXPORT med_err MEDparameterValueRd(const med_idt fid, const char *const paramname, const med_int numdt, const med_int numit, unsigned char *const value)
Cette routine permet la lecture de la valeur d'un paramètre numérique scalaire.
Definition: MEDparameterValueRd.c:37
MESSAGE
#define MESSAGE(chaine)
Definition: med_utils.h:324
med_int
int med_int
Definition: med.h:342
med_field_type
med_field_type
Definition: med.h:165
MED_INT
Definition: med.h:170
med.h
ISCRUTE
#define ISCRUTE(entier)
Definition: med_utils.h:313
med_float
double med_float
Definition: med.h:336
IFORMAT
#define IFORMAT
Definition: med_utils.h:145
MED_NO_DT
#define MED_NO_DT
Definition: med.h:320
MEDparameterCr
MEDC_EXPORT med_err MEDparameterCr(const med_idt fid, const char *const paramname, const med_parameter_type paramtype, const char *const description, const char *const dtunit)
Cette routine permet la création d'un paramètre numérique scalaire.
Definition: MEDparameterCr.c:38
MODE_ACCES
#define MODE_ACCES
Definition: 3.0.8/test10.c:34
SSCRUTE
#define SSCRUTE(chaine)
Definition: med_utils.h:323
MEDnParameter
MEDC_EXPORT med_int MEDnParameter(const med_idt fid)
Cette routine permet la lecture du nombre de paramètre numérique scalaire dans un fichier.
Definition: MEDnParameter.c:34
MED_NAME_SIZE
#define MED_NAME_SIZE
Definition: med.h:81
MEDparameterComputationStepInfo
MEDC_EXPORT med_err MEDparameterComputationStepInfo(const med_idt fid, const char *const paramname, const int csit, med_int *const numdt, med_int *const numit, med_float *const dt)
Cette routine permet la lecture des informations relatives à une étape de calcul du paramètre numériq...
Definition: MEDparameterComputationStepInfo.c:38
MEDfileClose
MEDC_EXPORT med_err MEDfileClose(med_idt fid)
Fermeture d'un fichier MED.
Definition: MEDfileClose.c:30
MED_UNDEF_DT
#define MED_UNDEF_DT
Definition: med.h:322
MEDparameterInfo
MEDC_EXPORT med_err MEDparameterInfo(const med_idt fid, const int paramit, char *const paramname, med_parameter_type *const paramtype, char *const description, char *const dtunit, med_int *const nstep)
Cette routine permet la lecture des informations relatives à un paramètre scalaire via un itérateur.
Definition: MEDparameterInfo.c:37
MED_FLOAT64
Definition: med.h:166
MED_NO_IT
#define MED_NO_IT
Definition: med.h:321
MEDparameterValueWr
MEDC_EXPORT med_err MEDparameterValueWr(const med_idt fid, const char *const paramname, const med_int numdt, const med_int numit, const med_float dt, const unsigned char *const value)
Cette routine permet l'écriture de la valeur d'un paramètre numérique scalaire.
Definition: MEDparameterValueWr.c:39
main
int main(int argc, char **argv)
Definition: 3.0.8/test10.c:50
med_utils.h