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