Back to index

salome-med  6.5.0
MEDMEM_MEDMEMgaussEcr.cxx
Go to the documentation of this file.
00001 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
00002 //
00003 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
00004 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
00005 //
00006 // This library is free software; you can redistribute it and/or
00007 // modify it under the terms of the GNU Lesser General Public
00008 // License as published by the Free Software Foundation; either
00009 // version 2.1 of the License.
00010 //
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 // Lesser General Public License for more details.
00015 //
00016 // You should have received a copy of the GNU Lesser General Public
00017 // License along with this library; if not, write to the Free Software
00018 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00019 //
00020 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00021 //
00022 
00023 #include "MEDMEM_MEDMEMgaussEcr.hxx"
00024 /*
00025  * En attendant une correction de la gestion du mode d'accès au fichier dans MEDfichier
00026  * on intègre la correction ici.
00027  */
00028 
00029 namespace med_2_3 {
00030   extern "C" {
00031 # define ICI                    {\
00032                                         fflush(stdout);\
00033                                         fprintf(stderr, "%s [%d] : " , __FILE__ , __LINE__ ) ;\
00034                                         fflush(stderr) ;\
00035                                 }
00036 
00037 # define ISCRUTE_MED(entier)        {\
00038                                         ICI ;\
00039                                         fprintf(stderr,"%s = %d\n",#entier,entier) ;\
00040                                         fflush(stderr) ;\
00041                                 }
00042 
00043 # define SSCRUTE_MED(chaine)        {\
00044                                         ICI ;\
00045                                         fprintf(stderr,"%s = \"%s\"\n",#chaine,chaine) ;\
00046                                         fflush(stderr) ;\
00047                                 }
00048 # define MESSAGE_MED(chaine)        {\
00049                                         ICI ;\
00050                                         fprintf(stderr,"%s\n",chaine) ;\
00051                                         fflush(stderr) ;\
00052                                 }
00053 
00054     extern void _MEDmodeErreurVerrouiller(void);
00055 
00056     /*
00057      * - Nom de la fonction : MEDgaussEcr
00058      * - Description : Itérateur renvoyant (n°pdt,n°or), le nbre de point de GAUSS pour le type d'élément,
00059      *                 et le  maillage par défaut avec son eventuel lien à un autre fichier.
00060      * - Parametres :
00061      *     - fid      (IN) : ID du fichier HDF courant
00062      *     - type_geo (IN) : Le type géométrique de l'entité concerné {MED_POINT,MED_SEG2 ......}
00063      *     - refcoo   (IN) : Les coordonnées des noeuds de l'élément de référence (tableau de taille(typegeo%100)*(typegeo/100) )
00064      *     - mode_coo (IN) : Choix du type d'entrelacement utilisé en mémoire pour refcoo et gscoo
00065      *                        { MED_FULL_INTERLACE(x1,y1,z1,x2,...)) , MED_NO_INTERLACE(x1,x2,y1,y2,z1,z2) }
00066      *     - ngauss   (IN) : Nombre de points de Gauss pour l'élément de référence considéré
00067      *     - gscoo    (IN) : Les coordonnées des points de Gauss pour l'élément de référence (tableau de taille ngauss*type_geo/100)
00068      *     - wg       (IN) : Poids à appliquer aux points d'intégration (tableau de taille ngauss)
00069      *     - locname (IN) : Nom à associer à la localisation (MED_TAILLe_NOM)
00070 
00071      REM :
00072      <locname> est à passer en paramètre de MEDchampEcrire.
00073     */
00074 
00075     med_err
00076     MEDMEMgaussEcr(med_idt fid, med_geometrie_element type_geo, med_float *refcoo, med_mode_switch mode_coo,
00077                    med_int ngauss, med_float *gscoo, med_float * wg, char * locname )
00078     {
00079       med_idt gid=0, chid=0;
00080       med_size dimd[1];
00081       med_err ret = -1;
00082       med_int typegeo = -1;
00083       char chemin[MED_TAILLE_GAUSS+1]="";
00084 
00085       /*
00086        * On inhibe le gestionnaire d'erreur HDF 5
00087        */
00088       _MEDmodeErreurVerrouiller();
00089 
00090       /*
00091        * Si le groupe "GAUSS" n'existe pas, on le cree
00092        */
00093       strncpy(chemin,MED_GAUSS,MED_TAILLE_GAUSS-1);
00094       chemin[MED_TAILLE_GAUSS-1] = '\0';
00095       if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
00096         if ((gid = _MEDdatagroupCreer(fid,chemin)) < 0) {
00097           MESSAGE_MED("Impossible de creer le groupe MED_GAUSS : ");
00098           SSCRUTE_MED(chemin); goto ERROR;
00099         }
00100 
00101       /*
00102        * Si le groupe <locname> n'existe pas, on le cree
00103        * Sinon => erreur
00104        */
00105       if ((chid = _MEDdatagroupOuvrir(gid,locname)) >= 0) {
00106         if ( false )//MED_MODE_ACCES != MED_LECTURE_ECRITURE )
00107   {
00108           MESSAGE_MED("Le nom de localisation existe déjà : ");
00109           SSCRUTE_MED(locname); goto ERROR;
00110         }
00111       } else
00112         if ((chid = _MEDdatagroupCreer(gid,locname)) < 0)
00113           goto ERROR;
00114 
00115       /*
00116        * On stocke <ngauss> sous forme d'attribut
00117        */
00118       if (_MEDattrEntierEcrire(chid,MED_NOM_NBR,&ngauss) < 0) {
00119         MESSAGE_MED("Erreur à l'écriture de l'attribut MED_NOM_NBR : ");
00120         ISCRUTE_MED(ngauss);goto ERROR;
00121       };
00122 
00123       /*
00124        * On stocke <type_geo> sous forme d'attribut
00125        */
00126       typegeo = (med_int) type_geo;
00127       /* sizeof(enum) tjrs = sizeof(int) en C, or
00128          sur machines 64 bits par défaut med_int==long,
00129          du coup sur  machines 64 bits _MEDattrEntierEcrire utilise
00130          le type hdf NATIVE_LONG, ce qui pose un problème qd on passe
00131          un enum.
00132       */
00133       if (_MEDattrEntierEcrire(chid,MED_NOM_GEO,&typegeo) < 0) {
00134         MESSAGE_MED("Erreur à l'écriture de l'attribut MED_NOM_GEO : ");
00135         ISCRUTE_MED(type_geo);goto ERROR;
00136       };
00137 
00138 
00139       /*
00140        * On stocke les coordonnées de référence dans un dataset
00141        */
00142 
00143       dimd[0] = (type_geo%100)*(type_geo/100);
00144       if ( _MEDdatasetNumEcrire(chid,MED_NOM_COO,MED_FLOAT64,mode_coo,(type_geo/100),MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,MED_NOPG,dimd,
00145                                 (unsigned char*) refcoo)  < 0 ) {
00146         MESSAGE_MED("Impossible d'ecrire le dataset : ");SSCRUTE_MED(MED_NOM_COO);
00147         ISCRUTE_MED(dimd); goto ERROR;
00148       }
00149 
00150       /*
00151        * On stocke les points d'intégration dans un dataset
00152        */
00153 
00154       dimd[0] = ngauss*(type_geo/100);
00155       if ( _MEDdatasetNumEcrire(chid,MED_NOM_GAU,MED_FLOAT64,mode_coo,(type_geo/100),MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,MED_NOPG,dimd,
00156                                 (unsigned char*) gscoo)  < 0 ) {
00157         MESSAGE_MED("Impossible d'ecrire le dataset : ");SSCRUTE_MED(MED_NOM_GAU);
00158         ISCRUTE_MED(dimd); goto ERROR;
00159       }
00160 
00161       /*
00162        * On stocke les poids dans un dataset
00163        */
00164 
00165       dimd[0] = ngauss;
00166       if ( _MEDdatasetNumEcrire(chid,MED_NOM_VAL,MED_FLOAT64,mode_coo,1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,MED_NOPG,dimd,
00167                                 (unsigned char*) wg)  < 0 ) {
00168         MESSAGE_MED("Impossible d'ecrire le dataset : ");SSCRUTE_MED(MED_NOM_VAL);
00169         ISCRUTE_MED(dimd); goto ERROR;
00170       }
00171 
00172 
00173       ret = 0;
00174 
00175     ERROR:
00176 
00177       /*
00178        * On ferme tout
00179        */
00180 
00181       if (chid>0)     if (_MEDdatagroupFermer(chid) < 0) {
00182         MESSAGE_MED("Impossible de fermer le datagroup : ");
00183         ISCRUTE_MED(chid); ret = -1;
00184       }
00185 
00186       if (gid>0)     if (_MEDdatagroupFermer(gid) < 0) {
00187         MESSAGE_MED("Impossible de fermer le datagroup : ");
00188         ISCRUTE_MED(gid); ret = -1;
00189       }
00190 
00191       return ret;
00192     }
00193 
00194 #undef MESSAGE_MED
00195 #undef SSCRUTE_MED
00196 #undef ISCRUTE_MED
00197 
00198   }
00199 }