ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-15 04:30:39 +05:00
Code Issues Packages Projects Releases Wiki Activity

To port on new version of MEDWrapper

Browse Source
This commit is contained in:
apo 2005-08-09 09:38:22 +00:00
parent c58ea6805e
commit f4613e1c36
2 changed files with 298 additions and 439 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

308
src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx
View File

@ -34,6 +34,7 @@
#include "SMESHDS_Group.hxx" #include "SMESHDS_Group.hxx"
#include "MED_Factory.hxx" #include "MED_Factory.hxx"
#include "MED_CoordUtils.hxx"
#include "MED_Utilities.hxx" #include "MED_Utilities.hxx"
#include <stdlib.h> #include <stdlib.h>
@ -48,7 +49,9 @@ static int MYDEBUG = 0;
using namespace MED; using namespace MED;
void DriverMED_R_SMESHDS_Mesh::SetMeshName(string theMeshName) void
DriverMED_R_SMESHDS_Mesh
::SetMeshName(string theMeshName)
{ {
myMeshName = theMeshName; myMeshName = theMeshName;
} }
@ -61,83 +64,9 @@ FindNode(const SMDS_Mesh* theMesh, TInt theId){
} }
enum ECoordName{eX, eY, eZ, eNone}; Driver_Mesh::Status
typedef TFloat (*TGetCoord)(MED::PNodeInfo&, TInt); DriverMED_R_SMESHDS_Mesh
::Perform()
template<ECoordName TheCoordId>
TFloat GetCoord(MED::PNodeInfo& thePNodeInfo, TInt theElemId){
return thePNodeInfo->GetNodeCoord(theElemId,TheCoordId);
}
template<>
TFloat GetCoord<eNone>(MED::PNodeInfo& thePNodeInfo, TInt theElemId){
return 0.0;
}
static TGetCoord aXYZGetCoord[3] = {
&GetCoord<eX>,
&GetCoord<eY>,
&GetCoord<eZ>
};
static TGetCoord aXYGetCoord[3] = {
&GetCoord<eX>,
&GetCoord<eY>,
&GetCoord<eNone>
};
static TGetCoord aYZGetCoord[3] = {
&GetCoord<eNone>,
&GetCoord<eX>,
&GetCoord<eY>
};
static TGetCoord aXZGetCoord[3] = {
&GetCoord<eX>,
&GetCoord<eNone>,
&GetCoord<eY>
};
static TGetCoord aXGetCoord[3] = {
&GetCoord<eX>,
&GetCoord<eNone>,
&GetCoord<eNone>
};
static TGetCoord aYGetCoord[3] = {
&GetCoord<eNone>,
&GetCoord<eX>,
&GetCoord<eNone>
};
static TGetCoord aZGetCoord[3] = {
&GetCoord<eNone>,
&GetCoord<eNone>,
&GetCoord<eX>
};
class TCoordHelper{
MED::PNodeInfo myPNodeInfo;
TGetCoord* myGetCoord;
public:
TCoordHelper(const MED::PNodeInfo& thePNodeInfo,
TGetCoord* theGetCoord):
myPNodeInfo(thePNodeInfo),
myGetCoord(theGetCoord)
{}
virtual ~TCoordHelper(){}
TFloat GetCoord(TInt theElemId, TInt theCoodId){
return (*myGetCoord[theCoodId])(myPNodeInfo,theElemId);
}
};
typedef boost::shared_ptr<TCoordHelper> TCoordHelperPtr;
Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
{ {
Status aResult = DRS_FAIL; Status aResult = DRS_FAIL;
try{ try{
@ -192,49 +121,16 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
//------------------------------------------------------ //------------------------------------------------------
PNodeInfo aNodeInfo = aMed->GetPNodeInfo(aMeshInfo); PNodeInfo aNodeInfo = aMed->GetPNodeInfo(aMeshInfo);
TCoordHelperPtr aCoordHelperPtr; PCoordHelper aCoordHelper = GetCoordHelper(aNodeInfo);
{
TInt aMeshDimension = aMeshInfo->GetDim();
bool anIsDimPresent[3] = {false, false, false};
for(TInt iDim = 0; iDim < aMeshDimension; iDim++){
string aDimName = aNodeInfo->GetCoordName(iDim);
if(aDimName == "x" || aDimName == "X")
anIsDimPresent[eX] = true;
else if(aDimName == "y" || aDimName == "Y")
anIsDimPresent[eY] = true;
else if(aDimName == "z" || aDimName == "Z")
anIsDimPresent[eZ] = true;
}
switch(aMeshDimension){
case 3:
aCoordHelperPtr.reset(new TCoordHelper(aNodeInfo,aXYZGetCoord));
break;
case 2:
if(anIsDimPresent[eY] && anIsDimPresent[eZ])
aCoordHelperPtr.reset(new TCoordHelper(aNodeInfo,aYZGetCoord));
else if(anIsDimPresent[eX] && anIsDimPresent[eZ])
aCoordHelperPtr.reset(new TCoordHelper(aNodeInfo,aXZGetCoord));
else
aCoordHelperPtr.reset(new TCoordHelper(aNodeInfo,aXYGetCoord));
break;
case 1:
if(anIsDimPresent[eY])
aCoordHelperPtr.reset(new TCoordHelper(aNodeInfo,aYGetCoord));
else if(anIsDimPresent[eZ])
aCoordHelperPtr.reset(new TCoordHelper(aNodeInfo,aZGetCoord));
else
aCoordHelperPtr.reset(new TCoordHelper(aNodeInfo,aXGetCoord));
break;
}
}
EBooleen anIsNodeNum = aNodeInfo->IsElemNum(); EBooleen anIsNodeNum = aNodeInfo->IsElemNum();
TInt aNbElems = aNodeInfo->GetNbElem(); TInt aNbElems = aNodeInfo->GetNbElem();
if(MYDEBUG) MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbElems<<"; anIsNodeNum = "<<anIsNodeNum); if(MYDEBUG) MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbElems<<"; anIsNodeNum = "<<anIsNodeNum);
for(TInt iElem = 0; iElem < aNbElems; iElem++){ for(TInt iElem = 0; iElem < aNbElems; iElem++){
TCCoordSlice aCoordSlice = aNodeInfo->GetCoordSlice(iElem);
double aCoords[3] = {0.0, 0.0, 0.0}; double aCoords[3] = {0.0, 0.0, 0.0};
for(TInt iDim = 0; iDim < 3; iDim++) for(TInt iDim = 0; iDim < 3; iDim++)
aCoords[iDim] = aCoordHelperPtr->GetCoord(iElem,iDim); aCoords[iDim] = aCoordHelper->GetCoord(aCoordSlice,iDim);
const SMDS_MeshNode* aNode; const SMDS_MeshNode* aNode;
if(anIsNodeNum) { if(anIsNodeNum) {
aNode = myMesh->AddNodeWithID aNode = myMesh->AddNodeWithID
@ -256,6 +152,7 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
// Reading pre information about all MED cells // Reading pre information about all MED cells
//-------------------------------------------- //--------------------------------------------
typedef std::vector<int> TNodeIds;
bool takeNumbers = true; // initially we trust the numbers from file bool takeNumbers = true; // initially we trust the numbers from file
MED::TEntityInfo aEntityInfo = aMed->GetEntityInfo(aMeshInfo); MED::TEntityInfo aEntityInfo = aMed->GetEntityInfo(aMeshInfo);
MED::TEntityInfo::iterator anEntityIter = aEntityInfo.begin(); MED::TEntityInfo::iterator anEntityIter = aEntityInfo.begin();
@ -264,62 +161,48 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
if(anEntity == eNOEUD) continue; if(anEntity == eNOEUD) continue;
// Reading MED cells to the corresponding SMDS structure // Reading MED cells to the corresponding SMDS structure
//------------------------------------------------------ //------------------------------------------------------
const MED::TGeom& aTGeom = anEntityIter->second; const MED::TGeom2Size& aGeom2Size = anEntityIter->second;
MED::TGeom::const_iterator anTGeomIter = aTGeom.begin(); MED::TGeom2Size::const_iterator aGeom2SizeIter = aGeom2Size.begin();
for(; anTGeomIter != aTGeom.end(); anTGeomIter++){ for(; aGeom2SizeIter != aGeom2Size.end(); aGeom2SizeIter++){
const EGeometrieElement& aGeom = anTGeomIter->first; const EGeometrieElement& aGeom = aGeom2SizeIter->first;
if (aGeom == ePOINT1) { switch(aGeom){
continue; case ePOINT1:
break;
} else if (aGeom == ePOLYGONE) { case ePOLYGONE: {
PPolygoneInfo aPolygoneInfo = aMed->GetPPolygoneInfo(aMeshInfo,anEntity,aGeom); PPolygoneInfo aPolygoneInfo = aMed->GetPPolygoneInfo(aMeshInfo,anEntity,aGeom);
EBooleen anIsElemNum = takeNumbers ? aPolygoneInfo->IsElemNum() : eFAUX; EBooleen anIsElemNum = takeNumbers ? aPolygoneInfo->IsElemNum() : eFAUX;
TElemNum aConn = aPolygoneInfo->GetConnectivite(); TInt aNbElem = aPolygoneInfo->GetNbElem();
TElemNum aIndex = aPolygoneInfo->GetIndex(); for(TInt iElem = 0; iElem < aNbElem; iElem++){
MED::TCConnSlice aConnSlice = aPolygoneInfo->GetConnSlice(iElem);
TInt nbPolygons = aPolygoneInfo->GetNbElem(); TInt aNbConn = aPolygoneInfo->GetNbConn(iElem);
TNodeIds aNodeIds(aNbConn);
for (TInt iPG = 0; iPG < nbPolygons; iPG++) {
// get nodes
TInt aCurrPG_FirstNodeIndex = aIndex[iPG] - 1;
int nbNodes = aPolygoneInfo->GetNbConn(iPG);
std::vector<int> nodes_ids (nbNodes);
//for (TInt inode = 0; inode < nbNodes; inode++) {
// nodes_ids[inode] = aConn[aCurrPG_FirstNodeIndex + inode];
//}
#ifdef _EDF_NODE_IDS_ #ifdef _EDF_NODE_IDS_
if (anIsNodeNum) { if(anIsNodeNum)
for (TInt inode = 0; inode < nbNodes; inode++) { for(TInt iConn = 0; iConn < aNbConn; iConn++)
nodes_ids[inode] = aNodeInfo->GetElemNum(aConn[aCurrPG_FirstNodeIndex + inode] - 1); aNodeIds[iConn] = aNodeInfo->GetElemNum(aConnSlice[iConn] - 1);
} else
} else { for(TInt iConn = 0; iConn < aNbConn; iConn++)
for (TInt inode = 0; inode < nbNodes; inode++) { aNodeIds[iConn] = aConnSlice[iConn];
nodes_ids[inode] = aConn[aCurrPG_FirstNodeIndex + inode];
}
}
#else #else
for (TInt inode = 0; inode < nbNodes; inode++) { for(TInt iConn = 0; iConn < aNbConn; iConn++)
nodes_ids[inode] = aConn[aCurrPG_FirstNodeIndex + inode]; aNodeIds[iConn] = aConnSlice[iConn];
}
#endif #endif
bool isRenum = false; bool isRenum = false;
SMDS_MeshElement* anElement = NULL; SMDS_MeshElement* anElement = NULL;
TInt aFamNum = aPolygoneInfo->GetFamNum(iPG); TInt aFamNum = aPolygoneInfo->GetFamNum(iElem);
try{ try{
if(anIsElemNum){ if(anIsElemNum){
anElement = myMesh->AddPolygonalFaceWithID TInt anElemId = aPolygoneInfo->GetElemNum(iElem);
(nodes_ids, aPolygoneInfo->GetElemNum(iPG)); anElement = myMesh->AddPolygonalFaceWithID(aNodeIds,anElemId);
} }
if(!anElement){ if(!anElement){
std::vector<const SMDS_MeshNode*> nodes (nbNodes); std::vector<const SMDS_MeshNode*> aNodes(aNbConn);
for (int inode = 0; inode < nbNodes; inode++) { for(TInt iConn = 0; iConn < aNbConn; iConn++)
nodes[inode] = FindNode(myMesh, nodes_ids[inode]); aNodes[iConn] = FindNode(myMesh,aNodeIds[iConn]);
} anElement = myMesh->AddPolygonalFace(aNodes);
anElement = myMesh->AddPolygonalFace(nodes);
isRenum = anIsElemNum; isRenum = anIsElemNum;
} }
}catch(const std::exception& exc){ }catch(const std::exception& exc){
@ -344,70 +227,51 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
} }
} }
} // for (TInt iPG = 0; iPG < nbPolygons; iPG++) } // for (TInt iPG = 0; iPG < nbPolygons; iPG++)
continue; break;
}
} else if (aGeom == ePOLYEDRE) { case ePOLYEDRE: {
PPolyedreInfo aPolyedreInfo = aMed->GetPPolyedreInfo(aMeshInfo,anEntity,aGeom); PPolyedreInfo aPolyedreInfo = aMed->GetPPolyedreInfo(aMeshInfo,anEntity,aGeom);
EBooleen anIsElemNum = takeNumbers ? aPolyedreInfo->IsElemNum() : eFAUX; EBooleen anIsElemNum = takeNumbers ? aPolyedreInfo->IsElemNum() : eFAUX;
TElemNum aConn = aPolyedreInfo->GetConnectivite(); TInt aNbElem = aPolyedreInfo->GetNbElem();
TElemNum aFacesIndex = aPolyedreInfo->GetFacesIndex(); for(TInt iElem = 0; iElem < aNbElem; iElem++){
TElemNum aIndex = aPolyedreInfo->GetIndex(); MED::TCConnSliceArr aConnSliceArr = aPolyedreInfo->GetConnSliceArr(iElem);
TInt aNbFaces = aConnSliceArr.size();
TInt nbPolyedres = aPolyedreInfo->GetNbElem(); typedef std::vector<int> TQuantities;
TQuantities aQuantities(aNbFaces);
for (int iPE = 0; iPE < nbPolyedres; iPE++) { TInt aNbNodes = aPolyedreInfo->GetNbNodes(iElem);
// get faces TNodeIds aNodeIds(aNbNodes);
int aCurrPE_FirstFaceIndex = aIndex[iPE] - 1; for(TInt iFace = 0, iNode = 0; iFace < aNbFaces; iFace++){
int aNextPE_FirstFaceIndex = aIndex[iPE + 1] - 1; MED::TCConnSlice aConnSlice = aConnSliceArr[iFace];
int nbFaces = aNextPE_FirstFaceIndex - aCurrPE_FirstFaceIndex; TInt aNbConn = aConnSlice.size();
std::vector<int> quantities (nbFaces); aQuantities[iFace] = aNbConn;
for (int iFa = 0; iFa < nbFaces; iFa++) {
int aCurrFace_FirstNodeIndex = aFacesIndex[aCurrPE_FirstFaceIndex + iFa] - 1;
int aNextFace_FirstNodeIndex = aFacesIndex[aCurrPE_FirstFaceIndex + iFa + 1] - 1;
int nbNodes = aNextFace_FirstNodeIndex - aCurrFace_FirstNodeIndex;
quantities[iFa] = nbNodes;
}
// get nodes
int aCurrPE_FirstNodeIndex = aFacesIndex[aCurrPE_FirstFaceIndex] - 1;
int nbPENodes = aPolyedreInfo->GetNbConn(iPE);
std::vector<int> nodes_ids (nbPENodes);
//for (int inode = 0; inode < nbPENodes; inode++) {
// nodes_ids[inode] = aConn[aCurrPE_FirstNodeIndex + inode];
//}
#ifdef _EDF_NODE_IDS_ #ifdef _EDF_NODE_IDS_
if (anIsNodeNum) { if(anIsNodeNum)
for (int inode = 0; inode < nbPENodes; inode++) { for(TInt iConn = 0; iConn < aNbConn; iConn++)
nodes_ids[inode] = aNodeInfo->GetElemNum(aConn[aCurrPE_FirstNodeIndex + inode] - 1); aNodeIds[iNode++] = aNodeInfo->GetElemNum(aConnSlice[iConn] - 1);
} else
} else { for(TInt iConn = 0; iConn < aNbConn; iConn++)
for (int inode = 0; inode < nbPENodes; inode++) { aNodeIds[iNode++] = aConnSlice[iConn];
nodes_ids[inode] = aConn[aCurrPE_FirstNodeIndex + inode];
}
}
#else #else
for (int inode = 0; inode < nbPENodes; inode++) { for(TInt iConn = 0; iConn < aNbConn; iConn++)
nodes_ids[inode] = aConn[aCurrPE_FirstNodeIndex + inode]; aNodeIds[iNode++] = aConnSlice[iConn];
}
#endif #endif
}
bool isRenum = false; bool isRenum = false;
SMDS_MeshElement* anElement = NULL; SMDS_MeshElement* anElement = NULL;
TInt aFamNum = aPolyedreInfo->GetFamNum(iPE); TInt aFamNum = aPolyedreInfo->GetFamNum(iElem);
try{ try{
if(anIsElemNum){ if(anIsElemNum){
anElement = myMesh->AddPolyhedralVolumeWithID TInt anElemId = aPolyedreInfo->GetElemNum(iElem);
(nodes_ids, quantities, aPolyedreInfo->GetElemNum(iPE)); anElement = myMesh->AddPolyhedralVolumeWithID(aNodeIds,aQuantities,anElemId);
} }
if(!anElement){ if(!anElement){
std::vector<const SMDS_MeshNode*> nodes (nbPENodes); std::vector<const SMDS_MeshNode*> aNodes(aNbNodes);
for (int inode = 0; inode < nbPENodes; inode++) { for(TInt iConn = 0; iConn < aNbNodes; iConn++)
nodes[inode] = FindNode(myMesh, nodes_ids[inode]); aNodes[iConn] = FindNode(myMesh,aNodeIds[iConn]);
} anElement = myMesh->AddPolyhedralVolume(aNodes,aQuantities);
anElement = myMesh->AddPolyhedralVolume(nodes, quantities);
isRenum = anIsElemNum; isRenum = anIsElemNum;
} }
}catch(const std::exception& exc){ }catch(const std::exception& exc){
@ -432,11 +296,9 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
} }
} }
} // for (int iPE = 0; iPE < nbPolyedres; iPE++) } // for (int iPE = 0; iPE < nbPolyedres; iPE++)
continue; break;
} else {
} }
default: {
PCellInfo aCellInfo = aMed->GetPCellInfo(aMeshInfo,anEntity,aGeom); PCellInfo aCellInfo = aMed->GetPCellInfo(aMeshInfo,anEntity,aGeom);
EBooleen anIsElemNum = takeNumbers ? aCellInfo->IsElemNum() : eFAUX; EBooleen anIsElemNum = takeNumbers ? aCellInfo->IsElemNum() : eFAUX;
TInt aNbElems = aCellInfo->GetNbElem(); TInt aNbElems = aCellInfo->GetNbElem();
@ -476,24 +338,20 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
aNbNodes = 8; aNbNodes = 8;
break; break;
} }
vector<TInt> aNodeIds(aNbNodes); TNodeIds aNodeIds(aNbNodes);
bool anIsValidConnect = false; bool anIsValidConnect = false;
TCConnSlice aConnSlice = aCellInfo->GetConnSlice(iElem);
try{ try{
#ifdef _EDF_NODE_IDS_ #ifdef _EDF_NODE_IDS_
if(anIsNodeNum) { if(anIsNodeNum)
for(int i = 0; i < aNbNodes; i++){ for(int iNode = 0; iNode < aNbNodes; iNode++)
aNodeIds[i] = aNodeInfo->GetElemNum(aCellInfo->GetConn(iElem,i)-1); aNodeIds[iNode] = aNodeInfo->GetElemNum(aConnSlice[iNode] - 1);
} else
}else{ for(int iNode = 0; iNode < aNbNodes; iNode++)
for(int i = 0; i < aNbNodes; i++){ aNodeIds[iNode] = aConnSlice[iNode];
aNodeIds[i] = aCellInfo->GetConn(iElem,i);
}
}
#else #else
for(int i = 0; i < aNbNodes; i++){ for(int iNode = 0; iNode < aNbNodes; iNode++)
aNodeIds[i] = aCellInfo->GetConn(iElem,i); aNodeIds[iNode] = aConnSlice[iNode];
}
#endif #endif
anIsValidConnect = true; anIsValidConnect = true;
}catch(const std::exception& exc){ }catch(const std::exception& exc){
@ -668,9 +526,9 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
} }
} }
} }
}}
} }
} }
break;
} }
} }
}catch(const std::exception& exc){ }catch(const std::exception& exc){

25
src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
View File

@ -365,8 +365,9 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
const ERepere SMDS_COORDINATE_SYSTEM = eCART; const ERepere SMDS_COORDINATE_SYSTEM = eCART;
PNodeInfo aNodeInfo = myMed->CrNodeInfo(aMeshInfo, PNodeInfo aNodeInfo = myMed->CrNodeInfo(aMeshInfo,
SMDS_COORDINATE_SYSTEM,
aCoordinates, aCoordinates,
eFULL_INTERLACE,
SMDS_COORDINATE_SYSTEM,
aCoordNames, aCoordNames,
aCoordUnits, aCoordUnits,
aFamilyNums, aFamilyNums,
@ -413,8 +414,8 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo, PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
SMDS_MED_ENTITY, SMDS_MED_ENTITY,
eSEG2, eSEG2,
SMDS_MED_CONNECTIVITY,
aConnectivity, aConnectivity,
SMDS_MED_CONNECTIVITY,
aFamilyNums, aFamilyNums,
anElemNums); anElemNums);
myMed->SetCellInfo(aCellInfo); myMed->SetCellInfo(aCellInfo);
@ -524,8 +525,8 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo, PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
SMDS_MED_ENTITY, SMDS_MED_ENTITY,
eTRIA3, eTRIA3,
SMDS_MED_CONNECTIVITY,
aTriaConn, aTriaConn,
SMDS_MED_CONNECTIVITY,
aTriaFamilyNums, aTriaFamilyNums,
anTriaElemNums); anTriaElemNums);
MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTRIA3<<"; aNbElems = "<<aNbElems); MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTRIA3<<"; aNbElems = "<<aNbElems);
@ -535,8 +536,8 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo, PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
SMDS_MED_ENTITY, SMDS_MED_ENTITY,
eQUAD4, eQUAD4,
SMDS_MED_CONNECTIVITY,
aQuadConn, aQuadConn,
SMDS_MED_CONNECTIVITY,
aQuadFamilyNums, aQuadFamilyNums,
aQuadElemNums); aQuadElemNums);
MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eQUAD4<<"; aNbElems = "<<aNbElems); MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eQUAD4<<"; aNbElems = "<<aNbElems);
@ -550,9 +551,9 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
PPolygoneInfo aCellInfo = myMed->CrPolygoneInfo(aMeshInfo, PPolygoneInfo aCellInfo = myMed->CrPolygoneInfo(aMeshInfo,
SMDS_MED_ENTITY, SMDS_MED_ENTITY,
ePOLYGONE, ePOLYGONE,
SMDS_MED_CONNECTIVITY,
aPolygoneConn, aPolygoneConn,
aPolygoneInds, aPolygoneInds,
SMDS_MED_CONNECTIVITY,
aPolygoneFamilyNums, aPolygoneFamilyNums,
aPolygoneElemNums); aPolygoneElemNums);
MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePOLYGONE<<"; aNbElems = "<<aNbElems); MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePOLYGONE<<"; aNbElems = "<<aNbElems);
@ -714,8 +715,8 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo, PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
SMDS_MED_ENTITY, SMDS_MED_ENTITY,
eTETRA4, eTETRA4,
SMDS_MED_CONNECTIVITY,
aTetraConn, aTetraConn,
SMDS_MED_CONNECTIVITY,
aTetraFamilyNums, aTetraFamilyNums,
anTetraElemNums); anTetraElemNums);
MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTETRA4<<"; aNbElems = "<<aNbElems); MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTETRA4<<"; aNbElems = "<<aNbElems);
@ -725,8 +726,8 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo, PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
SMDS_MED_ENTITY, SMDS_MED_ENTITY,
ePYRA5, ePYRA5,
SMDS_MED_CONNECTIVITY,
aPyraConn, aPyraConn,
SMDS_MED_CONNECTIVITY,
aPyraFamilyNums, aPyraFamilyNums,
anPyraElemNums); anPyraElemNums);
MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePYRA5<<"; aNbElems = "<<aNbElems); MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePYRA5<<"; aNbElems = "<<aNbElems);
@ -736,8 +737,8 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo, PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
SMDS_MED_ENTITY, SMDS_MED_ENTITY,
ePENTA6, ePENTA6,
SMDS_MED_CONNECTIVITY,
aPentaConn, aPentaConn,
SMDS_MED_CONNECTIVITY,
aPentaFamilyNums, aPentaFamilyNums,
anPentaElemNums); anPentaElemNums);
MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePENTA6<<"; aNbElems = "<<aNbElems); MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePENTA6<<"; aNbElems = "<<aNbElems);
@ -747,8 +748,8 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo, PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
SMDS_MED_ENTITY, SMDS_MED_ENTITY,
eHEXA8, eHEXA8,
SMDS_MED_CONNECTIVITY,
aHexaConn, aHexaConn,
SMDS_MED_CONNECTIVITY,
aHexaFamilyNums, aHexaFamilyNums,
aHexaElemNums); aHexaElemNums);
MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eHEXA8<<"; aNbElems = "<<aNbElems); MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eHEXA8<<"; aNbElems = "<<aNbElems);
@ -762,10 +763,10 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
PPolyedreInfo aCellInfo = myMed->CrPolyedreInfo(aMeshInfo, PPolyedreInfo aCellInfo = myMed->CrPolyedreInfo(aMeshInfo,
SMDS_MED_ENTITY, SMDS_MED_ENTITY,
ePOLYEDRE, ePOLYEDRE,
SMDS_MED_CONNECTIVITY,
aPolyedreConn,
aPolyedreFaces,
aPolyedreInds, aPolyedreInds,
aPolyedreFaces,
aPolyedreConn,
SMDS_MED_CONNECTIVITY,
aPolyedreFamilyNums, aPolyedreFamilyNums,
aPolyedreElemNums); aPolyedreElemNums);
MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePOLYEDRE<<"; aNbElems = "<<aNbElems); MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePOLYEDRE<<"; aNbElems = "<<aNbElems);