1 // Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
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.
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.
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
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : DriverCGNS_Write.cxx
23 // Created : Fri Aug 5 17:43:54 2011
24 // Author : Edward AGAPOV (eap)
26 #include "DriverCGNS_Write.hxx"
28 #include "SMDS_MeshNode.hxx"
29 #include "SMDS_VolumeTool.hxx"
30 #include "SMESHDS_GroupBase.hxx"
31 #include "SMESHDS_Mesh.hxx"
32 #include "SMESH_Comment.hxx"
37 #if CGNS_VERSION < 3100
45 //================================================================================
47 * \brief Return interlace and type of CGNS element for the given SMDSAbs_EntityType
49 //================================================================================
51 const int* getInterlaceAndType( const SMDSAbs_EntityType smType,
52 CGNS_ENUMT( ElementType_t ) & cgType )
54 static vector< const int* > interlaces;
55 static vector< CGNS_ENUMT( ElementType_t )> cgTypes;
56 if ( interlaces.empty() )
58 interlaces.resize( SMDSEntity_Last, 0 );
59 cgTypes.resize( SMDSEntity_Last, CGNS_ENUMV( ElementTypeNull ));
61 static int ids[] = {0};
62 interlaces[SMDSEntity_0D] = ids;
63 cgTypes [SMDSEntity_0D] = CGNS_ENUMV( NODE );
66 static int ids[] = { 0, 1 };
67 interlaces[SMDSEntity_Edge] = ids;
68 cgTypes [SMDSEntity_Edge] = CGNS_ENUMV( BAR_2 );
71 static int ids[] = { 0, 1, 2 };
72 interlaces[SMDSEntity_Quad_Edge] = ids;
73 cgTypes [SMDSEntity_Quad_Edge] = CGNS_ENUMV( BAR_3 );
76 static int ids[] = { 0, 2, 1 };
77 interlaces[SMDSEntity_Triangle] = ids;
78 cgTypes [SMDSEntity_Triangle] = CGNS_ENUMV( TRI_3 );
81 static int ids[] = { 0, 2, 1, 5, 4, 3 };
82 interlaces[SMDSEntity_Quad_Triangle] = ids;
83 cgTypes [SMDSEntity_Quad_Triangle] = CGNS_ENUMV( TRI_6 );
84 interlaces[SMDSEntity_BiQuad_Triangle] = ids;
85 cgTypes [SMDSEntity_BiQuad_Triangle] = CGNS_ENUMV( TRI_6 );
88 static int ids[] = { 0, 3, 2, 1 };
89 interlaces[SMDSEntity_Quadrangle] = ids;
90 cgTypes [SMDSEntity_Quadrangle] = CGNS_ENUMV( QUAD_4 );
93 static int ids[] = { 0,3,2,1,7,6,5,4 };
94 interlaces[SMDSEntity_Quad_Quadrangle] = ids;
95 cgTypes [SMDSEntity_Quad_Quadrangle] = CGNS_ENUMV( QUAD_8 );
98 static int ids[] = { 0,3,2,1,7,6,5,4,8 };
99 interlaces[SMDSEntity_BiQuad_Quadrangle] = ids;
100 cgTypes [SMDSEntity_BiQuad_Quadrangle] = CGNS_ENUMV( QUAD_9 );
103 static int ids[] = { 0, 2, 1, 3 };
104 interlaces[SMDSEntity_Tetra] = ids;
105 cgTypes [SMDSEntity_Tetra] = CGNS_ENUMV( TETRA_4 );
108 static int ids[] = { 0,2,1,3,6,5,4,7,9,8 };
109 interlaces[SMDSEntity_Quad_Tetra] = ids;
110 cgTypes [SMDSEntity_Quad_Tetra] = CGNS_ENUMV( TETRA_10 );
113 static int ids[] = { 0,3,2,1,4 };
114 interlaces[SMDSEntity_Pyramid] = ids;
115 cgTypes [SMDSEntity_Pyramid] = CGNS_ENUMV( PYRA_5 );
118 static int ids[] = { 0,3,2,1,4,8,7,6,5,9,12,11,10 };
119 interlaces[SMDSEntity_Quad_Pyramid] = ids;
120 cgTypes [SMDSEntity_Quad_Pyramid] = CGNS_ENUMV( PYRA_13 );
123 static int ids[] = { 0,2,1,3,5,4 };
124 interlaces[SMDSEntity_Penta] = ids;
125 cgTypes [SMDSEntity_Penta] = CGNS_ENUMV( PENTA_6 );
128 static int ids[] = { 0,2,1,3,5,4,8,7,6,9,11,10,14,13,12 };
129 interlaces[SMDSEntity_Quad_Penta] = ids;
130 cgTypes [SMDSEntity_Quad_Penta] = CGNS_ENUMV( PENTA_15 );
133 static int ids[] = { 0,3,2,1,4,7,6,5 };
134 interlaces[SMDSEntity_Hexa] = ids;
135 cgTypes [SMDSEntity_Hexa] = CGNS_ENUMV( HEXA_8 );
138 static int ids[] = { 0,3,2,1,4,7,6,5,11,10,9,8,12,15,14,13,19,18,17,16 };
139 interlaces[SMDSEntity_Quad_Hexa] = ids;
140 cgTypes [SMDSEntity_Quad_Hexa] = CGNS_ENUMV( HEXA_20 );
143 static int ids[] = { 0,3,2,1,4,7,6,5,11,10,9,8,12,15,14,13,19,18,17,16,
144 20, 24,23,22,21, 25, 26};
145 interlaces[SMDSEntity_TriQuad_Hexa] = ids;
146 cgTypes [SMDSEntity_TriQuad_Hexa] = CGNS_ENUMV( HEXA_27 );
149 cgTypes[SMDSEntity_Polygon] = CGNS_ENUMV( NGON_n );
150 cgTypes[SMDSEntity_Polyhedra] = CGNS_ENUMV( NFACE_n );
151 cgTypes[SMDSEntity_Hexagonal_Prism] = CGNS_ENUMV( NFACE_n );
154 cgType = cgTypes[ smType ];
155 return interlaces[ smType ];
158 //================================================================================
160 * \brief Cut off type of boundary condition from the group name
162 //================================================================================
164 CGNS_ENUMT( BCType_t ) getBCType( string& groupName )
166 CGNS_ENUMT( BCType_t ) bcType = CGNS_ENUMV( BCGeneral ); // default type
168 // boundary condition type starts from "BC"
169 size_t bcBeg = groupName.find("BC");
170 if ( bcBeg != string::npos )
172 for ( int t = 0; t < NofValidBCTypes; ++t )
174 CGNS_ENUMT( BCType_t ) type = CGNS_ENUMT( BCType_t)( t );
175 string typeName = cg_BCTypeName( type );
176 if ( typeName == &groupName[0] + bcBeg )
179 while ( bcBeg > 0 && isspace( bcBeg-1 ))
184 groupName = groupName.substr( 0, bcBeg-1 );
191 //================================================================================
193 * \brief Sortable face of a polyhedron
197 int _id; // id of NGON_n
198 vector< int > _nodes; // lowest node IDs used for sorting
200 TPolyhedFace( const SMDS_MeshNode** nodes, const int nbNodes, int ID):_id(ID)
203 for ( int i = 0; i < nbNodes; ++i )
204 ids.insert( nodes[i]->GetID() );
206 _nodes.resize( 3 ); // std::min( nbNodes, 4 )); hope 3 nodes is enough
207 set< int >::iterator idIt = ids.begin();
208 for ( size_t j = 0; j < _nodes.size(); ++j, ++idIt )
211 bool operator< (const TPolyhedFace& o ) const
213 return _nodes < o._nodes;
216 //================================================================================
218 * \brief Return CGNS id of an element
220 //================================================================================
222 cgsize_t cgnsID( const SMDS_MeshElement* elem,
223 const map< const SMDS_MeshElement*, cgsize_t >& elem2cgID )
225 map< const SMDS_MeshElement*, cgsize_t >::const_iterator e2id = elem2cgID.find( elem );
226 return ( e2id == elem2cgID.end() ? elem->GetID() : e2id->second );
231 //================================================================================
233 * \brief Write the mesh into the CGNS file
235 //================================================================================
237 Driver_Mesh::Status DriverCGNS_Write::Perform()
239 myErrorMessages.clear();
241 if ( !myMesh || myMesh->GetMeshInfo().NbElements() < 1 )
242 return addMessage( !myMesh ? "NULL mesh" : "Empty mesh (no elements)", /*fatal = */true );
245 if ( cg_open(myFile.c_str(), CG_MODE_MODIFY, &_fn) != CG_OK &&
246 cg_open(myFile.c_str(), CG_MODE_WRITE, &_fn) != CG_OK )
247 return addMessage( cg_get_error(), /*fatal = */true );
252 const int spaceDim = 3;
254 if ( myMesh->NbFaces() > 0 ) meshDim = 2;
255 if ( myMesh->NbVolumes() > 0 ) meshDim = 3;
257 if ( myMeshName.empty() )
260 if ( cg_nbases( _fn, &nbases) == CG_OK)
261 myMeshName = ( SMESH_Comment("Base_") << nbases+1 );
263 myMeshName = "Base_0";
266 if ( cg_base_write( _fn, myMeshName.c_str(), meshDim, spaceDim, &iBase))
267 return addMessage( cg_get_error(), /*fatal = */true );
272 int nbCells = myMesh->NbEdges();
274 nbCells = myMesh->NbVolumes();
275 else if ( meshDim == 2 )
276 nbCells = myMesh->NbFaces();
278 cgsize_t size[9] = { myMesh->NbNodes(), nbCells, /*NBoundVertex=*/0, 0,0,0,0,0,0 };
280 if ( cg_zone_write( _fn, iBase, "SMESH_Mesh", size,
281 CGNS_ENUMV( Unstructured ), &iZone) != CG_OK )
282 return addMessage( cg_get_error(), /*fatal = */true );
284 // Map to store only elements whose an SMDS ID differs from a CGNS one
285 typedef map< const SMDS_MeshElement*, cgsize_t > TElem2cgIDMap;
286 vector< TElem2cgIDMap > elem2cgIDByEntity( SMDSEntity_Last );
287 TElem2cgIDMap::iterator elem2cgIDIter;
289 TElem2cgIDMap & n2cgID = elem2cgIDByEntity[ SMDSEntity_Node ];
294 vector< double > coords( myMesh->NbNodes() );
297 SMDS_NodeIteratorPtr nIt = myMesh->nodesIterator( /*idInceasingOrder=*/true );
298 for ( int i = 0; nIt->more(); ++i ) coords[i] = nIt->next()->X();
299 if ( cg_coord_write( _fn, iBase, iZone, CGNS_ENUMV(RealDouble),
300 "CoordinateX", &coords[0], &iC) != CG_OK )
301 return addMessage( cg_get_error(), /*fatal = */true );
303 nIt = myMesh->nodesIterator( /*idInceasingOrder=*/true );
304 for ( int i = 0; nIt->more(); ++i ) coords[i] = nIt->next()->Y();
305 if ( cg_coord_write( _fn, iBase, iZone, CGNS_ENUMV(RealDouble),
306 "CoordinateY", &coords[0], &iC) != CG_OK )
307 return addMessage( cg_get_error(), /*fatal = */true );
309 nIt = myMesh->nodesIterator( /*idInceasingOrder=*/true );
310 for ( int i = 0; nIt->more(); ++i ) coords[i] = nIt->next()->Z();
311 if ( cg_coord_write( _fn, iBase, iZone, CGNS_ENUMV(RealDouble),
312 "CoordinateZ", &coords[0], &iC) != CG_OK )
313 return addMessage( cg_get_error(), /*fatal = */true );
315 // store CGNS ids of nodes
316 nIt = myMesh->nodesIterator( /*idInceasingOrder=*/true );
317 for ( int i = 0; nIt->more(); ++i )
319 const SMDS_MeshElement* n = nIt->next();
320 if ( n->GetID() != i+1 )
321 n2cgID.insert( n2cgID.end(), make_pair( n, i+1 ));
327 cgsize_t cgID = 1, startID;
329 // write into a section all successive elements of one geom type
331 vector< cgsize_t > elemData;
332 SMDS_ElemIteratorPtr elemIt = myMesh->elementsIterator();
333 const SMDS_MeshElement* elem = elemIt->next();
336 const SMDSAbs_EntityType elemType = elem->GetEntityType();
337 CGNS_ENUMT( ElementType_t ) cgType;
338 const int* interlace = getInterlaceAndType( elemType, cgType );
340 TElem2cgIDMap & elem2cgID = elem2cgIDByEntity[ elemType ];
345 if ( interlace ) // STANDARD elements
347 int cgnsNbNodes; // get nb nodes by element type, that can be less that elem->NbNodes()
348 cg_npe( cgType, &cgnsNbNodes );
351 for ( int i = 0; i < cgnsNbNodes; ++i )
352 elemData.push_back( cgnsID( elem->GetNode( interlace[i] ), n2cgID ));
353 if ( elem->GetID() != cgID )
354 elem2cgID.insert( elem2cgID.end(), make_pair( elem, cgID ));
356 elem = elemIt->more() ? elemIt->next() : 0;
358 while ( elem && elem->GetEntityType() == elemType );
360 else if ( elemType == SMDSEntity_Polygon ) // POLYGONS
363 elemData.push_back( elem->NbNodes() );
364 for ( int i = 0, nb = elem->NbNodes(); i < nb; ++i )
365 elemData.push_back( cgnsID( elem->GetNode(i), n2cgID ));
366 if ( elem->GetID() != cgID )
367 elem2cgID.insert( elem2cgID.end(), make_pair( elem, cgID ));
369 elem = elemIt->more() ? elemIt->next() : 0;
371 while ( elem && elem->GetEntityType() == elemType );
373 else if ( elemType == SMDSEntity_Polyhedra ||
374 elemType == SMDSEntity_Hexagonal_Prism) // POLYHEDRA
376 // to save polyhedrons after all
377 const SMDS_MeshInfo& meshInfo = myMesh->GetMeshInfo();
378 if ( meshInfo.NbPolyhedrons() == meshInfo.NbElements() - cgID + 1 )
379 break; // only polyhedrons remain
380 while ( elem && elem->GetEntityType() == elemType )
381 elem = elemIt->more() ? elemIt->next() : 0;
385 SMESH_Comment sectionName( cg_ElementTypeName( cgType ));
386 sectionName << " " << startID << " - " << cgID-1;
388 if ( cg_section_write(_fn, iBase, iZone, sectionName.c_str(), cgType, startID,
389 cgID-1, /*nbndry=*/0, &elemData[0], &iSec) != CG_OK )
390 return addMessage( cg_get_error(), /*fatal = */true );
392 // Write polyhedral volumes
393 // -------------------------
395 if ( myMesh->GetMeshInfo().NbElements() > cgID-1 ) // polyhedra or hexagonal prisms remain
397 // the polyhedron (NFACE_n) is described as a set of signed face IDs,
398 // so first we are to write all polygones (NGON_n) bounding polyhedrons
400 vector< cgsize_t > faceData;
401 set< TPolyhedFace > faces;
402 set< TPolyhedFace >::iterator faceInSet;
403 vector<const SMDS_MeshNode *> faceNodesVec;
404 int nbPolygones = 0, faceID;
410 int nbPolyhTreated = 0;
412 TElem2cgIDMap * elem2cgID = 0;
413 TElem2cgIDMap & n2cgID = elem2cgIDByEntity[ SMDSEntity_Node ];
415 SMDS_ElemIteratorPtr elemIt = myMesh->elementsIterator();
416 while ( elemIt->more() )
418 elem = elemIt->next();
419 SMDSAbs_EntityType type = elem->GetEntityType();
420 if ( type == SMDSEntity_Polyhedra ||
421 type == SMDSEntity_Hexagonal_Prism )
425 vol.SetExternalNormal();
426 const int nbFaces = vol.NbFaces();
427 elemData.push_back( nbFaces );
428 for ( int iF = 0; iF < nbFaces; ++iF )
430 const int nbNodes = vol.NbFaceNodes( iF );
431 const SMDS_MeshNode** faceNodes = vol.GetFaceNodes( iF );
432 faceNodesVec.assign( faceNodes, faceNodes + nbNodes );
433 if (( elem = myMesh->FindElement( faceNodesVec, SMDSAbs_Face, /*noMedium=*/false)))
435 // a face of the polyhedron is present in the mesh
436 faceID = cgnsID( elem, elem2cgIDByEntity[ elem->GetEntityType() ]);
438 else if ( vol.IsFreeFace( iF ))
440 // the face is not shared by volumes
443 faceData.push_back( nbNodes );
444 for ( int i = 0; i < nbNodes; ++i )
445 faceData.push_back( cgnsID( faceNodes[i], n2cgID ));
449 TPolyhedFace face( faceNodes, nbNodes, cgID );
450 faceInSet = faces.insert( faces.end(), face );
451 if ( faceInSet->_id == cgID ) // the face encounters for the 1st time
455 faceData.push_back( nbNodes );
456 for ( int i = 0; i < nbNodes; ++i )
457 faceData.push_back( cgnsID( faceNodes[i], n2cgID ));
461 // the face encounters for the 2nd time; we hope it won't encounter once more,
462 // for that we can erase it from the set of faces
463 faceID = -faceInSet->_id;
464 faces.erase( faceInSet );
467 elemData.push_back( faceID );
472 if ( nbPolygones > 0 )
474 if ( cg_section_write(_fn, iBase, iZone, "Faces of Polyhedrons",
475 CGNS_ENUMV( NGON_n ), cgID - nbPolygones, cgID-1,
476 /*nbndry=*/0, &faceData[0], &iSec) != CG_OK )
477 return addMessage( cg_get_error(), /*fatal = */true );
480 if ( cg_section_write(_fn, iBase, iZone, "Polyhedrons",
481 CGNS_ENUMV( NFACE_n ), cgID, cgID+nbPolyhTreated-1,
482 /*nbndry=*/0, &elemData[0], &iSec) != CG_OK )
483 return addMessage( cg_get_error(), /*fatal = */true );
485 if ( !myMesh->GetGroups().empty() )
487 // store CGNS ids of polyhedrons
488 elem2cgID = &elem2cgIDByEntity[ SMDSEntity_Polyhedra ];
489 elemIt = myMesh->elementsIterator();
490 while ( elemIt->more() )
492 elem = elemIt->next();
493 if ( elem->GetEntityType() == SMDSEntity_Polyhedra )
495 if ( elem->GetID() != cgID )
496 elem2cgID->insert( elem2cgID->end(), make_pair( elem, cgID ));
501 } // write polyhedral volumes
504 // Write groups as boundary conditions
505 // ------------------------------------
507 const set<SMESHDS_GroupBase*>& groups = myMesh->GetGroups();
508 set<SMESHDS_GroupBase*>::const_iterator grpIt = groups.begin();
509 set< string > groupNames; groupNames.insert(""); // to avoid duplicated and empty names
510 for ( ; grpIt != groups.end(); ++grpIt )
512 const SMESHDS_GroupBase* group = *grpIt;
514 // write BC location (default is Vertex)
515 CGNS_ENUMT( GridLocation_t ) location = CGNS_ENUMV( Vertex );
516 if ( group->GetType() != SMDSAbs_Node )
520 switch ( group->GetType() ) {
521 case SMDSAbs_Volume: location = CGNS_ENUMV( FaceCenter ); break; // !!!
522 case SMDSAbs_Face: location = CGNS_ENUMV( FaceCenter ); break; // OK
523 case SMDSAbs_Edge: location = CGNS_ENUMV( EdgeCenter ); break; // OK
528 switch ( group->GetType() ) {
529 case SMDSAbs_Face: location = CGNS_ENUMV( FaceCenter ); break; // ???
530 case SMDSAbs_Edge: location = CGNS_ENUMV( EdgeCenter ); break; // OK
535 location = CGNS_ENUMV( EdgeCenter ); break; // ???
540 // try to extract type of boundary condition from the group name
541 string name = group->GetStoreName();
542 CGNS_ENUMT( BCType_t ) bcType = getBCType( name );
543 while ( !groupNames.insert( name ).second )
544 name = (SMESH_Comment( "Group_") << groupNames.size());
546 // write IDs of elements
547 vector< cgsize_t > pnts;
548 pnts.reserve( group->Extent() );
549 SMDS_ElemIteratorPtr elemIt = group->GetElements();
550 while ( elemIt->more() )
552 const SMDS_MeshElement* elem = elemIt->next();
553 pnts.push_back( cgnsID( elem, elem2cgIDByEntity[ elem->GetEntityType() ]));
556 if ( cg_boco_write( _fn, iBase, iZone, name.c_str(), bcType,
557 CGNS_ENUMV( PointList ), pnts.size(), &pnts[0], &iBC) != CG_OK )
558 return addMessage( cg_get_error(), /*fatal = */true);
561 if ( location != CGNS_ENUMV( Vertex ))
563 if ( cg_boco_gridlocation_write( _fn, iBase, iZone, iBC, location) != CG_OK )
564 return addMessage( cg_get_error(), /*fatal = */false);
570 //================================================================================
574 //================================================================================
576 DriverCGNS_Write::DriverCGNS_Write(): _fn(0)
580 //================================================================================
582 * \brief Close the cgns file at destruction
584 //================================================================================
586 DriverCGNS_Write::~DriverCGNS_Write()