ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-02-11 17:53:08 +05:00
Code Issues Packages Projects Releases Wiki Activity

[Bug PAL7252] DEVELOPMENT: Porting to MED2.2

Browse Source
This commit is contained in:
apo 2004-12-28 13:48:15 +00:00
parent 57d4d5c456
commit f432a8d3c1
12 changed files with 318 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
adm_local/unix/make_commence.in
View File

@ -97,12 +97,6 @@ HDF5_INCLUDES=@HDF5_INCLUDES@
HDF5_LIBS=@HDF5_LIBS@ HDF5_LIBS=@HDF5_LIBS@
HDF5_MT_LIBS=@HDF5_MT_LIBS@ HDF5_MT_LIBS=@HDF5_MT_LIBS@
# MED2
MED2_INCLUDES=@MED2_INCLUDES@
MED2_LIBS=@MED2_LIBS@
MED2_MT_LIBS=@MED2_MT_LIBS@
# OpenCasCade # OpenCasCade
OCC_INCLUDES=@CAS_CPPFLAGS@ OCC_INCLUDES=@CAS_CPPFLAGS@
@ -251,8 +245,8 @@ ac_cxx_mutable.m4 check_mico.m4 libtool.m4 \
ac_cxx_namespaces.m4 check_omniorb.m4 pyembed.m4 \ ac_cxx_namespaces.m4 check_omniorb.m4 pyembed.m4 \
ac_cxx_partial_specialization.m4 check_opengl.m4 python.m4 \ ac_cxx_partial_specialization.m4 check_opengl.m4 python.m4 \
ac_cxx_typename.m4 check_pthreads.m4 check_cas.m4 \ ac_cxx_typename.m4 check_pthreads.m4 check_cas.m4 \
ac_cc_warnings.m4 check_qt.m4 check_med2.m4 \ ac_cc_warnings.m4 check_qt.m4 check_boost.m4 \
check_swig.m4 check_boost.m4 check_swig.m4
$(top_srcdir)/aclocal.m4: $(ACLOCAL_SRC:%=@KERNEL_ROOT_DIR@/salome_adm/unix/config_files/%) $(top_srcdir)/aclocal.m4: $(ACLOCAL_SRC:%=@KERNEL_ROOT_DIR@/salome_adm/unix/config_files/%)
cd $(top_srcdir) ; aclocal --acdir=adm_local/unix/config_files -I @KERNEL_ROOT_DIR@/salome_adm/unix/config_files cd $(top_srcdir) ; aclocal --acdir=adm_local/unix/config_files -I @KERNEL_ROOT_DIR@/salome_adm/unix/config_files

10
configure.in.base
View File

@ -233,14 +233,6 @@ echo
CHECK_HDF5 CHECK_HDF5
echo
echo ---------------------------------------------
echo testing MED2
echo ---------------------------------------------
echo
CHECK_MED2
echo echo
echo --------------------------------------------- echo ---------------------------------------------
echo Testing OpenCascade echo Testing OpenCascade
@ -288,7 +280,7 @@ echo ---------------------------------------------
echo echo
echo Configure echo Configure
variables="cc_ok boost_ok lex_yacc_ok python_ok swig_ok threads_ok OpenGL_ok qt_ok vtk_ok hdf5_ok med2_ok omniORB_ok occ_ok doxygen_ok graphviz_ok Kernel_ok Geom_ok Med_ok" variables="cc_ok boost_ok lex_yacc_ok python_ok swig_ok threads_ok OpenGL_ok qt_ok vtk_ok hdf5_ok omniORB_ok occ_ok doxygen_ok graphviz_ok Kernel_ok Geom_ok Med_ok"
for var in $variables for var in $variables
do do

13
src/DriverMED/DriverMED_Family.cxx
View File

