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

CoTech decision: move MEDWrapper from MED to SMESH

Browse Source 
+	MEDWrapper \
This commit is contained in:
eap 2013-06-24 10:06:18 +00:00
parent b9d6d0aef9
commit 7ec258416f
44 changed files with 14713 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
src/DriverMED/DriverMED.hxx Normal file
View File

@ -0,0 +1,28 @@
// Copyright (C) 2007-2013 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.
//
// 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
//
// Declarations needed for usage of DriverMED
#include <boost/shared_ptr.hpp>
class DriverMED_Family;
typedef boost::shared_ptr<DriverMED_Family> DriverMED_FamilyPtr;

4
src/DriverMED/DriverMED_Family.h
View File

@ -24,12 +24,12 @@
// File : DriverMED_Family.hxx
// Author : Julia DOROVSKIKH
// Module : SMESH
// $Header$
//
#ifndef _INCLUDE_DRIVERMED_FAMILY
#define _INCLUDE_DRIVERMED_FAMILY
#include "SMESH_DriverMED.hxx"
#include "DriverMED.hxx"
#include "SMDS_Mesh.hxx"
#include "SMESHDS_GroupBase.hxx"
@ -49,8 +49,6 @@
#define REST_BALL_FAMILY -5
#define FIRST_ELEM_FAMILY -6
class DriverMED_Family;
typedef boost::shared_ptr<DriverMED_Family> DriverMED_FamilyPtr;
typedef std::list<DriverMED_FamilyPtr > DriverMED_FamilyPtrList;
typedef std::map<int,SMESHDS_SubMesh* > SMESHDS_SubMeshPtrMap;
typedef std::list<SMESHDS_GroupBase* > SMESHDS_GroupBasePtrList;

52
src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx
View File

