src/SMESH_I/SMESH_MEDMesh_i.cxx

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