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

0021803: EDF 2351 : Available versions of MED in TUI function ExportMED aren't consistent with GUI behavior

Browse Source
This commit is contained in:
vsr 2016-04-06 17:24:26 +03:00
parent d502984073
commit d3e1cabf77
89 changed files with 7130 additions and 8510 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -296,7 +296,7 @@ INCLUDE(CMakePackageConfigHelpers)
# They all have to be INSTALL'd with the option "EXPORT ${PROJECT_NAME}TargetGroup"
SET(_${PROJECT_NAME}_exposed_targets
SMESHControls MeshDriver MeshDriverDAT MeshDriverGMF MeshDriverMED
MeshDriverSTL MeshDriverUNV MEDWrapperBase MEDWrapper MEDWrapper_V2_2
MeshDriverSTL MeshDriverUNV MEDWrapper
SMDS SMESHimpl SMESHEngine SMESHClient SMESHDS
SMESHUtils StdMeshers StdMeshersEngine MeshJobManagerEngine
SPADDERPluginTesterEngine SalomeIDLSMESH SalomeIDLSPADDER

2
SalomeSMESHConfig.cmake.in
View File

@ -138,9 +138,7 @@ SET(SMESH_MeshDriverGMF MeshDriverGMF)
SET(SMESH_MeshDriverMED MeshDriverMED)
SET(SMESH_MeshDriverSTL MeshDriverSTL)
SET(SMESH_MeshDriverUNV MeshDriverUNV)
SET(SMESH_MEDWrapperBase MEDWrapperBase)
SET(SMESH_MEDWrapper MEDWrapper)
SET(SMESH_MEDWrapper_V2_2 MEDWrapper_V2_2)
IF(SALOME_SMESH_ENABLE_MEFISTO)
SET(SMESH_MEFISTO2D MEFISTO2D)
ENDIF(SALOME_SMESH_ENABLE_MEFISTO)

12
idl/SMESH_Gen.idl
View File

@ -411,10 +411,20 @@ module SMESH
*/
long GetObjectId(in Object theObject);
/*!
* \brief Get version of MED format being used.
*/
string GetMEDFileVersion();
/*!
* \brief Get MED version of the file by its name.
*/
boolean GetMEDVersion(in string theFileName, out MED_VERSION theVersion);
string GetMEDVersion(in string theFileName);
/*!
* \brief Check compatibility of file with MED format being used.
*/
boolean CheckCompatibility(in string theFileName);
/*!
* \brief Get names of meshes defined in file with the specified name.

51
idl/SMESH_Mesh.idl
View File

@ -235,15 +235,6 @@ module SMESH
DRS_FAIL // general failure (exception etc.)
};
/*!
* Enumeration for ExportToMED*()
*/
enum MED_VERSION
{
MED_V2_1,
MED_V2_2
};
/*!
* \brief A structure containing information about MED file
*/
@ -623,13 +614,12 @@ module SMESH
boolean HasDuplicatedGroupNamesMED();
/*!
* Export Mesh to a MED Format file
* Export a Mesh to MED file.
* @params
* - file : name of the MED file
* - fileName : name of the MED file
* - auto_groups : boolean parameter for creating/not creating
* the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
* the typical use is auto_groups=false.
* - version : defines the version of format of MED file, that will be created
* - overwrite : boolean parameter for overwriting/not overwriting the file, if it exists
* - autoDimension : if @c true, a space dimension of a MED mesh can be either
* - 1D if all mesh nodes lie on OX coordinate axis, or
@ -637,18 +627,16 @@ module SMESH
* - 3D in the rest cases.
* If @a autoDimension is @c false, the space dimension is always 3.
*/
void ExportToMEDX( in string file,
in boolean auto_groups,
in MED_VERSION version,
in boolean overwrite,
in boolean autoDimension) raises (SALOME::SALOME_Exception);
void ExportMED( in string fileName,
in boolean auto_groups,
in boolean overwrite,
in boolean autoDimension) raises (SALOME::SALOME_Exception);
/*!
* Export a [part of] Mesh into a MED file
* @params
* - meshPart : a part of mesh to store
* - file : name of the MED file
* - version : define the version of format of MED file, that will be created
* - fileName : name of the MED file
* - overwrite : boolean parameter for overwriting/not overwriting the file, if it exists
* - autoDimension : if @c True, a space dimension for export is defined by mesh
* configuration; for example a planar mesh lying on XOY plane
@ -663,31 +651,13 @@ module SMESH
* - 's' stands for _solids_ field.
*/
void ExportPartToMED( in SMESH_IDSource meshPart,
in string file,
in string fileName,
in boolean auto_groups,
in MED_VERSION version,
in boolean overwrite,
in boolean autoDimension,
in GEOM::ListOfFields fields,
in string geomAssocFields ) raises (SALOME::SALOME_Exception);
/*!
* Export Mesh to a MED Format file
* Works, just the same as ExportToMEDX, with overwrite parameter equal to true.
* The method is kept in order to support old functionality
*/
void ExportToMED( in string file, in boolean auto_groups, in MED_VERSION theVersion )
raises (SALOME::SALOME_Exception);
/*!
* Export Mesh to MED_V2_1 MED format
* Works, just the same as ExportToMEDX with MED_VERSION parameter equal to MED_V2_1
* and overwrite parameter equal to true
* The method is kept in order to support old functionality
*/
void ExportMED( in string file, in boolean auto_groups )
raises (SALOME::SALOME_Exception);
/*!
* Export Mesh to SAUV formatted file
* Write a temporary med file and use med2sauv
@ -695,11 +665,6 @@ module SMESH
void ExportSAUV( in string file, in boolean auto_groups )
raises (SALOME::SALOME_Exception);
/*!
* Return string representation of a MED file version comprising nbDigits
*/
string GetVersionString(in MED_VERSION version, in short nbDigits);
/*!
* Export Mesh to different Formats
* (UNV supported version is I-DEAS 10)

5
src/DriverMED/CMakeLists.txt
View File

@ -25,8 +25,7 @@ INCLUDE_DIRECTORIES(
${CAS_INCLUDE_DIRS}
${VTK_INCLUDE_DIRS}
${Boost_INCLUDE_DIRS}
${PROJECT_SOURCE_DIR}/src/MEDWrapper/Base
${PROJECT_SOURCE_DIR}/src/MEDWrapper/Factory
${PROJECT_SOURCE_DIR}/src/MEDWrapper
${PROJECT_SOURCE_DIR}/src/Driver
${PROJECT_SOURCE_DIR}/src/SMDS
${PROJECT_SOURCE_DIR}/src/SMESHUtils
@ -45,8 +44,6 @@ SET(_link_LIBRARIES
${Boost_LIBRARIES}
MeshDriver
MEDWrapper
MEDWrapperBase
MEDWrapper_V2_2
)
SET(_link_LIBRARIES_bin

6
src/DriverMED/DriverMED_Family.cxx
View File

@ -383,11 +383,7 @@ DriverMED_Family::GetFamilyInfo(const MED::PWrapper& theWrapper,
}
string aValue = aStr.str();
// PAL19785,0019867 - med forbids whitespace to be the last char in the name
int maxSize;
//if ( theWrapper->GetVersion() == MED::eV2_1 )
// maxSize = MED::GetNOMLength<MED::eV2_1>();
//else
maxSize = MED::GetNOMLength<MED::eV2_2>();
int maxSize = MED::GetNOMLength();
int lastCharPos = min( maxSize, (int) aValue.size() ) - 1;
while ( isspace( aValue[ lastCharPos ] ))
aValue.resize( lastCharPos-- );

4
src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx
View File

@ -110,7 +110,7 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
#endif
myFamilies.clear();
if(MYDEBUG) MESSAGE("Perform - myFile : "<<myFile);
PWrapper aMed = CrWrapper(myFile,true);
PWrapper aMed = CrWrapperR(myFile);
aResult = DRS_EMPTY;
TInt aNbMeshes = aMed->GetNbMeshes();
@ -1022,7 +1022,7 @@ list<string> DriverMED_R_SMESHDS_Mesh::GetMeshNames(Status& theStatus)
try {
if(MYDEBUG) MESSAGE("GetMeshNames - myFile : " << myFile);
theStatus = DRS_OK;
PWrapper aMed = CrWrapper(myFile);
PWrapper aMed = CrWrapperR(myFile);
if (TInt aNbMeshes = aMed->GetNbMeshes()) {
for (int iMesh = 0; iMesh < aNbMeshes; iMesh++) {

2
src/DriverMED/DriverMED_W_Field.cxx
View File

@ -254,7 +254,7 @@ Driver_Mesh::Status DriverMED_W_Field::Perform()
if ( !myMesh )
return addMessage("Supporting mesh not set", /*isFatal=*/true );
MED::PWrapper medFile = MED::CrWrapper( myFile, MED::eV2_2 );
MED::PWrapper medFile = MED::CrWrapperW( myFile );
MED::PMeshInfo meshInfo;
if ( myMeshId > 0 )
{

28
src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
View File

@ -52,7 +52,6 @@ using namespace MED;
DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
myMedVersion(MED::eV2_2),
myAllSubMeshes (false),
myDoGroupOfNodes (false),
myDoGroupOfEdges (false),
@ -65,36 +64,11 @@ DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
myDoAllInGroups(false)
{}
void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName,
MED::EVersion theId)
{
Driver_SMESHDS_Mesh::SetFile(theFileName);
myMedVersion = theId;
}
void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName)
{
Driver_SMESHDS_Mesh::SetFile(theFileName);
}
string DriverMED_W_SMESHDS_Mesh::GetVersionString(const MED::EVersion theVersion, int theNbDigits)
{
TInt majeur, mineur, release;
majeur = mineur = release = 0;
// if ( theVersion == eV2_1 )
// MED::GetVersionRelease<eV2_1>(majeur, mineur, release);
// else
MED::GetVersionRelease<eV2_2>(majeur, mineur, release);
ostringstream name;
if ( theNbDigits > 0 )
name << majeur;
if ( theNbDigits > 1 )
name << "." << mineur;
if ( theNbDigits > 2 )
name << "." << release;
return name.str();
}
void DriverMED_W_SMESHDS_Mesh::AddGroup(SMESHDS_GroupBase* theGroup)
{
myGroups.push_back(theGroup);
@ -457,7 +431,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
}
}
MED::PWrapper myMed = CrWrapper(myFile,myMedVersion);
MED::PWrapper myMed = CrWrapperW(myFile);
PMeshInfo aMeshInfo = myMed->CrMeshInfo(aMeshDimension,aSpaceDimension,aMeshName);
//MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
myMed->SetMeshInfo(aMeshInfo);

6
src/DriverMED/DriverMED_W_SMESHDS_Mesh.h
View File

@ -47,12 +47,9 @@ class MESHDRIVERMED_EXPORT 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);
void SetFile(const std::string& theFileName);
void SetAutoDimension(bool toFindOutDimension) { myAutoDimension = toFindOutDimension; }
static std::string GetVersionString(const MED::EVersion theVersion, int theNbDigits=2);
void AddGroupOfNodes();
void AddGroupOfEdges();
void AddGroupOfFaces();
@ -77,7 +74,6 @@ class MESHDRIVERMED_EXPORT DriverMED_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
private:
MED::EVersion myMedVersion;
std::list<SMESHDS_GroupBase*> myGroups;
bool myAllSubMeshes;
std::vector<SMESHDS_SubMesh*> mySubMeshes;

78
src/MEDWrapper/Base/CMakeLists.txt
View File

@ -1,78 +0,0 @@
# Copyright (C) 2012-2016 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# --- options ---
# additional include directories
INCLUDE_DIRECTORIES(
${HDF5_INCLUDE_DIRS}
${Boost_INCLUDE_DIRS}
${KERNEL_INCLUDE_DIRS}
${MEDFILE_INCLUDE_DIRS}
)
# additional preprocessor / compiler flags
ADD_DEFINITIONS(
${HDF5_DEFINITIONS}
${BOOST_DEFINITIONS}
)
SET(_link_LIBRARIES
${Boost_LIBRARIES}
)
# --- headers ---
# header files / no moc processing
SET(MEDWrapperBase_HEADERS
MED_Common.hxx
MED_Vector.hxx
MED_SharedPtr.hxx
MED_SliceArray.hxx
MED_Wrapper.hxx
MED_TWrapper.hxx
MED_Structures.hxx
MED_TStructures.hxx
MED_Algorithm.hxx
MED_GaussUtils.hxx
MED_CoordUtils.hxx
MED_Utilities.hxx
MED_GaussDef.hxx
MED_WrapperBase.hxx
)
# --- sources ---
# sources / static
SET(MEDWrapperBase_SOURCES
MED_Structures.cxx
MED_Wrapper.cxx
MED_Algorithm.cxx
MED_GaussUtils.cxx
MED_CoordUtils.cxx
MED_Utilities.cxx
MED_GaussDef.cxx
)
# --- rules ---
ADD_LIBRARY(MEDWrapperBase ${MEDWrapperBase_SOURCES})
TARGET_LINK_LIBRARIES(MEDWrapperBase ${_link_LIBRARIES})
INSTALL(TARGETS MEDWrapperBase EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
INSTALL(FILES ${MEDWrapperBase_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})

865
src/MEDWrapper/Base/MED_Structures.cxx
View File

@ -1,865 +0,0 @@
// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File : MED_Structure.cxx
// Author : Eugeny NIKOLAEV
//
#include "MED_Structures.hxx"
#include "MED_Utilities.hxx"
#include <cstring>
using namespace MED;
namespace MED
{
TInt
GetNbNodes(EGeometrieElement typmai)
{
return typmai%100;
}
std::string
GetString(TInt theId,
TInt theStep,
const TString& theString)
{
const char* aPos = &theString[theId*theStep];
TInt aSize = std::min(TInt(strlen(aPos)),theStep);
return std::string(aPos,aSize);
}
void
SetString(TInt theId,
TInt theStep,
TString& theString,
const std::string& theValue)
{
TInt aSize = std::min(TInt(theValue.size()+1),theStep);
char* aPos = &theString[theId*theStep];
strncpy(aPos,theValue.c_str(),aSize);
}
void
SetString(TInt theId,
TInt theStep,
TString& theString,
const TString& theValue)
{
TInt aSize = std::min(TInt(theValue.size()+1),theStep);
char* aPos = &theString[theId*theStep];
const char* aValue = &theValue[0];
strncpy(aPos,aValue,aSize);
}
TInt
GetDimGaussCoord(EGeometrieElement theGeom)
{
return theGeom/100;
}
TInt
GetNbRefCoord(EGeometrieElement theGeom)
{
return (theGeom%100);
}
//---------------------------------------------------------------
PFloatTimeStampValue
CastToFloatTimeStampValue(const PTimeStampValueBase& theTimeStampValue)
{
return theTimeStampValue;
}
PIntTimeStampValue
CastToIntTimeStampValue(const PTimeStampValueBase& theTimeStampValue)
{
return theTimeStampValue;
}
}
//---------------------------------------------------------------
TInt
TFamilyInfo
::GetAttrId(TInt theId) const
{
return myAttrId[theId];
}
TInt
TFamilyInfo
::GetAttrVal(TInt theId) const
{
return myAttrVal[theId];
}
void
TFamilyInfo
::SetAttrId(TInt theId,TInt theVal)
{
myAttrId[theId] = theVal;
}
void
TFamilyInfo
::SetAttrVal(TInt theId,TInt theVal)
{
myAttrVal[theId] = theVal;
}
//---------------------------------------------------------------
TInt
TElemInfo
::GetFamNum(TInt theId) const
{
return (*myFamNum)[theId];
}
void
TElemInfo
::SetFamNum(TInt theId, TInt theVal)
{
(*myFamNum)[theId] = theVal;
myIsFamNum = eVRAI;
}
TInt
TElemInfo
::GetElemNum(TInt theId) const
{
return (*myElemNum)[theId];
}
void
TElemInfo
::SetElemNum(TInt theId, TInt theVal)
{
(*myElemNum)[theId] = theVal;
}
//---------------------------------------------------------------
TCCoordSlice
TNodeInfo
::GetCoordSlice(TInt theId) const
{
TInt aDim = myMeshInfo->GetSpaceDim();
if(GetModeSwitch() == eFULL_INTERLACE)
return TCCoordSlice(*myCoord, std::slice(theId*aDim, aDim, 1));
else
return TCCoordSlice(*myCoord, std::slice(theId, aDim, aDim));
}
TCoordSlice
TNodeInfo
::GetCoordSlice(TInt theId)
{
TInt aDim = myMeshInfo->GetSpaceDim();
if(GetModeSwitch() == eFULL_INTERLACE)
return TCoordSlice(*myCoord, std::slice(theId*aDim,aDim,1));
else
return TCoordSlice(*myCoord, std::slice(theId,aDim,aDim));
}
//---------------------------------------------------------------
TCConnSlice
TCellInfo
::GetConnSlice(TInt theElemId) const
{
if(GetModeSwitch() == eFULL_INTERLACE)
return TCConnSlice(*myConn, std::slice(GetConnDim()*theElemId, GetNbNodes(myGeom), 1));
else
return TCConnSlice(*myConn, std::slice(theElemId, GetNbNodes(myGeom), GetConnDim()));
}
TConnSlice
TCellInfo
::GetConnSlice(TInt theElemId)
{
if(GetModeSwitch() == eFULL_INTERLACE)
return TConnSlice(*myConn, std::slice(GetConnDim()*theElemId, GetNbNodes(myGeom), 1));
else
return TConnSlice(*myConn, std::slice(theElemId, GetNbNodes(myGeom), GetConnDim()));
}
//---------------------------------------------------------------
TInt
TPolygoneInfo
::GetNbConn(TInt theElemId) const
{
return (*myIndex)[theElemId + 1] - (*myIndex)[theElemId];
}
TCConnSlice
TPolygoneInfo
::GetConnSlice(TInt theElemId) const
{
return TCConnSlice(*myConn, std::slice((*myIndex)[theElemId] - 1, GetNbConn(theElemId), 1));
}
TConnSlice
TPolygoneInfo
::GetConnSlice(TInt theElemId)
{
return TConnSlice(*myConn, std::slice((*myIndex)[theElemId] - 1, GetNbConn(theElemId), 1));
}
//---------------------------------------------------------------
TInt
TPolyedreInfo
::GetNbFaces(TInt theElemId) const
{
return (*myIndex)[theElemId+1] - (*myIndex)[theElemId];
}
TInt
TPolyedreInfo
::GetNbNodes(TInt theElemId) const
{
TInt aNbNodes = 0;
TInt aNbFaces = GetNbFaces(theElemId);
TInt aStartFaceId = (*myIndex)[theElemId] - 1;
for(TInt aFaceId = 0; aFaceId < aNbFaces; aFaceId++, aStartFaceId++){
TInt aCurrentId = (*myFaces)[aStartFaceId];
TInt aDiff = (*myFaces)[aStartFaceId + 1] - aCurrentId;
aNbNodes += aDiff;
}
return aNbNodes;
}
TCConnSliceArr
TPolyedreInfo
::GetConnSliceArr(TInt theElemId) const
{
TInt aNbFaces = GetNbFaces(theElemId);
TCConnSliceArr aConnSliceArr(aNbFaces);
TInt aStartFaceId = (*myIndex)[theElemId] - 1;
for(TInt aFaceId = 0; aFaceId < aNbFaces; aFaceId++, aStartFaceId++){
TInt aCurrentId = (*myFaces)[aStartFaceId];
TInt aDiff = (*myFaces)[aStartFaceId + 1] - aCurrentId;
aConnSliceArr[aFaceId] =
TCConnSlice(*myConn, std::slice(aCurrentId - 1, aDiff, 1));
}
return aConnSliceArr;
}
TConnSliceArr
TPolyedreInfo
::GetConnSliceArr(TInt theElemId)
{
TInt aNbFaces = GetNbFaces(theElemId);
TConnSliceArr aConnSliceArr(aNbFaces);
TInt aStartFaceId = (*myIndex)[theElemId] - 1;
for(TInt aFaceId = 0; aFaceId < aNbFaces; aFaceId++, aStartFaceId++){
TInt aCurrentId = (*myFaces)[aStartFaceId];
TInt aDiff = (*myFaces)[aStartFaceId + 1] - aCurrentId;
aConnSliceArr[aFaceId] =
TConnSlice(*myConn, std::slice(aCurrentId - 1, aDiff, 1));
}
return aConnSliceArr;
}
//---------------------------------------------------------------
TMeshValueBase
::TMeshValueBase():
myNbElem(0),
myNbComp(0),
myNbGauss(0),
myStep(0)
{}
void
TMeshValueBase
::Allocate(TInt theNbElem,
TInt theNbGauss,
TInt theNbComp,
EModeSwitch theMode)
{
myModeSwitch = theMode;
myNbElem = theNbElem;
myNbGauss = theNbGauss;
myNbComp = theNbComp;
myStep = theNbComp*theNbGauss;
}
size_t
TMeshValueBase
::GetSize() const
{
return myNbElem * myStep;
}
size_t
TMeshValueBase
::GetNbVal() const
{
return myNbElem * myNbGauss;
}
size_t
TMeshValueBase
::GetNbGauss() const
{
return myNbGauss;
}
size_t
TMeshValueBase
::GetStep() const
{
return myStep;
}
//---------------------------------------------------------------
TInt
TProfileInfo
::GetElemNum(TInt theId) const
{
return (*myElemNum)[theId];
}
void
TProfileInfo
::SetElemNum(TInt theId,TInt theVal)
{
(*myElemNum)[theId] = theVal;
}
//---------------------------------------------------------------
bool
TGaussInfo::TLess
::operator()(const TKey& theLeft, const TKey& theRight) const
{
EGeometrieElement aLGeom = boost::get<0>(theLeft);
EGeometrieElement aRGeom = boost::get<0>(theRight);
if(aLGeom != aRGeom)
return aLGeom < aRGeom;
const std::string& aLStr = boost::get<1>(theLeft);
const std::string& aRStr = boost::get<1>(theRight);
return aLStr < aRStr;
}
bool
TGaussInfo::TLess
::operator()(const TGaussInfo& theLeft, const TGaussInfo& theRight) const
{
if(!&theLeft)
return true;
if(!&theRight)
return false;
if(theLeft.myGeom != theRight.myGeom)
return theLeft.myGeom < theRight.myGeom;
if(theLeft.myRefCoord != theRight.myRefCoord)
return theLeft.myRefCoord < theRight.myRefCoord;
return theLeft.myGaussCoord < theRight.myGaussCoord;
}
TCCoordSlice
TGaussInfo
::GetRefCoordSlice(TInt theId) const
{
if(GetModeSwitch() == eFULL_INTERLACE)
return TCCoordSlice(myRefCoord,std::slice(theId*GetDim(),GetDim(),1));
else
return TCCoordSlice(myRefCoord,std::slice(theId,GetDim(),GetDim()));
}
TCoordSlice
TGaussInfo
::GetRefCoordSlice(TInt theId)
{
if(GetModeSwitch() == eFULL_INTERLACE)
return TCoordSlice(myRefCoord,std::slice(theId*GetDim(),GetDim(),1));
else
return TCoordSlice(myRefCoord,std::slice(theId,GetDim(),GetDim()));
}
TCCoordSlice
TGaussInfo
::GetGaussCoordSlice(TInt theId) const
{
if(GetModeSwitch() == eFULL_INTERLACE)
return TCCoordSlice(myGaussCoord,std::slice(theId*GetDim(),GetDim(),1));
else
return TCCoordSlice(myGaussCoord,std::slice(theId,GetDim(),GetDim()));
}
TCoordSlice
TGaussInfo
::GetGaussCoordSlice(TInt theId)
{
if(GetModeSwitch() == eFULL_INTERLACE)
return TCoordSlice(myGaussCoord,std::slice(theId*GetDim(),GetNbGauss(),1));
else
return TCoordSlice(myGaussCoord,std::slice(theId,GetNbGauss(),GetDim()));
}
//---------------------------------------------------------------
TInt
TTimeStampInfo
::GetNbGauss(EGeometrieElement theGeom) const
{
TGeom2NbGauss::const_iterator anIter = myGeom2NbGauss.find(theGeom);
if(anIter == myGeom2NbGauss.end())
return 1;//EXCEPTION(runtime_error,"TTimeStampInfo::GetNbGauss - myGeom2NbGauss.find(theGeom) fails");
return anIter->second;
}
//---------------------------------------------------------------
// TGrilleInfo structure methods
//---------------------------------------------------------------
const EGrilleType&
TGrilleInfo
::GetGrilleType() const
{
return myGrilleType;
}
EGrilleType
TGrilleInfo
::GetGrilleType()
{
return myGrilleType;
}
void
TGrilleInfo
::SetGrilleType(EGrilleType theGrilleType)
{
myGrilleType = theGrilleType;
}
const
TIndexes&
TGrilleInfo
::GetMapOfIndexes() const
{
return myIndixes;
}
TIndexes&
TGrilleInfo
::GetMapOfIndexes()
{
return myIndixes;
}
const
TFloatVector&
TGrilleInfo
::GetIndexes(TInt theAxisNumber) const
{
TIndexes::const_iterator aIter=myIndixes.find(theAxisNumber);
if(aIter==myIndixes.end())
EXCEPTION(std::runtime_error, "const TGrilleInfo::GetIndexes - myIndixes.find(theAxisNumber); fails");
return aIter->second;
}
TFloatVector&
TGrilleInfo
::GetIndexes(TInt theAxisNumber)
{
TIndexes::iterator aIter=myIndixes.find(theAxisNumber);
if(aIter==myIndixes.end())
EXCEPTION(std::runtime_error, "TGrilleInfo::GetIndexes - myIndixes.find(theAxisNumber="<<theAxisNumber<<"); fails");
return aIter->second;
}
TInt
TGrilleInfo
::GetNbIndexes(TInt theAxisNumber)
{
const TFloatVector& aVector=GetIndexes(theAxisNumber);
return aVector.size();
}
TInt
TGrilleInfo
::GetNbNodes()
{
TInt nbNodes=0;
TInt aDim = myMeshInfo->GetDim();
for(int i=0;i<aDim;i++)
if(nbNodes == 0)
nbNodes = this->GetGrilleStructure()[i];
else
nbNodes = nbNodes*this->GetGrilleStructure()[i];
return nbNodes;
}
TInt
TGrilleInfo
::GetNbCells()
{
TInt nbCells=0;
TInt aDim = myMeshInfo->GetDim();
for(int i=0;i<aDim;i++)
if(nbCells == 0)
nbCells = this->GetGrilleStructure()[i]-1;
else
nbCells = nbCells*(this->GetGrilleStructure()[i]-1);
return nbCells;
}
TInt
TGrilleInfo
::GetNbSubCells()
{
TInt nb=0;
TInt aDim = myMeshInfo->GetDim();
switch (aDim) {
case 3:
nb =
(myGrilleStructure[0] ) * (myGrilleStructure[1]-1) * (myGrilleStructure[2]-1) +
(myGrilleStructure[0]-1) * (myGrilleStructure[1] ) * (myGrilleStructure[2]-1) +
(myGrilleStructure[0]-1) * (myGrilleStructure[1]-1) * (myGrilleStructure[2] );
break;
case 2:
nb =
(myGrilleStructure[0] ) * (myGrilleStructure[1]-1) +
(myGrilleStructure[0]-1) * (myGrilleStructure[1] );
break;
}
return nb;
}
EGeometrieElement
TGrilleInfo
::GetGeom()
{
TInt aDim = myMeshInfo->GetDim();
switch(aDim){
case 1:
return eSEG2;
case 2:
return eQUAD4;
case 3:
return eHEXA8;
default:
return eNONE;
}
}
EGeometrieElement
TGrilleInfo
::GetSubGeom()
{
TInt aDim = myMeshInfo->GetDim();
switch(aDim){
case 2:
return eSEG2;
case 3:
return eQUAD4;
}
return eNONE;
}
EEntiteMaillage
TGrilleInfo
::GetEntity()
{
return eMAILLE;
}
EEntiteMaillage
TGrilleInfo
::GetSubEntity()
{
TInt aDim = myMeshInfo->GetDim();
switch(aDim){
case 2:
return eARETE;
case 3:
return eFACE;
}
return EEntiteMaillage(-1);
}
const
TIntVector&
TGrilleInfo
::GetGrilleStructure() const
{
return myGrilleStructure;
}
TIntVector
TGrilleInfo
::GetGrilleStructure()
{
return myGrilleStructure;
}
void
TGrilleInfo
::SetGrilleStructure(TInt theAxis,TInt theNb)
{
if(theAxis >= 0 && theAxis <=2 && theNb >= 0)
myGrilleStructure[theAxis]=theNb;
}
const
TNodeCoord&
TGrilleInfo
::GetNodeCoord() const
{
return myCoord;
}
TNodeCoord&
TGrilleInfo
::GetNodeCoord()
{
return myCoord;
}
TNodeCoord
TGrilleInfo
::GetCoord(TInt theId)
{
TNodeCoord aCoord;
TInt aDim = myMeshInfo->GetDim();
TInt aNbNodes = this->GetNbNodes();
aCoord.resize(aDim);
if(theId >= aNbNodes)
EXCEPTION(std::runtime_error, "TGrilleInfo::GetCoord - theId out of range");
if(myGrilleType == eGRILLE_STANDARD){
switch(aDim){
case 3:
aCoord[2] = myCoord[aDim*theId+2];
case 2:
aCoord[1] = myCoord[aDim*theId+1];
case 1:{
aCoord[0] = myCoord[aDim*theId];
break;
}
}
} else {
TFloatVector aVecX = this->GetIndexes(0);
TInt nbIndxX = this->GetNbIndexes(0);
switch(aDim){
case 1:{
aCoord[0] = aVecX[theId];
break;
}
case 2:{
TFloatVector aVecY = this->GetIndexes(1);
TInt i,j,k;
i = j = k = 0;
i = theId % nbIndxX;
j = theId / nbIndxX;
if(myGrilleType == eGRILLE_CARTESIENNE){
aCoord[0] = aVecX[i];
aCoord[1] = aVecY[j];
} else { // eGRILLE_POLAIRE (cylindrical)
aCoord[0] = aVecX[i] * cos(aVecY[j]);
aCoord[1] = aVecX[i] * sin(aVecY[j]);
}
break;
}
case 3:{
TFloatVector aVecY = this->GetIndexes(1);
TInt nbIndxY = this->GetNbIndexes(1);
TFloatVector aVecZ = this->GetIndexes(2);
TInt i,j,k;
i = j = k = 0;
i = theId % nbIndxX;
j = (theId / nbIndxX) % nbIndxY;
k = theId / (nbIndxX*nbIndxY);
if(myGrilleType == eGRILLE_CARTESIENNE){
aCoord[0] = aVecX[i];
aCoord[1] = aVecY[j];
aCoord[2] = aVecZ[k];
} else { // eGRILLE_POLAIRE (cylindrical)
aCoord[0] = aVecX[i] * cos(aVecY[j]);
aCoord[1] = aVecX[i] * sin(aVecY[j]);
aCoord[2] = aVecZ[k];
}
break;
}
}
}
return aCoord;
}
TIntVector
TGrilleInfo
::GetConn(TInt theId, const bool isSub)
{
TIntVector anIndexes;
TInt aDim = myMeshInfo->GetDim();
TInt idx;
TInt iMin, jMin, kMin, iMax, jMax, kMax;
TInt loc[3];
loc[0] = loc[1] = loc[2] = 0;
iMin = iMax = jMin = jMax = kMin = kMax = 0;
switch(aDim) {
case 3:
{
TInt nbX = this->GetGrilleStructure()[0];
TInt nbY = this->GetGrilleStructure()[1];
TInt nbZ = this->GetGrilleStructure()[2];
TInt d01 = nbX*nbY, dX = 1, dY = 1, dZ = 1;
if ( isSub )
{
if ( theId < nbX * (nbY-1) * (nbZ-1))
{ // face is normal to X axis
dX = 0;
}
else if ( theId < nbX * (nbY-1) * (nbZ-1) + (nbX-1) * nbY * (nbZ-1))
{ // face is normal to Y axis
theId -= nbX * (nbY-1) * (nbZ-1);
dY = 0;
}
else
{
theId -= nbX * (nbY-1) * (nbZ-1) + (nbX-1) * nbY * (nbZ-1);
dZ = 0;
}
}
//else
{
iMin = theId % (nbX - dX);
jMin = (theId / (nbX - dX)) % (nbY - dY);
kMin = theId / ((nbX - dX) * (nbY - dY));
iMax = iMin+dX;
jMax = jMin+dY;
kMax = kMin+dZ;
}
for (loc[2]=kMin; loc[2]<=kMax; loc[2]++)
for (loc[1]=jMin; loc[1]<=jMax; loc[1]++)
for (loc[0]=iMin; loc[0]<=iMax; loc[0]++)
{
idx = loc[0] + loc[1]*nbX + loc[2]*d01;
anIndexes.push_back(idx);
}
break;
}
case 2:
{
TInt nbX = this->GetGrilleStructure()[0];
TInt nbY = this->GetGrilleStructure()[1];
TInt dX = 1, dY = 1;
if ( isSub )
{
if ( theId < nbX * (nbY-1))
{ // edge is normal to X axis
dX = 0;
}
else
{
theId -= nbX * (nbY-1);
dY = 0;
}
}
iMin = theId % (nbX-dX);
jMin = theId / (nbX-dX);
iMax = iMin+dX;
jMax = jMin+dY;
for (loc[1]=jMin; loc[1]<=jMax; loc[1]++)
for (loc[0]=iMin; loc[0]<=iMax; loc[0]++)
{
idx = loc[0] + loc[1]*nbX;
anIndexes.push_back(idx);
}
break;
}
case 1:
{
iMin = theId;
for (loc[0]=iMin; loc[0]<=iMin+1; loc[0]++)
{
idx = loc[0];
anIndexes.push_back(idx);
}
break;
}
}
return anIndexes;
}
TInt
TGrilleInfo
::GetFamNumNode(TInt theId) const
{
return myFamNumNode[theId];
}
void
TGrilleInfo
::SetFamNumNode(TInt theId,TInt theVal)
{
myFamNumNode[theId] = theVal;
}
TInt
TGrilleInfo
::GetFamNum(TInt theId) const
{
return myFamNum[theId];
}
void
TGrilleInfo
::SetFamNum(TInt theId,TInt theVal)
{
myFamNum[theId] = theVal;
}
TInt
TGrilleInfo
::GetFamSubNum(TInt theId) const
{
return myFamSubNum[theId];
}
void
TGrilleInfo
::SetFamSubNum(TInt theId,TInt theVal)
{
myFamSubNum[theId] = theVal;
}

578
src/MEDWrapper/Base/MED_TWrapper.hxx
View File

@ -1,578 +0,0 @@
// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#ifndef MED_TWrapper_HeaderFile
#define MED_TWrapper_HeaderFile
#include "MED_TStructures.hxx"
#include "MED_Wrapper.hxx"
namespace MED
{
template<EVersion eVersion>
class TTWrapper: public TWrapper
{
public:
//----------------------------------------------------------------------------
//! Gets version of the MED library used for the MED file
virtual
EVersion
GetVersion()
{
return eVersion;
}
//----------------------------------------------------------------------------
virtual
PMeshInfo
CrMeshInfo(TInt theDim = 0, TInt theSpaceDim = 0,
const std::string& theValue = "",
EMaillage theType = eNON_STRUCTURE,
const std::string& theDesc = "")
{
return PMeshInfo(new TTMeshInfo<eVersion>
(theDim,
theSpaceDim,
theValue,
theType,
theDesc));
}
virtual
PMeshInfo
CrMeshInfo(const PMeshInfo& theInfo)
{
return PMeshInfo(new TTMeshInfo<eVersion>(theInfo));
}
//----------------------------------------------------------------------------
virtual
PFamilyInfo
CrFamilyInfo(const PMeshInfo& theMeshInfo,
TInt theNbGroup = 0,
TInt theNbAttr = 0,
TInt theId = 0,
const std::string& theValue = "")
{
return PFamilyInfo(new TTFamilyInfo<eVersion>
(theMeshInfo,
theNbGroup,
theNbAttr,
theId,
theValue));
}
virtual
PFamilyInfo
CrFamilyInfo(const PMeshInfo& theMeshInfo,
const std::string& theValue,
TInt theId,
const MED::TStringSet& theGroupNames,
const MED::TStringVector& theAttrDescs = MED::TStringVector(),
const MED::TIntVector& theAttrIds = MED::TIntVector(),
const MED::TIntVector& theAttrVals = MED::TIntVector())
{
return PFamilyInfo(new TTFamilyInfo<eVersion>
(theMeshInfo,
theValue,
theId,
theGroupNames,
theAttrDescs,
theAttrIds,
theAttrVals));
}
virtual
PFamilyInfo
CrFamilyInfo(const PMeshInfo& theMeshInfo,
const PFamilyInfo& theInfo)
{
return PFamilyInfo(new TTFamilyInfo<eVersion>
(theMeshInfo,
theInfo));
}
//----------------------------------------------------------------------------
virtual
PElemInfo
CrElemInfo(const PMeshInfo& theMeshInfo,
TInt theNbElem,
EBooleen theIsElemNum = eVRAI,
EBooleen theIsElemNames = eVRAI)
{
return PElemInfo(new TTElemInfo<eVersion>
(theMeshInfo,
theNbElem,
theIsElemNum,
theIsElemNames));
}
virtual
PElemInfo
CrElemInfo(const PMeshInfo& theMeshInfo,
TInt theNbElem,
const TIntVector& theFamNum,
const TIntVector& aElemNum,
const TStringVector& aElemNames)
{
return PElemInfo(new TTElemInfo<eVersion>
(theMeshInfo,
theNbElem,
theFamNum,
aElemNum,
aElemNames));
}
//----------------------------------------------------------------------------
virtual
PNodeInfo
CrNodeInfo(const PMeshInfo& theMeshInfo,
TInt theNbElem,
EModeSwitch theMode = eFULL_INTERLACE,
ERepere theSystem = eCART,
EBooleen theIsElemNum = eVRAI,
EBooleen theIsElemNames = eVRAI)
{
return PNodeInfo(new TTNodeInfo<eVersion>
(theMeshInfo,
theNbElem,
theMode,
theSystem,
theIsElemNum,
theIsElemNames));
}
virtual
PNodeInfo
CrNodeInfo(const PMeshInfo& theMeshInfo,
const TFloatVector& theNodeCoords,
EModeSwitch theMode = eFULL_INTERLACE,
ERepere theSystem = eCART,
const TStringVector& theCoordNames = TStringVector(),
const TStringVector& theCoordUnits = TStringVector(),
const TIntVector& theFamilyNums = TIntVector(),
const TIntVector& theElemNums = TIntVector(),
const TStringVector& theElemNames = TStringVector())
{
return PNodeInfo(new TTNodeInfo<eVersion>
(theMeshInfo,
theNodeCoords,
theMode,
theSystem,
theCoordNames,
theCoordUnits,
theFamilyNums,
theElemNums,
theElemNames));
}
virtual
PNodeInfo
CrNodeInfo(const PMeshInfo& theMeshInfo,
const PNodeInfo& theInfo)
{
return PNodeInfo(new TTNodeInfo<eVersion>
(theMeshInfo,
theInfo));
}
//----------------------------------------------------------------------------
virtual
PPolygoneInfo
CrPolygoneInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TInt theNbElem,
TInt theConnSize,
EConnectivite theConnMode = eNOD,
EBooleen theIsElemNum = eVRAI,
EBooleen theIsElemNames = eVRAI)
{
return PPolygoneInfo(new TTPolygoneInfo<eVersion>
(theMeshInfo,
theEntity,
theGeom,
theNbElem,
theConnSize,
theConnMode,
theIsElemNum,
theIsElemNames));
}
virtual
PPolygoneInfo
CrPolygoneInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
const TIntVector& theIndexes,
const TIntVector& theConnectivities,
EConnectivite theConnMode = eNOD,
const TIntVector& theFamilyNums = TIntVector(),
const TIntVector& theElemNums = TIntVector(),
const TStringVector& theElemNames = TStringVector())
{
return PPolygoneInfo(new TTPolygoneInfo<eVersion>
(theMeshInfo,
theEntity,
theGeom,
theIndexes,
theConnectivities,
theConnMode,
theFamilyNums,
theElemNums,
theElemNames));
}
virtual
PPolygoneInfo
CrPolygoneInfo(const PMeshInfo& theMeshInfo,
const PPolygoneInfo& theInfo)
{
return PPolygoneInfo(new TTPolygoneInfo<eVersion>
(theMeshInfo,
theInfo));
}
//----------------------------------------------------------------------------
virtual
PPolyedreInfo
CrPolyedreInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TInt theNbElem,
TInt theNbFaces,
TInt theConnSize,
EConnectivite theConnMode = eNOD,
EBooleen theIsElemNum = eVRAI,
EBooleen theIsElemNames = eVRAI)
{
return PPolyedreInfo(new TTPolyedreInfo<eVersion>
(theMeshInfo,
theEntity,
theGeom,
theNbElem,
theNbFaces,
theConnSize,
theConnMode,
theIsElemNum,
theIsElemNames));
}
virtual
PPolyedreInfo
CrPolyedreInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
const TIntVector& theIndexes,
const TIntVector& theFaces,
const TIntVector& theConnectivities,
EConnectivite theConnMode = eNOD,
const TIntVector& theFamilyNums = TIntVector(),
const TIntVector& theElemNums = TIntVector(),
const TStringVector& theElemNames = TStringVector())
{
return PPolyedreInfo(new TTPolyedreInfo<eVersion>
(theMeshInfo,
theEntity,
theGeom,
theIndexes,
theFaces,
theConnectivities,
theConnMode,
theFamilyNums,
theElemNums,
theElemNames));
}
virtual
PPolyedreInfo
CrPolyedreInfo(const PMeshInfo& theMeshInfo,
const PPolyedreInfo& theInfo)
{
return PPolyedreInfo(new TTPolyedreInfo<eVersion>
(theMeshInfo,
theInfo));
}
//----------------------------------------------------------------------------
virtual
PCellInfo
CrCellInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TInt theNbElem,
EConnectivite theConnMode = eNOD,
EBooleen theIsElemNum = eVRAI,
EBooleen theIsElemNames = eVRAI,
EModeSwitch theMode = eFULL_INTERLACE)
{
return PCellInfo(new TTCellInfo<eVersion>
(theMeshInfo,
theEntity,
theGeom,
theNbElem,
theConnMode,
theIsElemNum,
theIsElemNames,
theMode));
}
virtual
PCellInfo
CrCellInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
const TIntVector& theConnectivities,
EConnectivite theConnMode = eNOD,
const TIntVector& theFamilyNums = TIntVector(),
const TIntVector& theElemNums = TIntVector(),
const TStringVector& theElemNames = TStringVector(),
EModeSwitch theMode = eFULL_INTERLACE)
{
return PCellInfo(new TTCellInfo<eVersion>
(theMeshInfo,
theEntity,
theGeom,
theConnectivities,
theConnMode,
theFamilyNums,
theElemNums,
theElemNames,
theMode));
}
virtual
PCellInfo
CrCellInfo(const PMeshInfo& theMeshInfo,
const PCellInfo& theInfo)
{
return PCellInfo(new TTCellInfo<eVersion>
(theMeshInfo,
theInfo));
}
//----------------------------------------------------------------------------
//! Creates a MEDWrapper MED Balls representation
virtual PBallInfo CrBallInfo(const PMeshInfo& theMeshInfo,
TInt theNbBalls,
EBooleen theIsElemNum = eVRAI)
{
return PBallInfo( new TTBallInfo<eVersion>( theMeshInfo, theNbBalls, theIsElemNum ));
}
//! Creates a MEDWrapper MED Balls representation
virtual PBallInfo CrBallInfo(const PMeshInfo& theMeshInfo,
const TIntVector& theNodes,
TFloatVector& theDiameters,
const TIntVector& theFamilyNums = TIntVector(),
const TIntVector& theElemNums = TIntVector())
{
return PBallInfo( new TTBallInfo<eVersion>( theMeshInfo, theNodes, theDiameters,
theFamilyNums, theElemNums));
}
//! A copy-constructor for the MEDWrapper MED Balls representation
virtual PBallInfo CrBallInfo(const PMeshInfo& theMeshInfo,
const PBallInfo& theInfo)
{
return PBallInfo( new TTBallInfo<eVersion>( theMeshInfo, theInfo ));
}
//----------------------------------------------------------------------------
virtual
PFieldInfo
CrFieldInfo(const PMeshInfo& theMeshInfo,
TInt theNbComp = 0,
ETypeChamp theType = eFLOAT64,
const std::string& theValue = "",
EBooleen theIsLocal = eVRAI,
TInt theNbRef = 1)
{
return PFieldInfo(new TTFieldInfo<eVersion>
(theMeshInfo,
theNbComp,
theType,
theValue,
theIsLocal,
theNbRef));
}
virtual
PFieldInfo
CrFieldInfo(const PMeshInfo& theMeshInfo,
const PFieldInfo& theInfo)
{
return PFieldInfo(new TTFieldInfo<eVersion>
(theMeshInfo,
theInfo));
}
//----------------------------------------------------------------------------
virtual
PTimeStampInfo
CrTimeStampInfo(const PFieldInfo& theFieldInfo,
EEntiteMaillage theEntity,
const TGeom2Size& theGeom2Size,
const TGeom2NbGauss& theGeom2NbGauss = TGeom2NbGauss(),
TInt theNumDt = 0,
TInt theNumOrd = 0,
TFloat theDt = 0,
const std::string& theUnitDt = "",
const TGeom2Gauss& theGeom2Gauss = TGeom2Gauss())
{
return PTimeStampInfo(new TTTimeStampInfo<eVersion>
(theFieldInfo,
theEntity,
theGeom2Size,
theGeom2NbGauss,
theNumDt,
theNumOrd,
theDt,
theUnitDt,
theGeom2Gauss));
}
virtual
PTimeStampInfo
CrTimeStampInfo(const PFieldInfo& theFieldInfo,
const PTimeStampInfo& theInfo)
{
return PTimeStampInfo(new TTTimeStampInfo<eVersion>
(theFieldInfo,
theInfo));
}
//----------------------------------------------------------------------------
virtual
PGaussInfo
CrGaussInfo(const TGaussInfo::TInfo& theInfo,
EModeSwitch theMode = eFULL_INTERLACE)
{
return PGaussInfo(new TTGaussInfo<eVersion>
(theInfo,
theMode));
}
//----------------------------------------------------------------------------
virtual
PProfileInfo
CrProfileInfo(const TProfileInfo::TInfo& theInfo,
EModeProfil theMode = eCOMPACT)
{
return PProfileInfo(new TTProfileInfo<eVersion>
(theInfo,
theMode));
}
//----------------------------------------------------------------------------
virtual
PTimeStampValueBase
CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
ETypeChamp theTypeChamp,
const TGeom2Profile& theGeom2Profile = TGeom2Profile(),
EModeSwitch theMode = eFULL_INTERLACE)
{
if(theTypeChamp == eFLOAT64)
return PTimeStampValueBase(new TTTimeStampValue<eVersion, TFloatMeshValue>
(theTimeStampInfo,
theTypeChamp,
theGeom2Profile,
theMode));
return PTimeStampValueBase(new TTTimeStampValue<eVersion, TIntMeshValue>
(theTimeStampInfo,
theTypeChamp,
theGeom2Profile,
theMode));
}
virtual
PTimeStampValueBase
CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
const PTimeStampValueBase& theInfo,
ETypeChamp theTypeChamp)
{
if(theTypeChamp == eFLOAT64)
return PTimeStampValueBase(new TTTimeStampValue<eVersion, TFloatMeshValue>
(theTimeStampInfo,
theInfo,
theTypeChamp));
return PTimeStampValueBase(new TTTimeStampValue<eVersion, TIntMeshValue>
(theTimeStampInfo,
theInfo,
theTypeChamp));
}
//----------------------------------------------------------------------------
virtual
PGrilleInfo
CrGrilleInfo(const PMeshInfo& theMeshInfo,
const PGrilleInfo& theInfo)
{
return PGrilleInfo(new TTGrilleInfo<eVersion>
(theMeshInfo,
theInfo));
}
virtual
PGrilleInfo
CrGrilleInfo(const PMeshInfo& theMeshInfo,
const EGrilleType& type)
{
return PGrilleInfo(new TTGrilleInfo<eVersion>
(theMeshInfo,
type));
}
virtual
PGrilleInfo
CrGrilleInfo(const PMeshInfo& theMeshInfo,
const EGrilleType& type,
const TInt& nbNodes)
{
return PGrilleInfo(new TTGrilleInfo<eVersion>
(theMeshInfo,
type,
nbNodes));
}
virtual
PGrilleInfo
CrGrilleInfo(const PMeshInfo& theMeshInfo,
const EGrilleType& type,
const MED::TIntVector& nbNodeVec)
{
return PGrilleInfo(new TTGrilleInfo<eVersion>
(theMeshInfo,
type,
nbNodeVec));
}
//----------------------------------------------------------------------------
};
}
#endif

