1 // Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
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.
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.
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
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
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"
34 using namespace MEDMEM;
35 using namespace MED_EN;
37 static void affiche_field_(FIELD_ * myField, const SUPPORT * mySupport)
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;
48 cout << "- iteration :" << endl ;
49 cout << " - numero : " << myField->getIterationNumber()<< endl ;
50 cout << " - ordre : " << myField->getOrderNumber()<< endl ;
51 cout << " - temps : " << myField->getTime()<< endl ;
53 cout << "- Type : " << myField->getValueType()<< endl;
55 cout << "- Adresse support : " << mySupport << endl;
58 template <class INTERLACING_TAG>
59 void affiche_fieldT(FIELD<double, INTERLACING_TAG> * myField,
60 const SUPPORT * mySupport)
62 const double * value = 0;
63 const int * number = 0;
65 affiche_field_((FIELD_ *) myField, mySupport);
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);
76 if ( myField->getInterlacingType() == MED_EN::MED_FULL_INTERLACE ) {
77 for (int i=1; i<NumberOf+1; i++) {
79 value = myField->getRow(i) ;
81 value = myField->getRow(number[i-1]);
82 for (int j=0; j<NumberOfComponents; j++)
83 cout << value[j]<< " ";
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]<< " ";
97 int main (int argc, char ** argv) {
99 if ((argc !=3) && (argc != 5)) {
100 cerr << "Usage : " << argv[0]
101 << " filename fieldName [iterationNumber] [orderNumber]" << endl << endl;
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]);
111 string meshName=""; //"MAILTRQU";
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.
124 FIELD<double> * myField1 = new FIELD<double>(MED_DRIVER,fileName,fieldName,
125 iterationNumber, orderNumber);
126 affiche_fieldT(myField1, myField1->getSupport());
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();
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();
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)
172 // FIELD<double> * myField2 = new FIELD<double>(MED_DRIVER,fileName,fieldName,
173 // iterationNumber, orderNumber);
175 // meshName = myField2->getSupport()->getMeshName();
176 // MESH * myMesh2 = new MESH(MED_DRIVER,fileName,meshName);
178 // const SUPPORT * mySupport2=myField2->getSupport();
179 // mySupport2->setMesh(myMesh2);
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);
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);
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.
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;
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;
226 // err=med_2_3::MEDfermer(id);
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
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());
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);
251 // //ESSAYER AVEC MAILLAGE DS FICHIER ET LIEN SUPORT-MESH PRESENTS SIMULTANEMENT
252 // //EN VERSION COHERENTE ET NON COHERENTE