ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-11-11 16:19:16 +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;
}

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

@ -19,24 +19,24 @@
//
// 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
{
//---------------------------------------------------------------
TEntity2TGeom2ElemInfo
GetEntity2TGeom2ElemInfo(const PWrapper& theWrapper,
TEntity2TGeom2ElemInfo
GetEntity2TGeom2ElemInfo(const PWrapper& theWrapper,
const PMeshInfo& theMeshInfo,
const MED::TEntityInfo& theEntityInfo)
{
@ -64,8 +64,7 @@ namespace MED
ADDMSG(MYDEBUG,"\n");
return anEntity2TGeom2ElemInfo;
}
//---------------------------------------------------------------
TFamilyInfoSet
GetFamilyInfoSet(const PWrapper& theWrapper,
@ -85,7 +84,6 @@ namespace MED
return aFamilyInfoSet;
}
//---------------------------------------------------------------
TGroupInfo
GetGroupInfo(const TFamilyInfoSet& theFamilyInfoSet)
@ -98,7 +96,7 @@ namespace MED
TInt aNbGroup = aFamilyInfo->GetNbGroup();
for(TInt iGroup = 0; iGroup < aNbGroup; iGroup++){
aGroup[aFamilyInfo->GetGroupName(iGroup)].insert(aFamilyInfo);
}
}
}
#ifdef _DEBUG_
@ -121,10 +119,9 @@ namespace MED
return aGroup;
}
//---------------------------------------------------------------
TFieldInfo2TimeStampInfoSet
GetFieldInfo2TimeStampInfoSet(const PWrapper& theWrapper,
TFieldInfo2TimeStampInfoSet
GetFieldInfo2TimeStampInfoSet(const PWrapper& theWrapper,
const PMeshInfo& theMeshInfo,
const MED::TEntityInfo& theEntityInfo)
{
@ -141,7 +138,7 @@ namespace MED
TInt aNbTimeStamps = theWrapper->GetNbTimeStamps(aFieldInfo,theEntityInfo,anEntity,aGeom2Size);
ADDMSG(MYDEBUG,"anEntity = "<<anEntity<<"; GetNbTimeStamps = "<<aNbTimeStamps<<"\n");
for(TInt iTimeStamp = 1; iTimeStamp <= aNbTimeStamps; iTimeStamp++){
PTimeStampInfo aTimeStamp =
PTimeStampInfo aTimeStamp =
theWrapper->GetPTimeStampInfo(aFieldInfo,anEntity,aGeom2Size,iTimeStamp);
aFieldInfo2TimeStampInfoSet[aFieldInfo].insert(aTimeStamp);
INITMSG(MYDEBUG,
@ -152,10 +149,9 @@ namespace MED
ADDMSG(MYDEBUG,"\n");
return aFieldInfo2TimeStampInfoSet;
}
//---------------------------------------------------------------
TEntite2TFieldInfo2TimeStampInfoSet
TEntite2TFieldInfo2TimeStampInfoSet
GetEntite2TFieldInfo2TimeStampInfoSet(const TFieldInfo2TimeStampInfoSet& theFieldInfo2TimeStampInfoSet)
{
TEntite2TFieldInfo2TimeStampInfoSet anEntite2TFieldInfo2TimeStampInfoSet;
@ -163,14 +159,13 @@ namespace MED
for(; anIter != theFieldInfo2TimeStampInfoSet.end(); anIter++){
const TTimeStampInfoSet& aTimeStampInfoSet = anIter->second;
//const PFieldInfo& aFieldInfo = anIter->first;
if(aTimeStampInfoSet.empty())
if(aTimeStampInfoSet.empty())
continue;
const PTimeStampInfo& aTimeStampInfo = *aTimeStampInfoSet.begin();
anEntite2TFieldInfo2TimeStampInfoSet[ConvertEntity(aTimeStampInfo->GetEntity())].insert(*anIter);
}
return anEntite2TFieldInfo2TimeStampInfoSet;
}
//---------------------------------------------------------------
bool
@ -181,16 +176,15 @@ namespace MED
return aLeftInfo->GetId() < aRightInfo->GetId();
}
//---------------------------------------------------------------
TEntity2FamilySet
GetEntity2FamilySet(const PWrapper& theWrapper,
TEntity2FamilySet
GetEntity2FamilySet(const PWrapper& theWrapper,
const TEntity2TGeom2ElemInfo& theEntity2TGeom2ElemInfo,
const TFamilyInfoSet& theFamilyInfoSet)
{
MSG(MYDEBUG,"GetFamiliesByEntity(...)");
TEntity2FamilySet anEntity2FamilySet;
typedef std::map<TInt,PFamilyInfo> TId2Family;
TId2Family anId2Family;
TFamilyInfoSet::const_iterator anIter = theFamilyInfoSet.begin();
@ -198,12 +192,12 @@ namespace MED
const PFamilyInfo& aFamilyInfo = *anIter;
anId2Family.insert(TId2Family::value_type(aFamilyInfo->GetId(),aFamilyInfo));
}
if(!anId2Family.empty()){
typedef std::map<TInt,TInt> TFamilyID2Size;
typedef std::map<EEntiteMaillage,TFamilyID2Size> TEntity2FamilyID;
TEntity2FamilyID anEntity2FamilyID;
if(!theEntity2TGeom2ElemInfo.empty()){
TEntity2TGeom2ElemInfo::const_iterator anIter = theEntity2TGeom2ElemInfo.begin();
for(; anIter != theEntity2TGeom2ElemInfo.end(); anIter++){
@ -221,7 +215,7 @@ namespace MED
}
}
}
if(!anEntity2FamilyID.empty()){
TEntity2FamilyID::const_iterator anIter = anEntity2FamilyID.begin();
for(; anIter != anEntity2FamilyID.end(); anIter++){
@ -243,15 +237,14 @@ namespace MED
}
}
}
}
}
ADDMSG(MYDEBUG,"\n");
return anEntity2FamilySet;
}
//---------------------------------------------------------------
TKey2Gauss
GetKey2Gauss(const PWrapper& theWrapper,
GetKey2Gauss(const PWrapper& theWrapper,
TErr* theErr,
EModeSwitch theMode)
{
@ -278,10 +271,9 @@ namespace MED
return aKey2Gauss;
}
//---------------------------------------------------------------
PProfileInfo
GetProfileInfo(const PWrapper& theWrapper,
GetProfileInfo(const PWrapper& theWrapper,
const std::string& theProfileName,
TErr* theErr,
EModeProfil theMode)
@ -296,11 +288,10 @@ namespace MED
}
return anInfo;
}
//---------------------------------------------------------------
TMKey2Profile
GetMKey2Profile(const PWrapper& theWrapper,
GetMKey2Profile(const PWrapper& theWrapper,
TErr* theErr,
EModeProfil theMode)
{
@ -312,7 +303,7 @@ namespace MED
PProfileInfo anInfo = theWrapper->GetPProfileInfo(anId,theMode,theErr);
const std::string& aName = boost::get<0>(aPreInfo);
aKey2Profile[aName] = anInfo;
#ifdef _DEBUG_
INITMSG(MYDEBUG,
"- aName = '"<<aName<<"'"<<
@ -324,14 +315,16 @@ namespace MED
}
ADDMSG(MYVALUEDEBUG, std::endl);
#endif
}
return TMKey2Profile(theMode,aKey2Profile);
}
//---------------------------------------------------------------
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);
}
}

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