113
src/MEDWrapper/Base/MED_Utilities.cxx
View File

@ -1,113 +0,0 @@
// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "MED_Utilities.hxx"
#include "MED_Common.hxx"
using namespace std;
#ifdef _DEBUG_
static int MYDEBUG = 0;
#else
// static int MYDEBUG = 0;
#endif
int MED::PrefixPrinter::myCounter = 0;
MED::PrefixPrinter::PrefixPrinter(bool theIsActive):
myIsActive(theIsActive)
{
if(myIsActive)
myCounter++;
MSG(MYDEBUG,"MED::PrefixPrinter::PrefixPrinter(...)- "<<myCounter);
}
MED::PrefixPrinter::~PrefixPrinter()
{
if(myIsActive){
myCounter--;
if(myCounter < 0)
EXCEPTION(runtime_error,"PrefixPrinter::~PrefixPrinter() - myCounter("<<myCounter<<") < 0");
}
}
string MED::PrefixPrinter::GetPrefix()
{
if(myCounter){
if(myCounter < 0)
EXCEPTION(runtime_error,"PrefixPrinter::~PrefixPrinter() - myCounter("<<myCounter<<") < 0");
return string(myCounter*2,' ');
}
return "";
}
static MED::TEntity2GeomSet Entity2GeomSet;
bool InitEntity2GeomSet()
{
using namespace MED;
TGeomSet& aGeomARETESet = Entity2GeomSet[eARETE];
aGeomARETESet.insert(eSEG2);
aGeomARETESet.insert(eSEG3);
TGeomSet& aGeomFACESet = Entity2GeomSet[eFACE];
aGeomFACESet.insert(eTRIA3);
aGeomFACESet.insert(eQUAD4);
aGeomFACESet.insert(eTRIA6);
aGeomFACESet.insert(eTRIA7);
aGeomFACESet.insert(eQUAD8);
aGeomFACESet.insert(eQUAD9);
aGeomFACESet.insert(ePOLYGONE);
aGeomFACESet.insert(ePOLYGON2);
TGeomSet& aGeomMAILLESet = Entity2GeomSet[eMAILLE];
aGeomMAILLESet.insert(ePOINT1);
aGeomMAILLESet.insert(aGeomARETESet.begin(),aGeomARETESet.end());
aGeomMAILLESet.insert(aGeomFACESet.begin(),aGeomFACESet.end());
aGeomMAILLESet.insert(eTETRA4);
aGeomMAILLESet.insert(ePYRA5);
aGeomMAILLESet.insert(ePENTA6);
aGeomMAILLESet.insert(eHEXA8);
aGeomMAILLESet.insert(eOCTA12);
aGeomMAILLESet.insert(eTETRA10);
aGeomMAILLESet.insert(ePYRA13);
aGeomMAILLESet.insert(ePENTA15);
aGeomMAILLESet.insert(eHEXA20);
aGeomMAILLESet.insert(eHEXA27);
aGeomMAILLESet.insert(ePOLYEDRE);
/* This combination allows reading nb of models of structure elements */
Entity2GeomSet[eSTRUCT_ELEMENT].insert(eAllGeoType);
return true;
}
static bool anIsInited = InitEntity2GeomSet();
const MED::TEntity2GeomSet& MED::GetEntity2GeomSet()
{
return Entity2GeomSet;
}

707
src/MEDWrapper/Base/MED_Wrapper.cxx
View File

@ -1,707 +0,0 @@
// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File : MED_Wrapper.cxx
// Author : Alexey PETROV
//
#include "MED_Wrapper.hxx"
#include "MED_Utilities.hxx"
#include <boost/version.hpp>
#ifdef _DEBUG_
static int MYDEBUG = 0;
static int MYVALUEDEBUG = 0;
#else
// static int MYDEBUG = 0;
// static int MYVALUEDEBUG = 0;
#endif
namespace MED
{
TLockProxy
::TLockProxy(TWrapper* theWrapper):
myWrapper(theWrapper)
{
#if BOOST_VERSION >= 103500
myWrapper->myMutex.lock();
#else
boost::detail::thread::lock_ops<TWrapper::TMutex>::lock(myWrapper->myMutex);
#endif
INITMSG(MYDEBUG,"TLockProxy() - this -"<<this<<"; myWrapper = "<<myWrapper<<std::endl);
}
TLockProxy
::~TLockProxy()
{
INITMSG(MYDEBUG,"~TLockProxy() - this -"<<this<<"; myWrapper = "<<myWrapper<<std::endl);
#if BOOST_VERSION >= 103500
myWrapper->myMutex.unlock();
#else
boost::detail::thread::lock_ops<TWrapper::TMutex>::unlock(myWrapper->myMutex);
#endif
}
TWrapper*
TLockProxy
::operator-> () const // never throws
{
return myWrapper;
}
//----------------------------------------------------------------------------
TWrapper::~TWrapper()
{
}
//----------------------------------------------------------------------------
PMeshInfo
TWrapper
::GetPMeshInfo(TInt theId,
TErr* theErr)
{
PMeshInfo anInfo = CrMeshInfo();
GetMeshInfo(theId,*anInfo,theErr);
return anInfo;
}
//----------------------------------------------------------------------------
PFamilyInfo
TWrapper
::GetPFamilyInfo(const PMeshInfo& theMeshInfo,
TInt theId,
TErr* theErr)
{
// must be reimplemented in connection with mesh type eSTRUCTURE
// if(theMeshInfo->GetType() != eNON_STRUCTURE)
// return PFamilyInfo();
TInt aNbAttr = GetNbFamAttr(theId,*theMeshInfo);
TInt aNbGroup = GetNbFamGroup(theId,*theMeshInfo);
PFamilyInfo anInfo = CrFamilyInfo(theMeshInfo,aNbGroup,aNbAttr);
GetFamilyInfo(theId,*anInfo,theErr);
#ifdef _DEBUG_
std::string aName = anInfo->GetName();
INITMSG(MYDEBUG,"GetPFamilyInfo - aFamilyName = '"<<aName<<
"'; andId = "<<anInfo->GetId()<<
"; aNbAttr = "<<aNbAttr<<
"; aNbGroup = "<<aNbGroup<<"\n");
for(TInt iGroup = 0; iGroup < aNbGroup; iGroup++){
aName = anInfo->GetGroupName(iGroup);
INITMSG(MYDEBUG,"aGroupName = '"<<aName<<"'\n");
}
#endif
return anInfo;
}
//----------------------------------------------------------------------------
PNodeInfo
TWrapper
::GetPNodeInfo(const PMeshInfo& theMeshInfo,
TErr* theErr)
{
TInt aNbElems = GetNbNodes(*theMeshInfo);
if(aNbElems == 0){
return PNodeInfo();
}
PNodeInfo anInfo = CrNodeInfo(theMeshInfo,aNbElems);
GetNodeInfo(*anInfo,theErr);
#ifdef _DEBUG_
TInt aDim = theMeshInfo->myDim;
TInt aNbElem = anInfo->GetNbElem();
INITMSG(MYDEBUG,"GetPNodeInfo: ");
{
INITMSG(MYDEBUG,"aCoords: "<<aNbElem<<": ");
TNodeCoord& aCoord = anInfo->myCoord;
for(TInt iElem = 0; iElem < aNbElem; iElem++){
for(TInt iDim = 0, anId = iElem*aDim; iDim < aDim; iDim++, anId++){
ADDMSG(MYVALUEDEBUG,aCoord[anId]<<",");
}
ADDMSG(MYVALUEDEBUG," ");
}
ADDMSG(MYDEBUG, std::endl);
BEGMSG(MYVALUEDEBUG, "GetFamNum: ");
for(TInt iElem = 0; iElem < aNbElem; iElem++){
ADDMSG(MYVALUEDEBUG,anInfo->GetFamNum(iElem)<<", ");
}
ADDMSG(MYVALUEDEBUG, std::endl);
if(anInfo->IsElemNum()){
BEGMSG(MYVALUEDEBUG,"GetElemNum: ");
for(TInt iElem = 0; iElem < aNbElem; iElem++){
ADDMSG(MYVALUEDEBUG,anInfo->GetElemNum(iElem)<<", ");
}
ADDMSG(MYVALUEDEBUG, std::endl);
}
}
ADDMSG(MYDEBUG, std::endl);
#endif
return anInfo;
}
//----------------------------------------------------------------------------
PPolygoneInfo
TWrapper
::GetPPolygoneInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
EConnectivite theConnMode)
{
if(theMeshInfo->GetType() != eNON_STRUCTURE)
return PPolygoneInfo();
TInt aNbElem = GetNbPolygones(theMeshInfo,theEntity,theGeom,theConnMode);
TInt aConnSize = GetPolygoneConnSize(theMeshInfo,theEntity,theGeom,theConnMode);
PPolygoneInfo anInfo = CrPolygoneInfo(theMeshInfo,theEntity,theGeom,aNbElem,aConnSize,theConnMode);
GetPolygoneInfo(anInfo);
#ifdef _DEBUG_
INITMSG(MYDEBUG,"GetPPolygoneInfo"<<
" - theGeom = "<<theGeom<<
"; aNbElem = "<<aNbElem<<": ");
for(TInt iElem = 1; iElem < aNbElem; iElem++){
TCConnSlice aConnSlice = anInfo->GetConnSlice(iElem);
TInt aConnDim = aConnSlice.size();
for(TInt iConn = 0; iConn < aConnDim; iConn++){
ADDMSG(MYVALUEDEBUG,aConnSlice[iConn]<<",");
}
ADDMSG(MYDEBUG," ");
}
ADDMSG(MYDEBUG, std::endl);
#endif
return anInfo;
}
//----------------------------------------------------------------------------
PPolyedreInfo
TWrapper
::GetPPolyedreInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
EConnectivite theConnMode)
{
if(theMeshInfo->GetType() != eNON_STRUCTURE)
return PPolyedreInfo();
TInt aNbElem = GetNbPolyedres(theMeshInfo,theEntity,theGeom,theConnMode);
TInt aNbFaces, aConnSize;
GetPolyedreConnSize(theMeshInfo,aNbFaces,aConnSize,theConnMode);
PPolyedreInfo anInfo = CrPolyedreInfo(theMeshInfo,theEntity,theGeom,aNbElem,aNbFaces,aConnSize,theConnMode);
GetPolyedreInfo(anInfo);
#ifdef _DEBUG_
INITMSG(MYDEBUG,"GetPPolyedreInfo"<<
" - theGeom = "<<theGeom<<
"; aNbElem = "<<aNbElem<<": ");
for(TInt iElem = 0; iElem < aNbElem; iElem++){
TCConnSliceArr aConnSliceArr = anInfo->GetConnSliceArr(iElem);
TInt aNbFaces = aConnSliceArr.size();
ADDMSG(MYDEBUG,"{");
for(TInt iFace = 0; iFace < aNbFaces; iFace++){
TCConnSlice aConnSlice = aConnSliceArr[iFace];
TInt aNbConn = aConnSlice.size();
ADDMSG(MYDEBUG,"[");
for(TInt iConn = 0; iConn < aNbConn; iConn++){
ADDMSG(MYVALUEDEBUG,aConnSlice[iConn]<<",");
}
ADDMSG(MYDEBUG,"] ");
}
ADDMSG(MYDEBUG,"} ");
}
ADDMSG(MYDEBUG, std::endl);
#endif
return anInfo;
}
//----------------------------------------------------------------------------
PElemInfo
TWrapper
::GetPElemInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
EConnectivite theConnMode,
TErr* theErr)
{
EMaillage aType = theMeshInfo->GetType();
if(aType == eNON_STRUCTURE){
switch(theGeom){
case ePOINT1:
if(theEntity == eNOEUD)
return GetPNodeInfo(theMeshInfo,theErr);
return GetPCellInfo(theMeshInfo,theEntity,theGeom,theConnMode,theErr);
break;
case ePOLYGONE:
return GetPPolygoneInfo(theMeshInfo,theEntity,theGeom,theConnMode);
break;
case ePOLYEDRE:
return GetPPolyedreInfo(theMeshInfo,theEntity,theGeom,theConnMode);
break;
default:
return GetPCellInfo(theMeshInfo,theEntity,theGeom,theConnMode,theErr);
}
} else {
PGrilleInfo aGrille = GetPGrilleInfo(theMeshInfo);
TInt nbElems;
EBooleen theIsElemNum = eFAUX;
// nodes
switch(theGeom){
case ePOINT1:
nbElems = aGrille->GetNbNodes();
theIsElemNum = eVRAI;
break;
case eSEG2:
case eQUAD4:
case eHEXA8:
nbElems = aGrille->GetNbCells();
break;
default:
nbElems = 0;
}
TIntVector aFamNum;
TIntVector aElemNum;
TStringVector aElemNames;
PElemInfo aElemInfo;
if(theGeom == ePOINT1){
aElemInfo = CrElemInfo(theMeshInfo,
nbElems,
theIsElemNum);
MED::TElemInfo &aTElemInfo = *aElemInfo;
// must be reimplemente in connection with mesh type eSTRUCTURE
// GetNumeration(aTElemInfo,
// nbElems,
// theEntity,
// theGeom,
// theErr);
GetFamilies(aTElemInfo,
nbElems,
theEntity,
theGeom,
theErr);
// must be reimplemente in connection with mesh type eSTRUCTURE
// GetNames(aTElemInfo,
// nbElems,
// theEntity,
// theGeom,
// theErr);
} else {
aElemInfo = CrElemInfo(theMeshInfo,
nbElems,
aFamNum,
aElemNum,
aElemNames);
}
return aElemInfo;
}
return PElemInfo();
}
//----------------------------------------------------------------------------
PCellInfo
TWrapper
::GetPCellInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
EConnectivite theConnMode,
TErr* theErr)
{
if(theMeshInfo->GetType() != eNON_STRUCTURE)
return PCellInfo();
TInt aNbElem = GetNbCells(theMeshInfo,theEntity,theGeom,theConnMode);
PCellInfo anInfo = CrCellInfo(theMeshInfo,theEntity,theGeom,aNbElem,theConnMode);
GetCellInfo(anInfo,theErr);
#ifdef _DEBUG_
TInt aConnDim = anInfo->GetConnDim();
INITMSG(MYDEBUG,"GetPCellInfo - theEntity = "<<theEntity<<"; theGeom = "<<theGeom<<"; aConnDim: "<<aConnDim<<"\n");
BEGMSG(MYDEBUG,"GetPCellInfo - aNbElem: "<<aNbElem<<": ");
for(TInt iElem = 0; iElem < aNbElem; iElem++){
TCConnSlice aConnSlice = anInfo->GetConnSlice(iElem);
for(TInt iConn = 0; iConn < aConnDim; iConn++){
ADDMSG(MYVALUEDEBUG,aConnSlice[iConn]<<",");
}
ADDMSG(MYVALUEDEBUG," ");
}
ADDMSG(MYDEBUG, std::endl);
BEGMSG(MYVALUEDEBUG,"GetPCellInfo - GetFamNum: ");
for(TInt iElem = 0; iElem < aNbElem; iElem++){
ADDMSG(MYVALUEDEBUG,anInfo->GetFamNum(iElem)<<", ");
}
ADDMSG(MYVALUEDEBUG, std::endl);
if(anInfo->IsElemNum()){
BEGMSG(MYVALUEDEBUG,"GetPCellInfo - GetElemNum: ");
for(TInt iElem = 0; iElem < aNbElem; iElem++){
ADDMSG(MYVALUEDEBUG,anInfo->GetElemNum(iElem)<<", ");
}
ADDMSG(MYVALUEDEBUG, std::endl);
}
ADDMSG(MYDEBUG, std::endl);
#endif
return anInfo;
}
//----------------------------------------------------------------------------
//! Read a MEDWrapped representation of MED Balls from the MED file
PBallInfo
TWrapper
::GetPBallInfo(const PMeshInfo& theMeshInfo)
{
TInt nbBalls = GetNbBalls(theMeshInfo);
if ( nbBalls < 1 ) return PBallInfo();
PBallInfo anInfo = CrBallInfo( theMeshInfo, nbBalls );
GetBallInfo(anInfo);
return anInfo;
}
//----------------------------------------------------------------------------
PFieldInfo
TWrapper
::GetPFieldInfo(const PMeshInfo& theMeshInfo,
TInt theId,
TErr* theErr)
{
TInt aNbComp = GetNbComp(theId);
PFieldInfo anInfo = CrFieldInfo(theMeshInfo,aNbComp);
GetFieldInfo(theId,*anInfo,theErr);
#ifdef _DEBUG_
INITMSG(MYDEBUG,
"GetPFieldInfo "<<
"- aName = '"<<anInfo->GetName()<<"'"<<
"; aType = "<<anInfo->GetType()<<
"; aNbComp = "<<aNbComp<<
std::endl);
#endif
return anInfo;
}
//----------------------------------------------------------------------------
PTimeStampInfo
TWrapper
::GetPTimeStampInfo(const PFieldInfo& theFieldInfo,
EEntiteMaillage theEntity,
const TGeom2Size& theGeom2Size,
TInt theId,
TErr* theErr)
{
PTimeStampInfo anInfo = CrTimeStampInfo(theFieldInfo,theEntity,theGeom2Size);
GetTimeStampInfo(theId,*anInfo,theErr);
#ifdef _DEBUG_
INITMSG(MYDEBUG,"GetPTimeStampInfo - anEntity = "<<anInfo->GetEntity()<<"\n");
TGeom2NbGauss& aGeom2NbGauss = anInfo->myGeom2NbGauss;
TGeom2NbGauss::const_iterator anIter = aGeom2NbGauss.begin();
for(; anIter != aGeom2NbGauss.end(); anIter++){
const EGeometrieElement& aGeom = anIter->first;
INITMSG(MYDEBUG,"aGeom = "<<aGeom<<" - "<<aGeom2NbGauss[aGeom]<<";\n");
}
#endif
return anInfo;
}
//----------------------------------------------------------------------------
PProfileInfo
TWrapper
::GetPProfileInfo(TInt theId,
EModeProfil theMode,
TErr* theErr)
{
TProfileInfo::TInfo aPreInfo = GetProfilePreInfo(theId);
PProfileInfo anInfo = CrProfileInfo(aPreInfo,theMode);
GetProfileInfo(theId,*anInfo,theErr);
return anInfo;
}
//----------------------------------------------------------------------------
PTimeStampValueBase
TWrapper
::CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
const TGeom2Profile& theGeom2Profile,
EModeSwitch theMode)
{
PFieldInfo aFieldInfo = theTimeStampInfo->GetFieldInfo();
return CrTimeStampValue(theTimeStampInfo,
aFieldInfo->GetType(),
theGeom2Profile,
theMode);
}
//----------------------------------------------------------------------------
PTimeStampValueBase
TWrapper
::CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
const PTimeStampValueBase& theInfo)
{
PFieldInfo aFieldInfo = theTimeStampInfo->GetFieldInfo();
return CrTimeStampValue(theTimeStampInfo,
theInfo,
aFieldInfo->GetType());
}
//----------------------------------------------------------------------------
template<class TimeStampValueType>
void
Print(SharedPtr<TimeStampValueType> theTimeStampValue)
{
INITMSG(MYDEBUG,"Print - TimeStampValue\n");
typename TimeStampValueType::TTGeom2Value& aGeom2Value = theTimeStampValue->myGeom2Value;
typename TimeStampValueType::TTGeom2Value::const_iterator anIter = aGeom2Value.begin();
for(; anIter != aGeom2Value.end(); anIter++){
const EGeometrieElement& aGeom = anIter->first;
const typename TimeStampValueType::TTMeshValue& aMeshValue = anIter->second;
TInt aNbElem = aMeshValue.myNbElem;
TInt aNbGauss = aMeshValue.myNbGauss;
TInt aNbComp = aMeshValue.myNbComp;
INITMSG(MYDEBUG,"aGeom = "<<aGeom<<" - "<<aNbElem<<": ");
for(TInt iElem = 0; iElem < aNbElem; iElem++){
typename TimeStampValueType::TTMeshValue::TCValueSliceArr aValueSliceArr = aMeshValue.GetGaussValueSliceArr(iElem);
ADDMSG(MYVALUEDEBUG,"{");
for(TInt iGauss = 0; iGauss < aNbGauss; iGauss++){
const typename TimeStampValueType::TTMeshValue::TCValueSlice& aValueSlice = aValueSliceArr[iGauss];
for(TInt iComp = 0; iComp < aNbComp; iComp++){
ADDMSG(MYVALUEDEBUG,aValueSlice[iComp]<<" ");
}
ADDMSG(MYVALUEDEBUG,"| ");
}
ADDMSG(MYVALUEDEBUG,"} ");
}
ADDMSG(MYDEBUG,"\n");
}
}
//----------------------------------------------------------------------------
PTimeStampValueBase
TWrapper
::GetPTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
const TMKey2Profile& theMKey2Profile,
const TKey2Gauss& theKey2Gauss,
TErr* theErr)
{
PFieldInfo aFieldInfo = theTimeStampInfo->GetFieldInfo();
PTimeStampValueBase anInfo = CrTimeStampValue(theTimeStampInfo,
aFieldInfo->GetType());
GetTimeStampValue(anInfo,
theMKey2Profile,
theKey2Gauss,
theErr);
#ifdef _DEBUG_
if(aFieldInfo->GetType() == eFLOAT64)
Print<TFloatTimeStampValue>(anInfo);
else
Print<TIntTimeStampValue>(anInfo);
#endif
return anInfo;
}
//----------------------------------------------------------------------------
void
TWrapper
::GetTimeStampVal(const PTimeStampVal& theVal,
const TMKey2Profile& theMKey2Profile,
const TKey2Gauss& theKey2Gauss,
TErr* theErr)
{
PTimeStampInfo aTimeStampInfo = theVal->GetTimeStampInfo();
PFieldInfo aFieldInfo = aTimeStampInfo->GetFieldInfo();
if(aFieldInfo->GetType() == eFLOAT64)
GetTimeStampValue(theVal,
theMKey2Profile,
theKey2Gauss,
theErr);
else{
PTimeStampValueBase aVal = CrTimeStampValue(aTimeStampInfo,
theVal,
eINT);
GetTimeStampValue(aVal,
theMKey2Profile,
theKey2Gauss,
theErr);
CopyTimeStampValueBase(aVal, theVal);
}
}
//----------------------------------------------------------------------------
void
TWrapper
::SetTimeStamp(const PTimeStampVal& theVal,
TErr* theErr)
{
PTimeStampInfo aTimeStampInfo = theVal->GetTimeStampInfo();
PFieldInfo aFieldInfo = aTimeStampInfo->GetFieldInfo();
if(aFieldInfo->GetType() == eFLOAT64)
SetTimeStampValue(theVal, theErr);
else{
PTimeStampValueBase aVal = CrTimeStampValue(aTimeStampInfo,
eINT,
theVal->GetGeom2Profile(),
theVal->GetModeSwitch());
CopyTimeStampValueBase(theVal, aVal);
SetTimeStampValue(aVal, theErr);
}
}
//----------------------------------------------------------------------------
PTimeStampVal
TWrapper
::CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
const TGeom2Profile& theGeom2Profile,
EModeSwitch theMode)
{
return CrTimeStampValue(theTimeStampInfo,
eFLOAT64,
theGeom2Profile,
theMode);
}
//----------------------------------------------------------------------------
PTimeStampVal
TWrapper
::CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
const PTimeStampVal& theInfo)
{
return CrTimeStampValue(theTimeStampInfo,
theInfo,
eFLOAT64);
}
//----------------------------------------------------------------------------
PTimeStampVal
TWrapper
::GetPTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
const TMKey2Profile& theMKey2Profile,
const TKey2Gauss& theKey2Gauss,
TErr* theErr)
{
PTimeStampVal anInfo = CrTimeStampVal(theTimeStampInfo);
GetTimeStampVal(anInfo,
theMKey2Profile,
theKey2Gauss,
theErr);
return anInfo;
}
//----------------------------------------------------------------------------
PGrilleInfo
TWrapper
::GetPGrilleInfo(const PMeshInfo& theMeshInfo)
{
if(theMeshInfo->GetType() != eSTRUCTURE)
return PGrilleInfo();
EGrilleType type;
GetGrilleType(*theMeshInfo,type);
PGrilleInfo anInfo;
if(type == eGRILLE_STANDARD){
const TInt nnoeuds = GetNbNodes(*theMeshInfo);
anInfo = CrGrilleInfo(theMeshInfo,type,nnoeuds);
}
else {
TIntVector aVec;
aVec.resize(theMeshInfo->GetDim());
for(int aAxe=0;aAxe<theMeshInfo->GetDim();aAxe++){
ETable aATable = eCOOR_IND1;
switch(aAxe){
case 0:
aATable = eCOOR_IND1;
break;
case 1:
aATable = eCOOR_IND2;
break;
case 2:
aATable = eCOOR_IND3;
break;
}
aVec[aAxe] = GetNbNodes(*theMeshInfo,aATable);
}
anInfo = CrGrilleInfo(theMeshInfo,type,aVec);
}
GetGrilleInfo(anInfo);
anInfo->SetGrilleType(type);
#ifdef _DEBUG_
INITMSG(MYDEBUG,"GetPGrilleInfo: ");
{
TInt aNbElem = anInfo->GetNbNodes();
BEGMSG(MYVALUEDEBUG,"GetFamNumNode: ");
for(TInt iElem = 0; iElem < aNbElem; iElem++){
ADDMSG(MYVALUEDEBUG,anInfo->GetFamNumNode(iElem)<<", ");
}
TInt aNbCells = anInfo->GetNbCells();
BEGMSG(MYVALUEDEBUG,"GetFamNum: ");
for(TInt iElem = 0; iElem < aNbCells; iElem++){
ADDMSG(MYVALUEDEBUG,anInfo->GetFamNum(iElem)<<", ");
}
ADDMSG(MYVALUEDEBUG, std::endl);
BEGMSG(MYVALUEDEBUG,"GetCoordName: ");
for(TInt iElem = 0; iElem < theMeshInfo->GetDim(); iElem++){
ADDMSG(MYVALUEDEBUG,anInfo->GetCoordName(iElem)<<", ");
}
ADDMSG(MYVALUEDEBUG, std::endl);
BEGMSG(MYVALUEDEBUG,"GetCoordUnit: ");
for(TInt iElem = 0; iElem < theMeshInfo->GetDim(); iElem++){
ADDMSG(MYVALUEDEBUG,anInfo->GetCoordUnit(iElem)<<", ");
}
ADDMSG(MYVALUEDEBUG, std::endl);
}
#endif
return anInfo;
}
//----------------------------------------------------------------------------
PGrilleInfo
TWrapper
::GetPGrilleInfo(const PMeshInfo& theMeshInfo,
const PGrilleInfo& theInfo)
{
PGrilleInfo anInfo = CrGrilleInfo(theMeshInfo,theInfo);
return anInfo;
}
}

