# _MEDmeshAdvancedRd30.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 void _MEDmeshAdvancedRd30(int dummy, ...)
    00026 {
    00027   med_access_mode       _MED_ACCESS_MODE;
    00028   med_err               _ret=-1;
    00029   med_idt               _meshid=0, _elemid=0;
    00030   med_idt               _datagroup=0,_fdatagroup=0,_dataset=0;
    00031   med_idt               _datagroup1=0,_datagroup2=0,_datagroup3=0,_datagroup4=0;
    00032   char                  _meshpath         [MED_TAILLE_SUP_MAA+MED_NAME_SIZE+1]="";
    00033   char                  _strpath          [MED_TAILLE_STRCT+MED_NAME_SIZE+1]=MED_STRCT;
    00034   char                  _datagroupname1   [2*MED_MAX_PARA+1]="";
    00035   char                  _datagroupname2   [MED_TAILLE_NOM_ENTITE+1]="";
    00036   char                  _datagroupname3   [MED_TAILLE_NOM_ENTITE+1]="";
    00037   char                  _datagroupname4   [MED_NAME_SIZE+1]="";
    00038   char                  _profilename      [MED_NAME_SIZE+1]="";
    00039   char                  _geotypename      [MED_TAILLE_NOM_ENTITE+1]="";
    00040 /*   char                  *_datasetname=NULL; */
    00041   char                  _datasetname[MED_TAILLE_NOM_ENTITE+1]="";
    00042   char                  _MED_NOM_COO[]=MED_NOM_COO, _MED_NOM_NOD[]=MED_NOM_NOD,_MED_NOM_DES[]=MED_NOM_DES;
    00043   med_bool              _filterparameterexist=MED_FALSE;
    00044 /*   int                   _entitydim=0,_entitynnodes=0,_entityndes=0; */
    00045   med_filter *          _filter           = NULL;
    00046   med_filter            _tmpfilter        = MED_FILTER_INIT;
    00047   med_filter            _paramfilter      = MED_FILTER_INIT;
    00048   med_int               _nbofconstituentpervalue=0,_spacedim=0;
    00049   med_sorting_type      _sortingtype=0;
    00050   med_int               _intsortingtype=0;
    00051   med_int               _false=0,_true=1,_true_or_false=_false;
    00052 /*   med_int               _profilearraysize=0; */
    00053   char                  _MED_NO_PROFILE_INTERNAL[]=MED_NO_PROFILE_INTERNAL;
    00054   char *                _tmpprofilename=_MED_NO_PROFILE_INTERNAL;
    00055   med_internal_type     _datatype;
    00056   med_int               _nbofvalueperentity=0;
    00057   med_int               _intmeshtype=0;
    00058   med_geometry_type     _sgeotype      = MED_NONE;
    00059   med_int               _medintsgeotype= 0;
    00060   med_bool              _chgt=MED_FALSE,_trsf=MED_FALSE;
    00061   med_bool              _isasupportmesh=MED_FALSE;
    00062   char                  _supportmeshname[MED_NAME_SIZE+1]="";
    00063   med_bool              _datasetexist=MED_FALSE,_isasoftlink=MED_FALSE;
    00064
    00065
    00066   MED_VARGS_DECL(const, med_idt               , , fid         );
    00067   MED_VARGS_DECL(const, char*  , const          , meshname    );
    00068   MED_VARGS_DECL(const, med_data_type         , , meddatatype );
    00069   MED_VARGS_DECL(const, char*  , const          , datasetname );
    00070   MED_VARGS_DECL(const, med_internal_type     , , datatype    );
    00071   MED_VARGS_DECL(const, med_int               , , numdt       );
    00072   MED_VARGS_DECL(const, med_int               , , numit       );
    00073   MED_VARGS_DECL(const, med_entity_type       , , entitytype  );
    00074   MED_VARGS_DECL(const, med_geometry_type     , , geotype     );
    00075   MED_VARGS_DECL(const, med_connectivity_mode , , cmode       );
    00076   MED_VARGS_DECL(const, med_storage_mode      , , storagemode );
    00077   MED_VARGS_DECL(const, char * , const          , profilename );
    00078   MED_VARGS_DECL(const, med_switch_mode       , , switchmode  );
    00079   MED_VARGS_DECL(const, med_int               , , dimselect   );
    00080   MED_VARGS_DECL(const, med_filter * , const    , filter      );
    00081   MED_VARGS_DECL(,unsigned char*, const         , value       );
    00082   MED_VARGS_DECL(, med_err *                   ,, fret        );
    00083
    00084   va_list params;
    00085   va_start(params,dummy);
    00086
    00087   MED_VARGS_DEF(const, med_idt               , , fid         );
    00088   MED_VARGS_DEF(const, char*  , const          , meshname    );
    00089   MED_VARGS_DEF(const, med_data_type         , , meddatatype );
    00090   MED_VARGS_DEF(const, char*  , const          , datasetname );
    00091   MED_VARGS_DEF(const, med_internal_type     , , datatype    );
    00092   MED_VARGS_DEF(const, med_int               , , numdt       );
    00093   MED_VARGS_DEF(const, med_int               , , numit       );
    00094   MED_VARGS_DEF(const, med_entity_type       , , entitytype  );
    00095   MED_VARGS_DEF(const, med_geometry_type     , , geotype     );
    00096   MED_VARGS_DEF(const, med_connectivity_mode , , cmode       );
    00097   MED_VARGS_DEF(const, med_storage_mode      , , storagemode );
    00098   MED_VARGS_DEF(const, char * , const          , profilename );
    00099   MED_VARGS_DEF(const, med_switch_mode       , , switchmode  );
    00100   MED_VARGS_DEF(const, med_int               , , dimselect   );
    00101   MED_VARGS_DEF(const, med_filter * , const    , filter      );
    00102   MED_VARGS_DEF(,unsigned char*, const         , value       );
    00103   MED_VARGS_DEF(, med_err *                   ,, fret        );
    00104
    00105   _datatype=datatype;
    00106
    00107
    00108   if (filter) {
    00109     _filter=(med_filter*)(filter); _filterparameterexist=MED_TRUE;
    00110   }
    00111   else {
    00112     _filter=&_tmpfilter;
    00113 /*     (*_filter).nbofentity              = nbofentity; */
    00114     (*_filter).nbofvaluesperentity     = 1;
    00115 /*   (*_filter).nbofconstituentpervalue = nbofconstituentpervalue; */
    00116     (*_filter).constituentselect       = dimselect;
    00117     (*_filter).switchmode              = switchmode;
    00118     (*_filter).storagemode             = storagemode;
    00119     strcpy((*_filter).profilename,profilename);
    00120 /*   (*_filter).profilearraysize        = profilearraysize; */
    00121   }
    00122
    00123   /*
    00124    * On inhibe le gestionnaire d'erreur HDF 5
    00125    */
    00126   _MEDmodeErreurVerrouiller();
    00127
    00128   if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
    00129     MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
    00130     goto ERROR;
    00131   }
    00132
    00133   /*
    00134    * Si le DataGroup MED_MAA n'existe pas => erreur
    00135    */
    00136   NOFINALBLANK(meshname,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     MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
    00147     SSCRUTE(meshname);SSCRUTE(MED_NOM_ESP);goto ERROR;
    00148   }
    00149
    00150   /* Lecture de l'attribut MED_NOM_TYP  */
    00151   if (_MEDattrEntierLire(_meshid,MED_NOM_TYP,&_intmeshtype) < 0) {
    00152     MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
    00153     SSCRUTE(meshname);SSCRUTE(MED_NOM_TYP);ISCRUTE(_intmeshtype);goto ERROR;
    00154   }
    00155
    00156
    00157   /*DEBUT  TODO : Externaliser ce traitement lié  aux éléments de structures */
    00158   if ( entitytype == MED_STRUCT_ELEMENT ) {
    00159     if ( MEDstructElementName(fid, geotype,_geotypename) < 0 ) {
    00160       MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDstructElementName");
    00161       ISCRUTE_int(geotype);goto ERROR;
    00162     }
    00163
    00164     if (meddatatype != MED_VARIABLE_ATTRIBUTE) {
    00165       strcat(_strpath,_geotypename);
    00166
    00167       /*
    00168        * Si le DataGroup /STRUCT/<elementname> n'existe pas => erreur
    00169        */
    00170       if ((_elemid = _MEDdatagroupOpen(fid,_strpath)) < 0)  {
    00171         MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_strpath);
    00172         goto ERROR;
    00173       }
    00174
    00175        /*
    00176        * Lecture de l'attribut MED_NOM_NOM (nom du maillage support)
    00177        */
    00178       /* Chercher plutôt ds le maillage support et supprimer les attributs NBM et NBN */
    00179       if ( _MEDattrStringLire(_elemid,MED_NOM_NOM,MED_NAME_SIZE,_supportmeshname) < 0) {
    00180         MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,_strpath);
    00181         SSCRUTE(MED_NOM_NOM);SSCRUTE(_supportmeshname);
    00182         goto ERROR;
    00183       }
    00184
    00185       /*
    00186        * Lecture de l'attribut MED_NOM_GEO (type géométrique des mailles support)
    00187        */
    00188       if ( _MEDattrEntierLire(_elemid,MED_NOM_GEO,&_medintsgeotype) < 0 ) {
    00189         MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,_strpath);
    00190         SSCRUTE(MED_NOM_GEO);ISCRUTE(_medintsgeotype);
    00191         goto ERROR;
    00192       }
    00193       _sgeotype = _medintsgeotype;
    00194
    00195       if (strlen(_supportmeshname) )
    00196         if ( (_nbofvalueperentity = MEDmeshnEntity(fid,_supportmeshname,MED_NO_DT,MED_NO_IT,
    00197                                                    MED_CELL,_sgeotype,MED_CONNECTIVITY,MED_NODAL,
    00198                                                    &_chgt,&_trsf) )  < 0) {
    00199           MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDmeshnEntity");
    00200           ISCRUTE(_nbofvalueperentity);goto ERROR;
    00201         }
    00202
    00203       if (_nbofvalueperentity ) {
    00204         if (!_nbofconstituentpervalue) _nbofconstituentpervalue=_sgeotype%100;
    00205       } else {
    00206         _nbofvalueperentity=1;
    00207         if (!_nbofconstituentpervalue) _nbofconstituentpervalue=1;
    00208       }
    00209
    00210     }
    00211   }
    00212
    00213   if (meddatatype == MED_VARIABLE_ATTRIBUTE) {
    00214     if ( MEDstructElementVarAttInfoByName(fid,
    00215                                           _geotypename,
    00216                                           datasetname,
    00217                                           (med_attribute_type* const) &_datatype,
    00218                                           &_nbofconstituentpervalue
    00219                                           ) < 0) {
    00220       MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDstructElementVarAttInfoByName");
    00221       ISCRUTE_int(geotype);SSCRUTE(datasetname);
    00222       ISCRUTE_int(_datatype);ISCRUTE(_nbofconstituentpervalue);goto ERROR;
    00223     }
    00224     _nbofvalueperentity=1;
    00225   }
    00226
    00227   /* FIN TODO*/
    00228
    00229   /* Si un nom de dataset est précisé, il est prioritaire sur la detection automatique en
    00230      fonction des paramètres meddatatype et cmode */
    00231   if ( !strlen(datasetname) ) {
    00232     if ( _MEDgetDatasetName( _datasetname, meddatatype, cmode ) < 0 ) {
    00233       MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDgetDatasetname");
    00234       ISCRUTE_int(meddatatype);ISCRUTE_int(cmode);SSCRUTE( _datasetname);goto ERROR;
    00235     }
    00236   } else
    00237     strncpy(_datasetname,datasetname,MED_TAILLE_NOM_ENTITE+1);
    00238
    00239
    00240   /* Si un type de dataset est précisé, il est prioritaire sur la détection automatique en
    00241      fonction des paramètres meddatatype et cmode */
    00242   /* TODO : renommer datatype en idatatype (internal) */
    00243   if ( _datatype == MED_INTERNAL_UNDEF)
    00244     if ( _MEDgetDatatype( &_datatype, meddatatype, cmode ) < 0 ) {
    00245       MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDgetDatatype");
    00246       ISCRUTE_int(meddatatype);ISCRUTE_int(cmode);ISCRUTE_int(_datatype);goto ERROR;
    00247     }
    00248
    00249   /* Vérification :
    00250      Le type de données MED traitées sont-elles compatibles avec le type de maillage ?
    00251   */
    00252   /* REM : Si datasetname ou datatype ne sont pas précisés, meddatatype doit l'être */
    00253   if ( meddatatype != MED_UNDEF_DATATYPE )
    00254     if ( _MEDmeshtypeCompatibility(meddatatype, _intmeshtype) < 0) {
    00255       MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_MEDDATATYPE,MED_ERR_VALUE_MSG);
    00256       ISCRUTE_int(meddatatype);ISCRUTE(_intmeshtype);goto ERROR;
    00257     }
    00258
    00259   if ( ! (_nbofvalueperentity && _nbofconstituentpervalue) )
    00260     if ( _MEDgetDatasetParameter( meddatatype, _spacedim, entitytype, geotype, cmode,
    00261                                   &_nbofvalueperentity,&_nbofconstituentpervalue) < 0 ) {
    00262       MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDgetDatasetParameter");
    00263       ISCRUTE_int(meddatatype);ISCRUTE_int(cmode);ISCRUTE(_nbofvalueperentity);
    00264       ISCRUTE(_nbofconstituentpervalue);goto ERROR;
    00265     }
    00266
    00267   if (_filterparameterexist) {
    00268     if ((*_filter).nbofconstituentpervalue != _nbofconstituentpervalue ) {
    00269       MED_ERR_(_ret,MED_ERR_NOTEQUAL,MED_ERR_ATTRIBUTE,MED_ERR_VALUE_MSG);
    00270       ISCRUTE((*_filter).nbofconstituentpervalue); ISCRUTE(_nbofconstituentpervalue );
    00271       goto ERROR;
    00272     }
    00273     if ((*_filter).nbofvaluesperentity != _nbofvalueperentity ) {
    00274       MED_ERR_(_ret,MED_ERR_NOTEQUAL,MED_ERR_ATTRIBUTE,MED_ERR_VALUE_MSG);
    00275       ISCRUTE((*_filter).nbofvaluesperentity); ISCRUTE(_nbofvalueperentity );
    00276       goto ERROR;
    00277     }
    00278   } else {
    00279     (*_filter).nbofconstituentpervalue = _nbofconstituentpervalue;
    00280     (*_filter).nbofvaluesperentity     = _nbofvalueperentity;
    00281   }
    00282
    00283   /*
    00284    * Ouverture du datagroup de niveau 2 <numdt>.<numit>
    00285    */
    00286   if ( _MEDattrEntierLire(_meshid,MED_NOM_SRT,&_intsortingtype) < 0) {
    00287     MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
    00288     SSCRUTE(meshname);SSCRUTE(MED_NOM_SRT);ISCRUTE(_intsortingtype);goto ERROR;
    00289   }
    00290   _sortingtype = (med_sorting_type) (_intsortingtype);
    00291
    00292   _MEDgetComputationStepName(_sortingtype,numdt,numit,_datagroupname1);
    00293   if ( (_datagroup1 = _MEDdatagroupOuvrir(_meshid,_datagroupname1)) < 0 ) {
    00294     MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
    00295     SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
    00296     SSCRUTE(_datagroupname1);ISCRUTE_id(_datagroup1);goto ERROR;
    00297   }
    00298
    00299
    00300
    00301   /*
    00302    *  Ouverture du datagroup de niveau 3 <entitytype>
    00303    */
    00304   if (_MEDgetEntityTypeName(_datagroupname2,entitytype) < 0) {
    00305     MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
    00306     ISCRUTE_int(entitytype);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);goto ERROR;
    00307   }
    00308
    00309   if ((_datagroup2 = _MEDdatagroupOuvrir(_datagroup1,_datagroupname2)) < 0) {
    00310     MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
    00311     SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
    00312     goto ERROR;
    00313   }
    00314
    00315
    00316
    00317   /*
    00318    *  Ouverture du datagroup de niveau 4 [.<geotype>]
    00319    */
    00320
    00321   if ( entitytype != MED_NODE ) {
    00322
    00323     if (strlen(_geotypename))
    00324       strncpy(_datagroupname3,_geotypename,MED_NAME_SIZE+1);
    00325     else
    00326       if ( _MEDgetInternalGeometryTypeName(_datagroupname3,geotype) < 0) {
    00327         MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
    00328         ISCRUTE_int(geotype);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
    00329         SSCRUTE(_datagroupname2);goto ERROR;
    00330       }
    00331
    00332     if ((_datagroup3 = _MEDdatagroupOuvrir(_datagroup2,_datagroupname3)) < 0) {
    00333           MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
    00334           SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
    00335           SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);goto ERROR;
    00336     }
    00337   }
    00338
    00339
    00340   if (_datagroup3) _datagroup=_datagroup3; else _datagroup=_datagroup2;
    00341
    00342   /*
    00343    *  Ouverture du datagroup de niveau 5 [VARATR]
    00344    */
    00345   /*Problème d'activation du profil */
    00346   if ( (meddatatype == MED_VARIABLE_ATTRIBUTE) || (meddatatype == MED_COORDINATE_TRSF) ) {
    00347     /* TODO : Pour simplifier et systématiser la procédure il faut
    00348        créer une routine spécifique qui donne le nom du datagroup  supplémentaire optionnel.
    00349        Si le retour est "" ne pas créer le datagroup. */
    00350     if (meddatatype == MED_VARIABLE_ATTRIBUTE)
    00351       strcpy(_datagroupname4,MED_VARATR_NOM);
    00352     else
    00353       strcpy(_datagroupname4,MED_COOTRF_NOM);
    00354
    00355     if ((_datagroup4 = _MEDdatagroupOuvrir(_datagroup,_datagroupname4)) < 0) {
    00356       MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
    00357       SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
    00358       SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);SSCRUTE(MED_VARATR_NOM);goto ERROR;
    00359     }
    00360   }
    00361
    00362   if (_datagroup4) _fdatagroup=_datagroup4; else _fdatagroup=_datagroup;
    00363
    00364   /*
    00365    * Attribut PFL (nombre de noeuds ou d'elements)
    00366    */
    00367   if ( _MEDattrStringLire(_datagroup,MED_NOM_PFL,MED_NAME_SIZE,_profilename) < 0) {
    00368     MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
    00369     SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
    00370     SSCRUTE(_datagroupname3); SSCRUTE(MED_NOM_PFL);SSCRUTE(_profilename);goto ERROR;
    00371   }
    00372
    00373   /*
    00374    * Coh�rence de l'attribut PFL (nombre de noeuds ou d'elements)
    00375    */
    00376   if ( strlen((*_filter).profilename)  )   /* != MED_NOPFL*/
    00377     _tmpprofilename=(*_filter).profilename;
    00378
    00379   if ( strcmp(_tmpprofilename,_profilename) ) {
    00380     MED_ERR_(_ret,MED_ERR_NOTEQUAL,MED_ERR_ATTRIBUTE,MED_ERR_PROFILE_MSG);
    00381     SSCRUTE(_tmpprofilename);SSCRUTE((*_filter).profilename);
    00382     SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
    00383     SSCRUTE(_datagroupname3);goto ERROR;
    00384   }
    00385
    00386 /*INUTILE : le param�tre est positionn� dans  MEDfilterEntityCr */
    00387 /*   if (!_filterparameterexist) (*_filter).profilearraysize =  _profilearraysize; */
    00388
    00389
    00390   /*
    00391    * Attribut NBR (nombre de noeuds ou d'elements)
    00392    */
    00393
    00394   if (_MEDdatasetExist(_fdatagroup,_datasetname,&_datasetexist,&_isasoftlink) < 0) {
    00395     MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatasetExist");
    00396     SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
    00397     SSCRUTE(_datagroupname3);SSCRUTE(_datasetname);SSCRUTE(_profilename);
    00398     goto ERROR;
    00399   }
    00400
    00401   /*INHIBITION DU MESSAGE POUR COMPATIBILITE COMPORTEMENT 2.3.6*/
    00402   if ( !_datasetexist) {
    00403     _ret = MED_ERR_DOESNTEXIST;
    00404     goto ERROR;
    00405   }
    00406
    00407   if ((_dataset = _MEDdatasetOuvrir(_fdatagroup,_datasetname)) < 0) {
    00408     MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATASET,_datasetname);
    00409     SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
    00410     SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);
    00411     goto ERROR;
    00412   }
    00413
    00414   if ( _MEDattrEntierLire(_dataset,MED_NOM_NBR,&((*_filter).nbofentity)) < 0) {
    00415     MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
    00416     SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);
    00417     SSCRUTE(MED_NOM_NBR);ISCRUTE((*_filter).nbofentity);goto ERROR;
    00418   }
    00419
    00420
    00421   if (!_filterparameterexist) {
    00422
    00423 #if _DEBUG_
    00424     ISCRUTE((*_filter).nbofentity              );
    00425     ISCRUTE((*_filter).nbofvaluesperentity     );
    00426     ISCRUTE((*_filter).nbofconstituentpervalue );
    00427     ISCRUTE((*_filter).constituentselect       );
    00428     ISCRUTE_int((*_filter).switchmode              );
    00429     ISCRUTE((*_filter).filterarraysize         );
    00430     ISCRUTE((*_filter).profilearraysize        );
    00431     ISCRUTE_int((*_filter).storagemode             );
    00432     SSCRUTE((*_filter).profilename             );
    00433 #endif
    00434
    00435     if ( MEDfilterEntityCr(fid, (*_filter).nbofentity,         (*_filter).nbofvaluesperentity,
    00436                            (*_filter).nbofconstituentpervalue, (*_filter).constituentselect,
    00437                            (*_filter).switchmode,              (*_filter).storagemode,
    00438                            (*_filter).profilename, MED_UNDEF_SIZE, NULL, &_paramfilter) < 0 ) {
    00439       MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_FILTER,MED_ERR_INTERNAL_MSG);
    00440       goto ERROR;
    00441     }
    00442     _filter = &_paramfilter;
    00443   }
    00444 #if _DEBUG_
    00445   ISCRUTE((*_filter).nbofentity              );
    00446   ISCRUTE((*_filter).nbofvaluesperentity     );
    00447   ISCRUTE((*_filter).nbofconstituentpervalue );
    00448   ISCRUTE((*_filter).constituentselect       );
    00449   ISCRUTE_int((*_filter).switchmode              );
    00450   ISCRUTE((*_filter).filterarraysize         );
    00451   ISCRUTE((*_filter).profilearraysize        );
    00452   ISCRUTE_int((*_filter).storagemode             );
    00453   SSCRUTE((*_filter).profilename             );
    00454   ISCRUTE_int(_datatype);
    00455 #endif
    00456
    00457   /*Il n'y a pas de connectivité à écrire pour les particules */
    00458   if (!( ( meddatatype == MED_CONNECTIVITY   )  &&
    00459          (!strcmp(_geotypename,"MED_PARTICLE"))
    00460          ) )
    00461     if ( _MEDdatasetRd(_fdatagroup,_datasetname,_datatype,_filter,value) < 0) {
    00462       MED_ERR_(_ret,MED_ERR_READ,MED_ERR_DATASET,datasetname);
    00463       SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
    00464       SSCRUTE(_datagroupname3);SSCRUTE(_profilename);
    00465       goto ERROR;
    00466     }
    00467
    00468   _ret = 0;
    00469
    00470  ERROR:
    00471
    00472   if (!_filterparameterexist) {
    00473     if ( MEDfilterClose(_filter) < 0 ) {
    00474       MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_FILTER,MED_ERR_MESH_MSG);
    00475     SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);
    00476     SSCRUTE(_profilename);goto ERROR;
    00477     }
    00478   }
    00479
    00480   if (_dataset>0)     if (_MEDdatasetFermer(_dataset) < 0) {
    00481     MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATASET,MED_NOM_COO);
    00482     ISCRUTE_id(_dataset);
    00483   }
    00484
    00485   if (_datagroup4>0)     if (_MEDdatagroupFermer(_datagroup4) < 0) {
    00486     MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_VARATR_NOM);
    00487     ISCRUTE_id(_datagroup4);
    00488   }
    00489
    00490   if (_datagroup3>0)     if (_MEDdatagroupFermer(_datagroup3) < 0) {
    00491     MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname3);
    00492     ISCRUTE_id(_datagroup3);
    00493   }
    00494
    00495   if (_datagroup2>0)     if (_MEDdatagroupFermer(_datagroup2) < 0) {
    00496     MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname2);
    00497     ISCRUTE_id(_datagroup2);
    00498   }
    00499
    00500   if (_datagroup1>0)     if (_MEDdatagroupFermer(_datagroup1) < 0) {
    00501     MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname1);
    00502     ISCRUTE_id(_datagroup1);
    00503   }
    00504
    00505   if (_meshid>0)            if (_MEDdatagroupFermer(_meshid) < 0) {
    00506     MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
    00507     ISCRUTE_id(_meshid);
    00508   }
    00509
    00510
    00511   va_end(params);
    00512   *fret = _ret;
    00513
    00514   return;
    00515 }
    00516