@ -19,116 +19,107 @@
//
// 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
GetEntity2TGeom2ElemInfo(const PWrapper& theWrapper,
GetEntity2TGeom2ElemInfo(const PWrapper& theWrapper,
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,
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
GetEntity2FamilySet(const PWrapper& theWrapper,
GetEntity2FamilySet(const PWrapper& theWrapper,
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
GetFieldInfo2TimeStampInfoSet(const PWrapper& theWrapper,
GetFieldInfo2TimeStampInfoSet(const PWrapper& theWrapper,
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
GetKey2Gauss(const PWrapper& theWrapper,
GetKey2Gauss(const PWrapper& theWrapper,
TErr* theErr = NULL,
EModeSwitch theMode = eFULL_INTERLACE);
//---------------------------------------------------------------
//! Get MED PROFILE by its name
MEDWRAPPER_EXPORT
PProfileInfo
GetProfileInfo(const PWrapper& theWrapper,
GetProfileInfo(const PWrapper& theWrapper,
const std::string& theProfileName,
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
GetMKey2Profile(const PWrapper& theWrapper,
GetMKey2Profile(const PWrapper& theWrapper,
TErr* theErr = NULL,
EModeProfil theMode = eCOMPACT);
@ -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;
}
}

132
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,114 +33,65 @@
#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;
#else
typedef int TInt;
#endif
#endif
typedef hid_t TIdt;
typedef herr_t TErr;
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 {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,
ePYRA5=305, ePENTA6=306, eHEXA8=308, eOCTA12=312, eTETRA10=310,
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;
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;
typedef enum {eMAILLE, eFACE, eARETE, eNOEUD, eNOEUD_ELEMENT, eSTRUCT_ELEMENT} EEntiteMaillage;
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;
typedef std::map<EEntiteMaillage,TGeom2Size> TEntityInfo;
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;
struct TMeshInfo;
typedef SharedPtr<TMeshInfo> PMeshInfo;
struct TFamilyInfo;
typedef SharedPtr<TFamilyInfo> PFamilyInfo;
@ -168,10 +121,10 @@ namespace MED{
struct TProfileInfo;
typedef SharedPtr<TProfileInfo> PProfileInfo;
struct TGaussInfo;
typedef SharedPtr<TGaussInfo> PGaussInfo;
class TGrilleInfo;
typedef SharedPtr<TGrilleInfo> PGrilleInfo;
@ -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

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

@ -19,68 +19,67 @@
//
// 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>
TFloat
TFloat
GetCoord(const TCCoordSlice& theCoordSlice)
{
return theCoordSlice[TCoordId];
}
template<>
TFloat
TFloat
GetCoord<eNone>(const TCCoordSlice& theCoordSlice)
{
return 0.0;
}
TGetCoord
aXYZGetCoord[3] = {
&GetCoord<eX>,
&GetCoord<eY>,
&GetCoord<eX>,
&GetCoord<eY>,
&GetCoord<eZ>
};
TGetCoord
aXYGetCoord[3] = {
&GetCoord<eX>,
&GetCoord<eY>,
&GetCoord<eX>,
&GetCoord<eY>,
&GetCoord<eNone>
};
TGetCoord
aYZGetCoord[3] = {
&GetCoord<eNone>,
&GetCoord<eX>,
&GetCoord<eX>,
&GetCoord<eY>
};
TGetCoord
TGetCoord
aXZGetCoord[3] = {
&GetCoord<eX>,
&GetCoord<eX>,
&GetCoord<eNone>,
&GetCoord<eY>
};
TGetCoord
TGetCoord
aXGetCoord[3] = {
&GetCoord<eX>,
&GetCoord<eX>,
&GetCoord<eNone>,
&GetCoord<eNone>
};
TGetCoord
aYGetCoord[3] = {
&GetCoord<eNone>,
&GetCoord<eX>,
&GetCoord<eX>,
&GetCoord<eNone>
};
@ -91,22 +90,20 @@ namespace MED
&GetCoord<eX>
};
//---------------------------------------------------------------
TCoordHelper
::TCoordHelper(TGetCoord* theGetCoord):
myGetCoord(theGetCoord)
{}
TFloat
TFloat
TCoordHelper
::GetCoord(TCCoordSlice& theCoordSlice,
::GetCoord(TCCoordSlice& theCoordSlice,
TInt theCoordId)
{
return (*myGetCoord[theCoordId])(theCoordSlice);
}
//---------------------------------------------------------------
PCoordHelper
GetCoordHelper(PNodeInfo theNodeInfo)

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

@ -19,38 +19,35 @@
//
// 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
{
TGetCoord* myGetCoord;
public:
TCoordHelper(TGetCoord* theGetCoord);
TFloat
GetCoord(TCCoordSlice& theCoordSlice,
TFloat
GetCoord(TCCoordSlice& theCoordSlice,
TInt theCoordId);
};
typedef SharedPtr<TCoordHelper> PCoordHelper;
//---------------------------------------------------------------
MEDWRAPPER_EXPORT
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);
}
}

32
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_FACTORY_EXPORT
PWrapper
CrWrapper(const std::string& theFileName,
bool theDoPreCheckInSeparateProcess = false);
MEDWRAPPER_EXPORT
bool GetMEDVersion( const std::string&, int&, int&, int& );
MEDWRAPPER_FACTORY_EXPORT
PWrapper
CrWrapper(const std::string& theFileName, EVersion theId);
MEDWRAPPER_EXPORT
bool CheckCompatibility( const std::string& );
MEDWRAPPER_EXPORT
PWrapper CrWrapperR( const std::string& );
MEDWRAPPER_EXPORT
PWrapper CrWrapperW( const std::string& );
}
#endif
#endif // MED_Factory_HeaderFile

79
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
@ -99,7 +94,7 @@ namespace MED
const double P1 = 1./1.8;
const double P2 = 1./1.125;
add( -a, P1 );
add( 0, P2 );
add( 0, P2 );
add( a, P1 ); break;
}
case 4: {
@ -107,11 +102,11 @@ namespace MED
const double P1 = 0.652145154862546, P2 = 0.347854845137454 ;
add( a, P1 );
add( -a, P1 );
add( b, P2 );
add( b, P2 );
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;
@ -139,11 +134,11 @@ namespace MED
case 6: { // FPG6
const double P1 = 0.11169079483905, P2 = 0.0549758718227661;
const double a = 0.445948490915965, b = 0.091576213509771;
add( b, b, P2 );
add( b, b, P2 );
add( 1-2*b, b, P2 );
add( b, 1-2*b, P2 );
add( a, 1-2*a, P1 );
add( a, a, P1 );
add( a, a, P1 );
add( 1-2*a, a, P1 ); break;
}
case 7: { // FPG7
@ -151,11 +146,11 @@ namespace MED
const double B = 0.101286507323456;
const double P1 = 0.066197076394253;
const double P2 = 0.062969590272413;
add( 1/3., 1/3., 9/80. );
add( A, A, P1 );
add( 1/3., 1/3., 9/80. );
add( A, A, P1 );
add( 1-2*A, A, P1 );
add( A, 1-2*A, P1 );
add( B, B, P2 );
add( B, B, P2 );
add( 1-2*B, B, P2 );
add( B, 1-2*B, P2 ); break;
}
@ -167,10 +162,10 @@ namespace MED
const double P1 = 0.025422453185103;
const double P2 = 0.058393137863189;
const double P3 = 0.041425537809187;
add( A, A, P1 );
add( A, A, P1 );
add( 1-2*A, A, P1 );
add( A, 1-2*A, P1 );
add( B, B, P2 );
add( B, B, P2 );
add( 1-2*B, B, P2 );
add( B, 1-2*B, P2 );
add( C, D, P3 );
@ -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);
}
}
@ -200,15 +195,15 @@ namespace MED
case 6: {
const double P1 = 0.11169079483905, P2 = 0.0549758718227661;
const double A = 0.445948490915965, B = 0.091576213509771;
add( 2*B-1, 1-4*B, 4*P2 );
add( 2*B-1, 1-4*B, 4*P2 );
add( 2*B-1, 2*B-1, 4*P2 );
add( 1-4*B, 2*B-1, 4*P2 );
add( 1-4*A, 2*A-1, 4*P1 );
add( 2*A-1, 1-4*A, 4*P1 );
add( 2*A-1, 1-4*A, 4*P1 );
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;
@ -399,12 +394,12 @@ namespace MED
add( 0., 0., h3, p3 ); break;
}
case 27: { // FPG27
const double a1 = 0.788073483;
const double b6 = 0.499369002;
const double b1 = 0.848418011;
const double c8 = 0.478508449;
const double c1 = 0.652816472;
const double d12 = 0.032303742;
const double a1 = 0.788073483;
const double b6 = 0.499369002;
const double b1 = 0.848418011;
const double c8 = 0.478508449;
const double c1 = 0.652816472;
const double d12 = 0.032303742;
const double d1 = 1.106412899;
double z = 1/2., fz = b1/2*(1 - z);
add( 0., 0., z, a1 ); // 1
@ -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");
}
}

14
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
*/
@ -46,9 +44,9 @@ namespace MED
* \param geomType - element geometry (EGeometrieElement or med_geometrie_element)
* \param nbPoints - nb gauss point
* \param variant - [1-3] to choose the variant of definition
*
*
* Throws in case of invalid parameters
* variant == 1 refers to "Fonctions de forme et points d'integration
* variant == 1 refers to "Fonctions de forme et points d'integration
* des elements finis" v7.4 by J. PELLET, X. DESROCHES, 15/09/05
* variant == 2 refers to the same doc v6.4 by J.P. LEFEBVRE, X. DESROCHES, 03/07/03
* variant == 3 refers to the same doc v6.4, second variant for 2D elements
@ -66,4 +64,4 @@ namespace MED
};
}
#endif
#endif // MED_GaussDef_HeaderFile

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

@ -19,19 +19,18 @@
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "MED_GaussUtils.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
//#define _DEBUG_REF_COORDS_
namespace MED
{
//---------------------------------------------------------------
@ -63,28 +62,27 @@ namespace MED
myGaussCoord.resize(theNbElem*myGaussStep);
}
TInt
TGaussCoord
::GetNbElem() const
{
return myNbElem;
{
return myNbElem;
}
TInt
TGaussCoord
::GetNbGauss() const
{
return myNbGauss;
{
return myNbGauss;
}
TInt
TGaussCoord
::GetDim() const
{
return myDim;
{
return myDim;
}
unsigned char*
TGaussCoord
::GetValuePtr()
@ -92,8 +90,7 @@ namespace MED
return (unsigned char*)&(myGaussCoord[0]);
}
TCCoordSliceArr
TCCoordSliceArr
TGaussCoord
::GetCoordSliceArr(TInt theElemId) const
{
@ -115,8 +112,7 @@ namespace MED
return aCoordSliceArr;
}
TCoordSliceArr
TCoordSliceArr
TGaussCoord
::GetCoordSliceArr(TInt theElemId)
{
@ -138,10 +134,9 @@ namespace MED
return aCoordSliceArr;
}
//---------------------------------------------------------------
inline
bool
bool
IsEqual(TFloat theLeft, TFloat theRight)
{
static TFloat EPS = 1.0E-3;
@ -150,7 +145,6 @@ namespace MED
return true;
}
//---------------------------------------------------------------
class TShapeFun::TFun
{
@ -167,7 +161,7 @@ namespace MED
myNbRef = theNbRef;
}
TCFloatVecSlice
TCFloatVecSlice
GetFunSlice(TInt theGaussId) const
{
return TCFloatVecSlice(myFun,std::slice(theGaussId*myNbRef,myNbRef,1));
@ -188,7 +182,7 @@ namespace MED
myNbRef(theNbRef)
{}
TCCoordSlice
TCCoordSlice
TShapeFun::GetCoord(TInt theRefId) const
{
return TCCoordSlice(myRefCoord,std::slice(theRefId*myDim,myDim,1));
@ -200,7 +194,7 @@ namespace MED
return TCoordSlice(myRefCoord,std::slice(theRefId*myDim,myDim,1));
}
void
void
TShapeFun::GetFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const
@ -210,7 +204,7 @@ namespace MED
theFun.Init(aNbGauss,aNbRef);
}
bool
bool
TShapeFun::IsSatisfy(const TCCoordSliceArr& theRefCoord) const
{
TInt aNbRef = theRefCoord.size();
@ -302,7 +296,7 @@ namespace MED
TCFloatVecSlice aFunSlice = aFun.GetFunSlice(aGaussId);
for(TInt aConnId = 0; aConnId < aConnDim; aConnId++){
TInt aNodeId = aConnSlice[aConnId] - 1;
TInt aNodeId = aConnSlice[aConnId] - 1;
TCCoordSlice aNodeCoordSlice = theNodeInfo.GetCoordSlice(aNodeId);
for(TInt aDimId = 0; aDimId < aDim; aDimId++){
@ -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)
@ -1601,7 +1543,7 @@ namespace MED
TInt aNbRef = myRefCoord.size();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
switch(aRefId){
case 0: aCoord[0] = 1.0; aCoord[1] = 0.0; aCoord[2] = 0.0; break;
case 3: aCoord[0] = 0.0; aCoord[1] = 1.0; aCoord[2] = 0.0; break;
case 2: aCoord[0] = -1.0; aCoord[1] = 0.0; aCoord[2] = 0.0; break;
@ -1617,7 +1559,7 @@ namespace MED
TFun& theFun) const
{
GetFun(theRef,theGauss,theFun);
TInt aNbGauss = theGauss.size();
for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
const TCCoordSlice& aCoord = theGauss[aGaussId];
@ -1637,8 +1579,6 @@ namespace MED
aSlice[4] = aCoord[2];
}
}
//---------------------------------------------------------------
TPyra13a::TPyra13a():
@ -1709,8 +1649,6 @@ namespace MED
}
}
//---------------------------------------------------------------
TPyra13b::TPyra13b():
TShapeFun(3,13)
@ -1780,11 +1718,9 @@ namespace MED
}
}
//---------------------------------------------------------------
bool
GetGaussCoord3D(const TGaussInfo& theGaussInfo,
GetGaussCoord3D(const TGaussInfo& theGaussInfo,
const TCellInfo& theCellInfo,
const TNodeInfo& theNodeInfo,
TGaussCoord& theGaussCoord,
@ -1966,7 +1902,7 @@ namespace MED
break;
}
default:
default:
INITMSG(MYDEBUG,"eNONE"<<std::endl);
return false;
}
@ -2015,7 +1951,7 @@ namespace MED
TCoordSlice& aGaussCoordSlice = aCoordSliceArr[aGaussId];
for(TInt aConnId = 0; aConnId < aConnDim; aConnId++){
TInt aNodeId = aConnSlice[aConnId] - 1;
TInt aNodeId = aConnSlice[aConnId] - 1;
TCCoordSlice aNodeCoordSlice = theNodeInfo.GetCoordSlice(aNodeId);
for(TInt aDimId = 0; aDimId < aDim; aDimId++){
@ -2048,7 +1984,6 @@ namespace MED
return true;
}
//---------------------------------------------------------------
bool
GetBaryCenter(const TPolygoneInfo& thePolygoneInfo,
@ -2090,7 +2025,7 @@ namespace MED
TCoordSlice& aGaussCoordSlice = aCoordSliceArr[aGaussId];
for(TInt aConnId = 0; aConnId < aNbConn; aConnId++){
TInt aNodeId = aConnSlice[aConnId] - 1;
TInt aNodeId = aConnSlice[aConnId] - 1;
TCCoordSlice aNodeCoordSlice = theNodeInfo.GetCoordSlice(aNodeId);
for(TInt aDimId = 0; aDimId < aDim; aDimId++){
@ -2107,7 +2042,6 @@ namespace MED
return true;
}
//---------------------------------------------------------------
bool
GetBaryCenter(const TPolyedreInfo& thePolyedreInfo,
@ -2153,7 +2087,7 @@ namespace MED
TCConnSlice aConnSlice = aConnSliceArr[aFaceId];
TInt aNbConn = aConnSlice.size();
for(TInt aConnId = 0; aConnId < aNbConn; aConnId++){
TInt aNodeId = aConnSlice[aConnId] - 1;
TInt aNodeId = aConnSlice[aConnId] - 1;
TCCoordSlice aNodeCoordSlice = theNodeInfo.GetCoordSlice(aNodeId);
for(TInt aDimId = 0; aDimId < aDim; aDimId++){

29
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
@ -34,7 +34,7 @@ namespace MED
//! Define a helper class to handle Gauss Points coordinates
class MEDWRAPPER_EXPORT TGaussCoord:
virtual TModeSwitchInfo
virtual TModeSwitchInfo
{
TInt myNbElem;
TInt myNbGauss;
@ -45,7 +45,7 @@ namespace MED
TNodeCoord myGaussCoord;
public:
TGaussCoord();
//! To init the class
@ -72,27 +72,25 @@ namespace MED
GetCoordSliceArr(TInt theElemId) const;
//! Get slice of the coordinate that corresponds to defined cell
TCoordSliceArr
TCoordSliceArr
GetCoordSliceArr(TInt theElemId);
};
typedef SharedPtr<TGaussCoord> PGaussCoord;
//---------------------------------------------------------------
//! To calculate Gauss Points coordinates
MEDWRAPPER_EXPORT
MEDWRAPPER_EXPORT
bool
GetGaussCoord3D(const TGaussInfo& theGaussInfo,
GetGaussCoord3D(const TGaussInfo& theGaussInfo,
const TCellInfo& theCellInfo,
const TNodeInfo& theNodeInfo,
TGaussCoord& theGaussCoord,
const TElemNum& theElemNum = TElemNum(),
EModeSwitch theMode = eFULL_INTERLACE);
//---------------------------------------------------------------
//! To calculate Gauss Points coordinates for defined TCellInfo as its bary center
MEDWRAPPER_EXPORT
MEDWRAPPER_EXPORT
bool
GetBaryCenter(const TCellInfo& theCellInfo,
const TNodeInfo& theNodeInfo,
@ -101,7 +99,7 @@ namespace MED
EModeSwitch theMode = eFULL_INTERLACE);
//! To calculate Gauss Points coordinates for defined TPolygoneInfo as its bary center
MEDWRAPPER_EXPORT
MEDWRAPPER_EXPORT
bool
GetBaryCenter(const TPolygoneInfo& thePolygoneInfo,
const TNodeInfo& theNodeInfo,
@ -110,7 +108,7 @@ namespace MED
EModeSwitch theMode = eFULL_INTERLACE);
//! To calculate Gauss Points coordinates for defined TPolyedreInfo as its bary center
MEDWRAPPER_EXPORT
MEDWRAPPER_EXPORT
bool
GetBaryCenter(const TPolyedreInfo& thePolyedreInfo,
const TNodeInfo& theNodeInfo,
@ -124,7 +122,7 @@ namespace MED
struct MEDWRAPPER_EXPORT TShapeFun
{
class TFun;
TFloatVector myRefCoord;
TInt myDim;
TInt myNbRef;
@ -140,7 +138,7 @@ namespace MED
void GetFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
virtual
virtual
void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const = 0;
@ -359,7 +357,6 @@ namespace MED
TFun& theFun) const;
};
//---------------------------------------------------------------
}
#endif
#endif // MED_GaussUtils_HeaderFile

30
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,11 +27,10 @@
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.
This class was introduced to provide correct and flexible memory management
This class was introduced to provide correct and flexible memory management
for all of the MEDWrapper objects.
*/
template<class T> class SharedPtr: public boost::shared_ptr<T>
@ -41,8 +41,8 @@ namespace MED
//! Construct the class by any type of a pointer
template<class Y>
explicit SharedPtr(Y * p):
boost::shared_ptr<T>(p)
explicit SharedPtr(Y * p):
boost::shared_ptr<T>(p)
{}
//! Construct the class by any specialisation of the class
@ -53,7 +53,7 @@ namespace MED
//! Copy-constructor
template<class Y>
SharedPtr&
SharedPtr&
operator=(SharedPtr<Y> const & r)
{
SharedPtr<T>(r).swap(*this);
@ -61,35 +61,33 @@ namespace MED
}
//! Introduce a flexible way to reset the wrapped pointer
template<class Y>
SharedPtr&
template<class Y>
SharedPtr&
operator()(Y * p) // Y must be complete
{
return operator=<Y>(SharedPtr<Y>(p));
}
//! Introduce a flexible way to reset the wrapped pointer
template<class Y>
SharedPtr&
template<class Y>
SharedPtr&
operator()(SharedPtr<Y> const & r) // Y must be complete
{
return operator=<Y>(SharedPtr<Y>(r));
}
//! To provide a flexible way to use reference to the wrapped pointer (const version)
operator const T& () const
{
operator const T& () const
{
return *(this->get());
}
//! To provide a flexible way to use reference to the wrapped pointer
operator T& ()
{
operator T& ()
{
return *(this->get());
}
};
}
#endif
#endif // MED_SharedPtr_HeaderFile

47
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
@ -38,12 +39,12 @@ namespace MED
{
//---------------------------------------------------------------
//! This class intends to provide a uniform way to handle multidimensional data (const version)
/*!
/*!
It just contains a pointer to real sequence and implement proper calculation of its indexes.
This class deals with constant pointer to the sources data and provides const method to
read them (data).
*/
template<class TValueType>
template<class TValueType>
class TCSlice
{
const TValueType* myCValuePtr; //!< Reference to source multidimensional data
@ -69,7 +70,7 @@ namespace MED
{
return mySlice.start() + theId*mySlice.stride();
}
size_t
get_id(size_t theId) const
{
@ -78,7 +79,7 @@ namespace MED
#endif
return calculate_id(theId);
}
size_t
get_id_at(size_t theId) const
{
@ -92,38 +93,38 @@ namespace MED
//! Construct the class from bare pointer
TCSlice(const value_type* theValuePtr,
size_t theSourceSize,
const std::slice& theSlice):
const std::slice& theSlice):
myCValuePtr(theValuePtr),
mySourceSize(theSourceSize),
mySlice(theSlice)
{}
//! Construct the class from corresponding container
TCSlice(const TVector<value_type>& theContainer,
const std::slice& theSlice):
const std::slice& theSlice):
myCValuePtr(&theContainer[0]),
mySourceSize(theContainer.size()),
mySlice(theSlice)
{}
//! Default constructor (dangerous)
TCSlice():
myCValuePtr(NULL)
{}
//! Get element by its number (const version)
const value_type&
const value_type&
operator[](size_t theId) const
{
return *(myCValuePtr + get_id(theId));
}
const value_type&
const value_type&
at(size_t theId) const
{
return *(myCValuePtr + get_id_at(theId));
}
//! Get range of the order numbers
size_t
size() const
@ -131,15 +132,14 @@ namespace MED
return mySlice.size();
}
};
//---------------------------------------------------------------
//! This class extends TCSlice functionality for non-constant case
template<class TValueType>
template<class TValueType>
class TSlice: public TCSlice<TValueType>
{
TValueType* myValuePtr;
public:
typedef TValueType value_type;
typedef TCSlice<TValueType> TSupperClass;
@ -147,39 +147,38 @@ namespace MED
//! Construct the class from bare pointer
TSlice(value_type* theValuePtr,
size_t theSourceSize,
const std::slice& theSlice):
const std::slice& theSlice):
TSupperClass(theValuePtr, theSourceSize, theSlice),
myValuePtr(theValuePtr)
{}
//! Construct the class from corresponding container
TSlice(TVector<value_type>& theContainer,
const std::slice& theSlice):
const std::slice& theSlice):
TSupperClass(theContainer, theSlice),
myValuePtr(&theContainer[0])
{}
//! Default constructor (dangerous)
TSlice():
myValuePtr(NULL)
{}
//! Get element by its number
value_type&
value_type&
operator[](size_t theId)
{
return *(myValuePtr + this->get_id(theId));
}
value_type&
value_type&
at(size_t theId)
{
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;
}
}

337
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,40 +36,44 @@
namespace MED
{
//---------------------------------------------------------------
//! Defines a type for managing sequence of strings
typedef TVector<char> TString;
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,
std::string
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);
//---------------------------------------------------------------
//! 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 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);
//---------------------------------------------------------------
//! Define a parent class for all MEDWrapper classes
struct MEDWRAPPER_EXPORT TBase
{
virtual ~TBase() {}
virtual ~TBase() {}
};
//---------------------------------------------------------------
//! Define a parent class for all named MED entities
struct MEDWRAPPER_EXPORT TNameInfo: virtual TBase
@ -76,11 +84,10 @@ 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
/*!
It defines through corresponding enumeration (EModeSwitch) how the sequence
It defines through corresponding enumeration (EModeSwitch) how the sequence
should be interpreted in C or Fortran mode (eFULL_INTERLACE or eNON_INTERLACE).
*/
struct MEDWRAPPER_EXPORT TModeSwitchInfo: virtual TBase
@ -95,67 +102,62 @@ 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;
TString myGroupNames;
//! Gets name of a bound MED GROUP by its number
virtual std::string GetGroupName(TInt theId) const = 0;
//! Sets name of the defined MED GROUP by its number
virtual void SetGroupName(TInt theId, const std::string& theValue) = 0;
TInt myNbAttr; //!< Defines number of the MED Family attributes
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;
TFamAttr myAttrId;
//! Get MED FAMILY attribute by its number
TInt GetAttrId(TInt theId) const;
//! Set MED FAMILY attribute by its number
@ -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;
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,22 +230,19 @@ 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:
struct MEDWRAPPER_EXPORT TNodeInfo:
virtual TElemInfo,
virtual TModeSwitchInfo
virtual TModeSwitchInfo
{
PNodeCoord myCoord; //!< Contains all nodal coordinates
@ -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,27 +270,27 @@ 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:
struct MEDWRAPPER_EXPORT TCellInfo:
virtual TElemInfo,
virtual TModeSwitchInfo
virtual TModeSwitchInfo
{
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
@ -306,23 +304,23 @@ namespace MED
//---------------------------------------------------------------
//! Define a base class which represents MED Polygon entity
struct MEDWRAPPER_EXPORT TPolygoneInfo:
struct MEDWRAPPER_EXPORT TPolygoneInfo:
virtual TElemInfo
{
//! 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,12 +336,12 @@ 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
//
struct MEDWRAPPER_EXPORT TBallInfo:
/*!
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
{
TFloatVector myDiameters;
@ -353,24 +351,25 @@ namespace MED
typedef TVector<TCConnSlice> TCConnSliceArr;
typedef TVector<TConnSlice> TConnSliceArr;
//---------------------------------------------------------------
//! Define a base class which represents MED Polyedre entity
struct MEDWRAPPER_EXPORT TPolyedreInfo:
struct MEDWRAPPER_EXPORT TPolyedreInfo:
virtual TElemInfo
{
//! 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
@ -389,28 +388,28 @@ namespace MED
//---------------------------------------------------------------
//! Define a base class which represents MED Field entity
struct MEDWRAPPER_EXPORT TFieldInfo:
struct MEDWRAPPER_EXPORT TFieldInfo:
virtual TNameInfo
{
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,27 +422,28 @@ 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:
struct MEDWRAPPER_EXPORT TGaussInfo:
virtual TNameInfo,
virtual TModeSwitchInfo
virtual TModeSwitchInfo
{
typedef boost::tuple<EGeometrieElement,std::string> TKey;
typedef boost::tuple<TKey,TInt> TInfo;
@ -457,12 +457,12 @@ namespace MED
};
//! Defines, which geometrical type the MED Gauss entity belongs to
EGeometrieElement myGeom;
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;
TNodeCoord myRefCoord;
//! Gives coordinates for the referenced node by its number
TCCoordSlice GetRefCoordSlice(TInt theId) const;
@ -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:
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
@ -536,11 +536,10 @@ namespace MED
//! Set unit of time for the MED TimeStamp
virtual void SetUnitDt(const std::string& theValue) = 0;
};
//---------------------------------------------------------------
//! The class represents MED Profile entity
struct MEDWRAPPER_EXPORT TProfileInfo:
struct MEDWRAPPER_EXPORT TProfileInfo:
virtual TNameInfo
{
typedef std::string TKey;
@ -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,17 +558,16 @@ 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:
virtual TModeSwitchInfo
virtual TModeSwitchInfo
{
TInt myNbElem;
TInt myNbComp;
@ -588,19 +586,19 @@ namespace MED
//! Returns size of the value container
size_t
GetSize() const;
//! Returns MED interpetation of the value size
size_t
GetNbVal() const;
//! Returns number of Gauss Points bounded with the value
size_t
GetNbGauss() const;
//! Returns step inside of the data array
size_t
GetStep() const;
//! Returns bare pointer on the internal value representation
virtual
unsigned char*
@ -611,17 +609,17 @@ namespace MED
//! The class is a helper one. It provide safe and flexible way to get access to values for a MED TimeStamp
template<class TValueType>
struct TTMeshValue:
virtual TMeshValueBase
virtual TMeshValueBase
{
typedef TValueType TValue;
typedef typename TValueType::value_type TElement;
typedef TSlice<TElement> TValueSlice;
typedef TCSlice<TElement> TCValueSlice;
typedef TVector<TCValueSlice> TCValueSliceArr;
typedef TVector<TValueSlice> TValueSliceArr;
TValue myValue;
//! Initialize the class
@ -682,7 +680,7 @@ namespace MED
}
//! Iteration through Gauss Points by their components
TValueSliceArr
TValueSliceArr
GetGaussValueSliceArr(TInt theElemId)
{
TValueSliceArr aValueSliceArr(myNbGauss);
@ -726,7 +724,7 @@ namespace MED
}
//! Iteration through components by corresponding Gauss Points
TValueSliceArr
TValueSliceArr
GetCompValueSliceArr(TInt theElemId)
{
if(GetModeSwitch() == eFULL_INTERLACE){
@ -750,18 +748,19 @@ 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;
typedef TVector<TCValueSlice> TCValueSliceArr;
typedef TVector<TValueSlice> TValueSliceArr;
typedef TFloatMeshValue TMeshValue;
typedef std::map<EGeometrieElement,TMeshValue> TGeom2Value;
@ -769,61 +768,61 @@ 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
struct MEDWRAPPER_EXPORT TTimeStampValueBase:
virtual TModeSwitchInfo
{
//! 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
virtual
ETypeChamp
GetTypeChamp() const = 0;
//! Allocates values for the given geometry
virtual
virtual
void
AllocateValue(EGeometrieElement theGeom,
TInt theNbElem,
TInt theNbGauss,
TInt theNbComp,
EModeSwitch theMode = eFULL_INTERLACE) = 0;
virtual
virtual
size_t
GetValueSize(EGeometrieElement theGeom) const = 0;
virtual
virtual
size_t
GetNbVal(EGeometrieElement theGeom) const = 0;
virtual
virtual
size_t
GetNbGauss(EGeometrieElement theGeom) const = 0;
virtual
virtual
unsigned char*
GetValuePtr(EGeometrieElement theGeom) = 0;
};
//---------------------------------------------------------------
//! The class implements a container for MED TimeStamp values
template<class TMeshValueType>
struct TTimeStampValue:
virtual TTimeStampValueBase
struct TTimeStampValue:
virtual TTimeStampValueBase
{
typedef TMeshValueType TTMeshValue;
typedef SharedPtr<TMeshValueType> PTMeshValue;
@ -833,7 +832,7 @@ namespace MED
ETypeChamp myTypeChamp; //<! Keeps type of the champ
//! Gets type of the champ
virtual
virtual
ETypeChamp
GetTypeChamp() const
{
@ -843,14 +842,14 @@ namespace MED
//! Keeps map of MED TimeStamp values per geometric type (const version)
TTGeom2Value myGeom2Value;
const TTGeom2Value&
const TTGeom2Value&
GetGeom2Value() const
{
return myGeom2Value;
}
//! Gets MED TimeStamp values for the given geometric type (const version)
const PTMeshValue&
const PTMeshValue&
GetMeshValuePtr(EGeometrieElement theGeom) const
{
typename TTGeom2Value::const_iterator anIter = myGeom2Value.find(theGeom);
@ -860,7 +859,7 @@ namespace MED
}
//! Gets MED TimeStamp values for the given geometric type
PTMeshValue&
PTMeshValue&
GetMeshValuePtr(EGeometrieElement theGeom)
{
myGeomSet.insert(theGeom);
@ -872,21 +871,20 @@ namespace MED
}
//! Gets MED TimeStamp values for the given geometric type (const version)
const TTMeshValue&
const TTMeshValue&
GetMeshValue(EGeometrieElement theGeom) const
{
return *(this->GetMeshValuePtr(theGeom));
}
//! Gets MED TimeStamp values for the given geometric type
TTMeshValue&
TTMeshValue&
GetMeshValue(EGeometrieElement theGeom)
{
return *(this->GetMeshValuePtr(theGeom));
}
};
//---------------------------------------------------------------
typedef TTimeStampValue<TFloatMeshValue> TFloatTimeStampValue;
typedef SharedPtr<TFloatTimeStampValue> PFloatTimeStampValue;
@ -896,11 +894,10 @@ namespace MED
typedef TTimeStampValue<TIntMeshValue> TIntTimeStampValue;
typedef SharedPtr<TIntTimeStampValue> PIntTimeStampValue;
PIntTimeStampValue MEDWRAPPER_EXPORT
CastToIntTimeStampValue(const PTimeStampValueBase& theTimeStampValue);
//---------------------------------------------------------------
template<class TMeshValueTypeFrom, class TMeshValueTypeTo>
void
@ -917,8 +914,8 @@ namespace MED
const EGeometrieElement& aGeom = anIter->first;
const typename TimeStampValueTypeFrom::TTMeshValue& aMeshValue = *anIter->second;
typename TimeStampValueTypeTo::TTMeshValue& aMeshValue2 = theTimeStampValueTo->GetMeshValue(aGeom);
aMeshValue2.Allocate(aMeshValue.myNbElem,
aMeshValue.myNbGauss,
aMeshValue2.Allocate(aMeshValue.myNbElem,
aMeshValue.myNbGauss,
aMeshValue.myNbComp,
aMeshValue.myModeSwitch);
const typename TimeStampValueTypeFrom::TTMeshValue::TValue& aValue = aMeshValue.myValue;
@ -929,6 +926,7 @@ namespace MED
}
}
//---------------------------------------------------------------
template<class TMeshValueType>
void
CopyTimeStampValue(SharedPtr<TTimeStampValue<TMeshValueType> > theTimeStampValueFrom,
@ -948,7 +946,7 @@ namespace MED
//---------------------------------------------------------------
inline
void
CopyTimeStampValueBase(const PTimeStampValueBase& theValueFrom,
CopyTimeStampValueBase(const PTimeStampValueBase& theValueFrom,
const PTimeStampValueBase& theValueTo)
{
if(theValueFrom->GetTypeChamp() == theValueTo->GetTypeChamp()){
@ -964,23 +962,22 @@ namespace MED
}
}
//---------------------------------------------------------------
// Backward compatibility declarations
// Backward compatibility declarations
typedef TFloatTimeStampValue TTimeStampVal;
typedef PFloatTimeStampValue PTimeStampVal;
//---------------------------------------------------------------
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)
@ -1026,7 +1020,7 @@ namespace MED
TFloatVector& GetIndexes(TInt theAxisNumber);
//!Gets a number of indices per axe
TInt GetNbIndexes(TInt theAxisNumber);
TInt GetNbNodes();//! Return count of all points
TInt GetNbCells();//! Return count of all cells
TInt GetNbSubCells();//! Return count of all entities of <mesh dimension-1>
@ -1045,37 +1039,34 @@ namespace MED
TIntVector GetGrilleStructure();
//!Sets the grille structure of theAxis axe to theNb.
void SetGrilleStructure(TInt theAxis,TInt theNb);
/*!
*Defines sequence MED Family indexes for corresponding mesh entites
*/
TElemNum myFamNum;
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);
/*!
*Defines sequence MED Family indexes for sub entites
*/
TElemNum myFamSubNum;
TElemNum myFamSubNum;
//! Get number of a MED FAMILY by order number of sub element
TInt GetFamSubNum(TInt theId) const;
//! Set number of a MED FAMILY for theId-th sub element
void SetFamSubNum(TInt theId, TInt theVal);
/*!
*Defines sequence MED Family indexes for corresponding mesh nodes
*/
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 "";
}

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

@ -19,18 +19,18 @@
//
// 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>
#include <iostream>
#include <sstream>
#include <string>
#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

15
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,8 +32,7 @@
namespace MED
{
//! Main purpose to introduce the class was to customize operator []
//! 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>
{
@ -68,15 +68,15 @@ namespace MED
public:
explicit
TVector(const allocator_type& __a = allocator_type()):
superclass(__a)
TVector(const allocator_type& __a = allocator_type()):
superclass(__a)
{}
TVector(size_type __n, const value_type& __val,
const allocator_type& __a = allocator_type()):
superclass(__n, __val, __a)
{}
explicit
TVector(size_type __n):
superclass(__n)
@ -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):