1052
src/MEDWrapper/Base/MED_Wrapper.hxx
View File

File diff suppressed because it is too large Load Diff

70
src/MEDWrapper/CMakeLists.txt
View File

@ -17,6 +17,70 @@
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
ADD_SUBDIRECTORY(Base)
ADD_SUBDIRECTORY(V2_2)
ADD_SUBDIRECTORY(Factory)
# --- options ---
# additional include directories
INCLUDE_DIRECTORIES(
${Boost_INCLUDE_DIRS}
${HDF5_INCLUDE_DIRS}
${MEDFILE_INCLUDE_DIRS}
${KERNEL_INCLUDE_DIRS}
)
# additional preprocessor / compiler flags
ADD_DEFINITIONS(
${BOOST_DEFINITIONS}
${HDF5_DEFINITIONS}
)
SET(_link_LIBRARIES
${Boost_LIBRARIES}
${HDF5_LIBS}
${MEDFILE_C_LIBRARIES}
)
# --- headers ---
# header files / no moc processing
SET(MEDWrapper_HEADERS
MED_Algorithm.hxx
MED_Common.hxx
MED_CoordUtils.hxx
MED_Factory.hxx
MED_GaussDef.hxx
MED_GaussUtils.hxx
MED_SharedPtr.hxx
MED_SliceArray.hxx
MED_Structures.hxx
MED_TStructures.hxx
MED_Utilities.hxx
MED_Vector.hxx
MED_Wrapper.hxx
MED_WrapperDef.hxx
)
# --- sources ---
# sources / static
SET(MEDWrapper_SOURCES
MED_Algorithm.cxx
MED_Common.cxx
MED_CoordUtils.cxx
MED_Factory.cxx
MED_GaussDef.cxx
MED_GaussUtils.cxx
MED_Structures.cxx
MED_Utilities.cxx
MED_Wrapper.cxx
)
# --- rules ---
ADD_LIBRARY(MEDWrapper ${MEDWrapper_SOURCES})
TARGET_LINK_LIBRARIES(MEDWrapper ${_link_LIBRARIES})
INSTALL(TARGETS MEDWrapper EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
ADD_EXECUTABLE(mprint_version mprint_version.cxx)
TARGET_LINK_LIBRARIES(mprint_version ${MEDFILE_C_LIBRARIES})
INSTALL(TARGETS mprint_version EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_BINS})
INSTALL(FILES ${MEDWrapper_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})

73
src/MEDWrapper/Factory/CMakeLists.txt
View File

@ -1,73 +0,0 @@
# Copyright (C) 2012-2016 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# --- options ---
# additional include directories
INCLUDE_DIRECTORIES(
${HDF5_INCLUDE_DIRS}
${Boost_INCLUDE_DIRS}
${MEDFILE_INCLUDE_DIRS}
${KERNEL_INCLUDE_DIRS}
${CMAKE_CURRENT_SOURCE_DIR}/../Base
${CMAKE_CURRENT_SOURCE_DIR}/../V2_2
)
# additional preprocessor / compiler flags
ADD_DEFINITIONS(
${HDF5_DEFINITIONS}
${BOOST_DEFINITIONS}
)
SET(_link_LIBRARIES
MEDWrapperBase
MEDWrapper_V2_2
${Boost_LIBRARIES}
${MEDFILE_C_LIBRARIES}
)
# --- headers ---
# header files / no moc processing
SET(MEDWrapper_HEADERS
MED_Factory.hxx
MED_WrapperFactory.hxx
)
# --- sources ---
# sources / static
SET(MEDWrapper_SOURCES
MED_Factory.cxx
)
# --- rules ---
ADD_LIBRARY(MEDWrapper ${MEDWrapper_SOURCES})
TARGET_LINK_LIBRARIES(MEDWrapper ${_link_LIBRARIES} ${MED_medloader} )
INSTALL(TARGETS MEDWrapper EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
ADD_EXECUTABLE(mprint_version mprint_version.cxx)
TARGET_LINK_LIBRARIES(mprint_version ${_link_LIBRARIES} MEDWrapper)
ADD_EXECUTABLE(MED_Test MED_Test.cxx)
TARGET_LINK_LIBRARIES(MED_Test ${_link_LIBRARIES} MEDWrapper)
INSTALL(TARGETS mprint_version MED_Test EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_BINS})
INSTALL(FILES ${MEDWrapper_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})

167
src/MEDWrapper/Factory/MED_Factory.cxx
View File

@ -1,167 +0,0 @@
// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "MED_Factory.hxx"
#include "MED_Utilities.hxx"
#include "MED_V2_2_Wrapper.hxx"
#include <stdio.h>
#include <errno.h>
#include <sstream>
#include <med.h>
extern "C"
{
#ifndef WIN32
#include <unistd.h>
#endif
}
#ifdef _DEBUG_
static int MYDEBUG = 0;
#else
static int MYDEBUG = 0;
#endif
namespace MED
{
EVersion GetVersionId(const std::string& theFileName,
bool theDoPreCheckInSeparateProcess)
{
INITMSG(MYDEBUG,"GetVersionId - theFileName = '"<<theFileName<<"'"<<std::endl);
EVersion aVersion = eVUnknown;
#ifndef WIN32
if (access(theFileName.c_str(),F_OK))
return aVersion;
if ( theDoPreCheckInSeparateProcess ) {
// First check, is it possible to deal with the file
std::ostringstream aStr;
// File name is in quotes for the case of space(s) inside it (PAL13009)
aStr<<"bash -c \""<<getenv("SMESH_ROOT_DIR")<<"/bin/salome/mprint_version \'"<<theFileName<<"\'\"";
if(!MYDEBUG)
aStr<<" 2>&1 > /dev/null";
std::string aCommand = aStr.str();
int aStatus = system(aCommand.c_str());
BEGMSG( MYDEBUG,"aCommand = '" << aCommand << "'; aStatus = " << aStatus
<< "; errno = " << errno << " = " << strerror( errno ) << std::endl );
if ( aStatus != 0 && errno != EAGAIN && errno != ENOMEM ) // "Cannot allocate memory" is OK
return aVersion;
}
#endif
// check compatibility of hdf and med versions
med_bool hdfok, medok;
MEDfileCompatibility(theFileName.c_str(), &hdfok, &medok);
if ((!hdfok) /*|| (!medok)*/) // med-2.1 is KO since med-3.0.0
return aVersion;
// Next, try to open the file trough the MED API
const char* aFileName = theFileName.c_str();
med_idt aFid = MEDfileOpen(aFileName,MED_ACC_RDONLY);
MSG(MYDEBUG,"GetVersionId - theFileName = '"<<theFileName<<"'; aFid = "<<aFid<<std::endl);
if(aFid >= 0){
med_int aMajor, aMinor, aRelease;
med_err aRet = MEDfileNumVersionRd(aFid,&aMajor,&aMinor,&aRelease);
INITMSG(MYDEBUG,"GetVersionId - theFileName = '"<<theFileName<<"'; aRet = "<<aRet<<std::endl);
if(aRet >= 0){
if(aMajor == 2 && aMinor == 1)
aVersion = eV2_1;
else
aVersion = eV2_2;
}
else {
// VSR: simulate med 2.3.6 behavior, med file version is assumed to 2.1
aVersion = eV2_1;
}
}
MEDfileClose(aFid);
BEGMSG(MYDEBUG,"GetVersionId - theFileName = '"<<theFileName<<"'; aVersion = "<<aVersion<<std::endl);
return aVersion;
}
bool getMEDVersion( const std::string& fname, int& major, int& minor, int& release )
{
med_idt f = MEDfileOpen(fname.c_str(), MED_ACC_RDONLY );
if( f<0 )
return false;
med_int aMajor, aMinor, aRelease;
med_err aRet = MEDfileNumVersionRd( f, &aMajor, &aMinor, &aRelease );
major = aMajor;
minor = aMinor;
release = aRelease;
MEDfileClose( f );
if( aRet<0 ) {
// VSR: simulate med 2.3.6 behavior, med file version is assumed to 2.1
major = 2; minor = release = -1;
//return false;
}
return true;
}
PWrapper CrWrapper(const std::string& theFileName,
bool theDoPreCheckInSeparateProcess)
{
PWrapper aWrapper;
EVersion aVersion = GetVersionId(theFileName,theDoPreCheckInSeparateProcess);
switch(aVersion){
case eV2_2:
aWrapper.reset(new MED::V2_2::TVWrapper(theFileName));
break;
case eV2_1:
EXCEPTION(std::runtime_error,"Cannot open file '"<<theFileName<<"'. Med version 2.1 is not supported any more.");
//aWrapper.reset(new MED::V2_1::TVWrapper(theFileName));
break;
default:
EXCEPTION(std::runtime_error,"MED::CrWrapper - theFileName = '"<<theFileName<<"'");
}
return aWrapper;
}
PWrapper CrWrapper(const std::string& theFileName, EVersion theId)
{
EVersion aVersion = GetVersionId(theFileName);
if(aVersion != theId)
remove(theFileName.c_str());
PWrapper aWrapper;
switch(theId){
case eV2_2:
aWrapper.reset(new MED::V2_2::TVWrapper(theFileName));
break;
case eV2_1:
EXCEPTION(std::runtime_error,"Cannot open file '"<<theFileName<<"'. Med version 2.1 is not supported any more.");
//aWrapper.reset(new MED::V2_1::TVWrapper(theFileName));
break;
default:
aWrapper.reset(new MED::V2_2::TVWrapper(theFileName));
}
return aWrapper;
}
}

347
src/MEDWrapper/Factory/MED_Test.cxx
View File

@ -1,347 +0,0 @@
// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "MED_Utilities.hxx"
#include "MED_Algorithm.hxx"
#include "MED_GaussUtils.hxx"
#include "MED_Factory.hxx"
#ifdef _DEBUG_
static int MYDEBUG = 1;
#else
// static int MYDEBUG = 0;
#endif
static int MYWRITEDEBUG = 1;
using namespace MED;
#undef _DEBUG_
void CheckMed(const std::string& theFileName)
{
MSG(MYDEBUG,"CheckMed - theFileName = '"<<theFileName<<"'");
{
//TErr anErr;
PWrapper aMed = CrWrapper(theFileName);
TKey2Gauss aKey2Gauss = GetKey2Gauss(aMed);
TMKey2Profile aMKey2Profile = GetMKey2Profile(aMed);
INITMSG(MYDEBUG,"aMed->GetNbProfiles() = "<<aMed->GetNbProfiles()<<std::endl);
TInt aNbMeshes = aMed->GetNbMeshes();
BEGMSG(MYDEBUG,"GetNbMeshes() = "<<aNbMeshes<<std::endl);
for(TInt iMesh = 1; iMesh <= aNbMeshes; iMesh++){
PMeshInfo aMeshInfo = aMed->GetPMeshInfo(iMesh);
INITMSG(MYDEBUG,"aMeshInfo->GetName() = '"<<aMeshInfo->GetName()<<"'"<<std::endl);
TEntityInfo aEntityInfo = aMed->GetEntityInfo(aMeshInfo);
TEntity2TGeom2ElemInfo anEntity2TGeom2ElemInfo =
GetEntity2TGeom2ElemInfo(aMed,aMeshInfo,aEntityInfo);
TFieldInfo2TimeStampInfoSet aFieldInfo2TimeStampInfoSet =
GetFieldInfo2TimeStampInfoSet(aMed,aMeshInfo,aEntityInfo);
TEntite2TFieldInfo2TimeStampInfoSet anEntite2TFieldInfo2TimeStampInfoSet =
GetEntite2TFieldInfo2TimeStampInfoSet(aFieldInfo2TimeStampInfoSet);
TEntite2TFieldInfo2TimeStampInfoSet::const_iterator anEntite2TFieldInfo2TimeStampInfoSetIter =
anEntite2TFieldInfo2TimeStampInfoSet.begin();
for(; anEntite2TFieldInfo2TimeStampInfoSetIter != anEntite2TFieldInfo2TimeStampInfoSet.end(); anEntite2TFieldInfo2TimeStampInfoSetIter++){
const TFieldInfo2TimeStampInfoSet& aFieldInfo2TimeStampInfoSet = anEntite2TFieldInfo2TimeStampInfoSetIter->second;
TFieldInfo2TimeStampInfoSet::const_iterator aFieldInfo2TimeStampInfoSetIter = aFieldInfo2TimeStampInfoSet.begin();
for(; aFieldInfo2TimeStampInfoSetIter != aFieldInfo2TimeStampInfoSet.end(); aFieldInfo2TimeStampInfoSetIter++){
PFieldInfo aFieldInfo = aFieldInfo2TimeStampInfoSetIter->first;
INITMSG(MYDEBUG,
"GetPFieldInfo "<<
"- aName = '"<<aFieldInfo->GetName()<<"'"<<
"; aType = "<<aFieldInfo->GetType()<<
"; aNbComp = "<<aFieldInfo->GetNbComp()<<
std::endl);
const TTimeStampInfoSet& aTimeStampInfoSet = aFieldInfo2TimeStampInfoSetIter->second;
TTimeStampInfoSet::const_iterator aTimeStampInfoSettIter = aTimeStampInfoSet.begin();
for(; aTimeStampInfoSettIter != aTimeStampInfoSet.end(); aTimeStampInfoSettIter++){
PTimeStampInfo aTimeStampInfo = *aTimeStampInfoSettIter;
INITMSG(MYDEBUG,
"GetPTimeStampInfo "<<
"- anEntity = "<<aTimeStampInfo->GetEntity()<<
"; aNumDt = "<<aTimeStampInfo->GetNumDt()<<
std::endl);
PTimeStampValueBase aTimeStampValue =
aMed->GetPTimeStampValue(aTimeStampInfo,
aMKey2Profile,
aKey2Gauss);
}
}
}
continue;
TFamilyInfoSet aFamilyInfoSet = GetFamilyInfoSet(aMed,aMeshInfo);
TEntity2FamilySet aEntity2FamilySet =
GetEntity2FamilySet(aMed,anEntity2TGeom2ElemInfo,aFamilyInfoSet);
TGroupInfo aGroupInfo = GetGroupInfo(aFamilyInfoSet);
PNodeInfo aNodeInfo = aMed->GetPNodeInfo(aMeshInfo);
TEntity2TGeom2ElemInfo::const_iterator anIter = anEntity2TGeom2ElemInfo.begin();
for(; anIter != anEntity2TGeom2ElemInfo.end(); anIter++){
const EEntiteMaillage& anEntity = anIter->first;
if(anEntity != eNOEUD){
const TGeom2ElemInfo& aGeom2ElemInfo = anIter->second;
TKey2Gauss::const_iterator anIter2 = aKey2Gauss.begin();
for(; anIter2 != aKey2Gauss.end(); anIter2++){
const TGaussInfo::TKey& aKey = anIter2->first;
EGeometrieElement aGeom = boost::get<0>(aKey);
TGeom2ElemInfo::const_iterator anIter3 = aGeom2ElemInfo.find(aGeom);
if(anIter3 != aGeom2ElemInfo.end()){
if(PCellInfo aCellInfo = anIter3->second){
PGaussInfo aGaussInfo = anIter2->second;
TGaussCoord aGaussCoord;
GetGaussCoord3D(aGaussInfo,aCellInfo,aNodeInfo,aGaussCoord);
}
}
}
}
}
}
}
MSG(MYDEBUG,"OK");
}
void CopyMed(const PWrapper& theMed,
const PWrapper& theMed2,
int theIncr)
{
TKey2Gauss aKey2Gauss = GetKey2Gauss(theMed);
TMKey2Profile aMKey2Profile = GetMKey2Profile(theMed);
TInt aNbMeshes = theMed->GetNbMeshes();
MSG(MYDEBUG,"aNbMeshes = "<<aNbMeshes);
std::string aName;
for(TInt iMesh = 0; iMesh < aNbMeshes; iMesh++){
PMeshInfo aMeshInfo = theMed->GetPMeshInfo(iMesh+1);
#ifdef _DEBUG_
TInt aDim = aMeshInfo->myDim;
aName = aMeshInfo->GetName();
INITMSG(MYDEBUG,"GetMeshInfo - aName = '"<<aName<<"'; aDim = "<<aDim<<"\n");
#endif
PMeshInfo aMeshInfo2 = theMed2->CrMeshInfo(aMeshInfo);
if(MYWRITEDEBUG){
aName = aMeshInfo2->GetName();
aName[0] += theIncr;
aMeshInfo2->SetName(aName);
theMed2->SetMeshInfo(aMeshInfo2);
BEGMSG(MYDEBUG,"aNbMeshes2 = "<<theMed2->GetNbMeshes()<<"\n");
}
TEntityInfo aEntityInfo = theMed->GetEntityInfo(aMeshInfo);
//continue;
TInt aNbFields = theMed->GetNbFields();
MSG(MYDEBUG,"GetNbFields() = "<<aNbFields);
for(TInt iField = 0; iField < aNbFields; iField++){
PFieldInfo aFieldInfo = theMed->GetPFieldInfo(aMeshInfo,iField+1);
#ifdef _DEBUG_
TInt aNbComp = aFieldInfo->GetNbComp();
INITMSG(MYDEBUG,"aName = '"<<aFieldInfo->GetName()<<"'; aNbComp = "<<aNbComp<<";\n");
#endif
PFieldInfo aFieldInfo2 = theMed->CrFieldInfo(aMeshInfo2,aFieldInfo);
if(MYWRITEDEBUG){
aName = aFieldInfo->GetName();
aName[0] += theIncr;
aFieldInfo2->SetName(aName);
theMed2->SetFieldInfo(aFieldInfo2);
}
EEntiteMaillage anEntity;
TGeom2Size aGeom2Size;
TInt aNbTimeStamps =
theMed->GetNbTimeStamps(aFieldInfo,aEntityInfo,anEntity,aGeom2Size);
{
INITMSG(MYDEBUG,"GetNbTimeStamps = "<<aNbTimeStamps<<std::endl);
for(TInt iTimeStamp = 0; iTimeStamp < aNbTimeStamps; iTimeStamp++){
PTimeStampInfo aTimeStampInfo =
theMed->GetPTimeStampInfo(aFieldInfo,anEntity,aGeom2Size,iTimeStamp+1);
#ifdef _DEBUG_
TInt aNumDt = aTimeStampInfo->GetNumDt();
INITMSG(MYDEBUG,"aNumDt = "<<aNumDt<<"\n");
#endif
PTimeStampInfo aTimeStampInfo2 =
theMed->CrTimeStampInfo(aFieldInfo2,aTimeStampInfo);
PTimeStampValueBase aTimeStampValue =
theMed->GetPTimeStampValue(aTimeStampInfo,
aMKey2Profile,
aKey2Gauss);
PTimeStampValueBase aTimeStampValue2 =
theMed->CrTimeStampValue(aTimeStampInfo2,
aTimeStampValue);
if(MYWRITEDEBUG) theMed2->SetTimeStamp(aTimeStampValue2);
}
}
}
TInt aNbFam = theMed->GetNbFamilies(aMeshInfo);
MSG(MYDEBUG,"GetNbFamilies() = "<<aNbFam);
for(TInt iFam = 0; iFam < aNbFam; iFam++){
PFamilyInfo aFamilyInfo = theMed->GetPFamilyInfo(aMeshInfo,iFam+1);
TInt aNbGroup = aFamilyInfo->GetNbGroup();
#ifdef _DEBUG_
TInt aNbAttr = aFamilyInfo->GetNbAttr();
#endif
TInt anId = aFamilyInfo->GetId();
if(anId == 0)
continue;
aName = aFamilyInfo->GetName();
#ifdef _DEBUG_
INITMSG(MYDEBUG,"aName = '"<<aName<<"'; anId = "<<anId<<
"; aNbAttr = "<<aNbAttr<<"; aNbGroup = "<<aNbGroup<<"\n");
#endif
PFamilyInfo aFamilyInfo2 = theMed->CrFamilyInfo(aMeshInfo2,aFamilyInfo);
for(TInt iGroup = 0; iGroup < aNbGroup; iGroup++){
aName = aFamilyInfo->GetGroupName(iGroup);
INITMSG(MYDEBUG,"aGroupName = '"<<aName<<"'\n");
aName[0] += theIncr;
aFamilyInfo2->SetGroupName(iGroup,aName);
}
if(MYWRITEDEBUG){
aName = aFamilyInfo->GetName();
aName[0] += theIncr;
aFamilyInfo2->SetName(aName);
theMed2->SetFamilyInfo(aFamilyInfo2);
INITMSG(MYDEBUG,"GetNbFamilies = "<<theMed2->GetNbFamilies(aMeshInfo2)<<std::endl);
}
}
MSG(MYDEBUG,"GetEntityInfo - aNbEntities = "<<aEntityInfo.size());
TEntityInfo::iterator anEntityInfoIter = aEntityInfo.begin();
for(; anEntityInfoIter != aEntityInfo.end(); anEntityInfoIter++){
const EEntiteMaillage& anEntity = anEntityInfoIter->first;
INITMSG(MYDEBUG,"anEntity = "<<anEntity<<"\n");
if(anEntity == eNOEUD){
PNodeInfo aNodeInfo = theMed->GetPNodeInfo(aMeshInfo);
PNodeInfo aNodeInfo2 = theMed->CrNodeInfo(aMeshInfo2,aNodeInfo);
if(MYWRITEDEBUG) theMed2->SetNodeInfo(aNodeInfo2);
continue;
}
TGeom2Size& aGeom2Size = anEntityInfoIter->second;
TGeom2Size::iterator aGeomIter = aGeom2Size.begin();
for(; aGeomIter != aGeom2Size.end(); aGeomIter++){
const EGeometrieElement& aGeom = aGeomIter->first;
#ifdef _DEBUG_
const TInt& aNbElem = aGeomIter->second;
INITMSG(MYDEBUG,"aGeom = "<<aGeom<<"; aNbElem = "<<aNbElem<<": ");
#endif
switch(aGeom){
case ePOLYGONE: {
PPolygoneInfo aPolygoneInfo = theMed->GetPPolygoneInfo(aMeshInfo,anEntity,aGeom);
PPolygoneInfo aPolygoneInfo2 = theMed->CrPolygoneInfo(aMeshInfo2,aPolygoneInfo);
if(MYWRITEDEBUG) theMed2->SetPolygoneInfo(aPolygoneInfo2);
break;
}
case ePOLYEDRE: {
PPolyedreInfo aPolyedreInfo = theMed->GetPPolyedreInfo(aMeshInfo,anEntity,aGeom);
PPolyedreInfo aPolyedreInfo2 = theMed->CrPolyedreInfo(aMeshInfo2,aPolyedreInfo);
if(MYWRITEDEBUG) theMed2->SetPolyedreInfo(aPolyedreInfo2);
break;
}
default:
PCellInfo aCellInfo = theMed->GetPCellInfo(aMeshInfo,anEntity,aGeom);
PCellInfo aCellInfo2 = theMed2->CrCellInfo(aMeshInfo2,aCellInfo);
if(MYWRITEDEBUG) theMed2->SetCellInfo(aCellInfo2);
}
}
}
}
MSG(MYDEBUG,"OK");
}
void CopyMed(const std::string& theFileName,
const std::string& theFileName2,
MED::EVersion theVersion,
int theNbCopy)
{
MSG(MYDEBUG,"CopyMed - theFileName = '"<<theFileName<<"'; theFileName2 = '"<<theFileName2<<"', theVersion = "<<theVersion);
PWrapper aMed = CrWrapper(theFileName);
PWrapper aMed2 = CrWrapper(theFileName2,theVersion);
for(int i = 0; i < theNbCopy; i++)
CopyMed(aMed,aMed2,i);
}
void ReadMed(const char* theFileName,
const char* theFileName2,
MED::EVersion theVersion = eV2_2,
int theNbCopy = 1)
{
MSG(MYDEBUG,"theFileName = '"<<theFileName<<"'; "<<
"theFileName2 = '"<<theFileName2<<"'; "<<
"theVersion = "<<theVersion<<"; "<<
"theNbCopy = "<<theNbCopy);
CopyMed(theFileName,theFileName2,theVersion,theNbCopy);
}
#ifdef WIN32
#pragma warning(disable:4101) // exc unreferenced ... ??
#endif
int main(int argc, char** argv){
#ifndef _DEBUG_
try{
#endif
if(argc == 2)
CheckMed(argv[1]);
if(argc == 3)
ReadMed(argv[1],argv[2]);
if(argc == 4)
ReadMed(argv[1],argv[2],MED::EVersion(atoi(argv[3])));
if(argc == 5)
ReadMed(argv[1],argv[2],MED::EVersion(atoi(argv[3])),atoi(argv[4]));
return 0;
#ifndef _DEBUG_
}catch(std::exception& exc){
MSG(MYDEBUG,"Follow exception was accured :\n"<<exc.what());
}catch(...){
MSG(MYDEBUG,"Unknown exception was accured");
}
#endif
return 1;
}

41
src/MEDWrapper/Base/MED_Algorithm.cxx → src/MEDWrapper/MED_Algorithm.cxx
View File

