Back to index

salome-med  6.5.0
test_profil_MedFieldDriver.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 #include <stdlib.h>
00023 #include<string>
00024 
00025 #include "MEDMEM_Exception.hxx"
00026 #include "MEDMEM_Mesh.hxx"
00027 #include "MEDMEM_MedMeshDriver.hxx"
00028 #include "MEDMEM_Field.hxx"
00029 #include "MEDMEM_MedFieldDriver.hxx"
00030 #include "MEDMEM_Support.hxx"
00031 #include "MEDMEM_define.hxx"
00032 
00033 using namespace std;
00034 using namespace MEDMEM;
00035 using namespace MED_EN;
00036 
00037 static void affiche_field_(FIELD_ * myField, const SUPPORT * mySupport)
00038 {
00039   cout << "Field "<< myField->getName() << " : " <<myField->getDescription() <<  endl ;
00040   int NumberOfComponents = myField->getNumberOfComponents() ;
00041   cout << "- Nombre de composantes : "<< NumberOfComponents << endl ;
00042   for (int i=1; i<NumberOfComponents+1; i++) {
00043     cout << "  - composante "<<i<<" :"<<endl ;
00044     cout << "      - nom         : "<<myField->getComponentName(i)<< endl;
00045     cout << "      - description : "<<myField->getComponentDescription(i) << endl;
00046     cout << "      - units       : "<<myField->getMEDComponentUnit(i) << endl;
00047   }
00048   cout << "- iteration :" << endl ;
00049   cout << "    - numero : " << myField->getIterationNumber()<< endl  ;
00050   cout << "    - ordre  : " << myField->getOrderNumber()<< endl  ;
00051   cout << "    - temps  : " << myField->getTime()<< endl  ;
00052 
00053   cout << "- Type : " << myField->getValueType()<< endl;
00054 
00055   cout << "- Adresse support : " << mySupport << endl;
00056 }
00057 
00058 template <class INTERLACING_TAG>
00059 void affiche_fieldT(FIELD<double, INTERLACING_TAG> * myField,
00060                     const SUPPORT * mySupport)
00061 {
00062   const double * value = 0;
00063   const int    * number = 0;
00064 
00065   affiche_field_((FIELD_ *) myField, mySupport);
00066 
00067   cout.setf(ios::fixed);
00068   cout << "- Valeurs :"<<endl;
00069   bool onAll   = mySupport->isOnAllElements();
00070   int NumberOf = mySupport->getNumberOfElements(MED_ALL_ELEMENTS);
00071   cout << "mySupport->getNumberOfElements(MED_ALL_ELEMENTS)" << NumberOf << endl;
00072   int NumberOfComponents = myField->getNumberOfComponents() ;
00073   cout << "myField->getNumberOfComponents()" << NumberOfComponents << endl;
00074   if (!onAll) number = mySupport->getNumber(MED_ALL_ELEMENTS);
00075 
00076   if ( myField->getInterlacingType() == MED_EN::MED_FULL_INTERLACE ) {
00077     for (int i=1; i<NumberOf+1; i++) {
00078       if (onAll)
00079         value = myField->getRow(i) ;
00080       else
00081         value = myField->getRow(number[i-1]);
00082       for (int j=0; j<NumberOfComponents; j++)
00083         cout << value[j]<< " ";
00084       cout<<endl;
00085     }
00086   }
00087   else {
00088     for (int j=1; j<NumberOfComponents+1; j++) {
00089       value = myField->getColumn(j) ;
00090       for (int i=0; i<NumberOf; i++)
00091         cout << value[i]<< " ";
00092       cout<<endl;
00093     }
00094   }
00095 }
00096 
00097 int main (int argc, char ** argv) {
00098 
00099   if ((argc !=3) && (argc != 5)) {
00100     cerr << "Usage : " << argv[0]
00101          << " filename fieldName [iterationNumber] [orderNumber]" << endl << endl;
00102     exit(-1);
00103   }
00104 
00105   string fileName  = argv[1] ;
00106   string fieldName = argv[2] ;
00107   int  iterationNumber=-1,orderNumber=-1;
00108   if ( argv[3] )  iterationNumber = atoi(argv[3]);
00109   if ( argv[4] )  orderNumber     = atoi(argv[4]);
00110 
00111   string meshName=""; //"MAILTRQU";
00112   //goto mode3;
00114     // TEST PREMIER MODE :
00115     // Le fichier MED lu contient le maillage associé au champ demandé (qui contient des profils )
00116     // Le driver du FIELD automatiquement crée est capable de lire les profils MEDFICHIER
00117     // (le SUPPORT est crée automatiquement, le nom du maillage associé est disponible dans
00118     // le SUPPORT mais la relation SUPPORT-MESH est non initialisée car le MESH n'est pas chargé).
00119     // Le driver utilise les informations du maillage dans le fichier pour transcrire les profils
00120     // de la numérotation locale MEDFICHIER à la numérotation globale MEDMEMOIRE).
00121     // A l'écriture, il se repose également sur le maillage contenu dans le fichier
00122     // pour effecuter la renumérotation.
00123     {
00124       FIELD<double> * myField1  = new FIELD<double>(MED_DRIVER,fileName,fieldName,
00125                                                     iterationNumber, orderNumber);
00126       affiche_fieldT(myField1, myField1->getSupport());
00127 
00128       // Pour éviter de modifier le fichier d'origine,
00129       // on en crée une copie avec uniquement le maillage.
00130       // Rem : Pour le test, le chargement du maillage n'est pas nécessaire
00131       //       On pourrait réécrire le Champ dans le fichier d'origine
00132       //       sous un autre nom.
00133       // Attention si le driver MED_MESH modifie le nombre d'éléments d'un type géométrique :
00134       // le calcul de renumérotation à l'écriture du champ risque d'être faux !
00135       meshName = myField1->getSupport()->getMeshName();
00136       MESH * myMesh = new MESH(MED_DRIVER,fileName,meshName);
00137       MED_MESH_WRONLY_DRIVER myMeshDriver1("Copy_withmesh_"+fileName,myMesh);
00138       int current=myMesh->addDriver(myMeshDriver1);
00139       myMesh->write(current);
00140       myMesh->removeReference();
00141 
00142       // On ajoute un driver en écriture, comme la relation SUPPORT-MESH n'est pas
00143       // initialisée, le driver doit trouver le maillage dans le fichier cible
00144       // pour réaliser la transcription des profils MEDMEMOIRE à MEDFICHIER.
00145       MED_FIELD_WRONLY_DRIVER<double> myFieldDriver2("Copy_withmesh_"+fileName,myField1) ;
00146       current = myField1->addDriver(myFieldDriver2);
00147       myField1->write(current);
00148       myField1->removeReference();
00149     }
00150 
00151 //  mode2:
00152 //     /////////////////////////////////////////////////////////////////////////////
00153 //       // TEST DEUXIEME MODE :
00154 //       // Lecture idem 1er mode
00155 //       // A l'écriture, le fichier cible ne contient pas le maillage mais la
00156 //       // relation SUPPORT-MESH étant établie le driver utilise les informations
00157 //       // dans le maillage en mémoire pour transcrire les profils.
00158 //       // Selon le modèle MED FICHIER, ce mode est interdit : le fichier doit au moins
00159 //       // contenir un lien sur le maillage (information pas encore exploitée dans MEDMEMOIRE
00160 //       // : pas de gestion de montage/démontage des fichiers )
00161 //       // Attention si le driver MED_MESH modifie le nombre d'éléments d'un type géométrique :
00162 //       // le calcul de renumérotation à l'écriture du champ risque d'être faux car les
00163 //       // profils crées à la lecture son basés sur le nombre d'éléments par type géoémtrique
00164 //       // du maillage contenu dans le fichier à la lecture.
00165 //       // Une solution consisterait à prendre en compte le montage de fichiers distants
00166 //       // et de prendre en compte la différence de nombre d'éléments par type géométrique
00167 //       // entre le maillage MEDMEM et le maillage MEDFICHIER
00168 //       // (Hum ! : Il serait plus simple que MEDMEMOIRE ne recalcule pas systématiquement
00169 //       //  ce que l'on ne lui demande pas, ce qui permettrait aussi de réécrire à l'identique
00170 //       // un fichier que l'on vient de lire)
00171 //    {
00172 //      FIELD<double> * myField2  = new FIELD<double>(MED_DRIVER,fileName,fieldName,
00173 //                                                 iterationNumber, orderNumber);
00174 
00175 //      meshName = myField2->getSupport()->getMeshName();
00176 //      MESH * myMesh2 = new MESH(MED_DRIVER,fileName,meshName);
00177 
00178 //      const SUPPORT * mySupport2=myField2->getSupport();
00179 //      mySupport2->setMesh(myMesh2);
00180 
00181 //      // On ajoute un driver en écriture, comme la relation SUPPORT-MESH est
00182 //      // initialisée, le driver utilise le maillage en mémoire
00183 //      // pour réaliser la transcription des profils MEDMEMOIRE à MEDFICHIER.
00184 //      MED_FIELD_WRONLY_DRIVER<double> myFieldDriver3("Copy_nomesh_"+fileName,myField2) ;
00185 //      int current = myField2->addDriver(myFieldDriver3);
00186 //      myField2->write(current);
00187 
00188 //      //Pour regarder le fichier produit avec MDUMP decommenter ces trois lignes
00189 //      //car le fichier qui est produit n'est pas à la norme MED
00190 //      //Il doit contenir soit le maillage associé soit un lien vers le maillage associé.
00191 //      //MED_MESH_WRONLY_DRIVER myMeshDriver2("Copy_nomesh_"+fileName,myMesh2);
00192 //      //current=myMesh2->addDriver(myMeshDriver2);
00193 //      //myMesh2->write(current);
00194 
00195 //      delete myField2;
00196 //      delete myMesh2;
00197 
00198 
00199 //    }
00200 //  mode3:
00201 //    // TEST TROISIEME MODE  :
00202 //    // A la lecture, le fichier MED lu ne contient pas le maillage  associé au champ demandé 
00203 //    // (mais un lien MEDFICHIER qui n'est pas exploité à ce jour).
00204 //    // Cependant avant sa lecture le FIELD a été associé à un SUPPORT
00205 //    // avec le lien au MESH préalablement chargé.
00206 //    // Le driver du FIELD (automatiquement crée) est capable de lire les profils MEDFICHIER
00207 //    //   et utilise la relation SUPPORT-MESH initialisée pour transcrire les profils
00208 //    //   de la numérotation locale MEDFICHIER à la numérotation globale MEDMEMOIRE).
00209 //    // REM: Une fois le champ chargé, il possède un nouveau support, le premier peut être libéré.
00210 //    //      En effet le driver du FIELD se fit uniquement au type géométriques définis dans le champ MEDFICHIER
00211 //    //      pour créer son SUPPORT car un SUPPORT crée "onAll" à partir d'un MESH repose sur tous
00212 //    //      les types géométriques du MESH ce qui n'est pas forcément le cas d'un champ MEDFICHIER
00213 //    //      (même sans profil) lu à posteriori.
00214 //    {
00215 //      med_2_3::med_err err=-1;
00216 //      med_2_3::med_idt id = med_2_3::MEDfileOpen(const_cast<char *> ( ("Copy_nomesh_"+fileName).c_str()),
00217 //                                            med_2_3::MED_ACC_RDWR);
00218 //      if (id <=0) cout << "Erreur dans MEDouvrir pour le fichier " << "Copy_nomesh_"+fileName <<endl;
00219 
00220 //      err=med_2_3::MEDlienEcr(id, const_cast<char *> ( ("Copy_withmesh_"+fileName).c_str()),
00221 //                           const_cast<char *> (meshName.c_str()) );
00222 //      if (err !=0) cout << "Erreur dans MEDlienEcr pour le maillage distant " << meshName
00223 //                     <<" contenu dans le fichier " << "Copy_withmesh_"+fileName <<endl;
00224 
00225 
00226 //      err=med_2_3::MEDfermer(id);
00227 
00228 //      MESH * myMesh3 = new MESH(MED_DRIVER,fileName,meshName);
00229 //      const SUPPORT * mySupport3= new SUPPORT(myMesh3,"Temporary Support",MED_CELL);
00230 //      FIELD<double> * myField3  = new FIELD<double>(mySupport3,MED_DRIVER,"Copy_nomesh_"+fileName,fieldName,
00231 //                                                 iterationNumber, orderNumber);
00232 //      delete mySupport3; // Il est déjà possible de libérer ce SUPPORT
00233 
00234 //      //TEST à la réecriture :
00235 //      string cpy("__Copy");
00236 //      vector < string > pflNames = myField3->getSupport()->getProfilNames();
00237 //      for (int i=0; i< pflNames.size(); ++i) {
00238 //        pflNames[i].resize(pflNames[i].size()-cpy.size());
00239 //        pflNames[i]+=cpy;
00240 //      }
00241 //      const_cast<SUPPORT*>(myField3->getSupport())->setProfilNames(pflNames);
00242 //      MED_FIELD_WRONLY_DRIVER<double> myFieldDriver4("Copy_nomesh_"+fileName,myField3) ;
00243 //      myFieldDriver4.setFieldName(myField3->getName()+"__Copy");
00244 //      int current = myField3->addDriver(myFieldDriver4);
00245 //      myField3->write(current);
00246 
00247 //      delete myMesh3;
00248 //      delete myField3;
00249 
00250 
00251 //      //ESSAYER AVEC MAILLAGE DS FICHIER ET LIEN SUPORT-MESH PRESENTS SIMULTANEMENT
00252 //      //EN VERSION COHERENTE ET NON COHERENTE
00253 //    }
00254 }