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