@ -19,17 +19,17 @@
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "MED_Algorithm.hxx"
#include "MED_Wrapper.hxx"
#include "MED_Utilities.hxx"
#ifdef _DEBUG_
static int MYDEBUG = 0;
static int MYVALUEDEBUG = 0;
#else
// static int MYDEBUG = 0;
// static int MYVALUEDEBUG = 0;
static int MYDEBUG = 0;
static int MYVALUEDEBUG = 0;
#endif
namespace MED
@ -65,7 +65,6 @@ namespace MED
return anEntity2TGeom2ElemInfo;
}
//---------------------------------------------------------------
TFamilyInfoSet
GetFamilyInfoSet(const PWrapper& theWrapper,
@ -85,7 +84,6 @@ namespace MED
return aFamilyInfoSet;
}
//---------------------------------------------------------------
TGroupInfo
GetGroupInfo(const TFamilyInfoSet& theFamilyInfoSet)
@ -121,7 +119,6 @@ namespace MED
return aGroup;
}
//---------------------------------------------------------------
TFieldInfo2TimeStampInfoSet
GetFieldInfo2TimeStampInfoSet(const PWrapper& theWrapper,
@ -153,7 +150,6 @@ namespace MED
return aFieldInfo2TimeStampInfoSet;
}
//---------------------------------------------------------------
TEntite2TFieldInfo2TimeStampInfoSet
GetEntite2TFieldInfo2TimeStampInfoSet(const TFieldInfo2TimeStampInfoSet& theFieldInfo2TimeStampInfoSet)
@ -171,7 +167,6 @@ namespace MED
return anEntite2TFieldInfo2TimeStampInfoSet;
}
//---------------------------------------------------------------
bool
operator<(const TFamilyTSize& theLeft, const TFamilyTSize& theRight)
@ -181,7 +176,6 @@ namespace MED
return aLeftInfo->GetId() < aRightInfo->GetId();
}
//---------------------------------------------------------------
TEntity2FamilySet
GetEntity2FamilySet(const PWrapper& theWrapper,
@ -248,7 +242,6 @@ namespace MED
return anEntity2FamilySet;
}
//---------------------------------------------------------------
TKey2Gauss
GetKey2Gauss(const PWrapper& theWrapper,
@ -278,7 +271,6 @@ namespace MED
return aKey2Gauss;
}
//---------------------------------------------------------------
PProfileInfo
GetProfileInfo(const PWrapper& theWrapper,
@ -297,7 +289,6 @@ namespace MED
return anInfo;
}
//---------------------------------------------------------------
TMKey2Profile
GetMKey2Profile(const PWrapper& theWrapper,
@ -331,7 +322,9 @@ namespace MED
//---------------------------------------------------------------
EEntiteMaillage
GetEntityByFamilyId(PGrilleInfo& theInfo,TInt theId){
GetEntityByFamilyId(PGrilleInfo& theInfo,
TInt theId)
{
TElemNum::iterator aNodeFamIter = (theInfo->myFamNumNode).begin();
for(;aNodeFamIter != (theInfo->myFamNumNode).end(); aNodeFamIter++){
if(theId == *aNodeFamIter)
@ -346,8 +339,10 @@ namespace MED
return EEntiteMaillage(-1);
}
//---------------------------------------------------------------
TFamilyID2NbCells
GetFamilyID2NbCells(PGrilleInfo& theInfo){
GetFamilyID2NbCells(PGrilleInfo& theInfo)
{
TFamilyID2NbCells aFamily2NbCells;
TInt aNbNodes = theInfo->myFamNumNode.size();
TInt aNbCells = theInfo->myFamNum.size();
@ -358,17 +353,21 @@ namespace MED
return aFamily2NbCells;
}
EEntiteMaillage ConvertEntity(const EEntiteMaillage& aEntity){
//---------------------------------------------------------------
EEntiteMaillage
ConvertEntity(const EEntiteMaillage& aEntity)
{
switch( aEntity ){
case eNOEUD_ELEMENT:
case eMAILLE: return eMAILLE; //eNOEUD_ELEMENT it is eMAILLE
case eMAILLE:
return eMAILLE; // eNOEUD_ELEMENT is eMAILLE
case eFACE:
case eARETE:
case eNOEUD: return aEntity; break;
default: return EEntiteMaillage(-1);
case eNOEUD:
return aEntity;
default:
break;
}
return EEntiteMaillage(-1);
}
}

56
src/MEDWrapper/Base/MED_Algorithm.hxx → src/MEDWrapper/MED_Algorithm.hxx
View File

@ -19,20 +19,37 @@
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#ifndef MED_Algorithm_HeaderFile
#define MED_Algorithm_HeaderFile
#include "MED_WrapperBase.hxx"
#include "MED_WrapperDef.hxx"
#include "MED_Structures.hxx"
#include <boost/tuple/tuple.hpp>
#include <set>
#include <string>
namespace MED
{
//---------------------------------------------------------------
typedef std::map<EGeometrieElement,PElemInfo> TGeom2ElemInfo;
typedef std::map<EEntiteMaillage,TGeom2ElemInfo> TEntity2TGeom2ElemInfo;
typedef std::set<PFamilyInfo> TFamilyInfoSet;
typedef std::map<std::string,TFamilyInfoSet> TGroupInfo;
typedef boost::tuple<PFamilyInfo,TInt> TFamilyTSize;
typedef std::set<TFamilyTSize> TFamilyTSizeSet;
typedef std::map<EEntiteMaillage,TFamilyTSizeSet> TEntity2FamilySet;
typedef std::set<PTimeStampInfo> TTimeStampInfoSet;
typedef std::map<PFieldInfo,TTimeStampInfoSet> TFieldInfo2TimeStampInfoSet;
typedef std::map<EEntiteMaillage,TFieldInfo2TimeStampInfoSet> TEntite2TFieldInfo2TimeStampInfoSet;
typedef std::map<TGaussInfo::TKey,PGaussInfo,TGaussInfo::TLess> TKey2Gauss;
typedef std::map<TProfileInfo::TKey,PProfileInfo> TKey2Profile;
typedef boost::tuple<EModeProfil,TKey2Profile> TMKey2Profile;
typedef std::map<TInt,TInt> TFamilyID2NbCells;
//---------------------------------------------------------------
//! Get set of TElemInfo by its geometrical type and corresponding MED ENTITY
MEDWRAPPER_EXPORT
TEntity2TGeom2ElemInfo
@ -40,28 +57,20 @@ namespace MED
const PMeshInfo& theMeshInfo,
const MED::TEntityInfo& theEntityInfo);
//---------------------------------------------------------------
typedef std::set<PFamilyInfo> TFamilyInfoSet;
//! Read set of MED FAMILIES for defined MED file
MEDWRAPPER_EXPORT
TFamilyInfoSet
GetFamilyInfoSet(const PWrapper& theWrapper,
const PMeshInfo& theMeshInfo);
//---------------------------------------------------------------
typedef boost::tuple<PFamilyInfo,TInt> TFamilyTSize;
//! Compare two MED FAMILIES
MEDWRAPPER_EXPORT
bool
operator<(const TFamilyTSize& theLeft, const TFamilyTSize& theRight);
typedef std::set<TFamilyTSize> TFamilyTSizeSet;
//---------------------------------------------------------------
typedef std::map<EEntiteMaillage,TFamilyTSizeSet> TEntity2FamilySet;
//! Split set of MED FAMILIES by corresponding MED ENTITY
MEDWRAPPER_EXPORT
TEntity2FamilySet
@ -69,20 +78,13 @@ namespace MED
const TEntity2TGeom2ElemInfo& theEntity2TGeom2ElemInfo,
const TFamilyInfoSet& theFamilyInfoSet);
//---------------------------------------------------------------
typedef std::map<std::string,TFamilyInfoSet> TGroupInfo;
//! Split the input set of MED FAMILIES by corresponding MED GROUPS
MEDWRAPPER_EXPORT
TGroupInfo
GetGroupInfo(const TFamilyInfoSet& theFamilyInfoSet);
//---------------------------------------------------------------
typedef std::set<PTimeStampInfo> TTimeStampInfoSet;
typedef std::map<PFieldInfo,TTimeStampInfoSet> TFieldInfo2TimeStampInfoSet;
//! Read set of MED TIMESTAMPS groupped by corresponding MED FIELDS
MEDWRAPPER_EXPORT
TFieldInfo2TimeStampInfoSet
@ -90,19 +92,13 @@ namespace MED
const PMeshInfo& theMeshInfo,
const MED::TEntityInfo& theEntityInfo);
//---------------------------------------------------------------
typedef std::map<EEntiteMaillage,TFieldInfo2TimeStampInfoSet> TEntite2TFieldInfo2TimeStampInfoSet;
//! Split the input set of MED TIMESTAMPS by corresponding MED FIELDS and MED ENTITIES
MEDWRAPPER_EXPORT
TEntite2TFieldInfo2TimeStampInfoSet
GetEntite2TFieldInfo2TimeStampInfoSet(const TFieldInfo2TimeStampInfoSet& theFieldInfo2TimeStampInfoSet);
//---------------------------------------------------------------
typedef std::map<TGaussInfo::TKey,PGaussInfo,TGaussInfo::TLess> TKey2Gauss;
//! Read set of MED GAUSS
MEDWRAPPER_EXPORT
TKey2Gauss
@ -110,7 +106,6 @@ namespace MED
TErr* theErr = NULL,
EModeSwitch theMode = eFULL_INTERLACE);
//---------------------------------------------------------------
//! Get MED PROFILE by its name
MEDWRAPPER_EXPORT
@ -120,11 +115,7 @@ namespace MED
TErr* theErr = NULL,
EModeProfil theMode = eCOMPACT);
//---------------------------------------------------------------
typedef std::map<TProfileInfo::TKey,PProfileInfo> TKey2Profile;
typedef boost::tuple<EModeProfil,TKey2Profile> TMKey2Profile;
//! Read set of MED PROFILES
MEDWRAPPER_EXPORT
TMKey2Profile
@ -139,18 +130,17 @@ namespace MED
GetEntityByFamilyId(PGrilleInfo& theInfo,
TInt theId);
typedef std::map<TInt,TInt> TFamilyID2NbCells;
//---------------------------------------------------------------
//! Get Number of cells for theId family, for Grille
MEDWRAPPER_EXPORT
TFamilyID2NbCells
GetFamilyID2NbCells(PGrilleInfo& theInfo);
//---------------------------------------------------------------
//! Convert eNOEUD_ELEMENT to eMAILLE
MEDWRAPPER_EXPORT
EEntiteMaillage
ConvertEntity(const EEntiteMaillage& aEntity);
}
#endif
#endif // MED_Algorithm_HeaderFile

121
src/MEDWrapper/MED_Common.cxx Normal file
View File

@ -0,0 +1,121 @@
// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "MED_Common.hxx"
#include <med.h>
namespace MED
{
TInt
GetDESCLength()
{
return 200;
}
TInt
GetIDENTLength()
{
return 8;
}
TInt
GetNOMLength()
{
return 64;
}
TInt
GetLNOMLength()
{
return 80;
}
TInt
GetPNOMLength()
{
return 16;
}
void
GetVersionRelease(TInt& major, TInt& minor, TInt& release)
{
major = MED_MAJOR_NUM;
minor = MED_MINOR_NUM;
release = MED_RELEASE_NUM;
}
TInt
GetNbConn(EGeometrieElement typmai,
EEntiteMaillage typent,
TInt mdim)
{
return typmai % 100;
}
TInt
GetNbNodes(EGeometrieElement typmai)
{
return typmai % 100;
}
const MED::TEntity2GeomSet& GetEntity2GeomSet()
{
static MED::TEntity2GeomSet Entity2GeomSet;
if ( Entity2GeomSet.empty() ) {
TGeomSet& aGeomARETESet = Entity2GeomSet[MED::eARETE];
aGeomARETESet.insert(MED::eSEG2);
aGeomARETESet.insert(MED::eSEG3);
TGeomSet& aGeomFACESet = Entity2GeomSet[MED::eFACE];
aGeomFACESet.insert(MED::eTRIA3);
aGeomFACESet.insert(MED::eQUAD4);
aGeomFACESet.insert(MED::eTRIA6);
aGeomFACESet.insert(MED::eTRIA7);
aGeomFACESet.insert(MED::eQUAD8);
aGeomFACESet.insert(MED::eQUAD9);
aGeomFACESet.insert(MED::ePOLYGONE);
aGeomFACESet.insert(MED::ePOLYGON2);
TGeomSet& aGeomMAILLESet = Entity2GeomSet[MED::eMAILLE];
aGeomMAILLESet.insert(MED::ePOINT1);
aGeomMAILLESet.insert(aGeomARETESet.begin(), aGeomARETESet.end());
aGeomMAILLESet.insert(aGeomFACESet.begin(), aGeomFACESet.end());
aGeomMAILLESet.insert(MED::eTETRA4);
aGeomMAILLESet.insert(MED::ePYRA5);
aGeomMAILLESet.insert(MED::ePENTA6);
aGeomMAILLESet.insert(MED::eHEXA8);
aGeomMAILLESet.insert(MED::eOCTA12);
aGeomMAILLESet.insert(MED::eTETRA10);
aGeomMAILLESet.insert(MED::ePYRA13);
aGeomMAILLESet.insert(MED::ePENTA15);
aGeomMAILLESet.insert(MED::eHEXA20);
aGeomMAILLESet.insert(MED::eHEXA27);
aGeomMAILLESet.insert(MED::ePOLYEDRE);
/* This combination allows reading nb of models of structure elements */
Entity2GeomSet[MED::eSTRUCT_ELEMENT].insert(MED::eAllGeoType);
}
return Entity2GeomSet;
}
}

112
src/MEDWrapper/Base/MED_Common.hxx → src/MEDWrapper/MED_Common.hxx
View File

@ -23,7 +23,9 @@
#ifndef MED_Common_HeaderFile
#define MED_Common_HeaderFile
#include "MED_WrapperBase.hxx"
#include "MED_WrapperDef.hxx"
#include "MED_Vector.hxx"
#include "MED_SharedPtr.hxx"
#include <string>
#include <set>
@ -31,23 +33,13 @@
#include <hdf5.h>
#include <boost/tuple/tuple.hpp>
#include "SALOMEconfig.h"
#include "MED_Vector.hxx"
#include "MED_SharedPtr.hxx"
#include "MED_SliceArray.hxx"
#ifdef WIN32
#pragma warning(disable:4099)
#endif
namespace MED{
enum EVersion {eVUnknown = -1, eV2_1, eV2_2};
typedef enum {eFAUX, eVRAI} EBooleen ;
namespace MED
{
typedef enum {eFAUX, eVRAI} EBooleen;
typedef double TFloat;
#if defined(HAVE_F77INT64)
typedef long TInt;
@ -59,33 +51,33 @@ namespace MED{
typedef enum {eFULL_INTERLACE, eNO_INTERLACE} EModeSwitch;
typedef enum {eFLOAT64=6, eINT=24, eLONG=26 } ETypeChamp;
typedef enum {eFLOAT64=6, eINT=24, eLONG=26} ETypeChamp;
typedef enum {eNON_STRUCTURE, eSTRUCTURE} EMaillage;
typedef enum {eCART, eCYL, eSPHER} ERepere;
typedef enum {eNOD, eDESC} EConnectivite ;
typedef enum {eNOD, eDESC} EConnectivite;
typedef enum {ePOINT1=1, eSEG2=102, eSEG3=103, eTRIA3=203,
eQUAD4=204, eTRIA6=206, eTRIA7=207, eQUAD8=208, eQUAD9=209,eTETRA4=304,
eQUAD4=204, eTRIA6=206, eTRIA7=207, eQUAD8=208, eQUAD9=209, eTETRA4=304,
ePYRA5=305, ePENTA6=306, eHEXA8=308, eOCTA12=312, eTETRA10=310,
ePYRA13=313, ePENTA15=315, eHEXA20=320, eHEXA27=327,
ePOLYGONE=400, ePOLYGON2=420, ePOLYEDRE=500, eNONE=0,
eBALL=1101 /*no such a type in med.h, it's just a trick*/,
eAllGeoType=-1 } EGeometrieElement;
eBALL=1101, // no such a type in med.h, it's just a trick
eAllGeoType=-1} EGeometrieElement;
typedef enum {eMAILLE, eFACE, eARETE, eNOEUD, eNOEUD_ELEMENT, eSTRUCT_ELEMENT} EEntiteMaillage;
typedef enum {eNO_PFLMOD, eGLOBAL, eCOMPACT} EModeProfil;
typedef enum {eNO_PFLMOD, eGLOBAL, eCOMPACT} EModeProfil;
typedef enum {eGRILLE_CARTESIENNE, eGRILLE_POLAIRE, eGRILLE_STANDARD} EGrilleType;
typedef enum {eCOOR, eCONN, eNOM, eNUM, eFAM, eCOOR_IND1, eCOOR_IND2, eCOOR_IND3} ETable;
typedef TVector<TInt> TIntVector;
typedef TVector<TFloat> TFloatVector;
typedef TVector<std::string> TStringVector;
typedef TVector<TInt> TIntVector;
typedef std::set<std::string> TStringSet;
typedef std::map<EGeometrieElement,TInt> TGeom2Size;
@ -94,45 +86,6 @@ namespace MED{
typedef std::set<EGeometrieElement> TGeomSet;
typedef std::map<EEntiteMaillage,TGeomSet> TEntity2GeomSet;
MEDWRAPPER_EXPORT
const TEntity2GeomSet&
GetEntity2GeomSet();
template<EVersion>
TInt MEDWRAPPER_EXPORT
GetDESCLength();
template<EVersion>
TInt MEDWRAPPER_EXPORT
GetIDENTLength();
template<EVersion>
TInt MEDWRAPPER_EXPORT
GetNOMLength();
template<EVersion>
TInt MEDWRAPPER_EXPORT
GetLNOMLength();
template<EVersion>
TInt MEDWRAPPER_EXPORT
GetPNOMLength();
template<EVersion>
void MEDWRAPPER_EXPORT
GetVersionRelease(TInt& majeur, TInt& mineur, TInt& release);
template<EVersion>
MEDWRAPPER_EXPORT
TInt
GetNbConn(EGeometrieElement typmai,
EEntiteMaillage typent,
TInt mdim);
MEDWRAPPER_EXPORT
TInt
GetNbNodes(EGeometrieElement typmai);
struct TNameInfo;
typedef SharedPtr<TNameInfo> PNameInfo;
@ -180,7 +133,42 @@ namespace MED{
struct TWrapper;
typedef SharedPtr<TWrapper> PWrapper;
MEDWRAPPER_EXPORT
TInt
GetDESCLength();
MEDWRAPPER_EXPORT
TInt
GetIDENTLength();
MEDWRAPPER_EXPORT
TInt
GetNOMLength();
MEDWRAPPER_EXPORT
TInt
GetLNOMLength();
MEDWRAPPER_EXPORT
TInt
GetPNOMLength();
MEDWRAPPER_EXPORT
void
GetVersionRelease(TInt&, TInt&, TInt&);
MEDWRAPPER_EXPORT
TInt
GetNbConn(EGeometrieElement, EEntiteMaillage, TInt);
MEDWRAPPER_EXPORT
TInt
GetNbNodes(EGeometrieElement typmai);
MEDWRAPPER_EXPORT
const TEntity2GeomSet&
GetEntity2GeomSet();
}
#endif
#endif // MED_Common_HeaderFile

5
src/MEDWrapper/Base/MED_CoordUtils.cxx → src/MEDWrapper/MED_CoordUtils.cxx
View File

@ -19,12 +19,12 @@
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "MED_CoordUtils.hxx"
#include "MED_Utilities.hxx"
namespace MED
{
enum ECoordName{eX, eY, eZ, eNone};
template<ECoordName TCoordId>
@ -69,7 +69,6 @@ namespace MED
&GetCoord<eY>
};
TGetCoord
aXGetCoord[3] = {
&GetCoord<eX>,
@ -91,7 +90,6 @@ namespace MED
&GetCoord<eX>
};
//---------------------------------------------------------------
TCoordHelper
::TCoordHelper(TGetCoord* theGetCoord):
@ -106,7 +104,6 @@ namespace MED
return (*myGetCoord[theCoordId])(theCoordSlice);
}
//---------------------------------------------------------------
PCoordHelper
GetCoordHelper(PNodeInfo theNodeInfo)

9
src/MEDWrapper/Base/MED_CoordUtils.hxx → src/MEDWrapper/MED_CoordUtils.hxx
View File

@ -19,18 +19,17 @@
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#ifndef MED_CoordUtils_HeaderFile
#define MED_CoordUtils_HeaderFile
#include "MED_WrapperBase.hxx"
#include "MED_WrapperDef.hxx"
#include "MED_Structures.hxx"
namespace MED
{
typedef TFloat (*TGetCoord)(const TCCoordSlice& theCoordSlice);
//---------------------------------------------------------------
class MEDWRAPPER_EXPORT TCoordHelper
{
@ -45,12 +44,10 @@ namespace MED
};
typedef SharedPtr<TCoordHelper> PCoordHelper;
//---------------------------------------------------------------
MEDWRAPPER_EXPORT
PCoordHelper
GetCoordHelper(PNodeInfo theNodeInfo);
}
#endif
#endif // MED_CoordUtils_HeaderFile

120
src/MEDWrapper/MED_Factory.cxx Normal file
View File

@ -0,0 +1,120 @@
// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "MED_Factory.hxx"
#include "MED_Utilities.hxx"
#include "MED_Wrapper.hxx"
#include <stdio.h>
#include <errno.h>
#include <sstream>
#include <med.h>
extern "C"
{
#ifndef WIN32
#include <unistd.h>
#endif
}
namespace MED
{
bool exists(const std::string& fileName)
{
#ifdef WIN32
return (GetFileAttributes(xmlPath.c_str()) != INVALID_FILE_ATTRIBUTES);
#else
return (access(fileName.c_str(), F_OK) == 0);
#endif
}
bool CheckCompatibility(const std::string& fileName)
{
bool ok = false;
// check that file is accessible
if ( exists(fileName) ) {
// check HDF5 && MED compatibility
med_bool hdfok, medok;
MEDfileCompatibility(fileName.c_str(), &hdfok, &medok);
if ( hdfok && medok ) {
med_idt aFid = MEDfileOpen(fileName.c_str(), MED_ACC_RDONLY);
if (aFid >= 0) {
med_int major, minor, release;
med_err ret = MEDfileNumVersionRd(aFid, &major, &minor, &release);
if (ret >= 0) {
int version = 100*major + minor;
if (version >= 202)
ok = true;
}
}
MEDfileClose(aFid);
}
}
return ok;
}
bool GetMEDVersion(const std::string& fileName, int& major, int& minor, int& release)
{
bool ok = false;
major = minor = release = 0;
med_idt aFid = MEDfileOpen(fileName.c_str(), MED_ACC_RDONLY);
if (aFid >= 0) {
med_int _major, _minor, _release;
med_err ret = MEDfileNumVersionRd(aFid, &_major, &_minor, &_release);
if (ret == 0) {
major = _major;
minor = _minor;
release = _release;
ok = true;
}
MEDfileClose(aFid);
}
return ok;
}
std::string GetMEDVersion(const std::string& fileName)
{
std::string version;
int major, minor, release;
if (GetMEDVersion(fileName, major, minor, release)) {
std::ostringstream os;
os << major << "." << minor << "." << release;
version = os.str();
}
return version;
}
PWrapper CrWrapperR(const std::string& fileName)
{
if (!CheckCompatibility(fileName)) {
EXCEPTION(std::runtime_error, "Cannot open file '"<<fileName<<"'.");
}
return new MED::TWrapper(fileName);
}
PWrapper CrWrapperW(const std::string& fileName)
{
if (!CheckCompatibility(fileName))
remove(fileName.c_str());
return new MED::TWrapper(fileName);
}
}

30
src/MEDWrapper/Factory/MED_Factory.hxx → src/MEDWrapper/MED_Factory.hxx
View File

@ -23,27 +23,27 @@
#ifndef MED_Factory_HeaderFile
#define MED_Factory_HeaderFile
#include "MED_WrapperFactory.hxx"
#include "MED_WrapperDef.hxx"
#include "MED_Wrapper.hxx"
#include <string>
namespace MED
{
MEDWRAPPER_FACTORY_EXPORT
EVersion
GetVersionId(const std::string& theFileName,
bool theDoPreCheckInSeparateProcess = false);
MEDWRAPPER_EXPORT
std::string GetMEDVersion( const std::string& );
MEDWRAPPER_FACTORY_EXPORT
bool getMEDVersion( const std::string&, int&, int&, int& );
MEDWRAPPER_EXPORT
bool GetMEDVersion( const std::string&, int&, int&, int& );
MEDWRAPPER_FACTORY_EXPORT
PWrapper
CrWrapper(const std::string& theFileName,
bool theDoPreCheckInSeparateProcess = false);
MEDWRAPPER_EXPORT
bool CheckCompatibility( const std::string& );
MEDWRAPPER_FACTORY_EXPORT
PWrapper
CrWrapper(const std::string& theFileName, EVersion theId);
MEDWRAPPER_EXPORT
PWrapper CrWrapperR( const std::string& );
MEDWRAPPER_EXPORT
PWrapper CrWrapperW( const std::string& );
}
#endif
#endif // MED_Factory_HeaderFile

45
src/MEDWrapper/Base/MED_GaussDef.cxx → src/MEDWrapper/MED_GaussDef.cxx
View File

@ -16,34 +16,30 @@
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File : MED_GaussDef.hxx
// Author : Edward AGAPOV (eap)
//
#include "MED_GaussDef.hxx"
#include "MED_Utilities.hxx"
#include "MED_GaussUtils.hxx"
namespace MED
{
using namespace std;
using namespace MED;
//---------------------------------------------------------------
void TGaussDef::add(const double x, const double weight)
{
if ( dim() != 1 )
EXCEPTION( logic_error,"dim() != 1");
EXCEPTION( std::logic_error,"dim() != 1");
if ( myWeights.capacity() == myWeights.size() )
EXCEPTION( logic_error,"Extra gauss point");
EXCEPTION( std::logic_error,"Extra gauss point");
myCoords.push_back( x );
myWeights.push_back( weight );
}
void TGaussDef::add(const double x, const double y, const double weight)
{
if ( dim() != 2 )
EXCEPTION( logic_error,"dim() != 2");
EXCEPTION( std::logic_error,"dim() != 2");
if ( myWeights.capacity() == myWeights.size() )
EXCEPTION( logic_error,"Extra gauss point");
EXCEPTION( std::logic_error,"Extra gauss point");
myCoords.push_back( x );
myCoords.push_back( y );
myWeights.push_back( weight );
@ -51,9 +47,9 @@ namespace MED
void TGaussDef::add(const double x, const double y, const double z, const double weight)
{
if ( dim() != 3 )
EXCEPTION( logic_error,"dim() != 3");
EXCEPTION( std::logic_error,"dim() != 3");
if ( myWeights.capacity() == myWeights.size() )
EXCEPTION( logic_error,"Extra gauss point");
EXCEPTION( std::logic_error,"Extra gauss point");
myCoords.push_back( x );
myCoords.push_back( y );
myCoords.push_back( z );
@ -66,7 +62,6 @@ namespace MED
aShapeFun.myRefCoord.end() );
}
//---------------------------------------------------------------
/*!
* \brief Fill definition of gauss points family
@ -111,7 +106,7 @@ namespace MED
add( -b, P2 ); break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for SEG"<<nbGauss);
EXCEPTION( std::logic_error,"Invalid nb of gauss points for SEG"<<nbGauss);
}
break;
@ -181,7 +176,7 @@ namespace MED
add( D, 1-C-D, P3 ); break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for TRIA, variant 1: "
EXCEPTION( std::logic_error,"Invalid nb of gauss points for TRIA, variant 1: "
<<nbGauss);
}
}
@ -208,7 +203,7 @@ namespace MED
add( 2*A-1, 2*A-1, 4*P1 ); break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for TRIA, variant 2: "
EXCEPTION( std::logic_error,"Invalid nb of gauss points for TRIA, variant 2: "
<<nbGauss);
}
}
@ -223,7 +218,7 @@ namespace MED
add( 0.2 , 0.6 , 25/96 ); break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for TRIA, variant 3: "
EXCEPTION( std::logic_error,"Invalid nb of gauss points for TRIA, variant 3: "
<<nbGauss);
}
}
@ -258,7 +253,7 @@ namespace MED
add( 0., 0., 64/81. ); break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for QUAD, variant 1: "
EXCEPTION( std::logic_error,"Invalid nb of gauss points for QUAD, variant 1: "
<<nbGauss);
}
}
@ -286,7 +281,7 @@ namespace MED
add( 0., 0., 64/81. ); break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for QUAD, variant 1: "
EXCEPTION( std::logic_error,"Invalid nb of gauss points for QUAD, variant 1: "
<<nbGauss);
}
}
@ -315,7 +310,7 @@ namespace MED
add( a, a, c12 ); break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for QUAD, variant 3: "
EXCEPTION( std::logic_error,"Invalid nb of gauss points for QUAD, variant 3: "
<<nbGauss);
}
}
@ -365,7 +360,7 @@ namespace MED
break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for TETRA: "<<nbGauss);
EXCEPTION( std::logic_error,"Invalid nb of gauss points for TETRA: "<<nbGauss);
}
break;
@ -444,7 +439,7 @@ namespace MED
break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for PYRA: "<<nbGauss);
EXCEPTION( std::logic_error,"Invalid nb of gauss points for PYRA: "<<nbGauss);
}
break;
case ePENTA6:
@ -502,7 +497,7 @@ namespace MED
break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for PENTA: " <<nbGauss);
EXCEPTION( std::logic_error,"Invalid nb of gauss points for PENTA: " <<nbGauss);
}
break;
@ -556,15 +551,15 @@ namespace MED
break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for PENTA: " <<nbGauss);
EXCEPTION( std::logic_error,"Invalid nb of gauss points for PENTA: " <<nbGauss);
}
break;
default:
EXCEPTION( logic_error,"unexpected EGeometrieElement: "<< geom);
EXCEPTION( std::logic_error,"unexpected EGeometrieElement: "<< geom);
}
if ( myWeights.capacity() != myWeights.size() )
EXCEPTION( logic_error,"Not all gauss points defined");
EXCEPTION( std::logic_error,"Not all gauss points defined");
}
}

10
src/MEDWrapper/Base/MED_GaussDef.hxx → src/MEDWrapper/MED_GaussDef.hxx
View File

@ -16,21 +16,19 @@
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File : MED_GaussDef.hxx
// Author : Edward AGAPOV (eap)
//
#ifndef MED_GaussDef_HeaderFile
#define MED_GaussDef_HeaderFile
#include "MED_WrapperBase.hxx"
#include "MED_WrapperDef.hxx"
//#include "MED_GaussUtils.hxx" <<<---- avoid dependence on boost
#include <vector>
namespace MED
{
class TShapeFun;
typedef std::vector<double> TDoubleVector;
/*!
* \brief Description of family of integration points
*/
@ -66,4 +64,4 @@ namespace MED
};
}
#endif
#endif // MED_GaussDef_HeaderFile

72
src/MEDWrapper/Base/MED_GaussUtils.cxx → src/MEDWrapper/MED_GaussUtils.cxx
View File

@ -19,6 +19,7 @@
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "MED_GaussUtils.hxx"
#include "MED_Utilities.hxx"
@ -26,12 +27,10 @@
static int MYDEBUG = 0;
static int MYVALUEDEBUG = 0;
#else
// static int MYDEBUG = 0;
// static int MYVALUEDEBUG = 0;
static int MYDEBUG = 0;
static int MYVALUEDEBUG = 0;
#endif
//#define _DEBUG_REF_COORDS_
namespace MED
{
//---------------------------------------------------------------
@ -63,7 +62,6 @@ namespace MED
myGaussCoord.resize(theNbElem*myGaussStep);
}
TInt
TGaussCoord
::GetNbElem() const
@ -92,7 +90,6 @@ namespace MED
return (unsigned char*)&(myGaussCoord[0]);
}
TCCoordSliceArr
TGaussCoord
::GetCoordSliceArr(TInt theElemId) const
@ -115,7 +112,6 @@ namespace MED
return aCoordSliceArr;
}
TCoordSliceArr
TGaussCoord
::GetCoordSliceArr(TInt theElemId)
@ -138,7 +134,6 @@ namespace MED
return aCoordSliceArr;
}
//---------------------------------------------------------------
inline
bool
@ -150,7 +145,6 @@ namespace MED
return true;
}
//---------------------------------------------------------------
class TShapeFun::TFun
{
@ -345,7 +339,6 @@ namespace MED
return false;
}
//---------------------------------------------------------------
TSeg2a::TSeg2a():TShapeFun(1,2)
{
@ -376,7 +369,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TSeg3a::TSeg3a():TShapeFun(1,3)
{
@ -409,8 +401,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TTria3a::TTria3a():
TShapeFun(2,3)
@ -444,8 +434,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TTria6a::TTria6a():TShapeFun(2,6)
{
@ -486,8 +474,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TTria3b::TTria3b():
TShapeFun(2,3)
@ -521,8 +507,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TTria6b::TTria6b():
TShapeFun(2,6)
@ -564,8 +548,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TQuad4a::TQuad4a():
TShapeFun(2,4)
@ -601,8 +583,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TQuad8a::TQuad8a():
TShapeFun(2,8)
@ -648,8 +628,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TQuad9a::TQuad9a():
TShapeFun(2,9)
@ -699,8 +677,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TQuad4b::TQuad4b():
TShapeFun(2,4)
@ -736,8 +712,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TQuad8b::TQuad8b():
TShapeFun(2,8)
@ -788,8 +762,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TQuad9b::TQuad9b():
TShapeFun(2,9)
@ -839,8 +811,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TTetra4a::TTetra4a():
TShapeFun(3,4)
@ -876,8 +846,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TTetra10a::TTetra10a():
TShapeFun(3,10)
@ -929,11 +897,8 @@ namespace MED
}
}
//---------------------------------------------------------------
TTetra4b::TTetra4b():
TShapeFun(3,4)
{
@ -968,8 +933,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TTetra10b::TTetra10b():
TShapeFun(3,10)
@ -1021,8 +984,6 @@ namespace MED
}
}
//---------------------------------------------------------------
THexa8a::THexa8a():
TShapeFun(3,8)
@ -1067,7 +1028,6 @@ namespace MED
}
}
//---------------------------------------------------------------
THexa20a::THexa20a(TInt theDim, TInt theNbRef):
TShapeFun(theDim,theNbRef)
@ -1145,8 +1105,6 @@ namespace MED
}
}
//---------------------------------------------------------------
THexa27a::THexa27a():
THexa20a(3,27)
@ -1209,8 +1167,6 @@ namespace MED
}
}
//---------------------------------------------------------------
THexa8b::THexa8b():
TShapeFun(3,8)
@ -1255,8 +1211,6 @@ namespace MED
}
}
//---------------------------------------------------------------
THexa20b::THexa20b(TInt theDim, TInt theNbRef):
TShapeFun(theDim,theNbRef)
@ -1334,8 +1288,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TPenta6a::TPenta6a():
TShapeFun(3,6)
@ -1376,8 +1328,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TPenta6b::TPenta6b():
TShapeFun(3,6)
@ -1418,8 +1368,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TPenta15a::TPenta15a():
TShapeFun(3,15)
@ -1482,8 +1430,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TPenta15b::TPenta15b():
TShapeFun(3,15)
@ -1546,8 +1492,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TPyra5a::TPyra5a():
TShapeFun(3,5)
@ -1592,8 +1536,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TPyra5b::TPyra5b():
TShapeFun(3,5)
@ -1638,8 +1580,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TPyra13a::TPyra13a():
TShapeFun(3,13)
@ -1709,8 +1649,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TPyra13b::TPyra13b():
TShapeFun(3,13)
@ -1780,8 +1718,6 @@ namespace MED
}
}
//---------------------------------------------------------------
bool
GetGaussCoord3D(const TGaussInfo& theGaussInfo,
@ -2048,7 +1984,6 @@ namespace MED
return true;
}
//---------------------------------------------------------------
bool
GetBaryCenter(const TPolygoneInfo& thePolygoneInfo,
@ -2107,7 +2042,6 @@ namespace MED
return true;
}
//---------------------------------------------------------------
bool
GetBaryCenter(const TPolyedreInfo& thePolyedreInfo,

9
src/MEDWrapper/Base/MED_GaussUtils.hxx → src/MEDWrapper/MED_GaussUtils.hxx
View File

@ -19,11 +19,11 @@
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#ifndef MED_GaussUtils_HeaderFile
#define MED_GaussUtils_HeaderFile
#include "MED_WrapperBase.hxx"
#include "MED_WrapperDef.hxx"
#include "MED_Structures.hxx"
namespace MED
@ -77,7 +77,6 @@ namespace MED
};
typedef SharedPtr<TGaussCoord> PGaussCoord;
//---------------------------------------------------------------
//! To calculate Gauss Points coordinates
MEDWRAPPER_EXPORT
@ -89,7 +88,6 @@ namespace MED
const TElemNum& theElemNum = TElemNum(),
EModeSwitch theMode = eFULL_INTERLACE);
//---------------------------------------------------------------
//! To calculate Gauss Points coordinates for defined TCellInfo as its bary center
MEDWRAPPER_EXPORT
@ -359,7 +357,6 @@ namespace MED
TFun& theFun) const;
};
//---------------------------------------------------------------
}
#endif
#endif // MED_GaussUtils_HeaderFile

6
src/MEDWrapper/Base/MED_SharedPtr.hxx → src/MEDWrapper/MED_SharedPtr.hxx
View File

