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
27 #include "DriverMED_W_SMESHDS_Mesh.h"
28 #include "DriverMED_W_SMDS_Mesh.h"
29 #include "DriverMED_Family.h"
31 #include "SMDS_MeshElement.hxx"
32 #include "SMDS_MeshNode.hxx"
33 #include "utilities.h"
35 #include "MEDA_Wrapper.hxx"
38 #include "MED_Utilities.hxx"
40 #define _EDF_NODE_IDS_
41 #define _ELEMENTS_BY_DIM_
43 DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh()
49 myAllSubMeshes (false),
50 myDoGroupOfNodes (false),
51 myDoGroupOfEdges (false),
52 myDoGroupOfFaces (false),
53 myDoGroupOfVolumes (false)
57 DriverMED_W_SMESHDS_Mesh::~DriverMED_W_SMESHDS_Mesh()
61 void DriverMED_W_SMESHDS_Mesh::SetMesh(SMDS_Mesh * aMesh)
66 void DriverMED_W_SMESHDS_Mesh::SetFile(string aFile)
71 void DriverMED_W_SMESHDS_Mesh::SetFileId(med_idt aFileId)
76 void DriverMED_W_SMESHDS_Mesh::SetMeshId(int aMeshId)
81 void DriverMED_W_SMESHDS_Mesh::SetMeshName(string theMeshName)
83 myMeshName = theMeshName;
86 void DriverMED_W_SMESHDS_Mesh::AddGroup(SMESHDS_Group* theGroup)
88 myGroups.push_back(theGroup);
91 void DriverMED_W_SMESHDS_Mesh::AddAllSubMeshes()
93 myAllSubMeshes = true;
96 void DriverMED_W_SMESHDS_Mesh::AddSubMesh(SMESHDS_SubMesh* theSubMesh, int theID)
98 mySubMeshes[theID] = theSubMesh;
101 void DriverMED_W_SMESHDS_Mesh::AddGroupOfNodes()
103 myDoGroupOfNodes = true;
106 void DriverMED_W_SMESHDS_Mesh::AddGroupOfEdges()
108 myDoGroupOfEdges = true;
111 void DriverMED_W_SMESHDS_Mesh::AddGroupOfFaces()
113 myDoGroupOfFaces = true;
116 void DriverMED_W_SMESHDS_Mesh::AddGroupOfVolumes()
118 myDoGroupOfVolumes = true;
121 void DriverMED_W_SMESHDS_Mesh::Write()
123 string myClass = string("SMDS_Mesh");
124 string myExtension = string("MED");
126 DriverMED_W_SMDS_Mesh *myWriter = new DriverMED_W_SMDS_Mesh;
128 myWriter->SetMesh(myMesh);
129 // myWriter->SetFile(myFile);
130 myWriter->SetMeshId(myMeshId);
131 myWriter->SetFileId(myFileId);
137 typedef double (SMDS_MeshNode::* TGetCoord)() const;
138 typedef const char* TName;
139 typedef const char* TUnit;
141 static TUnit aUnit[3] = {"m","m","m"};
143 static TGetCoord aXYZGetCoord[3] = {
148 static TName aXYZName[3] = {"x","y","z"};
151 static TGetCoord aXYGetCoord[2] = {
155 static TName aXYName[2] = {"x","y"};
157 static TGetCoord aYZGetCoord[2] = {
161 static TName aYZName[2] = {"y","z"};
163 static TGetCoord aXZGetCoord[2] = {
167 static TName aXZName[2] = {"x","z"};
170 static TGetCoord aXGetCoord[1] = {
173 static TName aXName[1] = {"x"};
175 static TGetCoord aYGetCoord[1] = {
178 static TName aYName[1] = {"y"};
180 static TGetCoord aZGetCoord[1] = {
183 static TName aZName[1] = {"z"};
187 SMDS_NodeIteratorPtr myNodeIter;
188 const SMDS_MeshNode* myCurrentNode;
189 TGetCoord* myGetCoord;
193 TCoordHelper(const SMDS_NodeIteratorPtr& theNodeIter,
194 TGetCoord* theGetCoord,
196 TUnit* theUnit = aUnit):
197 myNodeIter(theNodeIter),
198 myGetCoord(theGetCoord),
202 virtual ~TCoordHelper(){}
204 return myNodeIter->more() &&
205 (myCurrentNode = myNodeIter->next());
207 const SMDS_MeshNode* GetNode(){
208 return myCurrentNode;
210 MED::TIntVector::value_type GetID(){
211 myCurrentNode->GetID();
213 MED::TFloatVector::value_type GetCoord(med_int theCoodId){
214 return (myCurrentNode->*myGetCoord[theCoodId])();
216 MED::TStringVector::value_type GetName(med_int theDimId){
217 return myName[theDimId];
219 MED::TStringVector::value_type GetUnit(med_int theDimId){
220 return myUnit[theDimId];
223 typedef boost::shared_ptr<TCoordHelper> TCoordHelperPtr;
226 void DriverMED_W_SMESHDS_Mesh::Add()
228 if (myMesh->hasConstructionEdges() || myMesh->hasConstructionFaces()) {
229 INFOS("SMDS_MESH with hasConstructionEdges() or hasConstructionFaces() do not supports!!!");
233 using namespace MEDA;
234 using namespace boost;
236 MESSAGE("Add - myFile : "<<myFile);
237 TWrapper aMed(myFile);
239 // Creating the MED mesh for corresponding SMDS structure
240 //-------------------------------------------------------
242 if (myMeshId != -1) {
243 ostringstream aMeshNameStr;
244 aMeshNameStr<<myMeshId;
245 aMeshName = aMeshNameStr.str();
247 aMeshName = myMeshName;
250 // Mesh dimension definition
251 med_int aMeshDimension;
252 TCoordHelperPtr aCoordHelperPtr;
254 bool anIsXDimension = false;
255 bool anIsYDimension = false;
256 bool anIsZDimension = false;
258 SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
260 if(aNodesIter->more()){
261 const SMDS_MeshNode* aNode = aNodesIter->next();
262 aBounds[0] = aBounds[1] = aNode->X();
263 aBounds[2] = aBounds[3] = aNode->Y();
264 aBounds[4] = aBounds[5] = aNode->Z();
266 while(aNodesIter->more()){
267 const SMDS_MeshNode* aNode = aNodesIter->next();
268 aBounds[0] = min(aBounds[0],aNode->X());
269 aBounds[1] = max(aBounds[1],aNode->X());
271 aBounds[2] = min(aBounds[2],aNode->Y());
272 aBounds[3] = max(aBounds[3],aNode->Y());
274 aBounds[4] = min(aBounds[4],aNode->Z());
275 aBounds[5] = max(aBounds[5],aNode->Z());
279 anIsXDimension = (aBounds[1] - aBounds[0]) > EPS;
280 anIsYDimension = (aBounds[3] - aBounds[2]) > EPS;
281 anIsZDimension = (aBounds[5] - aBounds[4]) > EPS;
283 aMeshDimension = anIsXDimension + anIsYDimension + anIsZDimension;
288 SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
289 switch(aMeshDimension){
291 aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYZGetCoord,aXYZName));
294 if(anIsXDimension && anIsYDimension)
295 aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYGetCoord,aXYName));
296 if(anIsYDimension && anIsZDimension)
297 aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYZGetCoord,aYZName));
298 if(anIsXDimension && anIsZDimension)
299 aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXZGetCoord,aXZName));
303 aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXGetCoord,aXName));
305 aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYGetCoord,aYName));
307 aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aZGetCoord,aZName));
313 PMeshInfo aMeshInfo = TWrapper::CrMeshInfo(aMeshDimension,aMeshName);
314 MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
315 aMed.SetMeshInfo(aMeshInfo);
317 // Storing SMDS groups and sub-meshes
318 //-----------------------------------
319 int myNodesDefaultFamilyId = 0;
320 int myEdgesDefaultFamilyId = 0;
321 int myFacesDefaultFamilyId = 0;
322 int myVolumesDefaultFamilyId = 0;
323 if (myDoGroupOfNodes)
324 myNodesDefaultFamilyId = REST_NODES_FAMILY;
325 if (myDoGroupOfEdges)
326 myEdgesDefaultFamilyId = REST_EDGES_FAMILY;
327 if (myDoGroupOfFaces)
328 myFacesDefaultFamilyId = REST_FACES_FAMILY;
329 if (myDoGroupOfVolumes)
330 myVolumesDefaultFamilyId = REST_VOLUMES_FAMILY;
332 MESSAGE("Add - aFamilyInfo");
333 map<const SMDS_MeshElement *, int> anElemFamMap;
334 list<DriverMED_FamilyPtr> aFamilies;
335 if (myAllSubMeshes) {
336 SMESHDS_Mesh* aSMESHDSMesh = dynamic_cast<SMESHDS_Mesh*>(myMesh);
338 EXCEPTION(runtime_error,"Can not cast SMDS_Mesh to SMESHDS_Mesh");
340 aFamilies = DriverMED_Family::MakeFamilies
341 (aSMESHDSMesh->SubMeshes(), myGroups,
342 myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
344 aFamilies = DriverMED_Family::MakeFamilies
345 (mySubMeshes, myGroups,
346 myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
348 list<DriverMED_FamilyPtr>::iterator aFamsIter = aFamilies.begin();
350 for (; aFamsIter != aFamilies.end(); aFamsIter++)
352 PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(aMeshInfo);
353 aMed.SetFamilyInfo(aFamilyInfo);
354 int aFamId = (*aFamsIter)->GetId();
356 const set<const SMDS_MeshElement *>& anElems = (*aFamsIter)->GetElements();
357 set<const SMDS_MeshElement *>::iterator anElemsIter = anElems.begin();
358 for (; anElemsIter != anElems.end(); anElemsIter++)
360 anElemFamMap[*anElemsIter] = aFamId;
362 // delete (*aFamsIter);
365 // Storing SMDS nodes to the MED file for the MED mesh
366 //----------------------------------------------------
367 #ifdef _EDF_NODE_IDS_
368 typedef map<med_int,med_int> TNodeIdMap;
369 TNodeIdMap aNodeIdMap;
371 med_int aNbElems = myMesh->NbNodes();
372 MED::TIntVector anElemNums(aNbElems);
373 MED::TIntVector aFamilyNums(aNbElems);
374 MED::TFloatVector aCoordinates(aNbElems*aMeshDimension);
375 for(med_int iNode = 0, aStartId = 0; aCoordHelperPtr->Next(); iNode++, aStartId += aMeshDimension){
376 for(med_int iCoord = 0; iCoord < aMeshDimension; iCoord++){
377 aCoordinates[aStartId+iCoord] = aCoordHelperPtr->GetCoord(iCoord);
379 int aNodeID = aCoordHelperPtr->GetID();
380 anElemNums[iNode] = aNodeID;
381 #ifdef _EDF_NODE_IDS_
382 aNodeIdMap[aNodeID] = iNode+1;
384 const SMDS_MeshNode* aNode = aCoordHelperPtr->GetNode();
385 if (anElemFamMap.find(aNode) != anElemFamMap.end())
386 aFamilyNums[iNode] = anElemFamMap[aNode];
388 aFamilyNums[iNode] = myNodesDefaultFamilyId;
391 MED::TStringVector aCoordNames(aMeshDimension);
392 MED::TStringVector aCoordUnits(aMeshDimension);
393 for(med_int iCoord = 0; iCoord < aMeshDimension; iCoord++){
394 aCoordNames[iCoord] = aCoordHelperPtr->GetName(iCoord);
395 aCoordUnits[iCoord] = aCoordHelperPtr->GetUnit(iCoord);
398 const med_repere SMDS_COORDINATE_SYSTEM = MED_CART;
400 PNodeInfo aNodeInfo = TWrapper::CrNodeInfo(aMeshInfo,
401 SMDS_COORDINATE_SYSTEM,
407 MESSAGE("Add - aNodeInfo->GetNbElem() = "<<aNbElems);
408 aMed.SetNodeInfo(aNodeInfo);
411 // Storing others SMDS elements to the MED file for the MED mesh
412 //--------------------------------------------------------------
413 med_entite_maillage SMDS_MED_ENTITY = MED_MAILLE;
414 const med_connectivite SMDS_MED_CONNECTIVITY = MED_NOD;
416 // Storing SMDS Edges
417 if(med_int aNbElems = myMesh->NbEdges()){
418 #ifdef _ELEMENTS_BY_DIM_
419 SMDS_MED_ENTITY = MED_ARETE;
421 SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator();
422 med_int aNbConnectivity = MED::GetNbConn(SMDS_MED_ENTITY,MED_SEG2,aMeshDimension);
423 MED::TIntVector anElemNums(aNbElems);
424 MED::TIntVector aFamilyNums(aNbElems);
425 MED::TIntVector aConnectivity(aNbElems*aNbConnectivity);
427 for(med_int iElem = 0, iConn = 0; anIter->more(); iElem++, iConn+=aNbConnectivity){
428 const SMDS_MeshEdge* anElem = anIter->next();
429 SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
430 for(med_int iNode = 0; iNode < aNbConnectivity && aNodesIter->more(); iNode++){
431 const SMDS_MeshElement* aNode = aNodesIter->next();
432 #ifdef _EDF_NODE_IDS_
433 aConnectivity[iConn+iNode] = aNodeIdMap[aNode->GetID()];
435 aConnectivity[iConn+iNode] = aNode->GetID();
438 anElemNums[iElem] = anElem->GetID();
440 if (anElemFamMap.find(anElem) != anElemFamMap.end())
441 aFamilyNums[iElem] = anElemFamMap[anElem];
443 aFamilyNums[iElem] = myEdgesDefaultFamilyId;
446 PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
449 SMDS_MED_CONNECTIVITY,
453 aMed.SetCellInfo(aCellInfo);
456 // Storing SMDS Faces
457 if(med_int aNbElems = myMesh->NbFaces()){
458 SMDS_FaceIteratorPtr anIter = myMesh->facesIterator();
459 #ifdef _ELEMENTS_BY_DIM_
460 SMDS_MED_ENTITY = MED_FACE;
462 med_int aNbTriaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TRIA3,aMeshDimension);
463 MED::TIntVector anTriaElemNums;
464 anTriaElemNums.reserve(aNbElems);
465 MED::TIntVector aTriaFamilyNums;
466 aTriaFamilyNums.reserve(aNbElems);
467 MED::TIntVector aTriaConn;
468 aTriaConn.reserve(aNbElems*aNbTriaConn);
470 med_int aNbQuadConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_QUAD4,aMeshDimension);
471 MED::TIntVector aQuadElemNums;
472 aQuadElemNums.reserve(aNbElems);
473 MED::TIntVector aQuadFamilyNums;
474 aQuadFamilyNums.reserve(aNbElems);
475 MED::TIntVector aQuadConn;
476 aQuadConn.reserve(aNbElems*aNbQuadConn);
478 for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
479 const SMDS_MeshFace* anElem = anIter->next();
480 med_int aNbNodes = anElem->NbNodes();
481 SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
482 med_int aNbConnectivity;
483 MED::TIntVector* anElemNums;
484 MED::TIntVector* aFamilyNums;
485 MED::TIntVector* aConnectivity;
488 aNbConnectivity = aNbTriaConn;
489 anElemNums = &anTriaElemNums;
490 aFamilyNums = &aTriaFamilyNums;
491 aConnectivity = &aTriaConn;
494 aNbConnectivity = aNbQuadConn;
495 anElemNums = &aQuadElemNums;
496 aFamilyNums = &aQuadFamilyNums;
497 aConnectivity = &aQuadConn;
500 MED::TIntVector aVector(aNbNodes);
501 for(med_int iNode = 0; aNodesIter->more(); iNode++){
502 const SMDS_MeshElement* aNode = aNodesIter->next();
503 aVector[iNode] = aNode->GetID();
506 med_int aSize = aConnectivity->size();
507 aConnectivity->resize(aSize+aNbConnectivity);
508 // There is some differnce between SMDS and MED in cells mapping
509 #ifdef _EDF_NODE_IDS_
512 (*aConnectivity)[aSize+0] = aNodeIdMap[aVector[0]];
513 (*aConnectivity)[aSize+1] = aNodeIdMap[aVector[1]];
514 (*aConnectivity)[aSize+2] = aNodeIdMap[aVector[3]];
515 (*aConnectivity)[aSize+3] = aNodeIdMap[aVector[2]];
517 for(med_int iNode = 0; iNode < aNbNodes; iNode++)
518 (*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]];
523 (*aConnectivity)[aSize+0] = aVector[0];
524 (*aConnectivity)[aSize+1] = aVector[1];
525 (*aConnectivity)[aSize+2] = aVector[3];
526 (*aConnectivity)[aSize+3] = aVector[2];
528 for(med_int iNode = 0; iNode < aNbNodes; iNode++)
529 (*aConnectivity)[aSize+iNode] = aVector[iNode];
532 anElemNums->push_back(anElem->GetID());
534 if (anElemFamMap.find(anElem) != anElemFamMap.end())
535 aFamilyNums->push_back(anElemFamMap[anElem]);
537 aFamilyNums->push_back(myFacesDefaultFamilyId);
539 if(med_int aNbElems = anTriaElemNums.size()){
540 PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
543 SMDS_MED_CONNECTIVITY,
547 MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TRIA3<<"; aNbElems = "<<aNbElems);
548 aMed.SetCellInfo(aCellInfo);
550 if(med_int aNbElems = aQuadElemNums.size()){
551 PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
554 SMDS_MED_CONNECTIVITY,
558 MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_QUAD4<<"; aNbElems = "<<aNbElems);
559 aMed.SetCellInfo(aCellInfo);
563 // Storing SMDS Volumes
564 if(med_int aNbElems = myMesh->NbVolumes()){
565 SMDS_VolumeIteratorPtr anIter = myMesh->volumesIterator();
566 #ifdef _ELEMENTS_BY_DIM_
567 SMDS_MED_ENTITY = MED_MAILLE;
569 med_int aNbTetraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TETRA4,aMeshDimension);
570 MED::TIntVector anTetraElemNums;
571 anTetraElemNums.reserve(aNbElems);
572 MED::TIntVector aTetraFamilyNums;
573 aTetraFamilyNums.reserve(aNbElems);
574 MED::TIntVector aTetraConn;
575 aTetraConn.reserve(aNbElems*aNbTetraConn);
577 med_int aNbPyraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PYRA5,aMeshDimension);
578 MED::TIntVector anPyraElemNums;
579 anPyraElemNums.reserve(aNbElems);
580 MED::TIntVector aPyraFamilyNums;
581 aPyraFamilyNums.reserve(aNbElems);
582 MED::TIntVector aPyraConn;
583 aPyraConn.reserve(aNbElems*aNbPyraConn);
585 med_int aNbPentaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PENTA6,aMeshDimension);
586 MED::TIntVector anPentaElemNums;
587 anPentaElemNums.reserve(aNbElems);
588 MED::TIntVector aPentaFamilyNums;
589 aPentaFamilyNums.reserve(aNbElems);
590 MED::TIntVector aPentaConn;
591 aPentaConn.reserve(aNbElems*aNbPentaConn);
593 med_int aNbHexaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_HEXA8,aMeshDimension);
594 MED::TIntVector aHexaElemNums;
595 aHexaElemNums.reserve(aNbElems);
596 MED::TIntVector aHexaFamilyNums;
597 aHexaFamilyNums.reserve(aNbElems);
598 MED::TIntVector aHexaConn;
599 aHexaConn.reserve(aNbElems*aNbHexaConn);
601 for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
602 const SMDS_MeshVolume* anElem = anIter->next();
603 med_int aNbNodes = anElem->NbNodes();
604 SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
605 med_int aNbConnectivity;
606 MED::TIntVector* anElemNums;
607 MED::TIntVector* aFamilyNums;
608 MED::TIntVector* aConnectivity;
611 aNbConnectivity = aNbTetraConn;
612 anElemNums = &anTetraElemNums;
613 aFamilyNums = &aTetraFamilyNums;
614 aConnectivity = &aTetraConn;
617 aNbConnectivity = aNbPyraConn;
618 anElemNums = &anPyraElemNums;
619 aFamilyNums = &aPyraFamilyNums;
620 aConnectivity = &aPyraConn;
623 aNbConnectivity = aNbPentaConn;
624 anElemNums = &anPentaElemNums;
625 aFamilyNums = &aPentaFamilyNums;
626 aConnectivity = &aPentaConn;
629 aNbConnectivity = aNbHexaConn;
630 anElemNums = &aHexaElemNums;
631 aFamilyNums = &aHexaFamilyNums;
632 aConnectivity = &aHexaConn;
635 MED::TIntVector aVector(aNbNodes);
636 for(med_int iNode = 0; aNodesIter->more(); iNode++){
637 const SMDS_MeshElement* aNode = aNodesIter->next();
638 aVector[iNode] = aNode->GetID();
640 med_int aSize = aConnectivity->size();
641 aConnectivity->resize(aSize+aNbConnectivity);
642 // There is some difference between SMDS and MED in cells mapping
643 #ifdef _EDF_NODE_IDS_
646 (*aConnectivity)[aSize+0] = aNodeIdMap[aVector[0]];
647 (*aConnectivity)[aSize+1] = aNodeIdMap[aVector[3]];
648 (*aConnectivity)[aSize+2] = aNodeIdMap[aVector[2]];
649 (*aConnectivity)[aSize+3] = aNodeIdMap[aVector[1]];
650 (*aConnectivity)[aSize+4] = aNodeIdMap[aVector[4]];
652 for(med_int iNode = 0; iNode < aNbNodes; iNode++)
653 (*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]];
658 (*aConnectivity)[aSize+0] = aVector[0];
659 (*aConnectivity)[aSize+1] = aVector[3];
660 (*aConnectivity)[aSize+2] = aVector[2];
661 (*aConnectivity)[aSize+3] = aVector[1];
662 (*aConnectivity)[aSize+4] = aVector[4];
664 for(med_int iNode = 0; iNode < aNbNodes; iNode++)
665 (*aConnectivity)[aSize+iNode] = aVector[iNode];
668 anElemNums->push_back(anElem->GetID());
670 if (anElemFamMap.find(anElem) != anElemFamMap.end())
671 aFamilyNums->push_back(anElemFamMap[anElem]);
673 aFamilyNums->push_back(myVolumesDefaultFamilyId);
676 if(med_int aNbElems = anTetraElemNums.size()){
677 PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
680 SMDS_MED_CONNECTIVITY,
684 MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TETRA4<<"; aNbElems = "<<aNbElems);
685 aMed.SetCellInfo(aCellInfo);
687 if(med_int aNbElems = anPyraElemNums.size()){
688 PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
691 SMDS_MED_CONNECTIVITY,
695 MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PYRA5<<"; aNbElems = "<<aNbElems);
696 aMed.SetCellInfo(aCellInfo);
698 if(med_int aNbElems = anPentaElemNums.size()){
699 PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
702 SMDS_MED_CONNECTIVITY,
706 MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PENTA6<<"; aNbElems = "<<aNbElems);
707 aMed.SetCellInfo(aCellInfo);
709 if(med_int aNbElems = aHexaElemNums.size()){
710 PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo,
713 SMDS_MED_CONNECTIVITY,
717 MESSAGE("Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_HEXA8<<"; aNbElems = "<<aNbElems);
718 aMed.SetCellInfo(aCellInfo);
721 }catch(const std::exception& exc){
722 INFOS("Follow exception was cought:\n\t"<<exc.what());
724 INFOS("Unknown exception was cought !!!");