# _MEDmeshAdvancedRd236.c

Aller à la documentation de ce fichier.

    00001 /*  This file is part of MED.
    00002  *
    00003  *  COPYRIGHT (C) 1999 - 2011  EDF R&D, CEA/DEN
    00004  *  MED is free software: you can redistribute it and/or modify
    00005  *  it under the terms of the GNU Lesser General Public License as published by
    00006  *  the Free Software Foundation, either version 3 of the License, or
    00007  *  (at your option) any later version.
    00008  *
    00009  *  MED is distributed in the hope that it will be useful,
    00010  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    00011  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00012  *  GNU Lesser General Public License for more details.
    00013  *
    00014  *  You should have received a copy of the GNU Lesser General Public License
    00015  *  along with MED.  If not, see <http://www.gnu.org/licenses/>.
    00016  */
    00017
    00018
    00019 #include <med.h>
    00020 #include <med_config.h>
    00021 #include <med_outils.h>
    00022 #include <string.h>
    00023 #include <stdlib.h>
    00024
    00025 #include <2.3.6/med23v30.h>
    00026 #include <2.3.6/med23v30_proto.h>
    00027 #include "2.3.6/med23v30_misc.h"
    00028 #include "2.3.6/med23v30_hdfi.h"
    00029
    00030
    00031 void _MEDmeshAdvancedRd236(int dummy, ...)
    00032 {
    00033   med_access_mode       _MED_ACCESS_MODE;
    00034   med_err               _ret=-1;
    00035   med_idt               _meshid=0;
    00036   med_idt               _datagroup=0, _datagroup2=0,_datagroup3=0,_dataset=0;
    00037   char                  _meshpath         [MED_TAILLE_SUP_MAA+MED_NAME_SIZE+1]="";
    00038   char                  _datagroupname2   [MED_TAILLE_NOM_ENTITE+1]="";
    00039   char                  _datagroupname3   [MED_TAILLE_NOM_ENTITE+1]="";
    00040   char                  _datasetname      [MED_TAILLE_NOM_ENTITE+1]="";
    00041
    00042   char                  _geotypename      [MED_TAILLE_NOM_ENTITE+1]="";
    00043   med_bool              _filterparameterexist=MED_FALSE;
    00044   med_filter *          _filter           = NULL;
    00045   med_filter            _tmpfilter        = MED_FILTER_INIT;
    00046   med_int               _nbofconstituentpervalue=0,_spacedim=0;
    00047   med_internal_type     _datatype;
    00048   med_int               _nbofvalueperentity=0;
    00049   med_mesh_type         _meshtype=MED_UNDEF_MESH_TYPE;
    00050   med_int               _intmeshtype=0;
    00051   med_bool              _isasupportmesh=MED_FALSE;
    00052   med_int               _intgridtype=0;
    00053   med_grid_type         _gridtype=MED_UNDEF_GRID_TYPE;
    00054
    00055
    00056   MED_VARGS_DECL(const, med_idt               , , fid         );
    00057   MED_VARGS_DECL(const, char*  , const          , meshname    );
    00058   MED_VARGS_DECL(const, med_data_type         , , meddatatype );
    00059   MED_VARGS_DECL(const, char*  , const          , datasetname );
    00060   MED_VARGS_DECL(const, med_internal_type     , , datatype    );
    00061   MED_VARGS_DECL(const, med_int               , , numdt       );
    00062   MED_VARGS_DECL(const, med_int               , , numit       );
    00063   MED_VARGS_DECL(const, med_entity_type       , , entitytype  );
    00064   MED_VARGS_DECL(const, med_geometry_type     , , geotype     );
    00065   MED_VARGS_DECL(const, med_connectivity_mode , , cmode       );
    00066   MED_VARGS_DECL(const, med_storage_mode      , , storagemode );
    00067   MED_VARGS_DECL(const, char * , const          , profilename );
    00068   MED_VARGS_DECL(const, med_switch_mode       , , switchmode  );
    00069   MED_VARGS_DECL(const, med_int               , , dimselect   );
    00070   MED_VARGS_DECL(const, med_filter * , const    , filter      );
    00071   MED_VARGS_DECL(,unsigned char*, const         , value       );
    00072   MED_VARGS_DECL(, med_err *                   ,, fret        );
    00073
    00074   va_list params;
    00075   va_start(params,dummy);
    00076
    00077   MED_VARGS_DEF(const, med_idt               , , fid         );
    00078   MED_VARGS_DEF(const, char*  , const          , meshname           );
    00079   MED_VARGS_DEF(const, med_data_type         , , meddatatype );
    00080   MED_VARGS_DEF(const, char*  , const          , datasetname );
    00081   MED_VARGS_DEF(const, med_internal_type     , , datatype           );
    00082   MED_VARGS_DEF(const, med_int               , , numdt           );
    00083   MED_VARGS_DEF(const, med_int               , , numit           );
    00084   MED_VARGS_DEF(const, med_entity_type       , , entitytype  );
    00085   MED_VARGS_DEF(const, med_geometry_type     , , geotype           );
    00086   MED_VARGS_DEF(const, med_connectivity_mode , , cmode           );
    00087   MED_VARGS_DEF(const, med_storage_mode      , , storagemode );
    00088   MED_VARGS_DEF(const, char * , const          , profilename );
    00089   MED_VARGS_DEF(const, med_switch_mode       , , switchmode  );
    00090   MED_VARGS_DEF(const, med_int               , , dimselect   );
    00091   MED_VARGS_DEF(const, med_filter * , const    , filter           );
    00092   MED_VARGS_DEF(,unsigned char*, const         , value       );
    00093   MED_VARGS_DEF(, med_err *                   ,, fret        );
    00094
    00095   _datatype=datatype;
    00096
    00097   if (filter) {
    00098     _filter=(med_filter*)(filter); _filterparameterexist=MED_TRUE;
    00099   }
    00100   else {
    00101     _filter=&_tmpfilter;
    00102 /*  Inutilisé en lecture 2.3.x*/
    00103 /*     (*_filter).nbofentity              = nbofentity; */
    00104     (*_filter).nbofvaluesperentity     = 1;
    00105 /*   (*_filter).nbofconstituentpervalue = nbofconstituentpervalue; */
    00106     (*_filter).constituentselect       = dimselect;
    00107     (*_filter).switchmode              = switchmode;
    00108     (*_filter).storagemode             = storagemode;
    00109     strcpy((*_filter).profilename,profilename);
    00110     (*_filter).profilearraysize        = 0;
    00111   }
    00112
    00113   if ( (*_filter).storagemode == MED_UNDEF_PFLMODE)
    00114     (*_filter).storagemode              = MED_GLOBAL_PFLMODE;
    00115
    00116   /*
    00117    * On inhibe le gestionnaire d'erreur HDF 5
    00118    */
    00119   _MEDmodeErreurVerrouiller();
    00120
    00121   if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
    00122     MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
    00123     goto ERROR;
    00124   }
    00125
    00126   /*
    00127    * Si le DataGroup MED_MAA n'existe pas => erreur
    00128    */
    00129   NOFINALBLANK(meshname,ERROR);
    00130
    00131
    00132   /* Les séquences de calcul dans les maillages ne sont gérées qu'à partir de la 3.0*/
    00133   if ( (numdt != MED_NO_DT) || (numit != MED_NO_IT) ) {
    00134     MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_COMPUTINGSTEP,MED_ERR_MESH_MSG);
    00135     SSCRUTE(meshname);ISCRUTE(numdt);ISCRUTE(numit);
    00136     goto ERROR;
    00137   }
    00138
    00139   if ((_meshid=_MEDmeshDatagroupOpen(fid,meshname,_meshpath,&_isasupportmesh)) < 0) {
    00140     MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
    00141     SSCRUTE(_meshpath); goto ERROR;
    00142   }
    00143
    00144   /* Lecture de l'attribut MED_NOM_ESP  */
    00145   if (_MEDattrEntierLire(_meshid,MED_NOM_ESP,&_spacedim) < 0) {
    00146     if (_MEDattrEntierLire(_meshid,MED_NOM_DIM,&_spacedim) < 0) {
    00147       MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
    00148       SSCRUTE(meshname);SSCRUTE(MED_NOM_DIM);goto ERROR;
    00149     }
    00150   }
    00151
    00152   /* Lecture de l'attribut MED_NOM_TYP  */
    00153   if (_MEDattrEntierLire(_meshid,MED_NOM_TYP,&_intmeshtype) < 0) {
    00154     MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
    00155     SSCRUTE(meshname);SSCRUTE(MED_NOM_TYP);ISCRUTE(_intmeshtype);goto ERROR;
    00156   }
    00157   _meshtype = (med_mesh_type) _intmeshtype;
    00158
    00159   if ( _meshtype == MED_STRUCTURED_MESH ) {
    00160  /*
    00161    * Lecture du type de grille (attribut MED_NOM_GTY)
    00162    */
    00163     if (_MEDattrEntierLire(_meshid,MED_NOM_GTY,&_intgridtype) < 0) {
    00164       MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
    00165       SSCRUTE(meshname);SSCRUTE(MED_NOM_GTY);ISCRUTE(_intgridtype);goto ERROR;
    00166     }
    00167     _gridtype=(med_grid_type) _intgridtype;
    00168   }
    00169
    00170
    00171   if ( (entitytype == MED_STRUCT_ELEMENT) || (meddatatype == MED_VARIABLE_ATTRIBUTE) ) {
    00172     MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
    00173     ISCRUTE_int(entitytype);ISCRUTE_int(meddatatype);goto ERROR;
    00174   }
    00175
    00176
    00177   /* Si un nom de dataset est précisé, il n'est pas géré en 2.3.6
    00178      Detection automatique en
    00179      fonction des paramètres meddatatype et cmode */
    00180   if ( !strlen(datasetname) ) {
    00181     if ( _MEDgetDatasetName( _datasetname, meddatatype, cmode ) < 0 ) {
    00182       MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDgetDatasetname");
    00183       ISCRUTE_int(meddatatype);ISCRUTE_int(cmode);SSCRUTE( _datasetname);goto ERROR;
    00184     }
    00185   } else {
    00186     MED_ERR_(_ret,MED_ERR_NULL,MED_ERR_DATASET,datasetname);
    00187     goto ERROR;
    00188   }
    00189
    00190   /* Si un type de dataset est précisé, il est prioritaire sur la détection automatique en
    00191      fonction des paramètres meddatatype et cmode */
    00192   /* TODO : renommer datatype en idatatype (internal) */
    00193 /*   if ( _datatype == MED_INTERNAL_UNDEF) */
    00194 /*     if ( _MEDgetDatatype( &_datatype, meddatatype, cmode ) < 0 ) { */
    00195 /*       MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDgetDatatype"); */
    00196 /*       ISCRUTE(meddatatype);ISCRUTE(cmode);ISCRUTE(_datatype);goto ERROR; */
    00197 /*     } */
    00198
    00199   /* Vérification :
    00200      Le type de données MED traitées sont-elles compatibles avec le type de maillage ?
    00201   */
    00202   /* REM : Si datasetname ou datatype ne sont pas précisés, meddatatype doit l'être */
    00203 /*   if ( meddatatype != MED_UNDEF_DATATYPE ) */
    00204 /*     if ( _MEDmeshtypeCompatibility(meddatatype, _intmeshtype) < 0) { */
    00205 /*       MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_MEDDATATYPE,MED_ERR_VALUE_MSG); */
    00206 /*       ISCRUTE_int(meddatatype);ISCRUTE_int(_intmeshtype);goto ERROR; */
    00207 /*     } */
    00208
    00209   if ( ! (_nbofvalueperentity && _nbofconstituentpervalue) )
    00210     if ( _MEDgetDatasetParameter( meddatatype, _spacedim, entitytype, geotype, cmode,
    00211                                   &_nbofvalueperentity,&_nbofconstituentpervalue) < 0 ) {
    00212       MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDgetDatasetParameter");
    00213       ISCRUTE_int(meddatatype);ISCRUTE_int(cmode);ISCRUTE(_nbofvalueperentity);
    00214       ISCRUTE(_nbofconstituentpervalue);goto ERROR;
    00215     }
    00216
    00217   if (_filterparameterexist) {
    00218     if ((*_filter).nbofconstituentpervalue != _nbofconstituentpervalue ) {
    00219       MED_ERR_(_ret,MED_ERR_NOTEQUAL,MED_ERR_ATTRIBUTE,MED_ERR_VALUE_MSG);
    00220       ISCRUTE((*_filter).nbofconstituentpervalue); ISCRUTE(_nbofconstituentpervalue );
    00221       goto ERROR;
    00222     }
    00223     if ((*_filter).nbofvaluesperentity != _nbofvalueperentity ) {
    00224       MED_ERR_(_ret,MED_ERR_NOTEQUAL,MED_ERR_ATTRIBUTE,MED_ERR_VALUE_MSG);
    00225       ISCRUTE((*_filter).nbofvaluesperentity); ISCRUTE(_nbofvalueperentity );
    00226       goto ERROR;
    00227     }
    00228   } else {
    00229     (*_filter).nbofconstituentpervalue = _nbofconstituentpervalue;
    00230     (*_filter).nbofvaluesperentity     = _nbofvalueperentity;
    00231   }
    00232
    00233
    00234   /*
    00235    *  Ouverture du datagroup de niveau 3 <entitytype>
    00236    */
    00237   if (_MEDgetEntityTypeName(_datagroupname2,entitytype) < 0) {
    00238     MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
    00239     ISCRUTE_int(entitytype);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);goto ERROR;
    00240   }
    00241
    00242   if ((_datagroup2 = _MEDdatagroupOuvrir(_meshid,_datagroupname2)) < 0) {
    00243     MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
    00244     SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
    00245     goto ERROR;
    00246   }
    00247
    00248
    00249   /*
    00250    *  Ouverture du datagroup de niveau 4 [.<geotype>]
    00251    */
    00252
    00253   if ( entitytype != MED_NODE ) {
    00254
    00255     if (strlen(_geotypename))
    00256       strncpy(_datagroupname3,_geotypename,MED_NAME_SIZE+1);
    00257     else
    00258       if ( _MEDgetInternalGeometryTypeName(_datagroupname3,geotype) < 0) {
    00259         MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
    00260         ISCRUTE_int(geotype);SSCRUTE(meshname);SSCRUTE(_datagroupname2);
    00261         goto ERROR;
    00262       }
    00263
    00264     if ((_datagroup3 = _MEDdatagroupOuvrir(_datagroup2,_datagroupname3)) < 0) {
    00265           MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
    00266           SSCRUTE(meshname);SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);
    00267           goto ERROR;
    00268     }
    00269   }
    00270
    00271
    00272   if (_datagroup3) _datagroup=_datagroup3; else _datagroup=_datagroup2;
    00273
    00274
    00275   /*
    00276    * Cohérence de l'attribut PFL (nombre de noeuds ou d'elements)
    00277    */
    00278   if ( strlen((*_filter).profilename)  ) {  /* != MED_NOPFL*/
    00279     MED_ERR_(_ret,MED_ERR_NULL,MED_ERR_PROFILE,(*_filter).profilename);
    00280     SSCRUTE(meshname);SSCRUTE(_datagroupname2);
    00281     SSCRUTE(_datagroupname3);goto ERROR;
    00282   }
    00283
    00284   if ((*_filter).storagemode != MED_GLOBAL_PFLMODE ) {
    00285     MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_FILTER,"");
    00286     ISCRUTE_int(geotype);SSCRUTE(meshname);SSCRUTE(_datagroupname2);
    00287     ISCRUTE_int((*_filter).storagemode);goto ERROR;
    00288   }
    00289
    00290   switch(meddatatype)
    00291     {
    00292
    00293     case MED_COORDINATE_AXIS1 :
    00294       strcpy(_datasetname,MED_NOM_IN1);
    00295       if (_gridtype == MED_CURVILINEAR_GRID) goto CURVILINEAR_LABEL; else goto COORDINATE_LABEL;
    00296
    00297     case MED_COORDINATE_AXIS2 :
    00298       strcpy(_datasetname,MED_NOM_IN2);
    00299       if (_gridtype == MED_CURVILINEAR_GRID) goto CURVILINEAR_LABEL; else goto COORDINATE_LABEL;
    00300
    00301     case MED_COORDINATE_AXIS3 :
    00302       strcpy(_datasetname,MED_NOM_IN3);
    00303       if (_gridtype == MED_CURVILINEAR_GRID) goto CURVILINEAR_LABEL; else goto COORDINATE_LABEL;
    00304
    00305     CURVILINEAR_LABEL:
    00306       if ((_dataset = _MEDdatasetOuvrir(_datagroup,MED_NOM_COO)) < 0) {
    00307         MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATASET,MED_NOM_COO);
    00308         goto ERROR;
    00309       }
    00310
    00311       if (_MEDattrEntierLire(_dataset,_datasetname, (unsigned char*) value ) < 0) {
    00312         MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,_datasetname);
    00313         goto ERROR;
    00314       }
    00315       break;
    00316
    00317
    00318     case MED_COORDINATE :
    00319     COORDINATE_LABEL:
    00320       if (_MEDdatasetNumLire(_datagroup,_datasetname,MED_FLOAT64,
    00321                                     (med_mode_switch) (*_filter).switchmode ,
    00322                                     (med_size)        (*_filter).nbofconstituentpervalue,
    00323                                     (med_size)        (*_filter).constituentselect,
    00324                                     (med_size)        (*_filter).filterarraysize,
    00325                                     MED_COMPACT,MED_PFL_NON_COMPACT,
    00326                                     (*_filter).filterarray23v30,
    00327                                     MED_NOPG, 0, (unsigned char*) value ) < 0)
    00328         goto ERROR;
    00329       break;
    00330
    00331
    00332     case MED_INDEX_FACE :
    00333     case MED_INDEX_NODE :
    00334       switch(cmode)
    00335         {
    00336         case MED_NODAL :
    00337           switch(meddatatype)
    00338             {
    00339             case MED_CONNECTIVITY :
    00340               strcpy(_datasetname,MED_NOM_NOD);
    00341               break;
    00342             case MED_INDEX_FACE :
    00343               if (geotype == MED_POLYHEDRON)
    00344                 strcpy(_datasetname,MED_NOM_INN);
    00345               else
    00346                 strcpy(_datasetname,MED_NOM_IFN);
    00347               break;
    00348             case MED_INDEX_NODE :
    00349               if (geotype == MED_POLYHEDRON)
    00350                 strcpy(_datasetname,MED_NOM_IFN);
    00351               else
    00352                 strcpy(_datasetname,MED_NOM_INN);
    00353               break;
    00354             }
    00355           break;
    00356
    00357         case MED_DESCENDING :
    00358           switch(meddatatype)
    00359             {
    00360             case MED_CONNECTIVITY :
    00361               strcpy(_datasetname,MED_NOM_DES);
    00362               break;
    00363             case MED_INDEX_FACE :
    00364               if (geotype == MED_POLYHEDRON)
    00365                 strcpy(_datasetname,MED_NOM_IND);
    00366               else
    00367                 strcpy(_datasetname,MED_NOM_IFD);
    00368               break;
    00369             case MED_INDEX_NODE :
    00370               if (geotype == MED_POLYHEDRON)
    00371                 strcpy(_datasetname,MED_NOM_IFD);
    00372               else
    00373                 strcpy(_datasetname,MED_NOM_IND);
    00374               break;
    00375             }
    00376           break;
    00377
    00378         default :
    00379           MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_CONNECTIVITYMODE,MED_ERR_VALUE_MSG);
    00380           ISCRUTE_int(cmode);goto ERROR;
    00381         }
    00382
    00383     case MED_CONNECTIVITY :
    00384 #if defined(HAVE_F77INT64)
    00385       if ( _MEDdatasetNumLire(_datagroup,_datasetname,MED_INT64,
    00386                               (med_mode_switch) (*_filter).switchmode ,
    00387                               (med_size) (*_filter).nbofconstituentpervalue,
    00388                               (med_size) (*_filter).constituentselect,
    00389                               (med_size) (*_filter).filterarraysize,MED_COMPACT,MED_PFL_NON_COMPACT,
    00390                               (*_filter).filterarray23v30,
    00391                               MED_NOPG, 0, (unsigned char*) value ) < 0)
    00392         goto ERROR;
    00393 #else
    00394       if ( _MEDdatasetNumLire(_datagroup,_datasetname,MED_INT32,
    00395                               (med_mode_switch) (*_filter).switchmode ,
    00396                               (med_size) (*_filter).nbofconstituentpervalue,
    00397                               (med_size) (*_filter).constituentselect,
    00398                               (med_size) (*_filter).filterarraysize,MED_COMPACT,MED_PFL_NON_COMPACT,
    00399                               (*_filter).filterarray23v30,
    00400                               MED_NOPG, 0, (unsigned char*) value ) < 0)
    00401         goto ERROR;
    00402 #endif
    00403
    00404       break;
    00405
    00406     case MED_NAME :
    00407       if (_MEDdatasetStringLire(_datagroup,_datasetname,(char *) value) < 0)
    00408         goto ERROR;
    00409       break;
    00410
    00411     case MED_NUMBER :
    00412     case MED_GLOBAL_NUMBER :
    00413     case MED_FAMILY_NUMBER :
    00414 #if defined(HAVE_F77INT64)
    00415       if (_MEDdatasetNumLire(_datagroup,_datasetname,MED_INT64,
    00416                              MED_NO_INTERLACE,
    00417                              (med_size)1,
    00418                              (med_size) (*_filter).constituentselect,
    00419                              (med_size) MED_NOPF,MED_NO_PFLMOD,MED_PFL_NON_COMPACT,
    00420                              (med_size *) NULL, MED_NOPG,0,
    00421                              (unsigned char*) value) < 0)
    00422         goto ERROR;
    00423 #else
    00424       if (_MEDdatasetNumLire(_datagroup,_datasetname,MED_INT32,
    00425                              MED_NO_INTERLACE,
    00426                              (med_size) 1,
    00427                              (med_size) (*_filter).constituentselect,
    00428                              (med_size) MED_NOPF,MED_NO_PFLMOD,MED_PFL_NON_COMPACT,
    00429                              (med_size *) NULL, MED_NOPG,0,
    00430                              (unsigned char*) value) < 0)
    00431         goto ERROR;
    00432 #endif
    00433       break;
    00434
    00435
    00436     case MED_COORDINATE_TRSF :
    00437     default :
    00438       MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_MEDDATATYPE,MED_ERR_VALUE_MSG);
    00439       ISCRUTE_int(meddatatype);goto ERROR;
    00440     }
    00441
    00442
    00443   _ret = 0;
    00444
    00445  ERROR:
    00446
    00447 /*   if (!_filterparameterexist) { */
    00448 /*     if ( MEDfilterClose(_filter) < 0 ) { */
    00449 /*       MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_FILTER,MED_ERR_MESH); */
    00450 /*     SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3); */
    00451 /*     SSCRUTE(_profilename);goto ERROR; */
    00452 /*     } */
    00453 /*   } */
    00454
    00455 /*   if (_dataset>0)     if (_MEDdatasetFermer(_dataset) < 0) { */
    00456 /*     MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATASET,MED_NOM_COO); */
    00457 /*     ISCRUTE_id(_dataset); */
    00458 /*   } */
    00459
    00460 /*   if (_datagroup4>0)     if (_MEDdatagroupFermer(_datagroup4) < 0) { */
    00461 /*     MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_VARATR_NOM); */
    00462 /*     ISCRUTE_id(_datagroup4); */
    00463 /*   } */
    00464
    00465   if (_dataset>0)     if (_MEDdatasetFermer(_dataset) < 0) {
    00466     MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATASET,MED_NOM_COO);
    00467     ISCRUTE_id(_dataset);
    00468   }
    00469
    00470   if (_datagroup3>0)     if (_MEDdatagroupFermer(_datagroup3) < 0) {
    00471     MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname3);
    00472     ISCRUTE_id(_datagroup3);
    00473   }
    00474
    00475   if (_datagroup2>0)     if (_MEDdatagroupFermer(_datagroup2) < 0) {
    00476     MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname2);
    00477     ISCRUTE_id(_datagroup2);
    00478   }
    00479
    00480 /*   if (_datagroup1>0)     if (_MEDdatagroupFermer(_datagroup1) < 0) { */
    00481 /*     MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname1); */
    00482 /*     ISCRUTE_id(_datagroup1); */
    00483 /*   } */
    00484
    00485   if (_meshid>0)            if (_MEDdatagroupFermer(_meshid) < 0) {
    00486     MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
    00487     ISCRUTE_id(_meshid);
    00488   }
    00489
    00490
    00491   va_end(params);
    00492   *fret = _ret;
    00493
    00494   return;
    00495 }
    00496