@ -19,6 +19,7 @@
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#ifndef MED_SharedPtr_HeaderFile
#define MED_SharedPtr_HeaderFile
@ -26,7 +27,6 @@
namespace MED
{
//! To extend the boost::shared_ptr to support such features automatic dynamic cast
/*!
All entities of the MEDWrapper package are handled as pointer.
@ -88,8 +88,6 @@ namespace MED
return *(this->get());
}
};
}
#endif
#endif // MED_SharedPtr_HeaderFile

7
src/MEDWrapper/Base/MED_SliceArray.hxx → src/MEDWrapper/MED_SliceArray.hxx
View File

@ -19,10 +19,11 @@
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#ifndef MED_SliceArray_HeaderFile
#define MED_SliceArray_HeaderFile
#ifdef WIN32 // for correctly compiling "valarray" in modules, which includes this file
#ifdef WIN32 // for correct compiling of "valarray" in modules, which include this file
#undef max
#undef min
#endif
@ -132,7 +133,6 @@ namespace MED
}
};
//---------------------------------------------------------------
//! This class extends TCSlice functionality for non-constant case
template<class TValueType>
@ -177,9 +177,8 @@ namespace MED
return *(myValuePtr + this->get_id_at(theId));
}
};
}
#undef MED_TCSLICE_CHECK_RANGE
#endif
#endif // MED_SliceArray_HeaderFile

849
src/MEDWrapper/MED_Structures.cxx Normal file
View File

@ -0,0 +1,849 @@
// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "MED_Structures.hxx"
#include "MED_Utilities.hxx"
#include <cstring>
namespace MED
{
std::string
GetString(TInt theId,
TInt theStep,
const TString& theString)
{
const char* aPos = &theString[theId*theStep];
TInt aSize = std::min(TInt(strlen(aPos)),theStep);
return std::string(aPos,aSize);
}
void
SetString(TInt theId,
TInt theStep,
TString& theString,
const std::string& theValue)
{
TInt aSize = std::min(TInt(theValue.size()+1),theStep);
char* aPos = &theString[theId*theStep];
strncpy(aPos,theValue.c_str(),aSize);
}
void
SetString(TInt theId,
TInt theStep,
TString& theString,
const TString& theValue)
{
TInt aSize = std::min(TInt(theValue.size()+1),theStep);
char* aPos = &theString[theId*theStep];
const char* aValue = &theValue[0];
strncpy(aPos,aValue,aSize);
}
TInt
GetDimGaussCoord(EGeometrieElement theGeom)
{
return theGeom/100;
}
TInt
GetNbRefCoord(EGeometrieElement theGeom)
{
return (theGeom%100);
}
//---------------------------------------------------------------
PFloatTimeStampValue
CastToFloatTimeStampValue(const PTimeStampValueBase& theTimeStampValue)
{
return theTimeStampValue;
}
PIntTimeStampValue
CastToIntTimeStampValue(const PTimeStampValueBase& theTimeStampValue)
{
return theTimeStampValue;
}
//---------------------------------------------------------------
TInt
TFamilyInfo
::GetAttrId(TInt theId) const
{
return myAttrId[theId];
}
TInt
TFamilyInfo
::GetAttrVal(TInt theId) const
{
return myAttrVal[theId];
}
void
TFamilyInfo
::SetAttrId(TInt theId,TInt theVal)
{
myAttrId[theId] = theVal;
}
void
TFamilyInfo
::SetAttrVal(TInt theId,TInt theVal)
{
myAttrVal[theId] = theVal;
}
//---------------------------------------------------------------
TInt
TElemInfo
::GetFamNum(TInt theId) const
{
return (*myFamNum)[theId];
}
void
TElemInfo
::SetFamNum(TInt theId, TInt theVal)
{
(*myFamNum)[theId] = theVal;
myIsFamNum = eVRAI;
}
TInt
TElemInfo
::GetElemNum(TInt theId) const
{
return (*myElemNum)[theId];
}
void
TElemInfo
::SetElemNum(TInt theId, TInt theVal)
{
(*myElemNum)[theId] = theVal;
}
//---------------------------------------------------------------
TCCoordSlice
TNodeInfo
::GetCoordSlice(TInt theId) const
{
TInt aDim = myMeshInfo->GetSpaceDim();
if(GetModeSwitch() == eFULL_INTERLACE)
return TCCoordSlice(*myCoord, std::slice(theId*aDim, aDim, 1));
else
return TCCoordSlice(*myCoord, std::slice(theId, aDim, aDim));
}
TCoordSlice
TNodeInfo
::GetCoordSlice(TInt theId)
{
TInt aDim = myMeshInfo->GetSpaceDim();
if(GetModeSwitch() == eFULL_INTERLACE)
return TCoordSlice(*myCoord, std::slice(theId*aDim,aDim,1));
else
return TCoordSlice(*myCoord, std::slice(theId,aDim,aDim));
}
//---------------------------------------------------------------
TCConnSlice
TCellInfo
::GetConnSlice(TInt theElemId) const
{
if(GetModeSwitch() == eFULL_INTERLACE)
return TCConnSlice(*myConn, std::slice(GetConnDim()*theElemId, GetNbNodes(myGeom), 1));
else
return TCConnSlice(*myConn, std::slice(theElemId, GetNbNodes(myGeom), GetConnDim()));
}
TConnSlice
TCellInfo
::GetConnSlice(TInt theElemId)
{
if(GetModeSwitch() == eFULL_INTERLACE)
return TConnSlice(*myConn, std::slice(GetConnDim()*theElemId, GetNbNodes(myGeom), 1));
else
return TConnSlice(*myConn, std::slice(theElemId, GetNbNodes(myGeom), GetConnDim()));
}
//---------------------------------------------------------------
TInt
TPolygoneInfo
::GetNbConn(TInt theElemId) const
{
return (*myIndex)[theElemId + 1] - (*myIndex)[theElemId];
}
TCConnSlice
TPolygoneInfo
::GetConnSlice(TInt theElemId) const
{
return TCConnSlice(*myConn, std::slice((*myIndex)[theElemId] - 1, GetNbConn(theElemId), 1));
}
TConnSlice
TPolygoneInfo
::GetConnSlice(TInt theElemId)
{
return TConnSlice(*myConn, std::slice((*myIndex)[theElemId] - 1, GetNbConn(theElemId), 1));
}
//---------------------------------------------------------------
TInt
TPolyedreInfo
::GetNbFaces(TInt theElemId) const
{
return (*myIndex)[theElemId+1] - (*myIndex)[theElemId];
}
TInt
TPolyedreInfo
::GetNbNodes(TInt theElemId) const
{
TInt aNbNodes = 0;
TInt aNbFaces = GetNbFaces(theElemId);
TInt aStartFaceId = (*myIndex)[theElemId] - 1;
for(TInt aFaceId = 0; aFaceId < aNbFaces; aFaceId++, aStartFaceId++){
TInt aCurrentId = (*myFaces)[aStartFaceId];
TInt aDiff = (*myFaces)[aStartFaceId + 1] - aCurrentId;
aNbNodes += aDiff;
}
return aNbNodes;
}
TCConnSliceArr
TPolyedreInfo
::GetConnSliceArr(TInt theElemId) const
{
TInt aNbFaces = GetNbFaces(theElemId);
TCConnSliceArr aConnSliceArr(aNbFaces);
TInt aStartFaceId = (*myIndex)[theElemId] - 1;
for(TInt aFaceId = 0; aFaceId < aNbFaces; aFaceId++, aStartFaceId++){
TInt aCurrentId = (*myFaces)[aStartFaceId];
TInt aDiff = (*myFaces)[aStartFaceId + 1] - aCurrentId;
aConnSliceArr[aFaceId] =
TCConnSlice(*myConn, std::slice(aCurrentId - 1, aDiff, 1));
}
return aConnSliceArr;
}
TConnSliceArr
TPolyedreInfo
::GetConnSliceArr(TInt theElemId)
{
TInt aNbFaces = GetNbFaces(theElemId);
TConnSliceArr aConnSliceArr(aNbFaces);
TInt aStartFaceId = (*myIndex)[theElemId] - 1;
for(TInt aFaceId = 0; aFaceId < aNbFaces; aFaceId++, aStartFaceId++){
TInt aCurrentId = (*myFaces)[aStartFaceId];
TInt aDiff = (*myFaces)[aStartFaceId + 1] - aCurrentId;
aConnSliceArr[aFaceId] =
TConnSlice(*myConn, std::slice(aCurrentId - 1, aDiff, 1));
}
return aConnSliceArr;
}
//---------------------------------------------------------------
TMeshValueBase
::TMeshValueBase():
myNbElem(0),
myNbComp(0),
myNbGauss(0),
myStep(0)
{}
void
TMeshValueBase
::Allocate(TInt theNbElem,
TInt theNbGauss,
TInt theNbComp,
EModeSwitch theMode)
{
myModeSwitch = theMode;
myNbElem = theNbElem;
myNbGauss = theNbGauss;
myNbComp = theNbComp;
myStep = theNbComp*theNbGauss;
}
size_t
TMeshValueBase
::GetSize() const
{
return myNbElem * myStep;
}
size_t
TMeshValueBase
::GetNbVal() const
{
return myNbElem * myNbGauss;
}
size_t
TMeshValueBase
::GetNbGauss() const
{
return myNbGauss;
}
size_t
TMeshValueBase
::GetStep() const
{
return myStep;
}
//---------------------------------------------------------------
TInt
TProfileInfo
::GetElemNum(TInt theId) const
{
return (*myElemNum)[theId];
}
void
TProfileInfo
::SetElemNum(TInt theId,TInt theVal)
{
(*myElemNum)[theId] = theVal;
}
//---------------------------------------------------------------
bool
TGaussInfo::TLess
::operator()(const TKey& theLeft, const TKey& theRight) const
{
EGeometrieElement aLGeom = boost::get<0>(theLeft);
EGeometrieElement aRGeom = boost::get<0>(theRight);
if(aLGeom != aRGeom)
return aLGeom < aRGeom;
const std::string& aLStr = boost::get<1>(theLeft);
const std::string& aRStr = boost::get<1>(theRight);
return aLStr < aRStr;
}
bool
TGaussInfo::TLess
::operator()(const TGaussInfo& theLeft, const TGaussInfo& theRight) const
{
if(!&theLeft)
return true;
if(!&theRight)
return false;
if(theLeft.myGeom != theRight.myGeom)
return theLeft.myGeom < theRight.myGeom;
if(theLeft.myRefCoord != theRight.myRefCoord)
return theLeft.myRefCoord < theRight.myRefCoord;
return theLeft.myGaussCoord < theRight.myGaussCoord;
}
TCCoordSlice
TGaussInfo
::GetRefCoordSlice(TInt theId) const
{
if(GetModeSwitch() == eFULL_INTERLACE)
return TCCoordSlice(myRefCoord,std::slice(theId*GetDim(),GetDim(),1));
else
return TCCoordSlice(myRefCoord,std::slice(theId,GetDim(),GetDim()));
}
TCoordSlice
TGaussInfo
::GetRefCoordSlice(TInt theId)
{
if(GetModeSwitch() == eFULL_INTERLACE)
return TCoordSlice(myRefCoord,std::slice(theId*GetDim(),GetDim(),1));
else
return TCoordSlice(myRefCoord,std::slice(theId,GetDim(),GetDim()));
}
TCCoordSlice
TGaussInfo
::GetGaussCoordSlice(TInt theId) const
{
if(GetModeSwitch() == eFULL_INTERLACE)
return TCCoordSlice(myGaussCoord,std::slice(theId*GetDim(),GetDim(),1));
else
return TCCoordSlice(myGaussCoord,std::slice(theId,GetDim(),GetDim()));
}
TCoordSlice
TGaussInfo
::GetGaussCoordSlice(TInt theId)
{
if(GetModeSwitch() == eFULL_INTERLACE)
return TCoordSlice(myGaussCoord,std::slice(theId*GetDim(),GetNbGauss(),1));
else
return TCoordSlice(myGaussCoord,std::slice(theId,GetNbGauss(),GetDim()));
}
//---------------------------------------------------------------
TInt
TTimeStampInfo
::GetNbGauss(EGeometrieElement theGeom) const
{
TGeom2NbGauss::const_iterator anIter = myGeom2NbGauss.find(theGeom);
if(anIter == myGeom2NbGauss.end())
return 1;//EXCEPTION(runtime_error,"TTimeStampInfo::GetNbGauss - myGeom2NbGauss.find(theGeom) fails");
return anIter->second;
}
//---------------------------------------------------------------
// TGrilleInfo structure methods
//---------------------------------------------------------------
const EGrilleType&
TGrilleInfo
::GetGrilleType() const
{
return myGrilleType;
}
EGrilleType
TGrilleInfo
::GetGrilleType()
{
return myGrilleType;
}
void
TGrilleInfo
::SetGrilleType(EGrilleType theGrilleType)
{
myGrilleType = theGrilleType;
}
const
TIndexes&
TGrilleInfo
::GetMapOfIndexes() const
{
return myIndixes;
}
TIndexes&
TGrilleInfo
::GetMapOfIndexes()
{
return myIndixes;
}
const
TFloatVector&
TGrilleInfo
::GetIndexes(TInt theAxisNumber) const
{
TIndexes::const_iterator aIter=myIndixes.find(theAxisNumber);
if(aIter==myIndixes.end())
EXCEPTION(std::runtime_error, "const TGrilleInfo::GetIndexes - myIndixes.find(theAxisNumber); fails");
return aIter->second;
}
TFloatVector&
TGrilleInfo
::GetIndexes(TInt theAxisNumber)
{
TIndexes::iterator aIter=myIndixes.find(theAxisNumber);
if(aIter==myIndixes.end())
EXCEPTION(std::runtime_error, "TGrilleInfo::GetIndexes - myIndixes.find(theAxisNumber="<<theAxisNumber<<"); fails");
return aIter->second;
}
TInt
TGrilleInfo
::GetNbIndexes(TInt theAxisNumber)
{
const TFloatVector& aVector=GetIndexes(theAxisNumber);
return aVector.size();
}
TInt
TGrilleInfo
::GetNbNodes()
{
TInt nbNodes=0;
TInt aDim = myMeshInfo->GetDim();
for(int i=0;i<aDim;i++)
if(nbNodes == 0)
nbNodes = this->GetGrilleStructure()[i];
else
nbNodes = nbNodes*this->GetGrilleStructure()[i];
return nbNodes;
}
TInt
TGrilleInfo
::GetNbCells()
{
TInt nbCells=0;
TInt aDim = myMeshInfo->GetDim();
for(int i=0;i<aDim;i++)
if(nbCells == 0)
nbCells = this->GetGrilleStructure()[i]-1;
else
nbCells = nbCells*(this->GetGrilleStructure()[i]-1);
return nbCells;
}
TInt
TGrilleInfo
::GetNbSubCells()
{
TInt nb=0;
TInt aDim = myMeshInfo->GetDim();
switch (aDim) {
case 3:
nb =
(myGrilleStructure[0] ) * (myGrilleStructure[1]-1) * (myGrilleStructure[2]-1) +
(myGrilleStructure[0]-1) * (myGrilleStructure[1] ) * (myGrilleStructure[2]-1) +
(myGrilleStructure[0]-1) * (myGrilleStructure[1]-1) * (myGrilleStructure[2] );
break;
case 2:
nb =
(myGrilleStructure[0] ) * (myGrilleStructure[1]-1) +
(myGrilleStructure[0]-1) * (myGrilleStructure[1] );
break;
}
return nb;
}
EGeometrieElement
TGrilleInfo
::GetGeom()
{
TInt aDim = myMeshInfo->GetDim();
switch(aDim){
case 1:
return eSEG2;
case 2:
return eQUAD4;
case 3:
return eHEXA8;
default:
return eNONE;
}
}
EGeometrieElement
TGrilleInfo
::GetSubGeom()
{
TInt aDim = myMeshInfo->GetDim();
switch(aDim){
case 2:
return eSEG2;
case 3:
return eQUAD4;
}
return eNONE;
}
EEntiteMaillage
TGrilleInfo
::GetEntity()
{
return eMAILLE;
}
EEntiteMaillage
TGrilleInfo
::GetSubEntity()
{
TInt aDim = myMeshInfo->GetDim();
switch(aDim){
case 2:
return eARETE;
case 3:
return eFACE;
}
return EEntiteMaillage(-1);
}
const
TIntVector&
TGrilleInfo
::GetGrilleStructure() const
{
return myGrilleStructure;
}
TIntVector
TGrilleInfo
::GetGrilleStructure()
{
return myGrilleStructure;
}
void
TGrilleInfo
::SetGrilleStructure(TInt theAxis,TInt theNb)
{
if(theAxis >= 0 && theAxis <=2 && theNb >= 0)
myGrilleStructure[theAxis]=theNb;
}
const
TNodeCoord&
TGrilleInfo
::GetNodeCoord() const
{
return myCoord;
}
TNodeCoord&
TGrilleInfo
::GetNodeCoord()
{
return myCoord;
}
TNodeCoord
TGrilleInfo
::GetCoord(TInt theId)
{
TNodeCoord aCoord;
TInt aDim = myMeshInfo->GetDim();
TInt aNbNodes = this->GetNbNodes();
aCoord.resize(aDim);
if(theId >= aNbNodes)
EXCEPTION(std::runtime_error, "TGrilleInfo::GetCoord - theId out of range");
if(myGrilleType == eGRILLE_STANDARD){
switch(aDim){
case 3:
aCoord[2] = myCoord[aDim*theId+2];
case 2:
aCoord[1] = myCoord[aDim*theId+1];
case 1:{
aCoord[0] = myCoord[aDim*theId];
break;
}
}
} else {
TFloatVector aVecX = this->GetIndexes(0);
TInt nbIndxX = this->GetNbIndexes(0);
switch(aDim){
case 1:{
aCoord[0] = aVecX[theId];
break;
}
case 2:{
TFloatVector aVecY = this->GetIndexes(1);
TInt i,j,k;
i = j = k = 0;
i = theId % nbIndxX;
j = theId / nbIndxX;
if(myGrilleType == eGRILLE_CARTESIENNE){
aCoord[0] = aVecX[i];
aCoord[1] = aVecY[j];
} else { // eGRILLE_POLAIRE (cylindrical)
aCoord[0] = aVecX[i] * cos(aVecY[j]);
aCoord[1] = aVecX[i] * sin(aVecY[j]);
}
break;
}
case 3:{
TFloatVector aVecY = this->GetIndexes(1);
TInt nbIndxY = this->GetNbIndexes(1);
TFloatVector aVecZ = this->GetIndexes(2);
TInt i,j,k;
i = j = k = 0;
i = theId % nbIndxX;
j = (theId / nbIndxX) % nbIndxY;
k = theId / (nbIndxX*nbIndxY);
if(myGrilleType == eGRILLE_CARTESIENNE){
aCoord[0] = aVecX[i];
aCoord[1] = aVecY[j];
aCoord[2] = aVecZ[k];
} else { // eGRILLE_POLAIRE (cylindrical)
aCoord[0] = aVecX[i] * cos(aVecY[j]);
aCoord[1] = aVecX[i] * sin(aVecY[j]);
aCoord[2] = aVecZ[k];
}
break;
}
}
}
return aCoord;
}
TIntVector
TGrilleInfo
::GetConn(TInt theId, const bool isSub)
{
TIntVector anIndexes;
TInt aDim = myMeshInfo->GetDim();
TInt idx;
TInt iMin, jMin, kMin, iMax, jMax, kMax;
TInt loc[3];
loc[0] = loc[1] = loc[2] = 0;
iMin = iMax = jMin = jMax = kMin = kMax = 0;
switch(aDim) {
case 3:
{
TInt nbX = this->GetGrilleStructure()[0];
TInt nbY = this->GetGrilleStructure()[1];
TInt nbZ = this->GetGrilleStructure()[2];
TInt d01 = nbX*nbY, dX = 1, dY = 1, dZ = 1;
if ( isSub )
{
if ( theId < nbX * (nbY-1) * (nbZ-1))
{ // face is normal to X axis
dX = 0;
}
else if ( theId < nbX * (nbY-1) * (nbZ-1) + (nbX-1) * nbY * (nbZ-1))
{ // face is normal to Y axis
theId -= nbX * (nbY-1) * (nbZ-1);
dY = 0;
}
else
{
theId -= nbX * (nbY-1) * (nbZ-1) + (nbX-1) * nbY * (nbZ-1);
dZ = 0;
}
}
//else
{
iMin = theId % (nbX - dX);
jMin = (theId / (nbX - dX)) % (nbY - dY);
kMin = theId / ((nbX - dX) * (nbY - dY));
iMax = iMin+dX;
jMax = jMin+dY;
kMax = kMin+dZ;
}
for (loc[2]=kMin; loc[2]<=kMax; loc[2]++)
for (loc[1]=jMin; loc[1]<=jMax; loc[1]++)
for (loc[0]=iMin; loc[0]<=iMax; loc[0]++)
{
idx = loc[0] + loc[1]*nbX + loc[2]*d01;
anIndexes.push_back(idx);
}
break;
}
case 2:
{
TInt nbX = this->GetGrilleStructure()[0];
TInt nbY = this->GetGrilleStructure()[1];
TInt dX = 1, dY = 1;
if ( isSub )
{
if ( theId < nbX * (nbY-1))
{ // edge is normal to X axis
dX = 0;
}
else
{
theId -= nbX * (nbY-1);
dY = 0;
}
}
iMin = theId % (nbX-dX);
jMin = theId / (nbX-dX);
iMax = iMin+dX;
jMax = jMin+dY;
for (loc[1]=jMin; loc[1]<=jMax; loc[1]++)
for (loc[0]=iMin; loc[0]<=iMax; loc[0]++)
{
idx = loc[0] + loc[1]*nbX;
anIndexes.push_back(idx);
}
break;
}
case 1:
{
iMin = theId;
for (loc[0]=iMin; loc[0]<=iMin+1; loc[0]++)
{
idx = loc[0];
anIndexes.push_back(idx);
}
break;
}
}
return anIndexes;
}
TInt
TGrilleInfo
::GetFamNumNode(TInt theId) const
{
return myFamNumNode[theId];
}
void
TGrilleInfo
::SetFamNumNode(TInt theId,TInt theVal)
{
myFamNumNode[theId] = theVal;
}
TInt
TGrilleInfo
::GetFamNum(TInt theId) const
{
return myFamNum[theId];
}
void
TGrilleInfo
::SetFamNum(TInt theId,TInt theVal)
{
myFamNum[theId] = theVal;
}
TInt
TGrilleInfo
::GetFamSubNum(TInt theId) const
{
return myFamSubNum[theId];
}
void
TGrilleInfo
::SetFamSubNum(TInt theId,TInt theVal)
{
myFamSubNum[theId] = theVal;
}
}

195
src/MEDWrapper/Base/MED_Structures.hxx → src/MEDWrapper/MED_Structures.hxx
View File

@ -23,8 +23,12 @@
#ifndef MED_Structures_HeaderFile
#define MED_Structures_HeaderFile
#include "MED_WrapperDef.hxx"
#include "MED_Common.hxx"
#include "MED_Utilities.hxx"
#include "MED_SliceArray.hxx"
#include <boost/tuple/tuple.hpp>
#ifdef WIN32
#pragma warning(disable:4251)
@ -32,31 +36,36 @@
namespace MED
{
//---------------------------------------------------------------
//! Defines a type for managing sequence of strings
typedef TVector<char> TString;
typedef SharedPtr<TString> PString;
//---------------------------------------------------------------
//! Extract a substring from the sequence of the strings
MEDWRAPPER_EXPORT
std::string
GetString(TInt theId, TInt theStep,
GetString(TInt theId,
TInt theStep,
const TString& theString);
//---------------------------------------------------------------
//! Set a substring in the sequence of the strings
MEDWRAPPER_EXPORT
void
SetString(TInt theId, TInt theStep,
TString& theString,
const std::string& theValue);
SetString(TInt theId,
TInt theStep,
TString& theString,
const std::string& theValue);
//---------------------------------------------------------------
//! Set a substring in the sequence of the strings
MEDWRAPPER_EXPORT
void
SetString(TInt theId, TInt theStep,
TString& theString,
const TString& theValue);
SetString(TInt theId,
TInt theStep,
TString& theString,
const TString& theValue);
//---------------------------------------------------------------
//! Define a parent class for all MEDWrapper classes
@ -65,7 +74,6 @@ namespace MED
virtual ~TBase() {}
};
//---------------------------------------------------------------
//! Define a parent class for all named MED entities
struct MEDWRAPPER_EXPORT TNameInfo: virtual TBase
@ -76,7 +84,6 @@ namespace MED
virtual void SetName(const TString& theValue) = 0; //!< Set a new name
};
//---------------------------------------------------------------
//! Define a parent class for all MED entities that contains a sequence of numbers
/*!
@ -95,53 +102,48 @@ namespace MED
myModeSwitch(theModeSwitch)
{}
EModeSwitch myModeSwitch; //!< Keeps the
EModeSwitch GetModeSwitch() const { return myModeSwitch;}
EModeSwitch myModeSwitch; //!< Keeps the interlace mode
EModeSwitch GetModeSwitch() const { return myModeSwitch; }
};
//---------------------------------------------------------------
//! Define a base class which represents MED Mesh entity
struct MEDWRAPPER_EXPORT TMeshInfo: virtual TNameInfo
{
TInt myDim; //!< Dimension of the mesh (0, 1, 2 or 3)
TInt GetDim() const { return myDim;} //!< Gets dimension of the mesh
TInt GetDim() const { return myDim; } //!< Gets dimension of the mesh
TInt mySpaceDim;
TInt GetSpaceDim() const { return mySpaceDim; }
EMaillage myType; //!< Type of the mesh
EMaillage GetType() const { return myType;} //!< Gets type of the mesh
EMaillage GetType() const { return myType; } //!< Gets type of the mesh
TString myDesc; //!< Description of the mesh
virtual std::string GetDesc() const = 0; //!< Get description for the mesh
virtual void SetDesc(const std::string& theValue) = 0; //!< Sets description for the mesh
};
//---------------------------------------------------------------
typedef TVector<TInt> TIntVector;
typedef TSlice<TInt> TIntVecSlice;
typedef TCSlice<TInt> TCIntVecSlice;
typedef TIntVector TFamAttr;
//---------------------------------------------------------------
//! Define a base class which represents MED Family entity
struct MEDWRAPPER_EXPORT TFamilyInfo: virtual TNameInfo
{
PMeshInfo myMeshInfo; //!< A reference to correspondig MED Mesh
//! Get a reference to corresponding MED Mesh
const PMeshInfo& GetMeshInfo() const { return myMeshInfo;}
const PMeshInfo& GetMeshInfo() const { return myMeshInfo; }
TInt myId; //!< An unique index of the MED FAMILY
TInt GetId() const { return myId;} //!< Gets number of the MED FAMILY
void SetId(TInt theId) { myId = theId;} //! Define number of the MED FAMILY
TInt GetId() const { return myId; } //!< Gets number of the MED FAMILY
void SetId(TInt theId) { myId = theId; } //! Define number of the MED FAMILY
TInt myNbGroup; //!< Defines number MED Groups connected to
//! Gets number of MED GROUPS the MED FAMILY is bound to
TInt GetNbGroup() const { return myNbGroup;}
TInt GetNbGroup() const { return myNbGroup; }
//! Contains sequence of the names for the MED Groups connected to
TString myGroupNames;
@ -152,7 +154,7 @@ namespace MED
TInt myNbAttr; //!< Defines number of the MED Family attributes
//! Gets number of attached attributes for the MED FAMILY
TInt GetNbAttr() const { return myNbAttr;}
TInt GetNbAttr() const { return myNbAttr; }
//! Defines sequence of the indexes of the MED Family attributes
TFamAttr myAttrId;
@ -176,38 +178,37 @@ namespace MED
virtual void SetAttrDesc(TInt theId, const std::string& theValue) = 0;
};
//---------------------------------------------------------------
typedef TIntVector TElemNum;
typedef SharedPtr<TElemNum> PElemNum;
//---------------------------------------------------------------
//! Define a parent class for all MED entities that describes mesh entites such as nodes and cells.
struct MEDWRAPPER_EXPORT TElemInfo: virtual TBase
{
PMeshInfo myMeshInfo; //!< A reference to correspondig MED Mesh
//! Get a reference to corresponding MED Mesh
const PMeshInfo& GetMeshInfo() const { return myMeshInfo;}
const PMeshInfo& GetMeshInfo() const { return myMeshInfo; }
TInt myNbElem; //<! Number of corresponding mesh entities
TInt GetNbElem() const { return myNbElem;} //! Get number of mesh elements
TInt GetNbElem() const { return myNbElem; } //! Get number of mesh elements
//! Defines sequence MED Family indexes for corresponding mesh entites
PElemNum myFamNum;
//! Get number of a MED FAMILY by order number of the mesh element
TInt GetFamNum(TInt theId) const;
//! Set number of a MED FAMILY for the mesh element with the order number
//! Set number of a MED FAMILY for the mesh element with the order number
void SetFamNum(TInt theId, TInt theVal);
//! Defines if the mesh elements are indexed
EBooleen myIsElemNum;
//! Let know if the mesh elements are indexed
EBooleen IsElemNum() const { return myIsElemNum;}
EBooleen IsElemNum() const { return myIsElemNum; }
//! Defines if the mesh elements family are indexed
EBooleen myIsFamNum;
//! Let know if the mesh elements family are indexed
EBooleen IsFamNum() const { return myIsFamNum;}
EBooleen IsFamNum() const { return myIsFamNum; }
//! Contains sequence of the indexes for the mesh elements
PElemNum myElemNum;
@ -219,7 +220,7 @@ namespace MED
//! Defines if the mesh elements are named
EBooleen myIsElemNames;
//! Let know if the mesh elements havew names
EBooleen IsElemNames() const { return myIsElemNames;}
EBooleen IsElemNames() const { return myIsElemNames; }
//! Contains sequence of the names for the mesh elements
PString myElemNames;
@ -229,18 +230,15 @@ namespace MED
virtual void SetElemName(TInt theId, const std::string& theValue) = 0;
};
//---------------------------------------------------------------
typedef TVector<TFloat> TFloatVector;
typedef TSlice<TFloat> TFloatVecSlice;
typedef TCSlice<TFloat> TCFloatVecSlice;
typedef TFloatVector TNodeCoord;
typedef SharedPtr<TNodeCoord> PNodeCoord;
typedef TFloatVecSlice TCoordSlice;
typedef TCFloatVecSlice TCCoordSlice;
//---------------------------------------------------------------
//! Define a base class which represents MED Nodes entity
struct MEDWRAPPER_EXPORT TNodeInfo:
virtual TElemInfo,
@ -255,9 +253,9 @@ namespace MED
ERepere mySystem; //!< Defines, which coordinate system is used
//! Get which coordinate system is used for the node describing
ERepere GetSystem() const { return mySystem;}
ERepere GetSystem() const { return mySystem; }
//! Set coordinate system to be used for the node describing
void SetSystem(ERepere theSystem) { mySystem = theSystem;}
void SetSystem(ERepere theSystem) { mySystem = theSystem; }
TString myCoordNames; //!< Contains names for the coordinate dimensions
//! Get name of the coordinate dimension by its order number
@ -272,11 +270,11 @@ namespace MED
virtual void SetCoordUnit(TInt theId, const std::string& theValue) = 0;
};
//---------------------------------------------------------------
typedef TIntVecSlice TConnSlice;
typedef TCIntVecSlice TCConnSlice;
//---------------------------------------------------------------
//! Define a base class which represents MED Cells entity
struct MEDWRAPPER_EXPORT TCellInfo:
virtual TElemInfo,
@ -284,15 +282,15 @@ namespace MED
{
EEntiteMaillage myEntity; //!< Defines the MED Entity where the mesh cells belongs to
//! Find out what MED ENTITY the cells belong to
EEntiteMaillage GetEntity() const { return myEntity;}
EEntiteMaillage GetEntity() const { return myEntity; }
EGeometrieElement myGeom; //!< Defines the MED Geometric type of the instance
//! Find out what MED geometrical type the cells belong to
EGeometrieElement GetGeom() const { return myGeom;}
EGeometrieElement GetGeom() const { return myGeom; }
EConnectivite myConnMode; //!< Defines connectivity mode
//! Find out in what connectivity the cells are written
EConnectivite GetConnMode() const { return myConnMode;}
//! Find out in what connectivity the cells are writen
EConnectivite GetConnMode() const { return myConnMode; }
virtual TInt GetConnDim() const = 0; //!< Gives step in the connectivity sequence
@ -312,17 +310,17 @@ namespace MED
//! Defines the MED Entity where the polygons belongs to
EEntiteMaillage myEntity; // MED_FACE|MED_MAILLE
//! Find out what MED ENTITY the MED Polygons belong to
EEntiteMaillage GetEntity() const { return myEntity;}
EEntiteMaillage GetEntity() const { return myEntity; }
//! Defines the MED Geometric type of the instance
EGeometrieElement myGeom; // ePOLYGONE
//! Find out what MED geometrical type the MED Polygons belong to
EGeometrieElement GetGeom() const { return ePOLYGONE;}
EGeometrieElement GetGeom() const { return ePOLYGONE; }
//! Defines connectivity mode
EConnectivite myConnMode; // eNOD|eDESC(eDESC not used)
//! Find out in what connectivity the cells are written
EConnectivite GetConnMode() const { return myConnMode;}
//! Find out in what connectivity the cells are writen
EConnectivite GetConnMode() const { return myConnMode; }
PElemNum myConn; //!< Table de connectivities
PElemNum myIndex; //!< Table de indexes
@ -338,11 +336,11 @@ namespace MED
//---------------------------------------------------------------
//! Define a class representing MED_BALL structure element.
//
// This could be a generic class for any structure element
// holding any number of contant and variable attributes
// but it's too hard to implement
//
/*!
This could be a generic class for any structure element
holding any number of contant and variable attributes
but it's too hard to implement
*/
struct MEDWRAPPER_EXPORT TBallInfo:
virtual TCellInfo
{
@ -353,6 +351,7 @@ namespace MED
typedef TVector<TCConnSlice> TCConnSliceArr;
typedef TVector<TConnSlice> TConnSliceArr;
//---------------------------------------------------------------
//! Define a base class which represents MED Polyedre entity
struct MEDWRAPPER_EXPORT TPolyedreInfo:
virtual TElemInfo
@ -360,17 +359,17 @@ namespace MED
//! Defines the MED Entity where the polyedres belongs to
EEntiteMaillage myEntity; // MED_FACE|MED_MAILLE
//! Find out what MED ENTITY the MED Polyedres belong to
EEntiteMaillage GetEntity() const { return myEntity;}
EEntiteMaillage GetEntity() const { return myEntity; }
//! Defines the MED Geometric type of the instance
EGeometrieElement myGeom; // ePOLYEDRE
//! Find out what MED geometrical type the MED Polyedres belong to
EGeometrieElement GetGeom() const { return ePOLYEDRE;}
EGeometrieElement GetGeom() const { return ePOLYEDRE; }
//! Defines connectivity mode
EConnectivite myConnMode; // eNOD|eDESC(eDESC not used)
//! Find out in what connectivity the cells are written
EConnectivite GetConnMode() const { return myConnMode;}
//! Find out in what connectivity the cells are writen
EConnectivite GetConnMode() const { return myConnMode; }
PElemNum myConn; //!< Table de connectivities
PElemNum myFaces; //!< Table de faces indexes
@ -394,23 +393,23 @@ namespace MED
{
PMeshInfo myMeshInfo; //!< A reference to corresponding MED Mesh
//! Get a reference to corresponding MED Mesh
const PMeshInfo& GetMeshInfo() const { return myMeshInfo;}
const PMeshInfo& GetMeshInfo() const { return myMeshInfo; }
ETypeChamp myType; //!< Defines type of MED Field
//! Find out what type of MED FIELD is used
ETypeChamp GetType() const { return myType;}
ETypeChamp GetType() const { return myType; }
TInt myNbComp; //!< Defines number of components stored in the field
//! Get number of components for MED FIELD
TInt GetNbComp() const { return myNbComp;}
TInt GetNbComp() const { return myNbComp; }
EBooleen myIsLocal; //!< Defines if the MED Field is local
//! Find out if MED FIELD is local or not
EBooleen GetIsLocal() const { return myIsLocal;}
EBooleen GetIsLocal() const { return myIsLocal; }
TInt myNbRef; //!< Defines number of references of the field
//! Find out number of references for the MED FIELD
TInt GetNbRef() const { return myNbRef;}
TInt GetNbRef() const { return myNbRef; }
TString myCompNames; //!< Contains names for each of MED Field components
//! Get name of the component by its order number
@ -423,23 +422,24 @@ namespace MED
virtual std::string GetUnitName(TInt theId) const = 0;
//! Set unit for the component by its order number
virtual void SetUnitName(TInt theId, const std::string& theValue) = 0;
};
//---------------------------------------------------------------
//! Get dimension of the Gauss coordinates for the defined type of mesh cell
MEDWRAPPER_EXPORT
TInt
GetDimGaussCoord(EGeometrieElement theGeom);
//---------------------------------------------------------------
//! Get number of referenced nodes for the defined type of mesh cell
MEDWRAPPER_EXPORT
TInt
GetNbRefCoord(EGeometrieElement theGeom);
//---------------------------------------------------------------
typedef TFloatVector TWeight;
//---------------------------------------------------------------
//! The class represents MED Gauss entity
struct MEDWRAPPER_EXPORT TGaussInfo:
virtual TNameInfo,
@ -459,7 +459,7 @@ namespace MED
//! Defines, which geometrical type the MED Gauss entity belongs to
EGeometrieElement myGeom;
//! Find out what MED geometrical type the MED GAUSS entity belong to
EGeometrieElement GetGeom() const { return myGeom;}
EGeometrieElement GetGeom() const { return myGeom; }
//! Contains coordinates for the refereced nodes
TNodeCoord myRefCoord;
@ -481,54 +481,54 @@ namespace MED
TWeight myWeight;
//! Gives number of the referenced nodes
TInt GetNbRef() const { return GetNbRefCoord(GetGeom());}
TInt GetNbRef() const { return GetNbRefCoord(GetGeom()); }
//! Gives dimension of the referenced nodes
TInt GetDim() const { return GetDimGaussCoord(GetGeom());}
TInt GetDim() const { return GetDimGaussCoord(GetGeom()); }
//! Gives number of the Gauss Points
TInt GetNbGauss() const { return (TInt)(myGaussCoord.size()/GetDim());}
TInt GetNbGauss() const { return (TInt)(myGaussCoord.size() / GetDim()); }
};
//---------------------------------------------------------------
typedef std::map<EGeometrieElement,PGaussInfo> TGeom2Gauss;
typedef std::map<EGeometrieElement,TInt> TGeom2NbGauss;
//---------------------------------------------------------------
//! Define a base class which represents MED TimeStamp
struct MEDWRAPPER_EXPORT TTimeStampInfo:
virtual TBase
{
PFieldInfo myFieldInfo; //!< A reference to correspondig MED Field
//! Get a reference to corresponding MED Field
const PFieldInfo& GetFieldInfo() const { return myFieldInfo;}
const PFieldInfo& GetFieldInfo() const { return myFieldInfo; }
//! Defines the MED Entity where the MED TimeStamp belongs to
EEntiteMaillage myEntity;
//! Find out to what MED Entity the MED TimeStamp belong to
EEntiteMaillage GetEntity() const { return myEntity;}
EEntiteMaillage GetEntity() const { return myEntity; }
//! Keeps map of number of cells per geometric type where the MED TimeStamp belongs to
TGeom2Size myGeom2Size;
//! Get map of number of cells per geometric type where the MED TimeStamp belongs to
const TGeom2Size& GetGeom2Size() const { return myGeom2Size;}
const TGeom2Size& GetGeom2Size() const { return myGeom2Size; }
TGeom2NbGauss myGeom2NbGauss; //!< Keeps number of the Gauss Points for the MED TimeStamp
TInt GetNbGauss(EGeometrieElement theGeom) const; //!< Gives number of the Gauss Points for the MED TimeStamp
TInt myNumDt; //!< Keeps number in time for the MED TimeStamp
TInt GetNumDt() const { return myNumDt;} //!< Defines number in time for the MED TimeStamp
TInt GetNumDt() const { return myNumDt; } //!< Defines number in time for the MED TimeStamp
TInt myNumOrd; //!< Keeps number for the MED TimeStamp
TInt GetNumOrd() const { return myNumOrd;} //!< Defines number for the MED TimeStamp
TInt GetNumOrd() const { return myNumOrd; } //!< Defines number for the MED TimeStamp
TFloat myDt; //!< Keeps time for the MED TimeStamp
TFloat GetDt() const { return myDt;} //!< Defines time for the MED TimeStamp
TFloat GetDt() const { return myDt; } //!< Defines time for the MED TimeStamp
//! Keeps map of MED Gauss entityes per geometric type
TGeom2Gauss myGeom2Gauss;
//! Gets a map of MED Gauss entityes per geometric type
const TGeom2Gauss& GetGeom2Gauss() const { return myGeom2Gauss;}
const TGeom2Gauss& GetGeom2Gauss() const { return myGeom2Gauss; }
TString myUnitDt; //!< Defines unit for the time for the MED TimeStamp
//! Get unit of time for the MED TimeStamp
@ -537,7 +537,6 @@ namespace MED
virtual void SetUnitDt(const std::string& theValue) = 0;
};
//---------------------------------------------------------------
//! The class represents MED Profile entity
struct MEDWRAPPER_EXPORT TProfileInfo:
@ -548,9 +547,9 @@ namespace MED
EModeProfil myMode; //!< Keeps mode for the MED Profile
//! Find out what mode of MED Profile is used
EModeProfil GetMode() const { return myMode;}
EModeProfil GetMode() const { return myMode; }
//! Set mode for the MED Profile
void SetMode(EModeProfil theMode) { myMode = theMode;}
void SetMode(EModeProfil theMode) { myMode = theMode; }
PElemNum myElemNum; //!< Keeps sequence of cell by its number which belong to the profile
//! Get number of mesh elelemts by its order number
@ -559,13 +558,12 @@ namespace MED
void SetElemNum(TInt theId, TInt theVal);
//! Find out if the MED Profile defined
bool IsPresent() const { return GetName() != "";}
bool IsPresent() const { return GetName() != ""; }
//! Find out size of the MED Profile
TInt GetSize() const { return (TInt)myElemNum->size();}
TInt GetSize() const { return (TInt)myElemNum->size(); }
};
//---------------------------------------------------------------
//! The class is a helper one. It provide safe and flexible way to get access to values for a MED TimeStamp
struct MEDWRAPPER_EXPORT TMeshValueBase:
@ -750,11 +748,12 @@ namespace MED
}
};
//---------------------------------------------------------------
typedef TTMeshValue<TFloatVector> TFloatMeshValue;
typedef TTMeshValue<TIntVector> TIntMeshValue;
//---------------------------------------------------------------
// Backward compatibility declarations
// Backward compatibility declarations
typedef TFloatVector TValue;
typedef TSlice<TFloat> TValueSlice;
typedef TCSlice<TFloat> TCValueSlice;
@ -769,6 +768,7 @@ namespace MED
typedef std::map<EGeometrieElement,PProfileInfo> TGeom2Profile;
typedef std::set<EGeometrieElement> TGeom;
//---------------------------------------------------------------
//! The class is a base class for MED TimeStamp values holder
struct MEDWRAPPER_EXPORT TTimeStampValueBase:
virtual TModeSwitchInfo
@ -776,16 +776,16 @@ namespace MED
//! A reference to correspondig MED TimeStamp
PTimeStampInfo myTimeStampInfo;
//!< Get a reference to correspondig MED TimeStamp
const PTimeStampInfo& GetTimeStampInfo() const { return myTimeStampInfo;}
const PTimeStampInfo& GetTimeStampInfo() const { return myTimeStampInfo; }
//! Keeps set of MED EGeometrieElement which contains values for the timestamp
TGeomSet myGeomSet;
const TGeomSet& GetGeomSet() const { return myGeomSet;}
const TGeomSet& GetGeomSet() const { return myGeomSet; }
//! Keeps map of MED Profiles per geometric type
TGeom2Profile myGeom2Profile;
//! Gets a map of MED Profiles per geometric type
const TGeom2Profile& GetGeom2Profile() const { return myGeom2Profile;}
const TGeom2Profile& GetGeom2Profile() const { return myGeom2Profile; }
//! Gets type of the champ
virtual
@ -818,7 +818,6 @@ namespace MED
GetValuePtr(EGeometrieElement theGeom) = 0;
};
//---------------------------------------------------------------
//! The class implements a container for MED TimeStamp values
template<class TMeshValueType>
@ -886,7 +885,6 @@ namespace MED
}
};
//---------------------------------------------------------------
typedef TTimeStampValue<TFloatMeshValue> TFloatTimeStampValue;
typedef SharedPtr<TFloatTimeStampValue> PFloatTimeStampValue;
@ -900,7 +898,6 @@ namespace MED
PIntTimeStampValue MEDWRAPPER_EXPORT
CastToIntTimeStampValue(const PTimeStampValueBase& theTimeStampValue);
//---------------------------------------------------------------
template<class TMeshValueTypeFrom, class TMeshValueTypeTo>
void
@ -929,6 +926,7 @@ namespace MED
}
}
//---------------------------------------------------------------
template<class TMeshValueType>
void
CopyTimeStampValue(SharedPtr<TTimeStampValue<TMeshValueType> > theTimeStampValueFrom,
@ -964,9 +962,8 @@ namespace MED
}
}
//---------------------------------------------------------------
// Backward compatibility declarations
// Backward compatibility declarations
typedef TFloatTimeStampValue TTimeStampVal;
typedef PFloatTimeStampValue PTimeStampVal;
@ -974,13 +971,13 @@ namespace MED
typedef std::map<TInt,TFloatVector> TIndexes;
typedef std::map<TInt,TString> TNames;
//---------------------------------------------------------------
//! Define a base class which represents MED Grille (structured mesh)
struct MEDWRAPPER_EXPORT TGrilleInfo:
virtual TModeSwitchInfo
{
PMeshInfo myMeshInfo;
const PMeshInfo& GetMeshInfo() const { return myMeshInfo;}
const PMeshInfo& GetMeshInfo() const { return myMeshInfo; }
TNodeCoord myCoord; //!< Contains all nodal coordinates, now used only for eGRILLE_STANDARD
//! Gives coordinates for mesh nodes (const version)
@ -999,8 +996,6 @@ namespace MED
//!Sets grille type
void SetGrilleType(EGrilleType theGrilleType);
TString myCoordNames; //!< Contains names for the coordinate dimensions
//! Get name of the coordinate dimension by its order number
virtual std::string GetCoordName(TInt theId) const = 0 ;
@ -1013,7 +1008,6 @@ namespace MED
//! Set name of unit for the coordinate dimension by its order number
virtual void SetCoordUnit(TInt theId, const std::string& theValue) = 0;
//! Map of index of axes and Table of indexes for certain axe, now used for eGRILLE_CARTESIENNE and eGRILLE_POLAIRE
TIndexes myIndixes;
//!Gets a map of Tables (const version)
@ -1052,7 +1046,7 @@ namespace MED
TElemNum myFamNum;
//! Get number of a MED FAMILY by order number of the mesh element
TInt GetFamNum(TInt theId) const;
//! Set number of a MED FAMILY for the mesh element with the order number
//! Set number of a MED FAMILY for the mesh element with the order number
void SetFamNum(TInt theId, TInt theVal);
/*!
@ -1070,12 +1064,9 @@ namespace MED
TElemNum myFamNumNode;
//! Get number of a MED FAMILY by order number of the mesh node
TInt GetFamNumNode(TInt theId) const;
//! Set number of a MED FAMILY for the mesh node with the order number
//! Set number of a MED FAMILY for the mesh node with the order number
void SetFamNumNode(TInt theId, TInt theVal);
};
}
#endif
#endif // MED_Structures_HeaderFile

198
src/MEDWrapper/Base/MED_TStructures.hxx → src/MEDWrapper/MED_TStructures.hxx
View File

@ -19,6 +19,7 @@
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#ifndef MED_TStructures_HeaderFile
#define MED_TStructures_HeaderFile
@ -91,12 +92,11 @@ namespace MED
};
//---------------------------------------------------------------
template<EVersion eVersion>
struct TTNameInfo: virtual TNameInfo
{
TTNameInfo(const std::string& theValue)
{
myName.resize(GetNOMLength<eVersion>()+1);
myName.resize(GetNOMLength()+1);
SetName(theValue);
}
@ -104,32 +104,30 @@ namespace MED
std::string
GetName() const
{
return GetString(0, GetNOMLength<eVersion>(), myName);
return GetString(0, GetNOMLength(), myName);
}
virtual
void
SetName(const std::string& theValue)
{
SetString(0, GetNOMLength<eVersion>(), myName, theValue);
SetString(0, GetNOMLength(), myName, theValue);
}
virtual
void
SetName(const TString& theValue)
{
SetString(0, GetNOMLength<eVersion>(), myName, theValue);
SetString(0, GetNOMLength(), myName, theValue);
}
};
//---------------------------------------------------------------
template<EVersion eVersion>
struct TTMeshInfo:
virtual TMeshInfo,
virtual TTNameInfo<eVersion>
virtual TTNameInfo
{
typedef TTNameInfo<eVersion> TNameInfoBase;
typedef TTNameInfo TNameInfoBase;
TTMeshInfo(const PMeshInfo& theInfo):
TNameInfoBase(theInfo->GetName())
@ -138,7 +136,7 @@ namespace MED
mySpaceDim = theInfo->GetSpaceDim();
myType = theInfo->GetType();
myDesc.resize(GetDESCLength<eVersion>()+1);
myDesc.resize(GetDESCLength()+1);
SetDesc(theInfo->GetDesc());
}
@ -152,7 +150,7 @@ namespace MED
mySpaceDim = theSpaceDim;
myType = theType;
myDesc.resize(GetDESCLength<eVersion>()+1);
myDesc.resize(GetDESCLength()+1);
SetDesc(theDesc);
}
@ -160,25 +158,23 @@ namespace MED
std::string
GetDesc() const
{
return GetString(0, GetDESCLength<eVersion>(), myDesc);
return GetString(0, GetDESCLength(), myDesc);
}
virtual
void
SetDesc(const std::string& theValue)
{
SetString(0, GetDESCLength<eVersion>(), myDesc, theValue);
SetString(0, GetDESCLength(), myDesc, theValue);
}
};
//---------------------------------------------------------------
template<EVersion eVersion>
struct TTFamilyInfo:
virtual TFamilyInfo,
virtual TTNameInfo<eVersion>
virtual TTNameInfo
{
typedef TTNameInfo<eVersion> TNameInfoBase;
typedef TTNameInfo TNameInfoBase;
TTFamilyInfo(const PMeshInfo& theMeshInfo, const PFamilyInfo& theInfo):
TNameInfoBase(theInfo->GetName())
@ -188,7 +184,7 @@ namespace MED
myId = theInfo->GetId();
myNbGroup = theInfo->GetNbGroup();
myGroupNames.resize(myNbGroup*GetLNOMLength<eVersion>()+1);
myGroupNames.resize(myNbGroup*GetLNOMLength()+1);
if(myNbGroup){
for(TInt anId = 0; anId < myNbGroup; anId++){
SetGroupName(anId,theInfo->GetGroupName(anId));
@ -198,7 +194,7 @@ namespace MED
myNbAttr = theInfo->GetNbAttr();
myAttrId.resize(myNbAttr);
myAttrVal.resize(myNbAttr);
myAttrDesc.resize(myNbAttr*GetDESCLength<eVersion>()+1);
myAttrDesc.resize(myNbAttr*GetDESCLength()+1);
if(myNbAttr){
for(TInt anId = 0; anId < myNbAttr; anId++){
SetAttrDesc(anId,theInfo->GetAttrDesc(anId));
@ -220,12 +216,12 @@ namespace MED
myId = theId;
myNbGroup = theNbGroup;
myGroupNames.resize(theNbGroup*GetLNOMLength<eVersion>()+1);
myGroupNames.resize(theNbGroup*GetLNOMLength()+1);
myNbAttr = theNbAttr;
myAttrId.resize(theNbAttr);
myAttrVal.resize(theNbAttr);
myAttrDesc.resize(theNbAttr*GetDESCLength<eVersion>()+1);
myAttrDesc.resize(theNbAttr*GetDESCLength()+1);
}
TTFamilyInfo(const PMeshInfo& theMeshInfo,
@ -242,7 +238,7 @@ namespace MED
myId = theId;
myNbGroup = (TInt)theGroupNames.size();
myGroupNames.resize(myNbGroup*GetLNOMLength<eVersion>()+1);
myGroupNames.resize(myNbGroup*GetLNOMLength()+1);
if(myNbGroup){
TStringSet::const_iterator anIter = theGroupNames.begin();
for(TInt anId = 0; anIter != theGroupNames.end(); anIter++, anId++){
@ -254,7 +250,7 @@ namespace MED
myNbAttr = (TInt)theAttrDescs.size();
myAttrId.resize(myNbAttr);
myAttrVal.resize(myNbAttr);
myAttrDesc.resize(myNbAttr*GetDESCLength<eVersion>()+1);
myAttrDesc.resize(myNbAttr*GetDESCLength()+1);
if(myNbAttr){
for(TInt anId = 0, anEnd = (TInt)theAttrDescs.size(); anId < anEnd; anId++){
SetAttrDesc(anId,theAttrDescs[anId]);
@ -268,34 +264,32 @@ namespace MED
std::string
GetGroupName(TInt theId) const
{
return GetString(theId, GetLNOMLength<eVersion>(), myGroupNames);
return GetString(theId, GetLNOMLength(), myGroupNames);
}
virtual
void
SetGroupName(TInt theId, const std::string& theValue)
{
SetString(theId, GetLNOMLength<eVersion>(), myGroupNames, theValue);
SetString(theId, GetLNOMLength(), myGroupNames, theValue);
}
virtual
std::string
GetAttrDesc(TInt theId) const
{
return GetString(theId, GetDESCLength<eVersion>(), myAttrDesc);
return GetString(theId, GetDESCLength(), myAttrDesc);
}
virtual
void
SetAttrDesc(TInt theId, const std::string& theValue)
{
SetString(theId, GetDESCLength<eVersion>(), myAttrDesc, theValue);
SetString(theId, GetDESCLength(), myAttrDesc, theValue);
}
};
//---------------------------------------------------------------
template<EVersion eVersion>
struct TTElemInfo: virtual TElemInfo
{
TTElemInfo(const PMeshInfo& theMeshInfo, const PElemInfo& theInfo)
@ -314,7 +308,7 @@ namespace MED
myIsElemNames = theInfo->IsElemNames();
if(theInfo->IsElemNames())
myElemNames.reset(new TString(myNbElem*GetPNOMLength<eVersion>() + 1));
myElemNames.reset(new TString(myNbElem*GetPNOMLength() + 1));
else
myElemNames.reset(new TString());
@ -354,7 +348,7 @@ namespace MED
myIsElemNames = theIsElemNames;
if(theIsElemNames)
myElemNames.reset(new TString(theNbElem*GetPNOMLength<eVersion>() + 1));
myElemNames.reset(new TString(theNbElem*GetPNOMLength() + 1));
else
myElemNames.reset(new TString());
}
@ -379,7 +373,7 @@ namespace MED
myIsElemNames = theElemNames.size()? eVRAI: eFAUX;
if(myIsElemNames)
myElemNames.reset(new TString(theNbElem*GetPNOMLength<eVersion>() + 1));
myElemNames.reset(new TString(theNbElem*GetPNOMLength() + 1));
else
myElemNames.reset(new TString());
@ -404,25 +398,23 @@ namespace MED
std::string
GetElemName(TInt theId) const
{
return GetString(theId,GetPNOMLength<eVersion>(), *myElemNames);
return GetString(theId,GetPNOMLength(), *myElemNames);
}
virtual
void
SetElemName(TInt theId, const std::string& theValue)
{
SetString(theId,GetPNOMLength<eVersion>(), *myElemNames, theValue);
SetString(theId,GetPNOMLength(), *myElemNames, theValue);
}
};
//---------------------------------------------------------------
template<EVersion eVersion>
struct TTNodeInfo:
virtual TNodeInfo,
virtual TTElemInfo<eVersion>
virtual TTElemInfo
{
typedef TTElemInfo<eVersion> TElemInfoBase;
typedef TTElemInfo TElemInfoBase;
TTNodeInfo(const PMeshInfo& theMeshInfo, const PNodeInfo& theInfo):
TNodeInfo(theInfo),
@ -436,11 +428,11 @@ namespace MED
TInt aSpaceDim = theMeshInfo->GetSpaceDim();
myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
myCoordNames.resize(aSpaceDim*GetPNOMLength()+1);
for(TInt anId = 0; anId < aSpaceDim; anId++)
SetCoordName(anId,theInfo->GetCoordName(anId));
myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
myCoordUnits.resize(aSpaceDim*GetPNOMLength()+1);
for(TInt anId = 0; anId < aSpaceDim; anId++)
SetCoordUnit(anId,theInfo->GetCoordUnit(anId));
}
@ -461,9 +453,9 @@ namespace MED
myCoord.reset(new TNodeCoord(theNbElem * theMeshInfo->mySpaceDim));
myCoordUnits.resize(theMeshInfo->mySpaceDim*GetPNOMLength<eVersion>()+1);
myCoordUnits.resize(theMeshInfo->mySpaceDim*GetPNOMLength()+1);
myCoordNames.resize(theMeshInfo->mySpaceDim*GetPNOMLength<eVersion>()+1);
myCoordNames.resize(theMeshInfo->mySpaceDim*GetPNOMLength()+1);
}
@ -489,12 +481,12 @@ namespace MED
TInt aSpaceDim = theMeshInfo->GetSpaceDim();
myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
myCoordNames.resize(aSpaceDim*GetPNOMLength()+1);
if(!theCoordNames.empty())
for(TInt anId = 0; anId < aSpaceDim; anId++)
SetCoordName(anId,theCoordNames[anId]);
myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>() + 1);
myCoordUnits.resize(aSpaceDim*GetPNOMLength() + 1);
if(!theCoordUnits.empty())
for(TInt anId = 0; anId < aSpaceDim; anId++)
SetCoordUnit(anId, theCoordUnits[anId]);
@ -504,38 +496,37 @@ namespace MED
std::string
GetCoordName(TInt theId) const
{
return GetString(theId,GetPNOMLength<eVersion>(),myCoordNames);
return GetString(theId,GetPNOMLength(),myCoordNames);
}
virtual
void
SetCoordName(TInt theId, const std::string& theValue)
{
SetString(theId,GetPNOMLength<eVersion>(),myCoordNames,theValue);
SetString(theId,GetPNOMLength(),myCoordNames,theValue);
}
virtual
std::string
GetCoordUnit(TInt theId) const
{
return GetString(theId,GetPNOMLength<eVersion>(),myCoordUnits);
return GetString(theId,GetPNOMLength(),myCoordUnits);
}
virtual
void
SetCoordUnit(TInt theId, const std::string& theValue)
{
SetString(theId,GetPNOMLength<eVersion>(),myCoordUnits,theValue);
SetString(theId,GetPNOMLength(),myCoordUnits,theValue);
}
};
//---------------------------------------------------------------
template<EVersion eVersion>
struct TTPolygoneInfo:
virtual TPolygoneInfo,
virtual TTElemInfo<eVersion>
virtual TTElemInfo
{
typedef TTElemInfo<eVersion> TElemInfoBase;
typedef TTElemInfo TElemInfoBase;
TTPolygoneInfo(const PMeshInfo& theMeshInfo, const PPolygoneInfo& theInfo):
TElemInfoBase(theMeshInfo,theInfo)
@ -597,12 +588,11 @@ namespace MED
};
//---------------------------------------------------------------
template<EVersion eVersion>
struct TTPolyedreInfo:
virtual TPolyedreInfo,
virtual TTElemInfo<eVersion>
virtual TTElemInfo
{
typedef TTElemInfo<eVersion> TElemInfoBase;
typedef TTElemInfo TElemInfoBase;
TTPolyedreInfo(const PMeshInfo& theMeshInfo, const PPolyedreInfo& theInfo):
TElemInfoBase(theMeshInfo,theInfo)
@ -669,12 +659,11 @@ namespace MED
};
//---------------------------------------------------------------
template<EVersion eVersion>
struct TTCellInfo:
virtual TCellInfo,
virtual TTElemInfo<eVersion>
virtual TTElemInfo
{
typedef TTElemInfo<eVersion> TElemInfoBase;
typedef TTElemInfo TElemInfoBase;
TTCellInfo(const PMeshInfo& theMeshInfo, const PCellInfo& theInfo):
TElemInfoBase(theMeshInfo,theInfo)
@ -684,7 +673,7 @@ namespace MED
myConnMode = theInfo->GetConnMode();
TInt aConnDim = GetNbNodes(myGeom);
TInt aNbConn = GetNbConn<eVersion>(myGeom, myEntity, myMeshInfo->myDim);
TInt aNbConn = GetNbConn(myGeom, myEntity, myMeshInfo->myDim);
myConn.reset(new TElemNum(myNbElem * aNbConn));
for(TInt anElemId = 0; anElemId < myNbElem; anElemId++){
TConnSlice aConnSlice = GetConnSlice(anElemId);
@ -713,7 +702,7 @@ namespace MED
myGeom = theGeom;
myConnMode = theConnMode;
TInt aNbConn = GetNbConn<eVersion>(theGeom, myEntity, theMeshInfo->myDim);
TInt aNbConn = GetNbConn(theGeom, myEntity, theMeshInfo->myDim);
myConn.reset(new TElemNum(theNbElem * aNbConn));
}
@ -738,7 +727,7 @@ namespace MED
myConnMode = theConnMode;
TInt aConnDim = GetNbNodes(myGeom);
TInt aNbConn = GetNbConn<eVersion>(myGeom, myEntity, myMeshInfo->myDim);
TInt aNbConn = GetNbConn(myGeom, myEntity, myMeshInfo->myDim);
myConn.reset(new TElemNum(myNbElem * aNbConn));
for(TInt anElemId = 0; anElemId < myNbElem; anElemId++){
TConnSlice aConnSlice = GetConnSlice(anElemId);
@ -752,18 +741,17 @@ namespace MED
TInt
GetConnDim() const
{
return GetNbConn<eVersion>(myGeom, myEntity, myMeshInfo->myDim);
return GetNbConn(myGeom, myEntity, myMeshInfo->myDim);
}
};
//---------------------------------------------------------------
template<EVersion eVersion>
struct TTBallInfo:
virtual TBallInfo,
virtual TTCellInfo<eVersion>
virtual TTCellInfo
{
typedef TTCellInfo<eVersion> TCellInfoBase;
typedef TTCellInfo TCellInfoBase;
TTBallInfo(const PMeshInfo& theMeshInfo, const PBallInfo& theInfo):
TCellInfoBase::TElemInfoBase(theMeshInfo, theInfo),
@ -816,12 +804,11 @@ namespace MED
};
//---------------------------------------------------------------
template<EVersion eVersion>
struct TTFieldInfo:
virtual TFieldInfo,
virtual TTNameInfo<eVersion>
virtual TTNameInfo
{
typedef TTNameInfo<eVersion> TNameInfoBase;
typedef TTNameInfo TNameInfoBase;
TTFieldInfo(const PMeshInfo& theMeshInfo, const PFieldInfo& theInfo):
TNameInfoBase(theInfo->GetName())
@ -829,12 +816,12 @@ namespace MED
myMeshInfo = theMeshInfo;
myNbComp = theInfo->GetNbComp();
myCompNames.resize(myNbComp*GetPNOMLength<eVersion>()+1);
myCompNames.resize(myNbComp*GetPNOMLength()+1);
for(TInt anId = 0; anId < myNbComp; anId++){
SetCompName(anId,theInfo->GetCompName(anId));
}
myUnitNames.resize(myNbComp*GetPNOMLength<eVersion>()+1);
myUnitNames.resize(myNbComp*GetPNOMLength()+1);
for(TInt anId = 0; anId < myNbComp; anId++){
SetUnitName(anId,theInfo->GetUnitName(anId));
}
@ -856,8 +843,8 @@ namespace MED
myMeshInfo = theMeshInfo;
myNbComp = theNbComp;
myCompNames.resize(theNbComp*GetPNOMLength<eVersion>()+1);
myUnitNames.resize(theNbComp*GetPNOMLength<eVersion>()+1);
myCompNames.resize(theNbComp*GetPNOMLength()+1);
myUnitNames.resize(theNbComp*GetPNOMLength()+1);
myType = theType;
@ -869,39 +856,37 @@ namespace MED
std::string
GetCompName(TInt theId) const
{
return GetString(theId,GetPNOMLength<eVersion>(),myCompNames);
return GetString(theId,GetPNOMLength(),myCompNames);
}
virtual
void
SetCompName(TInt theId, const std::string& theValue)
{
SetString(theId,GetPNOMLength<eVersion>(),myCompNames,theValue);
SetString(theId,GetPNOMLength(),myCompNames,theValue);
}
virtual
std::string
GetUnitName(TInt theId) const
{
return GetString(theId,GetPNOMLength<eVersion>(),myUnitNames);
return GetString(theId,GetPNOMLength(),myUnitNames);
}
virtual
void
SetUnitName(TInt theId, const std::string& theValue)
{
SetString(theId,GetPNOMLength<eVersion>(),myUnitNames,theValue);
SetString(theId,GetPNOMLength(),myUnitNames,theValue);
}
};
//---------------------------------------------------------------
template<EVersion eVersion>
struct TTGaussInfo:
virtual TGaussInfo,
virtual TTNameInfo<eVersion>
virtual TTNameInfo
{
typedef TTNameInfo<eVersion> TNameInfoBase;
typedef TTNameInfo TNameInfoBase;
TTGaussInfo(const TGaussInfo::TInfo& theInfo,
EModeSwitch theMode):
@ -919,9 +904,7 @@ namespace MED
}
};
//---------------------------------------------------------------
template<EVersion eVersion>
struct TTTimeStampInfo: virtual TTimeStampInfo
{
TTTimeStampInfo(const PFieldInfo& theFieldInfo, const PTimeStampInfo& theInfo)
@ -935,7 +918,7 @@ namespace MED
myNumOrd = theInfo->GetNumOrd();
myDt = theInfo->GetDt();
myUnitDt.resize(GetPNOMLength<eVersion>()+1);
myUnitDt.resize(GetPNOMLength()+1);
SetUnitDt(theInfo->GetUnitDt());
myGeom2NbGauss = theInfo->myGeom2NbGauss;
@ -961,7 +944,7 @@ namespace MED
myNumOrd = theNumDt;
myDt = theDt;
myUnitDt.resize(GetPNOMLength<eVersion>()+1);
myUnitDt.resize(GetPNOMLength()+1);
SetUnitDt(theUnitDt);
myGeom2NbGauss = theGeom2NbGauss;
@ -972,25 +955,23 @@ namespace MED
std::string
GetUnitDt() const
{
return GetString(0,GetPNOMLength<eVersion>(),myUnitDt);
return GetString(0,GetPNOMLength(),myUnitDt);
}
virtual
void
SetUnitDt(const std::string& theValue)
{
SetString(0,GetPNOMLength<eVersion>(),myUnitDt,theValue);
SetString(0,GetPNOMLength(),myUnitDt,theValue);
}
};
//---------------------------------------------------------------
template<EVersion eVersion>
struct TTProfileInfo:
virtual TProfileInfo,
virtual TTNameInfo<eVersion>
virtual TTNameInfo
{
typedef TTNameInfo<eVersion> TNameInfoBase;
typedef TTNameInfo TNameInfoBase;
TTProfileInfo(const TProfileInfo::TInfo& theInfo,
EModeProfil theMode):
@ -1002,9 +983,8 @@ namespace MED
}
};
//---------------------------------------------------------------
template<EVersion eVersion, class TMeshValueType>
template<class TMeshValueType>
struct TTTimeStampValue: virtual TTimeStampValue<TMeshValueType>
{
TTTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
@ -1097,7 +1077,6 @@ namespace MED
};
//---------------------------------------------------------------
template<EVersion eVersion>
struct TTGrilleInfo:
virtual TGrilleInfo
{
@ -1134,11 +1113,11 @@ namespace MED
TInt aSpaceDim = theMeshInfo->GetSpaceDim();
if(type == eGRILLE_STANDARD){
myCoord.resize(aSpaceDim*nnoeuds);
myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
myCoordNames.resize(aSpaceDim*GetPNOMLength()+1);
myCoordUnits.resize(aSpaceDim*GetPNOMLength()+1);
} else { //if(type == eGRILLE_CARTESIENNE){
myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
myCoordNames.resize(aSpaceDim*GetPNOMLength()+aSpaceDim);
myCoordUnits.resize(aSpaceDim*GetPNOMLength()+aSpaceDim);
}
myGrilleStructure.resize(aSpaceDim);
myFamNumNode.resize(nnoeuds);
@ -1150,11 +1129,11 @@ namespace MED
myMeshInfo = theMeshInfo;
TInt aSpaceDim = theMeshInfo->GetSpaceDim();
if(type == eGRILLE_STANDARD){
myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
myCoordNames.resize(aSpaceDim*GetPNOMLength()+1);
myCoordUnits.resize(aSpaceDim*GetPNOMLength()+1);
} else {// if(type == eGRILLE_CARTESIENNE){
myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
myCoordNames.resize(aSpaceDim*GetPNOMLength()+aSpaceDim);
myCoordUnits.resize(aSpaceDim*GetPNOMLength()+aSpaceDim);
}
myGrilleStructure.resize(aSpaceDim);
}
@ -1167,11 +1146,11 @@ namespace MED
TInt aSpaceDim = theMeshInfo->GetSpaceDim();
if(type == eGRILLE_STANDARD){
myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+1);
myCoordNames.resize(aSpaceDim*GetPNOMLength()+1);
myCoordUnits.resize(aSpaceDim*GetPNOMLength()+1);
} else {// if(type == eGRILLE_CARTESIENNE){
myCoordNames.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
myCoordUnits.resize(aSpaceDim*GetPNOMLength<eVersion>()+aSpaceDim);
myCoordNames.resize(aSpaceDim*GetPNOMLength()+aSpaceDim);
myCoordUnits.resize(aSpaceDim*GetPNOMLength()+aSpaceDim);
}
if(type != eGRILLE_STANDARD)
@ -1185,31 +1164,30 @@ namespace MED
std::string
GetCoordName(TInt theId) const
{
return GetString(theId,GetPNOMLength<eVersion>(),myCoordNames);
return GetString(theId,GetPNOMLength(),myCoordNames);
}
virtual
void
SetCoordName(TInt theId, const std::string& theValue)
{
SetString(theId,GetPNOMLength<eVersion>(),myCoordNames,theValue);
SetString(theId,GetPNOMLength(),myCoordNames,theValue);
}
virtual
std::string
GetCoordUnit(TInt theId) const
{
return GetString(theId,GetPNOMLength<eVersion>(),myCoordUnits);
return GetString(theId,GetPNOMLength(),myCoordUnits);
}
virtual
void
SetCoordUnit(TInt theId, const std::string& theValue)
{
SetString(theId,GetPNOMLength<eVersion>(),myCoordUnits,theValue);
SetString(theId,GetPNOMLength(),myCoordUnits,theValue);
}
};
}
#endif
#endif // MED_TStructures_HeaderFile

55
src/MEDWrapper/Factory/MED_WrapperFactory.hxx → src/MEDWrapper/MED_Utilities.cxx Executable file → Normal file
View File

@ -19,28 +19,41 @@
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File : MED_WrapperFactory.hxx
// Author : Alexander A. BORODIN
//
#ifndef _MED_WrapperFactory_HXX_
#define _MED_WrapperFactory_HXX_
#ifdef WIN32
#if defined MEDWRAPPER_FACTORY_EXPORTS || defined MEDWrapper_EXPORTS
#if defined WIN32
#define MEDWRAPPER_FACTORY_EXPORT __declspec( dllexport )
#else
#define MEDWRAPPER_FACTORY_EXPORT
#endif
#else
#if defined WIN32
#define MEDWRAPPER_FACTORY_EXPORT __declspec( dllimport )
#else
#define MEDWRAPPER_FACTORY_EXPORT
#endif
#endif
#include "MED_Utilities.hxx"
#include "MED_Common.hxx"
#ifdef _DEBUG_
static int MYDEBUG = 0;
#else
#define MEDWRAPPER_FACTORY_EXPORT
static int MYDEBUG = 0;
#endif
#endif
int MED::PrefixPrinter::myCounter = 0;
MED::PrefixPrinter::PrefixPrinter(bool theIsActive):
myIsActive(theIsActive)
{
if(myIsActive)
myCounter++;
MSG(MYDEBUG,"MED::PrefixPrinter::PrefixPrinter(...)- "<<myCounter);
}
MED::PrefixPrinter::~PrefixPrinter()
{
if(myIsActive){
myCounter--;
if(myCounter < 0)
EXCEPTION(std::runtime_error,"PrefixPrinter::~PrefixPrinter() - myCounter("<<myCounter<<") < 0");
}
}
std::string MED::PrefixPrinter::GetPrefix()
{
if(myCounter){
if(myCounter < 0)
EXCEPTION(std::runtime_error,"PrefixPrinter::~PrefixPrinter() - myCounter("<<myCounter<<") < 0");
return std::string(myCounter*2,' ');
}
return "";
}

13
src/MEDWrapper/Base/MED_Utilities.hxx → src/MEDWrapper/MED_Utilities.hxx
View File

@ -19,10 +19,11 @@
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#ifndef MED_Utilities_HeaderFile
#define MED_Utilities_HeaderFile
#include "MED_WrapperBase.hxx"
#include "MED_WrapperDef.hxx"
#include <iostream>
#include <sstream>
@ -30,7 +31,6 @@
#include <string.h>
#include <stdexcept>
namespace MED
{
class MEDWRAPPER_EXPORT PrefixPrinter
@ -51,14 +51,13 @@ namespace MED
#define INITMSGA(deb,lev,msg) MED::PrefixPrinter aPrefixPrinter_##lev(deb); BEGMSG(deb,msg)
#define INITMSG(deb,msg) INITMSGA(deb,,msg)
#define ADDMSG(deb,msg) if(deb) std::cout<<msg
#else
#else // _DEBUG_
#define MSG(deb,msg)
#define BEGMSG(deb,msg)
#define INITMSGA(deb,lev,msg)
#define INITMSG(deb,msg)
#define ADDMSG(deb,msg)
#endif
#endif // _DEBUG_
#ifndef EXCEPTION
@ -68,6 +67,6 @@ namespace MED
throw TYPE(aStream.str().c_str());\
}
#endif
#endif // EXCEPTION
#endif
#endif // MED_Utilities_HeaderFile

5
src/MEDWrapper/Base/MED_Vector.hxx → src/MEDWrapper/MED_Vector.hxx
View File

@ -19,6 +19,7 @@
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#ifndef MED_Vector_HeaderFile
#define MED_Vector_HeaderFile
@ -31,7 +32,6 @@
namespace MED
{
//! Main purpose to introduce the class was to customize operator []
template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
class TVector : public std::vector<_Tp, _Alloc>
@ -144,9 +144,8 @@ namespace MED
return get_value(__n);
}
};
}
#undef MED_TVECTOR_CHECK_RANGE
#endif
#endif // MED_Vector_HeaderFile

4053
src/MEDWrapper/MED_Wrapper.cxx Normal file
View File

File diff suppressed because it is too large Load Diff

1027
src/MEDWrapper/MED_Wrapper.hxx Normal file
View File

File diff suppressed because it is too large Load Diff

30
src/MEDWrapper/Base/MED_WrapperBase.hxx → src/MEDWrapper/MED_WrapperDef.hxx
View File

@ -19,28 +19,18 @@
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File : MED_WrapperBase.hxx
// Author : Alexander A. BORODIN
//
#ifndef _MED_WrapperBase_HXX_
#define _MED_WrapperBase_HXX_
#ifndef MED_WrapperDef_HeaderFile
#define MED_WrapperDef_HeaderFile
#ifdef WIN32
#if defined MEDWRAPPER_BASE_EXPORTS || defined MEDWrapperBase_EXPORTS
#if defined WIN32
#define MEDWRAPPER_EXPORT __declspec( dllexport )
#else
#define MEDWRAPPER_EXPORT
#endif
#else
#if defined WIN32
#define MEDWRAPPER_EXPORT __declspec( dllimport )
#else
#define MEDWRAPPER_EXPORT
#endif
#endif
# if defined(MEDWRAPPER_EXPORTS) || defined(MEDWrapper_EXPORTS)
# define MEDWRAPPER_EXPORT __declspec( dllexport )
# else
# define MEDWRAPPER_EXPORT __declspec( dllimport )
# endif // WIN32
#else
#define MEDWRAPPER_EXPORT
# define MEDWRAPPER_EXPORT
#endif
#endif
#endif // MED_WrapperDef_HeaderFile

63
src/MEDWrapper/V2_2/CMakeLists.txt
View File

@ -1,63 +0,0 @@
# Copyright (C) 2012-2016 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# --- options ---
# additional include directories
INCLUDE_DIRECTORIES(
${MEDFILE_INCLUDE_DIRS}
${HDF5_INCLUDE_DIRS}
${Boost_INCLUDE_DIRS}
${KERNEL_INCLUDE_DIRS}
${CMAKE_CURRENT_SOURCE_DIR}/../Base
)
# additional preprocessor / compiler flags
ADD_DEFINITIONS(
${HDF5_DEFINITIONS}
${BOOST_DEFINITIONS}
)
SET(_link_LIBRARIES
${HDF5_LIBS}
${MEDFILE_C_LIBRARIES}
${Boost_LIBRARIES}
MEDWrapperBase
)
# --- headers ---
# header files / no moc processing
SET(MEDWrapper_V2_2_HEADERS
MED_V2_2_Wrapper.hxx
)
# --- sources ---
# sources / static
SET(MEDWrapper_V2_2_SOURCES
MED_V2_2_Wrapper.cxx
)
# --- rules ---
ADD_LIBRARY(MEDWrapper_V2_2 ${MEDWrapper_V2_2_SOURCES})
TARGET_LINK_LIBRARIES(MEDWrapper_V2_2 ${_link_LIBRARIES})
INSTALL(TARGETS MEDWrapper_V2_2 EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
INSTALL(FILES ${MEDWrapper_V2_2_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})

2882
src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx
View File

File diff suppressed because it is too large Load Diff

489
src/MEDWrapper/V2_2/MED_V2_2_Wrapper.hxx
View File

@ -1,489 +0,0 @@
// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#ifndef MED_V2_2_Wrapper_HeaderFile
#define MED_V2_2_Wrapper_HeaderFile
#ifdef WIN32
#if defined MEDWRAPPER_V2_2_EXPORTS || defined MEDWrapper_V2_2_EXPORTS
#if defined WIN32
#define MED_V22_WRAPPER_EXPORT __declspec( dllexport )
#else
#define MED_V22_WRAPPER_EXPORT
#endif
#else
#if defined WIN32
#define MED_V22_WRAPPER_EXPORT __declspec( dllimport )
#else
#define MED_V22_WRAPPER_EXPORT
#endif
#endif
#else
#define MED_V22_WRAPPER_EXPORT
#endif
#include "MED_Structures.hxx"
#include "MED_TWrapper.hxx"
namespace MED
{
template<>
TInt MED_V22_WRAPPER_EXPORT
GetDESCLength<eV2_2>();
template<>
TInt MED_V22_WRAPPER_EXPORT
GetIDENTLength<eV2_2>();
template<>
TInt MED_V22_WRAPPER_EXPORT
GetNOMLength<eV2_2>();
template<>
TInt MED_V22_WRAPPER_EXPORT
GetLNOMLength<eV2_2>();
template<>
TInt MED_V22_WRAPPER_EXPORT
GetPNOMLength<eV2_2>();
template<>
void MED_V22_WRAPPER_EXPORT
GetVersionRelease<eV2_2>(TInt& majeur, TInt& mineur, TInt& release);
template<>
TInt MED_V22_WRAPPER_EXPORT
GetNbConn<eV2_2>(EGeometrieElement typmai,
EEntiteMaillage typent,
TInt mdim);
namespace V2_2
{
//----------------------------------------------------------------------------
class TFile;
typedef boost::shared_ptr<TFile> PFile;
typedef enum {eLECTURE, eLECTURE_ECRITURE, eLECTURE_AJOUT, eCREATION} EModeAcces;
//----------------------------------------------------------------------------
class MED_V22_WRAPPER_EXPORT TVWrapper: public MED::TTWrapper<eV2_2>
{
TVWrapper();
TVWrapper(const TVWrapper&);
TVWrapper& operator=(const TVWrapper&);
public:
TVWrapper(const std::string& theFileName);
//----------------------------------------------------------------------------
virtual
TInt
GetNbMeshes(TErr* theErr = NULL);
virtual
void
GetMeshInfo(TInt theMeshId, MED::TMeshInfo&,
TErr* theErr = NULL);
virtual
void
SetMeshInfo(const MED::TMeshInfo& theInfo,
TErr* theErr = NULL);
void SetMeshInfo(const MED::TMeshInfo& theInfo,
EModeAcces theMode,
TErr* theErr = NULL);
//----------------------------------------------------------------------------
virtual
TInt
GetNbFamilies(const MED::TMeshInfo& theMeshInfo,
TErr* theErr = NULL);
virtual
TInt
GetNbFamAttr(TInt theFamId,
const MED::TMeshInfo& theInfo,
TErr* theErr = NULL);
virtual
TInt
GetNbFamGroup(TInt theFamId,
const MED::TMeshInfo& theInfo,
TErr* theErr = NULL);
virtual
void
GetFamilyInfo(TInt theFamId,
MED::TFamilyInfo& theInfo,
TErr* theErr = NULL);
virtual
void
SetFamilyInfo(const MED::TFamilyInfo& theInfo,
TErr* theErr = NULL);
void
SetFamilyInfo(const MED::TFamilyInfo& theInfo,
EModeAcces theMode,
TErr* theErr = NULL);
//----------------------------------------------------------------------------
virtual
void
GetNames(TElemInfo& theInfo,
TInt nb,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr = NULL);
virtual
void
GetNumeration(TElemInfo& theInfo,
TInt nb,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr = NULL);
virtual
void
GetFamilies(TElemInfo& theInfo,
TInt nb,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr = NULL);
virtual
void
SetNames(const TElemInfo& theInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr = NULL);
void
SetNames(const TElemInfo& theInfo,
EModeAcces theMode,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr = NULL);
virtual
void
SetNumeration(const TElemInfo& theInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr = NULL);
void
SetNumeration(const TElemInfo& theInfo,
EModeAcces theMode,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr = NULL);
virtual
void
SetFamilies(const TElemInfo& theInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr = NULL);
void
SetFamilies(const TElemInfo& theInfo,
EModeAcces theMode,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr = NULL);
//----------------------------------------------------------------------------
virtual
TInt
GetNbNodes(const MED::TMeshInfo& theMeshInfo,
TErr* theErr = NULL)
{
return GetNbNodes(theMeshInfo,eCOOR,theErr);
}
TInt
GetNbNodes(const MED::TMeshInfo& theMeshInfo,
ETable theTable,
TErr* theErr = NULL);
virtual
void
GetNodeInfo(MED::TNodeInfo& theInfo,
TErr* theErr = NULL);
virtual
void
SetNodeInfo(const MED::TNodeInfo& theInfo,
TErr* theErr = NULL);
void
SetNodeInfo(const MED::TNodeInfo& theInfo,
EModeAcces theMode,
TErr* theErr = NULL);
//----------------------------------------------------------------------------
virtual
void
GetPolygoneInfo(TPolygoneInfo& theInfo,
TErr* theErr = NULL);
virtual
void
SetPolygoneInfo(const TPolygoneInfo& theInfo,
TErr* theErr = NULL);
void
SetPolygoneInfo(const MED::TPolygoneInfo& theInfo,
EModeAcces theMode,
TErr* theErr = NULL);
virtual
TInt
GetNbPolygones(const TMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
EConnectivite theConnMode = eNOD,
TErr* theErr = NULL);
virtual
TInt
GetPolygoneConnSize(const TMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
EConnectivite theConnMode = eNOD,
TErr* theErr = NULL);
//----------------------------------------------------------------------------
virtual
void
GetPolyedreInfo(TPolyedreInfo& theInfo,
TErr* theErr = NULL);
virtual
void
SetPolyedreInfo(const TPolyedreInfo& theInfo,
TErr* theErr = NULL);
void
SetPolyedreInfo(const MED::TPolyedreInfo& theInfo,
EModeAcces theMode,
TErr* theErr = NULL);
virtual
TInt
GetNbPolyedres(const TMeshInfo& theMeshInfo,
EEntiteMaillage,
EGeometrieElement,
EConnectivite,
TErr* theErr = NULL);
virtual
void
GetPolyedreConnSize(const TMeshInfo& theMeshInfo,
TInt& theNbFaces,
TInt& theConnSize,
EConnectivite theConnMode = eNOD,
TErr* theErr = NULL);
//----------------------------------------------------------------------------
virtual
TEntityInfo
GetEntityInfo(const MED::TMeshInfo& theMeshInfo,
EConnectivite theConnMode = eNOD,
TErr* theErr = NULL);
virtual
TInt
GetNbCells(const MED::TMeshInfo& theMeshInfo,
EEntiteMaillage,
EGeometrieElement,
EConnectivite theConnMode = eNOD,
TErr* theErr = NULL);
virtual
void
GetCellInfo(MED::TCellInfo& theInfo,
TErr* theErr = NULL);
virtual
void
SetCellInfo(const MED::TCellInfo& theInfo,
TErr* theErr = NULL);
void
SetCellInfo(const MED::TCellInfo& theInfo,
EModeAcces theMode,
TErr* theErr = NULL);
//----------------------------------------------------------------------------
//! Read geom type of MED_BALL structural element
EGeometrieElement GetBallGeom(const TMeshInfo& theMeshInfo);
//! Read number of balls in the Mesh
virtual TInt GetNbBalls(const TMeshInfo& theMeshInfo);
//! Read a MEDWrapped representation of MED_BALL from the MED file
virtual void GetBallInfo(TBallInfo& theInfo, TErr* theErr = NULL);
//! Write a MEDWrapped representation of MED_BALL to the MED file
virtual void SetBallInfo(const TBallInfo& theInfo, TErr* theErr);
//! Write a MEDWrapped representation of MED_BALL to the MED file
void SetBallInfo(const TBallInfo& theInfo, EModeAcces theMode, TErr* theErr);
//----------------------------------------------------------------------------
virtual
TInt
GetNbFields(TErr* theErr = NULL);
virtual
TInt
GetNbComp(TInt theFieldId,
TErr* theErr = NULL);
virtual
void
GetFieldInfo(TInt theFieldId,
MED::TFieldInfo& theInfo,
TErr* theErr = NULL);
virtual
void
SetFieldInfo(const MED::TFieldInfo& theInfo,
TErr* theErr = NULL);
void
SetFieldInfo(const MED::TFieldInfo& theInfo,
EModeAcces theMode,
TErr* theErr = NULL);
//----------------------------------------------------------------------------
virtual
TInt
GetNbGauss(TErr* theErr = NULL);
virtual
TGaussInfo::TInfo
GetGaussPreInfo(TInt theId,
TErr* theErr = NULL);
virtual
void
GetGaussInfo(TInt theId,
TGaussInfo& theInfo,
TErr* theErr = NULL);
//----------------------------------------------------------------------------
virtual
TInt
GetNbProfiles(TErr* theErr = NULL);
virtual
TProfileInfo::TInfo
GetProfilePreInfo(TInt theId,
TErr* theErr = NULL);
virtual
void
GetProfileInfo(TInt theId,
TProfileInfo& theInfo,
TErr* theErr = NULL);
virtual
void
SetProfileInfo(const TProfileInfo& theInfo,
TErr* theErr = NULL);
void
SetProfileInfo(const TProfileInfo& theInfo,
EModeAcces theMode,
TErr* theErr = NULL);
//----------------------------------------------------------------------------
virtual
TInt
GetNbTimeStamps(const MED::TFieldInfo& theInfo,
const MED::TEntityInfo& theEntityInfo,
EEntiteMaillage& theEntity,
TGeom2Size& theGeom2Size,
TErr* theErr = NULL);
virtual
void
GetTimeStampInfo(TInt theTimeStampId,
MED::TTimeStampInfo& theInfo,
TErr* theErr = NULL);
virtual
void
GetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
const TMKey2Profile& theMKey2Profile,
const TKey2Gauss& theKey2Gauss,
TErr* theErr = NULL);
virtual
void
SetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
TErr* theErr = NULL);
void
SetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
EModeAcces theMode,
TErr* theErr = NULL);
//----------------------------------------------------------------------------
virtual
void
GetGrilleInfo(TGrilleInfo& theGrilleInfo,
TErr* theErr = NULL);
virtual
void
SetGrilleInfo(const MED::TGrilleInfo& theGrilleInfo,
TErr* theErr = NULL);
void
SetGrilleInfo(const MED::TGrilleInfo& theGrilleInfo,
EModeAcces theMode,
TErr* theErr = NULL);
virtual
void
GetGrilleType(const MED::TMeshInfo& theMeshInfo,
EGrilleType& type,
TErr* theErr = NULL);
void
GetGrilleStruct(const MED::TMeshInfo& theMeshInfo,
TIntVector& theStruct,
TErr* theErr = NULL);
protected:
PFile myFile;
};
}
}
#endif

26
src/MEDWrapper/Factory/mprint_version.cxx → src/MEDWrapper/mprint_version.cxx
View File

@ -27,18 +27,22 @@
int main (int argc, char **argv)
{
med_idt aFid = MEDfileOpen(argv[1],MED_ACC_RDONLY);
if(aFid < 0)
exit(1);
if ( argc < 2 )
return -1;
med_int aMajor, aMinor, aRelease;
med_err aRet = MEDfileNumVersionRd(aFid,&aMajor,&aMinor,&aRelease);
MEDfileClose(aFid);
if(aRet < 0) {
// VSR: simulate med 2.3.6 behavior, med file version is assumed to 2.1
aMajor=2;
aMinor=aRelease=-1;
med_idt fid = MEDfileOpen(argv[1], MED_ACC_RDONLY);
if (fid < 0)
return 1;
med_int major, minor, release;
med_err aRet = MEDfileNumVersionRd(fid, &major, &minor, &release);
MEDfileClose(fid);
if (aRet < 0) {
// VSR: simulate med 2.3.6 behavior, med file version is assumed to be 2.1 or older
major = 2;
minor = release = -1;
}
printf("%d.%d.%d\n",aMajor,aMinor,aRelease);
printf("%d.%d.%d\n", major, minor, release);
return 0;
}

2
src/SMESH/CMakeLists.txt
View File

@ -27,7 +27,7 @@ INCLUDE_DIRECTORIES(
${Boost_INCLUDE_DIRS}
${HDF5_INCLUDE_DIRS}
${PROJECT_SOURCE_DIR}/src/Controls
${PROJECT_SOURCE_DIR}/src/MEDWrapper/Base
${PROJECT_SOURCE_DIR}/src/MEDWrapper
${PROJECT_SOURCE_DIR}/src/Driver
${PROJECT_SOURCE_DIR}/src/DriverDAT
${PROJECT_SOURCE_DIR}/src/DriverMED

6
src/SMESH/SMESH_Mesh.cxx
View File

@ -1376,7 +1376,6 @@ bool SMESH_Mesh::HasDuplicatedGroupNamesMED()
* \param [in] theAutoGroups - boolean parameter for creating/not creating
* the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
* the typical use is auto_groups=false.
* \param [in] theVersion - defines the version of format of MED file, that will be created
* \param [in] meshPart - mesh data to export
* \param [in] theAutoDimension - if \c true, a space dimension of a MED mesh can be either
* - 1D if all mesh nodes lie on OX coordinate axis, or
@ -1392,7 +1391,6 @@ bool SMESH_Mesh::HasDuplicatedGroupNamesMED()
void SMESH_Mesh::ExportMED(const char * file,
const char* theMeshName,
bool theAutoGroups,
int theVersion,
const SMESHDS_Mesh* meshPart,
bool theAutoDimension,
bool theAddODOnVertices,
@ -1402,7 +1400,7 @@ void SMESH_Mesh::ExportMED(const char * file,
SMESH_TRY;
DriverMED_W_SMESHDS_Mesh myWriter;
myWriter.SetFile ( file, MED::EVersion(theVersion) );
myWriter.SetFile ( file );
myWriter.SetMesh ( meshPart ? (SMESHDS_Mesh*) meshPart : _myMeshDS );
myWriter.SetAutoDimension( theAutoDimension );
myWriter.AddODOnVertices ( theAddODOnVertices );
@ -1478,7 +1476,7 @@ void SMESH_Mesh::ExportSAUV(const char *file,
cmd += "from medutilities import my_remove ; my_remove(r'" + medfilename + "')";
cmd += "\"";
system(cmd.c_str());
ExportMED(medfilename.c_str(), theMeshName, theAutoGroups, /*theVersion=*/1,
ExportMED(medfilename.c_str(), theMeshName, theAutoGroups,
/*meshPart=*/NULL, /*theAutoDimension=*/false, /*theAddODOnVertices=*/false,
/*theAllElemsToGroup=*/true ); // theAllElemsToGroup is for PAL0023413
#ifdef WIN32

1
src/SMESH/SMESH_Mesh.hxx
View File

@ -249,7 +249,6 @@ class SMESH_EXPORT SMESH_Mesh
void ExportMED(const char * theFile,
const char* theMeshName = NULL,
bool theAutoGroups = true,
int theVersion = 0,
const SMESHDS_Mesh* theMeshPart = 0,
bool theAutoDimension = false,
bool theAddODOnVertices = false,

2
src/SMESHClient/CMakeLists.txt
View File

@ -71,8 +71,6 @@ SET(_link_LIBRARIES
SMESHDS
SMESHControls
MEDWrapper
MEDWrapperBase
MEDWrapper_V2_2
)
# --- headers ---

2
src/SMESHGUI/CMakeLists.txt
View File

@ -42,7 +42,7 @@ INCLUDE_DIRECTORIES(
${PROJECT_SOURCE_DIR}/src/SMESHUtils
${PROJECT_SOURCE_DIR}/src/Controls
${PROJECT_SOURCE_DIR}/src/SMESHClient
${PROJECT_SOURCE_DIR}/src/MEDWrapper/Base
${PROJECT_SOURCE_DIR}/src/MEDWrapper
${PROJECT_BINARY_DIR}
${PROJECT_BINARY_DIR}/idl
)

58
src/SMESHGUI/SMESHGUI.cxx
View File

@ -238,8 +238,8 @@ namespace
}
else if ( theCommandID == SMESHOp::OpImportSAUV ||
theCommandID == SMESHOp::OpPopupImportSAUV ) {
filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
filter.append( QObject::tr( "All files (*)" ) );
filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
}
else if ( theCommandID == SMESHOp::OpImportGMF ||
theCommandID == SMESHOp::OpPopupImportGMF ) {
@ -650,8 +650,7 @@ namespace
// Get parameters of export operation
QString aFilename;
SMESH::MED_VERSION aFormat = SMESH::MED_V2_2;
QString aFilename;
// Init the parameters with the default values
bool aIsASCII_STL = true;
bool toCreateGroups = false;
@ -728,27 +727,14 @@ namespace
}
else if ( isMED || isSAUV ) // Export to MED or SAUV
{
QMap<QString, SMESH::MED_VERSION> aFilterMap;
//QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
QStringList filters;
if ( isMED ) {
QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
//aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
}
else { // isSAUV
aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
filters << QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)";
}
QStringList filters;
QString aDefaultFilter;
QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
for ( ; it != aFilterMap.end(); ++it ) {
filters.push_back( it.key() );
if (it.value() == SMESH::MED_V2_2)
aDefaultFilter = it.key();
}
QStringList checkBoxes;
checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
@ -761,7 +747,6 @@ namespace
new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
fd->setWindowTitle( aTitle );
fd->setNameFilters( filters );
fd->selectNameFilter( aDefaultFilter );
fd->SetChecked( toCreateGroups, 0 );
fd->SetChecked( toFindOutDim, 1 );
if ( !anInitialPath.isEmpty() )
@ -789,34 +774,13 @@ namespace
aFilename = QString::null;
break;
}
aFormat = aFilterMap[fd->selectedNameFilter()];
toOverwrite = fv->isOverwrite();
is_ok = true;
if ( !aFilename.isEmpty() ) {
// med-2.1 does not support poly elements
if ( aFormat==SMESH::MED_V2_1 )
for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
{
int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
QObject::tr("SMESH_WRN_WARNING"),
QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
QObject::tr("SMESH_BUT_YES"),
QObject::tr("SMESH_BUT_NO"), 0, 1);
if (aRet != 0) {
is_ok = false;
break;
}
}
}
if( !toOverwrite ) {
// can't append to an existing using other format
SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
if( !isVersionOk || aVersion != aFormat ) {
bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckCompatibility( aFilename.toUtf8().constData() );
if ( !isVersionOk ) {
int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
QObject::tr("SMESH_WRN_WARNING"),
QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
@ -901,11 +865,11 @@ namespace
const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups,
toOverwrite && aMeshIndex == 0, toFindOutDim );
else
aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
toOverwrite && aMeshIndex == 0, toFindOutDim,
fields, geoAssFields.toLatin1().data() );
}
}