@ -52,6 +52,26 @@ static int MYDEBUG = 0;
using namespace MED;
using namespace std;
typedef std::map<int, DriverMED_FamilyPtr> TID2FamilyMap;
namespace DriverMED
{
bool buildMeshGrille(const MED::PWrapper& theWrapper,
const MED::PMeshInfo& theMeshInfo,
SMESHDS_Mesh* theMesh,
const TID2FamilyMap& myFamilies);
/*!
* \brief Ensure aFamily has a required ID
* \param aFamily - a family to check
* \param anID - an ID aFamily should have
* \param myFamilies - a map of the family ID to the Family
* \retval bool - true if successful
*/
bool checkFamilyID(DriverMED_FamilyPtr & aFamily,
int anID,
const TID2FamilyMap& myFamilies);
}
void
DriverMED_R_SMESHDS_Mesh
::SetMeshName(string theMeshName)
@ -135,7 +155,7 @@ DriverMED_R_SMESHDS_Mesh
}
if (aMeshInfo->GetType() == MED::eSTRUCTURE){
/*bool aRes = */buildMeshGrille(aMed,aMeshInfo);
/*bool aRes = */DriverMED::buildMeshGrille(aMed,aMeshInfo,myMesh,myFamilies);
continue;
}
@ -169,7 +189,7 @@ DriverMED_R_SMESHDS_Mesh
// Save reference to this node from its family
TInt aFamNum = aNodeInfo->GetFamNum(iElem);
if ( checkFamilyID ( aFamily, aFamNum ))
if ( DriverMED::checkFamilyID ( aFamily, aFamNum, myFamilies ))
{
aFamily->AddElement(aNode);
aFamily->SetType(SMDSAbs_Node);
@ -257,7 +277,7 @@ DriverMED_R_SMESHDS_Mesh
// Save reference to this element from its family
TInt aFamNum = aBallInfo->GetFamNum(iBall);
if ( checkFamilyID ( aFamily, aFamNum ))
if ( DriverMED::checkFamilyID ( aFamily, aFamNum, myFamilies ))
{
aFamily->AddElement(anElement);
aFamily->SetType( SMDSAbs_Ball );
@ -329,7 +349,7 @@ DriverMED_R_SMESHDS_Mesh
if(aResult < DRS_WARN_RENUMBER)
aResult = DRS_WARN_RENUMBER;
}
if ( checkFamilyID ( aFamily, aFamNum ))
if ( DriverMED::checkFamilyID ( aFamily, aFamNum, myFamilies ))
{
// Save reference to this element from its family
aFamily->AddElement(anElement);
@ -409,7 +429,7 @@ DriverMED_R_SMESHDS_Mesh
if (aResult < DRS_WARN_RENUMBER)
aResult = DRS_WARN_RENUMBER;
}
if ( checkFamilyID ( aFamily, aFamNum )) {
if ( DriverMED::checkFamilyID ( aFamily, aFamNum, myFamilies )) {
// Save reference to this element from its family
aFamily->AddElement(anElement);
aFamily->SetType(anElement->GetType());
@ -920,7 +940,7 @@ DriverMED_R_SMESHDS_Mesh
if (aResult < DRS_WARN_RENUMBER)
aResult = DRS_WARN_RENUMBER;
}
if ( checkFamilyID ( aFamily, aFamNum )) {
if ( DriverMED::checkFamilyID ( aFamily, aFamNum, myFamilies )) {
// Save reference to this element from its family
myFamilies[aFamNum]->AddElement(anElement);
myFamilies[aFamNum]->SetType(anElement->GetType());
@ -1127,7 +1147,9 @@ void DriverMED_R_SMESHDS_Mesh::CreateAllSubMeshes ()
* \param anID - an ID aFamily should have
* \retval bool - true if successful
*/
bool DriverMED_R_SMESHDS_Mesh::checkFamilyID(DriverMED_FamilyPtr & aFamily, int anID) const
bool DriverMED::checkFamilyID(DriverMED_FamilyPtr & aFamily,
int anID,
const TID2FamilyMap& myFamilies)
{
if ( !aFamily || aFamily->GetId() != anID ) {
map<int, DriverMED_FamilyPtr>::const_iterator i_fam = myFamilies.find(anID);
@ -1138,14 +1160,18 @@ bool DriverMED_R_SMESHDS_Mesh::checkFamilyID(DriverMED_FamilyPtr & aFamily, int
return ( aFamily->GetId() == anID );
}
/*! \brief Reading the structured mesh and convert to non structured (by filling of smesh structure for non structured mesh)
/*!
* \brief Reading the structured mesh and convert to non structured
* (by filling of smesh structure for non structured mesh)
* \param theWrapper - PWrapper const pointer
* \param theMeshInfo - PMeshInfo const pointer
* \param myFamilies - a map of the family ID to the Family
* \return TRUE, if successfully. Else FALSE
*/
bool DriverMED_R_SMESHDS_Mesh::buildMeshGrille(const MED::PWrapper& theWrapper,
const MED::PMeshInfo& theMeshInfo)
bool DriverMED::buildMeshGrille(const MED::PWrapper& theWrapper,
const MED::PMeshInfo& theMeshInfo,
SMESHDS_Mesh* myMesh,
const TID2FamilyMap& myFamilies)
{
bool res = true;
@ -1167,7 +1193,7 @@ bool DriverMED_R_SMESHDS_Mesh::buildMeshGrille(const MED::PWrapper& theWrapper,
if((aGrilleInfo->myFamNumNode).size() > 0){
TInt aFamNum = aGrilleInfo->GetFamNumNode(iNode);
if ( checkFamilyID ( aFamily, aFamNum ))
if ( DriverMED::checkFamilyID ( aFamily, aFamNum, myFamilies ))
{
aFamily->AddElement(aNode);
aFamily->SetType(SMDSAbs_Node);
@ -1224,7 +1250,7 @@ bool DriverMED_R_SMESHDS_Mesh::buildMeshGrille(const MED::PWrapper& theWrapper,
}
if((aGrilleInfo->myFamNum).size() > 0){
TInt aFamNum = aGrilleInfo->GetFamNum(iCell);
if ( checkFamilyID ( aFamily, aFamNum )){
if ( DriverMED::checkFamilyID ( aFamily, aFamNum, myFamilies )){
aFamily->AddElement(anElement);
aFamily->SetType(anElement->GetType());
}

16
src/DriverMED/DriverMED_R_SMESHDS_Mesh.h
View File

@ -29,10 +29,12 @@
#include "SMESH_DriverMED.hxx"
#include "DriverMED.hxx"
#include "Driver_SMESHDS_Mesh.h"
#include "DriverMED_Family.h"
#include "SMDSAbs_ElementType.hxx"
#include <list>
#include <map>
class SMESHDS_Mesh;
class SMESHDS_Group;
@ -53,18 +55,6 @@ class MESHDRIVERMED_EXPORT DriverMED_R_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
std::list<std::string> GetMeshNames(Status& theStatus);
void SetMeshName(std::string theMeshName);
private:
/*!
* \brief Ensure aFamily has required ID
* \param aFamily - a family to check
* \param anID - an ID aFamily should have
* \retval bool - true if successful
*/
bool checkFamilyID(DriverMED_FamilyPtr & aFamily, int anID) const;
bool buildMeshGrille(const MED::PWrapper& theWrapper,
const MED::PMeshInfo& theMeshInfo);
private:
std::string myMeshName;
std::map<int, DriverMED_FamilyPtr> myFamilies;

18
src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
View File

@ -24,19 +24,19 @@
// File : DriverMED_W_SMESHDS_Mesh.cxx
// Module : SMESH
//
#include <sstream>
#include "DriverMED_W_SMESHDS_Mesh.h"
#include "DriverMED_Family.h"
#include "SMESHDS_Mesh.hxx"
#include "DriverMED_Family.h"
#include "MED_Factory.hxx"
#include "MED_Utilities.hxx"
#include "SMDS_MeshElement.hxx"
#include "SMDS_MeshNode.hxx"
#include "SMDS_PolyhedralVolumeOfNodes.hxx"
#include "SMESHDS_Mesh.hxx"
#include "utilities.h"
#include <utilities.h>
#include "MED_Utilities.hxx"
#define _EDF_NODE_IDS_
//#define _ELEMENTS_BY_DIM_
@ -46,6 +46,7 @@ using namespace MED;
DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
myMedVersion(MED::eV2_2),
myAllSubMeshes (false),
myDoGroupOfNodes (false),
myDoGroupOfEdges (false),
@ -57,15 +58,15 @@ DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
{}
void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName,
MED::EVersion theId)
MED::EVersion theId)
{
myMed = CrWrapper(theFileName,theId);
Driver_SMESHDS_Mesh::SetFile(theFileName);
myMedVersion = theId;
}
void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName)
{
return SetFile(theFileName,MED::eV2_2);
Driver_SMESHDS_Mesh::SetFile(theFileName);
}
string DriverMED_W_SMESHDS_Mesh::GetVersionString(const MED::EVersion theVersion, int theNbDigits)
@ -393,6 +394,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
if ( myMesh->NbVolumes() > 0 )
aMeshDimension = 3;
MED::PWrapper myMed = CrWrapper(myFile,myMedVersion);
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

@ -30,7 +30,7 @@
#include "SMESH_DriverMED.hxx"
#include "Driver_SMESHDS_Mesh.h"
#include "MED_Factory.hxx"
#include "MED_Common.hxx"
#include <string>
#include <list>
@ -72,7 +72,7 @@ class MESHDRIVERMED_EXPORT DriverMED_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
private:
MED::PWrapper myMed;
MED::EVersion myMedVersion;
std::list<SMESHDS_GroupBase*> myGroups;
bool myAllSubMeshes;
std::map<int,SMESHDS_SubMesh*> mySubMeshes;
@ -85,6 +85,4 @@ class MESHDRIVERMED_EXPORT DriverMED_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
bool myAutoDimension;
};
#endif

15
src/DriverMED/Makefile.am
View File

@ -26,6 +26,7 @@ include $(top_srcdir)/adm_local/unix/make_common_starter.am
# header files
salomeinclude_HEADERS = \
DriverMED.hxx \
DriverMED_R_SMESHDS_Mesh.h \
DriverMED_W_SMESHDS_Mesh.h \
DriverMED_Family.h \
@ -47,12 +48,13 @@ dist_MED_Test_SOURCES = \
# additionnal information to compil and link file
libMeshDriverMED_la_CPPFLAGS = \
$(MED_CXXFLAGS) \
@HDF5_INCLUDES@ \
$(KERNEL_CXXFLAGS) \
$(CAS_CPPFLAGS) \
$(VTK_INCLUDES) \
$(BOOST_CPPFLAGS) \
-I$(srcdir)/../MEDWrapper/Base \
-I$(srcdir)/../MEDWrapper/Factory \
-I$(srcdir)/../Driver \
-I$(srcdir)/../SMDS \
-I$(srcdir)/../SMESHUtils \
@ -61,7 +63,9 @@ libMeshDriverMED_la_CPPFLAGS = \
libMeshDriverMED_la_LDFLAGS = \
$(BOOST_LIBS) \
../Driver/libMeshDriver.la \
$(MED_LDFLAGS) -lMEDWrapper -lMEDWrapperBase -lMEDWrapper_V2_2
../MEDWrapper/Factory/libMEDWrapper.la \
../MEDWrapper/Base/libMEDWrapperBase.la \
../MEDWrapper/V2_2/libMEDWrapper_V2_2.la \
$(BOOST_LIB_SYSTEM)
MED_Test_CPPFLAGS = \
@ -77,8 +81,7 @@ MED_Test_LDADD = \
-lOpUtil \
-lSALOMELocalTrace \
-lSALOMEBasics \
$(MED_LDFLAGS) \
-lMEDWrapper \
-lMEDWrapperBase \
-lMEDWrapper_V2_2
../MEDWrapper/Factory/libMEDWrapper.la \
../MEDWrapper/Base/libMEDWrapperBase.la \
../MEDWrapper/V2_2/libMEDWrapper_V2_2.la \
$(BOOST_LIB_SYSTEM)

47
src/MEDWrapper/Base/CMakeLists.txt Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2012-2013 CEA/DEN, EDF R&D
#
# 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.
#
# 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_DIRECTORIES(
${HDF5_INCLUDE_DIRS}
${BOOST_INCLUDE_DIRS}
)
IF(MED_ENABLE_KERNEL)
INCLUDE_DIRECTORIES(${KERNEL_ROOT_DIR}/include/salome)
ELSE(MED_ENABLE_KERNEL)
INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR}/adm_local_without_kernel)
ENDIF(MED_ENABLE_KERNEL)
SET(MEDWrapperBase_SOURCES
MED_Structures.cxx
MED_Wrapper.cxx
MED_Algorithm.cxx
MED_GaussUtils.cxx
MED_CoordUtils.cxx
MED_Utilities.cxx
MED_GaussDef.cxx
)
ADD_LIBRARY(MEDWrapperBase SHARED ${MEDWrapperBase_SOURCES})
SET_TARGET_PROPERTIES(MEDWrapperBase PROPERTIES COMPILE_FLAGS "-D${MACHINE} ${HDF5_DEFINITIONS} ${BOOST_DEFINITIONS} ${PLATFORM_DEFINITIONS}")
TARGET_LINK_LIBRARIES(MEDWrapperBase ${BOOST_LIB_THREAD} ${BOOST_LIB_DATE_TIME})
INSTALL(TARGETS MEDWrapperBase DESTINATION ${MED_salomelib_LIBS})
FILE(GLOB MEDWrapperBase_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
INSTALL(FILES ${MEDWrapperBase_HEADERS_HXX} DESTINATION ${MED_salomeinclude_HEADERS})

375
src/MEDWrapper/Base/MED_Algorithm.cxx Normal file
View File

@ -0,0 +1,375 @@
// Copyright (C) 2007-2013 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.
//
// 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_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;
#endif
namespace MED
{
//---------------------------------------------------------------
TEntity2TGeom2ElemInfo
GetEntity2TGeom2ElemInfo(const PWrapper& theWrapper,
const PMeshInfo& theMeshInfo,
const MED::TEntityInfo& theEntityInfo)
{
MSG(MYDEBUG,"GetElemsByEntity(...)");
TEntity2TGeom2ElemInfo anEntity2TGeom2ElemInfo;
MED::TEntityInfo::const_iterator anIter = theEntityInfo.begin();
PElemInfo anElemInfo;
TErr anErr;
for(; anIter != theEntityInfo.end(); anIter++){
const EEntiteMaillage& anEntity = anIter->first;
const TGeom2Size& aGeom2Size = anIter->second;
TGeom2ElemInfo& aGeom2ElemInfo = anEntity2TGeom2ElemInfo[anEntity];
if(anEntity == eNOEUD){
aGeom2ElemInfo[ePOINT1] = theWrapper->GetPElemInfo(theMeshInfo);
continue;
}
TGeom2Size::const_iterator anIter2 = aGeom2Size.begin();
for(; anIter2 != aGeom2Size.end(); anIter2++){
const EGeometrieElement& aGeom = anIter2->first;
aGeom2ElemInfo[aGeom] = theWrapper->GetPElemInfo(theMeshInfo,anEntity,aGeom,MED::eNOD,&anErr);
}
}
ADDMSG(MYDEBUG,"\n");
return anEntity2TGeom2ElemInfo;
}
//---------------------------------------------------------------
TFamilyInfoSet
GetFamilyInfoSet(const PWrapper& theWrapper,
const PMeshInfo& theMeshInfo)
{
MSG(MYDEBUG,"GetFamilies(...)");
TErr anErr;
TFamilyInfoSet aFamilyInfoSet;
TInt aNbFam = theWrapper->GetNbFamilies(*theMeshInfo);
INITMSG(MYDEBUG,"GetNbFamilies() = "<<aNbFam<<"\n");
for(TInt iFam = 1; iFam <= aNbFam; iFam++){
PFamilyInfo aFamilyInfo = theWrapper->GetPFamilyInfo(theMeshInfo,iFam,&anErr);
if(anErr >= 0)
aFamilyInfoSet.insert(aFamilyInfo);
}
ADDMSG(MYDEBUG,"\n");
return aFamilyInfoSet;
}
//---------------------------------------------------------------
TGroupInfo
GetGroupInfo(const TFamilyInfoSet& theFamilyInfoSet)
{
MSG(MYDEBUG,"GetFamiliesByGroup(...)");
TGroupInfo aGroup;
TFamilyInfoSet::const_iterator anIter = theFamilyInfoSet.begin();
for(; anIter != theFamilyInfoSet.end(); anIter++){
const PFamilyInfo& aFamilyInfo = *anIter;
TInt aNbGroup = aFamilyInfo->GetNbGroup();
for(TInt iGroup = 0; iGroup < aNbGroup; iGroup++){
aGroup[aFamilyInfo->GetGroupName(iGroup)].insert(aFamilyInfo);
}
}
#ifdef _DEBUG_
if(MYDEBUG){
TGroupInfo::const_iterator anIter = aGroup.begin();
for(; anIter != aGroup.end(); anIter++){
const std::string& aName = anIter->first;
INITMSG(MYDEBUG,"aGroupName = '"<<aName<<"'\n");
const TFamilyInfoSet& aFamilyInfoSet = anIter->second;
TFamilyInfoSet::const_iterator anFamIter = aFamilyInfoSet.begin();
for(; anFamIter != aFamilyInfoSet.end(); anFamIter++){
const PFamilyInfo& aFamilyInfo = *anFamIter;
INITMSG(MYDEBUG,"aFamilyName = '"<<aFamilyInfo->GetName()<<"'\n");
}
}
ADDMSG(MYDEBUG,"\n");
}
#endif
return aGroup;
}
//---------------------------------------------------------------
TFieldInfo2TimeStampInfoSet
GetFieldInfo2TimeStampInfoSet(const PWrapper& theWrapper,
const PMeshInfo& theMeshInfo,
const MED::TEntityInfo& theEntityInfo)
{
MSG(MYDEBUG,"GetFieldsByEntity(...)");
TFieldInfo2TimeStampInfoSet aFieldInfo2TimeStampInfoSet;
TInt aNbFields = theWrapper->GetNbFields();
INITMSG(MYDEBUG,"GetNbFields() = "<<aNbFields<<"\n");
for(TInt iField = 1; iField <= aNbFields; iField++){
PFieldInfo aFieldInfo = theWrapper->GetPFieldInfo(theMeshInfo,iField);
INITMSG(MYDEBUG,"aFieldName = '"<<aFieldInfo->GetName()<<
"'; aNbComp = "<<aFieldInfo->GetNbComp()<<"; ");
TGeom2Size aGeom2Size;
EEntiteMaillage anEntity = EEntiteMaillage(-1);
TInt aNbTimeStamps = theWrapper->GetNbTimeStamps(aFieldInfo,theEntityInfo,anEntity,aGeom2Size);
ADDMSG(MYDEBUG,"anEntity = "<<anEntity<<"; GetNbTimeStamps = "<<aNbTimeStamps<<"\n");
for(TInt iTimeStamp = 1; iTimeStamp <= aNbTimeStamps; iTimeStamp++){
PTimeStampInfo aTimeStamp =
theWrapper->GetPTimeStampInfo(aFieldInfo,anEntity,aGeom2Size,iTimeStamp);
aFieldInfo2TimeStampInfoSet[aFieldInfo].insert(aTimeStamp);
INITMSG(MYDEBUG,
"aDt = "<<aTimeStamp->GetDt()<<
", Unit = \'"<<aTimeStamp->GetUnitDt()<<"\n");
}
}
ADDMSG(MYDEBUG,"\n");
return aFieldInfo2TimeStampInfoSet;
}
//---------------------------------------------------------------
TEntite2TFieldInfo2TimeStampInfoSet
GetEntite2TFieldInfo2TimeStampInfoSet(const TFieldInfo2TimeStampInfoSet& theFieldInfo2TimeStampInfoSet)
{
TEntite2TFieldInfo2TimeStampInfoSet anEntite2TFieldInfo2TimeStampInfoSet;
TFieldInfo2TimeStampInfoSet::const_iterator anIter = theFieldInfo2TimeStampInfoSet.begin();
for(; anIter != theFieldInfo2TimeStampInfoSet.end(); anIter++){
const TTimeStampInfoSet& aTimeStampInfoSet = anIter->second;
//const PFieldInfo& aFieldInfo = anIter->first;
if(aTimeStampInfoSet.empty())
continue;
const PTimeStampInfo& aTimeStampInfo = *aTimeStampInfoSet.begin();
anEntite2TFieldInfo2TimeStampInfoSet[ConvertEntity(aTimeStampInfo->GetEntity())].insert(*anIter);
}
return anEntite2TFieldInfo2TimeStampInfoSet;
}
//---------------------------------------------------------------
bool
operator<(const TFamilyTSize& theLeft, const TFamilyTSize& theRight)
{
const MED::PFamilyInfo& aLeftInfo = boost::get<0>(theLeft);
const MED::PFamilyInfo& aRightInfo = boost::get<0>(theRight);
return aLeftInfo->GetId() < aRightInfo->GetId();
}
//---------------------------------------------------------------
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();
for(; anIter != theFamilyInfoSet.end(); anIter++){
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++){
const EEntiteMaillage& anEntity = anIter->first;
TFamilyID2Size& aFamilyID2Size = anEntity2FamilyID[anEntity];
const TGeom2ElemInfo& aGeom2ElemInfo = anIter->second;
TGeom2ElemInfo::const_iterator aGeom2ElemInfoIter = aGeom2ElemInfo.begin();
for(; aGeom2ElemInfoIter != aGeom2ElemInfo.end(); aGeom2ElemInfoIter++){
const PElemInfo& aElemInfo = aGeom2ElemInfoIter->second;
if(TInt aNbElem = aElemInfo->GetNbElem()){
for(TInt i = 0; i < aNbElem; i++){
aFamilyID2Size[aElemInfo->GetFamNum(i)] += 1;
}
}
}
}
}
if(!anEntity2FamilyID.empty()){
TEntity2FamilyID::const_iterator anIter = anEntity2FamilyID.begin();
for(; anIter != anEntity2FamilyID.end(); anIter++){
const EEntiteMaillage& anEntity = anIter->first;
INITMSG(MYDEBUG,"anEntity = "<<anEntity<<":\n");
const TFamilyID2Size& aFamilyID2Size = anIter->second;
TFamilyID2Size::const_iterator anIter2 = aFamilyID2Size.begin();
for(; anIter2 != aFamilyID2Size.end(); anIter2++){
TInt anId = anIter2->first;
TInt aSize = anIter2->second;
TId2Family::const_iterator anIter3 = anId2Family.find(anId);
if(anIter3 != anId2Family.end()){
const PFamilyInfo& aFamilyInfo = anIter3->second;
anEntity2FamilySet[anEntity].insert(TFamilyTSize(aFamilyInfo,aSize));
INITMSG(MYDEBUG,
"aFamilyName = '"<<aFamilyInfo->GetName()<<
"' anId = "<<aFamilyInfo->GetId()<<"\n");
}
}
}
}
}
ADDMSG(MYDEBUG,"\n");
return anEntity2FamilySet;
}
//---------------------------------------------------------------
TKey2Gauss
GetKey2Gauss(const PWrapper& theWrapper,
TErr* theErr,
EModeSwitch theMode)
{
INITMSG(MYDEBUG,"GetKey2Gauss - theMode = "<<theMode<<std::endl);
TKey2Gauss aKey2Gauss;
TInt aNbGauss = theWrapper->GetNbGauss(theErr);
for(TInt anId = 1; anId <= aNbGauss; anId++){
TGaussInfo::TInfo aPreInfo = theWrapper->GetGaussPreInfo(anId);
PGaussInfo anInfo = theWrapper->CrGaussInfo(aPreInfo,theMode);
theWrapper->GetGaussInfo(anId,anInfo,theErr);
TGaussInfo::TKey aKey = boost::get<0>(aPreInfo);
aKey2Gauss[aKey] = anInfo;
#ifdef _DEBUG_
const EGeometrieElement& aGeom = boost::get<0>(aKey);
const std::string& aName = boost::get<1>(aKey);
INITMSG(MYDEBUG,
"- aGeom = "<<aGeom<<
"; aName = '"<<aName<<"'"<<
std::endl);
#endif
}
return aKey2Gauss;
}
//---------------------------------------------------------------
PProfileInfo
GetProfileInfo(const PWrapper& theWrapper,
const std::string& theProfileName,
TErr* theErr,
EModeProfil theMode)
{
PProfileInfo anInfo;
TInt aNbProfiles = theWrapper->GetNbProfiles(theErr);
for(TInt anId = 1; anId <= aNbProfiles; anId++){
TProfileInfo::TInfo aPreInfo = theWrapper->GetProfilePreInfo(anId);
const std::string& aName = boost::get<0>(aPreInfo);
if(aName == theProfileName)
return theWrapper->GetPProfileInfo(anId,theMode,theErr);
}
return anInfo;
}
//---------------------------------------------------------------
TMKey2Profile
GetMKey2Profile(const PWrapper& theWrapper,
TErr* theErr,
EModeProfil theMode)
{
INITMSG(MYDEBUG,"GetMKey2Profile - theMode = "<<theMode<<std::endl);
TKey2Profile aKey2Profile;
TInt aNbProfiles = theWrapper->GetNbProfiles(theErr);
for(TInt anId = 1; anId <= aNbProfiles; anId++){
TProfileInfo::TInfo aPreInfo = theWrapper->GetProfilePreInfo(anId);
PProfileInfo anInfo = theWrapper->GetPProfileInfo(anId,theMode,theErr);
const std::string& aName = boost::get<0>(aPreInfo);
aKey2Profile[aName] = anInfo;
#ifdef _DEBUG_
INITMSG(MYDEBUG,
"- aName = '"<<aName<<"'"<<
" : "<<
std::endl);
TInt aNbElem = anInfo->GetSize();
for(TInt iElem = 0; iElem < aNbElem; iElem++){
ADDMSG(MYVALUEDEBUG,anInfo->GetElemNum(iElem)<<", ");
}
ADDMSG(MYVALUEDEBUG, std::endl);
#endif
}
return TMKey2Profile(theMode,aKey2Profile);
}
//---------------------------------------------------------------
EEntiteMaillage
GetEntityByFamilyId(PGrilleInfo& theInfo,TInt theId){
TElemNum::iterator aNodeFamIter = (theInfo->myFamNumNode).begin();
for(;aNodeFamIter != (theInfo->myFamNumNode).end(); aNodeFamIter++){
if(theId == *aNodeFamIter)
return eNOEUD;
}
TElemNum::iterator aCellFamIter = (theInfo->myFamNum).begin();
for(;aCellFamIter != (theInfo->myFamNum).end(); aCellFamIter++){
if(theId == *aCellFamIter)
return eMAILLE;
}
EXCEPTION(std::runtime_error, "GetEntityByFamilyId - fails");
return EEntiteMaillage(-1);
}
TFamilyID2NbCells
GetFamilyID2NbCells(PGrilleInfo& theInfo){
TFamilyID2NbCells aFamily2NbCells;
TInt aNbNodes = theInfo->myFamNumNode.size();
TInt aNbCells = theInfo->myFamNum.size();
for(TInt i=0; i<aNbNodes; i++) aFamily2NbCells[theInfo->GetFamNumNode(i)] = 0;
for(TInt i=0; i<aNbCells; i++) aFamily2NbCells[theInfo->GetFamNum(i)] = 0;
for(TInt i=0; i<aNbNodes; i++) aFamily2NbCells[theInfo->GetFamNumNode(i)] += 1;
for(TInt i=0; i<aNbCells; i++) aFamily2NbCells[theInfo->GetFamNum(i)] += 1;
return aFamily2NbCells;
}
EEntiteMaillage ConvertEntity(const EEntiteMaillage& aEntity){
switch( aEntity ){
case eNOEUD_ELEMENT:
case eMAILLE: return eMAILLE; //eNOEUD_ELEMENT it is eMAILLE
case eFACE:
case eARETE:
case eNOEUD: return aEntity; break;
default: return EEntiteMaillage(-1);
}
}
}

157
src/MEDWrapper/Base/MED_Algorithm.hxx Normal file
View File

@ -0,0 +1,157 @@
// Copyright (C) 2007-2013 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.
//
// 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_Algorithm_HeaderFile
#define MED_Algorithm_HeaderFile
#include "MED_WrapperBase.hxx"
#include "MED_Structures.hxx"
#include <set>
namespace MED
{
//---------------------------------------------------------------
typedef std::map<EGeometrieElement,PElemInfo> TGeom2ElemInfo;
typedef std::map<EEntiteMaillage,TGeom2ElemInfo> TEntity2TGeom2ElemInfo;
//! Get set of TElemInfo by its geometrical type and corresponding MED ENTITY
MEDWRAPPER_EXPORT
TEntity2TGeom2ElemInfo
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,
const PMeshInfo& theMeshInfo);
//---------------------------------------------------------------
typedef boost::tuple<PFamilyInfo,TInt> TFamilyTSize;
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,
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,
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,
TErr* theErr = NULL,
EModeSwitch theMode = eFULL_INTERLACE);
//---------------------------------------------------------------
//! Get MED PROFILE by its name
MEDWRAPPER_EXPORT
PProfileInfo
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,
TErr* theErr = NULL,
EModeProfil theMode = eCOMPACT);
//---------------------------------------------------------------
//! Get Entity for Grille by family id.
MEDWRAPPER_EXPORT
EEntiteMaillage
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

186
src/MEDWrapper/Base/MED_Common.hxx Normal file
View File

@ -0,0 +1,186 @@
// Copyright (C) 2007-2013 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.
//
// 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_Common_HeaderFile
#define MED_Common_HeaderFile
#include "MED_WrapperBase.hxx"
#include <string>
#include <set>
#include <map>
#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 ;
typedef double TFloat;
#if defined(HAVE_F77INT64)
typedef long TInt;
#else
typedef int TInt;
#endif
typedef hid_t TIdt;
typedef herr_t TErr;
typedef enum {eFULL_INTERLACE, eNO_INTERLACE} EModeSwitch;
typedef enum {eFLOAT64=6, eINT=26} ETypeChamp;
typedef enum {eNON_STRUCTURE, eSTRUCTURE} EMaillage;
typedef enum {eCART, eCYL, eSPHER} ERepere;
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,
ePYRA13=313, ePENTA15=315, eHEXA20=320, eHEXA27=327,
ePOLYGONE=400, 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 {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<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;
struct TElemInfo;
typedef SharedPtr<TElemInfo> PElemInfo;
struct TNodeInfo;
typedef SharedPtr<TNodeInfo> PNodeInfo;
struct TPolygoneInfo;
typedef SharedPtr<TPolygoneInfo> PPolygoneInfo;
struct TPolyedreInfo;
typedef SharedPtr<TPolyedreInfo> PPolyedreInfo;
struct TCellInfo;
typedef SharedPtr<TCellInfo> PCellInfo;
struct TBallInfo;
typedef SharedPtr<TBallInfo> PBallInfo;
struct TFieldInfo;
typedef SharedPtr<TFieldInfo> PFieldInfo;
struct TTimeStampInfo;
typedef SharedPtr<TTimeStampInfo> PTimeStampInfo;
struct TProfileInfo;
typedef SharedPtr<TProfileInfo> PProfileInfo;
struct TGaussInfo;
typedef SharedPtr<TGaussInfo> PGaussInfo;
class TGrilleInfo;
typedef SharedPtr<TGrilleInfo> PGrilleInfo;
struct TTimeStampValueBase;
typedef SharedPtr<TTimeStampValueBase> PTimeStampValueBase;
struct TWrapper;
typedef SharedPtr<TWrapper> PWrapper;
}
#endif

160
src/MEDWrapper/Base/MED_CoordUtils.cxx Normal file
View File

@ -0,0 +1,160 @@
// Copyright (C) 2007-2013 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.
//
// 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_CoordUtils.hxx"
#include "MED_Utilities.hxx"
namespace MED
{
enum ECoordName{eX, eY, eZ, eNone};
template<ECoordName TCoordId>
TFloat
GetCoord(const TCCoordSlice& theCoordSlice)
{
return theCoordSlice[TCoordId];
}
template<>
TFloat
GetCoord<eNone>(const TCCoordSlice& theCoordSlice)
{
return 0.0;
}
TGetCoord
aXYZGetCoord[3] = {
&GetCoord<eX>,
&GetCoord<eY>,
&GetCoord<eZ>
};
TGetCoord
aXYGetCoord[3] = {
&GetCoord<eX>,
&GetCoord<eY>,
&GetCoord<eNone>
};
TGetCoord
aYZGetCoord[3] = {
&GetCoord<eNone>,
&GetCoord<eX>,
&GetCoord<eY>
};
TGetCoord
aXZGetCoord[3] = {
&GetCoord<eX>,
&GetCoord<eNone>,
&GetCoord<eY>
};
TGetCoord
aXGetCoord[3] = {
&GetCoord<eX>,
&GetCoord<eNone>,
&GetCoord<eNone>
};
TGetCoord
aYGetCoord[3] = {
&GetCoord<eNone>,
&GetCoord<eX>,
&GetCoord<eNone>
};
TGetCoord
aZGetCoord[3] = {
&GetCoord<eNone>,
&GetCoord<eNone>,
&GetCoord<eX>
};
//---------------------------------------------------------------
TCoordHelper
::TCoordHelper(TGetCoord* theGetCoord):
myGetCoord(theGetCoord)
{}
TFloat
TCoordHelper
::GetCoord(TCCoordSlice& theCoordSlice,
TInt theCoordId)
{
return (*myGetCoord[theCoordId])(theCoordSlice);
}
//---------------------------------------------------------------
PCoordHelper
GetCoordHelper(PNodeInfo theNodeInfo)
{
PCoordHelper aCoordHelper;
{
PMeshInfo aMeshInfo = theNodeInfo->GetMeshInfo();
TInt aMeshDimension = aMeshInfo->GetDim();
bool anIsDimPresent[3] = {false, false, false};
for(int iDim = 0; iDim < aMeshDimension; iDim++){
// PAL16857(SMESH not conform to the MED convention) ->
// 1D - always along X
// 2D - always in XOY plane
anIsDimPresent[iDim] = iDim < aMeshDimension;
// std::string aName = theNodeInfo->GetCoordName(iDim);
// if ( aName.size() > 1 ) // PAL12148, aName has size 8 or 16
// aName = aName.substr(0,1);
// if(aName == "x" || aName == "X")
// anIsDimPresent[eX] = true;
// else if(aName == "y" || aName == "Y")
// anIsDimPresent[eY] = true;
// else if(aName == "z" || aName == "Z")
// anIsDimPresent[eZ] = true;
}
switch(aMeshDimension){
case 3:
aCoordHelper.reset(new TCoordHelper(aXYZGetCoord));
break;
case 2:
if(anIsDimPresent[eY] && anIsDimPresent[eZ])
aCoordHelper.reset(new TCoordHelper(aYZGetCoord));
else if(anIsDimPresent[eX] && anIsDimPresent[eZ])
aCoordHelper.reset(new TCoordHelper(aXZGetCoord));
else
aCoordHelper.reset(new TCoordHelper(aXYGetCoord));
break;
case 1:
if(anIsDimPresent[eY])
aCoordHelper.reset(new TCoordHelper(aYGetCoord));
else if(anIsDimPresent[eZ])
aCoordHelper.reset(new TCoordHelper(aZGetCoord));
else
aCoordHelper.reset(new TCoordHelper(aXGetCoord));
break;
}
}
return aCoordHelper;
}
}

57
src/MEDWrapper/Base/MED_CoordUtils.hxx Normal file
View File

@ -0,0 +1,57 @@
// Copyright (C) 2007-2013 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.
//
// 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_CoordUtils_HeaderFile
#define MED_CoordUtils_HeaderFile
#include "MED_WrapperBase.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,
TInt theCoordId);
};
typedef SharedPtr<TCoordHelper> PCoordHelper;
//---------------------------------------------------------------
MEDWRAPPER_EXPORT
PCoordHelper
GetCoordHelper(PNodeInfo theNodeInfo);
}
#endif

