From: prascle Date: Mon, 17 Jan 2005 15:48:36 +0000 (+0000) Subject: PR: merge from tag mergeto_trunk_18Jan05 X-Git-Tag: V2_2_0a1~2 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=ac9ce587bb07788690346a2b520c4eba9995e85c;p=modules%2Fkernel.git PR: merge from tag mergeto_trunk_18Jan05 --- diff --git a/src/MEDWrapper/Base/MED_Algorithm.cxx b/src/MEDWrapper/Base/MED_Algorithm.cxx new file mode 100644 index 000000000..cafc21b0b --- /dev/null +++ b/src/MEDWrapper/Base/MED_Algorithm.cxx @@ -0,0 +1,264 @@ +// +// +// 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_Algorithm.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{ + //--------------------------------------------------------------- + TCellGroup + GetCellsByEntity(TWrapper& theWrapper, + const PMeshInfo& theMeshInfo, + const MED::TEntityInfo& theEntityInfo) + { + MSG(MYDEBUG,"GetCellsByEntity(...)"); + TCellGroup aGroup; + MED::TEntityInfo::const_iterator anIter = theEntityInfo.begin(); + for(; anIter != theEntityInfo.end(); anIter++){ + const EEntiteMaillage& anEntity = anIter->first; + if(anEntity == eNOEUD) continue; + const MED::TGeom& aGeom = anIter->second; + TCellSet& aCellSet = aGroup[anEntity]; + MED::TGeom::const_iterator anGeomIter = aGeom.begin(); + for(; anGeomIter != aGeom.end(); anGeomIter++){ + const EGeometrieElement& aGeo = anGeomIter->first; + PCellInfo aCellInfo = theWrapper.GetPCellInfo(theMeshInfo,anEntity,aGeo); + aCellSet.insert(aCellInfo); + if(MYDEBUG){ + TInt aNbElem = aCellInfo->GetNbElem(); + INITMSG(MYDEBUG,"aGeo = "<GetConnDim(); + for(TInt iConn = 0; iConn < iConnEnd; iConn++){ + ADDMSG(MYVALUEDEBUG,aCellInfo->GetConn(iElem,iConn)<<","); + } + ADDMSG(MYVALUEDEBUG," "); + } + ADDMSG(MYDEBUG,"\n"); + } + } + } + ADDMSG(MYDEBUG,"\n"); + return aGroup; + } + + + //--------------------------------------------------------------- + TFamilyGroup + GetFamilies(TWrapper& theWrapper, + const PMeshInfo& theMeshInfo) + { + MSG(MYDEBUG,"GetFamilies(...)"); + TFamilyGroup aGroup; + TInt aNbFam = theWrapper.GetNbFamilies(*theMeshInfo); + INITMSG(MYDEBUG,"GetNbFamilies() = "<GetName(); + TInt aNbAttr = aFamilyInfo->GetNbAttr(); + TInt aNbGroup = aFamilyInfo->GetNbGroup(); + INITMSG(MYDEBUG, + "aFamilyName = '"<GetGroupName(iGroup); + INITMSG(MYDEBUG,"aGroupName = '"<GetNbGroup(); + for(TInt iGroup = 0; iGroup < aNbGroup; iGroup++){ + aGroup[aFamilyInfo->GetGroupName(iGroup)].insert(aFamilyInfo); + } + } + if(MYDEBUG){ + TGroupInfo::const_iterator anIter = aGroup.begin(); + for(; anIter != aGroup.end(); anIter++){ + string aName = anIter->first; + INITMSG(MYDEBUG,"aGroupName = '"<second; + TFamilyGroup::const_iterator anFamIter = aFamilyGroup.begin(); + for(; anFamIter != aFamilyGroup.end(); anFamIter++){ + const PFamilyInfo& aFamilyInfo = *anFamIter; + INITMSG(MYDEBUG,"aFamilyName = '"<GetName()<<"'\n"); + } + } + ADDMSG(MYDEBUG,"\n"); + } + return aGroup; + } + + + //--------------------------------------------------------------- + TTimeStampGroup + GetFieldsByEntity(TWrapper& theWrapper, + const PMeshInfo& theMeshInfo, + const MED::TEntityInfo& theEntityInfo) + { + MSG(MYDEBUG,"GetFieldsByEntity(...)"); + TTimeStampGroup aGroup; + TInt aNbFields = theWrapper.GetNbFields(); + INITMSG(MYDEBUG,"GetNbFields() = "<GetNbComp(); + string aName = aFieldInfo->GetName(); + INITMSG(MYDEBUG,"aFieldName = '"<GetUnitDt() + <<"\', aNbGauss = "<GetNbGauss()<<"\n"); + } + } + ADDMSG(MYDEBUG,"\n"); + return aGroup; + } + + + TFieldGroup + GetFieldsByEntity(const TTimeStampGroup& theTimeStampGroup) + { + TFieldGroup aGroup; + TTimeStampGroup::const_iterator anIter = theTimeStampGroup.begin(); + for(; anIter != theTimeStampGroup.end(); anIter++){ + //const PFieldInfo& aFieldInfo = anIter->first; + const TTimeStampSet& aTimeStampSet = anIter->second; + if(aTimeStampSet.empty()) continue; + const PTimeStampInfo& aTimeStampInfo = *aTimeStampSet.begin(); + aGroup[aTimeStampInfo->GetEntity()].insert(*anIter); + } + return aGroup; + } + + + TFamilyByEntity + GetFamiliesByEntity(TWrapper& theWrapper, + const PNodeInfo& theNodeInfo, + const TCellGroup& theCellGroup, + const TFamilyGroup& theFamilyGroup) + { + MSG(MYDEBUG,"GetFamiliesByEntity(...)"); + TFamilyByEntity aFamilyByEntity; + + typedef map TFamilyByIdMap; + TFamilyByIdMap aFamilyByIdMap; + TFamilyGroup::const_iterator anIter = theFamilyGroup.begin(); + for(; anIter != theFamilyGroup.end(); anIter++){ + const PFamilyInfo& aFamilyInfo = *anIter; + aFamilyByIdMap.insert(TFamilyByIdMap::value_type(aFamilyInfo->GetId(),aFamilyInfo)); + } + + if(!aFamilyByIdMap.empty()){ + typedef set TFamilyIdSet; + typedef map TFamilyIdByEntity; + TFamilyIdByEntity aFamilyIdByEntity; + + if(theNodeInfo!=0){ + if(TInt aNbElem = theNodeInfo->GetNbElem()){ + TFamilyIdSet& aFamilyIdSet = aFamilyIdByEntity[eNOEUD]; + for(TInt i = 0; i < aNbElem; i++){ + aFamilyIdSet.insert(theNodeInfo->GetFamNum(i)); + } + } + } + + if(!theCellGroup.empty()){ + TCellGroup::const_iterator anIter = theCellGroup.begin(); + for(; anIter != theCellGroup.end(); anIter++){ + const EEntiteMaillage& anEntity = anIter->first; + TFamilyIdSet& aFamilyIdSet = aFamilyIdByEntity[anEntity]; + const TCellSet& aCellSet = anIter->second; + TCellSet::const_iterator anCellIter = aCellSet.begin(); + for(; anCellIter != aCellSet.end(); anCellIter++){ + const PCellInfo& aCellInfo = *anCellIter; + if(TInt aNbElem = aCellInfo->GetNbElem()){ + for(TInt i = 0; i < aNbElem; i++){ + aFamilyIdSet.insert(aCellInfo->GetFamNum(i)); + } + } + } + } + } + + if(!aFamilyIdByEntity.empty()){ + TFamilyIdByEntity::const_iterator anIter = aFamilyIdByEntity.begin(); + for(; anIter != aFamilyIdByEntity.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); + INITMSG(MYDEBUG, + "aFamilyName = '"<GetName()<< + "' anId = "<GetId()<<"\n"); + } + } + } + } + } + ADDMSG(MYDEBUG,"\n"); + return aFamilyByEntity; + } + +} diff --git a/src/MEDWrapper/Base/MED_Algorithm.hxx b/src/MEDWrapper/Base/MED_Algorithm.hxx new file mode 100644 index 000000000..7d519c0ad --- /dev/null +++ b/src/MEDWrapper/Base/MED_Algorithm.hxx @@ -0,0 +1,85 @@ +// +// +// 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_Algorithm_HeaderFile +#define MED_Algorithm_HeaderFile + +#include "MED_Structures.hxx" +#include "MED_Wrapper.hxx" + +#include + +namespace MED{ + //--------------------------------------------------------------- + typedef std::set TCellSet; + typedef std::map TCellGroup; + + TCellGroup GetCellsByEntity(TWrapper& theWrapper, + const PMeshInfo& theMeshInfo, + const MED::TEntityInfo& theEntityInfo); + + + //--------------------------------------------------------------- + typedef std::set TFamilyGroup; + + TFamilyGroup GetFamilies(TWrapper& theWrapper, + const PMeshInfo& theMeshInfo); + + + //--------------------------------------------------------------- + typedef std::map TFamilyByEntity; + + TFamilyByEntity GetFamiliesByEntity(TWrapper& theWrapper, + const PNodeInfo& theNodeInfo, + const TCellGroup& theCellGroup, + const TFamilyGroup& theFamilyGroup); + + + //--------------------------------------------------------------- + typedef std::map TGroupInfo; + + TGroupInfo GetFamiliesByGroup(const TFamilyGroup& theGroupInfo); + + + //--------------------------------------------------------------- + typedef std::set TTimeStampSet; + typedef std::map TTimeStampGroup; + + TTimeStampGroup GetFieldsByEntity(TWrapper& theWrapper, + const PMeshInfo& theMeshInfo, + const MED::TEntityInfo& theEntityInfo); + + + //--------------------------------------------------------------- + typedef std::map TFieldGroup; + + TFieldGroup GetFieldsByEntity(const TTimeStampGroup& theTimeStampGroup); + +} + +#endif diff --git a/src/MEDWrapper/Base/MED_Common.hxx b/src/MEDWrapper/Base/MED_Common.hxx new file mode 100644 index 000000000..51307abe8 --- /dev/null +++ b/src/MEDWrapper/Base/MED_Common.hxx @@ -0,0 +1,141 @@ +// +// +// 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_Common_HeaderFile +#define MED_Common_HeaderFile + +#include +#include +#include +#include + +extern "C"{ +#include +} + +#include + +namespace MED{ + + template class shared_ptr: public boost::shared_ptr + { + public: + shared_ptr() {} + + template + explicit shared_ptr(Y * p): boost::shared_ptr(p) {} + + template + shared_ptr(shared_ptr const & r): boost::shared_ptr(r) {} + + operator const T& () const { return *get();} + + operator T& () { return *get();} + }; + + + typedef enum {eFAUX, eVRAI} EBooleen ; + typedef double TFloat; + typedef int TInt; + + typedef hid_t TIdt; + typedef herr_t TErr; + + typedef enum {eFLOAT64=6, eINT=26} ETypeChamp; + + typedef enum {eNON_STRUCTURE, eSTRUCTURE} EMaillage; + + typedef enum {eCART, eCYL, eSPHER} ERepere; + + typedef enum {eNOD, eDESC} EConnectivite ; + + typedef enum {ePOINT1=1, eSEG2=102, eSEG3=103, eTRIA3=203, + eQUAD4=204, eTRIA6=206,eQUAD8=208, eTETRA4=304, + ePYRA5=305, ePENTA6=306, eHEXA8=308, eTETRA10=310, + ePYRA13=313, ePENTA15=315, eHEXA20=320, + ePOLYGONE=400, ePOLYEDRE=500, eNONE=0} EGeometrieElement; + + typedef enum {eMAILLE, eFACE, eARETE, eNOEUD} EEntiteMaillage; + + typedef enum {eNO_PFLMOD, eGLOBAL, eCOMPACT} EModeProfil; + + typedef std::vector TFloatVector; + typedef std::vector TStringVector; + typedef std::vector TIntVector; + typedef std::set TStringSet; + + typedef std::map TGeom; + typedef std::map TEntityInfo; + + typedef std::set TGeomSet; + typedef std::map TEntity2GeomSet; + + const TEntity2GeomSet& GetEntity2GeomSet(); + + inline TInt GetNbConn(EEntiteMaillage theEntity, + EGeometrieElement theElem, + TInt theMeshDim) + { + TInt anElemDim = theElem / 100, nsup = 0; + if(theEntity == eMAILLE && anElemDim < theMeshDim) nsup = 1; + return nsup + theElem % 100; + } + + struct TNameInfo; + typedef MED::shared_ptr PNameInfo; + + struct TMeshInfo; + typedef MED::shared_ptr PMeshInfo; + + struct TFamilyInfo; + typedef MED::shared_ptr PFamilyInfo; + + struct TElemInfo; + typedef MED::shared_ptr PElemInfo; + + struct TNodeInfo; + typedef MED::shared_ptr PNodeInfo; + + struct TCellInfo; + typedef MED::shared_ptr PCellInfo; + + struct TFieldInfo; + typedef MED::shared_ptr PFieldInfo; + + struct TTimeStampInfo; + typedef MED::shared_ptr PTimeStampInfo; + + struct TTimeStampVal; + typedef MED::shared_ptr PTimeStampVal; + + class TWrapper; + typedef MED::shared_ptr PWrapper; +}; + + +#endif diff --git a/src/MEDWrapper/Base/MED_Structures.hxx b/src/MEDWrapper/Base/MED_Structures.hxx new file mode 100644 index 000000000..8ade5eb2f --- /dev/null +++ b/src/MEDWrapper/Base/MED_Structures.hxx @@ -0,0 +1,304 @@ +// +// +// 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_Structures_HeaderFile +#define MED_Structures_HeaderFile + +#include "MED_Common.hxx" + +namespace MED{ + + //--------------------------------------------------------------- + typedef std::vector TString; + + inline std::string GetString(TInt theId, TInt theStep, + const TString& theString) + { + const char* aPos = &theString[theId*theStep]; + TInt aSize = std::min(TInt(strlen(aPos)),theStep); + return std::string(aPos,aSize); + } + + inline void SetString(TInt theId, TInt theStep, + TString& theString, + const std::string& theValue) + { + TInt aSize = std::min(TInt(theValue.size()+1),theStep); + strncpy(&theString[theId*theStep],theValue.c_str(),aSize); + } + + + //--------------------------------------------------------------- + struct TBase + { + virtual ~TBase() {} + }; + + + //--------------------------------------------------------------- + struct TNameInfo: virtual TBase + { + TString myName; + virtual std::string GetName() const = 0; + virtual void SetName(const std::string& theValue) = 0; + }; + + + //--------------------------------------------------------------- + struct TMeshInfo: virtual TNameInfo + { + TInt myDim; + TInt GetDim() const { return myDim;} + + EMaillage myType; + EMaillage GetType() const { return myType;} + + TString myDesc; + virtual std::string GetDesc() const = 0; + virtual void SetDesc(const std::string& theValue) = 0; + }; + + + //--------------------------------------------------------------- + typedef std::vector TFamAttr; + + struct TFamilyInfo: virtual TNameInfo + { + PMeshInfo myMeshInfo; + const PMeshInfo& GetMeshInfo() const { return myMeshInfo;} + + TInt myId; + TInt GetId() const { return myId;} + void SetId(TInt theId) { myId = theId;} + + TInt myNbGroup; + TInt GetNbGroup() const { return myNbGroup;} + + TString myGroupNames; + virtual std::string GetGroupName(TInt theId) const = 0; + virtual void SetGroupName(TInt theId, const std::string& theValue) = 0; + + TInt myNbAttr; + TInt GetNbAttr() const { return myNbAttr;} + + TFamAttr myAttrId; + TInt GetAttrId(TInt theId) const { return myAttrId[theId];} + void SetAttrId(TInt theId, TInt theVal) { myAttrId[theId] = theVal;} + + TFamAttr myAttrVal; + TInt GetAttrVal(TInt theId) const { return myAttrVal[theId];} + void SetAttrVal(TInt theId, TInt theVal) { myAttrVal[theId] = theVal;} + + TString myAttrDesc; + virtual std::string GetAttrDesc(TInt theId) const = 0; + virtual void SetAttrDesc(TInt theId, const std::string& theValue) = 0; + }; + + + //--------------------------------------------------------------- + typedef std::vector TElemNum; + + struct TElemInfo: virtual TBase + { + PMeshInfo myMeshInfo; + const PMeshInfo& GetMeshInfo() const { return myMeshInfo;} + + TInt myNbElem; + TInt GetNbElem() const { return myNbElem;} + + TElemNum myFamNum; + TInt GetFamNum(TInt theId) const { return myFamNum[theId];} + void SetFamNum(TInt theId, TInt theVal) { myFamNum[theId] = theVal;} + + EBooleen myIsElemNum; + EBooleen IsElemNum() const { return myIsElemNum;} + + TElemNum myElemNum; + TInt GetElemNum(TInt theId) const { return myElemNum[theId];} + void SetElemNum(TInt theId, TInt theVal) { myElemNum[theId] = theVal;} + + EBooleen myIsElemNames; + EBooleen IsElemNames() const { return myIsElemNames;} + + TString myElemNames; + virtual std::string GetElemName(TInt theId) const = 0; + virtual void SetElemName(TInt theId, const std::string& theValue) = 0; + }; + + + //--------------------------------------------------------------- + typedef std::vector TNodeCoord; + + struct TNodeInfo: virtual TElemInfo + { + TNodeCoord myCoord; + TFloat GetNodeCoord(TInt theId, TInt theComp) const { + return myCoord[myMeshInfo->myDim*theId + theComp]; + } + void SetNodeCoord(TInt theId, TInt theComp, TFloat theVal){ + myCoord[myMeshInfo->myDim*theId + theComp] = theVal; + } + + ERepere mySystem; + ERepere GetSystem() const { return mySystem;} + void SetSystem(ERepere theSystem) { mySystem = theSystem;} + + TString myCoordNames; + virtual std::string GetCoordName(TInt theId) const = 0; + virtual void SetCoordName(TInt theId, const std::string& theValue) = 0; + + TString myCoordUnits; + virtual std::string GetCoordUnit(TInt theId) const = 0; + virtual void SetCoordUnit(TInt theId, const std::string& theValue) = 0; + }; + + + //--------------------------------------------------------------- + struct TCellInfo: virtual TElemInfo + { + EEntiteMaillage myTEntity; + EEntiteMaillage GetEntity() const { return myTEntity;} + + EGeometrieElement myTGeom; + EGeometrieElement GetGeom() const { return myTGeom;} + + EConnectivite myTConn; + EConnectivite GetConn() const { return myTConn;} + + TInt myConnDim; + TInt GetConnDim() const { return myConnDim;} + + TElemNum myConn; + TInt GetConn(TInt theElemId, TInt theConnId) const { + return myConn[myConnDim*theElemId + theConnId]; + } + void SetConn(TInt theElemId, TInt theConnId, TInt theVal){ + myConn[myConnDim*theElemId + theConnId] = theVal; + } + }; + + + //--------------------------------------------------------------- + struct TFieldInfo: virtual TNameInfo + { + PMeshInfo myMeshInfo; + const PMeshInfo& GetMeshInfo() const { return myMeshInfo;} + + ETypeChamp myType; + ETypeChamp GetType() const { return myType;} + + TInt myNbComp; + TInt GetNbComp() const { return myNbComp;} + + EBooleen myIsLocal; + EBooleen GetIsLocal() const { return myIsLocal;} + + TInt myNbRef; + TInt GetNbRef() const { return myNbRef;} + + TString myCompNames; + virtual std::string GetCompName(TInt theId) const = 0; + virtual void SetCompName(TInt theId, const std::string& theValue) = 0; + + TString myUnitNames; + virtual std::string GetUnitName(TInt theId) const = 0; + virtual void SetUnitName(TInt theId, const std::string& theValue) = 0; + }; + + + //--------------------------------------------------------------- + struct TTimeStampInfo: virtual TBase + { + PFieldInfo myFieldInfo; + const PFieldInfo& GetFieldInfo() const { return myFieldInfo;} + + EEntiteMaillage myEntity; + EEntiteMaillage GetEntity() const { return myEntity;} + + TGeom myGeom; + const TGeom& GetGeom() const { return myGeom;} + + TInt myNbGauss, myNumDt, myNumOrd; + TInt GetNbGauss() const { return myNbGauss;} + TInt GetNumDt() const { return myNumDt;} + TInt GetNumOrd() const { return myNumOrd;} + + TFloat myDt; + TFloat GetDt() const { return myDt;} + + TString myGaussName; + virtual std::string GetGaussName() const = 0; + virtual void SetGaussName(const std::string& theValue) = 0; + + TString myUnitDt; + virtual std::string GetUnitDt() const = 0; + virtual void SetUnitDt(const std::string& theValue) = 0; + }; + + + //--------------------------------------------------------------- + typedef std::vector TValue; + typedef std::map TMeshValue; + + struct TTimeStampVal: virtual TBase + { + PTimeStampInfo myTimeStampInfo; + const PTimeStampInfo& GetTimeStampInfo() const { return myTimeStampInfo;} + + TMeshValue myMeshValue; + TFloat GetVal(EGeometrieElement theGeom, TInt theId, + TInt theComp, TInt theGauss = 0) 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()) + return anIter->second[theId*aStep + theComp*aNbGauss + theGauss]; + return TFloat(); + } + void SetVal(EGeometrieElement theGeom, TInt theId, + TInt theComp, TFloat theVal, TInt theGauss = 0) + { + TInt aNbComp = myTimeStampInfo->myFieldInfo->myNbComp; + TInt aNbGauss = myTimeStampInfo->myNbGauss; + TInt aStep = aNbComp*aNbGauss; + myMeshValue[theGeom][theId*aStep + theComp*aNbGauss + theGauss] = theVal; + } + EModeProfil myPflMode; + EModeProfil GetPflMode() const { return myPflMode;} + void GetPflMode(EModeProfil theVal) { myPflMode = theVal;} + + TString myPflName; + virtual std::string GetPflName() const = 0; + virtual void SetPflName(const std::string& theValue) = 0; + }; + +} + +#endif diff --git a/src/MEDWrapper/Base/MED_TStructures.hxx b/src/MEDWrapper/Base/MED_TStructures.hxx new file mode 100644 index 000000000..93dc7b66b --- /dev/null +++ b/src/MEDWrapper/Base/MED_TStructures.hxx @@ -0,0 +1,668 @@ +// +// +// 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_TStructures_HeaderFile +#define MED_TStructures_HeaderFile + +#include "MED_Structures.hxx" + +namespace MED{ + + const TInt DESC = 200; + const TInt IDENT = 8; + const TInt NOM = 32; + const TInt LNOM = 80; + + //--------------------------------------------------------------- + template + struct TTNameInfo: virtual TNameInfo + { + TTNameInfo(const std::string& theValue = "") + { + myName.resize(nNOM+1); + SetName(theValue); + } + + virtual std::string GetName() const { + return GetString(0,nNOM,myName); + } + + virtual void SetName(const std::string& theValue){ + SetString(0,nNOM,myName,theValue); + } + }; + + + //--------------------------------------------------------------- + template + struct TTMeshInfo: TMeshInfo, TTNameInfo + { + typedef TTNameInfo TNameInfoBase; + + TTMeshInfo(const PMeshInfo& theInfo): + TNameInfoBase(theInfo->GetName()) + { + myDim = theInfo->GetDim(); + myType = theInfo->GetType(); + + myDesc.resize(nDESC+1); + SetDesc(theInfo->GetDesc()); + } + + TTMeshInfo(TInt theDim = 0, + const std::string& theValue = "", + EMaillage theType = eNON_STRUCTURE, + const std::string& theDesc = ""): + TNameInfoBase(theValue) + { + myDim = theDim; + myType = theType; + + myDesc.resize(nDESC+1); + SetDesc(theDesc); + } + + virtual std::string GetDesc() const { + return GetString(0,nDESC,myDesc); + } + + virtual void SetDesc(const std::string& theValue){ + SetString(0,nDESC,myDesc,theValue); + } + }; + + + //--------------------------------------------------------------- + template + struct TTFamilyInfo: TFamilyInfo, TTNameInfo + { + typedef TTNameInfo TNameInfoBase; + + TTFamilyInfo(const PMeshInfo& theMeshInfo, const PFamilyInfo& theInfo): + TNameInfoBase(theInfo->GetName()) + { + myMeshInfo = theMeshInfo; + + myId = theInfo->GetId(); + + myNbGroup = theInfo->GetNbGroup(); + myGroupNames.resize(myNbGroup*nLNOM+1); + if(myNbGroup){ + for(TInt anId = 0; anId < myNbGroup; anId++){ + SetGroupName(anId,theInfo->GetGroupName(anId)); + } + } + + myNbAttr = theInfo->GetNbAttr(); + myAttrId.resize(myNbAttr); + myAttrVal.resize(myNbAttr); + myAttrDesc.resize(myNbAttr*nDESC+1); + if(myNbAttr){ + for(TInt anId = 0; anId < myNbAttr; anId++){ + SetAttrDesc(anId,theInfo->GetAttrDesc(anId)); + myAttrVal[anId] = theInfo->GetAttrVal(anId); + myAttrId[anId] = theInfo->GetAttrId(anId); + } + } + } + + TTFamilyInfo(const PMeshInfo& theMeshInfo, + TInt theNbGroup = 0, + TInt theNbAttr = 0, + TInt theId = 0, + const std::string& theValue = ""): + TNameInfoBase(theValue) + { + myMeshInfo = theMeshInfo; + + myId = theId; + + myNbGroup = theNbGroup; + myGroupNames.resize(theNbGroup*nLNOM+1); + + myNbAttr = theNbAttr; + myAttrId.resize(theNbAttr); + myAttrVal.resize(theNbAttr); + myAttrDesc.resize(theNbAttr*nDESC+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()): + TNameInfoBase(theValue) + { + myMeshInfo = theMeshInfo; + + myId = theId; + + myNbGroup = theGroupNames.size(); + myGroupNames.resize(myNbGroup*nLNOM+1); + if(myNbGroup){ + TStringSet::const_iterator anIter = theGroupNames.begin(); + for(TInt anId = 0; anIter != theGroupNames.end(); anIter++, anId++){ + const std::string& aVal = *anIter; + SetGroupName(anId,aVal); + } + } + + myNbAttr = theAttrDescs.size(); + myAttrId.resize(myNbAttr); + myAttrVal.resize(myNbAttr); + myAttrDesc.resize(myNbAttr*nDESC+1); + if(myNbAttr){ + for(TInt anId = 0, anEnd = theAttrDescs.size(); anId < anEnd; anId++){ + SetAttrDesc(anId,theAttrDescs[anId]); + myAttrVal[anId] = theAttrVals[anId]; + myAttrId[anId] = theAttrIds[anId]; + } + } + } + + virtual std::string GetGroupName(TInt theId) const { + return GetString(theId,nLNOM,myGroupNames); + } + + virtual void SetGroupName(TInt theId, const std::string& theValue){ + SetString(theId,nLNOM,myGroupNames,theValue); + } + + virtual std::string GetAttrDesc(TInt theId) const { + return GetString(theId,nDESC,myAttrDesc); + } + + virtual void SetAttrDesc(TInt theId, const std::string& theValue){ + SetString(theId,nDESC,myAttrDesc,theValue); + } + }; + + + //--------------------------------------------------------------- + template + struct TTElemInfo: virtual TElemInfo + { + TTElemInfo(const PMeshInfo& theMeshInfo, const PElemInfo& theInfo) + { + myMeshInfo = theMeshInfo; + + myNbElem = theInfo->GetNbElem(); + myFamNum.resize(myNbElem); + + myIsElemNum = theInfo->IsElemNum(); + myElemNum.resize(myIsElemNum == eFAUX? 0: myNbElem); + + myIsElemNames = theInfo->IsElemNames(); + myElemNames.resize(myNbElem*nPNOM+1); + + if(myNbElem){ + for(TInt anId = 0; anId < myNbElem; anId++){ + myFamNum[anId] = theInfo->GetFamNum(anId); + } + if(myIsElemNum == eVRAI){ + for(TInt anId = 0; anId < myNbElem; anId++){ + myElemNum[anId] = theInfo->GetElemNum(anId); + } + } + if(myIsElemNames == eVRAI){ + for(TInt anId = 0; anId < myNbElem; anId++){ + SetElemName(anId,theInfo->GetElemName(anId)); + } + } + } + } + + TTElemInfo(const PMeshInfo& theMeshInfo, + TInt theNbElem, + EBooleen theIsElemNum = eVRAI, + EBooleen theIsElemNames = eVRAI) + { + myMeshInfo = theMeshInfo; + + myNbElem = theNbElem; + myFamNum.resize(theNbElem); + + myIsElemNum = theIsElemNum; + myElemNum.resize(theIsElemNum == eFAUX? 0: theNbElem); + + myIsElemNames = theIsElemNames; + myElemNames.resize(theNbElem*nPNOM+1); + } + + TTElemInfo(const PMeshInfo& theMeshInfo, + const TIntVector& theFamilyNums, + const TIntVector& theElemNums, + const TStringVector& theElemNames = TStringVector()) + { + myMeshInfo = theMeshInfo; + + myNbElem = theFamilyNums.size(); + myFamNum.resize(myNbElem); + + myIsElemNum = theElemNums.size()? eVRAI: eFAUX; + myElemNum.resize(theElemNums.size()); + + myIsElemNames = theElemNames.size()? eVRAI: eFAUX; + myElemNames.resize(theElemNames.size()*nPNOM+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++){ + const std::string& aVal = theElemNames[anId]; + SetElemName(anId,aVal); + } + } + } + } + + virtual std::string GetElemName(TInt theId) const { + return GetString(theId,nPNOM,myElemNames); + } + + virtual void SetElemName(TInt theId, const std::string& theValue){ + SetString(theId,nPNOM,myElemNames,theValue); + } + }; + + + //--------------------------------------------------------------- + template + struct TTNodeInfo: TNodeInfo, TTElemInfo + { + typedef TTElemInfo TElemInfoBase; + + TTNodeInfo(const PMeshInfo& theMeshInfo, const PNodeInfo& theInfo): + TElemInfoBase(theMeshInfo,theInfo) + { + 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)); + } + } + + myCoordNames.resize(aDim*nPNOM+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++){ + SetCoordUnit(anId,theInfo->GetCoordUnit(anId)); + } + } + + TTNodeInfo(const PMeshInfo& theMeshInfo, + TInt theNbElem, + ERepere theSystem = eCART, + EBooleen theIsElemNum = eVRAI, + EBooleen theIsElemNames = eVRAI): + TElemInfoBase(theMeshInfo, + theNbElem, + theIsElemNum, + theIsElemNames) + { + mySystem = theSystem; + myCoord.resize(theNbElem*theMeshInfo->myDim); + myCoordNames.resize(theMeshInfo->myDim*nPNOM+1); + myCoordUnits.resize(theMeshInfo->myDim*nPNOM+1); + } + + + TTNodeInfo(const PMeshInfo& theMeshInfo, + ERepere theSystem, + const TFloatVector& theNodeCoords, + const TStringVector& theCoordNames, + const TStringVector& theCoordUnits, + const TIntVector& theFamilyNums, + const TIntVector& theElemNums, + const TStringVector& theElemNames = TStringVector()): + TElemInfoBase(theMeshInfo, + theFamilyNums, + theElemNums, + theElemNames) + { + mySystem = theSystem; + myCoord.resize(theNodeCoords.size()); + + for(TInt anId = 0, anEnd = myCoord.size(); anId < anEnd; anId++){ + myCoord[anId] = theNodeCoords[anId]; + } + + TInt aDim = theMeshInfo->GetDim(); + myCoordNames.resize(aDim*nPNOM+1); + 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]); + } + } + + virtual std::string GetCoordName(TInt theId) const { + return GetString(theId,nPNOM,myCoordNames); + } + + virtual void SetCoordName(TInt theId, const std::string& theValue){ + SetString(theId,nPNOM,myCoordNames,theValue); + } + + virtual std::string GetCoordUnit(TInt theId) const { + return GetString(theId,nPNOM,myCoordUnits); + } + + virtual void SetCoordUnit(TInt theId, const std::string& theValue){ + SetString(theId,nPNOM,myCoordUnits,theValue); + } + }; + + + //--------------------------------------------------------------- + template + struct TTCellInfo: TCellInfo, TTElemInfo + { + typedef TTElemInfo TElemInfoBase; + + TTCellInfo(const PMeshInfo& theMeshInfo, const PCellInfo& theInfo): + TElemInfoBase(theMeshInfo,theInfo) + { + myTEntity = theInfo->GetEntity(); + myTGeom = theInfo->GetGeom(); + myTConn = theInfo->GetConn(); + myConnDim = theInfo->GetConnDim(); + + myConn.resize(myNbElem*myConnDim); + for(TInt anElemId = 0; anElemId < myNbElem; anElemId++){ + for(TInt anConnId = 0; anConnId < myConnDim; anConnId++){ + SetConn(anElemId,anConnId,theInfo->GetConn(anElemId,anConnId)); + } + } + } + + TTCellInfo(const PMeshInfo& theMeshInfo, + TInt theNbElem, + EEntiteMaillage theTEntity, + EGeometrieElement theTGeom, + EConnectivite theTConn = eNOD, + EBooleen theIsElemNum = eVRAI, + EBooleen theIsElemNames = eVRAI): + TElemInfoBase(theMeshInfo, + theNbElem, + theIsElemNum, + theIsElemNames) + { + myTEntity = theTEntity; + myTGeom = theTGeom; + myTConn = theTConn; + myConnDim = GetNbConn(myTEntity,myTGeom,theMeshInfo->myDim); + myConn.resize(theNbElem*myConnDim); + } + + TTCellInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theTEntity, + EGeometrieElement theTGeom, + EConnectivite theTConn, + const TIntVector& theConnectivities, + const TIntVector& theFamilyNums, + const TIntVector& theElemNums, + const TStringVector& theElemNames = TStringVector()): + TTElemInfo(theMeshInfo, + theFamilyNums, + theElemNums, + theElemNames) + { + myTEntity = theTEntity; + myTGeom = theTGeom; + myTConn = theTConn; + myConnDim = GetNbConn(myTEntity,myTGeom,theMeshInfo->myDim); + myConn.resize(theConnectivities.size()); + for(TInt anId = 0, anEnd = myConn.size(); anId < anEnd; anId++){ + myConn[anId] = theConnectivities[anId]; + } + } + }; + + + //--------------------------------------------------------------- + template + struct TTFieldInfo: TFieldInfo, TTNameInfo + { + typedef TTNameInfo TNameInfoBase; + + TTFieldInfo(const PMeshInfo& theMeshInfo, const PFieldInfo& theInfo): + TNameInfoBase(theInfo->GetName()) + { + myMeshInfo = theMeshInfo; + + myNbComp = theInfo->GetNbComp(); + myCompNames.resize(myNbComp*nPNOM+1); + for(TInt anId = 0; anId < myNbComp; anId++){ + SetCompName(anId,theInfo->GetCompName(anId)); + } + + myUnitNames.resize(myNbComp*nPNOM+1); + for(TInt anId = 0; anId < myNbComp; anId++){ + SetUnitName(anId,theInfo->GetUnitName(anId)); + } + + myType = theInfo->GetType(); + + myIsLocal = theInfo->GetIsLocal(); + myNbRef = theInfo->GetNbRef(); + } + + TTFieldInfo(const PMeshInfo& theMeshInfo, + TInt theNbComp = 0, + ETypeChamp theType = eFLOAT64, + const std::string& theValue = "", + EBooleen theIsLocal = eVRAI, + TInt theNbRef = 1): + TNameInfoBase(theValue) + { + myMeshInfo = theMeshInfo; + + myNbComp = theNbComp; + myCompNames.resize(theNbComp*nPNOM+1); + myUnitNames.resize(theNbComp*nPNOM+1); + + myType = theType; + + myIsLocal = theIsLocal; + myNbRef = theNbRef; + } + + virtual std::string GetCompName(TInt theId) const { + return GetString(theId,nPNOM,myCompNames); + } + + virtual void SetCompName(TInt theId, const std::string& theValue){ + SetString(theId,nPNOM,myCompNames,theValue); + } + + virtual std::string GetUnitName(TInt theId) const { + return GetString(theId,nPNOM,myUnitNames); + } + + virtual void SetUnitName(TInt theId, const std::string& theValue){ + SetString(theId,nPNOM,myUnitNames,theValue); + } + }; + + + //--------------------------------------------------------------- + template + struct TTTimeStampInfo: TTimeStampInfo + { + TTTimeStampInfo(const PFieldInfo& theFieldInfo, const PTimeStampInfo& theInfo) + { + myFieldInfo = theFieldInfo; + + myEntity = theInfo->GetEntity(); + myGeom = theInfo->GetGeom(); + + myNbGauss = theInfo->GetNbGauss(); + myNumDt = theInfo->GetNumDt(); + myNumOrd = theInfo->GetNumOrd(); + myDt = theInfo->GetDt(); + + myUnitDt.resize(nPNOM+1); + SetUnitDt(theInfo->GetUnitDt()); + + myGaussName.resize(nNOM+1); + SetGaussName(theInfo->GetGaussName()); + } + + 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 = "") + { + myFieldInfo = theFieldInfo; + + myEntity = theEntity; + myGeom = theGeom; + + myNbGauss = theNbGauss; + myNumDt = theNumDt; + myNumOrd = theNumDt; + myDt = theDt; + + myUnitDt.resize(nPNOM+1); + SetUnitDt(theUnitDt); + + myGaussName.resize(nNOM+1); + SetGaussName(theGaussName); + } + + virtual std::string GetGaussName() const { + return GetString(0,nNOM,myGaussName); + } + + virtual void SetGaussName(const std::string& theValue){ + SetString(0,nNOM,myGaussName,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 TTTimeStampVal: TTimeStampVal + { + TTTimeStampVal(const PTimeStampInfo& theTimeStampInfo, const PTimeStampVal& theInfo) + { + myTimeStampInfo = theTimeStampInfo; + + myPflMode = theInfo->GetPflMode(); + + 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); + } + } + } + } + } + + TTTimeStampVal(const PTimeStampInfo& theTimeStampInfo, + const std::string& thePflName = "", + EModeProfil thePflMode = eCOMPACT) + { + myTimeStampInfo = theTimeStampInfo; + + myPflMode = thePflMode; + + myPflName.resize(nNOM+1); + SetPflName(thePflName); + + 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 EGeometrieElement& aGeom = anIter->first; + TInt aNb = anIter->second*aNbComp*aNbGauss; + myMeshValue[aGeom].resize(aNb); + } + } + + virtual std::string GetPflName() const { + return GetString(0,nNOM,myPflName); + } + + virtual void SetPflName(const std::string& theValue){ + SetString(0,nNOM,myPflName,theValue); + } + }; + +} + +#endif diff --git a/src/MEDWrapper/Base/MED_TWrapper.hxx b/src/MEDWrapper/Base/MED_TWrapper.hxx new file mode 100644 index 000000000..b5811b09e --- /dev/null +++ b/src/MEDWrapper/Base/MED_TWrapper.hxx @@ -0,0 +1,275 @@ +// +// +// 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_TWrapper_HeaderFile +#define MED_TWrapper_HeaderFile + +#include "MED_TStructures.hxx" +#include "MED_Wrapper.hxx" + +namespace MED{ + + template + class TTWrapper: public TWrapper{ + public: + //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + virtual PMeshInfo CrMeshInfo(TInt theDim = 0, + const std::string& theValue = "", + EMaillage theType = eNON_STRUCTURE, + const std::string& theDesc = "") + { + return PMeshInfo(new TTMeshInfo + (theDim, + theValue, + theType, + theDesc)); + } + + virtual PMeshInfo CrMeshInfo(const PMeshInfo& theInfo) + { + return PMeshInfo(new TTMeshInfo(theInfo)); + } + + + //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + virtual PFamilyInfo CrFamilyInfo(const PMeshInfo& theMeshInfo, + TInt theNbGroup = 0, + TInt theNbAttr = 0, + TInt theId = 0, + const std::string& theValue = "") + { + return PFamilyInfo(new TTFamilyInfo + (theMeshInfo, + theNbGroup, + theNbAttr, + theId, + theValue)); + } + + virtual PFamilyInfo CrFamilyInfo(const PMeshInfo& theMeshInfo, + const std::string& theValue, + TInt theId, + const MED::TStringSet& theGroupNames, + const MED::TStringVector& theAttrDescs = MED::TStringVector(), + const MED::TIntVector& theAttrIds = MED::TIntVector(), + const MED::TIntVector& theAttrVals = MED::TIntVector()) + { + return PFamilyInfo(new TTFamilyInfo + (theMeshInfo, + theValue, + theId, + theGroupNames, + theAttrDescs, + theAttrIds, + theAttrVals)); + } + + virtual PFamilyInfo CrFamilyInfo(const PMeshInfo& theMeshInfo, + const PFamilyInfo& theInfo) + { + return PFamilyInfo(new TTFamilyInfo + (theMeshInfo, + theInfo)); + } + + + //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + virtual PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo, + TInt theNbElem, + ERepere theSystem = eCART, + EBooleen theIsElemNum = eVRAI, + EBooleen theIsElemNames = eVRAI) + { + return PNodeInfo(new TTNodeInfo + (theMeshInfo, + theNbElem, + theSystem, + theIsElemNum, + theIsElemNames)); + } + + virtual PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo, + ERepere theSystem, + const TFloatVector& theNodeCoords, + const TStringVector& theCoordNames, + const TStringVector& theCoordUnits, + const TIntVector& theFamilyNums, + const TIntVector& theElemNums, + const TStringVector& theElemNames = TStringVector()) + { + return PNodeInfo(new TTNodeInfo + (theMeshInfo, + theSystem, + theNodeCoords, + theCoordNames, + theCoordUnits, + theFamilyNums, + theElemNums, + theElemNames)); + } + + virtual PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo, + const PNodeInfo& theInfo) + { + return PNodeInfo(new TTNodeInfo + (theMeshInfo, + theInfo)); + } + + + //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + virtual PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo, + TInt theNbElem, + EEntiteMaillage theTEntity, + EGeometrieElement theTGeom, + EConnectivite theTConn = eNOD, + EBooleen theIsElemNum = eVRAI, + EBooleen theIsElemNames = eVRAI) + { + return PCellInfo(new TTCellInfo + (theMeshInfo, + theNbElem, + theTEntity, + theTGeom, + theTConn, + theIsElemNum, + theIsElemNames)); + } + + virtual PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo, + EEntiteMaillage theTEntity, + EGeometrieElement theTGeom, + EConnectivite theTConn, + const TIntVector& theConnectivities, + const TIntVector& theFamilyNums, + const TIntVector& theElemNums, + const TStringVector& theElemNames = TStringVector()) + { + return PCellInfo(new TTCellInfo + (theMeshInfo, + theTEntity, + theTGeom, + theTConn, + theConnectivities, + theFamilyNums, + theElemNums, + theElemNames)); + } + + virtual PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo, + const PCellInfo& theInfo) + { + return PCellInfo(new TTCellInfo + (theMeshInfo, + theInfo)); + } + + + //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + virtual PFieldInfo CrFieldInfo(const PMeshInfo& theMeshInfo, + TInt theNbComp = 0, + ETypeChamp theType = eFLOAT64, + const std::string& theValue = "", + EBooleen theIsLocal = eVRAI, + TInt theNbRef = 1) + { + return PFieldInfo(new TTFieldInfo + (theMeshInfo, + theNbComp, + theType, + theValue, + theIsLocal, + theNbRef)); + } + + virtual PFieldInfo CrFieldInfo(const PMeshInfo& theMeshInfo, + const PFieldInfo& theInfo) + { + return PFieldInfo(new TTFieldInfo + (theMeshInfo, + theInfo)); + } + + + //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + virtual PTimeStampInfo CrTimeStampInfo(const PFieldInfo& theFieldInfo, + EEntiteMaillage theEntity, + const TGeom& theGeom, + TInt theNbGauss = 0, + TInt theNumDt = 0, + TInt theNumOrd = 0, + TFloat theDt = 0, + const std::string& theUnitDt = "", + const std::string& theGaussName = "") + { + return PTimeStampInfo(new TTTimeStampInfo + (theFieldInfo, + theEntity, + theGeom, + theNbGauss, + theNumDt, + theNumOrd, + theDt, + theUnitDt, + theGaussName)); + } + + virtual PTimeStampInfo CrTimeStampInfo(const PFieldInfo& theFieldInfo, + const PTimeStampInfo& theInfo) + { + return PTimeStampInfo(new TTTimeStampInfo + (theFieldInfo, + theInfo)); + } + + + //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + virtual PTimeStampVal CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo, + const std::string& thePflName = "", + EModeProfil thePflMode = eCOMPACT) + { + return PTimeStampVal(new TTTimeStampVal + (theTimeStampInfo, + thePflName, + thePflMode)); + } + + virtual PTimeStampVal CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo, + const PTimeStampVal& theInfo) + { + return PTimeStampVal(new TTTimeStampVal + (theTimeStampInfo, + theInfo)); + } + + }; + +} + + +#endif diff --git a/src/MEDWrapper/Base/MED_Utilities.cxx b/src/MEDWrapper/Base/MED_Utilities.cxx new file mode 100644 index 000000000..1454a96f3 --- /dev/null +++ b/src/MEDWrapper/Base/MED_Utilities.cxx @@ -0,0 +1,104 @@ +// +// +// 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_Utilities.hxx" +#include "MED_Common.hxx" + +using namespace std; + +#ifdef _DEBUG_ +static int MYDEBUG = 0; +#else +static int MYDEBUG = 0; +#endif + + +int MED::PrefixPrinter::myCounter = 0; + +MED::PrefixPrinter::PrefixPrinter(bool theIsActive): + myIsActive(theIsActive) +{ + if(myIsActive) + myCounter++; + MSG(MYDEBUG,"MED::PrefixPrinter::PrefixPrinter(...)- "< +#include +#include +#include + + +namespace MED{ + using namespace std; + class PrefixPrinter{ + static int myCounter; + bool myIsActive; + public: + PrefixPrinter(bool theIsActive = true); + ~PrefixPrinter(); + + static string GetPrefix(); + }; +}; + + +#ifdef _DEBUG_ + #define MSG(deb,msg) if(deb) std::cout< + +extern "C"{ +#include +} + +#ifdef _DEBUG_ +static int MYDEBUG = 0; +#else +static int MYDEBUG = 0; +#endif + +namespace MED{ + + EVersion GetVersionId(const std::string& theFileName) + { + EVersion aVersion = eVUnknown; + char* aFileName = const_cast(theFileName.c_str()); + med_idt aFid = MEDouvrir(aFileName,MED_LECTURE); + MSG(MYDEBUG,"GetVersionId - theFileName = '"<GetNbMeshes(); + INITMSG(MYDEBUG,"GetNbMeshes() = "<GetPMeshInfo(iMesh); + INITMSG(MYDEBUG,"aMeshInfo->GetName() = "<GetName()<GetPNodeInfo(aMeshInfo); + + TEntityInfo aEntityInfo = aMed->GetEntityInfo(aMeshInfo); + + TCellGroup aCellGroup = GetCellsByEntity(aMed,aMeshInfo,aEntityInfo); + + TFamilyGroup aFamilyGroup = GetFamilies(aMed,aMeshInfo); + + TFamilyByEntity aFamilyByEntity = GetFamiliesByEntity(aMed,aNodeInfo,aCellGroup,aFamilyGroup); + + TGroupInfo aGroupInfo = GetFamiliesByGroup(aFamilyGroup); + + TTimeStampGroup aTimeStampGroup = GetFieldsByEntity(aMed,aMeshInfo,aEntityInfo); + + TFieldGroup aFieldGroup = GetFieldsByEntity(aTimeStampGroup); + } + } + MSG(MYDEBUG,"OK"); +} + + +void CopyMed(const PWrapper& theMed, + const PWrapper& theMed2, + int theIncr) +{ + TInt aNbMeshes = theMed->GetNbMeshes(); + MSG(MYDEBUG,"aNbMeshes = "<GetPMeshInfo(iMesh+1); + TInt aDim = aMeshInfo->myDim; + aName = aMeshInfo->GetName(); + INITMSG(MYDEBUG,"GetMeshInfo - aName = '"<CrMeshInfo(aMeshInfo); + if(MYWRITEDEBUG){ + aName = aMeshInfo2->GetName(); + + aName[0] += theIncr; + aMeshInfo2->SetName(aName); + theMed2->SetMeshInfo(aMeshInfo2); + BEGMSG(MYDEBUG,"aNbMeshes2 = "<GetNbMeshes()<<"\n"); + } + + TEntityInfo aEntityInfo = theMed->GetEntityInfo(aMeshInfo); + + //continue; + + TInt aNbFields = theMed->GetNbFields(); + MSG(MYDEBUG,"GetNbFields() = "<GetPFieldInfo(aMeshInfo,iField+1); + TInt aNbComp = aFieldInfo->GetNbComp(); + INITMSG(MYDEBUG,"aName = '"<GetName()<<"'; aNbComp = "<CrFieldInfo(aMeshInfo2,aFieldInfo); + + if(MYWRITEDEBUG){ + aName = aFieldInfo->GetName(); + aName[0] += theIncr; + aFieldInfo2->SetName(aName); + theMed2->SetFieldInfo(aFieldInfo2); + } + + EEntiteMaillage anEntity; + TGeom aTGeom; + TInt aNbTimeStamps = + theMed->GetNbTimeStamps(aFieldInfo,aEntityInfo,anEntity,aTGeom); + { + INITMSG(MYDEBUG,"GetNbTimeStamps = "<GetPTimeStampInfo(aFieldInfo,anEntity,aTGeom,iTimeStamp+1); + TInt aNumDt = aTimeStampInfo->GetNumDt(); + TInt aNbGauss = aTimeStampInfo->GetNbGauss(); + INITMSG(MYDEBUG,"aNbGauss = "<CrTimeStampInfo(aFieldInfo2,aTimeStampInfo); + + PTimeStampVal aTimeStampVal = theMed->GetPTimeStampVal(aTimeStampInfo); + + 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 = "<GetNbFamilies(aMeshInfo); + MSG(MYDEBUG,"GetNbFamilies() = "<GetPFamilyInfo(aMeshInfo,iFam+1); + TInt aNbGroup = aFamilyInfo->GetNbGroup(); + TInt aNbAttr = aFamilyInfo->GetNbAttr(); + TInt anId = aFamilyInfo->GetId(); + aName = aFamilyInfo->GetName(); + INITMSG(MYDEBUG,"aName = '"<CrFamilyInfo(aMeshInfo2,aFamilyInfo); + for(TInt iGroup = 0; iGroup < aNbGroup; iGroup++){ + aName = aFamilyInfo->GetGroupName(iGroup); + INITMSG(MYDEBUG,"aGroupName = '"<SetGroupName(iGroup,aName); + } + + if(MYWRITEDEBUG){ + aName = aFamilyInfo->GetName(); + aName[0] += theIncr; + aFamilyInfo2->SetName(aName); + theMed2->SetFamilyInfo(aFamilyInfo2); + INITMSG(MYDEBUG,"GetNbFamilies = "<GetNbFamilies(aMeshInfo2)<GetPNodeInfo(aMeshInfo); + TInt aNbNodes = aNodeInfo->GetNbElem(); + INITMSG(MYDEBUG,"GetNodeInfo - aNbNodes = "<myCoord; + for(TInt iNode = 0; iNode < aNbNodes; iNode++){ + for(TInt iDim = 0, anId = iNode*aDim; iDim < aDim; iDim++, anId++){ + ADDMSG(MYVALUEDEBUG,aCoord[anId]<<","); + aCoord[anId] += theIncr; + } + ADDMSG(MYVALUEDEBUG," "); + } + ADDMSG(MYDEBUG,endl); + PNodeInfo aNodeInfo2 = theMed->CrNodeInfo(aMeshInfo2,aNodeInfo); + if(MYWRITEDEBUG) theMed2->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; + INITMSG(MYDEBUG,"aGeom = "<GetPCellInfo(aMeshInfo,anEntity,aGeom); + TInt aConnDim = aCellInfo->GetConnDim(); + for(TInt iElem = 0; iElem < aNbElem; iElem++){ + for(TInt iConn = 0; iConn < aConnDim; iConn++){ + ADDMSG(MYVALUEDEBUG,aCellInfo->GetConn(iElem,iConn)<<","); + } + ADDMSG(MYVALUEDEBUG," "); + } + ADDMSG(MYDEBUG,endl); + PCellInfo aCellInfo2 = theMed->CrCellInfo(aMeshInfo2,aCellInfo); + if(MYWRITEDEBUG) theMed2->SetCellInfo(aCellInfo2); + } + } + + } + MSG(MYDEBUG,"OK"); +} + + +void CopyMed(const std::string& theFileName, + const std::string& theFileName2, + MED::EVersion theVersion, + int theNbCopy) +{ + MSG(MYDEBUG,"CopyMed - theFileName = '"<first; - if(anEntity == MED_NOEUD) continue; - const MED::TGeom& aGeom = anIter->second; - TCellSet& aCellSet = aGroup[anEntity]; - MED::TGeom::const_iterator anGeomIter = aGeom.begin(); - for(; anGeomIter != aGeom.end(); anGeomIter++){ - const med_geometrie_element& aGeo = anGeomIter->first; - PCellInfo aCellInfo = theWrapper.GetCellInfo(theMeshInfo,anEntity,aGeo); - aCellSet.insert(aCellInfo); - if(MYDEBUG){ - med_int aNbElem = aCellInfo->GetNbElem(); - MED::PrefixPrinter aPrefixPrinter; - BEGMSG("aGeo = "<GetConnDim(); - for(int iConn = 0; iConn < iConnEnd; iConn++){ - ADDMSG(aCellInfo->GetConn(iElem,iConn)<<","); - } - ADDMSG(" "); - } - ADDMSG("\n"); - } - } - } - if(MYDEBUG) ADDMSG("\n"); - return aGroup; -} - - -//--------------------------------------------------------------- -TFamilyGroup -MEDA::GetFamilies(TWrapper& theWrapper, - const PMeshInfo& theMeshInfo) -{ - if(MYDEBUG) MESSAGE("GetFamilies(...)"); - TFamilyGroup aGroup; - int aNbFam = theWrapper.GetNbFamilies(theMeshInfo); - MED::PrefixPrinter aPrefixPrinter; - if(MYDEBUG) BEGMSG("GetNbFamilies() = "<GetName(); - med_int aNbAttr = aFamilyInfo->GetNbAttr(); - med_int aNbGroup = aFamilyInfo->GetNbGroup(); - BEGMSG("aFamilyName = '"<GetGroupName(iGroup); - MED::PrefixPrinter aPrefixPrinter; - BEGMSG("aGroupName = '"<GetNbGroup(); - for(int iGroup = 0; iGroup < aNbGroup; iGroup++){ - aGroup[aFamilyInfo->GetGroupName(iGroup)].insert(aFamilyInfo); - } - } - if(MYDEBUG){ - TGroupInfo::const_iterator anIter = aGroup.begin(); - for(; anIter != aGroup.end(); anIter++){ - string aName = anIter->first; - MED::PrefixPrinter aPrefixPrinter; - BEGMSG("aGroupName = '"<second; - TFamilyGroup::const_iterator anFamIter = aFamilyGroup.begin(); - for(; anFamIter != aFamilyGroup.end(); anFamIter++){ - const PFamilyInfo& aFamilyInfo = *anFamIter; - MED::PrefixPrinter aPrefixPrinter; - BEGMSG("aFamilyName = '"<GetName()<<"'\n"); - } - } - ADDMSG("\n"); - } - return aGroup; -} - - -//--------------------------------------------------------------- -TTimeStampGroup -MEDA::GetFieldsByEntity(TWrapper& theWrapper, - const PMeshInfo& theMeshInfo, - const MED::TEntityInfo theEntityInfo) -{ - if(MYDEBUG) MESSAGE("GetFieldsByEntity(...)"); - TTimeStampGroup aGroup; - med_int aNbFields = theWrapper.GetNbFields(); - MED::PrefixPrinter aPrefixPrinter; - if(MYDEBUG) BEGMSG("GetNbFields() = "<GetNbComp(); - string aName = aFieldInfo->GetName(); - MED::PrefixPrinter aPrefixPrinter; - if(MYDEBUG) BEGMSG("aFieldName = '"<GetNbGauss(); - MED::PrefixPrinter aPrefixPrinter; - if(MYDEBUG) BEGMSG("aDt = "<GetDt()<<", "<GetUnitDt()<<"\n"); - } - } - if(MYDEBUG) ADDMSG("\n"); - return aGroup; -} - - -TFieldGroup -MEDA::GetFieldsByEntity(const TTimeStampGroup& theTimeStampGroup) -{ - TFieldGroup aGroup; - TTimeStampGroup::const_iterator anIter = theTimeStampGroup.begin(); - for(; anIter != theTimeStampGroup.end(); anIter++){ - const PFieldInfo& aFieldInfo = anIter->first; - const TTimeStampSet& aTimeStampSet = anIter->second; - if(aTimeStampSet.empty()) continue; - const PTimeStampInfo& aTimeStampInfo = *aTimeStampSet.begin(); - aGroup[aTimeStampInfo->GetEntity()].insert(*anIter); - } - return aGroup; -} - - -TFamilyByEntity -MEDA::GetFamiliesByEntity(TWrapper& theWrapper, - const PNodeInfo& theNodeInfo, - const TCellGroup& theCellGroup, - const TFamilyGroup& theFamilyGroup) -{ - if(MYDEBUG) MESSAGE("GetFamiliesByEntity(...)"); - TFamilyByEntity aFamilyByEntity; - - typedef map TFamilyByIdMap; - TFamilyByIdMap aFamilyByIdMap; - TFamilyGroup::const_iterator anIter = theFamilyGroup.begin(); - for(; anIter != theFamilyGroup.end(); anIter++){ - const PFamilyInfo& aFamilyInfo = *anIter; - aFamilyByIdMap.insert(TFamilyByIdMap::value_type(aFamilyInfo->GetId(),aFamilyInfo)); - } - - if(!aFamilyByIdMap.empty()){ - typedef set TFamilyIdSet; - typedef map TFamilyIdByEntity; - TFamilyIdByEntity aFamilyIdByEntity; - - if(theNodeInfo!=0){ - if(med_int aNbElem = theNodeInfo->GetNbElem()){ - TFamilyIdSet& aFamilyIdSet = aFamilyIdByEntity[MED_NOEUD]; - for(med_int i = 0; i < aNbElem; i++){ - aFamilyIdSet.insert(theNodeInfo->GetFamNum(i)); - } - } - } - - if(!theCellGroup.empty()){ - TCellGroup::const_iterator anIter = theCellGroup.begin(); - for(; anIter != theCellGroup.end(); anIter++){ - const med_entite_maillage& anEntity = anIter->first; - TFamilyIdSet& aFamilyIdSet = aFamilyIdByEntity[anEntity]; - const TCellSet& aCellSet = anIter->second; - TCellSet::const_iterator anCellIter = aCellSet.begin(); - for(; anCellIter != aCellSet.end(); anCellIter++){ - const PCellInfo& aCellInfo = *anCellIter; - if(med_int aNbElem = aCellInfo->GetNbElem()){ - for(med_int i = 0; i < aNbElem; i++){ - aFamilyIdSet.insert(aCellInfo->GetFamNum(i)); - } - } - } - } - } - - if(!aFamilyIdByEntity.empty()){ - TFamilyIdByEntity::const_iterator anIter = aFamilyIdByEntity.begin(); - for(; anIter != aFamilyIdByEntity.end(); anIter++){ - const med_entite_maillage& anEntity = anIter->first; - MED::PrefixPrinter aPrefixPrinter; - if(MYDEBUG) BEGMSG("anEntity = "<second; - TFamilyIdSet::const_iterator anFamilyIdIter = aFamilyIdSet.begin(); - for(; anFamilyIdIter != aFamilyIdSet.end(); anFamilyIdIter++){ - const med_int& aFamilyId = *anFamilyIdIter; - TFamilyByIdMap::const_iterator - anFamilyByIdMapIter = aFamilyByIdMap.find(aFamilyId); - if(anFamilyByIdMapIter != aFamilyByIdMap.end()){ - const PFamilyInfo& aFamilyInfo = anFamilyByIdMapIter->second; - aFamilyByEntity[anEntity].insert(aFamilyInfo); - MED::PrefixPrinter aPrefixPrinter; - if(MYDEBUG) - BEGMSG("aFamilyName = '"<GetName()<< - "' anId = "<GetId()<<"\n"); - } - } - } - } - } - if(MYDEBUG) ADDMSG("\n"); - return aFamilyByEntity; -} - diff --git a/src/MEDWrapper/MEDA_Algorithm.hxx b/src/MEDWrapper/MEDA_Algorithm.hxx deleted file mode 100644 index 326da0d5d..000000000 --- a/src/MEDWrapper/MEDA_Algorithm.hxx +++ /dev/null @@ -1,69 +0,0 @@ -// Copyright (C) 2003 CEA/DEN, EDF R&D -// -// -// -// File : VISU_DatConvertor.hxx -// Author : Alexey PETROV -// Module : VISU - -#ifndef MEDA_Algorithm_HeaderFile -#define MEDA_Algorithm_HeaderFile - -#include "MEDA_Structures.hxx" -#include "MEDA_Wrapper.hxx" - -#include - -namespace MEDA{ - using namespace std; - using namespace boost; - - - //--------------------------------------------------------------- - typedef set TCellSet; - typedef map TCellGroup; - - TCellGroup GetCellsByEntity(TWrapper& theWrapper, - const PMeshInfo& theMeshInfo, - const MED::TEntityInfo theEntityInfo); - - - //--------------------------------------------------------------- - typedef set TFamilyGroup; - - TFamilyGroup GetFamilies(TWrapper& theWrapper, - const PMeshInfo& theMeshInfo); - - - //--------------------------------------------------------------- - typedef map TFamilyByEntity; - - TFamilyByEntity GetFamiliesByEntity(TWrapper& theWrapper, - const PNodeInfo& theNodeInfo, - const TCellGroup& theCellGroup, - const TFamilyGroup& theFamilyGroup); - - - //--------------------------------------------------------------- - typedef map TGroupInfo; - - TGroupInfo GetFamiliesByGroup(const TFamilyGroup& theGroupInfo); - - - //--------------------------------------------------------------- - typedef set TTimeStampSet; - typedef map TTimeStampGroup; - - TTimeStampGroup GetFieldsByEntity(TWrapper& theWrapper, - const PMeshInfo& theMeshInfo, - const MED::TEntityInfo theEntityInfo); - - - //--------------------------------------------------------------- - typedef map TFieldGroup; - - TFieldGroup GetFieldsByEntity(const TTimeStampGroup& theTimeStampGroup); - -}; - -#endif diff --git a/src/MEDWrapper/MEDA_Structures.cxx b/src/MEDWrapper/MEDA_Structures.cxx deleted file mode 100644 index eb10c07b5..000000000 --- a/src/MEDWrapper/MEDA_Structures.cxx +++ /dev/null @@ -1,333 +0,0 @@ -// Copyright (C) 2003 CEA/DEN, EDF R&D -// -// -// -// File : VISU_DatConvertor.cxx -// Author : Alexey PETROV -// Module : VISU - -#include "MEDA_Structures.hxx" -#include "MED_Structures.hxx" -#include "MED_Utilities.hxx" - -using namespace std; -using namespace MEDA; - -#ifdef _DEBUG_ -static int MYDEBUG = 1; -#else -static int MYDEBUG = 0; -#endif - - -//--------------------------------------------------------------- -TNameInfo::TNameInfo(const MED::PNameInfo& theInfo): - myInfo(theInfo) -{} - -string TNameInfo::GetName() const{ - return myInfo->GetName(); -} - -void TNameInfo::SetName(const string& theValue){ - myInfo->SetName(theValue); -} - - -//--------------------------------------------------------------- -TMeshInfo::TMeshInfo(const MED::PMeshInfo& theInfo): - TNameInfo(theInfo), - myInfo(theInfo) -{} - -med_int TMeshInfo::GetDim() const{ - return myInfo->myDim; -} - - -//--------------------------------------------------------------- -TFamilyInfo::TFamilyInfo(const MED::PFamilyInfo& theInfo): - TNameInfo(theInfo), - myInfo(theInfo) -{} - -med_int TFamilyInfo::GetId() const{ - return myInfo->myId; -} - -void TFamilyInfo::SetId(med_int theId){ - myInfo->myId = theId; -} - -med_int TFamilyInfo::GetNbGroup() const{ - return myInfo->myNbGroup; -} - -string TFamilyInfo::GetGroupName(med_int theId) const{ - return myInfo->GetGroupName(theId); -} - -void TFamilyInfo::SetGroupName(med_int theId, const string& theValue){ - myInfo->SetGroupName(theId,theValue); -} - -med_int TFamilyInfo::GetNbAttr() const{ - return myInfo->myNbAttr; -} - -string TFamilyInfo::GetAttrDesc(med_int theId) const{ - return myInfo->GetAttrDesc(theId); -} - -void TFamilyInfo::SetAttrDesc(med_int theId, const string& theValue){ - myInfo->SetAttrDesc(theId,theValue); -} - -med_int TFamilyInfo::GetAttrId(med_int theId) const{ - return myInfo->myAttrId[theId]; -} - -void TFamilyInfo::SetAttrId(med_int theId, med_int theVal){ - myInfo->myAttrId[theId] = theVal; -} - -med_int TFamilyInfo::GetAttrVal(med_int theId) const{ - return myInfo->myAttrVal[theId]; -} - -void TFamilyInfo::SetAttrVal(med_int theId, med_int theVal){ - myInfo->myAttrVal[theId] = theVal; -} - - -//--------------------------------------------------------------- -TElemInfo::TElemInfo(const MED::PElemInfo& theInfo): - myInfo(theInfo) -{} - -med_int TElemInfo::GetNbElem() const{ - return myInfo->myNbElem; -} - -med_int TElemInfo::GetFamNum(med_int theId) const{ - return myInfo->myFamNum[theId]; -} - -void TElemInfo::SetFamNum(med_int theId, med_int theValue){ - myInfo->myFamNum[theId] = theValue; -} - -med_booleen TElemInfo::IsElemNum() const{ - return myInfo->myIsElemNum; -} - -med_int TElemInfo::GetElemNum(med_int theId) const{ - if(theId < 0 || myInfo->myElemNum.size() < theId) - EXCEPTION(runtime_error,"TElemInfo::GetElemNum - myInfo->myElemNum.size() = "<< - myInfo->myElemNum.size()<<"; theId = "<myElemNum[theId]; -} - -void TElemInfo::SetElemNum(med_int theId, med_int theValue){ - if(theId < 0 || myInfo->myElemNum.size() < theId) - EXCEPTION(runtime_error,"TElemInfo::SetElemNum - myInfo->myElemNum.size() = "<< - myInfo->myElemNum.size()<<"; theId = "<myElemNum[theId] = theValue; -} - -med_booleen TElemInfo::IsElemNames() const{ - return myInfo->myIsElemNames; -} - -string TElemInfo::GetElemName(med_int theId) const{ - return myInfo->GetElemName(theId); -} - -void TElemInfo::SetElemName(med_int theId, const string& theValue){ - myInfo->SetElemName(theId,theValue); -} - - -//--------------------------------------------------------------- -TNodeInfo::TNodeInfo(const MED::PNodeInfo& theInfo): - TElemInfo(theInfo), - myInfo(theInfo) -{} - -med_repere TNodeInfo::GetSystem() const{ - return myInfo->mySystem; -} - -void TNodeInfo::GetSystem(med_repere theSystem){ - myInfo->mySystem = theSystem; -} - -med_float TNodeInfo::GetNodeCoord(med_int theId, med_int theComp) const{ - return myInfo->myCoord[myInfo->myMeshInfo->myDim*theId + theComp]; -} - -void TNodeInfo::SetNodeCoord(med_int theId, med_int theComp, med_float theVal){ - myInfo->myCoord[myInfo->myMeshInfo->myDim*theId + theComp] = theVal; -} - -string TNodeInfo::GetCoordName(med_int theId) const{ - return myInfo->GetCoordName(theId); -} - -void TNodeInfo::SetCoordName(med_int theId, const string& theValue){ - myInfo->SetCoordName(theId,theValue); -} - -string TNodeInfo::GetCoordUnit(med_int theId) const{ - return myInfo->GetCoordUnit(theId); -} - -void TNodeInfo::SetCoordUnit(med_int theId, const string& theValue){ - myInfo->SetCoordUnit(theId,theValue); -} - - -//--------------------------------------------------------------- -TCellInfo::TCellInfo(const MED::PCellInfo& theInfo): - TElemInfo(theInfo), - myInfo(theInfo) -{} - -med_entite_maillage TCellInfo::GetEntity() const{ - return myInfo->myTEntity; -} - -med_geometrie_element TCellInfo::GetGeom() const{ - return myInfo->myTGeom; -} - -med_connectivite TCellInfo::GetConn() const{ - return myInfo->myTConn; -} - -med_int TCellInfo::GetConnDim() const{ - return myInfo->myConnDim; -} - -med_int TCellInfo::GetConn(med_int theElemId, med_int theConnId) const{ - med_int anId = myInfo->myConnDim*theElemId + theConnId; - if(anId < 0 || myInfo->myConn.size() < anId) - EXCEPTION(runtime_error,"TElemInfo::GetConn - myInfo->myConn.size() = "<< - myInfo->myConn.size()<<"; anId = "<myConn[anId]; -} - -void TCellInfo::SetConn(med_int theElemId, med_int theConnId, med_int theVal){ - med_int anId = myInfo->myConnDim*theElemId + theConnId; - if(anId < 0 || myInfo->myConn.size() < anId) - EXCEPTION(runtime_error,"TElemInfo::SetConn - myInfo->myConn.size() = "<< - myInfo->myConn.size()<<"; anId = "<myConn[myInfo->myConnDim*theElemId + theConnId] = theVal; -} - - -//--------------------------------------------------------------- -TFieldInfo::TFieldInfo(const MED::PFieldInfo& theInfo): - TNameInfo(theInfo), - myInfo(theInfo) -{} - -med_type_champ TFieldInfo::GetType() const{ - return myInfo->myType; -} - -med_int TFieldInfo::GetNbComp() const{ - return myInfo->myNbComp; -} - -string TFieldInfo::GetCompName(med_int theId) const{ - return myInfo->GetCompName(theId); -} - -void TFieldInfo::SetCompName(med_int theId, const string& theValue){ - myInfo->SetCompName(theId,theValue); -} - -string TFieldInfo::GetUnitName(med_int theId) const{ - return myInfo->GetUnitName(theId); -} - -void TFieldInfo::SetUnitName(med_int theId, const string& theValue){ - myInfo->SetUnitName(theId,theValue); -} - - -//--------------------------------------------------------------- -TTimeStampInfo::TTimeStampInfo(const MED::PTimeStampInfo& theInfo): - myInfo(theInfo) -{} - -med_entite_maillage TTimeStampInfo::GetEntity() const{ - return myInfo->myEntity; -} - -const MED::TGeom& TTimeStampInfo::GetGeom() const{ - return myInfo->myGeom; -} - -med_int TTimeStampInfo::GetNbGauss() const{ - return myInfo->myNbGauss; -} - -med_int TTimeStampInfo::GetNumDt() const{ - return myInfo->myNumDt; -} - -med_int TTimeStampInfo::GetNumOrd() const{ - return myInfo->myNumOrd; -} - -med_float TTimeStampInfo::GetDt() const{ - return myInfo->myDt; -} - -string TTimeStampInfo::GetUnitDt() const{ - return myInfo->GetUnitDt(); -} - -void TTimeStampInfo::SetUnitDt(const string& theValue){ - myInfo->SetUnitDt(theValue); -} - - -//--------------------------------------------------------------- -TTimeStampVal::TTimeStampVal(const MED::PTimeStampVal& theInfo): - myInfo(theInfo) -{} - -med_float TTimeStampVal::GetVal(med_geometrie_element theGeom, - med_int theId, - med_int theComp, - med_int theGauss) const -{ - med_int aNbComp = myInfo->myTimeStampInfo->myFieldInfo->myNbComp; - med_int aNbGauss = myInfo->myTimeStampInfo->myNbGauss; - med_int aStep = aNbComp*aNbGauss; - return myInfo->myMeshValue[theGeom][theId*aStep + theComp*aNbGauss + theGauss]; -} - -void TTimeStampVal::SetVal(med_geometrie_element theGeom, - med_int theId, - med_int theComp, - med_float theVal, - med_int theGauss) -{ - med_int aNbComp = myInfo->myTimeStampInfo->myFieldInfo->myNbComp; - med_int aNbGauss = myInfo->myTimeStampInfo->myNbGauss; - med_int aStep = aNbComp*aNbGauss; - myInfo->myMeshValue[theGeom][theId*aStep + theComp*aNbGauss + theGauss] = theVal; -} - -string TTimeStampVal::GetPflName() const{ - return myInfo->GetPflName(); -} - -void TTimeStampVal::SetPflName(const string& theValue){ - myInfo->SetPflName(theValue); -} - diff --git a/src/MEDWrapper/MEDA_Structures.hxx b/src/MEDWrapper/MEDA_Structures.hxx deleted file mode 100644 index 674600a00..000000000 --- a/src/MEDWrapper/MEDA_Structures.hxx +++ /dev/null @@ -1,205 +0,0 @@ -// Copyright (C) 2003 CEA/DEN, EDF R&D -// -// -// -// File : VISU_DatConvertor.hxx -// Author : Alexey PETROV -// Module : VISU - -#ifndef MEDA_Structures_HeaderFile -#define MEDA_Structures_HeaderFile - -#include "MED_Common.hxx" - -namespace MEDA{ - using namespace std; - using namespace boost; - -//--------------------------------------------------------------- - class TNameInfo{ - friend class TWrapper; - TNameInfo(); - protected: - MED::PNameInfo myInfo; - TNameInfo(const MED::PNameInfo& theInfo); - public: - virtual ~TNameInfo() {} - - string GetName() const; - void SetName(const string& theValue); - }; - - -//--------------------------------------------------------------- - class TMeshInfo: public TNameInfo{ - friend class TWrapper; - TMeshInfo(); - protected: - MED::PMeshInfo myInfo; - TMeshInfo(const MED::PMeshInfo& theInfo); - - public: - med_int GetDim() const; - }; - typedef shared_ptr PMeshInfo; - - -//--------------------------------------------------------------- - class TFamilyInfo: public TNameInfo{ - friend class TWrapper; - TFamilyInfo(); - protected: - MED::PFamilyInfo myInfo; - TFamilyInfo(const MED::PFamilyInfo& theInfo); - public: - med_int GetId() const; - void SetId(med_int theId); - - med_int GetNbGroup() const; - string GetGroupName(med_int theId) const; - void SetGroupName(med_int theId, const string& theValue); - - med_int GetNbAttr() const; - string GetAttrDesc(med_int theId) const; - void SetAttrDesc(med_int theId, const string& theValue); - - med_int GetAttrId(med_int theId) const; - void SetAttrId(med_int theId, med_int theVal); - - med_int GetAttrVal(med_int theId) const; - void SetAttrVal(med_int theId, med_int theVal); - }; - typedef shared_ptr PFamilyInfo; - - -//--------------------------------------------------------------- - class TElemInfo{ - friend class TWrapper; - TElemInfo(); - protected: - MED::PElemInfo myInfo; - TElemInfo(const MED::PElemInfo& theInfo); - public: - virtual ~TElemInfo() {} - - med_int GetNbElem() const; - - med_int GetFamNum(med_int theId) const; - void SetFamNum(med_int theId, med_int theValue); - - med_booleen IsElemNum() const; - med_int GetElemNum(med_int theId) const; - void SetElemNum(med_int theId, med_int theValue); - - med_booleen IsElemNames() const; - string GetElemName(med_int theId) const; - void SetElemName(med_int theId, const string& theValue); - }; - - -//--------------------------------------------------------------- - class TNodeInfo: public TElemInfo{ - friend class TWrapper; - TNodeInfo(); - protected: - MED::PNodeInfo myInfo; - TNodeInfo(const MED::PNodeInfo& theInfo); - public: - med_repere GetSystem() const; - void GetSystem(med_repere theSystem); - - med_float GetNodeCoord(med_int theId, med_int theComp) const; - void SetNodeCoord(med_int theId, med_int theComp, med_float theVal); - - string GetCoordName(med_int theId) const; - void SetCoordName(med_int theId, const string& theValue); - - string GetCoordUnit(med_int theId) const; - void SetCoordUnit(med_int theId, const string& theValue); - }; - typedef shared_ptr PNodeInfo; - - -//--------------------------------------------------------------- - class TCellInfo: public TElemInfo{ - friend class TWrapper; - TCellInfo(); - protected: - MED::PCellInfo myInfo; - TCellInfo(const MED::PCellInfo& theInfo); - public: - med_entite_maillage GetEntity() const; - med_geometrie_element GetGeom() const; - med_connectivite GetConn() const; - - med_int GetConnDim() const; - med_int GetConn(med_int theElemId, med_int theConnId) const; - void SetConn(med_int theElemId, med_int theConnId, med_int theVal); - }; - typedef shared_ptr PCellInfo; - - -//--------------------------------------------------------------- - class TFieldInfo: public TNameInfo{ - friend class TWrapper; - TFieldInfo(); - protected: - MED::PFieldInfo myInfo; - TFieldInfo(const MED::PFieldInfo& theInfo); - public: - med_type_champ GetType() const; - med_int GetNbComp() const; - - string GetCompName(med_int theId) const; - void SetCompName(med_int theId, const string& theValue); - - string GetUnitName(med_int theId) const; - void SetUnitName(med_int theId, const string& theValue); - }; - typedef shared_ptr PFieldInfo; - - -//--------------------------------------------------------------- - class TTimeStampInfo{ - friend class TWrapper; - TTimeStampInfo(); - protected: - MED::PTimeStampInfo myInfo; - TTimeStampInfo(const MED::PTimeStampInfo& theInfo); - public: - med_entite_maillage GetEntity() const; - const MED::TGeom& GetGeom() const; - - med_int GetNbGauss() const; - med_int GetNumDt() const; - med_int GetNumOrd() const; - - med_float GetDt() const; - - string GetUnitDt() const; - void SetUnitDt(const string& theValue); - }; - typedef shared_ptr PTimeStampInfo; - - -//--------------------------------------------------------------- - class TTimeStampVal{ - friend class TWrapper; - TTimeStampVal(); - protected: - MED::PTimeStampVal myInfo; - TTimeStampVal(const MED::PTimeStampVal& theInfo); - public: - med_float GetVal(med_geometrie_element theGeom, med_int theId, - med_int theComp, med_int theGauss = 0) const; - void SetVal(med_geometrie_element theGeom, med_int theId, - med_int theComp, med_float theVal, med_int theGauss = 0); - - string GetPflName() const; - void SetPflName(const string& theValue); - }; - typedef shared_ptr PTimeStampVal; - -}; - -#endif diff --git a/src/MEDWrapper/MEDA_Test.cxx b/src/MEDWrapper/MEDA_Test.cxx deleted file mode 100644 index 396dd1dc5..000000000 --- a/src/MEDWrapper/MEDA_Test.cxx +++ /dev/null @@ -1,182 +0,0 @@ -// VISU OBJECT : interactive object for VISU entities implementation -// -// 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: VISUConvertor.cxx -// Author: Alexey PETROV -// Module : VISU - -#include "MEDA_Structures.hxx" -#include "MEDA_Wrapper.hxx" -#include "MED_Utilities.hxx" - -using namespace std; - -#ifdef DEBUG -static int MYDEBUG = 1; -#else -static int MYDEBUG = 0; -#endif - - -void ReadMed(const char* theFileName){ - using namespace MEDA; - TWrapper aMed(theFileName); - string aFileName = theFileName; - aFileName += "+"; - TWrapper aMedW(aFileName); - - int aNbMeshes = aMed.GetNbMeshes(); - cout<<"GetNbMeshes() = "<GetDim(); - PMeshInfo aMeshInfoW = TWrapper::CrMeshInfo(aMeshInfo); - aName = aMeshInfoW->GetName(); - cout<<"GetMeshInfo - aName = '"<SetGroupName(iGroup,aName); - } - aMedW.SetFamilyInfo(aFamilyInfoW); - } - - MED::TEntityInfo aEntityInfo = aMed.GetEntityInfo(aMeshInfo); - cout<<"GetEntityInfo - aNbEntities = "<first; - cout<<"\tanEntity = "<GetNbElem(); - cout<<"\tGetNodeInfo - aNbNodes = "<GetNodeCoord(iNode,iDim)<<","; - } - cout<<" "; - } - cout<second; - MED::TGeom::const_iterator anTGeomIter = aTGeom.begin(); - for(; anTGeomIter != aTGeom.end(); anTGeomIter++){ - const med_geometrie_element& aGeom = anTGeomIter->first; - PCellInfo aCellInfo = aMed.GetCellInfo(aMeshInfo,anEntity,aGeom); - PCellInfo aCellInfoW = TWrapper::CrCellInfo(aMeshInfoW,aCellInfo); - med_int aNbElem = aCellInfo->GetNbElem(); - cout<<"\t\taGeom = "<GetConnDim(); - for(int iConn = 0; iConn < iConnEnd; iConn++){ - //cout<GetConn(iElem,iConn)<<","; - } - cout<<" "; - } - cout<SetName(aName); - aMedW.SetFieldInfo(aFieldInfoW); - MED::TGeom aTGeom; - med_entite_maillage anEntity; - med_int aNbTimeStamps = aMed.GetNbTimeStamps(aFieldInfo,aEntityInfo,anEntity,aTGeom); - cout<<"anEntity = "<GetUnitDt()<first; - med_int aNbElem = anTGeomIter->second; - cout<<"\t\taGeom = "<GetVal(aGeom,iElem,j,k)<<","; - } - } - cout<<" "; - } - cout<<"\n"; - } - aMedW.SetTimeStamp(aTimeStampValW); - } - } - } - cout<<"OK"< 1) - ReadMed(argv[1]); - return 0; - try{ - if(argc > 1) - ReadMed(argv[1]); - return 0; - }catch(std::exception& exc){ - cout<<"Follow exception was accured :\n"< 1) - ReadMed(argv[1]); - return 0; - }catch(std::exception& exc){ - cout<<"Follow exception was accured :\n"<myInfo)); - return PMeshInfo(new TMeshInfo(anInfo)); -} - -med_int TWrapper::GetNbMeshes(){ - return myWrapper->GetNbMeshes(); -} - -PMeshInfo TWrapper::GetMeshInfo(med_int theId){ - PMeshInfo anInfo = CrMeshInfo(); - myWrapper->GetMeshInfo(theId+1,*anInfo->myInfo); - if(MYDEBUG){ - MESSAGE("GetMeshInfo(...)"); - MED::PrefixPrinter aPrefixPrinter; - BEGMSG("aName = '"<GetName()<<"'; aDim = "<GetDim()<<"\n"); - ADDMSG("\n"); - } - return anInfo; -} - -void TWrapper::SetMeshInfo(const PMeshInfo& theInfo){ - myWrapper->SetMeshInfo(*theInfo->myInfo); -} - - -//--------------------------------------------------------------- -PFamilyInfo TWrapper::CrFamilyInfo(const PMeshInfo& theMeshInfo, - med_int theNbGroup, - med_int theNbAttr, - med_int theId, - const string& theValue) -{ - const MED::PMeshInfo& aMeshInfo = theMeshInfo->myInfo; - MED::PFamilyInfo anInfo(new MED::TFamilyInfo(aMeshInfo, - theNbGroup, - theNbAttr, - theId, - theValue)); - return PFamilyInfo(new TFamilyInfo(anInfo)); -} - -PFamilyInfo TWrapper::CrFamilyInfo(const PMeshInfo& theMeshInfo, - const string& theValue, - med_int theId, - const MED::TStringSet& theGroupNames, - const MED::TStringVector& theAttrDescs, - const MED::TIntVector& theAttrIds, - const MED::TIntVector& theAttrVals) -{ - const MED::PMeshInfo& aMeshInfo = theMeshInfo->myInfo; - MED::PFamilyInfo anInfo(new MED::TFamilyInfo(aMeshInfo, - theValue, - theId, - theGroupNames, - theAttrDescs, - theAttrIds, - theAttrVals)); - return PFamilyInfo(new TFamilyInfo(anInfo)); -} - -PFamilyInfo TWrapper::CrFamilyInfo(const PMeshInfo& theMeshInfo, - const PFamilyInfo& theInfo) -{ - MED::PFamilyInfo anInfo(new MED::TFamilyInfo(*theInfo->myInfo)); - anInfo->myMeshInfo = theMeshInfo->myInfo; - return PFamilyInfo(new TFamilyInfo(anInfo)); -} - -med_int TWrapper::GetNbFamilies(const PMeshInfo& theMeshInfo){ - return myWrapper->GetNbFamilies(*theMeshInfo->myInfo); -} - -PFamilyInfo TWrapper::GetFamilyInfo(const PMeshInfo& theMeshInfo, med_int theId){ - med_int aNbAttr = myWrapper->GetNbFamAttr(theId+1,*theMeshInfo->myInfo); - med_int aNbGroup = myWrapper->GetNbFamGroup(theId+1,*theMeshInfo->myInfo); - PFamilyInfo anInfo = CrFamilyInfo(theMeshInfo,aNbGroup,aNbAttr); - myWrapper->GetFamilyInfo(theId+1,*anInfo->myInfo); - if(MYDEBUG){ - MESSAGE("GetFamilyInfo(...)"); - MED::PrefixPrinter aPrefixPrinter; - BEGMSG("aName = '"<GetName()<<"'; anId = "<GetId()<<"\n"); - ADDMSG("\n"); - } - return anInfo; -} - -void TWrapper::SetFamilyInfo(const PFamilyInfo& theInfo){ - myWrapper->SetFamilyInfo(*theInfo->myInfo); -} - - -//--------------------------------------------------------------- -PNodeInfo TWrapper::CrNodeInfo(const PMeshInfo& theMeshInfo, - med_int theNbElem, - med_repere theSystem, - med_booleen theIsElemNum, - med_booleen theIsElemNames) -{ - const MED::PMeshInfo& aMeshInfo = theMeshInfo->myInfo; - MED::PNodeInfo anInfo(new MED::TNodeInfo(aMeshInfo, - theNbElem, - theSystem, - theIsElemNum, - theIsElemNames)); - return PNodeInfo(new TNodeInfo(anInfo)); -} - -PNodeInfo TWrapper::CrNodeInfo(const PMeshInfo& theMeshInfo, - med_repere theSystem, - const MED::TFloatVector& theNodeCoords, - const MED::TStringVector& theCoordNames, - const MED::TStringVector& theCoordUnits, - const MED::TIntVector& theFamilyNums, - const MED::TIntVector& theElemNums, - const MED::TStringVector& theElemNames) -{ - const MED::PMeshInfo& aMeshInfo = theMeshInfo->myInfo; - MED::PNodeInfo anInfo(new MED::TNodeInfo(aMeshInfo, - theSystem, - theNodeCoords, - theCoordNames, - theCoordUnits, - theFamilyNums, - theElemNums, - theElemNames)); - return PNodeInfo(new TNodeInfo(anInfo)); -} - -PNodeInfo TWrapper::CrNodeInfo(const PMeshInfo& theMeshInfo, - const PNodeInfo& theInfo) -{ - MED::PNodeInfo anInfo(new MED::TNodeInfo(*theInfo->myInfo)); - anInfo->myMeshInfo = theMeshInfo->myInfo; - return PNodeInfo(new TNodeInfo(anInfo)); -} - -PNodeInfo TWrapper::GetNodeInfo(const PMeshInfo& theMeshInfo){ - med_int aNbElems = myWrapper->GetNbNodes(*theMeshInfo->myInfo); - PNodeInfo anInfo = CrNodeInfo(theMeshInfo,aNbElems); - myWrapper->GetNodeInfo(*anInfo->myInfo); - return anInfo; -} - -void TWrapper::SetNodeInfo(const PNodeInfo& theInfo){ - myWrapper->SetNodeInfo(*theInfo->myInfo); -} - - -//--------------------------------------------------------------- -MED::TEntityInfo TWrapper::GetEntityInfo(const PMeshInfo& theMeshInfo){ - return myWrapper->GetEntityInfo(*theMeshInfo->myInfo); -} - -PCellInfo TWrapper::CrCellInfo(const PMeshInfo& theMeshInfo, - med_int theNbElem, - med_entite_maillage theEntity, - med_geometrie_element theGeom, - med_connectivite theConn, - med_booleen theIsElemNum, - med_booleen theIsElemNames) -{ - MED::PCellInfo anInfo(new MED::TCellInfo(theMeshInfo->myInfo, - theNbElem, - theEntity, - theGeom, - theConn, - theIsElemNum, - theIsElemNames)); - return PCellInfo(new TCellInfo(anInfo)); -} - -PCellInfo TWrapper::CrCellInfo(const PMeshInfo& theMeshInfo, - med_entite_maillage theEntity, - med_geometrie_element theGeom, - med_connectivite theConn, - const MED::TIntVector& theConnectivities, - const MED::TIntVector& theFamilyNums, - const MED::TIntVector& theElemNums, - const MED::TStringVector& theElemNames) -{ - MED::PCellInfo anInfo(new MED::TCellInfo(theMeshInfo->myInfo, - theEntity, - theGeom, - theConn, - theConnectivities, - theFamilyNums, - theElemNums, - theElemNames)); - return PCellInfo(new TCellInfo(anInfo)); -} - -PCellInfo TWrapper::CrCellInfo(const PMeshInfo& theMeshInfo, - const PCellInfo& theInfo) -{ - MED::PCellInfo anInfo(new MED::TCellInfo(*theInfo->myInfo)); - anInfo->myMeshInfo = theMeshInfo->myInfo; - return PCellInfo(new TCellInfo(anInfo)); -} - -PCellInfo TWrapper::GetCellInfo(const PMeshInfo& theMeshInfo, - med_entite_maillage theEntity, - med_geometrie_element theGeom, - med_connectivite theConn) -{ - med_int aNbElem = myWrapper->GetNbCells(*theMeshInfo->myInfo,theEntity,theGeom,theConn); - PCellInfo anInfo = CrCellInfo(theMeshInfo,aNbElem,theEntity,theGeom,theConn); - myWrapper->GetCellInfo(*anInfo->myInfo); - return anInfo; -} - -void TWrapper::SetCellInfo(const PCellInfo& theInfo){ - myWrapper->SetCellInfo(*theInfo->myInfo); -} - - -//--------------------------------------------------------------- -PFieldInfo TWrapper::CrFieldInfo(const PMeshInfo& theMeshInfo, - med_int theNbComp, - med_type_champ theType, - const string& theValue) -{ - MED::PFieldInfo anInfo(new MED::TFieldInfo(theMeshInfo->myInfo, - theNbComp, - theType, - theValue)); - return PFieldInfo(new TFieldInfo(anInfo)); -} - -PFieldInfo TWrapper::CrFieldInfo(const PMeshInfo& theMeshInfo, - const PFieldInfo& theInfo) -{ - MED::PFieldInfo anInfo(new MED::TFieldInfo(*theInfo->myInfo)); - anInfo->myMeshInfo = theMeshInfo->myInfo; - return PFieldInfo(new TFieldInfo(anInfo)); -} - -med_int TWrapper::GetNbFields(){ - return myWrapper->GetNbFields(); -} - -PFieldInfo TWrapper::GetFieldInfo(const PMeshInfo& theMeshInfo, med_int theId){ - med_int aNbComp = myWrapper->GetNbComp(theId+1); - PFieldInfo anInfo = CrFieldInfo(theMeshInfo,aNbComp); - myWrapper->GetFieldInfo(theId+1,*anInfo->myInfo); - return anInfo; -} - -void TWrapper::SetFieldInfo(const PFieldInfo& theInfo){ - myWrapper->SetFieldInfo(*theInfo->myInfo); -} - - -//--------------------------------------------------------------- -PTimeStampInfo TWrapper::CrTimeStampInfo(const PFieldInfo& theFieldInfo, - med_entite_maillage theEntity, - const MED::TGeom& theGeom) -{ - MED::PTimeStampInfo anInfo(new MED::TTimeStampInfo(theFieldInfo->myInfo, - theEntity, - theGeom)); - return PTimeStampInfo(new TTimeStampInfo(anInfo)); -} - -PTimeStampInfo TWrapper::CrTimeStampInfo(const PFieldInfo& theFieldInfo, - const PTimeStampInfo& theInfo) -{ - MED::PTimeStampInfo anInfo(new MED::TTimeStampInfo(*theInfo->myInfo)); - anInfo->myFieldInfo = theFieldInfo->myInfo; - return PTimeStampInfo(new TTimeStampInfo(anInfo)); -} - -med_int TWrapper::GetNbTimeStamps(const PFieldInfo& theFieldInfo, - const MED::TEntityInfo& theEntityInfo, - med_entite_maillage& theEntity, - MED::TGeom& theGeom) -{ - return myWrapper->GetNbTimeStamps(*theFieldInfo->myInfo, - theEntityInfo, - theEntity, - theGeom); -} - -PTimeStampInfo TWrapper::GetTimeStampInfo(const PFieldInfo& theFieldInfo, - med_int theId, - med_entite_maillage theEntity, - const MED::TGeom& theGeom) -{ - PTimeStampInfo anInfo = CrTimeStampInfo(theFieldInfo,theEntity,theGeom); - myWrapper->GetTimeStampInfo(theId+1,*anInfo->myInfo); - return anInfo; -} - - -//--------------------------------------------------------------- -PTimeStampVal TWrapper::CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo) -{ - MED::PTimeStampVal anInfo(new MED::TTimeStampVal(theTimeStampInfo->myInfo)); - return PTimeStampVal(new TTimeStampVal(anInfo)); -} - -PTimeStampVal TWrapper::CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo, - const PTimeStampVal& theInfo) -{ - MED::PTimeStampVal anInfo(new MED::TTimeStampVal(*theInfo->myInfo)); - anInfo->myTimeStampInfo = theTimeStampInfo->myInfo; - return PTimeStampVal(new TTimeStampVal(anInfo)); -} - -PTimeStampVal TWrapper::GetTimeStampVal(const PTimeStampInfo& theTimeStampInfo) -{ - PTimeStampVal anInfo = CrTimeStampVal(theTimeStampInfo); - myWrapper->GetTimeStampVal(*anInfo->myInfo); - return anInfo; -} - -void TWrapper::SetTimeStamp(const PTimeStampVal& theTimeStampVal){ - myWrapper->SetTimeStamp(*theTimeStampVal->myInfo); -} diff --git a/src/MEDWrapper/MEDA_Wrapper.hxx b/src/MEDWrapper/MEDA_Wrapper.hxx deleted file mode 100644 index e135e214c..000000000 --- a/src/MEDWrapper/MEDA_Wrapper.hxx +++ /dev/null @@ -1,161 +0,0 @@ -// Copyright (C) 2003 CEA/DEN, EDF R&D -// -// -// -// File : VISU_DatConvertor.hxx -// Author : Alexey PETROV -// Module : VISU - -#ifndef MEDA_Wrapper_HeaderFile -#define MEDA_Wrapper_HeaderFile - -#include "MEDA_Structures.hxx" - -namespace MEDA{ - class TWrapper{ - TWrapper(); - TWrapper(const TWrapper&); - protected: - MED::PWrapper myWrapper; - - public: - TWrapper(const string& theFileName); - - - //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - static PMeshInfo CrMeshInfo(med_int theDim = 0, - const string& theValue = ""); - - static PMeshInfo CrMeshInfo(const PMeshInfo& theMeshInfo); - - med_int GetNbMeshes(); - - PMeshInfo GetMeshInfo(med_int theId); - - void SetMeshInfo(const PMeshInfo& theInfo); - - //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - static PFamilyInfo CrFamilyInfo(const PMeshInfo& theMeshInfo, - med_int theNbGroup = 0, - med_int theNbAttr = 0, - med_int theId = 0, - const string& theValue = ""); - - static PFamilyInfo CrFamilyInfo(const PMeshInfo& theMeshInfo, - const string& theValue, - med_int theId, - const MED::TStringSet& theGroupNames, - const MED::TStringVector& theAttrDescs = MED::TStringVector(), - const MED::TIntVector& theAttrIds = MED::TIntVector(), - const MED::TIntVector& theAttrVals = MED::TIntVector()); - - static PFamilyInfo CrFamilyInfo(const PMeshInfo& theMeshInfo, - const PFamilyInfo& theInfo); - - med_int GetNbFamilies(const PMeshInfo& theMeshInfo); - - PFamilyInfo GetFamilyInfo(const PMeshInfo& theMeshInfo, med_int theId); - - void SetFamilyInfo(const PFamilyInfo& theInfo); - - //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - static PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo, - med_int theNbElem, - med_repere theSystem = MED_CART, - med_booleen theIsElemNum = MED_VRAI, - med_booleen theIsElemNames = MED_VRAI); - - static PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo, - med_repere theSystem, - const MED::TFloatVector& theNodeCoords, - const MED::TStringVector& theCoordNames, - const MED::TStringVector& theCoordUnits, - const MED::TIntVector& theFamilyNums, - const MED::TIntVector& theElemNums, - const MED::TStringVector& theElemNames = MED::TStringVector()); - - static PNodeInfo CrNodeInfo(const PMeshInfo& theMeshInfo, - const PNodeInfo& theInfo); - - PNodeInfo GetNodeInfo(const PMeshInfo& theMeshInfo); - - void SetNodeInfo(const PNodeInfo& theInfo); - - //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - MED::TEntityInfo GetEntityInfo(const PMeshInfo& theMeshInfo); - - static PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo, - med_int theNbElem, - med_entite_maillage theEntity, - med_geometrie_element theGeom, - med_connectivite theConn = MED_NOD, - med_booleen theIsElemNum = MED_VRAI, - med_booleen theIsElemNames = MED_VRAI); - - static PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo, - med_entite_maillage theEntity, - med_geometrie_element theGeom, - med_connectivite theConn, - const MED::TIntVector& theConnectivities, - const MED::TIntVector& theFamilyNums, - const MED::TIntVector& theElemNums, - const MED::TStringVector& theElemNames = MED::TStringVector()); - - static PCellInfo CrCellInfo(const PMeshInfo& theMeshInfo, - const PCellInfo& theInfo); - - PCellInfo GetCellInfo(const PMeshInfo& theMeshInfo, - med_entite_maillage theEntity, - med_geometrie_element theGeom, - med_connectivite theConn = MED_NOD); - - void SetCellInfo(const PCellInfo& theInfo); - - //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - static PFieldInfo CrFieldInfo(const PMeshInfo& theMeshInfo, - med_int theNbComp = 0, - med_type_champ theType = MED_REEL64, - const string& theValue = ""); - - static PFieldInfo CrFieldInfo(const PMeshInfo& theMeshInfo, - const PFieldInfo& theInfo); - med_int GetNbFields(); - - PFieldInfo GetFieldInfo(const PMeshInfo& theMeshInfo, med_int theId); - - void SetFieldInfo(const PFieldInfo& theInfo); - - //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - static PTimeStampInfo CrTimeStampInfo(const PFieldInfo& theFieldInfo, - med_entite_maillage theEntity, - const MED::TGeom& theGeom); - - static PTimeStampInfo CrTimeStampInfo(const PFieldInfo& theFieldInfo, - const PTimeStampInfo& theInfo); - - med_int GetNbTimeStamps(const PFieldInfo& theFieldInfo, - const MED::TEntityInfo& theEntityInfo, - med_entite_maillage& theEntity, - MED::TGeom& theGeom); - - PTimeStampInfo GetTimeStampInfo(const PFieldInfo& theFieldInfo, - med_int theId, - med_entite_maillage theEntity, - const MED::TGeom& theGeom); - - - //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - static PTimeStampVal CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo); - - static PTimeStampVal CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo, - const PTimeStampVal& theInfo); - - PTimeStampVal GetTimeStampVal(const PTimeStampInfo& theTimeStampInfo); - - void SetTimeStamp(const PTimeStampVal& theTimeStampVal); - }; - -}; - - -#endif diff --git a/src/MEDWrapper/MED_Common.hxx b/src/MEDWrapper/MED_Common.hxx deleted file mode 100644 index 0afa3b4cc..000000000 --- a/src/MEDWrapper/MED_Common.hxx +++ /dev/null @@ -1,71 +0,0 @@ -// Copyright (C) 2003 CEA/DEN, EDF R&D -// -// -// -// File : VISU_DatConvertor.hxx -// Author : Alexey PETROV -// Module : VISU - -#ifndef MED_Common_HeaderFile -#define MED_Common_HeaderFile - -#include -#include -#include -#include - -extern "C"{ -#include -} - -#include - -namespace MED{ - using namespace std; - using namespace boost; - - typedef vector TFloatVector; - typedef vector TStringVector; - typedef vector TIntVector; - typedef set TStringSet; - - typedef map TGeom; - typedef map TEntityInfo; - - med_int GetNbConn(med_entite_maillage theMedEntity, - med_geometrie_element theMedType, - med_int theMeshDim); - - struct TNameInfo; - typedef shared_ptr PNameInfo; - - struct TMeshInfo; - typedef shared_ptr PMeshInfo; - - struct TFamilyInfo; - typedef shared_ptr PFamilyInfo; - - struct TElemInfo; - typedef shared_ptr PElemInfo; - - struct TNodeInfo; - typedef shared_ptr PNodeInfo; - - struct TCellInfo; - typedef shared_ptr PCellInfo; - - struct TFieldInfo; - typedef shared_ptr PFieldInfo; - - struct TTimeStampInfo; - typedef shared_ptr PTimeStampInfo; - - struct TTimeStampVal; - typedef shared_ptr PTimeStampVal; - - class TWrapper; - typedef shared_ptr PWrapper; -}; - - -#endif diff --git a/src/MEDWrapper/MED_Structures.cxx b/src/MEDWrapper/MED_Structures.cxx deleted file mode 100644 index 500a3e932..000000000 --- a/src/MEDWrapper/MED_Structures.cxx +++ /dev/null @@ -1,440 +0,0 @@ -// Copyright (C) 2003 CEA/DEN, EDF R&D -// -// -// -// File : VISU_DatConvertor.cxx -// Author : Alexey PETROV -// Module : VISU - -#include "MED_Structures.hxx" -#include "MED_Utilities.hxx" -#include -using namespace std; -using namespace MED; - -#ifdef _DEBUG_ -static int MYDEBUG = 1; -#else -static int MYDEBUG = 0; -#endif - -#if defined __GNUC__ - #if __GNUC__ == 2 - #define __GNUC_2__ - #endif -#endif - -//--------------------------------------------------------------- -string MED::GetString(med_int theId, med_int theStep, - const TString& theString) -{ - const char* aPos = &theString[theId*theStep]; - med_int aSize = min(med_int(strlen(aPos)),theStep); - return string(aPos,aSize); -} - -void MED::SetString(med_int theId, med_int theStep, - TString& theString, const string& theValue) -{ - med_int aSize = min(med_int(theValue.size()+1),theStep); - if(aSize > theStep) - EXCEPTION(runtime_error,"SetString(...): aSize =="< theStep"); - strncpy(&theString[theId*theStep],theValue.c_str(),aSize); -} - -med_int MED::GetNbConn(med_entite_maillage theMedEntity, - med_geometrie_element theMedType, - med_int theMeshDim) -{ - med_int anElemDim = theMedType / 100, nsup = 0; - if(theMedEntity == MED_MAILLE && anElemDim < theMeshDim) nsup = 1; - return nsup + theMedType % 100; -} - - -//--------------------------------------------------------------- -TNameInfo::TNameInfo(const string& theValue): -#if defined __GNUC_2__ - // _CS_phb Attention, il s'agit dans ce cas (gcc2.*) d'un vector. - // L'appel des arguments est inversé. - myName(MED_TAILLE_NOM+1,'\0') -#else - myName('\0',MED_TAILLE_NOM+1) -#endif -{ - if(theValue != "") SetName(theValue); -} - -string TNameInfo::GetName() const { - return GetString(0,MED_TAILLE_NOM,myName); -} - -void TNameInfo::SetName(const string& theValue){ - SetString(0,MED_TAILLE_NOM,myName,theValue); -} - - -//--------------------------------------------------------------- -TMeshInfo::TMeshInfo(med_int theDim, - const string& theValue): - TNameInfo(theValue), - myDim(theDim) -{} - -//--------------------------------------------------------------- -TFamilyInfo::TFamilyInfo(const PMeshInfo& theMeshInfo, - med_int theNbGroup, - med_int theNbAttr, - med_int theId, - const string& theValue): - TNameInfo(theValue), - myMeshInfo(theMeshInfo), - myId(theId), - myNbGroup(theNbGroup), -#if defined __GNUC_2__ - // _CS_phb Attention, il s'agit dans ce cas (gcc2.*) d'un vector - // L'appel des arguments est inversé. - myGroupNames(theNbGroup*MED_TAILLE_LNOM+1,'\0'), -#else - myGroupNames('\0',theNbGroup*MED_TAILLE_LNOM+1), -#endif - myNbAttr(theNbAttr), - myAttrId(theNbAttr), - myAttrVal(theNbAttr), -#if defined __GNUC_2__ - myAttrDesc(theNbAttr*MED_TAILLE_DESC+1,'\0') -#else - myAttrDesc('\0',theNbAttr*MED_TAILLE_DESC+1) -#endif -{} - -TFamilyInfo::TFamilyInfo(const PMeshInfo& theMeshInfo, - const string& theValue, - med_int theId, - const TStringSet& theGroupNames, - const TStringVector& theAttrDescs, - const TIntVector& theAttrIds, - const TIntVector& theAttrVals): - TNameInfo(theValue), - myMeshInfo(theMeshInfo), - myId(theId), - myNbGroup(theGroupNames.size()), -#if defined __GNUC_2__ - // _CS_phb Attention, il s'agit dans ce cas (gcc2.*) d'un vector - // L'appel des arguments est inversé. - myGroupNames(theGroupNames.size()*MED_TAILLE_LNOM+1,'\0'), -#else - myGroupNames('\0',theGroupNames.size()*MED_TAILLE_LNOM+1), -#endif - myNbAttr(theAttrDescs.size()), - myAttrId(theAttrDescs.size()), - myAttrVal(theAttrDescs.size()), -#if defined __GNUC_2__ - myAttrDesc(theAttrDescs.size()*MED_TAILLE_DESC+1,'\0') -#else - myAttrDesc('\0',theAttrDescs.size()*MED_TAILLE_DESC+1) -#endif - -{ - if(myNbGroup){ - TStringSet::const_iterator anIter = theGroupNames.begin(); - for(med_int anId = 0; anIter != theGroupNames.end(); anIter++, anId++){ - const string& aVal = *anIter; - SetGroupName(anId,aVal); - } - } - if(myNbAttr){ - for(med_int anId = 0, anEnd = theAttrDescs.size(); anId < anEnd; anId++){ - const string& aVal = theAttrDescs[anId]; - SetAttrDesc(anId,aVal); - myAttrId[anId] = theAttrIds[anId]; - myAttrVal[anId] = theAttrVals[anId]; - } - } -} - -string TFamilyInfo::GetGroupName(med_int theId) const { - return GetString(theId,MED_TAILLE_LNOM,myGroupNames); -} - -void TFamilyInfo::SetGroupName(med_int theId, const string& theValue){ - SetString(theId,MED_TAILLE_LNOM,myGroupNames,theValue); -} - -string TFamilyInfo::GetAttrDesc(med_int theId) const { - return GetString(theId,MED_TAILLE_DESC,myAttrDesc); -} - -void TFamilyInfo::SetAttrDesc(med_int theId, const string& theValue){ - SetString(theId,MED_TAILLE_DESC,myAttrDesc,theValue); -} - - -//--------------------------------------------------------------- -TElemInfo::TElemInfo(const PMeshInfo& theMeshInfo, - med_int theNbElem, - med_booleen theIsElemNum, - med_booleen theIsElemNames): - myMeshInfo(theMeshInfo), - myNbElem(theNbElem), - myFamNum(theNbElem), - myIsElemNum(theIsElemNum), - myElemNum(theIsElemNum == MED_FAUX? 0: theNbElem), - myIsElemNames(theIsElemNames), -#if defined __GNUC_2__ - myElemNames((theIsElemNames == MED_FAUX? 0: theNbElem)*MED_TAILLE_PNOM+1,'\0') -#else - myElemNames('\0',(theIsElemNames == MED_FAUX? 0: theNbElem)*MED_TAILLE_PNOM+1) -#endif -{} - -TElemInfo::TElemInfo(const PMeshInfo& theMeshInfo, - const TIntVector& theFamilyNums, - const TIntVector& theElemNums, - const TStringVector& theElemNames): - myMeshInfo(theMeshInfo), - myNbElem(theFamilyNums.size()), - myFamNum(theFamilyNums.size()), - myIsElemNum(theElemNums.size()? MED_VRAI: MED_FAUX), - myElemNum(theElemNums.size()), - myIsElemNames(theElemNames.size()? MED_VRAI: MED_FAUX), -#if defined __GNUC_2__ - myElemNames(theElemNames.size()*MED_TAILLE_PNOM+1,'\0') -#else - myElemNames('\0',theElemNames.size()*MED_TAILLE_PNOM+1) -#endif -{ - if(myNbElem){ - for(med_int anId = 0; anId < myNbElem; anId++){ - myFamNum[anId] = theFamilyNums[anId]; - } - if(myIsElemNum == MED_VRAI){ - for(med_int anId = 0; anId < myNbElem; anId++){ - myElemNum[anId] = theElemNums[anId]; - } - } - if(myIsElemNames == MED_VRAI){ - for(med_int anId = 0; anId < myNbElem; anId++){ - const string& aVal = theElemNames[anId]; - SetElemName(anId,aVal); - } - } - } -} - -string TElemInfo::GetElemName(med_int theId) const { - return GetString(theId,MED_TAILLE_PNOM,myElemNames); -} - -void TElemInfo::SetElemName(med_int theId, const string& theValue){ - SetString(theId,MED_TAILLE_PNOM,myElemNames,theValue); -} - - -//--------------------------------------------------------------- -TNodeInfo::TNodeInfo(const PMeshInfo& theMeshInfo, - med_int theNbElem, - med_repere theSystem, - med_booleen theIsElemNum, - med_booleen theIsElemNames): - TElemInfo(theMeshInfo,theNbElem,theIsElemNum,theIsElemNames), - myCoord(theNbElem*theMeshInfo->myDim), - mySystem(theSystem), -#if defined __GNUC_2__ - myCoordNames(theMeshInfo->myDim*MED_TAILLE_PNOM+1,'\0'), - myCoordUnits(theMeshInfo->myDim*MED_TAILLE_PNOM+1,'\0') -#else - myCoordNames('\0',theMeshInfo->myDim*MED_TAILLE_PNOM+1), - myCoordUnits('\0',theMeshInfo->myDim*MED_TAILLE_PNOM+1) -#endif -{} - -TNodeInfo::TNodeInfo(const PMeshInfo& theMeshInfo, - med_repere theSystem, - const TFloatVector& theNodeCoords, - const TStringVector& theCoordNames, - const TStringVector& theCoordUnits, - const TIntVector& theFamilyNums, - const TIntVector& theElemNums, - const TStringVector& theElemNames): - TElemInfo(theMeshInfo,theFamilyNums,theElemNums,theElemNames), - myCoord(theNodeCoords.size()), - mySystem(theSystem), -#if defined __GNUC_2__ - myCoordNames(theMeshInfo->myDim*MED_TAILLE_PNOM+1,'\0'), - myCoordUnits(theMeshInfo->myDim*MED_TAILLE_PNOM+1,'\0') -#else - myCoordNames('\0',theMeshInfo->myDim*MED_TAILLE_PNOM+1), - myCoordUnits('\0',theMeshInfo->myDim*MED_TAILLE_PNOM+1) -#endif -{ - if(myCoord.size() == myNbElem*theMeshInfo->myDim){ - for(med_int anId = 0, anEnd = myCoord.size(); anId < anEnd; anId++){ - myCoord[anId] = theNodeCoords[anId]; - } - }else - EXCEPTION(runtime_error,"myCoord.size() != myNbElem*theMeshInfo->myDim"); - - for(med_int anId = 0; anId < theMeshInfo->myDim; anId++){ -#if defined __GNUC_2__ - const string& aVal = theCoordNames[anId]; -#else - const string& aVal = theCoordNames.at(anId); -#endif - - SetCoordName(anId,aVal); - } - - for(med_int anId = 0; anId < theMeshInfo->myDim; anId++){ -#if defined __GNUC_2__ - const string& aVal = theCoordUnits[anId]; -#else - const string& aVal = theCoordUnits.at(anId); -#endif - SetCoordUnit(anId,aVal); - } -} - -string TNodeInfo::GetCoordName(med_int theId) const { - return GetString(theId,MED_TAILLE_PNOM,myCoordNames); -} - -void TNodeInfo::SetCoordName(med_int theId, const string& theValue){ - SetString(theId,MED_TAILLE_PNOM,myCoordNames,theValue); -} - -string TNodeInfo::GetCoordUnit(med_int theId) const { - return GetString(theId,MED_TAILLE_PNOM,myCoordUnits); -} - -void TNodeInfo::SetCoordUnit(med_int theId, const string& theValue){ - SetString(theId,MED_TAILLE_PNOM,myCoordUnits,theValue); -} - - -//--------------------------------------------------------------- -TCellInfo::TCellInfo(const PMeshInfo& theMeshInfo, - med_int theNbElem, - med_entite_maillage theTEntity, - med_geometrie_element theTGeom, - med_connectivite theTConn, - med_booleen theIsElemNum, - med_booleen theIsElemNames): - TElemInfo(theMeshInfo,theNbElem,theIsElemNum,theIsElemNames), - myTEntity(theTEntity), - myTGeom(theTGeom), - myTConn(theTConn), - myConnDim(GetNbConn(myTEntity,myTGeom,theMeshInfo->myDim)), - myConn(theNbElem*myConnDim) -{} - -TCellInfo::TCellInfo(const PMeshInfo& theMeshInfo, - med_entite_maillage theTEntity, - med_geometrie_element theTGeom, - med_connectivite theTConn, - const TIntVector& theConnectivities, - const TIntVector& theFamilyNums, - const TIntVector& theElemNums, - const TStringVector& theElemNames): - TElemInfo(theMeshInfo,theFamilyNums,theElemNums,theElemNames), - myTEntity(theTEntity), - myTGeom(theTGeom), - myTConn(theTConn), - myConnDim(GetNbConn(myTEntity,myTGeom,theMeshInfo->myDim)), - myConn(theConnectivities.size()) -{ - if(myConn.size() == myConnDim*theFamilyNums.size()){ - for(med_int anId = 0, anEnd = myConn.size(); anId < anEnd; anId++){ - myConn[anId] = theConnectivities[anId]; - } - }else - EXCEPTION(runtime_error,"myConn.size() == myConnDim*theFamilyNums.size()"); -} - -//--------------------------------------------------------------- -TFieldInfo::TFieldInfo(const PMeshInfo& theMeshInfo, - med_int theNbComp, - med_type_champ theType, - const string& theValue): - TNameInfo(theValue), - myMeshInfo(theMeshInfo), - myNbComp(theNbComp), - myType(theType), -#if defined __GNUC_2__ - myCompNames(theNbComp*MED_TAILLE_PNOM + 1,'\0'), - myUnitNames(theNbComp*MED_TAILLE_PNOM + 1,'\0') -#else - myCompNames('\0',theNbComp*MED_TAILLE_PNOM + 1), - myUnitNames('\0',theNbComp*MED_TAILLE_PNOM + 1) -#endif -{} - -string TFieldInfo::GetCompName(med_int theId) const { - return GetString(theId,MED_TAILLE_PNOM,myCompNames); -} - -void TFieldInfo::SetCompName(med_int theId, const string& theValue){ - SetString(theId,MED_TAILLE_PNOM,myCompNames,theValue); -} - -string TFieldInfo::GetUnitName(med_int theId) const { - return GetString(theId,MED_TAILLE_PNOM,myUnitNames); -} - -void TFieldInfo::SetUnitName(med_int theId, const string& theValue){ - SetString(theId,MED_TAILLE_PNOM,myUnitNames,theValue); -} - - -//--------------------------------------------------------------- -TTimeStampInfo::TTimeStampInfo(const PFieldInfo& theFieldInfo, - med_entite_maillage theEntity, - const TGeom& theGeom): - myFieldInfo(theFieldInfo), - myEntity(theEntity), - myGeom(theGeom), -#if defined __GNUC_2__ - myUnitDt(MED_TAILLE_PNOM+1,'\0') -#else - myUnitDt('\0',MED_TAILLE_PNOM+1) -#endif -{} - -string TTimeStampInfo::GetUnitDt() const { - return GetString(0,MED_TAILLE_PNOM,myUnitDt); -} - -void TTimeStampInfo::SetUnitDt(const string& theValue){ - SetString(0,MED_TAILLE_PNOM,myUnitDt,theValue); -} - - -//--------------------------------------------------------------- -TTimeStampVal::TTimeStampVal(const PTimeStampInfo& theTimeStampInfo): - myTimeStampInfo(theTimeStampInfo), -#if defined __GNUC_2__ - myPflName(MED_TAILLE_NOM+1,'\0') -#else - myPflName('\0',MED_TAILLE_NOM+1) -#endif -{ - med_int aNbComp = theTimeStampInfo->myFieldInfo->myNbComp; - med_int aNbGauss = theTimeStampInfo->myNbGauss; - const TGeom& aTGeom = theTimeStampInfo->myGeom; - TGeom::const_iterator anIter = aTGeom.begin(); - for(; anIter != aTGeom.end(); anIter++){ - const med_geometrie_element& aGeom = anIter->first; - med_int aNb = anIter->second*aNbComp*aNbGauss; - myMeshValue[aGeom].resize(aNb); - } -} - -string TTimeStampVal::GetPflName() const { - return GetString(0,MED_TAILLE_NOM,myPflName); -} - -void TTimeStampVal::SetPflName(const string& theValue){ - SetString(0,MED_TAILLE_NOM,myPflName,theValue); -} - - diff --git a/src/MEDWrapper/MED_Structures.hxx b/src/MEDWrapper/MED_Structures.hxx deleted file mode 100644 index 727e83c34..000000000 --- a/src/MEDWrapper/MED_Structures.hxx +++ /dev/null @@ -1,243 +0,0 @@ -// Copyright (C) 2003 CEA/DEN, EDF R&D -// -// -// -// File : VISU_DatConvertor.hxx -// Author : Alexey PETROV -// Module : VISU - -#ifndef MED_Structures_HeaderFile -#define MED_Structures_HeaderFile - -#if defined __GNUC__ - #if __GNUC__ == 2 - #define __GNUC_2__ - #endif -#endif - -#if defined __GNUC_2__ -#include -#endif -#include - -#include "MED_Common.hxx" - -namespace MED{ - using namespace std; - using namespace boost; - -//--------------------------------------------------------------- -#if defined __GNUC_2__ - typedef vector TString; -#else - typedef valarray TString; -#endif - - string GetString(med_int theId, med_int theStep, const TString& theString); - void SetString(med_int theId, med_int theStep, TString& theString, - const string& theValue); - - -//--------------------------------------------------------------- - struct TNameInfo{ - TNameInfo(const string& theValue = ""); - virtual ~TNameInfo() {} - - TString myName; - string GetName() const; - void SetName(const string& theValue); - }; - - -//--------------------------------------------------------------- - struct TMeshInfo: TNameInfo{ - TMeshInfo(med_int theDim = 0, - const string& theValue = ""); - - med_int myDim; - }; - - -//--------------------------------------------------------------- - typedef valarray TFamAttr; - - struct TFamilyInfo: TNameInfo{ - TFamilyInfo(const PMeshInfo& theMeshInfo, - med_int theNbGroup = 0, - med_int theNbAttr = 0, - med_int theId = 0, - const string& theValue = ""); - - TFamilyInfo(const PMeshInfo& theMeshInfo, - const string& theValue, - med_int theId, - const TStringSet& theGroupNames, - const TStringVector& theAttrDescs = TStringVector(), - const TIntVector& theAttrIds = TIntVector(), - const TIntVector& theAttrVals = TIntVector()); - - PMeshInfo myMeshInfo; - med_int myId; - - med_int myNbGroup; - TString myGroupNames; - string GetGroupName(med_int theId) const; - void SetGroupName(med_int theId, const string& theValue); - - med_int myNbAttr; - TFamAttr myAttrId; - TFamAttr myAttrVal; - - TString myAttrDesc; - string GetAttrDesc(med_int theId) const; - void SetAttrDesc(med_int theId, const string& theValue); - }; - - -//--------------------------------------------------------------- - typedef valarray TElemNum; - - struct TElemInfo{ - TElemInfo(const PMeshInfo& theMeshInfo, - med_int theNbElem, - med_booleen theIsElemNum = MED_VRAI, - med_booleen theIsElemNames = MED_VRAI); - TElemInfo(const PMeshInfo& theMeshInfo, - const TIntVector& theFamilyNums, - const TIntVector& theElemNums, - const TStringVector& theElemNames = TStringVector()); - virtual ~TElemInfo() {} - - PMeshInfo myMeshInfo; - med_int myNbElem; - - TElemNum myFamNum; - - med_booleen myIsElemNum; - TElemNum myElemNum; - - med_booleen myIsElemNames; - TString myElemNames; - string GetElemName(med_int theId) const; - void SetElemName(med_int theId, const string& theValue); - }; - - -//--------------------------------------------------------------- - typedef valarray TNodeCoord; - - struct TNodeInfo: TElemInfo{ - TNodeInfo(const PMeshInfo& theMeshInfo, - med_int theNbElem, - med_repere theSystem = MED_CART, - med_booleen theIsElemNum = MED_VRAI, - med_booleen theIsElemNames = MED_VRAI); - - TNodeInfo(const PMeshInfo& theMeshInfo, - med_repere theSystem, - const TFloatVector& theNodeCoords, - const TStringVector& theCoordNames, - const TStringVector& theCoordUnits, - const TIntVector& theFamilyNums, - const TIntVector& theElemNums, - const TStringVector& theElemNames = TStringVector()); - - TNodeCoord myCoord; - med_repere mySystem; - - TString myCoordNames; - string GetCoordName(med_int theId) const; - void SetCoordName(med_int theId, const string& theValue); - - TString myCoordUnits; - string GetCoordUnit(med_int theId) const; - void SetCoordUnit(med_int theId, const string& theValue); - }; - - -//--------------------------------------------------------------- - struct TCellInfo: TElemInfo{ - TCellInfo(const PMeshInfo& theMeshInfo, - med_int theNbElem, - med_entite_maillage theTEntity, - med_geometrie_element theTGeom, - med_connectivite theTConn = MED_NOD, - med_booleen theIsElemNum = MED_VRAI, - med_booleen theIsElemNames = MED_VRAI); - - TCellInfo(const PMeshInfo& theMeshInfo, - med_entite_maillage theTEntity, - med_geometrie_element theTGeom, - med_connectivite theTConn, - const TIntVector& theConnectivities, - const TIntVector& theFamilyNums, - const TIntVector& theElemNums, - const TStringVector& theElemNames = TStringVector()); - - med_entite_maillage myTEntity; - med_geometrie_element myTGeom; - med_connectivite myTConn; - - med_int myConnDim; - TElemNum myConn; - }; - - -//--------------------------------------------------------------- - struct TFieldInfo: TNameInfo{ - TFieldInfo(const PMeshInfo& theMeshInfo, - med_int theNbComp = 0, - med_type_champ theType = MED_REEL64, - const string& theValue = ""); - - PMeshInfo myMeshInfo; - med_type_champ myType; - med_int myNbComp; - - TString myCompNames; - string GetCompName(med_int theId) const; - void SetCompName(med_int theId, const string& theValue); - - TString myUnitNames; - string GetUnitName(med_int theId) const; - void SetUnitName(med_int theId, const string& theValue); - }; - - -//--------------------------------------------------------------- - struct TTimeStampInfo{ - TTimeStampInfo(const PFieldInfo& theFieldInfo, - med_entite_maillage theEntity, - const TGeom& theGeom); - - PFieldInfo myFieldInfo; - med_entite_maillage myEntity; - TGeom myGeom; - - med_int myNbGauss, myNumDt, myNumOrd; - med_float myDt; - - TString myUnitDt; - string GetUnitDt() const; - void SetUnitDt(const string& theValue); - }; - - - typedef valarray TValue; - typedef map TMeshValue; -//--------------------------------------------------------------- - struct TTimeStampVal{ - TTimeStampVal(const PTimeStampInfo& theTimeStampInfo); - - PTimeStampInfo myTimeStampInfo; - TMeshValue myMeshValue; - - TString myPflName; - string GetPflName() const; - void SetPflName(const string& theValue); - }; - -}; - - -#endif diff --git a/src/MEDWrapper/MED_Test.cxx b/src/MEDWrapper/MED_Test.cxx deleted file mode 100644 index adc7477d1..000000000 --- a/src/MEDWrapper/MED_Test.cxx +++ /dev/null @@ -1,186 +0,0 @@ -// VISU OBJECT : interactive object for VISU entities implementation -// -// 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: VISUConvertor.cxx -// Author: Alexey PETROV -// Module : VISU - -#include "MED_Structures.hxx" -#include "MED_Wrapper.hxx" -#include "MED_Utilities.hxx" - -using namespace std; - -#ifdef DEBUG -static int MYDEBUG = 1; -#else -static int MYDEBUG = 0; -#endif - - -void ReadMed(const char* theFileName){ - using namespace MED; - TWrapper aMed(theFileName); - string aFileName = theFileName; - aFileName += "-"; - TWrapper aMedW(aFileName); - - int aNbMeshes = aMed.GetNbMeshes(); - MESSAGE("GetNbMeshes() = "<myDim; - aName = aMeshInfo->GetName(); - MESSAGE("GetMeshInfo - aName = '"<SetGroupName(iGroup,aName); - } - - aMedW.SetFamilyInfo(*aFamilyInfo); - } - - MESSAGE("GetEntityInfo - aNbEntities = "<first; - MESSAGE("\tanEntity = "<myCoord; - for(int iNode = 0; iNode < aNbNodes; iNode++){ - for(int iDim = 0, anId = iNode*aDim; iDim < aDim; iDim++, anId++){ - //MESSAGE(aCoord[anId]<<","); - aCoord[anId] += 1.0; - } - //MESSAGE(" "); - } - MESSAGE(endl); - aNodeInfo->myMeshInfo = aNewMeshInfo; - aMedW.SetNodeInfo(*aNodeInfo); - continue; - } - TGeom& aTGeom = anEntityInfoIter->second; - TGeom::iterator anTGeomIter = aTGeom.begin(); - for(; anTGeomIter != aTGeom.end(); anTGeomIter++){ - const med_geometrie_element& aGeom = anTGeomIter->first; - med_int& aNbElem = anTGeomIter->second; - MESSAGE("\t\taGeom = "<myNbElem; iElem++){ - int i = iElem*aCellInfo->myConnDim; - for(int iConn = 0; iConn < aCellInfo->myConnDim; iConn++, i++){ - //MESSAGE(aCellInfo->myConn[i]<<","); - } - //MESSAGE(" "); - } - MESSAGE(endl); - aCellInfo->myMeshInfo = aNewMeshInfo; - aMedW.SetCellInfo(*aCellInfo); - } - } - - } - MESSAGE("OK"); -} - - -int main(int argc, char** argv){ - try{ - if(argc > 1) - ReadMed(argv[1]); - return 0; - }catch(std::exception& exc){ - MESSAGE("Follow exception was accured :\n"< -#include -#include -#include - - -namespace MED{ - using namespace std; - class PrefixPrinter{ - static int myCounter; - public: - PrefixPrinter(); - ~PrefixPrinter(); - - static string GetPrefix(); - }; -}; - - -#ifndef MESSAGE - -#define MESSAGE(msg) std::cout<<__FILE__<<"["<<__LINE__<<"]::"<(theInfo); - ret = MEDmaaCr(myFile.Id(), - &anInfo.myName[0], - anInfo.myDim); - }catch(...){} - if(ret < 0){ - TFileWrapper aFileWrapper(myFile,MED_REMP); - - TMeshInfo& anInfo = const_cast(theInfo); - ret = MEDmaaCr(myFile.Id(), - &anInfo.myName[0], - anInfo.myDim); - } - if(ret < 0) - EXCEPTION(runtime_error,"SetMeshInfo - MEDmaaCr(...)"); -} - - -med_int TWrapper::GetNbFamilies(const TMeshInfo& theInfo){ - TFileWrapper aFileWrapper(myFile,MED_LECT); - - TMeshInfo& anInfo = const_cast(theInfo); - return MEDnFam(myFile.Id(), - &anInfo.myName[0], - 0, - MED_FAMILLE); -} - - -med_int TWrapper::GetNbFamAttr(med_int theFamId, const TMeshInfo& theInfo){ - TFileWrapper aFileWrapper(myFile,MED_LECT); - - TMeshInfo& anInfo = const_cast(theInfo); - return MEDnFam(myFile.Id(), - &anInfo.myName[0], - theFamId, - MED_ATTR); -} - - -med_int TWrapper::GetNbFamGroup(med_int theFamId, const TMeshInfo& theInfo){ - TFileWrapper aFileWrapper(myFile,MED_LECT); - - TMeshInfo& anInfo = const_cast(theInfo); - return MEDnFam(myFile.Id(), - &anInfo.myName[0], - theFamId, - MED_GROUPE); -} - - -void TWrapper::GetFamilyInfo(med_int theFamId, TFamilyInfo& theInfo){ - TFileWrapper aFileWrapper(myFile,MED_LECT); - - TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; - - med_err ret = MEDfamInfo(myFile.Id(), - &aMeshInfo.myName[0], - theFamId, - &theInfo.myName[0], - &theInfo.myId, - &theInfo.myAttrId[0], - &theInfo.myAttrVal[0], - &theInfo.myAttrDesc[0], - &theInfo.myNbAttr, - &theInfo.myGroupNames[0], - &theInfo.myNbGroup); - if(ret < 0) - EXCEPTION(runtime_error,"GetFamilyInfo - MEDfamInfo(...)"); -} - - -void TWrapper::SetFamilyInfo(const TFamilyInfo& theInfo){ - TFileWrapper aFileWrapper(myFile,MED_ECRI); - - TFamilyInfo& anInfo = const_cast(theInfo); - TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; - - med_err ret = MEDfamCr(myFile.Id(), - &aMeshInfo.myName[0], - &anInfo.myName[0], - anInfo.myId, - &anInfo.myAttrId[0], - &anInfo.myAttrVal[0], - &anInfo.myAttrDesc[0], - anInfo.myNbAttr, - &anInfo.myGroupNames[0], - anInfo.myNbGroup); - if(ret < 0) - EXCEPTION(runtime_error,"SetFamilyInfo - MEDfamCr(...)"); -} - - -med_int TWrapper::GetNbNodes(const TMeshInfo& theMeshInfo){ - TFileWrapper aFileWrapper(myFile,MED_LECT); - - TMeshInfo& aMeshInfo = const_cast(theMeshInfo); - - return MEDnEntMaa(myFile.Id(), - &aMeshInfo.myName[0], - MED_COOR,MED_NOEUD, - med_geometrie_element(0), - med_connectivite(0)); -} - - -void TWrapper::GetNodeInfo(TNodeInfo& theInfo){ - TFileWrapper aFileWrapper(myFile,MED_LECT); - - TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; - - med_err ret = MEDnoeudsLire(myFile.Id(), - &aMeshInfo.myName[0], - aMeshInfo.myDim, - &theInfo.myCoord[0], - MED_FULL_INTERLACE, - &theInfo.mySystem, - &theInfo.myCoordNames[0], - &theInfo.myCoordUnits[0], - &theInfo.myElemNames[0], - &theInfo.myIsElemNames, - &theInfo.myElemNum[0], - &theInfo.myIsElemNum, - &theInfo.myFamNum[0], - theInfo.myNbElem); - if(ret < 0) - EXCEPTION(runtime_error,"GetNodeInfo - MEDnoeudsLire(...)"); -} - - -void TWrapper::SetNodeInfo(const TNodeInfo& theInfo) -{ - TFileWrapper aFileWrapper(myFile,MED_ECRI); - - TNodeInfo& anInfo = const_cast(theInfo); - TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; - - med_err ret = MEDnoeudsEcr(myFile.Id(), - &aMeshInfo.myName[0], - aMeshInfo.myDim, - &anInfo.myCoord[0], - MED_FULL_INTERLACE, - anInfo.mySystem, - &anInfo.myCoordNames[0], - &anInfo.myCoordUnits[0], - &anInfo.myElemNames[0], - anInfo.myIsElemNames, - &anInfo.myElemNum[0], - anInfo.myIsElemNum, - &anInfo.myFamNum[0], - anInfo.myNbElem, - MED_REMP); - if(ret < 0) - EXCEPTION(runtime_error,"SetNodeInfo - MEDnoeudsEcr(...)"); -} - - -TEntityInfo TWrapper::GetEntityInfo(const TMeshInfo& theMeshInfo){ - TFileWrapper aFileWrapper(myFile,MED_LECT); - - TEntityInfo anInfo; - if(med_int aNbElem = GetNbNodes(theMeshInfo)){ - anInfo[MED_NOEUD][MED_POINT1] = aNbElem; - med_entite_maillage anEntityVector[3] = {MED_MAILLE, MED_FACE, MED_ARETE}; - for(med_int iEntity = 0; iEntity < 3; iEntity++){ - med_int iGeomEnd; - med_entite_maillage& anEntity = anEntityVector[iEntity]; - med_geometrie_element* aGeomVector; - GetEntity2Geom(anEntity,aGeomVector,&iGeomEnd); - for(med_int iGeom = 0; iGeom < iGeomEnd; iGeom++) { - med_geometrie_element& aGeom = aGeomVector[iGeom]; - if(med_int aNb = GetNbCells(theMeshInfo,anEntity,aGeom)){ - anInfo[anEntity][aGeom] = aNb; - } - } - } - } - return anInfo; -} - - -med_int TWrapper::GetNbCells(const TMeshInfo& theMeshInfo, - med_entite_maillage theTEntity, - med_geometrie_element theTGeom, - med_connectivite theTConn) -{ - TFileWrapper aFileWrapper(myFile,MED_LECT); - - TMeshInfo& aMeshInfo = const_cast(theMeshInfo); - - return MEDnEntMaa(myFile.Id(), - &aMeshInfo.myName[0], - MED_CONN, - theTEntity, - theTGeom, - theTConn); -} - - -void TWrapper::GetCellInfo(TCellInfo& theInfo) -{ - TFileWrapper aFileWrapper(myFile,MED_LECT); - - TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; - med_int aNbElem = theInfo.myElemNum.size(); - - med_err ret = MEDelementsLire(myFile.Id(), - &aMeshInfo.myName[0], - aMeshInfo.myDim, - &theInfo.myConn[0], - MED_FULL_INTERLACE, - &theInfo.myElemNames[0], - &theInfo.myIsElemNames, - &theInfo.myElemNum[0], - &theInfo.myIsElemNum, - &theInfo.myFamNum[0], - aNbElem, - theInfo.myTEntity, - theInfo.myTGeom, - theInfo.myTConn); - if(ret < 0) - EXCEPTION(runtime_error,"GetCellInfo - MEDelementsLire(...)"); -} - - -void TWrapper::SetCellInfo(const TCellInfo& theInfo) -{ - TFileWrapper aFileWrapper(myFile,MED_ECRI); - - TCellInfo& anInfo = const_cast(theInfo); - TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; - med_int aNbElem = anInfo.myElemNum.size(); - - med_err ret = MEDelementsEcr(myFile.Id(), - &aMeshInfo.myName[0], - aMeshInfo.myDim, - &anInfo.myConn[0], - MED_FULL_INTERLACE, - &anInfo.myElemNames[0], - anInfo.myIsElemNames, - &anInfo.myElemNum[0], - anInfo.myIsElemNum, - &anInfo.myFamNum[0], - anInfo.myNbElem, - anInfo.myTEntity, - anInfo.myTGeom, - anInfo.myTConn, - MED_REMP); - - if(ret < 0) - EXCEPTION(runtime_error,"GetCellInfo - MEDelementsLire(...)"); -} - - -med_int TWrapper::GetNbFields(){ - TFileWrapper aFileWrapper(myFile,MED_LECT); - - return MEDnChamp(myFile.Id(),0); -} - - -med_int TWrapper::GetNbComp(med_int theFieldId){ - TFileWrapper aFileWrapper(myFile,MED_LECT); - - return MEDnChamp(myFile.Id(),theFieldId); -} - - -void TWrapper::GetFieldInfo(med_int theFieldId, TFieldInfo& theInfo){ - TFileWrapper aFileWrapper(myFile,MED_LECT); - - med_err ret = MEDchampInfo(myFile.Id(), - theFieldId, - &theInfo.myName[0], - &theInfo.myType, - &theInfo.myCompNames[0], - &theInfo.myUnitNames[0], - theInfo.myNbComp); - if(ret < 0) - EXCEPTION(runtime_error,"GetFieldInfo - MEDchampInfo(...)"); -} - - -void TWrapper::SetFieldInfo(const TFieldInfo& theInfo) -{ - TFileWrapper aFileWrapper(myFile,MED_ECRI); - - TFieldInfo& anInfo = const_cast(theInfo); - med_err ret = MEDchampCr(myFile.Id(), - &anInfo.myName[0], - anInfo.myType, - &anInfo.myCompNames[0], - &anInfo.myUnitNames[0], - anInfo.myNbComp); - if(ret < 0) - EXCEPTION(runtime_error,"SetFieldInfo - MEDchampEcr(...)"); -} - - -med_int TWrapper::GetNbTimeStamps(const TFieldInfo& theInfo, - const TEntityInfo& theEntityInfo, - med_entite_maillage& theEntity, - TGeom& theGeom) -{ - TFileWrapper aFileWrapper(myFile,MED_LECT); - - if(theEntityInfo.empty()) - EXCEPTION(runtime_error,"GetNbTimeStamps - There is no any Entity on the Mesh"); - - theGeom.clear(); - med_int aNbTimeStamps = 0; - TFieldInfo& anInfo = const_cast(theInfo); - TEntityInfo::const_iterator anIter = theEntityInfo.begin(); - for(; anIter != theEntityInfo.end(); anIter++){ - const med_entite_maillage& anEntity = anIter->first; - const TGeom& aTGeom = anIter->second; - TGeom::const_iterator anGeomIter = aTGeom.begin(); - for(; anGeomIter != aTGeom.end(); anGeomIter++){ - const med_geometrie_element& aGeom = anGeomIter->first; - aNbTimeStamps = MEDnPasdetemps(myFile.Id(),&anInfo.myName[0],anEntity,aGeom); - if(aNbTimeStamps){ - theEntity = anEntity; - theGeom[aGeom] = anGeomIter->second; - } - } - if(aNbTimeStamps) break; - } - return aNbTimeStamps; -} - - -void TWrapper::GetTimeStampInfo(med_int theTimeStampId, TTimeStampInfo& theInfo) -{ - TFileWrapper aFileWrapper(myFile,MED_LECT); - med_idt anId = myFile.Id(); - - TFieldInfo& aFieldInfo = *theInfo.myFieldInfo; - TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo; - - med_entite_maillage anEntity = theInfo.myEntity; - TGeom& aTGeom = theInfo.myGeom; - if(aTGeom.empty()) - EXCEPTION(runtime_error,"GetTimeStampInfo - There is no any cell"); - - TGeom::iterator anIter = aTGeom.begin(); - med_geometrie_element aGeom = anIter->first; - - med_err ret = MEDpasdetempsInfo(anId, - &aFieldInfo.myName[0], - anEntity, - aGeom, - theTimeStampId, - &aMeshInfo.myName[0], - &theInfo.myNbGauss, - &theInfo.myNumDt, - &theInfo.myUnitDt[0], - &theInfo.myDt, - &theInfo.myNumOrd); - if(ret < 0) - EXCEPTION(runtime_error,"GetTimeStampInfo - MEDpasdetempsInfo(...)"); - - static med_int MAX_NB_GAUSS_POINTS = 32; - if(theInfo.myNbGauss > MAX_NB_GAUSS_POINTS) - theInfo.myNbGauss = 1; -} - -void TWrapper::SetTimeStamp(const TTimeStampVal& theVal) -{ - TFileWrapper aFileWrapper(myFile,MED_ECRI); - - TTimeStampVal& aVal = const_cast(theVal); - TTimeStampInfo& aTimeStampInfo = *aVal.myTimeStampInfo; - TFieldInfo& aFieldInfo = *aTimeStampInfo.myFieldInfo; - TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo; - TMeshValue& aMeshValue = aVal.myMeshValue; - - med_entite_maillage anEntity = aTimeStampInfo.myEntity; - TMeshValue::iterator anIter = aMeshValue.begin(); - for(; anIter != aMeshValue.end(); anIter++){ - const med_geometrie_element& aGeom = anIter->first; - TValue& aValue = aVal.myMeshValue[aGeom]; - med_int iEnd = aValue.size(); - med_int aNbVal = iEnd / aFieldInfo.myNbComp; - - med_err ret; - switch(aFieldInfo.myType){ - case MED_REEL64: { - valarray& anArray = aValue; - - ret = MEDchampEcr(myFile.Id(), - &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; - } - case MED_INT32: - case MED_INT: { - valarray anArray(iEnd); - for(med_int i = 0; i< iEnd; i++) anArray[i] = med_int(aValue[i]); - - ret = MEDchampEcr(myFile.Id(), - &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: - EXCEPTION(runtime_error,"SetTimeStamp - Type of the field == "<first; - med_int aNbVal = MEDnVal(anId,&aFieldInfo.myName[0],anEntity,aGeom, - aTimeStampInfo.myNumDt,aTimeStampInfo.myNumOrd); - if(aNbVal <= 0) - EXCEPTION(runtime_error,"GetTimeStampInfo - MEDnVal(...) - aNbVal == "< -} -#include "MED_Structures.hxx" - - -namespace MED{ -//--------------------------------------------------------------- - class TFile{ - TFile(); - TFile(const TFile&); - public: - TFile(const string& theFileName); - ~TFile(); - - void Open(med_mode_acces theMode); - const med_idt& Id() const; - void Close(); - - protected: - char* myFileName; - med_idt myFid; - int myCount; - }; - - -//--------------------------------------------------------------- - class TFileWrapper{ - TFile& myFile; - public: - TFileWrapper(TFile& theFile, med_mode_acces theMode): - myFile(theFile) - { - myFile.Open(theMode); - } - - ~TFileWrapper(){ - myFile.Close(); - } - }; - - -//--------------------------------------------------------------- - class TWrapper{ - TWrapper(); - TWrapper(const TWrapper&); - - public: - TWrapper(const string& theFileName); - - - //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - med_int GetNbMeshes(); - - void GetMeshInfo(med_int theMeshId, TMeshInfo&); - void SetMeshInfo(const TMeshInfo& theInfo); - - - //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - med_int GetNbFamilies(const TMeshInfo& theMeshInfo); - med_int GetNbFamAttr(med_int theFamId, const TMeshInfo& theInfo); - med_int GetNbFamGroup(med_int theFamId, const TMeshInfo& theInfo); - - void GetFamilyInfo(med_int theFamId, TFamilyInfo& theInfo); - void SetFamilyInfo(const TFamilyInfo& theInfo); - - - //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - med_int GetNbNodes(const TMeshInfo& theMeshInfo); - - void GetNodeInfo(TNodeInfo&); - void SetNodeInfo(const TNodeInfo&); - - - //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - TEntityInfo GetEntityInfo(const TMeshInfo& theMeshInfo); - - med_int GetNbCells(const TMeshInfo& theMeshInfo, - med_entite_maillage, - med_geometrie_element, - med_connectivite theTConn = MED_NOD); - - void GetCellInfo(TCellInfo& theInfo); - void SetCellInfo(const TCellInfo& theInfo); - - - //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - med_int GetNbFields(); - - med_int GetNbComp(med_int theFieldId); - - void GetFieldInfo(med_int theFieldId, TFieldInfo& theInfo); - void SetFieldInfo(const TFieldInfo& theInfo); - - - //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - med_int GetNbTimeStamps(const TFieldInfo& theInfo, - const TEntityInfo& theEntityInfo, - med_entite_maillage& theEntity, - TGeom& theGeom); - - void GetTimeStampInfo(med_int theTimeStampId, TTimeStampInfo&); - - void GetTimeStampVal(TTimeStampVal& theTimeStampVal); - - void SetTimeStamp(const TTimeStampVal& theTimeStampVal); - - protected: - TFile myFile; - }; - -}; - -#endif diff --git a/src/MEDWrapper/Makefile.in b/src/MEDWrapper/Makefile.in index 71cbd7cbd..c6a625e10 100644 --- a/src/MEDWrapper/Makefile.in +++ b/src/MEDWrapper/Makefile.in @@ -1,4 +1,4 @@ -# VISU OBJECT : interactive object for VISU entities implementation +# # # Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS @@ -21,8 +21,10 @@ # # # -# File : Makefile.in -# Module : VISU +# File : +# Author : +# Module : +# $Header$ top_srcdir=@top_srcdir@ top_builddir=../.. @@ -32,20 +34,6 @@ VPATH=.:@srcdir@:@top_srcdir@/idl @COMMENCE@ -EXPORT_HEADERS = MED_Common.hxx MED_Utilities.hxx MEDA_Structures.hxx MEDA_Wrapper.hxx MEDA_Algorithm.hxx +SUBDIRS = Base V2_1 V2_2 Factory -# Libraries targets - -LIB = libMEDWrapper.la -LIB_SRC = MED_Structures.cxx MED_Wrapper.cxx MED_Utilities.cxx \ - MEDA_Structures.cxx MEDA_Wrapper.cxx MEDA_Algorithm.cxx - -# Executables targets -BIN = MED_Test MEDA_Test MEDA_Test1 -BIN_SRC = - -CPPFLAGS+= $(BOOST_CPPFLAGS) $(MED2_INCLUDES) - -LDFLAGS+= $(MED2_LIBS) $(HDF5_LIBS) - -@CONCLUDE@ +@MODULE@ diff --git a/src/MEDWrapper/V2_1/MED1cstring.cxx b/src/MEDWrapper/V2_1/MED1cstring.cxx new file mode 100644 index 000000000..0b1595241 --- /dev/null +++ b/src/MEDWrapper/V2_1/MED1cstring.cxx @@ -0,0 +1,61 @@ +/************************************************************************* +* 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], + &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], + &theInfo.myId, + &theInfo.myAttrId[0], + &theInfo.myAttrVal[0], + &theInfo.myAttrDesc[0], + &theInfo.myNbAttr, + &theInfo.myGroupNames[0], + &theInfo.myNbGroup); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"GetFamilyInfo - MEDfamInfo - "<< + "&aMeshInfo.myName[0] = '"<<&aMeshInfo.myName[0]<<"'; "<< + "theFamId = "<(theMeshInfo); + + return MEDnEntMaa(myFile->Id(), + &aMeshInfo.myName[0], + MED_COOR, + MED_NOEUD, + med_geometrie_element(0), + med_connectivite(0)); + } + + + void TVWrapper::GetNodeInfo(MED::TNodeInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECT,theErr); + + if(theErr && *theErr < 0) + return; + + MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; + + med_repere& aRepere = static_cast(theInfo.mySystem); + med_booleen& anIsElemNames = static_cast(theInfo.myIsElemNames); + med_booleen& anIsElemNum = static_cast(theInfo.myIsElemNum); + + TErr aRet = MEDnoeudsLire(myFile->Id(), + &aMeshInfo.myName[0], + aMeshInfo.myDim, + &theInfo.myCoord[0], + MED_FULL_INTERLACE, + &aRepere, + &theInfo.myCoordNames[0], + &theInfo.myCoordUnits[0], + &theInfo.myElemNames[0], + &anIsElemNames, + &theInfo.myElemNum[0], + &anIsElemNum, + &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; + + med_repere& aRepere = static_cast(theInfo.mySystem); + med_booleen& anIsElemNames = static_cast(theInfo.myIsElemNames); + med_booleen& anIsElemNum = static_cast(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, + &anInfo.myElemNum[0], + anIsElemNum, + &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; + + if(TInt aNbElem = GetNbNodes(theMeshInfo)){ + 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; + if(TInt aNb = GetNbCells(theMeshInfo,anEntity,aGeom,theTConn,theErr)){ + anInfo[anEntity][aGeom] = aNb; + } + } + } + } + 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 = static_cast(theTEntity); + med_geometrie_element& aGeom = static_cast(theTGeom); + med_connectivite& aConn = static_cast(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 = static_cast(theInfo.myIsElemNames); + med_booleen& anIsElemNum = static_cast(theInfo.myIsElemNum); + med_entite_maillage& anEntity = static_cast(theInfo.myTEntity); + med_geometrie_element& aGeom = static_cast(theInfo.myTGeom); + med_connectivite& aConn = static_cast(theInfo.myTConn); + + TErr aRet = MEDelementsLire(myFile->Id(), + &aMeshInfo.myName[0], + aMeshInfo.myDim, + &theInfo.myConn[0], + MED_FULL_INTERLACE, + &theInfo.myElemNames[0], + &anIsElemNames, + &theInfo.myElemNum[0], + &anIsElemNum, + &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 = static_cast(theInfo.myIsElemNames); + med_booleen& anIsElemNum = static_cast(theInfo.myIsElemNum); + med_entite_maillage& anEntity = static_cast(theInfo.myTEntity); + med_geometrie_element& aGeom = static_cast(theInfo.myTGeom); + med_connectivite& aConn = static_cast(theInfo.myTConn); + + TErr aRet = MEDelementsEcr(myFile->Id(), + &aMeshInfo.myName[0], + aMeshInfo.myDim, + &anInfo.myConn[0], + MED_FULL_INTERLACE, + &anInfo.myElemNames[0], + anIsElemNames, + &anInfo.myElemNum[0], + anIsElemNum, + &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 = static_cast(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 = static_cast(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 = static_cast(anIter->first); + const TGeom& aTGeom = anIter->second; + TGeom::const_iterator anGeomIter = aTGeom.begin(); + for(; anGeomIter != aTGeom.end(); anGeomIter++){ + const med_geometrie_element& aGeom = static_cast(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){ + *theErr &= !aTGeom.empty(); + if(!*theErr) + return; + } + + 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 = static_cast(theInfo.myEntity); + + TGeom::iterator anIter = aTGeom.begin(); + med_geometrie_element& aGeom = static_cast(anIter->first); + + TErr aRet = MEDpasdetempsInfo(myFile->Id(), + &aFieldInfo.myName[0], + anEntity, + aGeom, + theTimeStampId, + &aMeshInfo.myName[0], + &theInfo.myNbGauss, + &theInfo.myNumDt, + &theInfo.myUnitDt[0], + &theInfo.myDt, + &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 > 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 = static_cast(aTimeStampInfo.myEntity); + TGeom& aTGeom = aTimeStampInfo.myGeom; + TGeom::iterator anIter = aTGeom.begin(); + for(; anIter != aTGeom.end(); anIter++){ + med_geometrie_element& aGeom = static_cast(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 = static_cast(aTimeStampInfo.myEntity); + TMeshValue::iterator anIter = aMeshValue.begin(); + for(; anIter != aMeshValue.end(); anIter++){ + med_geometrie_element& aGeom = static_cast(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 new file mode 100644 index 000000000..6a7b708e0 --- /dev/null +++ b/src/MEDWrapper/V2_1/MEDattrFermer.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 : _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 new file mode 100644 index 000000000..51ae76e11 --- /dev/null +++ b/src/MEDWrapper/V2_1/MEDattrNumEcrire.cxx @@ -0,0 +1,107 @@ +/************************************************************************* +* 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 new file mode 100644 index 000000000..12299c5a7 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDattrOuvrir.cxx b/src/MEDWrapper/V2_1/MEDattrOuvrir.cxx new file mode 100644 index 000000000..bcf6be527 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDattrStringEcrire.cxx b/src/MEDWrapper/V2_1/MEDattrStringEcrire.cxx new file mode 100644 index 000000000..128336808 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDattrStringLire.cxx b/src/MEDWrapper/V2_1/MEDattrStringLire.cxx new file mode 100644 index 000000000..764b9e2f6 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDbodyFittedEcr.cxx b/src/MEDWrapper/V2_1/MEDbodyFittedEcr.cxx new file mode 100644 index 000000000..c7d84f46a --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDchampCr.cxx b/src/MEDWrapper/V2_1/MEDchampCr.cxx new file mode 100644 index 000000000..13fe5520a --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDchampEcr.cxx b/src/MEDWrapper/V2_1/MEDchampEcr.cxx new file mode 100644 index 000000000..14f5090bc --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDchampLire.cxx b/src/MEDWrapper/V2_1/MEDchampLire.cxx new file mode 100644 index 000000000..ad21a6840 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDconnEcr.cxx b/src/MEDWrapper/V2_1/MEDconnEcr.cxx new file mode 100644 index 000000000..a8395b5c2 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDconnLire.cxx b/src/MEDWrapper/V2_1/MEDconnLire.cxx new file mode 100644 index 000000000..9e6c29f48 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDcoordLire.cxx b/src/MEDWrapper/V2_1/MEDcoordLire.cxx new file mode 100644 index 000000000..1335f1a1b --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDdatagroupCreer.cxx b/src/MEDWrapper/V2_1/MEDdatagroupCreer.cxx new file mode 100644 index 000000000..4b9170479 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDdatagroupFermer.cxx b/src/MEDWrapper/V2_1/MEDdatagroupFermer.cxx new file mode 100644 index 000000000..b48ea41c9 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDdatagroupOuvrir.cxx b/src/MEDWrapper/V2_1/MEDdatagroupOuvrir.cxx new file mode 100644 index 000000000..89cdbe4f7 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDdatasetFermer.cxx b/src/MEDWrapper/V2_1/MEDdatasetFermer.cxx new file mode 100644 index 000000000..7694e052e --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDdatasetNumEcrire.cxx b/src/MEDWrapper/V2_1/MEDdatasetNumEcrire.cxx new file mode 100644 index 000000000..85fb2a7b2 --- /dev/null +++ b/src/MEDWrapper/V2_1/MEDdatasetNumEcrire.cxx @@ -0,0 +1,373 @@ +/************************************************************************* +* 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 : _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 new file mode 100644 index 000000000..8195e36a7 --- /dev/null +++ b/src/MEDWrapper/V2_1/MEDdatasetNumLire.cxx @@ -0,0 +1,349 @@ +/************************************************************************* +* 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 : _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 new file mode 100644 index 000000000..b3e852cd1 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDdatasetStringEcrire.cxx b/src/MEDWrapper/V2_1/MEDdatasetStringEcrire.cxx new file mode 100644 index 000000000..651f5a84d --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDdatasetStringLire.cxx b/src/MEDWrapper/V2_1/MEDdatasetStringLire.cxx new file mode 100644 index 000000000..017ccbf7b --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDdimLire.cxx b/src/MEDWrapper/V2_1/MEDdimLire.cxx new file mode 100644 index 000000000..3ca50c61f --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDelementsEcr.cxx b/src/MEDWrapper/V2_1/MEDelementsEcr.cxx new file mode 100644 index 000000000..e67b44d38 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDelementsLire.cxx b/src/MEDWrapper/V2_1/MEDelementsLire.cxx new file mode 100644 index 000000000..bdd85909e --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDequivCr.cxx b/src/MEDWrapper/V2_1/MEDequivCr.cxx new file mode 100644 index 000000000..a5a3b816d --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDequivEcr.cxx b/src/MEDWrapper/V2_1/MEDequivEcr.cxx new file mode 100644 index 000000000..dfa3f72b1 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDequivInfo.cxx b/src/MEDWrapper/V2_1/MEDequivInfo.cxx new file mode 100644 index 000000000..e031dec8a --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDequivLire.cxx b/src/MEDWrapper/V2_1/MEDequivLire.cxx new file mode 100644 index 000000000..824e21c99 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDfam2groA.cxx b/src/MEDWrapper/V2_1/MEDfam2groA.cxx new file mode 100644 index 000000000..b964f813a --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDfam2groB.cxx b/src/MEDWrapper/V2_1/MEDfam2groB.cxx new file mode 100644 index 000000000..3dbea6071 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDfamEcr.cxx b/src/MEDWrapper/V2_1/MEDfamEcr.cxx new file mode 100644 index 000000000..e6beb4bf9 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDfamGridEcr.cxx b/src/MEDWrapper/V2_1/MEDfamGridEcr.cxx new file mode 100644 index 000000000..be590c651 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDfamGridLire.cxx b/src/MEDWrapper/V2_1/MEDfamGridLire.cxx new file mode 100644 index 000000000..2f89144e9 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDfamInfo.cxx b/src/MEDWrapper/V2_1/MEDfamInfo.cxx new file mode 100644 index 000000000..b4527b122 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDfamLire.cxx b/src/MEDWrapper/V2_1/MEDfamLire.cxx new file mode 100644 index 000000000..501b98f7c --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDfamMaaCr.cxx b/src/MEDWrapper/V2_1/MEDfamMaaCr.cxx new file mode 100644 index 000000000..f7dc6d2b4 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDfamMaaInfo.cxx b/src/MEDWrapper/V2_1/MEDfamMaaInfo.cxx new file mode 100644 index 000000000..9868abfbd --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDfamMaaLire.cxx b/src/MEDWrapper/V2_1/MEDfamMaaLire.cxx new file mode 100644 index 000000000..ed3401a9b --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDfichEntete.cxx b/src/MEDWrapper/V2_1/MEDfichEntete.cxx new file mode 100644 index 000000000..b191d3a4a --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDfichierCreer.cxx b/src/MEDWrapper/V2_1/MEDfichierCreer.cxx new file mode 100644 index 000000000..dd72e8b4b --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDfichierFermer.cxx b/src/MEDWrapper/V2_1/MEDfichierFermer.cxx new file mode 100644 index 000000000..c0024e544 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDfichierOuvrir.cxx b/src/MEDWrapper/V2_1/MEDfichierOuvrir.cxx new file mode 100644 index 000000000..593fbd675 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDformatConforme.cxx b/src/MEDWrapper/V2_1/MEDformatConforme.cxx new file mode 100644 index 000000000..d5ddea8b3 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDfstring.cxx b/src/MEDWrapper/V2_1/MEDfstring.cxx new file mode 100644 index 000000000..e1bc4faae --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDgridEcr.cxx b/src/MEDWrapper/V2_1/MEDgridEcr.cxx new file mode 100644 index 000000000..3acc181ee --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDgridInfo.cxx b/src/MEDWrapper/V2_1/MEDgridInfo.cxx new file mode 100644 index 000000000..43de1b2dd --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDgridLire.cxx b/src/MEDWrapper/V2_1/MEDgridLire.cxx new file mode 100644 index 000000000..032266335 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDgro2famA.cxx b/src/MEDWrapper/V2_1/MEDgro2famA.cxx new file mode 100644 index 000000000..5838900ea --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDmaaCr.cxx b/src/MEDWrapper/V2_1/MEDmaaCr.cxx new file mode 100644 index 000000000..c4b50b717 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDmaaInfo.cxx b/src/MEDWrapper/V2_1/MEDmaaInfo.cxx new file mode 100644 index 000000000..e2b48a7cb --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDmodeErreurVerrouiller.cxx b/src/MEDWrapper/V2_1/MEDmodeErreurVerrouiller.cxx new file mode 100644 index 000000000..aa4eb0882 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnChamp.cxx b/src/MEDWrapper/V2_1/MEDnChamp.cxx new file mode 100644 index 000000000..55347ba5f --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnCorres.cxx b/src/MEDWrapper/V2_1/MEDnCorres.cxx new file mode 100644 index 000000000..10b583021 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnEntMaa.cxx b/src/MEDWrapper/V2_1/MEDnEntMaa.cxx new file mode 100644 index 000000000..7f9cfbdc4 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnEntites.cxx b/src/MEDWrapper/V2_1/MEDnEntites.cxx new file mode 100644 index 000000000..b5b32c468 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnFam.cxx b/src/MEDWrapper/V2_1/MEDnFam.cxx new file mode 100644 index 000000000..3ac75795f --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnGrid.cxx b/src/MEDWrapper/V2_1/MEDnGrid.cxx new file mode 100644 index 000000000..607888cf2 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnMaa.cxx b/src/MEDWrapper/V2_1/MEDnMaa.cxx new file mode 100644 index 000000000..a7a8124b6 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnObjets.cxx b/src/MEDWrapper/V2_1/MEDnObjets.cxx new file mode 100644 index 000000000..6720f95f3 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnPasdetemps.cxx b/src/MEDWrapper/V2_1/MEDnPasdetemps.cxx new file mode 100644 index 000000000..6cad0ba8e --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnProfil.cxx b/src/MEDWrapper/V2_1/MEDnProfil.cxx new file mode 100644 index 000000000..5dcb6482f --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnVal.cxx b/src/MEDWrapper/V2_1/MEDnVal.cxx new file mode 100644 index 000000000..010c82636 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnValProfil.cxx b/src/MEDWrapper/V2_1/MEDnValProfil.cxx new file mode 100644 index 000000000..7c14cf2ed --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnbnoisEcr.cxx b/src/MEDWrapper/V2_1/MEDnbnoisEcr.cxx new file mode 100644 index 000000000..3c287ce7f --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnbnoisLire.cxx b/src/MEDWrapper/V2_1/MEDnbnoisLire.cxx new file mode 100644 index 000000000..363d66ffe --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnbnomaEcr.cxx b/src/MEDWrapper/V2_1/MEDnbnomaEcr.cxx new file mode 100644 index 000000000..2d635253f --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnbnomaLire.cxx b/src/MEDWrapper/V2_1/MEDnbnomaLire.cxx new file mode 100644 index 000000000..b018a0aa5 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnbnosoEcr.cxx b/src/MEDWrapper/V2_1/MEDnbnosoEcr.cxx new file mode 100644 index 000000000..453ebe29f --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnbnosoLire.cxx b/src/MEDWrapper/V2_1/MEDnbnosoLire.cxx new file mode 100644 index 000000000..7a1b67270 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnoeudsEcr.cxx b/src/MEDWrapper/V2_1/MEDnoeudsEcr.cxx new file mode 100644 index 000000000..808d25864 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnoeudsLire.cxx b/src/MEDWrapper/V2_1/MEDnoeudsLire.cxx new file mode 100644 index 000000000..68014ba9a --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnomDataset.cxx b/src/MEDWrapper/V2_1/MEDnomDataset.cxx new file mode 100644 index 000000000..fe72b24bb --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnomEcr.cxx b/src/MEDWrapper/V2_1/MEDnomEcr.cxx new file mode 100644 index 000000000..a71cf4757 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnomEntite.cxx b/src/MEDWrapper/V2_1/MEDnomEntite.cxx new file mode 100644 index 000000000..b5b4350fb --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnomGeometrie.cxx b/src/MEDWrapper/V2_1/MEDnomGeometrie.cxx new file mode 100644 index 000000000..3cbc6bbe0 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnomLire.cxx b/src/MEDWrapper/V2_1/MEDnomLire.cxx new file mode 100644 index 000000000..4ec85b304 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnumEcr.cxx b/src/MEDWrapper/V2_1/MEDnumEcr.cxx new file mode 100644 index 000000000..d72b6ce9f --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDnumLire.cxx b/src/MEDWrapper/V2_1/MEDnumLire.cxx new file mode 100644 index 000000000..938964060 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDobjetIdentifer.cxx b/src/MEDWrapper/V2_1/MEDobjetIdentifer.cxx new file mode 100644 index 000000000..14361bee5 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDouvrir.cxx b/src/MEDWrapper/V2_1/MEDouvrir.cxx new file mode 100644 index 000000000..0d259deb6 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDparametresGeometrie.cxx b/src/MEDWrapper/V2_1/MEDparametresGeometrie.cxx new file mode 100644 index 000000000..02a722f05 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDpasdetempsInfo.cxx b/src/MEDWrapper/V2_1/MEDpasdetempsInfo.cxx new file mode 100644 index 000000000..e95f6019c --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDprofilEcr.cxx b/src/MEDWrapper/V2_1/MEDprofilEcr.cxx new file mode 100644 index 000000000..b2d1e97b8 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDprofilInfo.cxx b/src/MEDWrapper/V2_1/MEDprofilInfo.cxx new file mode 100644 index 000000000..77f29687f --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDprofilLire.cxx b/src/MEDWrapper/V2_1/MEDprofilLire.cxx new file mode 100644 index 000000000..7621f82d8 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDunvCr.cxx b/src/MEDWrapper/V2_1/MEDunvCr.cxx new file mode 100644 index 000000000..a1bcd9843 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDunvLire.cxx b/src/MEDWrapper/V2_1/MEDunvLire.cxx new file mode 100644 index 000000000..f6ddc5f6b --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDversionConforme.cxx b/src/MEDWrapper/V2_1/MEDversionConforme.cxx new file mode 100644 index 000000000..764a9a83a --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDversionDonner.cxx b/src/MEDWrapper/V2_1/MEDversionDonner.cxx new file mode 100644 index 000000000..33a57726a --- /dev/null +++ b/src/MEDWrapper/V2_1/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/MEDversionLire.cxx b/src/MEDWrapper/V2_1/MEDversionLire.cxx new file mode 100644 index 000000000..b358d8357 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/Makefile.in b/src/MEDWrapper/V2_1/Makefile.in new file mode 100644 index 000000000..32939397b --- /dev/null +++ b/src/MEDWrapper/V2_1/Makefile.in @@ -0,0 +1,166 @@ +# +# +# 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 = 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 + +# Executables targets +BIN = mdump_V2_1 test1_V2_1 +BIN_SRC = + +CPPFLAGS+= $(BOOST_CPPFLAGS) $(HDF5_INCLUDES) -DPCLINUX + +LDFLAGS+= $(HDF5_LIBS) -lMEDWrapperBase + +@CONCLUDE@ diff --git a/src/MEDWrapper/V2_1/mdump_V2_1.cxx b/src/MEDWrapper/V2_1/mdump_V2_1.cxx new file mode 100644 index 000000000..6c959fde4 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/med.hxx b/src/MEDWrapper/V2_1/med.hxx new file mode 100644 index 000000000..2fe174f9a --- /dev/null +++ b/src/MEDWrapper/V2_1/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/med_hdfi.hxx b/src/MEDWrapper/V2_1/med_hdfi.hxx new file mode 100644 index 000000000..670ff63a9 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/med_misc.hxx b/src/MEDWrapper/V2_1/med_misc.hxx new file mode 100644 index 000000000..9e9676ec8 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/med_outils.hxx b/src/MEDWrapper/V2_1/med_outils.hxx new file mode 100644 index 000000000..b897a6219 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/med_proto.hxx b/src/MEDWrapper/V2_1/med_proto.hxx new file mode 100644 index 000000000..1847b56a8 --- /dev/null +++ b/src/MEDWrapper/V2_1/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/med_utils.hxx b/src/MEDWrapper/V2_1/med_utils.hxx new file mode 100644 index 000000000..0c16d650e --- /dev/null +++ b/src/MEDWrapper/V2_1/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/test1_V2_1.cxx b/src/MEDWrapper/V2_1/test1_V2_1.cxx new file mode 100644 index 000000000..20746cb11 --- /dev/null +++ b/src/MEDWrapper/V2_1/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_2/MED_V2_2_Wrapper.cxx b/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx new file mode 100644 index 000000000..2405e7743 --- /dev/null +++ b/src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx @@ -0,0 +1,945 @@ +// +// +// 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_2_Wrapper.hxx" +#include "MED_Utilities.hxx" + +extern "C"{ +#include +} + +#ifdef _DEBUG_ +static int MYDEBUG = 0; +#else +static int MYDEBUG = 0; +#endif + + + +namespace MED{ + namespace V2_2{ + + //--------------------------------------------------------------- + class TFile{ + TFile(); + TFile(const TFile&); + + public: + TFile(const std::string& theFileName): + myFid(0), + 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 > 0); + else if(myFid < 0) + EXCEPTION(runtime_error,"TFile - MEDouvrir('"<Open(theMode,theErr); + } + + ~TFileWrapper(){ + myFile->Close(); + } + }; + + + //--------------------------------------------------------------- + TVWrapper::TVWrapper(const std::string& theFileName): + myFile(new TFile(theFileName)) + { + } + + + TInt TVWrapper::GetNbMeshes(TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && !*theErr) + return -1; + + return MEDnMaa(myFile->Id()); + } + + + void TVWrapper::GetMeshInfo(TInt theMeshId, + MED::TMeshInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && !*theErr) + return; + + med_maillage& aType = static_cast(theInfo.myType); + + TErr aRet = MEDmaaInfo(myFile->Id(), + theMeshId, + &theInfo.myName[0], + &theInfo.myDim, + &aType, + &theInfo.myDesc[0]); + 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) + return; + + MED::TMeshInfo& anInfo = const_cast(theInfo); + + med_maillage& aType = static_cast(theInfo.myType); + + TErr aRet = MEDmaaCr(myFile->Id(), + &anInfo.myName[0], + anInfo.myDim, + aType, + &anInfo.myDesc[0]); + if(aRet == 0){ + aRet = MEDunvCr(myFile->Id(), + &anInfo.myName[0]); + } + + INITMSG(MYDEBUG,"TVWrapper::SetMeshInfo - MED_MODE_ACCES = "<(theInfo); + return MEDnFam(myFile->Id(), + &anInfo.myName[0]); + } + + + TInt TVWrapper::GetNbFamAttr(TInt theFamId, + const MED::TMeshInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && !*theErr) + return -1; + + MED::TMeshInfo& anInfo = const_cast(theInfo); + return MEDnAttribut(myFile->Id(), + &anInfo.myName[0], + theFamId); + } + + + TInt TVWrapper::GetNbFamGroup(TInt theFamId, + const MED::TMeshInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && !*theErr) + return -1; + + MED::TMeshInfo& anInfo = const_cast(theInfo); + return MEDnGroupe(myFile->Id(), + &anInfo.myName[0], + theFamId); + } + + + void TVWrapper::GetFamilyInfo(TInt theFamId, + MED::TFamilyInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && !*theErr) + return; + + MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; + + TErr aRet = MEDfamInfo(myFile->Id(), + &aMeshInfo.myName[0], + theFamId, + &theInfo.myName[0], + &theInfo.myId, + &theInfo.myAttrId[0], + &theInfo.myAttrVal[0], + &theInfo.myAttrDesc[0], + &theInfo.myNbAttr, + &theInfo.myGroupNames[0], + &theInfo.myNbGroup); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"GetFamilyInfo - MEDfamInfo(...) - "<< + " aMeshInfo.myName = '"<<&aMeshInfo.myName[0]<< + "'; theFamId = "<(theMeshInfo); + + return MEDnEntMaa(myFile->Id(), + &aMeshInfo.myName[0], + MED_COOR, + MED_NOEUD, + med_geometrie_element(0), + med_connectivite(0)); + } + + + void TVWrapper::GetNodeInfo(MED::TNodeInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && !*theErr) + return; + + MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; + + med_repere& aRepere = static_cast(theInfo.mySystem); + med_booleen& anIsElemNames = static_cast(theInfo.myIsElemNames); + med_booleen& anIsElemNum = static_cast(theInfo.myIsElemNum); + + TErr aRet = MEDnoeudsLire(myFile->Id(), + &aMeshInfo.myName[0], + aMeshInfo.myDim, + &theInfo.myCoord[0], + MED_FULL_INTERLACE, + &aRepere, + &theInfo.myCoordNames[0], + &theInfo.myCoordUnits[0], + &theInfo.myElemNames[0], + &anIsElemNames, + &theInfo.myElemNum[0], + &anIsElemNum, + &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) + return; + + MED::TNodeInfo& anInfo = const_cast(theInfo); + MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; + + med_repere& aRepere = static_cast(theInfo.mySystem); + med_booleen& anIsElemNames = static_cast(theInfo.myIsElemNames); + med_booleen& anIsElemNum = static_cast(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, + &anInfo.myElemNum[0], + anIsElemNum, + &anInfo.myFamNum[0], + anInfo.myNbElem); + 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,eLECTURE_ECRITURE,&aRet); + + if(aRet < 0) + SetNodeInfo(theInfo,eLECTURE_AJOUT,theErr); + } + + + TEntityInfo TVWrapper::GetEntityInfo(const MED::TMeshInfo& theMeshInfo, + EConnectivite theTConn, + TErr* theErr) + { + TEntityInfo anInfo; + + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && !*theErr) + return anInfo; + + if(TInt aNbElem = GetNbNodes(theMeshInfo)){ + 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; + if(TInt aNb = GetNbCells(theMeshInfo,anEntity,aGeom,theTConn,theErr)){ + anInfo[anEntity][aGeom] = aNb; + } + } + } + } + return anInfo; + } + + + TInt TVWrapper::GetNbCells(const MED::TMeshInfo& theMeshInfo, + EEntiteMaillage theTEntity, + EGeometrieElement theTGeom, + EConnectivite theTConn, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && !*theErr) + return -1; + + MED::TMeshInfo& aMeshInfo = const_cast(theMeshInfo); + + med_entite_maillage& anEntity = static_cast(theTEntity); + med_geometrie_element& aGeom = static_cast(theTGeom); + med_connectivite& aConn = static_cast(theTConn); + + return MEDnEntMaa(myFile->Id(), + &aMeshInfo.myName[0], + MED_CONN, + anEntity, + aGeom, + aConn); + } + + + void TVWrapper::GetCellInfo(MED::TCellInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && !*theErr) + return; + + MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo; + TInt aNbElem = theInfo.myElemNum.size(); + + med_booleen& anIsElemNames = static_cast(theInfo.myIsElemNames); + med_booleen& anIsElemNum = static_cast(theInfo.myIsElemNum); + med_entite_maillage& anEntity = static_cast(theInfo.myTEntity); + med_geometrie_element& aGeom = static_cast(theInfo.myTGeom); + med_connectivite& aConn = static_cast(theInfo.myTConn); + + TErr aRet = MEDelementsLire(myFile->Id(), + &aMeshInfo.myName[0], + aMeshInfo.myDim, + &theInfo.myConn[0], + MED_FULL_INTERLACE, + &theInfo.myElemNames[0], + &anIsElemNames, + &theInfo.myElemNum[0], + &anIsElemNum, + &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) + return; + + MED::TCellInfo& anInfo = const_cast(theInfo); + MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo; + + med_booleen& anIsElemNames = static_cast(theInfo.myIsElemNames); + med_booleen& anIsElemNum = static_cast(theInfo.myIsElemNum); + med_entite_maillage& anEntity = static_cast(theInfo.myTEntity); + med_geometrie_element& aGeom = static_cast(theInfo.myTGeom); + med_connectivite& aConn = static_cast(theInfo.myTConn); + + TErr aRet = MEDelementsEcr(myFile->Id(), + &aMeshInfo.myName[0], + aMeshInfo.myDim, + &anInfo.myConn[0], + MED_FULL_INTERLACE, + &anInfo.myElemNames[0], + anIsElemNames, + &anInfo.myElemNum[0], + anIsElemNum, + &anInfo.myFamNum[0], + anInfo.myNbElem, + anEntity, + aGeom, + aConn); + + if(theErr) + *theErr = aRet; + else if(aRet < 0) + EXCEPTION(runtime_error,"GetCellInfo - MEDelementsLire(...)"); + } + + + void TVWrapper::SetCellInfo(const MED::TCellInfo& theInfo, + TErr* theErr) + { + SetCellInfo(theInfo,eLECTURE_ECRITURE,theErr); + } + + + TInt TVWrapper::GetNbFields(TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && !*theErr) + return -1; + + return MEDnChamp(myFile->Id(),0); + } + + + TInt TVWrapper::GetNbComp(TInt theFieldId, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && !*theErr) + return -1; + + return MEDnChamp(myFile->Id(),theFieldId); + } + + + void TVWrapper::GetFieldInfo(TInt theFieldId, + MED::TFieldInfo& theInfo, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && !*theErr) + return; + + med_type_champ& aType = static_cast(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) + return; + + MED::TFieldInfo& anInfo = const_cast(theInfo); + + med_type_champ& aType = static_cast(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 - MEDchampEcr(...)"); + } + + + void TVWrapper::SetFieldInfo(const MED::TFieldInfo& theInfo, + TErr* theErr) + { + TErr aRet; + SetFieldInfo(theInfo,eLECTURE_ECRITURE,&aRet); + + if(aRet < 0) + SetFieldInfo(theInfo,eLECTURE_AJOUT,theErr); + } + + + TInt TVWrapper::GetNbTimeStamps(const MED::TFieldInfo& theInfo, + const MED::TEntityInfo& theEntityInfo, + EEntiteMaillage& theEntity, + TGeom& theGeom, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr){ + *theErr &= !theEntityInfo.empty(); + if(!*theErr) + return -1; + } + + if(theEntityInfo.empty()) + EXCEPTION(runtime_error,"GetNbTimeStamps - There is no any Entity on the Mesh"); + + theGeom.clear(); + TInt aNbTimeStamps = 0; + MED::TFieldInfo& anInfo = const_cast(theInfo); + TEntityInfo::const_iterator anIter = theEntityInfo.begin(); + for(; anIter != theEntityInfo.end(); anIter++){ + const med_entite_maillage& anEntity = static_cast(anIter->first); + const TGeom& aTGeom = anIter->second; + TGeom::const_iterator anGeomIter = aTGeom.begin(); + for(; anGeomIter != aTGeom.end(); anGeomIter++){ + const med_geometrie_element& aGeom = static_cast(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,eLECTURE,theErr); + + TGeom& aTGeom = theInfo.myGeom; + + if(theErr){ + *theErr &= !aTGeom.empty(); + if(!*theErr) + return; + } + + 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 = static_cast(theInfo.myEntity); + + TGeom::iterator anIter = aTGeom.begin(); + med_geometrie_element& aGeom = static_cast(anIter->first); + + med_booleen& anIsLocal = static_cast(aFieldInfo.myIsLocal); + + TErr aRet = MEDpasdetempsInfo(myFile->Id(), + &aFieldInfo.myName[0], + anEntity, + aGeom, + theTimeStampId, + &theInfo.myNbGauss, + &theInfo.myNumDt, + &theInfo.myNumOrd, + &theInfo.myUnitDt[0], + &theInfo.myDt, + &aMeshInfo.myName[0], + &anIsLocal, + &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 > MAX_NB_GAUSS_POINTS) + theInfo.myNbGauss = 1; + } + + + void TVWrapper::GetTimeStampVal(MED::TTimeStampVal& theVal, + TErr* theErr) + { + TFileWrapper aFileWrapper(myFile,eLECTURE,theErr); + + if(theErr && !*theErr) + return; + + TIdt anId = myFile->Id(); + + MED::TTimeStampInfo& aTimeStampInfo = *theVal.myTimeStampInfo; + MED::TFieldInfo& aFieldInfo = *aTimeStampInfo.myFieldInfo; + MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo; + + med_entite_maillage& anEntity = static_cast(aTimeStampInfo.myEntity); + med_mode_profil& aPflMode = static_cast(theVal.myPflMode); + TGeom& aTGeom = aTimeStampInfo.myGeom; + TGeom::iterator anIter = aTGeom.begin(); + for(; anIter != aTGeom.end(); anIter++){ + med_geometrie_element& aGeom = static_cast(anIter->first); + TInt aNbVal = MEDnVal(anId, + &aFieldInfo.myName[0], + anEntity, + aGeom, + aTimeStampInfo.myNumDt, + aTimeStampInfo.myNumOrd, + &aMeshInfo.myName[0], + aPflMode); + if(aNbVal <= 0){ + if(theErr){ + *theErr = MED_FAUX; + 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 = static_cast(aTimeStampInfo.myEntity); + med_mode_profil& aPflMode = static_cast(theVal.myPflMode); + TMeshValue::iterator anIter = aMeshValue.begin(); + for(; anIter != aMeshValue.end(); anIter++){ + med_geometrie_element& aGeom = static_cast(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.myGaussName[0], + MED_ALL, + &aVal.myPflName[0], + aPflMode, + 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.myGaussName[0], + MED_ALL, + &aVal.myPflName[0], + aPflMode, + anEntity, + aGeom, + aTimeStampInfo.myNumDt, + &aTimeStampInfo.myUnitDt[0], + aTimeStampInfo.myDt, + aTimeStampInfo.myNumOrd); + break; + }} + + if(aRet < 0){ + if(theErr){ + *theErr = MED_FAUX; + 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 {eLECTURE, eLECTURE_ECRITURE, eLECTURE_AJOUT, eCREATION} 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_2/Makefile.in b/src/MEDWrapper/V2_2/Makefile.in new file mode 100644 index 000000000..a1cf82e92 --- /dev/null +++ b/src/MEDWrapper/V2_2/Makefile.in @@ -0,0 +1,54 @@ +# +# +# 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_2.la +LIB_SRC = \ + MED_V2_2_Wrapper.cxx + +EXPORT_HEADERS = \ + MED_V2_2_Wrapper.hxx + +# Executables targets +BIN = +BIN_SRC = + +CPPFLAGS+= $(BOOST_CPPFLAGS) $(MED2_INCLUDES) + +LDFLAGS+= $(MED2_LIBS) $(HDF5_LIBS) -lMEDWrapperBase + +@CONCLUDE@ diff --git a/src/Utils/Utils_CorbaException.hxx b/src/Utils/Utils_CorbaException.hxx index 44d642b86..5d6d5bf51 100644 --- a/src/Utils/Utils_CorbaException.hxx +++ b/src/Utils/Utils_CorbaException.hxx @@ -45,9 +45,10 @@ throw SALOME::SALOME_Exception(ExDescription); \ } -#include +#include + //Dump the CORBA exception type. -static std::ostream& operator<<(std::ostream& os, const CORBA::Exception& e) +inline std::ostream& operator<<(std::ostream& os, const CORBA::Exception& e) { CORBA::Any tmp; tmp<<= e; @@ -63,4 +64,5 @@ static std::ostream& operator<<(std::ostream& os, const CORBA::Exception& e) return os; } + #endif