2
src/SMESHGUI/SMESHGUI_FileInfoDlg.cxx
View File

@ -23,8 +23,6 @@
//
#include "SMESHGUI_FileInfoDlg.h"
#include "MED_Common.hxx"
#include <QGridLayout>
#include <QLabel>
#include <QLineEdit>

15
src/SMESHGUI/SMESH_msg_en.ts
View File

@ -11,6 +11,10 @@
<source>MED_FILES_FILTER</source>
<translation>MED files</translation>
</message>
<message>
<source>SAUV_FILES_FILTER</source>
<translation>SAUV files</translation>
</message>
<message>
<source>IDEAS_FILES_FILTER</source>
<translation>IDEAS files</translation>
@ -23,10 +27,6 @@
<source>TEXT_FILES_FILTER</source>
<translation>TXT files</translation>
</message>
<message>
<source>MED_VX_FILES_FILTER</source>
<translation>MED %1 files</translation>
</message>
<message>
<source>STL_FILES_FILTER</source>
<translation>STL files</translation>
@ -1764,13 +1764,6 @@ Do you want to continue?</translation>
<source>SMESH_EXPORT_ONLY_GPOUP</source>
<translation>You are going to export the group without its mesh.
Do you want to continue?</translation>
</message>
<message>
<source>SMESH_EXPORT_MED_V2_1</source>
<translation>During export mesh with name - &quot;%1&quot; to MED 2.1
polygons and polyhedrons elements will be missed
For correct export use MED 2.2
Are you sure want to export to MED 2.1?</translation>
</message>
<message>
<source>SMESH_EXPORT_MED_VERSION_COLLISION</source>

