ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-29 03:10:34 +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_MT_LIBS=@HDF5_MT_LIBS@
# MED2
MED2_INCLUDES=@MED2_INCLUDES@
MED2_LIBS=@MED2_LIBS@
MED2_MT_LIBS=@MED2_MT_LIBS@
# OpenCasCade
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_partial_specialization.m4 check_opengl.m4 python.m4 \
ac_cxx_typename.m4 check_pthreads.m4 check_cas.m4 \
ac_cc_warnings.m4 check_qt.m4 check_med2.m4 \
check_swig.m4 check_boost.m4
ac_cc_warnings.m4 check_qt.m4 check_boost.m4 \
check_swig.m4
$(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

10
configure.in.base
View File

@ -233,14 +233,6 @@ echo
CHECK_HDF5
echo
echo ---------------------------------------------
echo testing MED2
echo ---------------------------------------------
echo
CHECK_MED2
echo
echo ---------------------------------------------
echo Testing OpenCascade
@ -288,7 +280,7 @@ echo ---------------------------------------------
echo
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
do

19
src/DriverMED/DriverMED_Family.cxx
View File

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

5
src/DriverMED/DriverMED_Family.h
View File

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

421
src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
View File

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

2
src/DriverMED/Makefile.in
View File

@ -60,7 +60,7 @@ LIB_SERVER_IDL =
# additionnal information to compil and link file
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
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 =
# 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)
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
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
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)
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 =
# 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)
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
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
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)
CXXFLAGS += -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome
#$(OCC_CXXFLAGS)