@ -26,6 +26,8 @@
// $Header$ // $Header$
#include "DriverMED_Family.h" #include "DriverMED_Family.h"
#include "MED_Factory.hxx"
#include <sstream> #include <sstream>
using namespace std; using namespace std;
@ -204,8 +206,9 @@ list<DriverMED_FamilyPtr> DriverMED_Family::MakeFamilies
* Create TFamilyInfo for this family * Create TFamilyInfo for this family
*/ */
//============================================================================= //=============================================================================
MEDA::PFamilyInfo DriverMED_Family::GetFamilyInfo MED::PFamilyInfo
(const MEDA::PMeshInfo& theMeshInfo) const DriverMED_Family::GetFamilyInfo(const MED::PWrapper& theWrapper,
const MED::PMeshInfo& theMeshInfo) const
{ {
string aValue; string aValue;
ostringstream aStr; ostringstream aStr;
@ -215,11 +218,13 @@ MEDA::PFamilyInfo DriverMED_Family::GetFamilyInfo
MED::TIntVector anAttrIds (1, myId); // Id=0, MED::TIntVector anAttrIds (1, myId); // Id=0,
MED::TIntVector anAttrVals (1, myId); // Value=0 MED::TIntVector anAttrVals (1, myId); // Value=0
MEDA::PFamilyInfo anInfo = MEDA::TWrapper::CrFamilyInfo(theMeshInfo, MED::PFamilyInfo anInfo = theWrapper->CrFamilyInfo(theMeshInfo,
aValue, aValue,
myId, myId,
myGroupNames, myGroupNames,
anAttrDescs,anAttrIds,anAttrVals); anAttrDescs,
anAttrIds,
anAttrVals);
// cout << endl; // cout << endl;
// cout << "Groups: "; // cout << "Groups: ";

5
src/DriverMED/DriverMED_Family.h
View File

@ -31,7 +31,7 @@
#include "SMDS_Mesh.hxx" #include "SMDS_Mesh.hxx"
#include "SMESHDS_GroupBase.hxx" #include "SMESHDS_GroupBase.hxx"
#include "SMESHDS_SubMesh.hxx" #include "SMESHDS_SubMesh.hxx"
#include "MEDA_Wrapper.hxx" #include "MED_Common.hxx"
#include <boost/shared_ptr.hpp> #include <boost/shared_ptr.hpp>
#include <set> #include <set>
@ -63,7 +63,8 @@ class DriverMED_Family
// from <theGroups> and other sub-meshes from <theSubMeshes>. // from <theGroups> and other sub-meshes from <theSubMeshes>.
// Resulting families have no common elements. // Resulting families have no common elements.
MEDA::PFamilyInfo GetFamilyInfo (const MEDA::PMeshInfo& theMeshInfo) const; MED::PFamilyInfo GetFamilyInfo (const MED::PWrapper& theWrapper,
const MED::PMeshInfo& theMeshInfo) const;
// Create TFamilyInfo for this family // Create TFamilyInfo for this family
const std::set<const SMDS_MeshElement *>& GetElements () const { return myElements; } const std::set<const SMDS_MeshElement *>& GetElements () const { return myElements; }

144
src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx
View File

@ -33,20 +33,22 @@
#include "SMESHDS_Group.hxx" #include "SMESHDS_Group.hxx"
#include "MEDA_Wrapper.hxx" #include "MED_Factory.hxx"
#include "MED_Utilities.hxx" #include "MED_Utilities.hxx"
#include <stdlib.h> #include <stdlib.h>
#define _EDF_NODE_IDS_ #define _EDF_NODE_IDS_
using namespace MED;
void DriverMED_R_SMESHDS_Mesh::SetMeshName(string theMeshName) void DriverMED_R_SMESHDS_Mesh::SetMeshName(string theMeshName)
{ {
myMeshName = theMeshName; myMeshName = theMeshName;
} }
static const SMDS_MeshNode* static const SMDS_MeshNode*
FindNode(const SMDS_Mesh* theMesh, med_int theId){ FindNode(const SMDS_Mesh* theMesh, TInt theId){
const SMDS_MeshNode* aNode = theMesh->FindNode(theId); const SMDS_MeshNode* aNode = theMesh->FindNode(theId);
if(aNode) return aNode; if(aNode) return aNode;
EXCEPTION(runtime_error,"SMDS_Mesh::FindNode - cannot find a SMDS_MeshNode for ID = "<<theId); EXCEPTION(runtime_error,"SMDS_Mesh::FindNode - cannot find a SMDS_MeshNode for ID = "<<theId);
@ -54,15 +56,15 @@ FindNode(const SMDS_Mesh* theMesh, med_int theId){
enum ECoordName{eX, eY, eZ, eNone}; enum ECoordName{eX, eY, eZ, eNone};
typedef med_float (*TGetCoord)(MEDA::PNodeInfo&, med_int); typedef TFloat (*TGetCoord)(MED::PNodeInfo&, TInt);
template<ECoordName TheCoordId> template<ECoordName TheCoordId>
med_float GetCoord(MEDA::PNodeInfo& thePNodeInfo, med_int theElemId){ TFloat GetCoord(MED::PNodeInfo& thePNodeInfo, TInt theElemId){
return thePNodeInfo->GetNodeCoord(theElemId,TheCoordId); return thePNodeInfo->GetNodeCoord(theElemId,TheCoordId);
} }
template<> template<>
med_float GetCoord<eNone>(MEDA::PNodeInfo& thePNodeInfo, med_int theElemId){ TFloat GetCoord<eNone>(MED::PNodeInfo& thePNodeInfo, TInt theElemId){
return 0.0; return 0.0;
} }
@ -113,16 +115,16 @@ static TGetCoord aZGetCoord[3] = {
class TCoordHelper{ class TCoordHelper{
MEDA::PNodeInfo myPNodeInfo; MED::PNodeInfo myPNodeInfo;
TGetCoord* myGetCoord; TGetCoord* myGetCoord;
public: public:
TCoordHelper(const MEDA::PNodeInfo& thePNodeInfo, TCoordHelper(const MED::PNodeInfo& thePNodeInfo,
TGetCoord* theGetCoord): TGetCoord* theGetCoord):
myPNodeInfo(thePNodeInfo), myPNodeInfo(thePNodeInfo),
myGetCoord(theGetCoord) myGetCoord(theGetCoord)
{} {}
virtual ~TCoordHelper(){} virtual ~TCoordHelper(){}
med_float GetCoord(med_int theElemId, med_int theCoodId){ TFloat GetCoord(TInt theElemId, TInt theCoodId){
return (*myGetCoord[theCoodId])(myPNodeInfo,theElemId); return (*myGetCoord[theCoodId])(myPNodeInfo,theElemId);
} }
}; };
@ -133,18 +135,16 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
{ {
Status aResult = DRS_FAIL; Status aResult = DRS_FAIL;
try{ try{
using namespace MEDA;
myFamilies.clear(); myFamilies.clear();
MESSAGE("Perform - myFile : "<<myFile); MESSAGE("Perform - myFile : "<<myFile);
TWrapper aMed(myFile); PWrapper aMed = CrWrapper(myFile);
aResult = DRS_EMPTY; aResult = DRS_EMPTY;
if(med_int aNbMeshes = aMed.GetNbMeshes()){ if(TInt aNbMeshes = aMed->GetNbMeshes()){
for(int iMesh = 0; iMesh < aNbMeshes; iMesh++){ for(int iMesh = 0; iMesh < aNbMeshes; iMesh++){
// Reading the MED mesh // Reading the MED mesh
//--------------------- //---------------------
PMeshInfo aMeshInfo = aMed.GetMeshInfo(iMesh); PMeshInfo aMeshInfo = aMed->GetPMeshInfo(iMesh+1);
string aMeshName; string aMeshName;
if (myMeshId != -1) { if (myMeshId != -1) {
ostringstream aMeshNameStr; ostringstream aMeshNameStr;
@ -156,22 +156,22 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
MESSAGE("Perform - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName()); MESSAGE("Perform - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
if(aMeshName != aMeshInfo->GetName()) continue; if(aMeshName != aMeshInfo->GetName()) continue;
aResult = DRS_OK; aResult = DRS_OK;
med_int aMeshDim = aMeshInfo->GetDim(); //TInt aMeshDim = aMeshInfo->GetDim();
// Reading MED families to the temporary structure // Reading MED families to the temporary structure
//------------------------------------------------ //------------------------------------------------
med_int aNbFams = aMed.GetNbFamilies(aMeshInfo); TInt aNbFams = aMed->GetNbFamilies(aMeshInfo);
MESSAGE("Read " << aNbFams << " families"); MESSAGE("Read " << aNbFams << " families");
for (med_int iFam = 0; iFam < aNbFams; iFam++) { for (TInt iFam = 0; iFam < aNbFams; iFam++) {
PFamilyInfo aFamilyInfo = aMed.GetFamilyInfo(aMeshInfo, iFam); PFamilyInfo aFamilyInfo = aMed->GetPFamilyInfo(aMeshInfo, iFam+1);
med_int aFamId = aFamilyInfo->GetId(); TInt aFamId = aFamilyInfo->GetId();
MESSAGE("Family " << aFamId << " :"); MESSAGE("Family " << aFamId << " :");
DriverMED_FamilyPtr aFamily (new DriverMED_Family); DriverMED_FamilyPtr aFamily (new DriverMED_Family);
med_int aNbGrp = aFamilyInfo->GetNbGroup(); TInt aNbGrp = aFamilyInfo->GetNbGroup();
MESSAGE("belong to " << aNbGrp << " groups"); MESSAGE("belong to " << aNbGrp << " groups");
for (med_int iGr = 0; iGr < aNbGrp; iGr++) { for (TInt iGr = 0; iGr < aNbGrp; iGr++) {
string aGroupName = aFamilyInfo->GetGroupName(iGr); string aGroupName = aFamilyInfo->GetGroupName(iGr);
MESSAGE(aGroupName); MESSAGE(aGroupName);
aFamily->AddGroupName(aGroupName); aFamily->AddGroupName(aGroupName);
@ -181,13 +181,13 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
// Reading MED nodes to the corresponding SMDS structure // Reading MED nodes to the corresponding SMDS structure
//------------------------------------------------------ //------------------------------------------------------
PNodeInfo aNodeInfo = aMed.GetNodeInfo(aMeshInfo); PNodeInfo aNodeInfo = aMed->GetPNodeInfo(aMeshInfo);
TCoordHelperPtr aCoordHelperPtr; TCoordHelperPtr aCoordHelperPtr;
{ {
med_int aMeshDimension = aMeshInfo->GetDim(); TInt aMeshDimension = aMeshInfo->GetDim();
bool anIsDimPresent[3] = {false, false, false}; bool anIsDimPresent[3] = {false, false, false};
for(med_int iDim = 0; iDim < aMeshDimension; iDim++){ for(TInt iDim = 0; iDim < aMeshDimension; iDim++){
string aDimName = aNodeInfo->GetCoordName(iDim); string aDimName = aNodeInfo->GetCoordName(iDim);
if(aDimName == "x" || aDimName == "X") if(aDimName == "x" || aDimName == "X")
anIsDimPresent[eX] = true; anIsDimPresent[eX] = true;
@ -219,12 +219,12 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
} }
} }
med_booleen anIsNodeNum = aNodeInfo->IsElemNum(); EBooleen anIsNodeNum = aNodeInfo->IsElemNum();
med_int aNbElems = aNodeInfo->GetNbElem(); TInt aNbElems = aNodeInfo->GetNbElem();
MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbElems<<"; anIsNodeNum = "<<anIsNodeNum); MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbElems<<"; anIsNodeNum = "<<anIsNodeNum);
for(med_int iElem = 0; iElem < aNbElems; iElem++){ for(TInt iElem = 0; iElem < aNbElems; iElem++){
double aCoords[3] = {0.0, 0.0, 0.0}; double aCoords[3] = {0.0, 0.0, 0.0};
for(med_int iDim = 0; iDim < 3; iDim++) for(TInt iDim = 0; iDim < 3; iDim++)
aCoords[iDim] = aCoordHelperPtr->GetCoord(iElem,iDim); aCoords[iDim] = aCoordHelperPtr->GetCoord(iElem,iDim);
const SMDS_MeshNode* aNode; const SMDS_MeshNode* aNode;
if(anIsNodeNum) { if(anIsNodeNum) {
@ -237,7 +237,7 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
//cout<<aNode->GetID()<<": "<<aNode->X()<<", "<<aNode->Y()<<", "<<aNode->Z()<<endl; //cout<<aNode->GetID()<<": "<<aNode->X()<<", "<<aNode->Y()<<", "<<aNode->Z()<<endl;
// Save reference to this node from its family // Save reference to this node from its family
med_int aFamNum = aNodeInfo->GetFamNum(iElem); TInt aFamNum = aNodeInfo->GetFamNum(iElem);
if (myFamilies.find(aFamNum) != myFamilies.end()) if (myFamilies.find(aFamNum) != myFamilies.end())
{ {
myFamilies[aFamNum]->AddElement(aNode); myFamilies[aFamNum]->AddElement(aNode);
@ -248,58 +248,58 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
// Reading pre information about all MED cells // Reading pre information about all MED cells
//-------------------------------------------- //--------------------------------------------
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();
for(; anEntityIter != aEntityInfo.end(); anEntityIter++){ for(; anEntityIter != aEntityInfo.end(); anEntityIter++){
const med_entite_maillage& anEntity = anEntityIter->first; const EEntiteMaillage& anEntity = anEntityIter->first;
if(anEntity == MED_NOEUD) 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::TGeom& aTGeom = anEntityIter->second;
MED::TGeom::const_iterator anTGeomIter = aTGeom.begin(); MED::TGeom::const_iterator anTGeomIter = aTGeom.begin();
for(; anTGeomIter != aTGeom.end(); anTGeomIter++){ for(; anTGeomIter != aTGeom.end(); anTGeomIter++){
const med_geometrie_element& aGeom = anTGeomIter->first; const EGeometrieElement& aGeom = anTGeomIter->first;
if(aGeom == MED_POINT1) continue; if(aGeom == ePOINT1) continue;
PCellInfo aCellInfo = aMed.GetCellInfo(aMeshInfo,anEntity,aGeom); PCellInfo aCellInfo = aMed->GetPCellInfo(aMeshInfo,anEntity,aGeom);
med_booleen anIsElemNum = takeNumbers ? aCellInfo->IsElemNum() : MED_FAUX; EBooleen anIsElemNum = takeNumbers ? aCellInfo->IsElemNum() : eFAUX;
med_int aNbElems = aCellInfo->GetNbElem(); TInt aNbElems = aCellInfo->GetNbElem();
MESSAGE("Perform - anEntity = "<<anEntity<<"; anIsElemNum = "<<anIsElemNum); MESSAGE("Perform - anEntity = "<<anEntity<<"; anIsElemNum = "<<anIsElemNum);
MESSAGE("Perform - aGeom = "<<aGeom<<"; aNbElems = "<<aNbElems); MESSAGE("Perform - aGeom = "<<aGeom<<"; aNbElems = "<<aNbElems);
for(int iElem = 0; iElem < aNbElems; iElem++){ for(int iElem = 0; iElem < aNbElems; iElem++){
med_int aNbNodes = -1; TInt aNbNodes = -1;
switch(aGeom){ switch(aGeom){
case MED_SEG2: case eSEG2:
case MED_SEG3: case eSEG3:
aNbNodes = 2; aNbNodes = 2;
break; break;
case MED_TRIA3: case eTRIA3:
case MED_TRIA6: case eTRIA6:
aNbNodes = 3; aNbNodes = 3;
break; break;
break; break;
case MED_QUAD4: case eQUAD4:
case MED_QUAD8: case eQUAD8:
aNbNodes = 4; aNbNodes = 4;
break; break;
case MED_TETRA4: case eTETRA4:
case MED_TETRA10: case eTETRA10:
aNbNodes = 4; aNbNodes = 4;
break; break;
case MED_PYRA5: case ePYRA5:
case MED_PYRA13: case ePYRA13:
aNbNodes = 5; aNbNodes = 5;
break; break;
case MED_PENTA6: case ePENTA6:
case MED_PENTA15: case ePENTA15:
aNbNodes = 6; aNbNodes = 6;
break; break;
case MED_HEXA8: case eHEXA8:
case MED_HEXA20: case eHEXA20:
aNbNodes = 8; aNbNodes = 8;
break; break;
} }
vector<med_int> aNodeIds(aNbNodes); vector<TInt> aNodeIds(aNbNodes);
#ifdef _EDF_NODE_IDS_ #ifdef _EDF_NODE_IDS_
if(anIsNodeNum) { if(anIsNodeNum) {
for(int i = 0; i < aNbNodes; i++){ for(int i = 0; i < aNbNodes; i++){
@ -318,11 +318,11 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
bool isRenum = false; bool isRenum = false;
SMDS_MeshElement* anElement = NULL; SMDS_MeshElement* anElement = NULL;
med_int aFamNum = aCellInfo->GetFamNum(iElem); TInt aFamNum = aCellInfo->GetFamNum(iElem);
try{ try{
switch(aGeom){ switch(aGeom){
case MED_SEG2: case eSEG2:
case MED_SEG3: case eSEG3:
if(anIsElemNum) if(anIsElemNum)
anElement = myMesh->AddEdgeWithID(aNodeIds[0], anElement = myMesh->AddEdgeWithID(aNodeIds[0],
aNodeIds[1], aNodeIds[1],
@ -333,8 +333,8 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
isRenum = anIsElemNum; isRenum = anIsElemNum;
} }
break; break;
case MED_TRIA3: case eTRIA3:
case MED_TRIA6: case eTRIA6:
aNbNodes = 3; aNbNodes = 3;
if(anIsElemNum) if(anIsElemNum)
anElement = myMesh->AddFaceWithID(aNodeIds[0], anElement = myMesh->AddFaceWithID(aNodeIds[0],
@ -348,8 +348,8 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
isRenum = anIsElemNum; isRenum = anIsElemNum;
} }
break; break;
case MED_QUAD4: case eQUAD4:
case MED_QUAD8: case eQUAD8:
aNbNodes = 4; aNbNodes = 4;
// There is some differnce between SMDS and MED // There is some differnce between SMDS and MED
if(anIsElemNum) if(anIsElemNum)
@ -366,8 +366,8 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
isRenum = anIsElemNum; isRenum = anIsElemNum;
} }
break; break;
case MED_TETRA4: case eTETRA4:
case MED_TETRA10: case eTETRA10:
aNbNodes = 4; aNbNodes = 4;
if(anIsElemNum) if(anIsElemNum)
anElement = myMesh->AddVolumeWithID(aNodeIds[0], anElement = myMesh->AddVolumeWithID(aNodeIds[0],
@ -383,8 +383,8 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
isRenum = anIsElemNum; isRenum = anIsElemNum;
} }
break; break;
case MED_PYRA5: case ePYRA5:
case MED_PYRA13: case ePYRA13:
aNbNodes = 5; aNbNodes = 5;
// There is some differnce between SMDS and MED // There is some differnce between SMDS and MED
if(anIsElemNum) if(anIsElemNum)
@ -403,8 +403,8 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
isRenum = anIsElemNum; isRenum = anIsElemNum;
} }
break; break;
case MED_PENTA6: case ePENTA6:
case MED_PENTA15: case ePENTA15:
aNbNodes = 6; aNbNodes = 6;
if(anIsElemNum) if(anIsElemNum)
anElement = myMesh->AddVolumeWithID(aNodeIds[0], anElement = myMesh->AddVolumeWithID(aNodeIds[0],
@ -424,8 +424,8 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
isRenum = anIsElemNum; isRenum = anIsElemNum;
} }
break; break;
case MED_HEXA8: case eHEXA8:
case MED_HEXA20: case eHEXA20:
aNbNodes = 8; aNbNodes = 8;
if(anIsElemNum) if(anIsElemNum)
anElement = myMesh->AddVolumeWithID(aNodeIds[0], anElement = myMesh->AddVolumeWithID(aNodeIds[0],
@ -463,7 +463,7 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
} }
else { else {
if (isRenum) { if (isRenum) {
anIsElemNum = MED_FAUX; anIsElemNum = eFAUX;
takeNumbers = false; takeNumbers = false;
if (aResult < DRS_WARN_RENUMBER) if (aResult < DRS_WARN_RENUMBER)
aResult = DRS_WARN_RENUMBER; aResult = DRS_WARN_RENUMBER;
@ -496,17 +496,15 @@ list<string> DriverMED_R_SMESHDS_Mesh::GetMeshNames(Status& theStatus)
list<string> aMeshNames; list<string> aMeshNames;
try { try {
using namespace MEDA;
MESSAGE("GetMeshNames - myFile : " << myFile); MESSAGE("GetMeshNames - myFile : " << myFile);
theStatus = DRS_OK; theStatus = DRS_OK;
TWrapper aMed (myFile); PWrapper aMed = CrWrapper(myFile);
if (med_int aNbMeshes = aMed.GetNbMeshes()) { if (TInt aNbMeshes = aMed->GetNbMeshes()) {
for (int iMesh = 0; iMesh < aNbMeshes; iMesh++) { for (int iMesh = 0; iMesh < aNbMeshes; iMesh++) {
// Reading the MED mesh // Reading the MED mesh
//--------------------- //---------------------
PMeshInfo aMeshInfo = aMed.GetMeshInfo(iMesh); PMeshInfo aMeshInfo = aMed->GetPMeshInfo(iMesh+1);
aMeshNames.push_back(aMeshInfo->GetName()); aMeshNames.push_back(aMeshInfo->GetName());
} }
} }

243
src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
View File

@ -35,13 +35,15 @@
#include "SMDS_MeshNode.hxx" #include "SMDS_MeshNode.hxx"
#include "utilities.h" #include "utilities.h"
#include "MEDA_Wrapper.hxx" #include "MED_Factory.hxx"
#include "MED_Utilities.hxx" #include "MED_Utilities.hxx"
#define _EDF_NODE_IDS_ #define _EDF_NODE_IDS_
//#define _ELEMENTS_BY_DIM_ //#define _ELEMENTS_BY_DIM_
using namespace std; using namespace std;
using namespace MED;
DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh(): DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
myAllSubMeshes (false), myAllSubMeshes (false),
@ -51,6 +53,17 @@ DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
myDoGroupOfVolumes (false) myDoGroupOfVolumes (false)
{} {}
void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName, MED::EVersion theId)
{
myMed = CrWrapper(theFileName,theId);
Driver_SMESHDS_Mesh::SetFile(theFileName);
}
void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName)
{
return SetFile(theFileName,MED::eV2_1);
}
void DriverMED_W_SMESHDS_Mesh::SetMeshName(const std::string& theMeshName) void DriverMED_W_SMESHDS_Mesh::SetMeshName(const std::string& theMeshName)
{ {
myMeshName = theMeshName; myMeshName = theMeshName;
@ -91,62 +104,63 @@ void DriverMED_W_SMESHDS_Mesh::AddGroupOfVolumes()
myDoGroupOfVolumes = true; myDoGroupOfVolumes = true;
} }
typedef double (SMDS_MeshNode::* TGetCoord)() const; namespace{
typedef const char* TName; typedef double (SMDS_MeshNode::* TGetCoord)() const;
typedef const char* TUnit; typedef const char* TName;
typedef const char* TUnit;
static TUnit aUnit[3] = {"m","m","m"}; TUnit aUnit[3] = {"m","m","m"};
static TGetCoord aXYZGetCoord[3] = { TGetCoord aXYZGetCoord[3] = {
&SMDS_MeshNode::X, &SMDS_MeshNode::X,
&SMDS_MeshNode::Y, &SMDS_MeshNode::Y,
&SMDS_MeshNode::Z &SMDS_MeshNode::Z
}; };
static TName aXYZName[3] = {"x","y","z"}; TName aXYZName[3] = {"x","y","z"};
static TGetCoord aXYGetCoord[2] = { TGetCoord aXYGetCoord[2] = {
&SMDS_MeshNode::X, &SMDS_MeshNode::X,
&SMDS_MeshNode::Y &SMDS_MeshNode::Y
}; };
static TName aXYName[2] = {"x","y"}; TName aXYName[2] = {"x","y"};
static TGetCoord aYZGetCoord[2] = { TGetCoord aYZGetCoord[2] = {
&SMDS_MeshNode::Y, &SMDS_MeshNode::Y,
&SMDS_MeshNode::Z &SMDS_MeshNode::Z
}; };
static TName aYZName[2] = {"y","z"}; TName aYZName[2] = {"y","z"};
static TGetCoord aXZGetCoord[2] = { TGetCoord aXZGetCoord[2] = {
&SMDS_MeshNode::X, &SMDS_MeshNode::X,
&SMDS_MeshNode::Z &SMDS_MeshNode::Z
}; };
static TName aXZName[2] = {"x","z"}; TName aXZName[2] = {"x","z"};
static TGetCoord aXGetCoord[1] = { TGetCoord aXGetCoord[1] = {
&SMDS_MeshNode::X &SMDS_MeshNode::X
}; };
static TName aXName[1] = {"x"}; TName aXName[1] = {"x"};
static TGetCoord aYGetCoord[1] = { TGetCoord aYGetCoord[1] = {
&SMDS_MeshNode::Y &SMDS_MeshNode::Y
}; };
static TName aYName[1] = {"y"}; TName aYName[1] = {"y"};
static TGetCoord aZGetCoord[1] = { TGetCoord aZGetCoord[1] = {
&SMDS_MeshNode::Z &SMDS_MeshNode::Z
}; };
static TName aZName[1] = {"z"}; TName aZName[1] = {"z"};
class TCoordHelper{ class TCoordHelper{
SMDS_NodeIteratorPtr myNodeIter; SMDS_NodeIteratorPtr myNodeIter;
const SMDS_MeshNode* myCurrentNode; const SMDS_MeshNode* myCurrentNode;
TGetCoord* myGetCoord; TGetCoord* myGetCoord;
TName* myName; TName* myName;
TUnit* myUnit; TUnit* myUnit;
public: public:
TCoordHelper(const SMDS_NodeIteratorPtr& theNodeIter, TCoordHelper(const SMDS_NodeIteratorPtr& theNodeIter,
TGetCoord* theGetCoord, TGetCoord* theGetCoord,
TName* theName, TName* theName,
@ -167,17 +181,19 @@ public:
MED::TIntVector::value_type GetID(){ MED::TIntVector::value_type GetID(){
return myCurrentNode->GetID(); return myCurrentNode->GetID();
} }
MED::TFloatVector::value_type GetCoord(med_int theCoodId){ MED::TFloatVector::value_type GetCoord(TInt theCoodId){
return (myCurrentNode->*myGetCoord[theCoodId])(); return (myCurrentNode->*myGetCoord[theCoodId])();
} }
MED::TStringVector::value_type GetName(med_int theDimId){ MED::TStringVector::value_type GetName(TInt theDimId){
return myName[theDimId]; return myName[theDimId];
} }
MED::TStringVector::value_type GetUnit(med_int theDimId){ MED::TStringVector::value_type GetUnit(TInt theDimId){
return myUnit[theDimId]; return myUnit[theDimId];
} }
}; };
typedef boost::shared_ptr<TCoordHelper> TCoordHelperPtr; typedef boost::shared_ptr<TCoordHelper> TCoordHelperPtr;
}
Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform() Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
@ -188,11 +204,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
return DRS_FAIL; return DRS_FAIL;
} }
try{ try{
using namespace MEDA;
using namespace boost;
MESSAGE("Perform - myFile : "<<myFile); MESSAGE("Perform - myFile : "<<myFile);
TWrapper aMed(myFile);
// Creating the MED mesh for corresponding SMDS structure // Creating the MED mesh for corresponding SMDS structure
//------------------------------------------------------- //-------------------------------------------------------
@ -206,12 +218,13 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
} }
// Mesh dimension definition // Mesh dimension definition
med_int aMeshDimension; TInt aMeshDimension;
TCoordHelperPtr aCoordHelperPtr; TCoordHelperPtr aCoordHelperPtr;
{ {
bool anIsXDimension = false; bool anIsXDimension = false;
bool anIsYDimension = false; bool anIsYDimension = false;
bool anIsZDimension = false; bool anIsZDimension = false;
cout<<"anIsDimension = "<<anIsXDimension<<", "<<anIsYDimension<<", "<<anIsZDimension<<endl;
{ {
SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator(); SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
double aBounds[6]; double aBounds[6];
@ -237,7 +250,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
anIsXDimension = (aBounds[1] - aBounds[0]) + abs(aBounds[1]) + abs(aBounds[0]) > EPS; anIsXDimension = (aBounds[1] - aBounds[0]) + abs(aBounds[1]) + abs(aBounds[0]) > EPS;
anIsYDimension = (aBounds[3] - aBounds[2]) + abs(aBounds[3]) + abs(aBounds[2]) > EPS; anIsYDimension = (aBounds[3] - aBounds[2]) + abs(aBounds[3]) + abs(aBounds[2]) > EPS;
anIsZDimension = (aBounds[5] - aBounds[4]) + abs(aBounds[5]) + abs(aBounds[4]) > EPS; anIsZDimension = (aBounds[5] - aBounds[4]) + abs(aBounds[5]) + abs(aBounds[4]) > EPS;
cout<<"anIsDimension = "<<anIsXDimension<<", "<<anIsYDimension<<", "<<anIsZDimension<<endl;
aMeshDimension = anIsXDimension + anIsYDimension + anIsZDimension; aMeshDimension = anIsXDimension + anIsYDimension + anIsZDimension;
if(!aMeshDimension) if(!aMeshDimension)
aMeshDimension = 3; aMeshDimension = 3;
@ -268,9 +281,9 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
} }
PMeshInfo aMeshInfo = TWrapper::CrMeshInfo(aMeshDimension,aMeshName); PMeshInfo aMeshInfo = myMed->CrMeshInfo(aMeshDimension,aMeshName);
MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName()); MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
aMed.SetMeshInfo(aMeshInfo); myMed->SetMeshInfo(aMeshInfo);
// Storing SMDS groups and sub-meshes // Storing SMDS groups and sub-meshes
//----------------------------------- //-----------------------------------
@ -303,8 +316,8 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
for (; aFamsIter != aFamilies.end(); aFamsIter++) for (; aFamsIter != aFamilies.end(); aFamsIter++)
{ {
PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(aMeshInfo); PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(myMed,aMeshInfo);
aMed.SetFamilyInfo(aFamilyInfo); myMed->SetFamilyInfo(aFamilyInfo);
int aFamId = (*aFamsIter)->GetId(); int aFamId = (*aFamsIter)->GetId();
const set<const SMDS_MeshElement *>& anElems = (*aFamsIter)->GetElements(); const set<const SMDS_MeshElement *>& anElems = (*aFamsIter)->GetElements();
@ -319,15 +332,15 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
// Storing SMDS nodes to the MED file for the MED mesh // Storing SMDS nodes to the MED file for the MED mesh
//---------------------------------------------------- //----------------------------------------------------
#ifdef _EDF_NODE_IDS_ #ifdef _EDF_NODE_IDS_
typedef map<med_int,med_int> TNodeIdMap; typedef map<TInt,TInt> TNodeIdMap;
TNodeIdMap aNodeIdMap; TNodeIdMap aNodeIdMap;
#endif #endif
med_int aNbElems = myMesh->NbNodes(); TInt aNbElems = myMesh->NbNodes();
MED::TIntVector anElemNums(aNbElems); MED::TIntVector anElemNums(aNbElems);
MED::TIntVector aFamilyNums(aNbElems); MED::TIntVector aFamilyNums(aNbElems);
MED::TFloatVector aCoordinates(aNbElems*aMeshDimension); MED::TFloatVector aCoordinates(aNbElems*aMeshDimension);
for(med_int iNode = 0, aStartId = 0; aCoordHelperPtr->Next(); iNode++, aStartId += aMeshDimension){ for(TInt iNode = 0, aStartId = 0; aCoordHelperPtr->Next(); iNode++, aStartId += aMeshDimension){
for(med_int iCoord = 0; iCoord < aMeshDimension; iCoord++){ for(TInt iCoord = 0; iCoord < aMeshDimension; iCoord++){
aCoordinates[aStartId+iCoord] = aCoordHelperPtr->GetCoord(iCoord); aCoordinates[aStartId+iCoord] = aCoordHelperPtr->GetCoord(iCoord);
} }
int aNodeID = aCoordHelperPtr->GetID(); int aNodeID = aCoordHelperPtr->GetID();
@ -344,14 +357,14 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
MED::TStringVector aCoordNames(aMeshDimension); MED::TStringVector aCoordNames(aMeshDimension);
MED::TStringVector aCoordUnits(aMeshDimension); MED::TStringVector aCoordUnits(aMeshDimension);
for(med_int iCoord = 0; iCoord < aMeshDimension; iCoord++){ for(TInt iCoord = 0; iCoord < aMeshDimension; iCoord++){
aCoordNames[iCoord] = aCoordHelperPtr->GetName(iCoord); aCoordNames[iCoord] = aCoordHelperPtr->GetName(iCoord);
aCoordUnits[iCoord] = aCoordHelperPtr->GetUnit(iCoord); aCoordUnits[iCoord] = aCoordHelperPtr->GetUnit(iCoord);
} }
const med_repere SMDS_COORDINATE_SYSTEM = MED_CART; const ERepere SMDS_COORDINATE_SYSTEM = eCART;
PNodeInfo aNodeInfo = TWrapper::CrNodeInfo(aMeshInfo, PNodeInfo aNodeInfo = myMed->CrNodeInfo(aMeshInfo,
SMDS_COORDINATE_SYSTEM, SMDS_COORDINATE_SYSTEM,
aCoordinates, aCoordinates,
aCoordNames, aCoordNames,
@ -359,29 +372,29 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
aFamilyNums, aFamilyNums,
anElemNums); anElemNums);
MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbElems); MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbElems);
aMed.SetNodeInfo(aNodeInfo); myMed->SetNodeInfo(aNodeInfo);
// Storing others SMDS elements to the MED file for the MED mesh // Storing others SMDS elements to the MED file for the MED mesh
//-------------------------------------------------------------- //--------------------------------------------------------------
med_entite_maillage SMDS_MED_ENTITY = MED_MAILLE; EEntiteMaillage SMDS_MED_ENTITY = eMAILLE;
const med_connectivite SMDS_MED_CONNECTIVITY = MED_NOD; const EConnectivite SMDS_MED_CONNECTIVITY = eNOD;
// Storing SMDS Edges // Storing SMDS Edges
if(med_int aNbElems = myMesh->NbEdges()){ if(TInt aNbElems = myMesh->NbEdges()){
#ifdef _ELEMENTS_BY_DIM_ #ifdef _ELEMENTS_BY_DIM_
SMDS_MED_ENTITY = MED_ARETE; SMDS_MED_ENTITY = eARETE;
#endif #endif
SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator(); SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator();
med_int aNbConnectivity = MED::GetNbConn(SMDS_MED_ENTITY,MED_SEG2,aMeshDimension); TInt aNbConnectivity = MED::GetNbConn(SMDS_MED_ENTITY,eSEG2,aMeshDimension);
MED::TIntVector anElemNums(aNbElems); MED::TIntVector anElemNums(aNbElems);
MED::TIntVector aFamilyNums(aNbElems); MED::TIntVector aFamilyNums(aNbElems);
MED::TIntVector aConnectivity(aNbElems*aNbConnectivity); MED::TIntVector aConnectivity(aNbElems*aNbConnectivity);
for(med_int iElem = 0, iConn = 0; anIter->more(); iElem++, iConn+=aNbConnectivity){ for(TInt iElem = 0, iConn = 0; anIter->more(); iElem++, iConn+=aNbConnectivity){
const SMDS_MeshEdge* anElem = anIter->next(); const SMDS_MeshEdge* anElem = anIter->next();
SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator(); SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
for(med_int iNode = 0; iNode < aNbConnectivity && aNodesIter->more(); iNode++){ for(TInt iNode = 0; iNode < aNbConnectivity && aNodesIter->more(); iNode++){
const SMDS_MeshElement* aNode = aNodesIter->next(); const SMDS_MeshElement* aNode = aNodesIter->next();
#ifdef _EDF_NODE_IDS_ #ifdef _EDF_NODE_IDS_
aConnectivity[iConn+iNode] = aNodeIdMap[aNode->GetID()]; aConnectivity[iConn+iNode] = aNodeIdMap[aNode->GetID()];
@ -397,23 +410,23 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
aFamilyNums[iElem] = myEdgesDefaultFamilyId; aFamilyNums[iElem] = myEdgesDefaultFamilyId;
} }
PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo, PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
SMDS_MED_ENTITY, SMDS_MED_ENTITY,
MED_SEG2, eSEG2,
SMDS_MED_CONNECTIVITY, SMDS_MED_CONNECTIVITY,
aConnectivity, aConnectivity,
aFamilyNums, aFamilyNums,
anElemNums); anElemNums);
aMed.SetCellInfo(aCellInfo); myMed->SetCellInfo(aCellInfo);
} }
// Storing SMDS Faces // Storing SMDS Faces
if(med_int aNbElems = myMesh->NbFaces()){ if(TInt aNbElems = myMesh->NbFaces()){
SMDS_FaceIteratorPtr anIter = myMesh->facesIterator(); SMDS_FaceIteratorPtr anIter = myMesh->facesIterator();
#ifdef _ELEMENTS_BY_DIM_ #ifdef _ELEMENTS_BY_DIM_
SMDS_MED_ENTITY = MED_FACE; SMDS_MED_ENTITY = eFACE;
#endif #endif
med_int aNbTriaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TRIA3,aMeshDimension); TInt aNbTriaConn = MED::GetNbConn(SMDS_MED_ENTITY,eTRIA3,aMeshDimension);
MED::TIntVector anTriaElemNums; MED::TIntVector anTriaElemNums;
anTriaElemNums.reserve(aNbElems); anTriaElemNums.reserve(aNbElems);
MED::TIntVector aTriaFamilyNums; MED::TIntVector aTriaFamilyNums;
@ -421,7 +434,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
MED::TIntVector aTriaConn; MED::TIntVector aTriaConn;
aTriaConn.reserve(aNbElems*aNbTriaConn); aTriaConn.reserve(aNbElems*aNbTriaConn);
med_int aNbQuadConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_QUAD4,aMeshDimension); TInt aNbQuadConn = MED::GetNbConn(SMDS_MED_ENTITY,eQUAD4,aMeshDimension);
MED::TIntVector aQuadElemNums; MED::TIntVector aQuadElemNums;
aQuadElemNums.reserve(aNbElems); aQuadElemNums.reserve(aNbElems);
MED::TIntVector aQuadFamilyNums; MED::TIntVector aQuadFamilyNums;
@ -429,11 +442,11 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
MED::TIntVector aQuadConn; MED::TIntVector aQuadConn;
aQuadConn.reserve(aNbElems*aNbQuadConn); aQuadConn.reserve(aNbElems*aNbQuadConn);
for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){ for(TInt iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
const SMDS_MeshFace* anElem = anIter->next(); const SMDS_MeshFace* anElem = anIter->next();
med_int aNbNodes = anElem->NbNodes(); TInt aNbNodes = anElem->NbNodes();
SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator(); SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
med_int aNbConnectivity; TInt aNbConnectivity;
MED::TIntVector* anElemNums; MED::TIntVector* anElemNums;
MED::TIntVector* aFamilyNums; MED::TIntVector* aFamilyNums;
MED::TIntVector* aConnectivity; MED::TIntVector* aConnectivity;
@ -452,12 +465,12 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
break; break;
} }
MED::TIntVector aVector(aNbNodes); MED::TIntVector aVector(aNbNodes);
for(med_int iNode = 0; aNodesIter->more(); iNode++){ for(TInt iNode = 0; aNodesIter->more(); iNode++){
const SMDS_MeshElement* aNode = aNodesIter->next(); const SMDS_MeshElement* aNode = aNodesIter->next();
aVector[iNode] = aNode->GetID(); aVector[iNode] = aNode->GetID();
} }
med_int aSize = aConnectivity->size(); TInt aSize = aConnectivity->size();
aConnectivity->resize(aSize+aNbConnectivity); aConnectivity->resize(aSize+aNbConnectivity);
// There is some differnce between SMDS and MED in cells mapping // There is some differnce between SMDS and MED in cells mapping
#ifdef _EDF_NODE_IDS_ #ifdef _EDF_NODE_IDS_
@ -468,7 +481,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
(*aConnectivity)[aSize+2] = aNodeIdMap[aVector[3]]; (*aConnectivity)[aSize+2] = aNodeIdMap[aVector[3]];
(*aConnectivity)[aSize+3] = aNodeIdMap[aVector[2]]; (*aConnectivity)[aSize+3] = aNodeIdMap[aVector[2]];
default: default:
for(med_int iNode = 0; iNode < aNbNodes; iNode++) for(TInt iNode = 0; iNode < aNbNodes; iNode++)
(*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]]; (*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]];
} }
#else #else
@ -479,7 +492,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
(*aConnectivity)[aSize+2] = aVector[3]; (*aConnectivity)[aSize+2] = aVector[3];
(*aConnectivity)[aSize+3] = aVector[2]; (*aConnectivity)[aSize+3] = aVector[2];
default: default:
for(med_int iNode = 0; iNode < aNbNodes; iNode++) for(TInt iNode = 0; iNode < aNbNodes; iNode++)
(*aConnectivity)[aSize+iNode] = aVector[iNode]; (*aConnectivity)[aSize+iNode] = aVector[iNode];
} }
#endif #endif
@ -490,37 +503,37 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
else else
aFamilyNums->push_back(myFacesDefaultFamilyId); aFamilyNums->push_back(myFacesDefaultFamilyId);
} }
if(med_int aNbElems = anTriaElemNums.size()){ if(TInt aNbElems = anTriaElemNums.size()){
PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo, PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
SMDS_MED_ENTITY, SMDS_MED_ENTITY,
MED_TRIA3, eTRIA3,
SMDS_MED_CONNECTIVITY, SMDS_MED_CONNECTIVITY,
aTriaConn, aTriaConn,
aTriaFamilyNums, aTriaFamilyNums,
anTriaElemNums); anTriaElemNums);
MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TRIA3<<"; aNbElems = "<<aNbElems); MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTRIA3<<"; aNbElems = "<<aNbElems);
aMed.SetCellInfo(aCellInfo); myMed->SetCellInfo(aCellInfo);
} }
if(med_int aNbElems = aQuadElemNums.size()){ if(TInt aNbElems = aQuadElemNums.size()){
PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo, PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
SMDS_MED_ENTITY, SMDS_MED_ENTITY,
MED_QUAD4, eQUAD4,
SMDS_MED_CONNECTIVITY, SMDS_MED_CONNECTIVITY,
aQuadConn, aQuadConn,
aQuadFamilyNums, aQuadFamilyNums,
aQuadElemNums); aQuadElemNums);
MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_QUAD4<<"; aNbElems = "<<aNbElems); MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eQUAD4<<"; aNbElems = "<<aNbElems);
aMed.SetCellInfo(aCellInfo); myMed->SetCellInfo(aCellInfo);
} }
} }
// Storing SMDS Volumes // Storing SMDS Volumes
if(med_int aNbElems = myMesh->NbVolumes()){ if(TInt aNbElems = myMesh->NbVolumes()){
SMDS_VolumeIteratorPtr anIter = myMesh->volumesIterator(); SMDS_VolumeIteratorPtr anIter = myMesh->volumesIterator();
#ifdef _ELEMENTS_BY_DIM_ #ifdef _ELEMENTS_BY_DIM_
SMDS_MED_ENTITY = MED_MAILLE; SMDS_MED_ENTITY = eMAILLE;
#endif #endif
med_int aNbTetraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_TETRA4,aMeshDimension); TInt aNbTetraConn = MED::GetNbConn(SMDS_MED_ENTITY,eTETRA4,aMeshDimension);
MED::TIntVector anTetraElemNums; MED::TIntVector anTetraElemNums;
anTetraElemNums.reserve(aNbElems); anTetraElemNums.reserve(aNbElems);
MED::TIntVector aTetraFamilyNums; MED::TIntVector aTetraFamilyNums;
@ -528,7 +541,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
MED::TIntVector aTetraConn; MED::TIntVector aTetraConn;
aTetraConn.reserve(aNbElems*aNbTetraConn); aTetraConn.reserve(aNbElems*aNbTetraConn);
med_int aNbPyraConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PYRA5,aMeshDimension); TInt aNbPyraConn = MED::GetNbConn(SMDS_MED_ENTITY,ePYRA5,aMeshDimension);
MED::TIntVector anPyraElemNums; MED::TIntVector anPyraElemNums;
anPyraElemNums.reserve(aNbElems); anPyraElemNums.reserve(aNbElems);
MED::TIntVector aPyraFamilyNums; MED::TIntVector aPyraFamilyNums;
@ -536,7 +549,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
MED::TIntVector aPyraConn; MED::TIntVector aPyraConn;
aPyraConn.reserve(aNbElems*aNbPyraConn); aPyraConn.reserve(aNbElems*aNbPyraConn);
med_int aNbPentaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_PENTA6,aMeshDimension); TInt aNbPentaConn = MED::GetNbConn(SMDS_MED_ENTITY,ePENTA6,aMeshDimension);
MED::TIntVector anPentaElemNums; MED::TIntVector anPentaElemNums;
anPentaElemNums.reserve(aNbElems); anPentaElemNums.reserve(aNbElems);
MED::TIntVector aPentaFamilyNums; MED::TIntVector aPentaFamilyNums;
@ -544,7 +557,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
MED::TIntVector aPentaConn; MED::TIntVector aPentaConn;
aPentaConn.reserve(aNbElems*aNbPentaConn); aPentaConn.reserve(aNbElems*aNbPentaConn);
med_int aNbHexaConn = MED::GetNbConn(SMDS_MED_ENTITY,MED_HEXA8,aMeshDimension); TInt aNbHexaConn = MED::GetNbConn(SMDS_MED_ENTITY,eHEXA8,aMeshDimension);
MED::TIntVector aHexaElemNums; MED::TIntVector aHexaElemNums;
aHexaElemNums.reserve(aNbElems); aHexaElemNums.reserve(aNbElems);
MED::TIntVector aHexaFamilyNums; MED::TIntVector aHexaFamilyNums;
@ -552,11 +565,11 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
MED::TIntVector aHexaConn; MED::TIntVector aHexaConn;
aHexaConn.reserve(aNbElems*aNbHexaConn); aHexaConn.reserve(aNbElems*aNbHexaConn);
for(med_int iElem = 0; iElem < aNbElems && anIter->more(); iElem++){ for(TInt iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
const SMDS_MeshVolume* anElem = anIter->next(); const SMDS_MeshVolume* anElem = anIter->next();
med_int aNbNodes = anElem->NbNodes(); TInt aNbNodes = anElem->NbNodes();
SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator(); SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
med_int aNbConnectivity; TInt aNbConnectivity;
MED::TIntVector* anElemNums; MED::TIntVector* anElemNums;
MED::TIntVector* aFamilyNums; MED::TIntVector* aFamilyNums;
MED::TIntVector* aConnectivity; MED::TIntVector* aConnectivity;
@ -587,11 +600,11 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
} }
MED::TIntVector aVector(aNbNodes); MED::TIntVector aVector(aNbNodes);
for(med_int iNode = 0; aNodesIter->more(); iNode++){ for(TInt iNode = 0; aNodesIter->more(); iNode++){
const SMDS_MeshElement* aNode = aNodesIter->next(); const SMDS_MeshElement* aNode = aNodesIter->next();
aVector[iNode] = aNode->GetID(); aVector[iNode] = aNode->GetID();
} }
med_int aSize = aConnectivity->size(); TInt aSize = aConnectivity->size();
aConnectivity->resize(aSize+aNbConnectivity); aConnectivity->resize(aSize+aNbConnectivity);
// There is some difference between SMDS and MED in cells mapping // There is some difference between SMDS and MED in cells mapping
#ifdef _EDF_NODE_IDS_ #ifdef _EDF_NODE_IDS_
@ -603,7 +616,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
(*aConnectivity)[aSize+3] = aNodeIdMap[aVector[1]]; (*aConnectivity)[aSize+3] = aNodeIdMap[aVector[1]];
(*aConnectivity)[aSize+4] = aNodeIdMap[aVector[4]]; (*aConnectivity)[aSize+4] = aNodeIdMap[aVector[4]];
default: default:
for(med_int iNode = 0; iNode < aNbNodes; iNode++) for(TInt iNode = 0; iNode < aNbNodes; iNode++)
(*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]]; (*aConnectivity)[aSize+iNode] = aNodeIdMap[aVector[iNode]];
} }
#else #else
@ -615,7 +628,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
(*aConnectivity)[aSize+3] = aVector[1]; (*aConnectivity)[aSize+3] = aVector[1];
(*aConnectivity)[aSize+4] = aVector[4]; (*aConnectivity)[aSize+4] = aVector[4];
default: default:
for(med_int iNode = 0; iNode < aNbNodes; iNode++) for(TInt iNode = 0; iNode < aNbNodes; iNode++)
(*aConnectivity)[aSize+iNode] = aVector[iNode]; (*aConnectivity)[aSize+iNode] = aVector[iNode];
} }
#endif #endif
@ -627,49 +640,49 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
aFamilyNums->push_back(myVolumesDefaultFamilyId); aFamilyNums->push_back(myVolumesDefaultFamilyId);
} }
if(med_int aNbElems = anTetraElemNums.size()){ if(TInt aNbElems = anTetraElemNums.size()){
PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo, PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
SMDS_MED_ENTITY, SMDS_MED_ENTITY,
MED_TETRA4, eTETRA4,
SMDS_MED_CONNECTIVITY, SMDS_MED_CONNECTIVITY,
aTetraConn, aTetraConn,
aTetraFamilyNums, aTetraFamilyNums,
anTetraElemNums); anTetraElemNums);
MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_TETRA4<<"; aNbElems = "<<aNbElems); MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eTETRA4<<"; aNbElems = "<<aNbElems);
aMed.SetCellInfo(aCellInfo); myMed->SetCellInfo(aCellInfo);
} }
if(med_int aNbElems = anPyraElemNums.size()){ if(TInt aNbElems = anPyraElemNums.size()){
PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo, PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
SMDS_MED_ENTITY, SMDS_MED_ENTITY,
MED_PYRA5, ePYRA5,
SMDS_MED_CONNECTIVITY, SMDS_MED_CONNECTIVITY,
aPyraConn, aPyraConn,
aPyraFamilyNums, aPyraFamilyNums,
anPyraElemNums); anPyraElemNums);
MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PYRA5<<"; aNbElems = "<<aNbElems); MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePYRA5<<"; aNbElems = "<<aNbElems);
aMed.SetCellInfo(aCellInfo); myMed->SetCellInfo(aCellInfo);
} }
if(med_int aNbElems = anPentaElemNums.size()){ if(TInt aNbElems = anPentaElemNums.size()){
PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo, PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
SMDS_MED_ENTITY, SMDS_MED_ENTITY,
MED_PENTA6, ePENTA6,
SMDS_MED_CONNECTIVITY, SMDS_MED_CONNECTIVITY,
aPentaConn, aPentaConn,
aPentaFamilyNums, aPentaFamilyNums,
anPentaElemNums); anPentaElemNums);
MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_PENTA6<<"; aNbElems = "<<aNbElems); MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<ePENTA6<<"; aNbElems = "<<aNbElems);
aMed.SetCellInfo(aCellInfo); myMed->SetCellInfo(aCellInfo);
} }
if(med_int aNbElems = aHexaElemNums.size()){ if(TInt aNbElems = aHexaElemNums.size()){
PCellInfo aCellInfo = TWrapper::CrCellInfo(aMeshInfo, PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
SMDS_MED_ENTITY, SMDS_MED_ENTITY,
MED_HEXA8, eHEXA8,
SMDS_MED_CONNECTIVITY, SMDS_MED_CONNECTIVITY,
aHexaConn, aHexaConn,
aHexaFamilyNums, aHexaFamilyNums,
aHexaElemNums); aHexaElemNums);
MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<MED_HEXA8<<"; aNbElems = "<<aNbElems); MESSAGE("Perform - anEntity = "<<SMDS_MED_ENTITY<<"; aGeom = "<<eHEXA8<<"; aNbElems = "<<aNbElems);
aMed.SetCellInfo(aCellInfo); myMed->SetCellInfo(aCellInfo);
} }
} }
}catch(const std::exception& exc){ }catch(const std::exception& exc){

5
src/DriverMED/DriverMED_W_SMESHDS_Mesh.h
View File

@ -28,6 +28,7 @@
#define _INCLUDE_DRIVERMED_W_SMESHDS_MESH #define _INCLUDE_DRIVERMED_W_SMESHDS_MESH
#include "Driver_SMESHDS_Mesh.h" #include "Driver_SMESHDS_Mesh.h"
#include "MED_Factory.hxx"
#include <string> #include <string>
#include <list> #include <list>
@ -43,6 +44,9 @@ class DriverMED_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
DriverMED_W_SMESHDS_Mesh(); DriverMED_W_SMESHDS_Mesh();
virtual void SetFile(const std::string& theFileName);
void SetFile(const std::string& theFileName, MED::EVersion theId);
/*! sets file name; only for usage with Add(), not Write() /*! sets file name; only for usage with Add(), not Write()
*/ */
void AddGroupOfNodes(); void AddGroupOfNodes();
@ -63,6 +67,7 @@ class DriverMED_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
private: private:
MED::PWrapper myMed;
std::string myMeshName; std::string myMeshName;
std::list<SMESHDS_GroupBase*> myGroups; std::list<SMESHDS_GroupBase*> myGroups;
bool myAllSubMeshes; bool myAllSubMeshes;

2
src/DriverMED/Makefile.in
View File

@ -60,7 +60,7 @@ LIB_SERVER_IDL =
# additionnal information to compil and link file # additionnal information to compil and link file
CPPFLAGS += $(OCC_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome $(BOOST_CPPFLAGS) CPPFLAGS += $(OCC_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome $(BOOST_CPPFLAGS)
CXXFLAGS += $(OCC_CXXFLAGS) $(MED2_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome CXXFLAGS += $(OCC_CXXFLAGS) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
LDFLAGS += -lMeshDriver -L${KERNEL_ROOT_DIR}/lib/salome -lMEDWrapper LDFLAGS += -lMeshDriver -L${KERNEL_ROOT_DIR}/lib/salome -lMEDWrapper
LDFLAGSFORBIN += -lMeshDriver -lSMDS -lSMESHDS -L${KERNEL_ROOT_DIR}/lib/salome -lMEDWrapper -lOpUtil -lSALOMELocalTrace LDFLAGSFORBIN += -lMeshDriver -lSMDS -lSMESHDS -L${KERNEL_ROOT_DIR}/lib/salome -lMEDWrapper -lOpUtil -lSALOMELocalTrace

4
src/SMESH/Makefile.in
View File

@ -74,9 +74,9 @@ BIN =
BIN_SRC = BIN_SRC =
# additionnal information to compile and link file # additionnal information to compile and link file
CPPFLAGS+= $(OCC_INCLUDES) $(MED2_INCLUDES) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome \ CPPFLAGS+= $(OCC_INCLUDES) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome \
-I${GEOM_ROOT_DIR}/include/salome $(BOOST_CPPFLAGS) -I${GEOM_ROOT_DIR}/include/salome $(BOOST_CPPFLAGS)
CXXFLAGS+= $(OCC_CXXFLAGS) $(MED2_INCLUDES) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome \ CXXFLAGS+= $(OCC_CXXFLAGS) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome \
-I${GEOM_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome
LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -L${GEOM_ROOT_DIR}/lib/salome -lNMTTools -lSMESHDS -lMeshDriverDAT -lMeshDriverSTL -lMeshDriverMED -lMeshDriverUNV LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -L${GEOM_ROOT_DIR}/lib/salome -lNMTTools -lSMESHDS -lMeshDriverDAT -lMeshDriverSTL -lMeshDriverMED -lMeshDriverUNV

2
src/SMESHGUI/Makefile.in
View File

@ -169,7 +169,7 @@ LIB_SERVER_IDL =
#BIN = SMESHBin #BIN = SMESHBin
CPPFLAGS += $(QT_INCLUDES) $(VTK_INCLUDES) $(OGL_INCLUDES) $(OCC_INCLUDES) $(PYTHON_INCLUDES) \ CPPFLAGS += $(QT_INCLUDES) $(VTK_INCLUDES) $(OGL_INCLUDES) $(OCC_INCLUDES) $(PYTHON_INCLUDES) \
$(MED2_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome \ -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome \
$(BOOST_CPPFLAGS) $(BOOST_CPPFLAGS)
CXXFLAGS += -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome CXXFLAGS += -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome

4
src/SMESH_I/Makefile.in
View File

@ -82,9 +82,9 @@ BIN = SMESHEngine
BIN_SRC = BIN_SRC =
# additionnal information to compil and link file # additionnal information to compil and link file
CPPFLAGS+= $(OCC_INCLUDES) $(MED2_INCLUDES) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome \ CPPFLAGS+= $(OCC_INCLUDES) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome \
-I${GEOM_ROOT_DIR}/include/salome $(BOOST_CPPFLAGS) -I${GEOM_ROOT_DIR}/include/salome $(BOOST_CPPFLAGS)
CXXFLAGS+= $(OCC_CXXFLAGS) $(MED2_INCLUDES) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome \ CXXFLAGS+= $(OCC_CXXFLAGS) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome \
-I${GEOM_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome
LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lRegistry -lSalomeHDFPersist -lSalomeLifeCycleCORBA -lTOOLSDS -lSalomeGenericObj \ LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -lSalomeContainer -lSalomeNS -lRegistry -lSalomeHDFPersist -lSalomeLifeCycleCORBA -lTOOLSDS -lSalomeGenericObj \

2
src/StdMeshersGUI/Makefile.in
View File

@ -66,7 +66,7 @@ LIB_SERVER_IDL =
# additionnal information to compil and link file # additionnal information to compil and link file
CPPFLAGS += $(QT_INCLUDES) $(VTK_INCLUDES) $(OGL_INCLUDES) $(OCC_INCLUDES) $(PYTHON_INCLUDES) \ CPPFLAGS += $(QT_INCLUDES) $(VTK_INCLUDES) $(OGL_INCLUDES) $(OCC_INCLUDES) $(PYTHON_INCLUDES) \
$(MED2_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome \ -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome \
$(BOOST_CPPFLAGS) $(BOOST_CPPFLAGS)
CXXFLAGS += -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome CXXFLAGS += -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome
#$(OCC_CXXFLAGS) #$(OCC_CXXFLAGS)