15
src/SMESHGUI/SMESH_msg_fr.ts
View File

@ -11,6 +11,10 @@
<source>MED_FILES_FILTER</source>
<translation>Fichiers MED</translation>
</message>
<message>
<source>SAUV_FILES_FILTER</source>
<translation>Fichiers SAUV</translation>
</message>
<message>
<source>IDEAS_FILES_FILTER</source>
<translation>Fichiers IDEAS</translation>
@ -23,10 +27,6 @@
<source>TEXT_FILES_FILTER</source>
<translation>Fichiers TXT</translation>
</message>
<message>
<source>MED_VX_FILES_FILTER</source>
<translation>Fichiers MED %1</translation>
</message>
<message>
<source>STL_FILES_FILTER</source>
<translation>Fichiers STL</translation>
@ -1748,13 +1748,6 @@ Voulez-vous continuer ?</translation>
<source>SMESH_EXPORT_ONLY_GPOUP</source>
<translation>Vous allez export le groupe sans son maillage.
Voulez-vous continuer ?</translation>
</message>
<message>
<source>SMESH_EXPORT_MED_V2_1</source>
<translation>Les éléments polygonaux et polyèdriques seront omis
dans le cas d&apos;exportation du maillage &quot;%1&quot; à MED 2.1
Utilisez MED 2.2 pour l&apos;exportation correcte.
Voulez-vous effectuer l&apos;exportation à MED 2.1 ?</translation>
</message>
<message>
<source>SMESH_EXPORT_MED_VERSION_COLLISION</source>

12
src/SMESHGUI/SMESH_msg_ja.ts
View File

@ -11,6 +11,10 @@
<source>MED_FILES_FILTER</source>
<translation>MEDファイル</translation>
</message>
<message>
<source>SAUV_FILES_FILTER</source>
<translation>SAUVファイル</translation>
</message>
<message>
<source>IDEAS_FILES_FILTER</source>
<translation>IDEAS ファイル</translation>
@ -23,10 +27,6 @@
<source>TEXT_FILES_FILTER</source>
<translation>TXT ファイル</translation>
</message>
<message>
<source>MED_VX_FILES_FILTER</source>
<translation>ファイル MED %1</translation>
</message>
<message>
<source>STL_FILES_FILTER</source>
<translation>STL ファイル</translation>
@ -1731,10 +1731,6 @@
<source>SMESH_EXPORT_ONLY_GPOUP</source>
<translation>そのメッシュなしでグループのエクスポートをしようとしています。続行しますか？</translation>
</message>
<message>
<source>SMESH_EXPORT_MED_V2_1</source>
<translation>多角形、多面体要素は正しいエクスポート用 MED 2.1 MED 2.2 にメッシュ '%' のエクスポートの場合省略されます。MED 2.1 をエクスポートしますか。</translation>
</message>
<message>
<source>SMESH_EXPORT_MED_VERSION_COLLISION</source>
<translation>ファイル「%1」MED バージョンは知られていないか、選択したバージョンと一致しません。ファイルを上書きしますか。</translation>

5
src/SMESH_I/CMakeLists.txt
View File

