src/MEDMEMBinTest/test_profil_MedFieldDriver.cxx

   1 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 #include <stdlib.h>
  23 #include<string>
  24
  25 #include "MEDMEM_Exception.hxx"
  26 #include "MEDMEM_Mesh.hxx"
  27 #include "MEDMEM_MedMeshDriver.hxx"
  28 #include "MEDMEM_Field.hxx"
  29 #include "MEDMEM_MedFieldDriver.hxx"
  30 #include "MEDMEM_Support.hxx"
  31 #include "MEDMEM_define.hxx"
  32
  33 using namespace std;
  34 using namespace MEDMEM;
  35 using namespace MED_EN;
  36
  37 static void affiche_field_(FIELD_ * myField, const SUPPORT * mySupport)
  38 {
  39   cout << "Field "<< myField->getName() << " : " <<myField->getDescription() <<  endl ;
  40   int NumberOfComponents = myField->getNumberOfComponents() ;
  41   cout << "- Nombre de composantes : "<< NumberOfComponents << endl ;
  42   for (int i=1; i<NumberOfComponents+1; i++) {
  43     cout << "  - composante "<<i<<" :"<<endl ;
  44     cout << "      - nom         : "<<myField->getComponentName(i)<< endl;
  45     cout << "      - description : "<<myField->getComponentDescription(i) << endl;
  46     cout << "      - units       : "<<myField->getMEDComponentUnit(i) << endl;
  47   }
  48   cout << "- iteration :" << endl ;
  49   cout << "    - numero : " << myField->getIterationNumber()<< endl  ;
  50   cout << "    - ordre  : " << myField->getOrderNumber()<< endl  ;
  51   cout << "    - temps  : " << myField->getTime()<< endl  ;
  52
  53   cout << "- Type : " << myField->getValueType()<< endl;
  54
  55   cout << "- Adresse support : " << mySupport << endl;
  56 }
  57
  58 template <class INTERLACING_TAG>
  59 void affiche_fieldT(FIELD<double, INTERLACING_TAG> * myField,
  60                     const SUPPORT * mySupport)
  61 {
  62   const double * value = 0;
  63   const int    * number = 0;
  64
  65   affiche_field_((FIELD_ *) myField, mySupport);
  66
  67   cout.setf(ios::fixed);
  68   cout << "- Valeurs :"<<endl;
  69   bool onAll   = mySupport->isOnAllElements();
  70   int NumberOf = mySupport->getNumberOfElements(MED_ALL_ELEMENTS);
  71   cout << "mySupport->getNumberOfElements(MED_ALL_ELEMENTS)" << NumberOf << endl;
  72   int NumberOfComponents = myField->getNumberOfComponents() ;
  73   cout << "myField->getNumberOfComponents()" << NumberOfComponents << endl;
  74   if (!onAll) number = mySupport->getNumber(MED_ALL_ELEMENTS);
  75
  76   if ( myField->getInterlacingType() == MED_EN::MED_FULL_INTERLACE ) {
  77     for (int i=1; i<NumberOf+1; i++) {
  78       if (onAll)
  79         value = myField->getRow(i) ;
  80       else
  81         value = myField->getRow(number[i-1]);
  82       for (int j=0; j<NumberOfComponents; j++)
  83         cout << value[j]<< " ";
  84       cout<<endl;
  85     }
  86   }
  87   else {
  88     for (int j=1; j<NumberOfComponents+1; j++) {
  89       value = myField->getColumn(j) ;
  90       for (int i=0; i<NumberOf; i++)
  91         cout << value[i]<< " ";
  92       cout<<endl;
  93     }
  94   }
  95 }
  96
  97 int main (int argc, char ** argv) {
  98
  99   if ((argc !=3) && (argc != 5)) {
 100     cerr << "Usage : " << argv[0]
 101          << " filename fieldName [iterationNumber] [orderNumber]" << endl << endl;
 102     exit(-1);
 103   }
 104
 105   string fileName  = argv[1] ;
 106   string fieldName = argv[2] ;
 107   int  iterationNumber=-1,orderNumber=-1;
 108   if ( argv[3] )  iterationNumber = atoi(argv[3]);
 109   if ( argv[4] )  orderNumber     = atoi(argv[4]);
 110
 111   string meshName=""; //"MAILTRQU";
 112   //goto mode3;
 113   /////////////////////////////////////////////////////////////////////////////////////////
 114     // TEST PREMIER MODE :
 115     // Le fichier MED lu contient le maillage associé au champ demandé (qui contient des profils )
 116     // Le driver du FIELD automatiquement crée est capable de lire les profils MEDFICHIER
 117     // (le SUPPORT est crée automatiquement, le nom du maillage associé est disponible dans
 118     // le SUPPORT mais la relation SUPPORT-MESH est non initialisée car le MESH n'est pas chargé).
 119     // Le driver utilise les informations du maillage dans le fichier pour transcrire les profils
 120     // de la numérotation locale MEDFICHIER à la numérotation globale MEDMEMOIRE).
 121     // A l'écriture, il se repose également sur le maillage contenu dans le fichier
 122     // pour effecuter la renumérotation.
 123     {
 124       FIELD<double> * myField1  = new FIELD<double>(MED_DRIVER,fileName,fieldName,
 125                                                     iterationNumber, orderNumber);
 126       affiche_fieldT(myField1, myField1->getSupport());
 127
 128       // Pour éviter de modifier le fichier d'origine,
 129       // on en crée une copie avec uniquement le maillage.
 130       // Rem : Pour le test, le chargement du maillage n'est pas nécessaire
 131       //       On pourrait réécrire le Champ dans le fichier d'origine
 132       //       sous un autre nom.
 133       // Attention si le driver MED_MESH modifie le nombre d'éléments d'un type géométrique :
 134       // le calcul de renumérotation à l'écriture du champ risque d'être faux !
 135       meshName = myField1->getSupport()->getMeshName();
 136       MESH * myMesh = new MESH(MED_DRIVER,fileName,meshName);
 137       MED_MESH_WRONLY_DRIVER myMeshDriver1("Copy_withmesh_"+fileName,myMesh);
 138       int current=myMesh->addDriver(myMeshDriver1);
 139       myMesh->write(current);
 140       myMesh->removeReference();
 141
 142       // On ajoute un driver en écriture, comme la relation SUPPORT-MESH n'est pas
 143       // initialisée, le driver doit trouver le maillage dans le fichier cible
 144       // pour réaliser la transcription des profils MEDMEMOIRE à MEDFICHIER.
 145       MED_FIELD_WRONLY_DRIVER<double> myFieldDriver2("Copy_withmesh_"+fileName,myField1) ;
 146       current = myField1->addDriver(myFieldDriver2);
 147       myField1->write(current);
 148       myField1->removeReference();
 149     }
 150
 151 //  mode2:
 152 //     /////////////////////////////////////////////////////////////////////////////
 153 //       // TEST DEUXIEME MODE :
 154 //       // Lecture idem 1er mode
 155 //       // A l'écriture, le fichier cible ne contient pas le maillage mais la
 156 //       // relation SUPPORT-MESH étant établie le driver utilise les informations
 157 //       // dans le maillage en mémoire pour transcrire les profils.
 158 //       // Selon le modèle MED FICHIER, ce mode est interdit : le fichier doit au moins
 159 //       // contenir un lien sur le maillage (information pas encore exploitée dans MEDMEMOIRE
 160 //       // : pas de gestion de montage/démontage des fichiers )
 161 //       // Attention si le driver MED_MESH modifie le nombre d'éléments d'un type géométrique :
 162 //       // le calcul de renumérotation à l'écriture du champ risque d'être faux car les
 163 //       // profils crées à la lecture son basés sur le nombre d'éléments par type géoémtrique
 164 //       // du maillage contenu dans le fichier à la lecture.
 165 //       // Une solution consisterait à prendre en compte le montage de fichiers distants
 166 //       // et de prendre en compte la différence de nombre d'éléments par type géométrique
 167 //       // entre le maillage MEDMEM et le maillage MEDFICHIER
 168 //       // (Hum ! : Il serait plus simple que MEDMEMOIRE ne recalcule pas systématiquement
 169 //       //  ce que l'on ne lui demande pas, ce qui permettrait aussi de réécrire à l'identique
 170 //       // un fichier que l'on vient de lire)
 171 //    {
 172 //      FIELD<double> * myField2  = new FIELD<double>(MED_DRIVER,fileName,fieldName,
 173 //                                                 iterationNumber, orderNumber);
 174
 175 //      meshName = myField2->getSupport()->getMeshName();
 176 //      MESH * myMesh2 = new MESH(MED_DRIVER,fileName,meshName);
 177
 178 //      const SUPPORT * mySupport2=myField2->getSupport();
 179 //      mySupport2->setMesh(myMesh2);
 180
 181 //      // On ajoute un driver en écriture, comme la relation SUPPORT-MESH est
 182 //      // initialisée, le driver utilise le maillage en mémoire
 183 //      // pour réaliser la transcription des profils MEDMEMOIRE à MEDFICHIER.
 184 //      MED_FIELD_WRONLY_DRIVER<double> myFieldDriver3("Copy_nomesh_"+fileName,myField2) ;
 185 //      int current = myField2->addDriver(myFieldDriver3);
 186 //      myField2->write(current);
 187
 188 //      //Pour regarder le fichier produit avec MDUMP decommenter ces trois lignes
 189 //      //car le fichier qui est produit n'est pas à la norme MED
 190 //      //Il doit contenir soit le maillage associé soit un lien vers le maillage associé.
 191 //      //MED_MESH_WRONLY_DRIVER myMeshDriver2("Copy_nomesh_"+fileName,myMesh2);
 192 //      //current=myMesh2->addDriver(myMeshDriver2);
 193 //      //myMesh2->write(current);
 194
 195 //      delete myField2;
 196 //      delete myMesh2;
 197
 198
 199 //    }
 200 //  mode3:
 201 //    // TEST TROISIEME MODE  :
 202 //    // A la lecture, le fichier MED lu ne contient pas le maillage  associé au champ demandé
 203 //    // (mais un lien MEDFICHIER qui n'est pas exploité à ce jour).
 204 //    // Cependant avant sa lecture le FIELD a été associé à un SUPPORT
 205 //    // avec le lien au MESH préalablement chargé.
 206 //    // Le driver du FIELD (automatiquement crée) est capable de lire les profils MEDFICHIER
 207 //    //   et utilise la relation SUPPORT-MESH initialisée pour transcrire les profils
 208 //    //   de la numérotation locale MEDFICHIER à la numérotation globale MEDMEMOIRE).
 209 //    // REM: Une fois le champ chargé, il possède un nouveau support, le premier peut être libéré.
 210 //    //      En effet le driver du FIELD se fit uniquement au type géométriques définis dans le champ MEDFICHIER
 211 //    //      pour créer son SUPPORT car un SUPPORT crée "onAll" à partir d'un MESH repose sur tous
 212 //    //      les types géométriques du MESH ce qui n'est pas forcément le cas d'un champ MEDFICHIER
 213 //    //      (même sans profil) lu à posteriori.
 214 //    {
 215 //      med_2_3::med_err err=-1;
 216 //      med_2_3::med_idt id = med_2_3::MEDfileOpen(const_cast<char *> ( ("Copy_nomesh_"+fileName).c_str()),
 217 //                                            med_2_3::MED_ACC_RDWR);
 218 //      if (id <=0) cout << "Erreur dans MEDouvrir pour le fichier " << "Copy_nomesh_"+fileName <<endl;
 219
 220 //      err=med_2_3::MEDlienEcr(id, const_cast<char *> ( ("Copy_withmesh_"+fileName).c_str()),
 221 //                           const_cast<char *> (meshName.c_str()) );
 222 //      if (err !=0) cout << "Erreur dans MEDlienEcr pour le maillage distant " << meshName
 223 //                     <<" contenu dans le fichier " << "Copy_withmesh_"+fileName <<endl;
 224
 225
 226 //      err=med_2_3::MEDfermer(id);
 227
 228 //      MESH * myMesh3 = new MESH(MED_DRIVER,fileName,meshName);
 229 //      const SUPPORT * mySupport3= new SUPPORT(myMesh3,"Temporary Support",MED_CELL);
 230 //      FIELD<double> * myField3  = new FIELD<double>(mySupport3,MED_DRIVER,"Copy_nomesh_"+fileName,fieldName,
 231 //                                                 iterationNumber, orderNumber);
 232 //      delete mySupport3; // Il est déjà possible de libérer ce SUPPORT
 233
 234 //      //TEST à la réecriture :
 235 //      string cpy("__Copy");
 236 //      vector < string > pflNames = myField3->getSupport()->getProfilNames();
 237 //      for (int i=0; i< pflNames.size(); ++i) {
 238 //        pflNames[i].resize(pflNames[i].size()-cpy.size());
 239 //        pflNames[i]+=cpy;
 240 //      }
 241 //      const_cast<SUPPORT*>(myField3->getSupport())->setProfilNames(pflNames);
 242 //      MED_FIELD_WRONLY_DRIVER<double> myFieldDriver4("Copy_nomesh_"+fileName,myField3) ;
 243 //      myFieldDriver4.setFieldName(myField3->getName()+"__Copy");
 244 //      int current = myField3->addDriver(myFieldDriver4);
 245 //      myField3->write(current);
 246
 247 //      delete myMesh3;
 248 //      delete myField3;
 249
 250
 251 //      //ESSAYER AVEC MAILLAGE DS FICHIER ET LIEN SUPORT-MESH PRESENTS SIMULTANEMENT
 252 //      //EN VERSION COHERENTE ET NON COHERENTE
 253 //    }
 254 }