From: nadir Date: Fri, 3 Feb 2006 14:26:39 +0000 (+0000) Subject: update with the version in the OCC branch OCC_development_generic_2006. X-Git-Tag: ForV3_2_0a1~1 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=119972d3b17e16d0ab8d2431589597dc133dbd94;p=modules%2Fmed.git update with the version in the OCC branch OCC_development_generic_2006. --- diff --git a/adm_local/unix/make_commence.in b/adm_local/unix/make_commence.in index 5b55b4a9e..292633657 100644 --- a/adm_local/unix/make_commence.in +++ b/adm_local/unix/make_commence.in @@ -41,6 +41,7 @@ CXX_DEPEND_FLAG = @CXX_DEPEND_FLAG@ # BOOST Library BOOST_CPPFLAGS = @BOOST_CPPFLAGS@ +BOOST_LIBS = @BOOST_LIBS@ # JAVA diff --git a/adm_local_without_kernel/unix/config_files/check_boost.m4 b/adm_local_without_kernel/unix/config_files/check_boost.m4 index 215ce8cf5..c77edba5d 100644 --- a/adm_local_without_kernel/unix/config_files/check_boost.m4 +++ b/adm_local_without_kernel/unix/config_files/check_boost.m4 @@ -28,6 +28,10 @@ AC_LANG_CPLUSPLUS AC_SUBST(BOOST_CPPFLAGS) BOOST_CPPFLAGS="" + +AC_SUBST(BOOST_LIBS) +BOOST_LIBS="" + boost_ok=no if test -z ${BOOSTDIR}; then @@ -37,17 +41,31 @@ if test -z ${BOOSTDIR}; then fi else AC_MSG_RESULT(\$BOOSTDIR = ${BOOSTDIR}) - AC_CHECKING(for boost/shared_ptr.hpp header file) + dnl BOOST headers + AC_CHECKING(for boost/shared_ptr.hpp header file) CPPFLAGS_old="${CPPFLAGS}" - BOOST_CPPFLAGS="-I${BOOSTDIR}" + BOOST_CPPFLAGS="-I${BOOSTDIR}/include" CPPFLAGS="${CPPFLAGS} ${BOOST_CPPFLAGS}" AC_CHECK_HEADER(boost/shared_ptr.hpp,boost_ok=yes,boost_ok=no) CPPFLAGS="${CPPFLAGS_old}" + + if test "x${boost_ok}" = "xyes" ; then + AC_MSG_RESULT(\$BOOST_CPPFLAGS = ${BOOST_CPPFLAGS}) + dnl BOOST libs + AC_CHECKING(for libboost_thread-mt.so library file) + AC_CHECK_FILE(${BOOSTDIR}/lib/libboost_thread-mt.so,boost_ok=yes,boost_ok=no) + if test "x${boost_ok}" = "xyes" ; then + BOOST_LIBS="-L${BOOSTDIR}/lib" + AC_MSG_RESULT(\$BOOST_LIBS = ${BOOST_LIBS}) + fi + fi fi +AC_MSG_RESULT(for boost: $boost_ok) + AC_LANG_RESTORE ])dnl diff --git a/doc/salome/tui/MED/doxyfile b/doc/salome/tui/MED/doxyfile index 7dfdb20b6..91bd757f2 100755 --- a/doc/salome/tui/MED/doxyfile +++ b/doc/salome/tui/MED/doxyfile @@ -1,74 +1,89 @@ -# Doxyfile 1.3-rc1 +# Doxyfile 1.3.7 #--------------------------------------------------------------------------- -# General configuration options +# Project related configuration options #--------------------------------------------------------------------------- PROJECT_NAME = "SALOME - MED - v.3.1.0" PROJECT_NUMBER = id#1.1 OUTPUT_DIRECTORY = ../ +CREATE_SUBDIRS = NO OUTPUT_LANGUAGE = English +USE_WINDOWS_ENCODING = NO +BRIEF_MEMBER_DESC = YES +REPEAT_BRIEF = YES +ABBREVIATE_BRIEF = +ALWAYS_DETAILED_SEC = NO +INLINE_INHERITED_MEMB = NO +FULL_PATH_NAMES = NO +STRIP_FROM_PATH = +STRIP_FROM_INC_PATH = +SHORT_NAMES = NO +JAVADOC_AUTOBRIEF = YES +MULTILINE_CPP_IS_BRIEF = NO +DETAILS_AT_TOP = NO +INHERIT_DOCS = NO +DISTRIBUTE_GROUP_DOC = NO +TAB_SIZE = 5 +ALIASES = +OPTIMIZE_OUTPUT_FOR_C = YES +OPTIMIZE_OUTPUT_JAVA = YES +SUBGROUPING = YES + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- EXTRACT_ALL = YES EXTRACT_PRIVATE = YES EXTRACT_STATIC = YES EXTRACT_LOCAL_CLASSES = YES -HIDE_UNDOC_MEMBERS = NO -HIDE_UNDOC_CLASSES = NO +EXTRACT_LOCAL_METHODS = NO +HIDE_UNDOC_MEMBERS = YES +HIDE_UNDOC_CLASSES = YES HIDE_FRIEND_COMPOUNDS = NO HIDE_IN_BODY_DOCS = NO -BRIEF_MEMBER_DESC = YES -REPEAT_BRIEF = NO -ALWAYS_DETAILED_SEC = YES -INLINE_INHERITED_MEMB = YES -FULL_PATH_NAMES = NO -STRIP_FROM_PATH = INTERNAL_DOCS = YES CASE_SENSE_NAMES = YES -SHORT_NAMES = NO HIDE_SCOPE_NAMES = NO -VERBATIM_HEADERS = YES SHOW_INCLUDE_FILES = YES -JAVADOC_AUTOBRIEF = YES -MULTILINE_CPP_IS_BRIEF = NO -DETAILS_AT_TOP = NO -INHERIT_DOCS = YES INLINE_INFO = YES SORT_MEMBER_DOCS = NO -DISTRIBUTE_GROUP_DOC = NO -TAB_SIZE = 5 +SORT_BRIEF_DOCS = NO +SORT_BY_SCOPE_NAME = NO GENERATE_TODOLIST = YES GENERATE_TESTLIST = YES GENERATE_BUGLIST = YES GENERATE_DEPRECATEDLIST= YES -ALIASES = ENABLED_SECTIONS = MAX_INITIALIZER_LINES = 25 -OPTIMIZE_OUTPUT_FOR_C = YES -OPTIMIZE_OUTPUT_JAVA = YES SHOW_USED_FILES = NO + #--------------------------------------------------------------------------- # configuration options related to warning and progress messages #--------------------------------------------------------------------------- QUIET = NO WARNINGS = YES WARN_IF_UNDOCUMENTED = YES +WARN_IF_DOC_ERROR = YES WARN_FORMAT = "$file:$line: $text" WARN_LOGFILE = log.txt + #--------------------------------------------------------------------------- # configuration options related to the input files #--------------------------------------------------------------------------- -INPUT = ../../../share/salome/idl/MED.idl \ - ../../../share/salome/idl/MED_Gen.idl -FILE_PATTERNS = -RECURSIVE = NO +INPUT = ../../../share/salome/src \ + ../../../share/salome/idl +FILE_PATTERNS = *.idl *.h *.hh *.hxx *.c *.cc *.cxx *.ixx *.jxx +RECURSIVE = YES EXCLUDE = EXCLUDE_SYMLINKS = NO EXCLUDE_PATTERNS = EXAMPLE_PATH = EXAMPLE_PATTERNS = -EXAMPLE_RECURSIVE = NO +EXAMPLE_RECURSIVE = YES IMAGE_PATH = sources/ INPUT_FILTER = FILTER_SOURCE_FILES = YES + #--------------------------------------------------------------------------- # configuration options related to source browsing #--------------------------------------------------------------------------- @@ -77,12 +92,15 @@ INLINE_SOURCES = NO STRIP_CODE_COMMENTS = YES REFERENCED_BY_RELATION = NO REFERENCES_RELATION = YES +VERBATIM_HEADERS = YES + #--------------------------------------------------------------------------- # configuration options related to the alphabetical class index #--------------------------------------------------------------------------- ALPHABETICAL_INDEX = NO COLS_IN_ALPHA_INDEX = 5 IGNORE_PREFIX = + #--------------------------------------------------------------------------- # configuration options related to the HTML output #--------------------------------------------------------------------------- @@ -103,6 +121,7 @@ DISABLE_INDEX = YES ENUM_VALUES_PER_LINE = 4 GENERATE_TREEVIEW = YES TREEVIEW_WIDTH = 250 + #--------------------------------------------------------------------------- # configuration options related to the LaTeX output #--------------------------------------------------------------------------- @@ -117,6 +136,8 @@ LATEX_HEADER = PDF_HYPERLINKS = NO USE_PDFLATEX = NO LATEX_BATCHMODE = NO +LATEX_HIDE_INDICES = NO + #--------------------------------------------------------------------------- # configuration options related to the RTF output #--------------------------------------------------------------------------- @@ -126,6 +147,7 @@ COMPACT_RTF = NO RTF_HYPERLINKS = NO RTF_STYLESHEET_FILE = RTF_EXTENSIONS_FILE = + #--------------------------------------------------------------------------- # configuration options related to the man page output #--------------------------------------------------------------------------- @@ -133,16 +155,21 @@ GENERATE_MAN = NO MAN_OUTPUT = man MAN_EXTENSION = .3 MAN_LINKS = NO + #--------------------------------------------------------------------------- # configuration options related to the XML output #--------------------------------------------------------------------------- GENERATE_XML = NO +XML_OUTPUT = xml XML_SCHEMA = XML_DTD = +XML_PROGRAMLISTING = YES + #--------------------------------------------------------------------------- # configuration options for the AutoGen Definitions output #--------------------------------------------------------------------------- GENERATE_AUTOGEN_DEF = NO + #--------------------------------------------------------------------------- # configuration options related to the Perl module output #--------------------------------------------------------------------------- @@ -150,6 +177,7 @@ GENERATE_PERLMOD = NO PERLMOD_LATEX = NO PERLMOD_PRETTY = YES PERLMOD_MAKEVAR_PREFIX = + #--------------------------------------------------------------------------- # Configuration options related to the preprocessor #--------------------------------------------------------------------------- @@ -162,14 +190,16 @@ INCLUDE_FILE_PATTERNS = PREDEFINED = EXPAND_AS_DEFINED = SKIP_FUNCTION_MACROS = NO + #--------------------------------------------------------------------------- -# Configuration::addtions related to external references +# Configuration::additions related to external references #--------------------------------------------------------------------------- TAGFILES = GENERATE_TAGFILE = ALLEXTERNALS = NO EXTERNAL_GROUPS = YES PERL_PATH = /usr/bin/perl + #--------------------------------------------------------------------------- # Configuration options related to the dot tool #--------------------------------------------------------------------------- @@ -178,24 +208,22 @@ HIDE_UNDOC_RELATIONS = NO HAVE_DOT = YES CLASS_GRAPH = YES COLLABORATION_GRAPH = NO +UML_LOOK = NO TEMPLATE_RELATIONS = YES INCLUDE_GRAPH = YES INCLUDED_BY_GRAPH = NO +CALL_GRAPH = NO GRAPHICAL_HIERARCHY = YES DOT_IMAGE_FORMAT = jpg DOT_PATH = DOTFILE_DIRS = MAX_DOT_GRAPH_WIDTH = 1024 MAX_DOT_GRAPH_HEIGHT = 1200 +MAX_DOT_GRAPH_DEPTH = 0 GENERATE_LEGEND = NO DOT_CLEANUP = YES + #--------------------------------------------------------------------------- -# Configuration::addtions related to the search engine +# Configuration::additions related to the search engine #--------------------------------------------------------------------------- SEARCHENGINE = NO -CGI_NAME = search.cgi -CGI_URL = -DOC_URL = -DOC_ABSPATH = -BIN_ABSPATH = /usr/local/bin/ -EXT_DOC_PATHS = diff --git a/src/INTERPOLATION/Makefile.in b/src/INTERPOLATION/Makefile.in index da0fbfd98..7e566ea9d 100644 --- a/src/INTERPOLATION/Makefile.in +++ b/src/INTERPOLATION/Makefile.in @@ -82,10 +82,10 @@ UseCaseWrapper_Maillage CPPFLAGS+=-U_DEBUG_ $(MED2_INCLUDES) $(HDF5_INCLUDES) -I../ CXXFLAGS+=-U_DEBUG_ @CXXTMPDPTHFLAGS@ #LDFLAGS+=$(MED2_LIBS) $(HDF5_LIBS) -LDFLAGS+=-lm $(MED2_LIBS) $(HDF5_LIBS) -lMEDWrapper_V2_1 +LDFLAGS+=-lm $(MED2_LIBS) $(HDF5_LIBS) -lmed_V2_1 #LDFLAGSFORBIN+=$(MED2_LIBS) $(HDF5_LIBS) -L../.libs -lmedmem -LDFLAGSFORBIN+=-lm $(MED2_LIBS) $(HDF5_LIBS) -L../.libs -lmedmem -lMEDWrapper_V2_1 -lMEDWrapperBase +LDFLAGSFORBIN+=-lm $(MED2_LIBS) $(HDF5_LIBS) -L../.libs -lmedmem -lmed_V2_1 ifeq ($(MED_WITH_KERNEL),yes) CPPFLAGS+= -I${KERNEL_ROOT_DIR}/include/salome diff --git a/src/MEDGUI/Makefile.in b/src/MEDGUI/Makefile.in index 94abc038e..f6fdb6d63 100644 --- a/src/MEDGUI/Makefile.in +++ b/src/MEDGUI/Makefile.in @@ -58,8 +58,7 @@ LIB_SERVER_IDL = # additionnal information to compil and link file -CPPFLAGS += $(QT_INCLUDES) $(VTK_INCLUDES) $(OCC_INCLUDES) $(PYTHON_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome -I${GUI_ROOT_DIR}/include/salome -I${BOOSTDIR} -LDFLAGS += -lSalomeApp -lMEDMEMImpl -lmedmem -lMEDEngine -I${KERNEL_ROOT_DIR}/include/salome -I${GUI_ROOT_DIR}/include/salome -I${BOOSTDIR} +CPPFLAGS += $(QT_INCLUDES) $(VTK_INCLUDES) $(OCC_INCLUDES) $(PYTHON_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome -I${GUI_ROOT_DIR}/include/salome ${BOOST_CPPFLAGS} LDFLAGS += -lSalomeApp -lMEDMEMImpl -lmedmem -lMEDEngine -L${KERNEL_ROOT_DIR}/lib/salome -L${GUI_ROOT_DIR}/lib/salome diff --git a/src/MEDMEM/Makefile.in b/src/MEDMEM/Makefile.in index 1a4f7957d..52aa6dd6b 100644 --- a/src/MEDMEM/Makefile.in +++ b/src/MEDMEM/Makefile.in @@ -158,11 +158,11 @@ CPPFLAGS+=$(MED2_INCLUDES) $(HDF5_INCLUDES) CXXFLAGS+=@CXXTMPDPTHFLAGS@ #LDFLAGS+=$(MED2_LIBS) $(HDF5_LIBS) # change motivated by the bug KERNEL4778. -LDFLAGS+=$(MED2_LIBS) $(HDF5_LIBS) -lMEDWrapper_V2_1 $(STDLIB) +LDFLAGS+=$(MED2_LIBS) $(HDF5_LIBS) -lmed_V2_1 $(STDLIB) #LDFLAGSFORBIN+=$(MED2_LIBS) $(HDF5_LIBS) # change motivated by the bug KERNEL4778. -LDFLAGSFORBIN+=-lm $(MED2_LIBS) $(HDF5_LIBS) -lMEDWrapper_V2_1 -lMEDWrapperBase +LDFLAGSFORBIN+=-lm $(MED2_LIBS) $(HDF5_LIBS) -lmed_V2_1 ifeq ($(MED_WITH_KERNEL),yes) CPPFLAGS+= -I${KERNEL_ROOT_DIR}/include/salome diff --git a/src/MEDWrapper/Base/MED_Algorithm.cxx b/src/MEDWrapper/Base/MED_Algorithm.cxx index 59dd4e54e..6f523efec 100644 --- a/src/MEDWrapper/Base/MED_Algorithm.cxx +++ b/src/MEDWrapper/Base/MED_Algorithm.cxx @@ -27,84 +27,90 @@ // $Header$ #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{ +namespace MED +{ //--------------------------------------------------------------- - TElemGroup - GetElemsByEntity(TWrapper& theWrapper, - const PMeshInfo& theMeshInfo, - const MED::TEntityInfo& theEntityInfo) + TEntity2TGeom2ElemInfo + GetEntity2TGeom2ElemInfo(const PWrapper& theWrapper, + const PMeshInfo& theMeshInfo, + const MED::TEntityInfo& theEntityInfo) { MSG(MYDEBUG,"GetElemsByEntity(...)"); - TElemGroup aGroup; + TEntity2TGeom2ElemInfo anEntity2TGeom2ElemInfo; MED::TEntityInfo::const_iterator anIter = theEntityInfo.begin(); for(; anIter != theEntityInfo.end(); anIter++){ const EEntiteMaillage& anEntity = anIter->first; - const MED::TGeom& aGeom = anIter->second; - TElemMap& anElemMap = aGroup[anEntity]; + const TGeom2Size& aGeom2Size = anIter->second; + TGeom2ElemInfo& aGeom2ElemInfo = anEntity2TGeom2ElemInfo[anEntity]; if(anEntity == eNOEUD){ - anElemMap[ePOINT1] = theWrapper.GetPNodeInfo(theMeshInfo); + aGeom2ElemInfo[ePOINT1] = theWrapper->GetPNodeInfo(theMeshInfo); continue; } - MED::TGeom::const_iterator anGeomIter = aGeom.begin(); - for(; anGeomIter != aGeom.end(); anGeomIter++){ - const EGeometrieElement& aGeo = anGeomIter->first; - switch(aGeo){ + TGeom2Size::const_iterator anIter2 = aGeom2Size.begin(); + for(; anIter2 != aGeom2Size.end(); anIter2++){ + const EGeometrieElement& aGeom = anIter2->first; + switch(aGeom){ case ePOLYGONE: { - anElemMap[ePOLYGONE] = theWrapper.GetPPolygoneInfo(theMeshInfo,anEntity,aGeo); + aGeom2ElemInfo[ePOLYGONE] = theWrapper->GetPPolygoneInfo(theMeshInfo,anEntity,aGeom); break; } case ePOLYEDRE: { - anElemMap[ePOLYEDRE] = theWrapper.GetPPolyedreInfo(theMeshInfo,anEntity,aGeo); + aGeom2ElemInfo[ePOLYEDRE] = theWrapper->GetPPolyedreInfo(theMeshInfo,anEntity,aGeom); break; } default: { - anElemMap[aGeo] = theWrapper.GetPCellInfo(theMeshInfo,anEntity,aGeo); + aGeom2ElemInfo[aGeom] = theWrapper->GetPCellInfo(theMeshInfo,anEntity,aGeom); }} } } ADDMSG(MYDEBUG,"\n"); - return aGroup; + return anEntity2TGeom2ElemInfo; } //--------------------------------------------------------------- - TFamilyGroup - GetFamilies(TWrapper& theWrapper, - const PMeshInfo& theMeshInfo) + TFamilyInfoSet + GetFamilyInfoSet(const PWrapper& theWrapper, + const PMeshInfo& theMeshInfo) { MSG(MYDEBUG,"GetFamilies(...)"); TErr anErr; - TFamilyGroup aGroup; - TInt aNbFam = theWrapper.GetNbFamilies(*theMeshInfo); + TFamilyInfoSet aFamilyInfoSet; + TInt aNbFam = theWrapper->GetNbFamilies(*theMeshInfo); INITMSG(MYDEBUG,"GetNbFamilies() = "<GetPFamilyInfo(theMeshInfo,iFam,&anErr); if(anErr >= 0) - aGroup.insert(aFamilyInfo); + aFamilyInfoSet.insert(aFamilyInfo); } ADDMSG(MYDEBUG,"\n"); - return aGroup; + return aFamilyInfoSet; } - TGroupInfo - GetFamiliesByGroup(const TFamilyGroup& theGroupInfo) + //--------------------------------------------------------------- + TGroupInfo + GetGroupInfo(const TFamilyInfoSet& theFamilyInfoSet) { MSG(MYDEBUG,"GetFamiliesByGroup(...)"); TGroupInfo aGroup; - TFamilyGroup::const_iterator anIter = theGroupInfo.begin(); - for(; anIter != theGroupInfo.end(); anIter++){ + 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++){ @@ -116,11 +122,11 @@ namespace MED{ if(MYDEBUG){ TGroupInfo::const_iterator anIter = aGroup.begin(); for(; anIter != aGroup.end(); anIter++){ - string aName = anIter->first; + const std::string& aName = anIter->first; INITMSG(MYDEBUG,"aGroupName = '"<second; - TFamilyGroup::const_iterator anFamIter = aFamilyGroup.begin(); - for(; anFamIter != aFamilyGroup.end(); anFamIter++){ + const TFamilyInfoSet& aFamilyInfoSet = anIter->second; + TFamilyInfoSet::const_iterator anFamIter = aFamilyInfoSet.begin(); + for(; anFamIter != aFamilyInfoSet.end(); anFamIter++){ const PFamilyInfo& aFamilyInfo = *anFamIter; INITMSG(MYDEBUG,"aFamilyName = '"<GetName()<<"'\n"); } @@ -134,106 +140,119 @@ namespace MED{ //--------------------------------------------------------------- - TTimeStampGroup - GetFieldsByEntity(TWrapper& theWrapper, - const PMeshInfo& theMeshInfo, - const MED::TEntityInfo& theEntityInfo) + TFieldInfo2TimeStampInfoSet + GetFieldInfo2TimeStampInfoSet(const PWrapper& theWrapper, + const PMeshInfo& theMeshInfo, + const MED::TEntityInfo& theEntityInfo) { MSG(MYDEBUG,"GetFieldsByEntity(...)"); - TTimeStampGroup aGroup; - TInt aNbFields = theWrapper.GetNbFields(); + TFieldInfo2TimeStampInfoSet aFieldInfo2TimeStampInfoSet; + TInt aNbFields = theWrapper->GetNbFields(); INITMSG(MYDEBUG,"GetNbFields() = "<GetPFieldInfo(theMeshInfo,iField); INITMSG(MYDEBUG,"aFieldName = '"<GetName()<< "'; aNbComp = "<GetNbComp()<<"; "); - MED::TGeom aGeom; + TGeom2Size aGeom2Size; EEntiteMaillage anEntity = EEntiteMaillage(-1); - TInt aNbTimeStamps = theWrapper.GetNbTimeStamps(aFieldInfo,theEntityInfo,anEntity,aGeom); + TInt aNbTimeStamps = theWrapper->GetNbTimeStamps(aFieldInfo,theEntityInfo,anEntity,aGeom2Size); ADDMSG(MYDEBUG,"anEntity = "<GetUnitDt() - <<"\', aNbGauss = "<GetNbGauss()<<"\n"); + theWrapper->GetPTimeStampInfo(aFieldInfo,anEntity,aGeom2Size,iTimeStamp); + aFieldInfo2TimeStampInfoSet[aFieldInfo].insert(aTimeStamp); + INITMSG(MYDEBUG, + "aDt = "<GetDt()<< + ", Unit = \'"<GetUnitDt()<<"\n"); } } ADDMSG(MYDEBUG,"\n"); - return aGroup; + return aFieldInfo2TimeStampInfoSet; } - TFieldGroup - GetFieldsByEntity(const TTimeStampGroup& theTimeStampGroup) + //--------------------------------------------------------------- + TEntite2TFieldInfo2TimeStampInfoSet + GetEntite2TFieldInfo2TimeStampInfoSet(const TFieldInfo2TimeStampInfoSet& theFieldInfo2TimeStampInfoSet) { - TFieldGroup aGroup; - TTimeStampGroup::const_iterator anIter = theTimeStampGroup.begin(); - for(; anIter != theTimeStampGroup.end(); anIter++){ + TEntite2TFieldInfo2TimeStampInfoSet anEntite2TFieldInfo2TimeStampInfoSet; + TFieldInfo2TimeStampInfoSet::const_iterator anIter = theFieldInfo2TimeStampInfoSet.begin(); + for(; anIter != theFieldInfo2TimeStampInfoSet.end(); anIter++){ + const TTimeStampInfoSet& aTimeStampInfoSet = anIter->second; //const PFieldInfo& aFieldInfo = anIter->first; - const TTimeStampSet& aTimeStampSet = anIter->second; - if(aTimeStampSet.empty()) continue; - const PTimeStampInfo& aTimeStampInfo = *aTimeStampSet.begin(); - aGroup[aTimeStampInfo->GetEntity()].insert(*anIter); + if(aTimeStampInfoSet.empty()) + continue; + const PTimeStampInfo& aTimeStampInfo = *aTimeStampInfoSet.begin(); + anEntite2TFieldInfo2TimeStampInfoSet[aTimeStampInfo->GetEntity()].insert(*anIter); } - return aGroup; + return anEntite2TFieldInfo2TimeStampInfoSet; } - TFamilyByEntity - GetFamiliesByEntity(TWrapper& theWrapper, - const TElemGroup& theElemGroup, - const TFamilyGroup& theFamilyGroup) + //--------------------------------------------------------------- + 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(...)"); - TFamilyByEntity aFamilyByEntity; + TEntity2FamilySet anEntity2FamilySet; - typedef map TFamilyByIdMap; - TFamilyByIdMap aFamilyByIdMap; - TFamilyGroup::const_iterator anIter = theFamilyGroup.begin(); - for(; anIter != theFamilyGroup.end(); anIter++){ + typedef map TId2Family; + TId2Family anId2Family; + TFamilyInfoSet::const_iterator anIter = theFamilyInfoSet.begin(); + for(; anIter != theFamilyInfoSet.end(); anIter++){ const PFamilyInfo& aFamilyInfo = *anIter; - aFamilyByIdMap.insert(TFamilyByIdMap::value_type(aFamilyInfo->GetId(),aFamilyInfo)); + anId2Family.insert(TId2Family::value_type(aFamilyInfo->GetId(),aFamilyInfo)); } - if(!aFamilyByIdMap.empty()){ - typedef set TFamilyIdSet; - typedef map TFamilyIdByEntity; - TFamilyIdByEntity aFamilyIdByEntity; + if(!anId2Family.empty()){ + typedef std::map TFamilyID2Size; + typedef map TEntity2FamilyID; + TEntity2FamilyID anEntity2FamilyID; - if(!theElemGroup.empty()){ - TElemGroup::const_iterator anIter = theElemGroup.begin(); - for(; anIter != theElemGroup.end(); anIter++){ + if(!theEntity2TGeom2ElemInfo.empty()){ + TEntity2TGeom2ElemInfo::const_iterator anIter = theEntity2TGeom2ElemInfo.begin(); + for(; anIter != theEntity2TGeom2ElemInfo.end(); anIter++){ const EEntiteMaillage& anEntity = anIter->first; - TFamilyIdSet& aFamilyIdSet = aFamilyIdByEntity[anEntity]; - const TElemMap& anElemMap = anIter->second; - TElemMap::const_iterator anElemIter = anElemMap.begin(); - for(; anElemIter != anElemMap.end(); anElemIter++){ - const PElemInfo& aElemInfo = anElemIter->second; + 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++){ - aFamilyIdSet.insert(aElemInfo->GetFamNum(i)); + aFamilyID2Size[aElemInfo->GetFamNum(i)] += 1; } } } } } - if(!aFamilyIdByEntity.empty()){ - TFamilyIdByEntity::const_iterator anIter = aFamilyIdByEntity.begin(); - for(; anIter != aFamilyIdByEntity.end(); anIter++){ + if(!anEntity2FamilyID.empty()){ + TEntity2FamilyID::const_iterator anIter = anEntity2FamilyID.begin(); + for(; anIter != anEntity2FamilyID.end(); anIter++){ const EEntiteMaillage& anEntity = anIter->first; INITMSG(MYDEBUG,"anEntity = "<second; - TFamilyIdSet::const_iterator anFamilyIdIter = aFamilyIdSet.begin(); - for(; anFamilyIdIter != aFamilyIdSet.end(); anFamilyIdIter++){ - const TInt& aFamilyId = *anFamilyIdIter; - TFamilyByIdMap::const_iterator - anFamilyByIdMapIter = aFamilyByIdMap.find(aFamilyId); - if(anFamilyByIdMapIter != aFamilyByIdMap.end()){ - const PFamilyInfo& aFamilyInfo = anFamilyByIdMapIter->second; - aFamilyByEntity[anEntity].insert(aFamilyInfo); + const TFamilyID2Size& aFamilyID2Size = anIter->second; + TFamilyID2Size::const_iterator anIter2 = aFamilyID2Size.begin(); + for(; anIter2 != aFamilyID2Size.end(); anIter2++){ + TInt anId = anIter2->first; + TInt aSize = anIter2->second; + TId2Family::const_iterator anIter3 = anId2Family.find(anId); + if(anIter3 != anId2Family.end()){ + const PFamilyInfo& aFamilyInfo = anIter3->second; + anEntity2FamilySet[anEntity].insert(TFamilyTSize(aFamilyInfo,aSize)); INITMSG(MYDEBUG, "aFamilyName = '"<GetName()<< "' anId = "<GetId()<<"\n"); @@ -243,7 +262,88 @@ namespace MED{ } } ADDMSG(MYDEBUG,"\n"); - return aFamilyByEntity; + 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 = '"<myElemNum.size(); + for(TInt iElem = 0; iElem < aNbElem; iElem++){ + ADDMSG(MYVALUEDEBUG,anInfo->GetElemNum(iElem)<<", "); + } + ADDMSG(MYVALUEDEBUG,endl); +#endif + + } + return TMKey2Profile(theMode,aKey2Profile); + } + } diff --git a/src/MEDWrapper/Base/MED_Algorithm.hxx b/src/MEDWrapper/Base/MED_Algorithm.hxx index d688f5135..e53380602 100644 --- a/src/MEDWrapper/Base/MED_Algorithm.hxx +++ b/src/MEDWrapper/Base/MED_Algorithm.hxx @@ -30,55 +30,104 @@ #define MED_Algorithm_HeaderFile #include "MED_Structures.hxx" -#include "MED_Wrapper.hxx" #include -namespace MED{ +namespace MED +{ //--------------------------------------------------------------- - typedef std::map TElemMap; - typedef std::map TElemGroup; + typedef std::map TGeom2ElemInfo; + typedef std::map TEntity2TGeom2ElemInfo; - TElemGroup GetElemsByEntity(TWrapper& theWrapper, - const PMeshInfo& theMeshInfo, - const MED::TEntityInfo& theEntityInfo); + //! Get set of TElemInfo by its geometrical type and corresponding MED ENTITY + TEntity2TGeom2ElemInfo + GetEntity2TGeom2ElemInfo(const PWrapper& theWrapper, + const PMeshInfo& theMeshInfo, + const MED::TEntityInfo& theEntityInfo); //--------------------------------------------------------------- - typedef std::set TFamilyGroup; - - TFamilyGroup GetFamilies(TWrapper& theWrapper, - const PMeshInfo& theMeshInfo); + typedef std::set TFamilyInfoSet; + //! Read set of MED FAMILIES for defined MED file + TFamilyInfoSet + GetFamilyInfoSet(const PWrapper& theWrapper, + const PMeshInfo& theMeshInfo); + //--------------------------------------------------------------- - typedef std::map TFamilyByEntity; - - TFamilyByEntity GetFamiliesByEntity(TWrapper& theWrapper, - const TElemGroup& theElemGroup, - const TFamilyGroup& theFamilyGroup); + typedef boost::tuple TFamilyTSize; + + bool + operator<(const TFamilyTSize& theLeft, const TFamilyTSize& theRight); + typedef std::set TFamilyTSizeSet; //--------------------------------------------------------------- - typedef std::map TGroupInfo; + typedef std::map TEntity2FamilySet; + + //! Split set of MED FAMILIES by corresponding MED ENTITY + TEntity2FamilySet + GetEntity2FamilySet(const PWrapper& theWrapper, + const TEntity2TGeom2ElemInfo& theEntity2TGeom2ElemInfo, + const TFamilyInfoSet& theFamilyInfoSet); - TGroupInfo GetFamiliesByGroup(const TFamilyGroup& theGroupInfo); + //--------------------------------------------------------------- + typedef std::map TGroupInfo; + + //! Split the input set of MED FAMILIES by corresponding MED GROUPS + TGroupInfo + GetGroupInfo(const TFamilyInfoSet& theFamilyInfoSet); + //--------------------------------------------------------------- - typedef std::set TTimeStampSet; - typedef std::map TTimeStampGroup; + typedef std::set TTimeStampInfoSet; + typedef std::map TFieldInfo2TimeStampInfoSet; + + //! Read set of MED TIMESTAMPS groupped by corresponding MED FIELDS + 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 + TEntite2TFieldInfo2TimeStampInfoSet + GetEntite2TFieldInfo2TimeStampInfoSet(const TFieldInfo2TimeStampInfoSet& theFieldInfo2TimeStampInfoSet); - TTimeStampGroup GetFieldsByEntity(TWrapper& theWrapper, - const PMeshInfo& theMeshInfo, - const MED::TEntityInfo& theEntityInfo); + + //--------------------------------------------------------------- + typedef std::map TKey2Gauss; + + //! Read set of MED GAUSS + TKey2Gauss + GetKey2Gauss(const PWrapper& theWrapper, + TErr* theErr = NULL, + EModeSwitch theMode = eFULL_INTERLACE); //--------------------------------------------------------------- - typedef std::map TFieldGroup; + //! Get MED PROFILE by its name + PProfileInfo + GetProfileInfo(const PWrapper& theWrapper, + const std::string& theProfileName, + TErr* theErr = NULL, + EModeProfil theMode = eCOMPACT); - TFieldGroup GetFieldsByEntity(const TTimeStampGroup& theTimeStampGroup); + //--------------------------------------------------------------- + typedef std::map TKey2Profile; + typedef boost::tuple TMKey2Profile; + + //! Read set of MED PROFILES + TMKey2Profile + GetMKey2Profile(const PWrapper& theWrapper, + TErr* theErr = NULL, + EModeProfil theMode = eCOMPACT); } #endif diff --git a/src/MEDWrapper/Base/MED_Common.hxx b/src/MEDWrapper/Base/MED_Common.hxx index 279489642..f659a8fc2 100644 --- a/src/MEDWrapper/Base/MED_Common.hxx +++ b/src/MEDWrapper/Base/MED_Common.hxx @@ -29,125 +29,27 @@ #ifndef MED_Common_HeaderFile #define MED_Common_HeaderFile -#include -#include -#include #include #include #include -extern "C"{ +extern "C" +{ #include } -#include +#include #include "SALOMEconfig.h" +#include "MED_Vector.hxx" +#include "MED_SharedPtr.hxx" +#include "MED_SliceArray.hxx" + namespace MED{ enum EVersion {eVUnknown = -1, eV2_1, eV2_2}; - - template class 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::polymorphic_cast_tag()) - {} - - template - SharedPtr& operator=(SharedPtr const & r) - { - boost::shared_ptr(r,boost::detail::polymorphic_cast_tag()).swap(*this); - return *this; - } - - template SharedPtr& operator()(Y * p) // Y must be complete - { - return operator=(SharedPtr(p)); - } - - operator const T& () const - { - return *(this->get()); - } - - operator T& () - { - return *(this->get()); - } - }; - - - template - class ConstSliceArray - { - const TContainer& myConstContainer; - std::slice mySlice; - protected: - size_t GetID(size_t theId) const - { - if(theId < mySlice.size()){ - size_t anId = mySlice.start() + theId*mySlice.stride(); - if(anId < myConstContainer.size()) - return anId; - } - throw std::out_of_range(); - return -1; - } - - public: - typedef typename TContainer::value_type TValue; - - ConstSliceArray(const TContainer& theContainer, - const std::slice& theSlice): - myConstContainer(theContainer), - mySlice(theSlice) - { - } - - const TValue& operator[](size_t theId) const - { - return myConstContainer[GetID(theId)]; - } - - size_t size() const - { - return mySlice.size(); - } - }; - - - template - class SliceArray: public ConstSliceArray - { - TContainer& myContainer; - - public: - typedef ConstSliceArray TSupperClass; - SliceArray(TContainer& theContainer, - const std::slice& theSlice): - TSupperClass(theContainer,theSlice), - myContainer(theContainer) - { - } - - typename TSupperClass::TValue& operator[](size_t theId) - { - return myContainer[this->GetID(theId)]; - } - }; - - typedef enum {eFAUX, eVRAI} EBooleen ; typedef double TFloat; #if defined(SUN4SOL2) || defined(PCLINUX) || defined(OSF1_32) || defined(IRIX64_32) || defined(RS6000) || defined(HP9000) @@ -159,6 +61,8 @@ namespace MED{ 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; @@ -177,36 +81,48 @@ namespace MED{ typedef enum {eNO_PFLMOD, eGLOBAL, eCOMPACT} EModeProfil; - typedef std::vector TFloatVector; - typedef std::vector TStringVector; - typedef std::vector TIntVector; + typedef TVector TFloatVector; + typedef TVector TStringVector; + typedef TVector TIntVector; typedef std::set TStringSet; - typedef std::map TGeom; - typedef std::map TEntityInfo; + typedef std::map TGeom2Size; + typedef std::map TEntityInfo; typedef std::set TGeomSet; typedef std::map TEntity2GeomSet; - const TEntity2GeomSet& GetEntity2GeomSet(); + const TEntity2GeomSet& + GetEntity2GeomSet(); - template - - TInt GetNbConn(EGeometrieElement typmai, - EEntiteMaillage typent, - TInt mdim); + template + TInt + GetDESCLength(); - template<> - TInt GetNbConn(EGeometrieElement typmai, - EEntiteMaillage typent, - TInt mdim); - - template<> - TInt GetNbConn(EGeometrieElement typmai, - EEntiteMaillage typent, - TInt mdim); - - TInt GetNbNodes(EGeometrieElement typmai); + template + TInt + GetIDENTLength(); + + template + TInt + GetNOMLength(); + + template + TInt + GetLNOMLength(); + + template + TInt + GetPNOMLength(); + + template + TInt + GetNbConn(EGeometrieElement typmai, + EEntiteMaillage typent, + TInt mdim); + + TInt + GetNbNodes(EGeometrieElement typmai); struct TNameInfo; typedef SharedPtr PNameInfo; @@ -237,6 +153,12 @@ namespace MED{ struct TTimeStampInfo; typedef SharedPtr PTimeStampInfo; + + struct TProfileInfo; + typedef SharedPtr PProfileInfo; + + struct TGaussInfo; + typedef SharedPtr PGaussInfo; struct TTimeStampVal; typedef SharedPtr PTimeStampVal; diff --git a/src/MEDWrapper/Base/MED_CoordUtils.cxx b/src/MEDWrapper/Base/MED_CoordUtils.cxx new file mode 100644 index 000000000..74225911b --- /dev/null +++ b/src/MEDWrapper/Base/MED_CoordUtils.cxx @@ -0,0 +1,160 @@ +// +// +// Copyright (C) 2003 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// +// +// File : +// Author : +// Module : +// $Header$ + +#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++){ + std::string aName = theNodeInfo->GetCoordName(iDim); + 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..9ed526407 --- /dev/null +++ b/src/MEDWrapper/Base/MED_CoordUtils.hxx @@ -0,0 +1,60 @@ +// +// +// Copyright (C) 2003 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// +// +// File : +// Author : +// Module : +// $Header$ + +#ifndef MED_CoordUtils_HeaderFile +#define MED_CoordUtils_HeaderFile + +#include "MED_Structures.hxx" + +namespace MED +{ + typedef TFloat (*TGetCoord)(const TCCoordSlice& theCoordSlice); + + + //--------------------------------------------------------------- + class TCoordHelper + { + TGetCoord* myGetCoord; + + public: + TCoordHelper(TGetCoord* theGetCoord); + + TFloat + GetCoord(TCCoordSlice& theCoordSlice, + TInt theCoordId); + }; + typedef SharedPtr PCoordHelper; + + + //--------------------------------------------------------------- + PCoordHelper + GetCoordHelper(PNodeInfo theNodeInfo); + +} + +#endif diff --git a/src/MEDWrapper/Base/MED_GaussUtils.cxx b/src/MEDWrapper/Base/MED_GaussUtils.cxx new file mode 100644 index 000000000..ad532ba42 --- /dev/null +++ b/src/MEDWrapper/Base/MED_GaussUtils.cxx @@ -0,0 +1,1364 @@ +// +// +// Copyright (C) 2003 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// +// +// File : +// Author : +// Module : +// $Header$ + +#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); + } + + + 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; + } + + + struct TShapeFun + { + class 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)); + } + }; + + typedef TVector TCCoordSliceArr; + typedef TVector TCoordSliceArr; + + TFloatVector myRefCoord; + TInt myDim; + TInt myNbRef; + + TShapeFun(TInt theDim = 0, TInt theNbRef = 0): + myDim(theDim), + myNbRef(theNbRef), + myRefCoord(theNbRef*theDim) + {} + + TInt + GetNbRef() const + { + return myNbRef; + } + + TCCoordSlice + GetCoord(TInt theRefId) const + { + return TCCoordSlice(myRefCoord,std::slice(theRefId*myDim,myDim,1)); + } + + TCoordSlice + GetCoord(TInt theRefId) + { + return TCoordSlice(myRefCoord,std::slice(theRefId*myDim,myDim,1)); + } + + void + GetFun(const TShapeFun::TCCoordSliceArr& theRef, + const TShapeFun::TCCoordSliceArr& theGauss, + TFun& theFun) const + { + TInt aNbRef = theRef.size(); + TInt aNbGauss = theGauss.size(); + theFun.Init(aNbGauss,aNbRef); + } + + virtual + void + InitFun(const TShapeFun::TCCoordSliceArr& theRef, + const TShapeFun::TCCoordSliceArr& theGauss, + TFun& theFun) const = 0; + + virtual + bool + IsSatisfy(const TShapeFun::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); + + 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 TGaussCoord: + virtual TModeSwitchInfo + { + TInt myNbElem; + TInt myNbGauss; + TInt myDim; + + TInt myGaussStep; + + TNodeCoord myGaussCoord; + + public: + + TGaussCoord(); + + //! 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); + + //! To init the class + void + Init(TInt theNbElem, + TInt theNbGauss, + TInt theDim, + EModeSwitch theMode = eFULL_INTERLACE); + + TInt + GetNbElem() const { return myNbElem; } + + TInt + GetNbGauss() const { return myNbGauss; } + + TInt + GetDim() const { return myDim; } + }; + + + //--------------------------------------------------------------- + //! To calculate Gauss Points coordinates + 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 + 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 + 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 + bool + GetBaryCenter(const TPolyedreInfo& thePolyedreInfo, + const TNodeInfo& theNodeInfo, + TGaussCoord& theGaussCoord, + const TElemNum& theElemNum = TElemNum(), + EModeSwitch theMode = eFULL_INTERLACE); +} + +#endif diff --git a/src/MEDWrapper/Base/MED_SharedPtr.hxx b/src/MEDWrapper/Base/MED_SharedPtr.hxx new file mode 100644 index 000000000..e0067f977 --- /dev/null +++ b/src/MEDWrapper/Base/MED_SharedPtr.hxx @@ -0,0 +1,102 @@ +// +// +// Copyright (C) 2003 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// +// +// File : +// Author : +// Module : +// $Header$ + +#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..d0b8923d9 --- /dev/null +++ b/src/MEDWrapper/Base/MED_SliceArray.hxx @@ -0,0 +1,136 @@ +// +// +// Copyright (C) 2003 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// +// +// File : +// Author : +// Module : +// $Header$ + +#ifndef MED_SliceArray_HeaderFile +#define MED_SliceArray_HeaderFile + +#include +#include + +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 + { + typedef const TContainer* PCContainer; + PCContainer myCContainer; //!< Reference to source multy-dimension data + std::slice mySlice; //!< Defines algorithm of index calculation + protected: + //! Calculate internal index to get proper element from the source multy-dimension data + size_t + GetID(size_t theId) const + { +#ifdef _DEBUG_ + size_t anId = -1; + if(theId < mySlice.size()){ + anId = mySlice.start() + theId*mySlice.stride(); + if(anId < myCContainer->size()) + return anId; + } + throw std::out_of_range(std::string("TCSlice::GetID")); + return anId; +#else + return mySlice.start() + theId*mySlice.stride(); +#endif + } + + public: + typedef typename TContainer::value_type value_type; + + //! Construct the class + TCSlice(const TContainer& theContainer, + const std::slice& theSlice): + myCContainer(&theContainer), + mySlice(theSlice) + {} + + //! Default constructor (dangerous) + TCSlice(): + myCContainer(NULL) + {} + + //! Get element by its number (const version) + const value_type& + operator[](size_t theId) const + { + return (*myCContainer)[GetID(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 + { + typedef TContainer* PContainer; + PContainer myContainer; + + public: + typedef typename TContainer::value_type value_type; + typedef TCSlice TSupperClass; + + //! Construct the class + TSlice(TContainer& theContainer, + const std::slice& theSlice): + TSupperClass(theContainer,theSlice), + myContainer(&theContainer) + { + } + + //! Default constructor (dangerous) + TSlice(): + myContainer(NULL) + {} + + //! Get element by its number + value_type& + operator[](size_t theId) + { + return (*myContainer)[this->GetID(theId)]; + } + }; + +} + + +#endif diff --git a/src/MEDWrapper/Base/MED_Structures.cxx b/src/MEDWrapper/Base/MED_Structures.cxx index c193acce8..0c1346e46 100644 --- a/src/MEDWrapper/Base/MED_Structures.cxx +++ b/src/MEDWrapper/Base/MED_Structures.cxx @@ -8,174 +8,449 @@ #include "MED_Structures.hxx" #include "MED_Utilities.hxx" -using namespace MED; - -#if defined __GNUC__ - #if __GNUC__ == 2 - #define __GNUC_2__ - #endif -#endif -#if defined __GNUC_2__ -#define GETINDEX(anArray,ind) anArray[ind] -#else -#define GETINDEX(anArray,ind) anArray.at(ind) -#endif - -namespace MED{ +using namespace MED; - TInt GetNbNodes(EGeometrieElement typmai) +namespace MED +{ + TInt + GetNbNodes(EGeometrieElement typmai) { return typmai%100; } - template<> - TInt GetNbConn(EGeometrieElement typmai, - EEntiteMaillage typent, - TInt mdim) + std::string + GetString(TInt theId, + TInt theStep, + const TString& theString) { - TInt nsup = 0; - - if(typent == eMAILLE){ - TInt edim = typmai / 100; - if(mdim == 2 || mdim == 3) - if(edim == 1) - nsup = 1; - - if(mdim == 3) - if (edim == 2) - nsup = 1; - } - - return nsup + typmai%100; + const char* aPos = &theString[theId*theStep]; + TInt aSize = std::min(TInt(strlen(aPos)),theStep); + return std::string(aPos,aSize); } - template<> - TInt GetNbConn(EGeometrieElement typmai, - EEntiteMaillage typent, - TInt mdim) + void + SetString(TInt theId, + TInt theStep, + TString& theString, + const std::string& theValue) { - return typmai%100; + TInt aSize = std::min(TInt(theValue.size()+1),theStep); + char* aPos = &theString[theId*theStep]; + strncpy(aPos,theValue.c_str(),aSize); } - std::string GetString(TInt theId, TInt theStep, - const TString& theString) + TInt + GetDimGaussCoord(EGeometrieElement theGeom) { - const char* aPos = &GETINDEX(theString,theId*theStep); - TInt aSize = std::min(TInt(strlen(aPos)),theStep); - return std::string(aPos,aSize); + return theGeom/100; } - void SetString(TInt theId, TInt theStep, - TString& theString, - const std::string& theValue) + TInt + GetNbRefCoord(EGeometrieElement theGeom) { - TInt aSize = std::min(TInt(theValue.size()+1),theStep); - char* aPos = &GETINDEX(theString,theId*theStep); - strncpy(aPos,theValue.c_str(),aSize); + return (theGeom%100); } } //--------------------------------------------------------------- -TInt TFamilyInfo::GetAttrId(TInt theId) const { - return GETINDEX(myAttrId,theId); +TInt +TFamilyInfo +::GetAttrId(TInt theId) const +{ + return myAttrId[theId]; } -TInt TFamilyInfo::GetAttrVal(TInt theId) const { - return GETINDEX(myAttrVal,theId); +TInt +TFamilyInfo +::GetAttrVal(TInt theId) const +{ + return myAttrVal[theId]; } -void TFamilyInfo::SetAttrId(TInt theId,TInt theVal) { - GETINDEX(myAttrId,theId) = theVal; +void +TFamilyInfo +::SetAttrId(TInt theId,TInt theVal) +{ + myAttrId[theId] = theVal; } -void TFamilyInfo::SetAttrVal(TInt theId,TInt theVal) { - GETINDEX(myAttrVal,theId) = theVal; +void +TFamilyInfo +::SetAttrVal(TInt theId,TInt theVal) +{ + myAttrVal[theId] = theVal; } //--------------------------------------------------------------- -TInt TElemInfo::GetFamNum(TInt theId) const { - return GETINDEX(myFamNum,theId); +TInt +TElemInfo +::GetFamNum(TInt theId) const +{ + return myFamNum[theId]; } -TInt TElemInfo::GetElemNum(TInt theId) const { - return GETINDEX(myElemNum,theId); +TInt +TElemInfo +::GetElemNum(TInt theId) const +{ + return myElemNum[theId]; } -void TElemInfo::SetFamNum(TInt theId,TInt theVal) { - GETINDEX(myFamNum,theId) = theVal; +void +TElemInfo +::SetFamNum(TInt theId,TInt theVal) +{ + myFamNum[theId] = theVal; } //--------------------------------------------------------------- -TFloat TNodeInfo::GetNodeCoord(TInt theId,TInt theComp) const { - return GETINDEX(myCoord,myMeshInfo->myDim*theId + theComp); +TCCoordSlice +TNodeInfo +::GetCoordSlice(TInt theId) const +{ + TInt aDim = myMeshInfo->GetDim(); + if(GetModeSwitch() == eFULL_INTERLACE) + return TCCoordSlice(myCoord,std::slice(theId*aDim,aDim,1)); + else + return TCCoordSlice(myCoord,std::slice(theId,aDim,aDim)); } -void TNodeInfo::SetNodeCoord(TInt theId,TInt theComp,TFloat theVal) { - GETINDEX(myCoord,myMeshInfo->myDim*theId + theComp) = theVal; +TCoordSlice +TNodeInfo +::GetCoordSlice(TInt theId) +{ + TInt aDim = myMeshInfo->GetDim(); + if(GetModeSwitch() == eFULL_INTERLACE) + return TCoordSlice(myCoord,std::slice(theId*aDim,aDim,1)); + else + return TCoordSlice(myCoord,std::slice(theId,aDim,aDim)); } //--------------------------------------------------------------- -TInt TCellInfo::GetConn(TInt theElemId, TInt theConnId) const { - return GETINDEX(myConn,GetConnDim()*theElemId + theConnId); +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())); } -void TCellInfo::SetConn(TInt theElemId, TInt theConnId, TInt theVal){ - GETINDEX(myConn,GetConnDim()*theElemId + theConnId) = theVal; + +//--------------------------------------------------------------- +TInt +TPolygoneInfo +::GetNbConn(TInt theElemId) const +{ + return myIndex[theElemId + 1] - myIndex[theElemId]; } -TConstConnSlice -TCellInfo::GetConnSlice(TInt theElemId) const +TCConnSlice +TPolygoneInfo +::GetConnSlice(TInt theElemId) const { - return TConstConnSlice(myConn,std::slice(GetConnDim()*theElemId,GetNbNodes(myTGeom),1)); + return TCConnSlice(myConn,std::slice(myIndex[theElemId]-1,GetNbConn(theElemId),1)); } TConnSlice -TCellInfo::GetConnSlice(TInt theElemId) +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 { - return TConnSlice(myConn,std::slice(GetConnDim()*theElemId,GetNbNodes(myTGeom),1)); + 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; } + //--------------------------------------------------------------- -TInt TPolygoneInfo::GetNbConn(TInt theElemId) const { - TInt i1 = GETINDEX(myIndex,theElemId); - TInt i2 = GETINDEX(myIndex,theElemId+1); - TInt ret = i2 - i1; - return ret; +TInt +TProfileInfo +::GetElemNum(TInt theId) const +{ + return myElemNum[theId]; +} + +void +TProfileInfo +::SetElemNum(TInt theId,TInt theVal) +{ + myElemNum[theId] = theVal; } //--------------------------------------------------------------- -TInt TPolyedreInfo::GetNbConn(TInt theElemId) const { - TInt ind1 = GETINDEX(myIndex,theElemId); - TInt ind2 = GETINDEX(myIndex,theElemId+1); +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.myGeom != theRight.myGeom) + return theLeft.myGeom < theRight.myGeom; - TInt inf1 = GETINDEX(myFacesIndex,ind1-1); - TInt inf2 = GETINDEX(myFacesIndex,ind2-1); + if(theLeft.myRefCoord != theRight.myRefCoord) + return theLeft.myRefCoord < theRight.myRefCoord; - TInt ret = inf2-inf1; - return ret; + 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()) + EXCEPTION(runtime_error,"TTimeStampInfo::GetNbGauss - myGeom2NbGauss.find(theGeom) fails"); + + return anIter->second; +} + + +//--------------------------------------------------------------- +void +TMeshValue +::Init(TInt theNbElem, + TInt theNbGauss, + TInt theNbComp, + EModeSwitch theMode) +{ + myModeSwitch = theMode; + + myNbElem = theNbElem; + myNbGauss = theNbGauss; + myNbComp = theNbComp; + + myStep = theNbComp*theNbGauss; + + myValue.resize(theNbElem*myStep); } //--------------------------------------------------------------- -TFloat TTimeStampVal::GetVal(EGeometrieElement theGeom, TInt theId, - TInt theComp, TInt theGauss) const { - TInt aNbComp = myTimeStampInfo->myFieldInfo->myNbComp; - TInt aNbGauss = myTimeStampInfo->myNbGauss; - TInt aStep = aNbComp*aNbGauss; - TMeshValue::const_iterator anIter = myMeshValue.find(theGeom); - if(anIter != myMeshValue.end()){ - TFloat aRet=GETINDEX(anIter->second,theId*aStep + theComp*aNbGauss + theGauss); - return aRet; - } - return TFloat(); -} - -void TTimeStampVal::SetVal(EGeometrieElement theGeom, TInt theId, - TInt theComp, TFloat theVal, TInt theGauss) -{ - TInt aNbComp = myTimeStampInfo->myFieldInfo->myNbComp; - TInt aNbGauss = myTimeStampInfo->myNbGauss; - TInt aStep = aNbComp*aNbGauss; - GETINDEX(myMeshValue[theGeom],theId*aStep + theComp*aNbGauss + theGauss) = theVal; +TCValueSliceArr +TMeshValue +::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; +} + +TValueSliceArr +TMeshValue +::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; +} + +//--------------------------------------------------------------- +TCValueSliceArr +TMeshValue +::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; +} + + +TValueSliceArr +TMeshValue +::GetCompValueSliceArr(TInt theElemId) +{ + TValueSliceArr aValueSliceArr(myNbGauss); + if(GetModeSwitch() == eFULL_INTERLACE){ + TInt anId = theElemId*myStep; + for(TInt aCompId = 0; aCompId < myNbComp; aCompId++){ + aValueSliceArr[aCompId] = + TValueSlice(myValue,std::slice(anId,myNbGauss,myNbComp)); + anId += 1; + } + } + else{ + for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){ + aValueSliceArr[aGaussId] = + TValueSlice(myValue,std::slice(theElemId,myNbComp,myStep)); + } + } + return aValueSliceArr; +} + + +//--------------------------------------------------------------- +const TMeshValue& +TTimeStampVal +::GetMeshValue(EGeometrieElement theGeom) const +{ + TGeom2Value::const_iterator anIter = myGeom2Value.find(theGeom); + if(anIter == myGeom2Value.end()) + EXCEPTION(runtime_error,"TTimeStampVal::GetMeshValue - myGeom2Value.find(theGeom) fails"); + return anIter->second; +} + +TMeshValue& +TTimeStampVal +::GetMeshValue(EGeometrieElement theGeom) +{ + return myGeom2Value[theGeom]; } diff --git a/src/MEDWrapper/Base/MED_Structures.hxx b/src/MEDWrapper/Base/MED_Structures.hxx index 560410eeb..f22f4b977 100644 --- a/src/MEDWrapper/Base/MED_Structures.hxx +++ b/src/MEDWrapper/Base/MED_Structures.hxx @@ -31,19 +31,24 @@ #include "MED_Common.hxx" -namespace MED{ +namespace MED +{ //--------------------------------------------------------------- - typedef std::vector TString; + //! Defines a type for managing sequence of strings + typedef TVector TString; + //! Extract a substring from the sequence of the strings std::string GetString(TInt theId, TInt theStep, const TString& theString); + //! Set a substring in the sequence of the strings void SetString(TInt theId, TInt theStep, TString& theString, const std::string& theValue); //--------------------------------------------------------------- + //! Define a parent class for all MEDWrapper classes struct TBase { virtual ~TBase() {} @@ -51,276 +56,542 @@ namespace MED{ //--------------------------------------------------------------- + //! Define a parent class for all named MED entities struct TNameInfo: virtual TBase { - TString myName; - virtual std::string GetName() const = 0; - virtual void SetName(const std::string& theValue) = 0; + 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 }; //--------------------------------------------------------------- + //! 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 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 TMeshInfo: virtual TNameInfo { - TInt myDim; - TInt GetDim() const { return myDim;} + TInt myDim; //!< Dimension of the mesh (0, 1, 2 or 3) + TInt GetDim() const { return myDim;} //!< Gets dimension of the mesh - EMaillage myType; - EMaillage GetType() const { return myType;} + EMaillage myType; //!< Type of the mesh + EMaillage GetType() const { return myType;} //!< Gets type of the mesh - TString myDesc; - virtual std::string GetDesc() const = 0; - virtual void SetDesc(const std::string& theValue) = 0; + 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 std::vector TFamAttr; + typedef TVector TIntVector; + typedef TSlice TIntVecSlice; + typedef TCSlice TCIntVecSlice; + typedef TIntVector TFamAttr; + + //! Define a base class which represents MED Family entity struct TFamilyInfo: virtual TNameInfo { - PMeshInfo myMeshInfo; - const PMeshInfo& GetMeshInfo() const { return myMeshInfo;} + PMeshInfo myMeshInfo; //!< A reference to correspondig MED Mesh + //! Get a reference to corresponding MED Mesh + const PMeshInfo& GetMeshInfo() const { return myMeshInfo;} - TInt myId; - TInt GetId() const { return myId;} - void SetId(TInt theId) { myId = theId;} + 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; - TInt GetNbGroup() const { return myNbGroup;} + TInt myNbGroup; //!< Defines number MED Groups connected to + //! Gets number of MED GROUPS the MED FAMILY is bound to + TInt GetNbGroup() const { return myNbGroup;} - TString myGroupNames; + //! 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; - TInt GetNbAttr() const { return myNbAttr;} + TInt myNbAttr; //!< Defines number of the MED Family attributes + //! Gets number of attached attributes for the MED FAMILY + TInt GetNbAttr() const { return myNbAttr;} - TFamAttr myAttrId; + //! 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 std::vector TElemNum; + typedef TIntVector TElemNum; + //! Define a parent class for all MED entities that describes mesh entites such as nodes and cells. struct TElemInfo: virtual TBase { - PMeshInfo myMeshInfo; + PMeshInfo myMeshInfo; //!< A reference to correspondig MED Mesh + //! Get a reference to corresponding MED Mesh const PMeshInfo& GetMeshInfo() const { return myMeshInfo;} - TInt myNbElem; - TInt GetNbElem() const { return myNbElem;} + TInt myNbElem; // TNodeCoord; - - struct TNodeInfo: virtual TElemInfo + typedef TVector TFloatVector; + typedef TSlice TFloatVecSlice; + typedef TCSlice TCFloatVecSlice; + + typedef TFloatVector TNodeCoord; + typedef TFloatVecSlice TCoordSlice; + typedef TCFloatVecSlice TCCoordSlice; + + //! Define a base class which represents MED Nodes entity + struct TNodeInfo: + virtual TElemInfo, + virtual TModeSwitchInfo { - TNodeCoord myCoord; - TFloat GetNodeCoord(TInt theId, TInt theComp) const; - void SetNodeCoord(TInt theId, TInt theComp, TFloat theVal); + TNodeCoord myCoord; //!< Contains all nodal coordinates - ERepere mySystem; + //! 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; + 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; + 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 SliceArray TConnSlice; - typedef ConstSliceArray TConstConnSlice; + typedef TIntVecSlice TConnSlice; + typedef TCIntVecSlice TCConnSlice; - struct TCellInfo: virtual TElemInfo + //! Define a base class which represents MED Cells entity + struct TCellInfo: + virtual TElemInfo, + virtual TModeSwitchInfo { - EEntiteMaillage myTEntity; - EEntiteMaillage GetEntity() const { return myTEntity;} + 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 myTGeom; - EGeometrieElement GetGeom() const { return myTGeom;} + 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 myTConn; - EConnectivite GetConn() const { return myTConn;} + EConnectivite myConnMode; //!< Defines connectivity mode + //! Let known in what connectivity the cells are writen + EConnectivite GetConnMode() const { return myConnMode;} - virtual TInt GetConnDim() const = 0; + virtual TInt GetConnDim() const = 0; //!< Gives step in the connectivity sequence - TElemNum myConn; - TConstConnSlice GetConnSlice(TInt theElemId) const; - TConnSlice GetConnSlice(TInt theElemId); + TElemNum myConn; //!< Defines sequence which describe connectivity for ech of mesh cell - TInt GetConn(TInt theElemId, TInt theConnId) const; - void SetConn(TInt theElemId, TInt theConnId, TInt theVal); + //! 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); }; //--------------------------------------------------------------- - struct TPolygoneInfo: virtual TElemInfo + //! Define a base class which represents MED Polygon entity + struct TPolygoneInfo: + virtual TElemInfo { - EEntiteMaillage myTEntity; // MED_FACE|MED_MAILLE - EEntiteMaillage GetEntity() const { return myTEntity;} + //! 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;} - EGeometrieElement myTGeom; // ePOLYGONE + //! 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;} - EConnectivite myTConn; // eNOD|eDESC(eDESC not used) - EConnectivite GetConn() const { return myTConn;} - - TInt myConnDim; - TInt GetConnDim() const { return myConnDim;} + //! Defines connectivity mode + EConnectivite myConnMode; // eNOD|eDESC(eDESC not used) + //! Let known in what connectivity the cells are writen + EConnectivite GetConnMode() const { return myConnMode;} - TElemNum myConn; // Table de connectivities - TElemNum GetConnectivite() const { return myConn;} + TElemNum myConn; //!< Table de connectivities + TElemNum myIndex; //!< Table de indexes - TElemNum myIndex; // Table de indexes - TElemNum GetIndex() {return myIndex;} + //! 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); }; //--------------------------------------------------------------- - struct TPolyedreInfo: virtual TElemInfo + typedef TVector TCConnSliceArr; + typedef TVector TConnSliceArr; + + //! Define a base class which represents MED Polyedre entity + struct TPolyedreInfo: + virtual TElemInfo { - EEntiteMaillage myTEntity; // MED_FACE|MED_MAILLE - EEntiteMaillage GetEntity() const { return myTEntity;} + //! 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;} - EGeometrieElement myTGeom; // ePOLYEDRE + //! 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;} - EConnectivite myTConn; // eNOD|eDESC(eDESC not used) - EConnectivite GetConn() const { return myTConn;} + //! Defines connectivity mode + EConnectivite myConnMode; // eNOD|eDESC(eDESC not used) + //! Let known in what connectivity the cells are writen + EConnectivite GetConnMode() const { return myConnMode;} - TInt myNbConn; - TInt GetNbConn() const { return myNbConn;} + TElemNum myConn; //!< Table de connectivities + TElemNum myFaces; //!< Table de faces indexes + TElemNum myIndex; //!< Table de indexes - TElemNum myConn; // Table de connectivities - TElemNum GetConnectivite() const { return myConn;} - - TInt myNbFacesIndex; - TInt GetNbFacesIndex() const { return myNbFacesIndex;} - - TElemNum myFacesIndex; // Table de faces indexes - TElemNum GetFacesIndex() {return myFacesIndex;} - - TElemNum myIndex; // Table de indexes - TElemNum GetIndex() {return myIndex;} - TInt GetNbConn(TInt theElemId) const; + //! 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); }; //--------------------------------------------------------------- - struct TFieldInfo: virtual TNameInfo + //! Define a base class which represents MED Field entity + struct TFieldInfo: + virtual TNameInfo { - PMeshInfo myMeshInfo; + PMeshInfo myMeshInfo; //!< A reference to correspondig MED Mesh + //! Get a reference to corresponding MED Mesh const PMeshInfo& GetMeshInfo() const { return myMeshInfo;} - ETypeChamp myType; + 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; + 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; + 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; + 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; + 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; + 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; }; //--------------------------------------------------------------- - struct TTimeStampInfo: virtual TBase + //! Get dimension of the Gauss coordinates for the defined type of mesh cell + TInt + GetDimGaussCoord(EGeometrieElement theGeom); + + //! Get number of referenced nodes for the defined type of mesh cell + TInt + GetNbRefCoord(EGeometrieElement theGeom); + + typedef TFloatVector TWeight; + + //! The class represents MED Gauss entity + struct TGaussInfo: + virtual TNameInfo, + virtual TModeSwitchInfo + { + typedef boost::tuple TKey; + typedef boost::tuple TInfo; + struct 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 myGaussCoord.size()/GetDim();} + }; + + + //--------------------------------------------------------------- + typedef std::map TGeom2Gauss; + typedef std::map TGeom2NbGauss; + + //! Define a base class which represents MED TimeStamp + struct TTimeStampInfo: + virtual TBase { - PFieldInfo myFieldInfo; + 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;} - TGeom myGeom; - const TGeom& GetGeom() const { return myGeom;} + //! 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 myNbGauss, myNumDt, myNumOrd; - TInt GetNbGauss() const { return myNbGauss;} - TInt GetNumDt() const { return myNumDt;} - TInt GetNumOrd() const { return myNumOrd;} + TInt myNumDt; //!< Keeps number in time for the MED TimeStamp + TInt GetNumDt() const { return myNumDt;} //!< Defines number in time for the MED TimeStamp - TFloat myDt; - TFloat GetDt() const { return myDt;} + TInt myNumOrd; //!< Keeps number for the MED TimeStamp + TInt GetNumOrd() const { return myNumOrd;} //!< Defines number for the MED TimeStamp - TString myGaussName; - virtual std::string GetGaussName() const = 0; - virtual void SetGaussName(const std::string& theValue) = 0; + TFloat myDt; //!< Keeps time for the MED TimeStamp + TFloat GetDt() const { return myDt;} //!< Defines time for the MED TimeStamp - TString myUnitDt; + //! 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; }; //--------------------------------------------------------------- - typedef std::vector TValue; - typedef std::map TMeshValue; + //! The class represents MED Profile entity + struct 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;} + + TElemNum 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 myElemNum.size();} + }; + + + //--------------------------------------------------------------- + typedef TFloatVector TValue; + typedef TSlice TValueSlice; + typedef TCSlice TCValueSlice; + + typedef TVector TCValueSliceArr; + typedef TVector TValueSliceArr; - struct TTimeStampVal: virtual TBase + //! The class is a helper one. It provide safe and flexible way to get access to values for a MED TimeStamp + struct TMeshValue: + virtual TModeSwitchInfo { - PTimeStampInfo myTimeStampInfo; + TValue myValue; + + TInt myNbElem; + TInt myNbComp; + TInt myNbGauss; + TInt myStep; + + //! Initialize the class + void + Init(TInt theNbElem, + TInt theNbGauss, + TInt theNbComp, + EModeSwitch theMode = eFULL_INTERLACE); + + //! Iteration through Gauss Points by their components + TCValueSliceArr + GetGaussValueSliceArr(TInt theElemId) const; + + //! Iteration through Gauss Points by their components + TValueSliceArr + GetGaussValueSliceArr(TInt theElemId); + + //! Iteration through components by corresponding Gauss Points + TCValueSliceArr + GetCompValueSliceArr(TInt theElemId) const; + + //! Iteration through components by corresponding Gauss Points + TValueSliceArr + GetCompValueSliceArr(TInt theElemId); + }; + + + //--------------------------------------------------------------- + typedef std::map TGeom2Value; + typedef std::map TGeom2Profile; + + //! The class implements a container for MED TimeStamp values + struct TTimeStampVal: + virtual TModeSwitchInfo + { + PTimeStampInfo myTimeStampInfo; //!< A reference to correspondig MED TimeStamp + //!< Get a reference to correspondig MED TimeStamp const PTimeStampInfo& GetTimeStampInfo() const { return myTimeStampInfo;} - TMeshValue myMeshValue; - TFloat GetVal(EGeometrieElement theGeom, TInt theId, - TInt theComp, TInt theGauss = 0) const; + //! 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;} + + TGeom2Value myGeom2Value; - void SetVal(EGeometrieElement theGeom, TInt theId, - TInt theComp, TFloat theVal, TInt theGauss = 0); - EModeProfil myPflMode; - EModeProfil GetPflMode() const { return myPflMode;} - void GetPflMode(EModeProfil theVal) { myPflMode = theVal;} + //! Keeps map of MED TimeStamp values per geometric type (const version) + const TMeshValue& GetMeshValue(EGeometrieElement theGeom) const; - TString myPflName; - virtual std::string GetPflName() const = 0; - virtual void SetPflName(const std::string& theValue) = 0; + //! Keeps map of MED TimeStamp values per geometric type + TMeshValue& GetMeshValue(EGeometrieElement theGeom); }; } diff --git a/src/MEDWrapper/Base/MED_TStructures.hxx b/src/MEDWrapper/Base/MED_TStructures.hxx index ed9d00d69..71be52285 100644 --- a/src/MEDWrapper/Base/MED_TStructures.hxx +++ b/src/MEDWrapper/Base/MED_TStructures.hxx @@ -31,40 +31,41 @@ #include "MED_Structures.hxx" -namespace MED{ - - const TInt DESC = 200; - const TInt IDENT = 8; - const TInt NOM = 32; - const TInt LNOM = 80; - +namespace MED +{ //--------------------------------------------------------------- - template + template struct TTNameInfo: virtual TNameInfo { - TTNameInfo(const std::string& theValue = "") + TTNameInfo(const std::string& theValue) { - myName.resize(nNOM+1); + myName.resize(GetNOMLength()+1); SetName(theValue); } - virtual std::string GetName() const { - return GetString(0,nNOM,myName); + virtual + std::string + GetName() const + { + return GetString(0,GetNOMLength(),myName); } - virtual void SetName(const std::string& theValue){ - SetString(0,nNOM,myName,theValue); + virtual + void + SetName(const std::string& theValue) + { + SetString(0,GetNOMLength(),myName,theValue); } }; //--------------------------------------------------------------- - template + template struct TTMeshInfo: virtual TMeshInfo, - virtual TTNameInfo + virtual TTNameInfo { - typedef TTNameInfo TNameInfoBase; + typedef TTNameInfo TNameInfoBase; TTMeshInfo(const PMeshInfo& theInfo): TNameInfoBase(theInfo->GetName()) @@ -72,40 +73,46 @@ namespace MED{ myDim = theInfo->GetDim(); myType = theInfo->GetType(); - myDesc.resize(nDESC+1); + myDesc.resize(GetDESCLength()+1); SetDesc(theInfo->GetDesc()); } - TTMeshInfo(TInt theDim = 0, - const std::string& theValue = "", - EMaillage theType = eNON_STRUCTURE, - const std::string& theDesc = ""): + TTMeshInfo(TInt theDim, + const std::string& theValue, + EMaillage theType, + const std::string& theDesc): TNameInfoBase(theValue) { myDim = theDim; myType = theType; - myDesc.resize(nDESC+1); + myDesc.resize(GetDESCLength()+1); SetDesc(theDesc); } - virtual std::string GetDesc() const { - return GetString(0,nDESC,myDesc); + virtual + std::string + GetDesc() const + { + return GetString(0,GetDESCLength(),myDesc); } - virtual void SetDesc(const std::string& theValue){ - SetString(0,nDESC,myDesc,theValue); + virtual + void + SetDesc(const std::string& theValue) + { + SetString(0,GetDESCLength(),myDesc,theValue); } }; //--------------------------------------------------------------- - template + template struct TTFamilyInfo: virtual TFamilyInfo, - virtual TTNameInfo + virtual TTNameInfo { - typedef TTNameInfo TNameInfoBase; + typedef TTNameInfo TNameInfoBase; TTFamilyInfo(const PMeshInfo& theMeshInfo, const PFamilyInfo& theInfo): TNameInfoBase(theInfo->GetName()) @@ -115,7 +122,7 @@ namespace MED{ myId = theInfo->GetId(); myNbGroup = theInfo->GetNbGroup(); - myGroupNames.resize(myNbGroup*nLNOM+1); + myGroupNames.resize(myNbGroup*GetLNOMLength()+1); if(myNbGroup){ for(TInt anId = 0; anId < myNbGroup; anId++){ SetGroupName(anId,theInfo->GetGroupName(anId)); @@ -125,7 +132,7 @@ namespace MED{ myNbAttr = theInfo->GetNbAttr(); myAttrId.resize(myNbAttr); myAttrVal.resize(myNbAttr); - myAttrDesc.resize(myNbAttr*nDESC+1); + myAttrDesc.resize(myNbAttr*GetDESCLength()+1); if(myNbAttr){ for(TInt anId = 0; anId < myNbAttr; anId++){ SetAttrDesc(anId,theInfo->GetAttrDesc(anId)); @@ -136,10 +143,10 @@ namespace MED{ } TTFamilyInfo(const PMeshInfo& theMeshInfo, - TInt theNbGroup = 0, - TInt theNbAttr = 0, - TInt theId = 0, - const std::string& theValue = ""): + TInt theNbGroup, + TInt theNbAttr, + TInt theId, + const std::string& theValue): TNameInfoBase(theValue) { myMeshInfo = theMeshInfo; @@ -147,21 +154,21 @@ namespace MED{ myId = theId; myNbGroup = theNbGroup; - myGroupNames.resize(theNbGroup*nLNOM+1); + myGroupNames.resize(theNbGroup*GetLNOMLength()+1); myNbAttr = theNbAttr; myAttrId.resize(theNbAttr); myAttrVal.resize(theNbAttr); - myAttrDesc.resize(theNbAttr*nDESC+1); + myAttrDesc.resize(theNbAttr*GetDESCLength()+1); } TTFamilyInfo(const PMeshInfo& theMeshInfo, const std::string& theValue, TInt theId, const TStringSet& theGroupNames, - const TStringVector& theAttrDescs = TStringVector(), - const TIntVector& theAttrIds = TIntVector(), - const TIntVector& theAttrVals = TIntVector()): + const TStringVector& theAttrDescs, + const TIntVector& theAttrIds, + const TIntVector& theAttrVals): TNameInfoBase(theValue) { myMeshInfo = theMeshInfo; @@ -169,7 +176,7 @@ namespace MED{ myId = theId; myNbGroup = theGroupNames.size(); - myGroupNames.resize(myNbGroup*nLNOM+1); + myGroupNames.resize(myNbGroup*GetLNOMLength()+1); if(myNbGroup){ TStringSet::const_iterator anIter = theGroupNames.begin(); for(TInt anId = 0; anIter != theGroupNames.end(); anIter++, anId++){ @@ -181,7 +188,7 @@ namespace MED{ myNbAttr = theAttrDescs.size(); myAttrId.resize(myNbAttr); myAttrVal.resize(myNbAttr); - myAttrDesc.resize(myNbAttr*nDESC+1); + myAttrDesc.resize(myNbAttr*GetDESCLength()+1); if(myNbAttr){ for(TInt anId = 0, anEnd = theAttrDescs.size(); anId < anEnd; anId++){ SetAttrDesc(anId,theAttrDescs[anId]); @@ -191,26 +198,38 @@ namespace MED{ } } - virtual std::string GetGroupName(TInt theId) const { - return GetString(theId,nLNOM,myGroupNames); + virtual + std::string + GetGroupName(TInt theId) const + { + return GetString(theId,GetLNOMLength(),myGroupNames); } - virtual void SetGroupName(TInt theId, const std::string& theValue){ - SetString(theId,nLNOM,myGroupNames,theValue); + virtual + void + SetGroupName(TInt theId, const std::string& theValue) + { + SetString(theId,GetLNOMLength(),myGroupNames,theValue); } - virtual std::string GetAttrDesc(TInt theId) const { - return GetString(theId,nDESC,myAttrDesc); + virtual + std::string + GetAttrDesc(TInt theId) const + { + return GetString(theId,GetDESCLength(),myAttrDesc); } - virtual void SetAttrDesc(TInt theId, const std::string& theValue){ - SetString(theId,nDESC,myAttrDesc,theValue); + virtual + void + SetAttrDesc(TInt theId, const std::string& theValue) + { + SetString(theId,GetDESCLength(),myAttrDesc,theValue); } }; //--------------------------------------------------------------- - template + template struct TTElemInfo: virtual TElemInfo { TTElemInfo(const PMeshInfo& theMeshInfo, const PElemInfo& theInfo) @@ -224,7 +243,7 @@ namespace MED{ myElemNum.resize(myIsElemNum == eFAUX? 0: myNbElem); myIsElemNames = theInfo->IsElemNames(); - myElemNames.resize(myNbElem*nPNOM+1); + myElemNames.resize(myNbElem*GetPNOMLength()+1); if(myNbElem){ for(TInt anId = 0; anId < myNbElem; anId++){ @@ -245,8 +264,8 @@ namespace MED{ TTElemInfo(const PMeshInfo& theMeshInfo, TInt theNbElem, - EBooleen theIsElemNum = eVRAI, - EBooleen theIsElemNames = eVRAI) + EBooleen theIsElemNum, + EBooleen theIsElemNames) { myMeshInfo = theMeshInfo; @@ -254,39 +273,43 @@ namespace MED{ myFamNum.resize(theNbElem); myIsElemNum = theIsElemNum; - myElemNum.resize(theIsElemNum == eFAUX? 0: theNbElem); + if(theIsElemNum) + myElemNum.resize(theNbElem); myIsElemNames = theIsElemNames; - myElemNames.resize(theNbElem*nPNOM+1); + if(theIsElemNames) + myElemNames.resize(theNbElem*GetPNOMLength()+1); } TTElemInfo(const PMeshInfo& theMeshInfo, + TInt theNbElem, const TIntVector& theFamilyNums, const TIntVector& theElemNums, - const TStringVector& theElemNames = TStringVector()) + const TStringVector& theElemNames) { myMeshInfo = theMeshInfo; - myNbElem = theFamilyNums.size(); - myFamNum.resize(myNbElem); + myNbElem = theNbElem; myIsElemNum = theElemNums.size()? eVRAI: eFAUX; - myElemNum.resize(theElemNums.size()); + if(myIsElemNum) + myElemNum.resize(theNbElem); myIsElemNames = theElemNames.size()? eVRAI: eFAUX; - myElemNames.resize(theElemNames.size()*nPNOM+1); + if(myIsElemNames) + myElemNames.resize(theNbElem*GetPNOMLength()+1); - if(myNbElem){ - for(TInt anId = 0; anId < myNbElem; anId++){ - myFamNum[anId] = theFamilyNums[anId]; - } - if(myIsElemNum == eVRAI){ - for(TInt anId = 0; anId < myNbElem; anId++){ - myElemNum[anId] = theElemNums[anId]; - } - } - if(myIsElemNames == eVRAI){ - for(TInt anId = 0; anId < myNbElem; anId++){ + if(theNbElem){ + + myFamNum.resize(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); } @@ -294,334 +317,371 @@ namespace MED{ } } - virtual std::string GetElemName(TInt theId) const { - return GetString(theId,nPNOM,myElemNames); + virtual + std::string + GetElemName(TInt theId) const + { + return GetString(theId,GetPNOMLength(),myElemNames); } - virtual void SetElemName(TInt theId, const std::string& theValue){ - SetString(theId,nPNOM,myElemNames,theValue); + virtual + void + SetElemName(TInt theId, const std::string& theValue) + { + SetString(theId,GetPNOMLength(),myElemNames,theValue); } }; //--------------------------------------------------------------- - template + template struct TTNodeInfo: virtual TNodeInfo, - virtual TTElemInfo + virtual TTElemInfo { - typedef TTElemInfo TElemInfoBase; + typedef TTElemInfo TElemInfoBase; TTNodeInfo(const PMeshInfo& theMeshInfo, const PNodeInfo& theInfo): - TElemInfoBase(theMeshInfo,theInfo) + TElemInfoBase(theMeshInfo,theInfo), + TNodeInfo(theInfo) { + myModeSwitch = theInfo->GetModeSwitch(); + mySystem = theInfo->GetSystem(); - - TInt aDim = theMeshInfo->GetDim(); - TInt aNbElem = theInfo->GetNbElem(); - myCoord.resize(aNbElem*aDim); - for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){ - for(TInt anDimId = 0; anDimId < aDim; anDimId++){ - SetNodeCoord(anElemId,anDimId,theInfo->GetNodeCoord(anElemId,anDimId)); - } - } + myCoord = theInfo->myCoord; + + TInt aDim = theMeshInfo->GetDim(); - myCoordNames.resize(aDim*nPNOM+1); - for(TInt anId = 0; anId < aDim; anId++){ + myCoordNames.resize(aDim*GetPNOMLength()+1); + for(TInt anId = 0; anId < aDim; anId++) SetCoordName(anId,theInfo->GetCoordName(anId)); - } - myCoordUnits.resize(aDim*nPNOM+1); - for(TInt anId = 0; anId < aDim; anId++){ + myCoordUnits.resize(aDim*GetPNOMLength()+1); + for(TInt anId = 0; anId < aDim; anId++) SetCoordUnit(anId,theInfo->GetCoordUnit(anId)); - } } TTNodeInfo(const PMeshInfo& theMeshInfo, TInt theNbElem, - ERepere theSystem = eCART, - EBooleen theIsElemNum = eVRAI, - EBooleen theIsElemNames = eVRAI): + EModeSwitch theMode, + ERepere theSystem, + EBooleen theIsElemNum, + EBooleen theIsElemNames): TElemInfoBase(theMeshInfo, theNbElem, theIsElemNum, - theIsElemNames) + theIsElemNames), + TModeSwitchInfo(theMode) { mySystem = theSystem; + myCoord.resize(theNbElem*theMeshInfo->myDim); - myCoordNames.resize(theMeshInfo->myDim*nPNOM+1); - myCoordUnits.resize(theMeshInfo->myDim*nPNOM+1); + + if(theIsElemNum) + myCoordUnits.resize(theMeshInfo->myDim*GetPNOMLength()+1); + + if(theIsElemNames) + myCoordNames.resize(theMeshInfo->myDim*GetPNOMLength()+1); } TTNodeInfo(const PMeshInfo& theMeshInfo, - ERepere theSystem, const TFloatVector& theNodeCoords, + EModeSwitch theMode, + ERepere theSystem, const TStringVector& theCoordNames, const TStringVector& theCoordUnits, const TIntVector& theFamilyNums, const TIntVector& theElemNums, - const TStringVector& theElemNames = TStringVector()): + const TStringVector& theElemNames): TElemInfoBase(theMeshInfo, + theNodeCoords.size()/theMeshInfo->GetDim(), theFamilyNums, theElemNums, - theElemNames) + theElemNames), + TModeSwitchInfo(theMode) { mySystem = theSystem; - myCoord.resize(theNodeCoords.size()); - - for(TInt anId = 0, anEnd = myCoord.size(); anId < anEnd; anId++){ - myCoord[anId] = theNodeCoords[anId]; - } + myCoord = theNodeCoords; + TInt aDim = theMeshInfo->GetDim(); - myCoordNames.resize(aDim*nPNOM+1); - for(TInt anId = 0; anId < aDim; anId++){ - SetCoordName(anId,theCoordNames[anId]); - } + + myCoordNames.resize(aDim*GetPNOMLength()+1); + if(!theCoordNames.empty()) + for(TInt anId = 0; anId < aDim; anId++) + SetCoordName(anId,theCoordNames[anId]); - myCoordUnits.resize(aDim*nPNOM+1); - for(TInt anId = 0; anId < aDim; anId++){ - SetCoordUnit(anId,theCoordUnits[anId]); - } + myCoordUnits.resize(aDim*GetPNOMLength()+1); + if(!theCoordUnits.empty()) + for(TInt anId = 0; anId < aDim; anId++) + SetCoordUnit(anId,theCoordUnits[anId]); } - virtual std::string GetCoordName(TInt theId) const { - return GetString(theId,nPNOM,myCoordNames); + virtual + std::string + GetCoordName(TInt theId) const + { + return GetString(theId,GetPNOMLength(),myCoordNames); } - virtual void SetCoordName(TInt theId, const std::string& theValue){ - SetString(theId,nPNOM,myCoordNames,theValue); + virtual + void + SetCoordName(TInt theId, const std::string& theValue) + { + SetString(theId,GetPNOMLength(),myCoordNames,theValue); } - virtual std::string GetCoordUnit(TInt theId) const { - return GetString(theId,nPNOM,myCoordUnits); + virtual + std::string + GetCoordUnit(TInt theId) const + { + return GetString(theId,GetPNOMLength(),myCoordUnits); } - virtual void SetCoordUnit(TInt theId, const std::string& theValue){ - SetString(theId,nPNOM,myCoordUnits,theValue); + virtual + void + SetCoordUnit(TInt theId, const std::string& theValue) + { + SetString(theId,GetPNOMLength(),myCoordUnits,theValue); } }; //--------------------------------------------------------------- - template + template struct TTPolygoneInfo: virtual TPolygoneInfo, - virtual TTElemInfo + virtual TTElemInfo { - typedef TTElemInfo TElemInfoBase; + typedef TTElemInfo TElemInfoBase; TTPolygoneInfo(const PMeshInfo& theMeshInfo, const PPolygoneInfo& theInfo): TElemInfoBase(theMeshInfo,theInfo) { - myTEntity = theInfo->GetEntity(); - myTGeom = theInfo->GetGeom(); - myTConn = theInfo->GetConn(); - myConnDim = theInfo->GetConnDim(); - myConn = theInfo->GetConnectivite(); - myIndex = theInfo->GetIndex(); + myEntity = theInfo->GetEntity(); + myGeom = theInfo->GetGeom(); + + myIndex = theInfo->myIndex; + myConn = theInfo->myConn; + + myConnMode = theInfo->GetConnMode(); } TTPolygoneInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TInt theNbElem, - TInt theNbConn, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn = eNOD, - EBooleen theIsElemNum = eVRAI, - EBooleen theIsElemNames = eVRAI): + TInt theConnSize, + EConnectivite theConnMode, + EBooleen theIsElemNum, + EBooleen theIsElemNames): TElemInfoBase(theMeshInfo, theNbElem, theIsElemNum, theIsElemNames) { - myTEntity = theTEntity; - myTGeom = theTGeom; - myTConn = theTConn; - myConnDim = theNbConn; - myConn.resize(myConnDim); + myEntity = theEntity; + myGeom = theGeom; + myIndex.resize(theNbElem+1); + myConn.resize(theConnSize); + + myConnMode = theConnMode; } TTPolygoneInfo(const PMeshInfo& theMeshInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn, - const TIntVector& theConnectivities, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, const TIntVector& theIndexes, + const TIntVector& theConnectivities, + EConnectivite theConnMode, const TIntVector& theFamilyNums, const TIntVector& theElemNums, - const TStringVector& theElemNames = TStringVector()): + const TStringVector& theElemNames): TElemInfoBase(theMeshInfo, + theIndexes.size() - 1, theFamilyNums, theElemNums, theElemNames) { - myTEntity = theTEntity; - myTGeom = theTGeom; - myTConn = theTConn; - myConnDim = theConnectivities.size(); - myConn = theConnectivities; + myEntity = theEntity; + myGeom = theGeom; + myIndex = theIndexes; + myConn = theConnectivities; + + myConnMode = theConnMode; } }; //--------------------------------------------------------------- - template + template struct TTPolyedreInfo: virtual TPolyedreInfo, - virtual TTElemInfo + virtual TTElemInfo { - typedef TTElemInfo TElemInfoBase; + typedef TTElemInfo TElemInfoBase; TTPolyedreInfo(const PMeshInfo& theMeshInfo, const PPolyedreInfo& theInfo): TElemInfoBase(theMeshInfo,theInfo) { - myTEntity = theInfo->GetEntity(); - myTGeom = theInfo->GetGeom(); - myTConn = theInfo->GetConn(); - myNbConn = theInfo->GetNbConn(); - myNbFacesIndex = theInfo->GetNbFacesIndex(); - myConn = theInfo->GetConnectivite(); - myFacesIndex = theInfo->GetFacesIndex(); - myIndex = theInfo->GetIndex(); + myEntity = theInfo->GetEntity(); + myGeom = theInfo->GetGeom(); + + myIndex = theInfo->myIndex; + myFaces = theInfo->myFaces; + myConn = theInfo->myConn; + + myConnMode = theInfo->GetConnMode(); } TTPolyedreInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TInt theNbElem, - TInt theNbConn, - TInt theNbFacesIndex, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn = eNOD, - EBooleen theIsElemNum = eVRAI, - EBooleen theIsElemNames = eVRAI): + TInt theNbFaces, + TInt theConnSize, + EConnectivite theConnMode, + EBooleen theIsElemNum, + EBooleen theIsElemNames): TElemInfoBase(theMeshInfo, theNbElem, theIsElemNum, theIsElemNames) { - myTEntity = theTEntity; - myTGeom = theTGeom; - myTConn = theTConn; - myNbConn = theNbConn; - myNbFacesIndex = theNbFacesIndex; - myConn.resize(myNbConn); - myFacesIndex.resize(myNbFacesIndex); - myIndex.resize(theNbElem+1); + myEntity = theEntity; + myGeom = theGeom; + + myIndex.resize(theNbElem + 1); + myFaces.resize(theNbFaces); + myConn.resize(theConnSize); + + myConnMode = theConnMode; } TTPolyedreInfo(const PMeshInfo& theMeshInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn, - const TIntVector& theConnectivities, - const TIntVector& theFacesIndexes, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, const TIntVector& theIndexes, + const TIntVector& theFaces, + const TIntVector& theConnectivities, + EConnectivite theConnMode, const TIntVector& theFamilyNums, const TIntVector& theElemNums, - const TStringVector& theElemNames = TStringVector()): + const TStringVector& theElemNames): TElemInfoBase(theMeshInfo, + theIndexes.size()-1, theFamilyNums, theElemNums, theElemNames) { - myTEntity = theTEntity; - myTGeom = theTGeom; - myTConn = theTConn; - myNbConn = theConnectivities.size(); - myNbFacesIndex = theFacesIndexes.size(); - myConn = theConnectivities; - myFacesIndex = theFacesIndexes; + myEntity = theEntity; + myGeom = theGeom; + myIndex = theIndexes; + myFaces = theFaces; + myConn = theConnectivities; + + myConnMode = theConnMode; } }; //--------------------------------------------------------------- - template + template struct TTCellInfo: virtual TCellInfo, - virtual TTElemInfo + virtual TTElemInfo { - typedef TTElemInfo TElemInfoBase; + typedef TTElemInfo TElemInfoBase; TTCellInfo(const PMeshInfo& theMeshInfo, const PCellInfo& theInfo): TElemInfoBase(theMeshInfo,theInfo) { - myTEntity = theInfo->GetEntity(); - myTGeom = theInfo->GetGeom(); - myTConn = theInfo->GetConn(); + myEntity = theInfo->GetEntity(); + myGeom = theInfo->GetGeom(); + myConnMode = theInfo->GetConnMode(); - TInt aConnDim = GetNbNodes(myTGeom); - myConn.resize(myNbElem*GetNbConn(myTGeom,myTEntity,myMeshInfo->myDim)); + TInt aConnDim = GetNbNodes(myGeom); + myConn.resize(myNbElem*GetNbConn(myGeom,myEntity,myMeshInfo->myDim)); for(TInt anElemId = 0; anElemId < myNbElem; anElemId++){ + TConnSlice aConnSlice = GetConnSlice(anElemId); + TCConnSlice aConnSlice2 = theInfo->GetConnSlice(anElemId); for(TInt anConnId = 0; anConnId < aConnDim; anConnId++){ - SetConn(anElemId,anConnId,theInfo->GetConn(anElemId,anConnId)); + aConnSlice[anConnId] = aConnSlice2[anConnId]; } } } TTCellInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TInt theNbElem, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn = eNOD, - EBooleen theIsElemNum = eVRAI, - EBooleen theIsElemNames = eVRAI): + EConnectivite theConnMode, + EBooleen theIsElemNum, + EBooleen theIsElemNames, + EModeSwitch theMode): TElemInfoBase(theMeshInfo, theNbElem, theIsElemNum, - theIsElemNames) + theIsElemNames), + TModeSwitchInfo(theMode) { - myTEntity = theTEntity; - myTGeom = theTGeom; - myTConn = theTConn; - myConn.resize(theNbElem*GetNbConn(theTGeom,myTEntity,theMeshInfo->myDim)); + myEntity = theEntity; + myGeom = theGeom; + + myConnMode = theConnMode; + myConn.resize(theNbElem*GetNbConn(theGeom,myEntity,theMeshInfo->myDim)); } TTCellInfo(const PMeshInfo& theMeshInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, const TIntVector& theConnectivities, + EConnectivite theConnMode, const TIntVector& theFamilyNums, const TIntVector& theElemNums, - const TStringVector& theElemNames = TStringVector()): + const TStringVector& theElemNames, + EModeSwitch theMode): TElemInfoBase(theMeshInfo, + theConnectivities.size()/GetNbNodes(theGeom), theFamilyNums, theElemNums, - theElemNames) + theElemNames), + TModeSwitchInfo(theMode) { - myTEntity = theTEntity; - myTGeom = theTGeom; - myTConn = theTConn; + myEntity = theEntity; + myGeom = theGeom; - TInt aConnDim = GetNbNodes(myTGeom); - myNbElem = theConnectivities.size() / aConnDim; - myConn.resize(myNbElem*GetNbConn(myTGeom,myTEntity,myMeshInfo->myDim)); + myConnMode = theConnMode; + TInt aConnDim = GetNbNodes(myGeom); + myConn.resize(myNbElem*GetNbConn(myGeom,myEntity,myMeshInfo->myDim)); for(TInt anElemId = 0; anElemId < myNbElem; anElemId++){ + TConnSlice aConnSlice = GetConnSlice(anElemId); for(TInt anConnId = 0; anConnId < aConnDim; anConnId++){ - SetConn(anElemId,anConnId,theConnectivities[anElemId*aConnDim+anConnId]); + aConnSlice[anConnId] = theConnectivities[anElemId*aConnDim+anConnId]; } } } - virtual TInt GetConnDim() const { - return GetNbConn(myTGeom,myTEntity,myMeshInfo->myDim); + virtual + TInt + GetConnDim() const + { + return GetNbConn(myGeom,myEntity,myMeshInfo->myDim); } }; //--------------------------------------------------------------- - template + template struct TTFieldInfo: virtual TFieldInfo, - virtual TTNameInfo + virtual TTNameInfo { - typedef TTNameInfo TNameInfoBase; + typedef TTNameInfo TNameInfoBase; TTFieldInfo(const PMeshInfo& theMeshInfo, const PFieldInfo& theInfo): TNameInfoBase(theInfo->GetName()) @@ -629,12 +689,12 @@ namespace MED{ myMeshInfo = theMeshInfo; myNbComp = theInfo->GetNbComp(); - myCompNames.resize(myNbComp*nPNOM+1); + myCompNames.resize(myNbComp*GetPNOMLength()+1); for(TInt anId = 0; anId < myNbComp; anId++){ SetCompName(anId,theInfo->GetCompName(anId)); } - myUnitNames.resize(myNbComp*nPNOM+1); + myUnitNames.resize(myNbComp*GetPNOMLength()+1); for(TInt anId = 0; anId < myNbComp; anId++){ SetUnitName(anId,theInfo->GetUnitName(anId)); } @@ -646,18 +706,18 @@ namespace MED{ } TTFieldInfo(const PMeshInfo& theMeshInfo, - TInt theNbComp = 0, - ETypeChamp theType = eFLOAT64, - const std::string& theValue = "", - EBooleen theIsLocal = eVRAI, - TInt theNbRef = 1): + TInt theNbComp, + ETypeChamp theType, + const std::string& theValue, + EBooleen theIsLocal, + TInt theNbRef): TNameInfoBase(theValue) { myMeshInfo = theMeshInfo; myNbComp = theNbComp; - myCompNames.resize(theNbComp*nPNOM+1); - myUnitNames.resize(theNbComp*nPNOM+1); + myCompNames.resize(theNbComp*GetPNOMLength()+1); + myUnitNames.resize(theNbComp*GetPNOMLength()+1); myType = theType; @@ -665,26 +725,63 @@ namespace MED{ myNbRef = theNbRef; } - virtual std::string GetCompName(TInt theId) const { - return GetString(theId,nPNOM,myCompNames); + 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 void SetCompName(TInt theId, const std::string& theValue){ - SetString(theId,nPNOM,myCompNames,theValue); + virtual + std::string + GetUnitName(TInt theId) const + { + return GetString(theId,GetPNOMLength(),myUnitNames); } - virtual std::string GetUnitName(TInt theId) const { - return GetString(theId,nPNOM,myUnitNames); + virtual + void + SetUnitName(TInt theId, const std::string& theValue) + { + SetString(theId,GetPNOMLength(),myUnitNames,theValue); } + }; + - virtual void SetUnitName(TInt theId, const std::string& theValue){ - SetString(theId,nPNOM,myUnitNames,theValue); + //--------------------------------------------------------------- + template + struct TTGaussInfo: + virtual TGaussInfo, + virtual TTNameInfo + { + typedef TTNameInfo TNameInfoBase; + + TTGaussInfo(const TGaussInfo::TInfo& theInfo, + EModeSwitch theMode): + TNameInfoBase(boost::get<1>(boost::get<0>(theInfo))), + TModeSwitchInfo(theMode) + { + 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 + template struct TTTimeStampInfo: virtual TTimeStampInfo { TTTimeStampInfo(const PFieldInfo& theFieldInfo, const PTimeStampInfo& theInfo) @@ -692,126 +789,124 @@ namespace MED{ myFieldInfo = theFieldInfo; myEntity = theInfo->GetEntity(); - myGeom = theInfo->GetGeom(); + myGeom2Size = theInfo->GetGeom2Size(); - myNbGauss = theInfo->GetNbGauss(); myNumDt = theInfo->GetNumDt(); myNumOrd = theInfo->GetNumOrd(); myDt = theInfo->GetDt(); - myUnitDt.resize(nPNOM+1); + myUnitDt.resize(GetPNOMLength()+1); SetUnitDt(theInfo->GetUnitDt()); - myGaussName.resize(nNOM+1); - SetGaussName(theInfo->GetGaussName()); + myGeom2NbGauss = theInfo->myGeom2NbGauss; + myGeom2Gauss = theInfo->GetGeom2Gauss(); } TTTimeStampInfo(const PFieldInfo& theFieldInfo, EEntiteMaillage theEntity, - const TGeom& theGeom, - TInt theNbGauss = 0, - TInt theNumDt = 0, - TInt theNumOrd = 0, - TFloat theDt = 0, - const std::string& theUnitDt = "", - const std::string& theGaussName = "") + const TGeom2Size& theGeom2Size, + const TGeom2NbGauss& theGeom2NbGauss, + TInt theNumDt, + TInt theNumOrd, + TFloat theDt, + const std::string& theUnitDt, + const TGeom2Gauss& theGeom2Gauss) { myFieldInfo = theFieldInfo; myEntity = theEntity; - myGeom = theGeom; + myGeom2Size = theGeom2Size; - myNbGauss = theNbGauss; myNumDt = theNumDt; myNumOrd = theNumDt; myDt = theDt; - myUnitDt.resize(nPNOM+1); + myUnitDt.resize(GetPNOMLength()+1); SetUnitDt(theUnitDt); - myGaussName.resize(nNOM+1); - SetGaussName(theGaussName); + myGeom2NbGauss = theGeom2NbGauss; + myGeom2Gauss = theGeom2Gauss; } - virtual std::string GetGaussName() const { - return GetString(0,nNOM,myGaussName); + virtual + std::string + GetUnitDt() const + { + return GetString(0,GetPNOMLength(),myUnitDt); } - virtual void SetGaussName(const std::string& theValue){ - SetString(0,nNOM,myGaussName,theValue); + virtual + void + SetUnitDt(const std::string& theValue) + { + SetString(0,GetPNOMLength(),myUnitDt,theValue); } + }; - virtual std::string GetUnitDt() const { - return GetString(0,nPNOM,myUnitDt); - } - virtual void SetUnitDt(const std::string& theValue){ - SetString(0,nPNOM,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.resize(aSize); + myMode = aSize > 0? theMode: eNO_PFLMOD; } }; //--------------------------------------------------------------- - template + template struct TTTimeStampVal: virtual TTimeStampVal { - TTTimeStampVal(const PTimeStampInfo& theTimeStampInfo, const PTimeStampVal& theInfo) + TTTimeStampVal(const PTimeStampInfo& theTimeStampInfo, + const PTimeStampVal& theInfo) { myTimeStampInfo = theTimeStampInfo; - myPflMode = theInfo->GetPflMode(); + myGeom2Profile = theInfo->GetGeom2Profile(); - myPflName.resize(nNOM+1); - SetPflName(theInfo->GetPflName()); - - TInt aNbComp = theTimeStampInfo->GetFieldInfo()->GetNbComp(); - const TGeom& aTGeom = theTimeStampInfo->GetGeom(); - TInt aNbGauss = theTimeStampInfo->GetNbGauss(); - TGeom::const_iterator anIter = aTGeom.begin(); - for(; anIter != aTGeom.end(); anIter++){ - const EGeometrieElement& aGeom = anIter->first; - TInt aNbElem = anIter->second; - TInt aSize = aNbElem*aNbComp*aNbGauss; - TValue& aValue = myMeshValue[aGeom]; - aValue.resize(aSize); - for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){ - for(TInt aCompId = 0; aCompId < aNbComp; aCompId++){ - for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){ - SetVal(aGeom,anElemId,aCompId,theInfo->GetVal(aGeom,anElemId,aCompId,aGaussId),aGaussId); - } - } - } - } + myGeom2Value = theInfo->myGeom2Value; } TTTimeStampVal(const PTimeStampInfo& theTimeStampInfo, - const std::string& thePflName = "", - EModeProfil thePflMode = eCOMPACT) + const TGeom2Profile& theGeom2Profile, + EModeSwitch theMode): + TModeSwitchInfo(theMode) { myTimeStampInfo = theTimeStampInfo; - myPflMode = thePflMode; - - myPflName.resize(nNOM+1); - SetPflName(thePflName); + myGeom2Profile = theGeom2Profile; TInt aNbComp = theTimeStampInfo->myFieldInfo->myNbComp; - TInt aNbGauss = theTimeStampInfo->myNbGauss; - const TGeom& aTGeom = theTimeStampInfo->myGeom; - TGeom::const_iterator anIter = aTGeom.begin(); - for(; anIter != aTGeom.end(); anIter++){ + + const TGeom2Size& aGeom2Size = theTimeStampInfo->myGeom2Size; + TGeom2Size::const_iterator anIter = aGeom2Size.begin(); + for(; anIter != aGeom2Size.end(); anIter++){ const EGeometrieElement& aGeom = anIter->first; - TInt aNb = anIter->second*aNbComp*aNbGauss; - myMeshValue[aGeom].resize(aNb); - } - } + TInt aNbElem = anIter->second; - virtual std::string GetPflName() const { - return GetString(0,nNOM,myPflName); - } - - virtual void SetPflName(const std::string& theValue){ - SetString(0,nNOM,myPflName,theValue); + 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); + + TMeshValue& aMeshValue = GetMeshValue(aGeom); + aMeshValue.Init(aNbElem,aNbGauss,aNbComp); + } } }; diff --git a/src/MEDWrapper/Base/MED_TWrapper.hxx b/src/MEDWrapper/Base/MED_TWrapper.hxx index e07ae30f8..3faa314c7 100644 --- a/src/MEDWrapper/Base/MED_TWrapper.hxx +++ b/src/MEDWrapper/Base/MED_TWrapper.hxx @@ -32,10 +32,12 @@ #include "MED_TStructures.hxx" #include "MED_Wrapper.hxx" -namespace MED{ +namespace MED +{ - template - class TTWrapper: public TWrapper{ + template + class TTWrapper: public TWrapper + { public: //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ virtual @@ -45,7 +47,7 @@ namespace MED{ EMaillage theType = eNON_STRUCTURE, const std::string& theDesc = "") { - return PMeshInfo(new TTMeshInfo + return PMeshInfo(new TTMeshInfo (theDim, theValue, theType, @@ -56,7 +58,7 @@ namespace MED{ PMeshInfo CrMeshInfo(const PMeshInfo& theInfo) { - return PMeshInfo(new TTMeshInfo(theInfo)); + return PMeshInfo(new TTMeshInfo(theInfo)); } @@ -69,7 +71,7 @@ namespace MED{ TInt theId = 0, const std::string& theValue = "") { - return PFamilyInfo(new TTFamilyInfo + return PFamilyInfo(new TTFamilyInfo (theMeshInfo, theNbGroup, theNbAttr, @@ -87,7 +89,7 @@ namespace MED{ const MED::TIntVector& theAttrIds = MED::TIntVector(), const MED::TIntVector& theAttrVals = MED::TIntVector()) { - return PFamilyInfo(new TTFamilyInfo + return PFamilyInfo(new TTFamilyInfo (theMeshInfo, theValue, theId, @@ -102,7 +104,7 @@ namespace MED{ CrFamilyInfo(const PMeshInfo& theMeshInfo, const PFamilyInfo& theInfo) { - return PFamilyInfo(new TTFamilyInfo + return PFamilyInfo(new TTFamilyInfo (theMeshInfo, theInfo)); } @@ -113,13 +115,15 @@ namespace MED{ PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo, TInt theNbElem, + EModeSwitch theMode = eFULL_INTERLACE, ERepere theSystem = eCART, EBooleen theIsElemNum = eVRAI, EBooleen theIsElemNames = eVRAI) { - return PNodeInfo(new TTNodeInfo + return PNodeInfo(new TTNodeInfo (theMeshInfo, theNbElem, + theMode, theSystem, theIsElemNum, theIsElemNames)); @@ -128,18 +132,20 @@ namespace MED{ virtual PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo, - ERepere theSystem, const TFloatVector& theNodeCoords, - const TStringVector& theCoordNames, - const TStringVector& theCoordUnits, - const TIntVector& theFamilyNums, - const TIntVector& theElemNums, + 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 + return PNodeInfo(new TTNodeInfo (theMeshInfo, - theSystem, theNodeCoords, + theMode, + theSystem, theCoordNames, theCoordUnits, theFamilyNums, @@ -152,7 +158,7 @@ namespace MED{ CrNodeInfo(const PMeshInfo& theMeshInfo, const PNodeInfo& theInfo) { - return PNodeInfo(new TTNodeInfo + return PNodeInfo(new TTNodeInfo (theMeshInfo, theInfo)); } @@ -161,21 +167,21 @@ namespace MED{ virtual PPolygoneInfo CrPolygoneInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TInt theNbElem, - TInt theNbConn, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn = eNOD, + TInt theConnSize, + EConnectivite theConnMode = eNOD, EBooleen theIsElemNum = eVRAI, EBooleen theIsElemNames = eVRAI) { - return PPolygoneInfo(new TTPolygoneInfo + return PPolygoneInfo(new TTPolygoneInfo (theMeshInfo, + theEntity, + theGeom, theNbElem, - theNbConn, - theTEntity, - theTGeom, - theTConn, + theConnSize, + theConnMode, theIsElemNum, theIsElemNames)); } @@ -183,22 +189,22 @@ namespace MED{ virtual PPolygoneInfo CrPolygoneInfo(const PMeshInfo& theMeshInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn, - const TIntVector& theConnectivities, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, const TIntVector& theIndexes, - const TIntVector& theFamilyNums, - const TIntVector& theElemNums, + const TIntVector& theConnectivities, + EConnectivite theConnMode = eNOD, + const TIntVector& theFamilyNums = TIntVector(), + const TIntVector& theElemNums = TIntVector(), const TStringVector& theElemNames = TStringVector()) { - return PPolygoneInfo(new TTPolygoneInfo + return PPolygoneInfo(new TTPolygoneInfo (theMeshInfo, - theTEntity, - theTGeom, - theTConn, - theConnectivities, + theEntity, + theGeom, theIndexes, + theConnectivities, + theConnMode, theFamilyNums, theElemNums, theElemNames)); @@ -209,7 +215,7 @@ namespace MED{ CrPolygoneInfo(const PMeshInfo& theMeshInfo, const PPolygoneInfo& theInfo) { - return PPolygoneInfo(new TTPolygoneInfo + return PPolygoneInfo(new TTPolygoneInfo (theMeshInfo, theInfo)); } @@ -218,23 +224,23 @@ namespace MED{ virtual PPolyedreInfo CrPolyedreInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TInt theNbElem, - TInt theNbConn, TInt theNbFaces, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn = eNOD, + TInt theConnSize, + EConnectivite theConnMode = eNOD, EBooleen theIsElemNum = eVRAI, EBooleen theIsElemNames = eVRAI) { - return PPolyedreInfo(new TTPolyedreInfo + return PPolyedreInfo(new TTPolyedreInfo (theMeshInfo, + theEntity, + theGeom, theNbElem, - theNbConn, theNbFaces, - theTEntity, - theTGeom, - theTConn, + theConnSize, + theConnMode, theIsElemNum, theIsElemNames)); } @@ -242,24 +248,24 @@ namespace MED{ virtual PPolyedreInfo CrPolyedreInfo(const PMeshInfo& theMeshInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn, - const TIntVector& theConnectivities, - const TIntVector& theFacesIndexes, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, const TIntVector& theIndexes, - const TIntVector& theFamilyNums, - const TIntVector& theElemNums, + 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 + return PPolyedreInfo(new TTPolyedreInfo (theMeshInfo, - theTEntity, - theTGeom, - theTConn, - theConnectivities, - theFacesIndexes, + theEntity, + theGeom, theIndexes, + theFaces, + theConnectivities, + theConnMode, theFamilyNums, theElemNums, theElemNames)); @@ -270,7 +276,7 @@ namespace MED{ CrPolyedreInfo(const PMeshInfo& theMeshInfo, const PPolyedreInfo& theInfo) { - return PPolyedreInfo(new TTPolyedreInfo + return PPolyedreInfo(new TTPolyedreInfo (theMeshInfo, theInfo)); } @@ -279,43 +285,47 @@ namespace MED{ virtual PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TInt theNbElem, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn = eNOD, + EConnectivite theConnMode = eNOD, EBooleen theIsElemNum = eVRAI, - EBooleen theIsElemNames = eVRAI) + EBooleen theIsElemNames = eVRAI, + EModeSwitch theMode = eFULL_INTERLACE) { - return PCellInfo(new TTCellInfo + return PCellInfo(new TTCellInfo (theMeshInfo, + theEntity, + theGeom, theNbElem, - theTEntity, - theTGeom, - theTConn, + theConnMode, theIsElemNum, - theIsElemNames)); + theIsElemNames, + theMode)); } virtual PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, const TIntVector& theConnectivities, - const TIntVector& theFamilyNums, - const TIntVector& theElemNums, - const TStringVector& theElemNames = TStringVector()) + EConnectivite theConnMode = eNOD, + const TIntVector& theFamilyNums = TIntVector(), + const TIntVector& theElemNums = TIntVector(), + const TStringVector& theElemNames = TStringVector(), + EModeSwitch theMode = eFULL_INTERLACE) { - return PCellInfo(new TTCellInfo + return PCellInfo(new TTCellInfo (theMeshInfo, - theTEntity, - theTGeom, - theTConn, + theEntity, + theGeom, theConnectivities, + theConnMode, theFamilyNums, theElemNums, - theElemNames)); + theElemNames, + theMode)); } virtual @@ -323,7 +333,7 @@ namespace MED{ CrCellInfo(const PMeshInfo& theMeshInfo, const PCellInfo& theInfo) { - return PCellInfo(new TTCellInfo + return PCellInfo(new TTCellInfo (theMeshInfo, theInfo)); } @@ -339,7 +349,7 @@ namespace MED{ EBooleen theIsLocal = eVRAI, TInt theNbRef = 1) { - return PFieldInfo(new TTFieldInfo + return PFieldInfo(new TTFieldInfo (theMeshInfo, theNbComp, theType, @@ -353,7 +363,7 @@ namespace MED{ CrFieldInfo(const PMeshInfo& theMeshInfo, const PFieldInfo& theInfo) { - return PFieldInfo(new TTFieldInfo + return PFieldInfo(new TTFieldInfo (theMeshInfo, theInfo)); } @@ -364,24 +374,24 @@ namespace MED{ PTimeStampInfo CrTimeStampInfo(const PFieldInfo& theFieldInfo, EEntiteMaillage theEntity, - const TGeom& theGeom, - TInt theNbGauss = 0, + const TGeom2Size& theGeom2Size, + const TGeom2NbGauss& theGeom2NbGauss = TGeom2NbGauss(), TInt theNumDt = 0, TInt theNumOrd = 0, TFloat theDt = 0, const std::string& theUnitDt = "", - const std::string& theGaussName = "") + const TGeom2Gauss& theGeom2Gauss = TGeom2Gauss()) { - return PTimeStampInfo(new TTTimeStampInfo + return PTimeStampInfo(new TTTimeStampInfo (theFieldInfo, theEntity, - theGeom, - theNbGauss, + theGeom2Size, + theGeom2NbGauss, theNumDt, theNumOrd, theDt, theUnitDt, - theGaussName)); + theGeom2Gauss)); } virtual @@ -389,23 +399,47 @@ namespace MED{ CrTimeStampInfo(const PFieldInfo& theFieldInfo, const PTimeStampInfo& theInfo) { - return PTimeStampInfo(new TTTimeStampInfo + 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 PTimeStampVal CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo, - const std::string& thePflName = "", - EModeProfil thePflMode = eCOMPACT) + const TGeom2Profile& theGeom2Profile = TGeom2Profile(), + EModeSwitch theMode = eFULL_INTERLACE) { - return PTimeStampVal(new TTTimeStampVal + return PTimeStampVal(new TTTimeStampVal (theTimeStampInfo, - thePflName, - thePflMode)); + theGeom2Profile, + theMode)); } virtual @@ -413,7 +447,7 @@ namespace MED{ CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo, const PTimeStampVal& theInfo) { - return PTimeStampVal(new TTTimeStampVal + return PTimeStampVal(new TTTimeStampVal (theTimeStampInfo, theInfo)); } diff --git a/src/MEDWrapper/Base/MED_Utilities.cxx b/src/MEDWrapper/Base/MED_Utilities.cxx index 5c53a4df2..c66b2fe2c 100644 --- a/src/MEDWrapper/Base/MED_Utilities.cxx +++ b/src/MEDWrapper/Base/MED_Utilities.cxx @@ -50,14 +50,20 @@ MED::PrefixPrinter::PrefixPrinter(bool theIsActive): MED::PrefixPrinter::~PrefixPrinter() { - if(myIsActive) + if(myIsActive){ myCounter--; + if(myCounter < 0) + EXCEPTION(runtime_error,"PrefixPrinter::~PrefixPrinter() - myCounter("< + +#if !defined(__GNUC_2__) && defined(__GNUC__) && (__GNUC__ == 2) + #define __GNUC_2__ +#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; + + public: + explicit + TVector(const allocator_type& __a = allocator_type()): + superclass(__a) + {} + + TVector(size_type __n, const value_type& __value, + const allocator_type& __a = allocator_type()): + superclass(__n, __value, __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(__GNUC_2__) + return superclass::operator[](__n); +#else + return this->at(__n); +#endif + } + + const_reference + operator[](size_type __n) const + { +#if defined(__GNUC_2__) + return superclass::operator[](__n); +#else + return this->at(__n); +#endif + } + }; + +} + + +#endif diff --git a/src/MEDWrapper/Base/MED_Wrapper.cxx b/src/MEDWrapper/Base/MED_Wrapper.cxx index 9f69a0cfd..763bdacba 100644 --- a/src/MEDWrapper/Base/MED_Wrapper.cxx +++ b/src/MEDWrapper/Base/MED_Wrapper.cxx @@ -17,10 +17,35 @@ static int MYDEBUG = 0; static int MYVALUEDEBUG = 0; #endif -namespace MED{ +namespace MED +{ + TLockProxy + ::TLockProxy(TWrapper* theWrapper): + myWrapper(theWrapper) + { + boost::detail::thread::lock_ops::lock(myWrapper->myMutex); + INITMSG(MYDEBUG,"TLockProxy() - this -"<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,endl); - - BEGMSG(MYDEBUG,"GetPNodeInfo - GetFamNum: "); - for(TInt iElem = 0; iElem < aNbElem; iElem++){ - ADDMSG(MYVALUEDEBUG,anInfo->GetFamNum(iElem)<<", "); - } - ADDMSG(MYDEBUG,endl); - - if(anInfo->IsElemNum()){ - BEGMSG(MYDEBUG,"GetPNodeInfo - GetElemNum: "); + INITMSG(MYDEBUG,"GetPNodeInfo: "); + { + INITMSG(MYDEBUG,"aCoords: "<myCoord; for(TInt iElem = 0; iElem < aNbElem; iElem++){ - ADDMSG(MYVALUEDEBUG,anInfo->GetElemNum(iElem)<<", "); + for(TInt iDim = 0, anId = iElem*aDim; iDim < aDim; iDim++, anId++){ + ADDMSG(MYVALUEDEBUG,aCoord[anId]<<","); + } + ADDMSG(MYVALUEDEBUG," "); } ADDMSG(MYDEBUG,endl); + + BEGMSG(MYVALUEDEBUG,"GetFamNum: "); + for(TInt iElem = 0; iElem < aNbElem; iElem++){ + ADDMSG(MYVALUEDEBUG,anInfo->GetFamNum(iElem)<<", "); + } + ADDMSG(MYVALUEDEBUG,endl); + + if(anInfo->IsElemNum()){ + BEGMSG(MYVALUEDEBUG,"GetElemNum: "); + for(TInt iElem = 0; iElem < aNbElem; iElem++){ + ADDMSG(MYVALUEDEBUG,anInfo->GetElemNum(iElem)<<", "); + } + ADDMSG(MYVALUEDEBUG,endl); + } } - ADDMSG(MYDEBUG,endl); #endif @@ -96,32 +127,29 @@ namespace MED{ } //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - PPolygoneInfo TWrapper::GetPPolygoneInfo(const PMeshInfo& theMeshInfo, - EEntiteMaillage theEntity, - EGeometrieElement theGeom, - EConnectivite theConn) + PPolygoneInfo + TWrapper + ::GetPPolygoneInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode) { - TInt aNbElem = GetNbPolygones(*theMeshInfo,theEntity,theGeom,theConn); - TInt aNbConn = GetNbPolygoneConn(*theMeshInfo,theEntity,theGeom,theConn); - PPolygoneInfo anInfo = CrPolygoneInfo(theMeshInfo,aNbElem,aNbConn,theEntity,theGeom,theConn); - GetPolygoneInfo(*anInfo); + 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_ - TElemNum aConn = anInfo->GetConnectivite(); - TElemNum aIndex = anInfo->GetIndex(); - TInt aNbIndex = aIndex.size(); - TInt aIndex0 = aIndex[0]; - INITMSG(MYDEBUG,"theGeom = "<GetConnSlice(iElem); + TInt aConnDim = aConnSlice.size(); + for(TInt iConn = 0; iConn < aConnDim; iConn++){ + ADDMSG(MYVALUEDEBUG,aConnSlice[iConn]<<","); + } ADDMSG(MYDEBUG," "); - aIndex0 = aIndex[iElem]; - } - ADDMSG(MYDEBUG,endl); - BEGMSG(MYDEBUG,"Indexes: "); - for(TInt iElem = 0; iElem < aIndex.size(); iElem++){ - ADDMSG(MYVALUEDEBUG,aIndex[iElem]<<","); } ADDMSG(MYDEBUG,endl); #endif @@ -130,79 +158,82 @@ namespace MED{ } //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - PPolyedreInfo TWrapper::GetPPolyedreInfo(const PMeshInfo& theMeshInfo, - EEntiteMaillage theEntity, - EGeometrieElement theGeom, - EConnectivite theConn) + PPolyedreInfo + TWrapper + ::GetPPolyedreInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode) { - TInt aNbElem = GetNbPolyedres(*theMeshInfo,theEntity,theGeom,theConn); - TInt aNbConn = 0; - TInt aNbFaces = 0; - GetNbPolyedreConnF(*theMeshInfo,theConn,aNbFaces,aNbConn); - PPolyedreInfo anInfo = CrPolyedreInfo(theMeshInfo,aNbElem,aNbConn,aNbFaces,theEntity,theGeom,theConn); - GetPolyedreInfo(*anInfo); + 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_ - TElemNum aConn = anInfo->GetConnectivite(); - TElemNum aFacesIndex = anInfo->GetFacesIndex(); - TElemNum aIndex = anInfo->GetIndex(); - - TInt aNbIndex = aIndex.size(); - - for (int aNp = 0; aNp < aNbIndex-1;aNp++){ - if (anInfo->IsElemNames()) - ADDMSG(MYDEBUG,anInfo->GetElemName(aNp)<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," ]"<GetConnDim(); INITMSG(MYDEBUG,"GetPCellInfo - theEntity = "<GetConnSlice(iElem); for(TInt iConn = 0; iConn < aConnDim; iConn++){ - ADDMSG(MYVALUEDEBUG,anInfo->GetConn(iElem,iConn)<<","); + ADDMSG(MYVALUEDEBUG,aConnSlice[iConn]<<","); } ADDMSG(MYVALUEDEBUG," "); } ADDMSG(MYDEBUG,endl); - BEGMSG(MYDEBUG,"GetPCellInfo - GetFamNum: "); + BEGMSG(MYVALUEDEBUG,"GetPCellInfo - GetFamNum: "); for(TInt iElem = 0; iElem < aNbElem; iElem++){ ADDMSG(MYVALUEDEBUG,anInfo->GetFamNum(iElem)<<", "); } - ADDMSG(MYDEBUG,endl); + ADDMSG(MYVALUEDEBUG,endl); if(anInfo->IsElemNum()){ - BEGMSG(MYDEBUG,"GetPCellInfo - GetElemNum: "); + BEGMSG(MYVALUEDEBUG,"GetPCellInfo - GetElemNum: "); for(TInt iElem = 0; iElem < aNbElem; iElem++){ ADDMSG(MYVALUEDEBUG,anInfo->GetElemNum(iElem)<<", "); } - ADDMSG(MYDEBUG,endl); + ADDMSG(MYVALUEDEBUG,endl); } ADDMSG(MYDEBUG,endl); #endif @@ -212,9 +243,11 @@ namespace MED{ //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - PFieldInfo TWrapper::GetPFieldInfo(const PMeshInfo& theMeshInfo, - TInt theId, - TErr* theErr) + PFieldInfo + TWrapper + ::GetPFieldInfo(const PMeshInfo& theMeshInfo, + TInt theId, + TErr* theErr) { TInt aNbComp = GetNbComp(theId); PFieldInfo anInfo = CrFieldInfo(theMeshInfo,aNbComp); @@ -222,8 +255,11 @@ namespace MED{ #ifdef _DEBUG_ INITMSG(MYDEBUG, - "GetPFieldInfo - aNbComp = "<myGeom2NbGauss; + TGeom2NbGauss::const_iterator anIter = aGeom2NbGauss.begin(); + for(; anIter != aGeom2NbGauss.end(); anIter++){ + const EGeometrieElement& aGeom = anIter->first; + INITMSG(MYDEBUG,"aGeom = "<GetNbGauss(); PFieldInfo aFieldInfo = theTimeStampInfo->GetFieldInfo(); - TInt aNbComp = aFieldInfo->GetNbComp(); INITMSG(MYDEBUG,"GetPTimeStampVal\n"); - TMeshValue& aMeshValue = anInfo->myMeshValue; - TMeshValue::const_iterator aMeshValueIter = aMeshValue.begin(); - for(; aMeshValueIter != aMeshValue.end(); aMeshValueIter++){ - const EGeometrieElement& aGeom = aMeshValueIter->first; - const TValue& aValue = aMeshValueIter->second; - TInt iElemEnd = aValue.size() / aNbComp / aNbGauss; - INITMSG(MYDEBUG,"aGeom = "<myGeom2Value; + TGeom2Value::const_iterator anIter = aGeom2Value.begin(); + for(; anIter != aGeom2Value.end(); anIter++){ + const EGeometrieElement& aGeom = anIter->first; + const TMeshValue& aMeshValue = anIter->second; + TInt aNbElem = aMeshValue.myNbElem; + TInt aNbGauss = aMeshValue.myNbGauss; + TInt aNbComp = aMeshValue.myNbComp; + INITMSG(MYDEBUG,"aGeom = "< + +namespace MED +{ + + //---------------------------------------------------------------------------- + //! Define a base class that wraps the MED API + struct TWrapper + { + typedef boost::mutex TMutex; + //! This is a syncronization primitive which allow to support thread safety for the MED access + TMutex myMutex; - struct TWrapper{ //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + //! Creates a MEDWrapper MED Mesh representation virtual PMeshInfo CrMeshInfo(TInt theDim = 0, @@ -42,24 +54,30 @@ namespace MED{ 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&, + 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, @@ -67,34 +85,40 @@ namespace MED{ //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + //! 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, @@ -103,6 +127,7 @@ namespace MED{ TInt theId = 0, const std::string& theValue = "") = 0; + //! Creates a MEDWrapper MED Family representation virtual PFamilyInfo CrFamilyInfo(const PMeshInfo& theMeshInfo, @@ -113,172 +138,206 @@ namespace MED{ 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 nb, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, + TInt theNb, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TErr* theErr = NULL) {} + //! Read sequence of numerous for any descendant of TElemInfo virtual void GetNumeration(TElemInfo& theInfo, - TInt nb, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, + 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 nb, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, + 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 theTEntity, - EGeometrieElement theTGeom, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TErr* theErr = NULL) {} + //! Write sequence of numerous for any descendant of TElemInfo virtual void SetNumeration(const TElemInfo& theInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TErr* theErr = NULL) {} + //! Write sequence MED Family indexes for any descendant of TElemInfo virtual void SetFamilies(const TElemInfo& theInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TErr* theErr = NULL) {} //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + //! Read number of nodes in defined MED Mesh virtual TInt GetNbNodes(const TMeshInfo& theMeshInfo, TErr* theErr = NULL) = 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 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, - ERepere theSystem, const TFloatVector& theNodeCoords, - const TStringVector& theCoordNames, - const TStringVector& theCoordUnits, - const TIntVector& theFamilyNums, - const TIntVector& theElemNums, + 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 support 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 support 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 support only for version of 2.2 and higher */ virtual TInt GetNbPolygones(const TMeshInfo& theMeshInfo, - EEntiteMaillage, - EGeometrieElement, - EConnectivite, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode = eNOD, TErr* theErr = NULL) - { return 0;} + { + return 0; + } + //! Read connectivity infroamtion for the MED Polygones in defined MED Mesh + /*! This feature is support only for version of 2.2 and higher */ virtual TInt - GetNbPolygoneConn(const TMeshInfo& theMeshInfo, - EEntiteMaillage, - EGeometrieElement, - EConnectivite, - TErr* theErr = NULL) - { return 0;} + 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 support only for version of 2.2 and higher */ virtual PPolygoneInfo CrPolygoneInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TInt theNbElem, - TInt theNbConn, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn = eNOD, + TInt theConnSize, + EConnectivite theConnMode = eNOD, EBooleen theIsElemNum = eVRAI, EBooleen theIsElemNames = eVRAI) { return PPolygoneInfo(); } + //! Creates a MEDWrapper MED Polygones representation + /*! This feature is support only for version of 2.2 and higher */ virtual PPolygoneInfo CrPolygoneInfo(const PMeshInfo& theMeshInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn, - const TIntVector& theConnectivities, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, const TIntVector& theIndexes, - const TIntVector& theFamilyNums, - const TIntVector& theElemNums, + 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, @@ -287,74 +346,91 @@ namespace MED{ 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 theConn = eNOD); + 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, - EGeometrieElement, - EConnectivite, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode = eNOD, TErr* theErr = NULL) - { return 0;} + { + 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 - GetNbPolyedreConnF(const TMeshInfo& theMeshInfo, - EConnectivite theConn, - TInt& nf, - TInt& nc, - TErr* theErr = NULL) - {} + 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 theNbConn, TInt theNbFaces, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn = eNOD, + 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 theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn, - const TIntVector& theConnectivities, - const TIntVector& theFaces, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, const TIntVector& theIndexes, - const TIntVector& theFamilyNums, - const TIntVector& theElemNums, + 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, @@ -363,93 +439,110 @@ namespace MED{ 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 theConn = eNOD); + 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 theTConn = eNOD, + 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, - EGeometrieElement, - EConnectivite theTConn = eNOD, + 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, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn = eNOD, + EConnectivite theConnMode = eNOD, EBooleen theIsElemNum = eVRAI, - EBooleen theIsElemNames = eVRAI) = 0; + EBooleen theIsElemNames = eVRAI, + EModeSwitch theMode = eFULL_INTERLACE) = 0; + //! Creates a MEDWrapper MED Cells representation virtual PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, const TIntVector& theConnectivities, - const TIntVector& theFamilyNums, - const TIntVector& theElemNums, - const TStringVector& theElemNames = TStringVector()) = 0; + 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 theConn = eNOD, + EConnectivite theConnMode = eNOD, TErr* theErr = NULL); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + //! 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, @@ -459,11 +552,13 @@ namespace MED{ 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, @@ -471,73 +566,238 @@ namespace MED{ //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + //! 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(); + } + + //! 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, - TGeom& theGeom, + 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 TGeom& theGeom, - TInt theNbGauss = 0, + const TGeom2Size& theGeom2Size, + const TGeom2NbGauss& theGeom2NbGauss = TGeom2NbGauss(), TInt theNumDt = 0, TInt theNumOrd = 0, TFloat theDt = 0, const std::string& theUnitDt = "", - const std::string& theGaussName = "") = 0; + 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 MED::TGeom& theGeom, + 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; + + //! 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 GetTimeStampVal(TTimeStampVal& theVal, + const TMKey2Profile& theMKey2Profile, + const TKey2Gauss& theKey2Gauss, TErr* theErr = NULL) = 0; + //! Write the values for MEDWrapper MED TIEMSTAMP to defined MED file virtual void SetTimeStamp(const TTimeStampVal& theTimeStampVal, TErr* theErr = NULL) = 0; + //! Creates the values for MEDWrapper MED TIEMSTAMP representation virtual PTimeStampVal CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo, - const std::string& thePflName = "", - EModeProfil thePflMode = eCOMPACT) = 0; + const TGeom2Profile& theGeom2Profile = TGeom2Profile(), + EModeSwitch theMode = eFULL_INTERLACE) = 0; + //! A copy-constructor for the values for MEDWrapper MED TIEMSTAMP representation virtual PTimeStampVal CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo, const PTimeStampVal& theInfo) = 0; + //! 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); }; + + //---------------------------------------------------------------------------- + //! This class provide thread-safety for MEDWrapper interaction + class TLockProxy + { + TLockProxy& operator=(const TLockProxy& ); + TWrapper* myWrapper; + + public: + TLockProxy(TWrapper* theWrapper); + + ~TLockProxy(); + + TWrapper * operator-> () const; + }; + + + //---------------------------------------------------------------------------- + //! To specialize the SharedPtr for TWrapper + template<> + class 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/Makefile.in b/src/MEDWrapper/Base/Makefile.in index dbb3f7164..5512b30e0 100644 --- a/src/MEDWrapper/Base/Makefile.in +++ b/src/MEDWrapper/Base/Makefile.in @@ -36,26 +36,35 @@ VPATH=.:@srcdir@:@top_srcdir@/idl EXPORT_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 # Libraries targets LIB = libMEDWrapperBase.la LIB_SRC = \ - MED_Structures.cxx MED_Wrapper.cxx \ - MED_Algorithm.cxx MED_Utilities.cxx + MED_Structures.cxx \ + MED_Wrapper.cxx \ + MED_Algorithm.cxx \ + MED_GaussUtils.cxx \ + MED_CoordUtils.cxx \ + MED_Utilities.cxx # Executables targets BIN = BIN_SRC = -CPPFLAGS+= $(BOOST_CPPFLAGS) $(HDF5_INCLUDES) -D@MACHINE@ +CPPFLAGS+= $(BOOST_CPPFLAGS) $(HDF5_INCLUDES) -D@MACHINE@ -LDFLAGS+= +LDFLAGS+= $(BOOST_LIBS) -lboost_thread-mt @CONCLUDE@ diff --git a/src/MEDWrapper/Factory/MED_Test.cxx b/src/MEDWrapper/Factory/MED_Test.cxx index 80ce383ad..969af7253 100644 --- a/src/MEDWrapper/Factory/MED_Test.cxx +++ b/src/MEDWrapper/Factory/MED_Test.cxx @@ -28,6 +28,7 @@ #include "MED_Utilities.hxx" #include "MED_Algorithm.hxx" +#include "MED_GaussUtils.hxx" #include "MED_Factory.hxx" #ifdef _DEBUG_ @@ -36,57 +37,101 @@ static int MYDEBUG = 1; static int MYDEBUG = 0; #endif -static int MYVALUEDEBUG = 0; - static int MYWRITEDEBUG = 1; using namespace MED; +#undef _DEBUG_ void CheckMed(const std::string& theFileName) { MSG(MYDEBUG,"CheckMed - theFileName = '"<GetNbProfiles() = "<GetNbProfiles()<GetNbMeshes(); - INITMSG(MYDEBUG,"GetNbMeshes() = "<GetName() = "<GetName()<GetName() = '"<GetName()<<"'"<GetEntityInfo(aMeshInfo); - TElemGroup aElemGroup = GetElemsByEntity(aMed,aMeshInfo,aEntityInfo); - - TFamilyGroup aFamilyGroup = GetFamilies(aMed,aMeshInfo); + TEntity2TGeom2ElemInfo anEntity2TGeom2ElemInfo = + GetEntity2TGeom2ElemInfo(aMed,aMeshInfo,aEntityInfo); + + TFieldInfo2TimeStampInfoSet aFieldInfo2TimeStampInfoSet = + GetFieldInfo2TimeStampInfoSet(aMed,aMeshInfo,aEntityInfo); - TFamilyByEntity aFamilyByEntity = GetFamiliesByEntity(aMed,aElemGroup,aFamilyGroup); + 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()<< + 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()<< + endl); + PTimeStampVal aTimeStampVal = aMed->GetPTimeStampVal(aTimeStampInfo, + aMKey2Profile, + aKey2Gauss); + } + } + } + + continue; + + TFamilyInfoSet aFamilyInfoSet = GetFamilyInfoSet(aMed,aMeshInfo); - TGroupInfo aGroupInfo = GetFamiliesByGroup(aFamilyGroup); + TEntity2FamilySet aEntity2FamilySet = + GetEntity2FamilySet(aMed,anEntity2TGeom2ElemInfo,aFamilyInfoSet); - TTimeStampGroup aTimeStampGroup = GetFieldsByEntity(aMed,aMeshInfo,aEntityInfo); + TGroupInfo aGroupInfo = GetGroupInfo(aFamilyInfoSet); - TFieldGroup aFieldGroup = GetFieldsByEntity(aTimeStampGroup); - - TFieldGroup::const_iterator aFieldGroupIter = aFieldGroup.begin(); - for(; aFieldGroupIter != aFieldGroup.end(); aFieldGroupIter++){ - const TTimeStampGroup& aTTimeStampGroup = aFieldGroupIter->second; - TTimeStampGroup::const_iterator aTTimeStampGroupIter = aTTimeStampGroup.begin(); - for(; aTTimeStampGroupIter != aTTimeStampGroup.end(); aTTimeStampGroupIter++){ - PFieldInfo aFieldInfo = aTTimeStampGroupIter->first; - const TTimeStampSet& aTimeStampSet = aTTimeStampGroupIter->second; - TTimeStampSet::const_iterator aTTimeStampSetIter = aTimeStampSet.begin(); - for(; aTTimeStampSetIter != aTimeStampSet.end(); aTTimeStampSetIter++){ - PTimeStampInfo aTimeStampInfo = *aTTimeStampSetIter; - TErr anErr; - PTimeStampVal aTimeStampVal = aMed->GetPTimeStampVal(aTimeStampInfo,&anErr); + 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"); @@ -97,6 +142,9 @@ 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 = "<GetNbTimeStamps(aFieldInfo,aEntityInfo,anEntity,aTGeom); + theMed->GetNbTimeStamps(aFieldInfo,aEntityInfo,anEntity,aGeom2Size); { INITMSG(MYDEBUG,"GetNbTimeStamps = "<GetPTimeStampInfo(aFieldInfo,anEntity,aTGeom,iTimeStamp+1); + theMed->GetPTimeStampInfo(aFieldInfo,anEntity,aGeom2Size,iTimeStamp+1); TInt aNumDt = aTimeStampInfo->GetNumDt(); - TInt aNbGauss = aTimeStampInfo->GetNbGauss(); - INITMSG(MYDEBUG,"aNbGauss = "<CrTimeStampInfo(aFieldInfo2,aTimeStampInfo); - PTimeStampVal aTimeStampVal = theMed->GetPTimeStampVal(aTimeStampInfo); + PTimeStampVal aTimeStampVal = theMed->GetPTimeStampVal(aTimeStampInfo, + aMKey2Profile, + aKey2Gauss); - PTimeStampVal aTimeStampVal2 = theMed->CrTimeStampVal(aTimeStampInfo2,aTimeStampVal); + PTimeStampVal aTimeStampVal2 = theMed->CrTimeStampVal(aTimeStampInfo2, + aTimeStampVal); if(MYWRITEDEBUG) theMed2->SetTimeStamp(aTimeStampVal2); - - TMeshValue& aMeshValue = aTimeStampVal->myMeshValue; - TMeshValue::iterator aMeshValueIter = aMeshValue.begin(); - for(; aMeshValueIter != aMeshValue.end(); aMeshValueIter++){ - EGeometrieElement aGeom = aMeshValueIter->first; - TValue aValue = aMeshValueIter->second; - INITMSG(MYDEBUG,"aGeom = "<SetNodeInfo(aNodeInfo2); continue; } - TGeom& aTGeom = anEntityInfoIter->second; - TGeom::iterator anTGeomIter = aTGeom.begin(); - for(; anTGeomIter != aTGeom.end(); anTGeomIter++){ - const EGeometrieElement& aGeom = anTGeomIter->first; - const TInt& aNbElem = anTGeomIter->second; + TGeom2Size& aGeom2Size = anEntityInfoIter->second; + TGeom2Size::iterator aGeomIter = aGeom2Size.begin(); + for(; aGeomIter != aGeom2Size.end(); aGeomIter++){ + const EGeometrieElement& aGeom = aGeomIter->first; + const TInt& aNbElem = aGeomIter->second; INITMSG(MYDEBUG,"aGeom = "<GetPPolygoneInfo(aMeshInfo,anEntity,aGeom); - TElemNum aConn = aPolygoneInfo->GetConnectivite(); - TElemNum aIndex = aPolygoneInfo->GetIndex(); - TInt aNbIndex = aIndex.size(); - TInt aIndex0 = aIndex[0]; - for(TInt iElem = 1; iElem < aNbIndex; iElem++){ - for (TInt i = aIndex0; i < aIndex[iElem];i++) - ADDMSG(MYVALUEDEBUG,aConn[i-1]<<","); - ADDMSG(MYDEBUG," "); - aIndex0 = aIndex[iElem]; - } - ADDMSG(MYDEBUG,endl); - INITMSG(MYDEBUG,"Indexes :"); - for(TInt iElem = 0; iElem < aIndex.size(); iElem++){ - ADDMSG(MYVALUEDEBUG,aIndex[iElem]<<","); - } - ADDMSG(MYDEBUG,endl); - PPolygoneInfo aPolygoneInfo2 = theMed->CrPolygoneInfo(aMeshInfo2,aPolygoneInfo); - if(MYWRITEDEBUG) theMed2->SetPolygoneInfo(aPolygoneInfo2); - break; - } - case ePOLYEDRE: - { - PPolyedreInfo aPolyedreInfo = theMed->GetPPolyedreInfo(aMeshInfo,anEntity,aGeom); - TElemNum aConn = aPolyedreInfo->GetConnectivite(); - TElemNum aFacesIndex = aPolyedreInfo->GetFacesIndex(); - TElemNum aIndex = aPolyedreInfo->GetIndex(); - - TInt aNbIndex = aIndex.size(); - - for (int aNp = 0; aNp < aNbIndex-1;aNp++){ - if (aPolyedreInfo->IsElemNames()) - ADDMSG(MYDEBUG,aPolyedreInfo->GetElemName(aNp)<CrPolyedreInfo(aMeshInfo2,aPolyedreInfo); - if(MYWRITEDEBUG) theMed2->SetPolyedreInfo(aPolyedreInfo2); - break; - } + case ePOLYGONE: { + PPolygoneInfo aPolygoneInfo = theMed->GetPPolygoneInfo(aMeshInfo,anEntity,aGeom); + PPolygoneInfo aPolygoneInfo2 = theMed->CrPolygoneInfo(aMeshInfo2,aPolygoneInfo); + if(MYWRITEDEBUG) theMed2->SetPolygoneInfo(aPolygoneInfo2); + break; + } + case ePOLYEDRE: { + PPolyedreInfo aPolyedreInfo = theMed->GetPPolyedreInfo(aMeshInfo,anEntity,aGeom); + PPolyedreInfo aPolyedreInfo2 = theMed->CrPolyedreInfo(aMeshInfo2,aPolyedreInfo); + if(MYWRITEDEBUG) theMed2->SetPolyedreInfo(aPolyedreInfo2); + break; + } default: PCellInfo aCellInfo = theMed->GetPCellInfo(aMeshInfo,anEntity,aGeom); PCellInfo aCellInfo2 = theMed2->CrCellInfo(aMeshInfo2,aCellInfo); @@ -317,7 +313,9 @@ void ReadMed(const char* theFileName, int main(int argc, char** argv){ +#ifndef _DEBUG_ try{ +#endif if(argc == 2) CheckMed(argv[1]); if(argc == 3) @@ -327,10 +325,12 @@ int main(int argc, char** argv){ if(argc == 5) ReadMed(argv[1],argv[2],MED::EVersion(atoi(argv[3])),atoi(argv[4])); return 0; +#ifndef _DEBUG_ }catch(std::exception& exc){ MSG(MYDEBUG,"Follow exception was accured :\n"< +#include "med_misc.hxx" + +/* + * - Nom de la fonction : _MED1cstring + * - Description : convertit une chaine de caracteres FORTRAN + * en une nouvelle chaine de caracteres C + * dont la longueur est passee en parametre. + * Les caracteres completes sont des blancs + * - Parametres : + * - chaine (IN) : la chaine FORTRAN + * - longueur_reelle (IN) : la longueur de la chaine FORTRAN + * - longueur_fixee (IN) : longueur de la chaine C a construire + * - Resultat : la nouvelle chaine C en cas de succes, NULL sinon + */ + +namespace med_2_1{ + +char * +_MED1cstring(char *chaine,int longueur_reelle,int longueur_fixee) +{ + char *nouvelle; + int i; + + if (longueur_reelle > longueur_fixee) + return NULL; + + if ((nouvelle = (char *) malloc(sizeof(char)*(longueur_fixee+1))) == NULL) + return NULL; + + for (i=0;i +#include "med_misc.hxx" + +/* + * - Nom de la fonction _MED2cstring + * - Description : convertit une chaine de caracteres FORTRAN en + * nouvelle chaine de caracteres C + * - Parametres : + * - chaine (IN) : la chaine FORTRAN + * - longueur (IN) : longueur de la chaine + * - Resultat : la nouvelle chaine C en cas de succes, NULL sinon + */ + +namespace med_2_1{ + +char * +_MED2cstring(char *chaine, int longueur) +{ + char *nouvelle; + char *temoin; + int long_reelle = longueur; + int i; + + if ( longueur < 0 ) return NULL; + + temoin = chaine+longueur-1; + while (*temoin == ' ' && (temoin != chaine) ) + { + temoin --; + long_reelle--; + } + if ( *temoin == ' ') long_reelle = 0; + + if ((nouvelle = (char *) malloc(sizeof(char)*(long_reelle+1))) == NULL) + return NULL; + + for (i=0;iINT32BE ? */ + type_hdf = H5T_STD_I32BE; + if ((H5Tconvert(H5T_NATIVE_INT,H5T_STD_I32BE,1,(void *)val,NULL,NULL)) < 0) + return -1; +#else + type_hdf = H5T_NATIVE_INT; +#endif + break; + + default : + return -1; + } + + if ((aid = H5Screate(H5S_SCALAR)) < 0) + return -1; + + if ( ((attr = H5Aopen_name(pere,nom)) > 0) && (mode != MED_REMP) ) + return -1; + else + if ( attr < 0) + if ((attr = H5Acreate(pere,nom,type_hdf,aid,H5P_DEFAULT)) < 0) return -1; + + if ((ret = H5Awrite(attr,type_hdf,val)) < 0) + return -1; + + + if ((ret = H5Sclose(aid)) < 0) + return -1; + if ((ret = H5Aclose(attr)) < 0) + return -1; + +#if defined(PCLINUX) + /* This explicit convertion cancel the previous on which avoid a mysterious bug between HDF&ASTER when reading + a file written under a PCLINUX system, we don't know yet if it is an HDF bug or an ASTER one */ + if (type == MED_INT) + if ((H5Tconvert(H5T_STD_I32BE,H5T_NATIVE_INT,1,(void *)val,NULL,NULL)) < 0) + return -1; +#endif + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDattrNumLire.cxx b/src/MEDWrapper/V2_1/Core/MEDattrNumLire.cxx new file mode 100644 index 000000000..12299c5a7 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDattrNumLire.cxx @@ -0,0 +1,77 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDattrNumLire + * - Description : lecture d'un attribut entier + * - Parametres : + * - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut + * - type (IN) : le type du champ {MED_REEL64,MED_INT} + * - nom (IN) : le nom de l'attribut + * - val (OUT) : la valeur de l'attribut + * - Resultat : 0 en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +_MEDattrNumLire(med_idt pere,med_type_champ type,char *nom,unsigned char *val) +{ + med_idt attid; + med_err ret; + int type_hdf; + + if ((attid = H5Aopen_name(pere,nom)) < 0) + return -1; + + switch(type) + { + case MED_REEL64 : +#if defined(PCLINUX) || defined(OSF1) + type_hdf = H5T_IEEE_F64BE; +#else + type_hdf = H5T_IEEE_F64LE; +#endif + break; + + case MED_INT : +#if defined(IRIX64) || defined(OSF1) + type_hdf = H5T_NATIVE_LONG; +#else + type_hdf = H5T_NATIVE_INT; +#endif + break; + + default : + return -1; + } + + if ((ret = H5Aread(attid,type_hdf,val)) < 0) + return -1; + + if ((ret = H5Aclose(attid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDattrOuvrir.cxx b/src/MEDWrapper/V2_1/Core/MEDattrOuvrir.cxx new file mode 100644 index 000000000..bcf6be527 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDattrOuvrir.cxx @@ -0,0 +1,45 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDattrOuvrir + * - Description : acces a l'attribut dont le nom est passe en parametre + * - Parametres : + * - pid (IN) : l'ID de l'objet HDF pere ou placer l'attribut + * - nom (IN) : le nom de l'attribut + * - Resultat : ID de l'attribut en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_idt +_MEDattrOuvrir(med_idt pid,char * nom) +{ + med_idt aid; + + if ((aid = H5Aopen_name(pid,nom)) < 0) + return -1; + + return aid; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDattrStringEcrire.cxx b/src/MEDWrapper/V2_1/Core/MEDattrStringEcrire.cxx new file mode 100644 index 000000000..128336808 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDattrStringEcrire.cxx @@ -0,0 +1,68 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDattrStringEcrire + * - Description : ecriture d'un attribut chaine de caracteres + * - Parametres : + * - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut + * - nom (IN) : le nom de l'attribut + * - longueur (IN) : strlen(val) + * - val (IN) : la valeur de l'attribut + * - Resultat : 0 en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +_MEDattrStringEcrire(med_idt pere,char *nom,int longueur,char *val, med_mode_acces mode) +{ + med_idt aid,attr, datatype; + med_err ret; + + if ((aid = H5Screate(H5S_SCALAR)) < 0) + return -1; + if((datatype = H5Tcopy(H5T_C_S1)) < 0) + return -1; + if((ret = H5Tset_size(datatype,longueur+1)) < 0) + return -1; + + if ( ((attr = H5Aopen_name(pere,nom)) > 0) + && (mode != MED_REMP) ) + return -1; + else + if ( attr < 0) + if ((attr = H5Acreate(pere,nom,datatype,aid,H5P_DEFAULT)) < 0) return -1; + + if ((ret = H5Awrite(attr, datatype, val)) < 0) + return -1; + + if ((ret = H5Sclose(aid)) < 0) + return -1; + if ((ret = H5Tclose(datatype)) < 0) + return -1; + if ((ret = H5Aclose(attr)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDattrStringLire.cxx b/src/MEDWrapper/V2_1/Core/MEDattrStringLire.cxx new file mode 100644 index 000000000..764b9e2f6 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDattrStringLire.cxx @@ -0,0 +1,57 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDattrStringLire + * - Description : lecture d'un attribut chaine de caracteres + * - Parametres : + * - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut + * - nom (IN) : le nom de l'attribut + * - longueur (IN) : strlen(val) + * - val (OUT) : la valeur de l'attribut + * - Resultat : 0 en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +_MEDattrStringLire(med_idt pere,char *nom,int longueur,char *val) +{ + med_idt attid,datatype; + med_err ret; + + if ((datatype = H5Tcopy(H5T_C_S1)) < 0) + return -1; + if ((ret = H5Tset_size(datatype,longueur+1)) < 0) + return -1; + if ((attid = H5Aopen_name(pere,nom)) < 0) + return -1; + if ((ret = H5Aread(attid,datatype,val)) < 0) + return -1; + if ((ret = H5Tclose(datatype)) < 0) + return -1; + if ((ret = H5Aclose(attid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDbodyFittedEcr.cxx b/src/MEDWrapper/V2_1/Core/MEDbodyFittedEcr.cxx new file mode 100644 index 000000000..c7d84f46a --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDbodyFittedEcr.cxx @@ -0,0 +1,142 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med_outils.hxx" +#include "med.hxx" + +#if defined(IRIX64) +#define MED_INTEGER MED_INT64 +#else +#define MED_INTEGER MED_INT32 +#endif + +namespace med_2_1{ + +med_err +MEDbodyFittedEcr(med_idt fid, char *maa, med_int mdim, med_float *coo, med_int *nbr, med_mode_switch mode_coo, + med_repere repere, char *nomcoo, char *unicoo, med_int *fam, med_int nnoeuds, med_mode_acces mode ) +{ + /* ecriture des coordonnees */ + med_idt maaid, noeid, dataset; + med_size dimd[1]; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + med_int type_rep_int; + int d; + char *ds; + + /* On inhibe le gestionnaire d'erreur HDF */ + _MEDmodeErreurVerrouiller(); + + /* Si le maillage n'existe pas => erreur */ + strcpy(chemin, MED_MAA); + strcat(chemin, maa); + if ((maaid = _MEDdatagroupOuvrir(fid, chemin)) < 0) { + return(-1); + }; + + /* Si le Data Group "NOE" n'existe pas on le cree */ + if ((noeid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE)) < 0) { + if ((noeid = _MEDdatagroupCreer(maaid, MED_NOM_NOE)) < 0) { + return(-1); + }; + }; + + /* Creation du Data Set "BOF" */ + dimd[0] = nnoeuds*mdim; + if (_MEDdatasetNumEcrire(noeid, MED_NOM_BOF, MED_REEL64, mode_coo, mdim, MED_ALL, MED_NOPF, 0, 0, dimd, (unsigned char*)coo, mode) < 0) { + return(-1); + }; + + /* On re-ouvre le Data Set "BOF" pour y placer des attributs */ + if ((dataset = _MEDdatasetOuvrir(noeid, MED_NOM_BOF)) < 0) { + return(-1); + }; + + /* Attribut NBR (nombre de noeuds) */ + if (_MEDattrEntierEcrire(dataset, MED_NOM_NBR, &nnoeuds, mode) < 0) { + return(-1); + }; + + /* L'attribut "REP" */ + type_rep_int = (med_int)repere; + if (_MEDattrEntierEcrire(dataset, MED_NOM_REP, &type_rep_int, mode) < 0) { + return(-1); + }; + + /* Attribut "NOM" */ + if (_MEDattrStringEcrire(dataset, MED_NOM_NOM, mdim*MED_TAILLE_PNOM, nomcoo, mode) < 0) { + return(-1); + }; + + /* Attribut "UNI" */ + if (_MEDattrStringEcrire(dataset, MED_NOM_UNI, mdim*MED_TAILLE_PNOM, unicoo, mode) < 0) { + return(-1); + }; + + if (_MEDdatasetFermer(dataset) < 0) return(-1); + + dimd[0] = 1; + for (d=0; d erreur */ + strcpy(chemin, MED_MAA); + strcat(chemin, maa); + maaid = _MEDdatagroupOuvrir(fid, chemin); + if (maaid < 0) return(-1); + + /* Si le Data Group "NOE" n'existe pas => erreur */ + noeid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE); + if (noeid < 0) return(-1); + + /* Lecture du Data Set "BOF" */ + if (_MEDdatasetNumLire(noeid, MED_NOM_BOF, MED_REEL64, mode_coo, mdim, MED_ALL, MED_NOPF, 0, 1, (unsigned char*)coo) < 0) { + return(-1); + }; + + /* On re-ouvre le Data Set "BOF" pour y lire des attributs */ + dataset = _MEDdatasetOuvrir(noeid, MED_NOM_BOF); + if (dataset < 0) return(-1); + + /* L'attribut "REP" */ + if (_MEDattrEntierLire(dataset, MED_NOM_REP, &type_rep_int) < 0) { + return(-1); + } else { + *repere = (med_repere)type_rep_int; + }; + + /* Attribut "NOM" */ + if (_MEDattrStringLire(dataset, MED_NOM_NOM, mdim*MED_TAILLE_PNOM, nomcoo) < 0) { + return(-1); + }; + + /* Attribut "UNI" */ + if (_MEDattrStringLire(dataset, MED_NOM_UNI, mdim*MED_TAILLE_PNOM, unicoo) < 0) { + return(-1); + }; + + /* lecture des numeros de familles */ + if (MEDfamLire(fid, maa, fam, nnoeuds, MED_NOEUD, MED_POINT1) < 0) { + return(-1); + }; + + /* On ferme tout */ + if (_MEDdatasetFermer(dataset) < 0) { + return(-1); + }; + if (_MEDdatagroupFermer(noeid) < 0) { + return(-1); + }; + if (_MEDdatagroupFermer(maaid) < 0) { + return(-1); + }; + return(0); +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDchampCr.cxx b/src/MEDWrapper/V2_1/Core/MEDchampCr.cxx new file mode 100644 index 000000000..13fe5520a --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDchampCr.cxx @@ -0,0 +1,83 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDchampCr(med_idt fid, char *champ, med_type_champ type, char *comp, + char *unit,med_int ncomp) +{ + med_err ret = 0; + med_idt root,gid; + char chemin[MED_TAILLE_CHA+1]; + med_size dimd[1]; + med_int _type = (med_int) type; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le Data Group "/CHA/" n'existe pas, on le cree + */ + strncpy(chemin,MED_CHA,MED_TAILLE_CHA-1); + chemin[MED_TAILLE_CHA-1] = '\0'; + if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0) + if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) + return -1; + + /* + * Si le Data Group cha n'existe pas, on le cree + * Sinon => erreur + */ + if ((gid = _MEDdatagroupOuvrir(root,champ)) >= 0) + return -1; + if ((gid = _MEDdatagroupCreer(root,champ)) < 0) + return -1; + + /* + * Les infos sur les composants du champ + */ + if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_NCO,&ncomp,MED_REMP)) < 0) + return -1; + if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_TYP,&_type,MED_REMP)) < 0) + return -1; + if ((ret = _MEDattrStringEcrire(gid,MED_NOM_NOM,MED_TAILLE_PNOM*ncomp,comp,MED_REMP)) < 0) + return -1; + if ((ret = _MEDattrStringEcrire(gid,MED_NOM_UNI,MED_TAILLE_PNOM*ncomp,unit,MED_REMP)) < 0) + return -1; + + /* + * On ferme tout + */ + if ((ret = _MEDdatagroupFermer(gid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(root)) < 0) + return -1; + + return ret; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDchampEcr.cxx b/src/MEDWrapper/V2_1/Core/MEDchampEcr.cxx new file mode 100644 index 000000000..14f5090bc --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDchampEcr.cxx @@ -0,0 +1,246 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +/* + * - Nom de la fonction : MEDchampEcr + * - Description : ecriture d'un Champ Résultat + * - Parametres : + * - fid (IN) : ID du fichier HDF courant + * - maa (IN) : le nom du maillage sur lequel s'applique le champ + * - cha (IN) : le nom du champ + * - val (IN) : valeurs du champ à stocker + * - interlace(IN) : entrelacement utilisé en mémoire {MED_FULL_INTERLACE,MED_NO_INTERLACE} + * - nbelem (IN) : nombre d'éléments (prend en compte le nbre + * de points de Gauss (c'est demandé à l'utilisateur ds la doc) mais pas le nbre de composantes) + * - ngauss (IN) : nbre de point de gauss utilisé (MED_NOPG si aucun) + * - numco (IN) : n° de la composante à stocker (MED_ALL si toutes) + * - profil (IN) : nom du profil utilisé (MED_NOPFL si inutilisé) + * - mode (IN) : mode d'ecriture MED (MED_ECRI | MED_REMP) + * - type_ent (IN) : entité concerné par le champ {MED_NOEUD,MED_ARETE,MED_FACE,MED_MAILLE} + * - type_geo (IN) : type géométrique de l'entité concerné {MED_POINT,MED_SEG2 ......} + * - numdt (IN) : n° du pas de temps (MED_NOPDT si aucun) + * - dt_unit (IN) : chaine de taille MED_NOMP indiquant l'unité du champ + * - dt (IN) : valeur du pas de temps + * - numo (IN) : n° d'ordre utilisé MED_NONOR si inutile + * - Resultat : 0 en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +MEDchampEcr(med_idt fid, char *maa, char *cha,unsigned char *val,med_mode_switch interlace,med_int nbelem,med_int ngauss, + med_int numco, char * profil, med_mode_acces mode, med_entite_maillage type_ent, + med_geometrie_element type_geo, med_int numdt,char * dt_unit, med_float dt, med_int numo) +{ + med_err ret; + med_idt chid,datagroup1,datagroup2; + med_int ncomp, chtype, i, locnumdt,pfluse; + char pflname [MED_TAILLE_NOM+1]; + char maillage[MED_TAILLE_NOM+1]; + char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2],nomdatagroup2[2*MED_MAX_PARA+1]; + char tmp1[MED_TAILLE_NOM_ENTITE+1]; + med_size dimd[1],psize; + med_int *pfltabtmp=0; + med_ssize *pfltab=0; + char chemin[MED_TAILLE_CHA+MED_TAILLE_NOM+1]; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + + /* + * Si le Data Group cha n'existe pas => erreur + */ + strcpy(chemin,MED_CHA); + strcat(chemin,cha); + if ((chid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * Creation du datagroup de niveau 1 [.] + */ + + if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0) + return -1; + if ((type_ent != MED_NOEUD)) + { + if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0) + return -1; + strcat(nomdatagroup1,"."); + strcat(nomdatagroup1,tmp1); + } + datagroup1 = 0; + if ( (datagroup1 = _MEDdatagroupOuvrir(chid,nomdatagroup1)) < 0) + if ((datagroup1 = _MEDdatagroupCreer(chid,nomdatagroup1)) < 0) + return -1; + + /* Creation du datagroup de niveau 2 . */ + if ( numdt == MED_NOPDT) locnumdt = MED_NOPDT; else locnumdt = numdt; + sprintf(nomdatagroup2,"%*li%*li",MED_MAX_PARA,(long ) locnumdt,MED_MAX_PARA,(long ) numo); + + + /*Cree ou ouvre (en mode MED_REMP) le datagroup nomdatagroup2 */ + datagroup2 = 0; + if (((datagroup2 = _MEDdatagroupOuvrir(datagroup1,nomdatagroup2)) > 0) + && (mode != MED_REMP)) + return -1; + else + if (datagroup2 < 0) + if ((datagroup2 = _MEDdatagroupCreer(datagroup1,nomdatagroup2)) < 0) + return -1; + + /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_NDT */ + if ((ret = _MEDattrEntierEcrire(datagroup2,MED_NOM_NDT,&numdt,mode)) < 0) + return -1; + + /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_PDT */ + if ((ret = _MEDattrFloatEcrire(datagroup2,MED_NOM_PDT,&dt,mode)) < 0) + return -1; + + /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_NOR */ + if ((ret = _MEDattrEntierEcrire(datagroup2,MED_NOM_NOR,&numo,mode)) < 0) + return -1; + + /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_NBR */ + if ((ret = _MEDattrEntierEcrire(datagroup2,MED_NOM_NBR,&nbelem,mode)) < 0) + return -1; + + /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_MAA */ + /* rem : Aucune verification de l'existence du maillage */ + strncpy(maillage,maa,MED_TAILLE_NOM); + maillage[MED_TAILLE_NOM]='\0'; + if ((ret = _MEDattrStringEcrire(datagroup2,MED_NOM_MAI,MED_TAILLE_NOM,maillage,mode)) < 0) + return -1; + + /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_PFL */ + pfluse = 0; + if ( strlen(profil) == 0) /* idem MED_NOPFL*/ + strncpy(pflname,MED_NOPFLi,MED_TAILLE_NOM+1); + else { + strncpy(pflname,profil,MED_TAILLE_NOM); + pflname[MED_TAILLE_NOM]='\0'; + pfluse = 1; + } + if ((ret = _MEDattrStringEcrire(datagroup2,MED_NOM_PFL,MED_TAILLE_NOM,pflname,mode)) < 0) + return -1; + + /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_UNI */ + if ( strlen(dt_unit) == 0) { + if ((ret = _MEDattrStringEcrire(datagroup2,MED_NOM_UNI,MED_TAILLE_PNOM," ",mode)) < 0) + return -1; + } else + if ((ret = _MEDattrStringEcrire(datagroup2,MED_NOM_UNI,MED_TAILLE_PNOM,dt_unit,mode)) < 0) + return -1; + + + /* Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_NGAU */ + /* Ecriture du nombre de pts de gauss propre au [.] */ + /* On n'utilise pas ngauss=MED_NOPG mais ngauss=1 si aucun pt de gauss */ + if ((ret = _MEDattrEntierEcrire(datagroup2,MED_NOM_NGA,&ngauss,mode)) < 0) + return -1; + + /*Lecture de l'attribut MED_NOM_NCO */ + if ((ret = _MEDattrEntierLire(chid,MED_NOM_NCO,&ncomp)) < 0) + return -1; + + /*Determination de la taille dimd[0] du dataset à stocker*/ + dimd[0] = nbelem*ncomp; + + /* Gestion des profils*/ + if ( pfluse ) { + + if ( ( i = MEDnValProfil(fid,pflname) ) < 0 ) + return -1; + else + psize = i; + + pfltabtmp = (med_int *) malloc (sizeof(med_int)*psize); + pfltab = (med_ssize *) malloc (sizeof(med_ssize)*psize); + if ((ret = MEDprofilLire(fid,pfltabtmp,pflname)) < 0) + return -1; + for (i=0;i erreur + */ + strcat(chemin,champ); + if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + + /* + * La liste des attributs + */ + if ((ret = _MEDattrEntierLire(gid,MED_NOM_TYP,(med_int*) type)) < 0) + return -1; + if ((ret = _MEDattrStringLire(gid,MED_NOM_NOM,ncomp*MED_TAILLE_PNOM, + comp)) < 0) + return -1; + if ((ret = _MEDattrStringLire(gid,MED_NOM_UNI,ncomp*MED_TAILLE_PNOM, + unit)) < 0) + return -1; + + /* + * On ferme tout + */ + if ((ret = _MEDdatagroupFermer(gid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDchampLire.cxx b/src/MEDWrapper/V2_1/Core/MEDchampLire.cxx new file mode 100644 index 000000000..ad21a6840 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDchampLire.cxx @@ -0,0 +1,194 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + + /*La taille de val allouée par l'utilisateur doit prendre en compte le nbre de points de gauss et le nbre de composantes*/ + +namespace med_2_1{ + +med_err +MEDchampLire(med_idt fid,char *maa, char *cha, unsigned char *val,med_mode_switch interlace,med_int numco, + char *profil,med_entite_maillage type_ent, med_geometrie_element type_geo, + med_int numdt, med_int numo) + /* VERIFIER LA POSSIBILITE DE RELIRE L'UNITE DE PAS DE TEMPS (DS CHAMPINFO) */ +{ + med_err ret; + med_idt chid, datagroup1, datagroup2; + med_int ncomp, chtype, ngauss, i, locnumdt, pfluse; + char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2],nomdatagroup2[2*MED_MAX_PARA+1]; + char tmp1[MED_TAILLE_NOM_ENTITE+1], pfltmp[MED_TAILLE_NOM+1]; + char chemin[MED_TAILLE_CHA+MED_TAILLE_NOM+1]; + med_size psize; + med_int *pfltabtmp=0; + med_ssize *pfltab=0; + char maatmp[MED_TAILLE_NOM+1]; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le Data Group cha n'existe pas => erreur + */ + strcpy(chemin,MED_CHA); + strcat(chemin,cha); + if ((chid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * Si le Data Group de niveau 1 [.] n'existe pas => erreur + */ + if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0) + return -1; + if ((type_ent != MED_NOEUD)) + { + if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0) + return -1; + strcat(nomdatagroup1,"."); + strcat(nomdatagroup1,tmp1); + } + datagroup1 = 0; + if ( (datagroup1 = _MEDdatagroupOuvrir(chid,nomdatagroup1)) < 0 ) + return -1; + + /* + * Si le Data Group de niveau 2 . n'existe pas => erreur + */ + if ( numdt == MED_NOPDT) locnumdt = MED_NOPDT; else locnumdt = numdt; + sprintf(nomdatagroup2,"%*li%*li",MED_MAX_PARA,(long ) locnumdt,MED_MAX_PARA,(long ) numo); + + datagroup2 = 0; + if ( (datagroup2 = _MEDdatagroupOuvrir(datagroup1,nomdatagroup2)) < 0) + return -1; + + /* Lecture du nbre de composantes du champ */ + + if ((ret = _MEDattrEntierLire(chid,MED_NOM_NCO,&ncomp)) < 0) + return -1; + + /* Gestion des profils*/ + + /* + * Lire le profil demandé + */ + + if ((ret = _MEDattrStringLire(datagroup2,MED_NOM_PFL,MED_TAILLE_NOM,pfltmp)) < 0) + return -1; + + if ( pfluse = (strcmp(pfltmp,MED_NOPFLi) && strcmp(pfltmp,"")) ) /* le test "" pour des raisons de compatibilité */ + { + strcpy(profil,pfltmp); + if ( (i = MEDnValProfil(fid,profil)) < 0 ) + return -1; + else + psize = i; + + pfltabtmp = (med_int *) malloc (sizeof(med_int)*psize); + pfltab = (med_ssize *) malloc (sizeof(med_ssize)*psize); + if ((ret = MEDprofilLire(fid,pfltabtmp,profil)) < 0) + return -1; + for (i=0;i[.] pour simplifier la relecture */ + if ( (ret = _MEDattrEntierLire(datagroup2,MED_NOM_NGA,&ngauss)) < 0 ) + return -1; + + /* + * Lecture du champ + */ + + if ((ret = _MEDattrEntierLire(chid,MED_NOM_TYP,&chtype)) < 0) + return -1; + + switch(chtype) + { + case MED_REEL64 : + if ((ret = _MEDdatasetNumLire(datagroup2,MED_NOM_CO,MED_REEL64, + interlace,ncomp,numco, + psize,pfltab,ngauss,val))< 0) + return -1; + break; + + case MED_INT32 : +#if defined(IRIX64)||defined(OSF1) + if ((ret = _MEDdatasetNumLire(datagroup2,MED_NOM_CO,MED_INT64, + interlace,ncomp,numco, + psize,pfltab,ngauss,val))< 0) + return -1; +#else + if ((ret = _MEDdatasetNumLire(datagroup2,MED_NOM_CO,MED_INT32, + interlace,ncomp,numco, + psize, pfltab,ngauss,val))< 0) + return -1; +#endif + break; + + case MED_INT64 : +#if defined(IRIX64)||defined(OSF1) + if ((ret = _MEDdatasetNumLire(datagroup2,MED_NOM_CO,MED_INT64, + interlace,ncomp,numco, + psize,pfltab,ngauss,val))< 0) + return -1; +#else + return -1; +#endif + break; + + default : + return -1; + } + + /* + * On ferme tout + */ + if ( pfluse ) { free(pfltab); free(pfltabtmp);} + + if ((ret = _MEDdatagroupFermer(datagroup2)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(datagroup1)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(chid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDconnEcr.cxx b/src/MEDWrapper/V2_1/Core/MEDconnEcr.cxx new file mode 100644 index 000000000..a8395b5c2 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDconnEcr.cxx @@ -0,0 +1,142 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +extern int mode_interlace; + +namespace med_2_1{ + +med_err +MEDconnEcr(med_idt fid,char *maa, med_int mdim, med_int *connectivite,med_mode_switch mode_switch, + med_int nbre,med_mode_acces mode,med_entite_maillage type_ent, + med_geometrie_element type_geo,med_connectivite type_conn) +{ + med_idt maaid, entid, geoid, dataset; + med_err ret; + med_size dimd[1]; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + char nom_ent[MED_TAILLE_NOM_ENTITE+1]; + char nom_geo[MED_TAILLE_NOM_ENTITE+1]; + char nom_dataset[MED_TAILLE_NOM_ENTITE+1]; + int dim, nnoe, ndes; + int nsup = 0; + int taille; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le maillage n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * On met a jour le nom du Data Group representant + * le type des entites + */ + if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) + return -1; + /* + * Si le Data Group des entites n'existe pas on le cree + */ + /*EF Gerer le mode */ + if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) + if ((entid = _MEDdatagroupCreer(maaid,nom_ent)) < 0) + return -1; + + /* + * On cree s'il n'existe pas le Data Group du type geometrique + */ + /*EF Gerer le mode */ + if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) + return -1; + if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) + if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0) + return -1; + + /* + * On regarde si le Data Set existe et on le cree sinon + */ + if ((ret=_MEDparametresGeometrie(type_ent,type_geo,&dim,&nnoe,&ndes))<0) + return -1; + if (mdim == 2 || mdim == 3) + if (type_ent == MED_MAILLE && dim == 1) + nsup = 1; + if (mdim == 3) + if (type_ent == MED_MAILLE && dim == 2) + nsup = 1; + switch(type_conn) + { + case MED_NOD : + strcpy(nom_dataset,MED_NOM_NOD); + taille = nsup + nnoe; + break; + + case MED_DESC : + strcpy(nom_dataset,MED_NOM_DES); + taille = nsup + ndes; + break; + + default : + return -1; + } + dimd[0] = nbre*taille; +#if defined(IRIX64)||defined(OSF1) + if ((ret = _MEDdatasetNumEcrire(geoid,nom_dataset,MED_INT64,mode_switch,(med_size)taille,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, + (unsigned char*) connectivite,mode)) < 0) + return -1; +#else + if ((ret = _MEDdatasetNumEcrire(geoid,nom_dataset,MED_INT32,mode_switch,(med_size)taille,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, + (unsigned char*) connectivite,mode)) < 0) + return -1; +#endif + + /* + * Attribut NBR (nombre de noeuds ou d'elements) + */ + if ((dataset = _MEDdatasetOuvrir(geoid,nom_dataset)) < 0) + return -1; + if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&nbre,mode)) < 0) + return -1; + + /* + * On ferme tout + */ + if ((ret = _MEDdatasetFermer(dataset)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(geoid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(entid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDconnLire.cxx b/src/MEDWrapper/V2_1/Core/MEDconnLire.cxx new file mode 100644 index 000000000..9e6c29f48 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDconnLire.cxx @@ -0,0 +1,149 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +extern int mode_interlace; + +namespace med_2_1{ + +med_err +MEDconnLire(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch, + med_int * pfltabtmp, med_size psizetmp, + med_entite_maillage type_ent, med_geometrie_element type_geo,med_connectivite type_conn) +{ + med_idt maaid,entid,geoid; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + char nom_ent[MED_TAILLE_NOM_ENTITE+1]; + char nom_geo[MED_TAILLE_NOM_ENTITE+1]; + char nom_dataset[MED_TAILLE_NOM_ENTITE+1]; + med_ssize * pfltab; + med_size psize; + int dim,nnoe,ndes; + int nsup = 0; + int taille; + int i,j; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le maillage n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * On met a jour le nom du Data Group representant + * le type des entites + */ + if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) + return -1; + /* + * Si le Data Group des entites n'existe pas => erreur + */ + if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) + return -1; + + /* + * si le Data Group du type geometrique n'existe pas => erreur + */ + if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) + return -1; + if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) + return -1; + + /* + * Si le Data Set de la connectivite n'existe pas => erreur + * Si oui => on le lit + */ + if ((ret=_MEDparametresGeometrie(type_ent,type_geo,&dim,&nnoe,&ndes))<0) + return -1; + if (mdim == 2 || mdim == 3) + if (type_ent == MED_MAILLE && dim == 1) + nsup = 1; + if (mdim == 3) + if (type_ent == MED_MAILLE && dim == 2) + nsup = 1; + + + psize = psizetmp; + switch(type_conn) + { + case MED_NOD : + strcpy(nom_dataset,MED_NOM_NOD); + taille = nsup + nnoe; + break; + + case MED_DESC : + strcpy(nom_dataset,MED_NOM_DES); + taille = nsup + ndes; + if ( psizetmp != MED_NOPF ) { + psize = psizetmp; + pfltab = (med_ssize *) malloc (sizeof(med_ssize)*psize); + for (i=0;i +#include + +namespace med_2_1{ + +med_err +MEDcoordEcr(med_idt fid, char *maa, med_int mdim, med_float *coo, + med_mode_switch mode_coo,med_int n, + med_mode_acces mode, med_repere type_rep, char *nom, char *unit) +{ + med_idt maaid, noeid, dataset; + med_err ret; + med_size dimd[1]; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + med_int type_rep_int; + /* + * On inhibe le gestionnaire d'erreur HDF + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le maillage n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * Si le Data Group "NOE" n'existe pas + * on le cree + */ + /* EF : A faire : gerer le mode MED_REMP*/ + if ((noeid = _MEDdatagroupOuvrir(maaid,MED_NOM_NOE)) < 0) + if ((noeid = _MEDdatagroupCreer(maaid,MED_NOM_NOE)) < 0) + return -1; + + /* + * Creation du Data Set "COO" + */ + dimd[0] = n*mdim; + if ((ret = _MEDdatasetNumEcrire(noeid,MED_NOM_COO,MED_REEL64,mode_coo,mdim,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, + (unsigned char*) coo,mode)) < 0) + return -1; + + /* + * On re-ouvre le Data Set "COO" pour y placer des attributs + */ + if ((dataset = _MEDdatasetOuvrir(noeid,MED_NOM_COO)) < 0) + return -1; + + /* + * Attribut NBR (nombre de noeuds) + */ + if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n,mode)) < 0) + return -1; + + /* + * L'attribut "REP" + */ + type_rep_int = (med_int) type_rep; + if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_REP,&type_rep_int,mode)) < 0) + return -1; + + /* + * Attribut "NOM" + */ + if ((ret = _MEDattrStringEcrire(dataset,MED_NOM_NOM,mdim*MED_TAILLE_PNOM,nom,mode)) < 0) + return -1; + + /* + * Attribut "UNI" + */ + if ((ret = _MEDattrStringEcrire(dataset,MED_NOM_UNI,mdim*MED_TAILLE_PNOM,unit,mode)) < 0) + return -1; + + /* + * On ferme tout + */ + if ((ret = _MEDdatasetFermer(dataset)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(noeid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDcoordLire.cxx b/src/MEDWrapper/V2_1/Core/MEDcoordLire.cxx new file mode 100644 index 000000000..1335f1a1b --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDcoordLire.cxx @@ -0,0 +1,125 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med_outils.hxx" +#include "med.hxx" + +#include +#include + +extern int mode_interlace; + +namespace med_2_1{ + +med_err +MEDcoordLire(med_idt fid, char *maa, med_int mdim, med_float *coo, + med_mode_switch mode_coo,med_int numco, + med_int * pfltabtmp, med_size psize, med_repere *type_rep, char *nom, char *unit) +{ + med_idt maaid, noeid, dataset; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + int i,j; + med_float *new_coo; + med_int type_rep_int; + med_ssize * pfltab; + + /* + * On inhibe le gestionnaire d'erreur + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le maillage n'existe pas => erreur + * Sinon on recupere sa dimension au passage + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * Si le Data Group "NOE" n'existe pas => erreur + */ + if ((noeid = _MEDdatagroupOuvrir(maaid,MED_NOM_NOE)) < 0) + return -1; + + /* + * Convertion de med_int en med_ssize + */ + if ( psize != MED_NOPF ) { + pfltab = (med_ssize *) malloc (sizeof(med_ssize)*psize); + for (i=0;i +#include "med_misc.hxx" + +/* + * - Nom de la fonction _MEDcstringFree + * - Description : libere la chaine de caracteres creee par + * les routines _MEDXcstring + * - Parametres : + * - chaine (IN/OUT) : la chaine de caracteres a detruire + * - Resultat : 0 si succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +_MEDcstringFree(char *chaine) +{ + + free(chaine); + return 0; + +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDdatagroupCreer.cxx b/src/MEDWrapper/V2_1/Core/MEDdatagroupCreer.cxx new file mode 100644 index 000000000..4b9170479 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDdatagroupCreer.cxx @@ -0,0 +1,45 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDdatagroupCreer + * - Description : creation et ouverture d'un Datagroup HDF + * - Parametres : + * - pid (IN) : l'ID de l'objet pere + * - nom (IN) : le nom de l'objet fils + * - Resultat : l'ID du fils en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_idt +_MEDdatagroupCreer(med_idt pid, char *nom) +{ + med_idt id; + + if ((id = H5Gcreate(pid,nom,0)) < 0) + return -1; + + return id; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDdatagroupFermer.cxx b/src/MEDWrapper/V2_1/Core/MEDdatagroupFermer.cxx new file mode 100644 index 000000000..b48ea41c9 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDdatagroupFermer.cxx @@ -0,0 +1,44 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDdatagroupFermer + * - Description : fermeture d'un datagroup HDF + * - Parametres : + * - id (IN) : l'ID du datagroup + * - Resultat : 0 en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +_MEDdatagroupFermer(med_idt id) +{ + med_err ret; + + if ((ret = H5Gclose(id)) < 0) + return -1; + else + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDdatagroupOuvrir.cxx b/src/MEDWrapper/V2_1/Core/MEDdatagroupOuvrir.cxx new file mode 100644 index 000000000..89cdbe4f7 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDdatagroupOuvrir.cxx @@ -0,0 +1,45 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDdatagroupOuvrir + * - Description : ouverture d'un datagroup HDF + * - Parametres : + * - pid (IN) : l'ID de l'objet pere + * - nom (IN) : le nom de l'objet fils + * - Resultat : l'ID du fils en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_idt +_MEDdatagroupOuvrir(med_idt pid, char *nom) +{ + med_idt id; + + if ((id = H5Gopen(pid,nom)) < 0) + return -1; + + return id; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDdatasetFermer.cxx b/src/MEDWrapper/V2_1/Core/MEDdatasetFermer.cxx new file mode 100644 index 000000000..7694e052e --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDdatasetFermer.cxx @@ -0,0 +1,43 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDdatasetFermer + * - Description : fermeture d'un objet HDF dataset + * - Parametres : + * - id (IN) : l'ID de l'objet HDF dataset + * - Resultat : 0 en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +_MEDdatasetFermer(med_idt id) +{ + med_err ret; + + if ((ret = H5Dclose(id)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDdatasetNumEcrire.cxx b/src/MEDWrapper/V2_1/Core/MEDdatasetNumEcrire.cxx new file mode 100644 index 000000000..bc9d6ff73 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDdatasetNumEcrire.cxx @@ -0,0 +1,440 @@ +// Copyright (C) 2005 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/ +// +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" +#include +#include "hdf5_version2api.hxx" + +/* + * - Nom de la fonction : _MEDdatasetNumEcrire + * - Description : ecriture d'un dataset tableau numerique + * - Parametres : + * - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut + * - nom (IN) : le nom du dataset + * - type (IN) : type numerique MED { MED_REEL64 , MED_INT32 , MED_INT64 } + * - interlace (IN) : Choix du type d'entrelacement utilisé par l'appelant { MED_FULL_INTERLACE(x1,y1,z1,x2,...)) , MED_NO_INTERLACE(x1,x2,y1,y2,z1,z2) } + * - nbdim (IN) : Dimension des éléments + * - fixdim (IN) : MED_ALL ou n° de la dimension a enregistrer + * - psize (IN) : Taille du profil à utiliser, MED_NOPF si pas de profil + * (référence les élements, cette taille ne prend pas en compte le nombre de pts de gauss ni la dimension ) + * - pfltab (IN) : Tableau contenant les n° déléments à traiter (1....oo) + * - pflmod (IN) : PARAMETRE A AJOUTER : Indique comment lire les informations en mémoire { MED_COMPACT, MED_GLOBALE }. + * - ngauss (IN) : Nombre de points de GAUSS par élément + * - size (IN) : Taille du tableau de valeurs + * (référence tous les élements, cette taille prend en compte le nombre de pts de gauss et la dimension ) + * - val (IN) : valeurs du tableau + * - mode (IN) : mode d'ecriture MED (MED_ECRI | MED_REMP) + * - Resultat : 0 en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +_MEDdatasetNumEcrire(med_idt pere,char *nom, med_type_champ type, + med_mode_switch interlace, med_size nbdim, med_size fixdim, + med_size psize, med_ssize * pfltab, med_int ngauss, + med_size *size, unsigned char *val, med_mode_acces mode) +{ + med_idt dataset, dataspace = 0, memspace = 0; +#ifdef HDF_NEW_API + med_size start_mem[1],start_data[1],*pflmem,*pfldsk; +#else + med_ssize start_mem[1],start_data[1],*pflmem,*pfldsk; +#endif + med_size stride[1],count[1],pcount[1],pflsize[1]; + med_err ret; + int i,j,index,type_hdf; + int dim, firstdim, dimutil, lastdim ; + med_mode_profil pflmod; + + /* Verify fixdim is between [0, nbdim] ( 0 is MED_ALL ) */ + if ( ( fixdim < 0 ) || ( fixdim > nbdim ) ) + return -1; + + /* block pflmod to MED_COMPACT (until med2.2) */ + pflmod = MED_COMPACT; + + switch(type) + { + case MED_REEL64 : + /* 1) IA32 is LE but due to an (?HDF convertion BUG?) when using H5T_NATIVE_DOUBLE/MED_REEL64? under PCLINUX + the file read under SGI is incorrect + 2) Compaq OSF/1 is LE, since we force SGI64,SUN4SOL2,HP to write double in LE even if they are BE, mips OSF/1 must be BE + REM : Be careful of compatibility between MED files when changing this (med2.2) */ +#if defined(PCLINUX) || defined(OSF1) + type_hdf = H5T_IEEE_F64BE; +#else + type_hdf = H5T_IEEE_F64LE; +#endif + break; + + case MED_INT32 : +#if defined(PCLINUX) + type_hdf = H5T_STD_I32BE; + if ((H5Tconvert(H5T_NATIVE_INT,H5T_STD_I32BE,(hsize_t)*size,(void *)val,NULL,(hid_t)0)) < 0) + return -1; +#else + type_hdf = H5T_NATIVE_INT; +#endif + break; + + case MED_INT64 : + type_hdf = H5T_NATIVE_LONG; + break; + + default : + return -1; + } + + + if ((dataset = H5Dopen(pere,nom)) < 0) + { + /* Whatever the size of the profil is we create a dataset with the size of the value array */ + /* Then if we used the MED_REMP mode we can append a new dimension to a previous one in the dataset */ + /* When we'll use the compression mode, the space used by unused values would be easily compressed */ + + if ((dataspace = H5Screate_simple(1,size,NULL)) < 0) + return -1; + if ((dataset = H5Dcreate(pere,nom,type_hdf,dataspace, + H5P_DEFAULT)) < 0) + return -1; + } + else + if (mode != MED_REMP) + { + H5Dclose(dataset); + return -1; + } + else + if ((dataspace = H5Dget_space(dataset)) <0) + return -1; + + + switch(interlace) + { /* switch Interlace */ + case MED_FULL_INTERLACE : + + /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/ + if ( fixdim != MED_ALL) + { + firstdim = fixdim-1; + lastdim = fixdim; + dimutil = 1; + } else { + firstdim = 0; + lastdim = nbdim; + dimutil = nbdim; + } + + count [0] = (*size)/(nbdim); + + + if ( psize == MED_NOPF ) { + + /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */ + if ( (memspace = H5Screate_simple (1, size, NULL)) <0) + return -1; + + stride[0] = nbdim; + + for (dim=firstdim; dim < lastdim; dim++) { + + start_mem[0] = dim; + if ( (ret = H5Sselect_hyperslab (memspace, H5S_SELECT_SET, start_mem, stride, + count, NULL)) <0) + return -1; + + start_data[0] = dim*count[0]; + if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL, + count, NULL)) <0) + return -1; + + if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace, + H5P_DEFAULT, val)) < 0) + return -1; + } + + } else { /* psize != MED_NOPF */ + + pflsize [0] = psize*ngauss*nbdim; + pcount [0] = psize*ngauss*dimutil; +#ifdef HDF_NEW_API + pflmem = (med_size *) malloc (sizeof(med_size)*pcount[0]); + pfldsk = (med_size *) malloc (sizeof(med_size)*pcount[0]); +#else + pflmem = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]); + pfldsk = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]); +#endif + + switch(pflmod) + { /* switch pflmod pout FULL_INTERLACE*/ + case MED_GLOBALE : + + /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */ + if ( (memspace = H5Screate_simple (1, size, NULL)) <0) + return -1; + + for (dim=firstdim; dim < lastdim; dim++) { + + for (i=0; i < psize; i++) /* i balaye les élements du profil */ + for (j=0; j < ngauss; j++) { + index = i*ngauss+j + (dim-firstdim)*(psize*ngauss); + pflmem[index] = (pfltab[i]-1)*ngauss*nbdim + j*nbdim+dim; + pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j; + } + } + +#ifdef HDF_NEW_API + if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, pcount[0], (const hsize_t **) pflmem ) ) <0) + return -1; + + if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], (const hsize_t **) pfldsk ) ) <0) + return -1; +#else + if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pflmem ) ) <0) + return -1; + + if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pfldsk ) ) <0) + return -1; +#endif + + break; + + case MED_COMPACT : + + /* Creation d'un data space mémoire de dimension 1, de la longeur du profil */ + /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose */ + /* que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */ + + if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0) + return -1; + + for (dim=firstdim; dim < lastdim; dim++) { + + for (i=0; i < psize; i++) /* i balaye les élements du profil */ + for (j=0; j < ngauss; j++) { + index = i*ngauss+j + (dim-firstdim)*(psize*ngauss); + pflmem[index] = i*ngauss*nbdim + j*nbdim+dim; + pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j; + } + } + +#ifdef HDF_NEW_API + if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, pcount[0], (const hsize_t **) pflmem ) ) <0) + return -1; + + if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], (const hsize_t **) pfldsk ) ) <0) + return -1; +#else + if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pflmem ) ) <0) + return -1; + + if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pfldsk ) ) <0) + return -1; +#endif + + break; + + default : + return -1; + } + + if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0) + return -1; + + free(pflmem); + free(pfldsk); + } + + + break; + + case MED_NO_INTERLACE : + + /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/ + + count[0] = (*size)/nbdim; + + if ( psize == MED_NOPF ) { + + if ( fixdim != MED_ALL) + start_data[0] = (fixdim-1)*count[0]; + else { + count[0] = *size; + start_data[0] = 0; + }; + + if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL, + count, NULL)) <0) + return -1; + + if ((ret = H5Dwrite(dataset,type_hdf,dataspace,dataspace, + H5P_DEFAULT, val)) < 0) + return -1; + + } else { + + if ( fixdim != MED_ALL) + { + firstdim = fixdim-1; + lastdim = fixdim; + dimutil = 1; + } else { + firstdim = 0; + lastdim = nbdim; + dimutil = nbdim; + } + + pflsize [0] = psize*ngauss*nbdim; + pcount [0] = psize*ngauss*dimutil; /* nom pas très coherent avec count !!! A revoir */ +#ifdef HDF_NEW_API + pfldsk = (med_size *) malloc(sizeof(med_size)*pcount[0]); +#else + pfldsk = (med_ssize *) malloc(sizeof(med_ssize)*pcount[0]); +#endif + + switch(pflmod) + { /*switch plfmod pour NO_INTERLACE */ + case MED_GLOBALE : + + for (dim=firstdim; dim < lastdim; dim++) { + + for (i=0; i < psize; i++) /* i balaye le nbre d'élements du profil */ + for (j=0; j < ngauss; j++) { + index = i*ngauss+j + (dim-firstdim)*(psize*ngauss); + pfldsk[index] = dim*count[0]+(pfltab[i]-1)*ngauss+j; + } + } + +#ifdef HDF_NEW_API + if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], (const hsize_t **) pfldsk ) ) <0) + return -1; +#else + if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], (const hssize_t **) pfldsk ) ) <0) + return -1; +#endif + + if ((ret = H5Dwrite(dataset,type_hdf,dataspace,dataspace,H5P_DEFAULT, val)) < 0) + return -1; + + break; + + case MED_COMPACT : + + /* Creation d'un data space mémoire de dimension 1, de la longeur du profil */ + /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose */ + /* que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */ + + if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0) + return -1; + +#ifdef HDF_NEW_API + pflmem = (med_size *) malloc (sizeof(med_size)*pcount[0]); +#else + pflmem = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]); +#endif + + /* Le profil COMPACT est contigüe, mais il est possible que l'on selectionne uniquemenent une dimension*/ + + for (dim=firstdim; dim < lastdim; dim++) { + + for (i=0; i < psize; i++) /* i balaye le nbre d'élements du profil */ + for (j=0; j < ngauss; j++) { + index = i*ngauss+j + (dim-firstdim)*(psize*ngauss); + pflmem[index] = dim*(psize*ngauss) + (pfltab[i]-1)*ngauss+j; + pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j; + } + } + +#ifdef HDF_NEW_API + if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET,pcount[0], (const hsize_t **) pflmem ) ) <0) + return -1; + + if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], (const hsize_t **) pfldsk ) ) <0) + return -1; +#else + if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET,pcount[0], (const hssize_t **) pflmem ) ) <0) + return -1; + + if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], (const hssize_t **) pfldsk ) ) <0) + return -1; +#endif + + if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0) + return -1; + + free(pflmem); + + break; + + default : + return -1; + + } + + free(pfldsk); + + }; + + break; + + default : + return -1; + } + + + if (memspace) + if ((ret = H5Sclose(memspace)) < 0) + return -1; + + if ((ret = H5Sclose(dataspace)) < 0) + return -1; + + if ((ret = H5Dclose(dataset)) < 0) + return -1; + +#if defined(PCLINUX) + if (type == MED_INT32) + if ((H5Tconvert(H5T_STD_I32BE,H5T_NATIVE_INT,(hsize_t)*size,(void *)val,NULL,(hid_t)0)) < 0) + return -1; +#endif + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDdatasetNumLire.cxx b/src/MEDWrapper/V2_1/Core/MEDdatasetNumLire.cxx new file mode 100644 index 000000000..e6ce9c37a --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDdatasetNumLire.cxx @@ -0,0 +1,416 @@ +// Copyright (C) 2005 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/ +// +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" +#include +#include "hdf5_version2api.hxx" + +/* + * - Nom de la fonction : _MEDdatasetNumLire + * - Description : lecture d'un dataset tableau numerique + * - Parametres : + * - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut + * - nom (IN) : le nom du dataset + * - type (IN) : type numerique MED + * - interlace (IN) : Choix du type d'entrelacement demandé par l'appelant { MED_FULL_INTERLACE(x1,y1,z1,x2,...)) , MED_NO_INTERLACE(x1,x2,y1,y2,z1,z2) } + * - nbdim (IN) : Dimension des éléments + * - fixdim (IN) : MED_ALL ou n° de la dimension a enregistrer à partir de 1..oo + * - psize (IN) : Taille du profil à utiliser, MED_NOPF si pas de profil + * - pfltab (IN) : Tableau contenant les n° déléments à traiter (1....oo) + * - pflmod (IN) : PARAMETRE A AJOUTER : Indique comment lire les informations en mémoire { MED_COMPACT, MED_GLOBALE }. + * - ngauss (IN) : Nombre de points de GAUSS par élément + * - val (OUT) : valeurs du tableau + * - Resultat : 0 en cas de succes, -1 sinon + * Equivalent à l'ancienne routine si .....,MED_NO_INTERLACE,1,MED_ALL,MED_NOPF,0,1 (peu importe),.... + */ + +namespace med_2_1{ + +med_err +_MEDdatasetNumLire(med_idt pere,char *nom,med_type_champ type, + med_mode_switch interlace, med_size nbdim, med_size fixdim, + med_size psize, med_ssize * pfltab, med_int ngauss, + unsigned char *val) +{ + med_idt dataset, dataspace = 0, memspace = 0; +#ifdef HDF_NEW_API + med_size start_mem[1],start_data[1],*pflmem=0,*pfldsk=0; +#else + med_ssize start_mem[1],start_data[1],*pflmem=0,*pfldsk=0; +#endif + med_size stride[1],count[1],pcount[1],size[1],pflsize[1]; + med_err ret; + int i,j,index,type_hdf; + hid_t datatype; + size_t typesize; + int dim, firstdim, dimutil, lastdim; + med_mode_profil pflmod; + + /* Verify fixdim is between [0, nbdim] ( 0 is MED_ALL ) */ + if ( ( fixdim < 0 ) || ( fixdim > nbdim ) ) + return -1; + + /* block pflmod to MED_COMPACT (until med2.2) */ + pflmod = MED_COMPACT; + + switch(type) + { + case MED_REEL64 : + /* 1) IA32 is LE but due to an (?HDF convertion BUG?) when using H5T_NATIVE_DOUBLE/MED_REEL64? under PCLINUX + the file read under SGI is incorrect + 2) Compaq OSF/1 is LE, since we force SGI64,SUN4SOL2,HP to write double in LE even if they are BE, mips OSF/1 must be BE + REM : Be careful of compatibility between MED files when changing this (med2.2) */ +#if defined(PCLINUX) || defined(OSF1) + type_hdf = H5T_IEEE_F64BE; +#else + type_hdf = H5T_IEEE_F64LE; +#endif + break; + + case MED_INT32 : + type_hdf = H5T_NATIVE_INT; + break; + + case MED_INT64 : + type_hdf = H5T_NATIVE_LONG; + break; + + default : + return -1; + } + + /* Ouverture du Dataset à lire */ + if ((dataset = H5Dopen(pere,nom)) < 0) + return -1; + + /* Interrogation de la taille du dataset */ + if ( (datatype = H5Dget_type(dataset )) < 0) return -1; + if ( (typesize = H5Tget_size(datatype)) < 0) return -1; + size[0] = H5Dget_storage_size(dataset) / typesize; + if ( H5Tclose(datatype) < 0) return -1; + + /* Create dataspace */ + if ((dataspace = H5Screate_simple(1,size,NULL)) < 0) + return -1; + + switch(interlace) + { + case MED_FULL_INTERLACE : + + /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/ + if ( fixdim != MED_ALL) + { + firstdim = fixdim-1; + lastdim = fixdim; + dimutil = 1; + } else { + firstdim = 0; + lastdim = nbdim; + dimutil = nbdim; + } + + count [0] = (*size)/(nbdim); + + + /*rem: Pas de vérification de l'assertion (*size)=n*nbdim */ + if ( psize == MED_NOPF ) { + + /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */ + if ( (memspace = H5Screate_simple (1, size, NULL)) <0) + return -1; + + stride[0] = nbdim; + + for (dim=firstdim; dim < lastdim; dim++) { + + start_mem[0] = dim; + if ( (ret = H5Sselect_hyperslab (memspace, H5S_SELECT_SET, start_mem, stride, + count, NULL)) <0) + return -1; + + start_data[0] = dim*count[0]; + if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL, + count, NULL)) <0) + return -1; + + if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace, + H5P_DEFAULT, val)) < 0) + return -1; + } + + } else { + + pflsize [0] = psize*ngauss*nbdim; + pcount [0] = psize*ngauss*dimutil; +#ifdef HDF_NEW_API + pflmem = (med_size *) malloc (sizeof(med_size)*pcount[0]); + pfldsk = (med_size *) malloc (sizeof(med_size)*pcount[0]); +#else + pflmem = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]); + pfldsk = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]); +#endif + + switch(pflmod) + { /* switch pflmod pour FULL_INTERLACE*/ + case MED_GLOBALE : + + /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */ + if ( (memspace = H5Screate_simple (1, size, NULL)) <0) + return -1; + + for (dim=firstdim; dim < lastdim; dim++) { + + for (i=0; i < psize; i++) /* i balaye les élements du profil */ + for (j=0; j < ngauss; j++) { + index = i*ngauss+j + (dim-firstdim)*(psize*ngauss); + pflmem[index] = (pfltab[i]-1)*ngauss*nbdim + j*nbdim+dim; + pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j; + } + } + +#ifdef HDF_NEW_API + if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], (const hsize_t **) pflmem ) ) <0) + return -1; + + if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], (const hsize_t **) pfldsk ) ) <0) + return -1; +#else + if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], (const hssize_t **) pflmem ) ) <0) + return -1; + + if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pfldsk ) ) <0) + return -1; +#endif + + break; + + case MED_COMPACT : + + /* Creation d'un data space mémoire de dimension 1, de la longeur du profil */ + /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose */ + /* que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */ + + if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0) + return -1; + + for (dim=firstdim; dim < lastdim; dim++) { + + for (i=0; i < psize; i++) /* i balaye les élements du profil */ + for (j=0; j < ngauss; j++) { + index = i*ngauss+j + (dim-firstdim)*(psize*ngauss); + pflmem[index] = i*ngauss*nbdim + j*nbdim+dim; + pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j; + } + } + +#ifdef HDF_NEW_API + if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], (const hsize_t **) pflmem ) ) <0) + return -1; + + if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], (const hsize_t **) pfldsk ) ) <0) + return -1; +#else + if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], (const hssize_t **) pflmem ) ) <0) + return -1; + + if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pfldsk ) ) <0) + return -1; +#endif + + break; + + default : + return -1; + } + + if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0) + return -1; + + free(pflmem); + free(pfldsk); + } + + break; + + case MED_NO_INTERLACE : + + /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/ + + count[0] = (*size)/nbdim; + + if ( psize == MED_NOPF ) { + + if ( fixdim != MED_ALL) + start_data[0] = (fixdim-1)*count[0]; + else { + count[0] = *size; + start_data[0] = 0; + }; + + if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL, + count, NULL)) <0) + return -1; + + if ((ret = H5Dread(dataset,type_hdf,dataspace,dataspace, + H5P_DEFAULT, val)) < 0) + return -1; + + } else { + + if ( fixdim != MED_ALL) + { + firstdim = fixdim-1; + lastdim = fixdim; + dimutil = 1; + } else { + firstdim = 0; + lastdim = nbdim; + dimutil = nbdim; + } + + pflsize [0] = psize*ngauss*nbdim; + pcount [0] = psize*ngauss*dimutil; /* nom pas très coherent avec count !!! A revoir */ +#ifdef HDF_NEW_API + pfldsk = (med_size *) malloc(sizeof(med_size)*pcount[0]); +#else + pfldsk = (med_ssize *) malloc(sizeof(med_ssize)*pcount[0]); +#endif + + switch(pflmod) + { /*switch plfmod pour NO_INTERLACE */ + case MED_GLOBALE : + + for (dim=firstdim; dim < lastdim; dim++) { + + for (i=0; i < psize; i++) /* i balaye le nbre d'élements du profil */ + for (j=0; j < ngauss; j++) { + index = i*ngauss+j + (dim-firstdim)*(psize*ngauss); + pfldsk[index] = dim*count[0]+(pfltab[i]-1)*ngauss+j; + } + } + +#ifdef HDF_NEW_API + if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], (const hsize_t **) pfldsk ) ) <0) + return -1; +#else + if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], (const hssize_t **) pfldsk ) ) <0) + return -1; +#endif + + if ((ret = H5Dread(dataset,type_hdf,dataspace,dataspace,H5P_DEFAULT, val)) < 0) + return -1; + + break; + + case MED_COMPACT : + + /* Creation d'un data space mémoire de dimension 1, de la longeur du profil */ + /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose */ + /* que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */ + + if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0) + return -1; + +#ifdef HDF_NEW_API + pflmem = (med_size *) malloc (sizeof(med_size)*pcount[0]); +#else + pflmem = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]); +#endif + + /* Le profil COMPACT est contigüe, mais il est possible que l'on selectionne uniquemenent une dimension*/ + + for (dim=firstdim; dim < lastdim; dim++) { + + for (i=0; i < psize; i++) /* i balaye le nbre d'élements du profil */ + for (j=0; j < ngauss; j++) { + index = i*ngauss+j + (dim-firstdim)*(psize*ngauss); + pflmem[index] = dim*(psize*ngauss) + (pfltab[i]-1)*ngauss+j; + pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j; + } + } + +#ifdef HDF_NEW_API + if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], (const hsize_t **) pflmem ) ) <0) + return -1; + + if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], (const hsize_t **) pfldsk ) ) <0) + return -1; +#else + if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], (const hssize_t **) pflmem ) ) <0) + return -1; + + if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], (const hssize_t **) pfldsk ) ) <0) + return -1; +#endif + + if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0) + return -1; + + break; + + default : + return -1; + + } + + free(pfldsk); + + }; + + break; + + default : + return -1; + } + + + + if (memspace) + if ((ret = H5Sclose(memspace)) < 0) + return -1; + + if ((ret = H5Sclose(dataspace)) < 0) + return -1; + + if ((ret = H5Dclose(dataset)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDdatasetOuvrir.cxx b/src/MEDWrapper/V2_1/Core/MEDdatasetOuvrir.cxx new file mode 100644 index 000000000..b3e852cd1 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDdatasetOuvrir.cxx @@ -0,0 +1,44 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDdatasetOuvrir + * - Description : ouverture d'un objet HDF dataset + * - Parametres : + * - pid (IN) : l'ID de l'objet HDF pere + * - nom (IN) : le nom du dataset + * - Resultat : ID du dataset en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_idt +_MEDdatasetOuvrir(med_idt pid,char *nom) +{ + med_idt id; + + if ((id = H5Dopen(pid,nom)) < 0) + return -1; + + return id; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDdatasetStringEcrire.cxx b/src/MEDWrapper/V2_1/Core/MEDdatasetStringEcrire.cxx new file mode 100644 index 000000000..651f5a84d --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDdatasetStringEcrire.cxx @@ -0,0 +1,87 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDdatasetStringEcrire + * - Description : ecriture d'un dataset tableau de caracteres + * - Parametres : + * - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut + * - nom (IN) : le nom de l'attribut + * - dimd (IN) : profil du tableau + * - val (IN) : valeurs du tableau + * - mode (IN) : mode d'ecriture MED + * - Resultat : 0 en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +_MEDdatasetStringEcrire(med_idt pere,char *nom,med_size *dimd, + char *val, med_mode_acces mode) +{ + med_idt dataset; + med_idt datatype = 0; + med_idt dataspace = 0; + med_err ret; + + if ((dataset = H5Dopen(pere,nom)) < 0) + { + if ((dataspace = H5Screate_simple(1,dimd,NULL)) < 0) + return -1; + if((datatype = H5Tcopy(H5T_C_S1)) < 0) + return -1; + if((ret = H5Tset_size(datatype,1)) < 0) + return -1; + if ((dataset = H5Dcreate(pere,nom,datatype,dataspace, + H5P_DEFAULT)) < 0) + return -1; + } + else + if (mode != MED_REMP) + { + H5Dclose(dataset); + return -1; + } + else + { + if ((dataspace = H5Screate_simple(1,dimd,NULL)) < 0) + return -1; + if((datatype = H5Tcopy(H5T_C_S1)) < 0) + return -1; + if((ret = H5Tset_size(datatype,1)) < 0) + return -1; + } + if ((ret = H5Dwrite(dataset,datatype,H5S_ALL,H5S_ALL, + H5P_DEFAULT, val)) < 0) + return -1; + if (dataspace) + if((ret = H5Sclose(dataspace)) < 0) + return -1; + if (datatype) + if ((ret = H5Tclose(datatype)) < 0) + return -1; + if ((ret = H5Dclose(dataset)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDdatasetStringLire.cxx b/src/MEDWrapper/V2_1/Core/MEDdatasetStringLire.cxx new file mode 100644 index 000000000..017ccbf7b --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDdatasetStringLire.cxx @@ -0,0 +1,56 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDdatasetStringLire + * - Description : lecture d'un dataset tableau de caracteres + * - Parametres : + * - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut + * - nom (IN) : le nom de l'attribut + * - val (IN) : valeurs du tableau + * - Resultat : 0 en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +_MEDdatasetStringLire(med_idt pere,char *nom,char *val) +{ + med_idt dataset,datatype; + med_err ret; + + if ((dataset = H5Dopen(pere,nom)) < 0) + return -1; + if ((datatype = H5Tcopy(H5T_C_S1)) < 0) + return -1; + if ((ret = H5Tset_size(datatype,1)) < 0) + return -1; + if ((ret = H5Dread(dataset,datatype,H5S_ALL,H5S_ALL,H5P_DEFAULT,val)) < 0) + return -1; + if ((ret = H5Tclose(datatype)) < 0) + return -1; + if ((ret = H5Dclose(dataset)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDdimLire.cxx b/src/MEDWrapper/V2_1/Core/MEDdimLire.cxx new file mode 100644 index 000000000..3ca50c61f --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDdimLire.cxx @@ -0,0 +1,62 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ +med_int +MEDdimLire(med_idt fid, char *maillage) +{ + med_idt maaid; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + med_int dim; + + /* + * On inhibe le gestionnaire d'erreur + */ + _MEDmodeErreurVerrouiller(); + + /* + * On regarde si le groupe existe => erreur si non + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maillage); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * On va lire l'attribut dimension + */ + if ((ret = _MEDattrEntierLire(maaid,MED_NOM_DIM,&dim)) < 0) + return -1; + + /* + * Fermetures des objets HDF + */ + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return dim; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDelementsEcr.cxx b/src/MEDWrapper/V2_1/Core/MEDelementsEcr.cxx new file mode 100644 index 000000000..e67b44d38 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDelementsEcr.cxx @@ -0,0 +1,54 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" + +namespace med_2_1{ + +med_err +MEDelementsEcr(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch, + char *nom,med_booleen inom,med_int *num,med_booleen inum, + med_int *fam,med_int nele,med_entite_maillage typ_ent, + med_geometrie_element typ_geo,med_connectivite typ_conn, + med_mode_acces mode) +{ + med_err ret; + + /* Ecriture de la connectivite */ + if ((ret = MEDconnEcr(fid,maa,mdim,connectivite,mode_switch,nele,mode,typ_ent,typ_geo, + typ_conn)) < 0) + return -1; + + /* Ecriture des noms */ + if (inom == MED_VRAI) + if ((ret = MEDnomEcr(fid,maa,nom,nele,mode,typ_ent,typ_geo)) < 0) + return -1; + + /* Ecriture des numeros */ + if (inum == MED_VRAI) + if ((ret = MEDnumEcr(fid,maa,num,nele,mode,typ_ent,typ_geo)) < 0) + return -1; + + /* Ecriture des numeros de familles */ + if ((ret = MEDfamEcr(fid,maa,fam,nele,mode,typ_ent,typ_geo)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDelementsLire.cxx b/src/MEDWrapper/V2_1/Core/MEDelementsLire.cxx new file mode 100644 index 000000000..bdd85909e --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDelementsLire.cxx @@ -0,0 +1,55 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" + +namespace med_2_1{ + +med_err +MEDelementsLire(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch, + char *nom,med_booleen *inom,med_int *num,med_booleen *inum, + med_int *fam,med_int nele,med_entite_maillage typ_ent, + med_geometrie_element typ_geo,med_connectivite typ_conn) +{ + med_err ret; + + /* Lecure de la connectivite */ + if ((ret = MEDconnLire(fid,maa,mdim,connectivite,mode_switch,0,MED_NOPF, + typ_ent,typ_geo,typ_conn)) < 0) + return -1; + + /* Lecture des noms */ + if ((ret = MEDnomLire(fid,maa,nom,nele,typ_ent,typ_geo)) < 0) + *inom = MED_FAUX; + else + *inom = MED_VRAI; + + /* Lecture des numeros */ + if ((ret = MEDnumLire(fid,maa,num,nele,typ_ent,typ_geo)) < 0) + *inum = MED_FAUX; + else + *inum = MED_VRAI; + + /* Lecture des numeros de familles */ + if ((ret = MEDfamLire(fid,maa,fam,nele,typ_ent,typ_geo)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDequivCr.cxx b/src/MEDWrapper/V2_1/Core/MEDequivCr.cxx new file mode 100644 index 000000000..a5a3b816d --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDequivCr.cxx @@ -0,0 +1,78 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDequivCr(med_idt fid,char *maa, char *eq, char *desc) +{ + med_idt root,eqid; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+MED_TAILLE_NOM+1]; + char tmp[MED_TAILLE_EQS+1]; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le Data Group "EQS" n'existe pas, on le cree + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + strncpy(tmp,MED_EQS,MED_TAILLE_EQS-1); + tmp[MED_TAILLE_EQS-1] = '\0'; + strcat(chemin,tmp); + if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0) + if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) + return -1; + + /* + * Si une equivalence du meme nom existe => erreur + * Sinon on la cree + */ + if ((eqid = _MEDdatagroupOuvrir(root,eq)) >= 0) + return -1; + if ((eqid = _MEDdatagroupCreer(root,eq)) < 0) + return -1; + + /* + * L'attribut "DES" + */ + if ((ret = _MEDattrStringEcrire(eqid,MED_NOM_DES,MED_TAILLE_DESC,desc,MED_REMP)) < 0) + return -1; + + /* + * On ferme tout + */ + if ((ret = _MEDdatagroupFermer(eqid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(root)) < 0) + return -1; + + return 0 ; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDequivEcr.cxx b/src/MEDWrapper/V2_1/Core/MEDequivEcr.cxx new file mode 100644 index 000000000..dfa3f72b1 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDequivEcr.cxx @@ -0,0 +1,111 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +extern int mode_interlace; + +namespace med_2_1{ + +med_err +MEDequivEcr(med_idt fid, char *maa, char *eq, med_int *corr, med_int n, + med_mode_acces mode, med_entite_maillage typ_ent, med_geometrie_element typ_geo) +{ + med_idt eqid, datagroup; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1]; + char nomdatagroup[MED_TAILLE_NOM+1]; + char tmp[MED_TAILLE_NOM_ENTITE+1]; + med_size dimd[1]; + + if (typ_geo == MED_TETRA4 || typ_geo == MED_TETRA10 || + typ_geo == MED_HEXA8 || typ_geo == MED_HEXA20 || + typ_geo == MED_PENTA6 || typ_geo == MED_PENTA15 || + typ_geo == MED_PYRA5 || typ_geo == MED_PYRA13) + return -1; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le Data Group de "eq" n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + strcat(chemin,MED_EQS); + strcat(chemin,eq); + if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * Ecriture de l'equivalence + */ + if ((ret = _MEDnomEntite(nomdatagroup,typ_ent)) < 0) + return -1; + if ((typ_ent != MED_NOEUD)) + { + if ((ret = _MEDnomGeometrie(tmp,typ_geo)) < 0) + return -1; + strcat(nomdatagroup,"."); + strcat(nomdatagroup,tmp); + } + datagroup = 0; + if (((datagroup = _MEDdatagroupOuvrir(eqid,nomdatagroup)) > 0) && + (mode != MED_REMP)) + return -1; + else + if (datagroup > 0) + _MEDdatagroupFermer(datagroup); + + /* EF : verifier que çà marche si le data groupe existe déjà */ + if ((datagroup = _MEDdatagroupCreer(eqid,nomdatagroup)) < 0) + return -1; + + if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n,mode)) < 0) + return -1; + + dimd[0] = 2*n; + +#if defined(IRIX64)||defined(OSF1) + if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_COR,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, + (unsigned char*) corr,mode)) < 0) + return -1; +#else + if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_COR,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, + (unsigned char*) corr,mode)) < 0) + return -1; +#endif + + /* + * On ferme tout + */ + if ((ret = _MEDdatagroupFermer(datagroup)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(eqid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDequivInfo.cxx b/src/MEDWrapper/V2_1/Core/MEDequivInfo.cxx new file mode 100644 index 000000000..e031dec8a --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDequivInfo.cxx @@ -0,0 +1,73 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDequivInfo(int fid, char *maa, int ind, char *eq, char *des) +{ + med_idt eqid; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1]; + int num; + int idx; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * On recupere le nom de l'equivalence + */ + num = ind - 1; + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + strcat(chemin,MED_EQS); + if ((idx = _MEDobjetIdentifier(fid,chemin,num,eq)) < 0) + return -1; + + /* + * Si le Data Group eq n'existe pas => erreur + */ + strcat(chemin,eq); + if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * L'attribut "DES" + */ + if ((ret = _MEDattrStringLire(eqid,MED_NOM_DES,MED_TAILLE_DESC,des)) < 0) + return -1; + + /* + * On ferme tout + */ + if ((ret = _MEDdatagroupFermer(eqid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDequivLire.cxx b/src/MEDWrapper/V2_1/Core/MEDequivLire.cxx new file mode 100644 index 000000000..824e21c99 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDequivLire.cxx @@ -0,0 +1,99 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +extern int mode_interlace; + +namespace med_2_1{ + +med_err +MEDequivLire(med_idt fid, char *maa, char *eq, med_int *corr, med_int n, + med_entite_maillage typ_ent,med_geometrie_element typ_geo) +{ + med_idt eqid, datagroup; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1]; + char nomdatagroup[MED_TAILLE_NOM+1]; + char tmp[MED_TAILLE_NOM_ENTITE+1]; + + if (typ_geo == MED_TETRA4 || typ_geo == MED_TETRA10 || + typ_geo == MED_HEXA8 || typ_geo == MED_HEXA20 || + typ_geo == MED_PENTA6 || typ_geo == MED_PENTA15 || + typ_geo == MED_PYRA5 || typ_geo == MED_PYRA13) + return -1; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le Data Group de "eq" n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + strcat(chemin,MED_EQS); + strcat(chemin,eq); + if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * Lecture de l'equivalence + */ + if ((ret = _MEDnomEntite(nomdatagroup,typ_ent)) < 0) + return -1; + if ((typ_ent != MED_NOEUD)) + { + if ((ret = _MEDnomGeometrie(tmp,typ_geo)) < 0) + return -1; + strcat(nomdatagroup,"."); + strcat(nomdatagroup,tmp); + } + if ((datagroup = _MEDdatagroupOuvrir(eqid,nomdatagroup)) < 0) + return -1; +#if defined(IRIX64)||defined(OSF1) + if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_COR,MED_INT64, + MED_NO_INTERLACE,1,MED_ALL, + MED_NOPF,0,MED_NOPG, + (unsigned char *) corr)) < 0) + return -1; +#else + if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_COR,MED_INT32, + MED_NO_INTERLACE,1,MED_ALL, + MED_NOPF,0,MED_NOPG, + (unsigned char *) corr)) < 0) + return -1; +#endif + + /* + * On ferme tout + */ + if ((ret = _MEDdatagroupFermer(datagroup)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(eqid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDfam2groA.cxx b/src/MEDWrapper/V2_1/Core/MEDfam2groA.cxx new file mode 100644 index 000000000..b964f813a --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDfam2groA.cxx @@ -0,0 +1,208 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include +#include +#include +#include "med.hxx" + + +/*********************************************************************** + * FONCTION MEDfam2groA + * + * - DESCRIPTION : 1ere etape dans la conversion des familles de groupes + * MED en goupes de noeuds et d'elements. + * Calcul des tailles des tableaux a allouer pour stocker les + * groupes que l'on veut creer. + * Les parametres renvoyes sont : + * 1 - le nombre de groupes de noeuds a creer (ngn) + * 2 - le nombre de groupes d'elements (nge) + * 3 - le nombre total de noeuds composant l'ensemble des groupes + * de noeuds (nindn) + * 4 - le nombre total d'elements composant l'ensemble des groupes + * d'elements (ninde) + * Ces parametres doivent permettre de creer les tables suivantes : + * 1 - une table de taille (nindn) contenant pour chaque groupe + * de noeuds la liste des noeuds le composant. Cette table + * sera indexee par une table de taille (ngn) qui contiendra + * pour chaque noeud un numero d'indice. Une table de taille + * (ngn) qui contiendra la liste des noms des differents + * groupes de noeuds. + * 2 - idem pour les elements + * Le remplissage de ces tables est realise par la fonction + * MEDfam2groB(). + * + * - PARAMETRES : + * NOM .E/S. TYPE . DESCRIPTION + * ------------------------------------------------------------------- + * nfam .E . med_int . nombre de familles + * numfam .E . med_int*. table des numeros de familles + * numfamnoe .E . med_int*. table des numeros de familles + * . . . des noeuds + * nnoeuds .E . med_int . nombre de noeuds + * numfamele .E . med_int*. table des numeros de familles + * . . . des elements + * nelememts .E . . nombre total d'elements + * grofam .E . char* . liste des groupes de familles + * indfamgro .E . int* . liste des indices des groupes + * . . . de familles dans grofam + * ngn . S. med_int*. nombre de groupes de noeuds a + * . . creer + * nge . S. med_int*. nombre de groupes d'elements a + * . . creer + * nindn . S. med_int*. taille de la table + * . . des groupes de noeuds a creer + * ninde . S. med_int*. taille de la table + * . . des groupes d'elements + * + * - RESULTAT : 0 si succes et -1 sinon + * + ***********************************************************************/ + +namespace med_2_1{ + +med_err +MEDfam2groA (med_int nfam,med_int *numfam,med_int *numfamnoe, + med_int nnoeuds,med_int *numfamele,med_int nelements, + char *grofam,int *indfamgro, + med_int *ngn,med_int *nge,med_int *nindn,med_int *ninde) +{ + int i,j,k; + char groupe[MED_TAILLE_LNOM]; + char *nomgronoe,*nomgroele,*tmp; + med_int numc; + int nnoe = 0,nele = 0; + int flag = 0; + + *ngn = 0; + *nge = 0; + *nindn = 0; + *ninde = 0; + + tmp = NULL; + nomgronoe = NULL; + nomgroele = NULL; + + /* Pour chaque famille, on regarde s'il y a de nouveaux groupes + de noeuds ou d'elements a creer. Pour chaque nouveau groupe, + on compte le nombre de noeuds ou d'elements qui devront lui etre + rataches */ + for (i=1;i<=nfam;i++) + if ((*(indfamgro+i)-*(indfamgro+i-1))/MED_TAILLE_LNOM > 0) + { + /* on releve le numero de la famille courante */ + numc = *(numfam+i-1); + nnoe = 0; + nele = 0; + /* si c'est une famille de noeuds, on compte le nombre de + noeuds qui y sont rattaches */ + if (numc > 0) + for (j=0;j 0) + { + *nindn = *nindn+nnoe; + if (*ngn == 0) + { + *ngn = 1; + if ((nomgronoe=(char*)malloc(sizeof(char)*MED_TAILLE_LNOM)) + == NULL) + return -1; + strncpy(nomgronoe,groupe,MED_TAILLE_LNOM); + } + else + { + flag = 0; + for (k=0;k<(*ngn);k++) + if (strncmp(groupe,nomgronoe+k*MED_TAILLE_LNOM, + MED_TAILLE_LNOM) == 0) + flag = 1; + if (flag == 0) + { + *ngn = *ngn + 1; + if ((tmp=(char*)malloc(sizeof(char)* + MED_TAILLE_LNOM**ngn)) == NULL) + return -1; + strncpy(tmp,nomgronoe,MED_TAILLE_LNOM*(*ngn-1)); + strncpy(tmp+MED_TAILLE_LNOM*(*ngn-1),groupe, + MED_TAILLE_LNOM); + free(nomgronoe); + nomgronoe = tmp; + } + } + } + if (numc < 0) + { + *ninde = *ninde+nele; + if (*nge == 0) + { + *nge = 1; + if ((nomgroele=(char *)malloc(sizeof(char)* + MED_TAILLE_LNOM)) == NULL) + return -1; + strncpy(nomgroele,groupe,MED_TAILLE_LNOM); + } + else + { + flag = 0; + for (k=0;k<(*nge);k++) + if (strncmp(groupe,nomgroele+k*MED_TAILLE_LNOM, + MED_TAILLE_LNOM) == 0) + flag = 1; + if (flag == 0) + { + *nge = *nge + 1; + if ((tmp = (char*) malloc(sizeof(char)*MED_TAILLE_LNOM* + *nge)) == NULL) + return -1; + strncpy(tmp,nomgroele,MED_TAILLE_LNOM*(*nge-1)); + strncpy(tmp+MED_TAILLE_LNOM*(*nge-1), groupe, + MED_TAILLE_LNOM); + free(nomgroele); + nomgroele = tmp; + } + } + } + } + } + + /* nettoyage memoire */ + free(nomgronoe); + free(nomgroele); + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDfam2groB.cxx b/src/MEDWrapper/V2_1/Core/MEDfam2groB.cxx new file mode 100644 index 000000000..3dbea6071 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDfam2groB.cxx @@ -0,0 +1,245 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + + +#include +#include +#include +#include "med.hxx" + +/*********************************************************************** + * FONCTION MEDfam2groB + * + * - DESCRIPTION : 2e etape dans la conversion des familles MED en + * groupes de noeuds et d'elements. Les tables allouees a partir + * des parametres calcules par MEDfam2groA() sont passees en argument + * a MEDfam2groB et remplies par cette derniere fonction. + * Il s'agit de : + * 1 - la table des noms de groupes de noeuds, chaque nom ayant + * une taille de MED_TAILLE_LNOM + * 2 - la table des noms des groupes d'elements + * 3 - la table des groupes de noeuds -i.e. pour chaque groupe + * la liste des numeros des noeuds qui le composent + * 4 - la table d'indexation de la table des groupes de noeuds + * 5 - la table des groupes d'elements + * 6 - la table d'indexation de la table des groupes d'elements + * + * - PARAMETRES : + * NOM .E/S. TYPE . DESCRIPTION + * ------------------------------------------------------------------- + * nfam .E . med_int . nombre de familles + * numfam .E . med_int*. table des numeros de familles + * numfamnoe .E . med_int*. table des numeros de familles + * . . . des noeuds + * nnoeuds .E . med_int . nombre de noeuds + * numfamele .E . med_int*. table des numeros de familles + * . . . des elements + * nelememts .E . med_int . nombre total d'elements + * grofam .E . char* . liste des groupes de familles + * indfamgro .E . int* . liste des indices des groupes + * . . . de familles dans indfamgro + * numnoeuds .E . med_int*. numeros des noeuds + * numele .E . med_int*. numeros des elements + * ngn .E . med_int . nombre de groupes de noeuds + * nge .E . med_int . nombre de groupes d'elements + * nindn .E . med_int . nombre d'indices dans la table + * . . des groupes de noeuds a creer + * ninde .E . med_int . nombre d'indices dans la table + * . . des groupes d'elements + * nomgronoe . S. char* . noms des groupes de noeuds + * nomgroele . S. char* . noms des groupes d'elements + * indgronoe . S. int* . indices des groupes de noeuds + * indgroele . S. int* . indices des groupes d'elements + * tabgronoe . S. med_int*. table des groupes de noeuds + * tabgroele . S. med_int*. table des groupes d'elements + * + * - RESULTAT : 0 + * + ***********************************************************************/ + +namespace med_2_1{ + +med_err +MEDfam2groB(med_int nfam,med_int *numfam,med_int *numfamnoe, + med_int nnoeuds,med_int *numfamele,med_int nelements, + char *grofam,int *indfamgro,med_int *numnoeuds, + med_int *numele,med_int ngn,med_int nge,med_int nindn, + med_int ninde,char *nomgronoe,char *nomgroele, + int *indgronoe,int *indgroele, + med_int *tabgronoe,med_int *tabgroele) +{ + int i,j,k; + char groupe[MED_TAILLE_LNOM]; + med_int numc; + int nnoe = 0, nele = 0; + int flag = 0; + int nn = 0, ne = 0; + int pos, cpt; + + /* initialisations */ + for (i=0;i<=ngn;i++) + *(indgronoe+i) = 0; + for (i=0;i<=nge;i++) + *(indgroele+i) = 0; + + /* 1ere passe : on passe en revue toutes les familles : + 1 - on etablit dans (nomgronoe) et dans (nomgroele) les listes + des noms de groupes de noeuds et d'elements + 2 - on place dans les tables d'index (indgronoe) et (indgroele) + le nombre de noeuds ou d'elements que chaque groupe se verra + attribuer */ + for (i=1;i<=nfam;i++) + { + numc = *(numfam+i-1); + nnoe = 0; + nele = 0; + if (numc > 0) + for (j=0;j 0) + { + if (nn == 0) + { + strncpy(nomgronoe,groupe,MED_TAILLE_LNOM); + nn = 1; + pos = 1; + } + else + { + flag = 0; + for (k=0; k 0) + { + flag = 0; + for (k=0;k<(*(indfamgro+j)-*(indfamgro+j-1))/MED_TAILLE_LNOM; + k++) + if (! strncmp(groupe, + grofam+*(indfamgro+j-1)+k*MED_TAILLE_LNOM, + MED_TAILLE_LNOM)) + flag = 1; + if (flag == 1) + for (k=0;k +#include + +namespace med_2_1{ + +med_err +MEDfamCr(med_idt fid,char* maa,char *famille,med_int numero, + med_int *attr_ident, med_int *attr_val, char *attr_desc, + med_int n_attr,char *groupe, med_int n_groupe) +{ + med_idt root, datagroup, famid; + med_err ret; + med_size dimd[1]; + char chemin[MED_TAILLE_MAA+MED_TAILLE_FAS+MED_TAILLE_NOM+1]; + char tmp[MED_TAILLE_FAS+1]; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le Data Group FAS n'existe pas, on le cree + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + strncpy(tmp,MED_FAS,MED_TAILLE_FAS-1); + tmp[MED_TAILLE_FAS-1] = '\0'; + strcat(chemin,tmp); + if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0) + if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) + return -1; + + /* + * Si le Data Group de meme nom que famille existe => erreur + * Sinon on le cree + */ + if ((famid = _MEDdatagroupOuvrir(root,famille)) >= 0) + return -1; + if ((famid = _MEDdatagroupCreer(root,famille)) < 0) + return -1; + + /* + * L'attribut NUM + */ + if ((ret = _MEDattrEntierEcrire(famid,MED_NOM_NUM,&numero,MED_REMP)) < 0) + return -1; + + /* + * Le Data Group "GRO" + */ + if (n_groupe > 0) + { + /* + * On cree le Data Group + */ + if ((datagroup = _MEDdatagroupCreer(famid,MED_NOM_GRO)) < 0) + return -1; + + /* + * L'attribut "NBR" + */ + if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n_groupe,MED_REMP)) < 0) + return -1; + + /* + * Data Set des noms des groupes "NOM" + */ + dimd[0] = n_groupe*MED_TAILLE_LNOM+1; + if ((ret = _MEDdatasetStringEcrire(datagroup,MED_NOM_NOM,dimd,groupe, + MED_REMP))<0) + return -1; + + /* + * On ferme le Data Group + */ + if ((ret = _MEDdatagroupFermer(datagroup)) < 0) + return -1; + } + + /* + * Le Data Group "ATT" + */ + + if (n_attr > 0) + { + if ((datagroup = _MEDdatagroupCreer(famid,MED_NOM_ATT)) < 0) + return -1; + + /* + * L'attribut "NBR" + */ + if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n_attr,MED_REMP)) < 0) + return -1; + + /* + * Le Data Set "IDE" + */ + dimd[0] = n_attr; +#if defined(IRIX64)||defined(OSF1) + if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_IDE,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, + (unsigned char *)attr_ident,MED_REMP)) < 0) + return -1; +#else + if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_IDE,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, + (unsigned char *)attr_ident,MED_REMP)) < 0) + return -1; +#endif + + /* + * Le Data Set "VAL" + */ + dimd[0] = n_attr; +#if defined(IRIX64)||defined(OSF1) + if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_VAL,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, + (unsigned char*)attr_val,MED_REMP)) < 0) + return -1; +#else + if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_VAL,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, + (unsigned char*)attr_val,MED_REMP)) < 0) + return -1; +#endif + + /* + * Le Data Set "DES" + */ + dimd[0] = n_attr*MED_TAILLE_DESC+1; + if ((ret = _MEDdatasetStringEcrire(datagroup,MED_NOM_DES,dimd,attr_desc, + MED_REMP)) < 0) + return -1; + + /* + * On ferme le Data Group + */ + if ((ret = _MEDdatagroupFermer(datagroup)) < 0) + return -1; + } + + /* + * On ferme tout + */ + if ((ret = _MEDdatagroupFermer(famid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(root)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDfamEcr.cxx b/src/MEDWrapper/V2_1/Core/MEDfamEcr.cxx new file mode 100644 index 000000000..e6beb4bf9 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDfamEcr.cxx @@ -0,0 +1,123 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDfamEcr(med_idt fid,char *maa, med_int *fam, med_int n, med_mode_acces mode, + med_entite_maillage type_ent, med_geometrie_element type_geo) +{ + med_idt root, maaid, entid, geoid, dataset; + med_err ret; + med_size dimd[1]; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + char nom_ent[MED_TAILLE_NOM_ENTITE+1]; + char nom_geo[MED_TAILLE_NOM_ENTITE+1]; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le maillage n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * On met a jour le nom du Data Group representant + * le type des entites + */ + if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) + return -1; + + /* + * Si le Data Group des entites n'existe pas on le cree + */ + if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) + if ((entid = _MEDdatagroupCreer(maaid,nom_ent)) < 0) + return -1; + + /* + * Pour les mailles, les faces et le aretes, on cree + * s'il n'existe pas le Data Group du type geometrique + */ + if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE)) + { + if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) + return -1; + + if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) + if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0) + return -1; + } + else + geoid = -1; + + /* + * Creation du Data Set "FAM" + */ + if (geoid == -1) + root = entid; + else + root = geoid; + dimd[0] = n; +#if defined(IRIX64) || defined(OSF1) + if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_FAM,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, + (unsigned char*)fam,mode)) < 0) + return -1; +#else + if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_FAM,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, + (unsigned char*)fam,mode)) < 0) + return -1; +#endif + + /* + * Attribut NBR (nombre de noeuds) + */ + if ((dataset = _MEDdatasetOuvrir(root,MED_NOM_FAM)) < 0) + return -1; + if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n,mode)) < 0) + return -1; + + /* + * On ferme tout + */ + if ((ret = _MEDdatasetFermer(dataset)) < 0) + return -1; + if (geoid != -1) + if ((ret = _MEDdatagroupFermer(geoid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(entid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDfamGridEcr.cxx b/src/MEDWrapper/V2_1/Core/MEDfamGridEcr.cxx new file mode 100644 index 000000000..be590c651 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDfamGridEcr.cxx @@ -0,0 +1,58 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" + +namespace med_2_1{ + +med_err +MEDfamGridEcr(med_idt fid, char *maa, med_int *fam, med_int n, med_mode_acces mode, med_entite_maillage type_ent) { + /* Ecrire des numeros de familles pour les grilles cartesiennes ou polaires : + - pour les noeuds + - pour les aretes + - pour les faces + - pour les mailles */ + + med_geometrie_element type_geo; + + switch(type_ent) { + case MED_NOEUD : { + type_geo = MED_POINT1; + break; + }; + case MED_ARETE : { + type_geo = MED_SEG2; + break; + }; + case MED_FACE : { + type_geo = MED_QUAD4; + break; + }; + case MED_MAILLE : { + type_geo = MED_HEXA8; + break; + }; + default : { + return(-1); + }; + }; + + return(MEDfamEcr(fid, maa, fam, n, mode, type_ent, type_geo)); +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDfamGridLire.cxx b/src/MEDWrapper/V2_1/Core/MEDfamGridLire.cxx new file mode 100644 index 000000000..2f89144e9 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDfamGridLire.cxx @@ -0,0 +1,58 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" + +namespace med_2_1{ + +med_err +MEDfamGridLire(med_idt fid, char *maa, med_int *fam, med_int n, med_entite_maillage type_ent) { + /* lecture des numeros de familles pour les grilles cartesiennes ou polaires : + - pour les noeuds + - pour les aretes + - pour les faces + - pour les mailles */ + + med_geometrie_element type_geo; + + switch(type_ent) { + case MED_NOEUD : { + type_geo = MED_POINT1; + break; + }; + case MED_ARETE : { + type_geo = MED_SEG2; + break; + }; + case MED_FACE : { + type_geo = MED_QUAD4; + break; + }; + case MED_MAILLE : { + type_geo = MED_HEXA8; + break; + }; + default : { + return(-1); + }; + }; + + return(MEDfamLire(fid, maa, fam, n, type_ent, type_geo)); +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDfamInfo.cxx b/src/MEDWrapper/V2_1/Core/MEDfamInfo.cxx new file mode 100644 index 000000000..b4527b122 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDfamInfo.cxx @@ -0,0 +1,160 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDfamInfo(med_idt fid,char *maa,int indice, char *famille, + med_int *numero, + med_int *attr_ident, med_int *attr_val, char *attr_desc, + med_int *n_attr, char *groupe ,med_int *n_groupe) +{ + med_idt famid,datagroup; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_FAS+2*MED_TAILLE_NOM+1]; + int num; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * On recupere le nom de la famille + */ + num = indice - 1; + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + strcat(chemin,MED_FAS); + if ((ret = _MEDobjetIdentifier(fid,chemin,num,famille)) < 0) + return -1; + + /* + * Si le Data Group de la famille n'existe pas => erreur + */ + strcat(chemin,famille); + if ((famid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * L'attribut NUM + */ + if ((ret = _MEDattrEntierLire(famid,MED_NOM_NUM,numero)) < 0) + return -1; + + /* + * Le Data Group "GRO" + */ + if ((datagroup = _MEDdatagroupOuvrir(famid,MED_NOM_GRO)) >= 0) + { + /* + * L'attribut "NBR" + */ + if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,n_groupe)) < 0) + return -1; + + /* + * Data Set des noms des groupes "NOM" + */ + if ((ret = _MEDdatasetStringLire(datagroup,MED_NOM_NOM,groupe)) < 0) + return -1; + + /* + * On ferme le Data Group + */ + if ((ret = _MEDdatagroupFermer(datagroup)) < 0) + return -1; + } + else + *n_groupe = 0; + + /* + * Le Data Group "ATT" + */ + if ((datagroup = _MEDdatagroupOuvrir(famid,MED_NOM_ATT)) >= 0) + { + /* + * L'attribut "NBR" + */ + if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,n_attr)) < 0) + return -1; + + /* + * Le Data Set "IDE" + */ +#if defined(IRIX64)||defined(OSF1) + if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_IDE,MED_INT64, + MED_NO_INTERLACE,1,MED_ALL, + MED_NOPF,0,MED_NOPG, + (unsigned char*) attr_ident)) < 0) + return -1; +#else + if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_IDE,MED_INT32, + MED_NO_INTERLACE,1,MED_ALL, + MED_NOPF,0,MED_NOPG, + (unsigned char*) attr_ident)) < 0) + return -1; +#endif + + /* + * Le Data Set "VAL" + */ +#if defined(IRIX64)||defined(OSF1) + if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_VAL,MED_INT64, + MED_NO_INTERLACE,1,MED_ALL, + MED_NOPF,0,MED_NOPG, + (unsigned char *) attr_val)) < 0) + return -1; +#else + if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_VAL,MED_INT32, + MED_NO_INTERLACE,1,MED_ALL, + MED_NOPF,0,MED_NOPG, + (unsigned char *) attr_val)) < 0) + return -1; +#endif + + /* + * Le Data Set "DES" + */ + ret = _MEDdatasetStringLire(datagroup,MED_NOM_DES,attr_desc); + + /* + * On ferme le Data Group + */ + if ((ret = _MEDdatagroupFermer(datagroup)) < 0) + return -1; + } + else + *n_attr = 0; + + /* + * On ferme tout + */ + if ((ret = _MEDdatagroupFermer(famid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDfamLire.cxx b/src/MEDWrapper/V2_1/Core/MEDfamLire.cxx new file mode 100644 index 000000000..501b98f7c --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDfamLire.cxx @@ -0,0 +1,112 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDfamLire(med_idt fid,char *maa, med_int *fam, med_int n, + med_entite_maillage type_ent,med_geometrie_element type_geo) +{ + med_idt root,maaid, entid, geoid; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + char nom_ent[MED_TAILLE_NOM_ENTITE+1]; + char nom_geo[MED_TAILLE_NOM_ENTITE+1]; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le maillage n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * On met a jour le nom du Data Group representant + * le type des entites + */ + if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) + return -1; + + /* + * Si le Data Group des entites n'existe pas => erreur + */ + if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) + return -1; + + /* + * Pour les mailles, les faces et le aretes, on cree + * si le Data Group du type geometrique => erreur + */ + if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE)) + { + if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) + return -1; + if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) + return -1; + } + else + geoid = -1; + + /* + * lecture du Data Set "FAM" + */ + if (geoid == -1) + root = entid; + else + root = geoid; +#if defined(IRIX64)||defined(OSF1) + if ((ret = _MEDdatasetNumLire(root,MED_NOM_FAM,MED_INT64, + MED_NO_INTERLACE,1,MED_ALL, + MED_NOPF,0,MED_NOPG, + (unsigned char *)fam)) < 0) + return -1; +#else + if ((ret = _MEDdatasetNumLire(root,MED_NOM_FAM,MED_INT32, + MED_NO_INTERLACE,1,MED_ALL, + MED_NOPF,0,MED_NOPG, + (unsigned char *)fam)) < 0) + return -1; +#endif + + /* + * On ferme tout + */ + if (geoid != -1) + if ((ret = _MEDdatagroupFermer(geoid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(entid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDfamMaaCr.cxx b/src/MEDWrapper/V2_1/Core/MEDfamMaaCr.cxx new file mode 100644 index 000000000..f7dc6d2b4 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDfamMaaCr.cxx @@ -0,0 +1,71 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include + +namespace med_2_1{ + +med_err +MEDfamMaaCr(med_idt fid,char *maa, + med_int *numfam,med_int *attide, + med_int *attval,char *attdes,int *indatt,char *gro,int *indgro, + med_int nfamilles) +{ + med_err ret; + med_int i; + med_int natt,ngro; + med_int numf; + char nomfam[MED_TAILLE_NOM+1]; + + /* La famille de numero 0 n'a aucun attribut, ni aucun groupe + Les familles de numero > 0 sont des familles de noeuds + Les familles de numero < 0 sont des familles d'elements */ + for (i=0;i 0) + { + strcpy(nomfam,"FAMILLE_NOEUD_"); + sprintf(nomfam,"%s%d",nomfam,numf); + nomfam[MED_TAILLE_NOM] = '\0'; + } + if (numf < 0) + { + strcpy(nomfam,"FAMILLE_ELEMENT_"); + sprintf(nomfam,"%s%d",nomfam,-numf); + nomfam[MED_TAILLE_NOM] = '\0'; + } + natt = *(indatt+i+1) - *(indatt+i); + ngro = (*(indgro+i+1) - *(indgro+i))/MED_TAILLE_LNOM; + if ((ret = MEDfamCr(fid,maa,nomfam,numf, + attide+*(indatt+i), + attval+*(indatt+i), + attdes+*(indatt+i)*MED_TAILLE_DESC,natt, + gro+*(indgro+i),ngro)) < 0) + return -1; + } + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDfamMaaInfo.cxx b/src/MEDWrapper/V2_1/Core/MEDfamMaaInfo.cxx new file mode 100644 index 000000000..9868abfbd --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDfamMaaInfo.cxx @@ -0,0 +1,52 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + + +#include "med.hxx" + +namespace med_2_1{ + +med_err +MEDfamMaaInfo(med_idt fid,char *maa,med_int *nfam,med_int *nattc, + med_int *ngroc) +{ + med_int ret; + med_int i; + + /* Lecture du nombre de familles */ + if ((*nfam = MEDnFam(fid,maa,0,(med_dim_famille)0)) < 0) + return -1; + + /* Lecture des nombres cumules de groupes et d'attributs dans toutes + les familles du maillage */ + *nattc = 0; + *ngroc = 0; + for (i=0;i<*nfam;i++) + { + if ((ret = MEDnFam(fid,maa,i+1,MED_ATTR)) < 0) + return -1; + *nattc += ret; + if ((ret = MEDnFam(fid,maa,i+1,MED_GROUPE)) < 0) + return -1; + *ngroc += ret; + } + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDfamMaaLire.cxx b/src/MEDWrapper/V2_1/Core/MEDfamMaaLire.cxx new file mode 100644 index 000000000..ed3401a9b --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDfamMaaLire.cxx @@ -0,0 +1,50 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +namespace med_2_1{ + +med_err +MEDfamMaaLire(med_idt fid,char *maa,med_int *numfam,med_int *attide, + med_int *attval,char *attdes,int *indatt,char *gro,int *indgro, + med_int nfamilles) +{ + med_err ret; + med_int natt,ngro; + med_int i; + char nom[MED_TAILLE_NOM+1]; + + *indatt = 0; + *indgro = 0; + for (i=0;i + +namespace med_2_1{ + +med_err +MEDfichDesEcr(med_idt fid, char *des, med_mode_acces mode) +{ + med_idt attr; + med_idt root; + med_err ret; + char nom[] = MED_NOM_DESCRIPTEUR; + char chemin[MED_TAILLE_MAA+1]; + + /* + * On inhibe le gestionnaire d'erreur + */ + _MEDmodeErreurVerrouiller(); + + /* + * On ouvre le Data Group racine + * s'il n'existe pas on le cree + */ + strncpy(chemin,MED_MAA,MED_TAILLE_MAA-1); + chemin[MED_TAILLE_MAA-1] = '\0'; + if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0) + if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) + return -1; + + /* + * On regarde si l'attribut existe + * Si oui on le met a jour en fonction + * du mode d'ouverture, sinon on le cree + */ + + if ((ret = _MEDattrStringEcrire(root,nom,MED_TAILLE_DESC,des,mode)) < 0) + return -1; + + /* + * Fermetures + */ + + if ((ret = _MEDdatagroupFermer(root)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDfichEntete.cxx b/src/MEDWrapper/V2_1/Core/MEDfichEntete.cxx new file mode 100644 index 000000000..b191d3a4a --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDfichEntete.cxx @@ -0,0 +1,79 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include + +namespace med_2_1{ + +med_err +MEDfichEntete(med_idt fid, med_fich_info quoi, char str[]) +{ + med_idt atid, root; + med_err ret; + char locale[MED_TAILLE_DESC+1]; + char chemin[MED_TAILLE_MAA+1]; + + switch (quoi) + { + case MED_HDF_VERSION : + strcpy(str,HDF_VERSION_ACTUELLE); + break; + + case MED_VERSION : + strcpy(str,MED_VERSION_ACTUELLE); + break; + + case MED_FICH_DES : + /* + * On inhibe le gestionnaire d'erreur HDF + */ + _MEDmodeErreurVerrouiller(); + + /* + * On ouvre le Data Group racine + */ + strncpy(chemin,MED_MAA,strlen(MED_MAA)-1); + chemin[MED_TAILLE_MAA-1] = '\0'; + if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * On regarde si l'attribut existe + * Si non => erreur + * Si oui => on le copie dans str + */ + if ((ret = _MEDattrStringLire(root,MED_NOM_DESCRIPTEUR, + MED_TAILLE_DESC,locale)) < 0) + return -1; + strcpy(str,locale); + + if ((ret == _MEDdatagroupFermer(root)) < 0) + return -1; + + break; + + default : + return -1; + } + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDfichierCreer.cxx b/src/MEDWrapper/V2_1/Core/MEDfichierCreer.cxx new file mode 100644 index 000000000..dd72e8b4b --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDfichierCreer.cxx @@ -0,0 +1,71 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDfichierCreer + * - Description : creation d'un fichier HDF + * - Parametres : + * - nom (IN) : le nom du fichier + * - Resultat : ID du fichier en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_idt +_MEDfichierCreer(char *nom) +{ + med_idt fid,gid; + med_err ret; + med_int majeur = MED_NUM_MAJEUR; + med_int mineur = MED_NUM_MINEUR; + med_int release = MED_NUM_RELEASE; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + if ((fid = H5Fcreate(nom,H5F_ACC_TRUNC, + H5P_DEFAULT,H5P_DEFAULT)) < 0) + return -1; + + if ((gid = _MEDdatagroupCreer(fid,MED_NOM_INFOS)) < 0) + return -1; + + /* Numero de versions de MED */ + if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_MAJEUR,&majeur,MED_REMP)) < 0) + return -1; + + if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_MINEUR,&mineur,MED_REMP)) < 0) + return -1; + + if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_RELEASE,&release,MED_REMP)) < 0) + return -1; + + /* On ferme tout */ + if ((ret = _MEDdatagroupFermer(gid)) < 0) + return -1; + + return fid; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDfichierFermer.cxx b/src/MEDWrapper/V2_1/Core/MEDfichierFermer.cxx new file mode 100644 index 000000000..c0024e544 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDfichierFermer.cxx @@ -0,0 +1,43 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDfichierFermer + * - Description : fermeture d'un fichier HDF + * - Parametres : + * - fid (IN) : ID du fichier + * - Resultat : 0 en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +_MEDfichierFermer(med_idt fid) +{ + med_err ret; + + if ((ret = H5Fclose(fid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDfichierOuvrir.cxx b/src/MEDWrapper/V2_1/Core/MEDfichierOuvrir.cxx new file mode 100644 index 000000000..593fbd675 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDfichierOuvrir.cxx @@ -0,0 +1,60 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDfichierOuvrir + * - Description : ouverture d'un fichier HDF en fonction du mode passe + * en parametre + * - Parametres : + * - nom (IN) : le nom du fichier + * - mode (IN) : mode d'ouverture + * - Resultat : ID du fichier en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_idt +_MEDfichierOuvrir(char *nom,med_mode_acces mode) +{ + med_idt fid; + int hdf_mode; + + switch(mode) + { + case MED_ECRI : + hdf_mode = H5F_ACC_RDWR; + break; + + case MED_LECT : + hdf_mode = H5F_ACC_RDONLY; + break; + + default : + return -1; + } + + if ((fid = H5Fopen(nom,hdf_mode,H5P_DEFAULT)) < 0) + return -1; + + return fid; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDformatConforme.cxx b/src/MEDWrapper/V2_1/Core/MEDformatConforme.cxx new file mode 100644 index 000000000..d5ddea8b3 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDformatConforme.cxx @@ -0,0 +1,40 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +namespace med_2_1{ + +med_err +MEDformatConforme(const char * nomfich) +{ + + /* + * On inhibe le gestionnaire d'erreur + */ + _MEDmodeErreurVerrouiller(); + + + if ( H5Fis_hdf5(nomfich) > 0 ) + return 0; + else + return -1; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDfstring.cxx b/src/MEDWrapper/V2_1/Core/MEDfstring.cxx new file mode 100644 index 000000000..e1bc4faae --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDfstring.cxx @@ -0,0 +1,47 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include + +/* + * Chaine C -> chaine FORTRAN completee par des blancs + */ + +namespace med_2_1{ + +med_err +_MEDfstring(char *chaine, med_int longueur_fixee) +{ + int longueur_reelle, i; + + if (longueur_fixee == 0 ) return 0; + + longueur_reelle = strlen(chaine); + if (longueur_fixee < longueur_reelle) + return -1; + + /* on supprime le caractere de fin de chaine C '\0' + et complete par des blancs */ + for (i=longueur_reelle;i erreur */ + if (_MEDdatagroupOuvrir(root, maillage) > 0) { + return(-1); + }; + + /* Creation du Data Group */ + maaid = _MEDdatagroupCreer(root, maillage); + if (maaid < 0) return(-1); + + /* Creation de l'attribut dimension */ + if (_MEDattrEntierEcrire(maaid, MED_NOM_DIM, &dim, MED_REMP) < 0) { + return(-1); + }; + + /* Creation de l'attribut grille */ + if (_MEDattrEntierEcrire(maaid, MED_NOM_GRD, &typ, MED_REMP) < 0) { + return(-1); + }; + + /* Nettoyages divers */ + if ( _MEDdatagroupFermer(maaid) < 0) return(-1); + if (_MEDdatagroupFermer(root) < 0) return(-1); + return(0); +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDgridEcr.cxx b/src/MEDWrapper/V2_1/Core/MEDgridEcr.cxx new file mode 100644 index 000000000..3acc181ee --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDgridEcr.cxx @@ -0,0 +1,109 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med_outils.hxx" +#include "med.hxx" + +namespace med_2_1{ + +med_err +MEDgridEcr(med_idt fid, char *maa, med_int mdim, med_float *coo, med_int nb, med_int dim, med_mode_switch mode_coo, + med_repere repere, char *nomcoo, char *unicoo, med_mode_acces mode ) +{ + /* ecriture des indices */ + + med_idt maaid, noeid, ds; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + med_size dimd[1]; + char *dataset; + med_int type_rep_int; + + /* On inhibe le gestionnaire d'erreur HDF */ + _MEDmodeErreurVerrouiller(); + + /* Si le maillage n'existe pas => erreur */ + strcpy(chemin, MED_MAA); + strcat(chemin, maa); + maaid = _MEDdatagroupOuvrir(fid, chemin); + if (maaid < 0) return(-1); + + /* Si le Data Group "NOE" n'existe pas on le cree */ + if ((noeid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE)) < 0) { + if ((noeid = _MEDdatagroupCreer(maaid, MED_NOM_NOE)) < 0) { + return(-1); + }; + }; + + switch (dim) { + case 0 : { + dataset = MED_NOM_IN1; + break; + }; + case 1 : { + dataset = MED_NOM_IN2; + break; + }; + case 2 : { + dataset = MED_NOM_IN3; + break; + }; + default : { + return(-1); + }; + }; + + /* Creation du Data Set "IN1" ou "IN2" ou "IN3" */ + dimd[0] = nb; + if (_MEDdatasetNumEcrire(noeid, dataset, MED_REEL64, mode_coo, 1, MED_ALL, MED_NOPF, 0, 0, dimd, (unsigned char*)coo, mode) < 0) { + return(-1); + }; + + /* On re-ouvre le Data Set "IN1" ou "IN2" ou "IN3" pour y placer des attributs */ + if ((ds = _MEDdatasetOuvrir(noeid, dataset)) < 0) { + return(-1); + }; + + /* Attribut NBR (nombre de noeuds) */ + if (_MEDattrEntierEcrire(ds, MED_NOM_NBR, &nb, mode) < 0) { + return(-1); + }; + + /* L'attribut "REP" */ + type_rep_int = (med_int)repere; + if (_MEDattrEntierEcrire(ds, MED_NOM_REP, &type_rep_int, mode) < 0) { + return(-1); + }; + + /* Attribut "NOM" */ + if (_MEDattrStringEcrire(ds, MED_NOM_NOM, mdim*MED_TAILLE_PNOM, nomcoo, mode) < 0) { + return(-1); + }; + + /* Attribut "UNI" */ + if (_MEDattrStringEcrire(ds, MED_NOM_UNI, mdim*MED_TAILLE_PNOM, unicoo, mode) < 0) { + return(-1); + }; + + /* On ferme tout */ + if (_MEDdatasetFermer(ds) < 0) return(-1); + if (_MEDdatagroupFermer(noeid) < 0) return(-1); + if (_MEDdatagroupFermer(maaid) < 0) return(-1); + return(0); +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDgridInfo.cxx b/src/MEDWrapper/V2_1/Core/MEDgridInfo.cxx new file mode 100644 index 000000000..43de1b2dd --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDgridInfo.cxx @@ -0,0 +1,60 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDgridInfo(med_idt fid, int indice, med_int *isAGrid, med_grid_type *typ) +{ + int numero; + med_idt maaid; + char maillage[MED_TAILLE_NOM+1]; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + + /* On inhibe le gestionnaire d'erreur */ + _MEDmodeErreurVerrouiller(); + + /* On recupere le nom du groupe de rang "indice" */ + numero = indice-1; + if (_MEDobjetIdentifier(fid, MED_MAA, numero, maillage) < 0) { + return(-1); + }; + + /* On va chercher l'attribut dimension */ + strcpy(chemin, MED_MAA); + strcat(chemin, maillage); + maaid = _MEDdatagroupOuvrir(fid, chemin); + if (maaid < 0) return(-1); + + if (_MEDattrEntierLire(maaid, MED_NOM_GRD, typ) < 0) { + *isAGrid = 0; + } else { + *isAGrid = 1; + }; + + if (_MEDdatagroupFermer(maaid) < 0) return(-1); + return(0); +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDgridLire.cxx b/src/MEDWrapper/V2_1/Core/MEDgridLire.cxx new file mode 100644 index 000000000..032266335 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDgridLire.cxx @@ -0,0 +1,85 @@ +#include "med_outils.hxx" +#include "med.hxx" + +namespace med_2_1{ + +med_err +MEDgridLire(med_idt fid, char *maa, med_int mdim, med_float *coo, med_int dim, med_mode_switch mode_coo, + med_repere *repere, char *nomcoo, char *unicoo ) +{ + med_idt maaid, noeid, ds; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + char *dataset; + med_int type_rep_int; + + /* On inhibe le gestionnaire d'erreur */ + _MEDmodeErreurVerrouiller(); + + /* Si le maillage n'existe pas => erreur */ + strcpy(chemin, MED_MAA); + strcat(chemin, maa); + maaid = _MEDdatagroupOuvrir(fid, chemin); + if (maaid < 0) return(-1); + + /* Si le Data Group "NOE" n'existe pas => erreur */ + noeid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE); + if (noeid < 0) return(-1); + + switch (dim) { + case 0 : { + dataset = MED_NOM_IN1; + break; + }; + case 1 : { + dataset = MED_NOM_IN2; + break; + }; + case 2 : { + dataset = MED_NOM_IN3; + break; + }; + default : { + return(-1); + }; + }; + + /* Lecture du Data Set "IN1" ou "IN2" ou "IN3" */ + if (_MEDdatasetNumLire(noeid, dataset, MED_REEL64, mode_coo, 1, MED_ALL, MED_NOPF, 0, 1, (unsigned char*)coo) < 0) { + return(-1); + }; + + /* On re-ouvre le Data Set precedant pour y lire des attributs */ + ds = _MEDdatasetOuvrir(noeid, dataset); + if (ds < 0) return(-1); + + /* L'attribut "REP" */ + if (_MEDattrEntierLire(ds, MED_NOM_REP, &type_rep_int) < 0) { + return(-1); + } else { + *repere = (med_repere)type_rep_int; + }; + + /* Attribut "NOM" */ + if (_MEDattrStringLire(ds, MED_NOM_NOM, mdim*MED_TAILLE_PNOM, nomcoo) < 0) { + return(-1); + }; + + /* Attribut "UNI" */ + if (_MEDattrStringLire(ds, MED_NOM_UNI, mdim*MED_TAILLE_PNOM, unicoo) < 0) { + return(-1); + }; + + /* On ferme tout */ + if (_MEDdatasetFermer(ds) < 0) { + return(-1); + }; + if (_MEDdatagroupFermer(noeid) < 0) { + return(-1); + }; + if (_MEDdatagroupFermer(maaid) < 0) { + return(-1); + }; + return(0); +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDgro2famA.cxx b/src/MEDWrapper/V2_1/Core/MEDgro2famA.cxx new file mode 100644 index 000000000..5838900ea --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDgro2famA.cxx @@ -0,0 +1,291 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + + +#include +#include + +#include "med.hxx" + +/*********************************************************************** + * FONCTION MEDgro2famA + * + * - DESCRIPTION : 1ere etape dans la conversion des groupes de noeuds + * et d'elements en familles MED. + * Calcul des tailles des tableaux que l'on devra allouer pour + * stocker les familles qui seront construites par MEDgro2famB(). + * Les parametres renvoyes sont : + * 1 - le nombre de familles MED a creer (nfamg) + * 2 - le nombre de noms groupes associes a l'ensemble des familles + * MED (nindf) + * Ces parametres doivent permettre a l'appelant de creer les tables + * suivantes : + * 1 - une table des noms des groupes propres a chaque famille, + * de taille : nindf*MED_TAILLE_LNOM+1 + * 2 - une table d'index donnant pour chaque famille son numero d'indice + * dans la table des noms, de taille : nfamg+1 + * 3 - une table destinee a contenir la liste des numeros de familles + * a creer, de taille : nfamg + * + * - PARAMETRES : + * NOM .E/S. TYPE . DESCRIPTION + * ------------------------------------------------------------------- + * nnoe .E . med_int . nombre de noeuds + * nele .E . med_int . nombre d'elements + * numnoe .E . med_int*. numeros des noeuds + * numele .E . med_int*. numeros des elements + * ngn .E . med_int . nombre de groupes de noeuds + * nge .E . med_int . nombre de groupes d'elements + * nindn .E . med_int . nombre d'indices dans la table + * . . . des groupes de noeuds + * ninde .E . med_int . nombre d'indices dans la table + * . . . de groupes d'elements + * indgronoe .E . int* . table index de la table des groupes + * . . . de noeuds + * indgroele .E . int* . table index de la table des groupes + * . . . d'elements + * tabgronoe .E . med_int*. table des groupes de noeuds + * tabgroele .E . med_int*. table des groupes d'elements + * nfamg . S. med_int*. nombre de familles MED a creer + * nidnf . S. med_int*. nombre de noms groupes associes a + * . . . l'ensemble des familles MED + * + * - RESULTAT : 0 si succes, -1 sinon + * + ***********************************************************************/ + +namespace med_2_1{ + +med_err +MEDgro2famA (med_int nnoe,med_int nele,med_int *numnoe,med_int *numele, + med_int ngn,med_int nge,med_int nindn, + med_int ninde,int *indgronoe,int *indgroele,med_int *tabgronoe, + med_int *tabgroele,med_int *nfamg,med_int *nindf) +{ + int i,j,k; + int *famnoe,*famele,*tmp; + int *p; + int flag, num,exist; + int nfamn, nfame; + int fam01 = 0; + int fam02 = 0; + + /* initialisations */ + famnoe = NULL; + famele = NULL; + + *nfamg = 0; + *nindf = 0; + nfamn = 0; + nfame = 0; + + if ((ngn > 0) || (nge > 0)) + { + /* pour chaque noeud : + 1 - on dresse la liste des groupes de noeuds auquel il appartient + 2 - en la comparant avec les listes pre-existantes, on + estime s'il est necessaire de creer une nouvelle famille de noeuds. + Si oui => on incremente le compteur local nfamn (nombre de familles + de noeuds) + on incremente le parametre nindf du nombre de groupes + que devra compter cette famille de noeuds + Si non => on ne fait rien */ + for (i=0;i +#include +#include +#include "med.hxx" + +/*********************************************************************** + * FONCTION MEDgro2famB + * + * - DESCRIPTION : 2eme etape dans la conversion des groupes de noeuds + * et d'elements en familles MED + * Mise a jour des tables suivantes passees en parametres : + * 1 - les nouveaux numeros des familles a creer + * 2 - les nouveaux numeros des familles des elements + * 3 - les nouveaux numeros des familles des noeuds + * 4 - les noms des groupes composant ces familles + * 5 - les index de la table des groupes + * + * - PARAMETRES : + * NOM .E/S. TYPE . DESCRIPTION + * ------------------------------------------------------------------- + * nnoe .E . med_int . nombre de noeuds + * nele .E . med_int . nombre d'elements + * numnoe .E . med_int*. numeros des noeuds + * numele .E . med_int*. numeros des elements + * ngn .E . med_int . nombre de groupes de noeuds + * nge .E . med_int . nombre de groupes d'elements + * nindn .E . med_int . nombre d'indices dans la table + * . . . des groupes de noeuds + * ninde .E . med_int . nombre d'indices dans la table + * . . . de groupes d'elements + * nomgronoe .E . char* . noms des groupes de noeuds + * nomgroele .E . char* . noms des groupes d'elements + * indgronoe .E . int* . table index de la table des groupes + * . . . de noeuds + * indgroele .E . int* . table index de la table des groupes + * . . . d'elements + * tabgronoe .E . int* . table des groupes de noeuds + * tabgroele .E . int* . table des groupes d'elements + * nfamg .E . med_int . nombre de familles MED a creer + * nidnf .E . med_int . nombre de noms groupes associes a + * . . . l'ensemble des familles MED + * newnumfam . S. med_int*. nouveaux numeros de familles + * newnumfamele . S. med_int*. nouveaux numeros de familles des + * . . . elements + * newnumfamnoe . S. med_int*. nouveaux numeros de familles des + * . . . noeuds + * newindfamgro . S. int* . table des index de la table des + * . . . noms de groupes associes aux familles + * newfamgro . . char* . table des noms des groupes des + * . . . familles + * + * - RESULTAT : 0 + * + ***********************************************************************/ + +namespace med_2_1{ + +med_err +MEDgro2famB (med_int nnoe,med_int nele,med_int *numnoe,med_int *numele, + med_int ngn,med_int nge,med_int nindn, + med_int ninde, char *nomgronoe,char *nomgroele, + int *indgronoe,int *indgroele,med_int *tabgronoe, + med_int *tabgroele,med_int nfamg,med_int nindf, + med_int *newnumfam,med_int *newnumfamele, + med_int *newnumfamnoe,int *newindfamgro, + char *newfamgro) +{ + int i,j,k; + + med_int *famnoe, *famele, *tmp; + med_int *p; + med_int num; + int flag,exist; + int nfamn, nfame; + int estfam0 = 1; + int newnumnoe, newnumele; + int tmp1; + int existfam0 = 0; + int ind = 0; + + famnoe = NULL; + famele = NULL; + + nfamn = 0; + nfame = 0; + newnumnoe = 0; + newnumele = 0; + + *newindfamgro = 0; + + if (nfamg > 1) + { + /* pour chaque noeud : + 1 - on dresse la liste des groupes de noeuds auquel il appartient + 2 - en la comparant avec les listes pre-existantes, on + estime s'il est necessaire de creer une nouvelle famille de noeuds. + Si oui => - on cree le numero de famille que l'on reporte + dans newnumfam + - on reporte ce numero dans newnumnoe + - on met a jour la table des noms des groupes des familles + ainsi que sa table d'index + Si non => on ne fait rien + ATTENTION : pour la famille 0, on ne met a jour que les numeros */ + for (i=0;i - on cree le numero de famille que l'on reporte + dans newnumfam + - on reporte ce numero dans newnumele + - on met a jour la table des noms des groupes des familles + ainsi que sa table d'index + Si non => on ne fait rien + ATTENTION : pour la famille 0, on ne met a jour que les numeros */ + for (i=0;i + +namespace med_2_1{ + +med_int +MEDlFichDes(med_idt fid) +{ + med_idt attr, root; + med_err ret=0; + char des[MED_TAILLE_DESC+1]; + med_int longueur=0; + char nom[MED_TAILLE_NOM+1]; + char chemin[MED_TAILLE_MAA+1]; + + /* + * On inhibe le gestionnaire d'erreur HDF + */ + _MEDmodeErreurVerrouiller(); + + /* + * On ouvre le Data Group racine + */ + strncpy(chemin,MED_MAA,MED_TAILLE_MAA-1); + chemin[MED_TAILLE_MAA-1] = '\0'; + if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * On regarde si l'attribut existe + * Si non => erreur + * Si oui => on retourne sa longueur + */ + strcpy(nom,MED_NOM_DESCRIPTEUR); + + if ((attr = _MEDattrOuvrir(root,nom)) < 0) { + _MEDdatagroupFermer(root); + longueur=0; + return 0; + } + + if ((ret = _MEDattrFermer(attr)) < 0) { + _MEDdatagroupFermer(root); + return -1; + } + + if ((ret = _MEDattrStringLire(root,nom,MED_TAILLE_DESC,des)) < 0) { + _MEDdatagroupFermer(root); + return -1; + } + + longueur = strlen(des); + + /* + * fermetures + */ + if ((ret == _MEDdatagroupFermer(root)) < 0) + return -1; + + return longueur; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDmaaCr.cxx b/src/MEDWrapper/V2_1/Core/MEDmaaCr.cxx new file mode 100644 index 000000000..c4b50b717 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDmaaCr.cxx @@ -0,0 +1,77 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDmaaCr(med_idt fid, char *maillage, med_int dim) +{ + med_idt maaid, root; + char chemin[MED_TAILLE_MAA+1]; + med_err ret; + + /* + * On inhibe le gestionnaire d'erreur + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si la racine n'existe pas on la cree + */ + strncpy(chemin,MED_MAA,strlen(MED_MAA)-1); + chemin[MED_TAILLE_MAA-1] = '\0'; + if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0) + if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) + return -1; + + /* + * si le maillage existe deja => erreur + */ + if ((maaid = _MEDdatagroupOuvrir(root,maillage)) > 0) + return -1; + + /* + * Creation du Data Group + */ + if ((maaid = _MEDdatagroupCreer(root,maillage)) < 0) + return -1; + + /* + * Creation de l'attribut dimension + */ + if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_DIM,&dim,MED_REMP)) < 0) + return -1; + + /* + * Nettoyages divers + */ + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(root)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDmaaInfo.cxx b/src/MEDWrapper/V2_1/Core/MEDmaaInfo.cxx new file mode 100644 index 000000000..e2b48a7cb --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDmaaInfo.cxx @@ -0,0 +1,62 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDmaaInfo(med_idt fid, int indice, char *maillage, med_int *dim) +{ + int numero; + med_idt maaid; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + + /* + * On inhibe le gestionnaire d'erreur + */ + _MEDmodeErreurVerrouiller(); + + /* + * On recupere le nom du groupe de rang "indice" + */ + numero = indice-1; + if ((ret = _MEDobjetIdentifier(fid,MED_MAA,numero,maillage)) < 0) + return -1; + + /* + * On va chercher l'attribut dimension + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maillage); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + if ((ret = _MEDattrEntierLire(maaid,MED_NOM_DIM,dim)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDmodeErreurVerrouiller.cxx b/src/MEDWrapper/V2_1/Core/MEDmodeErreurVerrouiller.cxx new file mode 100644 index 000000000..aa4eb0882 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDmodeErreurVerrouiller.cxx @@ -0,0 +1,37 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDmodeErreurVerrouiller + * - Description : inhibe le mode erreur HDF5 + * - Parametres : aucun + * - Resultat : aucun + */ + +namespace med_2_1{ + +void +_MEDmodeErreurVerrouiller() +{ + H5Eset_auto(NULL,NULL); +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnChamp.cxx b/src/MEDWrapper/V2_1/Core/MEDnChamp.cxx new file mode 100644 index 000000000..55347ba5f --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnChamp.cxx @@ -0,0 +1,87 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include +#include +#include "med_outils.hxx" + +namespace med_2_1{ + +med_int +MEDnChamp(med_idt fid, int indice) +{ + int n1; + med_int n2; + med_idt datagroup; + med_err ret; + char nomdatagroup[MED_TAILLE_NOM+1]; + int num; + char chemin[MED_TAILLE_CHA+MED_TAILLE_NOM+1]; + + if (indice < 0) + return -1; + + /* + * On inhibe le gestionnaire d'erreur HDF + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le Data Group cha n'existe pas et indice == 0 => 0 + * sinon erreur => erreur + */ + strcpy(chemin,MED_CHA); + + /* + * Si indice == 0 => nombre de champs + */ + if (indice == 0) + { + n1 = 0; + _MEDnObjets(fid,chemin,&n1); + n2 = n1; + } + + /* + * Si indice > 0 => nbre de composants + */ + if (indice > 0) + { + /* + * On recupere le nom du champ + */ + num = indice-1; + if ((ret = _MEDobjetIdentifier(fid,chemin,num,nomdatagroup)) < 0) + return -1; + strcat(chemin,nomdatagroup); + /* + * On recupere le nombre de composants + */ + if ((datagroup = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NCO,&n2)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(datagroup)) < 0) + return -1; + } + + return n2; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnCorres.cxx b/src/MEDWrapper/V2_1/Core/MEDnCorres.cxx new file mode 100644 index 000000000..10b583021 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnCorres.cxx @@ -0,0 +1,83 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_int +MEDnCorres(med_idt fid,char *maa,char *eq,med_entite_maillage typ_ent, + med_geometrie_element typ_geo) +{ + med_idt eqid, datagroup; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1]; + char nomdatagroup[MED_TAILLE_NOM+1]; + char tmp[MED_TAILLE_NOM_ENTITE+1]; + med_int n; + + if (typ_geo == MED_TETRA4 || typ_geo == MED_TETRA10 || + typ_geo == MED_HEXA8 || typ_geo == MED_HEXA20 || + typ_geo == MED_PENTA6 || typ_geo == MED_PENTA15 || + typ_geo == MED_PYRA5 || typ_geo == MED_PYRA13) + return -1; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le Data Group de "eq" n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + strcat(chemin,MED_EQS); + strcat(chemin,eq); + if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + if ((ret = _MEDnomEntite(nomdatagroup,typ_ent)) < 0) + return -1; + if ((typ_ent != MED_NOEUD)) + { + if ((ret = _MEDnomGeometrie(tmp,typ_geo)) < 0) + return -1; + strcat(nomdatagroup,"."); + strcat(nomdatagroup,tmp); + } + if ((datagroup = _MEDdatagroupOuvrir(eqid,nomdatagroup)) < 0) + return 0; + if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,&n)) < 0) + return -1; + + /* + * On ferme tout + */ + if ((ret = _MEDdatagroupFermer(datagroup)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(eqid)) < 0) + return -1; + + return n; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnEntMaa.cxx b/src/MEDWrapper/V2_1/Core/MEDnEntMaa.cxx new file mode 100644 index 000000000..7f9cfbdc4 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnEntMaa.cxx @@ -0,0 +1,111 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_int +MEDnEntMaa(med_idt fid, char *maa, med_table quoi, med_entite_maillage type_ent, + med_geometrie_element type_geo, med_connectivite type_conn) +{ + med_idt root, maaid, entid,geoid, dataset=0; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + char nom_ent[MED_TAILLE_NOM_ENTITE+1]; + char nom_geo[MED_TAILLE_NOM_ENTITE+1]; + char nom_dataset[MED_TAILLE_NOM_ENTITE+1]; + med_int res = 0; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le maillage n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * On met a jour le nom du Data Group representant + * le type des entites + */ + if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) + return -1; + + /* + * Si le Data Group des entites n'existe pas => res = 0 + */ + entid = _MEDdatagroupOuvrir(maaid,nom_ent); + + /* + * Pour les mailles, les faces et le aretes + * si le Data Group du type geometrique n'existe pas => res = 0 + */ + if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE)) + { + if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) + return -1; + geoid = _MEDdatagroupOuvrir(entid,nom_geo); + } + else + geoid = -1; + + /* + * Ouverture du Data Set renvoye par _MEDnomDataset() + * S'il n'existe pas => erreur + * Sinon lecture de l'attribut NBR + */ + if (geoid == -1) + root = entid; + else + root = geoid; + if ((ret = _MEDnomDataset(nom_dataset,quoi,type_conn)) < 0) + return -1; + dataset = _MEDdatasetOuvrir(root,nom_dataset); + if (dataset > 0) + if ((ret = _MEDattrEntierLire(dataset,MED_NOM_NBR,&res)) < 0) + return -1; + + /* + * On ferme tout + */ + if (dataset > 0) + if ((ret = _MEDdatasetFermer(dataset)) < 0) + return -1; + if (geoid > 0) + if ((ret = _MEDdatagroupFermer(geoid)) < 0) + return -1; + if (entid > 0) + if ((ret = _MEDdatagroupFermer(entid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return res; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnEntites.cxx b/src/MEDWrapper/V2_1/Core/MEDnEntites.cxx new file mode 100644 index 000000000..b5b32c468 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnEntites.cxx @@ -0,0 +1,69 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" + +namespace med_2_1{ + +med_int +MEDnEntites(med_idt fid,char *maa,med_entite_maillage typ_ent, + med_connectivite typ_con) +{ + med_int total = 0; + int i; + med_geometrie_element typ_mai[MED_NBR_GEOMETRIE_MAILLE] = {MED_POINT1,MED_SEG2, + MED_SEG3,MED_TRIA3, + MED_TRIA6,MED_QUAD4, + MED_QUAD8,MED_TETRA4, + MED_TETRA10,MED_HEXA8, + MED_HEXA20,MED_PENTA6, + MED_PENTA15,MED_PYRA5, + MED_PYRA13}; + med_geometrie_element typ_fac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6, + MED_QUAD4,MED_QUAD8}; + med_geometrie_element typ_are[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3}; + + switch (typ_ent) + { + case MED_MAILLE : + for (i=0;i +#include + +namespace med_2_1{ + +med_int +MEDnEquiv(med_idt fid, char *maa) +{ + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+MED_TAILLE_EQS+1]; + int n; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + strcat(chemin,MED_EQS); + n = 0; + _MEDnObjets(fid,chemin,&n); + + return (med_int) n; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnFam.cxx b/src/MEDWrapper/V2_1/Core/MEDnFam.cxx new file mode 100644 index 000000000..3ac75795f --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnFam.cxx @@ -0,0 +1,108 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_int +MEDnFam(med_idt fid,char *maa, int indice, med_dim_famille quoi) +{ + med_idt datagroup,famid; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_FAS+2*MED_TAILLE_NOM+1]; + med_int n; + int n_tmp; + int num; + char famille[MED_TAILLE_NOM+1]; + + + /* + * On inhibe le gestionnaire d'erreur HDF + */ + _MEDmodeErreurVerrouiller(); + + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + strcat(chemin,MED_FAS); + if (indice == 0) + { + n_tmp = 0; + _MEDnObjets(fid,chemin,&n_tmp); + n = (med_int ) n_tmp; + } + else + { + /* + * On recupere le nom de la famille + */ + num = indice - 1; + if ((ret = _MEDobjetIdentifier(fid,chemin,num, + famille)) < 0) + return -1; + + /* + * Si le Data Group de la famille n'existe pas => erreur + */ + strcat(chemin,famille); + if ((famid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + switch (quoi) + { + case MED_GROUPE : + if ((datagroup = _MEDdatagroupOuvrir(famid,MED_NOM_GRO)) < 0) + n = 0; + else + { + if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,&n)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(datagroup)) < 0) + return -1; + } + break; + + case MED_ATTR : + if ((datagroup = _MEDdatagroupOuvrir(famid,MED_NOM_ATT)) < 0) + n = 0; + else + { + if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,&n)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(datagroup)) < 0) + return -1; + } + break; + + default : + return -1; + } + + if ((ret = _MEDdatagroupFermer(famid)) < 0) + return -1; + + } + + return (med_int) n; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnGrid.cxx b/src/MEDWrapper/V2_1/Core/MEDnGrid.cxx new file mode 100644 index 000000000..607888cf2 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnGrid.cxx @@ -0,0 +1,114 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +namespace med_2_1{ + +med_int +MEDnGrid(med_idt fid, char *maa, med_grid n) +{ + med_idt maaid, entid, geoid, dataset; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + char nom_ent[MED_TAILLE_NOM_ENTITE+1]; + char *nom_dataset; + med_int res = (-1); + + /* On inhibe le gestionnaire d'erreur HDF 5 */ + _MEDmodeErreurVerrouiller(); + + /* Si le maillage n'existe pas => erreur */ + strcpy(chemin, MED_MAA); + strcat(chemin, maa); + maaid = _MEDdatagroupOuvrir(fid, chemin); + if (maaid < 0) return(-1); + + switch (n) { + case MED_FAM_NOEUD : { + nom_dataset = MED_NOM_FAM; + if (_MEDnomEntite(nom_ent, MED_NOEUD) < 0) return(-1); + entid = _MEDdatagroupOuvrir(maaid, nom_ent); + break; + }; + case MED_FAM_ARETE : { + nom_dataset = MED_NOM_FAM; + if (_MEDnomEntite(nom_ent, MED_ARETE) < 0) return(-1); + geoid = _MEDdatagroupOuvrir(maaid, nom_ent); + if (geoid < 0) return(-1); + if (_MEDnomGeometrie(nom_ent, MED_SEG2) < 0) return(-1); + entid = _MEDdatagroupOuvrir(geoid, nom_ent); + break; + }; + case MED_FAM_FACE : { + nom_dataset = MED_NOM_FAM; + if (_MEDnomEntite(nom_ent, MED_FACE) < 0) return(-1); + geoid = _MEDdatagroupOuvrir(maaid, nom_ent); + if (geoid < 0) return(-1); + if (_MEDnomGeometrie(nom_ent, MED_QUAD4) < 0) return(-1); + entid = _MEDdatagroupOuvrir(geoid, nom_ent); + break; + }; + case MED_FAM_MAILLE : { + nom_dataset = MED_NOM_FAM; + if (_MEDnomEntite(nom_ent, MED_MAILLE) < 0) return(-1); + geoid = _MEDdatagroupOuvrir(maaid, nom_ent); + if (geoid < 0) return(-1); + if (_MEDnomGeometrie(nom_ent, MED_HEXA8) < 0) return(-1); + entid = _MEDdatagroupOuvrir(geoid, nom_ent); + break; + }; + case MED_GRID_NOEUD : { + nom_dataset = MED_NOM_BOF; + entid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE); + break; + }; + case MED_GRID_D1 : { + nom_dataset = MED_NOM_IN1; + entid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE); + break; + }; + case MED_GRID_D2 : { + nom_dataset = MED_NOM_IN2; + entid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE); + break; + }; + case MED_GRID_D3 : { + nom_dataset = MED_NOM_IN3; + entid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE); + break; + }; + default : { + return(-1); + }; + }; + + if (entid < 0) return(-1); + dataset = _MEDdatasetOuvrir(entid, nom_dataset); + if (dataset < 0) return(-1); + if (_MEDattrEntierLire(dataset, MED_NOM_NBR, &res) < 0) return(-1); + + /* On ferme tout */ + if (_MEDdatasetFermer(dataset) < 0) return(-1); + if (_MEDdatagroupFermer(entid) < 0) return(-1); + if (_MEDdatagroupFermer(maaid) < 0) return(-1); + + return(res); +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnMaa.cxx b/src/MEDWrapper/V2_1/Core/MEDnMaa.cxx new file mode 100644 index 000000000..a7a8124b6 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnMaa.cxx @@ -0,0 +1,39 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include + +namespace med_2_1{ + +med_int +MEDnMaa(med_idt fid) +{ + int n; + + _MEDmodeErreurVerrouiller(); + + n = 0; + _MEDnObjets(fid,MED_MAA,&n); + + return (med_int) n; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnObjets.cxx b/src/MEDWrapper/V2_1/Core/MEDnObjets.cxx new file mode 100644 index 000000000..6720f95f3 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnObjets.cxx @@ -0,0 +1,46 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDnObjets + * - Description : indique le nombre d'objets HDF contenu dans le + * datagroup passe en argument + * - Parametres : + * - fid (IN) : l'ID du fichier HDF + * - chemin (IN) : chemin d'acces au datagroup + * - n (OUT) : le nombre recherche + * - Resultat : 0 en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +_MEDnObjets(med_idt fid,char *chemin,int *n) +{ + int idx; + + if ((idx = H5Giterate(fid,chemin,NULL,_MEDindiceNum,(void *)n)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnPasdetemps.cxx b/src/MEDWrapper/V2_1/Core/MEDnPasdetemps.cxx new file mode 100644 index 000000000..6cad0ba8e --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnPasdetemps.cxx @@ -0,0 +1,73 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +/* + * Nombre de Couple (PDT,NOR) pour le champ + */ + +namespace med_2_1{ + +med_int +MEDnPasdetemps(med_idt fid,char *cha,med_entite_maillage type_ent, + med_geometrie_element type_geo) + +{ + med_err ret; + int n1; + char nomdatagroup1[MED_TAILLE_NOM+1]; + char tmp1 [MED_TAILLE_NOM_ENTITE+1]; + char chemin [MED_TAILLE_CHA+(MED_TAILLE_NOM+1)+MED_TAILLE_NOM+1]; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Creation du chemin d'accès aux différents (PDT,NOR) pour les différents [.] + */ + strcpy(chemin,MED_CHA); + strcat(chemin,cha); + strcat(chemin,"/"); + + if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0) + return -1; + if ((type_ent != MED_NOEUD)) + { + if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0) + return -1; + strcat(nomdatagroup1,"."); + strcat(nomdatagroup1,tmp1); + } + strcat(chemin,nomdatagroup1); + + n1 =0; + _MEDnObjets(fid,chemin,&n1); + + return (med_int) n1; + +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnProfil.cxx b/src/MEDWrapper/V2_1/Core/MEDnProfil.cxx new file mode 100644 index 000000000..5dcb6482f --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnProfil.cxx @@ -0,0 +1,38 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +namespace med_2_1{ + +med_int +MEDnProfil(med_idt fid) +{ + int n; + med_err ret; + + _MEDmodeErreurVerrouiller(); + + n = 0; + _MEDnObjets(fid,MED_PROFILS,&n); + + return (med_int) n; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnVal.cxx b/src/MEDWrapper/V2_1/Core/MEDnVal.cxx new file mode 100644 index 000000000..010c82636 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnVal.cxx @@ -0,0 +1,83 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include +#include +#include "med_outils.hxx" + +namespace med_2_1{ + +med_int +MEDnVal(med_idt fid, char *champ, med_entite_maillage type_ent, + med_geometrie_element type_geo,med_int numdt, med_int numo) +{ + med_int n; + med_idt datagroup; + med_err ret; + char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2],nomdatagroup2[2*MED_MAX_PARA+1]; + char tmp1 [MED_TAILLE_NOM_ENTITE+1]; + char chemin [MED_TAILLE_CHA+(MED_TAILLE_NOM+1)+(2*MED_TAILLE_NOM_ENTITE+2)+(2*MED_MAX_PARA)+1+100]; + + /* + * On inhibe le gestionnaire d'erreur HDF + */ + _MEDmodeErreurVerrouiller(); + + /* + * On cree le chemin d'accès + */ + strcpy(chemin,MED_CHA); + strcat(chemin,champ); + strcat(chemin,"/"); + + /* On cree le nom du datagroup de niveau 1 */ + if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0) + return -1; + if ((type_ent != MED_NOEUD)) + { + if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0) + return -1; + strcat(nomdatagroup1,"."); + strcat(nomdatagroup1,tmp1); + } + strcat(chemin,nomdatagroup1); + strcat(chemin,"/"); + + /* Creation du datagroup de niveau 2 . */ + sprintf(nomdatagroup2,"%*li%*li",MED_MAX_PARA,(long ) numdt,MED_MAX_PARA,(long ) numo); + strcat(chemin,nomdatagroup2); + + /* + * Acces au champ + */ + if ((datagroup = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return 0; + if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,&n)) < 0) + return -1; + + /* + * fermetures + */ + if ((ret = _MEDdatagroupFermer(datagroup)) < 0) + return -1; + + return n; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnValProfil.cxx b/src/MEDWrapper/V2_1/Core/MEDnValProfil.cxx new file mode 100644 index 000000000..7c14cf2ed --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnValProfil.cxx @@ -0,0 +1,60 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_int +MEDnValProfil(med_idt fid, char *nom) +{ + med_int n = 0; + med_idt pid; + char chemin[MED_TAILLE_PROFILS+MED_TAILLE_NOM+1]; + med_err ret; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * ouverture du groupe /PROFILS/"nom" + */ + strcpy(chemin,MED_PROFILS); + strcat(chemin,nom); + if ((pid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + if ((ret = _MEDattrEntierLire(pid,MED_NOM_N,&n)) < 0) + return ret; + + /* + * On ferme tout + */ + if ((ret = _MEDdatagroupFermer(pid)) < 0) + return -1; + + return n; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnbnoisEcr.cxx b/src/MEDWrapper/V2_1/Core/MEDnbnoisEcr.cxx new file mode 100644 index 000000000..3c287ce7f --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnbnoisEcr.cxx @@ -0,0 +1,62 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDnbnoisEcr(med_idt fid, char *nom_maillage,med_int n) +{ + med_idt maaid; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + med_err ret; + + /* + * On inhibe le gestionnaire d'erreur HDF + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le maillage n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,nom_maillage); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * Creation de l'attribut "Nombre de Noeuds Isoles" + */ + if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_NNI,&n,MED_REMP)) < 0) + return -1; + + /* + * Fermetures des objets + */ + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnbnoisLire.cxx b/src/MEDWrapper/V2_1/Core/MEDnbnoisLire.cxx new file mode 100644 index 000000000..363d66ffe --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnbnoisLire.cxx @@ -0,0 +1,63 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_int +MEDnbnoisLire(med_idt fid,char *nom_maillage) +{ + med_idt maaid; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + med_int n; + + /* + * On inhibe le gestionnaire d'erreur + */ + _MEDmodeErreurVerrouiller(); + + /* + * On regarde si le maillage existe => erreur si non + */ + strcpy(chemin,MED_MAA); + strcat(chemin,nom_maillage); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * On va lire l'attribut "NNI" + */ + if ((ret = _MEDattrEntierLire(maaid,MED_NOM_NNI,&n)) < 0) + return -1; + + /* + * Fermetures des objets HDF + */ + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return n; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnbnomaEcr.cxx b/src/MEDWrapper/V2_1/Core/MEDnbnomaEcr.cxx new file mode 100644 index 000000000..2d635253f --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnbnomaEcr.cxx @@ -0,0 +1,62 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDnbnomaEcr(med_idt fid, char *nom_maillage,med_int n) +{ + med_idt maaid; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + med_err ret; + + /* + * On inhibe le gestionnaire d'erreur + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le maillage n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,nom_maillage); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * Creation de l'attribut "Nombre de Noeuds Max par maille" + */ + if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_NNM,&n,MED_REMP)) < 0) + return -1; + + /* + * Nettoyages divers + */ + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnbnomaLire.cxx b/src/MEDWrapper/V2_1/Core/MEDnbnomaLire.cxx new file mode 100644 index 000000000..b018a0aa5 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnbnomaLire.cxx @@ -0,0 +1,63 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_int +MEDnbnomaLire(med_idt fid,char *nom_maillage) +{ + med_idt maaid; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + med_int n; + + /* + * On inhibe le gestionnaire d'erreur HDF + */ + _MEDmodeErreurVerrouiller(); + + /* + * On regarde si le maillage existe => erreur si non + */ + strcpy(chemin,MED_MAA); + strcat(chemin,nom_maillage); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * On va lire l'attribut "NNM" + */ + if ((ret = _MEDattrEntierLire(maaid,MED_NOM_NNM,&n)) < 0) + return -1; + + /* + * Fermetures des objets HDF + */ + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return n; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnbnosoEcr.cxx b/src/MEDWrapper/V2_1/Core/MEDnbnosoEcr.cxx new file mode 100644 index 000000000..453ebe29f --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnbnosoEcr.cxx @@ -0,0 +1,62 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDnbnosoEcr(med_idt fid, char *nom_maillage,med_int n) +{ + med_idt maaid; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + med_err ret; + + /* + * On inhibe le gestionnaire d'erreur HDF + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le maillage n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,nom_maillage); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * Creation de l'attribut "Nombre de Noeuds Sommets" + */ + if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_NNS,&n,MED_REMP)) < 0) + return -1; + + /* + * Fermetures + */ + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnbnosoLire.cxx b/src/MEDWrapper/V2_1/Core/MEDnbnosoLire.cxx new file mode 100644 index 000000000..7a1b67270 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnbnosoLire.cxx @@ -0,0 +1,63 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med_outils.hxx" +#include "med.hxx" + +#include +#include + +namespace med_2_1{ + +med_int +MEDnbnosoLire(med_idt fid,char *nom_maillage) +{ + med_idt maaid; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + med_int n; + + /* + * On inhibe le gestionnaire d'erreur + */ + _MEDmodeErreurVerrouiller(); + + /* + * On regarde si le maillage existe => erreur si non + */ + strcpy(chemin,MED_MAA); + strcat(chemin,nom_maillage); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * On va lire l'attribut "NNS" + */ + if ((ret = _MEDattrEntierLire(maaid,MED_NOM_NNS,&n)) < 0) + return -1; + + /* + * Fermetures des objets HDF + */ + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return n; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnoeudsEcr.cxx b/src/MEDWrapper/V2_1/Core/MEDnoeudsEcr.cxx new file mode 100644 index 000000000..808d25864 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnoeudsEcr.cxx @@ -0,0 +1,55 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" + +namespace med_2_1{ + +med_err +MEDnoeudsEcr(med_idt fid,char *maa,med_int mdim,med_float *coord, + med_mode_switch mode_coo, + med_repere repere,char *nomcoo, char *unicoo,char *nom, + med_booleen inom,med_int *num,med_booleen inum,med_int *fam, + med_int nnoeuds,med_mode_acces mode) +{ + med_err ret; + + /* ecriture des coordonnees */ + if ((ret = MEDcoordEcr(fid,maa,mdim,coord,mode_coo, + nnoeuds,mode,repere,nomcoo, + unicoo)) < 0) + return -1; + + /* ecriture des noms (facultatifs) */ + if (inom == MED_VRAI) + if ((ret = MEDnomEcr(fid,maa,nom,nnoeuds,mode,MED_NOEUD,MED_POINT1)) < 0) + return -1; + + /* ecriture des numeros (facultatifs) */ + if (inum == MED_VRAI) + if ((ret = MEDnumEcr(fid,maa,num,nnoeuds,mode,MED_NOEUD,MED_POINT1)) < 0) + return -1; + + /* ecriture des numeros de familles */ + if ((ret = MEDfamEcr(fid,maa,fam,nnoeuds,mode,MED_NOEUD,MED_POINT1)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnoeudsLire.cxx b/src/MEDWrapper/V2_1/Core/MEDnoeudsLire.cxx new file mode 100644 index 000000000..68014ba9a --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnoeudsLire.cxx @@ -0,0 +1,57 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + + +#include "med.hxx" + +namespace med_2_1{ + +med_err +MEDnoeudsLire(med_idt fid,char *maa,med_int mdim, med_float *coord, + med_mode_switch mode_coo, + med_repere *repere,char *nomcoo, char *unicoo,char *nom, + med_booleen *inom,med_int *num,med_booleen *inum,med_int *fam, + med_int nnoeuds) +{ + med_err ret; + + /* lecture des coordonnees */ + if ((ret = MEDcoordLire(fid,maa,mdim,coord,mode_coo,MED_ALL,0,MED_NOPF,repere,nomcoo, + unicoo)) < 0) + return -1; + + /* lecture des noms (facultatifs) */ + if ((ret = MEDnomLire(fid,maa,nom,nnoeuds,MED_NOEUD,MED_POINT1)) < 0) + *inom = MED_FAUX; + else + *inom = MED_VRAI; + + /* lecture des numeros (facultatifs) */ + if ((ret = MEDnumLire(fid,maa,num,nnoeuds,MED_NOEUD,MED_POINT1)) < 0) + *inum = MED_FAUX; + else + *inum = MED_VRAI; + + /* lecture des numeros de familles */ + if ((ret = MEDfamLire(fid,maa,fam,nnoeuds,MED_NOEUD,MED_POINT1)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnomDataset.cxx b/src/MEDWrapper/V2_1/Core/MEDnomDataset.cxx new file mode 100644 index 000000000..fe72b24bb --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnomDataset.cxx @@ -0,0 +1,79 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDnomDataset + * - Description : fournit un nom de dataset + * - Parametres : + * - nom_dataset (OUT) : le nom du data set + * - quoi (IN) : le type de table MED + * - type_conn (IN) : le type de connectivite + * - Resultat : 0 en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +_MEDnomDataset(char *nom_dataset,med_table quoi,med_connectivite type_conn) +{ + switch(quoi) + { + case MED_COOR : + strcpy(nom_dataset,MED_NOM_COO); + break; + + case MED_CONN : + switch(type_conn) + { + case MED_NOD : + strcpy(nom_dataset,MED_NOM_NOD); + break; + + case MED_DESC : + strcpy(nom_dataset,MED_NOM_DES); + break; + + default : + return -1; + } + break; + + case MED_NOM : + strcpy(nom_dataset,MED_NOM_NOM); + break; + + case MED_NUM : + strcpy(nom_dataset,MED_NOM_NUM); + break; + + case MED_FAM : + strcpy(nom_dataset,MED_NOM_FAM); + break; + + default : + return -1; + } + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnomEcr.cxx b/src/MEDWrapper/V2_1/Core/MEDnomEcr.cxx new file mode 100644 index 000000000..a71cf4757 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnomEcr.cxx @@ -0,0 +1,116 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDnomEcr(med_idt fid,char *maa, char *nom, med_int n, med_mode_acces mode, + med_entite_maillage type_ent,med_geometrie_element type_geo) +{ + med_idt root, maaid, entid, geoid, dataset; + med_err ret; + med_size dimd[1]; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + char nom_ent[MED_TAILLE_NOM_ENTITE+1]; + char nom_geo[MED_TAILLE_NOM_ENTITE+1]; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le maillage n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * On met a jour le nom du Data Group representant + * le type des entites + */ + if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) + return -1; + + /* + * Si le Data Group des entites n'existe pas on le cree + */ + if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) + if ((entid = _MEDdatagroupCreer(maaid,nom_ent)) < 0) + return -1; + + /* + * Pour les mailles, les faces et le aretes, on cree + * s'il n'existe pas le Data Group du type geometrique + */ + if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE)) + { + if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) + return -1; + + if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) + if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0) + return -1; + } + else + geoid = -1; + + /* + * Creation du Data Set "NOM" + */ + if (geoid == -1) + root = entid; + else + root = geoid; + dimd[0] = n*MED_TAILLE_PNOM+1; + if ((ret = _MEDdatasetStringEcrire(root,MED_NOM_NOM,dimd,nom,mode)) < 0) + return -1; + + /* + * Attribut NBR (nombre de noeuds) + */ + if ((dataset = _MEDdatasetOuvrir(root,MED_NOM_NOM)) < 0) + return -1; + if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n,mode)) < 0) + return -1; + + /* + * On ferme tout + */ + if ((ret = _MEDdatasetFermer(dataset)) < 0) + return -1; + if (geoid > 0) + if ((ret = _MEDdatagroupFermer(geoid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(entid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnomEntite.cxx b/src/MEDWrapper/V2_1/Core/MEDnomEntite.cxx new file mode 100644 index 000000000..b5b4350fb --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnomEntite.cxx @@ -0,0 +1,60 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDnomEntite + * - Description : fournit le nom associe a un type d'entite MED + * - Parametres : + * - nom_ent (OUT) : le nom de l'entite + * - type_ent (IN) : le type de l'entite + * - Resultat : 0 en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +_MEDnomEntite(char *nom_ent,med_entite_maillage type_ent) +{ + switch(type_ent) + { + case MED_NOEUD : + strcpy(nom_ent,MED_NOM_NOE); + break; + + case MED_MAILLE : + strcpy(nom_ent,MED_NOM_MAI); + break; + + case MED_FACE : + strcpy(nom_ent,MED_NOM_FAC); + break; + + case MED_ARETE : + strcpy(nom_ent,MED_NOM_ARE); + break; + + default : + return -1; + } + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnomGeometrie.cxx b/src/MEDWrapper/V2_1/Core/MEDnomGeometrie.cxx new file mode 100644 index 000000000..3cbc6bbe0 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnomGeometrie.cxx @@ -0,0 +1,106 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDnomGeometrie + * - Description : fournit le nom de l'element geometrique associe + * au type geometrique MED + * - Parametres : + * - nom_geo (OUT) : le nom de l'element + * - type_geo (IN) : le type de l'element + * - Resultat : 0 en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +_MEDnomGeometrie(char *nom_geo,med_geometrie_element type_geo) +{ + switch (type_geo) + { + case MED_POINT1 : + strcpy(nom_geo,MED_NOM_PO1); + break; + + case MED_SEG2 : + strcpy(nom_geo,MED_NOM_SE2); + break; + + case MED_SEG3 : + strcpy(nom_geo,MED_NOM_SE3); + break; + + case MED_TRIA3 : + strcpy(nom_geo,MED_NOM_TR3); + break; + + case MED_TRIA6 : + strcpy(nom_geo,MED_NOM_TR6); + break; + + case MED_QUAD4 : + strcpy(nom_geo,MED_NOM_QU4); + break; + + case MED_QUAD8 : + strcpy(nom_geo,MED_NOM_QU8); + break; + + case MED_TETRA4 : + strcpy(nom_geo,MED_NOM_TE4); + break; + + case MED_TETRA10 : + strcpy(nom_geo,MED_NOM_T10); + break; + + case MED_HEXA8 : + strcpy(nom_geo,MED_NOM_HE8); + break; + + case MED_HEXA20 : + strcpy(nom_geo,MED_NOM_H20); + break; + + case MED_PENTA6 : + strcpy(nom_geo,MED_NOM_PE6); + break; + + case MED_PENTA15 : + strcpy(nom_geo,MED_NOM_P15); + break; + + case MED_PYRA5 : + strcpy(nom_geo,MED_NOM_PY5); + break; + + case MED_PYRA13 : + strcpy(nom_geo,MED_NOM_P13); + break; + + default : + return -1; + } + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnomLire.cxx b/src/MEDWrapper/V2_1/Core/MEDnomLire.cxx new file mode 100644 index 000000000..4ec85b304 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnomLire.cxx @@ -0,0 +1,101 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDnomLire(med_idt fid,char *maa, char *nom, med_int n, + med_entite_maillage type_ent,med_geometrie_element type_geo) +{ + med_idt root, maaid, entid, geoid; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + char nom_ent[MED_TAILLE_NOM_ENTITE+1]; + char nom_geo[MED_TAILLE_NOM_ENTITE+1]; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le maillage n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * On met a jour le nom du Data Group representant + * le type des entites + */ + if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) + return -1; + + /* + * Si le Data Group des entites n'existe pas => erreur + */ + if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) + return -1; + + /* + * Pour les mailles, les faces et le aretes, + * on ouvre le Data Group du type geometrique + */ + if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE)) + { + if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) + return -1; + if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) + return -1; + } + else + geoid = -1; + + /* + * lecture du Data Set "NOM" + */ + if (geoid == -1) + root = entid; + else + root = geoid; + if ((ret = _MEDdatasetStringLire(root,MED_NOM_NOM,nom)) < 0) + return -1; + + /* + * On ferme tout + */ + if (geoid > 0) + if ((ret = _MEDdatagroupFermer(geoid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(entid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnumEcr.cxx b/src/MEDWrapper/V2_1/Core/MEDnumEcr.cxx new file mode 100644 index 000000000..d72b6ce9f --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnumEcr.cxx @@ -0,0 +1,123 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDnumEcr(med_idt fid,char *maa, med_int *num, med_int n, med_mode_acces mode, + med_entite_maillage type_ent,med_geometrie_element type_geo) +{ + med_idt root, maaid, entid, geoid, dataset; + med_err ret; + med_size dimd[1]; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + char nom_ent[MED_TAILLE_NOM_ENTITE+1]; + char nom_geo[MED_TAILLE_NOM_ENTITE+1]; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le maillage n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * On met a jour le nom du Data Group representant + * le type des entites + */ + if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) + return -1; + + /* + * Si le Data Group des entites n'existe pas on le cree + */ + if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) + if ((root = _MEDdatagroupCreer(maaid,nom_ent)) < 0) + return -1; + + /* + * Pour les mailles, les faces et le aretes, on cree + * s'il n'existe pas le Data Group du type geometrique + */ + if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE)) + { + if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) + return -1; + + if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) + if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0) + return -1; + } + else + geoid = -1; + + /* + * Creation du Data Set "NUM" + */ + if (geoid == -1) + root = entid; + else + root = geoid; + dimd[0] = n; +#if defined(IRIX64)||defined(OSF1) + if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_NUM,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, + (unsigned char*) num,mode)) < 0) + return -1; +#else + if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_NUM,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, + (unsigned char*) num,mode)) < 0) + return -1; +#endif + + /* + * Attribut NBR (nombre de noeuds) + */ + if ((dataset = _MEDdatasetOuvrir(root,MED_NOM_NUM)) < 0) + return -1; + if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n,mode)) < 0) + return -1; + + /* + * On ferme tout + */ + if ((ret = _MEDdatasetFermer(dataset)) < 0) + return -1; + if (geoid != -1) + if ((ret = _MEDdatagroupFermer(geoid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(entid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDnumLire.cxx b/src/MEDWrapper/V2_1/Core/MEDnumLire.cxx new file mode 100644 index 000000000..938964060 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDnumLire.cxx @@ -0,0 +1,112 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDnumLire(med_idt fid,char *maa, med_int *num, med_int n, + med_entite_maillage type_ent,med_geometrie_element type_geo) +{ + med_idt root,maaid,entid,geoid; + med_err ret; + char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + char nom_ent[MED_TAILLE_NOM_ENTITE+1]; + char nom_geo[MED_TAILLE_NOM_ENTITE+1]; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le maillage n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * On met a jour le nom du Data Group representant + * le type des entites + */ + if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) + return -1; + + /* + * Si le Data Group des entites n'existe pas => erreur + */ + if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) + return -1; + + /* + * Pour les mailles, les faces et le aretes, + * si le Data Group du type geometrique => erreur + */ + if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE)) + { + if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) + return -1; + if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) + return -1; + } + else + geoid = -1; + + /* + * lecture du Data Set "NUM" + */ + if (geoid == -1) + root = entid; + else + root = geoid; +#if defined(IRIX64)||defined(OSF1) + if ((ret = _MEDdatasetNumLire(root,MED_NOM_NUM,MED_INT64, + MED_NO_INTERLACE,1,MED_ALL, + MED_NOPF,0,MED_NOPG, + (unsigned char*) num)) < 0) + return -1; +#else + if ((ret = _MEDdatasetNumLire(root,MED_NOM_NUM,MED_INT32, + MED_NO_INTERLACE,1,MED_ALL, + MED_NOPF,0,MED_NOPG, + (unsigned char*) num)) < 0) + return -1; +#endif + + /* + * On ferme tout + */ + if (geoid != -1) + if ((ret = _MEDdatagroupFermer(geoid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(entid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDobjetIdentifer.cxx b/src/MEDWrapper/V2_1/Core/MEDobjetIdentifer.cxx new file mode 100644 index 000000000..14361bee5 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDobjetIdentifer.cxx @@ -0,0 +1,49 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDobjetIdentifier + * - Description : retrouve le nom de l'objet de rang "indice" + * se trouvant dans le datagroup "chemin" + * - Parametres : + * - fid (IN) : l'ID du fichier ou se trouve le datagroup + * - chemin (IN) : chemin d'acces au datagroup + * - indice (IN) : indice de l'objet du datagroup dont on veut + * le nom + * - nom (OUT) : le nom + * - Resultat : 0 en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +_MEDobjetIdentifier(med_idt fid,char *chemin,int indice,void *nom) +{ + int idx; + + if ((idx = H5Giterate(fid,chemin,&indice,_MEDindiceInfo, + nom)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDouvrir.cxx b/src/MEDWrapper/V2_1/Core/MEDouvrir.cxx new file mode 100644 index 000000000..0d259deb6 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDouvrir.cxx @@ -0,0 +1,76 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#ifdef PPRO_NT +#define F_OK 0 +#else +#include +#endif + +namespace med_2_1{ + +med_idt +MEDouvrir(char *nom, med_mode_acces mode_acces) +{ + med_idt fid; + + /* + * On inhibe le gestionnaire d'erreur HDF + */ + _MEDmodeErreurVerrouiller(); + + /* + * On ouvre le fichier MED sous HDF + */ + switch(mode_acces) + { + case MED_LECT : + if (access(nom,F_OK)) + return -1; + else + if ((fid = _MEDfichierOuvrir(nom,mode_acces)) < 0) + return -1; + break; + + case MED_ECRI : + if (access(nom,F_OK)) + { + if ((fid = _MEDfichierCreer(nom)) < 0) + return -1; + } + else + if ((fid = _MEDfichierOuvrir(nom,mode_acces)) < 0) + return -1; + break; + + case MED_REMP : + if ((fid = _MEDfichierCreer(nom)) < 0) + return -1; + break; + + default : + return -1; + } + + return fid; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDparametresGeometrie.cxx b/src/MEDWrapper/V2_1/Core/MEDparametresGeometrie.cxx new file mode 100644 index 000000000..02a722f05 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDparametresGeometrie.cxx @@ -0,0 +1,164 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +/* + * - Nom de la fonction : _MEDparametresGeometrie + * - Description : fournit les parametres geometriques des differents + * entites et elements MED + * - Parametres : + * - typ_ent (IN) : type d'entite de l'element + * - type_geo (IN) : le type geometrique de l'element + * - dim (OUT) : dimension de l'element + * - nnoe (OUT) : nombre de noeuds composant l'element (connectivite + * nodale) + * - ndes (OUT) : nombre de composants dans l'elements (connectivite + * descendante) + * - Resultat : 0 en cas de succes, -1 sinon + */ + +namespace med_2_1{ + +med_err +_MEDparametresGeometrie(med_entite_maillage type_ent, + med_geometrie_element type_geo, int *dim, + int *nnoe,int *ndes) +{ + *nnoe = type_geo % 100; + *dim = type_geo / 100; + + switch(type_ent) + { + case MED_MAILLE : + switch (type_geo) + { + case MED_POINT1 : + *ndes = 0; + break; + + case MED_SEG2 : + *ndes = 2; + break; + + case MED_SEG3 : + *ndes = 3; + break; + + case MED_TRIA3 : + *ndes = 3; + break; + + case MED_TRIA6 : + *ndes = 3; + break; + + case MED_QUAD4 : + *ndes = 4; + break; + + case MED_QUAD8 : + *ndes = 4; + break; + + case MED_TETRA4 : + *ndes = 4; + break; + + case MED_TETRA10 : + *ndes = 4; + break; + + case MED_HEXA8 : + *ndes = 6; + break; + + case MED_HEXA20 : + *ndes = 6; + break; + + case MED_PENTA6 : + *ndes = 5; + break; + + case MED_PENTA15 : + *ndes = 5; + break; + + case MED_PYRA5 : + *ndes = 5; + break; + + case MED_PYRA13 : + *ndes = 5; + break; + + default : + return -1; + } + break; + + case MED_FACE : + switch(type_geo) + { + case MED_TRIA3 : + *ndes = 3; + break; + + case MED_TRIA6 : + *ndes = 3; + break; + + case MED_QUAD4 : + *ndes = 4; + break; + + case MED_QUAD8 : + *ndes = 4; + break; + + default : + return -1; + } + break; + + case MED_ARETE : + switch(type_geo) + { + case MED_SEG2 : + *ndes = 2; + break; + + case MED_SEG3 : + *ndes = 3; + break; + + default : + return -1; + } + break; + + default : + return -1; + } + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDpasdetempsInfo.cxx b/src/MEDWrapper/V2_1/Core/MEDpasdetempsInfo.cxx new file mode 100644 index 000000000..e95f6019c --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDpasdetempsInfo.cxx @@ -0,0 +1,100 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +/* Le nom de cette fonction n'est pas très bien choisie */ + +namespace med_2_1{ + +med_err +MEDpasdetempsInfo(med_idt fid,char *champ + ,med_entite_maillage type_ent, med_geometrie_element type_geo, + int indice, char *maa, med_int * ngauss, med_int * numdt, char * dt_unit, med_float * dt, + med_int * numo) +{ + + med_err ret=0; + med_int gauss_size; + med_idt gid; + char chemin[(MED_TAILLE_CHA+MED_TAILLE_NOM+1)+(2*MED_TAILLE_NOM_ENTITE+2)+2*MED_MAX_PARA+1]; + int num; + char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2],nomdatagroup2[2*MED_MAX_PARA+1]; + char tmp1 [MED_TAILLE_NOM_ENTITE+1]; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * On recupere le nom du datagroup . + */ + strcpy(chemin,MED_CHA); + strcat(chemin,champ); + strcat(chemin,"/"); + + if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0) + return -1; + if ((type_ent != MED_NOEUD)) + { + if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0) + return -1; + strcat(nomdatagroup1,"."); + strcat(nomdatagroup1,tmp1); + } + strcat(chemin,nomdatagroup1); + strcat(chemin,"/"); + + num = indice - 1; + if ((ret = _MEDobjetIdentifier(fid,chemin,num,nomdatagroup2)) < 0) + return -1; + strcat(chemin,nomdatagroup2); + if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * La liste des attributs + */ + if ((ret = _MEDattrStringLire(gid,MED_NOM_MAI,MED_TAILLE_NOM,maa)) < 0) + return -1; + + if ((ret = _MEDattrEntierLire(gid,MED_NOM_NDT,(med_int*) numdt)) < 0) + return -1; + + if ((ret = _MEDattrFloatLire(gid,MED_NOM_PDT,(med_float*) dt)) < 0) + return -1; + + if ((ret = _MEDattrStringLire(gid,MED_NOM_UNI,MED_TAILLE_PNOM,dt_unit)) < 0) + return -1; + + if ((ret = _MEDattrEntierLire(gid,MED_NOM_NOR,(med_int*) numo)) < 0) + return -1; + + if ( (ret = _MEDattrEntierLire(gid,MED_NOM_NGA,ngauss)) < 0 ) + return -1; + + + if ((ret = _MEDdatagroupFermer(gid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDprofilEcr.cxx b/src/MEDWrapper/V2_1/Core/MEDprofilEcr.cxx new file mode 100644 index 000000000..b2d1e97b8 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDprofilEcr.cxx @@ -0,0 +1,89 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDprofilEcr(med_idt fid,med_int *pflval,med_int n,char *nom) +{ + med_idt root, pid, did; + med_size dimd[1]; + med_err ret; + char chemin[MED_TAILLE_PROFILS+1]; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le groupe "PROFILS" n'existe pas, on le cree + */ + strncpy(chemin,MED_PROFILS,MED_TAILLE_PROFILS-1); + chemin[MED_TAILLE_PROFILS-1] = '\0'; + if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0) + if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) + return -1; + + /* + * Si le groupe "nom" n'existe pas, on le cree + * Sinon => erreur + */ + if ((pid = _MEDdatagroupOuvrir(root,nom)) >= 0) + return -1; + if ((pid = _MEDdatagroupCreer(root,nom)) < 0) + return -1; + + /* + * On stocke "n" sous forme d'attribut + */ + if ((ret = _MEDattrEntierEcrire(pid,MED_NOM_N,&n,MED_REMP)) < 0) + return -1; + + /* + * On stocke le profil dans un dataset + */ + dimd[0] = n; +#if defined(IRIX64)||defined(OSF1) + if ((ret = _MEDdatasetNumEcrire(pid,MED_NOM_PFL,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, + (unsigned char*) pflval,MED_REMP)) < 0) + return -1; +#else + if ((ret = _MEDdatasetNumEcrire(pid,MED_NOM_PFL,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, + (unsigned char*) pflval,MED_REMP)) < 0) + return -1; +#endif + + /* + * On ferme tout + */ + if ((ret = _MEDdatagroupFermer(pid)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(root)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDprofilInfo.cxx b/src/MEDWrapper/V2_1/Core/MEDprofilInfo.cxx new file mode 100644 index 000000000..77f29687f --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDprofilInfo.cxx @@ -0,0 +1,62 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDprofilInfo(med_idt fid, int indice, char *profil, med_int *n) +{ + int numero; + med_idt proid; + med_err ret; + char chemin[MED_TAILLE_PROFILS+MED_TAILLE_NOM+1]; + + /* + * On inhibe le gestionnaire d'erreur + */ + _MEDmodeErreurVerrouiller(); + + /* + * On recupere le nom du groupe de rang "indice" + */ + numero = indice-1; + if ((ret = _MEDobjetIdentifier(fid,MED_PROFILS,numero,profil)) < 0) + return -1; + + /* + * On va chercher l'attribut taille du profil + */ + strcpy(chemin,MED_PROFILS); + strcat(chemin,profil); + if ((proid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + if ((ret = _MEDattrEntierLire(proid,MED_NOM_N,n)) < 0) + return -1; + if ((ret = _MEDdatagroupFermer(proid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDprofilLire.cxx b/src/MEDWrapper/V2_1/Core/MEDprofilLire.cxx new file mode 100644 index 000000000..7621f82d8 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDprofilLire.cxx @@ -0,0 +1,73 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +namespace med_2_1{ + +med_err +MEDprofilLire(med_idt fid,med_int *pflval, char *nom) +{ + med_err ret = 0; + med_idt pid,did; + char chemin[MED_TAILLE_PROFILS+MED_TAILLE_NOM+1]; + + /* + * On inhibe le gestionnaire d'erreur HDF 5 + */ + _MEDmodeErreurVerrouiller(); + + /* + * ouverture du groupe /PROFILS/"nom" + */ + strcpy(chemin,MED_PROFILS); + strcat(chemin,nom); + if ((pid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * Lecture du profil + */ +#if defined(IRIX64)||defined(OSF1) + if ((ret = _MEDdatasetNumLire(pid,MED_NOM_PFL,MED_INT64, + MED_NO_INTERLACE,1,MED_ALL, + MED_NOPF,0,MED_NOPG, + (unsigned char *) pflval)) < 0) + return -1; +#else + if ((ret = _MEDdatasetNumLire(pid,MED_NOM_PFL,MED_INT32, + MED_NO_INTERLACE,1,MED_ALL, + MED_NOPF,0,MED_NOPG, + (unsigned char *) pflval)) < 0) + return -1; +#endif + + /* + * On ferme tout + */ + if ((ret = _MEDdatagroupFermer(pid)) < 0) + return -1; + + return ret; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDunvCr.cxx b/src/MEDWrapper/V2_1/Core/MEDunvCr.cxx new file mode 100644 index 000000000..a1bcd9843 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDunvCr.cxx @@ -0,0 +1,102 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +#include +#include + +#ifdef PPRO_NT +// Windows Header Files: +#include +#include +#include +#else +#include +#endif + +namespace med_2_1{ + +med_err +MEDunvCr(med_idt fid, char *maa) +{ + med_idt maaid; + char chemin [MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + char nomu [MED_TAILLE_LNOM+1]; + time_t temps; +#ifdef PPRO_NT + struct timeb tp; + char lpBuffer [UNLEN+1]; + long nSize = UNLEN+1; +#else + struct timeval tp; +#endif + med_err ret; + + /* + * On inhibe le gestionnaire d'erreur + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le maillage n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * Creation/Ecriture de l'attribut nom universel + */ + +#ifdef PPRO_NT + if ( GetUserName(lpBuffer,&nSize) == 0 ) return -1; + if ( nSize > MED_TAILLE_NOM ) nSize = MED_TAILLE_NOM; + strncpy(nomu,lpBuffer,nSize); + strcat(nomu," "); + temps=time(&temps); + strcat(nomu,ctime(&temps)); + ftime(&tp); + nSize = strlen(nomu)-1; + if ( sprintf(&nomu[nSize]," %hu",tp.millitm) < 0 ) return -1; +#else + if (cuserid(nomu) == (void*) NULL) return -1; + strcat(nomu," "); + temps=time(&temps); + strcat(nomu,ctime(&temps)); + if ( gettimeofday(&tp,NULL) < 0 ) return -1; + if ( sprintf(&nomu[strlen(nomu)-1]," %li",tp.tv_usec) < 0 ) return -1; +#endif + if ((ret = _MEDattrStringEcrire(maaid,MED_NOM_UNV,MED_TAILLE_LNOM,nomu,MED_REMP)) < 0) + return -1; + + /* + * Nettoyages divers + */ + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDunvLire.cxx b/src/MEDWrapper/V2_1/Core/MEDunvLire.cxx new file mode 100644 index 000000000..f6ddc5f6b --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDunvLire.cxx @@ -0,0 +1,66 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +#include +#include + +#include +#include + +namespace med_2_1{ + +med_err +MEDunvLire(med_idt fid, char *maa,char *nomu) +{ + med_idt maaid; + char chemin [MED_TAILLE_MAA+MED_TAILLE_NOM+1]; + med_err ret; + + /* + * On inhibe le gestionnaire d'erreur + */ + _MEDmodeErreurVerrouiller(); + + /* + * Si le maillage n'existe pas => erreur + */ + strcpy(chemin,MED_MAA); + strcat(chemin,maa); + if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) + return -1; + + /* + * Creation/Ecriture de l'attribut nom universel + */ + if ((ret = _MEDattrStringLire(maaid,MED_NOM_UNV,MED_TAILLE_LNOM, + nomu )) < 0) + return -1; + + /* + * Nettoyages divers + */ + if ((ret = _MEDdatagroupFermer(maaid)) < 0) + return -1; + + return 0; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDversionConforme.cxx b/src/MEDWrapper/V2_1/Core/MEDversionConforme.cxx new file mode 100644 index 000000000..764a9a83a --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDversionConforme.cxx @@ -0,0 +1,68 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +namespace med_2_1{ + +med_err +MEDversionConforme(const char *nom) { + med_int majeur, mineur; + med_idt fid, gid; + med_err ret; + + /* + * On inhibe le gestionnaire d'erreur HDF + */ + _MEDmodeErreurVerrouiller(); + + /* + * On ouvre le fichier MED en mode MED_LECT + */ + if ((fid = _MEDfichierOuvrir((char *)nom,MED_LECT)) < 0) + return -1; + + /* + * Lecture du numero de version + */ + if ((gid = _MEDdatagroupOuvrir(fid,MED_NOM_INFOS)) < 0) + return -1; + + if ((ret = _MEDattrEntierLire(gid,MED_NOM_MAJEUR,&majeur)) < 0) + return -1; + + if ((ret = _MEDattrEntierLire(gid,MED_NOM_MINEUR,&mineur)) < 0) + return -1; + + /* + * On ferme tout + */ + if ((ret = _MEDdatagroupFermer(gid)) < 0) + return -1; + + if ((ret = _MEDfichierFermer(fid)) < 0) + return -1; + + if ((majeur == MED_NUM_MAJEUR) && (mineur == MED_NUM_MINEUR)) + return 0; + else + return -1; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDversionDonner.cxx b/src/MEDWrapper/V2_1/Core/MEDversionDonner.cxx new file mode 100644 index 000000000..33a57726a --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDversionDonner.cxx @@ -0,0 +1,31 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +namespace med_2_1{ + +void +MEDversionDonner(med_int *majeur, med_int *mineur, med_int *release) { + *majeur = MED_NUM_MAJEUR; + *mineur = MED_NUM_MINEUR; + *release = MED_NUM_RELEASE; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/MEDversionLire.cxx b/src/MEDWrapper/V2_1/Core/MEDversionLire.cxx new file mode 100644 index 000000000..b358d8357 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/MEDversionLire.cxx @@ -0,0 +1,55 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#include "med.hxx" +#include "med_outils.hxx" + +namespace med_2_1{ + +med_err +MEDversionLire(med_idt fid, med_int *majeur, med_int *mineur, med_int *release) +{ + med_err ret = 0; + med_idt gid; + + /* On ouvre le group ou se trouvent les infos */ + if ((gid = _MEDdatagroupOuvrir(fid,MED_NOM_INFOS)) < 0) { + *majeur = 2; + *mineur = -1; + *release = -1; + ret = 0; + } + else { + if ((ret = _MEDattrEntierLire(gid,MED_NOM_MAJEUR,majeur)) < 0) + return -1; + + if ((ret = _MEDattrEntierLire(gid,MED_NOM_MINEUR,mineur)) < 0) + return -1; + + if ((ret = _MEDattrEntierLire(gid,MED_NOM_RELEASE,release)) < 0) + return -1; + + /* On ferme tout */ + if ((ret = _MEDdatagroupFermer(gid)) < 0) + return -1; + } + + return ret; +} + +} diff --git a/src/MEDWrapper/V2_1/Core/Makefile.in b/src/MEDWrapper/V2_1/Core/Makefile.in new file mode 100644 index 000000000..8cdceac4b --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/Makefile.in @@ -0,0 +1,169 @@ +# +# +# Copyright (C) 2003 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +# +# +# +# File : +# Author : +# Module : +# $Header$ + +top_srcdir=@top_srcdir@ +top_builddir=../../../.. +srcdir=@srcdir@ +VPATH=.:@srcdir@:@top_srcdir@/idl + + +@COMMENCE@ + +LIB_SRC_TOOLS_HDFI= \ +MEDattrFermer.cxx \ +MEDattrNumEcrire.cxx \ +MEDattrNumLire.cxx \ +MEDattrOuvrir.cxx \ +MEDattrStringEcrire.cxx \ +MEDattrStringLire.cxx \ +MEDdatagroupCreer.cxx \ +MEDdatagroupFermer.cxx \ +MEDdatagroupOuvrir.cxx \ +MEDdatasetFermer.cxx \ +MEDdatasetNumEcrire.cxx \ +MEDdatasetNumLire.cxx \ +MEDdatasetOuvrir.cxx \ +MEDdatasetStringEcrire.cxx \ +MEDdatasetStringLire.cxx \ +MEDfichierCreer.cxx \ +MEDfichierFermer.cxx \ +MEDfichierOuvrir.cxx \ +MEDindiceInfo.cxx \ +MEDindiceNum.cxx \ +MEDmodeErreurVerrouiller.cxx \ +MEDnObjets.cxx \ +MEDobjetIdentifer.cxx + +LIB_SRC_TOOLS_MISC= \ +MED1cstring.cxx MEDnomDataset.cxx \ +MED2cstring.cxx MEDnomEntite.cxx \ +MEDGeometrieElement.cxx MEDnomGeometrie.cxx \ +MEDcstringFree.cxx MEDparametresGeometrie.cxx \ +MEDfstring.cxx + +LIB_SRC_API_CI= \ +MEDchampCr.cxx \ +MEDchampEcr.cxx \ +MEDchampInfo.cxx \ +MEDchampLire.cxx \ +MEDconnEcr.cxx \ +MEDconnLire.cxx \ +MEDcoordEcr.cxx \ +MEDcoordLire.cxx \ +MEDdimLire.cxx \ +MEDelementsEcr.cxx \ +MEDelementsLire.cxx \ +MEDequivCr.cxx \ +MEDequivEcr.cxx \ +MEDequivInfo.cxx \ +MEDequivLire.cxx \ +MEDfam2groA.cxx \ +MEDfam2groB.cxx \ +MEDfamCr.cxx \ +MEDfamEcr.cxx \ +MEDfamInfo.cxx \ +MEDfamLire.cxx \ +MEDfamMaaCr.cxx \ +MEDfamMaaInfo.cxx \ +MEDfamMaaLire.cxx \ +MEDfermer.cxx \ +MEDfichDesEcr.cxx \ +MEDfichEntete.cxx \ +MEDgro2famA.cxx \ +MEDgro2famB.cxx \ +MEDlFichDes.cxx \ +MEDmaaCr.cxx \ +MEDmaaInfo.cxx \ +MEDnChamp.cxx \ +MEDnCorres.cxx \ +MEDnEntMaa.cxx \ +MEDnEntites.cxx \ +MEDnEquiv.cxx \ +MEDnFam.cxx \ +MEDnMaa.cxx \ +MEDnPasdetemps.cxx \ +MEDnProfil.cxx \ +MEDnVal.cxx \ +MEDnValProfil.cxx \ +MEDnbnoisEcr.cxx \ +MEDnbnoisLire.cxx \ +MEDnbnomaEcr.cxx \ +MEDnbnomaLire.cxx \ +MEDnbnosoEcr.cxx \ +MEDnbnosoLire.cxx \ +MEDnoeudsEcr.cxx \ +MEDnoeudsLire.cxx \ +MEDnomEcr.cxx \ +MEDnomLire.cxx \ +MEDnumEcr.cxx \ +MEDnumLire.cxx \ +MEDouvrir.cxx \ +MEDpasdetempsInfo.cxx \ +MEDprofilEcr.cxx \ +MEDprofilLire.cxx \ +MEDprofilInfo.cxx \ +MEDunvCr.cxx \ +MEDunvLire.cxx \ +MEDformatConforme.cxx \ +MEDversionConforme.cxx \ +MEDversionDonner.cxx \ +MEDversionLire.cxx \ +MEDbodyFittedEcr.cxx \ +MEDbodyFittedLire.cxx \ +MEDfamGridEcr.cxx \ +MEDfamGridLire.cxx \ +MEDgridCr.cxx \ +MEDgridEcr.cxx \ +MEDgridInfo.cxx \ +MEDgridLire.cxx \ +MEDnGrid.cxx + +# Libraries targets + +LIB = libmed_V2_1.la +LIB_SRC = \ + $(LIB_SRC_TOOLS_HDFI) \ + $(LIB_SRC_TOOLS_MISC) \ + $(LIB_SRC_API_CI) + +EXPORT_HEADERS = \ + med.hxx \ + med_proto.hxx \ + hdf5_version2api.hxx + +# Executables targets +BIN = mdump_V2_1 test1_V2_1 +BIN_SRC = + +CPPFLAGS+= -D@MACHINE@ $(BOOST_CPPFLAGS) $(HDF5_INCLUDES) + +LDFLAGS+= $(HDF5_LIBS) + +LDFLAGSFORBIN=$(LDFLAGS) + +@CONCLUDE@ diff --git a/src/MEDWrapper/V2_1/Core/hdf5_version2api.hxx b/src/MEDWrapper/V2_1/Core/hdf5_version2api.hxx new file mode 100644 index 000000000..2e353ea07 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/hdf5_version2api.hxx @@ -0,0 +1,45 @@ + +#ifndef _hdf5_version2api_hxx_ +#define _hdf5_version2api_hxx_ +// Copyright (C) 2005 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/ +// + +#include + +#if H5_VERS_MAJOR < 1 +#elif H5_VERS_MAJOR == 1 + +#if H5_VERS_MINOR < 6 +#elif H5_VERS_MINOR == 6 + +#if H5_VERS_RELEASE < 4 +#else +#define HDF_NEW_API +#endif + +#else /* H5_VERS_MINOR >= 7 */ +#define HDF_NEW_API +#endif /* H5_VERS_MINOR */ + +#else /* H5_VERS_MAJOR >= 2 */ +#define HDF_NEW_API +#endif /* H5_VERS_MAJOR */ + +#endif diff --git a/src/MEDWrapper/V2_1/Core/mdump_V2_1.cxx b/src/MEDWrapper/V2_1/Core/mdump_V2_1.cxx new file mode 100644 index 000000000..6c959fde4 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/mdump_V2_1.cxx @@ -0,0 +1,1626 @@ +/****************************************************************************** + * - Nom du fichier : mdump.c + * + * - Description : utilitaire de dump pour fichier MED V2.1 + * + *****************************************************************************/ +#define NBR_MAILLE_EQU 7 + +#include +#include +#include + +#include "med.hxx" +using namespace med_2_1; + +/******************************************************************* + * DUMP D'UN FICHIER MED STRUCTURE EN GRILLE : * + * NOEUDS, ELEMENTS, FAMILLES, EQUIVALENCES, CHAMPS DE RESULTATS * + *******************************************************************/ + +int grid_cartesian_or_polar(med_idt fid, int numero, med_mode_switch mode_coo) { + med_int mdim, nnoe, nfam, i, j; + char nommaa[MED_TAILLE_NOM+1]; + char nom_universel[MED_TAILLE_LNOM+1]; + med_float *coo; + med_int *fam; + char nomcoo[3*MED_TAILLE_PNOM+1]; + char unicoo[3*MED_TAILLE_PNOM+1]; + med_repere rep; + char str[MED_TAILLE_PNOM+1]; + + fprintf(stdout,"\n(****************************)\n"); + fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n"); + fprintf(stdout,"(****************************)\n"); + + /* lecture du nom et de la dimension de la grille */ + if (MEDmaaInfo(fid, numero, nommaa, &mdim) < 0) { + fprintf(stderr, ">> ERREUR : lecture du nom de la grille\n"); + return(EXIT_FAILURE); + }; + fprintf(stdout, "- Nom de la grille : <<%s>>\n", nommaa); + fprintf(stdout, "- Dimension de la grille : %d\n", mdim); + + /* lecture du nom universel (presence optionnelle) */ + if (MEDunvLire(fid, nommaa, nom_universel) > 0) { + fprintf(stdout, "- Nom universel de la grille : %s \n", nom_universel); + } else { + fprintf(stdout, "- Pas de nom universel \n"); + }; + + /* nombre de familles */ + nfam = MEDnFam(fid, nommaa, 0, (med_dim_famille)0); + if (nfam < 0) { + fprintf(stderr, ">> ERREUR : lecture du nombre de familles\n"); + return(EXIT_FAILURE); + }; + fprintf(stdout, "- Nombre de familles : %d \n", nfam); + + fprintf(stdout, "\n- Lecture des indices : \n"); + for (i=0; i> ERREUR : lecture des indices \n"); + return(EXIT_FAILURE); + }; + + fprintf(stdout, "- Type de repere des coordonnees : %d \n", rep); + + fprintf(stdout, "- Nom des coordonnees : \n"); + for (j=0; j 0) { + fam = (med_int*)malloc(sizeof(med_int)*nfam); + if (MEDfamGridLire(fid, nommaa, fam, nfam,MED_NOEUD) < 0) { + fprintf(stderr, ">> ERREUR : lecture des familles\n"); + return(EXIT_FAILURE); + }; + + fprintf(stdout, "\n- Numeros des familles des noeuds :\n"); + for (i=0; i> ERREUR : lecture du nom du maillage body fitted\n"); + return(EXIT_FAILURE); + }; + fprintf(stdout, "- Nom du maillage body fitted : <<%s>>\n", nommaa); + fprintf(stdout, "- Dimension du maillage body fitted : %d\n", mdim); + + /* lecture du nom universel (presence optionnelle) */ + if (MEDunvLire(fid, nommaa, nom_universel) > 0) { + fprintf(stdout, "- Nom universel du maillage body fitted : %s \n", nom_universel); + } else { + fprintf(stdout, "- Pas de nom universel \n"); + }; + + /* Combien de noeuds ? */ + /* nnoe = MEDnGrid(fid, nommaa, -1);*/ + nnoe = MEDnGrid(fid, nommaa, MED_GRID_NOEUD); + if (nnoe < 0) { + fprintf(stderr, ">> ERREUR : lecture du nombre de noeuds (via MEDnGrid) \n"); + return(EXIT_FAILURE); + }; + fprintf(stdout, "- Nombre de noeuds : %d \n", nnoe); + + /* Combien de noeuds dans la dimension 1 ? */ + i = MEDnGrid(fid, nommaa, (med_grid)0); + if (i < 0) { + fprintf(stderr, ">> ERREUR : lecture du nombre de noeuds (via MEDnGrid) dans la dimension 1 \n"); + return(EXIT_FAILURE); + }; + fprintf(stdout, "- Nombre de noeuds dans la dimension 1 : %d \n", i); + + /* Combien de noeuds dans la dimension 2 ? */ + i = MEDnGrid(fid, nommaa, (med_grid)1); + if (i < 0) { + fprintf(stderr, ">> ERREUR : lecture du nombre de noeuds (via MEDnGrid) dans la dimension 2 \n"); + return(EXIT_FAILURE); + }; + fprintf(stdout, "- Nombre de noeuds dans la dimension 2 : %d \n", i); + + /* nombre de familles */ + nfam = MEDnFam(fid, nommaa, 0,(med_dim_famille)0); + if (nfam < 0) { + fprintf(stderr, ">> ERREUR : lecture du nombre de familles \n"); + return(EXIT_FAILURE); + }; + fprintf(stdout, "- Nombre de familles : %d \n", nfam); + + coo = (med_float*)malloc(sizeof(med_float)*nnoe*mdim); + fam = (med_int*)malloc(sizeof(med_int)*nnoe); + + if (MEDbodyFittedLire(fid, nommaa, mdim, coo, mode_coo, &rep, nomcoo, unicoo, fam, nnoe) < 0) { + fprintf(stderr, ">> ERREUR : lecture des noeuds \n"); + return(EXIT_FAILURE); + }; + + fprintf(stdout, "- Type de repere des coordonnees : %d \n", rep); + + fprintf(stdout, "- Nom des coordonnees : \n"); + for (i=0; i> ERREUR : type de maillage inconnu\n"); + return(EXIT_FAILURE); + }; + }; +} + +/****************************************************************************** + * DUMP D'UN FICHIER MED : NOEUDS, + * ELEMENTS, FAMILLES, EQUIVALENCES, CHAMPS DE RESULTATS + *****************************************************************************/ + +int main (int argc, char **argv) +{ + med_err ret = 0; + med_idt fid; + int i,j,k,l,kp; + int numero; + char message[200]; + /* nombre d'objets MED */ + char nom_universel[MED_TAILLE_LNOM+1]; + med_int long_fichier_en_tete; + char *fichier_en_tete; + char version_hdf[10]; + char version_med[10]; + med_int nmaa,mdim,nnoe; + med_int nmai[MED_NBR_GEOMETRIE_MAILLE],nfac[MED_NBR_GEOMETRIE_FACE]; + med_int nare[MED_NBR_GEOMETRIE_ARETE]; + /* nom du maillage */ + char nommaa[MED_TAILLE_NOM+1]; + /* noeuds */ + med_float *coo; + char nomcoo[3*MED_TAILLE_PNOM+1]; + char unicoo[3*MED_TAILLE_PNOM+1]; + char *nomnoe; + med_int *numnoe; + med_int *nufano; + med_repere rep; + med_booleen inonoe,inunoe; + med_mode_switch mode_coo; + char str[MED_TAILLE_PNOM+1]; + /* elements */ + med_int nsup; + med_int edim; + med_int taille; + med_int *connectivite; + char *nomele; + med_int *numele; + med_int *nufael; + med_booleen inoele, inuele; + med_connectivite typ_con; + med_geometrie_element typgeo; + med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE] = {MED_POINT1,MED_SEG2, + MED_SEG3,MED_TRIA3, + MED_TRIA6,MED_QUAD4, + MED_QUAD8,MED_TETRA4, + MED_TETRA10,MED_HEXA8, + MED_HEXA20,MED_PENTA6, + MED_PENTA15,MED_PYRA5, + MED_PYRA13}; + med_int desmai[MED_NBR_GEOMETRIE_MAILLE] = {0,2,3,3,3,4,4,4,4,6,6,5,5,5,5}; + med_int nmailles[MED_NBR_GEOMETRIE_MAILLE]; + char nommai[MED_NBR_GEOMETRIE_MAILLE] [MED_TAILLE_NOM+1] = {"MED_POINT1", + "MED_SEG2", + "MED_SEG3", + "MED_TRIA3", + "MED_TRIA6", + "MED_QUAD4", + "MED_QUAD8", + "MED_TETRA4", + "MED_TETRA10", + "MED_HEXA8", + "MED_HEXA20", + "MED_PENTA6", + "MED_PENTA15", + "MED_PYRA5", + "MED_PYRA13"}; + med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6, + MED_QUAD4,MED_QUAD8}; + med_int desfac[MED_NBR_GEOMETRIE_FACE] = {3,3,4,4}; + med_int nfaces[MED_NBR_GEOMETRIE_FACE]; + char nomfac[MED_NBR_GEOMETRIE_FACE][MED_TAILLE_NOM+1] = {"MED_TRIA3","MED_TRIA6", + "MED_QUAD4","MED_QUAD8"}; + med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3}; + med_int desare[MED_NBR_GEOMETRIE_ARETE] = {2,3}; + med_int naretes[MED_NBR_GEOMETRIE_ARETE]; + char nomare[MED_NBR_GEOMETRIE_ARETE] [MED_TAILLE_NOM+1] = {"MED_SEG2","MED_SEG3"}; + /* familles */ + med_int nfam; + med_int natt,ngro; + char *attdes,*gro; + med_int *attval,*attide; + char nomfam[MED_TAILLE_NOM+1]; + med_int numfam; + char str1[MED_TAILLE_DESC+1]; + char str2[MED_TAILLE_LNOM+1]; + /* equivalences */ + med_int nequ,ncor; + med_int *cor; + char equ[MED_TAILLE_NOM+1]; + char des[MED_TAILLE_DESC+1]; + /* champs de resultats */ + char *comp; + char *unit; + char nomcha[MED_TAILLE_NOM+1]; + char maillage_champ[MED_TAILLE_NOM+1]; + med_int ncomp; + med_float *valr; + med_int *vale; + med_type_champ typcha; + med_int ncha; + med_int nval; + int reponse; + int lecture_en_tete_seulement = 0; + med_int npdt; + med_int ngauss,numdt,numo; + med_float dt; + char dtunit[MED_TAILLE_PNOM+1]; + char pflnom[MED_TAILLE_NOM+1]; + med_int pflsize; + med_int *pflval; + med_int isGrid; + med_grid_type theType; + + /**************************************************************************** + * TEST DU NOMBRE D'ARGUMENTS * + * argument 1 = nom du fichier MED * + ****************************************************************************/ + if (argc != 2 && argc != 5) + { + fprintf(stderr,">> ERREUR : nombre de parametres incorrects \n"); + exit(EXIT_FAILURE); + } + + /**************************************************************************** + * OUVERTURE DU FICHIER EN LECTURE * + ****************************************************************************/ + fid = MEDouvrir(argv[1],MED_LECT); + if (fid < 0) + { + fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",argv[1]); + exit(EXIT_FAILURE); + } + + + /**************************************************************************** + * QUESTIONS PRELIMINAIRES * + * 1. Mode d'affichage des coordonnees (entrelace ou non) ? * + * 2. Connectivite des elements (nodale ou descendante) * + ****************************************************************************/ + fprintf(stdout,"\n >>>>>> DUMP DU FICHIER %s >>>>>>\n",argv[1]); + + /* en-tete du fichier (presence optionnelle) */ + long_fichier_en_tete = MEDlFichDes(fid); + if (long_fichier_en_tete > 0) + { + fichier_en_tete = (char *) malloc(sizeof(char)*(long_fichier_en_tete+1)); + ret = MEDfichEntete(fid,MED_FICH_DES,fichier_en_tete); + if (ret < 0) + { + fprintf(stderr,">> ERREUR : lecture de l'en-tete du fichier \n"); + exit(EXIT_FAILURE); + } + fprintf(stdout,"- En-tete du fichier : %s \n",fichier_en_tete); + free(fichier_en_tete); + } + /* versions hdf et med */ + ret = MEDfichEntete(fid,MED_HDF_VERSION,version_hdf); + if (ret < 0) + { + fprintf(stderr,">> ERREUR : lecture du numero de version de HDF \n"); + exit(EXIT_FAILURE); + } + ret = MEDfichEntete(fid,MED_VERSION,version_med); + if (ret < 0) + { + fprintf(stderr,">> ERREUR : lecture du numero de version de MED \n"); + exit(EXIT_FAILURE); + } + fprintf(stdout,"- Version de HDF utilisee : %s \n",version_hdf); + fprintf(stdout,"- Version de MED utilisee : %s \n",version_med); + + if (argc == 2) + { + fprintf(stdout,"(*****************)\n"); + fprintf(stdout,"(* PARAMETRAGE : *)\n"); + fprintf(stdout,"(*****************)\n"); + fprintf(stdout,"- Mode d'affichage des coordonnées des noeuds ? \n"); + fprintf(stdout," 1. Mode entrelacé : taper 1 \n"); + fprintf(stdout," 2. Mode non entrelacé : taper 2 \n"); + reponse = 0; + do + { + fprintf(stdout," Reponse : "); + scanf("%d",&reponse); + } + while (reponse != 1 && reponse != 2); + if (reponse == 1) + mode_coo = MED_FULL_INTERLACE; + else + mode_coo = MED_NO_INTERLACE; + + fprintf(stdout,"- Connectivité des éléments ? \n"); + fprintf(stdout," 1. Nodale : taper 1 \n"); + fprintf(stdout," 2. Descendante : taper 2 \n"); + reponse = 0; + do + { + fprintf(stdout," Reponse : "); + scanf("%d",&reponse); + } + while (reponse != 1 && reponse != 2); + if (reponse == 1) + typ_con = MED_NOD; + else + typ_con = MED_DESC; + } + else + { + if (! strcmp(argv[3],"NODALE")) + typ_con = MED_NOD; + if (! strcmp(argv[3],"DESCENDANTE")) + typ_con = MED_DESC; + + if (!strcmp(argv[4],"NO_INTERLACE")) + mode_coo = MED_NO_INTERLACE; + if (!strcmp(argv[4],"FULL_INTERLACE")) + mode_coo = MED_FULL_INTERLACE; + if (! strcmp(argv[4],"LECTURE_EN_TETE_SEULEMENT")) + lecture_en_tete_seulement = 1; + + } + + /**************************************************************************** + * QUEL MAILLAGE LIRE * + ****************************************************************************/ + nmaa = MEDnMaa(fid); + if (nmaa < 0) + { + fprintf(stderr,">> ERREUR : lecture du nombre de maillages \n"); + exit(EXIT_FAILURE); + } + + /* Quel maillage lire ? */ + if (argc == 2) + { + fprintf(stdout,"- Il y a %d maillages dans ce fichier \n",nmaa); + fprintf(stdout," Lequel voulez-vous lire (1|2|3|...|n) ?\n"); + do + { + fprintf(stdout," Reponse : "); + scanf("%d",&numero); + } + while (numero > nmaa || numero <= 0); + } + else + { + numero = atoi(argv[2]); + if (numero > nmaa || numero <= 0) + { + fprintf(stderr,">> ERREUR : il y a %d maillages dans ce fichier \n", + nmaa); + exit(EXIT_FAILURE); + } + } + +/***************************************************************************** + * QUELLE SORTE DE MAILLAGE : GRILLE OU PAS * + *****************************************************************************/ + + fprintf(stdout,"\n(**************************************************)\n"); + fprintf(stdout,"(* MAILLAGE STRUCTURE (GRILLE) OU NON STRUCTURE : *)\n"); + fprintf(stdout,"(**************************************************)\n"); + + /* lecture de la sorte de maillage : structure ou pas */ + ret = MEDgridInfo(fid, numero, &isGrid, &theType); + if (ret < 0) { + fprintf(stderr, ">> ERREUR : lecture de la sorte de maillage (structure ou pas)\n"); + exit(EXIT_FAILURE); + }; + fprintf(stdout, "- Sorte de maillage : %s\n", isGrid? "structure (grille)": "non structure"); + if (isGrid) { + ret = grid(fid, numero, theType, mode_coo); + if (ret == 0) { + ret = MEDfermer(fid); + if (ret == 0) { + fprintf(stdout, "\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n", argv[1]); + } else { + fprintf(stderr, ">> ERREUR : erreur a la fermeture du fichier %s\n", argv[1]); + }; + }; + if (ret == 0) { + return(0); + } else { + exit(EXIT_FAILURE); + }; + }; + + /**************************************************************************** + * NOMBRES D'OBJETS MED * + ****************************************************************************/ + fprintf(stdout,"\n(****************************)\n"); + fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n"); + fprintf(stdout,"(****************************)\n"); + + /* lecture du nom et de la dimension du maillage */ + ret = MEDmaaInfo(fid,numero,nommaa,&mdim); + if (ret < 0) + { + fprintf(stderr,">> ERREUR : lecture du nom du maillage \n"); + exit(EXIT_FAILURE); + } + fprintf(stdout,"- Nom du maillage : <<%s>>\n",nommaa); + fprintf(stdout,"- Dimension du maillage : %d\n",mdim); + + /* lecture du nom universel (presence optionnelle) */ + ret = MEDunvLire(fid,nommaa,nom_universel); + if (ret > 0) + fprintf(stdout,"- Nom universel du maillage : %s \n",nom_universel); + else + fprintf(stdout,"- Pas de nom universel \n"); + + + /* Combien de noeuds ? */ + nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,(med_geometrie_element)0,(med_connectivite)0); + if (nnoe < 0) + { + fprintf(stderr,">> ERREUR : lecture du nombre de noeuds (via MEDnEntMaa) \n"); + exit(EXIT_FAILURE); + } + fprintf(stdout,"- Nombre de noeuds : %d \n",nnoe); + + /* Combien de mailles, faces ou aretes ? */ + for (i=0;i> ERREUR : lecture du nombre de mailles \n"); + exit(EXIT_FAILURE); + } + fprintf (stdout,"- Nombre de mailles de type %s : %d \n",nommai[i],nmailles[i]); + } + + for (i=0;i> ERREUR : lecture du nombre de faces \n"); + exit(EXIT_FAILURE); + } + fprintf (stdout,"- Nombre de faces de type %s : %d \n",nomfac[i],nfaces[i]); + } + + for (i=0;i> ERREUR : lecture du nombre d'aretes \n"); + exit(EXIT_FAILURE); + } + fprintf (stdout,"- Nombre d'aretes de type %s : %d \n",nomare[i],naretes[i]); + } + + /* nombre de familles */ + nfam = MEDnFam(fid,nommaa,0,(med_dim_famille)0); + if (nfam < 0) + { + fprintf(stderr,">> ERREUR : lecture du nombre de familles \n"); + exit(EXIT_FAILURE); + } + fprintf(stdout,"- Nombre de familles : %d \n",nfam); + + /* combien d'equivalences dans le fichier */ + nequ = MEDnEquiv(fid,nommaa); + if (nequ < 0) + { + fprintf(stderr,">> ERREUR : lecture du nombre d'equivalences \n"); + exit(EXIT_FAILURE); + } + fprintf(stdout,"- Nombre d'equivalences : %d \n",nequ); + + /* combien de champs dans le fichier */ + ncha = MEDnChamp(fid,0); + if (ncha < 0) + { + fprintf(stderr,">> ERREUR : lecture du nombre de champs \n"); + exit(EXIT_FAILURE); + } + fprintf(stdout,"- Nombre de champs : %d \n",ncha); + + /* Doit-on s'arreter ? */ + if (lecture_en_tete_seulement) + { + ret = MEDfermer(fid); + if (ret == 0) + { + fprintf(stdout,"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1]); + return 0; + } + else + { + fprintf(stderr,">> ERREUR : fermeture du fichier %s \n",argv[1]); + exit(EXIT_FAILURE); + } + } + + /**************************************************************************** + * LECTURE DES NOEUDS * + ****************************************************************************/ + fprintf(stdout,"\n(************************)\n"); + fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n"); + fprintf(stdout,"(************************)\n"); + + /* Allocations memoires */ + /* table des coordonnees + profil : (dimension * nombre de noeuds ) */ + coo = (med_float*) malloc(sizeof(med_float)*nnoe*mdim); + /* table des numeros, des numeros de familles des noeuds + profil : (nombre de noeuds) */ + numnoe = (med_int*) malloc(sizeof(med_int)*nnoe); + nufano = (med_int*) malloc(sizeof(med_int)*nnoe); + /* table des noms des noeuds + profil : (nnoe*MED_TAILLE_PNOM+1) */ + nomnoe = (char*) malloc(MED_TAILLE_PNOM*nnoe+1); + + /* lecture des noeuds : + - coordonnees + - noms (optionnel dans un fichier MED) + - numeros (optionnel dans un fichier MED) + - numeros des familles */ + ret = MEDnoeudsLire(fid,nommaa,mdim,coo,mode_coo,&rep, + nomcoo,unicoo,nomnoe,&inonoe,numnoe,&inunoe, + nufano,nnoe); + if (ret < 0) + strcpy(message,">> ERREUR : lecture des noeuds \n"); + + /* affichage des resultats */ + if (ret == 0) + { + fprintf(stdout,"- Type de repere des coordonnees : %d \n",rep); + fprintf(stdout,"- Nom des coordonnees : \n"); + for (i=0;i 0 && ret == 0) + { + /* dimension de la maille */ + edim = typmai[i] / 100; + nsup = 0; + if (mdim == 2 || mdim == 3) + if (edim == 1) + nsup = 1; + if (mdim == 3) + if (edim == 2) + nsup = 1; + switch(typ_con) + { + case MED_NOD : + taille = nsup+typmai[i]%100; + break; + + case MED_DESC : + taille = nsup+desmai[i]; + break; + + default : + ret = -1; + } + + /* allocation memoire */ + connectivite = (med_int*)malloc(sizeof(med_int)* + taille*nmailles[i]); + nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM* + nmailles[i]+1); + numele = (med_int*)malloc(sizeof(med_int)* + nmailles[i]); + nufael = (med_int*)malloc(sizeof(med_int)* + nmailles[i]); + + /* lecture des données */ + ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo, + nomele,&inoele,numele,&inuele,nufael, + nmailles[i],MED_MAILLE,typmai[i], + typ_con); + if (ret < 0) + strcpy(message,">> ERREUR : lecture des mailles \n"); + + /* affichage des resultats */ + if (ret == 0) + { + fprintf(stdout,"\n\n- Mailles de type %s : ", nommai[i]); + fprintf(stdout,"\n - Connectivité : \n"); + for (j=0;j 0 && ret == 0) + { + /* dimension de la face */ + edim = typfac[i] / 100; + nsup = 0; + if (mdim == 2 || mdim == 3) + if (edim == 1) + nsup = 1; + if (mdim == 3) + if (edim == 2) + nsup = 1; + switch(typ_con) + { + case MED_NOD : + taille = nsup+typfac[i]%100; + break; + + case MED_DESC : + taille = nsup+desfac[i]; + break; + + default : + ret = -1; + } + + /* allocation memoire */ + connectivite = (med_int*)malloc(sizeof(med_int)* + taille*nfaces[i]); + nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM* + nfaces[i]+1); + numele = (med_int*)malloc(sizeof(med_int)* + nfaces[i]); + nufael = (med_int*)malloc(sizeof(med_int)* + nfaces[i]); + + /* lecture des données */ + ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo, + nomele,&inoele,numele,&inuele,nufael, + nfaces[i],MED_FACE,typfac[i], + typ_con); + if (ret < 0) + strcpy(message,">> ERREUR : lecture des faces \n"); + + /* affichage des resultats */ + if (ret == 0) + { + fprintf(stdout,"\n- Faces de type %s : ", nomfac[i]); + fprintf(stdout,"\n - Connectivité : \n"); + for (j=0;j 0 && ret == 0) + { + /* dimension de l'arete */ + edim = typare[i] / 100; + nsup = 0; + if (mdim == 2 || mdim == 3) + if (edim == 1) + nsup = 1; + if (mdim == 3) + if (edim == 2) + nsup = 1; + switch(typ_con) + { + case MED_NOD : + taille = nsup+typare[i]%100; + break; + + case MED_DESC : + taille = nsup+desare[i]; + break; + + default : + ret = -1; + } + + /* allocation memoire */ + connectivite = (med_int*)malloc(sizeof(med_int)* + taille*naretes[i]); + nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM* + naretes[i]+1); + numele = (med_int*)malloc(sizeof(med_int)* + naretes[i]); + nufael = (med_int*)malloc(sizeof(med_int)* + naretes[i]); + + /* lecture des données */ + ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo, + nomele,&inoele,numele,&inuele,nufael, + naretes[i],MED_ARETE,typare[i], + typ_con); + if (ret < 0) + strcpy(message,">> ERREUR : lecture des aretes \n"); + + /* affichage des resultats */ + if (ret == 0) + { + fprintf(stdout,"\n- Aretes de type %d : ", nomare[i]); + fprintf(stdout,"\n - Connectivité : \n"); + for (j=0;j> ERREUR : lecture du nombre de groupes d'une famille \n"); + } + + /* nombre d'attributs */ + if (ret == 0) + { + natt = MEDnFam(fid,nommaa,i+1,MED_ATTR); + if (natt < 0) + { + ret = -1; + strcpy(message, + ">> ERREUR : lecture du nombre d'attributs d'une famille\n"); + } + } + + if (ret == 0) + fprintf(stdout,"- Famille %d a %d attributs et %d groupes \n",i+1,natt,ngro); + + /* nom,numero,attributs,groupes */ + if (ret == 0) + { + attide = (med_int*) malloc(sizeof(med_int)*natt); + attval = (med_int*) malloc(sizeof(med_int)*natt); + attdes = (char *) malloc(MED_TAILLE_DESC*natt+1); + gro = (char*) malloc(MED_TAILLE_LNOM*ngro+1); + ret = MEDfamInfo(fid,nommaa,i+1,nomfam,&numfam,attide,attval, + attdes,&natt,gro,&ngro); + fprintf(stdout," - Famille de nom %s et de numero %d : \n",nomfam,numfam); + fprintf(stdout," - Attributs : \n"); + for (j=0;j> ERREUR : lecture informations sur equivalence\n"); + + /* lecture des correspondances sur les differents types d'entites */ + if (ret == 0) + { + /* les noeuds */ + if ((ncor = MEDnCorres(fid,nommaa,equ,MED_NOEUD,(med_geometrie_element)0)) < 0) + { + ret = -1; + strcpy(message,">> ERREUR : lecture nombre de correspondances\n"); + } + else + fprintf(stdout,"\n - Il y a %d correspondances sur les noeuds \n",ncor); + if (ncor > 0) + { + cor = (med_int*) malloc(sizeof(med_int)*ncor*2); + ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_NOEUD,(med_geometrie_element)0); + if (ret == 0) + for (j=0;j> ERREUR : lecture des correspondances\n"); + free(cor); + } + + /* sur les mailles : on ne prend pas en compte les mailles 3D */ + if (ret ==0) + for (j=0;j> ERREUR : lecture informations sur nombre de correspondances \n"); + } + else + fprintf(stdout,"\n - Il y a %d correspondances sur les mailles %s \n",ncor, + nommai[j]); + if (ncor > 0) + { + cor = (med_int*) malloc(sizeof(med_int)*ncor*2); + ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_MAILLE, + typmai[j]); + if (ret == 0) + for (k=0;k> ERREUR : correspondances\n"); + free(cor); + } + } + + /* sur les faces */ + if (ret == 0) + for (j=0;j> ERREUR : informations sur correspondances \n"); + } + else + fprintf(stdout,"\n - Il y a %d correspondances sur les faces %s\n",ncor, + nomfac[j]); + if (ncor > 0) + { + cor = (med_int*) malloc(sizeof(med_int)*ncor*2); + ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_FACE, + typfac[j]); + if (ret < 0) + strcpy(message,"ERREUR : lecture des equivalences \n"); + else + for (k=0;k> ERREUR : nombre de correspondances \n"); + } + else + fprintf(stdout,"\n - Il y a %d correspondances sur les aretes %s \n", + ncor,nomare[j]); + if (ncor > 0) + { + cor = (med_int*) malloc(sizeof(med_int)*ncor*2); + ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_ARETE, + typare[j]); + if (ret < 0) + strcpy(message,">> ERREUR : equivalences \n"); + else + for (k=0;k> ERREUR : nombre de composants d'un champ\n"); + } + + /* allocation memoire de comp et unit*/ + if (ret == 0) + { + comp = (char*) malloc(ncomp*MED_TAILLE_PNOM+1); + unit = (char*) malloc(ncomp*MED_TAILLE_PNOM+1); + } + + /* infos sur les champs */ + if (ret == 0) + ret = MEDchampInfo(fid,i+1,nomcha,&typcha,comp,unit,ncomp); + if (ret < 0) + strcpy(message,">> ERREUR : information sur les champs \n"); + + if (ret == 0) { + fprintf(stdout," - Nom du champ : %s de type %d\n",nomcha,typcha); + fprintf(stdout," - Nom des composantes : %s\n",comp); + fprintf(stdout," - Unites des composantes : %s \n",unit); + free(comp); + free(unit); + } + + + if (ret == 0) /* Valeurs sur les noeuds */ + { + /* Combien de pas de temps ? */ + npdt = MEDnPasdetemps(fid,nomcha,MED_NOEUD,(med_geometrie_element)0); + if (npdt < 0) + ret = -1; + if (ret == -1) + strcpy(message,">> ERREUR : la lecture du nombe de pas de temps"); + else + fprintf(stdout,"\n - Il y a %d pas de temps sur les noeuds \n",npdt); + + /* Lecture des valeurs pour tous les pas de temps */ + if (ret == 0) + for (j=0;j \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n", + numdt,dt,numo,ngauss); + else + strcpy(message,">> ERREUR : information sur les pas de temps \n"); + + /* Combien de valeurs a lire ? */ + if (ret == 0 && (! strcmp(maillage_champ,nommaa))) + { + if ((nval = MEDnVal(fid,nomcha,MED_NOEUD,(med_geometrie_element)0,numdt,numo)) < 0) + { + ret = -1; + strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n"); + } + else + fprintf(stdout,"\n - Il y a %d valeurs sur les noeuds \n",nval); + } + + if (ret == 0 && (! strcmp(maillage_champ,nommaa))) + { + if (typcha == MED_REEL64) + { + valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval); + ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL, + pflnom,MED_NOEUD,(med_geometrie_element)0,numdt,numo); + + if (ret < 0) + strcpy(message,">> ERREUR : lecture des champs \n"); + else + for (k=0;k> ERREUR : lecture des champs \n"); + else + for (k=0;k> ERREUR : lecture de la taille du profil \n"); + } + else + { + fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize); + pflval = (med_int*) malloc(sizeof(med_int)*pflsize); + + if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0) + strcpy(message,">> ERREUR : lecture du profil \n"); + else + for (l=0;l> ERREUR : la lecture du nombe de pas de temps"); + else + fprintf(stdout,"\n - Il y a %d pas de temps sur les mailles de type %d \n",npdt,typgeo); + + /* Lecture des valeurs pour tous les pas de temps */ + if (ret == 0) + for (j=0;j \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n", + numdt,dt,numo,ngauss); + else + strcpy(message,">> ERREUR : information sur les pas de temps \n"); + + /* Combien de valeurs a lire ? */ + if (ret == 0 && (! strcmp(maillage_champ,nommaa))) + { + if ((nval = MEDnVal(fid,nomcha,MED_MAILLE,typgeo,numdt,numo)) < 0) + { + ret = -1; + strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n"); + } + else + fprintf(stdout,"\n - Il y a %d valeurs sur les noeuds \n",nval); + } + + if (ret == 0 && (! strcmp(maillage_champ,nommaa))) + { + if (typcha == MED_REEL64) + { + valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval); + ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL, + pflnom,MED_MAILLE,typgeo,numdt,numo); + if (ret < 0) + strcpy(message,">> ERREUR : lecture des champs \n"); + else + for (kp=0;kp> ERREUR : lecture des champs \n"); + else + for (kp=0;kp> ERREUR : lecture de la taille du profil \n"); + } + else + { + fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize); + pflval = (med_int*) malloc(sizeof(med_int)*pflsize); + + if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0) + strcpy(message,">> ERREUR : lecture du profil \n"); + else + for (l=0;l> ERREUR : la lecture du nombe de pas de temps"); + else + fprintf(stdout,"\n - Il y a %d pas de temps sur les faces de type %d \n",npdt,typgeo); + + /* Lecture des valeurs pour tous les pas de temps */ + if (ret == 0) + for (j=0;j \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n", + numdt,dt,numo,ngauss); + else + strcpy(message,">> ERREUR : information sur les pas de temps \n"); + + /* Combien de valeurs a lire ? */ + if (ret == 0 && (! strcmp(maillage_champ,nommaa))) + { + if ((nval = MEDnVal(fid,nomcha,MED_FACE,typgeo,numdt,numo)) < 0) + { + ret = -1; + strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n"); + } + else + fprintf(stdout,"\n - Il y a %d valeurs sur les noeuds \n",nval); + } + + if (ret == 0 && (! strcmp(maillage_champ,nommaa))) + { + if (typcha == MED_REEL64) + { + valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval); + ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL, + pflnom,MED_FACE,typgeo,numdt,numo); + if (ret < 0) + strcpy(message,">> ERREUR : lecture des champs \n"); + else + for (kp=0;kp> ERREUR : lecture des champs \n"); + else + for (kp=0;kp> ERREUR : lecture de la taille du profil \n"); + } + else + { + fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize); + pflval = (med_int*) malloc(sizeof(med_int)*pflsize); + + if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0) + strcpy(message,">> ERREUR : lecture du profil \n"); + else + for (l=0;l> ERREUR : la lecture du nombe de pas de temps"); + else + fprintf(stdout,"\n - Il y a %d pas de temps sur les aretes de type %d \n",npdt,typgeo); + + /* Lecture des valeurs pour tous les pas de temps */ + if (ret == 0) + for (j=0;j \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n", + numdt,dt,numo,ngauss); + else + strcpy(message,">> ERREUR : information sur les pas de temps \n"); + + /* Combien de valeurs a lire ? */ + if (ret == 0 && (! strcmp(maillage_champ,nommaa))) + { + if ((nval = MEDnVal(fid,nomcha,MED_ARETE,typgeo,numdt,numo)) < 0) + { + ret = -1; + strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n"); + } + else + fprintf(stdout,"\n - Il y a %d valeurs sur les noeuds \n",nval); + } + + if (ret == 0 && (! strcmp(maillage_champ,nommaa))) + { + if (typcha == MED_REEL64) + { + valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval); + ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL, + pflnom,MED_ARETE,typgeo,numdt,numo); + if (ret < 0) + strcpy(message,">> ERREUR : lecture des champs \n"); + else + for (kp=0;kp> ERREUR : lecture des champs \n"); + else + for (kp=0;kp> ERREUR : lecture de la taille du profil \n"); + } + else + { + fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize); + pflval = (med_int*) malloc(sizeof(med_int)*pflsize); + + if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0) + strcpy(message,">> ERREUR : lecture du profil \n"); + else + for (l=0;l>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1]); + else + fprintf(stderr,">> ERREUR : erreur a la fermeture du fichier %s\n",argv[1]); + + return 0; +} diff --git a/src/MEDWrapper/V2_1/Core/med.hxx b/src/MEDWrapper/V2_1/Core/med.hxx new file mode 100644 index 000000000..2fe174f9a --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/med.hxx @@ -0,0 +1,164 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2003 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#ifndef MED_H +#define MED_H + +extern "C"{ +#include +} + +namespace med_2_1{ + +#define MED_NULL (void *) NULL +#define MED_MAX_PARA 20 + +#define MED_TAILLE_DESC 200 +#define MED_TAILLE_IDENT 8 +#define MED_TAILLE_NOM 32 +#define MED_TAILLE_LNOM 80 +#define MED_TAILLE_PNOM 8 + +/* Integration des developpements OCC */ +typedef enum {MED_CARTESIAN, MED_POLAR, MED_BODY_FITTED} med_grid_type; + +typedef enum {MED_GRID_D1=0, MED_GRID_D2=1, MED_GRID_D3=2, + MED_GRID_NOEUD=3, + MED_FAM_NOEUD=4, MED_FAM_ARETE=5, MED_FAM_FACE=6, MED_FAM_MAILLE=7 } med_grid; + +/* Fin de l'integration*/ + +typedef enum {MED_FULL_INTERLACE, + MED_NO_INTERLACE} med_mode_switch; + +typedef enum {MED_GLOBALE, + MED_COMPACT } med_mode_profil; + +typedef enum {MED_LECT,MED_ECRI,MED_REMP} med_mode_acces; + +typedef enum {MED_MAILLE, MED_FACE, MED_ARETE, MED_NOEUD} med_entite_maillage; + +typedef enum {MED_COOR, MED_CONN, MED_NOM, MED_NUM, MED_FAM} med_table; + +typedef enum {MED_REEL64=6, MED_INT32=24,MED_INT64=26, MED_INT} med_type_champ; + +#define MED_NBR_GEOMETRIE_MAILLE 15 +#define MED_NBR_GEOMETRIE_FACE 4 +#define MED_NBR_GEOMETRIE_ARETE 2 +typedef enum {MED_POINT1=1, MED_SEG2=102, MED_SEG3=103, MED_TRIA3=203, + MED_QUAD4=204, MED_TRIA6=206,MED_QUAD8=208, MED_TETRA4=304, + MED_PYRA5=305, MED_PENTA6=306, MED_HEXA8=308, MED_TETRA10=310, + MED_PYRA13=313, MED_PENTA15=315, MED_HEXA20=320} +med_geometrie_element; + +typedef enum {MED_NOD, MED_DESC} med_connectivite ; + +typedef enum {MED_CART, MED_CYL, MED_SPHER} med_repere; + +typedef enum {MED_FAUX, MED_VRAI} med_booleen ; + +typedef enum {MED_GROUPE, MED_ATTR, MED_FAMILLE} med_dim_famille; + +typedef enum {MED_COMP, MED_DTYPE} med_dim_champ; + +typedef enum {MED_HDF_VERSION, MED_VERSION, MED_FICH_DES} med_fich_info; + +#define MED_NOPG 1 /* -> pas de point de Gauss */ +#define MED_NOPFL "" /* -> pas de profils utilisateur */ +#define MED_NOPFLi " " /* Variable Interne */ +#define MED_NOPF 0 /* -> pas de profils pour _MEDdataseNnumEcrire */ +#define MED_NOPDT -1 /* rem: pas de pas de temps negatifs */ +#define MED_NONOR -1 /* rem: pas de n°ordre negatif */ +#define MED_DIM1 1 /* PAS */ +#define MED_ALL 0 + +#if defined(SUN4SOL2) || defined(PCLINUX) || defined(OSF1_32) || defined(IRIX64_32) || defined(RS6000) +/* interface C/FORTRAN */ +/* this true only with g77 and gcc : we must change it to use directly NOMF_... and INT32 or INT64 - + it will be more simple to understand and to use ! */ +#define NOMF_POST_UNDERSCORE + +/* correspondance des types avec HDF 5 */ +typedef hsize_t med_size; +typedef hssize_t med_ssize; +typedef hid_t med_idt; +typedef herr_t med_err; + +/* types elementaires */ +typedef int med_int; +typedef double med_float; +#endif + +#if defined(HP9000) +/* correspondance des types avec HDF 5 */ +typedef hsize_t med_size; +typedef hssize_t med_ssize; +typedef hid_t med_idt; +typedef herr_t med_err; + +/* types elementaires */ +typedef int med_int; +typedef double med_float; +#endif + +#if defined(IRIX64) || defined(OSF1) +#define NOMF_POST_UNDERSCORE + +/* correspondance des types avec HDF 5 */ +typedef hsize_t med_size; +typedef hssize_t med_ssize; +typedef hid_t med_idt; +typedef herr_t med_err; + +/* types elementaires */ +typedef long med_int; +typedef double med_float; +#endif + + +#if defined(PPRO_NT) +/* correspondance des types avec HDF 5 */ +typedef hsize_t med_size; +typedef hssize_t med_ssize; +typedef hid_t med_idt; +typedef herr_t med_err; + +/* types elementaires */ +typedef int med_int; +typedef double med_float; +#endif + + +#if defined(NOMF_PRE_UNDERSCORE) && defined(NOMF_POST_UNDERSCORE) +# define NOMF(x) _##x##_ +#endif +#if defined(NOMF_PRE_UNDERSCORE) && !defined(NOMF_POST_UNDERSCORE) +# define NOMF(x) _##x +#endif +#if !defined(NOMF_PRE_UNDERSCORE) && defined(NOMF_POST_UNDERSCORE) +# define NOMF(x) x##_ +#endif +#if !defined(NOMF_PRE_UNDERSCORE) && !defined(NOMF_POST_UNDERSCORE) +# define NOMF(x) x +#endif + +} + +#include "med_proto.hxx" + +#endif /* MED_H */ diff --git a/src/MEDWrapper/V2_1/Core/med_hdfi.hxx b/src/MEDWrapper/V2_1/Core/med_hdfi.hxx new file mode 100644 index 000000000..670ff63a9 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/med_hdfi.hxx @@ -0,0 +1,120 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#ifndef MED_HDFI_H +#define MED_HDFI_H +#include "med.hxx" + +/* FONCTIONS INTERFACE MED/HDF */ +namespace med_2_1{ + +/* Gestion des fichiers HDF */ +extern +med_idt _MEDfichierCreer(char *nom); + +extern +med_idt _MEDfichierOuvrir(char *nom,med_mode_acces mode); + +extern +med_err _MEDfichierFermer(med_idt fid); + + +/* Gestion des datagroups HDF */ +extern +med_idt _MEDdatagroupCreer(med_idt pid, char *nom); + +extern +med_idt _MEDdatagroupOuvrir(med_idt pid, char *nom); + +extern +med_err _MEDdatagroupFermer(med_idt id); + + +/* Gestion des datasets HDF */ + +extern +med_idt _MEDdatasetOuvrir(med_idt pid,char *nom); + +extern +med_err _MEDdatasetFermer(med_idt id); + +extern +med_err _MEDdatasetNumEcrire (med_idt pere,char *nom, med_type_champ type, + med_mode_switch interlace, med_size nbdim, med_size fixdim, + med_size psize, med_ssize * profil, med_int ngauss, + med_size *size, unsigned char *val, med_mode_acces mode); + + +extern +med_err _MEDdatasetNumLire(med_idt pere,char *nom,med_type_champ type, + med_mode_switch interlace, med_size nbdim, med_size fixdim, + med_size psize, med_ssize * pfltab, med_int ngauss, + unsigned char *val); + +extern +med_err _MEDdatasetStringEcrire(med_idt pere,char *nom,med_size *dimd, + char *val, med_mode_acces mode); + +extern +med_err _MEDdatasetStringLire(med_idt pere,char *nom,char *val); + +/* Gestion des attributs HDF */ +extern +med_idt _MEDattrOuvrir(med_idt pid,char * nom); + +extern +med_err _MEDattrFermer(med_idt id); + +extern +med_err _MEDattrNumEcrire(med_idt pere,med_type_champ type,char *nom,unsigned char *val,med_mode_acces mode); + +#define _MEDattrEntierEcrire(w,x,y,z) _MEDattrNumEcrire(w,MED_INT ,x,(unsigned char *) y,z) +#define _MEDattrFloatEcrire(w,x,y,z) _MEDattrNumEcrire(w,MED_REEL64,x,(unsigned char *) y,z) + +extern +med_err _MEDattrNumLire(med_idt pere,med_type_champ type,char *nom,unsigned char *val); + +#define _MEDattrEntierLire(x,y,z) _MEDattrNumLire(x,MED_INT ,y,(unsigned char*)z) +#define _MEDattrFloatLire(x,y,z) _MEDattrNumLire(x,MED_REEL64,y,(unsigned char*)z) + +extern +med_err _MEDattrStringEcrire(med_idt pere,char *nom,int longueur,char *val,med_mode_acces mode); + +extern +med_err _MEDattrStringLire(med_idt pere,char *nom,int longueur,char *val); + + +/* Divers */ +extern +med_err _MEDindiceInfo(med_idt id, const char *nom, void *donnees); + +extern +med_err _MEDindiceNum(med_idt id,const char *nom, void *donnees); + +extern +med_err _MEDobjetIdentifier(med_idt fid,char *chemin,int indice,void *nom); + +extern +med_err _MEDnObjets(med_idt fid,char *chemin,int *n); + +extern +void _MEDmodeErreurVerrouiller(); + +} + +#endif /* MED_HDFI_H */ diff --git a/src/MEDWrapper/V2_1/Core/med_misc.hxx b/src/MEDWrapper/V2_1/Core/med_misc.hxx new file mode 100644 index 000000000..9e9676ec8 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/med_misc.hxx @@ -0,0 +1,62 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#ifndef MED_MISC_H +#define MED_MISC_H +#include "med.hxx" + + +/* CHAINES DE CARACTERES FORTRAN => C */ +namespace med_2_1{ + +extern +char *_MED1cstring(char *chaine,int longueur_reelle,int longueur_fixee); + +extern +char *_MED2cstring(char *chaine, int longueur); + +extern +med_err _MEDcstringFree(char *chaine); + +extern +med_err _MEDfstring(char *chaine, med_int longueur_fixee); + +/* Noms associes aux objets MED */ +extern +med_err _MEDnomEntite(char *nom_ent,med_entite_maillage type_ent); + +extern +med_err _MEDnomGeometrie(char *nom_geo,med_geometrie_element type_geo); + +extern +med_err _MEDparametresGeometrie(med_entite_maillage type_ent, + med_geometrie_element type_geo, int *dim, int *nnoe, + int *ndes); +extern +med_err _MEDnomDataset(char *nom_dataset,med_table quoi, + med_connectivite type_conn); + +/* Geometrie des objets MED */ +extern +med_err _MEDGeometrieElement(med_geometrie_element typ_geo[], + med_entite_maillage typ_ent); + +} + +#endif /* MED_MISC_H */ + diff --git a/src/MEDWrapper/V2_1/Core/med_outils.hxx b/src/MEDWrapper/V2_1/Core/med_outils.hxx new file mode 100644 index 000000000..b897a6219 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/med_outils.hxx @@ -0,0 +1,127 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2003 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#ifndef MED_OUTILS_H +#define MED_OUTILS_H +#include "med.hxx" + +#define MED_NOM_MAJEUR "MAJ" +#define MED_NOM_MINEUR "MIN" +#define MED_NOM_RELEASE "REL" + +#define MED_NUM_MAJEUR 2 +#define MED_NUM_MINEUR 1 +#define MED_NUM_RELEASE 6 + +#define MED_NOM_INFOS "INFOS_GENERALES" + +#define MED_NOM_DESCRIPTEUR "descripteur de fichier" +#define MED_VERSION_ACTUELLE "2.1.6" +#define HDF_VERSION_ACTUELLE "5-1.4.4" + +/* Noms des data sets ou attributs correspondant a des entites MED */ +#define MED_TAILLE_NOM_ENTITE 3 +#define MED_NOM_NUM "NUM" +#define MED_NOM_NBR "NBR" +#define MED_NOM_NOM "NOM" +#define MED_NOM_UNV "UNV" +#define MED_NOM_NNS "NNS" +#define MED_NOM_NNM "NNM" +#define MED_NOM_NNI "NNI" +#define MED_NOM_GRO "GRO" +#define MED_NOM_ATT "ATT" +#define MED_NOM_NCO "NCO" +#define MED_NOM_DIM "DIM" +#define MED_NOM_FAM "FAM" +#define MED_NOM_IDE "IDE" +#define MED_NOM_VAL "VAL" +#define MED_NOM_DES "DES" +#define MED_NOM_COR "COR" +#define MED_NOM_DIM "DIM" +#define MED_NOM_NOE "NOE" +#define MED_NOM_COO "COO" +#define MED_NOM_REP "REP" +#define MED_NOM_UNI "UNI" +#define MED_NOM_NOD "NOD" +#define MED_NOM_TYP "TYP" +#define MED_NOM_CO "CO" +#define MED_NOM_NCW "NCW" +#define MED_NOM_TYW "TYW" +#define MED_NOM_MAI "MAI" +#define MED_NOM_FAC "FAC" +#define MED_NOM_ARE "ARE" +#define MED_NOM_PO1 "PO1" +#define MED_NOM_SE2 "SE2" +#define MED_NOM_SE3 "SE3" +#define MED_NOM_TR3 "TR3" +#define MED_NOM_TR6 "TR6" +#define MED_NOM_QU4 "QU4" +#define MED_NOM_QU8 "QU8" +#define MED_NOM_TE4 "TE4" +#define MED_NOM_T10 "T10" +#define MED_NOM_HE8 "HE8" +#define MED_NOM_H20 "H20" +#define MED_NOM_PE6 "PE6" +#define MED_NOM_P15 "P15" +#define MED_NOM_PY5 "PY5" +#define MED_NOM_P13 "P13" + +#define MED_NOM_GEO "GEO" +#define MED_NOM_GAU "GAU" +#define MED_NOM_NGA "NGA" +#define MED_NOM_N "N" +#define MED_NOM_PFL "PFL" +#define MED_NOM_NDT "NDT" +#define MED_NOM_PDT "PDT" +#define MED_NOM_NOR "NOR" + +/* Integration des developpements OCC */ +#define MED_NOM_GRD "GRD" +#define MED_NOM_BOF "BOF" +#define MED_NOM_IN1 "IN1" +#define MED_NOM_IN2 "IN2" +#define MED_NOM_IN3 "IN3" + +/* Nom du DATA GROUP CONTENANT TOUS LES MAILLAGES DU FICHIER HDF */ +#define MED_MAA "/ENS_MAA/" +#define MED_TAILLE_MAA 9 + +/* Nom du data group ou ranger les champs solution */ +#define MED_CHA "/CHA/" +#define MED_TAILLE_CHA 5 + +/* Nom du data group ou ranger les familles */ +#define MED_FAS "/FAS/" +#define MED_TAILLE_FAS 5 + +/* Nom du data group ou ranger les equivalences */ +#define MED_EQS "/EQS/" +#define MED_TAILLE_EQS 5 + +/* Nom du data groupe contenant les profils */ +#define MED_PROFILS "/PROFILS/" +#define MED_TAILLE_PROFILS 9 + +/*Pour eviter le bug solaris*/ +#include + +/* Interface des routines du composant tools */ +#include "med_misc.hxx" +#include "med_hdfi.hxx" +#include "med_utils.hxx" +#endif /* MED_OUTILS_H */ diff --git a/src/MEDWrapper/V2_1/Core/med_proto.hxx b/src/MEDWrapper/V2_1/Core/med_proto.hxx new file mode 100644 index 000000000..1847b56a8 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/med_proto.hxx @@ -0,0 +1,276 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +#ifndef MED_PROTO_H +#define MED_PROTO_H + +/* Interface de l'API MED */ +namespace med_2_1{ +/* Fichier */ +extern med_idt +MEDouvrir(char *nom, med_mode_acces mode_acces); +extern med_err +MEDfermer(med_idt fid); +extern med_int +MEDlFichDes(med_idt fid); +extern med_err +MEDfichEntete(med_idt fid, med_fich_info quoi, char str[]); +extern med_err +MEDfichDesEcr(med_idt fid, char *des, med_mode_acces mode); +extern med_err +MEDunvCr(med_idt fid, char *maa); +extern med_err +MEDunvLire(med_idt fid, char *maa,char *nomu); +extern med_err +MEDformatConforme(const char * nomfich); +extern med_err +MEDversionConforme(const char *nom); +extern void +MEDversionDonner(med_int *majeur, med_int *mineur, med_int *release); +extern med_err +MEDversionLire(med_idt fid, med_int *majeur, med_int *mineur, med_int *release); + + + +/* Maillage */ +extern med_err +MEDmaaCr(med_idt fid, char *maillage, med_int dim); +extern med_int +MEDdimLire(med_idt fid, char *maillage); +extern med_err +MEDmaaInfo(med_idt fid, int indice, char *maillage, med_int *dim); +extern med_int +MEDnMaa(med_idt fid); +extern med_err +MEDnbnosoEcr(med_idt fid, char *nom_maillage,med_int n); +extern med_int +MEDnbnosoLire(med_idt fid,char *nom_maillage); +extern med_err +MEDnbnoisEcr(med_idt fid, char *nom_maillage,med_int n); +extern med_int +MEDnbnoisLire(med_idt fid,char *nom_maillage); +extern med_err +MEDnbnomaEcr(med_idt fid, char *nom_maillage,med_int n); +extern med_int +MEDnbnomaLire(med_idt fid,char *nom_maillage); + +/* EntMaillage */ +extern med_err +MEDconnEcr(med_idt fid,char *maa, med_int mdim, med_int *connectivite,med_mode_switch mode_switch, + med_int nbre,med_mode_acces mode,med_entite_maillage type_ent, + med_geometrie_element type_geo,med_connectivite type_conn); + +extern med_err +MEDconnLire(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch, + med_int * pfltab, med_size psize, + med_entite_maillage type_ent, med_geometrie_element type_geo,med_connectivite type_conn); +extern med_err +MEDnomEcr(med_idt fid,char *maa, char *nom, med_int n, med_mode_acces mode, + med_entite_maillage type_ent,med_geometrie_element type_geo); +extern med_err +MEDnomLire(med_idt fid,char *maa, char *nom, med_int n, + med_entite_maillage type_ent,med_geometrie_element type_geo); +extern med_err +MEDnumLire(med_idt fid,char *maa, med_int *num, med_int n, + med_entite_maillage type_ent,med_geometrie_element type_geo); +extern med_err +MEDnumEcr(med_idt fid,char *maa, med_int *num, med_int n, med_mode_acces mode, + med_entite_maillage type_ent,med_geometrie_element type_geo); +extern med_err +MEDcoordEcr(med_idt fid, char *maa, med_int mdim, med_float *coo, + med_mode_switch mode_coo,med_int n, + med_mode_acces mode, med_repere type_rep, char *nom, char *unit); +extern med_err +MEDcoordLire(med_idt fid, char *maa, med_int mdim, med_float *coo, + med_mode_switch mode_coo,med_int numco, + med_int * pfltab, med_size psize, med_repere *type_rep, char *nom, char *unit); + +extern med_int +MEDnEntMaa(med_idt fid, char *maa, med_table quoi, med_entite_maillage type_ent, + med_geometrie_element type_geo, med_connectivite type_conn); + + +/* Resultat */ +extern med_err MEDchampCr(med_idt fid, char *champ, med_type_champ type, char *comp, + char *unit,med_int ncomp); + +extern med_err +MEDchampEcr(med_idt fid, char *maa, char *cha,unsigned char *val,med_mode_switch interlace,med_int nbelem,med_int ngauss, + med_int numco, char * profil, med_mode_acces mode, med_entite_maillage type_ent, + med_geometrie_element type_geo, med_int numdt,char * dt_unit, med_float dt, med_int numo); + +extern med_err +MEDchampLire(med_idt fid,char *maa, char *cha, unsigned char *val,med_mode_switch interlace,med_int numco, + char *profil,med_entite_maillage type_ent, med_geometrie_element type_geo, + med_int numdt, med_int numo); + +extern med_err +MEDchampInfo(med_idt fid,int indice,char *champ, + med_type_champ *type,char *comp,char *unit, + med_int ncomp); + +extern med_int +MEDnChamp(med_idt fid, int indice); + +extern med_int +MEDnVal(med_idt fid, char *champ, med_entite_maillage typ_ent, + med_geometrie_element typ_geo,med_int numdt, med_int numo); + + +/* Famille */ +extern med_err +MEDfamEcr(med_idt fid,char *maa, med_int *fam, med_int n, med_mode_acces mode, + med_entite_maillage type_ent, med_geometrie_element type_geo); +extern med_err +MEDfamLire(med_idt fid,char *maa, med_int *fam, med_int n, + med_entite_maillage type_ent,med_geometrie_element type_geo); +extern med_err +MEDfamCr(med_idt fid,char* maa,char *famille,med_int numero, + med_int *attr_ident, med_int *attr_val,char *attr_desc,med_int n_attr, + char *groupe , med_int n_groupe); +extern med_int +MEDnFam(med_idt fid,char *maa, int indice, med_dim_famille quoi); + +extern med_err +MEDfamInfo(med_idt fid,char *maa,int indice, char *famille, + med_int *numero, + med_int *attr_ident, med_int *attr_val, char *attr_desc, + med_int *n_attr,char *groupe ,med_int *n_groupe); + +/* Equivalence */ +extern med_err +MEDequivCr(med_idt fid,char *maa, char *eq, char *desc); +extern med_err +MEDequivLire(med_idt fid, char *maa, char *eq, med_int *corr, med_int n, + med_entite_maillage typ_ent,med_geometrie_element typ_geo); +extern med_err +MEDequivEcr(med_idt fid, char *maa, char *eq, med_int *corr, med_int n, + med_mode_acces mode, med_entite_maillage typ_ent, med_geometrie_element typ_geo); +extern med_err +MEDequivInfo(med_idt fid, char *maa, int ind, char *eq, char *des); +extern med_int +MEDnEquiv(med_idt fid, char *maa); +extern med_int +MEDnCorres(med_idt fid,char *maa,char *eq,med_entite_maillage typ_ent, + med_geometrie_element typ_geo); + + +/* Routines de niveau intermediaire */ +extern med_int +MEDnEntites(med_idt fid,char *maa,med_entite_maillage typ_ent, + med_connectivite typ_con); + +extern med_err +MEDnoeudsLire(med_idt fid,char *maa,med_int mdim, med_float *coord, + med_mode_switch mode_coo, + med_repere *repere,char *nomcoo, char *unicoo,char *nom, + med_booleen *inom,med_int *num,med_booleen *inum,med_int *fam, + med_int nnoeuds); + +extern med_err +MEDnoeudsEcr(med_idt fid,char *maa,med_int mdim,med_float *coord, + med_mode_switch mode_coo, + med_repere repere,char *nomcoo, char *unicoo,char *nom, + med_booleen inom,med_int *num,med_booleen inum,med_int *fam, + med_int nnoeuds,med_mode_acces mode); +extern med_err +MEDelementsEcr(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch, + char *nom,med_booleen inom,med_int *num,med_booleen inum, + med_int *fam,med_int nele,med_entite_maillage typ_ent, + med_geometrie_element typ_geo,med_connectivite typ_conn,med_mode_acces mode); +extern med_err +MEDelementsLire(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch, + char *nom,med_booleen *inom,med_int *num,med_booleen *inum, + med_int *fam,med_int nele,med_entite_maillage typ_ent, + med_geometrie_element typ_geo,med_connectivite typ_conn); + +/* Routines de haut niveau */ + +/*(? On enlève le reste ?)*/ + +extern med_err +MEDfamMaaInfo(med_idt fid,char *maa,med_int *nfam,med_int *nattc, + med_int *ngroc); + +extern med_err +MEDfamMaaLire(med_idt fid,char *maa, + med_int *numfam,med_int *attide, + med_int *attval,char *attdes,int *indatt,char *gro,int *indgro, + med_int nfamilles); + +extern med_err +MEDfamMaaCr(med_idt fid,char *maa, + med_int *numfam,med_int *attide, + med_int *attval,char *attdes,int *indatt,char *gro,int *indgro, + med_int nfamilles); + +/* Routines concernant les profils */ + +extern med_err +MEDprofilInfo(med_idt fid, int indice, char *profil, med_int *n); + +extern med_int +MEDnProfil(med_idt fid); + +extern med_err +MEDprofilEcr(med_idt fid,med_int *pflval,med_int n,char *nom); + +extern med_int +MEDnValProfil(med_idt fid, char *nom); + +extern med_err +MEDprofilLire(med_idt fid, med_int *pflval, char *nom); + +/* Routines concernant les pas de temps/ numéros d'ordre */ + +extern med_int +MEDnPasdetemps(med_idt fid,char *cha,med_entite_maillage type_ent, + med_geometrie_element type_geo); + +extern med_err +MEDpasdetempsInfo(med_idt fid,char *champ + ,med_entite_maillage type_ent, med_geometrie_element type_geo, + int indice, char *maa, med_int * ngauss, med_int * numdt, char * dt_unit, med_float * dt, + med_int * numo); + +/* Grilles */ + +med_int MEDnGrid(med_idt fid, char *maa, med_grid n); +med_err MEDgridCr(med_idt fid, char *maillage, med_int dim, med_grid_type typ); +med_err MEDgridInfo(med_idt fid, int indice, med_int *isAGrid, med_grid_type *typ); +med_err MEDgridEcr( + med_idt fid, char *maa, med_int mdim, med_float *coo, med_int nb, med_int dim, med_mode_switch mode_coo, + med_repere repere, char *nomcoo, char *unicoo, med_mode_acces mode ); +med_err MEDgridLire( + med_idt fid, char *maa, med_int mdim, med_float *coo, med_int dim, med_mode_switch mode_coo, + med_repere *repere, char *nomcoo, char *unicoo ); +med_err MEDfamGridEcr(med_idt fid, char *maa, med_int *fam, med_int n, med_mode_acces mode, med_entite_maillage type_ent); +med_err MEDfamGridLire(med_idt fid, char *maa, med_int *fam, med_int n, med_entite_maillage type_ent); +med_err MEDbodyFittedEcr( + med_idt fid, char *maa, med_int mdim, med_float *coo, med_int *nbr, med_mode_switch mode_coo, + med_repere repere, char *nomcoo, char *unicoo, med_int *fam, med_int nnoeuds, med_mode_acces mode ); +med_err MEDbodyFittedLire( + med_idt fid, char *maa, med_int mdim, med_float *coo, med_mode_switch mode_coo, + med_repere *repere, char *nomcoo, char *unicoo, med_int *fam, med_int nnoeuds ); +} + +#endif /* MED_PROTO_H */ + + + + diff --git a/src/MEDWrapper/V2_1/Core/med_utils.hxx b/src/MEDWrapper/V2_1/Core/med_utils.hxx new file mode 100644 index 000000000..0c16d650e --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/med_utils.hxx @@ -0,0 +1,261 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +# ifndef __UTILITES_H__ +# define __UTILITES_H__ + + +/* pour indiquer le statut des arguments des fonctions. */ + +#ifdef _IN +#error _IN already defined +#endif +#define _IN + +#ifdef _OUT +#error _OUT already defined +#endif +#define _OUT + +#ifdef _INOUT +#error _INOUT already defined +#endif +#define _INOUT + +#ifdef _UNUSED +#error _UNUSED already defined +#endif +#define _UNUSED + + + + + + + +/* --- Pour afficher le nom du fichier source courant et le numero de la ligne courante --- */ +/* --- sur la stderr. --- */ + +# define ICI {\ + fflush(stdout);\ + fprintf(stderr, "%s [%d] : " , __FILE__ , __LINE__ ) ;\ + fflush(stderr) ;\ + } + + + + + + + +/* --- Pour afficher la date et l'heure de la compilation du fichier source courant, --- */ +/* --- sur la stdout. --- */ + +# ifdef INFOS_COMPILATION +# error INFOS_COMPILATION already defined +# endif +# define INFOS_COMPILATION {\ + fflush(stderr);\ + fprintf(stdout, "%s [%d] : " , __FILE__ , __LINE__ ) ;\ + fprintf(stdout,"Compilation le %s" , __DATE__);\ + fprintf(stdout," a %s" , __TIME__ );\ + fprintf(stdout,"\n\n\n" );\ + fflush(stdout) ;\ + } + + + + + + + +/* --- Pour attendre "secondes" secondes et afficher un message sur la stderr indiquant --- */ +/* --- cette attente volontaire. --- */ + +# ifdef ATTENTE +# error ATTENTE already defined +# endif +# define ATTENTE(secondes) {\ + ICI ;\ + fprintf( stderr, "ATTENTE de %d secondes" , secondes);\ + fflush(stderr) ;\ + sleep(secondes) ;\ + fprintf( stderr, "\n" );\ + fflush(stderr) ;\ + } + + + + + + + +/* ---------- Les macros suivantes ne doivent pas deja exister ! ---------- */ + +# ifdef EXECUTION +# error EXECUTION already defined +# endif +# ifdef INTERRUPTION +# error INTERRUPTION already defined +# endif +# ifdef ISCRUTE +# error ISCRUTE already defined +# endif +# ifdef RSCRUTE +# error RSCRUTE already defined +# endif +# ifdef SSCRUTE +# error SSCRUTE already defined +# endif +# ifdef CSCRUTE +# error CSCRUTE already defined +# endif +# ifdef XSCRUTE +# error XSCRUTE already defined +# endif +# ifdef MESSAGE +# error MESSAGE already defined +# endif + + + + + +# ifdef _DEBOG_ + + +/* --- Pour tracer sur la stderr l'execution d"une instruction. --- */ + +# define EXECUTION(instruction) {\ + ICI ;\ + fprintf( stderr,"INSTRUCTION %s" , #instruction ) ;\ + fflush(stderr);\ + instruction ;\ + fflush(stdout);\ + fprintf( stderr," FRANCHIE\n" ) ;\ + fflush(stderr);\ + } + + + + + + + +/* --- Pour afficher un message d'interruption volontaire et retourner le code retour --- */ +/* --- "code" --- */ + +# define INTERRUPTION(code) {\ + ICI ;\ + fprintf( stderr," INTERRUPTION code = %d",code) ;\ + fprintf(stderr,"\n") ;\ + exit(code) ;\ + } + + + + + + + +/* --- Pour conditionner la poursuite du traitement par la validite de la condition --- */ +/* --- "condiiton". --- */ + +# ifndef ASSERT +# define ASSERT(condition) if( !(condition) ){\ + ICI ;\ + fprintf(stderr,"condition %s VIOLEE\n",#condition);\ + INTERRUPTION(17);\ + } +# endif /* # ifndef ASSERT */ + + + + + + + +/* --- Pour afficher sur la stderr la valeur d'une variable precedee de son nom. --- */ + +# define ISCRUTE(entier) {\ + ICI ;\ + fprintf(stderr,"%s = %d\n",#entier,entier) ;\ + fflush(stderr) ;\ + } +# define RSCRUTE(reel) {\ + ICI ;\ + fprintf(stderr,"%s = %f\n",#reel,reel) ;\ + fflush(stderr) ;\ + } +# define XSCRUTE(pointeur) {\ + ICI ;\ + fprintf(stderr,"%s = %x\n",#pointeur,pointeur) ;\ + fflush(stderr) ;\ + } +# define CSCRUTE(car) {\ + ICI ;\ + fprintf(stderr,"%s = %c\n",#car,car) ;\ + fflush(stderr) ;\ + } +# define SSCRUTE(chaine) {\ + ICI ;\ + fprintf(stderr,"%s = \"%s\"\n",#chaine,chaine) ;\ + fflush(stderr) ;\ + } +# define MESSAGE(chaine) {\ + ICI ;\ + fprintf(stderr,"%s\n",chaine) ;\ + fflush(stderr) ;\ + } +# define FIN(nom) {\ + ICI ;\ + fprintf( stderr , "} FIN %s\n\n\n" , nom ) ;\ + fflush(stderr) ;\ + } +# define DEBUT(nom) {\ + fprintf( stderr , "\n\n\n") ;\ + ICI ;\ + fprintf( stderr , "{ DEBUT %s\n" , nom ) ;\ + fflush(stderr) ;\ + } + + +# else /* # ifdef _DEBOG_ */ + + + +# define EXECUTION(instruction) instruction +# define INTERRUPTION(code) + +# ifndef ASSERT +# define ASSERT(condition) +# endif + +# define ISCRUTE(entier) +# define RSCRUTE(reel) +# define CSCRUTE(car) +# define SSCRUTE(chaine) +# define MESSAGE(chaine) +# define DEBUT(nom) +# define FIN(nom) + + +# endif /* # ifdef _DEBOG_ */ + + +# endif /* # ifndef __UTILITES_H__ */ diff --git a/src/MEDWrapper/V2_1/Core/test1_V2_1.cxx b/src/MEDWrapper/V2_1/Core/test1_V2_1.cxx new file mode 100644 index 000000000..20746cb11 --- /dev/null +++ b/src/MEDWrapper/V2_1/Core/test1_V2_1.cxx @@ -0,0 +1,72 @@ +/************************************************************************* +* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. +* +* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. +* +* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE +* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, +* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA +* +*************************************************************************/ + +/****************************************************************************** + * - Nom du fichier : test1.c + * + * - Description : tests des routines d'ouverture/fermeture des + * fichiers MED + * + *****************************************************************************/ + +#include "med.hxx" +using namespace med_2_1; + +/****************************************************************************** + * OUVERTURE/FERMETURE DE FICHIERS : + * + * Description : + * - ouverture du fichier en mode ecriture avec remplacement + * - ecriture d'une description du fichier (optionnel) + * - fermeture du fichier + * - ouverture du fichier en mode de lecture + * - fermeture du fichier + *****************************************************************************/ + +int main (int argc, char **argv) +{ + med_err ret = 0; + med_idt fid; + char des[MED_TAILLE_DESC+1]="Ceci est un courte description du mon fichier test1.med"; + + fid = MEDouvrir("test1.med",MED_REMP); + if (fid < 0) + ret = -1; + printf("%d\n",ret); + + if (ret == 0) + ret = MEDfichDesEcr(fid,des, MED_REMP); + printf("%d\n",ret); + + ret = MEDfermer(fid); + printf("%d\n",ret); + + fid = MEDouvrir("test1.med",MED_LECT); + if (fid < 0) + ret = -1; + printf("%d\n",ret); + + ret = MEDfermer(fid); + printf("%d\n",ret); + + return 0; +} + + + + diff --git a/src/MEDWrapper/V2_1/MED1cstring.cxx b/src/MEDWrapper/V2_1/MED1cstring.cxx deleted file mode 100644 index e41a89c05..000000000 --- a/src/MEDWrapper/V2_1/MED1cstring.cxx +++ /dev/null @@ -1,80 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - - -#include -#include "med_misc.hxx" - -/* - * - Nom de la fonction : _MED1cstring - * - Description : convertit une chaine de caracteres FORTRAN - * en une nouvelle chaine de caracteres C - * dont la longueur est passee en parametre. - * Les caracteres completes sont des blancs - * - Parametres : - * - chaine (IN) : la chaine FORTRAN - * - longueur_reelle (IN) : la longueur de la chaine FORTRAN - * - longueur_fixee (IN) : longueur de la chaine C a construire - * - Resultat : la nouvelle chaine C en cas de succes, NULL sinon - */ - -namespace med_2_1{ - -char * -_MED1cstring(char *chaine,int longueur_reelle,int longueur_fixee) -{ - char *nouvelle; - int i; - - if (longueur_reelle > longueur_fixee) - return NULL; - - if ((nouvelle = (char *) malloc(sizeof(char)*(longueur_fixee+1))) == NULL) - return NULL; - - for (i=0;i -#include "med_misc.hxx" - -/* - * - Nom de la fonction _MED2cstring - * - Description : convertit une chaine de caracteres FORTRAN en - * nouvelle chaine de caracteres C - * - Parametres : - * - chaine (IN) : la chaine FORTRAN - * - longueur (IN) : longueur de la chaine - * - Resultat : la nouvelle chaine C en cas de succes, NULL sinon - */ - -namespace med_2_1{ - -char * -_MED2cstring(char *chaine, int longueur) -{ - char *nouvelle; - char *temoin; - int long_reelle = longueur; - int i; - - if ( longueur < 0 ) return NULL; - - temoin = chaine+longueur-1; - while (*temoin == ' ' && (temoin != chaine) ) - { - temoin --; - long_reelle--; - } - if ( *temoin == ' ') long_reelle = 0; - - if ((nouvelle = (char *) malloc(sizeof(char)*(long_reelle+1))) == NULL) - return NULL; - - for (i=0;i(myFileName.c_str()); - myFid = MEDouvrir(aFileName,med_mode_acces(theMode)); - } - if(theErr){ - *theErr = TErr(myFid); - INITMSG(MYDEBUG && myFid < 0,"TFile::Open - MED_MODE_ACCES = "<Open(theMode,theErr); - } - - ~TFileWrapper(){ - myFile->Close(); - } - }; - - - //--------------------------------------------------------------- - TVWrapper::TVWrapper(const std::string& theFileName): - myFile(new TFile(theFileName)) - {} - - - TInt TVWrapper::GetNbMeshes(TErr* theErr) - { - TFileWrapper aFileWrapper(myFile,eLECT,theErr); - - if(theErr && *theErr < 0) - return -1; - - return MEDnMaa(myFile->Id()); - } - - - void TVWrapper::GetMeshInfo(TInt theMeshId, - MED::TMeshInfo& theInfo, - TErr* theErr) - { - TFileWrapper aFileWrapper(myFile,eLECT,theErr); - - if(theErr && *theErr < 0) - return; - - TErr aRet = MEDmaaInfo(myFile->Id(), - theMeshId, - &theInfo.myName[0], - (med_2_1::med_int *)&theInfo.myDim); - if(theErr) - *theErr = aRet; - else if(aRet < 0) - EXCEPTION(runtime_error,"GetMeshInfo - MEDmaaInfo(...)"); - } - - - 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); - - TErr aRet = MEDmaaCr(myFile->Id(), - &anInfo.myName[0], - anInfo.myDim); - - INITMSG(MYDEBUG,"TVWrapper::SetMeshInfo - MED_MODE_ACCES = "<(theInfo); - return MEDnFam(myFile->Id(), - &anInfo.myName[0], - 0, - MED_FAMILLE); - } - - - TInt TVWrapper::GetNbFamAttr(TInt theFamId, - const MED::TMeshInfo& theInfo, - TErr* theErr) - { - TFileWrapper aFileWrapper(myFile,eLECT,theErr); - - if(theErr && *theErr < 0) - return -1; - - MED::TMeshInfo& anInfo = const_cast(theInfo); - return MEDnFam(myFile->Id(), - &anInfo.myName[0], - theFamId, - MED_ATTR); - } - - - TInt TVWrapper::GetNbFamGroup(TInt theFamId, - const MED::TMeshInfo& theInfo, - TErr* theErr) - { - TFileWrapper aFileWrapper(myFile,eLECT,theErr); - - if(theErr && *theErr < 0) - return -1; - - MED::TMeshInfo& anInfo = const_cast(theInfo); - return MEDnFam(myFile->Id(), - &anInfo.myName[0], - theFamId, - MED_GROUPE); - } - - - void TVWrapper::GetFamilyInfo(TInt theFamId, - MED::TFamilyInfo& theInfo, - TErr* theErr) - { - TFileWrapper aFileWrapper(myFile,eLECT,theErr); - - if(theErr && *theErr < 0) - return; - - MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; - - TErr aRet = MEDfamInfo(myFile->Id(), - &aMeshInfo.myName[0], - theFamId, - &theInfo.myName[0], - (med_2_1::med_int *)&theInfo.myId, - (med_2_1::med_int *)&theInfo.myAttrId[0], - (med_2_1::med_int *)&theInfo.myAttrVal[0], - &theInfo.myAttrDesc[0], - (med_2_1::med_int *)&theInfo.myNbAttr, - &theInfo.myGroupNames[0], - (med_2_1::med_int *)&theInfo.myNbGroup); - - if(theErr) - *theErr = aRet; - else if(aRet < 0) - EXCEPTION(runtime_error,"GetFamilyInfo - MEDfamInfo - "<< - "&aMeshInfo.myName[0] = '"<<&aMeshInfo.myName[0]<<"'; "<< - "theFamId = "<(theMeshInfo); - - TInt aRet = MEDnEntMaa(myFile->Id(), - &aMeshInfo.myName[0], - MED_COOR, - MED_NOEUD, - med_geometrie_element(0), - med_connectivite(0)); - - ADDMSG(MYDEBUG," nbnodes="<Id(), - &aMeshInfo.myName[0], - aMeshInfo.myDim, - &theInfo.myCoord[0], - MED_FULL_INTERLACE, - &aRepere, - &theInfo.myCoordNames[0], - &theInfo.myCoordUnits[0], - &theInfo.myElemNames[0], - &anIsElemNames, - (med_2_1::med_int *)&theInfo.myElemNum[0], - &anIsElemNum, - (med_2_1::med_int *)&theInfo.myFamNum[0], - theInfo.myNbElem); - - ADDMSG(MYDEBUG," myDim="<(theInfo); - MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; - - med_repere& aRepere = (med_repere&)(theInfo.mySystem); - med_booleen& anIsElemNames = (med_booleen&)(theInfo.myIsElemNames); - med_booleen& anIsElemNum = (med_booleen&)(theInfo.myIsElemNum); - - TErr aRet = MEDnoeudsEcr(myFile->Id(), - &aMeshInfo.myName[0], - aMeshInfo.myDim, - &anInfo.myCoord[0], - MED_FULL_INTERLACE, - aRepere, - &anInfo.myCoordNames[0], - &anInfo.myCoordUnits[0], - &anInfo.myElemNames[0], - anIsElemNames, - (med_2_1::med_int *)&anInfo.myElemNum[0], - anIsElemNum, - (med_2_1::med_int *)&anInfo.myFamNum[0], - anInfo.myNbElem, - MED_REMP); - if(theErr) - *theErr = aRet; - else if(aRet < 0) - EXCEPTION(runtime_error,"SetNodeInfo - MEDnoeudsEcr(...)"); - } - - - void TVWrapper::SetNodeInfo(const MED::TNodeInfo& theInfo, - TErr* theErr) - { - TErr aRet; - SetNodeInfo(theInfo,eECRI,&aRet); - - if(aRet < 0) - SetNodeInfo(theInfo,eREMP,theErr); - } - - - TEntityInfo TVWrapper::GetEntityInfo(const MED::TMeshInfo& theMeshInfo, - EConnectivite theTConn, - TErr* theErr) - { - TEntityInfo anInfo; - - TFileWrapper aFileWrapper(myFile,eLECT,theErr); - - if(theErr && *theErr < 0) - return anInfo; - - 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,theTConn,theErr); - if(aNbElem > 0) - anInfo[anEntity][aGeom] = aNbElem; - } - } - } - return anInfo; - } - - - TInt TVWrapper::GetNbCells(const MED::TMeshInfo& theMeshInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn, - TErr* theErr) - { - TFileWrapper aFileWrapper(myFile,eLECT,theErr); - - if(theErr && *theErr < 0) - return -1; - - MED::TMeshInfo& aMeshInfo = const_cast(theMeshInfo); - - med_entite_maillage anEntity = med_entite_maillage(theTEntity); - med_geometrie_element aGeom = med_geometrie_element(theTGeom); - med_connectivite aConn = med_connectivite(theTConn); - - return MEDnEntMaa(myFile->Id(), - &aMeshInfo.myName[0], - MED_CONN, - anEntity, - aGeom, - aConn); - } - - - void TVWrapper::GetCellInfo(MED::TCellInfo& theInfo, - TErr* theErr) - { - TFileWrapper aFileWrapper(myFile,eLECT,theErr); - - if(theErr && *theErr < 0) - return; - - MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; - TInt aNbElem = theInfo.myElemNum.size(); - - med_booleen& anIsElemNames = (med_booleen&)(theInfo.myIsElemNames); - med_booleen& anIsElemNum = (med_booleen&)(theInfo.myIsElemNum); - med_entite_maillage& anEntity = (med_entite_maillage&)(theInfo.myTEntity); - med_geometrie_element& aGeom = (med_geometrie_element&)(theInfo.myTGeom); - med_connectivite& aConn = (med_connectivite&)(theInfo.myTConn); - - TErr aRet = MEDelementsLire(myFile->Id(), - &aMeshInfo.myName[0], - aMeshInfo.myDim, - (med_2_1::med_int *)&theInfo.myConn[0], - MED_FULL_INTERLACE, - &theInfo.myElemNames[0], - &anIsElemNames, - (med_2_1::med_int *)&theInfo.myElemNum[0], - &anIsElemNum, - (med_2_1::med_int *)&theInfo.myFamNum[0], - aNbElem, - anEntity, - aGeom, - aConn); - - if(theErr) - *theErr = aRet; - else if(aRet < 0) - EXCEPTION(runtime_error,"GetCellInfo - MEDelementsLire(...)"); - } - - - 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; - - med_booleen& anIsElemNames = (med_booleen&)(theInfo.myIsElemNames); - med_booleen& anIsElemNum = (med_booleen&)(theInfo.myIsElemNum); - med_entite_maillage& anEntity = (med_entite_maillage&)(theInfo.myTEntity); - med_geometrie_element& aGeom = (med_geometrie_element&)(theInfo.myTGeom); - med_connectivite& aConn = (med_connectivite&)(theInfo.myTConn); - - TErr aRet = MEDelementsEcr(myFile->Id(), - &aMeshInfo.myName[0], - aMeshInfo.myDim, - (med_2_1::med_int *)&anInfo.myConn[0], - MED_FULL_INTERLACE, - &anInfo.myElemNames[0], - anIsElemNames, - (med_2_1::med_int *)&anInfo.myElemNum[0], - anIsElemNum, - (med_2_1::med_int *)&anInfo.myFamNum[0], - anInfo.myNbElem, - anEntity, - aGeom, - aConn, - MED_REMP); - - if(theErr) - *theErr = aRet; - else if(aRet < 0) - EXCEPTION(runtime_error,"GetCellInfo - MEDelementsLire(...)"); - } - - - void TVWrapper::SetCellInfo(const MED::TCellInfo& theInfo, - TErr* theErr) - { - TErr aRet; - SetCellInfo(theInfo,eECRI,&aRet); - - if(aRet < 0) - SetCellInfo(theInfo,eREMP,theErr); - } - - - TInt TVWrapper::GetNbFields(TErr* theErr) - { - TFileWrapper aFileWrapper(myFile,eLECT,theErr); - - if(theErr && *theErr < 0) - return -1; - - return MEDnChamp(myFile->Id(),0); - } - - - TInt TVWrapper::GetNbComp(TInt theFieldId, - TErr* theErr) - { - TFileWrapper aFileWrapper(myFile,eLECT,theErr); - - if(theErr && *theErr < 0) - return -1; - - return MEDnChamp(myFile->Id(),theFieldId); - } - - - void TVWrapper::GetFieldInfo(TInt theFieldId, - MED::TFieldInfo& theInfo, - TErr* theErr) - { - TFileWrapper aFileWrapper(myFile,eLECT,theErr); - - if(theErr && *theErr < 0) - return; - - med_type_champ& aType = (med_type_champ&)(theInfo.myType); - - TErr aRet = MEDchampInfo(myFile->Id(), - theFieldId, - &theInfo.myName[0], - &aType, - &theInfo.myCompNames[0], - &theInfo.myUnitNames[0], - theInfo.myNbComp); - if(theErr) - *theErr = aRet; - else if(aRet < 0) - EXCEPTION(runtime_error,"GetFieldInfo - MEDchampInfo(...)"); - } - - - 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); - - med_type_champ& aType = (med_type_champ&)(theInfo.myType); - - TErr aRet = MEDchampCr(myFile->Id(), - &anInfo.myName[0], - aType, - &anInfo.myCompNames[0], - &anInfo.myUnitNames[0], - anInfo.myNbComp); - - if(theErr) - *theErr = aRet; - else if(aRet < 0) - EXCEPTION(runtime_error,"SetFieldInfo - MEDchampCr(...)"); - } - - - void TVWrapper::SetFieldInfo(const MED::TFieldInfo& theInfo, - TErr* theErr) - { - try{ - - TErr aRet; - SetFieldInfo(theInfo,eECRI,&aRet); - - if(aRet < 0) - SetFieldInfo(theInfo,eREMP,theErr); - - }catch(const std::exception& theExc){ - EXCEPTION(runtime_error,"SetFieldInfo(...)"<(theInfo); - TEntityInfo::const_iterator anIter = theEntityInfo.begin(); - for(; anIter != theEntityInfo.end(); anIter++){ - const med_entite_maillage& anEntity = (const med_entite_maillage&)(anIter->first); - const TGeom& aTGeom = anIter->second; - TGeom::const_iterator anGeomIter = aTGeom.begin(); - for(; anGeomIter != aTGeom.end(); anGeomIter++){ - const med_geometrie_element& aGeom = (const med_geometrie_element&)(anGeomIter->first); - aNbTimeStamps = MEDnPasdetemps(myFile->Id(),&anInfo.myName[0],anEntity,aGeom); - if(aNbTimeStamps){ - theEntity = EEntiteMaillage(anEntity); - theGeom[EGeometrieElement(aGeom)] = anGeomIter->second; - } - } - if(aNbTimeStamps) - break; - } - return aNbTimeStamps; - } - - - void TVWrapper::GetTimeStampInfo(TInt theTimeStampId, - MED::TTimeStampInfo& theInfo, - TErr* theErr) - { - TFileWrapper aFileWrapper(myFile,eLECT,theErr); - - TGeom& aTGeom = theInfo.myGeom; - - if(theErr){ - if(aTGeom.empty()) - *theErr = -1; - if(*theErr < 0) - return; - }else if(aTGeom.empty()) - EXCEPTION(runtime_error,"GetTimeStampInfo - There is no any cell"); - - MED::TFieldInfo& aFieldInfo = *theInfo.myFieldInfo; - MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo; - - med_entite_maillage& anEntity = (med_entite_maillage&)(theInfo.myEntity); - - TGeom::iterator anIter = aTGeom.begin(); - med_geometrie_element& aGeom = (med_geometrie_element&)(anIter->first); - - TErr aRet = MEDpasdetempsInfo(myFile->Id(), - &aFieldInfo.myName[0], - anEntity, - aGeom, - theTimeStampId, - &aMeshInfo.myName[0], - (med_2_1::med_int *)&theInfo.myNbGauss, - (med_2_1::med_int *)&theInfo.myNumDt, - &theInfo.myUnitDt[0], - &theInfo.myDt, - (med_2_1::med_int *)&theInfo.myNumOrd); - - if(theErr) - *theErr = aRet; - else if(aRet < 0) - EXCEPTION(runtime_error,"GetTimeStampInfo - MEDpasdetempsInfo(...)"); - - static TInt MAX_NB_GAUSS_POINTS = 32; - if(theInfo.myNbGauss <= 0 || theInfo.myNbGauss > MAX_NB_GAUSS_POINTS) - theInfo.myNbGauss = 1; - } - - - void TVWrapper::GetTimeStampVal(MED::TTimeStampVal& theVal, - TErr* theErr) - { - TFileWrapper aFileWrapper(myFile,eLECT,theErr); - - if(theErr && *theErr < 0) - return; - - TIdt anId = myFile->Id(); - - MED::TTimeStampInfo& aTimeStampInfo = *theVal.myTimeStampInfo; - MED::TFieldInfo& aFieldInfo = *aTimeStampInfo.myFieldInfo; - MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo; - - med_entite_maillage& anEntity = (med_entite_maillage&)(aTimeStampInfo.myEntity); - TGeom& aTGeom = aTimeStampInfo.myGeom; - TGeom::iterator anIter = aTGeom.begin(); - for(; anIter != aTGeom.end(); anIter++){ - med_geometrie_element& aGeom = (med_geometrie_element&)(anIter->first); - TInt aNbVal = MEDnVal(anId, - &aFieldInfo.myName[0], - anEntity, - aGeom, - aTimeStampInfo.myNumDt, - aTimeStampInfo.myNumOrd); - if(aNbVal <= 0){ - if(theErr){ - *theErr = -1; - return; - } - EXCEPTION(runtime_error,"GetTimeStampInfo - MEDnVal(...) - aNbVal == "<Id(); - - MED::TTimeStampVal& aVal = const_cast(theVal); - MED::TTimeStampInfo& aTimeStampInfo = *aVal.myTimeStampInfo; - MED::TFieldInfo& aFieldInfo = *aTimeStampInfo.myFieldInfo; - MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo; - MED::TMeshValue& aMeshValue = aVal.myMeshValue; - - med_entite_maillage& anEntity = (med_entite_maillage&)(aTimeStampInfo.myEntity); - TMeshValue::iterator anIter = aMeshValue.begin(); - for(; anIter != aMeshValue.end(); anIter++){ - med_geometrie_element& aGeom = (med_geometrie_element&)(anIter->first); - TValue& aValue = aVal.myMeshValue[EGeometrieElement(aGeom)]; - med_int iEnd = aValue.size(); - med_int aNbVal = iEnd / aFieldInfo.myNbComp; - - switch(aFieldInfo.myType){ - case eFLOAT64: { - std::vector& anArray = aValue; - - aRet = MEDchampEcr(anId, - &aMeshInfo.myName[0], - &aFieldInfo.myName[0], - (unsigned char*)&anArray[0], - MED_FULL_INTERLACE, - aNbVal, - aTimeStampInfo.myNbGauss, - MED_ALL, - &aVal.myPflName[0], - MED_ECRI, - anEntity, - aGeom, - aTimeStampInfo.myNumDt, - &aTimeStampInfo.myUnitDt[0], - aTimeStampInfo.myDt, - aTimeStampInfo.myNumOrd); - break; - } - default: { - vector anArray(iEnd); - for(TInt i = 0; i< iEnd; i++) anArray[i] = TInt(aValue[i]); - - aRet = MEDchampEcr(anId, - &aMeshInfo.myName[0], - &aFieldInfo.myName[0], - (unsigned char*)&anArray[0], - MED_FULL_INTERLACE, - aNbVal, - aTimeStampInfo.myNbGauss, - MED_ALL, - &aVal.myPflName[0], - MED_ECRI, - anEntity, - aGeom, - aTimeStampInfo.myNumDt, - &aTimeStampInfo.myUnitDt[0], - aTimeStampInfo.myDt, - aTimeStampInfo.myNumOrd); - break; - }} - - if(aRet < 0){ - if(theErr){ - *theErr = aRet; - break; - } - EXCEPTION(runtime_error,"SetTimeStamp - MEDchampEcr(...)"); - } - - } - - INITMSG(MYDEBUG,"TVWrapper::SetMeshInfo - MED_MODE_ACCES = "< TVMeshInfo; - - typedef MED::TTFamilyInfo TVFamilyInfo; - - typedef MED::TTNodeInfo TVNodeInfo; - - typedef MED::TTCellInfo TVCellInfo; - - typedef MED::TTFieldInfo TVFieldInfo; - - typedef MED::TTTimeStampInfo TVTimeStampInfo; - - typedef MED::TTTimeStampVal TVTimeStampVal; - - //--------------------------------------------------------------- - class TFile; - typedef boost::shared_ptr PFile; - - typedef enum {eLECT, eECRI, eREMP} EModeAcces; - - //--------------------------------------------------------------- - class 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 TInt GetNbNodes(const MED::TMeshInfo& theMeshInfo, - 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 TEntityInfo GetEntityInfo(const MED::TMeshInfo& theMeshInfo, - EConnectivite theTConn = eNOD, - TErr* theErr = NULL); - - virtual TInt GetNbCells(const MED::TMeshInfo& theMeshInfo, - EEntiteMaillage, - EGeometrieElement, - EConnectivite theTConn = 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); - - - //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - 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 GetNbTimeStamps(const MED::TFieldInfo& theInfo, - const MED::TEntityInfo& theEntityInfo, - EEntiteMaillage& theEntity, - TGeom& theGeom, - TErr* theErr = NULL); - - virtual void GetTimeStampInfo(TInt theTimeStampId, - MED::TTimeStampInfo& theInfo, - TErr* theErr = NULL); - - virtual void GetTimeStampVal(MED::TTimeStampVal& theVal, - TErr* theErr = NULL); - - virtual void SetTimeStamp(const MED::TTimeStampVal& theTimeStampVal, - TErr* theErr = NULL); - - void SetTimeStamp(const MED::TTimeStampVal& theTimeStampVal, - EModeAcces theMode, - TErr* theErr = NULL); - - protected: - PFile myFile; - }; - } -} - -#endif diff --git a/src/MEDWrapper/V2_1/MEDattrFermer.cxx b/src/MEDWrapper/V2_1/MEDattrFermer.cxx deleted file mode 100644 index 6501c1fc4..000000000 --- a/src/MEDWrapper/V2_1/MEDattrFermer.cxx +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDattrFermer - * - Description : fermeture de l'acces a l'attribut dont l'ID est passe en - * parametre - * - Parametres : - * - pid (IN) : l'ID de l'objet HDF pere ou placer l'attribut - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDattrFermer(med_idt id) -{ - med_err ret; - - if ((ret = H5Aclose(id)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDattrNumEcrire.cxx b/src/MEDWrapper/V2_1/MEDattrNumEcrire.cxx deleted file mode 100644 index 9ceaffc88..000000000 --- a/src/MEDWrapper/V2_1/MEDattrNumEcrire.cxx +++ /dev/null @@ -1,126 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDattrNumEcrire - * - Description : ecriture d'un attribut entier - * - Parametres : - * - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut - * - type (IN) : le type du champ {MED_REEL64,MED_INT} - * - nom (IN) : le nom de l'attribut - * - val (IN) : la valeur de l'attribut - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDattrNumEcrire(med_idt pere,med_type_champ type,char *nom,unsigned char *val, - med_mode_acces mode) -{ - med_idt aid,attr; - med_err ret; - int type_hdf; - - switch(type) - { - case MED_REEL64 : - /* 1) IA32 is LE but due to an (?HDF convertion BUG?) when using H5T_NATIVE_DOUBLE/MED_REEL64? under PCLINUX - the file read under SGI is incorrect - 2) Compaq OSF/1 is LE, since we force SGI64,SUN4SOL2,HP to write double in LE even if they are BE, mips OSF/1 must be BE - REM : Be careful of compatibility between MED files when changing this (med2.2) */ -#if defined(PCLINUX) || defined(OSF1) - type_hdf = H5T_IEEE_F64BE; -#else - type_hdf = H5T_IEEE_F64LE; -#endif - break; - - case MED_INT : -#if defined(IRIX64) || defined(OSF1) - type_hdf = H5T_NATIVE_LONG; -#elif defined(PCLINUX) - /* This explicit convertion avoid a core dump between in HDF&ASTER when reading on SGI - a file written under a PCLINUX system (in founction H5Tconvert), - we don't know yet if it is an HDF bug or an ASTER one */ - /* The problem seems to be in convertion process between INT32LE->INT32BE ? */ - type_hdf = H5T_STD_I32BE; - if ((H5Tconvert(H5T_NATIVE_INT,H5T_STD_I32BE,1,(void *)val,NULL,NULL)) < 0) - return -1; -#else - type_hdf = H5T_NATIVE_INT; -#endif - break; - - default : - return -1; - } - - if ((aid = H5Screate(H5S_SCALAR)) < 0) - return -1; - - if ( ((attr = H5Aopen_name(pere,nom)) > 0) && (mode != MED_REMP) ) - return -1; - else - if ( attr < 0) - if ((attr = H5Acreate(pere,nom,type_hdf,aid,H5P_DEFAULT)) < 0) return -1; - - if ((ret = H5Awrite(attr,type_hdf,val)) < 0) - return -1; - - - if ((ret = H5Sclose(aid)) < 0) - return -1; - if ((ret = H5Aclose(attr)) < 0) - return -1; - -#if defined(PCLINUX) - /* This explicit convertion cancel the previous on which avoid a mysterious bug between HDF&ASTER when reading - a file written under a PCLINUX system, we don't know yet if it is an HDF bug or an ASTER one */ - if (type == MED_INT) - if ((H5Tconvert(H5T_STD_I32BE,H5T_NATIVE_INT,1,(void *)val,NULL,NULL)) < 0) - return -1; -#endif - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDattrNumLire.cxx b/src/MEDWrapper/V2_1/MEDattrNumLire.cxx deleted file mode 100644 index 206003a1a..000000000 --- a/src/MEDWrapper/V2_1/MEDattrNumLire.cxx +++ /dev/null @@ -1,96 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDattrNumLire - * - Description : lecture d'un attribut entier - * - Parametres : - * - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut - * - type (IN) : le type du champ {MED_REEL64,MED_INT} - * - nom (IN) : le nom de l'attribut - * - val (OUT) : la valeur de l'attribut - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDattrNumLire(med_idt pere,med_type_champ type,char *nom,unsigned char *val) -{ - med_idt attid; - med_err ret; - int type_hdf; - - if ((attid = H5Aopen_name(pere,nom)) < 0) - return -1; - - switch(type) - { - case MED_REEL64 : -#if defined(PCLINUX) || defined(OSF1) - type_hdf = H5T_IEEE_F64BE; -#else - type_hdf = H5T_IEEE_F64LE; -#endif - break; - - case MED_INT : -#if defined(IRIX64) || defined(OSF1) - type_hdf = H5T_NATIVE_LONG; -#else - type_hdf = H5T_NATIVE_INT; -#endif - break; - - default : - return -1; - } - - if ((ret = H5Aread(attid,type_hdf,val)) < 0) - return -1; - - if ((ret = H5Aclose(attid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDattrOuvrir.cxx b/src/MEDWrapper/V2_1/MEDattrOuvrir.cxx deleted file mode 100644 index 860b06905..000000000 --- a/src/MEDWrapper/V2_1/MEDattrOuvrir.cxx +++ /dev/null @@ -1,64 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDattrOuvrir - * - Description : acces a l'attribut dont le nom est passe en parametre - * - Parametres : - * - pid (IN) : l'ID de l'objet HDF pere ou placer l'attribut - * - nom (IN) : le nom de l'attribut - * - Resultat : ID de l'attribut en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_idt -_MEDattrOuvrir(med_idt pid,char * nom) -{ - med_idt aid; - - if ((aid = H5Aopen_name(pid,nom)) < 0) - return -1; - - return aid; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDattrStringEcrire.cxx b/src/MEDWrapper/V2_1/MEDattrStringEcrire.cxx deleted file mode 100644 index 093f72813..000000000 --- a/src/MEDWrapper/V2_1/MEDattrStringEcrire.cxx +++ /dev/null @@ -1,87 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDattrStringEcrire - * - Description : ecriture d'un attribut chaine de caracteres - * - Parametres : - * - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut - * - nom (IN) : le nom de l'attribut - * - longueur (IN) : strlen(val) - * - val (IN) : la valeur de l'attribut - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDattrStringEcrire(med_idt pere,char *nom,int longueur,char *val, med_mode_acces mode) -{ - med_idt aid,attr, datatype; - med_err ret; - - if ((aid = H5Screate(H5S_SCALAR)) < 0) - return -1; - if((datatype = H5Tcopy(H5T_C_S1)) < 0) - return -1; - if((ret = H5Tset_size(datatype,longueur+1)) < 0) - return -1; - - if ( ((attr = H5Aopen_name(pere,nom)) > 0) - && (mode != MED_REMP) ) - return -1; - else - if ( attr < 0) - if ((attr = H5Acreate(pere,nom,datatype,aid,H5P_DEFAULT)) < 0) return -1; - - if ((ret = H5Awrite(attr, datatype, val)) < 0) - return -1; - - if ((ret = H5Sclose(aid)) < 0) - return -1; - if ((ret = H5Tclose(datatype)) < 0) - return -1; - if ((ret = H5Aclose(attr)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDattrStringLire.cxx b/src/MEDWrapper/V2_1/MEDattrStringLire.cxx deleted file mode 100644 index 125d0f4f2..000000000 --- a/src/MEDWrapper/V2_1/MEDattrStringLire.cxx +++ /dev/null @@ -1,76 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDattrStringLire - * - Description : lecture d'un attribut chaine de caracteres - * - Parametres : - * - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut - * - nom (IN) : le nom de l'attribut - * - longueur (IN) : strlen(val) - * - val (OUT) : la valeur de l'attribut - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDattrStringLire(med_idt pere,char *nom,int longueur,char *val) -{ - med_idt attid,datatype; - med_err ret; - - if ((datatype = H5Tcopy(H5T_C_S1)) < 0) - return -1; - if ((ret = H5Tset_size(datatype,longueur+1)) < 0) - return -1; - if ((attid = H5Aopen_name(pere,nom)) < 0) - return -1; - if ((ret = H5Aread(attid,datatype,val)) < 0) - return -1; - if ((ret = H5Tclose(datatype)) < 0) - return -1; - if ((ret = H5Aclose(attid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDbodyFittedEcr.cxx b/src/MEDWrapper/V2_1/MEDbodyFittedEcr.cxx deleted file mode 100644 index 175896332..000000000 --- a/src/MEDWrapper/V2_1/MEDbodyFittedEcr.cxx +++ /dev/null @@ -1,161 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med_outils.hxx" -#include "med.hxx" - -#if defined(IRIX64) -#define MED_INTEGER MED_INT64 -#else -#define MED_INTEGER MED_INT32 -#endif - -namespace med_2_1{ - -med_err -MEDbodyFittedEcr(med_idt fid, char *maa, med_int mdim, med_float *coo, med_int *nbr, med_mode_switch mode_coo, - med_repere repere, char *nomcoo, char *unicoo, med_int *fam, med_int nnoeuds, med_mode_acces mode ) -{ - /* ecriture des coordonnees */ - med_idt maaid, noeid, dataset; - med_size dimd[1]; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - med_int type_rep_int; - int d; - char *ds; - - /* On inhibe le gestionnaire d'erreur HDF */ - _MEDmodeErreurVerrouiller(); - - /* Si le maillage n'existe pas => erreur */ - strcpy(chemin, MED_MAA); - strcat(chemin, maa); - if ((maaid = _MEDdatagroupOuvrir(fid, chemin)) < 0) { - return(-1); - }; - - /* Si le Data Group "NOE" n'existe pas on le cree */ - if ((noeid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE)) < 0) { - if ((noeid = _MEDdatagroupCreer(maaid, MED_NOM_NOE)) < 0) { - return(-1); - }; - }; - - /* Creation du Data Set "BOF" */ - dimd[0] = nnoeuds*mdim; - if (_MEDdatasetNumEcrire(noeid, MED_NOM_BOF, MED_REEL64, mode_coo, mdim, MED_ALL, MED_NOPF, 0, 0, dimd, (unsigned char*)coo, mode) < 0) { - return(-1); - }; - - /* On re-ouvre le Data Set "BOF" pour y placer des attributs */ - if ((dataset = _MEDdatasetOuvrir(noeid, MED_NOM_BOF)) < 0) { - return(-1); - }; - - /* Attribut NBR (nombre de noeuds) */ - if (_MEDattrEntierEcrire(dataset, MED_NOM_NBR, &nnoeuds, mode) < 0) { - return(-1); - }; - - /* L'attribut "REP" */ - type_rep_int = (med_int)repere; - if (_MEDattrEntierEcrire(dataset, MED_NOM_REP, &type_rep_int, mode) < 0) { - return(-1); - }; - - /* Attribut "NOM" */ - if (_MEDattrStringEcrire(dataset, MED_NOM_NOM, mdim*MED_TAILLE_PNOM, nomcoo, mode) < 0) { - return(-1); - }; - - /* Attribut "UNI" */ - if (_MEDattrStringEcrire(dataset, MED_NOM_UNI, mdim*MED_TAILLE_PNOM, unicoo, mode) < 0) { - return(-1); - }; - - if (_MEDdatasetFermer(dataset) < 0) return(-1); - - dimd[0] = 1; - for (d=0; d erreur */ - strcpy(chemin, MED_MAA); - strcat(chemin, maa); - maaid = _MEDdatagroupOuvrir(fid, chemin); - if (maaid < 0) return(-1); - - /* Si le Data Group "NOE" n'existe pas => erreur */ - noeid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE); - if (noeid < 0) return(-1); - - /* Lecture du Data Set "BOF" */ - if (_MEDdatasetNumLire(noeid, MED_NOM_BOF, MED_REEL64, mode_coo, mdim, MED_ALL, MED_NOPF, 0, 1, (unsigned char*)coo) < 0) { - return(-1); - }; - - /* On re-ouvre le Data Set "BOF" pour y lire des attributs */ - dataset = _MEDdatasetOuvrir(noeid, MED_NOM_BOF); - if (dataset < 0) return(-1); - - /* L'attribut "REP" */ - if (_MEDattrEntierLire(dataset, MED_NOM_REP, &type_rep_int) < 0) { - return(-1); - } else { - *repere = (med_repere)type_rep_int; - }; - - /* Attribut "NOM" */ - if (_MEDattrStringLire(dataset, MED_NOM_NOM, mdim*MED_TAILLE_PNOM, nomcoo) < 0) { - return(-1); - }; - - /* Attribut "UNI" */ - if (_MEDattrStringLire(dataset, MED_NOM_UNI, mdim*MED_TAILLE_PNOM, unicoo) < 0) { - return(-1); - }; - - /* lecture des numeros de familles */ - if (MEDfamLire(fid, maa, fam, nnoeuds, MED_NOEUD, MED_POINT1) < 0) { - return(-1); - }; - - /* On ferme tout */ - if (_MEDdatasetFermer(dataset) < 0) { - return(-1); - }; - if (_MEDdatagroupFermer(noeid) < 0) { - return(-1); - }; - if (_MEDdatagroupFermer(maaid) < 0) { - return(-1); - }; - return(0); -} - -} diff --git a/src/MEDWrapper/V2_1/MEDchampCr.cxx b/src/MEDWrapper/V2_1/MEDchampCr.cxx deleted file mode 100644 index dca950a3f..000000000 --- a/src/MEDWrapper/V2_1/MEDchampCr.cxx +++ /dev/null @@ -1,102 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDchampCr(med_idt fid, char *champ, med_type_champ type, char *comp, - char *unit,med_int ncomp) -{ - med_err ret = 0; - med_idt root,gid; - char chemin[MED_TAILLE_CHA+1]; - med_size dimd[1]; - med_int _type = (med_int) type; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le Data Group "/CHA/" n'existe pas, on le cree - */ - strncpy(chemin,MED_CHA,MED_TAILLE_CHA-1); - chemin[MED_TAILLE_CHA-1] = '\0'; - if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0) - if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) - return -1; - - /* - * Si le Data Group cha n'existe pas, on le cree - * Sinon => erreur - */ - if ((gid = _MEDdatagroupOuvrir(root,champ)) >= 0) - return -1; - if ((gid = _MEDdatagroupCreer(root,champ)) < 0) - return -1; - - /* - * Les infos sur les composants du champ - */ - if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_NCO,&ncomp,MED_REMP)) < 0) - return -1; - if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_TYP,&_type,MED_REMP)) < 0) - return -1; - if ((ret = _MEDattrStringEcrire(gid,MED_NOM_NOM,MED_TAILLE_PNOM*ncomp,comp,MED_REMP)) < 0) - return -1; - if ((ret = _MEDattrStringEcrire(gid,MED_NOM_UNI,MED_TAILLE_PNOM*ncomp,unit,MED_REMP)) < 0) - return -1; - - /* - * On ferme tout - */ - if ((ret = _MEDdatagroupFermer(gid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(root)) < 0) - return -1; - - return ret; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDchampEcr.cxx b/src/MEDWrapper/V2_1/MEDchampEcr.cxx deleted file mode 100644 index 6c5dd4709..000000000 --- a/src/MEDWrapper/V2_1/MEDchampEcr.cxx +++ /dev/null @@ -1,265 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -/* - * - Nom de la fonction : MEDchampEcr - * - Description : ecriture d'un Champ Résultat - * - Parametres : - * - fid (IN) : ID du fichier HDF courant - * - maa (IN) : le nom du maillage sur lequel s'applique le champ - * - cha (IN) : le nom du champ - * - val (IN) : valeurs du champ à stocker - * - interlace(IN) : entrelacement utilisé en mémoire {MED_FULL_INTERLACE,MED_NO_INTERLACE} - * - nbelem (IN) : nombre d'éléments (prend en compte le nbre - * de points de Gauss (c'est demandé à l'utilisateur ds la doc) mais pas le nbre de composantes) - * - ngauss (IN) : nbre de point de gauss utilisé (MED_NOPG si aucun) - * - numco (IN) : n° de la composante à stocker (MED_ALL si toutes) - * - profil (IN) : nom du profil utilisé (MED_NOPFL si inutilisé) - * - mode (IN) : mode d'ecriture MED (MED_ECRI | MED_REMP) - * - type_ent (IN) : entité concerné par le champ {MED_NOEUD,MED_ARETE,MED_FACE,MED_MAILLE} - * - type_geo (IN) : type géométrique de l'entité concerné {MED_POINT,MED_SEG2 ......} - * - numdt (IN) : n° du pas de temps (MED_NOPDT si aucun) - * - dt_unit (IN) : chaine de taille MED_NOMP indiquant l'unité du champ - * - dt (IN) : valeur du pas de temps - * - numo (IN) : n° d'ordre utilisé MED_NONOR si inutile - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -MEDchampEcr(med_idt fid, char *maa, char *cha,unsigned char *val,med_mode_switch interlace,med_int nbelem,med_int ngauss, - med_int numco, char * profil, med_mode_acces mode, med_entite_maillage type_ent, - med_geometrie_element type_geo, med_int numdt,char * dt_unit, med_float dt, med_int numo) -{ - med_err ret; - med_idt chid,datagroup1,datagroup2; - med_int ncomp, chtype, i, locnumdt,pfluse; - char pflname [MED_TAILLE_NOM+1]; - char maillage[MED_TAILLE_NOM+1]; - char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2],nomdatagroup2[2*MED_MAX_PARA+1]; - char tmp1[MED_TAILLE_NOM_ENTITE+1]; - med_size dimd[1],psize; - med_int *pfltabtmp=0; - med_ssize *pfltab=0; - char chemin[MED_TAILLE_CHA+MED_TAILLE_NOM+1]; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - - /* - * Si le Data Group cha n'existe pas => erreur - */ - strcpy(chemin,MED_CHA); - strcat(chemin,cha); - if ((chid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * Creation du datagroup de niveau 1 [.] - */ - - if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0) - return -1; - if ((type_ent != MED_NOEUD)) - { - if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0) - return -1; - strcat(nomdatagroup1,"."); - strcat(nomdatagroup1,tmp1); - } - datagroup1 = 0; - if ( (datagroup1 = _MEDdatagroupOuvrir(chid,nomdatagroup1)) < 0) - if ((datagroup1 = _MEDdatagroupCreer(chid,nomdatagroup1)) < 0) - return -1; - - /* Creation du datagroup de niveau 2 . */ - if ( numdt == MED_NOPDT) locnumdt = MED_NOPDT; else locnumdt = numdt; - sprintf(nomdatagroup2,"%*li%*li",MED_MAX_PARA,(long ) locnumdt,MED_MAX_PARA,(long ) numo); - - - /*Cree ou ouvre (en mode MED_REMP) le datagroup nomdatagroup2 */ - datagroup2 = 0; - if (((datagroup2 = _MEDdatagroupOuvrir(datagroup1,nomdatagroup2)) > 0) - && (mode != MED_REMP)) - return -1; - else - if (datagroup2 < 0) - if ((datagroup2 = _MEDdatagroupCreer(datagroup1,nomdatagroup2)) < 0) - return -1; - - /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_NDT */ - if ((ret = _MEDattrEntierEcrire(datagroup2,MED_NOM_NDT,&numdt,mode)) < 0) - return -1; - - /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_PDT */ - if ((ret = _MEDattrFloatEcrire(datagroup2,MED_NOM_PDT,&dt,mode)) < 0) - return -1; - - /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_NOR */ - if ((ret = _MEDattrEntierEcrire(datagroup2,MED_NOM_NOR,&numo,mode)) < 0) - return -1; - - /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_NBR */ - if ((ret = _MEDattrEntierEcrire(datagroup2,MED_NOM_NBR,&nbelem,mode)) < 0) - return -1; - - /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_MAA */ - /* rem : Aucune verification de l'existence du maillage */ - strncpy(maillage,maa,MED_TAILLE_NOM); - maillage[MED_TAILLE_NOM]='\0'; - if ((ret = _MEDattrStringEcrire(datagroup2,MED_NOM_MAI,MED_TAILLE_NOM,maillage,mode)) < 0) - return -1; - - /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_PFL */ - pfluse = 0; - if ( strlen(profil) == 0) /* idem MED_NOPFL*/ - strncpy(pflname,MED_NOPFLi,MED_TAILLE_NOM+1); - else { - strncpy(pflname,profil,MED_TAILLE_NOM); - pflname[MED_TAILLE_NOM]='\0'; - pfluse = 1; - } - if ((ret = _MEDattrStringEcrire(datagroup2,MED_NOM_PFL,MED_TAILLE_NOM,pflname,mode)) < 0) - return -1; - - /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_UNI */ - if ( strlen(dt_unit) == 0) { - if ((ret = _MEDattrStringEcrire(datagroup2,MED_NOM_UNI,MED_TAILLE_PNOM," ",mode)) < 0) - return -1; - } else - if ((ret = _MEDattrStringEcrire(datagroup2,MED_NOM_UNI,MED_TAILLE_PNOM,dt_unit,mode)) < 0) - return -1; - - - /* Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_NGAU */ - /* Ecriture du nombre de pts de gauss propre au [.] */ - /* On n'utilise pas ngauss=MED_NOPG mais ngauss=1 si aucun pt de gauss */ - if ((ret = _MEDattrEntierEcrire(datagroup2,MED_NOM_NGA,&ngauss,mode)) < 0) - return -1; - - /*Lecture de l'attribut MED_NOM_NCO */ - if ((ret = _MEDattrEntierLire(chid,MED_NOM_NCO,&ncomp)) < 0) - return -1; - - /*Determination de la taille dimd[0] du dataset à stocker*/ - dimd[0] = nbelem*ncomp; - - /* Gestion des profils*/ - if ( pfluse ) { - - if ( ( i = MEDnValProfil(fid,pflname) ) < 0 ) - return -1; - else - psize = i; - - pfltabtmp = (med_int *) malloc (sizeof(med_int)*psize); - pfltab = (med_ssize *) malloc (sizeof(med_ssize)*psize); - if ((ret = MEDprofilLire(fid,pfltabtmp,pflname)) < 0) - return -1; - for (i=0;i erreur - */ - strcat(chemin,champ); - if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - - /* - * La liste des attributs - */ - if ((ret = _MEDattrEntierLire(gid,MED_NOM_TYP,(med_int*) type)) < 0) - return -1; - if ((ret = _MEDattrStringLire(gid,MED_NOM_NOM,ncomp*MED_TAILLE_PNOM, - comp)) < 0) - return -1; - if ((ret = _MEDattrStringLire(gid,MED_NOM_UNI,ncomp*MED_TAILLE_PNOM, - unit)) < 0) - return -1; - - /* - * On ferme tout - */ - if ((ret = _MEDdatagroupFermer(gid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDchampLire.cxx b/src/MEDWrapper/V2_1/MEDchampLire.cxx deleted file mode 100644 index aea72c6ba..000000000 --- a/src/MEDWrapper/V2_1/MEDchampLire.cxx +++ /dev/null @@ -1,213 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - - /*La taille de val allouée par l'utilisateur doit prendre en compte le nbre de points de gauss et le nbre de composantes*/ - -namespace med_2_1{ - -med_err -MEDchampLire(med_idt fid,char *maa, char *cha, unsigned char *val,med_mode_switch interlace,med_int numco, - char *profil,med_entite_maillage type_ent, med_geometrie_element type_geo, - med_int numdt, med_int numo) - /* VERIFIER LA POSSIBILITE DE RELIRE L'UNITE DE PAS DE TEMPS (DS CHAMPINFO) */ -{ - med_err ret; - med_idt chid, datagroup1, datagroup2; - med_int ncomp, chtype, ngauss, i, locnumdt, pfluse; - char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2],nomdatagroup2[2*MED_MAX_PARA+1]; - char tmp1[MED_TAILLE_NOM_ENTITE+1], pfltmp[MED_TAILLE_NOM+1]; - char chemin[MED_TAILLE_CHA+MED_TAILLE_NOM+1]; - med_size psize; - med_int *pfltabtmp=0; - med_ssize *pfltab=0; - char maatmp[MED_TAILLE_NOM+1]; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le Data Group cha n'existe pas => erreur - */ - strcpy(chemin,MED_CHA); - strcat(chemin,cha); - if ((chid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * Si le Data Group de niveau 1 [.] n'existe pas => erreur - */ - if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0) - return -1; - if ((type_ent != MED_NOEUD)) - { - if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0) - return -1; - strcat(nomdatagroup1,"."); - strcat(nomdatagroup1,tmp1); - } - datagroup1 = 0; - if ( (datagroup1 = _MEDdatagroupOuvrir(chid,nomdatagroup1)) < 0 ) - return -1; - - /* - * Si le Data Group de niveau 2 . n'existe pas => erreur - */ - if ( numdt == MED_NOPDT) locnumdt = MED_NOPDT; else locnumdt = numdt; - sprintf(nomdatagroup2,"%*li%*li",MED_MAX_PARA,(long ) locnumdt,MED_MAX_PARA,(long ) numo); - - datagroup2 = 0; - if ( (datagroup2 = _MEDdatagroupOuvrir(datagroup1,nomdatagroup2)) < 0) - return -1; - - /* Lecture du nbre de composantes du champ */ - - if ((ret = _MEDattrEntierLire(chid,MED_NOM_NCO,&ncomp)) < 0) - return -1; - - /* Gestion des profils*/ - - /* - * Lire le profil demandé - */ - - if ((ret = _MEDattrStringLire(datagroup2,MED_NOM_PFL,MED_TAILLE_NOM,pfltmp)) < 0) - return -1; - - if ( pfluse = (strcmp(pfltmp,MED_NOPFLi) && strcmp(pfltmp,"")) ) /* le test "" pour des raisons de compatibilité */ - { - strcpy(profil,pfltmp); - if ( (i = MEDnValProfil(fid,profil)) < 0 ) - return -1; - else - psize = i; - - pfltabtmp = (med_int *) malloc (sizeof(med_int)*psize); - pfltab = (med_ssize *) malloc (sizeof(med_ssize)*psize); - if ((ret = MEDprofilLire(fid,pfltabtmp,profil)) < 0) - return -1; - for (i=0;i[.] pour simplifier la relecture */ - if ( (ret = _MEDattrEntierLire(datagroup2,MED_NOM_NGA,&ngauss)) < 0 ) - return -1; - - /* - * Lecture du champ - */ - - if ((ret = _MEDattrEntierLire(chid,MED_NOM_TYP,&chtype)) < 0) - return -1; - - switch(chtype) - { - case MED_REEL64 : - if ((ret = _MEDdatasetNumLire(datagroup2,MED_NOM_CO,MED_REEL64, - interlace,ncomp,numco, - psize,pfltab,ngauss,val))< 0) - return -1; - break; - - case MED_INT32 : -#if defined(IRIX64)||defined(OSF1) - if ((ret = _MEDdatasetNumLire(datagroup2,MED_NOM_CO,MED_INT64, - interlace,ncomp,numco, - psize,pfltab,ngauss,val))< 0) - return -1; -#else - if ((ret = _MEDdatasetNumLire(datagroup2,MED_NOM_CO,MED_INT32, - interlace,ncomp,numco, - psize, pfltab,ngauss,val))< 0) - return -1; -#endif - break; - - case MED_INT64 : -#if defined(IRIX64)||defined(OSF1) - if ((ret = _MEDdatasetNumLire(datagroup2,MED_NOM_CO,MED_INT64, - interlace,ncomp,numco, - psize,pfltab,ngauss,val))< 0) - return -1; -#else - return -1; -#endif - break; - - default : - return -1; - } - - /* - * On ferme tout - */ - if ( pfluse ) { free(pfltab); free(pfltabtmp);} - - if ((ret = _MEDdatagroupFermer(datagroup2)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(datagroup1)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(chid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDconnEcr.cxx b/src/MEDWrapper/V2_1/MEDconnEcr.cxx deleted file mode 100644 index 9bf9d4709..000000000 --- a/src/MEDWrapper/V2_1/MEDconnEcr.cxx +++ /dev/null @@ -1,161 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -extern int mode_interlace; - -namespace med_2_1{ - -med_err -MEDconnEcr(med_idt fid,char *maa, med_int mdim, med_int *connectivite,med_mode_switch mode_switch, - med_int nbre,med_mode_acces mode,med_entite_maillage type_ent, - med_geometrie_element type_geo,med_connectivite type_conn) -{ - med_idt maaid, entid, geoid, dataset; - med_err ret; - med_size dimd[1]; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - char nom_ent[MED_TAILLE_NOM_ENTITE+1]; - char nom_geo[MED_TAILLE_NOM_ENTITE+1]; - char nom_dataset[MED_TAILLE_NOM_ENTITE+1]; - int dim, nnoe, ndes; - int nsup = 0; - int taille; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le maillage n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * On met a jour le nom du Data Group representant - * le type des entites - */ - if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) - return -1; - /* - * Si le Data Group des entites n'existe pas on le cree - */ - /*EF Gerer le mode */ - if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) - if ((entid = _MEDdatagroupCreer(maaid,nom_ent)) < 0) - return -1; - - /* - * On cree s'il n'existe pas le Data Group du type geometrique - */ - /*EF Gerer le mode */ - if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) - return -1; - if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) - if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0) - return -1; - - /* - * On regarde si le Data Set existe et on le cree sinon - */ - if ((ret=_MEDparametresGeometrie(type_ent,type_geo,&dim,&nnoe,&ndes))<0) - return -1; - if (mdim == 2 || mdim == 3) - if (type_ent == MED_MAILLE && dim == 1) - nsup = 1; - if (mdim == 3) - if (type_ent == MED_MAILLE && dim == 2) - nsup = 1; - switch(type_conn) - { - case MED_NOD : - strcpy(nom_dataset,MED_NOM_NOD); - taille = nsup + nnoe; - break; - - case MED_DESC : - strcpy(nom_dataset,MED_NOM_DES); - taille = nsup + ndes; - break; - - default : - return -1; - } - dimd[0] = nbre*taille; -#if defined(IRIX64)||defined(OSF1) - if ((ret = _MEDdatasetNumEcrire(geoid,nom_dataset,MED_INT64,mode_switch,(med_size)taille,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, - (unsigned char*) connectivite,mode)) < 0) - return -1; -#else - if ((ret = _MEDdatasetNumEcrire(geoid,nom_dataset,MED_INT32,mode_switch,(med_size)taille,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, - (unsigned char*) connectivite,mode)) < 0) - return -1; -#endif - - /* - * Attribut NBR (nombre de noeuds ou d'elements) - */ - if ((dataset = _MEDdatasetOuvrir(geoid,nom_dataset)) < 0) - return -1; - if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&nbre,mode)) < 0) - return -1; - - /* - * On ferme tout - */ - if ((ret = _MEDdatasetFermer(dataset)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(geoid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(entid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDconnLire.cxx b/src/MEDWrapper/V2_1/MEDconnLire.cxx deleted file mode 100644 index 45a9d7009..000000000 --- a/src/MEDWrapper/V2_1/MEDconnLire.cxx +++ /dev/null @@ -1,168 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -extern int mode_interlace; - -namespace med_2_1{ - -med_err -MEDconnLire(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch, - med_int * pfltabtmp, med_size psizetmp, - med_entite_maillage type_ent, med_geometrie_element type_geo,med_connectivite type_conn) -{ - med_idt maaid,entid,geoid; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - char nom_ent[MED_TAILLE_NOM_ENTITE+1]; - char nom_geo[MED_TAILLE_NOM_ENTITE+1]; - char nom_dataset[MED_TAILLE_NOM_ENTITE+1]; - med_ssize * pfltab; - med_size psize; - int dim,nnoe,ndes; - int nsup = 0; - int taille; - int i,j; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le maillage n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * On met a jour le nom du Data Group representant - * le type des entites - */ - if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) - return -1; - /* - * Si le Data Group des entites n'existe pas => erreur - */ - if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) - return -1; - - /* - * si le Data Group du type geometrique n'existe pas => erreur - */ - if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) - return -1; - if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) - return -1; - - /* - * Si le Data Set de la connectivite n'existe pas => erreur - * Si oui => on le lit - */ - if ((ret=_MEDparametresGeometrie(type_ent,type_geo,&dim,&nnoe,&ndes))<0) - return -1; - if (mdim == 2 || mdim == 3) - if (type_ent == MED_MAILLE && dim == 1) - nsup = 1; - if (mdim == 3) - if (type_ent == MED_MAILLE && dim == 2) - nsup = 1; - - - psize = psizetmp; - switch(type_conn) - { - case MED_NOD : - strcpy(nom_dataset,MED_NOM_NOD); - taille = nsup + nnoe; - break; - - case MED_DESC : - strcpy(nom_dataset,MED_NOM_DES); - taille = nsup + ndes; - if ( psizetmp != MED_NOPF ) { - psize = psizetmp; - pfltab = (med_ssize *) malloc (sizeof(med_ssize)*psize); - for (i=0;i -#include - -namespace med_2_1{ - -med_err -MEDcoordEcr(med_idt fid, char *maa, med_int mdim, med_float *coo, - med_mode_switch mode_coo,med_int n, - med_mode_acces mode, med_repere type_rep, char *nom, char *unit) -{ - med_idt maaid, noeid, dataset; - med_err ret; - med_size dimd[1]; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - med_int type_rep_int; - /* - * On inhibe le gestionnaire d'erreur HDF - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le maillage n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * Si le Data Group "NOE" n'existe pas - * on le cree - */ - /* EF : A faire : gerer le mode MED_REMP*/ - if ((noeid = _MEDdatagroupOuvrir(maaid,MED_NOM_NOE)) < 0) - if ((noeid = _MEDdatagroupCreer(maaid,MED_NOM_NOE)) < 0) - return -1; - - /* - * Creation du Data Set "COO" - */ - dimd[0] = n*mdim; - if ((ret = _MEDdatasetNumEcrire(noeid,MED_NOM_COO,MED_REEL64,mode_coo,mdim,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, - (unsigned char*) coo,mode)) < 0) - return -1; - - /* - * On re-ouvre le Data Set "COO" pour y placer des attributs - */ - if ((dataset = _MEDdatasetOuvrir(noeid,MED_NOM_COO)) < 0) - return -1; - - /* - * Attribut NBR (nombre de noeuds) - */ - if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n,mode)) < 0) - return -1; - - /* - * L'attribut "REP" - */ - type_rep_int = (med_int) type_rep; - if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_REP,&type_rep_int,mode)) < 0) - return -1; - - /* - * Attribut "NOM" - */ - if ((ret = _MEDattrStringEcrire(dataset,MED_NOM_NOM,mdim*MED_TAILLE_PNOM,nom,mode)) < 0) - return -1; - - /* - * Attribut "UNI" - */ - if ((ret = _MEDattrStringEcrire(dataset,MED_NOM_UNI,mdim*MED_TAILLE_PNOM,unit,mode)) < 0) - return -1; - - /* - * On ferme tout - */ - if ((ret = _MEDdatasetFermer(dataset)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(noeid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDcoordLire.cxx b/src/MEDWrapper/V2_1/MEDcoordLire.cxx deleted file mode 100644 index 70be872c9..000000000 --- a/src/MEDWrapper/V2_1/MEDcoordLire.cxx +++ /dev/null @@ -1,144 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med_outils.hxx" -#include "med.hxx" - -#include -#include - -extern int mode_interlace; - -namespace med_2_1{ - -med_err -MEDcoordLire(med_idt fid, char *maa, med_int mdim, med_float *coo, - med_mode_switch mode_coo,med_int numco, - med_int * pfltabtmp, med_size psize, med_repere *type_rep, char *nom, char *unit) -{ - med_idt maaid, noeid, dataset; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - int i,j; - med_float *new_coo; - med_int type_rep_int; - med_ssize * pfltab; - - /* - * On inhibe le gestionnaire d'erreur - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le maillage n'existe pas => erreur - * Sinon on recupere sa dimension au passage - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * Si le Data Group "NOE" n'existe pas => erreur - */ - if ((noeid = _MEDdatagroupOuvrir(maaid,MED_NOM_NOE)) < 0) - return -1; - - /* - * Convertion de med_int en med_ssize - */ - if ( psize != MED_NOPF ) { - pfltab = (med_ssize *) malloc (sizeof(med_ssize)*psize); - for (i=0;i -#include "med_misc.hxx" - -/* - * - Nom de la fonction _MEDcstringFree - * - Description : libere la chaine de caracteres creee par - * les routines _MEDXcstring - * - Parametres : - * - chaine (IN/OUT) : la chaine de caracteres a detruire - * - Resultat : 0 si succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDcstringFree(char *chaine) -{ - - free(chaine); - return 0; - -} - -} diff --git a/src/MEDWrapper/V2_1/MEDdatagroupCreer.cxx b/src/MEDWrapper/V2_1/MEDdatagroupCreer.cxx deleted file mode 100644 index 7329d8798..000000000 --- a/src/MEDWrapper/V2_1/MEDdatagroupCreer.cxx +++ /dev/null @@ -1,64 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDdatagroupCreer - * - Description : creation et ouverture d'un Datagroup HDF - * - Parametres : - * - pid (IN) : l'ID de l'objet pere - * - nom (IN) : le nom de l'objet fils - * - Resultat : l'ID du fils en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_idt -_MEDdatagroupCreer(med_idt pid, char *nom) -{ - med_idt id; - - if ((id = H5Gcreate(pid,nom,0)) < 0) - return -1; - - return id; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDdatagroupFermer.cxx b/src/MEDWrapper/V2_1/MEDdatagroupFermer.cxx deleted file mode 100644 index 316ad6693..000000000 --- a/src/MEDWrapper/V2_1/MEDdatagroupFermer.cxx +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDdatagroupFermer - * - Description : fermeture d'un datagroup HDF - * - Parametres : - * - id (IN) : l'ID du datagroup - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDdatagroupFermer(med_idt id) -{ - med_err ret; - - if ((ret = H5Gclose(id)) < 0) - return -1; - else - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDdatagroupOuvrir.cxx b/src/MEDWrapper/V2_1/MEDdatagroupOuvrir.cxx deleted file mode 100644 index 78024a64f..000000000 --- a/src/MEDWrapper/V2_1/MEDdatagroupOuvrir.cxx +++ /dev/null @@ -1,64 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDdatagroupOuvrir - * - Description : ouverture d'un datagroup HDF - * - Parametres : - * - pid (IN) : l'ID de l'objet pere - * - nom (IN) : le nom de l'objet fils - * - Resultat : l'ID du fils en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_idt -_MEDdatagroupOuvrir(med_idt pid, char *nom) -{ - med_idt id; - - if ((id = H5Gopen(pid,nom)) < 0) - return -1; - - return id; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDdatasetFermer.cxx b/src/MEDWrapper/V2_1/MEDdatasetFermer.cxx deleted file mode 100644 index 70259a891..000000000 --- a/src/MEDWrapper/V2_1/MEDdatasetFermer.cxx +++ /dev/null @@ -1,62 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDdatasetFermer - * - Description : fermeture d'un objet HDF dataset - * - Parametres : - * - id (IN) : l'ID de l'objet HDF dataset - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDdatasetFermer(med_idt id) -{ - med_err ret; - - if ((ret = H5Dclose(id)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDdatasetNumEcrire.cxx b/src/MEDWrapper/V2_1/MEDdatasetNumEcrire.cxx deleted file mode 100644 index cd4c59fc3..000000000 --- a/src/MEDWrapper/V2_1/MEDdatasetNumEcrire.cxx +++ /dev/null @@ -1,393 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" -#include - -/* - * - Nom de la fonction : _MEDdatasetNumEcrire - * - Description : ecriture d'un dataset tableau numerique - * - Parametres : - * - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut - * - nom (IN) : le nom du dataset - * - type (IN) : type numerique MED { MED_REEL64 , MED_INT32 , MED_INT64 } - * - interlace (IN) : Choix du type d'entrelacement utilisé par l'appelant { MED_FULL_INTERLACE(x1,y1,z1,x2,...)) , MED_NO_INTERLACE(x1,x2,y1,y2,z1,z2) } - * - nbdim (IN) : Dimension des éléments - * - fixdim (IN) : MED_ALL ou n° de la dimension a enregistrer - * - psize (IN) : Taille du profil à utiliser, MED_NOPF si pas de profil - * (référence les élements, cette taille ne prend pas en compte le nombre de pts de gauss ni la dimension ) - * - pfltab (IN) : Tableau contenant les n° déléments à traiter (1....oo) - * - pflmod (IN) : PARAMETRE A AJOUTER : Indique comment lire les informations en mémoire { MED_COMPACT, MED_GLOBALE }. - * - ngauss (IN) : Nombre de points de GAUSS par élément - * - size (IN) : Taille du tableau de valeurs - * (référence tous les élements, cette taille prend en compte le nombre de pts de gauss et la dimension ) - * - val (IN) : valeurs du tableau - * - mode (IN) : mode d'ecriture MED (MED_ECRI | MED_REMP) - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDdatasetNumEcrire(med_idt pere,char *nom, med_type_champ type, - med_mode_switch interlace, med_size nbdim, med_size fixdim, - med_size psize, med_ssize * pfltab, med_int ngauss, - med_size *size, unsigned char *val, med_mode_acces mode) -{ - med_idt dataset, dataspace = 0, memspace = 0; - med_ssize start_mem[1],start_data[1],*pflmem,*pfldsk; - med_size stride[1],count[1],pcount[1],pflsize[1]; - med_err ret; - int i,j,index,type_hdf; - int dim, firstdim, dimutil, lastdim ; - med_mode_profil pflmod; - - /* Verify fixdim is between [0, nbdim] ( 0 is MED_ALL ) */ - if ( ( fixdim < 0 ) || ( fixdim > nbdim ) ) - return -1; - - /* block pflmod to MED_COMPACT (until med2.2) */ - pflmod = MED_COMPACT; - - switch(type) - { - case MED_REEL64 : - /* 1) IA32 is LE but due to an (?HDF convertion BUG?) when using H5T_NATIVE_DOUBLE/MED_REEL64? under PCLINUX - the file read under SGI is incorrect - 2) Compaq OSF/1 is LE, since we force SGI64,SUN4SOL2,HP to write double in LE even if they are BE, mips OSF/1 must be BE - REM : Be careful of compatibility between MED files when changing this (med2.2) */ -#if defined(PCLINUX) || defined(OSF1) - type_hdf = H5T_IEEE_F64BE; -#else - type_hdf = H5T_IEEE_F64LE; -#endif - break; - - case MED_INT32 : -#if defined(PCLINUX) - type_hdf = H5T_STD_I32BE; - if ((H5Tconvert(H5T_NATIVE_INT,H5T_STD_I32BE,(hsize_t)*size,(void *)val,NULL,NULL)) < 0) - return -1; -#else - type_hdf = H5T_NATIVE_INT; -#endif - break; - - case MED_INT64 : - type_hdf = H5T_NATIVE_LONG; - break; - - default : - return -1; - } - - - if ((dataset = H5Dopen(pere,nom)) < 0) - { - /* Whatever the size of the profil is we create a dataset with the size of the value array */ - /* Then if we used the MED_REMP mode we can append a new dimension to a previous one in the dataset */ - /* When we'll use the compression mode, the space used by unused values would be easily compressed */ - - if ((dataspace = H5Screate_simple(1,size,NULL)) < 0) - return -1; - if ((dataset = H5Dcreate(pere,nom,type_hdf,dataspace, - H5P_DEFAULT)) < 0) - return -1; - } - else - if (mode != MED_REMP) - { - H5Dclose(dataset); - return -1; - } - else - if ((dataspace = H5Dget_space(dataset)) <0) - return -1; - - - switch(interlace) - { /* switch Interlace */ - case MED_FULL_INTERLACE : - - /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/ - if ( fixdim != MED_ALL) - { - firstdim = fixdim-1; - lastdim = fixdim; - dimutil = 1; - } else { - firstdim = 0; - lastdim = nbdim; - dimutil = nbdim; - } - - count [0] = (*size)/(nbdim); - - - if ( psize == MED_NOPF ) { - - /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */ - if ( (memspace = H5Screate_simple (1, size, NULL)) <0) - return -1; - - stride[0] = nbdim; - - for (dim=firstdim; dim < lastdim; dim++) { - - start_mem[0] = dim; - if ( (ret = H5Sselect_hyperslab (memspace, H5S_SELECT_SET, start_mem, stride, - count, NULL)) <0) - return -1; - - start_data[0] = dim*count[0]; - if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL, - count, NULL)) <0) - return -1; - - if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace, - H5P_DEFAULT, val)) < 0) - return -1; - } - - } else { /* psize != MED_NOPF */ - - pflsize [0] = psize*ngauss*nbdim; - pcount [0] = psize*ngauss*dimutil; - pflmem = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]); - pfldsk = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]); - - switch(pflmod) - { /* switch pflmod pout FULL_INTERLACE*/ - case MED_GLOBALE : - - /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */ - if ( (memspace = H5Screate_simple (1, size, NULL)) <0) - return -1; - - for (dim=firstdim; dim < lastdim; dim++) { - - for (i=0; i < psize; i++) /* i balaye les élements du profil */ - for (j=0; j < ngauss; j++) { - index = i*ngauss+j + (dim-firstdim)*(psize*ngauss); - pflmem[index] = (pfltab[i]-1)*ngauss*nbdim + j*nbdim+dim; - pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j; - } - } - - if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pflmem ) ) <0) - return -1; - - if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pfldsk ) ) <0) - return -1; - - break; - - case MED_COMPACT : - - /* Creation d'un data space mémoire de dimension 1, de la longeur du profil */ - /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose */ - /* que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */ - - if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0) - return -1; - - for (dim=firstdim; dim < lastdim; dim++) { - - for (i=0; i < psize; i++) /* i balaye les élements du profil */ - for (j=0; j < ngauss; j++) { - index = i*ngauss+j + (dim-firstdim)*(psize*ngauss); - pflmem[index] = i*ngauss*nbdim + j*nbdim+dim; - pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j; - } - } - - if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pflmem ) ) <0) - return -1; - - if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pfldsk ) ) <0) - return -1; - - break; - - default : - return -1; - } - - if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0) - return -1; - - free(pflmem); - free(pfldsk); - } - - - break; - - case MED_NO_INTERLACE : - - /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/ - - count[0] = (*size)/nbdim; - - if ( psize == MED_NOPF ) { - - if ( fixdim != MED_ALL) - start_data[0] = (fixdim-1)*count[0]; - else { - count[0] = *size; - start_data[0] = 0; - }; - - if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL, - count, NULL)) <0) - return -1; - - if ((ret = H5Dwrite(dataset,type_hdf,dataspace,dataspace, - H5P_DEFAULT, val)) < 0) - return -1; - - } else { - - if ( fixdim != MED_ALL) - { - firstdim = fixdim-1; - lastdim = fixdim; - dimutil = 1; - } else { - firstdim = 0; - lastdim = nbdim; - dimutil = nbdim; - } - - pflsize [0] = psize*ngauss*nbdim; - pcount [0] = psize*ngauss*dimutil; /* nom pas très coherent avec count !!! A revoir */ - pfldsk = (med_ssize *) malloc(sizeof(med_ssize)*pcount[0]); - - switch(pflmod) - { /*switch plfmod pour NO_INTERLACE */ - case MED_GLOBALE : - - for (dim=firstdim; dim < lastdim; dim++) { - - for (i=0; i < psize; i++) /* i balaye le nbre d'élements du profil */ - for (j=0; j < ngauss; j++) { - index = i*ngauss+j + (dim-firstdim)*(psize*ngauss); - pfldsk[index] = dim*count[0]+(pfltab[i]-1)*ngauss+j; - } - } - - if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], (const hssize_t **) pfldsk ) ) <0) - return -1; - - if ((ret = H5Dwrite(dataset,type_hdf,dataspace,dataspace,H5P_DEFAULT, val)) < 0) - return -1; - - break; - - case MED_COMPACT : - - /* Creation d'un data space mémoire de dimension 1, de la longeur du profil */ - /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose */ - /* que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */ - - if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0) - return -1; - - pflmem = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]); - - /* Le profil COMPACT est contigüe, mais il est possible que l'on selectionne uniquemenent une dimension*/ - - for (dim=firstdim; dim < lastdim; dim++) { - - for (i=0; i < psize; i++) /* i balaye le nbre d'élements du profil */ - for (j=0; j < ngauss; j++) { - index = i*ngauss+j + (dim-firstdim)*(psize*ngauss); - pflmem[index] = dim*(psize*ngauss) + (pfltab[i]-1)*ngauss+j; - pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j; - } - } - - if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET,pcount[0], (const hssize_t **) pflmem ) ) <0) - return -1; - - if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], (const hssize_t **) pfldsk ) ) <0) - return -1; - - if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0) - return -1; - - free(pflmem); - - break; - - default : - return -1; - - } - - free(pfldsk); - - }; - - break; - - default : - return -1; - } - - - if (memspace) - if ((ret = H5Sclose(memspace)) < 0) - return -1; - - if ((ret = H5Sclose(dataspace)) < 0) - return -1; - - if ((ret = H5Dclose(dataset)) < 0) - return -1; - -#if defined(PCLINUX) - if (type == MED_INT32) - if ((H5Tconvert(H5T_STD_I32BE,H5T_NATIVE_INT,(hsize_t)*size,(void *)val,NULL,NULL)) < 0) - return -1; -#endif - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDdatasetNumLire.cxx b/src/MEDWrapper/V2_1/MEDdatasetNumLire.cxx deleted file mode 100644 index 20a2d2a1d..000000000 --- a/src/MEDWrapper/V2_1/MEDdatasetNumLire.cxx +++ /dev/null @@ -1,369 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" -#include - -/* - * - Nom de la fonction : _MEDdatasetNumLire - * - Description : lecture d'un dataset tableau numerique - * - Parametres : - * - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut - * - nom (IN) : le nom du dataset - * - type (IN) : type numerique MED - * - interlace (IN) : Choix du type d'entrelacement demandé par l'appelant { MED_FULL_INTERLACE(x1,y1,z1,x2,...)) , MED_NO_INTERLACE(x1,x2,y1,y2,z1,z2) } - * - nbdim (IN) : Dimension des éléments - * - fixdim (IN) : MED_ALL ou n° de la dimension a enregistrer à partir de 1..oo - * - psize (IN) : Taille du profil à utiliser, MED_NOPF si pas de profil - * - pfltab (IN) : Tableau contenant les n° déléments à traiter (1....oo) - * - pflmod (IN) : PARAMETRE A AJOUTER : Indique comment lire les informations en mémoire { MED_COMPACT, MED_GLOBALE }. - * - ngauss (IN) : Nombre de points de GAUSS par élément - * - val (OUT) : valeurs du tableau - * - Resultat : 0 en cas de succes, -1 sinon - * Equivalent à l'ancienne routine si .....,MED_NO_INTERLACE,1,MED_ALL,MED_NOPF,0,1 (peu importe),.... - */ - -namespace med_2_1{ - -med_err -_MEDdatasetNumLire(med_idt pere,char *nom,med_type_champ type, - med_mode_switch interlace, med_size nbdim, med_size fixdim, - med_size psize, med_ssize * pfltab, med_int ngauss, - unsigned char *val) -{ - med_idt dataset, dataspace = 0, memspace = 0; - med_ssize start_mem[1],start_data[1],*pflmem=0,*pfldsk=0; - med_size stride[1],count[1],pcount[1],size[1],pflsize[1]; - med_err ret; - int i,j,index,type_hdf; - hid_t datatype; - size_t typesize; - int dim, firstdim, dimutil, lastdim; - med_mode_profil pflmod; - - /* Verify fixdim is between [0, nbdim] ( 0 is MED_ALL ) */ - if ( ( fixdim < 0 ) || ( fixdim > nbdim ) ) - return -1; - - /* block pflmod to MED_COMPACT (until med2.2) */ - pflmod = MED_COMPACT; - - switch(type) - { - case MED_REEL64 : - /* 1) IA32 is LE but due to an (?HDF convertion BUG?) when using H5T_NATIVE_DOUBLE/MED_REEL64? under PCLINUX - the file read under SGI is incorrect - 2) Compaq OSF/1 is LE, since we force SGI64,SUN4SOL2,HP to write double in LE even if they are BE, mips OSF/1 must be BE - REM : Be careful of compatibility between MED files when changing this (med2.2) */ -#if defined(PCLINUX) || defined(OSF1) - type_hdf = H5T_IEEE_F64BE; -#else - type_hdf = H5T_IEEE_F64LE; -#endif - break; - - case MED_INT32 : - type_hdf = H5T_NATIVE_INT; - break; - - case MED_INT64 : - type_hdf = H5T_NATIVE_LONG; - break; - - default : - return -1; - } - - /* Ouverture du Dataset à lire */ - if ((dataset = H5Dopen(pere,nom)) < 0) - return -1; - - /* Interrogation de la taille du dataset */ - if ( (datatype = H5Dget_type(dataset )) < 0) return -1; - if ( (typesize = H5Tget_size(datatype)) < 0) return -1; - size[0] = H5Dget_storage_size(dataset) / typesize; - if ( H5Tclose(datatype) < 0) return -1; - - /* Create dataspace */ - if ((dataspace = H5Screate_simple(1,size,NULL)) < 0) - return -1; - - switch(interlace) - { - case MED_FULL_INTERLACE : - - /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/ - if ( fixdim != MED_ALL) - { - firstdim = fixdim-1; - lastdim = fixdim; - dimutil = 1; - } else { - firstdim = 0; - lastdim = nbdim; - dimutil = nbdim; - } - - count [0] = (*size)/(nbdim); - - - /*rem: Pas de vérification de l'assertion (*size)=n*nbdim */ - if ( psize == MED_NOPF ) { - - /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */ - if ( (memspace = H5Screate_simple (1, size, NULL)) <0) - return -1; - - stride[0] = nbdim; - - for (dim=firstdim; dim < lastdim; dim++) { - - start_mem[0] = dim; - if ( (ret = H5Sselect_hyperslab (memspace, H5S_SELECT_SET, start_mem, stride, - count, NULL)) <0) - return -1; - - start_data[0] = dim*count[0]; - if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL, - count, NULL)) <0) - return -1; - - if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace, - H5P_DEFAULT, val)) < 0) - return -1; - } - - } else { - - pflsize [0] = psize*ngauss*nbdim; - pcount [0] = psize*ngauss*dimutil; - pflmem = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]); - pfldsk = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]); - - switch(pflmod) - { /* switch pflmod pour FULL_INTERLACE*/ - case MED_GLOBALE : - - /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */ - if ( (memspace = H5Screate_simple (1, size, NULL)) <0) - return -1; - - for (dim=firstdim; dim < lastdim; dim++) { - - for (i=0; i < psize; i++) /* i balaye les élements du profil */ - for (j=0; j < ngauss; j++) { - index = i*ngauss+j + (dim-firstdim)*(psize*ngauss); - pflmem[index] = (pfltab[i]-1)*ngauss*nbdim + j*nbdim+dim; - pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j; - } - } - - if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], (const hssize_t **) pflmem ) ) <0) - return -1; - - if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pfldsk ) ) <0) - return -1; - - break; - - case MED_COMPACT : - - /* Creation d'un data space mémoire de dimension 1, de la longeur du profil */ - /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose */ - /* que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */ - - if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0) - return -1; - - for (dim=firstdim; dim < lastdim; dim++) { - - for (i=0; i < psize; i++) /* i balaye les élements du profil */ - for (j=0; j < ngauss; j++) { - index = i*ngauss+j + (dim-firstdim)*(psize*ngauss); - pflmem[index] = i*ngauss*nbdim + j*nbdim+dim; - pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j; - } - } - - if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], (const hssize_t **) pflmem ) ) <0) - return -1; - - if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], (const hssize_t **) pfldsk ) ) <0) - return -1; - - break; - - default : - return -1; - } - - if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0) - return -1; - - free(pflmem); - free(pfldsk); - } - - break; - - case MED_NO_INTERLACE : - - /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/ - - count[0] = (*size)/nbdim; - - if ( psize == MED_NOPF ) { - - if ( fixdim != MED_ALL) - start_data[0] = (fixdim-1)*count[0]; - else { - count[0] = *size; - start_data[0] = 0; - }; - - if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL, - count, NULL)) <0) - return -1; - - if ((ret = H5Dread(dataset,type_hdf,dataspace,dataspace, - H5P_DEFAULT, val)) < 0) - return -1; - - } else { - - if ( fixdim != MED_ALL) - { - firstdim = fixdim-1; - lastdim = fixdim; - dimutil = 1; - } else { - firstdim = 0; - lastdim = nbdim; - dimutil = nbdim; - } - - pflsize [0] = psize*ngauss*nbdim; - pcount [0] = psize*ngauss*dimutil; /* nom pas très coherent avec count !!! A revoir */ - pfldsk = (med_ssize *) malloc(sizeof(med_ssize)*pcount[0]); - - switch(pflmod) - { /*switch plfmod pour NO_INTERLACE */ - case MED_GLOBALE : - - for (dim=firstdim; dim < lastdim; dim++) { - - for (i=0; i < psize; i++) /* i balaye le nbre d'élements du profil */ - for (j=0; j < ngauss; j++) { - index = i*ngauss+j + (dim-firstdim)*(psize*ngauss); - pfldsk[index] = dim*count[0]+(pfltab[i]-1)*ngauss+j; - } - } - - if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], (const hssize_t **) pfldsk ) ) <0) - return -1; - - if ((ret = H5Dread(dataset,type_hdf,dataspace,dataspace,H5P_DEFAULT, val)) < 0) - return -1; - - break; - - case MED_COMPACT : - - /* Creation d'un data space mémoire de dimension 1, de la longeur du profil */ - /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose */ - /* que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */ - - if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0) - return -1; - - pflmem = (med_ssize *) malloc (sizeof(med_ssize)*pcount[0]); - - /* Le profil COMPACT est contigüe, mais il est possible que l'on selectionne uniquemenent une dimension*/ - - for (dim=firstdim; dim < lastdim; dim++) { - - for (i=0; i < psize; i++) /* i balaye le nbre d'élements du profil */ - for (j=0; j < ngauss; j++) { - index = i*ngauss+j + (dim-firstdim)*(psize*ngauss); - pflmem[index] = dim*(psize*ngauss) + (pfltab[i]-1)*ngauss+j; - pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j; - } - } - - if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], (const hssize_t **) pflmem ) ) <0) - return -1; - - if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], (const hssize_t **) pfldsk ) ) <0) - return -1; - - if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0) - return -1; - - break; - - default : - return -1; - - } - - free(pfldsk); - - }; - - break; - - default : - return -1; - } - - - - if (memspace) - if ((ret = H5Sclose(memspace)) < 0) - return -1; - - if ((ret = H5Sclose(dataspace)) < 0) - return -1; - - if ((ret = H5Dclose(dataset)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDdatasetOuvrir.cxx b/src/MEDWrapper/V2_1/MEDdatasetOuvrir.cxx deleted file mode 100644 index 3c37511e0..000000000 --- a/src/MEDWrapper/V2_1/MEDdatasetOuvrir.cxx +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDdatasetOuvrir - * - Description : ouverture d'un objet HDF dataset - * - Parametres : - * - pid (IN) : l'ID de l'objet HDF pere - * - nom (IN) : le nom du dataset - * - Resultat : ID du dataset en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_idt -_MEDdatasetOuvrir(med_idt pid,char *nom) -{ - med_idt id; - - if ((id = H5Dopen(pid,nom)) < 0) - return -1; - - return id; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDdatasetStringEcrire.cxx b/src/MEDWrapper/V2_1/MEDdatasetStringEcrire.cxx deleted file mode 100644 index 02de46980..000000000 --- a/src/MEDWrapper/V2_1/MEDdatasetStringEcrire.cxx +++ /dev/null @@ -1,106 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDdatasetStringEcrire - * - Description : ecriture d'un dataset tableau de caracteres - * - Parametres : - * - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut - * - nom (IN) : le nom de l'attribut - * - dimd (IN) : profil du tableau - * - val (IN) : valeurs du tableau - * - mode (IN) : mode d'ecriture MED - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDdatasetStringEcrire(med_idt pere,char *nom,med_size *dimd, - char *val, med_mode_acces mode) -{ - med_idt dataset; - med_idt datatype = 0; - med_idt dataspace = 0; - med_err ret; - - if ((dataset = H5Dopen(pere,nom)) < 0) - { - if ((dataspace = H5Screate_simple(1,dimd,NULL)) < 0) - return -1; - if((datatype = H5Tcopy(H5T_C_S1)) < 0) - return -1; - if((ret = H5Tset_size(datatype,1)) < 0) - return -1; - if ((dataset = H5Dcreate(pere,nom,datatype,dataspace, - H5P_DEFAULT)) < 0) - return -1; - } - else - if (mode != MED_REMP) - { - H5Dclose(dataset); - return -1; - } - else - { - if ((dataspace = H5Screate_simple(1,dimd,NULL)) < 0) - return -1; - if((datatype = H5Tcopy(H5T_C_S1)) < 0) - return -1; - if((ret = H5Tset_size(datatype,1)) < 0) - return -1; - } - if ((ret = H5Dwrite(dataset,datatype,H5S_ALL,H5S_ALL, - H5P_DEFAULT, val)) < 0) - return -1; - if (dataspace) - if((ret = H5Sclose(dataspace)) < 0) - return -1; - if (datatype) - if ((ret = H5Tclose(datatype)) < 0) - return -1; - if ((ret = H5Dclose(dataset)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDdatasetStringLire.cxx b/src/MEDWrapper/V2_1/MEDdatasetStringLire.cxx deleted file mode 100644 index a88e2bce5..000000000 --- a/src/MEDWrapper/V2_1/MEDdatasetStringLire.cxx +++ /dev/null @@ -1,75 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDdatasetStringLire - * - Description : lecture d'un dataset tableau de caracteres - * - Parametres : - * - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut - * - nom (IN) : le nom de l'attribut - * - val (IN) : valeurs du tableau - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDdatasetStringLire(med_idt pere,char *nom,char *val) -{ - med_idt dataset,datatype; - med_err ret; - - if ((dataset = H5Dopen(pere,nom)) < 0) - return -1; - if ((datatype = H5Tcopy(H5T_C_S1)) < 0) - return -1; - if ((ret = H5Tset_size(datatype,1)) < 0) - return -1; - if ((ret = H5Dread(dataset,datatype,H5S_ALL,H5S_ALL,H5P_DEFAULT,val)) < 0) - return -1; - if ((ret = H5Tclose(datatype)) < 0) - return -1; - if ((ret = H5Dclose(dataset)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDdimLire.cxx b/src/MEDWrapper/V2_1/MEDdimLire.cxx deleted file mode 100644 index caad4c5c1..000000000 --- a/src/MEDWrapper/V2_1/MEDdimLire.cxx +++ /dev/null @@ -1,81 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ -med_int -MEDdimLire(med_idt fid, char *maillage) -{ - med_idt maaid; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - med_int dim; - - /* - * On inhibe le gestionnaire d'erreur - */ - _MEDmodeErreurVerrouiller(); - - /* - * On regarde si le groupe existe => erreur si non - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maillage); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * On va lire l'attribut dimension - */ - if ((ret = _MEDattrEntierLire(maaid,MED_NOM_DIM,&dim)) < 0) - return -1; - - /* - * Fermetures des objets HDF - */ - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return dim; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDelementsEcr.cxx b/src/MEDWrapper/V2_1/MEDelementsEcr.cxx deleted file mode 100644 index ce57c5a85..000000000 --- a/src/MEDWrapper/V2_1/MEDelementsEcr.cxx +++ /dev/null @@ -1,73 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" - -namespace med_2_1{ - -med_err -MEDelementsEcr(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch, - char *nom,med_booleen inom,med_int *num,med_booleen inum, - med_int *fam,med_int nele,med_entite_maillage typ_ent, - med_geometrie_element typ_geo,med_connectivite typ_conn, - med_mode_acces mode) -{ - med_err ret; - - /* Ecriture de la connectivite */ - if ((ret = MEDconnEcr(fid,maa,mdim,connectivite,mode_switch,nele,mode,typ_ent,typ_geo, - typ_conn)) < 0) - return -1; - - /* Ecriture des noms */ - if (inom == MED_VRAI) - if ((ret = MEDnomEcr(fid,maa,nom,nele,mode,typ_ent,typ_geo)) < 0) - return -1; - - /* Ecriture des numeros */ - if (inum == MED_VRAI) - if ((ret = MEDnumEcr(fid,maa,num,nele,mode,typ_ent,typ_geo)) < 0) - return -1; - - /* Ecriture des numeros de familles */ - if ((ret = MEDfamEcr(fid,maa,fam,nele,mode,typ_ent,typ_geo)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDelementsLire.cxx b/src/MEDWrapper/V2_1/MEDelementsLire.cxx deleted file mode 100644 index 88716ffe9..000000000 --- a/src/MEDWrapper/V2_1/MEDelementsLire.cxx +++ /dev/null @@ -1,74 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" - -namespace med_2_1{ - -med_err -MEDelementsLire(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch, - char *nom,med_booleen *inom,med_int *num,med_booleen *inum, - med_int *fam,med_int nele,med_entite_maillage typ_ent, - med_geometrie_element typ_geo,med_connectivite typ_conn) -{ - med_err ret; - - /* Lecure de la connectivite */ - if ((ret = MEDconnLire(fid,maa,mdim,connectivite,mode_switch,0,MED_NOPF, - typ_ent,typ_geo,typ_conn)) < 0) - return -1; - - /* Lecture des noms */ - if ((ret = MEDnomLire(fid,maa,nom,nele,typ_ent,typ_geo)) < 0) - *inom = MED_FAUX; - else - *inom = MED_VRAI; - - /* Lecture des numeros */ - if ((ret = MEDnumLire(fid,maa,num,nele,typ_ent,typ_geo)) < 0) - *inum = MED_FAUX; - else - *inum = MED_VRAI; - - /* Lecture des numeros de familles */ - if ((ret = MEDfamLire(fid,maa,fam,nele,typ_ent,typ_geo)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDequivCr.cxx b/src/MEDWrapper/V2_1/MEDequivCr.cxx deleted file mode 100644 index 8579cb6b2..000000000 --- a/src/MEDWrapper/V2_1/MEDequivCr.cxx +++ /dev/null @@ -1,97 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDequivCr(med_idt fid,char *maa, char *eq, char *desc) -{ - med_idt root,eqid; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+MED_TAILLE_NOM+1]; - char tmp[MED_TAILLE_EQS+1]; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le Data Group "EQS" n'existe pas, on le cree - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - strncpy(tmp,MED_EQS,MED_TAILLE_EQS-1); - tmp[MED_TAILLE_EQS-1] = '\0'; - strcat(chemin,tmp); - if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0) - if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) - return -1; - - /* - * Si une equivalence du meme nom existe => erreur - * Sinon on la cree - */ - if ((eqid = _MEDdatagroupOuvrir(root,eq)) >= 0) - return -1; - if ((eqid = _MEDdatagroupCreer(root,eq)) < 0) - return -1; - - /* - * L'attribut "DES" - */ - if ((ret = _MEDattrStringEcrire(eqid,MED_NOM_DES,MED_TAILLE_DESC,desc,MED_REMP)) < 0) - return -1; - - /* - * On ferme tout - */ - if ((ret = _MEDdatagroupFermer(eqid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(root)) < 0) - return -1; - - return 0 ; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDequivEcr.cxx b/src/MEDWrapper/V2_1/MEDequivEcr.cxx deleted file mode 100644 index bcbaa2cdd..000000000 --- a/src/MEDWrapper/V2_1/MEDequivEcr.cxx +++ /dev/null @@ -1,130 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -extern int mode_interlace; - -namespace med_2_1{ - -med_err -MEDequivEcr(med_idt fid, char *maa, char *eq, med_int *corr, med_int n, - med_mode_acces mode, med_entite_maillage typ_ent, med_geometrie_element typ_geo) -{ - med_idt eqid, datagroup; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1]; - char nomdatagroup[MED_TAILLE_NOM+1]; - char tmp[MED_TAILLE_NOM_ENTITE+1]; - med_size dimd[1]; - - if (typ_geo == MED_TETRA4 || typ_geo == MED_TETRA10 || - typ_geo == MED_HEXA8 || typ_geo == MED_HEXA20 || - typ_geo == MED_PENTA6 || typ_geo == MED_PENTA15 || - typ_geo == MED_PYRA5 || typ_geo == MED_PYRA13) - return -1; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le Data Group de "eq" n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - strcat(chemin,MED_EQS); - strcat(chemin,eq); - if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * Ecriture de l'equivalence - */ - if ((ret = _MEDnomEntite(nomdatagroup,typ_ent)) < 0) - return -1; - if ((typ_ent != MED_NOEUD)) - { - if ((ret = _MEDnomGeometrie(tmp,typ_geo)) < 0) - return -1; - strcat(nomdatagroup,"."); - strcat(nomdatagroup,tmp); - } - datagroup = 0; - if (((datagroup = _MEDdatagroupOuvrir(eqid,nomdatagroup)) > 0) && - (mode != MED_REMP)) - return -1; - else - if (datagroup > 0) - _MEDdatagroupFermer(datagroup); - - /* EF : verifier que çà marche si le data groupe existe déjà */ - if ((datagroup = _MEDdatagroupCreer(eqid,nomdatagroup)) < 0) - return -1; - - if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n,mode)) < 0) - return -1; - - dimd[0] = 2*n; - -#if defined(IRIX64)||defined(OSF1) - if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_COR,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, - (unsigned char*) corr,mode)) < 0) - return -1; -#else - if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_COR,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, - (unsigned char*) corr,mode)) < 0) - return -1; -#endif - - /* - * On ferme tout - */ - if ((ret = _MEDdatagroupFermer(datagroup)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(eqid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDequivInfo.cxx b/src/MEDWrapper/V2_1/MEDequivInfo.cxx deleted file mode 100644 index abb213140..000000000 --- a/src/MEDWrapper/V2_1/MEDequivInfo.cxx +++ /dev/null @@ -1,92 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDequivInfo(int fid, char *maa, int ind, char *eq, char *des) -{ - med_idt eqid; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1]; - int num; - int idx; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * On recupere le nom de l'equivalence - */ - num = ind - 1; - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - strcat(chemin,MED_EQS); - if ((idx = _MEDobjetIdentifier(fid,chemin,num,eq)) < 0) - return -1; - - /* - * Si le Data Group eq n'existe pas => erreur - */ - strcat(chemin,eq); - if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * L'attribut "DES" - */ - if ((ret = _MEDattrStringLire(eqid,MED_NOM_DES,MED_TAILLE_DESC,des)) < 0) - return -1; - - /* - * On ferme tout - */ - if ((ret = _MEDdatagroupFermer(eqid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDequivLire.cxx b/src/MEDWrapper/V2_1/MEDequivLire.cxx deleted file mode 100644 index 3ae9b4fab..000000000 --- a/src/MEDWrapper/V2_1/MEDequivLire.cxx +++ /dev/null @@ -1,118 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -extern int mode_interlace; - -namespace med_2_1{ - -med_err -MEDequivLire(med_idt fid, char *maa, char *eq, med_int *corr, med_int n, - med_entite_maillage typ_ent,med_geometrie_element typ_geo) -{ - med_idt eqid, datagroup; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1]; - char nomdatagroup[MED_TAILLE_NOM+1]; - char tmp[MED_TAILLE_NOM_ENTITE+1]; - - if (typ_geo == MED_TETRA4 || typ_geo == MED_TETRA10 || - typ_geo == MED_HEXA8 || typ_geo == MED_HEXA20 || - typ_geo == MED_PENTA6 || typ_geo == MED_PENTA15 || - typ_geo == MED_PYRA5 || typ_geo == MED_PYRA13) - return -1; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le Data Group de "eq" n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - strcat(chemin,MED_EQS); - strcat(chemin,eq); - if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * Lecture de l'equivalence - */ - if ((ret = _MEDnomEntite(nomdatagroup,typ_ent)) < 0) - return -1; - if ((typ_ent != MED_NOEUD)) - { - if ((ret = _MEDnomGeometrie(tmp,typ_geo)) < 0) - return -1; - strcat(nomdatagroup,"."); - strcat(nomdatagroup,tmp); - } - if ((datagroup = _MEDdatagroupOuvrir(eqid,nomdatagroup)) < 0) - return -1; -#if defined(IRIX64)||defined(OSF1) - if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_COR,MED_INT64, - MED_NO_INTERLACE,1,MED_ALL, - MED_NOPF,0,MED_NOPG, - (unsigned char *) corr)) < 0) - return -1; -#else - if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_COR,MED_INT32, - MED_NO_INTERLACE,1,MED_ALL, - MED_NOPF,0,MED_NOPG, - (unsigned char *) corr)) < 0) - return -1; -#endif - - /* - * On ferme tout - */ - if ((ret = _MEDdatagroupFermer(datagroup)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(eqid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDfam2groA.cxx b/src/MEDWrapper/V2_1/MEDfam2groA.cxx deleted file mode 100644 index 6be083267..000000000 --- a/src/MEDWrapper/V2_1/MEDfam2groA.cxx +++ /dev/null @@ -1,227 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include -#include -#include -#include "med.hxx" - - -/*********************************************************************** - * FONCTION MEDfam2groA - * - * - DESCRIPTION : 1ere etape dans la conversion des familles de groupes - * MED en goupes de noeuds et d'elements. - * Calcul des tailles des tableaux a allouer pour stocker les - * groupes que l'on veut creer. - * Les parametres renvoyes sont : - * 1 - le nombre de groupes de noeuds a creer (ngn) - * 2 - le nombre de groupes d'elements (nge) - * 3 - le nombre total de noeuds composant l'ensemble des groupes - * de noeuds (nindn) - * 4 - le nombre total d'elements composant l'ensemble des groupes - * d'elements (ninde) - * Ces parametres doivent permettre de creer les tables suivantes : - * 1 - une table de taille (nindn) contenant pour chaque groupe - * de noeuds la liste des noeuds le composant. Cette table - * sera indexee par une table de taille (ngn) qui contiendra - * pour chaque noeud un numero d'indice. Une table de taille - * (ngn) qui contiendra la liste des noms des differents - * groupes de noeuds. - * 2 - idem pour les elements - * Le remplissage de ces tables est realise par la fonction - * MEDfam2groB(). - * - * - PARAMETRES : - * NOM .E/S. TYPE . DESCRIPTION - * ------------------------------------------------------------------- - * nfam .E . med_int . nombre de familles - * numfam .E . med_int*. table des numeros de familles - * numfamnoe .E . med_int*. table des numeros de familles - * . . . des noeuds - * nnoeuds .E . med_int . nombre de noeuds - * numfamele .E . med_int*. table des numeros de familles - * . . . des elements - * nelememts .E . . nombre total d'elements - * grofam .E . char* . liste des groupes de familles - * indfamgro .E . int* . liste des indices des groupes - * . . . de familles dans grofam - * ngn . S. med_int*. nombre de groupes de noeuds a - * . . creer - * nge . S. med_int*. nombre de groupes d'elements a - * . . creer - * nindn . S. med_int*. taille de la table - * . . des groupes de noeuds a creer - * ninde . S. med_int*. taille de la table - * . . des groupes d'elements - * - * - RESULTAT : 0 si succes et -1 sinon - * - ***********************************************************************/ - -namespace med_2_1{ - -med_err -MEDfam2groA (med_int nfam,med_int *numfam,med_int *numfamnoe, - med_int nnoeuds,med_int *numfamele,med_int nelements, - char *grofam,int *indfamgro, - med_int *ngn,med_int *nge,med_int *nindn,med_int *ninde) -{ - int i,j,k; - char groupe[MED_TAILLE_LNOM]; - char *nomgronoe,*nomgroele,*tmp; - med_int numc; - int nnoe = 0,nele = 0; - int flag = 0; - - *ngn = 0; - *nge = 0; - *nindn = 0; - *ninde = 0; - - tmp = NULL; - nomgronoe = NULL; - nomgroele = NULL; - - /* Pour chaque famille, on regarde s'il y a de nouveaux groupes - de noeuds ou d'elements a creer. Pour chaque nouveau groupe, - on compte le nombre de noeuds ou d'elements qui devront lui etre - rataches */ - for (i=1;i<=nfam;i++) - if ((*(indfamgro+i)-*(indfamgro+i-1))/MED_TAILLE_LNOM > 0) - { - /* on releve le numero de la famille courante */ - numc = *(numfam+i-1); - nnoe = 0; - nele = 0; - /* si c'est une famille de noeuds, on compte le nombre de - noeuds qui y sont rattaches */ - if (numc > 0) - for (j=0;j 0) - { - *nindn = *nindn+nnoe; - if (*ngn == 0) - { - *ngn = 1; - if ((nomgronoe=(char*)malloc(sizeof(char)*MED_TAILLE_LNOM)) - == NULL) - return -1; - strncpy(nomgronoe,groupe,MED_TAILLE_LNOM); - } - else - { - flag = 0; - for (k=0;k<(*ngn);k++) - if (strncmp(groupe,nomgronoe+k*MED_TAILLE_LNOM, - MED_TAILLE_LNOM) == 0) - flag = 1; - if (flag == 0) - { - *ngn = *ngn + 1; - if ((tmp=(char*)malloc(sizeof(char)* - MED_TAILLE_LNOM**ngn)) == NULL) - return -1; - strncpy(tmp,nomgronoe,MED_TAILLE_LNOM*(*ngn-1)); - strncpy(tmp+MED_TAILLE_LNOM*(*ngn-1),groupe, - MED_TAILLE_LNOM); - free(nomgronoe); - nomgronoe = tmp; - } - } - } - if (numc < 0) - { - *ninde = *ninde+nele; - if (*nge == 0) - { - *nge = 1; - if ((nomgroele=(char *)malloc(sizeof(char)* - MED_TAILLE_LNOM)) == NULL) - return -1; - strncpy(nomgroele,groupe,MED_TAILLE_LNOM); - } - else - { - flag = 0; - for (k=0;k<(*nge);k++) - if (strncmp(groupe,nomgroele+k*MED_TAILLE_LNOM, - MED_TAILLE_LNOM) == 0) - flag = 1; - if (flag == 0) - { - *nge = *nge + 1; - if ((tmp = (char*) malloc(sizeof(char)*MED_TAILLE_LNOM* - *nge)) == NULL) - return -1; - strncpy(tmp,nomgroele,MED_TAILLE_LNOM*(*nge-1)); - strncpy(tmp+MED_TAILLE_LNOM*(*nge-1), groupe, - MED_TAILLE_LNOM); - free(nomgroele); - nomgroele = tmp; - } - } - } - } - } - - /* nettoyage memoire */ - free(nomgronoe); - free(nomgroele); - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDfam2groB.cxx b/src/MEDWrapper/V2_1/MEDfam2groB.cxx deleted file mode 100644 index e7cf5b2d2..000000000 --- a/src/MEDWrapper/V2_1/MEDfam2groB.cxx +++ /dev/null @@ -1,264 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - - -#include -#include -#include -#include "med.hxx" - -/*********************************************************************** - * FONCTION MEDfam2groB - * - * - DESCRIPTION : 2e etape dans la conversion des familles MED en - * groupes de noeuds et d'elements. Les tables allouees a partir - * des parametres calcules par MEDfam2groA() sont passees en argument - * a MEDfam2groB et remplies par cette derniere fonction. - * Il s'agit de : - * 1 - la table des noms de groupes de noeuds, chaque nom ayant - * une taille de MED_TAILLE_LNOM - * 2 - la table des noms des groupes d'elements - * 3 - la table des groupes de noeuds -i.e. pour chaque groupe - * la liste des numeros des noeuds qui le composent - * 4 - la table d'indexation de la table des groupes de noeuds - * 5 - la table des groupes d'elements - * 6 - la table d'indexation de la table des groupes d'elements - * - * - PARAMETRES : - * NOM .E/S. TYPE . DESCRIPTION - * ------------------------------------------------------------------- - * nfam .E . med_int . nombre de familles - * numfam .E . med_int*. table des numeros de familles - * numfamnoe .E . med_int*. table des numeros de familles - * . . . des noeuds - * nnoeuds .E . med_int . nombre de noeuds - * numfamele .E . med_int*. table des numeros de familles - * . . . des elements - * nelememts .E . med_int . nombre total d'elements - * grofam .E . char* . liste des groupes de familles - * indfamgro .E . int* . liste des indices des groupes - * . . . de familles dans indfamgro - * numnoeuds .E . med_int*. numeros des noeuds - * numele .E . med_int*. numeros des elements - * ngn .E . med_int . nombre de groupes de noeuds - * nge .E . med_int . nombre de groupes d'elements - * nindn .E . med_int . nombre d'indices dans la table - * . . des groupes de noeuds a creer - * ninde .E . med_int . nombre d'indices dans la table - * . . des groupes d'elements - * nomgronoe . S. char* . noms des groupes de noeuds - * nomgroele . S. char* . noms des groupes d'elements - * indgronoe . S. int* . indices des groupes de noeuds - * indgroele . S. int* . indices des groupes d'elements - * tabgronoe . S. med_int*. table des groupes de noeuds - * tabgroele . S. med_int*. table des groupes d'elements - * - * - RESULTAT : 0 - * - ***********************************************************************/ - -namespace med_2_1{ - -med_err -MEDfam2groB(med_int nfam,med_int *numfam,med_int *numfamnoe, - med_int nnoeuds,med_int *numfamele,med_int nelements, - char *grofam,int *indfamgro,med_int *numnoeuds, - med_int *numele,med_int ngn,med_int nge,med_int nindn, - med_int ninde,char *nomgronoe,char *nomgroele, - int *indgronoe,int *indgroele, - med_int *tabgronoe,med_int *tabgroele) -{ - int i,j,k; - char groupe[MED_TAILLE_LNOM]; - med_int numc; - int nnoe = 0, nele = 0; - int flag = 0; - int nn = 0, ne = 0; - int pos, cpt; - - /* initialisations */ - for (i=0;i<=ngn;i++) - *(indgronoe+i) = 0; - for (i=0;i<=nge;i++) - *(indgroele+i) = 0; - - /* 1ere passe : on passe en revue toutes les familles : - 1 - on etablit dans (nomgronoe) et dans (nomgroele) les listes - des noms de groupes de noeuds et d'elements - 2 - on place dans les tables d'index (indgronoe) et (indgroele) - le nombre de noeuds ou d'elements que chaque groupe se verra - attribuer */ - for (i=1;i<=nfam;i++) - { - numc = *(numfam+i-1); - nnoe = 0; - nele = 0; - if (numc > 0) - for (j=0;j 0) - { - if (nn == 0) - { - strncpy(nomgronoe,groupe,MED_TAILLE_LNOM); - nn = 1; - pos = 1; - } - else - { - flag = 0; - for (k=0; k 0) - { - flag = 0; - for (k=0;k<(*(indfamgro+j)-*(indfamgro+j-1))/MED_TAILLE_LNOM; - k++) - if (! strncmp(groupe, - grofam+*(indfamgro+j-1)+k*MED_TAILLE_LNOM, - MED_TAILLE_LNOM)) - flag = 1; - if (flag == 1) - for (k=0;k -#include - -namespace med_2_1{ - -med_err -MEDfamCr(med_idt fid,char* maa,char *famille,med_int numero, - med_int *attr_ident, med_int *attr_val, char *attr_desc, - med_int n_attr,char *groupe, med_int n_groupe) -{ - med_idt root, datagroup, famid; - med_err ret; - med_size dimd[1]; - char chemin[MED_TAILLE_MAA+MED_TAILLE_FAS+MED_TAILLE_NOM+1]; - char tmp[MED_TAILLE_FAS+1]; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le Data Group FAS n'existe pas, on le cree - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - strncpy(tmp,MED_FAS,MED_TAILLE_FAS-1); - tmp[MED_TAILLE_FAS-1] = '\0'; - strcat(chemin,tmp); - if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0) - if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) - return -1; - - /* - * Si le Data Group de meme nom que famille existe => erreur - * Sinon on le cree - */ - if ((famid = _MEDdatagroupOuvrir(root,famille)) >= 0) - return -1; - if ((famid = _MEDdatagroupCreer(root,famille)) < 0) - return -1; - - /* - * L'attribut NUM - */ - if ((ret = _MEDattrEntierEcrire(famid,MED_NOM_NUM,&numero,MED_REMP)) < 0) - return -1; - - /* - * Le Data Group "GRO" - */ - if (n_groupe > 0) - { - /* - * On cree le Data Group - */ - if ((datagroup = _MEDdatagroupCreer(famid,MED_NOM_GRO)) < 0) - return -1; - - /* - * L'attribut "NBR" - */ - if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n_groupe,MED_REMP)) < 0) - return -1; - - /* - * Data Set des noms des groupes "NOM" - */ - dimd[0] = n_groupe*MED_TAILLE_LNOM+1; - if ((ret = _MEDdatasetStringEcrire(datagroup,MED_NOM_NOM,dimd,groupe, - MED_REMP))<0) - return -1; - - /* - * On ferme le Data Group - */ - if ((ret = _MEDdatagroupFermer(datagroup)) < 0) - return -1; - } - - /* - * Le Data Group "ATT" - */ - - if (n_attr > 0) - { - if ((datagroup = _MEDdatagroupCreer(famid,MED_NOM_ATT)) < 0) - return -1; - - /* - * L'attribut "NBR" - */ - if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n_attr,MED_REMP)) < 0) - return -1; - - /* - * Le Data Set "IDE" - */ - dimd[0] = n_attr; -#if defined(IRIX64)||defined(OSF1) - if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_IDE,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, - (unsigned char *)attr_ident,MED_REMP)) < 0) - return -1; -#else - if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_IDE,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, - (unsigned char *)attr_ident,MED_REMP)) < 0) - return -1; -#endif - - /* - * Le Data Set "VAL" - */ - dimd[0] = n_attr; -#if defined(IRIX64)||defined(OSF1) - if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_VAL,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, - (unsigned char*)attr_val,MED_REMP)) < 0) - return -1; -#else - if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_VAL,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, - (unsigned char*)attr_val,MED_REMP)) < 0) - return -1; -#endif - - /* - * Le Data Set "DES" - */ - dimd[0] = n_attr*MED_TAILLE_DESC+1; - if ((ret = _MEDdatasetStringEcrire(datagroup,MED_NOM_DES,dimd,attr_desc, - MED_REMP)) < 0) - return -1; - - /* - * On ferme le Data Group - */ - if ((ret = _MEDdatagroupFermer(datagroup)) < 0) - return -1; - } - - /* - * On ferme tout - */ - if ((ret = _MEDdatagroupFermer(famid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(root)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDfamEcr.cxx b/src/MEDWrapper/V2_1/MEDfamEcr.cxx deleted file mode 100644 index 998072646..000000000 --- a/src/MEDWrapper/V2_1/MEDfamEcr.cxx +++ /dev/null @@ -1,142 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDfamEcr(med_idt fid,char *maa, med_int *fam, med_int n, med_mode_acces mode, - med_entite_maillage type_ent, med_geometrie_element type_geo) -{ - med_idt root, maaid, entid, geoid, dataset; - med_err ret; - med_size dimd[1]; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - char nom_ent[MED_TAILLE_NOM_ENTITE+1]; - char nom_geo[MED_TAILLE_NOM_ENTITE+1]; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le maillage n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * On met a jour le nom du Data Group representant - * le type des entites - */ - if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) - return -1; - - /* - * Si le Data Group des entites n'existe pas on le cree - */ - if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) - if ((entid = _MEDdatagroupCreer(maaid,nom_ent)) < 0) - return -1; - - /* - * Pour les mailles, les faces et le aretes, on cree - * s'il n'existe pas le Data Group du type geometrique - */ - if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE)) - { - if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) - return -1; - - if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) - if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0) - return -1; - } - else - geoid = -1; - - /* - * Creation du Data Set "FAM" - */ - if (geoid == -1) - root = entid; - else - root = geoid; - dimd[0] = n; -#if defined(IRIX64) || defined(OSF1) - if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_FAM,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, - (unsigned char*)fam,mode)) < 0) - return -1; -#else - if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_FAM,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, - (unsigned char*)fam,mode)) < 0) - return -1; -#endif - - /* - * Attribut NBR (nombre de noeuds) - */ - if ((dataset = _MEDdatasetOuvrir(root,MED_NOM_FAM)) < 0) - return -1; - if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n,mode)) < 0) - return -1; - - /* - * On ferme tout - */ - if ((ret = _MEDdatasetFermer(dataset)) < 0) - return -1; - if (geoid != -1) - if ((ret = _MEDdatagroupFermer(geoid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(entid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDfamGridEcr.cxx b/src/MEDWrapper/V2_1/MEDfamGridEcr.cxx deleted file mode 100644 index 3631c8baa..000000000 --- a/src/MEDWrapper/V2_1/MEDfamGridEcr.cxx +++ /dev/null @@ -1,77 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" - -namespace med_2_1{ - -med_err -MEDfamGridEcr(med_idt fid, char *maa, med_int *fam, med_int n, med_mode_acces mode, med_entite_maillage type_ent) { - /* Ecrire des numeros de familles pour les grilles cartesiennes ou polaires : - - pour les noeuds - - pour les aretes - - pour les faces - - pour les mailles */ - - med_geometrie_element type_geo; - - switch(type_ent) { - case MED_NOEUD : { - type_geo = MED_POINT1; - break; - }; - case MED_ARETE : { - type_geo = MED_SEG2; - break; - }; - case MED_FACE : { - type_geo = MED_QUAD4; - break; - }; - case MED_MAILLE : { - type_geo = MED_HEXA8; - break; - }; - default : { - return(-1); - }; - }; - - return(MEDfamEcr(fid, maa, fam, n, mode, type_ent, type_geo)); -} - -} diff --git a/src/MEDWrapper/V2_1/MEDfamGridLire.cxx b/src/MEDWrapper/V2_1/MEDfamGridLire.cxx deleted file mode 100644 index b68b22a58..000000000 --- a/src/MEDWrapper/V2_1/MEDfamGridLire.cxx +++ /dev/null @@ -1,77 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" - -namespace med_2_1{ - -med_err -MEDfamGridLire(med_idt fid, char *maa, med_int *fam, med_int n, med_entite_maillage type_ent) { - /* lecture des numeros de familles pour les grilles cartesiennes ou polaires : - - pour les noeuds - - pour les aretes - - pour les faces - - pour les mailles */ - - med_geometrie_element type_geo; - - switch(type_ent) { - case MED_NOEUD : { - type_geo = MED_POINT1; - break; - }; - case MED_ARETE : { - type_geo = MED_SEG2; - break; - }; - case MED_FACE : { - type_geo = MED_QUAD4; - break; - }; - case MED_MAILLE : { - type_geo = MED_HEXA8; - break; - }; - default : { - return(-1); - }; - }; - - return(MEDfamLire(fid, maa, fam, n, type_ent, type_geo)); -} - -} diff --git a/src/MEDWrapper/V2_1/MEDfamInfo.cxx b/src/MEDWrapper/V2_1/MEDfamInfo.cxx deleted file mode 100644 index 65c332f3f..000000000 --- a/src/MEDWrapper/V2_1/MEDfamInfo.cxx +++ /dev/null @@ -1,179 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDfamInfo(med_idt fid,char *maa,int indice, char *famille, - med_int *numero, - med_int *attr_ident, med_int *attr_val, char *attr_desc, - med_int *n_attr, char *groupe ,med_int *n_groupe) -{ - med_idt famid,datagroup; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_FAS+2*MED_TAILLE_NOM+1]; - int num; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * On recupere le nom de la famille - */ - num = indice - 1; - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - strcat(chemin,MED_FAS); - if ((ret = _MEDobjetIdentifier(fid,chemin,num,famille)) < 0) - return -1; - - /* - * Si le Data Group de la famille n'existe pas => erreur - */ - strcat(chemin,famille); - if ((famid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * L'attribut NUM - */ - if ((ret = _MEDattrEntierLire(famid,MED_NOM_NUM,numero)) < 0) - return -1; - - /* - * Le Data Group "GRO" - */ - if ((datagroup = _MEDdatagroupOuvrir(famid,MED_NOM_GRO)) >= 0) - { - /* - * L'attribut "NBR" - */ - if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,n_groupe)) < 0) - return -1; - - /* - * Data Set des noms des groupes "NOM" - */ - if ((ret = _MEDdatasetStringLire(datagroup,MED_NOM_NOM,groupe)) < 0) - return -1; - - /* - * On ferme le Data Group - */ - if ((ret = _MEDdatagroupFermer(datagroup)) < 0) - return -1; - } - else - *n_groupe = 0; - - /* - * Le Data Group "ATT" - */ - if ((datagroup = _MEDdatagroupOuvrir(famid,MED_NOM_ATT)) >= 0) - { - /* - * L'attribut "NBR" - */ - if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,n_attr)) < 0) - return -1; - - /* - * Le Data Set "IDE" - */ -#if defined(IRIX64)||defined(OSF1) - if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_IDE,MED_INT64, - MED_NO_INTERLACE,1,MED_ALL, - MED_NOPF,0,MED_NOPG, - (unsigned char*) attr_ident)) < 0) - return -1; -#else - if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_IDE,MED_INT32, - MED_NO_INTERLACE,1,MED_ALL, - MED_NOPF,0,MED_NOPG, - (unsigned char*) attr_ident)) < 0) - return -1; -#endif - - /* - * Le Data Set "VAL" - */ -#if defined(IRIX64)||defined(OSF1) - if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_VAL,MED_INT64, - MED_NO_INTERLACE,1,MED_ALL, - MED_NOPF,0,MED_NOPG, - (unsigned char *) attr_val)) < 0) - return -1; -#else - if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_VAL,MED_INT32, - MED_NO_INTERLACE,1,MED_ALL, - MED_NOPF,0,MED_NOPG, - (unsigned char *) attr_val)) < 0) - return -1; -#endif - - /* - * Le Data Set "DES" - */ - ret = _MEDdatasetStringLire(datagroup,MED_NOM_DES,attr_desc); - - /* - * On ferme le Data Group - */ - if ((ret = _MEDdatagroupFermer(datagroup)) < 0) - return -1; - } - else - *n_attr = 0; - - /* - * On ferme tout - */ - if ((ret = _MEDdatagroupFermer(famid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDfamLire.cxx b/src/MEDWrapper/V2_1/MEDfamLire.cxx deleted file mode 100644 index cee72f183..000000000 --- a/src/MEDWrapper/V2_1/MEDfamLire.cxx +++ /dev/null @@ -1,131 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDfamLire(med_idt fid,char *maa, med_int *fam, med_int n, - med_entite_maillage type_ent,med_geometrie_element type_geo) -{ - med_idt root,maaid, entid, geoid; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - char nom_ent[MED_TAILLE_NOM_ENTITE+1]; - char nom_geo[MED_TAILLE_NOM_ENTITE+1]; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le maillage n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * On met a jour le nom du Data Group representant - * le type des entites - */ - if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) - return -1; - - /* - * Si le Data Group des entites n'existe pas => erreur - */ - if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) - return -1; - - /* - * Pour les mailles, les faces et le aretes, on cree - * si le Data Group du type geometrique => erreur - */ - if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE)) - { - if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) - return -1; - if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) - return -1; - } - else - geoid = -1; - - /* - * lecture du Data Set "FAM" - */ - if (geoid == -1) - root = entid; - else - root = geoid; -#if defined(IRIX64)||defined(OSF1) - if ((ret = _MEDdatasetNumLire(root,MED_NOM_FAM,MED_INT64, - MED_NO_INTERLACE,1,MED_ALL, - MED_NOPF,0,MED_NOPG, - (unsigned char *)fam)) < 0) - return -1; -#else - if ((ret = _MEDdatasetNumLire(root,MED_NOM_FAM,MED_INT32, - MED_NO_INTERLACE,1,MED_ALL, - MED_NOPF,0,MED_NOPG, - (unsigned char *)fam)) < 0) - return -1; -#endif - - /* - * On ferme tout - */ - if (geoid != -1) - if ((ret = _MEDdatagroupFermer(geoid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(entid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDfamMaaCr.cxx b/src/MEDWrapper/V2_1/MEDfamMaaCr.cxx deleted file mode 100644 index d35067194..000000000 --- a/src/MEDWrapper/V2_1/MEDfamMaaCr.cxx +++ /dev/null @@ -1,90 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include - -namespace med_2_1{ - -med_err -MEDfamMaaCr(med_idt fid,char *maa, - med_int *numfam,med_int *attide, - med_int *attval,char *attdes,int *indatt,char *gro,int *indgro, - med_int nfamilles) -{ - med_err ret; - med_int i; - med_int natt,ngro; - med_int numf; - char nomfam[MED_TAILLE_NOM+1]; - - /* La famille de numero 0 n'a aucun attribut, ni aucun groupe - Les familles de numero > 0 sont des familles de noeuds - Les familles de numero < 0 sont des familles d'elements */ - for (i=0;i 0) - { - strcpy(nomfam,"FAMILLE_NOEUD_"); - sprintf(nomfam,"%s%d",nomfam,numf); - nomfam[MED_TAILLE_NOM] = '\0'; - } - if (numf < 0) - { - strcpy(nomfam,"FAMILLE_ELEMENT_"); - sprintf(nomfam,"%s%d",nomfam,-numf); - nomfam[MED_TAILLE_NOM] = '\0'; - } - natt = *(indatt+i+1) - *(indatt+i); - ngro = (*(indgro+i+1) - *(indgro+i))/MED_TAILLE_LNOM; - if ((ret = MEDfamCr(fid,maa,nomfam,numf, - attide+*(indatt+i), - attval+*(indatt+i), - attdes+*(indatt+i)*MED_TAILLE_DESC,natt, - gro+*(indgro+i),ngro)) < 0) - return -1; - } - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDfamMaaInfo.cxx b/src/MEDWrapper/V2_1/MEDfamMaaInfo.cxx deleted file mode 100644 index 2a9e0d341..000000000 --- a/src/MEDWrapper/V2_1/MEDfamMaaInfo.cxx +++ /dev/null @@ -1,71 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - - -#include "med.hxx" - -namespace med_2_1{ - -med_err -MEDfamMaaInfo(med_idt fid,char *maa,med_int *nfam,med_int *nattc, - med_int *ngroc) -{ - med_int ret; - med_int i; - - /* Lecture du nombre de familles */ - if ((*nfam = MEDnFam(fid,maa,0,(med_dim_famille)0)) < 0) - return -1; - - /* Lecture des nombres cumules de groupes et d'attributs dans toutes - les familles du maillage */ - *nattc = 0; - *ngroc = 0; - for (i=0;i<*nfam;i++) - { - if ((ret = MEDnFam(fid,maa,i+1,MED_ATTR)) < 0) - return -1; - *nattc += ret; - if ((ret = MEDnFam(fid,maa,i+1,MED_GROUPE)) < 0) - return -1; - *ngroc += ret; - } - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDfamMaaLire.cxx b/src/MEDWrapper/V2_1/MEDfamMaaLire.cxx deleted file mode 100644 index 5131a5534..000000000 --- a/src/MEDWrapper/V2_1/MEDfamMaaLire.cxx +++ /dev/null @@ -1,69 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -namespace med_2_1{ - -med_err -MEDfamMaaLire(med_idt fid,char *maa,med_int *numfam,med_int *attide, - med_int *attval,char *attdes,int *indatt,char *gro,int *indgro, - med_int nfamilles) -{ - med_err ret; - med_int natt,ngro; - med_int i; - char nom[MED_TAILLE_NOM+1]; - - *indatt = 0; - *indgro = 0; - for (i=0;i - -namespace med_2_1{ - -med_err -MEDfichDesEcr(med_idt fid, char *des, med_mode_acces mode) -{ - med_idt attr; - med_idt root; - med_err ret; - char nom[] = MED_NOM_DESCRIPTEUR; - char chemin[MED_TAILLE_MAA+1]; - - /* - * On inhibe le gestionnaire d'erreur - */ - _MEDmodeErreurVerrouiller(); - - /* - * On ouvre le Data Group racine - * s'il n'existe pas on le cree - */ - strncpy(chemin,MED_MAA,MED_TAILLE_MAA-1); - chemin[MED_TAILLE_MAA-1] = '\0'; - if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0) - if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) - return -1; - - /* - * On regarde si l'attribut existe - * Si oui on le met a jour en fonction - * du mode d'ouverture, sinon on le cree - */ - - if ((ret = _MEDattrStringEcrire(root,nom,MED_TAILLE_DESC,des,mode)) < 0) - return -1; - - /* - * Fermetures - */ - - if ((ret = _MEDdatagroupFermer(root)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDfichEntete.cxx b/src/MEDWrapper/V2_1/MEDfichEntete.cxx deleted file mode 100644 index 86932617a..000000000 --- a/src/MEDWrapper/V2_1/MEDfichEntete.cxx +++ /dev/null @@ -1,98 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include - -namespace med_2_1{ - -med_err -MEDfichEntete(med_idt fid, med_fich_info quoi, char str[]) -{ - med_idt atid, root; - med_err ret; - char locale[MED_TAILLE_DESC+1]; - char chemin[MED_TAILLE_MAA+1]; - - switch (quoi) - { - case MED_HDF_VERSION : - strcpy(str,HDF_VERSION_ACTUELLE); - break; - - case MED_VERSION : - strcpy(str,MED_VERSION_ACTUELLE); - break; - - case MED_FICH_DES : - /* - * On inhibe le gestionnaire d'erreur HDF - */ - _MEDmodeErreurVerrouiller(); - - /* - * On ouvre le Data Group racine - */ - strncpy(chemin,MED_MAA,strlen(MED_MAA)-1); - chemin[MED_TAILLE_MAA-1] = '\0'; - if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * On regarde si l'attribut existe - * Si non => erreur - * Si oui => on le copie dans str - */ - if ((ret = _MEDattrStringLire(root,MED_NOM_DESCRIPTEUR, - MED_TAILLE_DESC,locale)) < 0) - return -1; - strcpy(str,locale); - - if ((ret == _MEDdatagroupFermer(root)) < 0) - return -1; - - break; - - default : - return -1; - } - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDfichierCreer.cxx b/src/MEDWrapper/V2_1/MEDfichierCreer.cxx deleted file mode 100644 index 54ffeb323..000000000 --- a/src/MEDWrapper/V2_1/MEDfichierCreer.cxx +++ /dev/null @@ -1,90 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDfichierCreer - * - Description : creation d'un fichier HDF - * - Parametres : - * - nom (IN) : le nom du fichier - * - Resultat : ID du fichier en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_idt -_MEDfichierCreer(char *nom) -{ - med_idt fid,gid; - med_err ret; - med_int majeur = MED_NUM_MAJEUR; - med_int mineur = MED_NUM_MINEUR; - med_int release = MED_NUM_RELEASE; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - if ((fid = H5Fcreate(nom,H5F_ACC_TRUNC, - H5P_DEFAULT,H5P_DEFAULT)) < 0) - return -1; - - if ((gid = _MEDdatagroupCreer(fid,MED_NOM_INFOS)) < 0) - return -1; - - /* Numero de versions de MED */ - if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_MAJEUR,&majeur,MED_REMP)) < 0) - return -1; - - if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_MINEUR,&mineur,MED_REMP)) < 0) - return -1; - - if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_RELEASE,&release,MED_REMP)) < 0) - return -1; - - /* On ferme tout */ - if ((ret = _MEDdatagroupFermer(gid)) < 0) - return -1; - - return fid; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDfichierFermer.cxx b/src/MEDWrapper/V2_1/MEDfichierFermer.cxx deleted file mode 100644 index efdece165..000000000 --- a/src/MEDWrapper/V2_1/MEDfichierFermer.cxx +++ /dev/null @@ -1,62 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDfichierFermer - * - Description : fermeture d'un fichier HDF - * - Parametres : - * - fid (IN) : ID du fichier - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDfichierFermer(med_idt fid) -{ - med_err ret; - - if ((ret = H5Fclose(fid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDfichierOuvrir.cxx b/src/MEDWrapper/V2_1/MEDfichierOuvrir.cxx deleted file mode 100644 index 093e2606d..000000000 --- a/src/MEDWrapper/V2_1/MEDfichierOuvrir.cxx +++ /dev/null @@ -1,79 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDfichierOuvrir - * - Description : ouverture d'un fichier HDF en fonction du mode passe - * en parametre - * - Parametres : - * - nom (IN) : le nom du fichier - * - mode (IN) : mode d'ouverture - * - Resultat : ID du fichier en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_idt -_MEDfichierOuvrir(char *nom,med_mode_acces mode) -{ - med_idt fid; - int hdf_mode; - - switch(mode) - { - case MED_ECRI : - hdf_mode = H5F_ACC_RDWR; - break; - - case MED_LECT : - hdf_mode = H5F_ACC_RDONLY; - break; - - default : - return -1; - } - - if ((fid = H5Fopen(nom,hdf_mode,H5P_DEFAULT)) < 0) - return -1; - - return fid; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDformatConforme.cxx b/src/MEDWrapper/V2_1/MEDformatConforme.cxx deleted file mode 100644 index 3e25577c6..000000000 --- a/src/MEDWrapper/V2_1/MEDformatConforme.cxx +++ /dev/null @@ -1,59 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -namespace med_2_1{ - -med_err -MEDformatConforme(const char * nomfich) -{ - - /* - * On inhibe le gestionnaire d'erreur - */ - _MEDmodeErreurVerrouiller(); - - - if ( H5Fis_hdf5(nomfich) > 0 ) - return 0; - else - return -1; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDfstring.cxx b/src/MEDWrapper/V2_1/MEDfstring.cxx deleted file mode 100644 index 54f812011..000000000 --- a/src/MEDWrapper/V2_1/MEDfstring.cxx +++ /dev/null @@ -1,66 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include - -/* - * Chaine C -> chaine FORTRAN completee par des blancs - */ - -namespace med_2_1{ - -med_err -_MEDfstring(char *chaine, med_int longueur_fixee) -{ - int longueur_reelle, i; - - if (longueur_fixee == 0 ) return 0; - - longueur_reelle = strlen(chaine); - if (longueur_fixee < longueur_reelle) - return -1; - - /* on supprime le caractere de fin de chaine C '\0' - et complete par des blancs */ - for (i=longueur_reelle;i erreur */ - if (_MEDdatagroupOuvrir(root, maillage) > 0) { - return(-1); - }; - - /* Creation du Data Group */ - maaid = _MEDdatagroupCreer(root, maillage); - if (maaid < 0) return(-1); - - /* Creation de l'attribut dimension */ - if (_MEDattrEntierEcrire(maaid, MED_NOM_DIM, &dim, MED_REMP) < 0) { - return(-1); - }; - - /* Creation de l'attribut grille */ - if (_MEDattrEntierEcrire(maaid, MED_NOM_GRD, &typ, MED_REMP) < 0) { - return(-1); - }; - - /* Nettoyages divers */ - if ( _MEDdatagroupFermer(maaid) < 0) return(-1); - if (_MEDdatagroupFermer(root) < 0) return(-1); - return(0); -} - -} diff --git a/src/MEDWrapper/V2_1/MEDgridEcr.cxx b/src/MEDWrapper/V2_1/MEDgridEcr.cxx deleted file mode 100644 index b4c08197e..000000000 --- a/src/MEDWrapper/V2_1/MEDgridEcr.cxx +++ /dev/null @@ -1,128 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med_outils.hxx" -#include "med.hxx" - -namespace med_2_1{ - -med_err -MEDgridEcr(med_idt fid, char *maa, med_int mdim, med_float *coo, med_int nb, med_int dim, med_mode_switch mode_coo, - med_repere repere, char *nomcoo, char *unicoo, med_mode_acces mode ) -{ - /* ecriture des indices */ - - med_idt maaid, noeid, ds; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - med_size dimd[1]; - char *dataset; - med_int type_rep_int; - - /* On inhibe le gestionnaire d'erreur HDF */ - _MEDmodeErreurVerrouiller(); - - /* Si le maillage n'existe pas => erreur */ - strcpy(chemin, MED_MAA); - strcat(chemin, maa); - maaid = _MEDdatagroupOuvrir(fid, chemin); - if (maaid < 0) return(-1); - - /* Si le Data Group "NOE" n'existe pas on le cree */ - if ((noeid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE)) < 0) { - if ((noeid = _MEDdatagroupCreer(maaid, MED_NOM_NOE)) < 0) { - return(-1); - }; - }; - - switch (dim) { - case 0 : { - dataset = MED_NOM_IN1; - break; - }; - case 1 : { - dataset = MED_NOM_IN2; - break; - }; - case 2 : { - dataset = MED_NOM_IN3; - break; - }; - default : { - return(-1); - }; - }; - - /* Creation du Data Set "IN1" ou "IN2" ou "IN3" */ - dimd[0] = nb; - if (_MEDdatasetNumEcrire(noeid, dataset, MED_REEL64, mode_coo, 1, MED_ALL, MED_NOPF, 0, 0, dimd, (unsigned char*)coo, mode) < 0) { - return(-1); - }; - - /* On re-ouvre le Data Set "IN1" ou "IN2" ou "IN3" pour y placer des attributs */ - if ((ds = _MEDdatasetOuvrir(noeid, dataset)) < 0) { - return(-1); - }; - - /* Attribut NBR (nombre de noeuds) */ - if (_MEDattrEntierEcrire(ds, MED_NOM_NBR, &nb, mode) < 0) { - return(-1); - }; - - /* L'attribut "REP" */ - type_rep_int = (med_int)repere; - if (_MEDattrEntierEcrire(ds, MED_NOM_REP, &type_rep_int, mode) < 0) { - return(-1); - }; - - /* Attribut "NOM" */ - if (_MEDattrStringEcrire(ds, MED_NOM_NOM, mdim*MED_TAILLE_PNOM, nomcoo, mode) < 0) { - return(-1); - }; - - /* Attribut "UNI" */ - if (_MEDattrStringEcrire(ds, MED_NOM_UNI, mdim*MED_TAILLE_PNOM, unicoo, mode) < 0) { - return(-1); - }; - - /* On ferme tout */ - if (_MEDdatasetFermer(ds) < 0) return(-1); - if (_MEDdatagroupFermer(noeid) < 0) return(-1); - if (_MEDdatagroupFermer(maaid) < 0) return(-1); - return(0); -} - -} diff --git a/src/MEDWrapper/V2_1/MEDgridInfo.cxx b/src/MEDWrapper/V2_1/MEDgridInfo.cxx deleted file mode 100644 index 6ac3e5fe6..000000000 --- a/src/MEDWrapper/V2_1/MEDgridInfo.cxx +++ /dev/null @@ -1,79 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDgridInfo(med_idt fid, int indice, med_int *isAGrid, med_grid_type *typ) -{ - int numero; - med_idt maaid; - char maillage[MED_TAILLE_NOM+1]; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - - /* On inhibe le gestionnaire d'erreur */ - _MEDmodeErreurVerrouiller(); - - /* On recupere le nom du groupe de rang "indice" */ - numero = indice-1; - if (_MEDobjetIdentifier(fid, MED_MAA, numero, maillage) < 0) { - return(-1); - }; - - /* On va chercher l'attribut dimension */ - strcpy(chemin, MED_MAA); - strcat(chemin, maillage); - maaid = _MEDdatagroupOuvrir(fid, chemin); - if (maaid < 0) return(-1); - - if (_MEDattrEntierLire(maaid, MED_NOM_GRD, typ) < 0) { - *isAGrid = 0; - } else { - *isAGrid = 1; - }; - - if (_MEDdatagroupFermer(maaid) < 0) return(-1); - return(0); -} - -} diff --git a/src/MEDWrapper/V2_1/MEDgridLire.cxx b/src/MEDWrapper/V2_1/MEDgridLire.cxx deleted file mode 100644 index 6369a69d4..000000000 --- a/src/MEDWrapper/V2_1/MEDgridLire.cxx +++ /dev/null @@ -1,104 +0,0 @@ -// Copyright (C) 2005 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/ -// -#include "med_outils.hxx" -#include "med.hxx" - -namespace med_2_1{ - -med_err -MEDgridLire(med_idt fid, char *maa, med_int mdim, med_float *coo, med_int dim, med_mode_switch mode_coo, - med_repere *repere, char *nomcoo, char *unicoo ) -{ - med_idt maaid, noeid, ds; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - char *dataset; - med_int type_rep_int; - - /* On inhibe le gestionnaire d'erreur */ - _MEDmodeErreurVerrouiller(); - - /* Si le maillage n'existe pas => erreur */ - strcpy(chemin, MED_MAA); - strcat(chemin, maa); - maaid = _MEDdatagroupOuvrir(fid, chemin); - if (maaid < 0) return(-1); - - /* Si le Data Group "NOE" n'existe pas => erreur */ - noeid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE); - if (noeid < 0) return(-1); - - switch (dim) { - case 0 : { - dataset = MED_NOM_IN1; - break; - }; - case 1 : { - dataset = MED_NOM_IN2; - break; - }; - case 2 : { - dataset = MED_NOM_IN3; - break; - }; - default : { - return(-1); - }; - }; - - /* Lecture du Data Set "IN1" ou "IN2" ou "IN3" */ - if (_MEDdatasetNumLire(noeid, dataset, MED_REEL64, mode_coo, 1, MED_ALL, MED_NOPF, 0, 1, (unsigned char*)coo) < 0) { - return(-1); - }; - - /* On re-ouvre le Data Set precedant pour y lire des attributs */ - ds = _MEDdatasetOuvrir(noeid, dataset); - if (ds < 0) return(-1); - - /* L'attribut "REP" */ - if (_MEDattrEntierLire(ds, MED_NOM_REP, &type_rep_int) < 0) { - return(-1); - } else { - *repere = (med_repere)type_rep_int; - }; - - /* Attribut "NOM" */ - if (_MEDattrStringLire(ds, MED_NOM_NOM, mdim*MED_TAILLE_PNOM, nomcoo) < 0) { - return(-1); - }; - - /* Attribut "UNI" */ - if (_MEDattrStringLire(ds, MED_NOM_UNI, mdim*MED_TAILLE_PNOM, unicoo) < 0) { - return(-1); - }; - - /* On ferme tout */ - if (_MEDdatasetFermer(ds) < 0) { - return(-1); - }; - if (_MEDdatagroupFermer(noeid) < 0) { - return(-1); - }; - if (_MEDdatagroupFermer(maaid) < 0) { - return(-1); - }; - return(0); -} - -} diff --git a/src/MEDWrapper/V2_1/MEDgro2famA.cxx b/src/MEDWrapper/V2_1/MEDgro2famA.cxx deleted file mode 100644 index b3f6c44f8..000000000 --- a/src/MEDWrapper/V2_1/MEDgro2famA.cxx +++ /dev/null @@ -1,310 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - - -#include -#include - -#include "med.hxx" - -/*********************************************************************** - * FONCTION MEDgro2famA - * - * - DESCRIPTION : 1ere etape dans la conversion des groupes de noeuds - * et d'elements en familles MED. - * Calcul des tailles des tableaux que l'on devra allouer pour - * stocker les familles qui seront construites par MEDgro2famB(). - * Les parametres renvoyes sont : - * 1 - le nombre de familles MED a creer (nfamg) - * 2 - le nombre de noms groupes associes a l'ensemble des familles - * MED (nindf) - * Ces parametres doivent permettre a l'appelant de creer les tables - * suivantes : - * 1 - une table des noms des groupes propres a chaque famille, - * de taille : nindf*MED_TAILLE_LNOM+1 - * 2 - une table d'index donnant pour chaque famille son numero d'indice - * dans la table des noms, de taille : nfamg+1 - * 3 - une table destinee a contenir la liste des numeros de familles - * a creer, de taille : nfamg - * - * - PARAMETRES : - * NOM .E/S. TYPE . DESCRIPTION - * ------------------------------------------------------------------- - * nnoe .E . med_int . nombre de noeuds - * nele .E . med_int . nombre d'elements - * numnoe .E . med_int*. numeros des noeuds - * numele .E . med_int*. numeros des elements - * ngn .E . med_int . nombre de groupes de noeuds - * nge .E . med_int . nombre de groupes d'elements - * nindn .E . med_int . nombre d'indices dans la table - * . . . des groupes de noeuds - * ninde .E . med_int . nombre d'indices dans la table - * . . . de groupes d'elements - * indgronoe .E . int* . table index de la table des groupes - * . . . de noeuds - * indgroele .E . int* . table index de la table des groupes - * . . . d'elements - * tabgronoe .E . med_int*. table des groupes de noeuds - * tabgroele .E . med_int*. table des groupes d'elements - * nfamg . S. med_int*. nombre de familles MED a creer - * nidnf . S. med_int*. nombre de noms groupes associes a - * . . . l'ensemble des familles MED - * - * - RESULTAT : 0 si succes, -1 sinon - * - ***********************************************************************/ - -namespace med_2_1{ - -med_err -MEDgro2famA (med_int nnoe,med_int nele,med_int *numnoe,med_int *numele, - med_int ngn,med_int nge,med_int nindn, - med_int ninde,int *indgronoe,int *indgroele,med_int *tabgronoe, - med_int *tabgroele,med_int *nfamg,med_int *nindf) -{ - int i,j,k; - int *famnoe,*famele,*tmp; - int *p; - int flag, num,exist; - int nfamn, nfame; - int fam01 = 0; - int fam02 = 0; - - /* initialisations */ - famnoe = NULL; - famele = NULL; - - *nfamg = 0; - *nindf = 0; - nfamn = 0; - nfame = 0; - - if ((ngn > 0) || (nge > 0)) - { - /* pour chaque noeud : - 1 - on dresse la liste des groupes de noeuds auquel il appartient - 2 - en la comparant avec les listes pre-existantes, on - estime s'il est necessaire de creer une nouvelle famille de noeuds. - Si oui => on incremente le compteur local nfamn (nombre de familles - de noeuds) - on incremente le parametre nindf du nombre de groupes - que devra compter cette famille de noeuds - Si non => on ne fait rien */ - for (i=0;i -#include -#include -#include "med.hxx" - -/*********************************************************************** - * FONCTION MEDgro2famB - * - * - DESCRIPTION : 2eme etape dans la conversion des groupes de noeuds - * et d'elements en familles MED - * Mise a jour des tables suivantes passees en parametres : - * 1 - les nouveaux numeros des familles a creer - * 2 - les nouveaux numeros des familles des elements - * 3 - les nouveaux numeros des familles des noeuds - * 4 - les noms des groupes composant ces familles - * 5 - les index de la table des groupes - * - * - PARAMETRES : - * NOM .E/S. TYPE . DESCRIPTION - * ------------------------------------------------------------------- - * nnoe .E . med_int . nombre de noeuds - * nele .E . med_int . nombre d'elements - * numnoe .E . med_int*. numeros des noeuds - * numele .E . med_int*. numeros des elements - * ngn .E . med_int . nombre de groupes de noeuds - * nge .E . med_int . nombre de groupes d'elements - * nindn .E . med_int . nombre d'indices dans la table - * . . . des groupes de noeuds - * ninde .E . med_int . nombre d'indices dans la table - * . . . de groupes d'elements - * nomgronoe .E . char* . noms des groupes de noeuds - * nomgroele .E . char* . noms des groupes d'elements - * indgronoe .E . int* . table index de la table des groupes - * . . . de noeuds - * indgroele .E . int* . table index de la table des groupes - * . . . d'elements - * tabgronoe .E . int* . table des groupes de noeuds - * tabgroele .E . int* . table des groupes d'elements - * nfamg .E . med_int . nombre de familles MED a creer - * nidnf .E . med_int . nombre de noms groupes associes a - * . . . l'ensemble des familles MED - * newnumfam . S. med_int*. nouveaux numeros de familles - * newnumfamele . S. med_int*. nouveaux numeros de familles des - * . . . elements - * newnumfamnoe . S. med_int*. nouveaux numeros de familles des - * . . . noeuds - * newindfamgro . S. int* . table des index de la table des - * . . . noms de groupes associes aux familles - * newfamgro . . char* . table des noms des groupes des - * . . . familles - * - * - RESULTAT : 0 - * - ***********************************************************************/ - -namespace med_2_1{ - -med_err -MEDgro2famB (med_int nnoe,med_int nele,med_int *numnoe,med_int *numele, - med_int ngn,med_int nge,med_int nindn, - med_int ninde, char *nomgronoe,char *nomgroele, - int *indgronoe,int *indgroele,med_int *tabgronoe, - med_int *tabgroele,med_int nfamg,med_int nindf, - med_int *newnumfam,med_int *newnumfamele, - med_int *newnumfamnoe,int *newindfamgro, - char *newfamgro) -{ - int i,j,k; - - med_int *famnoe, *famele, *tmp; - med_int *p; - med_int num; - int flag,exist; - int nfamn, nfame; - int estfam0 = 1; - int newnumnoe, newnumele; - int tmp1; - int existfam0 = 0; - int ind = 0; - - famnoe = NULL; - famele = NULL; - - nfamn = 0; - nfame = 0; - newnumnoe = 0; - newnumele = 0; - - *newindfamgro = 0; - - if (nfamg > 1) - { - /* pour chaque noeud : - 1 - on dresse la liste des groupes de noeuds auquel il appartient - 2 - en la comparant avec les listes pre-existantes, on - estime s'il est necessaire de creer une nouvelle famille de noeuds. - Si oui => - on cree le numero de famille que l'on reporte - dans newnumfam - - on reporte ce numero dans newnumnoe - - on met a jour la table des noms des groupes des familles - ainsi que sa table d'index - Si non => on ne fait rien - ATTENTION : pour la famille 0, on ne met a jour que les numeros */ - for (i=0;i - on cree le numero de famille que l'on reporte - dans newnumfam - - on reporte ce numero dans newnumele - - on met a jour la table des noms des groupes des familles - ainsi que sa table d'index - Si non => on ne fait rien - ATTENTION : pour la famille 0, on ne met a jour que les numeros */ - for (i=0;i - -namespace med_2_1{ - -med_int -MEDlFichDes(med_idt fid) -{ - med_idt attr, root; - med_err ret=0; - char des[MED_TAILLE_DESC+1]; - med_int longueur=0; - char nom[MED_TAILLE_NOM+1]; - char chemin[MED_TAILLE_MAA+1]; - - /* - * On inhibe le gestionnaire d'erreur HDF - */ - _MEDmodeErreurVerrouiller(); - - /* - * On ouvre le Data Group racine - */ - strncpy(chemin,MED_MAA,MED_TAILLE_MAA-1); - chemin[MED_TAILLE_MAA-1] = '\0'; - if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * On regarde si l'attribut existe - * Si non => erreur - * Si oui => on retourne sa longueur - */ - strcpy(nom,MED_NOM_DESCRIPTEUR); - - if ((attr = _MEDattrOuvrir(root,nom)) < 0) { - _MEDdatagroupFermer(root); - longueur=0; - return 0; - } - - if ((ret = _MEDattrFermer(attr)) < 0) { - _MEDdatagroupFermer(root); - return -1; - } - - if ((ret = _MEDattrStringLire(root,nom,MED_TAILLE_DESC,des)) < 0) { - _MEDdatagroupFermer(root); - return -1; - } - - longueur = strlen(des); - - /* - * fermetures - */ - if ((ret == _MEDdatagroupFermer(root)) < 0) - return -1; - - return longueur; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDmaaCr.cxx b/src/MEDWrapper/V2_1/MEDmaaCr.cxx deleted file mode 100644 index cb6c72a3c..000000000 --- a/src/MEDWrapper/V2_1/MEDmaaCr.cxx +++ /dev/null @@ -1,96 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDmaaCr(med_idt fid, char *maillage, med_int dim) -{ - med_idt maaid, root; - char chemin[MED_TAILLE_MAA+1]; - med_err ret; - - /* - * On inhibe le gestionnaire d'erreur - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si la racine n'existe pas on la cree - */ - strncpy(chemin,MED_MAA,strlen(MED_MAA)-1); - chemin[MED_TAILLE_MAA-1] = '\0'; - if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0) - if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) - return -1; - - /* - * si le maillage existe deja => erreur - */ - if ((maaid = _MEDdatagroupOuvrir(root,maillage)) > 0) - return -1; - - /* - * Creation du Data Group - */ - if ((maaid = _MEDdatagroupCreer(root,maillage)) < 0) - return -1; - - /* - * Creation de l'attribut dimension - */ - if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_DIM,&dim,MED_REMP)) < 0) - return -1; - - /* - * Nettoyages divers - */ - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(root)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDmaaInfo.cxx b/src/MEDWrapper/V2_1/MEDmaaInfo.cxx deleted file mode 100644 index 5094e7057..000000000 --- a/src/MEDWrapper/V2_1/MEDmaaInfo.cxx +++ /dev/null @@ -1,81 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDmaaInfo(med_idt fid, int indice, char *maillage, med_int *dim) -{ - int numero; - med_idt maaid; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - - /* - * On inhibe le gestionnaire d'erreur - */ - _MEDmodeErreurVerrouiller(); - - /* - * On recupere le nom du groupe de rang "indice" - */ - numero = indice-1; - if ((ret = _MEDobjetIdentifier(fid,MED_MAA,numero,maillage)) < 0) - return -1; - - /* - * On va chercher l'attribut dimension - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maillage); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - if ((ret = _MEDattrEntierLire(maaid,MED_NOM_DIM,dim)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDmodeErreurVerrouiller.cxx b/src/MEDWrapper/V2_1/MEDmodeErreurVerrouiller.cxx deleted file mode 100644 index eb89a46ca..000000000 --- a/src/MEDWrapper/V2_1/MEDmodeErreurVerrouiller.cxx +++ /dev/null @@ -1,56 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDmodeErreurVerrouiller - * - Description : inhibe le mode erreur HDF5 - * - Parametres : aucun - * - Resultat : aucun - */ - -namespace med_2_1{ - -void -_MEDmodeErreurVerrouiller() -{ - H5Eset_auto(NULL,NULL); -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnChamp.cxx b/src/MEDWrapper/V2_1/MEDnChamp.cxx deleted file mode 100644 index ff4490588..000000000 --- a/src/MEDWrapper/V2_1/MEDnChamp.cxx +++ /dev/null @@ -1,106 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include -#include -#include "med_outils.hxx" - -namespace med_2_1{ - -med_int -MEDnChamp(med_idt fid, int indice) -{ - int n1; - med_int n2; - med_idt datagroup; - med_err ret; - char nomdatagroup[MED_TAILLE_NOM+1]; - int num; - char chemin[MED_TAILLE_CHA+MED_TAILLE_NOM+1]; - - if (indice < 0) - return -1; - - /* - * On inhibe le gestionnaire d'erreur HDF - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le Data Group cha n'existe pas et indice == 0 => 0 - * sinon erreur => erreur - */ - strcpy(chemin,MED_CHA); - - /* - * Si indice == 0 => nombre de champs - */ - if (indice == 0) - { - n1 = 0; - _MEDnObjets(fid,chemin,&n1); - n2 = n1; - } - - /* - * Si indice > 0 => nbre de composants - */ - if (indice > 0) - { - /* - * On recupere le nom du champ - */ - num = indice-1; - if ((ret = _MEDobjetIdentifier(fid,chemin,num,nomdatagroup)) < 0) - return -1; - strcat(chemin,nomdatagroup); - /* - * On recupere le nombre de composants - */ - if ((datagroup = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NCO,&n2)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(datagroup)) < 0) - return -1; - } - - return n2; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnCorres.cxx b/src/MEDWrapper/V2_1/MEDnCorres.cxx deleted file mode 100644 index a5fb6d5a6..000000000 --- a/src/MEDWrapper/V2_1/MEDnCorres.cxx +++ /dev/null @@ -1,102 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_int -MEDnCorres(med_idt fid,char *maa,char *eq,med_entite_maillage typ_ent, - med_geometrie_element typ_geo) -{ - med_idt eqid, datagroup; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1]; - char nomdatagroup[MED_TAILLE_NOM+1]; - char tmp[MED_TAILLE_NOM_ENTITE+1]; - med_int n; - - if (typ_geo == MED_TETRA4 || typ_geo == MED_TETRA10 || - typ_geo == MED_HEXA8 || typ_geo == MED_HEXA20 || - typ_geo == MED_PENTA6 || typ_geo == MED_PENTA15 || - typ_geo == MED_PYRA5 || typ_geo == MED_PYRA13) - return -1; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le Data Group de "eq" n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - strcat(chemin,MED_EQS); - strcat(chemin,eq); - if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - if ((ret = _MEDnomEntite(nomdatagroup,typ_ent)) < 0) - return -1; - if ((typ_ent != MED_NOEUD)) - { - if ((ret = _MEDnomGeometrie(tmp,typ_geo)) < 0) - return -1; - strcat(nomdatagroup,"."); - strcat(nomdatagroup,tmp); - } - if ((datagroup = _MEDdatagroupOuvrir(eqid,nomdatagroup)) < 0) - return 0; - if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,&n)) < 0) - return -1; - - /* - * On ferme tout - */ - if ((ret = _MEDdatagroupFermer(datagroup)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(eqid)) < 0) - return -1; - - return n; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnEntMaa.cxx b/src/MEDWrapper/V2_1/MEDnEntMaa.cxx deleted file mode 100644 index 933a428d8..000000000 --- a/src/MEDWrapper/V2_1/MEDnEntMaa.cxx +++ /dev/null @@ -1,130 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_int -MEDnEntMaa(med_idt fid, char *maa, med_table quoi, med_entite_maillage type_ent, - med_geometrie_element type_geo, med_connectivite type_conn) -{ - med_idt root, maaid, entid,geoid, dataset=0; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - char nom_ent[MED_TAILLE_NOM_ENTITE+1]; - char nom_geo[MED_TAILLE_NOM_ENTITE+1]; - char nom_dataset[MED_TAILLE_NOM_ENTITE+1]; - med_int res = 0; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le maillage n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * On met a jour le nom du Data Group representant - * le type des entites - */ - if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) - return -1; - - /* - * Si le Data Group des entites n'existe pas => res = 0 - */ - entid = _MEDdatagroupOuvrir(maaid,nom_ent); - - /* - * Pour les mailles, les faces et le aretes - * si le Data Group du type geometrique n'existe pas => res = 0 - */ - if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE)) - { - if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) - return -1; - geoid = _MEDdatagroupOuvrir(entid,nom_geo); - } - else - geoid = -1; - - /* - * Ouverture du Data Set renvoye par _MEDnomDataset() - * S'il n'existe pas => erreur - * Sinon lecture de l'attribut NBR - */ - if (geoid == -1) - root = entid; - else - root = geoid; - if ((ret = _MEDnomDataset(nom_dataset,quoi,type_conn)) < 0) - return -1; - dataset = _MEDdatasetOuvrir(root,nom_dataset); - if (dataset > 0) - if ((ret = _MEDattrEntierLire(dataset,MED_NOM_NBR,&res)) < 0) - return -1; - - /* - * On ferme tout - */ - if (dataset > 0) - if ((ret = _MEDdatasetFermer(dataset)) < 0) - return -1; - if (geoid > 0) - if ((ret = _MEDdatagroupFermer(geoid)) < 0) - return -1; - if (entid > 0) - if ((ret = _MEDdatagroupFermer(entid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return res; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnEntites.cxx b/src/MEDWrapper/V2_1/MEDnEntites.cxx deleted file mode 100644 index 9b409244b..000000000 --- a/src/MEDWrapper/V2_1/MEDnEntites.cxx +++ /dev/null @@ -1,88 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" - -namespace med_2_1{ - -med_int -MEDnEntites(med_idt fid,char *maa,med_entite_maillage typ_ent, - med_connectivite typ_con) -{ - med_int total = 0; - int i; - med_geometrie_element typ_mai[MED_NBR_GEOMETRIE_MAILLE] = {MED_POINT1,MED_SEG2, - MED_SEG3,MED_TRIA3, - MED_TRIA6,MED_QUAD4, - MED_QUAD8,MED_TETRA4, - MED_TETRA10,MED_HEXA8, - MED_HEXA20,MED_PENTA6, - MED_PENTA15,MED_PYRA5, - MED_PYRA13}; - med_geometrie_element typ_fac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6, - MED_QUAD4,MED_QUAD8}; - med_geometrie_element typ_are[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3}; - - switch (typ_ent) - { - case MED_MAILLE : - for (i=0;i -#include - -namespace med_2_1{ - -med_int -MEDnEquiv(med_idt fid, char *maa) -{ - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+MED_TAILLE_EQS+1]; - int n; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - strcat(chemin,MED_EQS); - n = 0; - _MEDnObjets(fid,chemin,&n); - - return (med_int) n; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnFam.cxx b/src/MEDWrapper/V2_1/MEDnFam.cxx deleted file mode 100644 index 55f4c96b0..000000000 --- a/src/MEDWrapper/V2_1/MEDnFam.cxx +++ /dev/null @@ -1,127 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_int -MEDnFam(med_idt fid,char *maa, int indice, med_dim_famille quoi) -{ - med_idt datagroup,famid; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_FAS+2*MED_TAILLE_NOM+1]; - med_int n; - int n_tmp; - int num; - char famille[MED_TAILLE_NOM+1]; - - - /* - * On inhibe le gestionnaire d'erreur HDF - */ - _MEDmodeErreurVerrouiller(); - - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - strcat(chemin,MED_FAS); - if (indice == 0) - { - n_tmp = 0; - _MEDnObjets(fid,chemin,&n_tmp); - n = (med_int ) n_tmp; - } - else - { - /* - * On recupere le nom de la famille - */ - num = indice - 1; - if ((ret = _MEDobjetIdentifier(fid,chemin,num, - famille)) < 0) - return -1; - - /* - * Si le Data Group de la famille n'existe pas => erreur - */ - strcat(chemin,famille); - if ((famid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - switch (quoi) - { - case MED_GROUPE : - if ((datagroup = _MEDdatagroupOuvrir(famid,MED_NOM_GRO)) < 0) - n = 0; - else - { - if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,&n)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(datagroup)) < 0) - return -1; - } - break; - - case MED_ATTR : - if ((datagroup = _MEDdatagroupOuvrir(famid,MED_NOM_ATT)) < 0) - n = 0; - else - { - if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,&n)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(datagroup)) < 0) - return -1; - } - break; - - default : - return -1; - } - - if ((ret = _MEDdatagroupFermer(famid)) < 0) - return -1; - - } - - return (med_int) n; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnGrid.cxx b/src/MEDWrapper/V2_1/MEDnGrid.cxx deleted file mode 100644 index 771a9962c..000000000 --- a/src/MEDWrapper/V2_1/MEDnGrid.cxx +++ /dev/null @@ -1,133 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -namespace med_2_1{ - -med_int -MEDnGrid(med_idt fid, char *maa, med_grid n) -{ - med_idt maaid, entid, geoid, dataset; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - char nom_ent[MED_TAILLE_NOM_ENTITE+1]; - char *nom_dataset; - med_int res = (-1); - - /* On inhibe le gestionnaire d'erreur HDF 5 */ - _MEDmodeErreurVerrouiller(); - - /* Si le maillage n'existe pas => erreur */ - strcpy(chemin, MED_MAA); - strcat(chemin, maa); - maaid = _MEDdatagroupOuvrir(fid, chemin); - if (maaid < 0) return(-1); - - switch (n) { - case MED_FAM_NOEUD : { - nom_dataset = MED_NOM_FAM; - if (_MEDnomEntite(nom_ent, MED_NOEUD) < 0) return(-1); - entid = _MEDdatagroupOuvrir(maaid, nom_ent); - break; - }; - case MED_FAM_ARETE : { - nom_dataset = MED_NOM_FAM; - if (_MEDnomEntite(nom_ent, MED_ARETE) < 0) return(-1); - geoid = _MEDdatagroupOuvrir(maaid, nom_ent); - if (geoid < 0) return(-1); - if (_MEDnomGeometrie(nom_ent, MED_SEG2) < 0) return(-1); - entid = _MEDdatagroupOuvrir(geoid, nom_ent); - break; - }; - case MED_FAM_FACE : { - nom_dataset = MED_NOM_FAM; - if (_MEDnomEntite(nom_ent, MED_FACE) < 0) return(-1); - geoid = _MEDdatagroupOuvrir(maaid, nom_ent); - if (geoid < 0) return(-1); - if (_MEDnomGeometrie(nom_ent, MED_QUAD4) < 0) return(-1); - entid = _MEDdatagroupOuvrir(geoid, nom_ent); - break; - }; - case MED_FAM_MAILLE : { - nom_dataset = MED_NOM_FAM; - if (_MEDnomEntite(nom_ent, MED_MAILLE) < 0) return(-1); - geoid = _MEDdatagroupOuvrir(maaid, nom_ent); - if (geoid < 0) return(-1); - if (_MEDnomGeometrie(nom_ent, MED_HEXA8) < 0) return(-1); - entid = _MEDdatagroupOuvrir(geoid, nom_ent); - break; - }; - case MED_GRID_NOEUD : { - nom_dataset = MED_NOM_BOF; - entid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE); - break; - }; - case MED_GRID_D1 : { - nom_dataset = MED_NOM_IN1; - entid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE); - break; - }; - case MED_GRID_D2 : { - nom_dataset = MED_NOM_IN2; - entid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE); - break; - }; - case MED_GRID_D3 : { - nom_dataset = MED_NOM_IN3; - entid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE); - break; - }; - default : { - return(-1); - }; - }; - - if (entid < 0) return(-1); - dataset = _MEDdatasetOuvrir(entid, nom_dataset); - if (dataset < 0) return(-1); - if (_MEDattrEntierLire(dataset, MED_NOM_NBR, &res) < 0) return(-1); - - /* On ferme tout */ - if (_MEDdatasetFermer(dataset) < 0) return(-1); - if (_MEDdatagroupFermer(entid) < 0) return(-1); - if (_MEDdatagroupFermer(maaid) < 0) return(-1); - - return(res); -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnMaa.cxx b/src/MEDWrapper/V2_1/MEDnMaa.cxx deleted file mode 100644 index e80596f48..000000000 --- a/src/MEDWrapper/V2_1/MEDnMaa.cxx +++ /dev/null @@ -1,58 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include - -namespace med_2_1{ - -med_int -MEDnMaa(med_idt fid) -{ - int n; - - _MEDmodeErreurVerrouiller(); - - n = 0; - _MEDnObjets(fid,MED_MAA,&n); - - return (med_int) n; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnObjets.cxx b/src/MEDWrapper/V2_1/MEDnObjets.cxx deleted file mode 100644 index 6b385766c..000000000 --- a/src/MEDWrapper/V2_1/MEDnObjets.cxx +++ /dev/null @@ -1,65 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDnObjets - * - Description : indique le nombre d'objets HDF contenu dans le - * datagroup passe en argument - * - Parametres : - * - fid (IN) : l'ID du fichier HDF - * - chemin (IN) : chemin d'acces au datagroup - * - n (OUT) : le nombre recherche - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDnObjets(med_idt fid,char *chemin,int *n) -{ - int idx; - - if ((idx = H5Giterate(fid,chemin,NULL,_MEDindiceNum,(void *)n)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnPasdetemps.cxx b/src/MEDWrapper/V2_1/MEDnPasdetemps.cxx deleted file mode 100644 index c8a5e5255..000000000 --- a/src/MEDWrapper/V2_1/MEDnPasdetemps.cxx +++ /dev/null @@ -1,92 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -/* - * Nombre de Couple (PDT,NOR) pour le champ - */ - -namespace med_2_1{ - -med_int -MEDnPasdetemps(med_idt fid,char *cha,med_entite_maillage type_ent, - med_geometrie_element type_geo) - -{ - med_err ret; - int n1; - char nomdatagroup1[MED_TAILLE_NOM+1]; - char tmp1 [MED_TAILLE_NOM_ENTITE+1]; - char chemin [MED_TAILLE_CHA+(MED_TAILLE_NOM+1)+MED_TAILLE_NOM+1]; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Creation du chemin d'accès aux différents (PDT,NOR) pour les différents [.] - */ - strcpy(chemin,MED_CHA); - strcat(chemin,cha); - strcat(chemin,"/"); - - if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0) - return -1; - if ((type_ent != MED_NOEUD)) - { - if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0) - return -1; - strcat(nomdatagroup1,"."); - strcat(nomdatagroup1,tmp1); - } - strcat(chemin,nomdatagroup1); - - n1 =0; - _MEDnObjets(fid,chemin,&n1); - - return (med_int) n1; - -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnProfil.cxx b/src/MEDWrapper/V2_1/MEDnProfil.cxx deleted file mode 100644 index 83f89b66d..000000000 --- a/src/MEDWrapper/V2_1/MEDnProfil.cxx +++ /dev/null @@ -1,57 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -namespace med_2_1{ - -med_int -MEDnProfil(med_idt fid) -{ - int n; - med_err ret; - - _MEDmodeErreurVerrouiller(); - - n = 0; - _MEDnObjets(fid,MED_PROFILS,&n); - - return (med_int) n; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnVal.cxx b/src/MEDWrapper/V2_1/MEDnVal.cxx deleted file mode 100644 index de0ce89e3..000000000 --- a/src/MEDWrapper/V2_1/MEDnVal.cxx +++ /dev/null @@ -1,102 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include -#include -#include "med_outils.hxx" - -namespace med_2_1{ - -med_int -MEDnVal(med_idt fid, char *champ, med_entite_maillage type_ent, - med_geometrie_element type_geo,med_int numdt, med_int numo) -{ - med_int n; - med_idt datagroup; - med_err ret; - char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2],nomdatagroup2[2*MED_MAX_PARA+1]; - char tmp1 [MED_TAILLE_NOM_ENTITE+1]; - char chemin [MED_TAILLE_CHA+(MED_TAILLE_NOM+1)+(2*MED_TAILLE_NOM_ENTITE+2)+(2*MED_MAX_PARA)+1+100]; - - /* - * On inhibe le gestionnaire d'erreur HDF - */ - _MEDmodeErreurVerrouiller(); - - /* - * On cree le chemin d'accès - */ - strcpy(chemin,MED_CHA); - strcat(chemin,champ); - strcat(chemin,"/"); - - /* On cree le nom du datagroup de niveau 1 */ - if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0) - return -1; - if ((type_ent != MED_NOEUD)) - { - if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0) - return -1; - strcat(nomdatagroup1,"."); - strcat(nomdatagroup1,tmp1); - } - strcat(chemin,nomdatagroup1); - strcat(chemin,"/"); - - /* Creation du datagroup de niveau 2 . */ - sprintf(nomdatagroup2,"%*li%*li",MED_MAX_PARA,(long ) numdt,MED_MAX_PARA,(long ) numo); - strcat(chemin,nomdatagroup2); - - /* - * Acces au champ - */ - if ((datagroup = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return 0; - if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,&n)) < 0) - return -1; - - /* - * fermetures - */ - if ((ret = _MEDdatagroupFermer(datagroup)) < 0) - return -1; - - return n; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnValProfil.cxx b/src/MEDWrapper/V2_1/MEDnValProfil.cxx deleted file mode 100644 index 341443614..000000000 --- a/src/MEDWrapper/V2_1/MEDnValProfil.cxx +++ /dev/null @@ -1,79 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_int -MEDnValProfil(med_idt fid, char *nom) -{ - med_int n = 0; - med_idt pid; - char chemin[MED_TAILLE_PROFILS+MED_TAILLE_NOM+1]; - med_err ret; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * ouverture du groupe /PROFILS/"nom" - */ - strcpy(chemin,MED_PROFILS); - strcat(chemin,nom); - if ((pid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - if ((ret = _MEDattrEntierLire(pid,MED_NOM_N,&n)) < 0) - return ret; - - /* - * On ferme tout - */ - if ((ret = _MEDdatagroupFermer(pid)) < 0) - return -1; - - return n; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnbnoisEcr.cxx b/src/MEDWrapper/V2_1/MEDnbnoisEcr.cxx deleted file mode 100644 index 00d767dd9..000000000 --- a/src/MEDWrapper/V2_1/MEDnbnoisEcr.cxx +++ /dev/null @@ -1,81 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDnbnoisEcr(med_idt fid, char *nom_maillage,med_int n) -{ - med_idt maaid; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - med_err ret; - - /* - * On inhibe le gestionnaire d'erreur HDF - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le maillage n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,nom_maillage); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * Creation de l'attribut "Nombre de Noeuds Isoles" - */ - if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_NNI,&n,MED_REMP)) < 0) - return -1; - - /* - * Fermetures des objets - */ - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnbnoisLire.cxx b/src/MEDWrapper/V2_1/MEDnbnoisLire.cxx deleted file mode 100644 index ef1b24f30..000000000 --- a/src/MEDWrapper/V2_1/MEDnbnoisLire.cxx +++ /dev/null @@ -1,82 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_int -MEDnbnoisLire(med_idt fid,char *nom_maillage) -{ - med_idt maaid; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - med_int n; - - /* - * On inhibe le gestionnaire d'erreur - */ - _MEDmodeErreurVerrouiller(); - - /* - * On regarde si le maillage existe => erreur si non - */ - strcpy(chemin,MED_MAA); - strcat(chemin,nom_maillage); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * On va lire l'attribut "NNI" - */ - if ((ret = _MEDattrEntierLire(maaid,MED_NOM_NNI,&n)) < 0) - return -1; - - /* - * Fermetures des objets HDF - */ - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return n; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnbnomaEcr.cxx b/src/MEDWrapper/V2_1/MEDnbnomaEcr.cxx deleted file mode 100644 index 0806e0838..000000000 --- a/src/MEDWrapper/V2_1/MEDnbnomaEcr.cxx +++ /dev/null @@ -1,81 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDnbnomaEcr(med_idt fid, char *nom_maillage,med_int n) -{ - med_idt maaid; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - med_err ret; - - /* - * On inhibe le gestionnaire d'erreur - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le maillage n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,nom_maillage); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * Creation de l'attribut "Nombre de Noeuds Max par maille" - */ - if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_NNM,&n,MED_REMP)) < 0) - return -1; - - /* - * Nettoyages divers - */ - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnbnomaLire.cxx b/src/MEDWrapper/V2_1/MEDnbnomaLire.cxx deleted file mode 100644 index dfbdc35f6..000000000 --- a/src/MEDWrapper/V2_1/MEDnbnomaLire.cxx +++ /dev/null @@ -1,82 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_int -MEDnbnomaLire(med_idt fid,char *nom_maillage) -{ - med_idt maaid; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - med_int n; - - /* - * On inhibe le gestionnaire d'erreur HDF - */ - _MEDmodeErreurVerrouiller(); - - /* - * On regarde si le maillage existe => erreur si non - */ - strcpy(chemin,MED_MAA); - strcat(chemin,nom_maillage); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * On va lire l'attribut "NNM" - */ - if ((ret = _MEDattrEntierLire(maaid,MED_NOM_NNM,&n)) < 0) - return -1; - - /* - * Fermetures des objets HDF - */ - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return n; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnbnosoEcr.cxx b/src/MEDWrapper/V2_1/MEDnbnosoEcr.cxx deleted file mode 100644 index 72e28be62..000000000 --- a/src/MEDWrapper/V2_1/MEDnbnosoEcr.cxx +++ /dev/null @@ -1,81 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDnbnosoEcr(med_idt fid, char *nom_maillage,med_int n) -{ - med_idt maaid; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - med_err ret; - - /* - * On inhibe le gestionnaire d'erreur HDF - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le maillage n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,nom_maillage); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * Creation de l'attribut "Nombre de Noeuds Sommets" - */ - if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_NNS,&n,MED_REMP)) < 0) - return -1; - - /* - * Fermetures - */ - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnbnosoLire.cxx b/src/MEDWrapper/V2_1/MEDnbnosoLire.cxx deleted file mode 100644 index e7307a85d..000000000 --- a/src/MEDWrapper/V2_1/MEDnbnosoLire.cxx +++ /dev/null @@ -1,82 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med_outils.hxx" -#include "med.hxx" - -#include -#include - -namespace med_2_1{ - -med_int -MEDnbnosoLire(med_idt fid,char *nom_maillage) -{ - med_idt maaid; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - med_int n; - - /* - * On inhibe le gestionnaire d'erreur - */ - _MEDmodeErreurVerrouiller(); - - /* - * On regarde si le maillage existe => erreur si non - */ - strcpy(chemin,MED_MAA); - strcat(chemin,nom_maillage); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * On va lire l'attribut "NNS" - */ - if ((ret = _MEDattrEntierLire(maaid,MED_NOM_NNS,&n)) < 0) - return -1; - - /* - * Fermetures des objets HDF - */ - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return n; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnoeudsEcr.cxx b/src/MEDWrapper/V2_1/MEDnoeudsEcr.cxx deleted file mode 100644 index 22ea92f9a..000000000 --- a/src/MEDWrapper/V2_1/MEDnoeudsEcr.cxx +++ /dev/null @@ -1,74 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" - -namespace med_2_1{ - -med_err -MEDnoeudsEcr(med_idt fid,char *maa,med_int mdim,med_float *coord, - med_mode_switch mode_coo, - med_repere repere,char *nomcoo, char *unicoo,char *nom, - med_booleen inom,med_int *num,med_booleen inum,med_int *fam, - med_int nnoeuds,med_mode_acces mode) -{ - med_err ret; - - /* ecriture des coordonnees */ - if ((ret = MEDcoordEcr(fid,maa,mdim,coord,mode_coo, - nnoeuds,mode,repere,nomcoo, - unicoo)) < 0) - return -1; - - /* ecriture des noms (facultatifs) */ - if (inom == MED_VRAI) - if ((ret = MEDnomEcr(fid,maa,nom,nnoeuds,mode,MED_NOEUD,MED_POINT1)) < 0) - return -1; - - /* ecriture des numeros (facultatifs) */ - if (inum == MED_VRAI) - if ((ret = MEDnumEcr(fid,maa,num,nnoeuds,mode,MED_NOEUD,MED_POINT1)) < 0) - return -1; - - /* ecriture des numeros de familles */ - if ((ret = MEDfamEcr(fid,maa,fam,nnoeuds,mode,MED_NOEUD,MED_POINT1)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnoeudsLire.cxx b/src/MEDWrapper/V2_1/MEDnoeudsLire.cxx deleted file mode 100644 index af76b98d1..000000000 --- a/src/MEDWrapper/V2_1/MEDnoeudsLire.cxx +++ /dev/null @@ -1,76 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - - -#include "med.hxx" - -namespace med_2_1{ - -med_err -MEDnoeudsLire(med_idt fid,char *maa,med_int mdim, med_float *coord, - med_mode_switch mode_coo, - med_repere *repere,char *nomcoo, char *unicoo,char *nom, - med_booleen *inom,med_int *num,med_booleen *inum,med_int *fam, - med_int nnoeuds) -{ - med_err ret; - - /* lecture des coordonnees */ - if ((ret = MEDcoordLire(fid,maa,mdim,coord,mode_coo,MED_ALL,0,MED_NOPF,repere,nomcoo, - unicoo)) < 0) - return -1; - - /* lecture des noms (facultatifs) */ - if ((ret = MEDnomLire(fid,maa,nom,nnoeuds,MED_NOEUD,MED_POINT1)) < 0) - *inom = MED_FAUX; - else - *inom = MED_VRAI; - - /* lecture des numeros (facultatifs) */ - if ((ret = MEDnumLire(fid,maa,num,nnoeuds,MED_NOEUD,MED_POINT1)) < 0) - *inum = MED_FAUX; - else - *inum = MED_VRAI; - - /* lecture des numeros de familles */ - if ((ret = MEDfamLire(fid,maa,fam,nnoeuds,MED_NOEUD,MED_POINT1)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnomDataset.cxx b/src/MEDWrapper/V2_1/MEDnomDataset.cxx deleted file mode 100644 index d041deada..000000000 --- a/src/MEDWrapper/V2_1/MEDnomDataset.cxx +++ /dev/null @@ -1,98 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDnomDataset - * - Description : fournit un nom de dataset - * - Parametres : - * - nom_dataset (OUT) : le nom du data set - * - quoi (IN) : le type de table MED - * - type_conn (IN) : le type de connectivite - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDnomDataset(char *nom_dataset,med_table quoi,med_connectivite type_conn) -{ - switch(quoi) - { - case MED_COOR : - strcpy(nom_dataset,MED_NOM_COO); - break; - - case MED_CONN : - switch(type_conn) - { - case MED_NOD : - strcpy(nom_dataset,MED_NOM_NOD); - break; - - case MED_DESC : - strcpy(nom_dataset,MED_NOM_DES); - break; - - default : - return -1; - } - break; - - case MED_NOM : - strcpy(nom_dataset,MED_NOM_NOM); - break; - - case MED_NUM : - strcpy(nom_dataset,MED_NOM_NUM); - break; - - case MED_FAM : - strcpy(nom_dataset,MED_NOM_FAM); - break; - - default : - return -1; - } - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnomEcr.cxx b/src/MEDWrapper/V2_1/MEDnomEcr.cxx deleted file mode 100644 index 9dfc9b811..000000000 --- a/src/MEDWrapper/V2_1/MEDnomEcr.cxx +++ /dev/null @@ -1,135 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDnomEcr(med_idt fid,char *maa, char *nom, med_int n, med_mode_acces mode, - med_entite_maillage type_ent,med_geometrie_element type_geo) -{ - med_idt root, maaid, entid, geoid, dataset; - med_err ret; - med_size dimd[1]; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - char nom_ent[MED_TAILLE_NOM_ENTITE+1]; - char nom_geo[MED_TAILLE_NOM_ENTITE+1]; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le maillage n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * On met a jour le nom du Data Group representant - * le type des entites - */ - if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) - return -1; - - /* - * Si le Data Group des entites n'existe pas on le cree - */ - if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) - if ((entid = _MEDdatagroupCreer(maaid,nom_ent)) < 0) - return -1; - - /* - * Pour les mailles, les faces et le aretes, on cree - * s'il n'existe pas le Data Group du type geometrique - */ - if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE)) - { - if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) - return -1; - - if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) - if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0) - return -1; - } - else - geoid = -1; - - /* - * Creation du Data Set "NOM" - */ - if (geoid == -1) - root = entid; - else - root = geoid; - dimd[0] = n*MED_TAILLE_PNOM+1; - if ((ret = _MEDdatasetStringEcrire(root,MED_NOM_NOM,dimd,nom,mode)) < 0) - return -1; - - /* - * Attribut NBR (nombre de noeuds) - */ - if ((dataset = _MEDdatasetOuvrir(root,MED_NOM_NOM)) < 0) - return -1; - if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n,mode)) < 0) - return -1; - - /* - * On ferme tout - */ - if ((ret = _MEDdatasetFermer(dataset)) < 0) - return -1; - if (geoid > 0) - if ((ret = _MEDdatagroupFermer(geoid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(entid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnomEntite.cxx b/src/MEDWrapper/V2_1/MEDnomEntite.cxx deleted file mode 100644 index 912f28840..000000000 --- a/src/MEDWrapper/V2_1/MEDnomEntite.cxx +++ /dev/null @@ -1,79 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDnomEntite - * - Description : fournit le nom associe a un type d'entite MED - * - Parametres : - * - nom_ent (OUT) : le nom de l'entite - * - type_ent (IN) : le type de l'entite - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDnomEntite(char *nom_ent,med_entite_maillage type_ent) -{ - switch(type_ent) - { - case MED_NOEUD : - strcpy(nom_ent,MED_NOM_NOE); - break; - - case MED_MAILLE : - strcpy(nom_ent,MED_NOM_MAI); - break; - - case MED_FACE : - strcpy(nom_ent,MED_NOM_FAC); - break; - - case MED_ARETE : - strcpy(nom_ent,MED_NOM_ARE); - break; - - default : - return -1; - } - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnomGeometrie.cxx b/src/MEDWrapper/V2_1/MEDnomGeometrie.cxx deleted file mode 100644 index cf3c4ba3a..000000000 --- a/src/MEDWrapper/V2_1/MEDnomGeometrie.cxx +++ /dev/null @@ -1,125 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDnomGeometrie - * - Description : fournit le nom de l'element geometrique associe - * au type geometrique MED - * - Parametres : - * - nom_geo (OUT) : le nom de l'element - * - type_geo (IN) : le type de l'element - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDnomGeometrie(char *nom_geo,med_geometrie_element type_geo) -{ - switch (type_geo) - { - case MED_POINT1 : - strcpy(nom_geo,MED_NOM_PO1); - break; - - case MED_SEG2 : - strcpy(nom_geo,MED_NOM_SE2); - break; - - case MED_SEG3 : - strcpy(nom_geo,MED_NOM_SE3); - break; - - case MED_TRIA3 : - strcpy(nom_geo,MED_NOM_TR3); - break; - - case MED_TRIA6 : - strcpy(nom_geo,MED_NOM_TR6); - break; - - case MED_QUAD4 : - strcpy(nom_geo,MED_NOM_QU4); - break; - - case MED_QUAD8 : - strcpy(nom_geo,MED_NOM_QU8); - break; - - case MED_TETRA4 : - strcpy(nom_geo,MED_NOM_TE4); - break; - - case MED_TETRA10 : - strcpy(nom_geo,MED_NOM_T10); - break; - - case MED_HEXA8 : - strcpy(nom_geo,MED_NOM_HE8); - break; - - case MED_HEXA20 : - strcpy(nom_geo,MED_NOM_H20); - break; - - case MED_PENTA6 : - strcpy(nom_geo,MED_NOM_PE6); - break; - - case MED_PENTA15 : - strcpy(nom_geo,MED_NOM_P15); - break; - - case MED_PYRA5 : - strcpy(nom_geo,MED_NOM_PY5); - break; - - case MED_PYRA13 : - strcpy(nom_geo,MED_NOM_P13); - break; - - default : - return -1; - } - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnomLire.cxx b/src/MEDWrapper/V2_1/MEDnomLire.cxx deleted file mode 100644 index ddd0e6932..000000000 --- a/src/MEDWrapper/V2_1/MEDnomLire.cxx +++ /dev/null @@ -1,120 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDnomLire(med_idt fid,char *maa, char *nom, med_int n, - med_entite_maillage type_ent,med_geometrie_element type_geo) -{ - med_idt root, maaid, entid, geoid; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - char nom_ent[MED_TAILLE_NOM_ENTITE+1]; - char nom_geo[MED_TAILLE_NOM_ENTITE+1]; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le maillage n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * On met a jour le nom du Data Group representant - * le type des entites - */ - if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) - return -1; - - /* - * Si le Data Group des entites n'existe pas => erreur - */ - if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) - return -1; - - /* - * Pour les mailles, les faces et le aretes, - * on ouvre le Data Group du type geometrique - */ - if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE)) - { - if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) - return -1; - if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) - return -1; - } - else - geoid = -1; - - /* - * lecture du Data Set "NOM" - */ - if (geoid == -1) - root = entid; - else - root = geoid; - if ((ret = _MEDdatasetStringLire(root,MED_NOM_NOM,nom)) < 0) - return -1; - - /* - * On ferme tout - */ - if (geoid > 0) - if ((ret = _MEDdatagroupFermer(geoid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(entid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnumEcr.cxx b/src/MEDWrapper/V2_1/MEDnumEcr.cxx deleted file mode 100644 index 4382dc27d..000000000 --- a/src/MEDWrapper/V2_1/MEDnumEcr.cxx +++ /dev/null @@ -1,142 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDnumEcr(med_idt fid,char *maa, med_int *num, med_int n, med_mode_acces mode, - med_entite_maillage type_ent,med_geometrie_element type_geo) -{ - med_idt root, maaid, entid, geoid, dataset; - med_err ret; - med_size dimd[1]; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - char nom_ent[MED_TAILLE_NOM_ENTITE+1]; - char nom_geo[MED_TAILLE_NOM_ENTITE+1]; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le maillage n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * On met a jour le nom du Data Group representant - * le type des entites - */ - if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) - return -1; - - /* - * Si le Data Group des entites n'existe pas on le cree - */ - if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) - if ((root = _MEDdatagroupCreer(maaid,nom_ent)) < 0) - return -1; - - /* - * Pour les mailles, les faces et le aretes, on cree - * s'il n'existe pas le Data Group du type geometrique - */ - if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE)) - { - if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) - return -1; - - if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) - if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0) - return -1; - } - else - geoid = -1; - - /* - * Creation du Data Set "NUM" - */ - if (geoid == -1) - root = entid; - else - root = geoid; - dimd[0] = n; -#if defined(IRIX64)||defined(OSF1) - if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_NUM,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, - (unsigned char*) num,mode)) < 0) - return -1; -#else - if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_NUM,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, - (unsigned char*) num,mode)) < 0) - return -1; -#endif - - /* - * Attribut NBR (nombre de noeuds) - */ - if ((dataset = _MEDdatasetOuvrir(root,MED_NOM_NUM)) < 0) - return -1; - if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n,mode)) < 0) - return -1; - - /* - * On ferme tout - */ - if ((ret = _MEDdatasetFermer(dataset)) < 0) - return -1; - if (geoid != -1) - if ((ret = _MEDdatagroupFermer(geoid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(entid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDnumLire.cxx b/src/MEDWrapper/V2_1/MEDnumLire.cxx deleted file mode 100644 index 93e7952a1..000000000 --- a/src/MEDWrapper/V2_1/MEDnumLire.cxx +++ /dev/null @@ -1,131 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDnumLire(med_idt fid,char *maa, med_int *num, med_int n, - med_entite_maillage type_ent,med_geometrie_element type_geo) -{ - med_idt root,maaid,entid,geoid; - med_err ret; - char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - char nom_ent[MED_TAILLE_NOM_ENTITE+1]; - char nom_geo[MED_TAILLE_NOM_ENTITE+1]; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le maillage n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * On met a jour le nom du Data Group representant - * le type des entites - */ - if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0) - return -1; - - /* - * Si le Data Group des entites n'existe pas => erreur - */ - if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) - return -1; - - /* - * Pour les mailles, les faces et le aretes, - * si le Data Group du type geometrique => erreur - */ - if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE)) - { - if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0) - return -1; - if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) - return -1; - } - else - geoid = -1; - - /* - * lecture du Data Set "NUM" - */ - if (geoid == -1) - root = entid; - else - root = geoid; -#if defined(IRIX64)||defined(OSF1) - if ((ret = _MEDdatasetNumLire(root,MED_NOM_NUM,MED_INT64, - MED_NO_INTERLACE,1,MED_ALL, - MED_NOPF,0,MED_NOPG, - (unsigned char*) num)) < 0) - return -1; -#else - if ((ret = _MEDdatasetNumLire(root,MED_NOM_NUM,MED_INT32, - MED_NO_INTERLACE,1,MED_ALL, - MED_NOPF,0,MED_NOPG, - (unsigned char*) num)) < 0) - return -1; -#endif - - /* - * On ferme tout - */ - if (geoid != -1) - if ((ret = _MEDdatagroupFermer(geoid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(entid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDobjetIdentifer.cxx b/src/MEDWrapper/V2_1/MEDobjetIdentifer.cxx deleted file mode 100644 index a48741414..000000000 --- a/src/MEDWrapper/V2_1/MEDobjetIdentifer.cxx +++ /dev/null @@ -1,68 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDobjetIdentifier - * - Description : retrouve le nom de l'objet de rang "indice" - * se trouvant dans le datagroup "chemin" - * - Parametres : - * - fid (IN) : l'ID du fichier ou se trouve le datagroup - * - chemin (IN) : chemin d'acces au datagroup - * - indice (IN) : indice de l'objet du datagroup dont on veut - * le nom - * - nom (OUT) : le nom - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDobjetIdentifier(med_idt fid,char *chemin,int indice,void *nom) -{ - int idx; - - if ((idx = H5Giterate(fid,chemin,&indice,_MEDindiceInfo, - nom)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDouvrir.cxx b/src/MEDWrapper/V2_1/MEDouvrir.cxx deleted file mode 100644 index 5471a2c50..000000000 --- a/src/MEDWrapper/V2_1/MEDouvrir.cxx +++ /dev/null @@ -1,95 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#ifdef PPRO_NT -#define F_OK 0 -#else -#include -#endif - -namespace med_2_1{ - -med_idt -MEDouvrir(char *nom, med_mode_acces mode_acces) -{ - med_idt fid; - - /* - * On inhibe le gestionnaire d'erreur HDF - */ - _MEDmodeErreurVerrouiller(); - - /* - * On ouvre le fichier MED sous HDF - */ - switch(mode_acces) - { - case MED_LECT : - if (access(nom,F_OK)) - return -1; - else - if ((fid = _MEDfichierOuvrir(nom,mode_acces)) < 0) - return -1; - break; - - case MED_ECRI : - if (access(nom,F_OK)) - { - if ((fid = _MEDfichierCreer(nom)) < 0) - return -1; - } - else - if ((fid = _MEDfichierOuvrir(nom,mode_acces)) < 0) - return -1; - break; - - case MED_REMP : - if ((fid = _MEDfichierCreer(nom)) < 0) - return -1; - break; - - default : - return -1; - } - - return fid; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDparametresGeometrie.cxx b/src/MEDWrapper/V2_1/MEDparametresGeometrie.cxx deleted file mode 100644 index 57f360ffe..000000000 --- a/src/MEDWrapper/V2_1/MEDparametresGeometrie.cxx +++ /dev/null @@ -1,183 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -/* - * - Nom de la fonction : _MEDparametresGeometrie - * - Description : fournit les parametres geometriques des differents - * entites et elements MED - * - Parametres : - * - typ_ent (IN) : type d'entite de l'element - * - type_geo (IN) : le type geometrique de l'element - * - dim (OUT) : dimension de l'element - * - nnoe (OUT) : nombre de noeuds composant l'element (connectivite - * nodale) - * - ndes (OUT) : nombre de composants dans l'elements (connectivite - * descendante) - * - Resultat : 0 en cas de succes, -1 sinon - */ - -namespace med_2_1{ - -med_err -_MEDparametresGeometrie(med_entite_maillage type_ent, - med_geometrie_element type_geo, int *dim, - int *nnoe,int *ndes) -{ - *nnoe = type_geo % 100; - *dim = type_geo / 100; - - switch(type_ent) - { - case MED_MAILLE : - switch (type_geo) - { - case MED_POINT1 : - *ndes = 0; - break; - - case MED_SEG2 : - *ndes = 2; - break; - - case MED_SEG3 : - *ndes = 3; - break; - - case MED_TRIA3 : - *ndes = 3; - break; - - case MED_TRIA6 : - *ndes = 3; - break; - - case MED_QUAD4 : - *ndes = 4; - break; - - case MED_QUAD8 : - *ndes = 4; - break; - - case MED_TETRA4 : - *ndes = 4; - break; - - case MED_TETRA10 : - *ndes = 4; - break; - - case MED_HEXA8 : - *ndes = 6; - break; - - case MED_HEXA20 : - *ndes = 6; - break; - - case MED_PENTA6 : - *ndes = 5; - break; - - case MED_PENTA15 : - *ndes = 5; - break; - - case MED_PYRA5 : - *ndes = 5; - break; - - case MED_PYRA13 : - *ndes = 5; - break; - - default : - return -1; - } - break; - - case MED_FACE : - switch(type_geo) - { - case MED_TRIA3 : - *ndes = 3; - break; - - case MED_TRIA6 : - *ndes = 3; - break; - - case MED_QUAD4 : - *ndes = 4; - break; - - case MED_QUAD8 : - *ndes = 4; - break; - - default : - return -1; - } - break; - - case MED_ARETE : - switch(type_geo) - { - case MED_SEG2 : - *ndes = 2; - break; - - case MED_SEG3 : - *ndes = 3; - break; - - default : - return -1; - } - break; - - default : - return -1; - } - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDpasdetempsInfo.cxx b/src/MEDWrapper/V2_1/MEDpasdetempsInfo.cxx deleted file mode 100644 index 7951c90ac..000000000 --- a/src/MEDWrapper/V2_1/MEDpasdetempsInfo.cxx +++ /dev/null @@ -1,119 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -/* Le nom de cette fonction n'est pas très bien choisie */ - -namespace med_2_1{ - -med_err -MEDpasdetempsInfo(med_idt fid,char *champ - ,med_entite_maillage type_ent, med_geometrie_element type_geo, - int indice, char *maa, med_int * ngauss, med_int * numdt, char * dt_unit, med_float * dt, - med_int * numo) -{ - - med_err ret=0; - med_int gauss_size; - med_idt gid; - char chemin[(MED_TAILLE_CHA+MED_TAILLE_NOM+1)+(2*MED_TAILLE_NOM_ENTITE+2)+2*MED_MAX_PARA+1]; - int num; - char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2],nomdatagroup2[2*MED_MAX_PARA+1]; - char tmp1 [MED_TAILLE_NOM_ENTITE+1]; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * On recupere le nom du datagroup . - */ - strcpy(chemin,MED_CHA); - strcat(chemin,champ); - strcat(chemin,"/"); - - if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0) - return -1; - if ((type_ent != MED_NOEUD)) - { - if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0) - return -1; - strcat(nomdatagroup1,"."); - strcat(nomdatagroup1,tmp1); - } - strcat(chemin,nomdatagroup1); - strcat(chemin,"/"); - - num = indice - 1; - if ((ret = _MEDobjetIdentifier(fid,chemin,num,nomdatagroup2)) < 0) - return -1; - strcat(chemin,nomdatagroup2); - if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * La liste des attributs - */ - if ((ret = _MEDattrStringLire(gid,MED_NOM_MAI,MED_TAILLE_NOM,maa)) < 0) - return -1; - - if ((ret = _MEDattrEntierLire(gid,MED_NOM_NDT,(med_int*) numdt)) < 0) - return -1; - - if ((ret = _MEDattrFloatLire(gid,MED_NOM_PDT,(med_float*) dt)) < 0) - return -1; - - if ((ret = _MEDattrStringLire(gid,MED_NOM_UNI,MED_TAILLE_PNOM,dt_unit)) < 0) - return -1; - - if ((ret = _MEDattrEntierLire(gid,MED_NOM_NOR,(med_int*) numo)) < 0) - return -1; - - if ( (ret = _MEDattrEntierLire(gid,MED_NOM_NGA,ngauss)) < 0 ) - return -1; - - - if ((ret = _MEDdatagroupFermer(gid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDprofilEcr.cxx b/src/MEDWrapper/V2_1/MEDprofilEcr.cxx deleted file mode 100644 index 0243e4eb0..000000000 --- a/src/MEDWrapper/V2_1/MEDprofilEcr.cxx +++ /dev/null @@ -1,108 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDprofilEcr(med_idt fid,med_int *pflval,med_int n,char *nom) -{ - med_idt root, pid, did; - med_size dimd[1]; - med_err ret; - char chemin[MED_TAILLE_PROFILS+1]; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le groupe "PROFILS" n'existe pas, on le cree - */ - strncpy(chemin,MED_PROFILS,MED_TAILLE_PROFILS-1); - chemin[MED_TAILLE_PROFILS-1] = '\0'; - if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0) - if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) - return -1; - - /* - * Si le groupe "nom" n'existe pas, on le cree - * Sinon => erreur - */ - if ((pid = _MEDdatagroupOuvrir(root,nom)) >= 0) - return -1; - if ((pid = _MEDdatagroupCreer(root,nom)) < 0) - return -1; - - /* - * On stocke "n" sous forme d'attribut - */ - if ((ret = _MEDattrEntierEcrire(pid,MED_NOM_N,&n,MED_REMP)) < 0) - return -1; - - /* - * On stocke le profil dans un dataset - */ - dimd[0] = n; -#if defined(IRIX64)||defined(OSF1) - if ((ret = _MEDdatasetNumEcrire(pid,MED_NOM_PFL,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, - (unsigned char*) pflval,MED_REMP)) < 0) - return -1; -#else - if ((ret = _MEDdatasetNumEcrire(pid,MED_NOM_PFL,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd, - (unsigned char*) pflval,MED_REMP)) < 0) - return -1; -#endif - - /* - * On ferme tout - */ - if ((ret = _MEDdatagroupFermer(pid)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(root)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDprofilInfo.cxx b/src/MEDWrapper/V2_1/MEDprofilInfo.cxx deleted file mode 100644 index 26b1f36e9..000000000 --- a/src/MEDWrapper/V2_1/MEDprofilInfo.cxx +++ /dev/null @@ -1,81 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDprofilInfo(med_idt fid, int indice, char *profil, med_int *n) -{ - int numero; - med_idt proid; - med_err ret; - char chemin[MED_TAILLE_PROFILS+MED_TAILLE_NOM+1]; - - /* - * On inhibe le gestionnaire d'erreur - */ - _MEDmodeErreurVerrouiller(); - - /* - * On recupere le nom du groupe de rang "indice" - */ - numero = indice-1; - if ((ret = _MEDobjetIdentifier(fid,MED_PROFILS,numero,profil)) < 0) - return -1; - - /* - * On va chercher l'attribut taille du profil - */ - strcpy(chemin,MED_PROFILS); - strcat(chemin,profil); - if ((proid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - if ((ret = _MEDattrEntierLire(proid,MED_NOM_N,n)) < 0) - return -1; - if ((ret = _MEDdatagroupFermer(proid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDprofilLire.cxx b/src/MEDWrapper/V2_1/MEDprofilLire.cxx deleted file mode 100644 index c954bddf8..000000000 --- a/src/MEDWrapper/V2_1/MEDprofilLire.cxx +++ /dev/null @@ -1,92 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -namespace med_2_1{ - -med_err -MEDprofilLire(med_idt fid,med_int *pflval, char *nom) -{ - med_err ret = 0; - med_idt pid,did; - char chemin[MED_TAILLE_PROFILS+MED_TAILLE_NOM+1]; - - /* - * On inhibe le gestionnaire d'erreur HDF 5 - */ - _MEDmodeErreurVerrouiller(); - - /* - * ouverture du groupe /PROFILS/"nom" - */ - strcpy(chemin,MED_PROFILS); - strcat(chemin,nom); - if ((pid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * Lecture du profil - */ -#if defined(IRIX64)||defined(OSF1) - if ((ret = _MEDdatasetNumLire(pid,MED_NOM_PFL,MED_INT64, - MED_NO_INTERLACE,1,MED_ALL, - MED_NOPF,0,MED_NOPG, - (unsigned char *) pflval)) < 0) - return -1; -#else - if ((ret = _MEDdatasetNumLire(pid,MED_NOM_PFL,MED_INT32, - MED_NO_INTERLACE,1,MED_ALL, - MED_NOPF,0,MED_NOPG, - (unsigned char *) pflval)) < 0) - return -1; -#endif - - /* - * On ferme tout - */ - if ((ret = _MEDdatagroupFermer(pid)) < 0) - return -1; - - return ret; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDunvCr.cxx b/src/MEDWrapper/V2_1/MEDunvCr.cxx deleted file mode 100644 index f521e7b67..000000000 --- a/src/MEDWrapper/V2_1/MEDunvCr.cxx +++ /dev/null @@ -1,121 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -#include -#include - -#ifdef PPRO_NT -// Windows Header Files: -#include -#include -#include -#else -#include -#endif - -namespace med_2_1{ - -med_err -MEDunvCr(med_idt fid, char *maa) -{ - med_idt maaid; - char chemin [MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - char nomu [MED_TAILLE_LNOM+1]; - time_t temps; -#ifdef PPRO_NT - struct timeb tp; - char lpBuffer [UNLEN+1]; - long nSize = UNLEN+1; -#else - struct timeval tp; -#endif - med_err ret; - - /* - * On inhibe le gestionnaire d'erreur - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le maillage n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * Creation/Ecriture de l'attribut nom universel - */ - -#ifdef PPRO_NT - if ( GetUserName(lpBuffer,&nSize) == 0 ) return -1; - if ( nSize > MED_TAILLE_NOM ) nSize = MED_TAILLE_NOM; - strncpy(nomu,lpBuffer,nSize); - strcat(nomu," "); - temps=time(&temps); - strcat(nomu,ctime(&temps)); - ftime(&tp); - nSize = strlen(nomu)-1; - if ( sprintf(&nomu[nSize]," %hu",tp.millitm) < 0 ) return -1; -#else - if (cuserid(nomu) == (void*) NULL) return -1; - strcat(nomu," "); - temps=time(&temps); - strcat(nomu,ctime(&temps)); - if ( gettimeofday(&tp,NULL) < 0 ) return -1; - if ( sprintf(&nomu[strlen(nomu)-1]," %li",tp.tv_usec) < 0 ) return -1; -#endif - if ((ret = _MEDattrStringEcrire(maaid,MED_NOM_UNV,MED_TAILLE_LNOM,nomu,MED_REMP)) < 0) - return -1; - - /* - * Nettoyages divers - */ - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDunvLire.cxx b/src/MEDWrapper/V2_1/MEDunvLire.cxx deleted file mode 100644 index 8743cb4e4..000000000 --- a/src/MEDWrapper/V2_1/MEDunvLire.cxx +++ /dev/null @@ -1,85 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -#include -#include - -#include -#include - -namespace med_2_1{ - -med_err -MEDunvLire(med_idt fid, char *maa,char *nomu) -{ - med_idt maaid; - char chemin [MED_TAILLE_MAA+MED_TAILLE_NOM+1]; - med_err ret; - - /* - * On inhibe le gestionnaire d'erreur - */ - _MEDmodeErreurVerrouiller(); - - /* - * Si le maillage n'existe pas => erreur - */ - strcpy(chemin,MED_MAA); - strcat(chemin,maa); - if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) - return -1; - - /* - * Creation/Ecriture de l'attribut nom universel - */ - if ((ret = _MEDattrStringLire(maaid,MED_NOM_UNV,MED_TAILLE_LNOM, - nomu )) < 0) - return -1; - - /* - * Nettoyages divers - */ - if ((ret = _MEDdatagroupFermer(maaid)) < 0) - return -1; - - return 0; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDversionConforme.cxx b/src/MEDWrapper/V2_1/MEDversionConforme.cxx deleted file mode 100644 index 201c2daf1..000000000 --- a/src/MEDWrapper/V2_1/MEDversionConforme.cxx +++ /dev/null @@ -1,87 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -namespace med_2_1{ - -med_err -MEDversionConforme(const char *nom) { - med_int majeur, mineur; - med_idt fid, gid; - med_err ret; - - /* - * On inhibe le gestionnaire d'erreur HDF - */ - _MEDmodeErreurVerrouiller(); - - /* - * On ouvre le fichier MED en mode MED_LECT - */ - if ((fid = _MEDfichierOuvrir((char *)nom,MED_LECT)) < 0) - return -1; - - /* - * Lecture du numero de version - */ - if ((gid = _MEDdatagroupOuvrir(fid,MED_NOM_INFOS)) < 0) - return -1; - - if ((ret = _MEDattrEntierLire(gid,MED_NOM_MAJEUR,&majeur)) < 0) - return -1; - - if ((ret = _MEDattrEntierLire(gid,MED_NOM_MINEUR,&mineur)) < 0) - return -1; - - /* - * On ferme tout - */ - if ((ret = _MEDdatagroupFermer(gid)) < 0) - return -1; - - if ((ret = _MEDfichierFermer(fid)) < 0) - return -1; - - if ((majeur == MED_NUM_MAJEUR) && (mineur == MED_NUM_MINEUR)) - return 0; - else - return -1; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDversionDonner.cxx b/src/MEDWrapper/V2_1/MEDversionDonner.cxx deleted file mode 100644 index e3f725d8a..000000000 --- a/src/MEDWrapper/V2_1/MEDversionDonner.cxx +++ /dev/null @@ -1,50 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -namespace med_2_1{ - -void -MEDversionDonner(med_int *majeur, med_int *mineur, med_int *release) { - *majeur = MED_NUM_MAJEUR; - *mineur = MED_NUM_MINEUR; - *release = MED_NUM_RELEASE; -} - -} diff --git a/src/MEDWrapper/V2_1/MEDversionLire.cxx b/src/MEDWrapper/V2_1/MEDversionLire.cxx deleted file mode 100644 index 56feeb542..000000000 --- a/src/MEDWrapper/V2_1/MEDversionLire.cxx +++ /dev/null @@ -1,74 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#include "med.hxx" -#include "med_outils.hxx" - -namespace med_2_1{ - -med_err -MEDversionLire(med_idt fid, med_int *majeur, med_int *mineur, med_int *release) -{ - med_err ret = 0; - med_idt gid; - - /* On ouvre le group ou se trouvent les infos */ - if ((gid = _MEDdatagroupOuvrir(fid,MED_NOM_INFOS)) < 0) { - *majeur = 2; - *mineur = -1; - *release = -1; - ret = 0; - } - else { - if ((ret = _MEDattrEntierLire(gid,MED_NOM_MAJEUR,majeur)) < 0) - return -1; - - if ((ret = _MEDattrEntierLire(gid,MED_NOM_MINEUR,mineur)) < 0) - return -1; - - if ((ret = _MEDattrEntierLire(gid,MED_NOM_RELEASE,release)) < 0) - return -1; - - /* On ferme tout */ - if ((ret = _MEDdatagroupFermer(gid)) < 0) - return -1; - } - - return ret; -} - -} diff --git a/src/MEDWrapper/V2_1/Makefile.in b/src/MEDWrapper/V2_1/Makefile.in index 778b27267..906408d74 100644 --- a/src/MEDWrapper/V2_1/Makefile.in +++ b/src/MEDWrapper/V2_1/Makefile.in @@ -34,137 +34,6 @@ VPATH=.:@srcdir@:@top_srcdir@/idl @COMMENCE@ -LIB_SRC_TOOLS_HDFI= \ -MEDattrFermer.cxx \ -MEDattrNumEcrire.cxx \ -MEDattrNumLire.cxx \ -MEDattrOuvrir.cxx \ -MEDattrStringEcrire.cxx \ -MEDattrStringLire.cxx \ -MEDdatagroupCreer.cxx \ -MEDdatagroupFermer.cxx \ -MEDdatagroupOuvrir.cxx \ -MEDdatasetFermer.cxx \ -MEDdatasetNumEcrire.cxx \ -MEDdatasetNumLire.cxx \ -MEDdatasetOuvrir.cxx \ -MEDdatasetStringEcrire.cxx \ -MEDdatasetStringLire.cxx \ -MEDfichierCreer.cxx \ -MEDfichierFermer.cxx \ -MEDfichierOuvrir.cxx \ -MEDindiceInfo.cxx \ -MEDindiceNum.cxx \ -MEDmodeErreurVerrouiller.cxx \ -MEDnObjets.cxx \ -MEDobjetIdentifer.cxx +SUBDIRS = Core Wrapper -LIB_SRC_TOOLS_MISC= \ -MED1cstring.cxx MEDnomDataset.cxx \ -MED2cstring.cxx MEDnomEntite.cxx \ -MEDGeometrieElement.cxx MEDnomGeometrie.cxx \ -MEDcstringFree.cxx MEDparametresGeometrie.cxx \ -MEDfstring.cxx - -LIB_SRC_API_CI= \ -MEDchampCr.cxx \ -MEDchampEcr.cxx \ -MEDchampInfo.cxx \ -MEDchampLire.cxx \ -MEDconnEcr.cxx \ -MEDconnLire.cxx \ -MEDcoordEcr.cxx \ -MEDcoordLire.cxx \ -MEDdimLire.cxx \ -MEDelementsEcr.cxx \ -MEDelementsLire.cxx \ -MEDequivCr.cxx \ -MEDequivEcr.cxx \ -MEDequivInfo.cxx \ -MEDequivLire.cxx \ -MEDfam2groA.cxx \ -MEDfam2groB.cxx \ -MEDfamCr.cxx \ -MEDfamEcr.cxx \ -MEDfamInfo.cxx \ -MEDfamLire.cxx \ -MEDfamMaaCr.cxx \ -MEDfamMaaInfo.cxx \ -MEDfamMaaLire.cxx \ -MEDfermer.cxx \ -MEDfichDesEcr.cxx \ -MEDfichEntete.cxx \ -MEDgro2famA.cxx \ -MEDgro2famB.cxx \ -MEDlFichDes.cxx \ -MEDmaaCr.cxx \ -MEDmaaInfo.cxx \ -MEDnChamp.cxx \ -MEDnCorres.cxx \ -MEDnEntMaa.cxx \ -MEDnEntites.cxx \ -MEDnEquiv.cxx \ -MEDnFam.cxx \ -MEDnMaa.cxx \ -MEDnPasdetemps.cxx \ -MEDnProfil.cxx \ -MEDnVal.cxx \ -MEDnValProfil.cxx \ -MEDnbnoisEcr.cxx \ -MEDnbnoisLire.cxx \ -MEDnbnomaEcr.cxx \ -MEDnbnomaLire.cxx \ -MEDnbnosoEcr.cxx \ -MEDnbnosoLire.cxx \ -MEDnoeudsEcr.cxx \ -MEDnoeudsLire.cxx \ -MEDnomEcr.cxx \ -MEDnomLire.cxx \ -MEDnumEcr.cxx \ -MEDnumLire.cxx \ -MEDouvrir.cxx \ -MEDpasdetempsInfo.cxx \ -MEDprofilEcr.cxx \ -MEDprofilLire.cxx \ -MEDprofilInfo.cxx \ -MEDunvCr.cxx \ -MEDunvLire.cxx \ -MEDformatConforme.cxx \ -MEDversionConforme.cxx \ -MEDversionDonner.cxx \ -MEDversionLire.cxx \ -MEDbodyFittedEcr.cxx \ -MEDbodyFittedLire.cxx \ -MEDfamGridEcr.cxx \ -MEDfamGridLire.cxx \ -MEDgridCr.cxx \ -MEDgridEcr.cxx \ -MEDgridInfo.cxx \ -MEDgridLire.cxx \ -MEDnGrid.cxx - -# Libraries targets - -LIB = libMEDWrapper_V2_1.la -LIB_SRC = \ - $(LIB_SRC_TOOLS_HDFI) \ - $(LIB_SRC_TOOLS_MISC) \ - $(LIB_SRC_API_CI) \ - MED_V2_1_Wrapper.cxx - -EXPORT_HEADERS = \ - MED_V2_1_Wrapper.hxx \ - med.hxx \ - med_proto.hxx - -# Executables targets -BIN = mdump_V2_1 test1_V2_1 -BIN_SRC = - -CPPFLAGS+= -D@MACHINE@ $(BOOST_CPPFLAGS) $(HDF5_INCLUDES) - -LDFLAGS+= $(HDF5_LIBS) -lMEDWrapperBase - -LDFLAGSFORBIN=$(LDFLAGS) - -@CONCLUDE@ +@MODULE@ diff --git a/src/MEDWrapper/V2_1/Wrapper/MED_V2_1_Wrapper.cxx b/src/MEDWrapper/V2_1/Wrapper/MED_V2_1_Wrapper.cxx new file mode 100644 index 000000000..0b95e7646 --- /dev/null +++ b/src/MEDWrapper/V2_1/Wrapper/MED_V2_1_Wrapper.cxx @@ -0,0 +1,1211 @@ +// +// +// Copyright (C) 2003 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// +// +// File : +// Author : +// Module : +// $Header$ + +#include "MED_V2_1_Wrapper.hxx" +#include "MED_Algorithm.hxx" +#include "MED_Utilities.hxx" + +#include "med.hxx" +using namespace med_2_1; + +#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 + GetLNOMLength() + { + return 80; + } + + template<> + TInt + GetNOMLength() + { + return 32; + } + + template<> + TInt + GetPNOMLength() + { + return 8; + } + + template<> + TInt + GetNbConn(EGeometrieElement typmai, + EEntiteMaillage typent, + TInt mdim) + { + TInt nsup = 0; + + if(typent == eMAILLE){ + TInt edim = typmai / 100; + if(mdim == 2 || mdim == 3) + if(edim == 1) + nsup = 1; + + if(mdim == 3) + if (edim == 2) + nsup = 1; + } + + return nsup + typmai%100; + } + + namespace V2_1 + { + + //--------------------------------------------------------------- + class TFile{ + TFile(); + TFile(const TFile&); + + public: + TFile(const std::string& theFileName): + myFid(-1), + myCount(0), + myFileName(theFileName) + {} + + ~TFile(){ + Close(); + } + + void Open(EModeAcces theMode, TErr* theErr = NULL){ + if(myCount++ == 0){ + char* aFileName = const_cast(myFileName.c_str()); + myFid = MEDouvrir(aFileName,med_mode_acces(theMode)); + } + if(theErr){ + *theErr = TErr(myFid); + INITMSG(MYDEBUG && myFid < 0,"TFile::Open - MED_MODE_ACCES = "<Open(theMode,theErr); + } + + ~TFileWrapper(){ + myFile->Close(); + } + }; + + + //--------------------------------------------------------------- + TVWrapper + ::TVWrapper(const std::string& theFileName): + myFile(new TFile(theFileName)) + {} + + + TInt + TVWrapper + ::GetNbMeshes(TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return -1; + + return MEDnMaa(myFile->Id()); + } + + + void + TVWrapper + ::GetMeshInfo(TInt theMeshId, + TMeshInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return; + + TErr aRet = MEDmaaInfo(myFile->Id(), + theMeshId, + &theInfo.myName[0], + (med_int*)&theInfo.myDim); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"GetMeshInfo - MEDmaaInfo(...)"); + } + + + void + TVWrapper + ::SetMeshInfo(const TMeshInfo& theInfo, + EModeAcces theMode, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,theMode,theErr); + + if(theErr && *theErr < 0) + return; + + TMeshInfo& anInfo = const_cast(theInfo); + + TErr aRet = MEDmaaCr(myFile->Id(), + &anInfo.myName[0], + anInfo.myDim); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"SetMeshInfo - MEDmaaCr(...)"); + } + + + void + TVWrapper + ::SetMeshInfo(const TMeshInfo& theInfo, + TErr* theErr) + { + TErr aRet; + SetMeshInfo(theInfo,eECRI,&aRet); + + if(aRet < 0) + SetMeshInfo(theInfo,eREMP,theErr); + } + + + TInt + TVWrapper + ::GetNbFamilies(const TMeshInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return -1; + + TMeshInfo& anInfo = const_cast(theInfo); + + return MEDnFam(myFile->Id(), + &anInfo.myName[0], + 0, + MED_FAMILLE); + } + + + TInt + TVWrapper + ::GetNbFamAttr(TInt theFamId, + const TMeshInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return -1; + + TMeshInfo& anInfo = const_cast(theInfo); + + return MEDnFam(myFile->Id(), + &anInfo.myName[0], + theFamId, + MED_ATTR); + } + + + TInt + TVWrapper + ::GetNbFamGroup(TInt theFamId, + const TMeshInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return -1; + + TMeshInfo& anInfo = const_cast(theInfo); + + return MEDnFam(myFile->Id(), + &anInfo.myName[0], + theFamId, + MED_GROUPE); + } + + + void + TVWrapper + ::GetFamilyInfo(TInt theFamId, + TFamilyInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return; + + TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; + + med_int* anAttrId = theInfo.myNbAttr > 0? (med_int*)&theInfo.myAttrId[0]: NULL; + med_int* anAttrVal = theInfo.myNbAttr > 0? (med_int*)&theInfo.myAttrVal[0]: NULL; + char* anAttrDesc = theInfo.myNbAttr > 0? &theInfo.myAttrDesc[0]: NULL; + char* aGroupNames = theInfo.myNbGroup > 0? &theInfo.myGroupNames[0]: NULL; + + TErr aRet = MEDfamInfo(myFile->Id(), + &aMeshInfo.myName[0], + theFamId, + &theInfo.myName[0], + (med_int*)&theInfo.myId, + anAttrId, + anAttrVal, + anAttrDesc, + (med_int*)&theInfo.myNbAttr, + aGroupNames, + (med_int*)&theInfo.myNbGroup); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"GetFamilyInfo - MEDfamInfo - "<< + "&aMeshInfo.myName[0] = '"<<&aMeshInfo.myName[0]<<"'; "<< + "theFamId = "<(theMeshInfo); + + TInt aRet = MEDnEntMaa(myFile->Id(), + &aMeshInfo.myName[0], + MED_COOR, + MED_NOEUD, + med_geometrie_element(0), + med_connectivite(0)); + return aRet; + } + + + void + TVWrapper + ::GetNodeInfo(TNodeInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return; + + TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; + + TErr aRet = MEDnoeudsLire(myFile->Id(), + &aMeshInfo.myName[0], + aMeshInfo.myDim, + &theInfo.myCoord[0], + med_mode_switch(theInfo.myModeSwitch), + (med_repere*)&theInfo.mySystem, + &theInfo.myCoordNames[0], + &theInfo.myCoordUnits[0], + &theInfo.myElemNames[0], + (med_booleen*)&theInfo.myIsElemNames, + (med_int*)&theInfo.myElemNum[0], + (med_booleen*)&theInfo.myIsElemNum, + (med_int*)&theInfo.myFamNum[0], + theInfo.myNbElem); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"GetNodeInfo - MEDnoeudsLire(...)"); + } + + + 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; + + char* anElemNames = theInfo.myIsElemNames? &anInfo.myElemNames[0]: NULL; + med_int* anElemNum = theInfo.myIsElemNum? &anInfo.myElemNum[0]: NULL; + + TErr aRet = MEDnoeudsEcr(myFile->Id(), + &aMeshInfo.myName[0], + aMeshInfo.myDim, + &anInfo.myCoord[0], + med_mode_switch(theInfo.myModeSwitch), + med_repere(theInfo.mySystem), + &anInfo.myCoordNames[0], + &anInfo.myCoordUnits[0], + anElemNames, + med_booleen(theInfo.myIsElemNames), + anElemNum, + med_booleen(theInfo.myIsElemNum), + (med_int*)&anInfo.myFamNum[0], + anInfo.myNbElem, + MED_REMP); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"SetNodeInfo - MEDnoeudsEcr(...)"); + } + + + void + TVWrapper + ::SetNodeInfo(const MED::TNodeInfo& theInfo, + TErr* theErr) + { + TErr aRet; + SetNodeInfo(theInfo,eECRI,&aRet); + + if(aRet < 0) + SetNodeInfo(theInfo,eREMP,theErr); + } + + + TEntityInfo + TVWrapper + ::GetEntityInfo(const TMeshInfo& theMeshInfo, + EConnectivite theConnMode, + TErr* theErr) + { + TEntityInfo anInfo; + + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return anInfo; + + 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) + anInfo[anEntity][aGeom] = aNbElem; + } + } + } + return anInfo; + } + + + TInt + TVWrapper + ::GetNbCells(const MED::TMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return -1; + + MED::TMeshInfo& aMeshInfo = const_cast(theMeshInfo); + + return MEDnEntMaa(myFile->Id(), + &aMeshInfo.myName[0], + MED_CONN, + med_entite_maillage(theEntity), + med_geometrie_element(theGeom), + med_connectivite(theConnMode)); + } + + + void + TVWrapper + ::GetCellInfo(MED::TCellInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return; + + MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; + TInt aNbElem = theInfo.myElemNum.size(); + + TErr aRet; + aRet = MEDelementsLire(myFile->Id(), + &aMeshInfo.myName[0], + aMeshInfo.myDim, + (med_int*)&theInfo.myConn[0], + med_mode_switch(theInfo.myModeSwitch), + &theInfo.myElemNames[0], + (med_booleen*)&theInfo.myIsElemNames, + (med_int*)&theInfo.myElemNum[0], + (med_booleen*)&theInfo.myIsElemNum, + (med_int*)&theInfo.myFamNum[0], + aNbElem, + med_entite_maillage(theInfo.myEntity), + med_geometrie_element(theInfo.myGeom), + med_connectivite(theInfo.myConnMode)); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"GetCellInfo - MEDelementsLire(...)"); + } + + + 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; + + char* anElemNames = theInfo.myIsElemNames? &anInfo.myElemNames[0]: NULL; + med_int* anElemNum = theInfo.myIsElemNum? &anInfo.myElemNum[0]: NULL; + + TErr aRet; + aRet = MEDelementsEcr(myFile->Id(), + &aMeshInfo.myName[0], + aMeshInfo.myDim, + (med_int*)&anInfo.myConn[0], + med_mode_switch(theInfo.myModeSwitch), + anElemNames, + med_booleen(theInfo.myIsElemNames), + anElemNum, + med_booleen(theInfo.myIsElemNum), + (med_int*)&anInfo.myFamNum[0], + anInfo.myNbElem, + med_entite_maillage(theInfo.myEntity), + med_geometrie_element(theInfo.myGeom), + med_connectivite(theInfo.myConnMode), + MED_REMP); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"GetCellInfo - MEDelementsLire(...)"); + } + + + void + TVWrapper + ::SetCellInfo(const MED::TCellInfo& theInfo, + TErr* theErr) + { + TErr aRet; + SetCellInfo(theInfo,eECRI,&aRet); + + if(aRet < 0) + SetCellInfo(theInfo,eREMP,theErr); + } + + + TInt + TVWrapper + ::GetNbFields(TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return -1; + + return MEDnChamp(myFile->Id(),0); + } + + + TInt + TVWrapper + ::GetNbComp(TInt theFieldId, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return -1; + + return MEDnChamp(myFile->Id(),theFieldId); + } + + + void + TVWrapper + ::GetFieldInfo(TInt theFieldId, + MED::TFieldInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return; + + TErr aRet; + aRet = MEDchampInfo(myFile->Id(), + theFieldId, + &theInfo.myName[0], + (med_type_champ*)&theInfo.myType, + &theInfo.myCompNames[0], + &theInfo.myUnitNames[0], + theInfo.myNbComp); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"GetFieldInfo - MEDchampInfo(...)"); + } + + + 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); + + TErr aRet; + aRet = MEDchampCr(myFile->Id(), + &anInfo.myName[0], + med_type_champ(theInfo.myType), + &anInfo.myCompNames[0], + &anInfo.myUnitNames[0], + anInfo.myNbComp); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"SetFieldInfo - MEDchampCr(...)"); + } + + + void + TVWrapper + ::SetFieldInfo(const MED::TFieldInfo& theInfo, + TErr* theErr) + { + try{ + + TErr aRet; + SetFieldInfo(theInfo,eECRI,&aRet); + + if(aRet < 0) + SetFieldInfo(theInfo,eREMP,theErr); + + }catch(const std::exception& theExc){ + EXCEPTION(runtime_error,"SetFieldInfo(...)"<Id()); + } + + + TProfileInfo::TInfo + TVWrapper + ::GetProfilePreInfo(TInt theId, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return TProfileInfo::TInfo("",-1); + + TInt aSize = -1; + TVector aName(GetNOMLength()+1); + + TErr aRet; + aRet = MEDprofilInfo(myFile->Id(), + theId, + &aName[0], + &aSize); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"GetProfilePreInfo - MEDprofilInfo(...)"); + + return TProfileInfo::TInfo(&aName[0],aSize); + } + + + void + TVWrapper + ::GetProfileInfo(TInt theId, + TProfileInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return; + + TErr aRet; + aRet = MEDprofilLire(myFile->Id(), + &theInfo.myElemNum[0], + &theInfo.myName[0]); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"SetNodeInfo - MEDprofilLire(...)"); + } + + + //----------------------------------------------------------------- + TInt + TVWrapper + ::GetNbTimeStamps(const MED::TFieldInfo& theInfo, + const MED::TEntityInfo& theEntityInfo, + EEntiteMaillage& theEntity, + TGeom2Size& theGeom2Size, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr){ + if(theEntityInfo.empty()) + *theErr = -1; + if(*theErr < 0) + return -1; + }else if(theEntityInfo.empty()) + EXCEPTION(runtime_error,"GetNbTimeStamps - There is no any Entity on the Mesh"); + + theGeom2Size.clear(); + TInt aNbTimeStamps = 0; + TIdt anId = myFile->Id(); + + MED::TFieldInfo& anInfo = const_cast(theInfo); + MED::TMeshInfo& aMeshInfo = anInfo.myMeshInfo; + + TEntityInfo::const_iterator anIter = theEntityInfo.begin(); + for(; anIter != theEntityInfo.end(); anIter++){ + med_entite_maillage anEntity = med_entite_maillage(anIter->first); + const TGeom2Size& aGeom2Size = anIter->second; + TGeom2Size::const_iterator anGeomIter = aGeom2Size.begin(); + for(; anGeomIter != aGeom2Size.end(); anGeomIter++){ + med_geometrie_element aGeom = med_geometrie_element(anGeomIter->first); + TInt aNbStamps = MEDnPasdetemps(anId, + &anInfo.myName[0], + anEntity, + aGeom); + if(aNbStamps > 0){ + INITMSG(MYDEBUG, + "GetNbTimeStamps aNbTimeStamps = "<()+1]; + char aDtUnit[GetPNOMLength()+1]; + med_int aNbGauss; + med_int aNumDt; + med_int aNumOrd; + med_float aDt; + TErr aRet = MEDpasdetempsInfo(anId, + &anInfo.myName[0], + anEntity, + aGeom, + iTimeStamp, + aMaillageChamp, + &aNbGauss, + &aNumDt, + aDtUnit, + &aDt, + &aNumOrd); + + INITMSG(MYDEBUG, + "GetNbTimeStamps aMaillageChamp = '"<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,eLECT,theErr); + + const TGeom2Size& aGeom2Size = theInfo.myGeom2Size; + + if(theErr){ + if(aGeom2Size.empty()) + *theErr = -1; + if(*theErr < 0) + return; + }else if(aGeom2Size.empty()) + EXCEPTION(runtime_error,"GetTimeStampInfo - There is no any cell"); + + MED::TFieldInfo& aFieldInfo = *theInfo.myFieldInfo; + MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo; + + TGeom2NbGauss& aGeom2NbGauss = theInfo.myGeom2NbGauss; + + TGeom2Size::const_iterator anIter = aGeom2Size.begin(); + for(; anIter != aGeom2Size.end(); anIter++){ + const EGeometrieElement& aGeom = anIter->first; + med_int aNbGauss = -1; + + TErr aRet; + aRet = MEDpasdetempsInfo(myFile->Id(), + &aFieldInfo.myName[0], + med_entite_maillage(theInfo.myEntity), + med_geometrie_element(anIter->first), + theTimeStampId, + &aMeshInfo.myName[0], + &aNbGauss, + (med_int*)&theInfo.myNumDt, + &theInfo.myUnitDt[0], + &theInfo.myDt, + (med_int*)&theInfo.myNumOrd); + + + 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(runtime_error,"GetTimeStampInfo - MEDpasdetempsInfo(...)"); + } + } + + + void + TVWrapper + ::GetTimeStampVal(TTimeStampVal& theVal, + const TMKey2Profile& theMKey2Profile, + const TKey2Gauss& theKey2Gauss, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return; + + TIdt anId = myFile->Id(); + + MED::TTimeStampInfo& aTimeStampInfo = *theVal.myTimeStampInfo; + MED::TFieldInfo& aFieldInfo = *aTimeStampInfo.myFieldInfo; + MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo; + + 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 aNbVal = MEDnVal(anId, + &aFieldInfo.myName[0], + med_entite_maillage(aTimeStampInfo.myEntity), + med_geometrie_element(aGeom), + aTimeStampInfo.myNumDt, + aTimeStampInfo.myNumOrd); + if(aNbVal <= 0){ + if(theErr){ + *theErr = -1; + return; + } + EXCEPTION(runtime_error,"GetTimeStampVal - MEDnVal(...) - aNbVal == "<second; + theVal.myGeom2Profile[aGeom] = aProfileInfo; + } + } + + if(aProfileInfo && aProfileInfo->IsPresent()){ + TInt aSize = aProfileInfo->GetSize()*aFieldInfo.myNbComp*aNbGauss; + if(aSize > aValue.size()){ + if(theErr){ + *theErr = -1; + return; + } + EXCEPTION(runtime_error, + "GetTimeStampVal - aSize("< aValue.size()("< + TInt + GetDESCLength(); + + template<> + TInt + GetIDENTLength(); + + template<> + TInt + GetNOMLength(); + + template<> + TInt + GetLNOMLength(); + + template<> + TInt + GetPNOMLength(); + + template<> + TInt + GetNbConn(EGeometrieElement typmai, + EEntiteMaillage typent, + TInt mdim); + + namespace V2_1 + { + typedef MED::TTMeshInfo TVMeshInfo; + + typedef MED::TTFamilyInfo TVFamilyInfo; + + typedef MED::TTNodeInfo TVNodeInfo; + + typedef MED::TTCellInfo TVCellInfo; + + typedef MED::TTFieldInfo TVFieldInfo; + + typedef MED::TTTimeStampInfo TVTimeStampInfo; + + typedef MED::TTTimeStampVal TVTimeStampVal; + + //--------------------------------------------------------------- + class TFile; + typedef boost::shared_ptr PFile; + + typedef enum {eLECT, eECRI, eREMP} EModeAcces; + + //--------------------------------------------------------------- + class 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 + TInt + GetNbNodes(const MED::TMeshInfo& theMeshInfo, + 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 + TEntityInfo + GetEntityInfo(const MED::TMeshInfo& theMeshInfo, + EConnectivite theConn = eNOD, + TErr* theErr = NULL); + + virtual + TInt + GetNbCells(const MED::TMeshInfo& theMeshInfo, + EEntiteMaillage, + EGeometrieElement, + EConnectivite theConn = 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); + + + //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + 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 + GetNbProfiles(TErr* theErr = NULL); + + virtual + TProfileInfo::TInfo + GetProfilePreInfo(TInt theId, + TErr* theErr = NULL); + + virtual + void + GetProfileInfo(TInt theId, + TProfileInfo& theInfo, + 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 + GetTimeStampVal(TTimeStampVal& theVal, + const TMKey2Profile& theMKey2Profile, + const TKey2Gauss& theKey2Gauss, + TErr* theErr = NULL); + + virtual + void + SetTimeStamp(const MED::TTimeStampVal& theTimeStampVal, + TErr* theErr = NULL); + + void + SetTimeStamp(const MED::TTimeStampVal& theTimeStampVal, + EModeAcces theMode, + TErr* theErr = NULL); + + protected: + PFile myFile; + }; + } +} + +#endif diff --git a/src/MEDWrapper/V2_1/Wrapper/Makefile.in b/src/MEDWrapper/V2_1/Wrapper/Makefile.in new file mode 100644 index 000000000..75c57b2d5 --- /dev/null +++ b/src/MEDWrapper/V2_1/Wrapper/Makefile.in @@ -0,0 +1,56 @@ +# +# +# Copyright (C) 2003 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +# +# +# +# File : +# Author : +# Module : +# $Header$ + +top_srcdir=@top_srcdir@ +top_builddir=../../../.. +srcdir=@srcdir@ +VPATH=.:@srcdir@:@top_srcdir@/idl + + +@COMMENCE@ + +# Libraries targets + +LIB = libMEDWrapper_V2_1.la +LIB_SRC = \ + MED_V2_1_Wrapper.cxx + +EXPORT_HEADERS = \ + MED_V2_1_Wrapper.hxx + +# Executables targets +BIN = +BIN_SRC = + +CPPFLAGS+= -D@MACHINE@ $(BOOST_CPPFLAGS) $(HDF5_INCLUDES) + +LDFLAGS+= $(HDF5_LIBS) -lMEDWrapperBase -lmed_V2_1 + +LDFLAGSFORBIN=$(LDFLAGS) + +@CONCLUDE@ diff --git a/src/MEDWrapper/V2_1/mdump_V2_1.cxx b/src/MEDWrapper/V2_1/mdump_V2_1.cxx deleted file mode 100644 index 7c9c125e0..000000000 --- a/src/MEDWrapper/V2_1/mdump_V2_1.cxx +++ /dev/null @@ -1,1645 +0,0 @@ -// Copyright (C) 2005 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/ -// -/****************************************************************************** - * - Nom du fichier : mdump.c - * - * - Description : utilitaire de dump pour fichier MED V2.1 - * - *****************************************************************************/ -#define NBR_MAILLE_EQU 7 - -#include -#include -#include - -#include "med.hxx" -using namespace med_2_1; - -/******************************************************************* - * DUMP D'UN FICHIER MED STRUCTURE EN GRILLE : * - * NOEUDS, ELEMENTS, FAMILLES, EQUIVALENCES, CHAMPS DE RESULTATS * - *******************************************************************/ - -int grid_cartesian_or_polar(med_idt fid, int numero, med_mode_switch mode_coo) { - med_int mdim, nnoe, nfam, i, j; - char nommaa[MED_TAILLE_NOM+1]; - char nom_universel[MED_TAILLE_LNOM+1]; - med_float *coo; - med_int *fam; - char nomcoo[3*MED_TAILLE_PNOM+1]; - char unicoo[3*MED_TAILLE_PNOM+1]; - med_repere rep; - char str[MED_TAILLE_PNOM+1]; - - fprintf(stdout,"\n(****************************)\n"); - fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n"); - fprintf(stdout,"(****************************)\n"); - - /* lecture du nom et de la dimension de la grille */ - if (MEDmaaInfo(fid, numero, nommaa, &mdim) < 0) { - fprintf(stderr, ">> ERREUR : lecture du nom de la grille\n"); - return(EXIT_FAILURE); - }; - fprintf(stdout, "- Nom de la grille : <<%s>>\n", nommaa); - fprintf(stdout, "- Dimension de la grille : %d\n", mdim); - - /* lecture du nom universel (presence optionnelle) */ - if (MEDunvLire(fid, nommaa, nom_universel) > 0) { - fprintf(stdout, "- Nom universel de la grille : %s \n", nom_universel); - } else { - fprintf(stdout, "- Pas de nom universel \n"); - }; - - /* nombre de familles */ - nfam = MEDnFam(fid, nommaa, 0, (med_dim_famille)0); - if (nfam < 0) { - fprintf(stderr, ">> ERREUR : lecture du nombre de familles\n"); - return(EXIT_FAILURE); - }; - fprintf(stdout, "- Nombre de familles : %d \n", nfam); - - fprintf(stdout, "\n- Lecture des indices : \n"); - for (i=0; i> ERREUR : lecture des indices \n"); - return(EXIT_FAILURE); - }; - - fprintf(stdout, "- Type de repere des coordonnees : %d \n", rep); - - fprintf(stdout, "- Nom des coordonnees : \n"); - for (j=0; j 0) { - fam = (med_int*)malloc(sizeof(med_int)*nfam); - if (MEDfamGridLire(fid, nommaa, fam, nfam,MED_NOEUD) < 0) { - fprintf(stderr, ">> ERREUR : lecture des familles\n"); - return(EXIT_FAILURE); - }; - - fprintf(stdout, "\n- Numeros des familles des noeuds :\n"); - for (i=0; i> ERREUR : lecture du nom du maillage body fitted\n"); - return(EXIT_FAILURE); - }; - fprintf(stdout, "- Nom du maillage body fitted : <<%s>>\n", nommaa); - fprintf(stdout, "- Dimension du maillage body fitted : %d\n", mdim); - - /* lecture du nom universel (presence optionnelle) */ - if (MEDunvLire(fid, nommaa, nom_universel) > 0) { - fprintf(stdout, "- Nom universel du maillage body fitted : %s \n", nom_universel); - } else { - fprintf(stdout, "- Pas de nom universel \n"); - }; - - /* Combien de noeuds ? */ - /* nnoe = MEDnGrid(fid, nommaa, -1);*/ - nnoe = MEDnGrid(fid, nommaa, MED_GRID_NOEUD); - if (nnoe < 0) { - fprintf(stderr, ">> ERREUR : lecture du nombre de noeuds (via MEDnGrid) \n"); - return(EXIT_FAILURE); - }; - fprintf(stdout, "- Nombre de noeuds : %d \n", nnoe); - - /* Combien de noeuds dans la dimension 1 ? */ - i = MEDnGrid(fid, nommaa, (med_grid)0); - if (i < 0) { - fprintf(stderr, ">> ERREUR : lecture du nombre de noeuds (via MEDnGrid) dans la dimension 1 \n"); - return(EXIT_FAILURE); - }; - fprintf(stdout, "- Nombre de noeuds dans la dimension 1 : %d \n", i); - - /* Combien de noeuds dans la dimension 2 ? */ - i = MEDnGrid(fid, nommaa, (med_grid)1); - if (i < 0) { - fprintf(stderr, ">> ERREUR : lecture du nombre de noeuds (via MEDnGrid) dans la dimension 2 \n"); - return(EXIT_FAILURE); - }; - fprintf(stdout, "- Nombre de noeuds dans la dimension 2 : %d \n", i); - - /* nombre de familles */ - nfam = MEDnFam(fid, nommaa, 0,(med_dim_famille)0); - if (nfam < 0) { - fprintf(stderr, ">> ERREUR : lecture du nombre de familles \n"); - return(EXIT_FAILURE); - }; - fprintf(stdout, "- Nombre de familles : %d \n", nfam); - - coo = (med_float*)malloc(sizeof(med_float)*nnoe*mdim); - fam = (med_int*)malloc(sizeof(med_int)*nnoe); - - if (MEDbodyFittedLire(fid, nommaa, mdim, coo, mode_coo, &rep, nomcoo, unicoo, fam, nnoe) < 0) { - fprintf(stderr, ">> ERREUR : lecture des noeuds \n"); - return(EXIT_FAILURE); - }; - - fprintf(stdout, "- Type de repere des coordonnees : %d \n", rep); - - fprintf(stdout, "- Nom des coordonnees : \n"); - for (i=0; i> ERREUR : type de maillage inconnu\n"); - return(EXIT_FAILURE); - }; - }; -} - -/****************************************************************************** - * DUMP D'UN FICHIER MED : NOEUDS, - * ELEMENTS, FAMILLES, EQUIVALENCES, CHAMPS DE RESULTATS - *****************************************************************************/ - -int main (int argc, char **argv) -{ - med_err ret = 0; - med_idt fid; - int i,j,k,l,kp; - int numero; - char message[200]; - /* nombre d'objets MED */ - char nom_universel[MED_TAILLE_LNOM+1]; - med_int long_fichier_en_tete; - char *fichier_en_tete; - char version_hdf[10]; - char version_med[10]; - med_int nmaa,mdim,nnoe; - med_int nmai[MED_NBR_GEOMETRIE_MAILLE],nfac[MED_NBR_GEOMETRIE_FACE]; - med_int nare[MED_NBR_GEOMETRIE_ARETE]; - /* nom du maillage */ - char nommaa[MED_TAILLE_NOM+1]; - /* noeuds */ - med_float *coo; - char nomcoo[3*MED_TAILLE_PNOM+1]; - char unicoo[3*MED_TAILLE_PNOM+1]; - char *nomnoe; - med_int *numnoe; - med_int *nufano; - med_repere rep; - med_booleen inonoe,inunoe; - med_mode_switch mode_coo; - char str[MED_TAILLE_PNOM+1]; - /* elements */ - med_int nsup; - med_int edim; - med_int taille; - med_int *connectivite; - char *nomele; - med_int *numele; - med_int *nufael; - med_booleen inoele, inuele; - med_connectivite typ_con; - med_geometrie_element typgeo; - med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE] = {MED_POINT1,MED_SEG2, - MED_SEG3,MED_TRIA3, - MED_TRIA6,MED_QUAD4, - MED_QUAD8,MED_TETRA4, - MED_TETRA10,MED_HEXA8, - MED_HEXA20,MED_PENTA6, - MED_PENTA15,MED_PYRA5, - MED_PYRA13}; - med_int desmai[MED_NBR_GEOMETRIE_MAILLE] = {0,2,3,3,3,4,4,4,4,6,6,5,5,5,5}; - med_int nmailles[MED_NBR_GEOMETRIE_MAILLE]; - char nommai[MED_NBR_GEOMETRIE_MAILLE] [MED_TAILLE_NOM+1] = {"MED_POINT1", - "MED_SEG2", - "MED_SEG3", - "MED_TRIA3", - "MED_TRIA6", - "MED_QUAD4", - "MED_QUAD8", - "MED_TETRA4", - "MED_TETRA10", - "MED_HEXA8", - "MED_HEXA20", - "MED_PENTA6", - "MED_PENTA15", - "MED_PYRA5", - "MED_PYRA13"}; - med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6, - MED_QUAD4,MED_QUAD8}; - med_int desfac[MED_NBR_GEOMETRIE_FACE] = {3,3,4,4}; - med_int nfaces[MED_NBR_GEOMETRIE_FACE]; - char nomfac[MED_NBR_GEOMETRIE_FACE][MED_TAILLE_NOM+1] = {"MED_TRIA3","MED_TRIA6", - "MED_QUAD4","MED_QUAD8"}; - med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3}; - med_int desare[MED_NBR_GEOMETRIE_ARETE] = {2,3}; - med_int naretes[MED_NBR_GEOMETRIE_ARETE]; - char nomare[MED_NBR_GEOMETRIE_ARETE] [MED_TAILLE_NOM+1] = {"MED_SEG2","MED_SEG3"}; - /* familles */ - med_int nfam; - med_int natt,ngro; - char *attdes,*gro; - med_int *attval,*attide; - char nomfam[MED_TAILLE_NOM+1]; - med_int numfam; - char str1[MED_TAILLE_DESC+1]; - char str2[MED_TAILLE_LNOM+1]; - /* equivalences */ - med_int nequ,ncor; - med_int *cor; - char equ[MED_TAILLE_NOM+1]; - char des[MED_TAILLE_DESC+1]; - /* champs de resultats */ - char *comp; - char *unit; - char nomcha[MED_TAILLE_NOM+1]; - char maillage_champ[MED_TAILLE_NOM+1]; - med_int ncomp; - med_float *valr; - med_int *vale; - med_type_champ typcha; - med_int ncha; - med_int nval; - int reponse; - int lecture_en_tete_seulement = 0; - med_int npdt; - med_int ngauss,numdt,numo; - med_float dt; - char dtunit[MED_TAILLE_PNOM+1]; - char pflnom[MED_TAILLE_NOM+1]; - med_int pflsize; - med_int *pflval; - med_int isGrid; - med_grid_type theType; - - /**************************************************************************** - * TEST DU NOMBRE D'ARGUMENTS * - * argument 1 = nom du fichier MED * - ****************************************************************************/ - if (argc != 2 && argc != 5) - { - fprintf(stderr,">> ERREUR : nombre de parametres incorrects \n"); - exit(EXIT_FAILURE); - } - - /**************************************************************************** - * OUVERTURE DU FICHIER EN LECTURE * - ****************************************************************************/ - fid = MEDouvrir(argv[1],MED_LECT); - if (fid < 0) - { - fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",argv[1]); - exit(EXIT_FAILURE); - } - - - /**************************************************************************** - * QUESTIONS PRELIMINAIRES * - * 1. Mode d'affichage des coordonnees (entrelace ou non) ? * - * 2. Connectivite des elements (nodale ou descendante) * - ****************************************************************************/ - fprintf(stdout,"\n >>>>>> DUMP DU FICHIER %s >>>>>>\n",argv[1]); - - /* en-tete du fichier (presence optionnelle) */ - long_fichier_en_tete = MEDlFichDes(fid); - if (long_fichier_en_tete > 0) - { - fichier_en_tete = (char *) malloc(sizeof(char)*(long_fichier_en_tete+1)); - ret = MEDfichEntete(fid,MED_FICH_DES,fichier_en_tete); - if (ret < 0) - { - fprintf(stderr,">> ERREUR : lecture de l'en-tete du fichier \n"); - exit(EXIT_FAILURE); - } - fprintf(stdout,"- En-tete du fichier : %s \n",fichier_en_tete); - free(fichier_en_tete); - } - /* versions hdf et med */ - ret = MEDfichEntete(fid,MED_HDF_VERSION,version_hdf); - if (ret < 0) - { - fprintf(stderr,">> ERREUR : lecture du numero de version de HDF \n"); - exit(EXIT_FAILURE); - } - ret = MEDfichEntete(fid,MED_VERSION,version_med); - if (ret < 0) - { - fprintf(stderr,">> ERREUR : lecture du numero de version de MED \n"); - exit(EXIT_FAILURE); - } - fprintf(stdout,"- Version de HDF utilisee : %s \n",version_hdf); - fprintf(stdout,"- Version de MED utilisee : %s \n",version_med); - - if (argc == 2) - { - fprintf(stdout,"(*****************)\n"); - fprintf(stdout,"(* PARAMETRAGE : *)\n"); - fprintf(stdout,"(*****************)\n"); - fprintf(stdout,"- Mode d'affichage des coordonnées des noeuds ? \n"); - fprintf(stdout," 1. Mode entrelacé : taper 1 \n"); - fprintf(stdout," 2. Mode non entrelacé : taper 2 \n"); - reponse = 0; - do - { - fprintf(stdout," Reponse : "); - scanf("%d",&reponse); - } - while (reponse != 1 && reponse != 2); - if (reponse == 1) - mode_coo = MED_FULL_INTERLACE; - else - mode_coo = MED_NO_INTERLACE; - - fprintf(stdout,"- Connectivité des éléments ? \n"); - fprintf(stdout," 1. Nodale : taper 1 \n"); - fprintf(stdout," 2. Descendante : taper 2 \n"); - reponse = 0; - do - { - fprintf(stdout," Reponse : "); - scanf("%d",&reponse); - } - while (reponse != 1 && reponse != 2); - if (reponse == 1) - typ_con = MED_NOD; - else - typ_con = MED_DESC; - } - else - { - if (! strcmp(argv[3],"NODALE")) - typ_con = MED_NOD; - if (! strcmp(argv[3],"DESCENDANTE")) - typ_con = MED_DESC; - - if (!strcmp(argv[4],"NO_INTERLACE")) - mode_coo = MED_NO_INTERLACE; - if (!strcmp(argv[4],"FULL_INTERLACE")) - mode_coo = MED_FULL_INTERLACE; - if (! strcmp(argv[4],"LECTURE_EN_TETE_SEULEMENT")) - lecture_en_tete_seulement = 1; - - } - - /**************************************************************************** - * QUEL MAILLAGE LIRE * - ****************************************************************************/ - nmaa = MEDnMaa(fid); - if (nmaa < 0) - { - fprintf(stderr,">> ERREUR : lecture du nombre de maillages \n"); - exit(EXIT_FAILURE); - } - - /* Quel maillage lire ? */ - if (argc == 2) - { - fprintf(stdout,"- Il y a %d maillages dans ce fichier \n",nmaa); - fprintf(stdout," Lequel voulez-vous lire (1|2|3|...|n) ?\n"); - do - { - fprintf(stdout," Reponse : "); - scanf("%d",&numero); - } - while (numero > nmaa || numero <= 0); - } - else - { - numero = atoi(argv[2]); - if (numero > nmaa || numero <= 0) - { - fprintf(stderr,">> ERREUR : il y a %d maillages dans ce fichier \n", - nmaa); - exit(EXIT_FAILURE); - } - } - -/***************************************************************************** - * QUELLE SORTE DE MAILLAGE : GRILLE OU PAS * - *****************************************************************************/ - - fprintf(stdout,"\n(**************************************************)\n"); - fprintf(stdout,"(* MAILLAGE STRUCTURE (GRILLE) OU NON STRUCTURE : *)\n"); - fprintf(stdout,"(**************************************************)\n"); - - /* lecture de la sorte de maillage : structure ou pas */ - ret = MEDgridInfo(fid, numero, &isGrid, &theType); - if (ret < 0) { - fprintf(stderr, ">> ERREUR : lecture de la sorte de maillage (structure ou pas)\n"); - exit(EXIT_FAILURE); - }; - fprintf(stdout, "- Sorte de maillage : %s\n", isGrid? "structure (grille)": "non structure"); - if (isGrid) { - ret = grid(fid, numero, theType, mode_coo); - if (ret == 0) { - ret = MEDfermer(fid); - if (ret == 0) { - fprintf(stdout, "\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n", argv[1]); - } else { - fprintf(stderr, ">> ERREUR : erreur a la fermeture du fichier %s\n", argv[1]); - }; - }; - if (ret == 0) { - return(0); - } else { - exit(EXIT_FAILURE); - }; - }; - - /**************************************************************************** - * NOMBRES D'OBJETS MED * - ****************************************************************************/ - fprintf(stdout,"\n(****************************)\n"); - fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n"); - fprintf(stdout,"(****************************)\n"); - - /* lecture du nom et de la dimension du maillage */ - ret = MEDmaaInfo(fid,numero,nommaa,&mdim); - if (ret < 0) - { - fprintf(stderr,">> ERREUR : lecture du nom du maillage \n"); - exit(EXIT_FAILURE); - } - fprintf(stdout,"- Nom du maillage : <<%s>>\n",nommaa); - fprintf(stdout,"- Dimension du maillage : %d\n",mdim); - - /* lecture du nom universel (presence optionnelle) */ - ret = MEDunvLire(fid,nommaa,nom_universel); - if (ret > 0) - fprintf(stdout,"- Nom universel du maillage : %s \n",nom_universel); - else - fprintf(stdout,"- Pas de nom universel \n"); - - - /* Combien de noeuds ? */ - nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,(med_geometrie_element)0,(med_connectivite)0); - if (nnoe < 0) - { - fprintf(stderr,">> ERREUR : lecture du nombre de noeuds (via MEDnEntMaa) \n"); - exit(EXIT_FAILURE); - } - fprintf(stdout,"- Nombre de noeuds : %d \n",nnoe); - - /* Combien de mailles, faces ou aretes ? */ - for (i=0;i> ERREUR : lecture du nombre de mailles \n"); - exit(EXIT_FAILURE); - } - fprintf (stdout,"- Nombre de mailles de type %s : %d \n",nommai[i],nmailles[i]); - } - - for (i=0;i> ERREUR : lecture du nombre de faces \n"); - exit(EXIT_FAILURE); - } - fprintf (stdout,"- Nombre de faces de type %s : %d \n",nomfac[i],nfaces[i]); - } - - for (i=0;i> ERREUR : lecture du nombre d'aretes \n"); - exit(EXIT_FAILURE); - } - fprintf (stdout,"- Nombre d'aretes de type %s : %d \n",nomare[i],naretes[i]); - } - - /* nombre de familles */ - nfam = MEDnFam(fid,nommaa,0,(med_dim_famille)0); - if (nfam < 0) - { - fprintf(stderr,">> ERREUR : lecture du nombre de familles \n"); - exit(EXIT_FAILURE); - } - fprintf(stdout,"- Nombre de familles : %d \n",nfam); - - /* combien d'equivalences dans le fichier */ - nequ = MEDnEquiv(fid,nommaa); - if (nequ < 0) - { - fprintf(stderr,">> ERREUR : lecture du nombre d'equivalences \n"); - exit(EXIT_FAILURE); - } - fprintf(stdout,"- Nombre d'equivalences : %d \n",nequ); - - /* combien de champs dans le fichier */ - ncha = MEDnChamp(fid,0); - if (ncha < 0) - { - fprintf(stderr,">> ERREUR : lecture du nombre de champs \n"); - exit(EXIT_FAILURE); - } - fprintf(stdout,"- Nombre de champs : %d \n",ncha); - - /* Doit-on s'arreter ? */ - if (lecture_en_tete_seulement) - { - ret = MEDfermer(fid); - if (ret == 0) - { - fprintf(stdout,"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1]); - return 0; - } - else - { - fprintf(stderr,">> ERREUR : fermeture du fichier %s \n",argv[1]); - exit(EXIT_FAILURE); - } - } - - /**************************************************************************** - * LECTURE DES NOEUDS * - ****************************************************************************/ - fprintf(stdout,"\n(************************)\n"); - fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n"); - fprintf(stdout,"(************************)\n"); - - /* Allocations memoires */ - /* table des coordonnees - profil : (dimension * nombre de noeuds ) */ - coo = (med_float*) malloc(sizeof(med_float)*nnoe*mdim); - /* table des numeros, des numeros de familles des noeuds - profil : (nombre de noeuds) */ - numnoe = (med_int*) malloc(sizeof(med_int)*nnoe); - nufano = (med_int*) malloc(sizeof(med_int)*nnoe); - /* table des noms des noeuds - profil : (nnoe*MED_TAILLE_PNOM+1) */ - nomnoe = (char*) malloc(MED_TAILLE_PNOM*nnoe+1); - - /* lecture des noeuds : - - coordonnees - - noms (optionnel dans un fichier MED) - - numeros (optionnel dans un fichier MED) - - numeros des familles */ - ret = MEDnoeudsLire(fid,nommaa,mdim,coo,mode_coo,&rep, - nomcoo,unicoo,nomnoe,&inonoe,numnoe,&inunoe, - nufano,nnoe); - if (ret < 0) - strcpy(message,">> ERREUR : lecture des noeuds \n"); - - /* affichage des resultats */ - if (ret == 0) - { - fprintf(stdout,"- Type de repere des coordonnees : %d \n",rep); - fprintf(stdout,"- Nom des coordonnees : \n"); - for (i=0;i 0 && ret == 0) - { - /* dimension de la maille */ - edim = typmai[i] / 100; - nsup = 0; - if (mdim == 2 || mdim == 3) - if (edim == 1) - nsup = 1; - if (mdim == 3) - if (edim == 2) - nsup = 1; - switch(typ_con) - { - case MED_NOD : - taille = nsup+typmai[i]%100; - break; - - case MED_DESC : - taille = nsup+desmai[i]; - break; - - default : - ret = -1; - } - - /* allocation memoire */ - connectivite = (med_int*)malloc(sizeof(med_int)* - taille*nmailles[i]); - nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM* - nmailles[i]+1); - numele = (med_int*)malloc(sizeof(med_int)* - nmailles[i]); - nufael = (med_int*)malloc(sizeof(med_int)* - nmailles[i]); - - /* lecture des données */ - ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo, - nomele,&inoele,numele,&inuele,nufael, - nmailles[i],MED_MAILLE,typmai[i], - typ_con); - if (ret < 0) - strcpy(message,">> ERREUR : lecture des mailles \n"); - - /* affichage des resultats */ - if (ret == 0) - { - fprintf(stdout,"\n\n- Mailles de type %s : ", nommai[i]); - fprintf(stdout,"\n - Connectivité : \n"); - for (j=0;j 0 && ret == 0) - { - /* dimension de la face */ - edim = typfac[i] / 100; - nsup = 0; - if (mdim == 2 || mdim == 3) - if (edim == 1) - nsup = 1; - if (mdim == 3) - if (edim == 2) - nsup = 1; - switch(typ_con) - { - case MED_NOD : - taille = nsup+typfac[i]%100; - break; - - case MED_DESC : - taille = nsup+desfac[i]; - break; - - default : - ret = -1; - } - - /* allocation memoire */ - connectivite = (med_int*)malloc(sizeof(med_int)* - taille*nfaces[i]); - nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM* - nfaces[i]+1); - numele = (med_int*)malloc(sizeof(med_int)* - nfaces[i]); - nufael = (med_int*)malloc(sizeof(med_int)* - nfaces[i]); - - /* lecture des données */ - ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo, - nomele,&inoele,numele,&inuele,nufael, - nfaces[i],MED_FACE,typfac[i], - typ_con); - if (ret < 0) - strcpy(message,">> ERREUR : lecture des faces \n"); - - /* affichage des resultats */ - if (ret == 0) - { - fprintf(stdout,"\n- Faces de type %s : ", nomfac[i]); - fprintf(stdout,"\n - Connectivité : \n"); - for (j=0;j 0 && ret == 0) - { - /* dimension de l'arete */ - edim = typare[i] / 100; - nsup = 0; - if (mdim == 2 || mdim == 3) - if (edim == 1) - nsup = 1; - if (mdim == 3) - if (edim == 2) - nsup = 1; - switch(typ_con) - { - case MED_NOD : - taille = nsup+typare[i]%100; - break; - - case MED_DESC : - taille = nsup+desare[i]; - break; - - default : - ret = -1; - } - - /* allocation memoire */ - connectivite = (med_int*)malloc(sizeof(med_int)* - taille*naretes[i]); - nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM* - naretes[i]+1); - numele = (med_int*)malloc(sizeof(med_int)* - naretes[i]); - nufael = (med_int*)malloc(sizeof(med_int)* - naretes[i]); - - /* lecture des données */ - ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo, - nomele,&inoele,numele,&inuele,nufael, - naretes[i],MED_ARETE,typare[i], - typ_con); - if (ret < 0) - strcpy(message,">> ERREUR : lecture des aretes \n"); - - /* affichage des resultats */ - if (ret == 0) - { - fprintf(stdout,"\n- Aretes de type %d : ", nomare[i]); - fprintf(stdout,"\n - Connectivité : \n"); - for (j=0;j> ERREUR : lecture du nombre de groupes d'une famille \n"); - } - - /* nombre d'attributs */ - if (ret == 0) - { - natt = MEDnFam(fid,nommaa,i+1,MED_ATTR); - if (natt < 0) - { - ret = -1; - strcpy(message, - ">> ERREUR : lecture du nombre d'attributs d'une famille\n"); - } - } - - if (ret == 0) - fprintf(stdout,"- Famille %d a %d attributs et %d groupes \n",i+1,natt,ngro); - - /* nom,numero,attributs,groupes */ - if (ret == 0) - { - attide = (med_int*) malloc(sizeof(med_int)*natt); - attval = (med_int*) malloc(sizeof(med_int)*natt); - attdes = (char *) malloc(MED_TAILLE_DESC*natt+1); - gro = (char*) malloc(MED_TAILLE_LNOM*ngro+1); - ret = MEDfamInfo(fid,nommaa,i+1,nomfam,&numfam,attide,attval, - attdes,&natt,gro,&ngro); - fprintf(stdout," - Famille de nom %s et de numero %d : \n",nomfam,numfam); - fprintf(stdout," - Attributs : \n"); - for (j=0;j> ERREUR : lecture informations sur equivalence\n"); - - /* lecture des correspondances sur les differents types d'entites */ - if (ret == 0) - { - /* les noeuds */ - if ((ncor = MEDnCorres(fid,nommaa,equ,MED_NOEUD,(med_geometrie_element)0)) < 0) - { - ret = -1; - strcpy(message,">> ERREUR : lecture nombre de correspondances\n"); - } - else - fprintf(stdout,"\n - Il y a %d correspondances sur les noeuds \n",ncor); - if (ncor > 0) - { - cor = (med_int*) malloc(sizeof(med_int)*ncor*2); - ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_NOEUD,(med_geometrie_element)0); - if (ret == 0) - for (j=0;j> ERREUR : lecture des correspondances\n"); - free(cor); - } - - /* sur les mailles : on ne prend pas en compte les mailles 3D */ - if (ret ==0) - for (j=0;j> ERREUR : lecture informations sur nombre de correspondances \n"); - } - else - fprintf(stdout,"\n - Il y a %d correspondances sur les mailles %s \n",ncor, - nommai[j]); - if (ncor > 0) - { - cor = (med_int*) malloc(sizeof(med_int)*ncor*2); - ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_MAILLE, - typmai[j]); - if (ret == 0) - for (k=0;k> ERREUR : correspondances\n"); - free(cor); - } - } - - /* sur les faces */ - if (ret == 0) - for (j=0;j> ERREUR : informations sur correspondances \n"); - } - else - fprintf(stdout,"\n - Il y a %d correspondances sur les faces %s\n",ncor, - nomfac[j]); - if (ncor > 0) - { - cor = (med_int*) malloc(sizeof(med_int)*ncor*2); - ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_FACE, - typfac[j]); - if (ret < 0) - strcpy(message,"ERREUR : lecture des equivalences \n"); - else - for (k=0;k> ERREUR : nombre de correspondances \n"); - } - else - fprintf(stdout,"\n - Il y a %d correspondances sur les aretes %s \n", - ncor,nomare[j]); - if (ncor > 0) - { - cor = (med_int*) malloc(sizeof(med_int)*ncor*2); - ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_ARETE, - typare[j]); - if (ret < 0) - strcpy(message,">> ERREUR : equivalences \n"); - else - for (k=0;k> ERREUR : nombre de composants d'un champ\n"); - } - - /* allocation memoire de comp et unit*/ - if (ret == 0) - { - comp = (char*) malloc(ncomp*MED_TAILLE_PNOM+1); - unit = (char*) malloc(ncomp*MED_TAILLE_PNOM+1); - } - - /* infos sur les champs */ - if (ret == 0) - ret = MEDchampInfo(fid,i+1,nomcha,&typcha,comp,unit,ncomp); - if (ret < 0) - strcpy(message,">> ERREUR : information sur les champs \n"); - - if (ret == 0) { - fprintf(stdout," - Nom du champ : %s de type %d\n",nomcha,typcha); - fprintf(stdout," - Nom des composantes : %s\n",comp); - fprintf(stdout," - Unites des composantes : %s \n",unit); - free(comp); - free(unit); - } - - - if (ret == 0) /* Valeurs sur les noeuds */ - { - /* Combien de pas de temps ? */ - npdt = MEDnPasdetemps(fid,nomcha,MED_NOEUD,(med_geometrie_element)0); - if (npdt < 0) - ret = -1; - if (ret == -1) - strcpy(message,">> ERREUR : la lecture du nombe de pas de temps"); - else - fprintf(stdout,"\n - Il y a %d pas de temps sur les noeuds \n",npdt); - - /* Lecture des valeurs pour tous les pas de temps */ - if (ret == 0) - for (j=0;j \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n", - numdt,dt,numo,ngauss); - else - strcpy(message,">> ERREUR : information sur les pas de temps \n"); - - /* Combien de valeurs a lire ? */ - if (ret == 0 && (! strcmp(maillage_champ,nommaa))) - { - if ((nval = MEDnVal(fid,nomcha,MED_NOEUD,(med_geometrie_element)0,numdt,numo)) < 0) - { - ret = -1; - strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n"); - } - else - fprintf(stdout,"\n - Il y a %d valeurs sur les noeuds \n",nval); - } - - if (ret == 0 && (! strcmp(maillage_champ,nommaa))) - { - if (typcha == MED_REEL64) - { - valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval); - ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL, - pflnom,MED_NOEUD,(med_geometrie_element)0,numdt,numo); - - if (ret < 0) - strcpy(message,">> ERREUR : lecture des champs \n"); - else - for (k=0;k> ERREUR : lecture des champs \n"); - else - for (k=0;k> ERREUR : lecture de la taille du profil \n"); - } - else - { - fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize); - pflval = (med_int*) malloc(sizeof(med_int)*pflsize); - - if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0) - strcpy(message,">> ERREUR : lecture du profil \n"); - else - for (l=0;l> ERREUR : la lecture du nombe de pas de temps"); - else - fprintf(stdout,"\n - Il y a %d pas de temps sur les mailles de type %d \n",npdt,typgeo); - - /* Lecture des valeurs pour tous les pas de temps */ - if (ret == 0) - for (j=0;j \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n", - numdt,dt,numo,ngauss); - else - strcpy(message,">> ERREUR : information sur les pas de temps \n"); - - /* Combien de valeurs a lire ? */ - if (ret == 0 && (! strcmp(maillage_champ,nommaa))) - { - if ((nval = MEDnVal(fid,nomcha,MED_MAILLE,typgeo,numdt,numo)) < 0) - { - ret = -1; - strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n"); - } - else - fprintf(stdout,"\n - Il y a %d valeurs sur les noeuds \n",nval); - } - - if (ret == 0 && (! strcmp(maillage_champ,nommaa))) - { - if (typcha == MED_REEL64) - { - valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval); - ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL, - pflnom,MED_MAILLE,typgeo,numdt,numo); - if (ret < 0) - strcpy(message,">> ERREUR : lecture des champs \n"); - else - for (kp=0;kp> ERREUR : lecture des champs \n"); - else - for (kp=0;kp> ERREUR : lecture de la taille du profil \n"); - } - else - { - fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize); - pflval = (med_int*) malloc(sizeof(med_int)*pflsize); - - if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0) - strcpy(message,">> ERREUR : lecture du profil \n"); - else - for (l=0;l> ERREUR : la lecture du nombe de pas de temps"); - else - fprintf(stdout,"\n - Il y a %d pas de temps sur les faces de type %d \n",npdt,typgeo); - - /* Lecture des valeurs pour tous les pas de temps */ - if (ret == 0) - for (j=0;j \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n", - numdt,dt,numo,ngauss); - else - strcpy(message,">> ERREUR : information sur les pas de temps \n"); - - /* Combien de valeurs a lire ? */ - if (ret == 0 && (! strcmp(maillage_champ,nommaa))) - { - if ((nval = MEDnVal(fid,nomcha,MED_FACE,typgeo,numdt,numo)) < 0) - { - ret = -1; - strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n"); - } - else - fprintf(stdout,"\n - Il y a %d valeurs sur les noeuds \n",nval); - } - - if (ret == 0 && (! strcmp(maillage_champ,nommaa))) - { - if (typcha == MED_REEL64) - { - valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval); - ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL, - pflnom,MED_FACE,typgeo,numdt,numo); - if (ret < 0) - strcpy(message,">> ERREUR : lecture des champs \n"); - else - for (kp=0;kp> ERREUR : lecture des champs \n"); - else - for (kp=0;kp> ERREUR : lecture de la taille du profil \n"); - } - else - { - fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize); - pflval = (med_int*) malloc(sizeof(med_int)*pflsize); - - if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0) - strcpy(message,">> ERREUR : lecture du profil \n"); - else - for (l=0;l> ERREUR : la lecture du nombe de pas de temps"); - else - fprintf(stdout,"\n - Il y a %d pas de temps sur les aretes de type %d \n",npdt,typgeo); - - /* Lecture des valeurs pour tous les pas de temps */ - if (ret == 0) - for (j=0;j \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n", - numdt,dt,numo,ngauss); - else - strcpy(message,">> ERREUR : information sur les pas de temps \n"); - - /* Combien de valeurs a lire ? */ - if (ret == 0 && (! strcmp(maillage_champ,nommaa))) - { - if ((nval = MEDnVal(fid,nomcha,MED_ARETE,typgeo,numdt,numo)) < 0) - { - ret = -1; - strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n"); - } - else - fprintf(stdout,"\n - Il y a %d valeurs sur les noeuds \n",nval); - } - - if (ret == 0 && (! strcmp(maillage_champ,nommaa))) - { - if (typcha == MED_REEL64) - { - valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval); - ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL, - pflnom,MED_ARETE,typgeo,numdt,numo); - if (ret < 0) - strcpy(message,">> ERREUR : lecture des champs \n"); - else - for (kp=0;kp> ERREUR : lecture des champs \n"); - else - for (kp=0;kp> ERREUR : lecture de la taille du profil \n"); - } - else - { - fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize); - pflval = (med_int*) malloc(sizeof(med_int)*pflsize); - - if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0) - strcpy(message,">> ERREUR : lecture du profil \n"); - else - for (l=0;l>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1]); - else - fprintf(stderr,">> ERREUR : erreur a la fermeture du fichier %s\n",argv[1]); - - return 0; -} diff --git a/src/MEDWrapper/V2_1/med.hxx b/src/MEDWrapper/V2_1/med.hxx deleted file mode 100644 index 9bb39cc2b..000000000 --- a/src/MEDWrapper/V2_1/med.hxx +++ /dev/null @@ -1,183 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2003 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#ifndef MED_H -#define MED_H - -extern "C"{ -#include -} - -namespace med_2_1{ - -#define MED_NULL (void *) NULL -#define MED_MAX_PARA 20 - -#define MED_TAILLE_DESC 200 -#define MED_TAILLE_IDENT 8 -#define MED_TAILLE_NOM 32 -#define MED_TAILLE_LNOM 80 -#define MED_TAILLE_PNOM 8 - -/* Integration des developpements OCC */ -typedef enum {MED_CARTESIAN, MED_POLAR, MED_BODY_FITTED} med_grid_type; - -typedef enum {MED_GRID_D1=0, MED_GRID_D2=1, MED_GRID_D3=2, - MED_GRID_NOEUD=3, - MED_FAM_NOEUD=4, MED_FAM_ARETE=5, MED_FAM_FACE=6, MED_FAM_MAILLE=7 } med_grid; - -/* Fin de l'integration*/ - -typedef enum {MED_FULL_INTERLACE, - MED_NO_INTERLACE} med_mode_switch; - -typedef enum {MED_GLOBALE, - MED_COMPACT } med_mode_profil; - -typedef enum {MED_LECT,MED_ECRI,MED_REMP} med_mode_acces; - -typedef enum {MED_MAILLE, MED_FACE, MED_ARETE, MED_NOEUD} med_entite_maillage; - -typedef enum {MED_COOR, MED_CONN, MED_NOM, MED_NUM, MED_FAM} med_table; - -typedef enum {MED_REEL64=6, MED_INT32=24,MED_INT64=26, MED_INT} med_type_champ; - -#define MED_NBR_GEOMETRIE_MAILLE 15 -#define MED_NBR_GEOMETRIE_FACE 4 -#define MED_NBR_GEOMETRIE_ARETE 2 -typedef enum {MED_POINT1=1, MED_SEG2=102, MED_SEG3=103, MED_TRIA3=203, - MED_QUAD4=204, MED_TRIA6=206,MED_QUAD8=208, MED_TETRA4=304, - MED_PYRA5=305, MED_PENTA6=306, MED_HEXA8=308, MED_TETRA10=310, - MED_PYRA13=313, MED_PENTA15=315, MED_HEXA20=320} -med_geometrie_element; - -typedef enum {MED_NOD, MED_DESC} med_connectivite ; - -typedef enum {MED_CART, MED_CYL, MED_SPHER} med_repere; - -typedef enum {MED_FAUX, MED_VRAI} med_booleen ; - -typedef enum {MED_GROUPE, MED_ATTR, MED_FAMILLE} med_dim_famille; - -typedef enum {MED_COMP, MED_DTYPE} med_dim_champ; - -typedef enum {MED_HDF_VERSION, MED_VERSION, MED_FICH_DES} med_fich_info; - -#define MED_NOPG 1 /* -> pas de point de Gauss */ -#define MED_NOPFL "" /* -> pas de profils utilisateur */ -#define MED_NOPFLi " " /* Variable Interne */ -#define MED_NOPF 0 /* -> pas de profils pour _MEDdataseNnumEcrire */ -#define MED_NOPDT -1 /* rem: pas de pas de temps negatifs */ -#define MED_NONOR -1 /* rem: pas de n°ordre negatif */ -#define MED_DIM1 1 /* PAS */ -#define MED_ALL 0 - -#if defined(SUN4SOL2) || defined(PCLINUX) || defined(OSF1_32) || defined(IRIX64_32) || defined(RS6000) -/* interface C/FORTRAN */ -/* this true only with g77 and gcc : we must change it to use directly NOMF_... and INT32 or INT64 - - it will be more simple to understand and to use ! */ -#define NOMF_POST_UNDERSCORE - -/* correspondance des types avec HDF 5 */ -typedef hsize_t med_size; -typedef hssize_t med_ssize; -typedef hid_t med_idt; -typedef herr_t med_err; - -/* types elementaires */ -typedef int med_int; -typedef double med_float; -#endif - -#if defined(HP9000) -/* correspondance des types avec HDF 5 */ -typedef hsize_t med_size; -typedef hssize_t med_ssize; -typedef hid_t med_idt; -typedef herr_t med_err; - -/* types elementaires */ -typedef int med_int; -typedef double med_float; -#endif - -#if defined(IRIX64) || defined(OSF1) -#define NOMF_POST_UNDERSCORE - -/* correspondance des types avec HDF 5 */ -typedef hsize_t med_size; -typedef hssize_t med_ssize; -typedef hid_t med_idt; -typedef herr_t med_err; - -/* types elementaires */ -typedef long med_int; -typedef double med_float; -#endif - - -#if defined(PPRO_NT) -/* correspondance des types avec HDF 5 */ -typedef hsize_t med_size; -typedef hssize_t med_ssize; -typedef hid_t med_idt; -typedef herr_t med_err; - -/* types elementaires */ -typedef int med_int; -typedef double med_float; -#endif - - -#if defined(NOMF_PRE_UNDERSCORE) && defined(NOMF_POST_UNDERSCORE) -# define NOMF(x) _##x##_ -#endif -#if defined(NOMF_PRE_UNDERSCORE) && !defined(NOMF_POST_UNDERSCORE) -# define NOMF(x) _##x -#endif -#if !defined(NOMF_PRE_UNDERSCORE) && defined(NOMF_POST_UNDERSCORE) -# define NOMF(x) x##_ -#endif -#if !defined(NOMF_PRE_UNDERSCORE) && !defined(NOMF_POST_UNDERSCORE) -# define NOMF(x) x -#endif - -} - -#include "med_proto.hxx" - -#endif /* MED_H */ diff --git a/src/MEDWrapper/V2_1/med_hdfi.hxx b/src/MEDWrapper/V2_1/med_hdfi.hxx deleted file mode 100644 index a2d95d46d..000000000 --- a/src/MEDWrapper/V2_1/med_hdfi.hxx +++ /dev/null @@ -1,139 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#ifndef MED_HDFI_H -#define MED_HDFI_H -#include "med.hxx" - -/* FONCTIONS INTERFACE MED/HDF */ -namespace med_2_1{ - -/* Gestion des fichiers HDF */ -extern -med_idt _MEDfichierCreer(char *nom); - -extern -med_idt _MEDfichierOuvrir(char *nom,med_mode_acces mode); - -extern -med_err _MEDfichierFermer(med_idt fid); - - -/* Gestion des datagroups HDF */ -extern -med_idt _MEDdatagroupCreer(med_idt pid, char *nom); - -extern -med_idt _MEDdatagroupOuvrir(med_idt pid, char *nom); - -extern -med_err _MEDdatagroupFermer(med_idt id); - - -/* Gestion des datasets HDF */ - -extern -med_idt _MEDdatasetOuvrir(med_idt pid,char *nom); - -extern -med_err _MEDdatasetFermer(med_idt id); - -extern -med_err _MEDdatasetNumEcrire (med_idt pere,char *nom, med_type_champ type, - med_mode_switch interlace, med_size nbdim, med_size fixdim, - med_size psize, med_ssize * profil, med_int ngauss, - med_size *size, unsigned char *val, med_mode_acces mode); - - -extern -med_err _MEDdatasetNumLire(med_idt pere,char *nom,med_type_champ type, - med_mode_switch interlace, med_size nbdim, med_size fixdim, - med_size psize, med_ssize * pfltab, med_int ngauss, - unsigned char *val); - -extern -med_err _MEDdatasetStringEcrire(med_idt pere,char *nom,med_size *dimd, - char *val, med_mode_acces mode); - -extern -med_err _MEDdatasetStringLire(med_idt pere,char *nom,char *val); - -/* Gestion des attributs HDF */ -extern -med_idt _MEDattrOuvrir(med_idt pid,char * nom); - -extern -med_err _MEDattrFermer(med_idt id); - -extern -med_err _MEDattrNumEcrire(med_idt pere,med_type_champ type,char *nom,unsigned char *val,med_mode_acces mode); - -#define _MEDattrEntierEcrire(w,x,y,z) _MEDattrNumEcrire(w,MED_INT ,x,(unsigned char *) y,z) -#define _MEDattrFloatEcrire(w,x,y,z) _MEDattrNumEcrire(w,MED_REEL64,x,(unsigned char *) y,z) - -extern -med_err _MEDattrNumLire(med_idt pere,med_type_champ type,char *nom,unsigned char *val); - -#define _MEDattrEntierLire(x,y,z) _MEDattrNumLire(x,MED_INT ,y,(unsigned char*)z) -#define _MEDattrFloatLire(x,y,z) _MEDattrNumLire(x,MED_REEL64,y,(unsigned char*)z) - -extern -med_err _MEDattrStringEcrire(med_idt pere,char *nom,int longueur,char *val,med_mode_acces mode); - -extern -med_err _MEDattrStringLire(med_idt pere,char *nom,int longueur,char *val); - - -/* Divers */ -extern -med_err _MEDindiceInfo(med_idt id, const char *nom, void *donnees); - -extern -med_err _MEDindiceNum(med_idt id,const char *nom, void *donnees); - -extern -med_err _MEDobjetIdentifier(med_idt fid,char *chemin,int indice,void *nom); - -extern -med_err _MEDnObjets(med_idt fid,char *chemin,int *n); - -extern -void _MEDmodeErreurVerrouiller(); - -} - -#endif /* MED_HDFI_H */ diff --git a/src/MEDWrapper/V2_1/med_misc.hxx b/src/MEDWrapper/V2_1/med_misc.hxx deleted file mode 100644 index 4202d92d6..000000000 --- a/src/MEDWrapper/V2_1/med_misc.hxx +++ /dev/null @@ -1,81 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#ifndef MED_MISC_H -#define MED_MISC_H -#include "med.hxx" - - -/* CHAINES DE CARACTERES FORTRAN => C */ -namespace med_2_1{ - -extern -char *_MED1cstring(char *chaine,int longueur_reelle,int longueur_fixee); - -extern -char *_MED2cstring(char *chaine, int longueur); - -extern -med_err _MEDcstringFree(char *chaine); - -extern -med_err _MEDfstring(char *chaine, med_int longueur_fixee); - -/* Noms associes aux objets MED */ -extern -med_err _MEDnomEntite(char *nom_ent,med_entite_maillage type_ent); - -extern -med_err _MEDnomGeometrie(char *nom_geo,med_geometrie_element type_geo); - -extern -med_err _MEDparametresGeometrie(med_entite_maillage type_ent, - med_geometrie_element type_geo, int *dim, int *nnoe, - int *ndes); -extern -med_err _MEDnomDataset(char *nom_dataset,med_table quoi, - med_connectivite type_conn); - -/* Geometrie des objets MED */ -extern -med_err _MEDGeometrieElement(med_geometrie_element typ_geo[], - med_entite_maillage typ_ent); - -} - -#endif /* MED_MISC_H */ - diff --git a/src/MEDWrapper/V2_1/med_outils.hxx b/src/MEDWrapper/V2_1/med_outils.hxx deleted file mode 100644 index 84d0635b7..000000000 --- a/src/MEDWrapper/V2_1/med_outils.hxx +++ /dev/null @@ -1,146 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2003 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#ifndef MED_OUTILS_H -#define MED_OUTILS_H -#include "med.hxx" - -#define MED_NOM_MAJEUR "MAJ" -#define MED_NOM_MINEUR "MIN" -#define MED_NOM_RELEASE "REL" - -#define MED_NUM_MAJEUR 2 -#define MED_NUM_MINEUR 1 -#define MED_NUM_RELEASE 6 - -#define MED_NOM_INFOS "INFOS_GENERALES" - -#define MED_NOM_DESCRIPTEUR "descripteur de fichier" -#define MED_VERSION_ACTUELLE "2.1.6" -#define HDF_VERSION_ACTUELLE "5-1.4.4" - -/* Noms des data sets ou attributs correspondant a des entites MED */ -#define MED_TAILLE_NOM_ENTITE 3 -#define MED_NOM_NUM "NUM" -#define MED_NOM_NBR "NBR" -#define MED_NOM_NOM "NOM" -#define MED_NOM_UNV "UNV" -#define MED_NOM_NNS "NNS" -#define MED_NOM_NNM "NNM" -#define MED_NOM_NNI "NNI" -#define MED_NOM_GRO "GRO" -#define MED_NOM_ATT "ATT" -#define MED_NOM_NCO "NCO" -#define MED_NOM_DIM "DIM" -#define MED_NOM_FAM "FAM" -#define MED_NOM_IDE "IDE" -#define MED_NOM_VAL "VAL" -#define MED_NOM_DES "DES" -#define MED_NOM_COR "COR" -#define MED_NOM_DIM "DIM" -#define MED_NOM_NOE "NOE" -#define MED_NOM_COO "COO" -#define MED_NOM_REP "REP" -#define MED_NOM_UNI "UNI" -#define MED_NOM_NOD "NOD" -#define MED_NOM_TYP "TYP" -#define MED_NOM_CO "CO" -#define MED_NOM_NCW "NCW" -#define MED_NOM_TYW "TYW" -#define MED_NOM_MAI "MAI" -#define MED_NOM_FAC "FAC" -#define MED_NOM_ARE "ARE" -#define MED_NOM_PO1 "PO1" -#define MED_NOM_SE2 "SE2" -#define MED_NOM_SE3 "SE3" -#define MED_NOM_TR3 "TR3" -#define MED_NOM_TR6 "TR6" -#define MED_NOM_QU4 "QU4" -#define MED_NOM_QU8 "QU8" -#define MED_NOM_TE4 "TE4" -#define MED_NOM_T10 "T10" -#define MED_NOM_HE8 "HE8" -#define MED_NOM_H20 "H20" -#define MED_NOM_PE6 "PE6" -#define MED_NOM_P15 "P15" -#define MED_NOM_PY5 "PY5" -#define MED_NOM_P13 "P13" - -#define MED_NOM_GEO "GEO" -#define MED_NOM_GAU "GAU" -#define MED_NOM_NGA "NGA" -#define MED_NOM_N "N" -#define MED_NOM_PFL "PFL" -#define MED_NOM_NDT "NDT" -#define MED_NOM_PDT "PDT" -#define MED_NOM_NOR "NOR" - -/* Integration des developpements OCC */ -#define MED_NOM_GRD "GRD" -#define MED_NOM_BOF "BOF" -#define MED_NOM_IN1 "IN1" -#define MED_NOM_IN2 "IN2" -#define MED_NOM_IN3 "IN3" - -/* Nom du DATA GROUP CONTENANT TOUS LES MAILLAGES DU FICHIER HDF */ -#define MED_MAA "/ENS_MAA/" -#define MED_TAILLE_MAA 9 - -/* Nom du data group ou ranger les champs solution */ -#define MED_CHA "/CHA/" -#define MED_TAILLE_CHA 5 - -/* Nom du data group ou ranger les familles */ -#define MED_FAS "/FAS/" -#define MED_TAILLE_FAS 5 - -/* Nom du data group ou ranger les equivalences */ -#define MED_EQS "/EQS/" -#define MED_TAILLE_EQS 5 - -/* Nom du data groupe contenant les profils */ -#define MED_PROFILS "/PROFILS/" -#define MED_TAILLE_PROFILS 9 - -/*Pour eviter le bug solaris*/ -#include - -/* Interface des routines du composant tools */ -#include "med_misc.hxx" -#include "med_hdfi.hxx" -#include "med_utils.hxx" -#endif /* MED_OUTILS_H */ diff --git a/src/MEDWrapper/V2_1/med_proto.hxx b/src/MEDWrapper/V2_1/med_proto.hxx deleted file mode 100644 index e5694a9d1..000000000 --- a/src/MEDWrapper/V2_1/med_proto.hxx +++ /dev/null @@ -1,295 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -#ifndef MED_PROTO_H -#define MED_PROTO_H - -/* Interface de l'API MED */ -namespace med_2_1{ -/* Fichier */ -extern med_idt -MEDouvrir(char *nom, med_mode_acces mode_acces); -extern med_err -MEDfermer(med_idt fid); -extern med_int -MEDlFichDes(med_idt fid); -extern med_err -MEDfichEntete(med_idt fid, med_fich_info quoi, char str[]); -extern med_err -MEDfichDesEcr(med_idt fid, char *des, med_mode_acces mode); -extern med_err -MEDunvCr(med_idt fid, char *maa); -extern med_err -MEDunvLire(med_idt fid, char *maa,char *nomu); -extern med_err -MEDformatConforme(const char * nomfich); -extern med_err -MEDversionConforme(const char *nom); -extern void -MEDversionDonner(med_int *majeur, med_int *mineur, med_int *release); -extern med_err -MEDversionLire(med_idt fid, med_int *majeur, med_int *mineur, med_int *release); - - - -/* Maillage */ -extern med_err -MEDmaaCr(med_idt fid, char *maillage, med_int dim); -extern med_int -MEDdimLire(med_idt fid, char *maillage); -extern med_err -MEDmaaInfo(med_idt fid, int indice, char *maillage, med_int *dim); -extern med_int -MEDnMaa(med_idt fid); -extern med_err -MEDnbnosoEcr(med_idt fid, char *nom_maillage,med_int n); -extern med_int -MEDnbnosoLire(med_idt fid,char *nom_maillage); -extern med_err -MEDnbnoisEcr(med_idt fid, char *nom_maillage,med_int n); -extern med_int -MEDnbnoisLire(med_idt fid,char *nom_maillage); -extern med_err -MEDnbnomaEcr(med_idt fid, char *nom_maillage,med_int n); -extern med_int -MEDnbnomaLire(med_idt fid,char *nom_maillage); - -/* EntMaillage */ -extern med_err -MEDconnEcr(med_idt fid,char *maa, med_int mdim, med_int *connectivite,med_mode_switch mode_switch, - med_int nbre,med_mode_acces mode,med_entite_maillage type_ent, - med_geometrie_element type_geo,med_connectivite type_conn); - -extern med_err -MEDconnLire(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch, - med_int * pfltab, med_size psize, - med_entite_maillage type_ent, med_geometrie_element type_geo,med_connectivite type_conn); -extern med_err -MEDnomEcr(med_idt fid,char *maa, char *nom, med_int n, med_mode_acces mode, - med_entite_maillage type_ent,med_geometrie_element type_geo); -extern med_err -MEDnomLire(med_idt fid,char *maa, char *nom, med_int n, - med_entite_maillage type_ent,med_geometrie_element type_geo); -extern med_err -MEDnumLire(med_idt fid,char *maa, med_int *num, med_int n, - med_entite_maillage type_ent,med_geometrie_element type_geo); -extern med_err -MEDnumEcr(med_idt fid,char *maa, med_int *num, med_int n, med_mode_acces mode, - med_entite_maillage type_ent,med_geometrie_element type_geo); -extern med_err -MEDcoordEcr(med_idt fid, char *maa, med_int mdim, med_float *coo, - med_mode_switch mode_coo,med_int n, - med_mode_acces mode, med_repere type_rep, char *nom, char *unit); -extern med_err -MEDcoordLire(med_idt fid, char *maa, med_int mdim, med_float *coo, - med_mode_switch mode_coo,med_int numco, - med_int * pfltab, med_size psize, med_repere *type_rep, char *nom, char *unit); - -extern med_int -MEDnEntMaa(med_idt fid, char *maa, med_table quoi, med_entite_maillage type_ent, - med_geometrie_element type_geo, med_connectivite type_conn); - - -/* Resultat */ -extern med_err MEDchampCr(med_idt fid, char *champ, med_type_champ type, char *comp, - char *unit,med_int ncomp); - -extern med_err -MEDchampEcr(med_idt fid, char *maa, char *cha,unsigned char *val,med_mode_switch interlace,med_int nbelem,med_int ngauss, - med_int numco, char * profil, med_mode_acces mode, med_entite_maillage type_ent, - med_geometrie_element type_geo, med_int numdt,char * dt_unit, med_float dt, med_int numo); - -extern med_err -MEDchampLire(med_idt fid,char *maa, char *cha, unsigned char *val,med_mode_switch interlace,med_int numco, - char *profil,med_entite_maillage type_ent, med_geometrie_element type_geo, - med_int numdt, med_int numo); - -extern med_err -MEDchampInfo(med_idt fid,int indice,char *champ, - med_type_champ *type,char *comp,char *unit, - med_int ncomp); - -extern med_int -MEDnChamp(med_idt fid, int indice); - -extern med_int -MEDnVal(med_idt fid, char *champ, med_entite_maillage typ_ent, - med_geometrie_element typ_geo,med_int numdt, med_int numo); - - -/* Famille */ -extern med_err -MEDfamEcr(med_idt fid,char *maa, med_int *fam, med_int n, med_mode_acces mode, - med_entite_maillage type_ent, med_geometrie_element type_geo); -extern med_err -MEDfamLire(med_idt fid,char *maa, med_int *fam, med_int n, - med_entite_maillage type_ent,med_geometrie_element type_geo); -extern med_err -MEDfamCr(med_idt fid,char* maa,char *famille,med_int numero, - med_int *attr_ident, med_int *attr_val,char *attr_desc,med_int n_attr, - char *groupe , med_int n_groupe); -extern med_int -MEDnFam(med_idt fid,char *maa, int indice, med_dim_famille quoi); - -extern med_err -MEDfamInfo(med_idt fid,char *maa,int indice, char *famille, - med_int *numero, - med_int *attr_ident, med_int *attr_val, char *attr_desc, - med_int *n_attr,char *groupe ,med_int *n_groupe); - -/* Equivalence */ -extern med_err -MEDequivCr(med_idt fid,char *maa, char *eq, char *desc); -extern med_err -MEDequivLire(med_idt fid, char *maa, char *eq, med_int *corr, med_int n, - med_entite_maillage typ_ent,med_geometrie_element typ_geo); -extern med_err -MEDequivEcr(med_idt fid, char *maa, char *eq, med_int *corr, med_int n, - med_mode_acces mode, med_entite_maillage typ_ent, med_geometrie_element typ_geo); -extern med_err -MEDequivInfo(med_idt fid, char *maa, int ind, char *eq, char *des); -extern med_int -MEDnEquiv(med_idt fid, char *maa); -extern med_int -MEDnCorres(med_idt fid,char *maa,char *eq,med_entite_maillage typ_ent, - med_geometrie_element typ_geo); - - -/* Routines de niveau intermediaire */ -extern med_int -MEDnEntites(med_idt fid,char *maa,med_entite_maillage typ_ent, - med_connectivite typ_con); - -extern med_err -MEDnoeudsLire(med_idt fid,char *maa,med_int mdim, med_float *coord, - med_mode_switch mode_coo, - med_repere *repere,char *nomcoo, char *unicoo,char *nom, - med_booleen *inom,med_int *num,med_booleen *inum,med_int *fam, - med_int nnoeuds); - -extern med_err -MEDnoeudsEcr(med_idt fid,char *maa,med_int mdim,med_float *coord, - med_mode_switch mode_coo, - med_repere repere,char *nomcoo, char *unicoo,char *nom, - med_booleen inom,med_int *num,med_booleen inum,med_int *fam, - med_int nnoeuds,med_mode_acces mode); -extern med_err -MEDelementsEcr(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch, - char *nom,med_booleen inom,med_int *num,med_booleen inum, - med_int *fam,med_int nele,med_entite_maillage typ_ent, - med_geometrie_element typ_geo,med_connectivite typ_conn,med_mode_acces mode); -extern med_err -MEDelementsLire(med_idt fid,char *maa,med_int mdim,med_int *connectivite,med_mode_switch mode_switch, - char *nom,med_booleen *inom,med_int *num,med_booleen *inum, - med_int *fam,med_int nele,med_entite_maillage typ_ent, - med_geometrie_element typ_geo,med_connectivite typ_conn); - -/* Routines de haut niveau */ - -/*(? On enlève le reste ?)*/ - -extern med_err -MEDfamMaaInfo(med_idt fid,char *maa,med_int *nfam,med_int *nattc, - med_int *ngroc); - -extern med_err -MEDfamMaaLire(med_idt fid,char *maa, - med_int *numfam,med_int *attide, - med_int *attval,char *attdes,int *indatt,char *gro,int *indgro, - med_int nfamilles); - -extern med_err -MEDfamMaaCr(med_idt fid,char *maa, - med_int *numfam,med_int *attide, - med_int *attval,char *attdes,int *indatt,char *gro,int *indgro, - med_int nfamilles); - -/* Routines concernant les profils */ - -extern med_err -MEDprofilInfo(med_idt fid, int indice, char *profil, med_int *n); - -extern med_int -MEDnProfil(med_idt fid); - -extern med_err -MEDprofilEcr(med_idt fid,med_int *pflval,med_int n,char *nom); - -extern med_int -MEDnValProfil(med_idt fid, char *nom); - -extern med_err -MEDprofilLire(med_idt fid, med_int *pflval, char *nom); - -/* Routines concernant les pas de temps/ numéros d'ordre */ - -extern med_int -MEDnPasdetemps(med_idt fid,char *cha,med_entite_maillage type_ent, - med_geometrie_element type_geo); - -extern med_err -MEDpasdetempsInfo(med_idt fid,char *champ - ,med_entite_maillage type_ent, med_geometrie_element type_geo, - int indice, char *maa, med_int * ngauss, med_int * numdt, char * dt_unit, med_float * dt, - med_int * numo); - -/* Grilles */ - -med_int MEDnGrid(med_idt fid, char *maa, med_grid n); -med_err MEDgridCr(med_idt fid, char *maillage, med_int dim, med_grid_type typ); -med_err MEDgridInfo(med_idt fid, int indice, med_int *isAGrid, med_grid_type *typ); -med_err MEDgridEcr( - med_idt fid, char *maa, med_int mdim, med_float *coo, med_int nb, med_int dim, med_mode_switch mode_coo, - med_repere repere, char *nomcoo, char *unicoo, med_mode_acces mode ); -med_err MEDgridLire( - med_idt fid, char *maa, med_int mdim, med_float *coo, med_int dim, med_mode_switch mode_coo, - med_repere *repere, char *nomcoo, char *unicoo ); -med_err MEDfamGridEcr(med_idt fid, char *maa, med_int *fam, med_int n, med_mode_acces mode, med_entite_maillage type_ent); -med_err MEDfamGridLire(med_idt fid, char *maa, med_int *fam, med_int n, med_entite_maillage type_ent); -med_err MEDbodyFittedEcr( - med_idt fid, char *maa, med_int mdim, med_float *coo, med_int *nbr, med_mode_switch mode_coo, - med_repere repere, char *nomcoo, char *unicoo, med_int *fam, med_int nnoeuds, med_mode_acces mode ); -med_err MEDbodyFittedLire( - med_idt fid, char *maa, med_int mdim, med_float *coo, med_mode_switch mode_coo, - med_repere *repere, char *nomcoo, char *unicoo, med_int *fam, med_int nnoeuds ); -} - -#endif /* MED_PROTO_H */ - - - - diff --git a/src/MEDWrapper/V2_1/med_utils.hxx b/src/MEDWrapper/V2_1/med_utils.hxx deleted file mode 100644 index 6e14343c5..000000000 --- a/src/MEDWrapper/V2_1/med_utils.hxx +++ /dev/null @@ -1,280 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -# ifndef __UTILITES_H__ -# define __UTILITES_H__ - - -/* pour indiquer le statut des arguments des fonctions. */ - -#ifdef _IN -#error _IN already defined -#endif -#define _IN - -#ifdef _OUT -#error _OUT already defined -#endif -#define _OUT - -#ifdef _INOUT -#error _INOUT already defined -#endif -#define _INOUT - -#ifdef _UNUSED -#error _UNUSED already defined -#endif -#define _UNUSED - - - - - - - -/* --- Pour afficher le nom du fichier source courant et le numero de la ligne courante --- */ -/* --- sur la stderr. --- */ - -# define ICI {\ - fflush(stdout);\ - fprintf(stderr, "%s [%d] : " , __FILE__ , __LINE__ ) ;\ - fflush(stderr) ;\ - } - - - - - - - -/* --- Pour afficher la date et l'heure de la compilation du fichier source courant, --- */ -/* --- sur la stdout. --- */ - -# ifdef INFOS_COMPILATION -# error INFOS_COMPILATION already defined -# endif -# define INFOS_COMPILATION {\ - fflush(stderr);\ - fprintf(stdout, "%s [%d] : " , __FILE__ , __LINE__ ) ;\ - fprintf(stdout,"Compilation le %s" , __DATE__);\ - fprintf(stdout," a %s" , __TIME__ );\ - fprintf(stdout,"\n\n\n" );\ - fflush(stdout) ;\ - } - - - - - - - -/* --- Pour attendre "secondes" secondes et afficher un message sur la stderr indiquant --- */ -/* --- cette attente volontaire. --- */ - -# ifdef ATTENTE -# error ATTENTE already defined -# endif -# define ATTENTE(secondes) {\ - ICI ;\ - fprintf( stderr, "ATTENTE de %d secondes" , secondes);\ - fflush(stderr) ;\ - sleep(secondes) ;\ - fprintf( stderr, "\n" );\ - fflush(stderr) ;\ - } - - - - - - - -/* ---------- Les macros suivantes ne doivent pas deja exister ! ---------- */ - -# ifdef EXECUTION -# error EXECUTION already defined -# endif -# ifdef INTERRUPTION -# error INTERRUPTION already defined -# endif -# ifdef ISCRUTE -# error ISCRUTE already defined -# endif -# ifdef RSCRUTE -# error RSCRUTE already defined -# endif -# ifdef SSCRUTE -# error SSCRUTE already defined -# endif -# ifdef CSCRUTE -# error CSCRUTE already defined -# endif -# ifdef XSCRUTE -# error XSCRUTE already defined -# endif -# ifdef MESSAGE -# error MESSAGE already defined -# endif - - - - - -# ifdef _DEBOG_ - - -/* --- Pour tracer sur la stderr l'execution d"une instruction. --- */ - -# define EXECUTION(instruction) {\ - ICI ;\ - fprintf( stderr,"INSTRUCTION %s" , #instruction ) ;\ - fflush(stderr);\ - instruction ;\ - fflush(stdout);\ - fprintf( stderr," FRANCHIE\n" ) ;\ - fflush(stderr);\ - } - - - - - - - -/* --- Pour afficher un message d'interruption volontaire et retourner le code retour --- */ -/* --- "code" --- */ - -# define INTERRUPTION(code) {\ - ICI ;\ - fprintf( stderr," INTERRUPTION code = %d",code) ;\ - fprintf(stderr,"\n") ;\ - exit(code) ;\ - } - - - - - - - -/* --- Pour conditionner la poursuite du traitement par la validite de la condition --- */ -/* --- "condiiton". --- */ - -# ifndef ASSERT -# define ASSERT(condition) if( !(condition) ){\ - ICI ;\ - fprintf(stderr,"condition %s VIOLEE\n",#condition);\ - INTERRUPTION(17);\ - } -# endif /* # ifndef ASSERT */ - - - - - - - -/* --- Pour afficher sur la stderr la valeur d'une variable precedee de son nom. --- */ - -# define ISCRUTE(entier) {\ - ICI ;\ - fprintf(stderr,"%s = %d\n",#entier,entier) ;\ - fflush(stderr) ;\ - } -# define RSCRUTE(reel) {\ - ICI ;\ - fprintf(stderr,"%s = %f\n",#reel,reel) ;\ - fflush(stderr) ;\ - } -# define XSCRUTE(pointeur) {\ - ICI ;\ - fprintf(stderr,"%s = %x\n",#pointeur,pointeur) ;\ - fflush(stderr) ;\ - } -# define CSCRUTE(car) {\ - ICI ;\ - fprintf(stderr,"%s = %c\n",#car,car) ;\ - fflush(stderr) ;\ - } -# define SSCRUTE(chaine) {\ - ICI ;\ - fprintf(stderr,"%s = \"%s\"\n",#chaine,chaine) ;\ - fflush(stderr) ;\ - } -# define MESSAGE(chaine) {\ - ICI ;\ - fprintf(stderr,"%s\n",chaine) ;\ - fflush(stderr) ;\ - } -# define FIN(nom) {\ - ICI ;\ - fprintf( stderr , "} FIN %s\n\n\n" , nom ) ;\ - fflush(stderr) ;\ - } -# define DEBUT(nom) {\ - fprintf( stderr , "\n\n\n") ;\ - ICI ;\ - fprintf( stderr , "{ DEBUT %s\n" , nom ) ;\ - fflush(stderr) ;\ - } - - -# else /* # ifdef _DEBOG_ */ - - - -# define EXECUTION(instruction) instruction -# define INTERRUPTION(code) - -# ifndef ASSERT -# define ASSERT(condition) -# endif - -# define ISCRUTE(entier) -# define RSCRUTE(reel) -# define CSCRUTE(car) -# define SSCRUTE(chaine) -# define MESSAGE(chaine) -# define DEBUT(nom) -# define FIN(nom) - - -# endif /* # ifdef _DEBOG_ */ - - -# endif /* # ifndef __UTILITES_H__ */ diff --git a/src/MEDWrapper/V2_1/test1_V2_1.cxx b/src/MEDWrapper/V2_1/test1_V2_1.cxx deleted file mode 100644 index 85a9258f7..000000000 --- a/src/MEDWrapper/V2_1/test1_V2_1.cxx +++ /dev/null @@ -1,91 +0,0 @@ -// Copyright (C) 2005 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/ -// -/************************************************************************* -* COPYRIGHT (C) 1999 - 2002 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, OR (AT YOUR OPTION) ANY LATER VERSION. -* -* THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -* WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -* LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. -* -* YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE -* ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, -* INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA -* -*************************************************************************/ - -/****************************************************************************** - * - Nom du fichier : test1.c - * - * - Description : tests des routines d'ouverture/fermeture des - * fichiers MED - * - *****************************************************************************/ - -#include "med.hxx" -using namespace med_2_1; - -/****************************************************************************** - * OUVERTURE/FERMETURE DE FICHIERS : - * - * Description : - * - ouverture du fichier en mode ecriture avec remplacement - * - ecriture d'une description du fichier (optionnel) - * - fermeture du fichier - * - ouverture du fichier en mode de lecture - * - fermeture du fichier - *****************************************************************************/ - -int main (int argc, char **argv) -{ - med_err ret = 0; - med_idt fid; - char des[MED_TAILLE_DESC+1]="Ceci est un courte description du mon fichier test1.med"; - - fid = MEDouvrir("test1.med",MED_REMP); - if (fid < 0) - ret = -1; - printf("%d\n",ret); - - if (ret == 0) - ret = MEDfichDesEcr(fid,des, MED_REMP); - printf("%d\n",ret); - - ret = MEDfermer(fid); - printf("%d\n",ret); - - fid = MEDouvrir("test1.med",MED_LECT); - if (fid < 0) - ret = -1; - printf("%d\n",ret); - - ret = MEDfermer(fid); - printf("%d\n",ret); - - return 0; -} - - - - diff --git a/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx b/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx index 179bfa45c..d01a450ae 100644 --- a/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx +++ b/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx @@ -27,10 +27,16 @@ // $Header$ #include "MED_V2_2_Wrapper.hxx" +#include "MED_Algorithm.hxx" #include "MED_Utilities.hxx" -extern "C"{ +extern "C" +{ #include + +med_err +MEDgaussInfo(med_idt fid, int indice, char * locname, med_geometrie_element * type_geo, + med_int * ngauss ); } #ifdef _DEBUG_ @@ -41,8 +47,54 @@ static int MYDEBUG = 0; -namespace MED{ - namespace V2_2{ +namespace MED +{ + template<> + TInt + GetDESCLength() + { + return 200; + } + + template<> + TInt + GetIDENTLength() + { + return 8; + } + + template<> + TInt + GetNOMLength() + { + return 32; + } + + template<> + TInt + GetLNOMLength() + { + return 80; + } + + template<> + TInt + GetPNOMLength() + { + return 16; + } + + template<> + TInt + GetNbConn(EGeometrieElement typmai, + EEntiteMaillage typent, + TInt mdim) + { + return typmai%100; + } + + namespace V2_2 + { //--------------------------------------------------------------- class TFile{ @@ -113,7 +165,9 @@ namespace MED{ } - TInt TVWrapper::GetNbMeshes(TErr* theErr) + TInt + TVWrapper + ::GetNbMeshes(TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -124,22 +178,22 @@ namespace MED{ } - void TVWrapper::GetMeshInfo(TInt theMeshId, - MED::TMeshInfo& theInfo, - TErr* theErr) + void + TVWrapper + ::GetMeshInfo(TInt theMeshId, + MED::TMeshInfo& theInfo, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); if(theErr && !*theErr) return; - med_maillage& aType = (med_maillage&)(theInfo.myType); - TErr aRet = MEDmaaInfo(myFile->Id(), theMeshId, &theInfo.myName[0], - (med_int *)&theInfo.myDim, - &aType, + (med_int*)&theInfo.myDim, + (med_maillage*)&theInfo.myType, &theInfo.myDesc[0]); if(theErr) *theErr = aRet; @@ -148,9 +202,11 @@ namespace MED{ } - void TVWrapper::SetMeshInfo(const MED::TMeshInfo& theInfo, - EModeAcces theMode, - TErr* theErr) + void + TVWrapper + ::SetMeshInfo(const MED::TMeshInfo& theInfo, + EModeAcces theMode, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,theMode,theErr); @@ -159,12 +215,10 @@ namespace MED{ MED::TMeshInfo& anInfo = const_cast(theInfo); - med_maillage& aType = (med_maillage&)(theInfo.myType); - TErr aRet = MEDmaaCr(myFile->Id(), &anInfo.myName[0], - anInfo.myDim, - aType, + med_int(anInfo.myDim), + med_maillage(theInfo.myType), &anInfo.myDesc[0]); if(aRet == 0){ aRet = MEDunvCr(myFile->Id(), @@ -180,8 +234,10 @@ namespace MED{ } - void TVWrapper::SetMeshInfo(const MED::TMeshInfo& theInfo, - TErr* theErr) + void + TVWrapper + ::SetMeshInfo(const MED::TMeshInfo& theInfo, + TErr* theErr) { TErr aRet; SetMeshInfo(theInfo,eLECTURE_ECRITURE,&aRet); @@ -194,8 +250,10 @@ namespace MED{ } - TInt TVWrapper::GetNbFamilies(const MED::TMeshInfo& theInfo, - TErr* theErr) + TInt + TVWrapper + ::GetNbFamilies(const MED::TMeshInfo& theInfo, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -208,9 +266,11 @@ namespace MED{ } - TInt TVWrapper::GetNbFamAttr(TInt theFamId, - const MED::TMeshInfo& theInfo, - TErr* theErr) + TInt + TVWrapper + ::GetNbFamAttr(TInt theFamId, + const MED::TMeshInfo& theInfo, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -224,9 +284,11 @@ namespace MED{ } - TInt TVWrapper::GetNbFamGroup(TInt theFamId, - const MED::TMeshInfo& theInfo, - TErr* theErr) + TInt + TVWrapper + ::GetNbFamGroup(TInt theFamId, + const MED::TMeshInfo& theInfo, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -240,9 +302,11 @@ namespace MED{ } - void TVWrapper::GetFamilyInfo(TInt theFamId, - MED::TFamilyInfo& theInfo, - TErr* theErr) + void + TVWrapper + ::GetFamilyInfo(TInt theFamId, + MED::TFamilyInfo& theInfo, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -251,17 +315,22 @@ namespace MED{ MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; + med_int* anAttrId = theInfo.myNbAttr > 0? (med_int*)&theInfo.myAttrId[0]: NULL; + med_int* anAttrVal = theInfo.myNbAttr > 0? (med_int*)&theInfo.myAttrVal[0]: NULL; + char* anAttrDesc = theInfo.myNbAttr > 0? &theInfo.myAttrDesc[0]: NULL; + char* aGroupNames = theInfo.myNbGroup > 0? &theInfo.myGroupNames[0]: NULL; + TErr aRet = MEDfamInfo(myFile->Id(), &aMeshInfo.myName[0], theFamId, &theInfo.myName[0], - (med_int *)&theInfo.myId, - (med_int *)&theInfo.myAttrId[0], - (med_int *)&theInfo.myAttrVal[0], - &theInfo.myAttrDesc[0], - (med_int *)&theInfo.myNbAttr, - &theInfo.myGroupNames[0], - (med_int *)&theInfo.myNbGroup); + (med_int*)&theInfo.myId, + anAttrId, + anAttrVal, + anAttrDesc, + (med_int*)&theInfo.myNbAttr, + aGroupNames, + (med_int*)&theInfo.myNbGroup); if(theErr) *theErr = aRet; @@ -271,18 +340,14 @@ namespace MED{ "'; theFamId = "<Id(), &aMeshInfo.myName[0], (med_int*)&theInfo.myElemNum[0], - nb, + theNb, anEntity, aGeom); - theInfo.myIsElemNum = (theInfo.myElemNum).empty()? EBooleen(0) : EBooleen(1) ; + theInfo.myIsElemNum = (theInfo.myElemNum).empty()? eFAUX : eVRAI ; if(theErr) *theErr = aRet; @@ -385,11 +458,13 @@ namespace MED{ EXCEPTION(runtime_error,"GetNumeration - MEDnumLire(...)"); } - void TVWrapper::GetFamilies(TElemInfo& theInfo, - TInt nb, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - TErr* theErr) + void + TVWrapper + ::GetFamilies(TElemInfo& theInfo, + TInt theNb, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -398,15 +473,12 @@ namespace MED{ MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; - med_entite_maillage& anEntity = (med_entite_maillage&)(theTEntity); - med_geometrie_element& aGeom = (med_geometrie_element&)(theTGeom); - TErr aRet = MEDfamLire(myFile->Id(), &aMeshInfo.myName[0], (med_int*)&theInfo.myFamNum[0], - nb, - anEntity, - aGeom); + theNb, + med_entite_maillage(theEntity), + med_geometrie_element(theGeom)); if(theErr) *theErr = aRet; @@ -414,19 +486,23 @@ namespace MED{ EXCEPTION(runtime_error,"GetFamilies - MEDfamLire(...)"); } - void TVWrapper::SetNames(const TElemInfo& theInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - TErr* theErr) + void + TVWrapper + ::SetNames(const TElemInfo& theInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr) { - SetNames(theInfo,eLECTURE_ECRITURE,theTEntity,theTGeom,theErr); + SetNames(theInfo,eLECTURE_ECRITURE,theEntity,theGeom,theErr); } - void TVWrapper::SetNames(const TElemInfo& theInfo, - EModeAcces theMode, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - TErr* theErr) + void + TVWrapper + ::SetNames(const TElemInfo& theInfo, + EModeAcces theMode, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,theMode,theErr); @@ -436,18 +512,14 @@ namespace MED{ MED::TElemInfo& anInfo = const_cast(theInfo); MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; - med_booleen& anIsElemNames = (med_booleen&)(theInfo.myIsElemNames); - med_entite_maillage& anEntity = (med_entite_maillage&)(theTEntity); - med_geometrie_element& aGeom = (med_geometrie_element&)(theTGeom); - TErr aRet = 0; - if (anIsElemNames){ + if(theInfo.myIsElemNames){ aRet = MEDnomEcr(myFile->Id(), &aMeshInfo.myName[0], &anInfo.myElemNames[0], anInfo.myElemNames.size(), - anEntity, - aGeom); + med_entite_maillage(theEntity), + med_geometrie_element(theGeom)); if(theErr) *theErr = aRet; else if(aRet < 0) @@ -455,19 +527,23 @@ namespace MED{ } } - void TVWrapper::SetNumeration(const TElemInfo& theInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - TErr* theErr) + void + TVWrapper + ::SetNumeration(const TElemInfo& theInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr) { - SetNumeration(theInfo,eLECTURE_ECRITURE,theTEntity,theTGeom,theErr); + SetNumeration(theInfo,eLECTURE_ECRITURE,theEntity,theGeom,theErr); } - void TVWrapper::SetNumeration(const TElemInfo& theInfo, - EModeAcces theMode, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - TErr* theErr) + void + TVWrapper + ::SetNumeration(const TElemInfo& theInfo, + EModeAcces theMode, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,theMode,theErr); @@ -477,18 +553,14 @@ namespace MED{ MED::TElemInfo& anInfo = const_cast(theInfo); MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; - med_booleen& anIsElemNum = (med_booleen&)(theInfo.myIsElemNum); - med_entite_maillage& anEntity = (med_entite_maillage&)(theTEntity); - med_geometrie_element& aGeom = (med_geometrie_element&)(theTGeom); - TErr aRet = 0; - if (anIsElemNum){ + if(theInfo.myIsElemNum){ aRet = MEDnumEcr(myFile->Id(), &aMeshInfo.myName[0], (med_int*)&anInfo.myElemNum[0], anInfo.myElemNum.size(), - anEntity, - aGeom); + med_entite_maillage(theEntity), + med_geometrie_element(theGeom)); if(theErr) *theErr = aRet; else if(aRet < 0) @@ -496,19 +568,23 @@ namespace MED{ } } - void TVWrapper::SetFamilies(const TElemInfo& theInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - TErr* theErr) + void + TVWrapper + ::SetFamilies(const TElemInfo& theInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr) { - SetFamilies(theInfo,eLECTURE_ECRITURE,theTEntity,theTGeom,theErr); + SetFamilies(theInfo,eLECTURE_ECRITURE,theEntity,theGeom,theErr); } - void TVWrapper::SetFamilies(const TElemInfo& theInfo, - EModeAcces theMode, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - TErr* theErr) + void + TVWrapper + ::SetFamilies(const TElemInfo& theInfo, + EModeAcces theMode, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,theMode,theErr); @@ -518,15 +594,12 @@ namespace MED{ MED::TElemInfo& anInfo = const_cast(theInfo); MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; - med_entite_maillage& anEntity = (med_entite_maillage&)(theTEntity); - med_geometrie_element& aGeom = (med_geometrie_element&)(theTGeom); - TErr aRet = MEDfamEcr(myFile->Id(), &aMeshInfo.myName[0], - (med_int *)&anInfo.myFamNum[0], + (med_int*)&anInfo.myFamNum[0], anInfo.myFamNum.size(), - anEntity, - aGeom); + med_entite_maillage(theEntity), + med_geometrie_element(theGeom)); if(theErr) *theErr = aRet; @@ -535,8 +608,10 @@ namespace MED{ } //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - TInt TVWrapper::GetNbNodes(const MED::TMeshInfo& theMeshInfo, - TErr* theErr) + TInt + TVWrapper + ::GetNbNodes(const MED::TMeshInfo& theMeshInfo, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -554,8 +629,10 @@ namespace MED{ } - void TVWrapper::GetNodeInfo(MED::TNodeInfo& theInfo, - TErr* theErr) + void + TVWrapper + ::GetNodeInfo(MED::TNodeInfo& theInfo, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -564,23 +641,22 @@ namespace MED{ MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; - med_repere& aRepere = (med_repere&)(theInfo.mySystem); - med_booleen& anIsElemNames = (med_booleen&)(theInfo.myIsElemNames); - med_booleen& anIsElemNum = (med_booleen&)(theInfo.myIsElemNum); + char* anElemNames = theInfo.myIsElemNames? &theInfo.myElemNames[0]: NULL; + med_int* anElemNum = theInfo.myIsElemNum? &theInfo.myElemNum[0]: NULL; TErr aRet = MEDnoeudsLire(myFile->Id(), &aMeshInfo.myName[0], aMeshInfo.myDim, &theInfo.myCoord[0], - MED_FULL_INTERLACE, - &aRepere, + med_mode_switch(theInfo.myModeSwitch), + (med_repere*)&theInfo.mySystem, &theInfo.myCoordNames[0], &theInfo.myCoordUnits[0], - &theInfo.myElemNames[0], - &anIsElemNames, - (med_int *)&theInfo.myElemNum[0], - &anIsElemNum, - (med_int *)&theInfo.myFamNum[0], + anElemNames, + (med_booleen*)&theInfo.myIsElemNames, + anElemNum, + (med_booleen*)&theInfo.myIsElemNum, + (med_int*)&theInfo.myFamNum[0], theInfo.myNbElem); if(theErr) *theErr = aRet; @@ -589,9 +665,11 @@ namespace MED{ } - void TVWrapper::SetNodeInfo(const MED::TNodeInfo& theInfo, - EModeAcces theMode, - TErr* theErr) + void + TVWrapper + ::SetNodeInfo(const MED::TNodeInfo& theInfo, + EModeAcces theMode, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,theMode,theErr); @@ -601,23 +679,22 @@ namespace MED{ MED::TNodeInfo& anInfo = const_cast(theInfo); MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; - med_repere& aRepere = (med_repere&)(theInfo.mySystem); - med_booleen& anIsElemNames = (med_booleen&)(theInfo.myIsElemNames); - med_booleen& anIsElemNum = (med_booleen&)(theInfo.myIsElemNum); + char* anElemNames = theInfo.myIsElemNames? &anInfo.myElemNames[0]: NULL; + med_int* anElemNum = theInfo.myIsElemNum? &anInfo.myElemNum[0]: NULL; TErr aRet = MEDnoeudsEcr(myFile->Id(), &aMeshInfo.myName[0], aMeshInfo.myDim, &anInfo.myCoord[0], - MED_FULL_INTERLACE, - aRepere, + med_mode_switch(theInfo.myModeSwitch), + med_repere(theInfo.mySystem), &anInfo.myCoordNames[0], &anInfo.myCoordUnits[0], - &anInfo.myElemNames[0], - anIsElemNames, - (med_int *)&anInfo.myElemNum[0], - anIsElemNum, - (med_int *)&anInfo.myFamNum[0], + anElemNames, + med_booleen(theInfo.myIsElemNames), + anElemNum, + med_booleen(theInfo.myIsElemNum), + (med_int*)&anInfo.myFamNum[0], anInfo.myNbElem); if(theErr) *theErr = aRet; @@ -626,8 +703,10 @@ namespace MED{ } - void TVWrapper::SetNodeInfo(const MED::TNodeInfo& theInfo, - TErr* theErr) + void + TVWrapper + ::SetNodeInfo(const MED::TNodeInfo& theInfo, + TErr* theErr) { TErr aRet; SetNodeInfo(theInfo,eLECTURE_ECRITURE,&aRet); @@ -636,8 +715,12 @@ namespace MED{ SetNodeInfo(theInfo,eLECTURE_AJOUT,theErr); } - void TVWrapper::GetPolygoneInfo(MED::TPolygoneInfo& theInfo, - TErr* theErr) + + //----------------------------------------------------------------- + void + TVWrapper + ::GetPolygoneInfo(MED::TPolygoneInfo& theInfo, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -647,47 +730,50 @@ namespace MED{ MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; TInt aNbElem = theInfo.myElemNum.size(); - med_entite_maillage& anEntity = (med_entite_maillage&)(theInfo.myTEntity); - med_connectivite& aConn = (med_connectivite&)(theInfo.myTConn); - - TErr aRet = 0; - + TErr aRet; aRet = MEDpolygoneConnLire(myFile->Id(), &aMeshInfo.myName[0], - (med_int *)&theInfo.myIndex[0], + (med_int*)&theInfo.myIndex[0], aNbElem+1, - (med_int *)&theInfo.myConn[0], - anEntity, - aConn); + (med_int*)&theInfo.myConn[0], + med_entite_maillage(theInfo.myEntity), + med_connectivite(theInfo.myConnMode)); if(theErr) *theErr = aRet; else if(aRet < 0) EXCEPTION(runtime_error,"GetPolygoneInfo - MEDpolygoneInfo(...)"); + if(theInfo.myIsElemNames){ + GetNames(theInfo,aNbElem,theInfo.myEntity,ePOLYGONE,&aRet); + if(theErr) + *theErr = aRet; + } - GetNames(theInfo,aNbElem,theInfo.myTEntity,ePOLYGONE,&aRet); - if(theErr) - *theErr = aRet; - - GetNumeration(theInfo,aNbElem,theInfo.myTEntity,ePOLYGONE,&aRet); - if(theErr) - *theErr = aRet; + if(theInfo.myIsElemNum){ + GetNumeration(theInfo,aNbElem,theInfo.myEntity,ePOLYGONE,&aRet); + if(theErr) + *theErr = aRet; + } - GetFamilies(theInfo,aNbElem,theInfo.myTEntity,ePOLYGONE,&aRet); + GetFamilies(theInfo,aNbElem,theInfo.myEntity,ePOLYGONE,&aRet); if(theErr) *theErr = aRet; } - void TVWrapper::SetPolygoneInfo(const MED::TPolygoneInfo& theInfo, - TErr* theErr) + 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) + void + TVWrapper + ::SetPolygoneInfo(const MED::TPolygoneInfo& theInfo, + EModeAcces theMode, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,theMode,theErr); @@ -697,49 +783,50 @@ namespace MED{ MED::TPolygoneInfo& anInfo = const_cast(theInfo); MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; - med_entite_maillage& anEntity = (med_entite_maillage&)(theInfo.myTEntity); - med_connectivite& aConn = (med_connectivite&)(theInfo.myTConn); - TErr aRet = MEDpolygoneConnEcr(myFile->Id(), &aMeshInfo.myName[0], - (med_int *)&anInfo.myIndex[0], + (med_int*)&anInfo.myIndex[0], anInfo.myNbElem+1, - (med_int *)&anInfo.myConn[0], - anEntity, - aConn); + (med_int*)&anInfo.myConn[0], + med_entite_maillage(theInfo.myEntity), + med_connectivite(theInfo.myConnMode)); if(theErr) *theErr = aRet; else if(aRet < 0) EXCEPTION(runtime_error,"SetPolygoneInfo - MEDpolygoneConnEcr(...)"); - SetNames(anInfo,theInfo.myTEntity,ePOLYGONE,&aRet); + SetNames(anInfo,theInfo.myEntity,ePOLYGONE,&aRet); if(theErr) *theErr = aRet; - SetNumeration(anInfo,theInfo.myTEntity,ePOLYGONE,&aRet); + SetNumeration(anInfo,theInfo.myEntity,ePOLYGONE,&aRet); if(theErr) *theErr = aRet; - SetFamilies(anInfo,theInfo.myTEntity,ePOLYGONE,&aRet); + SetFamilies(anInfo,theInfo.myEntity,ePOLYGONE,&aRet); if(theErr) *theErr = aRet; } - TInt TVWrapper::GetNbPolygones(const MED::TMeshInfo& theMeshInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn, - TErr* theErr) + TInt + TVWrapper + ::GetNbPolygones(const MED::TMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode, + TErr* theErr) { - return GetNbCells(theMeshInfo,theTEntity,theTGeom,theTConn,theErr); + return GetNbCells(theMeshInfo,theEntity,theGeom,theConnMode,theErr); } - TInt TVWrapper::GetNbPolygoneConn(const MED::TMeshInfo& theMeshInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn, - TErr* theErr) + TInt + TVWrapper + ::GetPolygoneConnSize(const MED::TMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -748,16 +835,14 @@ namespace MED{ MED::TMeshInfo& aMeshInfo = const_cast(theMeshInfo); - med_entite_maillage& anEntity = (med_entite_maillage&)(theTEntity); - med_connectivite& aConn = (med_connectivite&)(theTConn); - med_int taille = 0; - TErr aRet = MEDpolygoneInfo(myFile->Id(), - &aMeshInfo.myName[0], - anEntity, - aConn, - &taille); + TErr aRet; + aRet = MEDpolygoneInfo(myFile->Id(), + &aMeshInfo.myName[0], + med_entite_maillage(theEntity), + med_connectivite(theConnMode), + &taille); if(theErr) *theErr = aRet; @@ -767,8 +852,11 @@ namespace MED{ return TInt(taille); } - void TVWrapper::GetPolyedreInfo(TPolyedreInfo& theInfo, - TErr* theErr) + //----------------------------------------------------------------- + void + TVWrapper + ::GetPolyedreInfo(TPolyedreInfo& theInfo, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -778,46 +866,51 @@ namespace MED{ MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; TInt aNbElem = theInfo.myElemNum.size(); - med_connectivite& aConn = (med_connectivite&)(theInfo.myTConn); - - TErr aRet = 0; - + TErr aRet; aRet = MEDpolyedreConnLire(myFile->Id(), &aMeshInfo.myName[0], - (med_int *)&theInfo.myIndex[0], - aNbElem+1, - (med_int *)&theInfo.myFacesIndex[0], - theInfo.myNbFacesIndex, - (med_int *)&theInfo.myConn[0], - aConn); + (med_int*)&theInfo.myIndex[0], + aNbElem + 1, + (med_int*)&theInfo.myFaces[0], + theInfo.myFaces.size(), + (med_int*)&theInfo.myConn[0], + med_connectivite(theInfo.myConnMode)); if(theErr) *theErr = aRet; else if(aRet < 0) EXCEPTION(runtime_error,"GetPolygoneInfo - MEDpolyedreConnLire(...)"); - GetNames(theInfo,aNbElem,theInfo.myTEntity,ePOLYEDRE,&aRet); - if(theErr) - *theErr = aRet; + if(theInfo.myIsElemNames){ + GetNames(theInfo,aNbElem,theInfo.myEntity,ePOLYEDRE,&aRet); + if(theErr) + *theErr = aRet; + } - GetNumeration(theInfo,aNbElem,theInfo.myTEntity,ePOLYEDRE,&aRet); - if(theErr) - *theErr = aRet; + if(theInfo.myIsElemNum){ + GetNumeration(theInfo,aNbElem,theInfo.myEntity,ePOLYEDRE,&aRet); + if(theErr) + *theErr = aRet; + } - GetFamilies(theInfo,aNbElem,theInfo.myTEntity,ePOLYEDRE,&aRet); + GetFamilies(theInfo,aNbElem,theInfo.myEntity,ePOLYEDRE,&aRet); if(theErr) *theErr = aRet; } - void TVWrapper::SetPolyedreInfo(const TPolyedreInfo& theInfo, - TErr* theErr) + void + TVWrapper + ::SetPolyedreInfo(const TPolyedreInfo& theInfo, + TErr* theErr) { SetPolyedreInfo(theInfo,eLECTURE_ECRITURE,theErr); } - void TVWrapper::SetPolyedreInfo(const MED::TPolyedreInfo& theInfo, - EModeAcces theMode, - TErr* theErr) + void + TVWrapper + ::SetPolyedreInfo(const MED::TPolyedreInfo& theInfo, + EModeAcces theMode, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,theMode,theErr); @@ -827,31 +920,27 @@ namespace MED{ MED::TPolyedreInfo& anInfo = const_cast(theInfo); MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; - med_booleen& anIsElemNames = (med_booleen&)(theInfo.myIsElemNames); - med_booleen& anIsElemNum = (med_booleen&)(theInfo.myIsElemNum); - med_entite_maillage& anEntity = (med_entite_maillage&)(theInfo.myTEntity); - med_connectivite& aConn = (med_connectivite&)(theInfo.myTConn); - - TErr aRet = MEDpolyedreConnEcr(myFile->Id(), - &aMeshInfo.myName[0], - (med_int *)&anInfo.myIndex[0], - anInfo.myNbElem+1, - (med_int *)&anInfo.myFacesIndex[0], - anInfo.myNbFacesIndex, - (med_int *)&anInfo.myConn[0], - aConn); + TErr aRet; + aRet = MEDpolyedreConnEcr(myFile->Id(), + &aMeshInfo.myName[0], + (med_int*)&anInfo.myIndex[0], + anInfo.myNbElem+1, + (med_int*)&anInfo.myFaces[0], + anInfo.myFaces.size(), + (med_int*)&anInfo.myConn[0], + med_connectivite(theInfo.myConnMode)); if(theErr) *theErr = aRet; else if(aRet < 0) EXCEPTION(runtime_error,"SetPolyedreInfo - MEDpolyedreConnEcr(...)"); - if (anIsElemNames){ + if(theInfo.myIsElemNames){ aRet = MEDnomEcr(myFile->Id(), &aMeshInfo.myName[0], &anInfo.myElemNames[0], anInfo.myElemNames.size(), - anEntity, + med_entite_maillage(theInfo.myEntity), MED_POLYEDRE); if(theErr) *theErr = aRet; @@ -859,12 +948,12 @@ namespace MED{ EXCEPTION(runtime_error,"SetPolyedreInfo - MEDnomEcr(...)"); } - if (anIsElemNum){ + if(theInfo.myIsElemNum){ aRet = MEDnumEcr(myFile->Id(), &aMeshInfo.myName[0], - (med_int *)&anInfo.myElemNum[0], + (med_int*)&anInfo.myElemNum[0], anInfo.myElemNum.size(), - anEntity, + med_entite_maillage(theInfo.myEntity), MED_POLYEDRE); if(theErr) *theErr = aRet; @@ -875,9 +964,9 @@ namespace MED{ aRet = MEDfamEcr(myFile->Id(), &aMeshInfo.myName[0], - (med_int *)&anInfo.myFamNum[0], + (med_int*)&anInfo.myFamNum[0], anInfo.myFamNum.size(), - anEntity, + med_entite_maillage(theInfo.myEntity), MED_POLYEDRE); if(theErr) @@ -886,33 +975,37 @@ namespace MED{ EXCEPTION(runtime_error,"SetPolyedreInfo - MEDfamEcr(...)"); } - TInt TVWrapper::GetNbPolyedres(const MED::TMeshInfo& theMeshInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn, - TErr* theErr) + TInt + TVWrapper + ::GetNbPolyedres(const MED::TMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode, + TErr* theErr) { - return GetNbCells(theMeshInfo,theTEntity,theTGeom,theTConn,theErr); + return GetNbCells(theMeshInfo,theEntity,theGeom,theConnMode,theErr); } - void TVWrapper::GetNbPolyedreConnF(const MED::TMeshInfo& theMeshInfo, - EConnectivite theTConn, - TInt& nf, - TInt& nc, - TErr* theErr) + void + TVWrapper + ::GetPolyedreConnSize(const TMeshInfo& theMeshInfo, + TInt& theNbFaces, + TInt& theConnSize, + EConnectivite theConnMode, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); - if(theErr && !*theErr) EXCEPTION(runtime_error,"GetPolyedreInfo - (...)"); + if(theErr && !*theErr) + EXCEPTION(runtime_error,"GetPolyedreInfo - (...)"); MED::TMeshInfo& aMeshInfo = const_cast(theMeshInfo); - med_connectivite& aConn = (med_connectivite&)(theTConn); TErr aRet = MEDpolyedreInfo(myFile->Id(), &aMeshInfo.myName[0], - aConn, - (med_int *)&nf, - (med_int *)&nc); + med_connectivite(theConnMode), + (med_int*)&theNbFaces, + (med_int*)&theConnSize); if(theErr) *theErr = aRet; @@ -921,9 +1014,12 @@ namespace MED{ } - TEntityInfo TVWrapper::GetEntityInfo(const MED::TMeshInfo& theMeshInfo, - EConnectivite theTConn, - TErr* theErr) + //----------------------------------------------------------------- + TEntityInfo + TVWrapper + ::GetEntityInfo(const MED::TMeshInfo& theMeshInfo, + EConnectivite theConnMode, + TErr* theErr) { TEntityInfo anInfo; @@ -945,7 +1041,7 @@ namespace MED{ TGeomSet::const_iterator anIterEnd2 = aGeomSet.end(); for(; anIter2 != anIterEnd2; anIter2++){ const EGeometrieElement& aGeom = *anIter2; - aNbElem = GetNbCells(theMeshInfo,anEntity,aGeom,theTConn,theErr); + aNbElem = GetNbCells(theMeshInfo,anEntity,aGeom,theConnMode,theErr); if(aNbElem > 0) anInfo[anEntity][aGeom] = aNbElem; } @@ -955,11 +1051,14 @@ namespace MED{ } - TInt TVWrapper::GetNbCells(const MED::TMeshInfo& theMeshInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, - EConnectivite theTConn, - TErr* theErr) + //----------------------------------------------------------------- + TInt + TVWrapper + ::GetNbCells(const MED::TMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -968,21 +1067,19 @@ namespace MED{ MED::TMeshInfo& aMeshInfo = const_cast(theMeshInfo); - med_entite_maillage anEntity = med_entite_maillage(theTEntity); - med_geometrie_element aGeom = med_geometrie_element(theTGeom); - med_connectivite aConn = med_connectivite(theTConn); - return MEDnEntMaa(myFile->Id(), &aMeshInfo.myName[0], MED_CONN, - anEntity, - aGeom, - aConn); + med_entite_maillage(theEntity), + med_geometrie_element(theGeom), + med_connectivite(theConnMode)); } - void TVWrapper::GetCellInfo(MED::TCellInfo& theInfo, - TErr* theErr) + void + TVWrapper + ::GetCellInfo(MED::TCellInfo& theInfo, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -992,26 +1089,24 @@ namespace MED{ MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; TInt aNbElem = theInfo.myElemNum.size(); - med_booleen& anIsElemNames = (med_booleen&)(theInfo.myIsElemNames); - med_booleen& anIsElemNum = (med_booleen&)(theInfo.myIsElemNum); - med_entite_maillage& anEntity = (med_entite_maillage&)(theInfo.myTEntity); - med_geometrie_element& aGeom = (med_geometrie_element&)(theInfo.myTGeom); - med_connectivite& aConn = (med_connectivite&)(theInfo.myTConn); - - TErr aRet = MEDelementsLire(myFile->Id(), - &aMeshInfo.myName[0], - aMeshInfo.myDim, - (med_int *)&theInfo.myConn[0], - MED_FULL_INTERLACE, - &theInfo.myElemNames[0], - &anIsElemNames, - (med_int *)&theInfo.myElemNum[0], - &anIsElemNum, - (med_int *)&theInfo.myFamNum[0], - aNbElem, - anEntity, - aGeom, - aConn); + char* anElemNames = theInfo.myIsElemNames? &theInfo.myElemNames[0]: NULL; + med_int* anElemNum = theInfo.myIsElemNum? &theInfo.myElemNum[0]: NULL; + + TErr aRet; + aRet = MEDelementsLire(myFile->Id(), + &aMeshInfo.myName[0], + aMeshInfo.myDim, + (med_int*)&theInfo.myConn[0], + med_mode_switch(theInfo.myModeSwitch), + anElemNames, + (med_booleen*)&theInfo.myIsElemNames, + anElemNum, + (med_booleen*)&theInfo.myIsElemNum, + (med_int*)&theInfo.myFamNum[0], + aNbElem, + med_entite_maillage(theInfo.myEntity), + med_geometrie_element(theInfo.myGeom), + med_connectivite(theInfo.myConnMode)); if(theErr) *theErr = aRet; else if(aRet < 0) @@ -1019,9 +1114,11 @@ namespace MED{ } - void TVWrapper::SetCellInfo(const MED::TCellInfo& theInfo, - EModeAcces theMode, - TErr* theErr) + void + TVWrapper + ::SetCellInfo(const MED::TCellInfo& theInfo, + EModeAcces theMode, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,theMode,theErr); @@ -1031,26 +1128,24 @@ namespace MED{ MED::TCellInfo& anInfo = const_cast(theInfo); MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; - med_booleen& anIsElemNames = (med_booleen&)(theInfo.myIsElemNames); - med_booleen& anIsElemNum = (med_booleen&)(theInfo.myIsElemNum); - med_entite_maillage& anEntity = (med_entite_maillage&)(theInfo.myTEntity); - med_geometrie_element& aGeom = (med_geometrie_element&)(theInfo.myTGeom); - med_connectivite& aConn = (med_connectivite&)(theInfo.myTConn); + char* anElemNames = theInfo.myIsElemNames? &anInfo.myElemNames[0]: NULL; + med_int* anElemNum = theInfo.myIsElemNum? &anInfo.myElemNum[0]: NULL; - TErr aRet = MEDelementsEcr(myFile->Id(), - &aMeshInfo.myName[0], - aMeshInfo.myDim, - (med_int *)&anInfo.myConn[0], - MED_FULL_INTERLACE, - &anInfo.myElemNames[0], - anIsElemNames, - (med_int *)&anInfo.myElemNum[0], - anIsElemNum, - (med_int *)&anInfo.myFamNum[0], - anInfo.myNbElem, - anEntity, - aGeom, - aConn); + TErr aRet; + aRet = MEDelementsEcr(myFile->Id(), + &aMeshInfo.myName[0], + aMeshInfo.myDim, + (med_int*)&anInfo.myConn[0], + med_mode_switch(theInfo.myModeSwitch), + anElemNames, + med_booleen(theInfo.myIsElemNames), + anElemNum, + med_booleen(theInfo.myIsElemNum), + (med_int*)&anInfo.myFamNum[0], + anInfo.myNbElem, + med_entite_maillage(theInfo.myEntity), + med_geometrie_element(theInfo.myGeom), + med_connectivite(theInfo.myConnMode)); if(theErr) *theErr = aRet; @@ -1059,14 +1154,19 @@ namespace MED{ } - void TVWrapper::SetCellInfo(const MED::TCellInfo& theInfo, - TErr* theErr) + void + TVWrapper + ::SetCellInfo(const MED::TCellInfo& theInfo, + TErr* theErr) { SetCellInfo(theInfo,eLECTURE_ECRITURE,theErr); } - TInt TVWrapper::GetNbFields(TErr* theErr) + //----------------------------------------------------------------- + TInt + TVWrapper + ::GetNbFields(TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -1077,8 +1177,10 @@ namespace MED{ } - TInt TVWrapper::GetNbComp(TInt theFieldId, - TErr* theErr) + TInt + TVWrapper + ::GetNbComp(TInt theFieldId, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -1089,8 +1191,10 @@ namespace MED{ } - void TVWrapper::GetFieldInfo(TInt theFieldId, - MED::TFieldInfo& theInfo, + void + TVWrapper + ::GetFieldInfo(TInt theFieldId, + MED::TFieldInfo& theInfo, TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -1098,15 +1202,14 @@ namespace MED{ if(theErr && !*theErr) return; - med_type_champ& aType = (med_type_champ&)(theInfo.myType); - - TErr aRet = MEDchampInfo(myFile->Id(), - theFieldId, - &theInfo.myName[0], - &aType, - &theInfo.myCompNames[0], - &theInfo.myUnitNames[0], - theInfo.myNbComp); + TErr aRet; + aRet = MEDchampInfo(myFile->Id(), + theFieldId, + &theInfo.myName[0], + (med_type_champ*)&theInfo.myType, + &theInfo.myCompNames[0], + &theInfo.myUnitNames[0], + theInfo.myNbComp); if(theErr) *theErr = aRet; else if(aRet < 0) @@ -1114,9 +1217,11 @@ namespace MED{ } - void TVWrapper::SetFieldInfo(const MED::TFieldInfo& theInfo, - EModeAcces theMode, - TErr* theErr) + void + TVWrapper + ::SetFieldInfo(const MED::TFieldInfo& theInfo, + EModeAcces theMode, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,theMode,theErr); @@ -1125,14 +1230,13 @@ namespace MED{ MED::TFieldInfo& anInfo = const_cast(theInfo); - med_type_champ& aType = (med_type_champ&)(theInfo.myType); - - TErr aRet = MEDchampCr(myFile->Id(), - &anInfo.myName[0], - aType, - &anInfo.myCompNames[0], - &anInfo.myUnitNames[0], - anInfo.myNbComp); + TErr aRet; + aRet = MEDchampCr(myFile->Id(), + &anInfo.myName[0], + med_type_champ(theInfo.myType), + &anInfo.myCompNames[0], + &anInfo.myUnitNames[0], + anInfo.myNbComp); if(theErr) *theErr = aRet; else if(aRet < 0) @@ -1140,8 +1244,10 @@ namespace MED{ } - void TVWrapper::SetFieldInfo(const MED::TFieldInfo& theInfo, - TErr* theErr) + void + TVWrapper + ::SetFieldInfo(const MED::TFieldInfo& theInfo, + TErr* theErr) { TErr aRet; SetFieldInfo(theInfo,eLECTURE_ECRITURE,&aRet); @@ -1151,11 +1257,147 @@ namespace MED{ } - TInt TVWrapper::GetNbTimeStamps(const MED::TFieldInfo& theInfo, - const MED::TEntityInfo& theEntityInfo, - EEntiteMaillage& theEntity, - TGeom& theGeom, - TErr* theErr) + //----------------------------------------------------------------- + TInt + TVWrapper + ::GetNbGauss(TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return -1; + + return MEDnGauss(myFile->Id()); + } + + + TGaussInfo::TInfo + TVWrapper + ::GetGaussPreInfo(TInt theId, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return TGaussInfo::TInfo(); + + med_int aNbGaussPoints = med_int(); + TVector aName(GetNOMLength()+1); + med_geometrie_element aGeom = MED_NONE; + + TErr aRet; + aRet = MEDgaussInfo(myFile->Id(), + theId, + &aName[0], + &aGeom, + &aNbGaussPoints); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"GetGaussPreInfo - MEDgaussInfo(...)"); + + 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; + + TErr aRet; + aRet = MEDgaussLire(myFile->Id(), + &theInfo.myRefCoord[0], + &theInfo.myGaussCoord[0], + &theInfo.myWeight[0], + med_mode_switch(theInfo.myModeSwitch), + &theInfo.myName[0]); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"GetGaussInfo - MEDgaussLire(...)"); + } + + + //----------------------------------------------------------------- + TInt + TVWrapper + ::GetNbProfiles(TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return -1; + + return MEDnProfil(myFile->Id()); + } + + + TProfileInfo::TInfo + TVWrapper + ::GetProfilePreInfo(TInt theId, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && *theErr < 0) + return TProfileInfo::TInfo(); + + TInt aSize = -1; + TVector aName(GetNOMLength()+1); + + TErr aRet; + aRet = MEDprofilInfo(myFile->Id(), + theId, + &aName[0], + &aSize); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"GetProfilePreInfo - MEDprofilInfo(...)"); + + 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; + + TErr aRet; + aRet = MEDprofilLire(myFile->Id(), + &theInfo.myElemNum[0], + &theInfo.myName[0]); + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"GetProfileInfo - MEDprofilLire(...)"); + } + + + //----------------------------------------------------------------- + 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); @@ -1168,86 +1410,131 @@ namespace MED{ }else if(theEntityInfo.empty()) EXCEPTION(runtime_error,"GetNbTimeStamps - There is no any Entity on the Mesh"); - theGeom.clear(); + theGeom2Size.clear(); TInt aNbTimeStamps = 0; + TIdt anId = myFile->Id(); + MED::TFieldInfo& anInfo = const_cast(theInfo); + MED::TMeshInfo& aMeshInfo = anInfo.myMeshInfo; + TEntityInfo::const_iterator anIter = theEntityInfo.begin(); for(; anIter != theEntityInfo.end(); anIter++){ - const med_entite_maillage& anEntity = (const med_entite_maillage&)(anIter->first); - const TGeom& aTGeom = anIter->second; - TGeom::const_iterator anGeomIter = aTGeom.begin(); - for(; anGeomIter != aTGeom.end(); anGeomIter++){ - const med_geometrie_element& aGeom = (const med_geometrie_element&)(anGeomIter->first); - TInt aTmp = MEDnPasdetemps(myFile->Id(),&anInfo.myName[0],anEntity,aGeom); - aNbTimeStamps = max(aTmp,aNbTimeStamps); - if (aNbTimeStamps<1) - continue; - BEGMSG(MYDEBUG,"GetNbTimeStamps aNbTimeStamps="<second; + med_entite_maillage anEntity = med_entite_maillage(anIter->first); + const TGeom2Size& aGeom2Size = anIter->second; + TGeom2Size::const_iterator anGeomIter = aGeom2Size.begin(); + for(; anGeomIter != aGeom2Size.end(); anGeomIter++){ + med_geometrie_element aGeom = med_geometrie_element(anGeomIter->first); + TInt aNbStamps = MEDnPasdetemps(anId, + &anInfo.myName[0], + anEntity, + aGeom); + if(aNbStamps > 0){ + INITMSG(MYDEBUG, + "GetNbTimeStamps aNbTimeStamps = "<()+1]; + char aDtUnit[GetPNOMLength()+1]; + med_int aNbGauss; + med_int aNumDt; + med_int aNumOrd; + med_float aDt; + med_booleen anIsLocal; + med_int aNbRef; + TErr aRet = MEDpasdetempsInfo(anId, + &anInfo.myName[0], + anEntity, + aGeom, + iTimeStamp, + &aNbGauss, + &aNumDt, + &aNumOrd, + aDtUnit, + &aDt, + aMaillageChamp, + &anIsLocal, + &aNbRef); + INITMSG(MYDEBUG, + "GetNbTimeStamps aMaillageChamp = '"<second; + theEntity = EEntiteMaillage(anEntity); + aNbTimeStamps = aNbStamps; + } + } } } - if(!theGeom.empty()) + if(!theGeom2Size.empty()) break; } return aNbTimeStamps; } - void TVWrapper::GetTimeStampInfo(TInt theTimeStampId, - MED::TTimeStampInfo& theInfo, - TErr* theErr) + void + TVWrapper + ::GetTimeStampInfo(TInt theTimeStampId, + MED::TTimeStampInfo& theInfo, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); - TGeom& aTGeom = theInfo.myGeom; + const TGeom2Size& aGeom2Size = theInfo.myGeom2Size; if(theErr){ - if(aTGeom.empty()) + if(aGeom2Size.empty()) *theErr = -1; if(*theErr < 0) return; - }else if(aTGeom.empty()) + }else if(aGeom2Size.empty()) EXCEPTION(runtime_error,"GetTimeStampInfo - There is no any cell"); MED::TFieldInfo& aFieldInfo = *theInfo.myFieldInfo; MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo; - med_entite_maillage& anEntity = (med_entite_maillage&)(theInfo.myEntity); - - TGeom::iterator anIter = aTGeom.begin(); - med_geometrie_element& aGeom = (med_geometrie_element&)(anIter->first); - - med_booleen& anIsLocal = (med_booleen&)(aFieldInfo.myIsLocal); - - TErr aRet = MEDpasdetempsInfo(myFile->Id(), - &aFieldInfo.myName[0], - anEntity, - aGeom, - theTimeStampId, - (med_int *)&theInfo.myNbGauss, - (med_int *)&theInfo.myNumDt, - (med_int *)&theInfo.myNumOrd, - &theInfo.myUnitDt[0], - &theInfo.myDt, - &aMeshInfo.myName[0], - &anIsLocal, - (med_int *)&aFieldInfo.myNbRef); - if(theErr) - *theErr = aRet; - else if(aRet < 0) - EXCEPTION(runtime_error,"GetTimeStampInfo - MEDpasdetempsInfo(...)"); - - static TInt MAX_NB_GAUSS_POINTS = 32; - if(theInfo.myNbGauss <= 0 || theInfo.myNbGauss > MAX_NB_GAUSS_POINTS) - theInfo.myNbGauss = 1; + TGeom2NbGauss& aGeom2NbGauss = theInfo.myGeom2NbGauss; + + TGeom2Size::const_iterator anIter = aGeom2Size.begin(); + for(; anIter != aGeom2Size.end(); anIter++){ + const EGeometrieElement& aGeom = anIter->first; + med_int aNbGauss = -1; + + TErr aRet; + aRet = MEDpasdetempsInfo(myFile->Id(), + &aFieldInfo.myName[0], + med_entite_maillage(theInfo.myEntity), + med_geometrie_element(anIter->first), + theTimeStampId, + &aNbGauss, + (med_int*)&theInfo.myNumDt, + (med_int*)&theInfo.myNumOrd, + &theInfo.myUnitDt[0], + &theInfo.myDt, + &aMeshInfo.myName[0], + (med_booleen*)&aFieldInfo.myIsLocal, + (med_int*)&aFieldInfo.myNbRef); + + 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(runtime_error,"GetTimeStampInfo - MEDpasdetempsInfo(...)"); + } } - void TVWrapper::GetTimeStampVal(MED::TTimeStampVal& theVal, - TErr* theErr) + void + TVWrapper + ::GetTimeStampVal(TTimeStampVal& theVal, + const TMKey2Profile& theMKey2Profile, + const TKey2Gauss& theKey2Gauss, + TErr* theErr) { TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); @@ -1260,20 +1547,63 @@ namespace MED{ MED::TFieldInfo& aFieldInfo = *aTimeStampInfo.myFieldInfo; MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo; - med_entite_maillage& anEntity = (med_entite_maillage&)(aTimeStampInfo.myEntity); - med_mode_profil& aPflMode = (med_mode_profil&)(theVal.myPflMode); - TGeom& aTGeom = aTimeStampInfo.myGeom; - TGeom::iterator anIter = aTGeom.begin(); - for(; anIter != aTGeom.end(); anIter++){ - med_geometrie_element& aGeom = (med_geometrie_element&)(anIter->first); + TGeom2Gauss& aGeom2Gauss = aTimeStampInfo.myGeom2Gauss; + TVector aGaussName(GetNOMLength()+1); + + med_mode_profil aProfileMode = med_mode_profil(boost::get<0>(theMKey2Profile)); + MED::TKey2Profile aKey2Profile = boost::get<1>(theMKey2Profile); + MED::TGeom2Profile& aGeom2Profile = theVal.myGeom2Profile; + TVector aProfileName(GetNOMLength()+1); + + TGeom2Size& aGeom2Size = aTimeStampInfo.myGeom2Size; + TGeom2Size::iterator anIter = aGeom2Size.begin(); + for(; anIter != aGeom2Size.end(); anIter++){ + EGeometrieElement aGeom = anIter->first; + TInt aNbCells = anIter->second; + + TInt aNbMeshRef = MEDnChampRef(anId, + &aFieldInfo.myName[0], + med_entite_maillage(aTimeStampInfo.myEntity), + med_geometrie_element(aGeom), + aTimeStampInfo.myNumDt, + aTimeStampInfo.myNumOrd); + if(aNbMeshRef < 1){ + if(theErr){ + *theErr = MED_FAUX; + return; + } + EXCEPTION(runtime_error,"GetTimeStampVal - MEDnChampRef(...) < 1"); + } + + TErr aRet; + med_int aNbGauss = -1; + aRet = MEDchampRefInfo(anId, + &aFieldInfo.myName[0], + med_entite_maillage(aTimeStampInfo.myEntity), + med_geometrie_element(aGeom), + aNbMeshRef, + aTimeStampInfo.myNumDt, + aTimeStampInfo.myNumOrd, + &aMeshInfo.myName[0], + (med_booleen*)&aFieldInfo.myIsLocal, + &aNbGauss); + + if(aRet < 0){ + if(theErr){ + *theErr = MED_FAUX; + return; + } + EXCEPTION(runtime_error,"GetTimeStampVal - MEDchampRefInfo(...)"); + } + TInt aNbVal = MEDnVal(anId, &aFieldInfo.myName[0], - anEntity, - aGeom, + med_entite_maillage(aTimeStampInfo.myEntity), + med_geometrie_element(aGeom), aTimeStampInfo.myNumDt, aTimeStampInfo.myNumOrd, &aMeshInfo.myName[0], - aPflMode); + aProfileMode); if(aNbVal <= 0){ if(theErr){ *theErr = -1; @@ -1282,64 +1612,56 @@ namespace MED{ EXCEPTION(runtime_error,"GetTimeStampInfo - MEDnVal(...) - aNbVal == "<second; + aGeom2Gauss[aGeom] = aGaussInfo; + } + } + + MED::PProfileInfo aProfileInfo; + if(strcmp(&aProfileName[0],"") != 0){ + MED::TKey2Profile::const_iterator anIter = aKey2Profile.find(&aProfileName[0]); + if(anIter != aKey2Profile.end()){ + aProfileInfo = anIter->second; + aGeom2Profile[aGeom] = aProfileInfo; + } + } + + if(aNbGauss > 1 && !aGaussInfo){ + if(theErr){ + *theErr = MED_FAUX; + return; + } + EXCEPTION(runtime_error,"GetValTimeStamp "<< + "- aNbGauss("< 1 && !aGaussInfo"<< + "; aGaussName = '"<<&aGaussName[0]<<"'"<< + "; aGeom = "<GetNbGauss()){ + if(theErr){ + *theErr = MED_FAUX; + return; + } + EXCEPTION(runtime_error,"GetValTimeStamp - aNbGauss != aGaussInfo->GetNbGauss()"); + } + + if(aProfileInfo && aProfileInfo->IsPresent()){ + TInt aNbSubCells = aProfileInfo->GetSize(); + + TInt aSize = aNbSubCells*aFieldInfo.myNbComp*aNbGauss; + if(aSize != aValue.size()){ + if(theErr){ + *theErr = -1; + return; + } + EXCEPTION(runtime_error, + "GetTimeStampInfo - aSize("<Id(); MED::TTimeStampVal& aVal = const_cast(theVal); + MED::TTimeStampInfo& aTimeStampInfo = *aVal.myTimeStampInfo; MED::TFieldInfo& aFieldInfo = *aTimeStampInfo.myFieldInfo; MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo; - MED::TMeshValue& aMeshValue = aVal.myMeshValue; - - med_entite_maillage& anEntity = (med_entite_maillage&)(aTimeStampInfo.myEntity); - med_mode_profil& aPflMode = (med_mode_profil&)(theVal.myPflMode); - TMeshValue::iterator anIter = aMeshValue.begin(); - for(; anIter != aMeshValue.end(); anIter++){ - med_geometrie_element& aGeom = (med_geometrie_element&)(anIter->first); - TValue& aValue = aVal.myMeshValue[EGeometrieElement(aGeom)]; - med_int iEnd = aValue.size(); - med_int aNbVal = iEnd / aFieldInfo.myNbComp; + MED::TGeom2Value& aGeom2Value = aVal.myGeom2Value; + + MED::TGeom2Gauss& aGeom2Gauss = aTimeStampInfo.myGeom2Gauss; + MED::TGeom2Profile& aGeom2Profile = aVal.myGeom2Profile; + + TGeom2Value::iterator anIter = aGeom2Value.begin(); + for(; anIter != aGeom2Value.end(); anIter++){ + EGeometrieElement aGeom = anIter->first; + TMeshValue& aMeshValue = anIter->second; + + 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_mode_profil aProfileMode = med_mode_profil(eNO_PFLMOD); + MED::TGeom2Profile::const_iterator aProfileIter = aGeom2Profile.find(aGeom); + if(aProfileIter != aGeom2Profile.end()){ + MED::PProfileInfo aProfileInfo = aProfileIter->second; + aProfileMode = med_mode_profil(aProfileInfo->myMode); + strcpy(&aProfileName[0],&aProfileInfo->myName[0]); + } + + med_int aNbVal = aMeshValue.myNbElem / aFieldInfo.myNbComp; + TValue& aValue = aMeshValue.myValue; + TInt anEnd = aValue.size(); switch(aFieldInfo.myType){ case eFLOAT64: { - std::vector& anArray = aValue; + TVector& anArray = aValue; aRet = MEDchampEcr(anId, &aMeshInfo.myName[0], &aFieldInfo.myName[0], (unsigned char*)&anArray[0], - MED_FULL_INTERLACE, + med_mode_switch(theVal.myModeSwitch), aNbVal, - &aTimeStampInfo.myGaussName[0], + &aGaussName[0], MED_ALL, - &aVal.myPflName[0], - aPflMode, - anEntity, - aGeom, + &aProfileName[0], + aProfileMode, + med_entite_maillage(aTimeStampInfo.myEntity), + med_geometrie_element(aGeom), aTimeStampInfo.myNumDt, &aTimeStampInfo.myUnitDt[0], aTimeStampInfo.myDt, @@ -1401,21 +1824,22 @@ namespace MED{ break; } default: { - vector anArray(iEnd); - for(TInt i = 0; i< iEnd; i++) anArray[i] = TInt(aValue[i]); + vector anArray(anEnd); + for(TInt anID = 0; anID < anEnd; anID++) + anArray[anID] = TInt(aValue[anID]); aRet = MEDchampEcr(anId, &aMeshInfo.myName[0], &aFieldInfo.myName[0], (unsigned char*)&anArray[0], - MED_FULL_INTERLACE, + med_mode_switch(theVal.myModeSwitch), aNbVal, - &aTimeStampInfo.myGaussName[0], + &aGaussName[0], MED_ALL, - &aVal.myPflName[0], - aPflMode, - anEntity, - aGeom, + &aProfileName[0], + aProfileMode, + med_entite_maillage(aTimeStampInfo.myEntity), + med_geometrie_element(aGeom), aTimeStampInfo.myNumDt, &aTimeStampInfo.myUnitDt[0], aTimeStampInfo.myDt, @@ -1437,8 +1861,10 @@ namespace MED{ } - void TVWrapper::SetTimeStamp(const MED::TTimeStampVal& theVal, - TErr* theErr) + void + TVWrapper + ::SetTimeStamp(const MED::TTimeStampVal& theVal, + TErr* theErr) { TErr aRet; SetTimeStamp(theVal,eLECTURE_ECRITURE,&aRet); diff --git a/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.hxx b/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.hxx index 9b20a1c57..f8398b758 100644 --- a/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.hxx +++ b/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.hxx @@ -32,24 +32,50 @@ #include "MED_Structures.hxx" #include "MED_TWrapper.hxx" -namespace MED{ - namespace V2_2{ +namespace MED +{ + template<> + TInt + GetDESCLength(); + + template<> + TInt + GetIDENTLength(); + + template<> + TInt + GetNOMLength(); + + template<> + TInt + GetLNOMLength(); + + template<> + TInt + GetPNOMLength(); - const TInt PNOM = 16; + template<> + TInt + GetNbConn(EGeometrieElement typmai, + EEntiteMaillage typent, + TInt mdim); - typedef MED::TTMeshInfo TVMeshInfo; + namespace V2_2 + { - typedef MED::TTFamilyInfo TVFamilyInfo; + typedef MED::TTMeshInfo TVMeshInfo; - typedef MED::TTNodeInfo TVNodeInfo; + typedef MED::TTFamilyInfo TVFamilyInfo; - typedef MED::TTCellInfo TVCellInfo; + typedef MED::TTNodeInfo TVNodeInfo; - typedef MED::TTFieldInfo TVFieldInfo; + typedef MED::TTCellInfo TVCellInfo; - typedef MED::TTTimeStampInfo TVTimeStampInfo; + typedef MED::TTFieldInfo TVFieldInfo; - typedef MED::TTTimeStampVal TVTimeStampVal; + typedef MED::TTTimeStampInfo TVTimeStampInfo; + + typedef MED::TTTimeStampVal TVTimeStampVal; //--------------------------------------------------------------- class TFile; @@ -58,7 +84,8 @@ namespace MED{ typedef enum {eLECTURE, eLECTURE_ECRITURE, eLECTURE_AJOUT, eCREATION} EModeAcces; //--------------------------------------------------------------- - class TVWrapper: public MED::TTWrapper{ + class TVWrapper: public MED::TTWrapper + { TVWrapper(); TVWrapper(const TVWrapper&); TVWrapper& operator=(const TVWrapper&); @@ -126,64 +153,64 @@ namespace MED{ void GetNames(TElemInfo& theInfo, TInt nb, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TErr* theErr = NULL); virtual void GetNumeration(TElemInfo& theInfo, TInt nb, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TErr* theErr = NULL); virtual void GetFamilies(TElemInfo& theInfo, TInt nb, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TErr* theErr = NULL); virtual void SetNames(const TElemInfo& theInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TErr* theErr = NULL); void SetNames(const TElemInfo& theInfo, EModeAcces theMode, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TErr* theErr = NULL); virtual void SetNumeration(const TElemInfo& theInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TErr* theErr = NULL); void SetNumeration(const TElemInfo& theInfo, EModeAcces theMode, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TErr* theErr = NULL); virtual void SetFamilies(const TElemInfo& theInfo, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TErr* theErr = NULL); void SetFamilies(const TElemInfo& theInfo, EModeAcces theMode, - EEntiteMaillage theTEntity, - EGeometrieElement theTGeom, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, TErr* theErr = NULL); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -226,17 +253,17 @@ namespace MED{ virtual TInt GetNbPolygones(const TMeshInfo& theMeshInfo, - EEntiteMaillage, - EGeometrieElement, - EConnectivite, - TErr* theErr = NULL); + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode = eNOD, + TErr* theErr = NULL); virtual TInt - GetNbPolygoneConn(const TMeshInfo& theMeshInfo, - EEntiteMaillage, - EGeometrieElement, - EConnectivite, + GetPolygoneConnSize(const TMeshInfo& theMeshInfo, + EEntiteMaillage theEntity, + EGeometrieElement theGeom, + EConnectivite theConnMode = eNOD, TErr* theErr = NULL); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -265,17 +292,17 @@ namespace MED{ virtual void - GetNbPolyedreConnF(const TMeshInfo& theMeshInfo, - EConnectivite, - TInt& nf, - TInt& nc, - TErr* theErr = NULL); + GetPolyedreConnSize(const TMeshInfo& theMeshInfo, + TInt& theNbFaces, + TInt& theConnSize, + EConnectivite theConnMode = eNOD, + TErr* theErr = NULL); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ virtual TEntityInfo GetEntityInfo(const MED::TMeshInfo& theMeshInfo, - EConnectivite theTConn = eNOD, + EConnectivite theConnMode = eNOD, TErr* theErr = NULL); virtual @@ -283,7 +310,7 @@ namespace MED{ GetNbCells(const MED::TMeshInfo& theMeshInfo, EEntiteMaillage, EGeometrieElement, - EConnectivite theTConn = eNOD, + EConnectivite theConnMode = eNOD, TErr* theErr = NULL); virtual @@ -328,14 +355,46 @@ namespace MED{ 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 TInt GetNbTimeStamps(const MED::TFieldInfo& theInfo, const MED::TEntityInfo& theEntityInfo, EEntiteMaillage& theEntity, - TGeom& theGeom, + TGeom2Size& theGeom2Size, TErr* theErr = NULL); virtual @@ -347,6 +406,8 @@ namespace MED{ virtual void GetTimeStampVal(MED::TTimeStampVal& theVal, + const TMKey2Profile& theMKey2Profile, + const TKey2Gauss& theKey2Gauss, TErr* theErr = NULL); virtual