Back to index

salome-med  6.5.0
test_profil_gauss_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 #include "MEDMEM_GaussLocalization.hxx"
00033 
00034 using namespace std;
00035 using namespace MEDMEM;
00036 using namespace MED_EN;
00037 
00038 #define INTERLACING_MODE FullInterlace
00039 static int fct2(int i,const int * number) { return i;}
00040 static int fct1(int i,const int * number) { return number[i]; }
00041 
00042 static void affiche_field_(FIELD_ * myField)
00043 {
00044   cout << "Field "<< myField->getName() << " : " <<myField->getDescription() <<  endl ;
00045   int NumberOfComponents = myField->getNumberOfComponents() ;
00046   cout << "- Nombre de composantes : "<< NumberOfComponents << endl ;
00047   for (int i=1; i<NumberOfComponents+1; i++) {
00048     cout << "  - composante "<<i<<" :"<<endl ;
00049     cout << "      - nom         : "<<myField->getComponentName(i)<< endl;
00050     cout << "      - description : "<<myField->getComponentDescription(i) << endl;
00051     cout << "      - units       : "<<myField->getMEDComponentUnit(i) << endl;
00052   }
00053   cout << "- iteration :" << endl ;
00054   cout << "    - numero : " << myField->getIterationNumber()<< endl  ;
00055   cout << "    - ordre  : " << myField->getOrderNumber()<< endl  ;
00056   cout << "    - temps  : " << myField->getTime()<< endl  ;
00057 
00058   cout << "- Type : " << myField->getValueType()<< endl;
00059   //PRESENCE DE POINTS DE GAUSS
00060 }
00061 
00062 // Cas de traitement des valeurs sans spécificité concernant
00063 // les points de Gauss ou les profils
00064 // Pas de spécificité concernant le type géométrique
00065 template <class INTERLACING_TAG>
00066 void affiche_fieldT(FIELD<double,INTERLACING_TAG> * myField)
00067 {
00068   const double * value = 0;
00069   affiche_field_((FIELD_ *) myField);
00070 
00071   cout.setf(ios::fixed);
00072 
00073   int numberOf              = myField->getNumberOfValues();
00074   int numberOfComponents    = myField->getNumberOfComponents() ;
00075   int valueLength           = myField->getValueLength();
00076   int numberOfGeometricType = myField->getNumberOfGeometricTypes();
00077   const int * nbOfElements  = myField->getNumberOfElements();
00078   const MED_EN::medGeometryElement * typeList      = myField->getGeometricTypes();
00079   // Suivant le traitement, on peut faire sortir  si il y a des points de Gauss
00080   // ou des profils
00081 
00082   cout << "myField->getValueLength        (MED_ALL_ELEMENTS) : " << valueLength << endl;
00083   cout << "myField->getNumberOfElements   (MED_ALL_ELEMENTS) : " << numberOf   << endl;
00084   cout << "myField->getNumberOfComponents ()                 : " << numberOfComponents << endl;
00085   cout << "myField->getNumberOfGeometricType ()              : " << numberOfGeometricType << endl;
00086   for (int i=0; i < numberOfGeometricType; i++) {
00087     cout << "Number Of Elements on type "<< MED_EN::geoNames[typeList[i]]
00088          <<" : "<< nbOfElements[i] << endl;
00089     cout << "Number Of Gauss Points on type "<< MED_EN::geoNames[typeList[i]]
00090          <<" : "<< myField->getNumberOfGaussPoints(typeList[i]) << endl;
00091     cout << "Localization description : " << endl << myField->getGaussLocalization(typeList[i]) << endl;
00092   }
00093 
00094   cout << "- Valeurs :"<<endl;
00095   for (int index=0; index < valueLength; index++) {
00096     cout << "value["<<index<<"] = "<< value[index];
00097     cout<<endl;
00098   }
00099 
00100 }
00101 
00102 // Spécialisation du traitement pour le mode FullInterlace
00103 // Spécifité de traitement par rapport aux profils (utilisation du SUPPORT)
00104 // Pas de spécificité concernant le type géométrique
00105 // Pas de spécificité concernant les points de Gauss
00106 template <>
00107 void affiche_fieldT(FIELD<double, FullInterlace> * myField)
00108 {
00109   const double * value = 0;
00110   const int    * number = 0;
00111 
00112   affiche_field_((FIELD_ *) myField);
00113   const SUPPORT * mySupport=myField->getSupport();
00114 
00115   cout.setf(ios::fixed);
00116 
00117 
00118   int numberOfComponents    = myField->getNumberOfComponents() ;
00119   int valueLength           = myField->getValueLength();
00120   const int * nbGaussPoints = myField->getNumberOfGaussPoints();
00121 
00122   int numberOf              = mySupport->getNumberOfElements(MED_ALL_ELEMENTS);
00123   int numberOfGeometricType = mySupport->getNumberOfTypes();
00124   const int * nbOfElements  = mySupport->getNumberOfElements();
00125   const MED_EN::medGeometryElement * typeList      = mySupport->getTypes();
00126   bool  onAll               = mySupport->isOnAllElements();
00127 
00128   cout << "mySupport->getValueLength           (MED_ALL_ELEMENTS) : " << valueLength << endl;
00129   cout << "mySupport->getNumberOfElements      (MED_ALL_ELEMENTS) : " << numberOf   << endl;
00130   cout << "mySupport->getNumberOfComponents    ()                 : " << numberOfComponents << endl;
00131   cout << "mySupport->getNumberOfGeometricType ()                 : " << numberOfGeometricType << endl;
00132   assert(numberOf == myField->getNumberOfValues() );
00133 
00134   // S'il existe des profils, je récupère la liste des numéros d'éléments
00135   // pour tous les types géométriques
00136   for (int i=0; i < numberOfGeometricType; i++) {
00137     cout << "Number Of Elements on type "<< MED_EN::geoNames[typeList[i]]
00138          <<" : "<< nbOfElements[i] << endl;
00139     cout << "Number Of Gauss Points on type "<< MED_EN::geoNames[typeList[i]]
00140          <<" : "<< nbGaussPoints[i] << endl;
00141     cout << "Localization description : " << endl << myField->getGaussLocalization(typeList[i]) << endl;
00142   }
00143 
00144   // On récupère la liste complète
00145   if (!onAll) number = mySupport->getNumber(MED_ALL_ELEMENTS);
00146 
00147   int elNo = -1;
00148   cout << "- Valeurs :" << endl;
00149   for (int i=1; i<=numberOf; i++) {
00150     if (onAll) elNo = i; else elNo = number[i-1];
00151     //cout << endl << "myField->getRow("<<elNo<<") : "<< myField->getRow(elNo) << endl;
00152     value = myField->getRow(elNo) ;
00153     //UP: getRow prend un numéro d'élément qui existe, getRow(1) n'existe pas forcément si il y a un profil
00154     //qui ne défini pas cet indice
00155     //cout << endl << " Valeur de getNbGaussI("<<elNo<<") :" << myField->getNbGaussI(elNo) << endl;
00156     for (int j=0; j<numberOfComponents*myField->getNbGaussI(elNo); j++)
00157       //UP : Prend en compte le nombre de points de Gauss de l'élément elNo
00158       cout << "value["<< elNo << "] = " << value[j] << " ";
00159     cout<<endl;
00160   }
00161 
00162 }
00163 
00164 // Spécialisation du traitement pour le mode NoInterlace
00165 // Spécifité de traitement par rapport aux profils (utilisation du SUPPORT)
00166 // Pas de spécificité concernant le type géométrique
00167 // Pas de spécificité concernant les points de Gauss
00168 template <>
00169 void affiche_fieldT(FIELD<double, NoInterlace> * myField)
00170 {
00171   const double * value = 0;
00172   const int    * number = 0;
00173 
00174   affiche_field_((FIELD_ *) myField);
00175   const SUPPORT * mySupport=myField->getSupport();
00176 
00177   cout.setf(ios::fixed);
00178 
00179 
00180   int numberOfComponents    = myField->getNumberOfComponents() ;
00181   int valueLength           = myField->getValueLength();
00182   const int * nbGaussPoints = myField->getNumberOfGaussPoints();
00183 
00184   int numberOf              = mySupport->getNumberOfElements(MED_ALL_ELEMENTS);
00185   int numberOfGeometricType = mySupport->getNumberOfTypes();
00186   const int * nbOfElements  = mySupport->getNumberOfElements();
00187   const MED_EN::medGeometryElement * typeList      = mySupport->getTypes();
00188   bool  onAll               = mySupport->isOnAllElements();
00189 
00190   cout << "mySupport->getValueLength           (MED_ALL_ELEMENTS) : " << valueLength << endl;
00191   cout << "mySupport->getNumberOfElements      (MED_ALL_ELEMENTS) : " << numberOf   << endl;
00192   cout << "mySupport->getNumberOfComponents    ()                 : " << numberOfComponents << endl;
00193   cout << "mySupport->getNumberOfGeometricType ()                 : " << numberOfGeometricType << endl;
00194   cout << "mySupport->getNumberOfElements(MED_ALL_ELEMENTS)       : " << numberOf << endl;
00195   assert(numberOf == myField->getNumberOfValues() );
00196 
00197   // S'il existe des profils, je récupère la liste des numéros d'éléments
00198   // pour tous les types géométriques
00199   for (int i=0; i < numberOfGeometricType; i++) {
00200     cout << "Number Of Elements on type "<< MED_EN::geoNames[typeList[i]]
00201          <<" : "<< nbOfElements[i] << endl;
00202     cout << "Number Of Gauss Points on type "<< MED_EN::geoNames[typeList[i]]
00203          <<" : "<< nbGaussPoints[i] << endl;
00204     cout << "Localization description : " << endl << myField->getGaussLocalization(typeList[i]) << endl;
00205   }
00206 
00207 
00208   int (* fct)(int,const int *);
00209 
00210   if (!onAll) {
00211     number = mySupport->getNumber(MED_ALL_ELEMENTS);
00212     fct=fct1;
00213   } else
00214     fct=fct2;
00215 
00216   int oneDimlength = valueLength/numberOfComponents;
00217   for (int j=1; j<=numberOfComponents; j++) {
00218     value = myField->getColumn(j) ;
00219     for (int i=0; i<oneDimlength; i++)
00220       cout << "value["<< fct(i,number) << ","<<j<<"]" << value[ fct(i,number) ] << " ";
00221     cout<<endl;
00222   }
00223 
00224 }
00225 
00226 
00227 template <class T, class INTERLACING_TAG>
00228 void affiche_fieldT2(FIELD< T,  INTERLACING_TAG> * myField)
00229 {}
00230 
00231 
00232 // Spécialisation du traitement pour le mode FullInterlace
00233 // Spécifité de traitement par rapport aux profils (utilisation du SUPPORT)
00234 // Spécificité concernant le type géométrique
00235 // Spécificité concernant les points de Gauss
00236 template <>
00237 void affiche_fieldT2(FIELD<double, FullInterlace> * myField)
00238 {
00239   const int    * number = 0;
00240 
00241   affiche_field_((FIELD_ *) myField);
00242   const SUPPORT * mySupport=myField->getSupport();
00243 
00244   cout.setf(ios::fixed);
00245 
00246 
00247   int numberOfComponents    = myField->getNumberOfComponents() ;
00248   int valueLength           = myField->getValueLength();
00249   const int * nbGaussPoints = myField->getNumberOfGaussPoints();
00250 
00251   int numberOf              = mySupport->getNumberOfElements(MED_ALL_ELEMENTS);
00252   int numberOfGeometricType = mySupport->getNumberOfTypes();
00253   const int * nbOfElements  = mySupport->getNumberOfElements();
00254   const MED_EN::medGeometryElement * typeList      = mySupport->getTypes();
00255   bool  onAll               = mySupport->isOnAllElements();
00256 
00257   cout << "mySupport->getValueLength           (MED_ALL_ELEMENTS) : " << valueLength << endl;
00258   cout << "mySupport->getNumberOfElements      (MED_ALL_ELEMENTS) : " << numberOf   << endl;
00259   cout << "mySupport->getNumberOfComponents    ()                 : " << numberOfComponents << endl;
00260   cout << "mySupport->getNumberOfGeometricType ()                 : " << numberOfGeometricType << endl;
00261   cout << "mySupport->getNumberOfElements(MED_ALL_ELEMENTS)       : " << numberOf << endl;
00262   assert(numberOf == myField->getNumberOfValues() );
00263 
00264   // S'il existe des profils, je récupère la liste des numéros d'éléments
00265   // pour tous les types géométriques
00266   for (int i=0; i < numberOfGeometricType; i++) {
00267     cout << "Number Of Elements on type "<< MED_EN::geoNames[typeList[i]]
00268          <<" : "<< nbOfElements[i] << endl;
00269     cout << "Number Of Gauss Points on type "<< MED_EN::geoNames[typeList[i]]
00270          <<" : "<< nbGaussPoints[i] << endl;
00271   }
00272 
00273 
00274   int (* fct)(int,const int *);
00275 
00276   if (!onAll) {
00277     number = mySupport->getNumber(MED_ALL_ELEMENTS);
00278     fct=fct1;
00279   } else
00280     fct=fct2;
00281 
00282   cout << "- Valeurs :"<<endl;
00283 
00284   int elemno = 1;
00285   for (int ntyp=1; ntyp <= numberOfGeometricType; ntyp++ ) {
00286     for (int  i=0; i < nbOfElements[ntyp-1] ; i++ ) {
00287       for (int k=1; k <= nbGaussPoints[ntyp-1]; k++)
00288         for (int j=1; j <= numberOfComponents; j++) {
00289           cout << " value["<< fct(elemno-1,number) << "," <<j<<","<<k<<"] = "
00290           << myField->getValueIJK(fct(elemno-1,number),j,k);
00291         }
00292       elemno++;
00293       cout << endl;
00294     }
00295   }
00296 
00297   assert((elemno-1) == numberOf);
00298 
00299 }
00300 
00301 
00302 int main (int argc, char ** argv) {
00303 
00304   if ((argc !=3) && (argc != 5)) {
00305     cerr << "Usage : " << argv[0]
00306          << " filename fieldName [iterationNumber] [orderNumber]" << endl << endl;
00307     exit(-1);
00308   }
00309 
00310   string fileName  = argv[1] ;
00311   string fieldName = argv[2] ;
00312   int  iterationNumber=-1,orderNumber=-1;
00313   if ( argv[3] )  iterationNumber = atoi(argv[3]);
00314   if ( argv[4] )  orderNumber     = atoi(argv[4]);
00315 
00316   string meshName="";//"MAILTRQU";
00317   //goto mode2;
00319     // TEST PREMIER MODE :
00320     // Le fichier MED lu contient le maillage associé au champ demandé (qui contient des profils )
00321     // Le driver du FIELD automatiquement crée est capable de lire les profils MEDFICHIER
00322     // (le SUPPORT est crée automatiquement, le nom du maillage associé est disponible dans
00323     // le SUPPORT mais la relation SUPPORT-MESH est non initialisée car le MESH n'est pas chargé).
00324     // Le driver utilise les informations du maillage dans le fichier pour transcrire les profils
00325     // de la numérotation locale MEDFICHIER à la numérotation globale MEDMEMOIRE).
00326     // A l'écriture, il se repose également sur le maillage contenu dans le fichier
00327     // pour effecuter la renumérotation.
00328     {
00329       FIELD<double,INTERLACING_MODE> * myField1  = new FIELD<double,INTERLACING_MODE>(MED_DRIVER,fileName,fieldName,
00330                                                                                       iterationNumber, orderNumber);
00331       affiche_fieldT(myField1);
00332       cout << endl;
00333       affiche_fieldT2(myField1);
00334 
00335       // Pour éviter de modifier le fichier d'origine,
00336       // on en crée une copie avec uniquement le maillage.
00337       // Rem : Pour le test, le chargement du maillage n'est pas nécessaire
00338       //       On pourrait réécrire le Champ dans le fichier d'origine
00339       //       sous un autre nom.
00340       // Attention si le driver MED_MESH modifie le nombre d'éléments d'un type géométrique :
00341       // le calcul de renumérotation à l'écriture du champ risque d'être faux !
00342       meshName = myField1->getSupport()->getMeshName();
00343       MESH * myMesh = new MESH(MED_DRIVER,fileName,meshName);
00344       MED_MESH_WRONLY_DRIVER myMeshDriver1("Copy_withmesh_"+fileName,myMesh);
00345       int current=myMesh->addDriver(myMeshDriver1);
00346       myMesh->write(current);
00347       myMesh->removeReference();
00348 
00349       // On ajoute un driver en écriture, comme la relation SUPPORT-MESH n'est pas
00350       // initialisée, le driver doit trouver le maillage dans le fichier cible
00351       // pour réaliser la transcription des profils MEDMEMOIRE à MEDFICHIER.
00352       MED_FIELD_WRONLY_DRIVER<double> myFieldDriver2("Copy_withmesh_"+fileName,myField1) ;
00353       current = myField1->addDriver(myFieldDriver2);
00354       myField1->write(current);
00355       myField1->removeReference();
00356     }
00357 
00358 //  mode2:
00359 //     /////////////////////////////////////////////////////////////////////////////
00360 //       // TEST DEUXIEME MODE :
00361 //       // Lecture idem 1er mode
00362 //       // A l'écriture, le fichier cible ne contient pas le maillage mais la
00363 //       // relation SUPPORT-MESH est établie, le driver peut donc utiliser les informations
00364 //       // dans le maillage pour transcrire les profils.
00365 //       // Selon le modèle MED FICHIER, ce mode est interdit : le fichier doit au moins
00366 //       // contenir un lien sur le maillage (information pas encore exploitée dans MEDMEMOIRE
00367 //       // : pas de gestion de montage/démontage des fichiers )
00368 //       // Attention si le driver MED_MESH modifie le nombre d'éléments d'un type géométrique :
00369 //       // le calcul de renumérotation à l'écriture du champ risque d'être faux car les
00370 //       // profils crées à la lecture sont basés sur le nombre d'éléments par type géoémtrique
00371 //       // du maillage contenu dans le fichier à la lecture.
00372 //       // Une solution consisterait à prendre en compte le montage de fichiers distants
00373 //       // et de prendre en compte la différence de nombre d'éléments par type géométrique
00374 //       // entre le maillage MEDMEM et le maillage MEDFICHIER
00375 //       // (Hum ! : Il serait plus simple que MEDMEMOIRE ne recalcule pas systématiquement
00376 //       //  ce que l'on ne lui demande pas, ce qui permettrait aussi de réécrire à l'identique
00377 //       // un fichier que l'on vient de lire)
00378 //    {
00379 //      FIELD<double,INTERLACING_MODE> * myField2  = new FIELD<double,INTERLACING_MODE>(MED_DRIVER,fileName,fieldName,
00380 //                                                                                   iterationNumber, orderNumber);
00381 
00382 //      meshName = myField2->getSupport()->getMeshName();
00383 //      MESH * myMesh2 = new MESH(MED_DRIVER,fileName,meshName);
00384 
00385 //      const SUPPORT * mySupport2=myField2->getSupport();
00386 //      mySupport2->setMesh(myMesh2);
00387 
00388 //      // On ajoute un driver en écriture, comme la relation SUPPORT-MESH est
00389 //      // initialisée, le driver utilise le maillage en mémoire
00390 //      // pour réaliser la transcription des profils MEDMEMOIRE à MEDFICHIER.
00391 //      MED_FIELD_WRONLY_DRIVER<double> myFieldDriver3("Copy_nomesh_"+fileName,myField2) ;
00392 //      int current = myField2->addDriver(myFieldDriver3);
00393 //      myField2->write(current);
00394 
00395 //      //Pour regarder le fichier produit avec MDUMP decommenter ces trois lignes
00396 //      //car le fichier qui est produit n'est pas à la norme MED
00397 //      //Il doit contenir soit le maillage associé soit un lien vers le maillage associé.
00398 //      //MED_MESH_WRONLY_DRIVER myMeshDriver2("Copy_nomesh_"+fileName,myMesh2);
00399 //      //current=myMesh2->addDriver(myMeshDriver2);
00400 //      //myMesh2->write(current);
00401 
00402 //      delete myField2;
00403 //      delete myMesh2;
00404 
00405 
00406 //    }
00407 //  mode3:
00408 //    // TEST TROISIEME MODE  :
00409 //    // A la lecture, le fichier MED lu ne contient pas le maillage  associé au champ demandé
00410 //    // (mais un lien MEDFICHIER qui n'est pas exploité à ce jour).
00411 //    // Cependant avant sa lecture le FIELD a été associé à un SUPPORT
00412 //    // avec le lien au MESH préalablement chargé.
00413 //    // Le driver du FIELD (automatiquement crée) est capable de lire les profils MEDFICHIER
00414 //    //   et utilise la relation SUPPORT-MESH initialisée pour transcrire les profils
00415 //    //   de la numérotation locale MEDFICHIER à la numérotation globale MEDMEMOIRE).
00416 //    // REM: Une fois le champ chargé, il possède un nouveau support, le premier peut être libéré.
00417 //    //      En effet le driver du FIELD se fit uniquement au type géométriques définis dans le champ MEDFICHIER
00418 //    //      pour créer son SUPPORT car un SUPPORT crée "onAll" à partir d'un MESH repose sur tous
00419 //    //      les types géométriques du MESH ce qui n'est pas forcément le cas d'un champ MEDFICHIER
00420 //    //      (même sans profil) lu à posteriori.
00421 //    {
00422 //      med_2_3::med_err err=-1;
00423 //      med_2_3::med_idt id = med_2_3::MEDfileOpen(const_cast<char *> ( ("Copy_nomesh_"+fileName).c_str()),
00424 //                                            med_2_3::MED_ACC_RDWR);
00425 //      if (id <=0) cout << "Erreur dans MEDouvrir pour le fichier " << "Copy_nomesh_"+fileName <<endl;
00426 
00427 //      err=med_2_3::MEDlienEcr(id, const_cast<char *> ( ("Copy_withmesh_"+fileName).c_str()),
00428 //                           const_cast<char *> (meshName.c_str()) );
00429 //      if (err !=0) cout << "Erreur dans MEDlienEcr pour le maillage distant " << meshName
00430 //                     <<" contenu dans le fichier " << "Copy_withmesh_"+fileName <<endl;
00431 
00432 
00433 //      err=med_2_3::MEDfermer(id);
00434 
00435 //      MESH * myMesh3 = new MESH(MED_DRIVER,fileName,meshName);
00436 //      const SUPPORT * mySupport3= new SUPPORT(myMesh3,"Temporary Support",MED_CELL);
00437 //      FIELD<double,INTERLACING_MODE> * myField3  = new FIELD<double,INTERLACING_MODE>(mySupport3,MED_DRIVER,"Copy_nomesh_"+fileName,fieldName, iterationNumber, orderNumber);
00438 //      delete mySupport3; // Il est déjà possible de libérer ce SUPPORT
00439 
00440 //      //TEST à la réecriture (renommage des profils
00441 //      // à cause de MEDprofilEcr qui ne prend pas en compte le mode
00442 //      // MED_LECTURE_AJOUT) ):
00443 //      string cpy("__Copy");
00444 //      vector < string > pflNames = myField3->getSupport()->getProfilNames();
00445 //      for (int i=0; i< pflNames.size(); ++i) {
00446 //        pflNames[i].resize(pflNames[i].size()-cpy.size());
00447 //        pflNames[i]+=cpy;
00448 //      }
00449 //      const_cast<SUPPORT*>(myField3->getSupport())->setProfilNames(pflNames);
00450 
00451 //      MED_FIELD_WRONLY_DRIVER<double> myFieldDriver4("Copy_nomesh_"+fileName,myField3) ;
00452 //      myFieldDriver4.setFieldName(myField3->getName()+"__Copy");
00453 //      int current = myField3->addDriver(myFieldDriver4);
00454 //      myField3->write(current);
00455 
00456 //      delete myMesh3;
00457 //      delete myField3;
00458 
00459 
00460 //      //ESSAYER AVEC MAILLAGE DS FICHIER ET LIEN SUPORT-MESH PRESENTS SIMULTANEMENT
00461 //      //EN VERSION COHERENTE ET NON COHERENTE
00462 //    }
00463 }