// File : DriverMED_W_SMESHDS_Mesh.cxx
// Module : SMESH
+#include <sstream>
+
#include "DriverMED_W_SMESHDS_Mesh.h"
#include "DriverMED_W_SMDS_Mesh.h"
#include "DriverMED_Family.h"
+#include "SMESHDS_Mesh.hxx"
#include "SMDS_MeshElement.hxx"
#include "SMDS_MeshNode.hxx"
#include "utilities.h"
#include "MEDA_Wrapper.hxx"
-#include <sstream>
-
#include "MED_Utilities.hxx"
-DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh()
- :
- myMesh (NULL),
- myFile (""),
- myFileId (-1),
- myMeshId (-1),
- myAllSubMeshes (false),
- myDoGroupOfNodes (false),
- myDoGroupOfEdges (false),
- myDoGroupOfFaces (false),
- myDoGroupOfVolumes (false)
-{
-}
-
-DriverMED_W_SMESHDS_Mesh::~DriverMED_W_SMESHDS_Mesh()
-{
-}
-
-void DriverMED_W_SMESHDS_Mesh::SetMesh(SMDS_Mesh * aMesh)
-{
- myMesh = aMesh;
-}
+#define _EDF_NODE_IDS_
+#define _ELEMENTS_BY_DIM_
-void DriverMED_W_SMESHDS_Mesh::SetFile(string aFile)
-{
- myFile = aFile;
-}
-
-void DriverMED_W_SMESHDS_Mesh::SetFileId(med_idt aFileId)
-{
- myFileId = aFileId;
-}
+using namespace std;
-void DriverMED_W_SMESHDS_Mesh::SetMeshId(int aMeshId)
-{
- myMeshId = aMeshId;
-}
+DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
+ myAllSubMeshes (false),
+ myDoGroupOfNodes (false),
+ myDoGroupOfEdges (false),
+ myDoGroupOfFaces (false),
+ myDoGroupOfVolumes (false)
+{}
-void DriverMED_W_SMESHDS_Mesh::SetMeshName(string theMeshName)
+void DriverMED_W_SMESHDS_Mesh::SetMeshName(const std::string& theMeshName)
{
myMeshName = theMeshName;
}
-void DriverMED_W_SMESHDS_Mesh::AddGroup(SMESHDS_Group* theGroup)
+void DriverMED_W_SMESHDS_Mesh::AddGroup(SMESHDS_GroupBase* theGroup)
{
myGroups.push_back(theGroup);
}
myDoGroupOfVolumes = true;
}
-void DriverMED_W_SMESHDS_Mesh::Write()
-{
- string myClass = string("SMDS_Mesh");
- string myExtension = string("MED");
-
- DriverMED_W_SMDS_Mesh *myWriter = new DriverMED_W_SMDS_Mesh;
-
- myWriter->SetMesh(myMesh);
- // myWriter->SetFile(myFile);
- myWriter->SetMeshId(myMeshId);
- myWriter->SetFileId(myFileId);
+typedef double (SMDS_MeshNode::* TGetCoord)() const;
+typedef const char* TName;
+typedef const char* TUnit;
+
+static TUnit aUnit[3] = {"m","m","m"};
+
+static TGetCoord aXYZGetCoord[3] = {
+ &SMDS_MeshNode::X,
+ &SMDS_MeshNode::Y,
+ &SMDS_MeshNode::Z
+};
+static TName aXYZName[3] = {"x","y","z"};
+
+
+static TGetCoord aXYGetCoord[2] = {
+ &SMDS_MeshNode::X,
+ &SMDS_MeshNode::Y
+};
+static TName aXYName[2] = {"x","y"};
+
+static TGetCoord aYZGetCoord[2] = {
+ &SMDS_MeshNode::Y,
+ &SMDS_MeshNode::Z
+};
+static TName aYZName[2] = {"y","z"};
+
+static TGetCoord aXZGetCoord[2] = {
+ &SMDS_MeshNode::X,
+ &SMDS_MeshNode::Z
+};
+static TName aXZName[2] = {"x","z"};
+
+
+static TGetCoord aXGetCoord[1] = {
+ &SMDS_MeshNode::X
+};
+static TName aXName[1] = {"x"};
+
+static TGetCoord aYGetCoord[1] = {
+ &SMDS_MeshNode::Y
+};
+static TName aYName[1] = {"y"};
+
+static TGetCoord aZGetCoord[1] = {
+ &SMDS_MeshNode::Z
+};
+static TName aZName[1] = {"z"};
+
+
+class TCoordHelper{
+ SMDS_NodeIteratorPtr myNodeIter;
+ const SMDS_MeshNode* myCurrentNode;
+ TGetCoord* myGetCoord;
+ TName* myName;
+ TUnit* myUnit;
+public:
+ TCoordHelper(const SMDS_NodeIteratorPtr& theNodeIter,
+ TGetCoord* theGetCoord,
+ TName* theName,
+ TUnit* theUnit = aUnit):
+ myNodeIter(theNodeIter),
+ myGetCoord(theGetCoord),
+ myName(theName),
+ myUnit(theUnit)
+ {}
+ virtual ~TCoordHelper(){}
+ bool Next(){
+ return myNodeIter->more() &&
+ (myCurrentNode = myNodeIter->next());
+ }
+ const SMDS_MeshNode* GetNode(){
+ return myCurrentNode;
+ }
+ MED::TIntVector::value_type GetID(){
+ return myCurrentNode->GetID();
+ }
+ MED::TFloatVector::value_type GetCoord(med_int theCoodId){
+ return (myCurrentNode->*myGetCoord[theCoodId])();
+ }
+ MED::TStringVector::value_type GetName(med_int theDimId){
+ return myName[theDimId];
+ }
+ MED::TStringVector::value_type GetUnit(med_int theDimId){
+ return myUnit[theDimId];
+ }
+};
+typedef boost::shared_ptr<TCoordHelper> TCoordHelperPtr;
- myWriter->Write();
-}
-void DriverMED_W_SMESHDS_Mesh::Add()
+Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
{
+ Status aResult = DRS_OK;
if (myMesh->hasConstructionEdges() || myMesh->hasConstructionFaces()) {
INFOS("SMDS_MESH with hasConstructionEdges() or hasConstructionFaces() do not supports!!!");
- return;
+ return DRS_FAIL;
}
try{
using namespace MEDA;
using namespace boost;
- MESSAGE("Add - myFile : "<<myFile);
+ MESSAGE("Perform - myFile : "<<myFile);
TWrapper aMed(myFile);
// Creating the MED mesh for corresponding SMDS structure
} else {
aMeshName = myMeshName;
}
- const int SMDS_MESH_DIM = 3;
- PMeshInfo aMeshInfo = TWrapper::CrMeshInfo(SMDS_MESH_DIM,aMeshName);
+
+ // Mesh dimension definition
+ med_int aMeshDimension;
+ TCoordHelperPtr aCoordHelperPtr;
+ {
+ bool anIsXDimension = false;
+ bool anIsYDimension = false;
+ bool anIsZDimension = false;
+ {
+ SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
+ double aBounds[6];
+ if(aNodesIter->more()){
+ const SMDS_MeshNode* aNode = aNodesIter->next();
+ aBounds[0] = aBounds[1] = aNode->X();
+ aBounds[2] = aBounds[3] = aNode->Y();
+ aBounds[4] = aBounds[5] = aNode->Z();
+ }
+ while(aNodesIter->more()){
+ const SMDS_MeshNode* aNode = aNodesIter->next();
+ aBounds[0] = min(aBounds[0],aNode->X());
+ aBounds[1] = max(aBounds[1],aNode->X());
+
+ aBounds[2] = min(aBounds[2],aNode->Y());
+ aBounds[3] = max(aBounds[3],aNode->Y());
+
+ aBounds[4] = min(aBounds[4],aNode->Z());
+ aBounds[5] = max(aBounds[5],aNode->Z());
+ }
+
+ double EPS = 1.0E-7;
+ anIsXDimension = (aBounds[1] - aBounds[0]) > EPS;
+ anIsYDimension = (aBounds[3] - aBounds[2]) > EPS;
+ anIsZDimension = (aBounds[5] - aBounds[4]) > EPS;
+
+ aMeshDimension = anIsXDimension + anIsYDimension + anIsZDimension;
+ if(!aMeshDimension)
+ aMeshDimension = 3;
+ }
+
+ SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
+ switch(aMeshDimension){
+ case 3:
+ aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYZGetCoord,aXYZName));
+ break;
+ case 2:
+ if(anIsXDimension && anIsYDimension)
+ aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYGetCoord,aXYName));
+ if(anIsYDimension && anIsZDimension)
+ aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYZGetCoord,aYZName));
+ if(anIsXDimension && anIsZDimension)
+ aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXZGetCoord,aXZName));
+ break;
+ case 1:
+ if(anIsXDimension)
+ aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXGetCoord,aXName));
+ if(anIsYDimension)
+ aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYGetCoord,aYName));
+ if(anIsZDimension)
+ aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aZGetCoord,aZName));
+ break;
+ }
+ }
+
+
+ PMeshInfo aMeshInfo = TWrapper::CrMeshInfo(aMeshDimension,aMeshName);
MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
aMed.SetMeshInfo(aMeshInfo);
if (myDoGroupOfVolumes)
myVolumesDefaultFamilyId = REST_VOLUMES_FAMILY;
- MESSAGE("Add - aFamilyInfo");
+ MESSAGE("Perform - aFamilyInfo");
map<const SMDS_MeshElement *, int> anElemFamMap;
list<DriverMED_FamilyPtr> aFamilies;
if (myAllSubMeshes) {
- SMESHDS_Mesh* aSMESHDSMesh = dynamic_cast<SMESHDS_Mesh*>(myMesh);
- if (!aSMESHDSMesh) {
- EXCEPTION(runtime_error,"Can not cast SMDS_Mesh to SMESHDS_Mesh");
- }
aFamilies = DriverMED_Family::MakeFamilies
- (aSMESHDSMesh->SubMeshes(), myGroups,
+ (myMesh->SubMeshes(), myGroups,
myDoGroupOfNodes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfVolumes);
} else {
aFamilies = DriverMED_Family::MakeFamilies
// Storing SMDS nodes to the MED file for the MED mesh
//----------------------------------------------------
+#ifdef _EDF_NODE_IDS_
typedef map<med_int,med_int> TNodeIdMap;
TNodeIdMap aNodeIdMap;
-
+#endif
med_int aNbElems = myMesh->NbNodes();
MED::TIntVector anElemNums(aNbElems);
MED::TIntVector aFamilyNums(aNbElems);
- MED::TFloatVector aCoordinates(aNbElems*SMDS_MESH_DIM);
- SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
- for(med_int iNode = 0, iCoord = 0; aNodesIter->more(); iNode++, iCoord+=SMDS_MESH_DIM){
- const SMDS_MeshNode* aNode = aNodesIter->next();
- aCoordinates[iCoord] = aNode->X();
- aCoordinates[iCoord+1] = aNode->Y();
- aCoordinates[iCoord+2] = aNode->Z();
- TNodeIdMap::key_type aNodeId = aNode->GetID();
- anElemNums[iNode] = aNodeId;
- aNodeIdMap[aNodeId] = iNode+1;
- //cout<<aNode->GetID()<<": "<<aNode->X()<<", "<<aNode->Y()<<", "<<aNode->Z()<<endl;
-
+ MED::TFloatVector aCoordinates(aNbElems*aMeshDimension);
+ for(med_int iNode = 0, aStartId = 0; aCoordHelperPtr->Next(); iNode++, aStartId += aMeshDimension){
+ for(med_int iCoord = 0; iCoord < aMeshDimension; iCoord++){
+ aCoordinates[aStartId+iCoord] = aCoordHelperPtr->GetCoord(iCoord);
+ }
+ int aNodeID = aCoordHelperPtr->GetID();
+ anElemNums[iNode] = aNodeID;
+#ifdef _EDF_NODE_IDS_
+ aNodeIdMap[aNodeID] = iNode+1;
+#endif
+ const SMDS_MeshNode* aNode = aCoordHelperPtr->GetNode();
if (anElemFamMap.find(aNode) != anElemFamMap.end())
- aFamilyNums[iNode] = anElemFamMap[aNode];
+ aFamilyNums[iNode] = anElemFamMap[aNode];
else
- aFamilyNums[iNode] = myNodesDefaultFamilyId;
+ aFamilyNums[iNode] = myNodesDefaultFamilyId;
}
- MED::TStringVector aCoordNames(3);
- aCoordNames[0] = "x"; aCoordNames[1] = "y"; aCoordNames[2] = "z";
-
- MED::TStringVector aCoordUnits(3);
- aCoordUnits[0] = "m"; aCoordUnits[1] = "m"; aCoordUnits[2] = "m";
+ MED::TStringVector aCoordNames(aMeshDimension);
+ MED::TStringVector aCoordUnits(aMeshDimension);
+ for(med_int iCoord = 0; iCoord < aMeshDimension; iCoord++){
+ aCoordNames[iCoord] = aCoordHelperPtr->GetName(iCoord);
+ aCoordUnits[iCoord] = aCoordHelperPtr->GetUnit(iCoord);
+ }
const med_repere SMDS_COORDINATE_SYSTEM = MED_CART;
aCoordUnits,
aFamilyNums,
anElemNums);
- MESSAGE("
Add - aNodeInfo->GetNbElem() = "<<aNbElems);
+ MESSAGE("
Perform - aNodeInfo->GetNbElem() = "<<aNbElems);
aMed.SetNodeInfo(aNodeInfo);
// Storing others SMDS elements to the MED file for the MED mesh
//--------------------------------------------------------------
- const med_entite_maillage SMDS_MED_ENTITY = MED_MAILLE;
+ med_entite_maillage SMDS_MED_ENTITY = MED_MAILLE;
const med_connectivite SMDS_MED_CONNECTIVITY = MED_NOD;
// Storing SMDS Edges
if(med_int aNbElems = myMesh->NbEdges()){
+#ifdef _ELEMENTS_BY_DIM_
+ SMDS_MED_ENTITY = MED_ARETE;
+#endif
SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator();
- med_int aNbConnectivity = MED::GetNbConn(SMDS_MED_ENTITY,MED_SEG2,SMDS_MESH_DIM);
+ med_int aNbConnectivity = MED::GetNbConn(SMDS_MED_ENTITY,MED_SEG2,aMeshDimension);
MED::TIntVector anElemNums(aNbElems);
MED::TIntVector aFamilyNums(aNbElems);
MED::TIntVector aConnectivity(aNbElems*aNbConnectivity);
SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
for(med_int iNode = 0; iNode < aNbConnectivity && aNodesIter->more(); iNode++){
const SMDS_MeshElement* aNode = aNodesIter->next();
+#ifdef _EDF_NODE_IDS_
aConnectivity[iConn+iNode] = aNodeIdMap[aNode->GetID()];
+#else
+ aConnectivity[iConn+iNode] = aNode->GetID();
+#endif
}
anElemNums[iElem] = anElem->GetID();
// Storing SMDS Faces
if(med_int aNbElems = myMesh->NbFaces()){
SMDS_FaceIteratorPtr anIter = myMesh->facesIterator();
-
- med_int aNbTriaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TRIA3,SMDS_MESH_DIM);
+#ifdef _ELEMENTS_BY_DIM_
+ SMDS_MED_ENTITY = MED_FACE;
+#endif
+ med_int aNbTriaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TRIA3,aMeshDimension);
MED::TIntVector anTriaElemNums;
anTriaElemNums.reserve(aNbElems);
MED::TIntVector aTriaFamilyNums;
MED::TIntVector aTriaConn;
aTriaConn.reserve(aNbElems*aNbTriaConn);
- med_int aNbQuadConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_QUAD4,SMDS_MESH_DIM);
+ med_int aNbQuadConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_QUAD4,aMeshDimension);
MED::TIntVector aQuadElemNums;
aQuadElemNums.reserve(aNbElems);
MED::TIntVector aQuadFamilyNums;
med_int aSize = aConnectivity->size();
aConnectivity->resize(aSize+aNbConnectivity);
// There is some differnce between SMDS and MED in cells mapping
+#ifdef _EDF_NODE_IDS_
switch(aNbNodes){
case 4:
(*aConnectivity)[aSize+0] = aNodeIdMap[aVector[0]];
for(med_int iNode = 0; iNode < aNbNodes; iNode++)
(*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]];
}
+#else
+ switch(aNbNodes){
+ case 4:
+ (*aConnectivity)[aSize+0] = aVector[0];
+ (*aConnectivity)[aSize+1] = aVector[1];
+ (*aConnectivity)[aSize+2] = aVector[3];
+ (*aConnectivity)[aSize+3] = aVector[2];
+ default:
+ for(med_int iNode = 0; iNode < aNbNodes; iNode++)
+ (*aConnectivity)[aSize+iNode] = aVector[iNode];
+ }
+#endif
anElemNums->push_back(anElem->GetID());
if (anElemFamMap.find(anElem) != anElemFamMap.end())
aTriaConn,
aTriaFamilyNums,
anTriaElemNums);
- MESSAGE("
Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TRIA3<<"; aNbElems = "<<aNbElems);
+ MESSAGE("
Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TRIA3<<"; aNbElems = "<<aNbElems);
aMed.SetCellInfo(aCellInfo);
}
if(med_int aNbElems = aQuadElemNums.size()){
aQuadConn,
aQuadFamilyNums,
aQuadElemNums);
- MESSAGE("
Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_QUAD4<<"; aNbElems = "<<aNbElems);
+ MESSAGE("
Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_QUAD4<<"; aNbElems = "<<aNbElems);
aMed.SetCellInfo(aCellInfo);
}
}
// Storing SMDS Volumes
if(med_int aNbElems = myMesh->NbVolumes()){
SMDS_VolumeIteratorPtr anIter = myMesh->volumesIterator();
-
- med_int aNbTetraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TETRA4,SMDS_MESH_DIM);
+#ifdef _ELEMENTS_BY_DIM_
+ SMDS_MED_ENTITY = MED_MAILLE;
+#endif
+ med_int aNbTetraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TETRA4,aMeshDimension);
MED::TIntVector anTetraElemNums;
anTetraElemNums.reserve(aNbElems);
MED::TIntVector aTetraFamilyNums;
MED::TIntVector aTetraConn;
aTetraConn.reserve(aNbElems*aNbTetraConn);
- med_int aNbPyraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PYRA5,SMDS_MESH_DIM);
+ med_int aNbPyraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PYRA5,aMeshDimension);
MED::TIntVector anPyraElemNums;
anPyraElemNums.reserve(aNbElems);
MED::TIntVector aPyraFamilyNums;
MED::TIntVector aPyraConn;
aPyraConn.reserve(aNbElems*aNbPyraConn);
- med_int aNbPentaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PENTA6,SMDS_MESH_DIM);
+ med_int aNbPentaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PENTA6,aMeshDimension);
MED::TIntVector anPentaElemNums;
anPentaElemNums.reserve(aNbElems);
MED::TIntVector aPentaFamilyNums;
MED::TIntVector aPentaConn;
aPentaConn.reserve(aNbElems*aNbPentaConn);
- med_int aNbHexaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_HEXA8,SMDS_MESH_DIM);
+ med_int aNbHexaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_HEXA8,aMeshDimension);
MED::TIntVector aHexaElemNums;
aHexaElemNums.reserve(aNbElems);
MED::TIntVector aHexaFamilyNums;
med_int aSize = aConnectivity->size();
aConnectivity->resize(aSize+aNbConnectivity);
// There is some difference between SMDS and MED in cells mapping
+#ifdef _EDF_NODE_IDS_
switch(aNbNodes){
case 5:
(*aConnectivity)[aSize+0] = aNodeIdMap[aVector[0]];
for(med_int iNode = 0; iNode < aNbNodes; iNode++)
(*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]];
}
+#else
+ switch(aNbNodes){
+ case 5:
+ (*aConnectivity)[aSize+0] = aVector[0];
+ (*aConnectivity)[aSize+1] = aVector[3];
+ (*aConnectivity)[aSize+2] = aVector[2];
+ (*aConnectivity)[aSize+3] = aVector[1];
+ (*aConnectivity)[aSize+4] = aVector[4];
+ default:
+ for(med_int iNode = 0; iNode < aNbNodes; iNode++)
+ (*aConnectivity)[aSize+iNode] = aVector[iNode];
+ }
+#endif
anElemNums->push_back(anElem->GetID());
if (anElemFamMap.find(anElem) != anElemFamMap.end())
aTetraConn,
aTetraFamilyNums,
anTetraElemNums);
- MESSAGE("
Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TETRA4<<"; aNbElems = "<<aNbElems);
+ MESSAGE("
Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TETRA4<<"; aNbElems = "<<aNbElems);
aMed.SetCellInfo(aCellInfo);
}
if(med_int aNbElems = anPyraElemNums.size()){
aPyraConn,
aPyraFamilyNums,
anPyraElemNums);
- MESSAGE("
Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PYRA5<<"; aNbElems = "<<aNbElems);
+ MESSAGE("
Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PYRA5<<"; aNbElems = "<<aNbElems);
aMed.SetCellInfo(aCellInfo);
}
if(med_int aNbElems = anPentaElemNums.size()){
aPentaConn,
aPentaFamilyNums,
anPentaElemNums);
- MESSAGE("
Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PENTA6<<"; aNbElems = "<<aNbElems);
+ MESSAGE("
Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PENTA6<<"; aNbElems = "<<aNbElems);
aMed.SetCellInfo(aCellInfo);
}
if(med_int aNbElems = aHexaElemNums.size()){
aHexaConn,
aHexaFamilyNums,
aHexaElemNums);
- MESSAGE("
Add - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_HEXA8<<"; aNbElems = "<<aNbElems);
+ MESSAGE("
Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_HEXA8<<"; aNbElems = "<<aNbElems);
aMed.SetCellInfo(aCellInfo);
}
}
myMeshId = -1;
myGroups.clear();
mySubMeshes.clear();
+ return aResult;
}
