1 // SMESH DriverMED : driver to read and write 'med' files
3 // Copyright (C) 2003 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
24 // File : DriverMED_W_SMESHDS_Mesh.cxx
29 #include "DriverMED_W_SMESHDS_Mesh.h"
30 #include "DriverMED_W_SMDS_Mesh.h"
31 #include "DriverMED_Family.h"
33 #include "SMESHDS_Mesh.hxx"
34 #include "SMDS_MeshElement.hxx"
35 #include "SMDS_MeshNode.hxx"
36 #include "utilities.h"
38 #include "MEDA_Wrapper.hxx"
39 #include "MED_Utilities.hxx"
41 #define _EDF_NODE_IDS_
42 //#define _ELEMENTS_BY_DIM_
46 DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
47 myAllSubMeshes (false),
48 myDoGroupOfNodes (false),
49 myDoGroupOfEdges (false),
50 myDoGroupOfFaces (false),
51 myDoGroupOfVolumes (false)
54 void DriverMED_W_SMESHDS_Mesh::SetMeshName(const std::string& theMeshName)
56 myMeshName = theMeshName;
59 void DriverMED_W_SMESHDS_Mesh::AddGroup(SMESHDS_GroupBase* theGroup)
61 myGroups.push_back(theGroup);
64 void DriverMED_W_SMESHDS_Mesh::AddAllSubMeshes()
66 myAllSubMeshes = true;
69 void DriverMED_W_SMESHDS_Mesh::AddSubMesh(SMESHDS_SubMesh* theSubMesh, int theID)
71 mySubMeshes[theID] = theSubMesh;
74 void DriverMED_W_SMESHDS_Mesh::AddGroupOfNodes()
76 myDoGroupOfNodes = true;
79 void DriverMED_W_SMESHDS_Mesh::AddGroupOfEdges()
81 myDoGroupOfEdges = true;
84 void DriverMED_W_SMESHDS_Mesh::AddGroupOfFaces()
86 myDoGroupOfFaces = true;
89 void DriverMED_W_SMESHDS_Mesh::AddGroupOfVolumes()
91 myDoGroupOfVolumes = true;
94 typedef double (SMDS_MeshNode::* TGetCoord)() const;
95 typedef const char* TName;
96 typedef const char* TUnit;
98 static TUnit aUnit[3] = {"m","m","m"};
100 static TGetCoord aXYZGetCoord[3] = {
105 static TName aXYZName[3] = {"x","y","z"};
108 static TGetCoord aXYGetCoord[2] = {
112 static TName aXYName[2] = {"x","y"};
114 static TGetCoord aYZGetCoord[2] = {
118 static TName aYZName[2] = {"y","z"};
120 static TGetCoord aXZGetCoord[2] = {
124 static TName aXZName[2] = {"x","z"};
127 static TGetCoord aXGetCoord[1] = {
130 static TName aXName[1] = {"x"};
132 static TGetCoord aYGetCoord[1] = {
135 static TName aYName[1] = {"y"};
137 static TGetCoord aZGetCoord[1] = {
140 static TName aZName[1] = {"z"};
144 SMDS_NodeIteratorPtr myNodeIter;
145 const SMDS_MeshNode* myCurrentNode;
146 TGetCoord* myGetCoord;
150 TCoordHelper(const SMDS_NodeIteratorPtr& theNodeIter,
151 TGetCoord* theGetCoord,
153 TUnit* theUnit = aUnit):
154 myNodeIter(theNodeIter),
155 myGetCoord(theGetCoord),
159 virtual ~TCoordHelper(){}
161 return myNodeIter->more() &&
162 (myCurrentNode = myNodeIter->next());
164 const SMDS_MeshNode* GetNode(){
165 return myCurrentNode;
167 MED::TIntVector::value_type GetID(){
168 return myCurrentNode->GetID();
170 MED::TFloatVector::value_type GetCoord(med_int theCoodId){
171 return (myCurrentNode->*myGetCoord[theCoodId])();
173 MED::TStringVector::value_type GetName(med_int theDimId){
174 return myName[theDimId];
176 MED::TStringVector::value_type GetUnit(med_int theDimId){
177 return myUnit[theDimId];
180 typedef boost::shared_ptr<TCoordHelper> TCoordHelperPtr;
183 Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
185 Status aResult = DRS_OK;
186 if (myMesh->hasConstructionEdges() || myMesh->hasConstructionFaces()) {
187 INFOS("SMDS_MESH with hasConstructionEdges() or hasConstructionFaces() do not supports!!!");
191 using namespace MEDA;
192 using namespace boost;
194 MESSAGE("Perform - myFile : "<<myFile);
195 TWrapper aMed(myFile);
197 // Creating the MED mesh for corresponding SMDS structure
198 //-------------------------------------------------------
200 if (myMeshId != -1) {
201 ostringstream aMeshNameStr;
202 aMeshNameStr<<myMeshId;
203 aMeshName = aMeshNameStr.str();
205 aMeshName = myMeshName;
208 // Mesh dimension definition
209 med_int aMeshDimension;
210 TCoordHelperPtr aCoordHelperPtr;
212 bool anIsXDimension = false;
213 bool anIsYDimension = false;
214 bool anIsZDimension = false;
216 SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
218 if(aNodesIter->more()){
219 const SMDS_MeshNode* aNode = aNodesIter->next();
220 aBounds[0] = aBounds[1] = aNode->X();
221 aBounds[2] = aBounds[3] = aNode->Y();
222 aBounds[4] = aBounds[5] = aNode->Z();
224 while(aNodesIter->more()){
225 const SMDS_MeshNode* aNode = aNodesIter->next();
226 aBounds[0] = min(aBounds[0],aNode->X());
227 aBounds[1] = max(aBounds[1],aNode->X());
229 aBounds[2] = min(aBounds[2],aNode->Y());
230 aBounds[3] = max(aBounds[3],aNode->Y());
232 aBounds[4] = min(aBounds[4],aNode->Z());
233 aBounds[5] = max(aBounds[5],aNode->Z());
237 anIsXDimension = (aBounds[1] - aBounds[0]) + abs(aBounds[1]) + abs(aBounds[0]) > EPS;
238 anIsYDimension = (aBounds[3] - aBounds[2]) + abs(aBounds[3]) + abs(aBounds[2]) > EPS;
239 anIsZDimension = (aBounds[5] - aBounds[4]) + abs(aBounds[5]) + abs(aBounds[4]) > EPS;
241 aMeshDimension = anIsXDimension + anIsYDimension + anIsZDimension;
246 SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
247 switch(aMeshDimension){
249 aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYZGetCoord,aXYZName));
252 if(anIsXDimension && anIsYDimension)
253 aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYGetCoord,aXYName));
254 if(anIsYDimension && anIsZDimension)
255 aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYZGetCoord,aYZName));
256 if(anIsXDimension && anIsZDimension)
257 aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXZGetCoord,aXZName));
261 aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXGetCoord,aXName));
263 aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYGetCoord,aYName));
265 aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aZGetCoord,aZName));
271 PMeshInfo aMeshInfo = TWrapper::CrMeshInfo(aMeshDimension,aMeshName);
272 MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
273 aMed.SetMeshInfo(aMeshInfo);
275 // Storing SMDS groups and sub-meshes
276 //-----------------------------------
277 int myNodesDefaultFamilyId = 0;
278 int myEdgesDefaultFamilyId = 0;
279 int myFacesDefaultFamilyId = 0;
280 int myVolumesDefaultFamilyId = 0;
281 if (myDoGroupOfNodes)
282 myNodesDefaultFamilyId = REST_NODES_FAMILY;
283 if (myDoGroupOfEdges)
284 myEdgesDefaultFamilyId = REST_EDGES_FAMILY;
285 if (myDoGroupOfFaces)
286 myFacesDefaultFamilyId = REST_FACES_FAMILY;
287 if (myDoGroupOfVolumes)
288 myVolumesDefaultFamilyId = REST_VOLUMES_FAMILY;
290 MESSAGE("Perform - aFamilyInfo");
291 map<const SMDS_MeshElement *, int> anElemFamMap;
292 list<DriverMED_FamilyPtr> aFamilies;
293 if (myAllSubMeshes) {
294 aFamilies = DriverMED_Family::MakeFamilies
295 (myMesh->SubMeshes(), myGroups,
296 myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
298 aFamilies = DriverMED_Family::MakeFamilies
299 (mySubMeshes, myGroups,
300 myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
302 list<DriverMED_FamilyPtr>::iterator aFamsIter = aFamilies.begin();
304 for (; aFamsIter != aFamilies.end(); aFamsIter++)
306 PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(aMeshInfo);
307 aMed.SetFamilyInfo(aFamilyInfo);
308 int aFamId = (*aFamsIter)->GetId();
310 const set<const SMDS_MeshElement *>& anElems = (*aFamsIter)->GetElements();
311 set<const SMDS_MeshElement *>::iterator anElemsIter = anElems.begin();
312 for (; anElemsIter != anElems.end(); anElemsIter++)
314 anElemFamMap[*anElemsIter] = aFamId;
316 // delete (*aFamsIter);
319 // Storing SMDS nodes to the MED file for the MED mesh
320 //----------------------------------------------------
321 #ifdef _EDF_NODE_IDS_
322 typedef map<med_int,med_int> TNodeIdMap;
323 TNodeIdMap aNodeIdMap;
325 med_int aNbElems = myMesh->NbNodes();
326 MED::TIntVector anElemNums(aNbElems);
327 MED::TIntVector aFamilyNums(aNbElems);
328 MED::TFloatVector aCoordinates(aNbElems*aMeshDimension);
329 for(med_int iNode = 0, aStartId = 0; aCoordHelperPtr->Next(); iNode++, aStartId += aMeshDimension){
330 for(med_int iCoord = 0; iCoord < aMeshDimension; iCoord++){
331 aCoordinates[aStartId+iCoord] = aCoordHelperPtr->GetCoord(iCoord);
333 int aNodeID = aCoordHelperPtr->GetID();
334 anElemNums[iNode] = aNodeID;
335 #ifdef _EDF_NODE_IDS_
336 aNodeIdMap[aNodeID] = iNode+1;
338 const SMDS_MeshNode* aNode = aCoordHelperPtr->GetNode();
339 if (anElemFamMap.find(aNode) != anElemFamMap.end())
340 aFamilyNums[iNode] = anElemFamMap[aNode];
342 aFamilyNums[iNode] = myNodesDefaultFamilyId;
345 MED::TStringVector aCoordNames(aMeshDimension);
346 MED::TStringVector aCoordUnits(aMeshDimension);
347 for(med_int iCoord = 0; iCoord < aMeshDimension; iCoord++){
348 aCoordNames[iCoord] = aCoordHelperPtr->GetName(iCoord);
349 aCoordUnits[iCoord] = aCoordHelperPtr->GetUnit(iCoord);
352 const med_repere SMDS_COORDINATE_SYSTEM = MED_CART;
354 PNodeInfo aNodeInfo = TWrapper::CrNodeInfo(aMeshInfo,
355 SMDS_COORDINATE_SYSTEM,
361 MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbElems);
362 aMed.SetNodeInfo(aNodeInfo);
365 // Storing others SMDS elements to the MED file for the MED mesh
366 //--------------------------------------------------------------
367 med_entite_maillage SMDS_MED_ENTITY = MED_MAILLE;
368 const med_connectivite SMDS_MED_CONNECTIVITY = MED_NOD;
370 // Storing SMDS Edges
371 if(med_int aNbElems = myMesh->NbEdges()){
372 #ifdef _ELEMENTS_BY_DIM_
373 SMDS_MED_ENTITY = MED_ARETE;
375 SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator();
376 med_int aNbConnectivity = MED::GetNbConn(SMDS_MED_ENTITY,MED_SEG2,aMeshDimension);
377 MED::TIntVector anElemNums(aNbElems);
378 MED::TIntVector aFamilyNums(aNbElems);
379 MED::TIntVector aConnectivity(aNbElems*aNbConnectivity);
381 for(med_int iElem = 0, iConn = 0; anIter->more(); iElem++, iConn+=aNbConnectivity){
382 const SMDS_MeshEdge* anElem = anIter->next();
383 SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
384 for(med_int iNode = 0; iNode < aNbConnectivity && aNodesIter->more(); iNode++){
385 const SMDS_MeshElement* aNode = aNodesIter->next();
386 #ifdef _EDF_NODE_IDS_
387 aConnectivity[iConn+iNode] = aNodeIdMap[aNode->GetID()];
389 aConnectivity[iConn+iNode] = aNode->GetID();
392 anElemNums[iElem] = anElem->GetID();
394 if (anElemFamMap.find(anElem) != anElemFamMap.end())
395 aFamilyNums[iElem] = anElemFamMap[anElem];
397 aFamilyNums[iElem] = myEdgesDefaultFamilyId;
400 PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
403 SMDS_MED_CONNECTIVITY,
407 aMed.SetCellInfo(aCellInfo);
410 // Storing SMDS Faces
411 if(med_int aNbElems = myMesh->NbFaces()){
412 SMDS_FaceIteratorPtr anIter = myMesh->facesIterator();
413 #ifdef _ELEMENTS_BY_DIM_
414 SMDS_MED_ENTITY = MED_FACE;
416 med_int aNbTriaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TRIA3,aMeshDimension);
417 MED::TIntVector anTriaElemNums;
418 anTriaElemNums.reserve(aNbElems);
419 MED::TIntVector aTriaFamilyNums;
420 aTriaFamilyNums.reserve(aNbElems);
421 MED::TIntVector aTriaConn;
422 aTriaConn.reserve(aNbElems*aNbTriaConn);
424 med_int aNbQuadConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_QUAD4,aMeshDimension);
425 MED::TIntVector aQuadElemNums;
426 aQuadElemNums.reserve(aNbElems);
427 MED::TIntVector aQuadFamilyNums;
428 aQuadFamilyNums.reserve(aNbElems);
429 MED::TIntVector aQuadConn;
430 aQuadConn.reserve(aNbElems*aNbQuadConn);
432 for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
433 const SMDS_MeshFace* anElem = anIter->next();
434 med_int aNbNodes = anElem->NbNodes();
435 SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
436 med_int aNbConnectivity;
437 MED::TIntVector* anElemNums;
438 MED::TIntVector* aFamilyNums;
439 MED::TIntVector* aConnectivity;
442 aNbConnectivity = aNbTriaConn;
443 anElemNums = &anTriaElemNums;
444 aFamilyNums = &aTriaFamilyNums;
445 aConnectivity = &aTriaConn;
448 aNbConnectivity = aNbQuadConn;
449 anElemNums = &aQuadElemNums;
450 aFamilyNums = &aQuadFamilyNums;
451 aConnectivity = &aQuadConn;
454 MED::TIntVector aVector(aNbNodes);
455 for(med_int iNode = 0; aNodesIter->more(); iNode++){
456 const SMDS_MeshElement* aNode = aNodesIter->next();
457 aVector[iNode] = aNode->GetID();
460 med_int aSize = aConnectivity->size();
461 aConnectivity->resize(aSize+aNbConnectivity);
462 // There is some differnce between SMDS and MED in cells mapping
463 #ifdef _EDF_NODE_IDS_
466 (*aConnectivity)[aSize+0] = aNodeIdMap[aVector[0]];
467 (*aConnectivity)[aSize+1] = aNodeIdMap[aVector[1]];
468 (*aConnectivity)[aSize+2] = aNodeIdMap[aVector[3]];
469 (*aConnectivity)[aSize+3] = aNodeIdMap[aVector[2]];
471 for(med_int iNode = 0; iNode < aNbNodes; iNode++)
472 (*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]];
477 (*aConnectivity)[aSize+0] = aVector[0];
478 (*aConnectivity)[aSize+1] = aVector[1];
479 (*aConnectivity)[aSize+2] = aVector[3];
480 (*aConnectivity)[aSize+3] = aVector[2];
482 for(med_int iNode = 0; iNode < aNbNodes; iNode++)
483 (*aConnectivity)[aSize+iNode] = aVector[iNode];
486 anElemNums->push_back(anElem->GetID());
488 if (anElemFamMap.find(anElem) != anElemFamMap.end())
489 aFamilyNums->push_back(anElemFamMap[anElem]);
491 aFamilyNums->push_back(myFacesDefaultFamilyId);
493 if(med_int aNbElems = anTriaElemNums.size()){
494 PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
497 SMDS_MED_CONNECTIVITY,
501 MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TRIA3<<"; aNbElems = "<<aNbElems);
502 aMed.SetCellInfo(aCellInfo);
504 if(med_int aNbElems = aQuadElemNums.size()){
505 PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
508 SMDS_MED_CONNECTIVITY,
512 MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_QUAD4<<"; aNbElems = "<<aNbElems);
513 aMed.SetCellInfo(aCellInfo);
517 // Storing SMDS Volumes
518 if(med_int aNbElems = myMesh->NbVolumes()){
519 SMDS_VolumeIteratorPtr anIter = myMesh->volumesIterator();
520 #ifdef _ELEMENTS_BY_DIM_
521 SMDS_MED_ENTITY = MED_MAILLE;
523 med_int aNbTetraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TETRA4,aMeshDimension);
524 MED::TIntVector anTetraElemNums;
525 anTetraElemNums.reserve(aNbElems);
526 MED::TIntVector aTetraFamilyNums;
527 aTetraFamilyNums.reserve(aNbElems);
528 MED::TIntVector aTetraConn;
529 aTetraConn.reserve(aNbElems*aNbTetraConn);
531 med_int aNbPyraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PYRA5,aMeshDimension);
532 MED::TIntVector anPyraElemNums;
533 anPyraElemNums.reserve(aNbElems);
534 MED::TIntVector aPyraFamilyNums;
535 aPyraFamilyNums.reserve(aNbElems);
536 MED::TIntVector aPyraConn;
537 aPyraConn.reserve(aNbElems*aNbPyraConn);
539 med_int aNbPentaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PENTA6,aMeshDimension);
540 MED::TIntVector anPentaElemNums;
541 anPentaElemNums.reserve(aNbElems);
542 MED::TIntVector aPentaFamilyNums;
543 aPentaFamilyNums.reserve(aNbElems);
544 MED::TIntVector aPentaConn;
545 aPentaConn.reserve(aNbElems*aNbPentaConn);
547 med_int aNbHexaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_HEXA8,aMeshDimension);
548 MED::TIntVector aHexaElemNums;
549 aHexaElemNums.reserve(aNbElems);
550 MED::TIntVector aHexaFamilyNums;
551 aHexaFamilyNums.reserve(aNbElems);
552 MED::TIntVector aHexaConn;
553 aHexaConn.reserve(aNbElems*aNbHexaConn);
555 for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
556 const SMDS_MeshVolume* anElem = anIter->next();
557 med_int aNbNodes = anElem->NbNodes();
558 SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
559 med_int aNbConnectivity;
560 MED::TIntVector* anElemNums;
561 MED::TIntVector* aFamilyNums;
562 MED::TIntVector* aConnectivity;
565 aNbConnectivity = aNbTetraConn;
566 anElemNums = &anTetraElemNums;
567 aFamilyNums = &aTetraFamilyNums;
568 aConnectivity = &aTetraConn;
571 aNbConnectivity = aNbPyraConn;
572 anElemNums = &anPyraElemNums;
573 aFamilyNums = &aPyraFamilyNums;
574 aConnectivity = &aPyraConn;
577 aNbConnectivity = aNbPentaConn;
578 anElemNums = &anPentaElemNums;
579 aFamilyNums = &aPentaFamilyNums;
580 aConnectivity = &aPentaConn;
583 aNbConnectivity = aNbHexaConn;
584 anElemNums = &aHexaElemNums;
585 aFamilyNums = &aHexaFamilyNums;
586 aConnectivity = &aHexaConn;
589 MED::TIntVector aVector(aNbNodes);
590 for(med_int iNode = 0; aNodesIter->more(); iNode++){
591 const SMDS_MeshElement* aNode = aNodesIter->next();
592 aVector[iNode] = aNode->GetID();
594 med_int aSize = aConnectivity->size();
595 aConnectivity->resize(aSize+aNbConnectivity);
596 // There is some difference between SMDS and MED in cells mapping
597 #ifdef _EDF_NODE_IDS_
600 (*aConnectivity)[aSize+0] = aNodeIdMap[aVector[0]];
601 (*aConnectivity)[aSize+1] = aNodeIdMap[aVector[3]];
602 (*aConnectivity)[aSize+2] = aNodeIdMap[aVector[2]];
603 (*aConnectivity)[aSize+3] = aNodeIdMap[aVector[1]];
604 (*aConnectivity)[aSize+4] = aNodeIdMap[aVector[4]];
606 for(med_int iNode = 0; iNode < aNbNodes; iNode++)
607 (*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]];
612 (*aConnectivity)[aSize+0] = aVector[0];
613 (*aConnectivity)[aSize+1] = aVector[3];
614 (*aConnectivity)[aSize+2] = aVector[2];
615 (*aConnectivity)[aSize+3] = aVector[1];
616 (*aConnectivity)[aSize+4] = aVector[4];
618 for(med_int iNode = 0; iNode < aNbNodes; iNode++)
619 (*aConnectivity)[aSize+iNode] = aVector[iNode];
622 anElemNums->push_back(anElem->GetID());
624 if (anElemFamMap.find(anElem) != anElemFamMap.end())
625 aFamilyNums->push_back(anElemFamMap[anElem]);
627 aFamilyNums->push_back(myVolumesDefaultFamilyId);
630 if(med_int aNbElems = anTetraElemNums.size()){
631 PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
634 SMDS_MED_CONNECTIVITY,
638 MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TETRA4<<"; aNbElems = "<<aNbElems);
639 aMed.SetCellInfo(aCellInfo);
641 if(med_int aNbElems = anPyraElemNums.size()){
642 PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
645 SMDS_MED_CONNECTIVITY,
649 MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PYRA5<<"; aNbElems = "<<aNbElems);
650 aMed.SetCellInfo(aCellInfo);
652 if(med_int aNbElems = anPentaElemNums.size()){
653 PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
656 SMDS_MED_CONNECTIVITY,
660 MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PENTA6<<"; aNbElems = "<<aNbElems);
661 aMed.SetCellInfo(aCellInfo);
663 if(med_int aNbElems = aHexaElemNums.size()){
664 PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
667 SMDS_MED_CONNECTIVITY,
671 MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_HEXA8<<"; aNbElems = "<<aNbElems);
672 aMed.SetCellInfo(aCellInfo);
675 }catch(const std::exception& exc){
676 INFOS("Follow exception was cought:\n\t"<<exc.what());
678 INFOS("Unknown exception was cought !!!");