570
src/MEDWrapper/Base/MED_GaussDef.cxx Normal file
View File

@ -0,0 +1,570 @@
// Copyright (C) 2007-2013 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.
//
// 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_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");
if ( myWeights.capacity() == myWeights.size() )
EXCEPTION( 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");
if ( myWeights.capacity() == myWeights.size() )
EXCEPTION( logic_error,"Extra gauss point");
myCoords.push_back( x );
myCoords.push_back( y );
myWeights.push_back( weight );
}
void TGaussDef::add(const double x, const double y, const double z, const double weight)
{
if ( dim() != 3 )
EXCEPTION( logic_error,"dim() != 3");
if ( myWeights.capacity() == myWeights.size() )
EXCEPTION( logic_error,"Extra gauss point");
myCoords.push_back( x );
myCoords.push_back( y );
myCoords.push_back( z );
myWeights.push_back( weight );
}
void TGaussDef::setRefCoords(const TShapeFun& aShapeFun)
{
myRefCoords.reserve( aShapeFun.myRefCoord.size() );
myRefCoords.assign( aShapeFun.myRefCoord.begin(),
aShapeFun.myRefCoord.end() );
}
//---------------------------------------------------------------
/*!
* \brief Fill definition of gauss points family
*/
//---------------------------------------------------------------
TGaussDef::TGaussDef(const int geom, const int nbGauss, const int variant)
{
myType = geom;
myCoords .reserve( nbGauss * dim() );
myWeights.reserve( nbGauss );
switch ( geom ) {
case eSEG2:
case eSEG3:
if (geom == eSEG2) setRefCoords( TSeg2a() );
else setRefCoords( TSeg3a() );
switch ( nbGauss ) {
case 1: {
add( 0.0, 2.0 ); break;
}
case 2: {
const double a = 0.577350269189626;
add( a, 1.0 );
add( -a, 1.0 ); break;
}
case 3: {
const double a = 0.774596669241;
const double P1 = 1./1.8;
const double P2 = 1./1.125;
add( -a, P1 );
add( 0, P2 );
add( a, P1 ); break;
}
case 4: {
const double a = 0.339981043584856, b = 0.861136311594053;
const double P1 = 0.652145154862546, P2 = 0.347854845137454 ;
add( a, P1 );
add( -a, P1 );
add( b, P2 );
add( -b, P2 ); break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for SEG"<<nbGauss);
}
break;
case eTRIA3:
case eTRIA6:
if ( variant == 1 ) {
if (geom == eTRIA3) setRefCoords( TTria3b() );
else setRefCoords( TTria6b() );
switch ( nbGauss ) {
case 1: { // FPG1
add( 1/3., 1/3., 1/2. ); break;
}
case 3: { // FPG3
// what about COT3 ???
add( 1/6., 1/6., 1/6. );
add( 2/3., 1/6., 1/6. );
add( 1/6., 2/3., 1/6. ); break;
}
case 4: { // FPG4
add( 1/5., 1/5., 25/(24*4.) );
add( 3/5., 1/5., 25/(24*4.) );
add( 1/5., 3/5., 25/(24*4.) );
add( 1/3., 1/3., -27/(24*4.) ); break;
}
case 6: { // FPG6
const double P1 = 0.11169079483905, P2 = 0.0549758718227661;
const double a = 0.445948490915965, b = 0.091576213509771;
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( 1-2*a, a, P1 ); break;
}
case 7: { // FPG7
const double A = 0.470142064105115;
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-2*A, A, P1 );
add( A, 1-2*A, P1 );
add( B, B, P2 );
add( 1-2*B, B, P2 );
add( B, 1-2*B, P2 ); break;
}
case 12: { // FPG12
const double A = 0.063089014491502;
const double B = 0.249286745170910;
const double C = 0.310352451033785;
const double D = 0.053145049844816;
const double P1 = 0.025422453185103;
const double P2 = 0.058393137863189;
const double P3 = 0.041425537809187;
add( A, A, P1 );
add( 1-2*A, A, P1 );
add( A, 1-2*A, P1 );
add( B, B, P2 );
add( 1-2*B, B, P2 );
add( B, 1-2*B, P2 );
add( C, D, P3 );
add( D, C, P3 );
add( 1-C-D, C, P3 );
add( 1-C-D, D, P3 );
add( C, 1-C-D, P3 );
add( D, 1-C-D, P3 ); break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for TRIA, variant 1: "
<<nbGauss);
}
}
else if ( variant == 2 ) {
if (geom == eTRIA3) setRefCoords( TTria3a() );
else setRefCoords( TTria6a() );
switch ( nbGauss ) {
case 1: {
add( -1/3., -1/3., 2. ); break;
}
case 3: {
add( -2/3., 1/3., 2/3. );
add( -2/3., -2/3., 2/3. );
add( 1/3., -2/3., 2/3. ); break;
}
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, 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, 2*A-1, 4*P1 ); break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for TRIA, variant 2: "
<<nbGauss);
}
}
else if ( variant == 3 ) {
if (geom == eTRIA3) setRefCoords( TTria3b() );
else setRefCoords( TTria6b() );
switch ( nbGauss ) {
case 4: {
add( 1/3., 1/3., -27/96 );
add( 0.2 , 0.2 , 25/96 );
add( 0.6 , 0.2 , 25/96 );
add( 0.2 , 0.6 , 25/96 ); break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for TRIA, variant 3: "
<<nbGauss);
}
}
break;
case eQUAD4:
case eQUAD8:
if ( variant == 1 ) {
if (geom == eQUAD4) setRefCoords( TQuad4b() );
else setRefCoords( TQuad8b() );
switch ( nbGauss ) {
case 1: { // FPG1
add( 0, 0, 4 ); break;
}
case 4: { // FPG4
const double a = 1/sqrt(3.);
add( -a, -a, 1 );
add( a, -a, 1 );
add( a, a, 1 );
add( -a, a, 1 ); break;
}
case 9: { // FPG9
const double a = 0.774596669241483;
add( -a, -a, 25/81. );
add( a, -a, 25/81. );
add( a, a, 25/81. );
add( -a, a, 25/81. );
add( 0., -a, 40/81. );
add( a, 0., 40/81. );
add( 0., a, 40/81. );
add( -a, 0., 40/81. );
add( 0., 0., 64/81. ); break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for QUAD, variant 1: "
<<nbGauss);
}
}
else if ( variant == 2 ) {
if (geom == eQUAD4) setRefCoords( TQuad4a() );
else setRefCoords( TQuad8a() );
switch ( nbGauss ) {
case 4: {
const double a = 1/sqrt(3.);
add( -a, a, 1 );
add( -a, -a, 1 );
add( a, -a, 1 );
add( a, a, 1 ); break;
}
case 9: {
const double a = 0.774596669241483;
add( -a, a, 25/81. );
add( -a, -a, 25/81. );
add( a, -a, 25/81. );
add( a, a, 25/81. );
add( -a, 0., 40/81. );
add( 0., -a, 40/81. );
add( a, 0., 40/81. );
add( 0., a, 40/81. );
add( 0., 0., 64/81. ); break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for QUAD, variant 1: "
<<nbGauss);
}
}
else if ( variant == 3 ) {
if (geom == eQUAD4) setRefCoords( TQuad4b() );
else setRefCoords( TQuad8b() );
switch ( nbGauss ) {
case 4: {
const double a = 3/sqrt(3.);
add( -a, -a, 1 );
add( -a, a, 1 );
add( a, -a, 1 );
add( a, a, 1 ); break;
}
case 9: {
const double a = sqrt(3/5.), c1 = 5/9., c2 = 8/9.;
const double c12 = c1*c2, c22 = c2*c2, c1c2 = c1*c2;
add( -a, -a, c12 );
add( -a, 0., c1c2 );
add( -a, a, c12 );
add( 0., -a, c1c2 );
add( 0., 0., c22 );
add( 0., a, c1c2 );
add( a, -a, c12 );
add( a, 0., c1c2 );
add( a, a, c12 ); break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for QUAD, variant 3: "
<<nbGauss);
}
}
break;
case eTETRA4:
case eTETRA10:
if (geom == eTETRA4) setRefCoords( TTetra4a() );
else setRefCoords( TTetra10a() );
switch ( nbGauss ) {
case 4: { // FPG4
const double a = (5 - sqrt(5.))/20., b = (5 + 3*sqrt(5.))/20.;
add( a, a, a, 1/24. );
add( a, a, b, 1/24. );
add( a, b, a, 1/24. );
add( b, a, a, 1/24. ); break;
}
case 5: { // FPG5
const double a = 0.25, b = 1/6., c = 0.5;
add( a, a, a, -2/15. );
add( b, b, b, 3/40. );
add( b, b, c, 3/40. );
add( b, c, b, 3/40. );
add( c, b, b, 3/40. ); break;
}
case 15: { // FPG15
const double a = 0.25;
const double b1 = (7 + sqrt(15.))/34., c1 = (13 + 3*sqrt(15.))/34., d = (5 - sqrt(15.))/20.;
const double b2 = (7 - sqrt(15.))/34., c2 = (13 - 3*sqrt(15.))/34., e = (5 + sqrt(15.))/20.;
const double P1 = (2665 - 14*sqrt(15.))/226800.;
const double P2 = (2665 + 14*sqrt(15.))/226800.;
add( a, a, a, 8/405.);//_____
add( b1, b1, b1, P1 );
add( b1, b1, c1, P1 );
add( b1, c1, b1, P1 );
add( c1, b1, b1, P1 );//_____
add( b2, b2, b2, P2 );
add( b2, b2, c2, P2 );
add( b2, c2, b2, P2 );
add( c2, b2, b2, P2 );//_____
add( d, d, e, 5/567.);
add( d, e, d, 5/567.);
add( e, d, d, 5/567.);
add( d, e, e, 5/567.);
add( e, d, e, 5/567.);
add( e, e, d, 5/567.);
break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for TETRA: "<<nbGauss);
}
break;
case ePYRA5:
case ePYRA13:
if (geom == ePYRA5) setRefCoords( TPyra5a() );
else setRefCoords( TPyra13a() );
switch ( nbGauss ) {
case 5: { // FPG5
const double h1 = 0.1531754163448146;
const double h2 = 0.6372983346207416;
add( .5, 0., h1, 2/15. );
add( 0., .5, h1, 2/15. );
add( -.5, 0., h1, 2/15. );
add( 0., -.5, h1, 2/15. );
add( 0., 0., h2, 2/15. ); break;
}
case 6: { // FPG6
const double p1 = 0.1024890634400000 ;
const double p2 = 0.1100000000000000 ;
const double p3 = 0.1467104129066667 ;
const double a = 0.5702963741068025 ;
const double h1 = 0.1666666666666666 ;
const double h2 = 0.08063183038464675;
const double h3 = 0.6098484849057127 ;
add( a, 0., h1, p1 );
add( 0., a, h1, p1 );
add( -a, 0., h1, p1 );
add( 0., -a, h1, p1 );
add( 0., 0., h2, p2 );
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 d1 = 1.106412899;
double z = 1/2., fz = b1/2*(1 - z);
add( 0., 0., z, a1 ); // 1
add( fz, fz, z, b6 ); // 2
add( -fz, fz, z, b6 ); // 3
add( -fz, -fz, z, b6 ); // 4
add( fz, -fz, z, b6 ); // 5
z = (1 - b1)/2.;
add( 0., 0., z, b6 ); // 6
z = (1 + b1)/2.;
add( 0., 0., z, b6 ); // 7
z = (1 - c1)/2.; fz = c1*(1 - z);
add( fz, 0., z, c8 ); // 8
add( 0., fz, z, c8 ); // 9
add( -fz, 0., z, c8 ); // 10
add( 0., -fz, z, c8 ); // 11
z = (1 + c1)/2.; fz = c1*(1 - z);
add( fz, 0., z, c8 ); // 12
add( 0., fz, z, c8 ); // 13
add( -fz, 0., z, c8 ); // 14
add( 0., -fz, z, c8 ); // 15
z = (1 - d1)/2., fz = d1/2*(1 - z);
add( fz, fz, z, d12); // 16
add( -fz, fz, z, d12); // 17
add( -fz, -fz, z, d12); // 18
add( fz, -fz, z, d12); // 19
z = 1/2.; fz = d1*(1 - z);
add( fz, 0., z, d12); // 20
add( 0., fz, z, d12); // 21
add( -fz, 0., z, d12); // 22
add( 0., -fz, z, d12); // 23
z = (1 + d1)/2., fz = d1/2*(1 - z);
add( fz, fz, z, d12); // 24
add( -fz, fz, z, d12); // 25
add( -fz, -fz, z, d12); // 26
add( fz, -fz, z, d12); // 27
break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for PYRA: "<<nbGauss);
}
break;
case ePENTA6:
case ePENTA15:
if (geom == ePENTA6) setRefCoords( TPenta6a() );
else setRefCoords( TPenta15a() );
switch ( nbGauss ) {
case 6: { // FPG6
const double a = sqrt(3.)/3.;
add( -a, .5, .5, 1/6. );
add( -a, 0., .5, 1/6. );
add( -a, .5, 0., 1/6. );
add( a, .5, .5, 1/6. );
add( a, 0., .5, 1/6. );
add( a, .5, 0., 1/6. ); break;
}
case 8: { // FPG8
const double a = 0.577350269189626;
add( -a, 1/3., 1/3., -27/96. );
add( -a, 0.6, 0.2, 25/96. );
add( -a, 0.2, 0.6, 25/96. );
add( -a, 0.2, 0.2, 25/96. );
add( +a, 1/3., 1/3., -27/96. );
add( +a, 0.6, 0.2, 25/96. );
add( +a, 0.2, 0.6, 25/96. );
add( +a, 0.2, 0.2, 25/96. ); break;
}
case 21: { // FPG21
const double d = sqrt(3/5.), c1 = 5/9., c2 = 8/9.; // d <=> alfa
const double a = (6 + sqrt(15.))/21.;
const double b = (6 - sqrt(15.))/21.;
const double P1 = (155 + sqrt(15.))/2400.;
const double P2 = (155 - sqrt(15.))/2400.; //___
add( -d, 1/3., 1/3., c1*9/80. );//___
add( -d, a, a, c1*P1 );
add( -d, 1-2*a, a, c1*P1 );
add( -d, a, 1-2*a, c1*P1 );//___
add( -d, b, b, c1*P2 );
add( -d, 1-2*b, b, c1*P2 );
add( -d, b, 1-2*b, c1*P2 );//___
add( 0., 1/3., 1/3., c2*9/80. );//___
add( 0., a, a, c2*P1 );
add( 0., 1-2*a, a, c2*P1 );
add( 0., a, 1-2*a, c2*P1 );//___
add( 0., b, b, c2*P2 );
add( 0., 1-2*b, b, c2*P2 );
add( 0., b, 1-2*b, c2*P2 );//___
add( d, 1/3., 1/3., c1*9/80. );//___
add( d, a, a, c1*P1 );
add( d, 1-2*a, a, c1*P1 );
add( d, a, 1-2*a, c1*P1 );//___
add( d, b, b, c1*P2 );
add( d, 1-2*b, b, c1*P2 );
add( d, b, 1-2*b, c1*P2 );//___
break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for PENTA: " <<nbGauss);
}
break;
case eHEXA8:
case eHEXA20:
if (geom == eHEXA8) setRefCoords( THexa8a() );
else setRefCoords( THexa20a() );
switch ( nbGauss ) {
case 8: { // FPG8
const double a = sqrt(3.)/3.;
add( -a, -a, -a, 1. );
add( -a, -a, a, 1. );
add( -a, a, -a, 1. );
add( -a, a, a, 1. );
add( a, -a, -a, 1. );
add( a, -a, a, 1. );
add( a, a, -a, 1. );
add( a, a, a, 1. ); break;
}
case 27: { // FPG27
const double a = sqrt(3/5.), c1 = 5/9., c2 = 8/9.;
const double c12 = c1*c1, c13 = c1*c1*c1;
const double c22 = c2*c2, c23 = c2*c2*c2;
add( -a, -a, -a, c13 ); // 1
add( -a, -a, 0., c12*c2 ); // 2
add( -a, -a, a, c13 ); // 3
add( -a, 0., -a, c12*c2 ); // 4
add( -a, 0., 0., c1*c22 ); // 5
add( -a, 0., a, c12*c2 ); // 6
add( -a, a, -a, c13 ); // 7
add( -a, a, 0., c12*c2 ); // 8
add( -a, a, a, c13 ); // 9
add( 0., -a, -a, c12*c2 ); // 10
add( 0., -a, 0., c1*c22 ); // 11
add( 0., -a, a, c12*c2 ); // 12
add( 0., 0., -a, c1*c22 ); // 13
add( 0., 0., 0., c23 ); // 14
add( 0., 0., a, c1*c22 ); // 15
add( 0., a, -a, c12*c2 ); // 16
add( 0., a, 0., c1*c22 ); // 17
add( 0., a, a, c12*c2 ); // 18
add( a, -a, -a, c13 ); // 19
add( a, -a, 0., c12*c2 ); // 20
add( a, -a, a, c13 ); // 21
add( a, 0., -a, c12*c2 ); // 22
add( a, 0., 0., c1*c22 ); // 23
add( a, 0., a, c12*c2 ); // 24
add( a, a, -a, c13 ); // 25
add( a, a, 0., c12*c2 ); // 26
add( a, a, a, c13 ); // 27
break;
}
default:
EXCEPTION( logic_error,"Invalid nb of gauss points for PENTA: " <<nbGauss);
}
break;
default:
EXCEPTION( logic_error,"unexpected EGeometrieElement: "<< geom);
}
if ( myWeights.capacity() != myWeights.size() )
EXCEPTION( logic_error,"Not all gauss points defined");
}
}

