]> SALOME platform Git repositories - modules/smesh.git/blob - src/DriverGMF/DriverGMF_Read.cxx
Salome HOME
Correction du cas-test faceGauche2
[modules/smesh.git] / src / DriverGMF / DriverGMF_Read.cxx
1 // Copyright (C) 2007-2021  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, or (at your option) any later version.
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 // File      : DriverGMF_Read.cxx
23 // Created   : Mon Sep 17 17:03:02 2012
24 // Author    : Edward AGAPOV (eap)
25
26 #include "DriverGMF_Read.hxx"
27 #include "DriverGMF.hxx"
28
29 #include "SMESHDS_Group.hxx"
30 #include "SMESHDS_Mesh.hxx"
31 #include "SMESH_Comment.hxx"
32 #include "SMESH_TypeDefs.hxx"
33
34 #include <Basics_Utils.hxx>
35
36 extern "C"
37 {
38 #include "libmesh5.h"
39 }
40
41 #include <stdarg.h>
42
43 // --------------------------------------------------------------------------------
44 DriverGMF_Read::DriverGMF_Read():
45   Driver_SMESHDS_Mesh(),
46   _makeRequiredGroups( true ),
47   _makeFaultGroups( true )
48 {
49 }
50 // --------------------------------------------------------------------------------
51 DriverGMF_Read::~DriverGMF_Read()
52 {
53 }
54
55 //================================================================================
56 /*!
57  * \brief Read a GMF file
58  */
59 //================================================================================
60
61 Driver_Mesh::Status DriverGMF_Read::Perform()
62 {
63   Kernel_Utils::Localizer loc;
64
65   Status status = DRS_OK;
66
67   int dim, version;
68
69   // open the file
70   int meshID = GmfOpenMesh( myFile.c_str(), GmfRead, &version, &dim );
71   if ( !meshID )
72   {
73     if ( DriverGMF::isExtensionCorrect( myFile ))
74       return addMessage( SMESH_Comment("Can't open for reading ") << myFile,
75                          /*fatal=*/true );
76     else
77       return addMessage( SMESH_Comment("Not '.mesh' or '.meshb' extension of file ") << myFile,
78                          /*fatal=*/true );
79   }
80   DriverGMF::MeshCloser aMeshCloser( meshID ); // An object closing GMF mesh at destruction
81
82   // Read nodes
83
84   int nbNodes = GmfStatKwd(meshID, GmfVertices);
85   if ( nbNodes < 1 )
86     return addMessage( "No nodes in the mesh", /*fatal=*/true );
87
88   GmfGotoKwd(meshID, GmfVertices);
89
90   int ref;
91
92   const int nodeIDShift = myMesh->GetMeshInfo().NbNodes();
93   if ( version != GmfFloat )
94   {
95     double x, y, z;
96     for ( int i = 1; i <= nbNodes; ++i )
97     {
98       GmfGetLin(meshID, GmfVertices, &x, &y, &z, &ref);
99       myMesh->AddNodeWithID( x,y,z, nodeIDShift + i);
100     }
101   }
102   else
103   {
104     float x, y, z;
105     for ( int i = 1; i <= nbNodes; ++i )
106     {
107       GmfGetLin(meshID, GmfVertices, &x, &y, &z, &ref);
108       myMesh->AddNodeWithID( x,y,z, nodeIDShift + i);
109     }
110   }
111
112   // Read elements
113
114   int iN[28]; // 28 - nb nodes in HEX27 (+ 1 for safety :)
115
116   /* Read edges */
117   const int edgeIDShift = myMesh->GetMeshInfo().NbElements();
118   if ( int nbEdges = GmfStatKwd(meshID, GmfEdges))
119   {
120     // read extra vertices for quadratic edges
121     std::vector<int> quadNodesAtEdges( nbEdges + 1, -1 );
122     if ( int nbQuadEdges = GmfStatKwd(meshID, GmfExtraVerticesAtEdges))
123     {
124       GmfGotoKwd(meshID, GmfExtraVerticesAtEdges);
125       for ( int i = 1; i <= nbQuadEdges; ++i )
126       {
127         GmfGetLin(meshID, GmfExtraVerticesAtEdges, &iN[0], &iN[1], &iN[2]);
128         if ( iN[1] >= 1 )
129           quadNodesAtEdges[ iN[0] ] = iN[2];
130       }
131     }
132     // create edges
133     GmfGotoKwd(meshID, GmfEdges);
134     for ( int i = 1; i <= nbEdges; ++i )
135     {
136       GmfGetLin(meshID, GmfEdges, &iN[0], &iN[1], &ref);
137       const int midN = quadNodesAtEdges[ i ];
138       if ( midN > 0 )
139       {
140         if ( !myMesh->AddEdgeWithID( iN[0], iN[1], midN, edgeIDShift + i ))
141           status = storeBadNodeIds( "GmfEdges + GmfExtraVerticesAtEdges",i,
142                                     3, iN[0], iN[1], midN);
143       }
144       else
145       {
146         if ( !myMesh->AddEdgeWithID( iN[0], iN[1], edgeIDShift + i ))
147           status = storeBadNodeIds( "GmfEdges",i, 2, iN[0], iN[1] );
148       }
149     }
150   }
151
152   /* Read triangles */
153   const int triaIDShift = myMesh->GetMeshInfo().NbElements();
154   if ( int nbTria = GmfStatKwd(meshID, GmfTriangles))
155   {
156     // read extra vertices for quadratic triangles
157     std::vector< std::vector<int> > quadNodesAtTriangles( nbTria + 1 );
158     if ( int nbQuadTria = GmfStatKwd(meshID, GmfExtraVerticesAtTriangles ))
159     {
160       GmfGotoKwd( meshID, GmfExtraVerticesAtTriangles );
161       for ( int i = 1; i <= nbQuadTria; ++i )
162       {
163         GmfGetLin(meshID, GmfExtraVerticesAtTriangles,
164                   &iN[0], &iN[1], &iN[2], &iN[3], &iN[4],
165                   &iN[5]); // iN[5] - preview TRIA7
166         if ( iN[0] <= nbTria )
167         {
168           std::vector<int>& nodes = quadNodesAtTriangles[ iN[0] ];
169           nodes.insert( nodes.end(), & iN[2], & iN[5+1] );
170           nodes.resize( iN[1] );
171         }
172       }
173     }
174     // create triangles
175     GmfGotoKwd(meshID, GmfTriangles);
176     for ( int i = 1; i <= nbTria; ++i )
177     {
178       GmfGetLin(meshID, GmfTriangles, &iN[0], &iN[1], &iN[2], &ref);
179       std::vector<int>& midN = quadNodesAtTriangles[ i ];
180       if ( midN.size() >= 3 )
181       {
182         if ( !myMesh->AddFaceWithID( iN[0],iN[1],iN[2], midN[0],midN[1],midN[2],
183                                      triaIDShift + i ))
184           status = storeBadNodeIds( "GmfTriangles + GmfExtraVerticesAtTriangles",i, 6,
185                                     iN[0],iN[1],iN[2], midN[0],midN[1],midN[2] );
186       }
187       else
188       {
189         if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], triaIDShift + i ))
190           status = storeBadNodeIds( "GmfTriangles",i, 3, iN[0], iN[1], iN[2] );
191       }
192       if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
193     }
194   }
195
196   /* Read quadrangles */
197   const int quadIDShift = myMesh->GetMeshInfo().NbElements();
198   if ( int nbQuad = GmfStatKwd(meshID, GmfQuadrilaterals))
199   {
200     // read extra vertices for quadratic quadrangles
201     std::vector< std::vector<int> > quadNodesAtQuadrilaterals( nbQuad + 1 );
202     if ( int nbQuadQuad = GmfStatKwd( meshID, GmfExtraVerticesAtQuadrilaterals ))
203     {
204       GmfGotoKwd(meshID, GmfExtraVerticesAtQuadrilaterals);
205       for ( int i = 1; i <= nbQuadQuad; ++i )
206       {
207         GmfGetLin(meshID, GmfExtraVerticesAtQuadrilaterals,
208                   &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &iN[6]);
209         if ( iN[0] <= nbQuad )
210         {
211           std::vector<int>& nodes = quadNodesAtQuadrilaterals[ iN[0] ];
212           nodes.insert( nodes.end(), & iN[2], & iN[6+1] );
213           nodes.resize( iN[1] );
214         }
215       }
216     }
217     // create quadrangles
218     GmfGotoKwd(meshID, GmfQuadrilaterals);
219     for ( int i = 1; i <= nbQuad; ++i )
220     {
221       GmfGetLin(meshID, GmfQuadrilaterals, &iN[0], &iN[1], &iN[2], &iN[3], &ref);
222       std::vector<int>& midN = quadNodesAtQuadrilaterals[ i ];
223       if ( midN.size() == 8-4 ) // QUAD8
224       {
225         if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3],
226                                      midN[0], midN[1], midN[2], midN[3],
227                                      quadIDShift + i ))
228           status = storeBadNodeIds( "GmfQuadrilaterals + GmfExtraVerticesAtQuadrilaterals",i, 8,
229                                     iN[0], iN[1],iN[2], iN[3],
230                                     midN[0], midN[1], midN[2], midN[3]);
231       }
232       else if ( midN.size() > 8-4 ) // QUAD9
233       {
234         if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3],
235                                      midN[0], midN[1], midN[2], midN[3], midN[4],
236                                      quadIDShift + i ))
237           status = storeBadNodeIds( "GmfQuadrilaterals + GmfExtraVerticesAtQuadrilaterals",i, 9,
238                                     iN[0], iN[1],iN[2], iN[3],
239                                     midN[0], midN[1], midN[2], midN[3], midN[4]);
240       }
241       else // QUAD4
242       {
243         if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3], quadIDShift + i ))
244           status = storeBadNodeIds( "GmfQuadrilaterals",i, 4, iN[0], iN[1],iN[2], iN[3] );
245       }
246       if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
247     }
248   }
249
250   /* Read terahedra */
251   const int tetIDShift = myMesh->GetMeshInfo().NbElements();
252   if ( int nbTet = GmfStatKwd( meshID, GmfTetrahedra ))
253   {
254     // read extra vertices for quadratic tetrahedra
255     std::vector< std::vector<int> > quadNodesAtTetrahedra( nbTet + 1 );
256     if ( int nbQuadTetra = GmfStatKwd( meshID, GmfExtraVerticesAtTetrahedra ))
257     {
258       GmfGotoKwd(meshID, GmfExtraVerticesAtTetrahedra);
259       for ( int i = 1; i <= nbQuadTetra; ++i )
260       {
261         GmfGetLin(meshID, GmfExtraVerticesAtTetrahedra,
262                   &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &iN[6], &iN[7]);
263         if ( iN[0] <= nbTet )
264         {
265           std::vector<int>& nodes = quadNodesAtTetrahedra[ iN[0] ];
266           nodes.insert( nodes.end(), & iN[2], & iN[7+1] );
267           nodes.resize( iN[1] );
268         }
269       }
270     }
271     // create tetrahedra
272     GmfGotoKwd(meshID, GmfTetrahedra);
273     for ( int i = 1; i <= nbTet; ++i )
274     {
275       GmfGetLin(meshID, GmfTetrahedra, &iN[0], &iN[1], &iN[2], &iN[3], &ref);
276       std::vector<int>& midN = quadNodesAtTetrahedra[ i ];  
277       if ( midN.size() >= 10-4 ) // TETRA10
278       {
279         if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], 
280                                        midN[2], midN[1], midN[0], midN[3], midN[5], midN[4],
281                                        tetIDShift + i ))
282           status = storeBadNodeIds( "GmfTetrahedra + GmfExtraVerticesAtTetrahedra",i, 10,
283                                     iN[0], iN[2], iN[1], iN[3], 
284                                     midN[2], midN[1], midN[0], midN[3], midN[5], midN[4] );
285       }
286       else // TETRA4
287       {
288         if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], tetIDShift + i ))
289           status = storeBadNodeIds( "GmfTetrahedra" ,i, 4, iN[0], iN[2], iN[1], iN[3] );
290       }
291       if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
292     }
293   }
294
295   /* Read pyramids */
296   const int pyrIDShift = myMesh->GetMeshInfo().NbElements();
297   if ( int nbPyr = GmfStatKwd(meshID, GmfPyramids))
298   {
299     GmfGotoKwd(meshID, GmfPyramids);
300     for ( int i = 1; i <= nbPyr; ++i )
301     {
302       GmfGetLin(meshID, GmfPyramids, &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &ref);
303       if ( !myMesh->AddVolumeWithID( iN[3], iN[2], iN[1], iN[0], iN[4], pyrIDShift + i ))
304         status = storeBadNodeIds( "GmfPyramids",i, 5, iN[0], iN[1],iN[2], iN[3], iN[4] );
305     }
306   }
307
308   /* Read hexahedra */
309   const int hexIDShift = myMesh->GetMeshInfo().NbElements();
310   if ( int nbHex = GmfStatKwd(meshID, GmfHexahedra))
311   {
312     // read extra vertices for quadratic hexahedra
313     std::vector< std::vector<int> > quadNodesAtHexahedra( nbHex + 1 );
314     if ( int nbQuadHexa = GmfStatKwd( meshID, GmfExtraVerticesAtHexahedra ))
315     {
316       GmfGotoKwd(meshID, GmfExtraVerticesAtHexahedra);
317       for ( int i = 1; i <= nbQuadHexa; ++i )
318       {
319         GmfGetLin(meshID, GmfExtraVerticesAtHexahedra, &iN[0], &iN[1], // Hexa Id, Nb extra vertices
320                   &iN[2], &iN[3], &iN[4], &iN[5],
321                   &iN[6], &iN[7], &iN[8], &iN[9],
322                   &iN[10], &iN[11], &iN[12], &iN[13], // HEXA20
323                   &iN[14],
324                   &iN[15], &iN[16], &iN[17], &iN[18], 
325                   &iN[19],
326                   &iN[20]);                          // HEXA27
327         if ( iN[0] <= nbHex )
328         {
329           std::vector<int>& nodes = quadNodesAtHexahedra[ iN[0] ];
330           nodes.insert( nodes.end(), & iN[2], & iN[20+1] );
331           nodes.resize( iN[1] );
332         }
333       }
334     }
335     // create hexhedra
336     GmfGotoKwd(meshID, GmfHexahedra);
337     for ( int i = 1; i <= nbHex; ++i )
338     {
339       GmfGetLin(meshID, GmfHexahedra, &iN[0], &iN[1], &iN[2], &iN[3],
340                 &iN[4], &iN[5], &iN[6], &iN[7], &ref);
341       std::vector<int>& midN = quadNodesAtHexahedra[ i ];
342       if ( midN.size() == 20-8 ) // HEXA20
343       {
344         if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
345                                        iN[4], iN[7], iN[6], iN[5],
346                                        midN[3], midN[2], midN[1], midN[0],
347                                        midN[7], midN[6], midN[5], midN[4],
348                                        midN[8], midN[11], midN[10], midN[9],
349                                        hexIDShift + i ))
350           status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 20, 
351                                     iN[0], iN[3], iN[2], iN[1],
352                                     iN[4], iN[7], iN[6], iN[5],
353                                     midN[3], midN[2], midN[1], midN[0],
354                                     midN[7], midN[6], midN[5], midN[4],
355                                     midN[8], midN[11], midN[10], midN[9]);
356       }
357       else if ( midN.size() >= 27-8 ) // HEXA27
358       {
359         if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
360                                        iN[4], iN[7], iN[6], iN[5],
361                                        midN[3], midN[2], midN[1], midN[0],
362                                        midN[7], midN[6], midN[5], midN[4],
363                                        midN[8], midN[11], midN[10], midN[9],
364                                        midN[12],
365                                        midN[16], midN[15], midN[14], midN[13],
366                                        midN[17],
367                                        midN[18],
368                                        hexIDShift + i ))
369           status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 27, 
370                                     iN[0], iN[3], iN[2], iN[1],
371                                     iN[4], iN[7], iN[6], iN[5],
372                                     midN[3], midN[2], midN[1], midN[0],
373                                     midN[7], midN[6], midN[5], midN[4],
374                                     midN[8], midN[11], midN[10], midN[9],
375                                     midN[12],
376                                     midN[16], midN[15], midN[14], midN[13],
377                                     midN[17],
378                                     midN[18]);
379       }
380       else // HEXA8
381       {
382         if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
383                                        iN[4], iN[7], iN[6], iN[5], hexIDShift + i ) )
384           status = storeBadNodeIds( "GmfHexahedra" ,i, 8, iN[0], iN[3], iN[2], iN[1],
385                                     iN[4], iN[7], iN[6], iN[5] );
386       }
387       if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
388     }
389   }
390
391   /* Read prism */
392   const int prismIDShift = myMesh->GetMeshInfo().NbElements();
393   if ( int nbPrism = GmfStatKwd(meshID, GmfPrisms))
394   {
395     GmfGotoKwd(meshID, GmfPrisms);
396     for ( int i = 1; i <= nbPrism; ++i )
397     {
398       GmfGetLin(meshID, GmfPrisms, &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &ref);
399       if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], iN[5], iN[4], prismIDShift + i))
400         status = storeBadNodeIds( "GmfPrisms",i,
401                                   6, iN[0], iN[1],iN[2], iN[3], iN[4], iN[5] );
402     }
403   }
404
405   // Read some entities into groups
406   // see MeshGems/Docs/meshgems_formats_description.pdf
407
408     // get ids of existing groups
409     std::set< int > groupIDs;
410     const std::set<SMESHDS_GroupBase*>&          groups = myMesh->GetGroups();
411     std::set<SMESHDS_GroupBase*>::const_iterator grIter = groups.begin();
412     for ( ; grIter != groups.end(); ++grIter )
413       groupIDs.insert( (*grIter)->GetID() );
414     if ( groupIDs.empty() ) groupIDs.insert( 0 );
415
416   // Read required entities into groups
417   if ( _makeRequiredGroups )
418   {
419
420     const int kes[4][3] = { { GmfRequiredVertices,      SMDSAbs_Node, nodeIDShift },
421                             { GmfRequiredEdges,         SMDSAbs_Edge, edgeIDShift },
422                             { GmfRequiredTriangles,     SMDSAbs_Face, triaIDShift },
423                             { GmfRequiredQuadrilaterals,SMDSAbs_Face, quadIDShift }
424                           };
425     const char* names[4] = { "_required_Vertices"      ,
426                              "_required_Edges"         ,
427                              "_required_Triangles"     ,
428                              "_required_Quadrilaterals" 
429                            };
430     for ( int i = 0; i < 4; ++i )
431     {
432       int                 gmfKwd = kes[i][0];
433       SMDSAbs_ElementType entity = (SMDSAbs_ElementType) kes[i][1];
434       int                 shift  = kes[i][2];
435       if ( int nb = GmfStatKwd(meshID, gmfKwd))
436       {
437         const int newID = *groupIDs.rbegin() + 1;
438         groupIDs.insert( newID );
439         SMESHDS_Group* group = new SMESHDS_Group( newID, myMesh, entity );
440         group->SetStoreName( names[i] );
441         myMesh->AddGroup( group );
442
443         GmfGotoKwd(meshID, gmfKwd);
444         for ( int i = 0; i < nb; ++i )
445         {
446           GmfGetLin(meshID, gmfKwd, &iN[0] );
447           group->Add( shift + iN[0] );
448         }
449       }
450     }
451   }
452
453   // Read fault entities into groups
454   if ( _makeFaultGroups )
455   {
456
457     const int kes[7][3] = { { GmfFault_SmallTri,     SMDSAbs_Face, triaIDShift },
458                             { GmfFault_BadShape,     SMDSAbs_Face, triaIDShift },
459                             { GmfFault_Overlap,      SMDSAbs_Face, triaIDShift },
460                             { GmfFault_Inter,        SMDSAbs_Face, triaIDShift },
461                             { GmfFault_NearTri,      SMDSAbs_Face, triaIDShift },
462                             { GmfFault_FreeEdge,     SMDSAbs_Face, triaIDShift },
463                             { GmfFault_MultipleEdge, SMDSAbs_Face, triaIDShift }
464                           };
465     const char* names[7] = { "Fault_SmallTri",
466                              "Fault_BadShape",
467                              "Fault_Overlap",
468                              "Fault_Inter", 
469                              "Fault_NearTri",
470                              "Fault_FreeEdge",
471                              "Fault_MultipleEdge"
472                            };
473     for ( int i = 0; i < 7; ++i )
474     {
475       int                 gmfKwd = kes[i][0];
476       SMDSAbs_ElementType entity = (SMDSAbs_ElementType) kes[i][1];
477       int                 shift  = kes[i][2];
478       if ( int nb = GmfStatKwd(meshID, gmfKwd))
479       {
480         const int newID = *groupIDs.rbegin() + 1;
481         groupIDs.insert( newID );
482         SMESHDS_Group* group = new SMESHDS_Group( newID, myMesh, entity );
483         group->SetStoreName( names[i] );
484         myMesh->AddGroup( group );
485
486         GmfGotoKwd(meshID, gmfKwd);
487         for ( int i = 0; i < nb; ++i )
488         {
489           GmfGetLin(meshID, gmfKwd, &iN[0] );
490           group->Add( shift + iN[0] );
491         }
492       }
493     }
494   }
495
496
497   myMesh->Modified();
498   myMesh->CompactMesh();
499
500   return status;
501 }
502
503 //================================================================================
504 /*!
505  * \brief Store a message about invalid IDs of nodes
506  */
507 //================================================================================
508
509 Driver_Mesh::Status DriverGMF_Read::storeBadNodeIds(const char* gmfKwd, int elemNb, int nb, ...)
510 {
511   if ( myStatus != DRS_OK )
512     return myStatus;
513
514   SMESH_Comment msg;
515
516   va_list VarArg;
517   va_start(VarArg, nb);
518
519   for ( int i = 0; i < nb; ++i )
520   {
521     int id = va_arg(VarArg, int );
522     if ( !myMesh->FindNode( id ))
523       msg << " " << id;
524   }
525   va_end(VarArg);
526
527   if ( !msg.empty() )
528   {
529     std::string nbStr;
530     const char* nbNames[] = { "1-st ", "2-nd ", "3-d " };
531     if ( elemNb < 3 ) nbStr = nbNames[ elemNb-1 ];
532     else              nbStr = SMESH_Comment(elemNb) << "-th ";
533
534     return addMessage
535       ( SMESH_Comment("Wrong node IDs of ")<< nbStr << gmfKwd << ":" << msg,
536         /*fatal=*/false );
537   }
538   return DRS_OK;
539 }