@ -31,8 +31,7 @@ INCLUDE_DIRECTORIES(
${PROJECT_SOURCE_DIR}/src/Controls
${PROJECT_SOURCE_DIR}/src/SMDS
${PROJECT_SOURCE_DIR}/src/SMESHDS
${PROJECT_SOURCE_DIR}/src/MEDWrapper/Base
${PROJECT_SOURCE_DIR}/src/MEDWrapper/Factory
${PROJECT_SOURCE_DIR}/src/MEDWrapper
${PROJECT_SOURCE_DIR}/src/Driver
${PROJECT_SOURCE_DIR}/src/DriverMED
${PROJECT_SOURCE_DIR}/src/DriverCGNS
@ -116,7 +115,7 @@ SET(SMESHEngine_HEADERS
SET(SMESHEngine_SOURCES
SMESH_Gen_i.cxx
SMESH_Gen_i_1.cxx
SMESH_DumpPython.cxx
SMESH_PythonDump.cxx
SMESH_Mesh_i.cxx
SMESH_subMesh_i.cxx
SMESH_MeshEditor_i.cxx

43
src/SMESH_I/SMESH_2smeshpy.cxx
View File

@ -440,6 +440,18 @@ namespace {
}
}
}
bool _FilterArg( const _AString& theArg )
{
static std::list<_AString> filteredArgs;
static bool initialized = false;
if ( !initialized ) {
initialized = true;
filteredArgs.push_back( "SMESH.MED_V2_1" );
filteredArgs.push_back( "SMESH.MED_V2_2" );
}
return std::find( filteredArgs.begin(), filteredArgs.end(), theArg ) != filteredArgs.end();
}
}
//================================================================================
@ -1971,16 +1983,26 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
// ----------------------------------------------------------------------
else if ( theCommand->MethodStartsFrom( "Export" ))
{
if ( method == "ExportToMED" || // ExportToMED() --> ExportMED()
method == "ExportToMEDX" ) // ExportToMEDX() --> ExportMED()
if ( method == "ExportToMED" || // ExportToMED() --> ExportMED()
method == "ExportToMEDX" || // ExportToMEDX() --> ExportMED()
method == "ExportMED" )
{
theCommand->SetMethod( "ExportMED" );
if ( theCommand->GetNbArgs() == 5 )
// filter out deprecated version parameter
vector< _AString > args;
for ( int i = 1; i <= theCommand->GetNbArgs(); i++ ) {
if ( !_FilterArg( theCommand->GetArg( i ) ) )
args.push_back( theCommand->GetArg( i ) );
}
theCommand->RemoveArgs();
for ( uint i = 0; i < args.size(); i++ )
theCommand->SetArg( i+1, args[i] );
if ( theCommand->GetNbArgs() == 4 )
{
// ExportToMEDX(...,autoDimension) -> ExportToMEDX(...,meshPart=None,autoDimension)
_AString autoDimension = theCommand->GetArg( 5 );
theCommand->SetArg( 5, "None" );
theCommand->SetArg( 6, autoDimension );
_AString autoDimension = theCommand->GetArg( 4 );
theCommand->SetArg( 4, "None" );
theCommand->SetArg( 5, autoDimension );
}
}
else if ( method == "ExportCGNS" )
@ -2006,6 +2028,15 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
TCollection_AsciiString newMethod = method;
newMethod.Remove( /*where=*/7, /*howmany=*/6 );
theCommand->SetMethod( newMethod );
// filter out deprecated version parameter
vector< _AString > args;
for ( int i = 1; i <= theCommand->GetNbArgs(); i++ ) {
if ( !_FilterArg( theCommand->GetArg( i ) ) )
args.push_back( theCommand->GetArg( i ) );
}
theCommand->RemoveArgs();
for ( uint i = 0; i < args.size(); i++ )
theCommand->SetArg( i+1, args[i] );
// make the 1st arg be the last one (or last but three for ExportMED())
_pyID partID = theCommand->GetArg( 1 );
int nbArgs = theCommand->GetNbArgs() - 3 * (newMethod == "ExportMED");

44
src/SMESH_I/SMESH_Gen_i.cxx
View File

@ -131,6 +131,7 @@
#include <map>
#include <fstream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
@ -2943,6 +2944,22 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
return newMesh._retn();
}
//================================================================================
/*!
* \brief Get version of MED format being used.
*/
//================================================================================
char* SMESH_Gen_i::GetMEDFileVersion()
{
MED::TInt majeur, mineur, release;
majeur = mineur = release = 0;
MED::GetVersionRelease(majeur, mineur, release);
std::ostringstream version;
version << majeur << "." << mineur << "." << release;
return CORBA::string_dup( version.str().c_str() );
}
//================================================================================
/*!
* SMESH_Gen_i::GetMEDVersion
@ -2950,17 +2967,22 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
* Get MED version of the file by its name
*/
//================================================================================
CORBA::Boolean SMESH_Gen_i::GetMEDVersion(const char* theFileName,
SMESH::MED_VERSION& theVersion)
char* SMESH_Gen_i::GetMEDVersion(const char* theFileName)
{
theVersion = SMESH::MED_V2_1;
MED::EVersion aVersion = MED::GetVersionId( theFileName );
switch( aVersion ) {
case MED::eV2_1 : theVersion = SMESH::MED_V2_1; return true;
case MED::eV2_2 : theVersion = SMESH::MED_V2_2; return true;
case MED::eVUnknown : return false;
}
return false;
std::string version = MED::GetMEDVersion( theFileName );
return CORBA::string_dup( version.c_str() );
}
//================================================================================
/*!
* SMESH_Gen_i::CheckCompatibility
*
* Check compatibility of file with MED format being used.
*/
//================================================================================
CORBA::Boolean SMESH_Gen_i::CheckCompatibility(const char* theFileName)
{
return MED::CheckCompatibility( theFileName );
}
//================================================================================
@ -2973,7 +2995,7 @@ CORBA::Boolean SMESH_Gen_i::GetMEDVersion(const char* theFileName,
SMESH::string_array* SMESH_Gen_i::GetMeshNames(const char* theFileName)
{
SMESH::string_array_var aResult = new SMESH::string_array();
MED::PWrapper aMed = MED::CrWrapper( theFileName );
MED::PWrapper aMed = MED::CrWrapperR( theFileName );
MED::TErr anErr;
MED::TInt aNbMeshes = aMed->GetNbMeshes( &anErr );
if( anErr >= 0 ) {

9
src/SMESH_I/SMESH_Gen_i.hxx
View File

@ -383,9 +383,14 @@ public:
CORBA::Double mergeTolerance)
throw ( SALOME::SALOME_Exception );
// Get version of MED format being used.
char* GetMEDFileVersion();
// Get MED version of the file by its name
CORBA::Boolean GetMEDVersion(const char* theFileName,
SMESH::MED_VERSION& theVersion);
char* GetMEDVersion(const char* theFileName);
// Check compatibility of file with MED format being used.
CORBA::Boolean CheckCompatibility(const char* theFileName);
// Get names of meshes defined in file with the specified name
SMESH::string_array* GetMeshNames(const char* theFileName);

68
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -402,8 +402,8 @@ SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName )
CreateGroupServants();
int major, minor, release;
if( !MED::getMEDVersion( theFileName, major, minor, release ) )
major = minor = release = -1;
major = minor = release = 0;
MED::GetMEDVersion(theFileName, major, minor, release);
_medFileInfo = new SMESH::MedFileInfo();
_medFileInfo->fileName = theFileName;
_medFileInfo->fileSize = 0;
@ -443,19 +443,6 @@ SMESH::DriverMED_ReadStatus SMESH_Mesh_i::ImportCGNSFile( const char* theFileNa
return ConvertDriverMEDReadStatus(status);
}
//================================================================================
/*!
* \brief Return string representation of a MED file version comprising nbDigits
*/
//================================================================================
char* SMESH_Mesh_i::GetVersionString(SMESH::MED_VERSION version, CORBA::Short nbDigits)
{
string ver = DriverMED_W_SMESHDS_Mesh::GetVersionString(MED::EVersion(version),
nbDigits);
return CORBA::string_dup( ver.c_str() );
}
//=============================================================================
/*!
* ImportUNVFile
@ -2973,15 +2960,14 @@ string SMESH_Mesh_i::prepareMeshNameAndGroups(const char* file,
//================================================================================
/*!
* \brief Export to med file
* \brief Export to MED file
*/
//================================================================================
void SMESH_Mesh_i::ExportToMEDX (const char* file,
CORBA::Boolean auto_groups,
SMESH::MED_VERSION theVersion,
CORBA::Boolean overwrite,
CORBA::Boolean autoDimension)
void SMESH_Mesh_i::ExportMED(const char* file,
CORBA::Boolean auto_groups,
CORBA::Boolean overwrite,
CORBA::Boolean autoDimension)
throw(SALOME::SALOME_Exception)
{
SMESH_TRY;
@ -2989,43 +2975,16 @@ void SMESH_Mesh_i::ExportToMEDX (const char* file,
_preMeshInfo->FullLoadFromFile();
string aMeshName = prepareMeshNameAndGroups(file, overwrite);
_impl->ExportMED( file, aMeshName.c_str(), auto_groups, theVersion, 0, autoDimension );
_impl->ExportMED( file, aMeshName.c_str(), auto_groups, 0, autoDimension );
TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportToMEDX( r'"
TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportMED( r'"
<< file << "', " << auto_groups << ", "
<< theVersion << ", " << overwrite << ", "
<< overwrite << ", "
<< autoDimension << " )";
SMESH_CATCH( SMESH::throwCorbaException );
}
//================================================================================
/*!
* \brief Export a mesh to a med file
*/
//================================================================================
void SMESH_Mesh_i::ExportToMED (const char* file,
CORBA::Boolean auto_groups,
SMESH::MED_VERSION theVersion)
throw(SALOME::SALOME_Exception)
{
ExportToMEDX(file,auto_groups,theVersion,true);
}
//================================================================================
/*!
* \brief Export a mesh to a med file
*/
//================================================================================
void SMESH_Mesh_i::ExportMED (const char* file,
CORBA::Boolean auto_groups)
throw(SALOME::SALOME_Exception)
{
ExportToMEDX(file,auto_groups,SMESH::MED_V2_2,true);
}
//================================================================================
/*!
* \brief Export a mesh to a SAUV file
@ -3131,7 +3090,6 @@ void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii)
void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
CORBA::Boolean auto_groups,
SMESH::MED_VERSION version,
CORBA::Boolean overwrite,
CORBA::Boolean autoDimension,
const GEOM::ListOfFields& fields,
@ -3185,7 +3143,7 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
{
aMeshName = prepareMeshNameAndGroups(file, overwrite);
_impl->ExportMED( file, aMeshName.c_str(), auto_groups,
version, 0, autoDimension, /*addODOnVertices=*/have0dField);
0, autoDimension, /*addODOnVertices=*/have0dField);
meshDS = _impl->GetMeshDS();
}
else
@ -3203,7 +3161,7 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
SMESH_MeshPartDS* partDS = new SMESH_MeshPartDS( meshPart );
_impl->ExportMED( file, aMeshName.c_str(), auto_groups,
version, partDS, autoDimension, /*addODOnVertices=*/have0dField);
partDS, autoDimension, /*addODOnVertices=*/have0dField);
meshDS = tmpDSDeleter._obj = partDS;
}
@ -3229,7 +3187,7 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
}
TPythonDump() << _this() << ".ExportPartToMED( "
<< meshPart << ", r'" << file << "', "
<< auto_groups << ", " << version << ", " << overwrite << ", "
<< auto_groups << ", " << overwrite << ", "
<< autoDimension << ", " << goList
<< ", '" << ( geomAssocFields ? geomAssocFields : "" ) << "'" << " )";

21
src/SMESH_I/SMESH_Mesh_i.hxx
View File

@ -225,21 +225,11 @@ public:
* Consider maximum group name length stored in MED file.
*/
CORBA::Boolean HasDuplicatedGroupNamesMED();
/*!
* Return string representation of a MED file version comprising nbDigits
*/
char* GetVersionString(SMESH::MED_VERSION version, CORBA::Short nbDigits);
void ExportToMEDX( const char* file,
CORBA::Boolean auto_groups,
SMESH::MED_VERSION version,
CORBA::Boolean overwrite,
CORBA::Boolean autoDimension=true) throw (SALOME::SALOME_Exception);
void ExportToMED ( const char* file,
CORBA::Boolean auto_groups,
SMESH::MED_VERSION version ) throw (SALOME::SALOME_Exception);
void ExportMED ( const char* file,
CORBA::Boolean auto_groups ) throw (SALOME::SALOME_Exception);
void ExportMED( const char* file,
CORBA::Boolean auto_groups,
CORBA::Boolean overwrite,
CORBA::Boolean autoDimension = true) throw (SALOME::SALOME_Exception);
void ExportSAUV( const char* file, CORBA::Boolean auto_groups ) throw (SALOME::SALOME_Exception);
@ -256,7 +246,6 @@ public:
void ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
CORBA::Boolean auto_groups,
SMESH::MED_VERSION version,
CORBA::Boolean overwrite,
CORBA::Boolean autoDim,
const GEOM::ListOfFields& fields,
@ -316,7 +305,7 @@ public:
CORBA::Long NbPolygons()
throw (SALOME::SALOME_Exception);
CORBA::Long NbPolygonsOfOrder(SMESH::ElementOrder order=SMESH::ORDER_ANY)
CORBA::Long NbPolygonsOfOrder(SMESH::ElementOrder order = SMESH::ORDER_ANY)
throw (SALOME::SALOME_Exception);
CORBA::Long NbVolumes()

7
src/SMESH_I/SMESH_PreMeshInfo.cxx
View File

@ -460,10 +460,7 @@ bool SMESH_PreMeshInfo::readMeshInfo()
{
_isInfoOk = true;
MED::PWrapper aMed = MED::CrWrapper(_medFileName,true);
// if ( aMed->GetVersion() != MED::eV2_2 )
// return false;
MED::PWrapper aMed = MED::CrWrapperR(_medFileName);
MED::PMeshInfo medMeshInfo = aMed->CrMeshInfo(3,3,SMESH_Comment( _meshID ));
// read nb nodes
@ -516,7 +513,7 @@ void SMESH_PreMeshInfo::readGroupInfo()
map< int, vector< SMESH_PreMeshInfo* > > famId2grInfo;
MED::PWrapper aMed = MED::CrWrapper(_medFileName,false);
MED::PWrapper aMed = MED::CrWrapperR(_medFileName);
MED::PMeshInfo medMeshInfo = aMed->CrMeshInfo(3,3,SMESH_Comment( _meshID ));
// read families to fill in famId2grInfo

12
src/SMESH_I/SMESH_DumpPython.cxx → src/SMESH_I/SMESH_PythonDump.cxx
View File

@ -468,7 +468,6 @@ namespace SMESH
return *this;
}
TPythonDump& TPythonDump:: operator<<(SMESH_Gen_i* theArg)
{
myStream << SMESHGenName(); return *this;
@ -484,17 +483,6 @@ namespace SMESH
myStream << theStr; return *this;
}
TPythonDump& TPythonDump::operator<<(SMESH::MED_VERSION theVersion)
{
switch (theVersion) {
case SMESH::MED_V2_1: myStream << "SMESH.MED_V2_1"; break;
case SMESH::MED_V2_2: myStream << "SMESH.MED_V2_2"; break;
default: myStream << theVersion;
}
return *this;
}
TPythonDump& TPythonDump::operator<<(const SMESH::AxisStruct & theAxis)
{
*this << "SMESH.AxisStruct( "

3
src/SMESH_I/SMESH_PythonDump.hxx
View File

@ -200,9 +200,6 @@ namespace SMESH
TPythonDump&
operator<<(SMESH_MeshEditor_i* theArg);
TPythonDump&
operator<<(SMESH::MED_VERSION theArg);
TPythonDump&
operator<<(const SMESH::AxisStruct & theAxis);

103
src/SMESH_SWIG/smeshBuilder.py
View File

@ -84,6 +84,10 @@ import salome
from salome.geom import geomBuilder
import SMESH # This is necessary for back compatibility
import omniORB # back compatibility
SMESH.MED_V2_1 = omniORB.EnumItem("MED_V2_1", 0) # back compatibility
SMESH.MED_V2_2 = omniORB.EnumItem("MED_V2_2", 1) # back compatibility
from SMESH import *
from salome.smesh.smesh_algorithm import Mesh_Algorithm
@ -1839,13 +1843,10 @@ class Mesh(metaclass=MeshMeta):
## Export the mesh in a file in MED format
## allowing to overwrite the file if it exists or add the exported data to its contents
# @param f is the file name
# @param fileName is the file name
# @param auto_groups boolean parameter for creating/not creating
# the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
# the typical use is auto_groups=False.
# @param version MED format version (MED_V2_1 or MED_V2_2,
# the latter meaning any current version). The parameter is
# obsolete since MED_V2_1 is no longer supported.
# @param overwrite boolean parameter for overwriting/not overwriting the file
# @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh
# @param autoDimension if @c True (default), a space dimension of a MED mesh can be either
@ -1861,17 +1862,33 @@ class Mesh(metaclass=MeshMeta):
# - 'f' stands for "_faces _" field;
# - 's' stands for "_solids _" field.
# @ingroup l2_impexp
def ExportMED(self, f, auto_groups=0, version=MED_V2_2,
overwrite=1, meshPart=None, autoDimension=True, fields=[], geomAssocFields=''):
def ExportMED(self, *args, **kwargs):
# process positional arguments
args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
fileName = args[0]
auto_groups = args[1] if len(args) > 1 else False
overwrite = args[2] if len(args) > 2 else True
meshPart = args[3] if len(args) > 3 else None
autoDimension = args[4] if len(args) > 4 else True
fields = args[5] if len(args) > 5 else []
geomAssocFields = args[6] if len(args) > 6 else ''
# process keywords arguments
auto_groups = kwargs.get("auto_groups", auto_groups)
overwrite = kwargs.get("overwrite", overwrite)
meshPart = kwargs.get("meshPart", meshPart)
autoDimension = kwargs.get("autoDimension", autoDimension)
fields = kwargs.get("fields", fields)
geomAssocFields = kwargs.get("geomAssocFields", geomAssocFields)
# invoke engine's function
if meshPart or fields or geomAssocFields:
unRegister = genObjUnRegister()
if isinstance( meshPart, list ):
meshPart = self.GetIDSource( meshPart, SMESH.ALL )
unRegister.set( meshPart )
self.mesh.ExportPartToMED( meshPart, f, auto_groups, version, overwrite, autoDimension,
self.mesh.ExportPartToMED( meshPart, fileName, auto_groups, overwrite, autoDimension,
fields, geomAssocFields)
else:
self.mesh.ExportToMEDX(f, auto_groups, version, overwrite, autoDimension)
self.mesh.ExportMED(fileName, auto_groups, overwrite, autoDimension)
## Export the mesh in a file in SAUV format
# @param f is the file name
@ -1961,10 +1978,7 @@ class Mesh(metaclass=MeshMeta):
## Deprecated, used only for compatibility! Please, use ExportMED() method instead.
# Export the mesh in a file in MED format
# allowing to overwrite the file if it exists or add the exported data to its contents
# @param f the file name
# @param version MED format version (MED_V2_1 or MED_V2_2,
# the latter meaning any current version). The parameter is
# obsolete since MED_V2_1 is no longer supported.
# @param fileName the file name
# @param opt boolean parameter for creating/not creating
# the groups Group_On_All_Nodes, Group_On_All_Faces, ...
# @param overwrite boolean parameter for overwriting/not overwriting the file
@ -1974,8 +1988,49 @@ class Mesh(metaclass=MeshMeta):
# - 3D in the rest cases.<br>
# If @a autoDimension is @c False, the space dimension is always 3.
# @ingroup l2_impexp
def ExportToMED(self, f, version=MED_V2_2, opt=0, overwrite=1, autoDimension=True):
self.mesh.ExportToMEDX(f, opt, version, overwrite, autoDimension)
def ExportToMED(self, *args, **kwargs):
print("WARNING: ExportToMED() is deprecated, use ExportMED() instead")
# process positional arguments
args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
fileName = args[0]
auto_groups = args[1] if len(args) > 1 else False
overwrite = args[2] if len(args) > 2 else True
autoDimension = args[3] if len(args) > 3 else True
# process keywords arguments
auto_groups = kwargs.get("opt", auto_groups) # old keyword name
auto_groups = kwargs.get("auto_groups", auto_groups) # new keyword name
overwrite = kwargs.get("overwrite", overwrite)
autoDimension = kwargs.get("autoDimension", autoDimension)
# invoke engine's function
self.mesh.ExportMED(fileName, auto_groups, overwrite, autoDimension)
## Deprecated, used only for compatibility! Please, use ExportMED() method instead.
# Export the mesh in a file in MED format
# allowing to overwrite the file if it exists or add the exported data to its contents
# @param fileName the file name
# @param opt boolean parameter for creating/not creating
# the groups Group_On_All_Nodes, Group_On_All_Faces, ...
# @param overwrite boolean parameter for overwriting/not overwriting the file
# @param autoDimension if @c True (default), a space dimension of a MED mesh can be either
# - 1D if all mesh nodes lie on OX coordinate axis, or
# - 2D if all mesh nodes lie on XOY coordinate plane, or
# - 3D in the rest cases.<br>
# If @a autoDimension is @c False, the space dimension is always 3.
# @ingroup l2_impexp
def ExportToMEDX(self, *args, **kwargs):
print("WARNING: ExportToMEDX() is deprecated, use ExportMED() instead")
# process positional arguments
args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
fileName = args[0]
auto_groups = args[1] if len(args) > 1 else False
overwrite = args[2] if len(args) > 2 else True
autoDimension = args[3] if len(args) > 3 else True
# process keywords arguments
auto_groups = kwargs.get("auto_groups", auto_groups)
overwrite = kwargs.get("overwrite", overwrite)
autoDimension = kwargs.get("autoDimension", autoDimension)
# invoke engine's function
self.mesh.ExportMED(fileName, auto_groups, overwrite, autoDimension)
# Operations with groups:
# ----------------------
@ -5121,7 +5176,25 @@ class meshProxy(SMESH._objref_SMESH_Mesh):
def CreateDimGroup(self,*args): # 2 args added: nbCommonNodes, underlyingOnly
if len( args ) == 3:
args += SMESH.ALL_NODES, True
return SMESH._objref_SMESH_Mesh.CreateDimGroup( self, *args )
return SMESH._objref_SMESH_Mesh.CreateDimGroup(self, *args)
def ExportToMEDX(self, *args): # function removed
print("WARNING: ExportToMEDX() is deprecated, use ExportMED() instead")
args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
SMESH._objref_SMESH_Mesh.ExportMED(self, *args)
def ExportToMED(self, *args): # function removed
print("WARNING: ExportToMED() is deprecated, use ExportMED() instead")
args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
while len(args) < 4: # !!!! nb of parameters for ExportToMED IDL's method
args.append(True)
SMESH._objref_SMESH_Mesh.ExportMED(self, *args)
def ExportPartToMED(self, *args): # 'version' parameter removed
args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
SMESH._objref_SMESH_Mesh.ExportPartToMED(self, *args)
def ExportMED(self, *args): # signature of method changed
args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
while len(args) < 4: # !!!! nb of parameters for ExportToMED IDL's method
args.append(True)
SMESH._objref_SMESH_Mesh.ExportMED(self, *args)
pass
omniORB.registerObjref(SMESH._objref_SMESH_Mesh._NP_RepositoryId, meshProxy)

4
src/Tools/ZCracksPlug/casTests/genereCube.py
View File

@ -109,7 +109,7 @@ def cube3D(L, N, outFile):
aFilter_1.SetMesh(Maillage_1.GetMesh())
FACE_temp = Maillage_1.GroupOnFilter( SMESH.FACE, noms[cont], aFilter_1 )
Maillage_1.ExportMED( outFile, 0, SMESH.MED_V2_2, 1, None ,1)
Maillage_1.ExportMED(outFile)
#if salome.sg.hasDesktop():
#salome.sg.updateObjBrowser(True)
@ -191,7 +191,7 @@ def cube2D(L, N, outFile):
aFilter_1.SetMesh(Maillage_1.GetMesh())
EDGE_temp = Maillage_1.GroupOnFilter( SMESH.EDGE, noms[cont], aFilter_1 )
Maillage_1.ExportMED( outFile, 0, SMESH.MED_V2_2, 1, None ,1)
Maillage_1.ExportMED(outFile)
#if salome.sg.hasDesktop():
#salome.sg.updateObjBrowser(True)

4
src/Tools/ZCracksPlug/ellipse.py
View File

@ -189,10 +189,10 @@ def generate(data_demi_grand_axe, data_centre, data_normale,
Maillage=uF.meshCrack(FACE_FISSURE, minSize, maxSize, chordal, dim)
try:
Maillage.ExportMED( outFile, 0, SMESH.MED_V2_2, 1, None ,1)
Maillage.ExportMED(outFile)
smesh.SetName(Maillage.GetMesh(), 'MAILLAGE_FISSURE')
except:
print('ExportToMEDX() failed. Invalid file name?')
print('ExportMED() failed. Invalid file name?')
## Set names of Mesh objects

2
src/Tools/ZCracksPlug/genereCrack.py
View File

@ -228,7 +228,7 @@ def generateCustom(crack, outFile):
else:
Group_1 = Maillage_1.CreateEmptyGroup( SMESH.NODE, 'crack' )
nbAdd = Group_1.AddFrom( Maillage_1.GetMesh() )
Maillage_1.ExportMED( outFile, 0, SMESH.MED_V2_2, 1, None ,1)
Maillage_1.ExportMED(outFile)
return(True)

4
src/Tools/ZCracksPlug/rectangle.py
View File

@ -216,10 +216,10 @@ def generate(data_longueur,data_largeur,data_centre,
Maillage=uF.meshCrack(FACE_FISSURE, minSize, maxSize, chordal, dim)
try:
Maillage.ExportMED( outFile, 0, SMESH.MED_V2_2, 1, None ,1)
Maillage.ExportMED(outFile)
smesh.SetName(Maillage.GetMesh(), 'MAILLAGE_FISSURE')
except:
print('ExportToMEDX() failed. Invalid file name?')
print('ExportMED() failed. Invalid file name?')
if salome.sg.hasDesktop():

4
src/Tools/ZCracksPlug/sphere.py
View File

@ -57,10 +57,10 @@ def generate(data_rayon,data_centre,outFile):
Maillage=uF.meshCrack(FACE_FISSURE, minSize, maxSize, chordal, dim=3)
try:
Maillage.ExportMED( outFile, 0, SMESH.MED_V2_2, 1, None ,1)
Maillage.ExportMED(outFile)
smesh.SetName(Maillage.GetMesh(), 'MAILLAGE_FISSURE')
except:
print('ExportToMEDX() failed. Invalid file name?')
print('ExportMED() failed. Invalid file name?')
## Set names of Mesh objects

4
src/Tools/ZCracksPlug/utilityFunctions.py
View File

@ -233,7 +233,7 @@ def extendElsets(meshFile, outFile=None):
if len(front)==0: crackOnly=False
if crackOnly:
mesh.ExportMED(outFile, 0, SMESH.MED_V2_2, 1, None ,1)
mesh.ExportMED(outFile)
return('crack')
# Propagates color using elem connectivity
@ -304,7 +304,7 @@ def extendElsets(meshFile, outFile=None):
mesh.MakeGroupByIds('Extended_side%d' %n ,SMESH.EDGE,grElemList[2][n])
if outFile==None: outFile=meshFile
mesh.ExportMED(outFile, 0, SMESH.MED_V2_2, 1, None ,1)
mesh.ExportMED(outFile)
return(True)

2
src/Tools/blocFissure/exemple2.py
View File

@ -56,7 +56,7 @@ Quadrangle_2D = boite.Quadrangle(algo=smeshBuilder.QUADRANGLE)
Hexa_3D = boite.Hexahedron(algo=smeshBuilder.Hexa)
isDone = boite.Compute()
smesh.SetName(boite, 'boite')
boite.ExportMED( r'boite.med', 0, SMESH.MED_V2_2, 1 )
boite.ExportMED(r'boite.med')
## set object names
smesh.SetName(boite.GetMesh(), 'boite')

2
src/Tools/blocFissure/gmu/construitFissureGenerale.py
View File

@ -328,7 +328,7 @@ def construitFissureGenerale(maillagesSains,
fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
logging.info("export maillage fini")
maillageComplet.ExportMED( fichierMaillageFissure, 0, SMESH.MED_V2_2, 1 )
maillageComplet.ExportMED(fichierMaillageFissure)
putName(maillageComplet, nomFicFissure)
logging.info("fichier maillage fissure %s", fichierMaillageFissure)

2
src/Tools/blocFissure/gmu/creeZoneDefautDansObjetSain.py
View File

@ -57,7 +57,7 @@ def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure,
[origShapes, verticesShapes, dmoyen] = \
creeZoneDefautMaillage(maillagesSains, shapeDefaut, tailleDefaut, nomZones, coordsNoeudsFissure)
maillageSain.ExportMED( fichierMaillageSain, 0, SMESH.MED_V2_2, 1 )
maillageSain.ExportMED(fichierMaillageSain)
logging.debug("fichier maillage sain %s", fichierMaillageSain)
[maillageSain, internalBoundary, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges] = \
peauInterne(fichierMaillageSain, shapeDefaut, nomZones)

2
src/Tools/blocFissure/gmu/insereFissureElliptique.py
View File

@ -189,7 +189,7 @@ def insereFissureElliptique(geometriesSaines, maillagesSains,
if step == 18:
return None
maillageComplet.ExportMED( fichierMaillageFissure, 0, SMESH.MED_V2_2, 1 )
maillageComplet.ExportMED(fichierMaillageFissure)
putName(maillageComplet, nomFicFissure)
logging.info("fichier maillage fissure : %s", fichierMaillageFissure)

2
src/Tools/blocFissure/gmu/insereFissureGenerale.py
View File

@ -1373,7 +1373,7 @@ def insereFissureGenerale(maillagesSains,
fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
logging.info("export maillage fini")
maillageComplet.ExportMED( fichierMaillageFissure, 0, SMESH.MED_V2_2, 1 )
maillageComplet.ExportMED(fichierMaillageFissure)
putName(maillageComplet, nomFicFissure)
logging.info("fichier maillage fissure %s", fichierMaillageFissure)

2
src/Tools/blocFissure/gmu/insereFissureLongue.py
View File

@ -649,7 +649,7 @@ def insereFissureLongue(geometriesSaines, maillagesSains,
#isDone = maillageComplet.ReorientObject( grps[0] )
fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
maillageComplet.ExportMED( fichierMaillageFissure, 0, SMESH.MED_V2_2, 1 )
maillageComplet.ExportMED(fichierMaillageFissure)
putName(maillageComplet, nomFicFissure)
logging.info("fichier maillage fissure %s", fichierMaillageFissure)

2
src/Tools/blocFissure/materielCasTests/cubeAngle.py
View File

@ -63,7 +63,7 @@ Quadrangle_2D = Mesh_1.Quadrangle(algo=smeshBuilder.QUADRANGLE)
Hexa_3D = Mesh_1.Hexahedron(algo=smeshBuilder.Hexa)
isDone = Mesh_1.Compute()
smesh.SetName(Mesh_1, 'Mesh_1')
Mesh_1.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests/CubeAngle.med"), 0, SMESH.MED_V2_2, 1 )
Mesh_1.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests/CubeAngle.med"))
## set object names
smesh.SetName(Mesh_1.GetMesh(), 'Mesh_1')

2
src/Tools/blocFissure/materielCasTests/cubeFin.py
View File

@ -122,7 +122,7 @@ smesh.SetName(ENCASTR_1, 'ENCASTR')
smesh.SetName(cubeFin_1.GetMesh(), 'cubeFin')
smesh.SetName(Nb_Segments_1, 'Nb. Segments_1')
cubeFin_1.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests/cubeFin.med"), 0, SMESH.MED_V2_2, 1 )
cubeFin_1.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests/cubeFin.med"))
if salome.sg.hasDesktop():
salome.sg.updateObjBrowser()

2
src/Tools/blocFissure/materielCasTests/decoupeCylindre.py
View File

@ -144,7 +144,7 @@ Nb_Segments_3 = Regular_1D_2.NumberOfSegments(6,[],[ ])
Nb_Segments_3.SetDistrType( 0 )
isDone = CylindreSain_1.Compute()
smesh.SetName(CylindreSain_1, 'CylindreSain')
CylindreSain_1.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests//CylindreSain.med"), 0, SMESH.MED_V2_2, 1 )
CylindreSain_1.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests//CylindreSain.med"))
SubMesh_1 = Regular_1D_1.GetSubMesh()
SubMesh_2 = Regular_1D_2.GetSubMesh()

2
src/Tools/blocFissure/materielCasTests/disque_perce.py
View File

@ -70,7 +70,7 @@ status = Disque_1.AddHypothesis(Nb_Segments_2,Compound_4)
Quadrangle_2D = Disque_1.Quadrangle(algo=smeshBuilder.QUADRANGLE)
isDone = Disque_1.Compute()
smesh.SetName(Disque_1, 'Disque')
Disque_1.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests/disque.med"), 0, SMESH.MED_V2_2, 1 )
Disque_1.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests/disque.med"))
SubMesh_1 = Regular_1D_1.GetSubMesh()
SubMesh_2 = Regular_1D_2.GetSubMesh()

2
src/Tools/blocFissure/materielCasTests/eprouvetteCourbe.py
View File

@ -87,7 +87,7 @@ Nb_Segments_3 = Regular_1D_2.NumberOfSegments(25)
Nb_Segments_3.SetDistrType( 0 )
isDone = EprouvetteCourbe_1.Compute()
smesh.SetName(EprouvetteCourbe_1, 'EprouvetteCourbe')
EprouvetteCourbe_1.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests/EprouvetteCourbe.med"), 0, SMESH.MED_V2_2, 1 )
EprouvetteCourbe_1.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests/EprouvetteCourbe.med"))
SubMesh_1 = Regular_1D_1.GetSubMesh()
SubMesh_2 = Regular_1D_2.GetSubMesh()

2
src/Tools/blocFissure/materielCasTests/eprouvetteDroite.py
View File

@ -121,7 +121,7 @@ Nb_Segments_3 = Regular_1D_2.NumberOfSegments(10,[],[ ])
Nb_Segments_3.SetDistrType( 0 )
isDone = eprouvetteDroite_1.Compute()
smesh.SetName(eprouvetteDroite_1, 'eprouvetteDroite')
eprouvetteDroite_1.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests/eprouvetteDroite.med"), 0, SMESH.MED_V2_2, 1 )
eprouvetteDroite_1.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests/eprouvetteDroite.med"))
SubMesh_1 = Regular_1D_1.GetSubMesh()
SubMesh_2 = Regular_1D_2.GetSubMesh()

2
src/Tools/blocFissure/materielCasTests/fissureGauche.py
View File

@ -116,7 +116,7 @@ Nb_Segments_3 = Regular_1D_2.NumberOfSegments(5,[],[ ])
Nb_Segments_3.SetDistrType( 0 )
isDone = objetSain_1.Compute()
smesh.SetName(objetSain_1, 'objetSain')
objetSain_1.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests/faceGaucheSain.med"), 0, SMESH.MED_V2_2, 1 )
objetSain_1.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests/faceGaucheSain.med"))
SubMesh_1 = Regular_1D_1.GetSubMesh()
SubMesh_2 = Regular_1D_2.GetSubMesh()

2
src/Tools/blocFissure/materielCasTests/fissureGauche2.py
View File

@ -84,7 +84,7 @@ Quadrangle_2D = Mesh_1.Quadrangle(algo=smeshBuilder.QUADRANGLE)
Hexa_3D = Mesh_1.Hexahedron(algo=smeshBuilder.Hexa)
isDone = Mesh_1.Compute()
smesh.SetName(Mesh_1, 'Mesh_1')
Mesh_1.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests/boiteSaine.med"), 0, SMESH.MED_V2_2, 1 )
Mesh_1.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests/boiteSaine.med"))
## set object names
smesh.SetName(Mesh_1.GetMesh(), 'Mesh_1')

2
src/Tools/blocFissure/materielCasTests/vis.py
View File

@ -192,7 +192,7 @@ visHex80 = smesh.CopyMesh( coupe_vis_1, 'visHex80', 1, 0)
[ tige_2, section_2, tige_haute_2, rond_2, tete_2, section_tete_2, conge_2, appui_2, p_imp_2, tige_rotated, tige_top, section_rotated, section_top, tige_haute_rotated, tige_haute_top, rond_rotated, rond_top, tete_rotated, tete_top, section_tete_rotated, section_tete_top, conge_rotated, conge_top, appui_rotated, appui_top, p_imp_rotated, p_imp_top ] = visHex80.GetGroups()
Sub_mesh_1 = Regular_1D_1.GetSubMesh()
Sub_mesh_2 = Regular_1D_2.GetSubMesh()
visHex80.ExportMED( os.path.join(gmu.pathBloc, "materielCasTests/visSain.med"), 0, SMESH.MED_V2_2, 1 )
visHex80.ExportMED(os.path.join(gmu.pathBloc, "materielCasTests/visSain.med"))
## Set names of Mesh objects

2
src/Tools/padder/spadderpy/gui/plugindialog.py
View File

@ -211,7 +211,7 @@ class PluginDialog(QDialog):
name. This returns the filename.
'''
filename=str("/tmp/padder_inputfile_"+meshName+".med")
meshObject.ExportToMEDX( filename, 0, SMESH.MED_V2_2, 1, 1 )
meshObject.ExportMED(filename, False, True, True)
return filename
def clear(self):