69
src/MEDWrapper/Base/MED_GaussDef.hxx Normal file
View File

@ -0,0 +1,69 @@
// Copyright (C) 2007-2013 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.
//
// 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_GaussDef.hxx
// Author : Edward AGAPOV (eap)
//
#ifndef MED_GaussDef_HeaderFile
#define MED_GaussDef_HeaderFile
#include "MED_WrapperBase.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
*/
struct TGaussDef
{
int myType; //!< element geometry (EGeometrieElement or med_geometrie_element)
TDoubleVector myRefCoords; //!< description of reference points
TDoubleVector myCoords; //!< coordinates of Gauss points
TDoubleVector myWeights; //!< weights, len(weights)==<nb of gauss points>
/*!
* \brief Creates definition of gauss points family
* \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
* 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
*/
MEDWRAPPER_EXPORT TGaussDef(const int geomType, const int nbPoints, const int variant=1);
MEDWRAPPER_EXPORT int dim() const { return myType/100; }
MEDWRAPPER_EXPORT int nbPoints() const { return myWeights.capacity(); }
private:
void add(const double x, const double weight);
void add(const double x, const double y, const double weight);
void add(const double x, const double y, const double z, const double weight);
void setRefCoords(const TShapeFun& aShapeFun);
};
}
#endif

