src/SMESH_I/SMESH_MEDMesh_i.cxx

   1 // Copyright (C) 2007-2011  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
  23 //  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
  24 //  File   : SMESH_MEDMesh_i.cxx
  25 //  Module : SMESH
  26 //
  27 #include "SMESH_MEDMesh_i.hxx"
  28 #include "SMESH_Gen_i.hxx"
  29 #include "SMESH_Mesh_i.hxx"
  30
  31 #include "SMESHDS_Mesh.hxx"
  32 #include "SMESHDS_SubMesh.hxx"
  33
  34 #include <TopExp.hxx>
  35 #include <TopExp_Explorer.hxx>
  36 #include <TopoDS.hxx>
  37 #include <TopoDS_Iterator.hxx>
  38 #include <TopoDS_Compound.hxx>
  39 #include <TopoDS_CompSolid.hxx>
  40 #include <TopoDS_Solid.hxx>
  41 #include <TopoDS_Shell.hxx>
  42 #include <TopoDS_Face.hxx>
  43 #include <TopoDS_Wire.hxx>
  44 #include <TopoDS_Edge.hxx>
  45 #include <TopoDS_Vertex.hxx>
  46 #include <TopoDS_Shape.hxx>
  47 #include <TopTools_MapOfShape.hxx>
  48
  49 #include "utilities.h"
  50 #include "Utils_CorbaException.hxx"
  51
  52 #include "SMESH_MEDSupport_i.hxx"
  53 #include "SMESH_MEDFamily_i.hxx"
  54
  55 # include "Utils_ORB_INIT.hxx"
  56 # include "Utils_SINGLETON.hxx"
  57 # include "Utils_ExceptHandlers.hxx"
  58
  59 extern "C"
  60 {
  61 #include <stdio.h>
  62 }
  63
  64 using namespace std;
  65
  66 //=============================================================================
  67 /*!
  68  * Default constructor
  69  */
  70 //=============================================================================
  71 // PN Est-ce un const ?
  72 SMESH_MEDMesh_i::SMESH_MEDMesh_i()
  73 {
  74   BEGIN_OF("Default Constructor SMESH_MEDMesh_i");
  75   END_OF("Default Constructor SMESH_MEDMesh_i");
  76 }
  77
  78 //=============================================================================
  79 /*!
  80  * Destructor
  81  */
  82 //=============================================================================
  83 SMESH_MEDMesh_i::~SMESH_MEDMesh_i()
  84 {
  85 }
  86
  87 //=============================================================================
  88 /*!
  89  * Constructor
  90  */
  91 //=============================================================================
  92 SMESH_MEDMesh_i::SMESH_MEDMesh_i(::SMESH_Mesh_i * m_i):_meshId(""),
  93                                                        _compte(false),
  94                                                        _creeFamily(false),
  95                                                        _famIdent(0),
  96                                                        _indexElts(0),
  97                                                        _indexEnts(0)
  98 {
  99   BEGIN_OF("Constructor SMESH_MEDMesh_i");
 100
 101   _mesh_i = m_i;
 102   _meshDS = _mesh_i->GetImpl().GetMeshDS();
 103
 104   END_OF("Constructor SMESH_MEDMesh_i");
 105 }
 106
 107 //=============================================================================
 108 /*!
 109  * CORBA: Accessor for Name
 110  */
 111 //=============================================================================
 112 char *SMESH_MEDMesh_i::getName() throw(SALOME::SALOME_Exception)
 113 {
 114   if (_meshDS == NULL)
 115     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 116                                  SALOME::INTERNAL_ERROR);
 117
 118   try
 119   {
 120     SMESH_Gen_i*             gen = SMESH_Gen_i::GetSMESHGen();
 121     SALOMEDS::Study_var    study = gen->GetCurrentStudy();
 122     SALOMEDS::SObject_var meshSO = gen->ObjectToSObject( study, _mesh_i->_this());
 123     if ( meshSO->_is_nil() )
 124       return CORBA::string_dup("toto");
 125
 126     CORBA::String_var name = meshSO->GetName();
 127     return CORBA::string_dup( name.in() );
 128   }
 129   catch(...)
 130   {
 131     MESSAGE("Exception en accedant au nom");
 132     THROW_SALOME_CORBA_EXCEPTION("Unable to acces Mesh C++ Object",
 133                                  SALOME::INTERNAL_ERROR);
 134   }
 135   return 0;
 136 }
 137
 138 //=============================================================================
 139 /*!
 140  * CORBA: Accessor for corbaindex cuisine interne
 141  */
 142 //=============================================================================
 143 CORBA::Long SMESH_MEDMesh_i::getCorbaIndex()throw(SALOME::SALOME_Exception)
 144 {
 145   MESSAGE("Non Implemente");
 146   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 147 }
 148
 149 //=============================================================================
 150 /*!
 151  * CORBA: Accessor for Space Dimension
 152  */
 153 //=============================================================================
 154 CORBA::Long SMESH_MEDMesh_i::getSpaceDimension()throw(SALOME::SALOME_Exception)
 155 {
 156   // PN : Il semblerait que la dimension soit fixee a 3
 157   if (_mesh_i == 0)
 158     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 159                                  SALOME::INTERNAL_ERROR);
 160   return 3;
 161 }
 162
 163 //=============================================================================
 164 /*!
 165  * CORBA: Accessor for Mesh Dimension
 166  */
 167 //=============================================================================
 168 CORBA::Long SMESH_MEDMesh_i::getMeshDimension()throw(SALOME::SALOME_Exception)
 169 {
 170   if (_mesh_i == 0)
 171     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 172                                  SALOME::INTERNAL_ERROR);
 173   // PN : Il semblerait que la dimension soit fixee a 3
 174   if (_mesh_i == 0)
 175     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 176                                  SALOME::INTERNAL_ERROR);
 177   return 3;
 178 }
 179 //=============================================================================
 180 /*!
 181  * CORBA: Accessor for the boolean _isAGrid
 182  */
 183 //=============================================================================
 184 CORBA::Boolean SMESH_MEDMesh_i::getIsAGrid() throw (SALOME::SALOME_Exception)
 185 {
 186   MESSAGE("!!!!!! NOT YET IMPLEMENTED !!!!!!");
 187
 188   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 189
 190   return false;
 191 }
 192 //=============================================================================
 193 /*!
 194  * CORBA: Accessor for the connectivities, to see if they exist
 195  */
 196 //=============================================================================
 197 CORBA::Boolean
 198 SMESH_MEDMesh_i::existConnectivity(SALOME_MED::medConnectivity connectivityType,
 199                                    SALOME_MED::medEntityMesh entity)
 200   throw (SALOME::SALOME_Exception)
 201 {
 202   MESSAGE("!!!!!! IMPLEMENTED BUT ONLY PARTIALLY !!!!!!");
 203
 204
 205   return false;
 206
 207 }
 208 //=============================================================================
 209 /*!
 210  * CORBA: Accessor for Coordinate
 211  */
 212 //=============================================================================
 213 CORBA::Double SMESH_MEDMesh_i::getCoordinate(CORBA::Long Number, CORBA::Long Axis)
 214   throw (SALOME::SALOME_Exception)
 215 {
 216   MESSAGE("!!!!!! NOT YET IMPLEMENTED !!!!");
 217
 218   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 219
 220   return 0.0;
 221 }
 222 //=============================================================================
 223 /*!
 224  * CORBA: Accessor for Coordinates System
 225  */
 226 //=============================================================================
 227 char *SMESH_MEDMesh_i::getCoordinatesSystem() throw(SALOME::SALOME_Exception)
 228 {
 229   if (_mesh_i == 0)
 230     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 231                                  SALOME::INTERNAL_ERROR);
 232   // PN : En dur. Non encore prevu
 233   try
 234   {
 235     string systcoo = "CARTESIEN";
 236     return CORBA::string_dup(systcoo.c_str());
 237   }
 238   catch(...)
 239   {
 240     MESSAGE("Exception en accedant au maillage");
 241     THROW_SALOME_CORBA_EXCEPTION("Unable to acces Mesh C++ Object",
 242                                  SALOME::INTERNAL_ERROR);
 243   }
 244 }
 245
 246 //=============================================================================
 247 /*!
 248  * CORBA: Accessor for Coordinates
 249  */
 250 //=============================================================================
 251 SALOME_TYPES::ListOfDouble * SMESH_MEDMesh_i::getCoordinates
 252 (SALOME_MED::medModeSwitch typeSwitch) throw(SALOME::SALOME_Exception)
 253 {
 254   if (_mesh_i == 0)
 255     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 256                                  SALOME::INTERNAL_ERROR);
 257   SALOME_TYPES::ListOfDouble_var myseq = new SALOME_TYPES::ListOfDouble;
 258   try
 259   {
 260     // PN  : En dur
 261     int spaceDimension = 3;
 262     int nbNodes = _meshDS->NbNodes();
 263     SCRUTE(nbNodes);
 264     myseq->length(nbNodes * spaceDimension);
 265     int i = 0;
 266
 267     SMDS_NodeIteratorPtr itNodes=_meshDS->nodesIterator();
 268     while(itNodes->more())
 269     {
 270       const SMDS_MeshNode* node = itNodes->next();
 271
 272       if (typeSwitch == SALOME_MED::MED_FULL_INTERLACE)
 273       {
 274         myseq[i * 3] = node->X();
 275         myseq[i * 3 + 1] = node->Y();
 276         myseq[i * 3 + 2] = node->Z();
 277         SCRUTE(myseq[i * 3]);
 278         SCRUTE(myseq[i * 3 + 1]);
 279         SCRUTE(myseq[i * 3 + 2]);
 280       }
 281       else
 282       {
 283         ASSERT(typeSwitch == SALOME_MED::MED_NO_INTERLACE);
 284         myseq[i] = node->X();
 285         myseq[i + nbNodes] = node->Y();
 286         myseq[i + (nbNodes * 2)] = node->Z();
 287         SCRUTE(myseq[i]);
 288         SCRUTE(myseq[i + nbNodes]);
 289         SCRUTE(myseq[i + (nbNodes * 2)]);
 290       }
 291       i++;
 292     }
 293   }
 294   catch(...)
 295   {
 296     MESSAGE("Exception en accedant aux coordonnees");
 297     THROW_SALOME_CORBA_EXCEPTION("Unable to acces Mesh C++ Object",
 298                                  SALOME::INTERNAL_ERROR);
 299   }
 300   return myseq._retn();
 301 }
 302
 303 //=============================================================================
 304 /*!
 305  * CORBA: Accessor for Coordinates Names
 306  */
 307 //=============================================================================
 308 SALOME_TYPES::ListOfString *
 309 SMESH_MEDMesh_i::getCoordinatesNames()throw(SALOME::SALOME_Exception)
 310 {
 311   if (_mesh_i == 0)
 312     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 313                                  SALOME::INTERNAL_ERROR);
 314   SALOME_TYPES::ListOfString_var myseq = new SALOME_TYPES::ListOfString;
 315   try
 316   {
 317     // PN : en dur
 318     int spaceDimension = 3;
 319     myseq->length(spaceDimension);
 320     myseq[0] = CORBA::string_dup("x");
 321     myseq[1] = CORBA::string_dup("y");
 322     myseq[2] = CORBA::string_dup("z");
 323   }
 324   catch(...)
 325   {
 326     MESSAGE("Exception en accedant aux noms des coordonnees");
 327     THROW_SALOME_CORBA_EXCEPTION("Unable to acces Mesh C++ Object",
 328                                  SALOME::INTERNAL_ERROR);
 329   }
 330   return myseq._retn();
 331
 332 }
 333
 334 //=============================================================================
 335 /*!
 336  * CORBA: Accessor for Coordinates Units
 337  */
 338 //=============================================================================
 339 SALOME_TYPES::ListOfString *
 340 SMESH_MEDMesh_i::getCoordinatesUnits()throw(SALOME::SALOME_Exception)
 341 {
 342   if (_mesh_i == 0)
 343     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 344                                  SALOME::INTERNAL_ERROR);
 345   SALOME_TYPES::ListOfString_var myseq = new SALOME_TYPES::ListOfString;
 346   try
 347   {
 348     // PN : en dur
 349     int spaceDimension = 3;
 350     myseq->length(spaceDimension);
 351     myseq[0] = CORBA::string_dup("m");
 352     myseq[1] = CORBA::string_dup("m");
 353     myseq[2] = CORBA::string_dup("m");
 354   }
 355   catch(...)
 356   {
 357     MESSAGE("Exception en accedant aux unites des coordonnees");
 358     THROW_SALOME_CORBA_EXCEPTION("Unable to acces Mesh C++ Object",
 359                                  SALOME::INTERNAL_ERROR);
 360   }
 361   return myseq._retn();
 362 }
 363
 364 //=============================================================================
 365 /*!
 366  * CORBA: Accessor for Number of Nodes
 367  */
 368 //=============================================================================
 369 CORBA::Long SMESH_MEDMesh_i::getNumberOfNodes()throw(SALOME::SALOME_Exception)
 370 {
 371   if (_mesh_i == 0)
 372     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 373                                  SALOME::INTERNAL_ERROR);
 374   try
 375   {
 376     return _meshDS->NbNodes();
 377   }
 378   catch(...)
 379   {
 380     MESSAGE("Exception en accedant au nombre de noeuds");
 381     THROW_SALOME_CORBA_EXCEPTION("Unable to acces Mesh C++ Object",
 382                                  SALOME::INTERNAL_ERROR);
 383   }
 384 }
 385
 386 //=============================================================================
 387 /*!
 388  * CORBA: Accessor for number of Types
 389  */
 390 //=============================================================================
 391 CORBA::Long SMESH_MEDMesh_i::getNumberOfTypes(SALOME_MED::medEntityMesh entity)
 392   throw(SALOME::SALOME_Exception)
 393 {
 394   if (_mesh_i == 0)
 395     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 396                                  SALOME::INTERNAL_ERROR);
 397   try
 398   {
 399     if (!_compte)
 400       calculeNbElts();
 401     int retour = 0;
 402     if (_mapNbTypes.find(entity) != _mapNbTypes.end())
 403       retour = _mapNbTypes[entity];
 404     return retour;
 405   }
 406   catch(...)
 407   {
 408     MESSAGE("Exception en accedant au nombre de Types");
 409     THROW_SALOME_CORBA_EXCEPTION("Unable to acces Mesh C++ Object",
 410                                  SALOME::INTERNAL_ERROR);
 411   }
 412 }
 413
 414 //=============================================================================
 415 /*!
 416  * CORBA: Accessor for existing geometry element types
 417  *        Not implemented for MED_ALL_ENTITIES
 418  */
 419 //=============================================================================
 420 SALOME_MED::medGeometryElement_array *
 421 SMESH_MEDMesh_i::getTypes(SALOME_MED::medEntityMesh entity) throw(SALOME::
 422                                                                   SALOME_Exception)
 423 {
 424   if (_mesh_i == 0)
 425     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 426                                  SALOME::INTERNAL_ERROR);
 427   if (entity == SALOME_MED::MED_ALL_ENTITIES)
 428     THROW_SALOME_CORBA_EXCEPTION("Not implemented for MED_ALL_ENTITIES",
 429                                  SALOME::BAD_PARAM);
 430   if (!_compte)
 431     calculeNbElts();
 432   SALOME_MED::medGeometryElement_array_var myseq =
 433     new SALOME_MED::medGeometryElement_array;
 434   try
 435   {
 436     if (_mapNbTypes.find(entity) == _mapNbTypes.end())
 437       THROW_SALOME_CORBA_EXCEPTION("No Such Entity in the mesh",
 438                                    SALOME::BAD_PARAM);
 439     int nbTypes = _mapNbTypes[entity];
 440
 441     myseq->length(nbTypes);
 442
 443     if (_mapIndToVectTypes.find(entity) == _mapIndToVectTypes.end())
 444       THROW_SALOME_CORBA_EXCEPTION("No Such Entity in the mesh",
 445                                    SALOME::INTERNAL_ERROR);
 446
 447     int index = _mapIndToVectTypes[entity];
 448     ASSERT(_TypesId[index].size() != 0);
 449     int i = 0;
 450     vector < SALOME_MED::medGeometryElement >::iterator it;
 451     for (it = _TypesId[index].begin(); it != _TypesId[index].end(); it++)
 452     {
 453       myseq[i++] = *it;
 454     };
 455   }
 456   catch(...)
 457   {
 458     MESSAGE("Exception en accedant aux differents types");
 459     THROW_SALOME_CORBA_EXCEPTION("Unable to acces Mesh C++ Object",
 460                                  SALOME::INTERNAL_ERROR);
 461   }
 462   return myseq._retn();
 463 }
 464
 465 //=============================================================================
 466 /*!
 467  * CORBA: Returns number of elements of type medGeometryElement
 468  *        Not implemented for MED_ALL_ELEMENTS
 469  *        implemented for MED_ALL_ENTITIES
 470  *
 471  * Dans cette implementation, il n est pas prevu de tenir compte du entity
 472  * qui ne doit pas pouvoir avoir deux valeurs differentes pour un geomElement
 473  */
 474 //=============================================================================
 475 CORBA::Long SMESH_MEDMesh_i::getNumberOfElements(SALOME_MED::
 476                                                  medEntityMesh entity,
 477                                                  SALOME_MED::medGeometryElement geomElement) throw(SALOME::SALOME_Exception)
 478 {
 479   if (_mesh_i == 0)
 480     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 481                                  SALOME::INTERNAL_ERROR);
 482   if (geomElement == SALOME_MED::MED_ALL_ELEMENTS)
 483     THROW_SALOME_CORBA_EXCEPTION("Not implemented for MED_ALL_ELEMENTS",
 484                                  SALOME::BAD_PARAM);
 485   if (!_compte)
 486     calculeNbElts();
 487
 488   try
 489   {
 490     int retour = 0;
 491     if (_mapIndToSeqElts.find(geomElement) != _mapIndToSeqElts.end())
 492     {
 493       int index = _mapIndToSeqElts[geomElement];
 494
 495       retour = _seq_elemId[index]->length();
 496     }
 497     return retour;
 498   }
 499   catch(...)
 500   {
 501     MESSAGE("Exception en accedant au nombre d élements");
 502     THROW_SALOME_CORBA_EXCEPTION("Unable to acces Mesh C++ Object",
 503                                  SALOME::INTERNAL_ERROR);
 504   }
 505 }
 506
 507 //=============================================================================
 508 /*!
 509  * CORBA: Accessor for connectivities
 510  */
 511 //=============================================================================
 512 SALOME_TYPES::ListOfLong *
 513 SMESH_MEDMesh_i::getConnectivity(SALOME_MED::medConnectivity mode,
 514                                  SALOME_MED::medEntityMesh entity,
 515                                  SALOME_MED::medGeometryElement geomElement)
 516   throw(SALOME::SALOME_Exception)
 517 {
 518   if (_mesh_i == 0)
 519     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 520                                  SALOME::INTERNAL_ERROR);
 521   if (mode != SALOME_MED::MED_NODAL)
 522     THROW_SALOME_CORBA_EXCEPTION("Not Implemented", SALOME::BAD_PARAM);
 523   /*if (typeSwitch == SALOME_MED::MED_NO_INTERLACE)
 524     THROW_SALOME_CORBA_EXCEPTION("Not Yet Implemented", SALOME::BAD_PARAM);*/
 525   if (!_compte)
 526     calculeNbElts();
 527
 528   // Faut-il renvoyer un pointeur vide ???
 529   if (_mapIndToSeqElts.find(geomElement) != _mapIndToSeqElts.end())
 530     THROW_SALOME_CORBA_EXCEPTION("No Such Element in the mesh",
 531                                  SALOME::BAD_PARAM);
 532
 533   int index = _mapIndToSeqElts[geomElement];
 534
 535   return _seq_elemId[index]._retn();
 536 }
 537
 538 //=============================================================================
 539 /*!
 540  * CORBA: Accessor for connectivities
 541  */
 542 //=============================================================================
 543 SALOME_TYPES::ListOfLong *
 544 SMESH_MEDMesh_i::getConnectivityIndex(SALOME_MED::medConnectivity mode,
 545                                       SALOME_MED::medEntityMesh entity)
 546   throw(SALOME::SALOME_Exception)
 547 {
 548   MESSAGE("Pas Implemente dans SMESH");
 549   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 550   return 0;
 551 }
 552
 553 //=============================================================================
 554 /*!
 555  * CORBA: Find an element corresponding to the given connectivity
 556  */
 557 //=============================================================================
 558 CORBA::Long
 559 SMESH_MEDMesh_i::getElementNumber(SALOME_MED::medConnectivity mode,
 560                                   SALOME_MED::medEntityMesh entity,
 561                                   SALOME_MED::medGeometryElement type,
 562                                   const SALOME_TYPES::ListOfLong & connectivity)
 563   throw(SALOME::SALOME_Exception)
 564 {
 565   const char *LOC = "getElementNumber ";
 566   MESSAGE(LOC << "Pas Implemente dans SMESH");
 567   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 568   return -1;
 569 }
 570
 571 //=============================================================================
 572 /*!
 573  * CORBA: Accessor for Ascendant connectivities
 574  * not implemented for MED_ALL_ENTITIES and MED_MAILLE
 575  */
 576 //=============================================================================
 577 SALOME_TYPES::ListOfLong *
 578 SMESH_MEDMesh_i::getReverseConnectivity(SALOME_MED::
 579                                         medConnectivity mode) throw(SALOME::SALOME_Exception)
 580 {
 581   MESSAGE("Pas Implemente dans SMESH");
 582   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 583   return 0;
 584 }
 585
 586 //=============================================================================
 587 /*!
 588  * CORBA: Accessor for connectivities
 589  */
 590 //=============================================================================
 591 SALOME_TYPES::ListOfLong *
 592 SMESH_MEDMesh_i::getReverseConnectivityIndex(SALOME_MED::
 593                                              medConnectivity mode) throw(SALOME::SALOME_Exception)
 594 {
 595   MESSAGE("Pas Implemente dans SMESH");
 596   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 597   return 0;
 598 }
 599
 600 //=============================================================================
 601 /*!
 602  * CORBA: Returns number of families within the mesh
 603  */
 604 //=============================================================================
 605 CORBA::Long SMESH_MEDMesh_i::getNumberOfFamilies(SALOME_MED::
 606                                                  medEntityMesh entity) throw(SALOME::SALOME_Exception)
 607 {
 608   if (_creeFamily == false)
 609     createFamilies();
 610   if (_mesh_i == 0)
 611     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 612                                  SALOME::INTERNAL_ERROR);
 613   return _families.size();
 614 }
 615
 616 //=============================================================================
 617 /*!
 618  * CORBA: Returns number of groups within the mesh
 619  */
 620 //=============================================================================
 621 CORBA::Long SMESH_MEDMesh_i::getNumberOfGroups(SALOME_MED::medEntityMesh entity)
 622   throw(SALOME::SALOME_Exception)
 623 {
 624   if (_mesh_i == 0)
 625     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 626                                  SALOME::INTERNAL_ERROR);
 627   MESSAGE(" Pas d implementation des groupes dans SMESH");
 628   return 0;
 629 }
 630
 631 //=============================================================================
 632 /*!
 633  * CORBA: Returns references for families within the mesh
 634  */
 635 //=============================================================================
 636 SALOME_MED::Family_array *
 637 SMESH_MEDMesh_i::getFamilies(SALOME_MED::
 638                              medEntityMesh entity) throw(SALOME::SALOME_Exception)
 639 {
 640   if (_creeFamily == false)
 641     createFamilies();
 642   if (_mesh_i == 0)
 643     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 644                                  SALOME::INTERNAL_ERROR);
 645   SALOME_MED::Family_array_var myseq = new SALOME_MED::Family_array;
 646   int nbfam = _families.size();
 647   myseq->length(nbfam);
 648   int i = 0;
 649   vector < SALOME_MED::FAMILY_ptr >::iterator it;
 650   for (it = _families.begin(); it != _families.end(); it++)
 651   {
 652     myseq[i++] = *it;
 653   };
 654   return myseq._retn();
 655 }
 656
 657 //=============================================================================
 658 /*!
 659  * CORBA: Returns references for family i within the mesh
 660  */
 661 //=============================================================================
 662 SALOME_MED::FAMILY_ptr SMESH_MEDMesh_i::getFamily(SALOME_MED::
 663                                                   medEntityMesh entity, CORBA::Long i) throw(SALOME::SALOME_Exception)
 664 {
 665   if (_creeFamily == false)
 666     createFamilies();
 667   if (_mesh_i == 0)
 668     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 669                                  SALOME::INTERNAL_ERROR);
 670
 671   SCRUTE(_families[i]->getName());
 672   MESSAGE(" SMESH_MEDMesh_i::getFamily " << i) return _families[i];
 673 }
 674
 675 //=============================================================================
 676 /*!
 677  * CORBA: Returns references for groups within the mesh
 678  */
 679 //=============================================================================
 680 SALOME_MED::Group_array *
 681 SMESH_MEDMesh_i::getGroups(SALOME_MED::medEntityMesh entity) throw(SALOME::
 682                                                                    SALOME_Exception)
 683 {
 684   if (_mesh_i == 0)
 685     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 686                                  SALOME::INTERNAL_ERROR);
 687   MESSAGE(" Pas d implementation des groupes dans SMESH");
 688   THROW_SALOME_CORBA_EXCEPTION("No group implementation", SALOME::BAD_PARAM);
 689 }
 690
 691 //=============================================================================
 692 /*!
 693  * CORBA: Returns references for group i within the mesh
 694  */
 695 //=============================================================================
 696 SALOME_MED::GROUP_ptr SMESH_MEDMesh_i::getGroup(SALOME_MED::
 697                                                 medEntityMesh entity, CORBA::Long i) throw(SALOME::SALOME_Exception)
 698 {
 699   if (_mesh_i == 0)
 700     THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
 701                                  SALOME::INTERNAL_ERROR);
 702   MESSAGE(" Pas d implementation des groupes dans SMESH");
 703   THROW_SALOME_CORBA_EXCEPTION("No group implementation", SALOME::BAD_PARAM);
 704 }
 705 //=============================================================================
 706 /*!
 707  * CORBA: Returns references for the global numbering index
 708  */
 709 //=============================================================================
 710 SALOME_TYPES::ListOfLong*
 711 SMESH_MEDMesh_i::getGlobalNumberingIndex(SALOME_MED::medEntityMesh entity)
 712   throw (SALOME::SALOME_Exception)
 713 {
 714   MESSAGE("!!!! NOT YET IMPLEMENTED !!!!!");
 715
 716   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 717
 718   return NULL;
 719 }
 720 //=============================================================================
 721 /*!
 722  * CORBA: Returns references for the support of boundary elements of type
 723  * entity
 724  */
 725 //=============================================================================
 726 SALOME_MED::SUPPORT_ptr
 727 SMESH_MEDMesh_i::getBoundaryElements(SALOME_MED::medEntityMesh entity)
 728   throw (SALOME::SALOME_Exception)
 729 {
 730   MESSAGE("!!!! NOT YET IMPLEMENTED !!!!!");
 731
 732   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 733
 734   return NULL;
 735 }
 736 //=============================================================================
 737 /*!
 738  * CORBA:  Method return a reference on a support define on all the element of
 739  *         an entity.
 740  */
 741 //=============================================================================
 742 SALOME_MED::SUPPORT_ptr
 743 SMESH_MEDMesh_i::getSupportOnAll(SALOME_MED::medEntityMesh entity)
 744   throw (SALOME::SALOME_Exception)
 745 {
 746   MESSAGE("!!!! NOT YET IMPLEMENTED !!!!!");
 747
 748   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 749
 750   return NULL;
 751 }
 752 //=============================================================================
 753 /*!
 754  * CORBA: Returns references for the support of the skin of the support
 755  * mySupport3D
 756  */
 757 //=============================================================================
 758 SALOME_MED::SUPPORT_ptr
 759 SMESH_MEDMesh_i::getSkin(SALOME_MED::SUPPORT_ptr mySupport3D)
 760   throw (SALOME::SALOME_Exception)
 761 {
 762   MESSAGE("!!!! NOT YET IMPLEMENTED !!!!!");
 763
 764   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 765
 766   return NULL;
 767 }
 768 //=============================================================================
 769 /*!
 770  * CORBA:
 771  */
 772 //=============================================================================
 773 SALOME_MED::FIELD_ptr SMESH_MEDMesh_i::getVolume(SALOME_MED::
 774                                                  SUPPORT_ptr mySupport) throw(SALOME::SALOME_Exception)
 775 {
 776   MESSAGE("Pas Implemente dans SMESH");
 777   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 778   return 0;
 779 }
 780
 781 //=============================================================================
 782 /*!
 783  * CORBA:
 784  */
 785 //=============================================================================
 786 SALOME_MED::FIELD_ptr SMESH_MEDMesh_i::getArea(SALOME_MED::
 787                                                SUPPORT_ptr mySupport) throw(SALOME::SALOME_Exception)
 788 {
 789   MESSAGE("Pas Implemente dans SMESH");
 790   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 791   return 0;
 792 }
 793
 794 //=============================================================================
 795 /*!
 796  * CORBA:
 797  */
 798 //=============================================================================
 799 SALOME_MED::FIELD_ptr SMESH_MEDMesh_i::getLength(SALOME_MED::
 800                                                  SUPPORT_ptr mySupport) throw(SALOME::SALOME_Exception)
 801 {
 802   MESSAGE("Pas Implemente dans SMESH");
 803   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 804   return 0;
 805 }
 806
 807 //=============================================================================
 808 /*!
 809  * CORBA:
 810  */
 811 //=============================================================================
 812 SALOME_MED::FIELD_ptr SMESH_MEDMesh_i::getNormal(SALOME_MED::
 813                                                  SUPPORT_ptr mySupport) throw(SALOME::SALOME_Exception)
 814 {
 815   MESSAGE("Pas Implemente dans SMESH");
 816   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 817   return 0;
 818 }
 819
 820 //=============================================================================
 821 /*!
 822  * CORBA:
 823  */
 824 //=============================================================================
 825 SALOME_MED::FIELD_ptr SMESH_MEDMesh_i::getBarycenter(SALOME_MED::
 826                                                      SUPPORT_ptr mySupport) throw(SALOME::SALOME_Exception)
 827 {
 828   MESSAGE("Pas Implemente dans SMESH");
 829   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 830   return 0;
 831 }
 832
 833 //=============================================================================
 834 /*!
 835  * CORBA:
 836  */
 837 //=============================================================================
 838 SALOME_MED::FIELD_ptr SMESH_MEDMesh_i::getNeighbourhood(SALOME_MED::
 839                                                         SUPPORT_ptr mySupport) throw(SALOME::SALOME_Exception)
 840 {
 841   MESSAGE("Non Implemente");
 842   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 843   return 0;
 844 }
 845
 846 //=============================================================================
 847 /*!
 848  * CORBA: add the Mesh in the StudyManager
 849  * PN Pas Implemente
 850  */
 851 //=============================================================================
 852 void SMESH_MEDMesh_i::addInStudy(SALOMEDS::Study_ptr myStudy,
 853                                  SALOME_MED::GMESH_ptr myIor) throw(SALOME::SALOME_Exception)
 854 {
 855   BEGIN_OF("MED_Mesh_i::addInStudy");
 856   if (_meshId != "")
 857   {
 858     MESSAGE("Mesh already in Study");
 859     THROW_SALOME_CORBA_EXCEPTION("Mesh already in Study",
 860                                  SALOME::BAD_PARAM);
 861   };
 862
 863   /*
 864    * SALOMEDS::StudyBuilder_var myBuilder = myStudy->NewBuilder();
 865    *
 866    * // Create SComponent labelled 'MED' if it doesn't already exit
 867    * SALOMEDS::SComponent_var medfather = myStudy->FindComponent("MED");
 868    * if ( CORBA::is_nil(medfather) )
 869    * {
 870    * MESSAGE("Add Component MED");
 871    * medfather = myBuilder->NewComponent("MED");
 872    * //myBuilder->AddAttribute (medfather,SALOMEDS::Name,"MED");
 873    * SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(
 874    * myBuilder->FindOrCreateAttribute(medfather, "AttributeName"));
 875    * aName->SetValue("MED");
 876    *
 877    * myBuilder->DefineComponentInstance(medfather,myIor);
 878    *
 879    * } ;
 880    *
 881    * MESSAGE("Add a mesh Object under MED");
 882    * myBuilder->NewCommand();
 883    * SALOMEDS::SObject_var newObj = myBuilder->NewObject(medfather);
 884    *
 885    * ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance() ;
 886    * ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting()) ;
 887    * CORBA::ORB_var &orb = init(0,0);
 888    * CORBA::String_var iorStr = orb->object_to_string(myIor);
 889    * //myBuilder->AddAttribute(newObj,SALOMEDS::IOR,iorStr.in());
 890    * SALOMEDS::AttributeIOR_var aIOR = SALOMEDS::AttributeIOR::_narrow(
 891    * myBuilder->FindOrCreateAttribute(newObj, "AttributeIOR"));
 892    * aIOR->SetValue(iorStr.c_str());
 893    *
 894    * //myBuilder->AddAttribute(newObj,SALOMEDS::Name,_mesh_i->getName().c_str());
 895    * SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(
 896    * myBuilder->FindOrCreateAttribute(newObj, "AttributeName"));
 897    * aName->SetValue(_mesh_i->getName().c_str());
 898    *
 899    * _meshId = newObj->GetID();
 900    * myBuilder->CommitCommand();
 901    *
 902    */
 903   END_OF("Mesh_i::addInStudy(SALOMEDS::Study_ptr myStudy)");
 904 }
 905
 906 //=============================================================================
 907 /*!
 908  * CORBA: write mesh in a med file
 909  */
 910 //=============================================================================
 911 void SMESH_MEDMesh_i::write(CORBA::Long i, const char *driverMeshName)
 912   throw(SALOME::SALOME_Exception)
 913 {
 914   MESSAGE("Non Implemente");
 915   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 916 }
 917
 918 //=============================================================================
 919 /*!
 920  * CORBA: read mesh in a med file
 921  */
 922 //=============================================================================
 923 void SMESH_MEDMesh_i::read(CORBA::Long i) throw(SALOME::SALOME_Exception)
 924 {
 925   MESSAGE("Non Implemente");
 926   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 927 }
 928
 929 //=============================================================================
 930 /*!
 931  * CORBA : release driver
 932  */
 933 //=============================================================================
 934 void SMESH_MEDMesh_i::rmDriver(CORBA::Long i) throw(SALOME::SALOME_Exception)
 935 {
 936   MESSAGE("Non Implemente");
 937   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 938 }
 939
 940 //=============================================================================
 941 /*!
 942  * CORBA : attach driver
 943  */
 944 //=============================================================================
 945 CORBA::Long SMESH_MEDMesh_i::addDriver(SALOME_MED::medDriverTypes driverType,
 946                                        const char *fileName, const char *meshName) throw(SALOME::SALOME_Exception)
 947 {
 948   MESSAGE("Non Implemente");
 949   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
 950   return 0;
 951 }
 952
 953 //=============================================================================
 954 /*!
 955  * Calcule le Nb d'elements par entite geometrique
 956  */
 957 //=============================================================================
 958 void SMESH_MEDMesh_i::calculeNbElts() throw(SALOME::SALOME_Exception)
 959 {
 960   if (!_compte)
 961   {
 962     _compte = true;
 963
 964     _mapNbTypes[SALOME_MED::MED_NODE] = 1;
 965     // On compte les aretes MED_SEG2 ou MED_SEG3
 966     // On range les elements dans  les vecteurs correspondants
 967
 968     _mapIndToSeqElts[SALOME_MED::MED_SEG2] = _indexElts++;
 969     _mapIndToSeqElts[SALOME_MED::MED_SEG3] = _indexElts++;
 970     _mapIndToVectTypes[SALOME_MED::MED_EDGE] = _indexEnts++;
 971
 972     int trouveSeg2 = 0;
 973     int trouveSeg3 = 0;
 974     SALOME_MED::medGeometryElement medElement;
 975
 976     SMDS_EdgeIteratorPtr itEdges=_meshDS->edgesIterator();
 977     while(itEdges->more())
 978     {
 979       const SMDS_MeshEdge* elem = itEdges->next();
 980       int nb_of_nodes = elem->NbNodes();
 981
 982       switch (nb_of_nodes)
 983       {
 984       case 2:
 985         {
 986           medElement = SALOME_MED::MED_SEG2;
 987           if (trouveSeg2 == 0)
 988           {
 989             trouveSeg2 = 1;
 990             _TypesId[SALOME_MED::MED_EDGE].
 991               push_back(SALOME_MED::MED_SEG2);
 992           }
 993           break;
 994         }
 995       case 3:
 996         {
 997           medElement = SALOME_MED::MED_SEG3;
 998           if (trouveSeg3 == 0)
 999           {
1000             trouveSeg3 = 1;
1001             _TypesId[SALOME_MED::MED_EDGE].
1002               push_back(SALOME_MED::MED_SEG3);
1003           }
1004           break;
1005         }
1006       }
1007       int index = _mapIndToSeqElts[medElement];
1008       SCRUTE(index);
1009       // Traitement de l arete
1010
1011       int longueur = _seq_elemId[index]->length();
1012       _seq_elemId[index]->length(longueur + nb_of_nodes);
1013
1014       SMDS_NodeIteratorPtr itn=_meshDS->nodesIterator();
1015
1016       for(int k=0; itn->more(); k++)
1017         _seq_elemId[index][longueur + k] = itn->next()->GetID()+1;
1018     }
1019
1020     _mapNbTypes[SALOME_MED::MED_EDGE] = trouveSeg2 + trouveSeg3;
1021
1022     // On compte les faces MED_TRIA3, MED_HEXA8, MED_TRIA6
1023     // On range les elements dans  les vecteurs correspondants
1024     int trouveTria3 = 0;
1025     int trouveTria6 = 0;
1026     int trouveQuad4 = 0;
1027
1028     _mapIndToSeqElts[SALOME_MED::MED_TRIA3] = _indexElts++;
1029     _mapIndToSeqElts[SALOME_MED::MED_TRIA6] = _indexElts++;
1030     _mapIndToSeqElts[SALOME_MED::MED_QUAD4] = _indexElts++;
1031     _mapIndToVectTypes[SALOME_MED::MED_FACE] = _indexEnts++;
1032
1033     SMDS_FaceIteratorPtr itFaces=_meshDS->facesIterator();
1034     while(itFaces->more())
1035     {
1036       const SMDS_MeshFace * elem = itFaces->next();
1037       int nb_of_nodes = elem->NbNodes();
1038
1039       switch (nb_of_nodes)
1040       {
1041       case 3:
1042         {
1043           medElement = SALOME_MED::MED_TRIA3;
1044           if (trouveTria3 == 0)
1045           {
1046             trouveTria3 = 1;
1047             _TypesId[SALOME_MED::MED_FACE].
1048               push_back(SALOME_MED::MED_TRIA3);
1049           }
1050           break;
1051         }
1052       case 4:
1053         {
1054           medElement = SALOME_MED::MED_QUAD4;
1055           if (trouveQuad4 == 0)
1056           {
1057             trouveQuad4 = 1;
1058             _TypesId[SALOME_MED::MED_FACE].
1059               push_back(SALOME_MED::MED_QUAD4);
1060           }
1061           break;
1062         }
1063       case 6:
1064         {
1065           medElement = SALOME_MED::MED_TRIA6;
1066           if (trouveTria6 == 0)
1067           {
1068             trouveTria6 = 1;
1069             _TypesId[SALOME_MED::MED_FACE].
1070               push_back(SALOME_MED::MED_TRIA6);
1071           }
1072           break;
1073         }
1074       }
1075       int index = _mapIndToSeqElts[medElement];
1076       SCRUTE(index);
1077
1078       // Traitement de la face
1079       // Attention La numérotation des noeuds Med commence a 1
1080
1081       int longueur = _seq_elemId[index]->length();
1082       _seq_elemId[index]->length(longueur + nb_of_nodes);
1083
1084       SMDS_NodeIteratorPtr itn=_meshDS->nodesIterator();
1085
1086       for(int k=0; itn->more(); k++)
1087         _seq_elemId[index][longueur + k] = itn->next()->GetID()+1;
1088     } //itFaces
1089
1090     _mapNbTypes[SALOME_MED::MED_FACE] =
1091       trouveTria3 + trouveTria6 + trouveQuad4;
1092
1093     _mapIndToSeqElts[SALOME_MED::MED_HEXA8] = _indexElts++;
1094     _mapIndToVectTypes[SALOME_MED::MED_CELL] = _indexEnts++;
1095     int index = _mapIndToSeqElts[medElement];
1096
1097     int trouveHexa8 = 0;
1098
1099     SMDS_VolumeIteratorPtr itVolumes=_meshDS->volumesIterator();
1100     while(itVolumes->more())
1101     {
1102       const SMDS_MeshVolume * elem = itVolumes->next();
1103
1104       int nb_of_nodes = elem->NbNodes();
1105       medElement = SALOME_MED::MED_HEXA8;
1106       ASSERT(nb_of_nodes == 8);
1107
1108       if (trouveHexa8 == 0)
1109       {
1110         trouveHexa8 = 1;
1111         _TypesId[SALOME_MED::MED_CELL].push_back(SALOME_MED::MED_HEXA8);
1112       };
1113       // Traitement de la maille
1114       int longueur = _seq_elemId[index]->length();
1115       _seq_elemId[index]->length(longueur + nb_of_nodes);
1116
1117       SMDS_NodeIteratorPtr itn=_meshDS->nodesIterator();
1118       for(int k=0; itn->more(); k++)
1119         _seq_elemId[index][longueur + k] = itn->next()->GetID()+1;
1120     }
1121
1122     _mapNbTypes[SALOME_MED::MED_CELL] = trouveHexa8;
1123     _mapNbTypes[SALOME_MED::MED_ALL_ENTITIES]
1124       =
1125       trouveHexa8 + trouveTria3 + trouveTria6 + trouveQuad4 + trouveSeg2 +
1126       trouveSeg3;
1127   }// fin du _compte
1128 };
1129
1130 //=============================================================================
1131 /*!
1132  * Creation des familles
1133  */
1134 //=============================================================================
1135 void SMESH_MEDMesh_i::createFamilies() throw(SALOME::SALOME_Exception)
1136 {
1137   Unexpect aCatch(SALOME_SalomeException);
1138   string famDes = ("Je ne sais pas");
1139   string famName0 = "Famille_";
1140   string famName;
1141   char numero[10];
1142
1143   if (_creeFamily == false)
1144   {
1145     _creeFamily = true;
1146     //SMESH_subMesh_i *subMeshServant;
1147
1148     map < int, SMESH_subMesh_i * >::iterator it;
1149     for (it = _mesh_i->_mapSubMesh_i.begin();
1150          it != _mesh_i->_mapSubMesh_i.end(); it++)
1151     {
1152       SMESH_subMesh_i *submesh_i = (*it).second;
1153       int famIdent = (*it).first;
1154
1155       ASSERT(famIdent < 999999999);
1156       sprintf(numero, "%d\n", famIdent);
1157       famName = famName0 + numero;
1158
1159       SMESH_MEDFamily_i *famservant =
1160         new SMESH_MEDFamily_i(famIdent, submesh_i,
1161                               famName, famDes, SALOME_MED::MED_NODE);
1162 #ifdef WNT
1163       SALOME_MED::FAMILY_ptr famille = SALOME_MED::FAMILY::_nil();
1164       POA_SALOME_MED::FAMILY* servantbase = dynamic_cast<POA_SALOME_MED::FAMILY*>(famservant);
1165       if ( servantbase )
1166         famille = SALOME_MED::FAMILY::_narrow( servantbase->_this() );
1167 #else
1168       SALOME_MED::FAMILY_ptr famille =
1169         SALOME_MED::FAMILY::_narrow( famservant->POA_SALOME_MED::FAMILY::_this() );
1170 #endif
1171       _families.push_back(famille);
1172     }
1173   }
1174 };
1175 //=============================================================================
1176 /*!
1177  * Gives informations of the considered mesh.
1178  */
1179 //=============================================================================
1180 SALOME_MED::GMESH::meshInfos * SMESH_MEDMesh_i::getMeshGlobal()
1181   throw (SALOME::SALOME_Exception)
1182 {
1183   MESSAGE("!!!! NOT YET IMPLEMENTED !!!!!");
1184
1185   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
1186
1187   return NULL;
1188 }
1189
1190 //================================================================================
1191 /*!
1192  * \brief Converts this GMESH into MESH
1193  */
1194 //================================================================================
1195
1196 SALOME_MED::MESH_ptr SMESH_MEDMesh_i::convertInMESH() throw (SALOME::SALOME_Exception)
1197 {
1198   MESSAGE("!!!! NOT YET IMPLEMENTED !!!!!");
1199
1200   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
1201
1202   return NULL;
1203 }
1204
1205 //=============================================================================
1206 /*!
1207  * Gives informations on coordinates of the considered mesh.
1208  */
1209 //=============================================================================
1210 SALOME_MED::GMESH::coordinateInfos * SMESH_MEDMesh_i::getCoordGlobal()
1211   throw (SALOME::SALOME_Exception)
1212 {
1213   MESSAGE("!!!! NOT YET IMPLEMENTED !!!!!");
1214
1215   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
1216
1217   return NULL;
1218 }
1219 //=============================================================================
1220 /*!
1221  * Gives informations on connectivities of the considered mesh for the entity
1222  * entity.
1223  */
1224 //=============================================================================
1225 SALOME_MED::MESH::connectivityInfos *
1226 SMESH_MEDMesh_i::getConnectGlobal(SALOME_MED::medEntityMesh entity)
1227   throw (SALOME::SALOME_Exception)
1228 {
1229   MESSAGE("!!!! NOT YET IMPLEMENTED !!!!!");
1230
1231   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
1232
1233   return NULL;
1234 }
1235 //=============================================================================
1236 /*!
1237  * Gives the type of the element number of entity entity
1238  */
1239 //=============================================================================
1240 SALOME_MED::medGeometryElement
1241 SMESH_MEDMesh_i::getElementType(SALOME_MED::medEntityMesh entity,
1242                                 CORBA::Long number)
1243   throw (SALOME::SALOME_Exception)
1244 {
1245   MESSAGE("!!!! NOT YET IMPLEMENTED !!!!!");
1246
1247   THROW_SALOME_CORBA_EXCEPTION("Unimplemented Method", SALOME::BAD_PARAM);
1248
1249   return (SALOME_MED::medGeometryElement) 0;
1250 }