From 7ec258416f5fd16634ee4ab7c789f9af809dee18 Mon Sep 17 00:00:00 2001 From: eap Date: Mon, 24 Jun 2013 10:06:18 +0000 Subject: [PATCH] CoTech decision: move MEDWrapper from MED to SMESH + MEDWrapper \ --- src/DriverMED/DriverMED.hxx | 28 + src/DriverMED/DriverMED_Family.h | 4 +- src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx | 52 +- src/DriverMED/DriverMED_R_SMESHDS_Mesh.h | 16 +- src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx | 18 +- src/DriverMED/DriverMED_W_SMESHDS_Mesh.h | 6 +- src/DriverMED/Makefile.am | 15 +- src/MEDWrapper/Base/CMakeLists.txt | 47 + src/MEDWrapper/Base/MED_Algorithm.cxx | 375 +++ src/MEDWrapper/Base/MED_Algorithm.hxx | 157 + src/MEDWrapper/Base/MED_Common.hxx | 186 ++ src/MEDWrapper/Base/MED_CoordUtils.cxx | 160 + src/MEDWrapper/Base/MED_CoordUtils.hxx | 57 + src/MEDWrapper/Base/MED_GaussDef.cxx | 570 ++++ src/MEDWrapper/Base/MED_GaussDef.hxx | 69 + src/MEDWrapper/Base/MED_GaussUtils.cxx | 2173 +++++++++++++ src/MEDWrapper/Base/MED_GaussUtils.hxx | 366 +++ src/MEDWrapper/Base/MED_SharedPtr.hxx | 96 + src/MEDWrapper/Base/MED_SliceArray.hxx | 186 ++ src/MEDWrapper/Base/MED_Structures.cxx | 865 +++++ src/MEDWrapper/Base/MED_Structures.hxx | 1081 +++++++ src/MEDWrapper/Base/MED_TStructures.hxx | 1216 +++++++ src/MEDWrapper/Base/MED_TWrapper.hxx | 578 ++++ src/MEDWrapper/Base/MED_Utilities.cxx | 113 + src/MEDWrapper/Base/MED_Utilities.hxx | 74 + src/MEDWrapper/Base/MED_Vector.hxx | 153 + src/MEDWrapper/Base/MED_Wrapper.cxx | 707 ++++ src/MEDWrapper/Base/MED_Wrapper.hxx | 1052 ++++++ src/MEDWrapper/Base/MED_WrapperBase.hxx | 46 + src/MEDWrapper/Base/Makefile.am | 52 + src/MEDWrapper/CMakeLists.txt | 22 + src/MEDWrapper/Factory/CMakeLists.txt | 57 + src/MEDWrapper/Factory/MED_Factory.cxx | 164 + src/MEDWrapper/Factory/MED_Factory.hxx | 48 + src/MEDWrapper/Factory/MED_Test.cxx | 347 ++ src/MEDWrapper/Factory/MED_WrapperFactory.hxx | 46 + src/MEDWrapper/Factory/Makefile.am | 47 + src/MEDWrapper/Factory/mprint_version.cxx | 44 + src/MEDWrapper/Makefile.am | 23 + src/MEDWrapper/V2_2/CMakeLists.txt | 43 + src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx | 2878 +++++++++++++++++ src/MEDWrapper/V2_2/MED_V2_2_Wrapper.hxx | 490 +++ src/MEDWrapper/V2_2/Makefile.am | 32 + src/Makefile.am | 1 + 44 files changed, 14713 insertions(+), 47 deletions(-) create mode 100644 src/DriverMED/DriverMED.hxx create mode 100644 src/MEDWrapper/Base/CMakeLists.txt create mode 100644 src/MEDWrapper/Base/MED_Algorithm.cxx create mode 100644 src/MEDWrapper/Base/MED_Algorithm.hxx create mode 100644 src/MEDWrapper/Base/MED_Common.hxx create mode 100644 src/MEDWrapper/Base/MED_CoordUtils.cxx create mode 100644 src/MEDWrapper/Base/MED_CoordUtils.hxx create mode 100644 src/MEDWrapper/Base/MED_GaussDef.cxx create mode 100644 src/MEDWrapper/Base/MED_GaussDef.hxx create mode 100644 src/MEDWrapper/Base/MED_GaussUtils.cxx create mode 100644 src/MEDWrapper/Base/MED_GaussUtils.hxx create mode 100644 src/MEDWrapper/Base/MED_SharedPtr.hxx create mode 100644 src/MEDWrapper/Base/MED_SliceArray.hxx create mode 100644 src/MEDWrapper/Base/MED_Structures.cxx create mode 100644 src/MEDWrapper/Base/MED_Structures.hxx create mode 100644 src/MEDWrapper/Base/MED_TStructures.hxx create mode 100644 src/MEDWrapper/Base/MED_TWrapper.hxx create mode 100644 src/MEDWrapper/Base/MED_Utilities.cxx create mode 100644 src/MEDWrapper/Base/MED_Utilities.hxx create mode 100644 src/MEDWrapper/Base/MED_Vector.hxx create mode 100644 src/MEDWrapper/Base/MED_Wrapper.cxx create mode 100644 src/MEDWrapper/Base/MED_Wrapper.hxx create mode 100755 src/MEDWrapper/Base/MED_WrapperBase.hxx create mode 100644 src/MEDWrapper/Base/Makefile.am create mode 100644 src/MEDWrapper/CMakeLists.txt create mode 100644 src/MEDWrapper/Factory/CMakeLists.txt create mode 100644 src/MEDWrapper/Factory/MED_Factory.cxx create mode 100644 src/MEDWrapper/Factory/MED_Factory.hxx create mode 100644 src/MEDWrapper/Factory/MED_Test.cxx create mode 100755 src/MEDWrapper/Factory/MED_WrapperFactory.hxx create mode 100644 src/MEDWrapper/Factory/Makefile.am create mode 100644 src/MEDWrapper/Factory/mprint_version.cxx create mode 100644 src/MEDWrapper/Makefile.am create mode 100644 src/MEDWrapper/V2_2/CMakeLists.txt create mode 100644 src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx create mode 100644 src/MEDWrapper/V2_2/MED_V2_2_Wrapper.hxx create mode 100644 src/MEDWrapper/V2_2/Makefile.am diff --git a/src/DriverMED/DriverMED.hxx b/src/DriverMED/DriverMED.hxx new file mode 100644 index 000000000..c2bee4b5f --- /dev/null +++ b/src/DriverMED/DriverMED.hxx @@ -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 + +class DriverMED_Family; +typedef boost::shared_ptr DriverMED_FamilyPtr; diff --git a/src/DriverMED/DriverMED_Family.h b/src/DriverMED/DriverMED_Family.h index 1cd35e271..c64c17f7c 100644 --- a/src/DriverMED/DriverMED_Family.h +++ b/src/DriverMED/DriverMED_Family.h @@ -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_FamilyPtr; typedef std::list DriverMED_FamilyPtrList; typedef std::map SMESHDS_SubMeshPtrMap; typedef std::list SMESHDS_GroupBasePtrList; diff --git a/src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx b/src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx index cd6243d16..b4ca1a08f 100644 --- a/src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx +++ b/src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx @@ -52,6 +52,26 @@ static int MYDEBUG = 0; using namespace MED; using namespace std; +typedef std::map 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::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()); } diff --git a/src/DriverMED/DriverMED_R_SMESHDS_Mesh.h b/src/DriverMED/DriverMED_R_SMESHDS_Mesh.h index 5e4459a32..71d38ef78 100644 --- a/src/DriverMED/DriverMED_R_SMESHDS_Mesh.h +++ b/src/DriverMED/DriverMED_R_SMESHDS_Mesh.h @@ -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 +#include class SMESHDS_Mesh; class SMESHDS_Group; @@ -53,18 +55,6 @@ class MESHDRIVERMED_EXPORT DriverMED_R_SMESHDS_Mesh: public Driver_SMESHDS_Mesh std::list 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 myFamilies; diff --git a/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx b/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx index 9289fb236..aa89eea40 100644 --- a/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx +++ b/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx @@ -24,19 +24,19 @@ // File : DriverMED_W_SMESHDS_Mesh.cxx // Module : SMESH // -#include #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 -#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 : "<GetName()); myMed->SetMeshInfo(aMeshInfo); diff --git a/src/DriverMED/DriverMED_W_SMESHDS_Mesh.h b/src/DriverMED/DriverMED_W_SMESHDS_Mesh.h index 95daf9fa6..30d1f475f 100644 --- a/src/DriverMED/DriverMED_W_SMESHDS_Mesh.h +++ b/src/DriverMED/DriverMED_W_SMESHDS_Mesh.h @@ -30,7 +30,7 @@ #include "SMESH_DriverMED.hxx" #include "Driver_SMESHDS_Mesh.h" -#include "MED_Factory.hxx" +#include "MED_Common.hxx" #include #include @@ -72,7 +72,7 @@ class MESHDRIVERMED_EXPORT DriverMED_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh private: - MED::PWrapper myMed; + MED::EVersion myMedVersion; std::list myGroups; bool myAllSubMeshes; std::map mySubMeshes; @@ -85,6 +85,4 @@ class MESHDRIVERMED_EXPORT DriverMED_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh bool myAutoDimension; }; - #endif - diff --git a/src/DriverMED/Makefile.am b/src/DriverMED/Makefile.am index 13ac7d451..dc58802a1 100644 --- a/src/DriverMED/Makefile.am +++ b/src/DriverMED/Makefile.am @@ -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) diff --git a/src/MEDWrapper/Base/CMakeLists.txt b/src/MEDWrapper/Base/CMakeLists.txt new file mode 100644 index 000000000..2d7fe409d --- /dev/null +++ b/src/MEDWrapper/Base/CMakeLists.txt @@ -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}) diff --git a/src/MEDWrapper/Base/MED_Algorithm.cxx b/src/MEDWrapper/Base/MED_Algorithm.cxx new file mode 100644 index 000000000..afe4ab7de --- /dev/null +++ b/src/MEDWrapper/Base/MED_Algorithm.cxx @@ -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() = "<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 = '"<second; + TFamilyInfoSet::const_iterator anFamIter = aFamilyInfoSet.begin(); + for(; anFamIter != aFamilyInfoSet.end(); anFamIter++){ + const PFamilyInfo& aFamilyInfo = *anFamIter; + INITMSG(MYDEBUG,"aFamilyName = '"<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() = "<GetPFieldInfo(theMeshInfo,iField); + INITMSG(MYDEBUG,"aFieldName = '"<GetName()<< + "'; aNbComp = "<GetNbComp()<<"; "); + TGeom2Size aGeom2Size; + EEntiteMaillage anEntity = EEntiteMaillage(-1); + TInt aNbTimeStamps = theWrapper->GetNbTimeStamps(aFieldInfo,theEntityInfo,anEntity,aGeom2Size); + ADDMSG(MYDEBUG,"anEntity = "<GetPTimeStampInfo(aFieldInfo,anEntity,aGeom2Size,iTimeStamp); + aFieldInfo2TimeStampInfoSet[aFieldInfo].insert(aTimeStamp); + INITMSG(MYDEBUG, + "aDt = "<GetDt()<< + ", Unit = \'"<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 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 TFamilyID2Size; + typedef std::map 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 = "<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 = '"<GetName()<< + "' anId = "<GetId()<<"\n"); + } + } + } + } + } + ADDMSG(MYDEBUG,"\n"); + return anEntity2FamilySet; + } + + + //--------------------------------------------------------------- + TKey2Gauss + GetKey2Gauss(const PWrapper& theWrapper, + TErr* theErr, + EModeSwitch theMode) + { + INITMSG(MYDEBUG,"GetKey2Gauss - theMode = "<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 = "<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 = "<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 = '"<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; iGetFamNumNode(i)] = 0; + for(TInt i=0; iGetFamNum(i)] = 0; + for(TInt i=0; iGetFamNumNode(i)] += 1; + for(TInt i=0; iGetFamNum(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); + + } + } +} diff --git a/src/MEDWrapper/Base/MED_Algorithm.hxx b/src/MEDWrapper/Base/MED_Algorithm.hxx new file mode 100644 index 000000000..ee7ac3780 --- /dev/null +++ b/src/MEDWrapper/Base/MED_Algorithm.hxx @@ -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 + +namespace MED +{ + //--------------------------------------------------------------- + typedef std::map TGeom2ElemInfo; + typedef std::map 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 TFamilyInfoSet; + + //! Read set of MED FAMILIES for defined MED file + MEDWRAPPER_EXPORT + TFamilyInfoSet + GetFamilyInfoSet(const PWrapper& theWrapper, + const PMeshInfo& theMeshInfo); + + + //--------------------------------------------------------------- + typedef boost::tuple TFamilyTSize; + + bool + operator<(const TFamilyTSize& theLeft, const TFamilyTSize& theRight); + typedef std::set TFamilyTSizeSet; + + + //--------------------------------------------------------------- + typedef std::map 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 TGroupInfo; + + //! Split the input set of MED FAMILIES by corresponding MED GROUPS + MEDWRAPPER_EXPORT + TGroupInfo + GetGroupInfo(const TFamilyInfoSet& theFamilyInfoSet); + + + //--------------------------------------------------------------- + typedef std::set TTimeStampInfoSet; + typedef std::map 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 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 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 TKey2Profile; + typedef boost::tuple 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 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 diff --git a/src/MEDWrapper/Base/MED_Common.hxx b/src/MEDWrapper/Base/MED_Common.hxx new file mode 100644 index 000000000..4715f6c85 --- /dev/null +++ b/src/MEDWrapper/Base/MED_Common.hxx @@ -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 +#include +#include + +#include + +#include + +#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 TFloatVector; + typedef TVector TStringVector; + typedef TVector TIntVector; + typedef std::set TStringSet; + + typedef std::map TGeom2Size; + typedef std::map TEntityInfo; + + typedef std::set TGeomSet; + typedef std::map TEntity2GeomSet; + + MEDWRAPPER_EXPORT + const TEntity2GeomSet& + GetEntity2GeomSet(); + + template + TInt MEDWRAPPER_EXPORT + GetDESCLength(); + + template + TInt MEDWRAPPER_EXPORT + GetIDENTLength(); + + template + TInt MEDWRAPPER_EXPORT + GetNOMLength(); + + template + TInt MEDWRAPPER_EXPORT + GetLNOMLength(); + + template + TInt MEDWRAPPER_EXPORT + GetPNOMLength(); + + template + void MEDWRAPPER_EXPORT + GetVersionRelease(TInt& majeur, TInt& mineur, TInt& release); + + template + MEDWRAPPER_EXPORT + TInt + GetNbConn(EGeometrieElement typmai, + EEntiteMaillage typent, + TInt mdim); + + MEDWRAPPER_EXPORT + TInt + GetNbNodes(EGeometrieElement typmai); + + struct TNameInfo; + typedef SharedPtr PNameInfo; + + struct TMeshInfo; + typedef SharedPtr PMeshInfo; + + struct TFamilyInfo; + typedef SharedPtr PFamilyInfo; + + struct TElemInfo; + typedef SharedPtr PElemInfo; + + struct TNodeInfo; + typedef SharedPtr PNodeInfo; + + struct TPolygoneInfo; + typedef SharedPtr PPolygoneInfo; + + struct TPolyedreInfo; + typedef SharedPtr PPolyedreInfo; + + struct TCellInfo; + typedef SharedPtr PCellInfo; + + struct TBallInfo; + typedef SharedPtr PBallInfo; + + struct TFieldInfo; + typedef SharedPtr PFieldInfo; + + struct TTimeStampInfo; + typedef SharedPtr PTimeStampInfo; + + struct TProfileInfo; + typedef SharedPtr PProfileInfo; + + struct TGaussInfo; + typedef SharedPtr PGaussInfo; + + class TGrilleInfo; + typedef SharedPtr PGrilleInfo; + + struct TTimeStampValueBase; + typedef SharedPtr PTimeStampValueBase; + + struct TWrapper; + typedef SharedPtr PWrapper; +} + + +#endif diff --git a/src/MEDWrapper/Base/MED_CoordUtils.cxx b/src/MEDWrapper/Base/MED_CoordUtils.cxx new file mode 100644 index 000000000..21f9162b0 --- /dev/null +++ b/src/MEDWrapper/Base/MED_CoordUtils.cxx @@ -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 + TFloat + GetCoord(const TCCoordSlice& theCoordSlice) + { + return theCoordSlice[TCoordId]; + } + + template<> + TFloat + GetCoord(const TCCoordSlice& theCoordSlice) + { + return 0.0; + } + + TGetCoord + aXYZGetCoord[3] = { + &GetCoord, + &GetCoord, + &GetCoord + }; + + TGetCoord + aXYGetCoord[3] = { + &GetCoord, + &GetCoord, + &GetCoord + }; + + TGetCoord + aYZGetCoord[3] = { + &GetCoord, + &GetCoord, + &GetCoord + }; + + TGetCoord + aXZGetCoord[3] = { + &GetCoord, + &GetCoord, + &GetCoord + }; + + + TGetCoord + aXGetCoord[3] = { + &GetCoord, + &GetCoord, + &GetCoord + }; + + TGetCoord + aYGetCoord[3] = { + &GetCoord, + &GetCoord, + &GetCoord + }; + + TGetCoord + aZGetCoord[3] = { + &GetCoord, + &GetCoord, + &GetCoord + }; + + + //--------------------------------------------------------------- + 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; + } +} diff --git a/src/MEDWrapper/Base/MED_CoordUtils.hxx b/src/MEDWrapper/Base/MED_CoordUtils.hxx new file mode 100644 index 000000000..17b09d761 --- /dev/null +++ b/src/MEDWrapper/Base/MED_CoordUtils.hxx @@ -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 PCoordHelper; + + + //--------------------------------------------------------------- + MEDWRAPPER_EXPORT + PCoordHelper + GetCoordHelper(PNodeInfo theNodeInfo); + +} + +#endif diff --git a/src/MEDWrapper/Base/MED_GaussDef.cxx b/src/MEDWrapper/Base/MED_GaussDef.cxx new file mode 100644 index 000000000..f89042e58 --- /dev/null +++ b/src/MEDWrapper/Base/MED_GaussDef.cxx @@ -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"< 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: " < + +namespace MED +{ + class TShapeFun; + typedef std::vector 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)== + + /*! + * \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 diff --git a/src/MEDWrapper/Base/MED_GaussUtils.cxx b/src/MEDWrapper/Base/MED_GaussUtils.cxx new file mode 100644 index 000000000..9ae82dfb3 --- /dev/null +++ b/src/MEDWrapper/Base/MED_GaussUtils.cxx @@ -0,0 +1,2173 @@ +// 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_GaussUtils.hxx" +#include "MED_Utilities.hxx" + +#ifdef _DEBUG_ +static int MYDEBUG = 0; +static int MYVALUEDEBUG = 0; +#else +// static int MYDEBUG = 0; +// static int MYVALUEDEBUG = 0; +#endif + +//#define _DEBUG_REF_COORDS_ + +namespace MED +{ + //--------------------------------------------------------------- + TGaussCoord + ::TGaussCoord(): + TModeSwitchInfo(eFULL_INTERLACE), + myNbElem(0), + myNbGauss(0), + myDim(0), + myGaussStep(0) + { + } + + void + TGaussCoord + ::Init(TInt theNbElem, + TInt theNbGauss, + TInt theDim, + EModeSwitch theMode) + { + myModeSwitch = theMode; + + myNbElem = theNbElem; + myNbGauss = theNbGauss; + myDim = theDim; + + myGaussStep = myNbGauss*myDim; + + myGaussCoord.resize(theNbElem*myGaussStep); + } + + + TInt + TGaussCoord + ::GetNbElem() const + { + return myNbElem; + } + + TInt + TGaussCoord + ::GetNbGauss() const + { + return myNbGauss; + } + + TInt + TGaussCoord + ::GetDim() const + { + return myDim; + } + + unsigned char* + TGaussCoord + ::GetValuePtr() + { + return (unsigned char*)&(myGaussCoord[0]); + } + + + TCCoordSliceArr + TGaussCoord + ::GetCoordSliceArr(TInt theElemId) const + { + TCCoordSliceArr aCoordSliceArr(myNbGauss); + if(GetModeSwitch() == eFULL_INTERLACE){ + TInt anId = theElemId*myGaussStep; + for(TInt anGaussId = 0; anGaussId < myNbGauss; anGaussId++){ + aCoordSliceArr[anGaussId] = + TCCoordSlice(myGaussCoord,std::slice(anId,myDim,1)); + anId += myDim; + } + } + else{ + for(TInt anGaussId = 0; anGaussId < myNbGauss; anGaussId++){ + aCoordSliceArr[anGaussId] = + TCCoordSlice(myGaussCoord,std::slice(theElemId,myDim,myGaussStep)); + } + } + return aCoordSliceArr; + } + + + TCoordSliceArr + TGaussCoord + ::GetCoordSliceArr(TInt theElemId) + { + TCoordSliceArr aCoordSliceArr(myNbGauss); + if(GetModeSwitch() == eFULL_INTERLACE){ + TInt anId = theElemId*myGaussStep; + for(TInt anGaussId = 0; anGaussId < myNbGauss; anGaussId++){ + aCoordSliceArr[anGaussId] = + TCoordSlice(myGaussCoord,std::slice(anId,myDim,1)); + anId += myDim; + } + } + else{ + for(TInt anGaussId = 0; anGaussId < myNbGauss; anGaussId++){ + aCoordSliceArr[anGaussId] = + TCoordSlice(myGaussCoord,std::slice(theElemId,myDim,myGaussStep)); + } + } + return aCoordSliceArr; + } + + + //--------------------------------------------------------------- + inline + bool + IsEqual(TFloat theLeft, TFloat theRight) + { + static TFloat EPS = 1.0E-3; + if(fabs(theLeft) + fabs(theRight) > EPS) + return fabs(theLeft-theRight)/(fabs(theLeft)+fabs(theRight)) < EPS; + return true; + } + + + //--------------------------------------------------------------- + class TShapeFun::TFun + { + TFloatVector myFun; + TInt myNbRef; + + public: + + void + Init(TInt theNbGauss, + TInt theNbRef) + { + myFun.resize(theNbGauss*theNbRef); + myNbRef = theNbRef; + } + + TCFloatVecSlice + GetFunSlice(TInt theGaussId) const + { + return TCFloatVecSlice(myFun,std::slice(theGaussId*myNbRef,myNbRef,1)); + } + + TFloatVecSlice + GetFunSlice(TInt theGaussId) + { + return TFloatVecSlice(myFun,std::slice(theGaussId*myNbRef,myNbRef,1)); + } + }; + + //--------------------------------------------------------------- + + TShapeFun::TShapeFun(TInt theDim, TInt theNbRef): + myRefCoord(theNbRef*theDim), + myDim(theDim), + myNbRef(theNbRef) + {} + + TCCoordSlice + TShapeFun::GetCoord(TInt theRefId) const + { + return TCCoordSlice(myRefCoord,std::slice(theRefId*myDim,myDim,1)); + } + + TCoordSlice + TShapeFun::GetCoord(TInt theRefId) + { + return TCoordSlice(myRefCoord,std::slice(theRefId*myDim,myDim,1)); + } + + void + TShapeFun::GetFun(const TCCoordSliceArr& theRef, + const TCCoordSliceArr& theGauss, + TFun& theFun) const + { + TInt aNbRef = theRef.size(); + TInt aNbGauss = theGauss.size(); + theFun.Init(aNbGauss,aNbRef); + } + + bool + TShapeFun::IsSatisfy(const TCCoordSliceArr& theRefCoord) const + { + TInt aNbRef = theRefCoord.size(); + TInt aNbRef2 = GetNbRef(); + INITMSG(MYDEBUG,"TShapeFun::IsSatisfy "<< + "- aNbRef("<GetDim(); + TInt aNbGauss = theGauss.size(); + + bool anIsSubMesh = !theElemNum.empty(); + TInt aNbElem; + if(anIsSubMesh) + aNbElem = theElemNum.size(); + else + aNbElem = theCellInfo.GetNbElem(); + + theGaussCoord.Init(aNbElem,aNbGauss,aDim,theMode); + + TFun aFun; + InitFun(theRef,theGauss,aFun); + TInt aConnDim = theCellInfo.GetConnDim(); + + INITMSG(MYDEBUG,"aDim = "<GetDim(); + static TInt aNbGauss = 1; + + bool anIsSubMesh = !theElemNum.empty(); + TInt aNbElem; + if(anIsSubMesh) + aNbElem = theElemNum.size(); + else + aNbElem = theCellInfo.GetNbElem(); + + theGaussCoord.Init(aNbElem,aNbGauss,aDim,theMode); + + TInt aConnDim = theCellInfo.GetConnDim(); + + INITMSGA(MYDEBUG,0, + "- aDim = "<GetDim(); + static TInt aNbGauss = 1; + + bool anIsSubMesh = !theElemNum.empty(); + TInt aNbElem; + if(anIsSubMesh) + aNbElem = theElemNum.size(); + else + aNbElem = thePolygoneInfo.GetNbElem(); + + theGaussCoord.Init(aNbElem,aNbGauss,aDim,theMode); + + INITMSGA(MYDEBUG,0, + "- aDim = "<GetDim(); + static TInt aNbGauss = 1; + + bool anIsSubMesh = !theElemNum.empty(); + TInt aNbElem; + if(anIsSubMesh) + aNbElem = theElemNum.size(); + else + aNbElem = thePolyedreInfo.GetNbElem(); + + theGaussCoord.Init(aNbElem,aNbGauss,aDim,theMode); + + INITMSGA(MYDEBUG,0, + "- aDim = "< TCCoordSliceArr; + typedef TVector 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 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 diff --git a/src/MEDWrapper/Base/MED_SharedPtr.hxx b/src/MEDWrapper/Base/MED_SharedPtr.hxx new file mode 100644 index 000000000..d0f4746c6 --- /dev/null +++ b/src/MEDWrapper/Base/MED_SharedPtr.hxx @@ -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 + +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 SharedPtr: public boost::shared_ptr + { + public: + //! Default constructor + SharedPtr() {} + + //! Construct the class by any type of a pointer + template + explicit SharedPtr(Y * p): + boost::shared_ptr(p) + {} + + //! Construct the class by any specialisation of the class + template + SharedPtr(SharedPtr const & r): + boost::shared_ptr(r,boost::detail::dynamic_cast_tag()) + {} + + //! Copy-constructor + template + SharedPtr& + operator=(SharedPtr const & r) + { + boost::shared_ptr(r,boost::detail::dynamic_cast_tag()).swap(*this); + return *this; + } + + //! Introduce a flexible way to reset the wrapped pointer + template + SharedPtr& + operator()(Y * p) // Y must be complete + { + return operator=(SharedPtr(p)); + } + + //! Introduce a flexible way to reset the wrapped pointer + template + SharedPtr& + operator()(SharedPtr const & r) // Y must be complete + { + return operator=(SharedPtr(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 diff --git a/src/MEDWrapper/Base/MED_SliceArray.hxx b/src/MEDWrapper/Base/MED_SliceArray.hxx new file mode 100644 index 000000000..c41951c75 --- /dev/null +++ b/src/MEDWrapper/Base/MED_SliceArray.hxx @@ -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 +#include + +//#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 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& 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 TSlice: public TCSlice + { + TValueType* myValuePtr; + + public: + typedef TValueType value_type; + typedef TCSlice 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& 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 diff --git a/src/MEDWrapper/Base/MED_Structures.cxx b/src/MEDWrapper/Base/MED_Structures.cxx new file mode 100644 index 000000000..e9059ad93 --- /dev/null +++ b/src/MEDWrapper/Base/MED_Structures.cxx @@ -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 + +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="<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;iGetGrilleStructure()[i]; + else + nbNodes = nbNodes*this->GetGrilleStructure()[i]; + + return nbNodes; +} + +TInt +TGrilleInfo +::GetNbCells() +{ + TInt nbCells=0; + TInt aDim = myMeshInfo->GetDim(); + for(int i=0;iGetGrilleStructure()[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; +} diff --git a/src/MEDWrapper/Base/MED_Structures.hxx b/src/MEDWrapper/Base/MED_Structures.hxx new file mode 100644 index 000000000..bcd361a67 --- /dev/null +++ b/src/MEDWrapper/Base/MED_Structures.hxx @@ -0,0 +1,1081 @@ +// 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_Structures_HeaderFile +#define MED_Structures_HeaderFile + +#include "MED_Common.hxx" +#include "MED_Utilities.hxx" + +#ifdef WIN32 +#pragma warning(disable:4251) +#endif + +namespace MED +{ + + //--------------------------------------------------------------- + //! Defines a type for managing sequence of strings + typedef TVector TString; + typedef SharedPtr PString; + + //! Extract a substring from the sequence of the strings + MEDWRAPPER_EXPORT + std::string + GetString(TInt theId, TInt theStep, + const TString& theString); + + //! Set a substring in the sequence of the strings + MEDWRAPPER_EXPORT + void + SetString(TInt theId, TInt theStep, + TString& theString, + const std::string& theValue); + + //! Set a substring in the sequence of the strings + MEDWRAPPER_EXPORT + void + SetString(TInt theId, TInt theStep, + TString& theString, + const TString& theValue); + + //--------------------------------------------------------------- + //! Define a parent class for all MEDWrapper classes + struct MEDWRAPPER_EXPORT TBase + { + virtual ~TBase() {} + }; + + + //--------------------------------------------------------------- + //! Define a parent class for all named MED entities + struct MEDWRAPPER_EXPORT TNameInfo: virtual TBase + { + TString myName; //!< Keeps its name + virtual std::string GetName() const = 0; //!< Gets its name + virtual void SetName(const std::string& theValue) = 0; //!< Set a new name + virtual void SetName(const TString& theValue) = 0; //!< Set a new name + }; + + + //--------------------------------------------------------------- + //! Define a parent class for all MED entities that contains a sequence of numbers + /*! + It defines through corresponding enumeration (EModeSwitch) how the sequence + should be interpreted in C or Fortran mode (eFULL_INTERLACE or eNON_INTERLACE). + */ + struct MEDWRAPPER_EXPORT TModeSwitchInfo: virtual TBase + { + //! To construct instance of the class by default + TModeSwitchInfo(): + myModeSwitch(eFULL_INTERLACE) + {} + + //! To construct instance of the class + TModeSwitchInfo(EModeSwitch theModeSwitch): + myModeSwitch(theModeSwitch) + {} + + EModeSwitch myModeSwitch; //!< Keeps the + EModeSwitch GetModeSwitch() const { return myModeSwitch;} + }; + + + //--------------------------------------------------------------- + //! Define a base class which represents MED Mesh entity + struct MEDWRAPPER_EXPORT TMeshInfo: virtual TNameInfo + { + TInt myDim; //!< Dimension of the mesh (0, 1, 2 or 3) + TInt GetDim() const { return myDim;} //!< Gets dimension of the mesh + + TInt mySpaceDim; + TInt GetSpaceDim() const { return mySpaceDim; } + + EMaillage myType; //!< Type of the mesh + EMaillage GetType() const { return myType;} //!< Gets type of the mesh + + TString myDesc; //!< Description of the mesh + virtual std::string GetDesc() const = 0; //!< Get description for the mesh + virtual void SetDesc(const std::string& theValue) = 0; //!< Sets description for the mesh + + + }; + + + //--------------------------------------------------------------- + typedef TVector TIntVector; + typedef TSlice TIntVecSlice; + typedef TCSlice TCIntVecSlice; + + typedef TIntVector TFamAttr; + + //! Define a base class which represents MED Family entity + struct MEDWRAPPER_EXPORT TFamilyInfo: virtual TNameInfo + { + PMeshInfo myMeshInfo; //!< A reference to correspondig MED Mesh + //! Get a reference to corresponding MED Mesh + const PMeshInfo& GetMeshInfo() const { return myMeshInfo;} + + TInt myId; //!< An unique index of the MED FAMILY + TInt GetId() const { return myId;} //!< Gets number of the MED FAMILY + void SetId(TInt theId) { myId = theId;} //! Define number of the MED FAMILY + + TInt myNbGroup; //!< Defines number MED Groups connected to + //! Gets number of MED GROUPS the MED FAMILY is bound to + TInt GetNbGroup() const { return myNbGroup;} + + //! Contains sequence of the names for the MED Groups connected to + TString myGroupNames; + //! Gets name of a bound MED GROUP by its number + virtual std::string GetGroupName(TInt theId) const = 0; + //! Sets name of the defined MED GROUP by its number + virtual void SetGroupName(TInt theId, const std::string& theValue) = 0; + + TInt myNbAttr; //!< Defines number of the MED Family attributes + //! Gets number of attached attributes for the MED FAMILY + TInt GetNbAttr() const { return myNbAttr;} + + //! Defines sequence of the indexes of the MED Family attributes + TFamAttr myAttrId; + //! Get MED FAMILY attribute by its number + TInt GetAttrId(TInt theId) const; + //! Set MED FAMILY attribute by its number + void SetAttrId(TInt theId, TInt theVal); + + //! Defines sequence of the values of the MED Family attributes + TFamAttr myAttrVal; + //! Get MED FAMILY attribute by its number + TInt GetAttrVal(TInt theId) const; + //! Set MED FAMILY attribute by its number + void SetAttrVal(TInt theId, TInt theVal); + + //! Defines sequence of the names of the MED Family attributes + TString myAttrDesc; + //! Get value of the MED FAMILY attribute by its number + virtual std::string GetAttrDesc(TInt theId) const = 0; + //! Set value of the MED FAMILY attribute by its number + virtual void SetAttrDesc(TInt theId, const std::string& theValue) = 0; + }; + + + //--------------------------------------------------------------- + typedef TIntVector TElemNum; + typedef SharedPtr PElemNum; + + //! Define a parent class for all MED entities that describes mesh entites such as nodes and cells. + struct MEDWRAPPER_EXPORT TElemInfo: virtual TBase + { + PMeshInfo myMeshInfo; //!< A reference to correspondig MED Mesh + //! Get a reference to corresponding MED Mesh + const PMeshInfo& GetMeshInfo() const { return myMeshInfo;} + + TInt myNbElem; // TFloatVector; + typedef TSlice TFloatVecSlice; + typedef TCSlice TCFloatVecSlice; + + typedef TFloatVector TNodeCoord; + typedef SharedPtr PNodeCoord; + + typedef TFloatVecSlice TCoordSlice; + typedef TCFloatVecSlice TCCoordSlice; + + //! Define a base class which represents MED Nodes entity + struct MEDWRAPPER_EXPORT TNodeInfo: + virtual TElemInfo, + virtual TModeSwitchInfo + { + PNodeCoord myCoord; //!< Contains all nodal coordinates + + //! Gives coordinates for mesh node by its number (const version) + TCCoordSlice GetCoordSlice(TInt theId) const; + //! Gives coordinates for mesh node by its number + TCoordSlice GetCoordSlice(TInt theId); + + ERepere mySystem; //!< Defines, which coordinate system is used + //! Get which coordinate system is used for the node describing + ERepere GetSystem() const { return mySystem;} + //! Set coordinate system to be used for the node describing + void SetSystem(ERepere theSystem) { mySystem = theSystem;} + + TString myCoordNames; //!< Contains names for the coordinate dimensions + //! Get name of the coordinate dimension by its order number + virtual std::string GetCoordName(TInt theId) const = 0; + //! Set name of the coordinate dimension by its order number + virtual void SetCoordName(TInt theId, const std::string& theValue) = 0; + + TString myCoordUnits; //!< Contains units for the coordinate dimensions + //! Get name of unit for the coordinate dimension by its order number + virtual std::string GetCoordUnit(TInt theId) const = 0; + //! Set name of unit for the coordinate dimension by its order number + virtual void SetCoordUnit(TInt theId, const std::string& theValue) = 0; + }; + + + //--------------------------------------------------------------- + typedef TIntVecSlice TConnSlice; + typedef TCIntVecSlice TCConnSlice; + + //! Define a base class which represents MED Cells entity + struct MEDWRAPPER_EXPORT TCellInfo: + virtual TElemInfo, + virtual TModeSwitchInfo + { + EEntiteMaillage myEntity; //!< Defines the MED Entity where the mesh cells belongs to + //! Let known what MED ENTITY the cells belong to + EEntiteMaillage GetEntity() const { return myEntity;} + + EGeometrieElement myGeom; //!< Defines the MED Geometric type of the instance + //! Let known what MED geometrical type the cells belong to + EGeometrieElement GetGeom() const { return myGeom;} + + EConnectivite myConnMode; //!< Defines connectivity mode + //! Let known in what connectivity the cells are writen + EConnectivite GetConnMode() const { return myConnMode;} + + virtual TInt GetConnDim() const = 0; //!< Gives step in the connectivity sequence + + PElemNum myConn; //!< Defines sequence which describe connectivity for each of mesh cell + + //! Gives connectivities for mesh cell by its number (const version) + TCConnSlice GetConnSlice(TInt theElemId) const; + //! Gives connectivities for mesh cell by its number + TConnSlice GetConnSlice(TInt theElemId); + }; + + //--------------------------------------------------------------- + //! Define a base class which represents MED Polygon entity + struct MEDWRAPPER_EXPORT TPolygoneInfo: + virtual TElemInfo + { + //! Defines the MED Entity where the polygons belongs to + EEntiteMaillage myEntity; // MED_FACE|MED_MAILLE + //! Let known what MED ENTITY the MED Polygons belong to + EEntiteMaillage GetEntity() const { return myEntity;} + + //! Defines the MED Geometric type of the instance + EGeometrieElement myGeom; // ePOLYGONE + //! Let known what MED geometrical type the MED Polygons belong to + EGeometrieElement GetGeom() const { return ePOLYGONE;} + + //! Defines connectivity mode + EConnectivite myConnMode; // eNOD|eDESC(eDESC not used) + //! Let known in what connectivity the cells are writen + EConnectivite GetConnMode() const { return myConnMode;} + + PElemNum myConn; //!< Table de connectivities + PElemNum myIndex; //!< Table de indexes + + //! Gives number of the connectivities for the defined polygon + TInt GetNbConn(TInt theElemId) const; + + //! Gives connectivities for polygon by its number (const version) + TCConnSlice GetConnSlice(TInt theElemId) const; + //! Gives connectivities for polygon by its number + TConnSlice GetConnSlice(TInt theElemId); + }; + + //--------------------------------------------------------------- + //! Define a class representing MED_BALL structure element. + // + // This could be a generic class for any structure element + // holding any number of contant and variable attributes + // but it's too hard to implement + // + struct MEDWRAPPER_EXPORT TBallInfo: + virtual TCellInfo + { + TFloatVector myDiameters; + }; + + //--------------------------------------------------------------- + typedef TVector TCConnSliceArr; + typedef TVector TConnSliceArr; + + //! Define a base class which represents MED Polyedre entity + struct MEDWRAPPER_EXPORT TPolyedreInfo: + virtual TElemInfo + { + //! Defines the MED Entity where the polyedres belongs to + EEntiteMaillage myEntity; // MED_FACE|MED_MAILLE + //! Let known what MED ENTITY the MED Polyedres belong to + EEntiteMaillage GetEntity() const { return myEntity;} + + //! Defines the MED Geometric type of the instance + EGeometrieElement myGeom; // ePOLYEDRE + //! Let known what MED geometrical type the MED Polyedres belong to + EGeometrieElement GetGeom() const { return ePOLYEDRE;} + + //! Defines connectivity mode + EConnectivite myConnMode; // eNOD|eDESC(eDESC not used) + //! Let known in what connectivity the cells are writen + EConnectivite GetConnMode() const { return myConnMode;} + + PElemNum myConn; //!< Table de connectivities + PElemNum myFaces; //!< Table de faces indexes + PElemNum myIndex; //!< Table de indexes + + //! Gives number of the faces for the defined polyedre (const version) + TInt GetNbFaces(TInt theElemId) const; + //! Gives number of the nodes for the defined polyedre + TInt GetNbNodes(TInt theElemId) const; + + //! Gives sequence of the face connectivities for polyedre by its number (const version) + TCConnSliceArr GetConnSliceArr(TInt theElemId) const; + //! Gives sequence of the face connectivities for polyedre by its number + TConnSliceArr GetConnSliceArr(TInt theElemId); + }; + + //--------------------------------------------------------------- + //! Define a base class which represents MED Field entity + struct MEDWRAPPER_EXPORT TFieldInfo: + virtual TNameInfo + { + PMeshInfo myMeshInfo; //!< A reference to correspondig MED Mesh + //! Get a reference to corresponding MED Mesh + const PMeshInfo& GetMeshInfo() const { return myMeshInfo;} + + ETypeChamp myType; //!< Defines type of the MED Field + //! Let known what type of the MED FIELD is used + ETypeChamp GetType() const { return myType;} + + TInt myNbComp; //!< Defines number of components stored in the field + //! Get number of components for the MED FIELD + TInt GetNbComp() const { return myNbComp;} + + EBooleen myIsLocal; //!< Defines if the MED Field is local + //! Let known is the MED FIELD is local or not + EBooleen GetIsLocal() const { return myIsLocal;} + + TInt myNbRef; //!< Defines number of refereces of the field + //! Let known number of references for the MED FIELD + TInt GetNbRef() const { return myNbRef;} + + TString myCompNames; //!< Contains names for each of MED Field components + //! Get name of the component by its order number + virtual std::string GetCompName(TInt theId) const = 0; + //! Set name for the component by its order number + virtual void SetCompName(TInt theId, const std::string& theValue) = 0; + + TString myUnitNames; //!< Contains units for each of MED Field components + //! Get unit of the component by its order number + virtual std::string GetUnitName(TInt theId) const = 0; + //! Set unit for the component by its order number + virtual void SetUnitName(TInt theId, const std::string& theValue) = 0; + + }; + + + //--------------------------------------------------------------- + //! Get dimension of the Gauss coordinates for the defined type of mesh cell + MEDWRAPPER_EXPORT + TInt + GetDimGaussCoord(EGeometrieElement theGeom); + + //! Get number of referenced nodes for the defined type of mesh cell + MEDWRAPPER_EXPORT + TInt + GetNbRefCoord(EGeometrieElement theGeom); + + typedef TFloatVector TWeight; + + //! The class represents MED Gauss entity + struct MEDWRAPPER_EXPORT TGaussInfo: + virtual TNameInfo, + virtual TModeSwitchInfo + { + typedef boost::tuple TKey; + typedef boost::tuple TInfo; + struct MEDWRAPPER_EXPORT TLess + { + bool + operator()(const TKey& theLeft, const TKey& theRight) const; + + bool + operator()(const TGaussInfo& theLeft, const TGaussInfo& theRight) const; + }; + + //! Defines, which geometrical type the MED Gauss entity belongs to + EGeometrieElement myGeom; + //! Let known what MED geometrical type the MED GAUSS entity belong to + EGeometrieElement GetGeom() const { return myGeom;} + + //! Contains coordinates for the refereced nodes + TNodeCoord myRefCoord; + + //! Gives coordinates for the referenced node by its number + TCCoordSlice GetRefCoordSlice(TInt theId) const; + //! Gives coordinates for the referenced node by its number + TCoordSlice GetRefCoordSlice(TInt theId); + + //! Contains coordinates for the Gauss points + TNodeCoord myGaussCoord; + + //! Gives coordinates for the Gauss points by its number + TCCoordSlice GetGaussCoordSlice(TInt theId) const; + //! Gives coordinates for the Gauss points by its number + TCoordSlice GetGaussCoordSlice(TInt theId); + + //! Contains wheights for the Gauss points + TWeight myWeight; + + //! Gives number of the referenced nodes + TInt GetNbRef() const { return GetNbRefCoord(GetGeom());} + + //! Gives dimension of the referenced nodes + TInt GetDim() const { return GetDimGaussCoord(GetGeom());} + + //! Gives number of the Gauss Points + TInt GetNbGauss() const { return (TInt)(myGaussCoord.size()/GetDim());} + }; + + + //--------------------------------------------------------------- + typedef std::map TGeom2Gauss; + typedef std::map TGeom2NbGauss; + + //! Define a base class which represents MED TimeStamp + struct MEDWRAPPER_EXPORT TTimeStampInfo: + virtual TBase + { + PFieldInfo myFieldInfo; //!< A reference to correspondig MED Field + //! Get a reference to corresponding MED Field + const PFieldInfo& GetFieldInfo() const { return myFieldInfo;} + + //! Defines the MED Entity where the MED TimeStamp belongs to + EEntiteMaillage myEntity; + //! Let known to what MED Entity the MED TimeStamp belong to + EEntiteMaillage GetEntity() const { return myEntity;} + + //! Keeps map of number of cells per geometric type where the MED TimeStamp belongs to + TGeom2Size myGeom2Size; + //! Get map of number of cells per geometric type where the MED TimeStamp belongs to + const TGeom2Size& GetGeom2Size() const { return myGeom2Size;} + + TGeom2NbGauss myGeom2NbGauss; //!< Keeps number of the Gauss Points for the MED TimeStamp + TInt GetNbGauss(EGeometrieElement theGeom) const; //!< Gives number of the Gauss Points for the MED TimeStamp + + TInt myNumDt; //!< Keeps number in time for the MED TimeStamp + TInt GetNumDt() const { return myNumDt;} //!< Defines number in time for the MED TimeStamp + + TInt myNumOrd; //!< Keeps number for the MED TimeStamp + TInt GetNumOrd() const { return myNumOrd;} //!< Defines number for the MED TimeStamp + + TFloat myDt; //!< Keeps time for the MED TimeStamp + TFloat GetDt() const { return myDt;} //!< Defines time for the MED TimeStamp + + //! Keeps map of MED Gauss entityes per geometric type + TGeom2Gauss myGeom2Gauss; + //! Gets a map of MED Gauss entityes per geometric type + const TGeom2Gauss& GetGeom2Gauss() const { return myGeom2Gauss;} + + TString myUnitDt; //!< Defines unit for the time for the MED TimeStamp + //! Get unit of time for the MED TimeStamp + virtual std::string GetUnitDt() const = 0; + //! Set unit of time for the MED TimeStamp + virtual void SetUnitDt(const std::string& theValue) = 0; + }; + + + //--------------------------------------------------------------- + //! The class represents MED Profile entity + struct MEDWRAPPER_EXPORT TProfileInfo: + virtual TNameInfo + { + typedef std::string TKey; + typedef boost::tuple TInfo; + + EModeProfil myMode; //!< Keeps mode for the MED Profile + //! Let known what mode of MED Profile is used + EModeProfil GetMode() const { return myMode;} + //! Set mode for the MED Profile + void SetMode(EModeProfil theMode) { myMode = theMode;} + + PElemNum myElemNum; //!< Keeps sequence of cell by its number which belong to the profile + //! Get number of mesh elelemts by its order number + TInt GetElemNum(TInt theId) const; + //! Set number of mesh elelemts by its order number + void SetElemNum(TInt theId, TInt theVal); + + //! Let known is the MED Profile defined + bool IsPresent() const { return GetName() != "";} + + //! Let known size of the MED Profile + TInt GetSize() const { return (TInt)myElemNum->size();} + }; + + + //--------------------------------------------------------------- + //! The class is a helper one. It provide safe and flexible way to get access to values for a MED TimeStamp + struct MEDWRAPPER_EXPORT TMeshValueBase: + virtual TModeSwitchInfo + { + TInt myNbElem; + TInt myNbComp; + TInt myNbGauss; + TInt myStep; + + TMeshValueBase(); + + //! Initialize the class + void + Allocate(TInt theNbElem, + TInt theNbGauss, + TInt theNbComp, + EModeSwitch theMode = eFULL_INTERLACE); + + //! Returns size of the value container + size_t + GetSize() const; + + //! Returns MED interpetation of the value size + size_t + GetNbVal() const; + + //! Returns number of Gauss Points bounded with the value + size_t + GetNbGauss() const; + + //! Returns step inside of the data array + size_t + GetStep() const; + + //! Returns bare pointer on the internal value representation + virtual + unsigned char* + GetValuePtr() = 0; + }; + + //--------------------------------------------------------------- + //! The class is a helper one. It provide safe and flexible way to get access to values for a MED TimeStamp + template + struct TTMeshValue: + virtual TMeshValueBase + { + typedef TValueType TValue; + typedef typename TValueType::value_type TElement; + + typedef TSlice TValueSlice; + typedef TCSlice TCValueSlice; + + typedef TVector TCValueSliceArr; + typedef TVector TValueSliceArr; + + TValue myValue; + + //! Initialize the class + void + Allocate(TInt theNbElem, + TInt theNbGauss, + TInt theNbComp, + EModeSwitch theMode = eFULL_INTERLACE) + { + TMeshValueBase::Allocate(theNbElem, theNbGauss, theNbComp, theMode); + myValue.resize(theNbElem * this->GetStep()); + } + + //! Returns bare pointer on the internal value representation + virtual + unsigned char* + GetValuePtr() + { + return (unsigned char*)&myValue[0]; + } + + //! Returns bare pointer on the internal value representation + virtual + TElement* + GetPointer() + { + return &myValue[0]; + } + + //! Returns bare pointer on the internal value representation + virtual + const TElement* + GetPointer() const + { + return &myValue[0]; + } + + //! Iteration through Gauss Points by their components + TCValueSliceArr + GetGaussValueSliceArr(TInt theElemId) const + { + TCValueSliceArr aValueSliceArr(myNbGauss); + if(GetModeSwitch() == eFULL_INTERLACE){ + TInt anId = theElemId * myStep; + for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){ + aValueSliceArr[aGaussId] = + TCValueSlice(myValue, std::slice(anId, myNbComp, 1)); + anId += myNbComp; + } + } + else{ + for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){ + aValueSliceArr[aGaussId] = + TCValueSlice(myValue, std::slice(theElemId, myNbComp, myStep)); + } + } + return aValueSliceArr; + } + + //! Iteration through Gauss Points by their components + TValueSliceArr + GetGaussValueSliceArr(TInt theElemId) + { + TValueSliceArr aValueSliceArr(myNbGauss); + if(GetModeSwitch() == eFULL_INTERLACE){ + TInt anId = theElemId*myStep; + for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){ + aValueSliceArr[aGaussId] = + TValueSlice(myValue, std::slice(anId, myNbComp, 1)); + anId += myNbComp; + } + } + else{ + for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){ + aValueSliceArr[aGaussId] = + TValueSlice(myValue, std::slice(theElemId, myNbComp, myStep)); + } + } + return aValueSliceArr; + } + + //! Iteration through components by corresponding Gauss Points + TCValueSliceArr + GetCompValueSliceArr(TInt theElemId) const + { + TCValueSliceArr aValueSliceArr(myNbComp); + if(GetModeSwitch() == eFULL_INTERLACE){ + TInt anId = theElemId*myStep; + for(TInt aCompId = 0; aCompId < myNbComp; aCompId++){ + aValueSliceArr[aCompId] = + TCValueSlice(myValue, std::slice(anId, myNbGauss, myNbComp)); + anId += 1; + } + } + else{ + for(TInt aCompId = 0; aCompId < myNbComp; aCompId++){ + aValueSliceArr[aCompId] = + TCValueSlice(myValue, std::slice(theElemId, myNbGauss, myStep)); + } + } + return aValueSliceArr; + } + + //! Iteration through components by corresponding Gauss Points + TValueSliceArr + GetCompValueSliceArr(TInt theElemId) + { + if(GetModeSwitch() == eFULL_INTERLACE){ + TValueSliceArr aValueSliceArr(myNbComp); + TInt anId = theElemId*myStep; + for(TInt aCompId = 0; aCompId < myNbComp; aCompId++){ + aValueSliceArr[aCompId] = + TValueSlice(myValue, std::slice(anId, myNbGauss, myNbComp)); + anId += 1; + } + return aValueSliceArr; + } + else{ + TValueSliceArr aValueSliceArr(myNbGauss); + for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){ + aValueSliceArr[aGaussId] = + TValueSlice(myValue,std::slice(theElemId, myNbComp, myStep)); + } + return aValueSliceArr; + } + } + }; + + typedef TTMeshValue TFloatMeshValue; + typedef TTMeshValue TIntMeshValue; + + //--------------------------------------------------------------- + // Backward compatibility declarations + typedef TFloatVector TValue; + typedef TSlice TValueSlice; + typedef TCSlice TCValueSlice; + + typedef TVector TCValueSliceArr; + typedef TVector TValueSliceArr; + + typedef TFloatMeshValue TMeshValue; + typedef std::map TGeom2Value; + + //--------------------------------------------------------------- + typedef std::map TGeom2Profile; + typedef std::set TGeom; + + //! The class is a base class for MED TimeStamp values holder + struct MEDWRAPPER_EXPORT TTimeStampValueBase: + virtual TModeSwitchInfo + { + //! A reference to correspondig MED TimeStamp + PTimeStampInfo myTimeStampInfo; + //!< Get a reference to correspondig MED TimeStamp + const PTimeStampInfo& GetTimeStampInfo() const { return myTimeStampInfo;} + + //! Keeps set of MED EGeometrieElement which contains values for the timestamp + TGeomSet myGeomSet; + const TGeomSet& GetGeomSet() const { return myGeomSet;} + + //! Keeps map of MED Profiles per geometric type + TGeom2Profile myGeom2Profile; + //! Gets a map of MED Profiles per geometric type + const TGeom2Profile& GetGeom2Profile() const { return myGeom2Profile;} + + //! Gets type of the champ + virtual + ETypeChamp + GetTypeChamp() const = 0; + + //! Allocates values for the given geometry + virtual + void + AllocateValue(EGeometrieElement theGeom, + TInt theNbElem, + TInt theNbGauss, + TInt theNbComp, + EModeSwitch theMode = eFULL_INTERLACE) = 0; + + virtual + size_t + GetValueSize(EGeometrieElement theGeom) const = 0; + + virtual + size_t + GetNbVal(EGeometrieElement theGeom) const = 0; + + virtual + size_t + GetNbGauss(EGeometrieElement theGeom) const = 0; + + virtual + unsigned char* + GetValuePtr(EGeometrieElement theGeom) = 0; + }; + + + //--------------------------------------------------------------- + //! The class implements a container for MED TimeStamp values + template + struct TTimeStampValue: + virtual TTimeStampValueBase + { + typedef TMeshValueType TTMeshValue; + typedef SharedPtr PTMeshValue; + typedef typename TMeshValueType::TElement TElement; + typedef std::map TTGeom2Value; + + ETypeChamp myTypeChamp; //second; + } + + //! Gets MED TimeStamp values for the given geometric type + PTMeshValue& + GetMeshValuePtr(EGeometrieElement theGeom) + { + myGeomSet.insert(theGeom); + if(myGeom2Value.find(theGeom) == myGeom2Value.end()){ + myGeom2Value[theGeom] = PTMeshValue(new TTMeshValue()); + return myGeom2Value[theGeom]; + } + return myGeom2Value[theGeom]; + } + + //! Gets MED TimeStamp values for the given geometric type (const version) + const TTMeshValue& + GetMeshValue(EGeometrieElement theGeom) const + { + return *(this->GetMeshValuePtr(theGeom)); + } + + //! Gets MED TimeStamp values for the given geometric type + TTMeshValue& + GetMeshValue(EGeometrieElement theGeom) + { + return *(this->GetMeshValuePtr(theGeom)); + } + }; + + + //--------------------------------------------------------------- + typedef TTimeStampValue TFloatTimeStampValue; + typedef SharedPtr PFloatTimeStampValue; + + PFloatTimeStampValue MEDWRAPPER_EXPORT + CastToFloatTimeStampValue(const PTimeStampValueBase& theTimeStampValue); + + typedef TTimeStampValue TIntTimeStampValue; + typedef SharedPtr PIntTimeStampValue; + + PIntTimeStampValue MEDWRAPPER_EXPORT + CastToIntTimeStampValue(const PTimeStampValueBase& theTimeStampValue); + + + //--------------------------------------------------------------- + template + void + CopyTimeStampValue(SharedPtr > theTimeStampValueFrom, + SharedPtr > theTimeStampValueTo) + { + typedef TTimeStampValue TimeStampValueTypeFrom; + typedef TTimeStampValue TimeStampValueTypeTo; + typedef typename TMeshValueTypeTo::TElement TElementTo; + + typename TimeStampValueTypeFrom::TTGeom2Value& aGeom2Value = theTimeStampValueFrom->myGeom2Value; + typename TimeStampValueTypeFrom::TTGeom2Value::const_iterator anIter = aGeom2Value.begin(); + for(; anIter != aGeom2Value.end(); anIter++){ + const EGeometrieElement& aGeom = anIter->first; + const typename TimeStampValueTypeFrom::TTMeshValue& aMeshValue = *anIter->second; + typename TimeStampValueTypeTo::TTMeshValue& aMeshValue2 = theTimeStampValueTo->GetMeshValue(aGeom); + aMeshValue2.Allocate(aMeshValue.myNbElem, + aMeshValue.myNbGauss, + aMeshValue.myNbComp, + aMeshValue.myModeSwitch); + const typename TimeStampValueTypeFrom::TTMeshValue::TValue& aValue = aMeshValue.myValue; + typename TimeStampValueTypeTo::TTMeshValue::TValue& aValue2 = aMeshValue2.myValue; + TInt aSize = aValue.size(); + for(TInt anId = 0; anId < aSize; anId++) + aValue2[anId] = TElementTo(aValue[anId]); + } + } + + template + void + CopyTimeStampValue(SharedPtr > theTimeStampValueFrom, + SharedPtr > theTimeStampValueTo) + { + typedef TTimeStampValue TimeStampValueType; + typename TimeStampValueType::TTGeom2Value& aGeom2Value = theTimeStampValueFrom->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; + typename TimeStampValueType::TTMeshValue& aMeshValue2 = theTimeStampValueTo->GetMeshValue(aGeom); + aMeshValue2 = aMeshValue; + } + } + + //--------------------------------------------------------------- + inline + void + CopyTimeStampValueBase(const PTimeStampValueBase& theValueFrom, + const PTimeStampValueBase& theValueTo) + { + if(theValueFrom->GetTypeChamp() == theValueTo->GetTypeChamp()){ + if(theValueFrom->GetTypeChamp() == eFLOAT64) + CopyTimeStampValue(theValueFrom, theValueTo); + else if(theValueFrom->GetTypeChamp() == eINT) + CopyTimeStampValue(theValueFrom, theValueTo); + }else{ + if(theValueFrom->GetTypeChamp() == eFLOAT64 && theValueTo->GetTypeChamp() == eINT) + CopyTimeStampValue(theValueFrom, theValueTo); + else if(theValueFrom->GetTypeChamp() == eINT && theValueTo->GetTypeChamp() == eFLOAT64) + CopyTimeStampValue(theValueFrom, theValueTo); + } + } + + + //--------------------------------------------------------------- + // Backward compatibility declarations + typedef TFloatTimeStampValue TTimeStampVal; + typedef PFloatTimeStampValue PTimeStampVal; + + //--------------------------------------------------------------- + typedef std::map TIndexes; + typedef std::map TNames; + + //! Define a base class which represents MED Grille (structured mesh) + struct MEDWRAPPER_EXPORT TGrilleInfo: + virtual TModeSwitchInfo + { + + PMeshInfo myMeshInfo; + const PMeshInfo& GetMeshInfo() const { return myMeshInfo;} + + TNodeCoord myCoord; //!< Contains all nodal coordinates, now used only for eGRILLE_STANDARD + //! Gives coordinates for mesh nodes (const version) + const TNodeCoord& GetNodeCoord() const; + TNodeCoord& GetNodeCoord(); + //! Gives coordinates for mesh node by its number, array index from 0 + TNodeCoord GetCoord(TInt theId); + //! Gives ids of nodes for mesh cell or sub-cell by its number, array index from 0 + TIntVector GetConn(TInt theId, const bool isSub=false); + + EGrilleType myGrilleType; //!< Defines grille type (eGRILLE_CARTESIENNE,eGRILLE_POLAIRE,eGRILLE_STANDARD) + //!Gets grille type (const version) + const EGrilleType& GetGrilleType() const; + //!Gets grille type + EGrilleType GetGrilleType(); + //!Sets grille type + void SetGrilleType(EGrilleType theGrilleType); + + + + TString myCoordNames; //!< Contains names for the coordinate dimensions + //! Get name of the coordinate dimension by its order number + virtual std::string GetCoordName(TInt theId) const = 0 ; + //! Set name of the coordinate dimension by its order number + virtual void SetCoordName(TInt theId, const std::string& theValue) = 0; + + TString myCoordUnits; //!< Contains units for the coordinate dimensions + //! Get name of unit for the coordinate dimension by its order number + virtual std::string GetCoordUnit(TInt theId) const = 0; + //! Set name of unit for the coordinate dimension by its order number + virtual void SetCoordUnit(TInt theId, const std::string& theValue) = 0; + + + //! Map of index of axes and Table of indexes for certain axe, now used for eGRILLE_CARTESIENNE and eGRILLE_POLAIRE + TIndexes myIndixes; + //!Gets a map of Tables (const version) + const TIndexes& GetMapOfIndexes() const ; + //!Gets a map of Tables + TIndexes& GetMapOfIndexes(); + //!Gets a Table of indexes for certain axe(const version) + const TFloatVector& GetIndexes(TInt theAxisNumber) const; + //!Gets a Table of indexes for certain axe + TFloatVector& GetIndexes(TInt theAxisNumber); + //!Gets a number of indices per axe + TInt GetNbIndexes(TInt theAxisNumber); + + TInt GetNbNodes();//! Return count of all points + TInt GetNbCells();//! Return count of all cells + TInt GetNbSubCells();//! Return count of all entities of + EGeometrieElement GetGeom();//! Return geometry of cells (calculated from mesh dimension) + EGeometrieElement GetSubGeom();//! Return geometry of subcells (calculated from mesh dimension) + EEntiteMaillage GetEntity();//! Return entity (eMAILLE) + EEntiteMaillage GetSubEntity();//! Return sub entity + + /*! + *Vector of grille structure (Example: {3,4,5}, 3 nodes in X axe, 4 nodes in Y axe, ...) + */ + TIntVector myGrilleStructure; + //!Gets grille structure(const version) + const TIntVector& GetGrilleStructure() const; + //!Gets grille structure + TIntVector GetGrilleStructure(); + //!Sets the grille structure of theAxis axe to theNb. + void SetGrilleStructure(TInt theAxis,TInt theNb); + + /*! + *Defines sequence MED Family indexes for corresponding mesh entites + */ + TElemNum myFamNum; + //! Get number of a MED FAMILY by order number of the mesh element + TInt GetFamNum(TInt theId) const; + //! Set number of a MED FAMILY for the mesh element with the order number + void SetFamNum(TInt theId, TInt theVal); + + /*! + *Defines sequence MED Family indexes for sub entites + */ + TElemNum myFamSubNum; + //! Get number of a MED FAMILY by order number of sub element + TInt GetFamSubNum(TInt theId) const; + //! Set number of a MED FAMILY for theId-th sub element + void SetFamSubNum(TInt theId, TInt theVal); + + /*! + *Defines sequence MED Family indexes for corresponding mesh nodes + */ + TElemNum myFamNumNode; + //! Get number of a MED FAMILY by order number of the mesh node + TInt GetFamNumNode(TInt theId) const; + //! Set number of a MED FAMILY for the mesh node with the order number + void SetFamNumNode(TInt theId, TInt theVal); + + }; + + +} + +#endif diff --git a/src/MEDWrapper/Base/MED_TStructures.hxx b/src/MEDWrapper/Base/MED_TStructures.hxx new file mode 100644 index 000000000..dfbca909a --- /dev/null +++ b/src/MEDWrapper/Base/MED_TStructures.hxx @@ -0,0 +1,1216 @@ +// 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_TStructures_HeaderFile +#define MED_TStructures_HeaderFile + +#include "MED_Structures.hxx" + +#ifdef WIN32 +#pragma warning(disable:4250) +#endif + +namespace MED +{ + //--------------------------------------------------------------- + //! To provide a common way to handle values of MEDWrapper types as native MED types + template + struct TValueHolder + { + TValue& myValue; + TRepresentation myRepresentation; + + TValueHolder(TValue& theValue): + myValue(theValue), + myRepresentation(TRepresentation(theValue)) + {} + + ~TValueHolder() + { + myValue = TValue(myRepresentation); + } + + TRepresentation* + operator& () + { + return &myRepresentation; + } + + operator TRepresentation () const + { + return myRepresentation; + } + + const TValue& + operator() () const + { + return myValue; + } + }; + + //! To customize TValueHolder common template definition for TVector + template + struct TValueHolder, TRepresentation> + { + typedef TVector TValue; + TValue& myValue; + TRepresentation* myRepresentation; + + TValueHolder(TValue& theValue): + myValue(theValue) + { + if(theValue.empty()) + myRepresentation = (TRepresentation*)NULL; + else + myRepresentation = (TRepresentation*)&theValue[0]; + } + + TRepresentation* + operator& () + { + return myRepresentation; + } + }; + + //--------------------------------------------------------------- + template + struct TTNameInfo: virtual TNameInfo + { + TTNameInfo(const std::string& theValue) + { + myName.resize(GetNOMLength()+1); + SetName(theValue); + } + + virtual + std::string + GetName() const + { + return GetString(0, GetNOMLength(), myName); + } + + virtual + void + SetName(const std::string& theValue) + { + SetString(0, GetNOMLength(), myName, theValue); + } + + virtual + void + SetName(const TString& theValue) + { + SetString(0, GetNOMLength(), myName, theValue); + } + }; + + + //--------------------------------------------------------------- + template + struct TTMeshInfo: + virtual TMeshInfo, + virtual TTNameInfo + { + typedef TTNameInfo TNameInfoBase; + + TTMeshInfo(const PMeshInfo& theInfo): + TNameInfoBase(theInfo->GetName()) + { + myDim = theInfo->GetDim(); + mySpaceDim = theInfo->GetSpaceDim(); + myType = theInfo->GetType(); + + myDesc.resize(GetDESCLength()+1); + SetDesc(theInfo->GetDesc()); + } + + TTMeshInfo(TInt theDim, TInt theSpaceDim, + const std::string& theValue, + EMaillage theType, + const std::string& theDesc): + TNameInfoBase(theValue) + { + myDim = theDim; + mySpaceDim = theSpaceDim; + myType = theType; + + myDesc.resize(GetDESCLength()+1); + SetDesc(theDesc); + } + + virtual + std::string + GetDesc() const + { + return GetString(0, GetDESCLength(), myDesc); + } + + virtual + void + SetDesc(const std::string& theValue) + { + SetString(0, GetDESCLength(), myDesc, theValue); + } + }; + + + //--------------------------------------------------------------- + template + struct TTFamilyInfo: + virtual TFamilyInfo, + virtual TTNameInfo + { + typedef TTNameInfo TNameInfoBase; + + TTFamilyInfo(const PMeshInfo& theMeshInfo, const PFamilyInfo& theInfo): + TNameInfoBase(theInfo->GetName()) + { + myMeshInfo = theMeshInfo; + + myId = theInfo->GetId(); + + myNbGroup = theInfo->GetNbGroup(); + myGroupNames.resize(myNbGroup*GetLNOMLength()+1); + if(myNbGroup){ + for(TInt anId = 0; anId < myNbGroup; anId++){ + SetGroupName(anId,theInfo->GetGroupName(anId)); + } + } + + myNbAttr = theInfo->GetNbAttr(); + myAttrId.resize(myNbAttr); + myAttrVal.resize(myNbAttr); + myAttrDesc.resize(myNbAttr*GetDESCLength()+1); + if(myNbAttr){ + for(TInt anId = 0; anId < myNbAttr; anId++){ + SetAttrDesc(anId,theInfo->GetAttrDesc(anId)); + myAttrVal[anId] = theInfo->GetAttrVal(anId); + myAttrId[anId] = theInfo->GetAttrId(anId); + } + } + } + + TTFamilyInfo(const PMeshInfo& theMeshInfo, + TInt theNbGroup, + TInt theNbAttr, + TInt theId, + const std::string& theValue): + TNameInfoBase(theValue) + { + myMeshInfo = theMeshInfo; + + myId = theId; + + myNbGroup = theNbGroup; + myGroupNames.resize(theNbGroup*GetLNOMLength()+1); + + myNbAttr = theNbAttr; + myAttrId.resize(theNbAttr); + myAttrVal.resize(theNbAttr); + myAttrDesc.resize(theNbAttr*GetDESCLength()+1); + } + + TTFamilyInfo(const PMeshInfo& theMeshInfo, + const std::string& theValue, + TInt theId, + const TStringSet& theGroupNames, + const TStringVector& theAttrDescs, + const TIntVector& theAttrIds, + const TIntVector& theAttrVals): + TNameInfoBase(theValue) + { + myMeshInfo = theMeshInfo; + + myId = theId; + + myNbGroup = (TInt)theGroupNames.size(); + myGroupNames.resize(myNbGroup*GetLNOMLength()+1); + if(myNbGroup){ + TStringSet::const_iterator anIter = theGroupNames.begin(); + for(TInt anId = 0; anIter != theGroupNames.end(); anIter++, anId++){ + const std::string& aVal = *anIter; + SetGroupName(anId,aVal); + } + } + + myNbAttr = (TInt)theAttrDescs.size(); + myAttrId.resize(myNbAttr); + myAttrVal.resize(myNbAttr); + myAttrDesc.resize(myNbAttr*GetDESCLength()+1); + if(myNbAttr){ + for(TInt anId = 0, anEnd = (TInt)theAttrDescs.size(); anId < anEnd; anId++){ + SetAttrDesc(anId,theAttrDescs[anId]); + myAttrVal[anId] = theAttrVals[anId]; + myAttrId[anId] = theAttrIds[anId]; + } + } + } + + virtual + std::string + GetGroupName(TInt theId) const + { + return GetString(theId, GetLNOMLength(), myGroupNames); + } + + virtual + void + SetGroupName(TInt theId, const std::string& theValue) + { + SetString(theId, GetLNOMLength(), myGroupNames, theValue); + } + + virtual + std::string + GetAttrDesc(TInt theId) const + { + return GetString(theId, GetDESCLength(), myAttrDesc); + } + + virtual + void + SetAttrDesc(TInt theId, const std::string& theValue) + { + SetString(theId, GetDESCLength(), myAttrDesc, theValue); + } + }; + + + //--------------------------------------------------------------- + template + struct TTElemInfo: virtual TElemInfo + { + TTElemInfo(const PMeshInfo& theMeshInfo, const PElemInfo& theInfo) + { + myMeshInfo = theMeshInfo; + + myNbElem = theInfo->GetNbElem(); + myFamNum.reset(new TElemNum(myNbElem)); + myIsFamNum = eFAUX; // is set to eVRAI in SetFamNum() + + myIsElemNum = theInfo->IsElemNum(); + if(theInfo->IsElemNum()) + myElemNum.reset(new TElemNum(myNbElem)); + else + myElemNum.reset(new TElemNum()); + + myIsElemNames = theInfo->IsElemNames(); + if(theInfo->IsElemNames()) + myElemNames.reset(new TString(myNbElem*GetPNOMLength() + 1)); + else + myElemNames.reset(new TString()); + + if(theInfo->GetNbElem()){ + for(TInt anId = 0; anId < myNbElem; anId++){ + SetFamNum(anId, theInfo->GetFamNum(anId)); + } + if(theInfo->IsElemNum() == eVRAI){ + for(TInt anId = 0; anId < myNbElem; anId++){ + SetElemNum(anId, theInfo->GetElemNum(anId)); + } + } + if(theInfo->IsElemNames() == eVRAI){ + for(TInt anId = 0; anId < myNbElem; anId++){ + SetElemName(anId,theInfo->GetElemName(anId)); + } + } + } + } + + TTElemInfo(const PMeshInfo& theMeshInfo, + TInt theNbElem, + EBooleen theIsElemNum, + EBooleen theIsElemNames) + { + myMeshInfo = theMeshInfo; + + myNbElem = theNbElem; + myFamNum.reset(new TElemNum(theNbElem)); + myIsFamNum = eFAUX; // is set to eVRAI in SetFamNum() + + myIsElemNum = theIsElemNum; + if(theIsElemNum) + myElemNum.reset(new TElemNum(theNbElem)); + else + myElemNum.reset(new TElemNum()); + + myIsElemNames = theIsElemNames; + if(theIsElemNames) + myElemNames.reset(new TString(theNbElem*GetPNOMLength() + 1)); + else + myElemNames.reset(new TString()); + } + + TTElemInfo(const PMeshInfo& theMeshInfo, + TInt theNbElem, + const TIntVector& theFamilyNums, + const TIntVector& theElemNums, + const TStringVector& theElemNames) + { + myMeshInfo = theMeshInfo; + + myNbElem = theNbElem; + myFamNum.reset(new TElemNum(theNbElem)); + myIsFamNum = eFAUX; // is set to eVRAI in SetFamNum() + + myIsElemNum = theElemNums.size()? eVRAI: eFAUX; + if(myIsElemNum) + myElemNum.reset(new TElemNum(theNbElem)); + else + myElemNum.reset(new TElemNum()); + + myIsElemNames = theElemNames.size()? eVRAI: eFAUX; + if(myIsElemNames) + myElemNames.reset(new TString(theNbElem*GetPNOMLength() + 1)); + else + myElemNames.reset(new TString()); + + if(theNbElem){ + + if(theFamilyNums.size()) + *myFamNum = theFamilyNums; + + if(myIsElemNum) + *myElemNum = theElemNums; + + if(myIsElemNames){ + for(TInt anId = 0; anId < theNbElem; anId++){ + const std::string& aVal = theElemNames[anId]; + SetElemName(anId,aVal); + } + } + } + } + + virtual + std::string + GetElemName(TInt theId) const + { + return GetString(theId,GetPNOMLength(), *myElemNames); + } + + virtual + void + SetElemName(TInt theId, const std::string& theValue) + { + SetString(theId,GetPNOMLength(), *myElemNames, theValue); + } + }; + + + //--------------------------------------------------------------- + template + struct TTNodeInfo: + virtual TNodeInfo, + virtual TTElemInfo + { + typedef TTElemInfo TElemInfoBase; + + TTNodeInfo(const PMeshInfo& theMeshInfo, const PNodeInfo& theInfo): + TNodeInfo(theInfo), + TElemInfoBase(theMeshInfo, theInfo) + { + myModeSwitch = theInfo->GetModeSwitch(); + + mySystem = theInfo->GetSystem(); + + myCoord.reset(new TNodeCoord(*theInfo->myCoord)); + + TInt aSpaceDim = theMeshInfo->GetSpaceDim(); + + myCoordNames.resize(aSpaceDim*GetPNOMLength()+1); + for(TInt anId = 0; anId < aSpaceDim; anId++) + SetCoordName(anId,theInfo->GetCoordName(anId)); + + myCoordUnits.resize(aSpaceDim*GetPNOMLength()+1); + for(TInt anId = 0; anId < aSpaceDim; anId++) + SetCoordUnit(anId,theInfo->GetCoordUnit(anId)); + } + + TTNodeInfo(const PMeshInfo& theMeshInfo, + TInt theNbElem, + EModeSwitch theMode, + ERepere theSystem, + EBooleen theIsElemNum, + EBooleen theIsElemNames): + TModeSwitchInfo(theMode), + TElemInfoBase(theMeshInfo, + theNbElem, + theIsElemNum, + theIsElemNames) + { + mySystem = theSystem; + + myCoord.reset(new TNodeCoord(theNbElem * theMeshInfo->mySpaceDim)); + + myCoordUnits.resize(theMeshInfo->mySpaceDim*GetPNOMLength()+1); + + myCoordNames.resize(theMeshInfo->mySpaceDim*GetPNOMLength()+1); + } + + + TTNodeInfo(const PMeshInfo& theMeshInfo, + const TFloatVector& theNodeCoords, + EModeSwitch theMode, + ERepere theSystem, + const TStringVector& theCoordNames, + const TStringVector& theCoordUnits, + const TIntVector& theFamilyNums, + const TIntVector& theElemNums, + const TStringVector& theElemNames): + TModeSwitchInfo(theMode), + TElemInfoBase(theMeshInfo, + (TInt)theNodeCoords.size()/theMeshInfo->GetDim(), + theFamilyNums, + theElemNums, + theElemNames) + { + mySystem = theSystem; + + myCoord.reset(new TNodeCoord(theNodeCoords)); + + TInt aSpaceDim = theMeshInfo->GetSpaceDim(); + + myCoordNames.resize(aSpaceDim*GetPNOMLength()+1); + if(!theCoordNames.empty()) + for(TInt anId = 0; anId < aSpaceDim; anId++) + SetCoordName(anId,theCoordNames[anId]); + + myCoordUnits.resize(aSpaceDim*GetPNOMLength() + 1); + if(!theCoordUnits.empty()) + for(TInt anId = 0; anId < aSpaceDim; anId++) + SetCoordUnit(anId, theCoordUnits[anId]); + } + + virtual + std::string + GetCoordName(TInt theId) const + { + return GetString(theId,GetPNOMLength(),myCoordNames); + } + + virtual + void + SetCoordName(TInt theId, const std::string& theValue) + { + SetString(theId,GetPNOMLength(),myCoordNames,theValue); + } + + virtual + std::string + GetCoordUnit(TInt theId) const + { + return GetString(theId,GetPNOMLength(),myCoordUnits); + } + + virtual + void + SetCoordUnit(TInt theId, const std::string& theValue) + { + SetString(theId,GetPNOMLength(),myCoordUnits,theValue); + } + }; + + //--------------------------------------------------------------- + template + struct TTPolygoneInfo: + virtual TPolygoneInfo, + virtual TTElemInfo + { + typedef TTElemInfo TElemInfoBase; + + TTPolygoneInfo(const PMeshInfo& theMeshInfo, const PPolygoneInfo& theInfo): + TElemInfoBase(theMeshInfo,theInfo) + { + myEntity = theInfo->GetEntity(); + myGeom = theInfo->GetGeom(); + + myIndex.reset(new TElemNum(*theInfo->myIndex)); + myConn.reset(new TElemNum(*theInfo->myConn)); + + myConnMode = theInfo->GetConnMode(); + } + + TTPolygoneInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TInt theNbElem, + TInt theConnSize, + EConnectivite theConnMode, + EBooleen theIsElemNum, + EBooleen theIsElemNames): + TElemInfoBase(theMeshInfo, + theNbElem, + theIsElemNum, + theIsElemNames) + { + myEntity = theEntity; + myGeom = theGeom; + + myIndex.reset(new TElemNum(theNbElem + 1)); + myConn.reset(new TElemNum(theConnSize)); + + myConnMode = theConnMode; + } + + TTPolygoneInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + const TIntVector& theIndexes, + const TIntVector& theConnectivities, + EConnectivite theConnMode, + const TIntVector& theFamilyNums, + const TIntVector& theElemNums, + const TStringVector& theElemNames): + TElemInfoBase(theMeshInfo, + (TInt)theIndexes.size() - 1, + theFamilyNums, + theElemNums, + theElemNames) + { + myEntity = theEntity; + myGeom = theGeom; + + myIndex.reset(new TElemNum(theIndexes)); + myConn.reset(new TElemNum(theConnectivities)); + + myConnMode = theConnMode; + } + }; + + //--------------------------------------------------------------- + template + struct TTPolyedreInfo: + virtual TPolyedreInfo, + virtual TTElemInfo + { + typedef TTElemInfo TElemInfoBase; + + TTPolyedreInfo(const PMeshInfo& theMeshInfo, const PPolyedreInfo& theInfo): + TElemInfoBase(theMeshInfo,theInfo) + { + myEntity = theInfo->GetEntity(); + myGeom = theInfo->GetGeom(); + + myIndex.reset(new TElemNum(*theInfo->myIndex)); + myFaces.reset(new TElemNum(*theInfo->myFaces)); + myConn.reset(new TElemNum(*theInfo->myConn)); + + myConnMode = theInfo->GetConnMode(); + } + + TTPolyedreInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TInt theNbElem, + TInt theNbFaces, + TInt theConnSize, + EConnectivite theConnMode, + EBooleen theIsElemNum, + EBooleen theIsElemNames): + TElemInfoBase(theMeshInfo, + theNbElem, + theIsElemNum, + theIsElemNames) + { + myEntity = theEntity; + myGeom = theGeom; + + myIndex.reset(new TElemNum(theNbElem + 1)); + myFaces.reset(new TElemNum(theNbFaces)); + myConn.reset(new TElemNum(theConnSize)); + + myConnMode = theConnMode; + } + + TTPolyedreInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + const TIntVector& theIndexes, + const TIntVector& theFaces, + const TIntVector& theConnectivities, + EConnectivite theConnMode, + const TIntVector& theFamilyNums, + const TIntVector& theElemNums, + const TStringVector& theElemNames): + TElemInfoBase(theMeshInfo, + (TInt)theIndexes.size()-1, + theFamilyNums, + theElemNums, + theElemNames) + { + myEntity = theEntity; + myGeom = theGeom; + + myIndex.reset(new TElemNum(theIndexes)); + myFaces.reset(new TElemNum(theFaces)); + myConn.reset(new TElemNum(theConnectivities)); + + myConnMode = theConnMode; + } + }; + + //--------------------------------------------------------------- + template + struct TTCellInfo: + virtual TCellInfo, + virtual TTElemInfo + { + typedef TTElemInfo TElemInfoBase; + + TTCellInfo(const PMeshInfo& theMeshInfo, const PCellInfo& theInfo): + TElemInfoBase(theMeshInfo,theInfo) + { + myEntity = theInfo->GetEntity(); + myGeom = theInfo->GetGeom(); + myConnMode = theInfo->GetConnMode(); + + TInt aConnDim = GetNbNodes(myGeom); + TInt aNbConn = GetNbConn(myGeom, myEntity, myMeshInfo->myDim); + myConn.reset(new TElemNum(myNbElem * aNbConn)); + for(TInt anElemId = 0; anElemId < myNbElem; anElemId++){ + TConnSlice aConnSlice = GetConnSlice(anElemId); + TCConnSlice aConnSlice2 = theInfo->GetConnSlice(anElemId); + for(TInt anConnId = 0; anConnId < aConnDim; anConnId++){ + aConnSlice[anConnId] = aConnSlice2[anConnId]; + } + } + } + + TTCellInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TInt theNbElem, + EConnectivite theConnMode, + EBooleen theIsElemNum, + EBooleen theIsElemNames, + EModeSwitch theMode): + TModeSwitchInfo(theMode), + TElemInfoBase(theMeshInfo, + theNbElem, + theIsElemNum, + theIsElemNames) + { + myEntity = theEntity; + myGeom = theGeom; + + myConnMode = theConnMode; + TInt aNbConn = GetNbConn(theGeom, myEntity, theMeshInfo->myDim); + myConn.reset(new TElemNum(theNbElem * aNbConn)); + } + + TTCellInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + const TIntVector& theConnectivities, + EConnectivite theConnMode, + const TIntVector& theFamilyNums, + const TIntVector& theElemNums, + const TStringVector& theElemNames, + EModeSwitch theMode): + TModeSwitchInfo(theMode), + TElemInfoBase(theMeshInfo, + (TInt)theConnectivities.size() / GetNbNodes(theGeom), + theFamilyNums, + theElemNums, + theElemNames) + { + myEntity = theEntity; + myGeom = theGeom; + + myConnMode = theConnMode; + TInt aConnDim = GetNbNodes(myGeom); + TInt aNbConn = GetNbConn(myGeom, myEntity, myMeshInfo->myDim); + myConn.reset(new TElemNum(myNbElem * aNbConn)); + for(TInt anElemId = 0; anElemId < myNbElem; anElemId++){ + TConnSlice aConnSlice = GetConnSlice(anElemId); + for(TInt anConnId = 0; anConnId < aConnDim; anConnId++){ + aConnSlice[anConnId] = theConnectivities[anElemId*aConnDim + anConnId]; + } + } + } + + virtual + TInt + GetConnDim() const + { + return GetNbConn(myGeom, myEntity, myMeshInfo->myDim); + } + + }; + + //--------------------------------------------------------------- + template + struct TTBallInfo: + virtual TBallInfo, + virtual TTCellInfo + { + typedef TTCellInfo TCellInfoBase; + + TTBallInfo(const PMeshInfo& theMeshInfo, const PBallInfo& theInfo): + TCellInfoBase::TElemInfoBase(theMeshInfo, theInfo), + TCellInfoBase(theMeshInfo,theInfo) + { + myDiameters = theInfo->myDiameters; + } + + TTBallInfo(const PMeshInfo& theMeshInfo, + TInt theNbElem, + EBooleen theIsElemNum ): + TCellInfoBase::TElemInfoBase(theMeshInfo, + theNbElem, + theIsElemNum, + /*theIsElemNames=*/eFAUX), + TCellInfoBase(theMeshInfo, + eSTRUCT_ELEMENT, + eBALL, + theNbElem, + /*EConnectivite=*/eNOD, + theIsElemNum, + /*theIsElemNames=*/eFAUX, + eFULL_INTERLACE) + { + myDiameters.resize( theNbElem ); + } + + TTBallInfo(const PMeshInfo& theMeshInfo, + const TIntVector& theNodes, + TFloatVector& theDiameters, + const TIntVector& theFamilyNums, + const TIntVector& theElemNums): + TCellInfoBase::TElemInfoBase(theMeshInfo, + (TInt)std::max(theNodes.size(),theDiameters.size() ), + theFamilyNums, + theElemNums, + TStringVector()), + TCellInfoBase(theMeshInfo, + eSTRUCT_ELEMENT, + eBALL, + theNodes, + /*EConnectivite=*/eNOD, + theFamilyNums, + theElemNums, + TStringVector(), + eFULL_INTERLACE) + { + myDiameters.swap( theDiameters ); + } + }; + + //--------------------------------------------------------------- + template + struct TTFieldInfo: + virtual TFieldInfo, + virtual TTNameInfo + { + typedef TTNameInfo TNameInfoBase; + + TTFieldInfo(const PMeshInfo& theMeshInfo, const PFieldInfo& theInfo): + TNameInfoBase(theInfo->GetName()) + { + myMeshInfo = theMeshInfo; + + myNbComp = theInfo->GetNbComp(); + myCompNames.resize(myNbComp*GetPNOMLength()+1); + for(TInt anId = 0; anId < myNbComp; anId++){ + SetCompName(anId,theInfo->GetCompName(anId)); + } + + myUnitNames.resize(myNbComp*GetPNOMLength()+1); + for(TInt anId = 0; anId < myNbComp; anId++){ + SetUnitName(anId,theInfo->GetUnitName(anId)); + } + + myType = theInfo->GetType(); + + myIsLocal = theInfo->GetIsLocal(); + myNbRef = theInfo->GetNbRef(); + } + + TTFieldInfo(const PMeshInfo& theMeshInfo, + TInt theNbComp, + ETypeChamp theType, + const std::string& theValue, + EBooleen theIsLocal, + TInt theNbRef): + TNameInfoBase(theValue) + { + myMeshInfo = theMeshInfo; + + myNbComp = theNbComp; + myCompNames.resize(theNbComp*GetPNOMLength()+1); + myUnitNames.resize(theNbComp*GetPNOMLength()+1); + + myType = theType; + + myIsLocal = theIsLocal; + myNbRef = theNbRef; + } + + virtual + std::string + GetCompName(TInt theId) const + { + return GetString(theId,GetPNOMLength(),myCompNames); + } + + virtual + void + SetCompName(TInt theId, const std::string& theValue) + { + SetString(theId,GetPNOMLength(),myCompNames,theValue); + } + + virtual + std::string + GetUnitName(TInt theId) const + { + return GetString(theId,GetPNOMLength(),myUnitNames); + } + + virtual + void + SetUnitName(TInt theId, const std::string& theValue) + { + SetString(theId,GetPNOMLength(),myUnitNames,theValue); + } + }; + + + //--------------------------------------------------------------- + template + struct TTGaussInfo: + virtual TGaussInfo, + virtual TTNameInfo + { + typedef TTNameInfo TNameInfoBase; + + TTGaussInfo(const TGaussInfo::TInfo& theInfo, + EModeSwitch theMode): + TModeSwitchInfo(theMode), + TNameInfoBase(boost::get<1>(boost::get<0>(theInfo))) + { + const TGaussInfo::TKey& aKey = boost::get<0>(theInfo); + + myGeom = boost::get<0>(aKey); + myRefCoord.resize(GetNbRef()*GetDim()); + + TInt aNbGauss = boost::get<1>(theInfo); + myGaussCoord.resize(aNbGauss*GetDim()); + myWeight.resize(aNbGauss); + } + }; + + + //--------------------------------------------------------------- + template + struct TTTimeStampInfo: virtual TTimeStampInfo + { + TTTimeStampInfo(const PFieldInfo& theFieldInfo, const PTimeStampInfo& theInfo) + { + myFieldInfo = theFieldInfo; + + myEntity = theInfo->GetEntity(); + myGeom2Size = theInfo->GetGeom2Size(); + + myNumDt = theInfo->GetNumDt(); + myNumOrd = theInfo->GetNumOrd(); + myDt = theInfo->GetDt(); + + myUnitDt.resize(GetPNOMLength()+1); + SetUnitDt(theInfo->GetUnitDt()); + + myGeom2NbGauss = theInfo->myGeom2NbGauss; + myGeom2Gauss = theInfo->GetGeom2Gauss(); + } + + TTTimeStampInfo(const PFieldInfo& theFieldInfo, + EEntiteMaillage theEntity, + const TGeom2Size& theGeom2Size, + const TGeom2NbGauss& theGeom2NbGauss, + TInt theNumDt, + TInt theNumOrd, + TFloat theDt, + const std::string& theUnitDt, + const TGeom2Gauss& theGeom2Gauss) + { + myFieldInfo = theFieldInfo; + + myEntity = theEntity; + myGeom2Size = theGeom2Size; + + myNumDt = theNumDt; + myNumOrd = theNumDt; + myDt = theDt; + + myUnitDt.resize(GetPNOMLength()+1); + SetUnitDt(theUnitDt); + + myGeom2NbGauss = theGeom2NbGauss; + myGeom2Gauss = theGeom2Gauss; + } + + virtual + std::string + GetUnitDt() const + { + return GetString(0,GetPNOMLength(),myUnitDt); + } + + virtual + void + SetUnitDt(const std::string& theValue) + { + SetString(0,GetPNOMLength(),myUnitDt,theValue); + } + }; + + + //--------------------------------------------------------------- + template + struct TTProfileInfo: + virtual TProfileInfo, + virtual TTNameInfo + { + typedef TTNameInfo TNameInfoBase; + + TTProfileInfo(const TProfileInfo::TInfo& theInfo, + EModeProfil theMode): + TNameInfoBase(boost::get<0>(theInfo)) + { + TInt aSize = boost::get<1>(theInfo); + myElemNum.reset(new TElemNum(aSize)); + myMode = aSize > 0? theMode: eNO_PFLMOD; + } + }; + + + //--------------------------------------------------------------- + template + struct TTTimeStampValue: virtual TTimeStampValue + { + TTTimeStampValue(const PTimeStampInfo& theTimeStampInfo, + const PTimeStampValueBase& theInfo, + ETypeChamp theTypeChamp) + { + typedef TTimeStampValue TCompatible; + if(TCompatible* aCompatible = dynamic_cast(theInfo.get())){ + this->myTimeStampInfo = theTimeStampInfo; + this->myTypeChamp = theTypeChamp; + this->myGeom2Profile = aCompatible->GetGeom2Profile(); + this->myGeom2Value = aCompatible->myGeom2Value; + this->myGeomSet = aCompatible->GetGeomSet(); + }else + EXCEPTION(std::runtime_error,"TTTimeStampValue::TTTimeStampValue - use incompatible arguments!"); + } + + TTTimeStampValue(const PTimeStampInfo& theTimeStampInfo, + ETypeChamp theTypeChamp, + const TGeom2Profile& theGeom2Profile, + EModeSwitch theMode): + TModeSwitchInfo(theMode) + { + this->myTimeStampInfo = theTimeStampInfo; + + this->myTypeChamp = theTypeChamp; + + this->myGeom2Profile = theGeom2Profile; + + TInt aNbComp = theTimeStampInfo->myFieldInfo->myNbComp; + + const TGeom2Size& aGeom2Size = theTimeStampInfo->GetGeom2Size(); + TGeom2Size::const_iterator anIter = aGeom2Size.begin(); + for(; anIter != aGeom2Size.end(); anIter++){ + const EGeometrieElement& aGeom = anIter->first; + TInt aNbElem = anIter->second; + + MED::PProfileInfo aProfileInfo; + MED::TGeom2Profile::const_iterator anIter = theGeom2Profile.find(aGeom); + if(anIter != theGeom2Profile.end()) + aProfileInfo = anIter->second; + + if(aProfileInfo && aProfileInfo->IsPresent()) + aNbElem = aProfileInfo->GetSize(); + + TInt aNbGauss = theTimeStampInfo->GetNbGauss(aGeom); + + this->GetMeshValue(aGeom).Allocate(aNbElem,aNbGauss,aNbComp); + } + } + + virtual + size_t + GetValueSize(EGeometrieElement theGeom) const + { + return this->GetMeshValue(theGeom).GetSize(); + } + + virtual + size_t + GetNbVal(EGeometrieElement theGeom) const + { + return this->GetMeshValue(theGeom).GetNbVal(); + } + + virtual + size_t + GetNbGauss(EGeometrieElement theGeom) const + { + return this->GetMeshValue(theGeom).GetNbGauss(); + } + + virtual + void + AllocateValue(EGeometrieElement theGeom, + TInt theNbElem, + TInt theNbGauss, + TInt theNbComp, + EModeSwitch theMode = eFULL_INTERLACE) + { + this->GetMeshValue(theGeom).Allocate(theNbElem,theNbGauss,theNbComp,theMode); + } + + virtual + unsigned char* + GetValuePtr(EGeometrieElement theGeom) + { + return this->GetMeshValue(theGeom).GetValuePtr(); + } + }; + + //--------------------------------------------------------------- + template + struct TTGrilleInfo: + virtual TGrilleInfo + { + TTGrilleInfo(const PMeshInfo& theMeshInfo, + const PGrilleInfo& theInfo) + { + myMeshInfo = theMeshInfo; + + myCoord = theInfo->GetNodeCoord(); + + myGrilleType = theInfo->GetGrilleType(); + + myCoordNames = theInfo->myCoordNames; + + myCoordUnits = theInfo->myCoordUnits; + + myIndixes = theInfo->GetMapOfIndexes(); + + myGrilleStructure = theInfo->GetGrilleStructure(); + + myGrilleType = theInfo->GetGrilleType(); + + myFamNumNode.resize(theInfo->GetNbNodes()); + myFamNumNode = theInfo->myFamNumNode; + + myFamNum = theInfo->myFamNum; + } + + TTGrilleInfo(const PMeshInfo& theMeshInfo, + const EGrilleType& type, + const TInt nnoeuds) + { + myMeshInfo = theMeshInfo; + TInt aSpaceDim = theMeshInfo->GetSpaceDim(); + if(type == eGRILLE_STANDARD){ + myCoord.resize(aSpaceDim*nnoeuds); + myCoordNames.resize(aSpaceDim*GetPNOMLength()+1); + myCoordUnits.resize(aSpaceDim*GetPNOMLength()+1); + } else { //if(type == eGRILLE_CARTESIENNE){ + myCoordNames.resize(aSpaceDim*GetPNOMLength()+aSpaceDim); + myCoordUnits.resize(aSpaceDim*GetPNOMLength()+aSpaceDim); + } + myGrilleStructure.resize(aSpaceDim); + myFamNumNode.resize(nnoeuds); + } + + TTGrilleInfo(const PMeshInfo& theMeshInfo, + const EGrilleType& type) + { + myMeshInfo = theMeshInfo; + TInt aSpaceDim = theMeshInfo->GetSpaceDim(); + if(type == eGRILLE_STANDARD){ + myCoordNames.resize(aSpaceDim*GetPNOMLength()+1); + myCoordUnits.resize(aSpaceDim*GetPNOMLength()+1); + } else {// if(type == eGRILLE_CARTESIENNE){ + myCoordNames.resize(aSpaceDim*GetPNOMLength()+aSpaceDim); + myCoordUnits.resize(aSpaceDim*GetPNOMLength()+aSpaceDim); + } + myGrilleStructure.resize(aSpaceDim); + } + + TTGrilleInfo(const PMeshInfo& theMeshInfo, + const EGrilleType& type, + const MED::TIntVector& nbNodeVec) + { + myMeshInfo = theMeshInfo; + + TInt aSpaceDim = theMeshInfo->GetSpaceDim(); + if(type == eGRILLE_STANDARD){ + myCoordNames.resize(aSpaceDim*GetPNOMLength()+1); + myCoordUnits.resize(aSpaceDim*GetPNOMLength()+1); + } else {// if(type == eGRILLE_CARTESIENNE){ + myCoordNames.resize(aSpaceDim*GetPNOMLength()+aSpaceDim); + myCoordUnits.resize(aSpaceDim*GetPNOMLength()+aSpaceDim); + } + + if(type != eGRILLE_STANDARD) + for(unsigned int aAxe=0;aAxe(),myCoordNames); + } + + virtual + void + SetCoordName(TInt theId, const std::string& theValue) + { + SetString(theId,GetPNOMLength(),myCoordNames,theValue); + } + + virtual + std::string + GetCoordUnit(TInt theId) const + { + return GetString(theId,GetPNOMLength(),myCoordUnits); + } + + virtual + void + SetCoordUnit(TInt theId, const std::string& theValue) + { + SetString(theId,GetPNOMLength(),myCoordUnits,theValue); + } + + }; +} + +#endif diff --git a/src/MEDWrapper/Base/MED_TWrapper.hxx b/src/MEDWrapper/Base/MED_TWrapper.hxx new file mode 100644 index 000000000..4acda13b4 --- /dev/null +++ b/src/MEDWrapper/Base/MED_TWrapper.hxx @@ -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 + 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 + (theDim, + theSpaceDim, + theValue, + theType, + theDesc)); + } + + virtual + PMeshInfo + CrMeshInfo(const PMeshInfo& theInfo) + { + return PMeshInfo(new TTMeshInfo(theInfo)); + } + + + //---------------------------------------------------------------------------- + virtual + PFamilyInfo + CrFamilyInfo(const PMeshInfo& theMeshInfo, + TInt theNbGroup = 0, + TInt theNbAttr = 0, + TInt theId = 0, + const std::string& theValue = "") + { + return PFamilyInfo(new TTFamilyInfo + (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 + (theMeshInfo, + theValue, + theId, + theGroupNames, + theAttrDescs, + theAttrIds, + theAttrVals)); + } + + virtual + PFamilyInfo + CrFamilyInfo(const PMeshInfo& theMeshInfo, + const PFamilyInfo& theInfo) + { + return PFamilyInfo(new TTFamilyInfo + (theMeshInfo, + theInfo)); + } + + //---------------------------------------------------------------------------- + virtual + PElemInfo + CrElemInfo(const PMeshInfo& theMeshInfo, + TInt theNbElem, + EBooleen theIsElemNum = eVRAI, + EBooleen theIsElemNames = eVRAI) + { + return PElemInfo(new TTElemInfo + (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 + (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 + (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 + (theMeshInfo, + theNodeCoords, + theMode, + theSystem, + theCoordNames, + theCoordUnits, + theFamilyNums, + theElemNums, + theElemNames)); + } + + virtual + PNodeInfo + CrNodeInfo(const PMeshInfo& theMeshInfo, + const PNodeInfo& theInfo) + { + return PNodeInfo(new TTNodeInfo + (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 + (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 + (theMeshInfo, + theEntity, + theGeom, + theIndexes, + theConnectivities, + theConnMode, + theFamilyNums, + theElemNums, + theElemNames)); + } + + virtual + PPolygoneInfo + CrPolygoneInfo(const PMeshInfo& theMeshInfo, + const PPolygoneInfo& theInfo) + { + return PPolygoneInfo(new TTPolygoneInfo + (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 + (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 + (theMeshInfo, + theEntity, + theGeom, + theIndexes, + theFaces, + theConnectivities, + theConnMode, + theFamilyNums, + theElemNums, + theElemNames)); + } + + virtual + PPolyedreInfo + CrPolyedreInfo(const PMeshInfo& theMeshInfo, + const PPolyedreInfo& theInfo) + { + return PPolyedreInfo(new TTPolyedreInfo + (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 + (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 + (theMeshInfo, + theEntity, + theGeom, + theConnectivities, + theConnMode, + theFamilyNums, + theElemNums, + theElemNames, + theMode)); + } + + virtual + PCellInfo + CrCellInfo(const PMeshInfo& theMeshInfo, + const PCellInfo& theInfo) + { + return PCellInfo(new TTCellInfo + (theMeshInfo, + theInfo)); + } + + //---------------------------------------------------------------------------- + //! Creates a MEDWrapper MED Balls representation + virtual PBallInfo CrBallInfo(const PMeshInfo& theMeshInfo, + TInt theNbBalls, + EBooleen theIsElemNum = eVRAI) + { + return PBallInfo( new TTBallInfo( 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( 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( 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 + (theMeshInfo, + theNbComp, + theType, + theValue, + theIsLocal, + theNbRef)); + } + + virtual + PFieldInfo + CrFieldInfo(const PMeshInfo& theMeshInfo, + const PFieldInfo& theInfo) + { + return PFieldInfo(new TTFieldInfo + (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 + (theFieldInfo, + theEntity, + theGeom2Size, + theGeom2NbGauss, + theNumDt, + theNumOrd, + theDt, + theUnitDt, + theGeom2Gauss)); + } + + virtual + PTimeStampInfo + CrTimeStampInfo(const PFieldInfo& theFieldInfo, + const PTimeStampInfo& theInfo) + { + return PTimeStampInfo(new TTTimeStampInfo + (theFieldInfo, + theInfo)); + } + + + //---------------------------------------------------------------------------- + virtual + PGaussInfo + CrGaussInfo(const TGaussInfo::TInfo& theInfo, + EModeSwitch theMode = eFULL_INTERLACE) + { + return PGaussInfo(new TTGaussInfo + (theInfo, + theMode)); + } + + + //---------------------------------------------------------------------------- + virtual + PProfileInfo + CrProfileInfo(const TProfileInfo::TInfo& theInfo, + EModeProfil theMode = eCOMPACT) + { + return PProfileInfo(new TTProfileInfo + (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 + (theTimeStampInfo, + theTypeChamp, + theGeom2Profile, + theMode)); + return PTimeStampValueBase(new TTTimeStampValue + (theTimeStampInfo, + theTypeChamp, + theGeom2Profile, + theMode)); + } + + virtual + PTimeStampValueBase + CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo, + const PTimeStampValueBase& theInfo, + ETypeChamp theTypeChamp) + { + if(theTypeChamp == eFLOAT64) + return PTimeStampValueBase(new TTTimeStampValue + (theTimeStampInfo, + theInfo, + theTypeChamp)); + return PTimeStampValueBase(new TTTimeStampValue + (theTimeStampInfo, + theInfo, + theTypeChamp)); + } + + //---------------------------------------------------------------------------- + virtual + PGrilleInfo + CrGrilleInfo(const PMeshInfo& theMeshInfo, + const PGrilleInfo& theInfo) + { + return PGrilleInfo(new TTGrilleInfo + (theMeshInfo, + theInfo)); + } + virtual + PGrilleInfo + CrGrilleInfo(const PMeshInfo& theMeshInfo, + const EGrilleType& type) + { + return PGrilleInfo(new TTGrilleInfo + (theMeshInfo, + type)); + } + + virtual + PGrilleInfo + CrGrilleInfo(const PMeshInfo& theMeshInfo, + const EGrilleType& type, + const TInt& nbNodes) + { + return PGrilleInfo(new TTGrilleInfo + (theMeshInfo, + type, + nbNodes)); + } + + virtual + PGrilleInfo + CrGrilleInfo(const PMeshInfo& theMeshInfo, + const EGrilleType& type, + const MED::TIntVector& nbNodeVec) + { + return PGrilleInfo(new TTGrilleInfo + (theMeshInfo, + type, + nbNodeVec)); + } + //---------------------------------------------------------------------------- + }; + +} + + +#endif diff --git a/src/MEDWrapper/Base/MED_Utilities.cxx b/src/MEDWrapper/Base/MED_Utilities.cxx new file mode 100644 index 000000000..49cd74aac --- /dev/null +++ b/src/MEDWrapper/Base/MED_Utilities.cxx @@ -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(...)- "< +#include +#include +#include +#include + + +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< +#include + +//#if defined(_DEBUG_) +# define MED_TVECTOR_CHECK_RANGE +//#endif + +namespace MED +{ + + //! Main purpose to introduce the class was to customize operator [] + template > + 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 + TVector(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()): + superclass(__first, __last, __a) + {} + + template + TVector(TVector<_Yp, _Al> __y): + superclass(__y.begin(), __y.end()) + {} + + TVector& + operator=(const TVector& __x) + { + superclass::operator=(__x); + return *this; + } + + template + 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 diff --git a/src/MEDWrapper/Base/MED_Wrapper.cxx b/src/MEDWrapper/Base/MED_Wrapper.cxx new file mode 100644 index 000000000..d04c28423 --- /dev/null +++ b/src/MEDWrapper/Base/MED_Wrapper.cxx @@ -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 + +#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::lock(myWrapper->myMutex); +#endif + INITMSG(MYDEBUG,"TLockProxy() - this -"<GetGroupName(iGroup); + INITMSG(MYDEBUG,"aGroupName = '"<myDim; + TInt aNbElem = anInfo->GetNbElem(); + INITMSG(MYDEBUG,"GetPNodeInfo: "); + { + INITMSG(MYDEBUG,"aCoords: "<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 = "<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 = "<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 = "<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 = '"<GetName()<<"'"<< + "; aType = "<GetType()<< + "; aNbComp = "<myGeom2NbGauss; + TGeom2NbGauss::const_iterator anIter = aGeom2NbGauss.begin(); + for(; anIter != aGeom2NbGauss.end(); anIter++){ + const EGeometrieElement& aGeom = anIter->first; + INITMSG(MYDEBUG,"aGeom = "<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 + void + Print(SharedPtr 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 = "<GetFieldInfo(); + PTimeStampValueBase anInfo = CrTimeStampValue(theTimeStampInfo, + aFieldInfo->GetType()); + GetTimeStampValue(anInfo, + theMKey2Profile, + theKey2Gauss, + theErr); +#ifdef _DEBUG_ + if(aFieldInfo->GetType() == eFLOAT64) + Print(anInfo); + else + Print(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;aAxeGetDim();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; + } +} diff --git a/src/MEDWrapper/Base/MED_Wrapper.hxx b/src/MEDWrapper/Base/MED_Wrapper.hxx new file mode 100644 index 000000000..027c9a545 --- /dev/null +++ b/src/MEDWrapper/Base/MED_Wrapper.hxx @@ -0,0 +1,1052 @@ +// 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_Wrapper_HeaderFile +#define MED_Wrapper_HeaderFile + +#include "MED_WrapperBase.hxx" + +#include "MED_Structures.hxx" +#include "MED_Algorithm.hxx" + +#include + +namespace MED +{ + + //---------------------------------------------------------------------------- + //! Define a base class that wraps the MED API + struct MEDWRAPPER_EXPORT TWrapper + { + typedef boost::mutex TMutex; + //! This is a syncronization primitive which allow to support thread safety for the MED access + TMutex myMutex; + + virtual + ~TWrapper(); + + //---------------------------------------------------------------------------- + //! Gets version of the MED library used for the MED file + virtual + EVersion + GetVersion() = 0; + + //---------------------------------------------------------------------------- + //! Creates a MEDWrapper MED Mesh representation + virtual + PMeshInfo + CrMeshInfo(TInt theDim = 0, TInt theSpaceDim = 0, + const std::string& theValue = "", + EMaillage theType = eNON_STRUCTURE, + const std::string& theDesc = "") = 0; + + //! A copy-constructor for the MEDWrapper MED Mesh representation + virtual + PMeshInfo + CrMeshInfo(const PMeshInfo& theInfo) = 0; + + //! Read number of MED Mesh entities in the defined MED file + virtual + TInt + GetNbMeshes(TErr* theErr = NULL) = 0; + + //! Read a MEDWrapper MED Mesh representation by its number + virtual + void + GetMeshInfo(TInt theMeshId, + TMeshInfo& theInfo, + TErr* theErr = NULL) = 0; + + //! Write the MEDWrapper MED Mesh representation in the defined MED file + virtual + void + SetMeshInfo(const TMeshInfo& theInfo, + TErr* theErr = NULL) = 0; + + //! Read a MEDWrapper MED Mesh representation by its number + virtual + PMeshInfo + GetPMeshInfo(TInt theId, + TErr* theErr = NULL); + + + //---------------------------------------------------------------------------- + //! Read number of MED Family entities in the defined MED file + virtual + TInt + GetNbFamilies(const TMeshInfo& theMeshInfo, + TErr* theErr = NULL) = 0; + + //! Read number of attributes for defined MED Family + virtual + TInt + GetNbFamAttr(TInt theFamId, + const TMeshInfo& theInfo, + TErr* theErr = NULL) = 0; + + //! Read number of MED Groups where MED Family with the number belong to + virtual + TInt + GetNbFamGroup(TInt theFamId, + const TMeshInfo& theInfo, + TErr* theErr = NULL) = 0; + + //! Read a MEDWrapper MED Family representation by its number + virtual + void + GetFamilyInfo(TInt theFamId, + TFamilyInfo& theInfo, + TErr* theErr = NULL) = 0; + + //! Write a MEDWrapper MED Family representation by its number + virtual + void + SetFamilyInfo(const TFamilyInfo& theInfo, + TErr* theErr = NULL) = 0; + + //! Creates a MEDWrapper MED Family representation + virtual + PFamilyInfo + CrFamilyInfo(const PMeshInfo& theMeshInfo, + TInt theNbGroup = 0, + TInt theNbAttr = 0, + TInt theId = 0, + const std::string& theValue = "") = 0; + + //! Creates a MEDWrapper MED Family representation + virtual + PFamilyInfo + CrFamilyInfo(const PMeshInfo& theMeshInfo, + const std::string& theValue, + TInt theId, + const TStringSet& theGroupNames, + const TStringVector& theAttrDescs = TStringVector(), + const TIntVector& theAttrIds = TIntVector(), + const TIntVector& theAttrVals = TIntVector()) = 0; + + //! A copy-constructor for the MEDWrapper MED Family representation + virtual + PFamilyInfo + CrFamilyInfo(const PMeshInfo& theMeshInfo, + const PFamilyInfo& theInfo) = 0; + + //! Write a MEDWrapper MED Family representation by its number + PFamilyInfo + GetPFamilyInfo(const PMeshInfo& theMeshInfo, + TInt theId, + TErr* theErr = NULL); + + //---------------------------------------------------------------------------- + //! Read sequence of names for any descendant of TElemInfo + virtual + void + GetNames(TElemInfo& theInfo, + TInt theNb, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr = NULL) + {} + + //! Read sequence of numerous for any descendant of TElemInfo + virtual + void + GetNumeration(TElemInfo& theInfo, + TInt theNb, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr = NULL) + {} + + //! Read sequence MED Family indexes for any descendant of TElemInfo + virtual + void + GetFamilies(TElemInfo& theInfo, + TInt theNb, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr = NULL) + {} + + //! Write sequence of names for any descendant of TElemInfo + virtual + void + SetNames(const TElemInfo& theInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr = NULL) + {} + + //! Write sequence of numerous for any descendant of TElemInfo + virtual + void + SetNumeration(const TElemInfo& theInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr = NULL) + {} + + //! Write sequence MED Family indexes for any descendant of TElemInfo + virtual + void + SetFamilies(const TElemInfo& theInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr = NULL) + {} + + //! Read a MEDWrapper MED Element representation from defined MED file + PElemInfo + GetPElemInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity = eNOEUD, + EGeometrieElement theGeom = ePOINT1, + EConnectivite theConnMode = eNOD, + TErr* theErr = NULL); + + //---------------------------------------------------------------------------- + //! Read number of nodes in defined MED Mesh + virtual + TInt + GetNbNodes(const TMeshInfo& theMeshInfo, + TErr* theErr = NULL) = 0; + + virtual + TInt + GetNbNodes(const TMeshInfo& theMeshInfo, + ETable theTable, + TErr* theErr = NULL) + { + return 0; + } + + //! Read a MEDWrapper MED Nodes representation from defined MED file + virtual + void + GetNodeInfo(TNodeInfo& theInfo, + TErr* theErr = NULL) = 0; + + //! Write the MEDWrapper MED Nodes representation into defined MED file + virtual + void + SetNodeInfo(const TNodeInfo& theInfo, + TErr* theErr = NULL) = 0; + + //! Creates a MEDWrapper MED Nodes representation + virtual + PElemInfo + CrElemInfo(const PMeshInfo& theMeshInfo, + TInt theNbElem, + EBooleen theIsElemNum = eVRAI, + EBooleen theIsElemNames = eVRAI) + { + return PElemInfo(); + } + + //! Creates a MEDWrapper MED Nodes representation + virtual + PElemInfo + CrElemInfo(const PMeshInfo& theMeshInfo, + TInt theNbElem, + const TIntVector& theFamNum, + const TIntVector& aElemNum, + const TStringVector& aElemNames) + { + return PElemInfo(); + } + + //! Creates a MEDWrapper MED Nodes representation + virtual + PNodeInfo + CrNodeInfo(const PMeshInfo& theMeshInfo, + TInt theNbElem, + EModeSwitch theMode = eFULL_INTERLACE, + ERepere theSystem = eCART, + EBooleen theIsElemNum = eVRAI, + EBooleen theIsElemNames = eVRAI) = 0; + + //! Creates a MEDWrapper MED Nodes representation + 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()) = 0; + + //! A copy-constructor for the MEDWrapper MED Nodes representation + virtual + PNodeInfo + CrNodeInfo(const PMeshInfo& theMeshInfo, + const PNodeInfo& theInfo) = 0; + + //! Read a MEDWrapper MED Nodes representation from defined MED file + PNodeInfo + GetPNodeInfo(const PMeshInfo& theMeshInfo, + TErr* theErr = NULL); + + //---------------------------------------------------------------------------- + //! Read a MEDWrapper MED Polygones representation from defined MED file + /*! This feature is supported only for version of 2.2 and higher */ + virtual + void + GetPolygoneInfo(TPolygoneInfo& theInfo, + TErr* theErr = NULL) + {} + + //! Write a MEDWrapper MED Polygones representation from defined MED file + /*! This feature is supported only for version of 2.2 and higher */ + virtual + void + SetPolygoneInfo(const TPolygoneInfo& theInfo, + TErr* theErr = NULL) + {} + + //! Read number of MED Polygones in defined MED Mesh + /*! This feature is supported only for version of 2.2 and higher */ + virtual + TInt + GetNbPolygones(const TMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode = eNOD, + TErr* theErr = NULL) + { + return 0; + } + + //! Read connectivity infroamtion for the MED Polygones in defined MED Mesh + /*! This feature is supported only for version of 2.2 and higher */ + virtual + TInt + GetPolygoneConnSize(const TMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode = eNOD, + TErr* theErr = NULL) + { + return 0; + } + + //! Creates a MEDWrapper MED Polygones representation + /*! This feature is supported only for version of 2.2 and higher */ + 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(); + } + + //! Creates a MEDWrapper MED Polygones representation + /*! This feature is supported only for version of 2.2 and higher */ + 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(); + } + + //! A copy-constructor for the MEDWrapper MED Polygones representation + virtual + PPolygoneInfo + CrPolygoneInfo(const PMeshInfo& theMeshInfo, + const PPolygoneInfo& theInfo) + { + return PPolygoneInfo(); + } + + //! Read a MEDWrapper MED Polygones representation from defined MED file + /*! This feature is support only for version of 2.2 and higher */ + PPolygoneInfo + GetPPolygoneInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode = eNOD); + + //---------------------------------------------------------------------------- + //! Read a MEDWrapper MED Polyedres representation from defined MED file + /*! This feature is support only for version of 2.2 and higher */ + virtual + void + GetPolyedreInfo(TPolyedreInfo& theInfo, + TErr* theErr = NULL) + {} + + //! Write a MEDWrapper MED Polyedres representation from defined MED file + /*! This feature is support only for version of 2.2 and higher */ + virtual + void + SetPolyedreInfo(const TPolyedreInfo& theInfo, + TErr* theErr = NULL) + {} + + //! Read number of MED Polyedres in defined MED Mesh + /*! This feature is support only for version of 2.2 and higher */ + virtual + TInt + GetNbPolyedres(const TMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode = eNOD, + TErr* theErr = NULL) + { + return 0; + } + + //! Read connectivity infroamtion for the MED Polyedres in defined MED Mesh + /*! This feature is support only for version of 2.2 and higher */ + virtual + void + GetPolyedreConnSize(const TMeshInfo& theMeshInfo, + TInt& theNbFaces, + TInt& theConnSize, + EConnectivite theConnMode = eNOD, + TErr* theErr = NULL) + { + theNbFaces = theConnSize = 0; + } + + 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(); + } + + //! Creates a MEDWrapper MED Polyedres representation + /*! This feature is support only for version of 2.2 and higher */ + 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(); + } + + //! A copy-constructor for the MEDWrapper MED Polyedres representation + virtual + PPolyedreInfo + CrPolyedreInfo(const PMeshInfo& theMeshInfo, + const PPolyedreInfo& theInfo) + { + return PPolyedreInfo(); + } + + //! Read a MEDWrapper MED Polyedres representation from defined MED file + /*! This feature is support only for version of 2.2 and higher */ + PPolyedreInfo + GetPPolyedreInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode = eNOD); + + //---------------------------------------------------------------------------- + //! Get TEntityInfo which contains brief information about existing cells and their destribution among MED ENTITIES + virtual + TEntityInfo + GetEntityInfo(const TMeshInfo& theMeshInfo, + EConnectivite theConnMode = eNOD, + TErr* theErr = NULL) = 0; + + //! Read number of cells for defined MED Mesh, ENTITY and geometrical type with define mode of connectivity + virtual + TInt + GetNbCells(const TMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode = eNOD, + TErr* theErr = NULL) = 0; + + //! Read a MEDWrapper MED Cells representation from defined MED file + virtual + void + GetCellInfo(TCellInfo& theInfo, + TErr* theErr = NULL) = 0; + + //! Write the MEDWrapper MED Cells representation into defined MED file + virtual + void + SetCellInfo(const TCellInfo& theInfo, + TErr* theErr = NULL) = 0; + + //! Creates a MEDWrapper MED Cells representation + 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) = 0; + + //! Creates a MEDWrapper MED Cells representation + 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) = 0; + + //! A copy-constructor for the MEDWrapper MED Cells representation + virtual + PCellInfo + CrCellInfo(const PMeshInfo& theMeshInfo, + const PCellInfo& theInfo) = 0; + + //! Read a MEDWrapper MED Cells representation from defined MED file + PCellInfo + GetPCellInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode = eNOD, + TErr* theErr = NULL); + + //---------------------------------------------------------------------------- + //! Read number of balls in the Mesh + /*! This feature is supported since version 3.0 */ + virtual + TInt + GetNbBalls(const TMeshInfo& theMeshInfo) + { + return 0; + } + + //! Read a MEDWrapped representation of MED_BALL from the MED file + /*! This feature is supported since version 3.0 */ + virtual + void + GetBallInfo(TBallInfo& theInfo, + TErr* theErr = NULL) + {} + + //! Write a MEDWrapped representation of MED_BALL to the MED file + /*! This feature is supported since version 3.0 */ + virtual + void + SetBallInfo(const TBallInfo& theInfo, + TErr* theErr = NULL) + {} + + //! Creates a MEDWrapper MED Balls representation + /*! This feature is supported since version 3.0 */ + virtual + PBallInfo + CrBallInfo(const PMeshInfo& theMeshInfo, + TInt theNbBalls, + EBooleen theIsElemNum = eVRAI) + { + return PBallInfo(); + } + + //! Creates a MEDWrapper MED Balls representation + /*! This feature is supported since version 3.0 */ + virtual + PBallInfo + CrBallInfo(const PMeshInfo& theMeshInfo, + const TIntVector& theNodes, + TFloatVector& theDiameters, + const TIntVector& theFamilyNums = TIntVector(), + const TIntVector& theElemNums = TIntVector()) + { + return PBallInfo(); + } + + //! A copy-constructor for the MEDWrapped MED Balls representation + virtual + PBallInfo + CrBallInfo(const PMeshInfo& theMeshInfo, + const PBallInfo& theInfo) + { + return PBallInfo(); + } + + //! Read a MEDWrapped MED Balls representation from defined MED file + /*! This feature is supported since version 3.0 */ + virtual + PBallInfo + GetPBallInfo(const PMeshInfo& theMeshInfo); + + //---------------------------------------------------------------------------- + //! Read number of MED FIELDS in defined MED Mesh + virtual + TInt + GetNbFields(TErr* theErr = NULL) = 0; + + //! Read number of components for the defined MED FIELD by its order number + virtual + TInt + GetNbComp(TInt theFieldId, + TErr* theErr = NULL) = 0; + + //! Read MEDWrapper MED FIELD representation by its order number + virtual + void + GetFieldInfo(TInt theFieldId, + TFieldInfo& theInfo, + TErr* theErr = NULL) = 0; + + //! Write MEDWrapper MED FIELD representation into defined MED file + virtual + void + SetFieldInfo(const TFieldInfo& theInfo, + TErr* theErr = NULL) = 0; + + + //! Creates a MEDWrapper MED FIELD representation + virtual + PFieldInfo + CrFieldInfo(const PMeshInfo& theMeshInfo, + TInt theNbComp = 0, + ETypeChamp theType = eFLOAT64, + const std::string& theValue = "", + EBooleen theIsLocal = eVRAI, + TInt theNbRef = 1) = 0; + + //! A copy-constructor for the MEDWrapper MED FIELD representation + virtual + PFieldInfo + CrFieldInfo(const PMeshInfo& theMeshInfo, + const PFieldInfo& theInfo) = 0; + + //! Read a MEDWrapper MED FIELD representation from defined MED file + PFieldInfo + GetPFieldInfo(const PMeshInfo& theMeshInfo, + TInt theId, + TErr* theErr = NULL); + + + //---------------------------------------------------------------------------- + //! Read number of MED GAUSS in defined MED Mesh + /*! This feature is support only for version of 2.2 and higher */ + virtual + TInt + GetNbGauss(TErr* theErr = NULL) + { + return TInt(); + } + + //! Read brief MED GAUSS information by its order number from defined MED Mesh + /*! This feature is support only for version of 2.2 and higher */ + virtual + TGaussInfo::TInfo + GetGaussPreInfo(TInt theId, + TErr* theErr = NULL) + { + return TGaussInfo::TInfo( TGaussInfo::TKey(ePOINT1,""),0 ); + } + + //! Read a MEDWrapper MED GAUSS representation by its order number from defined MED file + /*! This feature is support only for version of 2.2 and higher */ + virtual + void + GetGaussInfo(TInt theId, + TGaussInfo& theInfo, + TErr* theErr = NULL) + {} + + //! Creates a MEDWrapper MED GAUSS representation + /*! This feature is support only for version of 2.2 and higher */ + virtual + PGaussInfo + CrGaussInfo(const TGaussInfo::TInfo& theInfo, + EModeSwitch theMode = eFULL_INTERLACE) = 0; + + + //---------------------------------------------------------------------------- + //! Read number of MED TIMESTAMPS in defined MED Mesh + /*! + By the way some additional information can be obtained: + - to what MED ENTITY the MED TIMESTAMP conntected to; + - on what geometrical types the MED TIMESTAMP defined to. + */ + virtual + TInt + GetNbTimeStamps(const TFieldInfo& theInfo, + const TEntityInfo& theEntityInfo, + EEntiteMaillage& theEntity, + TGeom2Size& theGeom2Size, + TErr* theErr = NULL) = 0; + + //! Read MEDWrapper MED TIMESTAMP representation by its order number + virtual + void + GetTimeStampInfo(TInt theTimeStampId, + TTimeStampInfo& theInfo, + TErr* theErr = NULL) = 0; + + //! Creates a MEDWrapper MED TIMESTAMP representation + 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()) = 0; + + //! A copy-constructor for the MEDWrapper MED TIMESTAMP representation + virtual + PTimeStampInfo + CrTimeStampInfo(const PFieldInfo& theFieldInfo, + const PTimeStampInfo& theInfo) = 0; + + //! Read MEDWrapper MED TIMESTAMP representation by its order number + PTimeStampInfo + GetPTimeStampInfo(const PFieldInfo& theFieldInfo, + EEntiteMaillage theEntity, + const TGeom2Size& theGeom2Size, + TInt theId, + TErr* theErr = NULL); + + + //---------------------------------------------------------------------------- + //! Read number of MED PROFILES in defined MED Mesh + virtual + TInt + GetNbProfiles(TErr* theErr = NULL) = 0; + + //! Read brief MED PROFILE information by its order number from defined MED Mesh + virtual + TProfileInfo::TInfo + GetProfilePreInfo(TInt theId, + TErr* theErr = NULL) = 0; + + //! Read a MEDWrapper MED PROFILE representation by its order number from defined MED file + virtual + void + GetProfileInfo(TInt theId, + TProfileInfo& theInfo, + TErr* theErr = NULL) = 0; + + //! Creates a MEDWrapper MED PROFILE representation + virtual + PProfileInfo + CrProfileInfo(const TProfileInfo::TInfo& theInfo, + EModeProfil theMode = eCOMPACT) = 0; + + //! Write a MEDWrapper MED PROFILE representation + virtual + void + SetProfileInfo(const TProfileInfo& theInfo, + TErr* theErr = NULL) = 0; + + //! Read a MEDWrapper MED PROFILE representation by its order number from defined MED file + PProfileInfo + GetPProfileInfo(TInt theId, + EModeProfil theMode = eCOMPACT, + TErr* theErr = NULL); + + + //---------------------------------------------------------------------------- + //! Read the values for MEDWrapper MED TIEMSTAMP from defined MED file + virtual + void + GetTimeStampValue(const PTimeStampValueBase& theTimeStampValue, + const TMKey2Profile& theMKey2Profile, + const TKey2Gauss& theKey2Gauss, + TErr* theErr = NULL) = 0; + + //! Write the values for MEDWrapper MED TIEMSTAMP to defined MED file + virtual + void + SetTimeStampValue(const PTimeStampValueBase& theTimeStampValue, + TErr* theErr = NULL) = 0; + + //! Creates the values for MEDWrapper MED TIEMSTAMP representation + virtual + PTimeStampValueBase + CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo, + ETypeChamp theTypeChamp, + const TGeom2Profile& theGeom2Profile = TGeom2Profile(), + EModeSwitch theMode = eFULL_INTERLACE) = 0; + + //! Creates the values for MEDWrapper MED TIEMSTAMP representation + virtual + PTimeStampValueBase + CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo, + const TGeom2Profile& theGeom2Profile = TGeom2Profile(), + EModeSwitch theMode = eFULL_INTERLACE); + + //! A copy-constructor for the values for MEDWrapper MED TIEMSTAMP representation + virtual + PTimeStampValueBase + CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo, + const PTimeStampValueBase& theInfo, + ETypeChamp theTypeChamp) = 0; + + //! A copy-constructor for the values for MEDWrapper MED TIEMSTAMP representation + virtual + PTimeStampValueBase + CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo, + const PTimeStampValueBase& theInfo); + + //! Read the values for MEDWrapper MED TIEMSTAMP from defined MED file + PTimeStampValueBase + GetPTimeStampValue(const PTimeStampInfo& theTimeStampInfo, + const TMKey2Profile& theMKey2Profile, + const TKey2Gauss& theKey2Gauss, + TErr* theErr = NULL); + + //---------------------------------------------------------------------------- + // Backward compatibility declarations + //! Read the values for MEDWrapper MED TIEMSTAMP from defined MED file + virtual + void + GetTimeStampVal(const PTimeStampVal& theVal, + const TMKey2Profile& theMKey2Profile, + const TKey2Gauss& theKey2Gauss, + TErr* theErr = NULL); + + //! Write the values for MEDWrapper MED TIEMSTAMP to defined MED file + virtual + void + SetTimeStamp(const PTimeStampVal& theVal, + TErr* theErr = NULL); + + //! Creates the values for MEDWrapper MED TIEMSTAMP representation + virtual + PTimeStampVal + CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo, + const TGeom2Profile& theGeom2Profile = TGeom2Profile(), + EModeSwitch theMode = eFULL_INTERLACE); + + //! A copy-constructor for the values for MEDWrapper MED TIEMSTAMP representation + virtual + PTimeStampVal + CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo, + const PTimeStampVal& theInfo); + + //! Read the values for MEDWrapper MED TIEMSTAMP from defined MED file + PTimeStampVal + GetPTimeStampVal(const PTimeStampInfo& theTimeStampInfo, + const TMKey2Profile& theMKey2Profile, + const TKey2Gauss& theKey2Gauss, + TErr* theErr = NULL); + + //---------------------------------------------------------------------------- + //! Read a MEDWrapper MED Grille representation from defined MED file + /*! This feature is support only for version of 2.2 and higher */ + PGrilleInfo + GetPGrilleInfo(const PMeshInfo& theMeshInfo); + + //! Read a MEDWrapper MED Grille representation from defined MED file + /*! This feature is support only for version of 2.2 and higher */ + PGrilleInfo + GetPGrilleInfo(const PMeshInfo& theMeshInfo, + const PGrilleInfo& theInfo); + + //! Read a MEDWrapper MED Grille representation from defined MED file + /*! This feature is support only for version of 2.2 and higher */ + virtual + void + GetGrilleInfo(TGrilleInfo& theInfo, + TErr* theErr = NULL) + {} + + //! Write the MEDWrapper MED Grille representation into defined MED file + /*! This feature is support only for version of 2.2 and higher */ + virtual + void + SetGrilleInfo(const TGrilleInfo& theInfo, + TErr* theErr = NULL) + {} + + /*! This feature is support only for version of 2.2 and higher */ + virtual + PGrilleInfo + CrGrilleInfo(const PMeshInfo& theMeshInfo, + const PGrilleInfo& theGrilleInfo) + { + return PGrilleInfo(); + } + + /*! This feature is support only for version of 2.2 and higher */ + virtual + PGrilleInfo + CrGrilleInfo(const PMeshInfo& theMeshInfo) + { + return PGrilleInfo(); + } + + /*! This feature is support only for version of 2.2 and higher */ + virtual + PGrilleInfo + CrGrilleInfo(const PMeshInfo& theMeshInfo, + const EGrilleType& type) + { + return PGrilleInfo(); + } + + /*! This feature is support only for version of 2.2 and higher */ + virtual + PGrilleInfo + CrGrilleInfo(const PMeshInfo& theMeshInfo, + const EGrilleType& type, + const TInt& nbNodes) + { + return PGrilleInfo(); + } + + /*! This feature is support only for version of 2.2 and higher */ + virtual + PGrilleInfo + CrGrilleInfo(const PMeshInfo& theMeshInfo, + const EGrilleType& type, + const MED::TIntVector& nbNodeVec) + { + return PGrilleInfo(); + } + + /*! This feature is support only for version of 2.2 and higher */ + virtual + void + GetGrilleType(const TMeshInfo& theMeshInfo, + EGrilleType& type, + TErr* theErr = NULL) + { + } + + }; + + + //---------------------------------------------------------------------------- + //! This class provide thread-safety for MEDWrapper interaction + class MEDWRAPPER_EXPORT TLockProxy + { + TLockProxy& operator=(const TLockProxy& ); + TWrapper* myWrapper; + + public: + TLockProxy(TWrapper* theWrapper); + + ~TLockProxy(); + + TWrapper * operator-> () const; + }; + + + //---------------------------------------------------------------------------- + //! To specialize the SharedPtr for TWrapper + template<> + class MEDWRAPPER_EXPORT SharedPtr: public boost::shared_ptr + { + public: + SharedPtr() {} + + template + explicit SharedPtr(Y * p): + boost::shared_ptr(p) + {} + + template + SharedPtr(SharedPtr const & r): + boost::shared_ptr(r,boost::detail::dynamic_cast_tag()) + {} + + template + SharedPtr& + operator=(SharedPtr const & r) + { + boost::shared_ptr(r,boost::detail::dynamic_cast_tag()).swap(*this); + return *this; + } + + template + SharedPtr& + operator()(Y * p) // Y must be complete + { + return operator=(SharedPtr(p)); + } + + template + SharedPtr& + operator()(SharedPtr const & r) // Y must be complete + { + return operator=(SharedPtr(r)); + } + + TLockProxy operator-> () const // never throws + { + return TLockProxy(this->get()); + } + + protected: + operator const TWrapper& () const; + + operator TWrapper& (); + + TWrapper& operator* () const; + + TWrapper * get() const // never throws + { + return boost::shared_ptr::get(); + } + }; + + //---------------------------------------------------------------------------- + typedef SharedPtr PWrapper; +} + +#endif diff --git a/src/MEDWrapper/Base/MED_WrapperBase.hxx b/src/MEDWrapper/Base/MED_WrapperBase.hxx new file mode 100755 index 000000000..128e4e89b --- /dev/null +++ b/src/MEDWrapper/Base/MED_WrapperBase.hxx @@ -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 diff --git a/src/MEDWrapper/Base/Makefile.am b/src/MEDWrapper/Base/Makefile.am new file mode 100644 index 000000000..8594ce7fc --- /dev/null +++ b/src/MEDWrapper/Base/Makefile.am @@ -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) diff --git a/src/MEDWrapper/CMakeLists.txt b/src/MEDWrapper/CMakeLists.txt new file mode 100644 index 000000000..90ed5a20a --- /dev/null +++ b/src/MEDWrapper/CMakeLists.txt @@ -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) diff --git a/src/MEDWrapper/Factory/CMakeLists.txt b/src/MEDWrapper/Factory/CMakeLists.txt new file mode 100644 index 000000000..08cd75cef --- /dev/null +++ b/src/MEDWrapper/Factory/CMakeLists.txt @@ -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}) diff --git a/src/MEDWrapper/Factory/MED_Factory.cxx b/src/MEDWrapper/Factory/MED_Factory.cxx new file mode 100644 index 000000000..a1781441b --- /dev/null +++ b/src/MEDWrapper/Factory/MED_Factory.cxx @@ -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 +#include + +extern "C" +{ +#include +#ifndef WIN32 + #include +#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 = '"<&1 > /dev/null"; + + std::string aCommand = aStr.str(); + int aStatus = system(aCommand.c_str()); + + BEGMSG(MYDEBUG,"aCommand = '"<GetNbProfiles() = "<GetNbProfiles()<GetNbMeshes(); + BEGMSG(MYDEBUG,"GetNbMeshes() = "<GetPMeshInfo(iMesh); + INITMSG(MYDEBUG,"aMeshInfo->GetName() = '"<GetName()<<"'"<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 = '"<GetName()<<"'"<< + "; aType = "<GetType()<< + "; aNbComp = "<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 = "<GetEntity()<< + "; aNumDt = "<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 = "<GetPMeshInfo(iMesh+1); +#ifdef _DEBUG_ + TInt aDim = aMeshInfo->myDim; + aName = aMeshInfo->GetName(); + INITMSG(MYDEBUG,"GetMeshInfo - aName = '"<CrMeshInfo(aMeshInfo); + if(MYWRITEDEBUG){ + aName = aMeshInfo2->GetName(); + + aName[0] += theIncr; + aMeshInfo2->SetName(aName); + theMed2->SetMeshInfo(aMeshInfo2); + BEGMSG(MYDEBUG,"aNbMeshes2 = "<GetNbMeshes()<<"\n"); + } + + TEntityInfo aEntityInfo = theMed->GetEntityInfo(aMeshInfo); + + //continue; + + TInt aNbFields = theMed->GetNbFields(); + MSG(MYDEBUG,"GetNbFields() = "<GetPFieldInfo(aMeshInfo,iField+1); +#ifdef _DEBUG_ + TInt aNbComp = aFieldInfo->GetNbComp(); + INITMSG(MYDEBUG,"aName = '"<GetName()<<"'; aNbComp = "<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 = "<GetPTimeStampInfo(aFieldInfo,anEntity,aGeom2Size,iTimeStamp+1); +#ifdef _DEBUG_ + TInt aNumDt = aTimeStampInfo->GetNumDt(); + INITMSG(MYDEBUG,"aNumDt = "<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() = "<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 = '"<CrFamilyInfo(aMeshInfo2,aFamilyInfo); + for(TInt iGroup = 0; iGroup < aNbGroup; iGroup++){ + aName = aFamilyInfo->GetGroupName(iGroup); + INITMSG(MYDEBUG,"aGroupName = '"<SetGroupName(iGroup,aName); + } + + if(MYWRITEDEBUG){ + aName = aFamilyInfo->GetName(); + aName[0] += theIncr; + aFamilyInfo2->SetName(aName); + theMed2->SetFamilyInfo(aFamilyInfo2); + INITMSG(MYDEBUG,"GetNbFamilies = "<GetNbFamilies(aMeshInfo2)<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 = "<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 = '"< + +#include +#include + +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); +} diff --git a/src/MEDWrapper/Makefile.am b/src/MEDWrapper/Makefile.am new file mode 100644 index 000000000..8ebdfd64a --- /dev/null +++ b/src/MEDWrapper/Makefile.am @@ -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 diff --git a/src/MEDWrapper/V2_2/CMakeLists.txt b/src/MEDWrapper/V2_2/CMakeLists.txt new file mode 100644 index 000000000..7bbe89e65 --- /dev/null +++ b/src/MEDWrapper/V2_2/CMakeLists.txt @@ -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}) diff --git a/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx b/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx new file mode 100644 index 000000000..a7dc74a85 --- /dev/null +++ b/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx @@ -0,0 +1,2878 @@ +// 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_V2_2_Wrapper.hxx" +#include "MED_Algorithm.hxx" +#include "MED_Utilities.hxx" + +extern "C" +{ +#include +#include +} + +#ifdef _DEBUG_ +static int MYDEBUG = 0; +// #else +// static int MYDEBUG = 0; +#endif + + + +namespace MED +{ + template<> + TInt + GetDESCLength() + { + return 200; + } + + template<> + TInt + GetIDENTLength() + { + return 8; + } + + template<> + TInt + GetNOMLength() + { + return 64; + } + + template<> + TInt + GetLNOMLength() + { + return 80; + } + + template<> + TInt + GetPNOMLength() + { + return 16; + } + + template<> + void + GetVersionRelease(TInt& majeur, TInt& mineur, TInt& release) + { + majeur=MED_MAJOR_NUM; + mineur=MED_MINOR_NUM; + release=MED_RELEASE_NUM; + } + + template<> + TInt + GetNbConn(EGeometrieElement typmai, + EEntiteMaillage typent, + TInt mdim) + { + return typmai%100; + } + + namespace V2_2 + { + + //--------------------------------------------------------------- + class TFile{ + TFile(); + TFile(const TFile&); + + public: + TFile(const std::string& theFileName): + myCount(0), + myFid(0), + myFileName(theFileName) + {} + + ~TFile() + { + Close(); + } + + void + Open(EModeAcces theMode, TErr* theErr = NULL) + { + if(myCount++ == 0){ + const char* aFileName = myFileName.c_str(); + myFid = MEDfileOpen(aFileName,med_access_mode(theMode)); + } + if(theErr) + *theErr = TErr(myFid); + else if(myFid < 0) + EXCEPTION(std::runtime_error,"TFile - MEDfileOpen('"<Open(theMode,theErr); + } + + ~TFileWrapper() + { + myFile->Close(); + } + }; + + + //--------------------------------------------------------------- + TVWrapper::TVWrapper(const std::string& theFileName): + myFile(new TFile(theFileName)) + {} + + + //---------------------------------------------------------------------------- + TInt + TVWrapper + ::GetNbMeshes(TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return -1; + + return MEDnMesh(myFile->Id()); + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::GetMeshInfo(TInt theMeshId, + MED::TMeshInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return; + + TValueHolder aMeshName(theInfo.myName); + TValueHolder aDim(theInfo.myDim); + TValueHolder aSpaceDim(theInfo.mySpaceDim); + TValueHolder aType(theInfo.myType); + char dtunit[MED_SNAME_SIZE+1]; + med_sorting_type sorttype; + med_int nstep; + med_axis_type at; + int naxis=MEDmeshnAxis(myFile->Id(),theMeshId); + char *axisname=new char[naxis*MED_SNAME_SIZE+1]; + char *axisunit=new char[naxis*MED_SNAME_SIZE+1]; + TErr aRet = MEDmeshInfo(myFile->Id(), + theMeshId, + &aMeshName, + &aSpaceDim, + &aDim, + &aType, + &theInfo.myDesc[0], + dtunit, + &sorttype, + &nstep, + &at, + axisname, + axisunit); + delete [] axisname; + delete [] axisunit; + if(aRet < 0) + EXCEPTION(std::runtime_error,"GetMeshInfo - MEDmeshInfo(...)"); + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetMeshInfo(const MED::TMeshInfo& theInfo, + EModeAcces theMode, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,theMode,theErr); + + if(theErr && *theErr < 0) + return; + + MED::TMeshInfo& anInfo = const_cast(theInfo); + + TValueHolder aMeshName(anInfo.myName); + TValueHolder aDim(anInfo.myDim); + TValueHolder aSpaceDim(anInfo.mySpaceDim); + TValueHolder aType(anInfo.myType); + TValueHolder aDesc(anInfo.myDesc); + + char *nam=new char[aSpaceDim*MED_SNAME_SIZE+1]; + std::fill(nam,nam+aSpaceDim*MED_SNAME_SIZE+1,'\0'); + char *unit=new char[aSpaceDim*MED_SNAME_SIZE+1]; + std::fill(unit,unit+aSpaceDim*MED_SNAME_SIZE+1,'\0'); + TErr aRet = MEDmeshCr(myFile->Id(), + &aMeshName, + aSpaceDim, + aDim, + aType, + &aDesc, + "", + MED_SORT_DTIT, + MED_CARTESIAN, + nam, + unit); + delete [] nam; + delete [] unit; + + //if(aRet == 0) + // aRet = MEDunvCr(myFile->Id(),&aMeshName); + + INITMSG(MYDEBUG,"TVWrapper::SetMeshInfo - MED_MODE_ACCES = "<(theInfo); + TValueHolder aName(anInfo.myName); + return MEDnFamily(myFile->Id(),&aName); + } + + + //---------------------------------------------------------------------------- + TInt + TVWrapper + ::GetNbFamAttr(TInt theFamId, + const MED::TMeshInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return -1; + + MED::TMeshInfo& anInfo = const_cast(theInfo); + + TValueHolder aName(anInfo.myName); + + return MEDnFamily23Attribute(myFile->Id(),&aName,theFamId); + } + + + //---------------------------------------------------------------------------- + TInt + TVWrapper + ::GetNbFamGroup(TInt theFamId, + const MED::TMeshInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return -1; + + MED::TMeshInfo& anInfo = const_cast(theInfo); + + TValueHolder aName(anInfo.myName); + + return MEDnFamilyGroup(myFile->Id(),&aName,theFamId); + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::GetFamilyInfo(TInt theFamId, + MED::TFamilyInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return; + + MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; + + TValueHolder aMeshName(aMeshInfo.myName); + TValueHolder aFamilyName(theInfo.myName); + TValueHolder aFamilyId(theInfo.myId); + TValueHolder anAttrId(theInfo.myAttrId); + TValueHolder anAttrVal(theInfo.myAttrVal); + TValueHolder anAttrDesc(theInfo.myAttrDesc); + TValueHolder aGroupNames(theInfo.myGroupNames); + + TErr aRet = MEDfamily23Info(myFile->Id(), + &aMeshName, + theFamId, + &aFamilyName, + &anAttrId, + &anAttrVal, + &anAttrDesc, + &aFamilyId, + &aGroupNames); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"GetFamilyInfo - MEDfamily23Info(...) - "<< + " aMeshInfo.myName = '"<<&aMeshName<< + "'; theFamId = "< aMeshName (aMeshInfo.myName); + TValueHolder anElemNames(theInfo.myElemNames); + TValueHolder anEntity (theEntity); + TValueHolder aGeom (theGeom); + + TErr aRet = MEDmeshEntityNameRd(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + anEntity, + aGeom, + &anElemNames); + + theInfo.myIsElemNames = aRet != 0? eFAUX : eVRAI ; + + if(theErr) + *theErr = aRet; + } + + //---------------------------------------------------------------------------- + void + TVWrapper + ::GetNumeration(TElemInfo& theInfo, + TInt theNb, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return; + + if ( theGeom == eBALL ) + theGeom = GetBallGeom( theInfo.myMeshInfo ); + + MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; + + TValueHolder aMeshName(aMeshInfo.myName); + TValueHolder anElemNum(theInfo.myElemNum); + TValueHolder anEntity (theEntity); + TValueHolder aGeom (theGeom); + + TErr aRet = MEDmeshEntityNumberRd(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + anEntity, + aGeom, + &anElemNum); + + theInfo.myIsElemNum = aRet != 0? eFAUX : eVRAI; + + if(theErr) + *theErr = aRet; + } + + //---------------------------------------------------------------------------- + void + TVWrapper + ::GetFamilies(TElemInfo& theInfo, + TInt theNb, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return; + + if ( theGeom == eBALL ) + theGeom = GetBallGeom( theInfo.myMeshInfo ); + + MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; + + TValueHolder aMeshName(aMeshInfo.myName); + TValueHolder aFamNum (theInfo.myFamNum); + TValueHolder anEntity (theEntity); + TValueHolder aGeom (theGeom); + + TErr aRet = MEDmeshEntityFamilyNumberRd(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + anEntity, + aGeom, + &aFamNum); + + if(aRet < 0) + { +// if (aRet == MED_ERR_DOESNTEXIST) // --- only valid with MED3.x files + { + int aSize = (int)theInfo.myFamNum->size(); + theInfo.myFamNum->clear(); + theInfo.myFamNum->resize(aSize,0); + aRet = 0; + } +// else +// EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshEntityFamilyNumberRd(...) of CELLS"); + } + if(theErr) + *theErr = aRet; + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetNames(const TElemInfo& theInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr) + { + SetNames(theInfo,eLECTURE_ECRITURE,theEntity,theGeom,theErr); + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetNames(const TElemInfo& theInfo, + EModeAcces theMode, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,theMode,theErr); + + if(theErr && *theErr < 0) + return; + + if ( theGeom == eBALL ) + theGeom = GetBallGeom( theInfo.myMeshInfo ); + + MED::TElemInfo& anInfo = const_cast(theInfo); + MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; + + TErr aRet = 0; + if(theInfo.myIsElemNames) + { + TValueHolder aMeshName (aMeshInfo.myName); + TValueHolder anElemNames(anInfo.myElemNames); + TValueHolder anEntity (theEntity); + TValueHolder aGeom (theGeom); + + aRet = MEDmeshEntityNameWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + anEntity, + aGeom, + (TInt)anInfo.myElemNames->size(), + &anElemNames); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"SetNames - MEDmeshEntityNameWr(...)"); + } + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetNumeration(const TElemInfo& theInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr) + { + SetNumeration(theInfo,eLECTURE_ECRITURE,theEntity,theGeom,theErr); + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetNumeration(const TElemInfo& theInfo, + EModeAcces theMode, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,theMode,theErr); + + if(theErr && *theErr < 0) + return; + + if ( theGeom == eBALL ) + theGeom = GetBallGeom( theInfo.myMeshInfo ); + + MED::TElemInfo& anInfo = const_cast(theInfo); + MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; + + TErr aRet = 0; + if(theInfo.myIsElemNum) + { + TValueHolder aMeshName(aMeshInfo.myName); + TValueHolder anElemNum(anInfo.myElemNum); + TValueHolder anEntity (theEntity); + TValueHolder aGeom (theGeom); + + aRet = MEDmeshEntityNumberWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + anEntity, + aGeom, + (TInt)anInfo.myElemNum->size(), + &anElemNum); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"SetNumeration - MEDmeshEntityNumberWr(...)"); + } + } + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetFamilies(const TElemInfo& theInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr) + { + SetFamilies(theInfo,eLECTURE_ECRITURE,theEntity,theGeom,theErr); + } + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetFamilies(const TElemInfo& theInfo, + EModeAcces theMode, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,theMode,theErr); + + if(theErr && *theErr < 0) + return; + + if ( theGeom == eBALL ) + theGeom = GetBallGeom( theInfo.myMeshInfo ); + + MED::TElemInfo& anInfo = const_cast(theInfo); + MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; + + TValueHolder aMeshName(aMeshInfo.myName); + TValueHolder aFamNum (anInfo.myFamNum); + TValueHolder anEntity (theEntity); + TValueHolder aGeom (theGeom); + + TErr aRet = MEDmeshEntityFamilyNumberWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + anEntity, + aGeom, + (TInt)anInfo.myFamNum->size(), + &aFamNum); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"SetFamilies - MEDmeshEntityFamilyNumberWr(...)"); + } + + //---------------------------------------------------------------------------- + TInt + TVWrapper + ::GetNbNodes(const MED::TMeshInfo& theMeshInfo, + ETable theTable, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return -1; + + MED::TMeshInfo& aMeshInfo = const_cast(theMeshInfo); + + TValueHolder aMeshName(aMeshInfo.myName); + TValueHolder aTable(theTable); + med_bool chgt,trsf; + return MEDmeshnEntity(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_NODE, + MED_NO_GEOTYPE, + aTable, + MED_NO_CMODE, + &chgt, + &trsf); + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::GetNodeInfo(MED::TNodeInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return; + + MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; + + TValueHolder aMeshName(aMeshInfo.myName); + TValueHolder aDim(aMeshInfo.myDim); + TValueHolder aCoord(theInfo.myCoord); + TValueHolder aModeSwitch(theInfo.myModeSwitch); + TValueHolder aSystem(theInfo.mySystem); + TValueHolder aCoordNames(theInfo.myCoordNames); + TValueHolder aCoordUnits(theInfo.myCoordUnits); + TValueHolder anElemNames(theInfo.myElemNames); + //TValueHolder anIsElemNames(theInfo.myIsElemNames); + TValueHolder anElemNum(theInfo.myElemNum); + //TValueHolder anIsElemNum(theInfo.myIsElemNum); + TValueHolder aFamNum(theInfo.myFamNum); + TValueHolder aNbElem(theInfo.myNbElem); + + TErr aRet = MEDmeshNodeCoordinateRd(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + aModeSwitch, + &aCoord); + + TErr aRet2 =MEDmeshEntityFamilyNumberRd(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_NODE, + MED_NO_GEOTYPE , + &aFamNum); + if (aRet2 < 0) + { +// if (aRet2 == MED_ERR_DOESNTEXIST) // --- only valid with MED3.x files + { + int mySize = (int)theInfo.myFamNum->size(); + theInfo.myFamNum->clear(); + theInfo.myFamNum->resize(mySize,0); + } +// else +// EXCEPTION(std::runtime_error,"GetNodeInfo - MEDmeshEntityFamilyNumberRd(...)"); + } + + if ( MEDmeshEntityNameRd(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_NODE, + MED_NO_GEOTYPE , + &anElemNames) < 0) theInfo.myIsElemNames=eFAUX; + + if ( MEDmeshEntityNumberRd(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_NODE, + MED_NO_GEOTYPE , + &anElemNum) < 0 ) theInfo.myIsElemNum=eFAUX; + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"GetNodeInfo - MEDmeshNodeCoordinateRd(...)"); + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetNodeInfo(const MED::TNodeInfo& theInfo, + EModeAcces theMode, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,theMode,theErr); + + if(theErr && *theErr < 0) + return; + + MED::TNodeInfo& anInfo = const_cast(theInfo); + MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; + + TValueHolder aMeshName (aMeshInfo.myName); + TValueHolder aCoord (anInfo.myCoord); + TValueHolder aModeSwitch (anInfo.myModeSwitch); + TValueHolder aSystem (anInfo.mySystem); + TValueHolder aCoordNames (anInfo.myCoordNames); + TValueHolder aCoordUnits (anInfo.myCoordUnits); + TValueHolder anElemNames (anInfo.myElemNames); + TValueHolder anIsElemNames(anInfo.myIsElemNames); + TValueHolder anElemNum (anInfo.myElemNum); + TValueHolder anIsElemNum (anInfo.myIsElemNum); + TValueHolder aFamNum (anInfo.myFamNum); + TValueHolder aNbElem (anInfo.myNbElem); + + TErr aRet = MEDmeshNodeCoordinateWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_NO_DT, + aModeSwitch, + aNbElem, + &aCoord); + + MEDmeshEntityFamilyNumberWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_NODE, + MED_NO_GEOTYPE, + aNbElem, + &aFamNum); + if(anIsElemNames) + MEDmeshEntityNameWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_NODE, + MED_NO_GEOTYPE, + aNbElem, + &anElemNames); + if(anIsElemNum) + MEDmeshEntityNumberWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_NODE, + MED_NO_GEOTYPE, + aNbElem, + &anElemNum); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"SetNodeInfo - MEDmeshNodeCoordinateWr(...)"); + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetNodeInfo(const MED::TNodeInfo& theInfo, + TErr* theErr) + { + TErr aRet; + SetNodeInfo(theInfo,eLECTURE_ECRITURE,&aRet); + + if(aRet < 0) + SetNodeInfo(theInfo,eLECTURE_AJOUT,&aRet); + + if(theErr) + *theErr = aRet; + } + + + //----------------------------------------------------------------- + void + TVWrapper + ::GetPolygoneInfo(MED::TPolygoneInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return; + + MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; + + TValueHolder aMeshName(aMeshInfo.myName); + TValueHolder anIndex(theInfo.myIndex); + TInt aNbElem = (TInt)theInfo.myElemNum->size(); + TValueHolder aConn(theInfo.myConn); + TValueHolder anEntity(theInfo.myEntity); + TValueHolder aConnMode(theInfo.myConnMode); + + TErr aRet; + aRet = MEDmeshPolygonRd(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + anEntity, + aConnMode, + &anIndex, + &aConn); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"GetPolygoneInfo - MEDmeshPolygonRd(...)"); + + if(theInfo.myIsElemNames){ + GetNames(theInfo,aNbElem,theInfo.myEntity,ePOLYGONE,&aRet); + if(theErr) + *theErr = aRet; + } + + if(theInfo.myIsElemNum){ + GetNumeration(theInfo,aNbElem,theInfo.myEntity,ePOLYGONE,&aRet); + if(theErr) + *theErr = aRet; + } + + GetFamilies(theInfo,aNbElem,theInfo.myEntity,ePOLYGONE,&aRet); + if(theErr) + *theErr = aRet; + } + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetPolygoneInfo(const MED::TPolygoneInfo& theInfo, + TErr* theErr) + { + SetPolygoneInfo(theInfo,eLECTURE_ECRITURE,theErr); + } + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetPolygoneInfo(const MED::TPolygoneInfo& theInfo, + EModeAcces theMode, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,theMode,theErr); + + if(theErr && *theErr < 0) + return; + + MED::TPolygoneInfo& anInfo = const_cast(theInfo); + MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; + + TValueHolder aMeshName(aMeshInfo.myName); + TValueHolder anIndex(anInfo.myIndex); + TValueHolder aConn(anInfo.myConn); + TValueHolder anEntity(anInfo.myEntity); + TValueHolder aConnMode(anInfo.myConnMode); + + TErr aRet = MEDmeshPolygonWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_UNDEF_DT, + anEntity, + aConnMode, + anInfo.myNbElem + 1, + &anIndex, + &aConn); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"SetPolygoneInfo - MEDmeshPolygonWr(...)"); + + SetNames(anInfo,theInfo.myEntity,ePOLYGONE,&aRet); + if(theErr) + *theErr = aRet; + + SetNumeration(anInfo,theInfo.myEntity,ePOLYGONE,&aRet); + if(theErr) + *theErr = aRet; + + SetFamilies(anInfo,theInfo.myEntity,ePOLYGONE,&aRet); + if(theErr) + *theErr = aRet; + } + + //---------------------------------------------------------------------------- + TInt + TVWrapper + ::GetNbPolygones(const MED::TMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode, + TErr* theErr) + { + return GetNbCells(theMeshInfo,theEntity,theGeom,theConnMode,theErr); + } + + //---------------------------------------------------------------------------- + TInt + TVWrapper + ::GetPolygoneConnSize(const MED::TMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return 0; + + MED::TMeshInfo& aMeshInfo = const_cast(theMeshInfo); + + TValueHolder aMeshName(aMeshInfo.myName); + med_int aTaille = 0; + med_bool chgt,trsf; + aTaille=MEDmeshnEntity(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + med_entity_type(theEntity), + MED_POLYGON, + MED_CONNECTIVITY, + med_connectivity_mode(theConnMode), + &chgt, + &trsf); + + + if(aTaille < 0) + EXCEPTION(std::runtime_error,"GetPolygoneInfo - MEDmeshnEntity(...)"); + + return TInt(aTaille); + } + + //----------------------------------------------------------------- + void + TVWrapper + ::GetPolyedreInfo(TPolyedreInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return; + + MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; + + TValueHolder aMeshName(aMeshInfo.myName); + TInt aNbElem = (TInt)theInfo.myElemNum->size(); + TValueHolder anIndex(theInfo.myIndex); + TValueHolder aFaces(theInfo.myFaces); + TValueHolder aConn(theInfo.myConn); + TValueHolder aConnMode(theInfo.myConnMode); + + TErr aRet; + aRet = MEDmeshPolyhedronRd(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_CELL, + aConnMode, + &anIndex, + &aFaces, + &aConn); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"GetPolygoneInfo - MEDmeshPolyhedronRd(...)"); + + if(theInfo.myIsElemNames){ + GetNames(theInfo,aNbElem,theInfo.myEntity,ePOLYEDRE,&aRet); + if(theErr) + *theErr = aRet; + } + + if(theInfo.myIsElemNum){ + GetNumeration(theInfo,aNbElem,theInfo.myEntity,ePOLYEDRE,&aRet); + if(theErr) + *theErr = aRet; + } + + GetFamilies(theInfo,aNbElem,theInfo.myEntity,ePOLYEDRE,&aRet); + if(theErr) + *theErr = aRet; + } + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetPolyedreInfo(const TPolyedreInfo& theInfo, + TErr* theErr) + { + SetPolyedreInfo(theInfo,eLECTURE_ECRITURE,theErr); + } + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetPolyedreInfo(const MED::TPolyedreInfo& theInfo, + EModeAcces theMode, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,theMode,theErr); + + if(theErr && *theErr < 0) + return; + + MED::TPolyedreInfo& anInfo = const_cast(theInfo); + MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; + + TValueHolder aMeshName(aMeshInfo.myName); + TValueHolder anIndex(anInfo.myIndex); + TValueHolder aFaces(anInfo.myFaces); + TValueHolder aConn(anInfo.myConn); + TValueHolder aConnMode(anInfo.myConnMode); + + TErr aRet; + aRet = MEDmeshPolyhedronWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_UNDEF_DT, + MED_CELL, + aConnMode, + anInfo.myNbElem+1, + &anIndex, + (TInt)anInfo.myFaces->size(), + &aFaces, + &aConn); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"SetPolyedreInfo - MEDmeshPolyhedronWr(...)"); + + TValueHolder anEntity(anInfo.myEntity); + + if(theInfo.myIsElemNames){ + TValueHolder anElemNames(anInfo.myElemNames); + aRet = MEDmeshEntityNameWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + anEntity, + MED_POLYHEDRON, + (TInt)anInfo.myElemNames->size(), + &anElemNames); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"SetPolyedreInfo - MEDmeshEntityNameWr(...)"); + } + + if(theInfo.myIsElemNum){ + TValueHolder anElemNum(anInfo.myElemNum); + aRet = MEDmeshEntityNumberWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + anEntity, + MED_POLYHEDRON, + (TInt)anInfo.myElemNum->size(), + &anElemNum); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"SetPolyedreInfo - MEDmeshEntityNumberWr(...)"); + } + + + TValueHolder aFamNum(anInfo.myFamNum); + aRet = MEDmeshEntityFamilyNumberWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + anEntity, + MED_POLYHEDRON, + (TInt)anInfo.myFamNum->size(), + &aFamNum); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"SetPolyedreInfo - MEDmeshEntityFamilyNumberWr(...)"); + } + + //---------------------------------------------------------------------------- + TInt + TVWrapper + ::GetNbPolyedres(const MED::TMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode, + TErr* theErr) + { + return GetNbCells(theMeshInfo,theEntity,theGeom,theConnMode,theErr); + } + + //---------------------------------------------------------------------------- + void + TVWrapper ::GetPolyedreConnSize(const TMeshInfo& theMeshInfo, + TInt& theNbFaces, + TInt& theConnSize, + EConnectivite theConnMode, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + EXCEPTION(std::runtime_error,"GetPolyedreConnSize - (...)"); + + MED::TMeshInfo& aMeshInfo = const_cast(theMeshInfo); + + TValueHolder aMeshName(aMeshInfo.myName); + TValueHolder aConnMode(theConnMode); + //TValueHolder aNbFaces(theNbFaces); + //TValueHolder aConnSize(theConnSize); + + med_bool chgt,trsf; + theNbFaces = MEDmeshnEntity(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_CELL, + MED_POLYHEDRON, + MED_INDEX_NODE, + aConnMode, + &chgt, + &trsf); + + theConnSize = MEDmeshnEntity(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_CELL, + MED_POLYHEDRON, + MED_CONNECTIVITY, + aConnMode, + &chgt, + &trsf); + + if(theNbFaces < 0 || theConnSize<0) + EXCEPTION(std::runtime_error,"GetPolygoneInfo - MEDmeshnEntity(...)"); + + } + + //----------------------------------------------------------------- + TEntityInfo + TVWrapper + ::GetEntityInfo(const MED::TMeshInfo& theMeshInfo, + EConnectivite theConnMode, + TErr* theErr) + { + TEntityInfo anInfo; + + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return anInfo; + + if(theMeshInfo.GetType() == eNON_STRUCTURE) { + TInt aNbElem = GetNbNodes(theMeshInfo); + if(aNbElem > 0){ + anInfo[eNOEUD][ePOINT1] = aNbElem; + const TEntity2GeomSet& anEntity2GeomSet = GetEntity2GeomSet(); + TEntity2GeomSet::const_iterator anIter = anEntity2GeomSet.begin(); + TEntity2GeomSet::const_iterator anIterEnd = anEntity2GeomSet.end(); + for(; anIter != anIterEnd; anIter++){ + const EEntiteMaillage& anEntity = anIter->first; + const TGeomSet& aGeomSet = anIter->second; + TGeomSet::const_iterator anIter2 = aGeomSet.begin(); + TGeomSet::const_iterator anIterEnd2 = aGeomSet.end(); + for(; anIter2 != anIterEnd2; anIter2++){ + const EGeometrieElement& aGeom = *anIter2; + aNbElem = GetNbCells(theMeshInfo,anEntity,aGeom,theConnMode,theErr); + if(aNbElem > 0) { + if ( anEntity == eSTRUCT_ELEMENT ) { + const TInt nbStructTypes = aNbElem; + for ( TInt structType = 0; structType < nbStructTypes; ++structType ) { + // check type name to keep only "MED_BALL" structured element + TValueHolder aMeshName((TString&) theMeshInfo.myName ); + char geotypename[ MED_NAME_SIZE + 1] = ""; + med_geometry_type geotype; + MEDmeshEntityInfo( myFile->Id(), &aMeshName, MED_NO_DT, MED_NO_IT, + med_entity_type(anEntity), structType+1, + geotypename, &geotype); + if ( strcmp( geotypename, MED_BALL_NAME ) == 0 ) { + aNbElem = GetNbCells( theMeshInfo, anEntity, EGeometrieElement(geotype), + theConnMode, theErr); + if ( aNbElem > 0 ) + anInfo[anEntity][EGeometrieElement(geotype)] = aNbElem; + } + } + } + else { + anInfo[anEntity][aGeom] = aNbElem; + } + } + } + } + } + } else { // eSTRUCTURE + EGrilleType aGrilleType; + TInt aNbNodes = 1; + TInt aNbElem = 1; + TInt aNbSub = 0; + TInt aDim = theMeshInfo.GetDim(); + EGeometrieElement aGeom, aSubGeom; + EEntiteMaillage aSubEntity = eMAILLE; + + GetGrilleType(theMeshInfo, aGrilleType); + + TIntVector aStruct(aDim); + if(aGrilleType == eGRILLE_STANDARD) + { + GetGrilleStruct(theMeshInfo, aStruct, theErr); + } + else + { // eGRILLE_CARTESIENNE and eGRILLE_POLAIRE + ETable aTable[3] = { eCOOR_IND1, eCOOR_IND2, eCOOR_IND3 }; + for(med_int anAxis = 0; anAxis < aDim; anAxis++) + aStruct[ anAxis ] = GetNbNodes(theMeshInfo, aTable[anAxis]); + } + for(med_int i = 0; i < aDim; i++){ + aNbNodes = aNbNodes * aStruct[i]; + aNbElem = aNbElem * (aStruct[i] - 1); + } + switch(aDim){ + case 1: + aGeom = eSEG2; + break; + case 2: + aGeom = eQUAD4; + aSubGeom = eSEG2; + aSubEntity = eARETE; + aNbSub = + (aStruct[0] ) * (aStruct[1]-1) + + (aStruct[0]-1) * (aStruct[1] ); + break; + case 3: + aGeom = eHEXA8; + aSubGeom = eQUAD4; + aSubEntity = eFACE; + aNbSub = + (aStruct[0] ) * (aStruct[1]-1) * (aStruct[2]-1) + + (aStruct[0]-1) * (aStruct[1] ) * (aStruct[2]-1) + + (aStruct[0]-1) * (aStruct[1]-1) * (aStruct[2] ); + break; + } + anInfo[eNOEUD][ePOINT1] = aNbNodes; + anInfo[eMAILLE][aGeom] = aNbElem; + if ( aDim > 1 ) + anInfo[aSubEntity][aSubGeom] = aNbSub; + } + return anInfo; + } + + + //----------------------------------------------------------------- + TInt + TVWrapper + ::GetNbCells(const MED::TMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return -1; + + MED::TMeshInfo& aMeshInfo = const_cast(theMeshInfo); + TValueHolder aMeshName(aMeshInfo.myName); + med_bool chgt,trsf; + if(theGeom!=MED::ePOLYGONE && theGeom!=MED::ePOLYEDRE && theGeom != MED::eBALL) + { + return MEDmeshnEntity(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + med_entity_type(theEntity), + med_geometry_type(theGeom), + MED_CONNECTIVITY, + med_connectivity_mode(theConnMode), + &chgt, + &trsf); + } + else if(theGeom==MED::ePOLYGONE) + { + return MEDmeshnEntity(myFile->Id(),&aMeshName,MED_NO_DT,MED_NO_IT,med_entity_type(theEntity), + MED_POLYGON,MED_INDEX_NODE,med_connectivity_mode(theConnMode),&chgt,&trsf)-1; + } + else if ( theGeom==MED::ePOLYEDRE ) + { + return MEDmeshnEntity(myFile->Id(),&aMeshName,MED_NO_DT,MED_NO_IT,med_entity_type(theEntity), + MED_POLYHEDRON,MED_INDEX_FACE,med_connectivity_mode(theConnMode),&chgt,&trsf)-1; + } + else if ( theGeom==MED::eBALL ) + { + return GetNbBalls( theMeshInfo ); + } + return 0; + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::GetCellInfo(MED::TCellInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return; + + MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; + + TValueHolder aMeshName (aMeshInfo.myName); + TValueHolder aConn (theInfo.myConn); + TValueHolder aModeSwitch (theInfo.myModeSwitch); + TValueHolder anElemNames (theInfo.myElemNames); + TValueHolder anIsElemNames(theInfo.myIsElemNames); + TValueHolder anElemNum (theInfo.myElemNum); + TValueHolder anIsElemNum (theInfo.myIsElemNum); + TValueHolder aFamNum (theInfo.myFamNum); + TValueHolder anIsFamNum (theInfo.myIsFamNum); + TValueHolder anEntity (theInfo.myEntity); + TValueHolder aGeom (theInfo.myGeom); + TValueHolder aConnMode (theInfo.myConnMode); + + TErr aRet; + aRet = MEDmeshElementRd(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + anEntity, + aGeom, + aConnMode, + aModeSwitch, + &aConn, + &anIsElemNames, + &anElemNames, + &anIsElemNum, + &anElemNum, + &anIsFamNum, + &aFamNum); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"GetCellInfo - MEDmeshElementRd(...)"); + + if (anIsFamNum == MED_FALSE) + { + int mySize = (int) theInfo.myFamNum->size(); + theInfo.myFamNum->clear(); + theInfo.myFamNum->resize(mySize, 0); + } + + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetCellInfo(const MED::TCellInfo& theInfo, + EModeAcces theMode, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,theMode,theErr); + + if(theErr && *theErr < 0) + return; + + MED::TCellInfo& anInfo = const_cast(theInfo); + MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; + + TValueHolder aMeshName (aMeshInfo.myName); + TValueHolder aConn (anInfo.myConn); + TValueHolder aModeSwitch (anInfo.myModeSwitch); + TValueHolder anElemNames (anInfo.myElemNames); + TValueHolder anIsElemNames(anInfo.myIsElemNames); + TValueHolder anElemNum (anInfo.myElemNum); + TValueHolder anIsElemNum (anInfo.myIsElemNum); + TValueHolder aFamNum (anInfo.myFamNum); + TValueHolder anIsFamNum (anInfo.myIsFamNum); + TValueHolder anEntity (anInfo.myEntity); + TValueHolder aGeom (anInfo.myGeom); + TValueHolder aConnMode (anInfo.myConnMode); + TValueHolder aNbElem (anInfo.myNbElem); + + TErr aRet; + aRet = MEDmeshElementConnectivityWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_UNDEF_DT, + anEntity, + aGeom, + aConnMode, + aModeSwitch, + aNbElem, + &aConn); + + MEDmeshEntityFamilyNumberWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + anEntity, + aGeom, + aNbElem, + &aFamNum); + if(anIsElemNames) + MEDmeshEntityNameWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + anEntity, + aGeom, + aNbElem, + &anElemNames); + if(anIsElemNum) + MEDmeshEntityNumberWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + anEntity, + aGeom, + aNbElem, + &anElemNum); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"SetCellInfo - MEDmeshElementWr(...)"); + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetCellInfo(const MED::TCellInfo& theInfo, + TErr* theErr) + { + SetCellInfo(theInfo,eLECTURE_ECRITURE,theErr); + } + + //---------------------------------------------------------------------------- + //! Read geom type of MED_BALL structural element + EGeometrieElement TVWrapper::GetBallGeom(const TMeshInfo& theMeshInfo) + { + TFileWrapper aFileWrapper(myFile,eLECTURE); + + // read med_geometry_type of "MED_BALL" element + char geotypename[ MED_NAME_SIZE + 1] = MED_BALL_NAME; + return EGeometrieElement( MEDstructElementGeotype( myFile->Id(), geotypename ) ); + } + + //---------------------------------------------------------------------------- + //! Read number of balls in the Mesh + TInt TVWrapper::GetNbBalls(const TMeshInfo& theMeshInfo) + { + TFileWrapper aFileWrapper(myFile,eLECTURE); + + EGeometrieElement ballType = GetBallGeom( theMeshInfo ); + if ( ballType < 0 ) + return 0; + + return GetNbCells( theMeshInfo, eSTRUCT_ELEMENT, ballType, eNOD ); + } + + //---------------------------------------------------------------------------- + //! Read a MEDWrapped representation of MED_BALL from the MED file + void TVWrapper::GetBallInfo(TBallInfo& theInfo, TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + // check geometry of MED_BALL + if ( theInfo.myGeom == eBALL ) + { + theInfo.myGeom = GetBallGeom( *theInfo.myMeshInfo ); + if ( theInfo.myGeom < 0 ) { + if ( !theErr ) + EXCEPTION(std::runtime_error,"GetBallInfo - no balls in the mesh"); + *theErr = theInfo.myGeom; + return; + } + } + + // read nodes ids + GetCellInfo( theInfo ); + + // read diameters + TValueHolder aMeshName (theInfo.myMeshInfo->myName); + TValueHolder aGeom (theInfo.myGeom); + TValueHolder aDiam (theInfo.myDiameters); + char varattname[ MED_NAME_SIZE + 1] = MED_BALL_DIAMETER; + + TErr aRet = MEDmeshStructElementVarAttRd( myFile->Id(), &aMeshName, + MED_NO_DT, MED_NO_IT, + aGeom, + varattname, + &aDiam); + if ( theErr ) + *theErr = aRet; + else if ( aRet < 0 ) + EXCEPTION(std::runtime_error,"GetBallInfo - pb at reading diameters"); + } + + + //---------------------------------------------------------------------------- + //! Write a MEDWrapped representation of MED_BALL to the MED file + void TVWrapper::SetBallInfo(const TBallInfo& theInfo, EModeAcces theMode, TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,theMode,theErr); + + TErr ret; + char ballsupportname[MED_NAME_SIZE+1]="BALL_SUPPORT_MESH"; + EGeometrieElement ballGeom = GetBallGeom( *theInfo.myMeshInfo ); + if ( ballGeom < 0 ) + { + // no ball model in the file, create support mesh for it + char dummyname [MED_NAME_SIZE*3+1]=""; + if (( ret = MEDsupportMeshCr( myFile->Id(), + ballsupportname, + theInfo.myMeshInfo->GetSpaceDim(), + theInfo.myMeshInfo->GetDim(), + "Support mesh for a ball model", + MED_CARTESIAN, + /*axisname=*/dummyname, /*unitname=*/dummyname)) < 0) { + if ( !theErr ) + EXCEPTION(std::runtime_error,"SetBallInfo - MEDsupportMeshCr"); + *theErr = ret; + return; + } + // write coordinates of 1 node + med_float coord[3] = {0,0,0}; + if ((ret = MEDmeshNodeCoordinateWr(myFile->Id(), + ballsupportname, MED_NO_DT, MED_NO_IT, 0.0, + MED_FULL_INTERLACE, /*nnode=*/1, coord)) < 0) { + if ( !theErr ) + EXCEPTION(std::runtime_error,"SetBallInfo - MEDmeshNodeCoordinateWr"); + *theErr = ret; + return; + } + // ball model creation + char geotypename[ MED_NAME_SIZE + 1] = MED_BALL_NAME; + if (( ballGeom = (EGeometrieElement) MEDstructElementCr(myFile->Id(), + geotypename, + theInfo.myMeshInfo->GetSpaceDim(), + ballsupportname, + MED_NODE,MED_NONE)) < 0 ) { + if ( !theErr ) + EXCEPTION(std::runtime_error,"SetBallInfo - MEDstructElementCr"); + *theErr = ret; + return; + } + // create diameter attribute + if (( ret = MEDstructElementVarAttCr(myFile->Id(), + geotypename, MED_BALL_DIAMETER, + MED_ATT_FLOAT64, /*ncomp=*/1)) < 0) { + if ( !theErr ) + EXCEPTION(std::runtime_error,"SetBallInfo - MEDstructElementVarAttCr"); + *theErr = ret; + return; + } + } // ballGeom < 0 + + TBallInfo& aBallInfo = ((TBallInfo&) theInfo ); + aBallInfo.myGeom = ballGeom; + + // write node ids + SetCellInfo(theInfo,theMode,theErr); + if ( theErr && theErr < 0 ) + return; + + // write diameter + TValueHolder aMeshName (aBallInfo.myMeshInfo->myName); + TValueHolder aGeom (aBallInfo.myGeom); + TValueHolder aDiam (aBallInfo.myDiameters); + ret = MEDmeshStructElementVarAttWr(myFile->Id(), &aMeshName, + MED_NO_DT, MED_NO_IT, + aGeom, MED_BALL_DIAMETER, + theInfo.myNbElem, &aDiam); + if ( theErr ) + *theErr = ret; + else if ( ret < 0 ) + EXCEPTION(std::runtime_error,"SetBallInfo - MEDmeshStructElementVarAttWr"); + } + + //---------------------------------------------------------------------------- + //! Write a MEDWrapped representation of MED_BALL to the MED file + void TVWrapper::SetBallInfo(const TBallInfo& theInfo, TErr* theErr) + { + SetBallInfo( theInfo, eLECTURE_ECRITURE, theErr ); + } + + //----------------------------------------------------------------- + TInt + TVWrapper + ::GetNbFields(TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return -1; + + return MEDnField(myFile->Id()); + } + + + //---------------------------------------------------------------------------- + TInt + TVWrapper + ::GetNbComp(TInt theFieldId, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return -1; + + return MEDfieldnComponent(myFile->Id(),theFieldId); + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::GetFieldInfo(TInt theFieldId, + MED::TFieldInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return; + + TString aFieldName(256); // Protect from memory problems with too long names + TValueHolder aType(theInfo.myType); + TValueHolder aCompNames(theInfo.myCompNames); + TValueHolder anUnitNames(theInfo.myUnitNames); + MED::TMeshInfo& aMeshInfo = theInfo.myMeshInfo; + + TErr aRet; + med_bool local; + char dtunit[MED_SNAME_SIZE+1]; + char local_mesh_name[MED_NAME_SIZE+1]=""; + med_int nbofstp; + theInfo.myNbComp = MEDfieldnComponent(myFile->Id(),theFieldId); + aRet = MEDfieldInfo(myFile->Id(), + theFieldId, + &aFieldName[0], + local_mesh_name, + &local, + &aType, + &aCompNames, + &anUnitNames, + dtunit, + &nbofstp); + + if(strcmp(&aMeshInfo.myName[0],local_mesh_name) != 0 ) { + if(theErr) + *theErr = -1; + return; + } + + theInfo.SetName(aFieldName); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"GetFieldInfo - MEDfieldInfo(...)"); + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetFieldInfo(const MED::TFieldInfo& theInfo, + EModeAcces theMode, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,theMode,theErr); + + if(theErr && *theErr < 0) + return; + + MED::TFieldInfo& anInfo = const_cast(theInfo); + + TValueHolder aFieldName(anInfo.myName); + TValueHolder aType(anInfo.myType); + TValueHolder aCompNames(anInfo.myCompNames); + TValueHolder anUnitNames(anInfo.myUnitNames); + MED::TMeshInfo& aMeshInfo = anInfo.myMeshInfo; + TErr aRet; + char dtunit[MED_SNAME_SIZE+1]; + std::fill(dtunit,dtunit+MED_SNAME_SIZE+1,'\0'); + aRet = MEDfieldCr(myFile->Id(), + &aFieldName, + aType, + anInfo.myNbComp, + &aCompNames, + &anUnitNames, + dtunit, + &aMeshInfo.myName[0]); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"SetFieldInfo - MEDfieldCr(...)"); + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::SetFieldInfo(const MED::TFieldInfo& theInfo, + TErr* theErr) + { + TErr aRet; + SetFieldInfo(theInfo,eLECTURE_ECRITURE,&aRet); + + if(aRet < 0) + SetFieldInfo(theInfo,eLECTURE_AJOUT,&aRet); + + if(theErr) + *theErr = aRet; + } + + + //---------------------------------------------------------------------------- + TInt + TVWrapper + ::GetNbGauss(TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return -1; + + return MEDnLocalization(myFile->Id()); + } + + + //---------------------------------------------------------------------------- + TGaussInfo::TInfo + TVWrapper + ::GetGaussPreInfo(TInt theId, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return TGaussInfo::TInfo( TGaussInfo::TKey(ePOINT1,""),0 ); + + med_int aNbGaussPoints = med_int(); + TVector aName(GetNOMLength()+1); + med_geometry_type aGeom = MED_NONE; + + TErr aRet; + med_int dim; + char geointerpname[MED_NAME_SIZE+1]=""; + char ipointstructmeshname[MED_NAME_SIZE+1]=""; + med_int nsectionmeshcell; + med_geometry_type sectiongeotype; + aRet = MEDlocalizationInfo (myFile->Id(), + theId, + &aName[0], + &aGeom, + &dim, + &aNbGaussPoints, + geointerpname, + ipointstructmeshname, + &nsectionmeshcell, + §iongeotype); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"GetGaussPreInfo - MEDlocalizationInfo(...)"); + return TGaussInfo::TInfo(TGaussInfo::TKey(EGeometrieElement(aGeom),&aName[0]), + TInt(aNbGaussPoints)); + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::GetGaussInfo(TInt theId, + TGaussInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return; + + TValueHolder aRefCoord(theInfo.myRefCoord); + TValueHolder aGaussCoord(theInfo.myGaussCoord); + TValueHolder aWeight(theInfo.myWeight); + TValueHolder aModeSwitch(theInfo.myModeSwitch); + TValueHolder aGaussName(theInfo.myName); + + TErr aRet; + aRet = MEDlocalizationRd(myFile->Id(), + &aGaussName, + aModeSwitch, + &aRefCoord, + &aGaussCoord, + &aWeight); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"GetGaussInfo - MEDlocalizationRd(...)"); + } + + + //---------------------------------------------------------------------------- + TInt + TVWrapper + ::GetNbProfiles(TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return -1; + + return MEDnProfile(myFile->Id()); + } + + TProfileInfo::TInfo + TVWrapper + ::GetProfilePreInfo(TInt theId, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return TProfileInfo::TInfo(); + + med_int aSize = -1; + TVector aName(GetNOMLength()+1); + + TErr aRet; + aRet = MEDprofileInfo(myFile->Id(), + theId, + &aName[0], + &aSize); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"GetProfilePreInfo - MEDprofileInfo(...)"); + + return TProfileInfo::TInfo(&aName[0],aSize); + } + + void + TVWrapper + ::GetProfileInfo(TInt theId, + TProfileInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return; + + TProfileInfo& anInfo = const_cast(theInfo); + TValueHolder anElemNum(anInfo.myElemNum); + TValueHolder aProfileName(anInfo.myName); + + TErr aRet; + aRet = MEDprofileRd(myFile->Id(), + &aProfileName, + &anElemNum); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"GetProfileInfo - MEDprofileRd(...)"); + } + + void + TVWrapper + ::SetProfileInfo(const TProfileInfo& theInfo, + EModeAcces theMode, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,theMode,theErr); + + if(theErr && *theErr < 0) + return; + + TProfileInfo& anInfo = const_cast(theInfo); + TValueHolder anElemNum(anInfo.myElemNum); + TValueHolder aProfileName(anInfo.myName); + + TErr aRet; + aRet = MEDprofileWr(myFile->Id(), // descripteur du fichier. + &aProfileName, // tableau de valeurs du profil. + theInfo.GetSize(), // taille du profil. + &anElemNum); // nom profil. + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"SetProfileInfo - MEDprofileWr(...)"); + } + + void + TVWrapper + ::SetProfileInfo(const TProfileInfo& theInfo, + TErr* theErr) + { + TErr aRet; + SetProfileInfo(theInfo,eLECTURE_ECRITURE,&aRet); + + if(aRet < 0) + SetProfileInfo(theInfo,eLECTURE_AJOUT,&aRet); + + if(aRet < 0) + SetProfileInfo(theInfo,eCREATION,&aRet); + + if(theErr) + *theErr = aRet; + } + + //----------------------------------------------------------------- + TInt + TVWrapper + ::GetNbTimeStamps(const MED::TFieldInfo& theInfo, + const MED::TEntityInfo& theEntityInfo, + EEntiteMaillage& theEntity, + TGeom2Size& theGeom2Size, + TErr* theErr) + { + theEntity = EEntiteMaillage(-1); + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr){ + if(theEntityInfo.empty()) + *theErr = -1; + if(*theErr < 0) + return -1; + }else if(theEntityInfo.empty()) + EXCEPTION(std::runtime_error,"GetNbTimeStamps - There is no any Entity on the Mesh"); + + bool anIsPerformAdditionalCheck = GetNbMeshes() > 1; + + theGeom2Size.clear(); + TInt aNbTimeStamps = 0; + TIdt anId = myFile->Id(); + + MED::TFieldInfo& anInfo = const_cast(theInfo); + TValueHolder aFieldName(anInfo.myName); + MED::TMeshInfo& aMeshInfo = anInfo.myMeshInfo; + + // workaround for IPAL13676 + MED::TEntityInfo localEntityInfo = theEntityInfo; + TEntityInfo::iterator anLocalIter = localEntityInfo.find(eMAILLE); + if(anLocalIter != localEntityInfo.end()){ + localEntityInfo[eNOEUD_ELEMENT] = anLocalIter->second; + } + + TEntityInfo::const_iterator anIter = localEntityInfo.begin(); + for(; anIter != localEntityInfo.end(); anIter++){ + med_entity_type anEntity = med_entity_type(anIter->first); + const TGeom2Size& aGeom2Size = anIter->second; + TGeom2Size::const_iterator anGeomIter = aGeom2Size.begin(); + for(; anGeomIter != aGeom2Size.end(); anGeomIter++){ + med_geometry_type aGeom = med_geometry_type(anGeomIter->first); + char aMeshName[MED_NAME_SIZE+1]; + med_bool islocal; + med_field_type ft; + char dtunit[MED_SNAME_SIZE+1]; + med_int myNbComp = MEDfieldnComponentByName(anId,&aFieldName); + char *cname=new char[myNbComp*MED_SNAME_SIZE+1]; + char *unitname=new char[myNbComp*MED_SNAME_SIZE+1]; + TInt aNbStamps; + MEDfieldInfoByName(anId, + &aFieldName, + aMeshName, + &islocal, + &ft, + cname, + unitname, + dtunit, + &aNbStamps); + delete [] cname; + delete [] unitname; + med_int nval = 0; + med_int aNumDt; + med_int aNumOrd; + med_float aDt; + if (aNbStamps > 0) + { + MEDfieldComputingStepInfo(anId, + &aFieldName, + 1, + &aNumDt, + &aNumOrd, + &aDt); + char profilename[MED_NAME_SIZE+1]; + char locname[MED_NAME_SIZE+1]; + med_int profilsize; + med_int aNbGauss; + + // protection from crash (division by zero) + // inside MEDfieldnValueWithProfile function + // caused by the workaround for IPAL13676 (see above) + if( anEntity == MED_NODE_ELEMENT && aGeom % 100 == 0 ) + continue; + + nval = MEDfieldnValueWithProfile(anId, + &aFieldName, + aNumDt, + aNumOrd, + anEntity, + med_geometry_type(aGeom), + 1, + MED_COMPACT_STMODE, + profilename, + &profilsize, + locname, + &aNbGauss); + } + bool anIsSatisfied =(nval > 0); + if(anIsSatisfied){ + INITMSG(MYDEBUG, + "GetNbTimeStamps aNbTimeStamps = "<second; + theEntity = EEntiteMaillage(anEntity); + aNbTimeStamps = aNbStamps; + } + } + if(!theGeom2Size.empty()) + break; + } + return aNbTimeStamps; + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::GetTimeStampInfo(TInt theTimeStampId, + MED::TTimeStampInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + const TGeom2Size& aGeom2Size = theInfo.myGeom2Size; + + if(theErr){ + if(aGeom2Size.empty()) + *theErr = -1; + if(*theErr < 0) + return; + }else if(aGeom2Size.empty()) + EXCEPTION(std::runtime_error,"GetTimeStampInfo - There is no any cell"); + + MED::TFieldInfo& aFieldInfo = *theInfo.myFieldInfo; + MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo; + + TValueHolder aFieldName(aFieldInfo.myName); + TValueHolder anEntity(theInfo.myEntity); + TValueHolder aNumDt(theInfo.myNumDt); + TValueHolder aNumOrd(theInfo.myNumOrd); + TValueHolder anUnitDt(theInfo.myUnitDt); + TValueHolder aDt(theInfo.myDt); + TValueHolder aMeshName(aMeshInfo.myName); + TValueHolder anIsLocal(aFieldInfo.myIsLocal); + TValueHolder aNbRef(aFieldInfo.myNbRef); + + TGeom2NbGauss& aGeom2NbGauss = theInfo.myGeom2NbGauss; + + // just to get a time stamp unit (anUnitDt) + med_field_type aFieldType; + med_int aNbComp = MEDfieldnComponentByName(myFile->Id(), &aFieldName); + char *aCompName = new char[aNbComp*MED_SNAME_SIZE+1]; + char *aCompUnit = new char[aNbComp*MED_SNAME_SIZE+1]; + TInt aNbStamps; + MEDfieldInfoByName(myFile->Id(), + &aFieldName, + &aMeshName, + &anIsLocal, + &aFieldType, + aCompName, + aCompUnit, + &anUnitDt, + &aNbStamps); + delete [] aCompName; + delete [] aCompUnit; + + TGeom2Size::const_iterator anIter = aGeom2Size.begin(); + for(; anIter != aGeom2Size.end(); anIter++){ + const EGeometrieElement& aGeom = anIter->first; + med_int aNbGauss = -1; + + TErr aRet; + aRet = MEDfieldComputingStepInfo(myFile->Id(), + &aFieldName, + theTimeStampId, + &aNumDt, + &aNumOrd, + &aDt); + char profilename[MED_NAME_SIZE+1]; + med_int profilsize; + char locname[MED_NAME_SIZE+1]; + MEDfieldnValueWithProfile(myFile->Id(), + &aFieldName, + aNumDt, + aNumOrd, + anEntity, + med_geometry_type(aGeom), + 1, + MED_COMPACT_STMODE, + profilename, + &profilsize, + locname, + &aNbGauss); + + static TInt MAX_NB_GAUSS_POINTS = 32; + if(aNbGauss <= 0 || aNbGauss > MAX_NB_GAUSS_POINTS) + aNbGauss = 1; + + aGeom2NbGauss[aGeom] = aNbGauss; + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"GetTimeStampInfo - MEDfieldnValueWithProfile(...)"); + } + } + + + //---------------------------------------------------------------------------- + void + TVWrapper + ::GetTimeStampValue(const PTimeStampValueBase& theTimeStampValue, + const TMKey2Profile& theMKey2Profile, + const TKey2Gauss& theKey2Gauss, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return; + + TIdt anId = myFile->Id(); + + TValueHolder aModeSwitch(theTimeStampValue->myModeSwitch); + MED::TGeom2Profile& aGeom2Profile = theTimeStampValue->myGeom2Profile; + + MED::PTimeStampInfo aTimeStampInfo = theTimeStampValue->myTimeStampInfo; + TValueHolder anEntity(aTimeStampInfo->myEntity); + TValueHolder aNumDt(aTimeStampInfo->myNumDt); + TValueHolder aNumOrd(aTimeStampInfo->myNumOrd); + + MED::PFieldInfo aFieldInfo = aTimeStampInfo->myFieldInfo; + TValueHolder aFieldName(aFieldInfo->myName); + TValueHolder anIsLocal(aFieldInfo->myIsLocal); + + MED::PMeshInfo aMeshInfo = aFieldInfo->myMeshInfo; + TValueHolder aMeshName(aMeshInfo->myName); + + TGeom2Gauss& aGeom2Gauss = aTimeStampInfo->myGeom2Gauss; + TVector aGaussName(GetNOMLength()+1); + + med_storage_mode aProfileMode = med_storage_mode(boost::get<0>(theMKey2Profile)); + MED::TKey2Profile aKey2Profile = boost::get<1>(theMKey2Profile); + TVector aProfileName(GetNOMLength()+1); + + TGeom2Size& aGeom2Size = aTimeStampInfo->myGeom2Size; + TGeom2Size::iterator anIter = aGeom2Size.begin(); + for(; anIter != aGeom2Size.end(); anIter++){ + EGeometrieElement aGeom = anIter->first; + TInt aNbElem = anIter->second; + med_int profilesize,aNbGauss; + + TInt aNbVal = MEDfieldnValueWithProfile(anId, + &aFieldName, + aNumDt, + aNumOrd, + anEntity, + med_geometry_type(aGeom), + 1, + aProfileMode, + &aProfileName[0], + &profilesize, + &aGaussName[0], + &aNbGauss); + + if(aNbVal <= 0){ + if(theErr){ + *theErr = -1; + return; + } + EXCEPTION(std::runtime_error,"GetTimeStampValue - MEDfieldnValueWithProfile(...) - aNbVal == "<myNbComp; + TInt aNbValue = aNbVal;// / aNbGauss; rules in MED changed + theTimeStampValue->AllocateValue(aGeom, + aNbValue, + aNbGauss, + aNbComp); + TInt aValueSize = theTimeStampValue->GetValueSize(aGeom); + + INITMSG(MYDEBUG, + "TVWrapper::GetTimeStampValue - aGeom = "<second; + aGeom2Gauss[aGeom] = aGaussInfo; + } + } + + MED::PProfileInfo aProfileInfo; + if(strcmp(&aProfileName[0],MED_NO_PROFILE) != 0){ + MED::TKey2Profile::const_iterator anIter = aKey2Profile.find(&aProfileName[0]); + if(anIter != aKey2Profile.end()){ + aProfileInfo = anIter->second; + aGeom2Profile[aGeom] = aProfileInfo; + } + } + + if(aGaussInfo && aNbGauss != aGaussInfo->GetNbGauss()){ + if(theErr){ + *theErr = MED_FALSE; + return; + } + EXCEPTION(std::runtime_error,"GetTimeStampValue - aNbGauss != aGaussInfo->GetNbGauss()"); + } + + if(aProfileInfo && aProfileInfo->IsPresent()){ + TInt aNbSubElem = aProfileInfo->GetSize(); + TInt aProfileSize = aNbSubElem*aNbComp*aNbGauss; + if(aProfileSize != aValueSize){ + if(theErr){ + *theErr = -1; + return; + } + EXCEPTION(std::runtime_error, + "GetTimeStampValue - aProfileSize("<Id(); + + TValueHolder aModeSwitch(theTimeStampValue->myModeSwitch); + MED::TGeom2Profile& aGeom2Profile = theTimeStampValue->myGeom2Profile; + + MED::PTimeStampInfo aTimeStampInfo = theTimeStampValue->myTimeStampInfo; + TValueHolder anEntity(aTimeStampInfo->myEntity); + TValueHolder aNumDt(aTimeStampInfo->myNumDt); + TValueHolder aNumOrd(aTimeStampInfo->myNumOrd); + TValueHolder anUnitDt(aTimeStampInfo->myUnitDt); + TValueHolder aDt(aTimeStampInfo->myDt); + MED::TGeom2Gauss& aGeom2Gauss = aTimeStampInfo->myGeom2Gauss; + + MED::PFieldInfo aFieldInfo = aTimeStampInfo->myFieldInfo; + TValueHolder aFieldName(aFieldInfo->myName); + + MED::PMeshInfo aMeshInfo = aFieldInfo->myMeshInfo; + TValueHolder aMeshName(aMeshInfo->myName); + + const TGeomSet& aGeomSet = theTimeStampValue->myGeomSet; + TGeomSet::const_iterator anIter = aGeomSet.begin(); + for(; anIter != aGeomSet.end(); anIter++){ + EGeometrieElement aGeom = *anIter; + + TVector aGaussName(GetNOMLength()+1); + MED::TGeom2Gauss::const_iterator aGaussIter = aGeom2Gauss.find(aGeom); + if(aGaussIter != aGeom2Gauss.end()){ + MED::PGaussInfo aGaussInfo = aGaussIter->second; + strcpy(&aGaussName[0],&aGaussInfo->myName[0]); + } + + TVector aProfileName(GetNOMLength()+1); + med_storage_mode aProfileMode = med_storage_mode(eNO_PFLMOD); + MED::TGeom2Profile::const_iterator aProfileIter = aGeom2Profile.find(aGeom); + if(aProfileIter != aGeom2Profile.end()){ + MED::PProfileInfo aProfileInfo = aProfileIter->second; + aProfileMode = med_storage_mode(aProfileInfo->myMode); + strcpy(&aProfileName[0],&aProfileInfo->myName[0]); + } + + med_int aNbVal = theTimeStampValue->GetNbVal(aGeom); + + aRet = MEDfieldValueWithProfileWr(anId, + &aFieldName, + aNumDt, + aNumOrd, + aDt, + anEntity, + med_geometry_type(aGeom), + aProfileMode, + &aProfileName[0], + &aGaussName[0], + aModeSwitch, + MED_ALL_CONSTITUENT, + aNbVal, + theTimeStampValue->GetValuePtr(aGeom)); + if(aRet < 0){ + if(theErr){ + *theErr = MED_FALSE; + break; + } + EXCEPTION(std::runtime_error,"SetTimeStampValue - MEDfieldValueWithProfileWr(...)"); + } + + } + + INITMSG(MYDEBUG,"TVWrapper::SetTimeStampValue - MED_MODE_ACCES = "< aCoord(anInfo.myCoord); + TValueHolder aModeSwitch(anInfo.myModeSwitch); + TValueHolder aCoordNames(anInfo.myCoordNames); + TValueHolder aCoordUnits(anInfo.myCoordUnits); + med_int aNbNoeuds = med_int(anInfo.myCoord.size() / aMeshInfo.myDim); + //med_axis_type aRepere = MED_CARTESIAN; + + aRet = MEDmeshNodeCoordinateWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_UNDEF_DT, + aModeSwitch, + aNbNoeuds, + &aCoord); + + if(aRet < 0) + EXCEPTION(std::runtime_error,"SetGrilleInfo - MEDmeshNodeCoordinateWr(...)"); + + TValueHolder aGrilleStructure(anInfo.myGrilleStructure); + aRet = MEDmeshGridStructWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_UNDEF_DT, + &aGrilleStructure); + if(aRet < 0) + EXCEPTION(std::runtime_error,"SetGrilleInfo - MEDmeshGridStructWr(...)"); + + } else { + for(med_int aAxis = 0; aAxis < aMeshInfo.myDim; aAxis++){ + aRet = MEDmeshGridIndexCoordinateWr(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_UNDEF_DT, + aAxis+1, + anInfo.GetIndexes(aAxis).size(), + &anInfo.GetIndexes(aAxis)[0]); + + if(aRet < 0) + EXCEPTION(std::runtime_error,"SetGrilleInfo - MEDmeshGridIndexCoordinateWr(...)"); + } + + } + + return; + } + + //---------------------------------------------------------------------------- + void + TVWrapper + ::GetGrilleInfo(TGrilleInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return; + + MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; + TValueHolder aMeshName(aMeshInfo.myName); + EMaillage aMaillageType = aMeshInfo.myType; + + GetGrilleType(aMeshInfo, theInfo.myGrilleType, theErr); + EGrilleType aGrilleType = theInfo.myGrilleType; + + TErr aRet = 0; + if(aMaillageType == eSTRUCTURE && aGrilleType == eGRILLE_STANDARD) { + GetGrilleStruct(aMeshInfo, theInfo.myGrilleStructure, theErr); + + TValueHolder aCoord(theInfo.myCoord); + TValueHolder aModeSwitch(theInfo.myModeSwitch); + TValueHolder aCoordNames(theInfo.myCoordNames); + TValueHolder aCoordUnits(theInfo.myCoordUnits); + //med_axis_type aRepere; + + aRet = MEDmeshNodeCoordinateRd(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + aModeSwitch, + &aCoord); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshNodeCoordinateRd(...)"); + + //TInt aNbNodes = theInfo.GetNbNodes();//GetNbFamilies(aMeshInfo); + TValueHolder aFamNumNode(theInfo.myFamNumNode); + + aRet = MEDmeshEntityFamilyNumberRd(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + MED_NODE, + MED_NO_GEOTYPE, + &aFamNumNode); + + if(aRet < 0) + { +// if (aRet == MED_ERR_DOESNTEXIST) // --- only valid with MED3.x files + { + int mySize = (int)theInfo.myFamNumNode.size(); + theInfo.myFamNumNode.clear(); + theInfo.myFamNumNode.resize(mySize,0); + aRet = 0; + } +// else +// EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshEntityFamilyNumberRd(...)"); + } + if(theErr) + *theErr = aRet; + + //============================ + } + + if(aMaillageType == eSTRUCTURE && aGrilleType != eGRILLE_STANDARD){ + ETable aTable; + for(med_int anAxis = 1; anAxis <= aMeshInfo.myDim; anAxis++){ + switch(anAxis){ + case 1 : + aTable = eCOOR_IND1; + break; + case 2 : + aTable = eCOOR_IND2; + break; + case 3 : + aTable = eCOOR_IND3; + break; + default : + aRet = -1; + } + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"GetGrilleInfo - anAxis number out of range(...)"); + + TInt aNbIndexes = GetNbNodes(aMeshInfo,aTable); + if(aNbIndexes < 0) + EXCEPTION(std::runtime_error,"GetGrilleInfo - Erreur a la lecture de la taille de l'indice"); + + TValueHolder anIndexes(theInfo.GetIndexes(anAxis-1)); + //TValueHolder table(aTable); + //char aCompNames[MED_SNAME_SIZE+1]; + //char anUnitNames[MED_SNAME_SIZE+1]; + aRet=MEDmeshGridIndexCoordinateRd(myFile->Id(),&aMeshName, + MED_NO_DT,MED_NO_IT, + anAxis, + &anIndexes); + + //theInfo.SetCoordName(anAxis-1, aCompNames); + //theInfo.SetCoordUnit(anAxis-1, anUnitNames); + theInfo.SetGrilleStructure(anAxis-1, aNbIndexes); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDindicesCoordLire(...)"); + } + } + + EGeometrieElement aGeom = theInfo.GetGeom(); + EEntiteMaillage aEntity = theInfo.GetEntity(); + TInt aNbCells = theInfo.GetNbCells(); + + theInfo.myFamNum.resize(aNbCells); + TValueHolder aFamNum(theInfo.myFamNum); + + aRet = MEDmeshEntityFamilyNumberRd(myFile->Id(), + &aMeshName,MED_NO_DT,MED_NO_IT,med_entity_type(aEntity), + med_geometry_type(aGeom),&aFamNum); + + if ( aMeshInfo.myDim == 3 ) + { + aGeom = theInfo.GetSubGeom(); + aEntity = theInfo.GetSubEntity(); + aNbCells = theInfo.GetNbSubCells(); + + theInfo.myFamSubNum.resize(aNbCells,0); + TValueHolder aFamNum(theInfo.myFamSubNum); + + aRet = MEDmeshEntityFamilyNumberRd(myFile->Id(), + &aMeshName,MED_NO_DT,MED_NO_IT, + med_entity_type(aEntity), + med_geometry_type(aGeom),&aFamNum); + } + if(aRet < 0) + { +// if (aRet == MED_ERR_DOESNTEXIST) // --- only valid with MED3.x files + { + int mySize = (int)theInfo.myFamNumNode.size(); + theInfo.myFamNumNode.clear(); + theInfo.myFamNumNode.resize(mySize,0); + aRet = 0; + } +// else +// EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshEntityFamilyNumberRd(...)"); + } + if(theErr) + *theErr = aRet; + } + + void + TVWrapper + ::GetGrilleType(const MED::TMeshInfo& theMeshInfo, + EGrilleType& theGridType, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + EXCEPTION(std::runtime_error," GetGrilleType - aFileWrapper (...)"); + + MED::TMeshInfo& aMeshInfo = const_cast(theMeshInfo); + + if(aMeshInfo.myType == eSTRUCTURE){ + TValueHolder aMeshName(aMeshInfo.myName); + TValueHolder aGridType(theGridType); + TErr aRet = MEDmeshGridTypeRd(myFile->Id(), + &aMeshName, + &aGridType); + + if(aRet < 0) + EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshGridTypeRd(...)"); + } + } + + void + TVWrapper + ::GetGrilleStruct(const MED::TMeshInfo& theMeshInfo, + TIntVector& theStruct, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return; + + TErr aRet; + MED::TMeshInfo& aMeshInfo = const_cast(theMeshInfo); + + TValueHolder aMeshName(aMeshInfo.myName); + TValueHolder aGridStructure(theStruct); + + aRet = MEDmeshGridStructRd(myFile->Id(), + &aMeshName, + MED_NO_DT, + MED_NO_IT, + &aGridStructure); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshGridStructRd(...)"); + } + + } +} diff --git a/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.hxx b/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.hxx new file mode 100644 index 000000000..9d5a74ca7 --- /dev/null +++ b/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.hxx @@ -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(); + + template<> + TInt MED_V22_WRAPPER_EXPORT + GetIDENTLength(); + + template<> + TInt MED_V22_WRAPPER_EXPORT + GetNOMLength(); + + template<> + TInt MED_V22_WRAPPER_EXPORT + GetLNOMLength(); + + template<> + TInt MED_V22_WRAPPER_EXPORT + GetPNOMLength(); + + template<> + void MED_V22_WRAPPER_EXPORT + GetVersionRelease(TInt& majeur, TInt& mineur, TInt& release); + + template<> + TInt MED_V22_WRAPPER_EXPORT + GetNbConn(EGeometrieElement typmai, + EEntiteMaillage typent, + TInt mdim); + + namespace V2_2 + { + //---------------------------------------------------------------------------- + class TFile; + typedef boost::shared_ptr PFile; + + typedef enum {eLECTURE, eLECTURE_ECRITURE, eLECTURE_AJOUT, eCREATION} EModeAcces; + + //---------------------------------------------------------------------------- + class MED_V22_WRAPPER_EXPORT TVWrapper: public MED::TTWrapper + { + 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 diff --git a/src/MEDWrapper/V2_2/Makefile.am b/src/MEDWrapper/V2_2/Makefile.am new file mode 100644 index 000000000..d744452a7 --- /dev/null +++ b/src/MEDWrapper/V2_2/Makefile.am @@ -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 diff --git a/src/Makefile.am b/src/Makefile.am index 3f6ab8b3e..566b9f4b4 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -34,6 +34,7 @@ SUBDIRS = \ SMESHUtils \ Controls \ Driver \ + MEDWrapper \ DriverMED \ DriverDAT \ DriverUNV \ -- 2.39.2