2173
src/MEDWrapper/Base/MED_GaussUtils.cxx Normal file
View File

File diff suppressed because it is too large Load Diff

366
src/MEDWrapper/Base/MED_GaussUtils.hxx Normal file
View File

@ -0,0 +1,366 @@
// Copyright (C) 2007-2013 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.
//
// 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_GaussUtils_HeaderFile
#define MED_GaussUtils_HeaderFile
#include "MED_WrapperBase.hxx"
#include "MED_Structures.hxx"
namespace MED
{
//---------------------------------------------------------------
typedef TVector<TCCoordSlice> TCCoordSliceArr;
typedef TVector<TCoordSlice> TCoordSliceArr;
//! Define a helper class to handle Gauss Points coordinates
class MEDWRAPPER_EXPORT TGaussCoord:
virtual TModeSwitchInfo
{
TInt myNbElem;
TInt myNbGauss;
TInt myDim;
TInt myGaussStep;
TNodeCoord myGaussCoord;
public:
TGaussCoord();
//! To init the class
void
Init(TInt theNbElem,
TInt theNbGauss,
TInt theDim,
EModeSwitch theMode = eFULL_INTERLACE);
TInt
GetNbElem() const;
TInt
GetNbGauss() const;
TInt
GetDim() const;
unsigned char*
GetValuePtr();
//! Get slice of the coordinate that corresponds to defined cell (const version)
TCCoordSliceArr
GetCoordSliceArr(TInt theElemId) const;
//! Get slice of the coordinate that corresponds to defined cell
TCoordSliceArr
GetCoordSliceArr(TInt theElemId);
};
typedef SharedPtr<TGaussCoord> PGaussCoord;
//---------------------------------------------------------------
//! To calculate Gauss Points coordinates
MEDWRAPPER_EXPORT
bool
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
bool
GetBaryCenter(const TCellInfo& theCellInfo,
const TNodeInfo& theNodeInfo,
TGaussCoord& theGaussCoord,
const TElemNum& theElemNum = TElemNum(),
EModeSwitch theMode = eFULL_INTERLACE);
//! To calculate Gauss Points coordinates for defined TPolygoneInfo as its bary center
MEDWRAPPER_EXPORT
bool
GetBaryCenter(const TPolygoneInfo& thePolygoneInfo,
const TNodeInfo& theNodeInfo,
TGaussCoord& theGaussCoord,
const TElemNum& theElemNum = TElemNum(),
EModeSwitch theMode = eFULL_INTERLACE);
//! To calculate Gauss Points coordinates for defined TPolyedreInfo as its bary center
MEDWRAPPER_EXPORT
bool
GetBaryCenter(const TPolyedreInfo& thePolyedreInfo,
const TNodeInfo& theNodeInfo,
TGaussCoord& theGaussCoord,
const TElemNum& theElemNum = TElemNum(),
EModeSwitch theMode = eFULL_INTERLACE);
//---------------------------------------------------------------
//! Shape function definitions
//---------------------------------------------------------------
struct MEDWRAPPER_EXPORT TShapeFun
{
class TFun;
TFloatVector myRefCoord;
TInt myDim;
TInt myNbRef;
TShapeFun(TInt theDim = 0, TInt theNbRef = 0);
TInt GetNbRef() const { return myNbRef; }
TCCoordSlice GetCoord(TInt theRefId) const;
TCoordSlice GetCoord(TInt theRefId);
void GetFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
virtual
void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const = 0;
virtual
bool IsSatisfy(const TCCoordSliceArr& theRefCoord) const;
bool Eval(const TCellInfo& theCellInfo,
const TNodeInfo& theNodeInfo,
const TElemNum& theElemNum,
const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TGaussCoord& theGaussCoord,
EModeSwitch theMode);
};
//---------------------------------------------------------------
struct TSeg2a: TShapeFun {
TSeg2a();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TSeg3a: TShapeFun {
TSeg3a();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TTria3a: TShapeFun {
TTria3a();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TTria6a: TShapeFun {
TTria6a();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TTria3b: TShapeFun {
TTria3b();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TTria6b: TShapeFun {
TTria6b();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TQuad4a: TShapeFun {
TQuad4a();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TQuad8a: TShapeFun {
TQuad8a();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TQuad9a: TShapeFun {
TQuad9a();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TQuad4b: TShapeFun {
TQuad4b();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TQuad8b: TShapeFun {
TQuad8b();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TQuad9b: TShapeFun {
TQuad9b();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TTetra4a: TShapeFun {
TTetra4a();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TTetra10a: TShapeFun {
TTetra10a();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TTetra4b: TShapeFun {
TTetra4b();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TTetra10b: TShapeFun {
TTetra10b();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct THexa8a: TShapeFun {
THexa8a();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct THexa20a: TShapeFun {
THexa20a(TInt theDim = 3, TInt theNbRef = 20);
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct THexa27a: THexa20a {
THexa27a();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct THexa8b: TShapeFun {
THexa8b();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct THexa20b: TShapeFun {
THexa20b(TInt theDim = 3, TInt theNbRef = 20);
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TPenta6a: TShapeFun {
TPenta6a();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TPenta6b: TShapeFun {
TPenta6b();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TPenta15a: TShapeFun {
TPenta15a();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TPenta15b: TShapeFun {
TPenta15b();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TPyra5a: TShapeFun {
TPyra5a();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TPyra5b: TShapeFun {
TPyra5b();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TPyra13a: TShapeFun {
TPyra13a();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
struct TPyra13b: TShapeFun {
TPyra13b();
virtual void InitFun(const TCCoordSliceArr& theRef,
const TCCoordSliceArr& theGauss,
TFun& theFun) const;
};
//---------------------------------------------------------------
}
#endif

96
src/MEDWrapper/Base/MED_SharedPtr.hxx Normal file
View File

@ -0,0 +1,96 @@
// Copyright (C) 2007-2013 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.
//
// 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_SharedPtr_HeaderFile
#define MED_SharedPtr_HeaderFile
#include <boost/shared_ptr.hpp>
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
for all of the MEDWrapper objects.
*/
template<class T> class SharedPtr: public boost::shared_ptr<T>
{
public:
//! Default constructor
SharedPtr() {}
//! Construct the class by any type of a pointer
template<class Y>
explicit SharedPtr(Y * p):
boost::shared_ptr<T>(p)
{}
//! Construct the class by any specialisation of the class
template<class Y>
SharedPtr(SharedPtr<Y> const & r):
boost::shared_ptr<T>(r,boost::detail::dynamic_cast_tag())
{}
//! Copy-constructor
template<class Y>
SharedPtr&
operator=(SharedPtr<Y> const & r)
{
boost::shared_ptr<T>(r,boost::detail::dynamic_cast_tag()).swap(*this);
return *this;
}
//! Introduce a flexible way to reset the wrapped pointer
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&
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
{
return *(this->get());
}
//! To provide a flexible way to use reference to the wrapped pointer
operator T& ()
{
return *(this->get());
}
};
}
#endif

186
src/MEDWrapper/Base/MED_SliceArray.hxx Normal file
View File

@ -0,0 +1,186 @@
// Copyright (C) 2007-2013 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.
//
// 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_SliceArray_HeaderFile
#define MED_SliceArray_HeaderFile
#ifdef WIN32 // for correctly compiling "valarray" in modules, which are includes this file
#undef max
#undef min
#endif
#include <valarray>
#include <stdexcept>
//#if defined(_DEBUG_)
# define MED_TCSLICE_CHECK_RANGE
//#endif
namespace MED
{
//---------------------------------------------------------------
//! This class intends to provide an uniform way to handle multy-dimention data (const version)
/*!
It just contains pointer to real sequence and implement proper calcultion of its indexes.
This class deal with constant pointer to the sources data and provide const method to
read the them (data).
*/
template<class TValueType>
class TCSlice
{
const TValueType* myCValuePtr; //!< Reference to source multy-dimension data
size_t mySourceSize; //!< Size of the source multy-dimension data
std::slice mySlice; //!< Defines algorithm of index calculation
protected:
void
check_id(size_t theId) const
{
long int anId = -1;
if(theId < mySlice.size()){
anId = mySlice.start() + theId*mySlice.stride();
if(anId < (long int)mySourceSize)
return;
}
throw std::out_of_range("TCSlice::check_id");
}
//! Calculate internal index to get proper element from the source multy-dimension data
size_t
calculate_id(size_t theId) const
{
return mySlice.start() + theId*mySlice.stride();
}
size_t
get_id(size_t theId) const
{
#ifdef MED_TCSLICE_CHECK_RANGE
check_id(theId);
#endif
return calculate_id(theId);
}
size_t
get_id_at(size_t theId) const
{
check_id(theId);
return calculate_id(theId);
}
public:
typedef TValueType value_type;
//! Construct the class from bare pointer
TCSlice(const value_type* theValuePtr,
size_t theSourceSize,
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):
myCValuePtr(&theContainer[0]),
mySourceSize(theContainer.size()),
mySlice(theSlice)
{}
//! Default constructor (dangerous)
TCSlice():
myCValuePtr(NULL)
{}
//! Get element by its number (const version)
const value_type&
operator[](size_t theId) const
{
return *(myCValuePtr + get_id(theId));
}
const value_type&
at(size_t theId) const
{
return *(myCValuePtr + get_id_at(theId));
}
//! Get range of the order numbers
size_t
size() const
{
return mySlice.size();
}
};
//---------------------------------------------------------------
//! This class extend TCSlice functionality for non-constant case
template<class TValueType>
class TSlice: public TCSlice<TValueType>
{
TValueType* myValuePtr;
public:
typedef TValueType value_type;
typedef TCSlice<TValueType> TSupperClass;
//! Construct the class from bare pointer
TSlice(value_type* theValuePtr,
size_t theSourceSize,
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):
TSupperClass(theContainer, theSlice),
myValuePtr(&theContainer[0])
{}
//! Default constructor (dangerous)
TSlice():
myValuePtr(NULL)
{}
//! Get element by its number
value_type&
operator[](size_t theId)
{
return *(myValuePtr + this->get_id(theId));
}
value_type&
at(size_t theId)
{
return *(myValuePtr + this->get_id_at(theId));
}
};
}
#undef MED_TCSLICE_CHECK_RANGE
#endif

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

@ -0,0 +1,865 @@
// Copyright (C) 2007-2013 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.
//
// 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;
}

1081
src/MEDWrapper/Base/MED_Structures.hxx Normal file
View File

File diff suppressed because it is too large Load Diff

1216
src/MEDWrapper/Base/MED_TStructures.hxx Normal file
View File

File diff suppressed because it is too large Load Diff

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

@ -0,0 +1,578 @@
// Copyright (C) 2007-2013 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.
//
// 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 Normal file
View File

@ -0,0 +1,113 @@
// Copyright (C) 2007-2013 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.
//
// 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);
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;
}

74
src/MEDWrapper/Base/MED_Utilities.hxx Normal file
View File

@ -0,0 +1,74 @@
// Copyright (C) 2007-2013 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.
//
// 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_Utilities_HeaderFile
#define MED_Utilities_HeaderFile
#include "MED_WrapperBase.hxx"
#include <iostream>
#include <sstream>
#include <string>
#include <string.h>
#include <stdexcept>
namespace MED
{
class MEDWRAPPER_EXPORT PrefixPrinter
{
static int myCounter;
bool myIsActive;
public:
PrefixPrinter(bool theIsActive = true);
~PrefixPrinter();
static std::string GetPrefix();
};
}
#ifdef _DEBUG_
#define MSG(deb,msg) if(deb) std::cout<<MED::PrefixPrinter::GetPrefix()<<msg<<" ("<<__FILE__<<" ["<<__LINE__<<"])\n"
#define BEGMSG(deb,msg) if(deb) std::cout<<MED::PrefixPrinter::GetPrefix()<<msg
#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
#define MSG(deb,msg)
#define BEGMSG(deb,msg)
#define INITMSGA(deb,lev,msg)
#define INITMSG(deb,msg)
#define ADDMSG(deb,msg)
#endif
#ifndef EXCEPTION
#define EXCEPTION(TYPE, MSG) {\
std::ostringstream aStream;\
aStream<<__FILE__<<"["<<__LINE__<<"]::"<<MSG;\
throw TYPE(aStream.str().c_str());\
}
#endif
#endif

153
src/MEDWrapper/Base/MED_Vector.hxx Normal file
View File

@ -0,0 +1,153 @@
// Copyright (C) 2007-2013 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.
//
// 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_Vector_HeaderFile
#define MED_Vector_HeaderFile
#include <vector>
#include <stdexcept>
//#if defined(_DEBUG_)
# define MED_TVECTOR_CHECK_RANGE
//#endif
namespace MED
{
//! Main purpose to introduce the class was to customize operator []
template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
class TVector : public std::vector<_Tp, _Alloc>
{
public:
typedef size_t size_type;
typedef std::vector<_Tp, _Alloc> superclass;
typedef typename superclass::allocator_type allocator_type;
typedef _Tp value_type;
typedef value_type& reference;
typedef const value_type& const_reference;
protected:
void
check_range(size_type __n) const
{
if (__n >= this->size())
throw std::out_of_range("TVector [] access out of range");
}
const_reference
get_value(size_type __n) const
{
return superclass::operator[](__n);
}
reference
get_value(size_type __n)
{
return superclass::operator[](__n);
}
public:
explicit
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)
{}
TVector(const TVector& __x):
superclass(__x)
{}
template<typename _InputIterator>
TVector(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type()):
superclass(__first, __last, __a)
{}
template<typename _Yp, typename _Al>
TVector(TVector<_Yp, _Al> __y):
superclass(__y.begin(), __y.end())
{}
TVector&
operator=(const TVector& __x)
{
superclass::operator=(__x);
return *this;
}
template<typename _Yp, typename _Al>
TVector&
operator=(TVector<_Yp, _Al> __y)
{
this->assign(__y.begin(), __y.end());
return *this;
}
reference
operator[](size_type __n)
{
#if defined(MED_TVECTOR_CHECK_RANGE)
check_range(__n);
#endif
return get_value(__n);
}
const_reference
operator[](size_type __n) const
{
#if defined(MED_TVECTOR_CHECK_RANGE)
check_range(__n);
#endif
return get_value(__n);
}
reference
at(size_type __n)
{
check_range(__n);
return get_value(__n);
}
const_reference
at(size_type __n) const
{
check_range(__n);
return get_value(__n);
}
};
}
#undef MED_TVECTOR_CHECK_RANGE
#endif

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

@ -0,0 +1,707 @@
// Copyright (C) 2007-2013 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.
//
// 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;
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 Normal file
View File

File diff suppressed because it is too large Load Diff

46
src/MEDWrapper/Base/MED_WrapperBase.hxx Executable file
View File

@ -0,0 +1,46 @@
// Copyright (C) 2007-2013 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.
//
// 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_WrapperBase.hxx
// Author : Alexander A. BORODIN
//
#ifndef _MED_WrapperBase_HXX_
#define _MED_WrapperBase_HXX_
#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
#else
#define MEDWRAPPER_EXPORT
#endif
#endif

52
src/MEDWrapper/Base/Makefile.am Normal file
View File

@ -0,0 +1,52 @@
# Copyright (C) 2007-2013 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.
#
# 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 $(top_srcdir)/adm_local/unix/make_common_starter.am
lib_LTLIBRARIES= libMEDWrapperBase.la
salomeinclude_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
dist_libMEDWrapperBase_la_SOURCES= \
MED_Structures.cxx \
MED_Wrapper.cxx \
MED_Algorithm.cxx \
MED_GaussUtils.cxx \
MED_CoordUtils.cxx \
MED_Utilities.cxx \
MED_GaussDef.cxx
libMEDWrapperBase_la_CPPFLAGS= $(BOOST_CPPFLAGS) $(HDF5_INCLUDES) -D@MACHINE@
libMEDWrapperBase_la_CPPFLAGS+= -I$(KERNEL_ROOT_DIR)/include/salome
libMEDWrapperBase_la_CPPFLAGS+= $(MED_CPPFLAGS)
libMEDWrapperBase_la_LDFLAGS= $(BOOST_LIB_THREAD) $(BOOST_LIB_SYSTEM) $(BOOST_LIB_DATE_TIME)

22
src/MEDWrapper/CMakeLists.txt Normal file
View File

@ -0,0 +1,22 @@
# Copyright (C) 2012-2013 CEA/DEN, EDF R&D
#
# 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.
#
# 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
#
ADD_SUBDIRECTORY(Base)
ADD_SUBDIRECTORY(V2_2)
ADD_SUBDIRECTORY(Factory)

57
src/MEDWrapper/Factory/CMakeLists.txt Normal file
View File

@ -0,0 +1,57 @@
# Copyright (C) 2012-2013 CEA/DEN, EDF R&D
#
# 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.
#
# 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_DIRECTORIES(
${HDF5_INCLUDE_DIRS}
${BOOST_INCLUDE_DIRS}
${MED3_INCLUDE_DIRS}
${CMAKE_CURRENT_SOURCE_DIR}/../Base
${CMAKE_CURRENT_SOURCE_DIR}/../V2_2
)
IF(MED_ENABLE_KERNEL)
INCLUDE_DIRECTORIES(${KERNEL_ROOT_DIR}/include/salome)
ELSE(MED_ENABLE_KERNEL)
INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR}/adm_local_without_kernel)
ENDIF(MED_ENABLE_KERNEL)
SET(MEDWrapper_SOURCES
MED_Factory.cxx
)
SET(mprint_version_SOURCES
mprint_version.cxx
)
ADD_LIBRARY(MEDWrapper SHARED ${MEDWrapper_SOURCES})
SET_TARGET_PROPERTIES(MEDWrapper PROPERTIES COMPILE_FLAGS "${BOOST_DEFINITIONS} ${MED3_DEFINITIONS} ${PLATFORM_DEFINITIONS}")
TARGET_LINK_LIBRARIES(MEDWrapper MEDWrapper_V2_2)
INSTALL(TARGETS MEDWrapper DESTINATION ${MED_salomelib_LIBS})
ADD_EXECUTABLE(mprint_version ${mprint_version_SOURCES})
SET_TARGET_PROPERTIES(mprint_version PROPERTIES COMPILE_FLAGS "${BOOST_DEFINITIONS} ${MED3_DEFINITIONS} ${PLATFORM_DEFINITIONS}")
TARGET_LINK_LIBRARIES(mprint_version MEDWrapper MEDWrapper_V2_2 MEDWrapperBase ${BOOST_LIBS} ${MED3_LIBS_C_ONLY})
ADD_EXECUTABLE(MED_Test ${mprint_version_SOURCES})
SET_TARGET_PROPERTIES(MED_Test PROPERTIES COMPILE_FLAGS "${BOOST_DEFINITIONS} ${MED3_DEFINITIONS} ${PLATFORM_DEFINITIONS}")
TARGET_LINK_LIBRARIES(MED_Test MEDWrapper MEDWrapper_V2_2 MEDWrapperBase ${BOOST_LIBS})
FILE(GLOB MEDWrapper_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
INSTALL(FILES ${MEDWrapper_HEADERS_HXX} DESTINATION ${MED_salomeinclude_HEADERS})
INSTALL(TARGETS mprint_version MED_Test DESTINATION ${MED_salomebin_BINS})

164
src/MEDWrapper/Factory/MED_Factory.cxx Normal file
View File

@ -0,0 +1,164 @@
// Copyright (C) 2007-2013 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.
//
// 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 <sstream>
extern "C"
{
#include <med.h>
#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("MED_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<<std::endl);
if(aStatus != 0)
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;
}
}

48
src/MEDWrapper/Factory/MED_Factory.hxx Normal file
View File

@ -0,0 +1,48 @@
// Copyright (C) 2007-2013 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.
//
// 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_Factory_HeaderFile
#define MED_Factory_HeaderFile
#include "MED_WrapperFactory.hxx"
#include "MED_Wrapper.hxx"
namespace MED
{
MEDWRAPPER_FACTORY_EXPORT
EVersion
GetVersionId(const std::string& theFileName,
bool theDoPreCheckInSeparateProcess = false);
MEDWRAPPER_FACTORY_EXPORT
bool getMEDVersion( const std::string&, int&, int&, int& );
MEDWRAPPER_FACTORY_EXPORT
PWrapper
CrWrapper(const std::string& theFileName,
bool theDoPreCheckInSeparateProcess = false);
MEDWRAPPER_FACTORY_EXPORT
PWrapper
CrWrapper(const std::string& theFileName, EVersion theId);
}
#endif

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

@ -0,0 +1,347 @@
// Copyright (C) 2007-2013 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.
//
// 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;
}

46
src/MEDWrapper/Factory/MED_WrapperFactory.hxx Executable file
View File

@ -0,0 +1,46 @@
// Copyright (C) 2007-2013 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.
//
// 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_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
#else
#define MEDWRAPPER_FACTORY_EXPORT
#endif
#endif

47
src/MEDWrapper/Factory/Makefile.am Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2007-2013 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.
#
# 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 $(top_srcdir)/adm_local/unix/make_common_starter.am
lib_LTLIBRARIES= libMEDWrapper.la
salomeinclude_HEADERS= \
MED_Factory.hxx \
MED_WrapperFactory.hxx
dist_libMEDWrapper_la_SOURCES= \
MED_Factory.cxx
libMEDWrapper_la_CPPFLAGS= $(BOOST_CPPFLAGS) $(MED3_INCLUDES) \
-I$(srcdir)/../Base
libMEDWrapper_la_CPPFLAGS+= -I$(KERNEL_ROOT_DIR)/include/salome
libMEDWrapper_la_CPPFLAGS+= -I$(srcdir)/../V2_2
libMEDWrapper_la_LDFLAGS= ../V2_2/libMEDWrapper_V2_2.la
# Executables targets
bin_PROGRAMS = MED_Test mprint_version
dist_MED_Test_SOURCES= MED_Test.cxx
MED_Test_CPPFLAGS= $(libMEDWrapper_la_CPPFLAGS)
MED_Test_LDADD= $(libMEDWrapper_la_LDFLAGS) ../Base/libMEDWrapperBase.la \
$(BOOST_LIB_THREAD) $(BOOST_LIB_SYSTEM) libMEDWrapper.la
dist_mprint_version_SOURCES= mprint_version.cxx
mprint_version_CPPFLAGS= $(libMEDWrapper_la_CPPFLAGS)
mprint_version_LDADD= $(libMEDWrapper_la_LDFLAGS) ../Base/libMEDWrapperBase.la \
$(BOOST_LIB_THREAD) $(BOOST_LIB_SYSTEM) libMEDWrapper.la $(MED3_LIBS_C_ONLY)

44
src/MEDWrapper/Factory/mprint_version.cxx Normal file
View File

@ -0,0 +1,44 @@
// Copyright (C) 2007-2013 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.
//
// 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.h>
#include <stdio.h>
#include <stdlib.h>
int main (int argc, char **argv)
{
med_idt aFid = MEDfileOpen(argv[1],MED_ACC_RDONLY);
if(aFid < 0)
exit(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;
}
printf("%d.%d.%d\n",aMajor,aMinor,aRelease);
}

23
src/MEDWrapper/Makefile.am Normal file
View File

@ -0,0 +1,23 @@
# Copyright (C) 2007-2013 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.
#
# 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 $(top_srcdir)/adm_local/unix/make_common_starter.am
SUBDIRS = Base V2_2 Factory
DIST_SUBDIRS = Base V2_2 Factory

43
src/MEDWrapper/V2_2/CMakeLists.txt Normal file
View File

@ -0,0 +1,43 @@
# Copyright (C) 2012-2013 CEA/DEN, EDF R&D
#
# 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.
#
# 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_DIRECTORIES(
${MED3_INCLUDE_DIRS}
${HDF5_INCLUDE_DIRS}
${BOOST_INCLUDE_DIRS}
${CMAKE_CURRENT_SOURCE_DIR}/../Base
)
SET(MEDWrapper_V2_2_SOURCES
MED_V2_2_Wrapper.cxx
)
IF(MED_ENABLE_KERNEL)
INCLUDE_DIRECTORIES(${KERNEL_ROOT_DIR}/include/salome)
ELSE(MED_ENABLE_KERNEL)
INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR}/adm_local_without_kernel)
ENDIF(MED_ENABLE_KERNEL)
ADD_LIBRARY(MEDWrapper_V2_2 SHARED ${MEDWrapper_V2_2_SOURCES})
SET_TARGET_PROPERTIES(MEDWrapper_V2_2 PROPERTIES COMPILE_FLAGS "${HDF5_DEFINITIONS} ${MED3_DEFINITIONS} ${BOOST_DEFINITIONS} ${PLATFORM_DEFINITIONS}")
TARGET_LINK_LIBRARIES(MEDWrapper_V2_2 MEDWrapperBase ${MED3_LIBS_C_ONLY} ${HDF5_LIBS})
INSTALL(TARGETS MEDWrapper_V2_2 DESTINATION ${MED_salomelib_LIBS})
FILE(GLOB MEDWrapper_V2_2_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
INSTALL(FILES ${MEDWrapper_V2_2_HEADERS_HXX} DESTINATION ${MED_salomeinclude_HEADERS})

2878
src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx Normal file
View File

File diff suppressed because it is too large Load Diff

490
src/MEDWrapper/V2_2/MED_V2_2_Wrapper.hxx Normal file
View File

@ -0,0 +1,490 @@
// Copyright (C) 2007-2013 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.
//
// 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

32
src/MEDWrapper/V2_2/Makefile.am Normal file
View File

@ -0,0 +1,32 @@
# Copyright (C) 2007-2013 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.
#
# 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 $(top_srcdir)/adm_local/unix/make_common_starter.am
lib_LTLIBRARIES= libMEDWrapper_V2_2.la
salomeinclude_HEADERS = \
MED_V2_2_Wrapper.hxx
dist_libMEDWrapper_V2_2_la_SOURCES = \
MED_V2_2_Wrapper.cxx
libMEDWrapper_V2_2_la_CPPFLAGS= $(BOOST_CPPFLAGS) $(MED3_INCLUDES) $(HDF5_INCLUDES) -I$(srcdir)/../Base
libMEDWrapper_V2_2_la_CPPFLAGS+= -I$(KERNEL_ROOT_DIR)/include/salome
libMEDWrapper_V2_2_la_LDFLAGS= $(MED3_LIBS_C_ONLY) $(HDF5_LIBS)
libMEDWrapper_V2_2_la_LIBADD= ../Base/libMEDWrapperBase.la

1
src/Makefile.am
View File

@ -34,6 +34,7 @@ SUBDIRS = \
SMESHUtils \
Controls \
Driver \
MEDWrapper \
DriverMED \
DriverDAT \
DriverUNV \