ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-03-15 17:51:27 +05:00
Code Issues Packages Projects Releases Wiki Activity
smesh/src/MEDWrapper/MED_Wrapper.cxx
Konstantin LEONTEV f028e1d7bf [bos #32517][EDF] Dynamic logging: Removed MYDEBUG.
2022-10-14 12:44:56 +03:00

4085 lines
139 KiB
C++
Raw Blame History

// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "MED_Wrapper.hxx"
#include "MED_TStructures.hxx"
#include "MED_Utilities.hxx"
#include "MED_TFile.hxx"
#include "MEDFileUtilities.hxx"
#include <med.h>
#include <med_err.h>
#include <med_proto.h>
#ifdef WIN32
#include <windows.h>
#endif
#include <boost/version.hpp>
namespace MED
{
//---------------------------------------------------------------
TLockProxy
::TLockProxy(TWrapper* theWrapper):
myWrapper(theWrapper)
{
#if BOOST_VERSION >= 103500
myWrapper->myMutex.lock();
#else
boost::detail::thread::lock_ops<TWrapper::TMutex>::lock(myWrapper->myMutex);
#endif
INITMSG("TLockProxy() - this -"<<this<<"; myWrapper = "<<myWrapper<<std::endl);
}
TLockProxy
::~TLockProxy()
{
INITMSG("~TLockProxy() - this -"<<this<<"; myWrapper = "<<myWrapper<<std::endl);
#if BOOST_VERSION >= 103500
myWrapper->myMutex.unlock();
#else
boost::detail::thread::lock_ops<TWrapper::TMutex>::unlock(myWrapper->myMutex);
#endif
}
TWrapper*
TLockProxy
::operator->() const // never throws
{
return myWrapper;
}
//---------------------------------------------------------------
const TIdt& MEDIDTHoder::Id() const
{
if (myFid < 0)
EXCEPTION(std::runtime_error, "TFile - GetFid() < 0");
return myFid;
}
void TMemFile::Open(EModeAcces theMode, TErr* theErr)
{
if (this->myCount++ == 0)
{
std::string dftFileName = MEDCoupling::MEDFileWritableStandAlone::GenerateUniqueDftFileNameInMem();
med_access_mode modeTmp(MED_ACC_CREAT);
if(memfile.app_image_ptr)
modeTmp = med_access_mode(theMode);
myFid = MEDmemFileOpen(dftFileName.c_str(),&memfile,MED_FALSE,modeTmp);
}
if (theErr)
*theErr = TErr(myFid);
else if (myFid < 0)
EXCEPTION(std::runtime_error,"TMemFile - MEDmemFileOpen");
}
TFile::TFile(const std::string& theFileName, TInt theMajor, TInt theMinor):
myFileName(theFileName),
myMajor(theMajor),
myMinor(theMinor)
{
if ((myMajor < 0) || (myMajor > MED_MAJOR_NUM)) myMajor = MED_MAJOR_NUM;
if ((myMinor < 0) || (myMajor == MED_MAJOR_NUM && myMinor > MED_MINOR_NUM)) myMinor = MED_MINOR_NUM;
}
void TFile::Open(EModeAcces theMode, TErr* theErr)
{
if (myCount++ == 0) {
const char* aFileName = myFileName.c_str();
#ifdef WIN32
if (med_access_mode(theMode) == MED_ACC_RDWR) {
// Force removing readonly attribute from a file under Windows, because of a bug in the HDF5
std::string aReadOlnyRmCmd = "attrib -r \"" + myFileName + "\"> nul 2>&1";
#ifdef UNICODE
const char* to_decode = aReadOlnyRmCmd.c_str();
int size_needed = MultiByteToWideChar(CP_UTF8, 0, to_decode, strlen(to_decode), NULL, 0);
wchar_t* awReadOlnyRmCmd = new wchar_t[size_needed + 1];
MultiByteToWideChar(CP_UTF8, 0, to_decode, strlen(to_decode), awReadOlnyRmCmd, size_needed);
awReadOlnyRmCmd[size_needed] = '\0';
_wsystem(awReadOlnyRmCmd);
delete[] awReadOlnyRmCmd;
#else
system(aReadOlnyRmCmd.c_str());
#endif
}
#endif
myFid = MEDfileVersionOpen(aFileName,med_access_mode(theMode), myMajor, myMinor, MED_RELEASE_NUM);
}
if (theErr)
*theErr = TErr(myFid);
else if (myFid < 0)
EXCEPTION(std::runtime_error,"TFile - MEDfileVersionOpen('"<<myFileName<<"',"<<theMode<<"',"<< myMajor <<"',"<< myMinor<<"',"<< MED_RELEASE_NUM<<")");
}
//---------------------------------------------------------------
class TFileWrapper
{
PFileInternal myFile;
TInt myMinor;
public:
TFileWrapper(const PFileInternal& theFile,
EModeAcces theMode,
TErr* theErr = NULL,
TInt theMinor=-1):
myFile(theFile),
myMinor(theMinor)
{
if (myMinor < 0) myMinor = MED_MINOR_NUM;
myFile->Open(theMode, theErr);
}
~TFileWrapper()
{
myFile->Close();
}
};
//----------------------------------------------------------------------------
template<class TimeStampValueType>
void
Print(SharedPtr<TimeStampValueType> theTimeStampValue)
{
INITMSG("Print - TimeStampValue\n");
typename TimeStampValueType::TTGeom2Value& aGeom2Value = theTimeStampValue->myGeom2Value;
typename TimeStampValueType::TTGeom2Value::const_iterator anIter = aGeom2Value.begin();
for (; anIter != aGeom2Value.end(); anIter++) {
const EGeometrieElement& aGeom = anIter->first;
const typename TimeStampValueType::TTMeshValue& aMeshValue = anIter->second;
TInt aNbElem = aMeshValue.myNbElem;
TInt aNbGauss = aMeshValue.myNbGauss;
TInt aNbComp = aMeshValue.myNbComp;
INITMSG("aGeom = "<<aGeom<<" - "<<aNbElem<<": ");
for (TInt iElem = 0; iElem < aNbElem; iElem++) {
typename TimeStampValueType::TTMeshValue::TCValueSliceArr aValueSliceArr =
aMeshValue.GetGaussValueSliceArr(iElem);
ADDMSG("{");
for (TInt iGauss = 0; iGauss < aNbGauss; iGauss++) {
const typename TimeStampValueType::TTMeshValue::TCValueSlice& aValueSlice =
aValueSliceArr[iGauss];
for (TInt iComp = 0; iComp < aNbComp; iComp++) {
ADDMSG(aValueSlice[iComp]<<" ");
}
ADDMSG("| ");
}
ADDMSG("} ");
}
ADDMSG("\n");
}
}
//---------------------------------------------------------------
TWrapper
::TWrapper(const std::string& theFileName, bool write, TFileInternal *tfileInst, TInt theMajor, TInt theMinor):
myMajor(theMajor),
myMinor(theMinor)
{
if(!tfileInst)
myFile.reset(new TFile(theFileName, theMajor, theMinor) );
else
myFile.reset(new TFileDecorator(tfileInst) );
TErr aRet;
if ( write ) {
myFile->Open(eLECTURE_ECRITURE, &aRet);
if (aRet < 0) {
myFile->Close();
myFile->Open(eCREATION, &aRet);
}
}
else {
myFile->Open(eLECTURE, &aRet);
}
}
//----------------------------------------------------------------------------
TWrapper::
~TWrapper()
{
}
//----------------------------------------------------------------------------
TInt
TWrapper
::GetNbMeshes(TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return -1;
return MEDnMesh(myFile->Id());
}
//----------------------------------------------------------------------------
void
TWrapper
::GetMeshInfo(TInt theMeshId,
MED::TMeshInfo& theInfo,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return;
TValueHolder<TString, char> aMeshName(theInfo.myName);
TValueHolder<TInt, med_int> aDim(theInfo.myDim);
TValueHolder<TInt, med_int> aSpaceDim(theInfo.mySpaceDim);
TValueHolder<EMaillage, med_mesh_type> aType(theInfo.myType);
char dtunit[MED_SNAME_SIZE+1];
med_sorting_type sorttype;
med_int nstep;
med_axis_type at;
int naxis = MEDmeshnAxis(myFile->Id(), theMeshId);
char *axisname = new char[naxis*MED_SNAME_SIZE+1];
char *axisunit = new char[naxis*MED_SNAME_SIZE+1];
TErr aRet = MEDmeshInfo(myFile->Id(),
theMeshId,
&aMeshName,
&aSpaceDim,
&aDim,
&aType,
&theInfo.myDesc[0],
dtunit,
&sorttype,
&nstep,
&at,
axisname,
axisunit);
delete [] axisname;
delete [] axisunit;
if (aRet < 0)
EXCEPTION(std::runtime_error, "GetMeshInfo - MEDmeshInfo(...)");
}
//----------------------------------------------------------------------------
void
TWrapper
::SetMeshInfo(const MED::TMeshInfo& theInfo,
TErr* theErr)
{
TErr aRet;
SetMeshInfo(theInfo, eLECTURE_ECRITURE, &aRet);
if (aRet < 0)
SetMeshInfo(theInfo, eLECTURE_AJOUT, &aRet);
if (aRet < 0)
SetMeshInfo(theInfo, eCREATION, &aRet);
if (theErr)
*theErr = aRet;
}
//----------------------------------------------------------------------------
void
TWrapper
::SetMeshInfo(const MED::TMeshInfo& theInfo,
EModeAcces theMode,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, theMode, theErr, myMinor);
if (theErr && *theErr < 0)
return;
MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
TValueHolder<TString, char> aMeshName(anInfo.myName);
TValueHolder<TInt, med_int> aDim(anInfo.myDim);
TValueHolder<TInt, med_int> aSpaceDim(anInfo.mySpaceDim);
TValueHolder<EMaillage, med_mesh_type> aType(anInfo.myType);
TValueHolder<TString, char> aDesc(anInfo.myDesc);
char *nam = new char[aSpaceDim*MED_SNAME_SIZE+1];
std::fill(nam, nam+aSpaceDim*MED_SNAME_SIZE+1, '\0');
char *unit = new char[aSpaceDim*MED_SNAME_SIZE+1];
std::fill(unit, unit+aSpaceDim*MED_SNAME_SIZE+1, '\0');
TErr aRet = MEDmeshCr(myFile->Id(),
&aMeshName,
aSpaceDim,
aDim,
aType,
&aDesc,
"",
MED_SORT_DTIT,
MED_CARTESIAN,
nam,
unit);
delete [] nam;
delete [] unit;
//if (aRet == 0)
// aRet = MEDunvCr(myFile->Id(),&aMeshName);
INITMSG("TWrapper::SetMeshInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "SetMeshInfo - MEDmeshCr(...)");
}
//----------------------------------------------------------------------------
PMeshInfo
TWrapper
::CrMeshInfo(TInt theDim,
TInt theSpaceDim,
const std::string& theValue,
EMaillage theType,
const std::string& theDesc)
{
return PMeshInfo(new TTMeshInfo
(theDim,
theSpaceDim,
theValue,
theType,
theDesc));
}
//----------------------------------------------------------------------------
PMeshInfo
TWrapper
::CrMeshInfo(const PMeshInfo& theInfo)
{
return PMeshInfo(new TTMeshInfo(theInfo));
}
//----------------------------------------------------------------------------
PMeshInfo
TWrapper
::GetPMeshInfo(TInt theId,
TErr* theErr)
{
PMeshInfo anInfo = CrMeshInfo();
GetMeshInfo(theId, *anInfo, theErr);
return anInfo;
}
//----------------------------------------------------------------------------
TInt
TWrapper
::GetNbFamilies(const MED::TMeshInfo& theInfo,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return -1;
MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
TValueHolder<TString, char> aName(anInfo.myName);
return MEDnFamily(myFile->Id(), &aName);
}
//----------------------------------------------------------------------------
TInt
TWrapper
::GetNbFamAttr(TInt theFamId,
const MED::TMeshInfo& theInfo,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return -1;
MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
TValueHolder<TString, char> aName(anInfo.myName);
return MEDnFamily23Attribute(myFile->Id(), &aName, theFamId);
}
//----------------------------------------------------------------------------
TInt
TWrapper
::GetNbFamGroup(TInt theFamId,
const MED::TMeshInfo& theInfo,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return -1;
MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
TValueHolder<TString, char> aName(anInfo.myName);
return MEDnFamilyGroup(myFile->Id(), &aName, theFamId);
}
//----------------------------------------------------------------------------
void
TWrapper
::GetFamilyInfo(TInt theFamId,
MED::TFamilyInfo& theInfo,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return;
MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
TValueHolder<TString, char> aFamilyName(theInfo.myName);
TValueHolder<TInt, med_int> aFamilyId(theInfo.myId);
TValueHolder<TFamAttr, med_int> anAttrId(theInfo.myAttrId);
TValueHolder<TFamAttr, med_int> anAttrVal(theInfo.myAttrVal);
TValueHolder<TString, char> anAttrDesc(theInfo.myAttrDesc);
TValueHolder<TString, char> aGroupNames(theInfo.myGroupNames);
TErr aRet = MEDfamily23Info(myFile->Id(),
&aMeshName,
theFamId,
&aFamilyName,
&anAttrId,
&anAttrVal,
&anAttrDesc,
&aFamilyId,
&aGroupNames);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "GetFamilyInfo - MEDfamily23Info(...) - "<<
" aMeshInfo.myName = '"<<&aMeshName<<
"'; theFamId = "<<theFamId<<
"; theInfo.myNbGroup = "<<theInfo.myNbGroup<<
"; theInfo.myNbAttr = "<<theInfo.myNbAttr);
}
//----------------------------------------------------------------------------
void
TWrapper
::SetFamilyInfo(const MED::TFamilyInfo& theInfo,
TErr* theErr)
{
TErr aRet;
SetFamilyInfo(theInfo, eLECTURE_ECRITURE, &aRet);
if (aRet < 0)
SetFamilyInfo(theInfo, eLECTURE_AJOUT, &aRet);
if (theErr)
*theErr = aRet;
}
//----------------------------------------------------------------------------
void
TWrapper
::SetFamilyInfo(const MED::TFamilyInfo& theInfo,
EModeAcces theMode,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, theMode, theErr, myMinor);
if (theErr && *theErr < 0)
return;
MED::TFamilyInfo& anInfo = const_cast<MED::TFamilyInfo&>(theInfo);
MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
TValueHolder<TString, char> aFamilyName(anInfo.myName);
TValueHolder<TInt, med_int> aFamilyId(anInfo.myId);
TValueHolder<TFamAttr, med_int> anAttrId(anInfo.myAttrId);
TValueHolder<TFamAttr, med_int> anAttrVal(anInfo.myAttrVal);
TValueHolder<TInt, med_int> aNbAttr(anInfo.myNbAttr);
TValueHolder<TString, char> anAttrDesc(anInfo.myAttrDesc);
TValueHolder<TInt, med_int> aNbGroup(anInfo.myNbGroup);
TValueHolder<TString, char> aGroupNames(anInfo.myGroupNames);
TErr aRet = MEDfamilyCr(myFile->Id(),
&aMeshName,
&aFamilyName,
aFamilyId,
aNbGroup,
&aGroupNames);
INITMSG("TWrapper::SetFamilyInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "SetFamilyInfo - MEDfamilyCr(...)");
}
//----------------------------------------------------------------------------
PFamilyInfo
TWrapper
::CrFamilyInfo(const PMeshInfo& theMeshInfo,
TInt theNbGroup,
TInt theNbAttr,
TInt theId,
const std::string& theValue)
{
return PFamilyInfo(new TTFamilyInfo
(theMeshInfo,
theNbGroup,
theNbAttr,
theId,
theValue));
}
//----------------------------------------------------------------------------
PFamilyInfo
TWrapper
::CrFamilyInfo(const PMeshInfo& theMeshInfo,
const std::string& theValue,
TInt theId,
const MED::TStringSet& theGroupNames,
const MED::TStringVector& theAttrDescs,
const MED::TIntVector& theAttrIds,
const MED::TIntVector& theAttrVals)
{
return PFamilyInfo(new TTFamilyInfo
(theMeshInfo,
theValue,
theId,
theGroupNames,
theAttrDescs,
theAttrIds,
theAttrVals));
}
//----------------------------------------------------------------------------
PFamilyInfo
TWrapper
::CrFamilyInfo(const PMeshInfo& theMeshInfo,
const PFamilyInfo& theInfo)
{
return PFamilyInfo(new TTFamilyInfo
(theMeshInfo,
theInfo));
}
//----------------------------------------------------------------------------
PFamilyInfo
TWrapper
::GetPFamilyInfo(const PMeshInfo& theMeshInfo,
TInt theId,
TErr* theErr)
{
// must be reimplemented in connection with mesh type eSTRUCTURE
// if (theMeshInfo->GetType() != eNON_STRUCTURE)
// return PFamilyInfo();
TInt aNbAttr = GetNbFamAttr(theId, *theMeshInfo);
TInt aNbGroup = GetNbFamGroup(theId, *theMeshInfo);
PFamilyInfo anInfo = CrFamilyInfo(theMeshInfo, aNbGroup, aNbAttr);
GetFamilyInfo(theId, *anInfo, theErr);
#ifdef _DEBUG_
std::string aName = anInfo->GetName();
INITMSG("GetPFamilyInfo - aFamilyName = '"<<aName<<
"'; andId = "<<anInfo->GetId()<<
"; aNbAttr = "<<aNbAttr<<
"; aNbGroup = "<<aNbGroup<<"\n");
for (TInt iGroup = 0; iGroup < aNbGroup; iGroup++) {
aName = anInfo->GetGroupName(iGroup);
INITMSG("aGroupName = '"<<aName<<"'\n");
}
#endif
return anInfo;
}
//----------------------------------------------------------------------------
void
TWrapper
::GetNames(TElemInfo& theInfo,
TInt /*theNb*/,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return;
if (theGeom == eBALL)
theGeom = GetBallGeom(theInfo.myMeshInfo);
MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
TValueHolder<TString, char> aMeshName (aMeshInfo.myName);
TValueHolder<TString, char> anElemNames(theInfo.myElemNames);
TValueHolder<EEntiteMaillage, med_entity_type> anEntity (theEntity);
TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theGeom);
TErr aRet = MEDmeshEntityNameRd(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
anEntity,
aGeom,
&anElemNames);
theInfo.myIsElemNames = aRet != 0? eFAUX : eVRAI ;
if (theErr)
*theErr = aRet;
}
//----------------------------------------------------------------------------
void
TWrapper
::SetNames(const TElemInfo& theInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr)
{
SetNames(theInfo, eLECTURE_ECRITURE, theEntity, theGeom, theErr);
}
//----------------------------------------------------------------------------
void
TWrapper
::SetNames(const TElemInfo& theInfo,
EModeAcces theMode,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, theMode, theErr, myMinor);
if (theErr && *theErr < 0)
return;
if (theGeom == eBALL)
theGeom = GetBallGeom(theInfo.myMeshInfo);
MED::TElemInfo& anInfo = const_cast<MED::TElemInfo&>(theInfo);
MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
TErr aRet = 0;
if (theInfo.myIsElemNames) {
TValueHolder<TString, char> aMeshName (aMeshInfo.myName);
TValueHolder<TString, char> anElemNames(anInfo.myElemNames);
TValueHolder<EEntiteMaillage, med_entity_type> anEntity (theEntity);
TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theGeom);
aRet = MEDmeshEntityNameWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
anEntity,
aGeom,
(TInt)anInfo.myElemNames->size(),
&anElemNames);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "SetNames - MEDmeshEntityNameWr(...)");
}
}
//----------------------------------------------------------------------------
void
TWrapper
::GetNumeration(TElemInfo& theInfo,
TInt /*theNb*/,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return;
if (theGeom == eBALL)
theGeom = GetBallGeom(theInfo.myMeshInfo);
MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
TValueHolder<TElemNum, med_int> anElemNum(theInfo.myElemNum);
TValueHolder<EEntiteMaillage, med_entity_type> anEntity (theEntity);
TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theGeom);
TErr aRet = MEDmeshEntityNumberRd(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
anEntity,
aGeom,
&anElemNum);
theInfo.myIsElemNum = aRet != 0? eFAUX : eVRAI;
if (theErr)
*theErr = aRet;
}
//----------------------------------------------------------------------------
void
TWrapper
::SetNumeration(const TElemInfo& theInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr)
{
SetNumeration(theInfo, eLECTURE_ECRITURE, theEntity, theGeom, theErr);
}
//----------------------------------------------------------------------------
void
TWrapper
::SetNumeration(const TElemInfo& theInfo,
EModeAcces theMode,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, theMode, theErr, myMinor);
if (theErr && *theErr < 0)
return;
if (theGeom == eBALL)
theGeom = GetBallGeom(theInfo.myMeshInfo);
MED::TElemInfo& anInfo = const_cast<MED::TElemInfo&>(theInfo);
MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
TErr aRet = 0;
if (theInfo.myIsElemNum) {
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
TValueHolder<EEntiteMaillage, med_entity_type> anEntity (theEntity);
TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theGeom);
aRet = MEDmeshEntityNumberWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
anEntity,
aGeom,
(TInt)anInfo.myElemNum->size(),
&anElemNum);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "SetNumeration - MEDmeshEntityNumberWr(...)");
}
}
//----------------------------------------------------------------------------
void
TWrapper
::GetFamilies(TElemInfo& theInfo,
TInt /*theNb*/,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return;
if (theGeom == eBALL)
theGeom = GetBallGeom(theInfo.myMeshInfo);
MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
TValueHolder<TElemNum, med_int> aFamNum (theInfo.myFamNum);
TValueHolder<EEntiteMaillage, med_entity_type> anEntity (theEntity);
TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theGeom);
TErr aRet = MEDmeshEntityFamilyNumberRd(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
anEntity,
aGeom,
&aFamNum);
if (aRet < 0) {
// if (aRet == MED_ERR_DOESNTEXIST) // --- only valid with MED3.x files
{
int aSize = (int)theInfo.myFamNum->size();
theInfo.myFamNum->clear();
theInfo.myFamNum->resize(aSize,0);
aRet = 0;
}
// else
// EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshEntityFamilyNumberRd(...) of CELLS");
}
if (theErr)
*theErr = aRet;
}
//----------------------------------------------------------------------------
void
TWrapper
::SetFamilies(const TElemInfo& theInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr)
{
SetFamilies(theInfo, eLECTURE_ECRITURE, theEntity, theGeom, theErr);
}
//----------------------------------------------------------------------------
void
TWrapper
::SetFamilies(const TElemInfo& theInfo,
EModeAcces theMode,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, theMode, theErr, myMinor);
if (theErr && *theErr < 0)
return;
if (theGeom == eBALL)
theGeom = GetBallGeom(theInfo.myMeshInfo);
MED::TElemInfo& anInfo = const_cast<MED::TElemInfo&>(theInfo);
MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
TValueHolder<TElemNum, med_int> aFamNum (anInfo.myFamNum);
TValueHolder<EEntiteMaillage, med_entity_type> anEntity (theEntity);
TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theGeom);
TErr aRet = MEDmeshEntityFamilyNumberWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
anEntity,
aGeom,
(TInt)anInfo.myFamNum->size(),
&aFamNum);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "SetFamilies - MEDmeshEntityFamilyNumberWr(...)");
}
//----------------------------------------------------------------------------
TInt
TWrapper
::GetNbNodes(const MED::TMeshInfo& theMeshInfo,
TErr* theErr)
{
return GetNbNodes(theMeshInfo, eCOOR, theErr);
}
//----------------------------------------------------------------------------
TInt
TWrapper
::GetNbNodes(const MED::TMeshInfo& theMeshInfo,
ETable theTable,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return -1;
MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
TValueHolder<ETable, med_data_type > aTable(theTable);
med_bool chgt,trsf;
return MEDmeshnEntity(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_NODE,
MED_NO_GEOTYPE,
aTable,
MED_NO_CMODE,
&chgt,
&trsf);
}
//----------------------------------------------------------------------------
void
TWrapper
::GetNodeInfo(MED::TNodeInfo& theInfo,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return;
MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
TValueHolder<TInt, med_int> aDim(aMeshInfo.myDim);
TValueHolder<TNodeCoord, med_float> aCoord(theInfo.myCoord);
TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(theInfo.myModeSwitch);
TValueHolder<ERepere, med_axis_type> aSystem(theInfo.mySystem);
TValueHolder<TString, char> aCoordNames(theInfo.myCoordNames);
TValueHolder<TString, char> aCoordUnits(theInfo.myCoordUnits);
TValueHolder<TString, char> anElemNames(theInfo.myElemNames);
//TValueHolder<EBooleen, med_bool> anIsElemNames(theInfo.myIsElemNames);
TValueHolder<TElemNum, med_int> anElemNum(theInfo.myElemNum);
//TValueHolder<EBooleen, med_bool> anIsElemNum(theInfo.myIsElemNum);
TValueHolder<TElemNum, med_int> aFamNum(theInfo.myFamNum);
TValueHolder<TInt, med_int> aNbElem(theInfo.myNbElem);
TErr aRet = MEDmeshNodeCoordinateRd(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
aModeSwitch,
&aCoord);
TErr aRet2 =MEDmeshEntityFamilyNumberRd(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_NODE,
MED_NO_GEOTYPE,
&aFamNum);
if (aRet2 < 0) {
// if (aRet2 == MED_ERR_DOESNTEXIST) // --- only valid with MED3.x files
{
int mySize = (int)theInfo.myFamNum->size();
theInfo.myFamNum->clear();
theInfo.myFamNum->resize(mySize,0);
}
// else
// EXCEPTION(std::runtime_error,"GetNodeInfo - MEDmeshEntityFamilyNumberRd(...)");
}
if (MEDmeshEntityNameRd(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_NODE,
MED_NO_GEOTYPE,
&anElemNames) < 0) theInfo.myIsElemNames=eFAUX;
if (MEDmeshEntityNumberRd(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_NODE,
MED_NO_GEOTYPE,
&anElemNum) < 0) theInfo.myIsElemNum=eFAUX;
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "GetNodeInfo - MEDmeshNodeCoordinateRd(...)");
}
//----------------------------------------------------------------------------
void
TWrapper
::SetNodeInfo(const MED::TNodeInfo& theInfo,
TErr* theErr)
{
TErr aRet;
SetNodeInfo(theInfo, eLECTURE_ECRITURE, &aRet);
if (aRet < 0)
SetNodeInfo(theInfo, eLECTURE_AJOUT, &aRet);
if (theErr)
*theErr = aRet;
}
//----------------------------------------------------------------------------
void
TWrapper
::SetNodeInfo(const MED::TNodeInfo& theInfo,
EModeAcces theMode,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, theMode, theErr, myMinor);
if (theErr && *theErr < 0)
return;
MED::TNodeInfo& anInfo = const_cast<MED::TNodeInfo&>(theInfo);
MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
TValueHolder<TString, char> aMeshName (aMeshInfo.myName);
TValueHolder<TNodeCoord, med_float> aCoord (anInfo.myCoord);
TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch (anInfo.myModeSwitch);
TValueHolder<ERepere, med_axis_type> aSystem (anInfo.mySystem);
TValueHolder<TString, char> aCoordNames (anInfo.myCoordNames);
TValueHolder<TString, char> aCoordUnits (anInfo.myCoordUnits);
TValueHolder<TString, char> anElemNames (anInfo.myElemNames);
TValueHolder<EBooleen, med_bool> anIsElemNames(anInfo.myIsElemNames);
TValueHolder<TElemNum, med_int> anElemNum (anInfo.myElemNum);
TValueHolder<EBooleen, med_bool> anIsElemNum (anInfo.myIsElemNum);
TValueHolder<TElemNum, med_int> aFamNum (anInfo.myFamNum);
TValueHolder<TInt, med_int> aNbElem (anInfo.myNbElem);
TErr aRet = MEDmeshNodeCoordinateWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_NO_DT,
aModeSwitch,
aNbElem,
&aCoord);
MEDmeshEntityFamilyNumberWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_NODE,
MED_NO_GEOTYPE,
aNbElem,
&aFamNum);
if (anIsElemNames)
MEDmeshEntityNameWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_NODE,
MED_NO_GEOTYPE,
aNbElem,
&anElemNames);
if (anIsElemNum)
MEDmeshEntityNumberWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_NODE,
MED_NO_GEOTYPE,
aNbElem,
&anElemNum);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "SetNodeInfo - MEDmeshNodeCoordinateWr(...)");
}
//----------------------------------------------------------------------------
PNodeInfo
TWrapper
::CrNodeInfo(const PMeshInfo& theMeshInfo,
TInt theNbElem,
EModeSwitch theMode,
ERepere theSystem,
EBooleen theIsElemNum,
EBooleen theIsElemNames)
{
return PNodeInfo(new TTNodeInfo
(theMeshInfo,
theNbElem,
theMode,
theSystem,
theIsElemNum,
theIsElemNames));
}
//----------------------------------------------------------------------------
PNodeInfo
TWrapper
::CrNodeInfo(const PMeshInfo& theMeshInfo,
const TFloatVector& theNodeCoords,
EModeSwitch theMode,
ERepere theSystem,
const TStringVector& theCoordNames,
const TStringVector& theCoordUnits,
const TIntVector& theFamilyNums,
const TIntVector& theElemNums,
const TStringVector& theElemNames)
{
return PNodeInfo(new TTNodeInfo
(theMeshInfo,
theNodeCoords,
theMode,
theSystem,
theCoordNames,
theCoordUnits,
theFamilyNums,
theElemNums,
theElemNames));
}
//----------------------------------------------------------------------------
PNodeInfo
TWrapper
::CrNodeInfo(const PMeshInfo& theMeshInfo,
const PNodeInfo& theInfo)
{
return PNodeInfo(new TTNodeInfo
(theMeshInfo,
theInfo));
}
//----------------------------------------------------------------------------
PNodeInfo
TWrapper
::GetPNodeInfo(const PMeshInfo& theMeshInfo,
TErr* theErr)
{
TInt aNbElems = GetNbNodes(*theMeshInfo);
if (aNbElems == 0) {
return PNodeInfo();
}
PNodeInfo anInfo = CrNodeInfo(theMeshInfo, aNbElems);
GetNodeInfo(*anInfo, theErr);
#ifdef _DEBUG_
TInt aDim = theMeshInfo->myDim;
TInt aNbElem = anInfo->GetNbElem();
INITMSG("GetPNodeInfo: ");
{
INITMSG("aCoords: "<<aNbElem<<": ");
TNodeCoord& aCoord = anInfo->myCoord;
for (TInt iElem = 0; iElem < aNbElem; iElem++) {
for (TInt iDim = 0, anId = iElem*aDim; iDim < aDim; iDim++, anId++) {
ADDMSG(aCoord[anId]<<",");
}
ADDMSG(" ");
}
ADDMSG(std::endl);
BEGMSG("GetFamNum: ");
for (TInt iElem = 0; iElem < aNbElem; iElem++) {
ADDMSG(anInfo->GetFamNum(iElem)<<", ");
}
ADDMSG(std::endl);
if (anInfo->IsElemNum()) {
BEGMSG("GetElemNum: ");
for (TInt iElem = 0; iElem < aNbElem; iElem++) {
ADDMSG(anInfo->GetElemNum(iElem)<<", ");
}
ADDMSG(std::endl);
}
}
ADDMSG(std::endl);
#endif
return anInfo;
}
//----------------------------------------------------------------------------
PElemInfo
TWrapper
::CrElemInfo(const PMeshInfo& theMeshInfo,
TInt theNbElem,
EBooleen theIsElemNum,
EBooleen theIsElemNames)
{
return PElemInfo(new TTElemInfo
(theMeshInfo,
theNbElem,
theIsElemNum,
theIsElemNames));
}
//----------------------------------------------------------------------------
PElemInfo
TWrapper
::CrElemInfo(const PMeshInfo& theMeshInfo,
TInt theNbElem,
const TIntVector& theFamNum,
const TIntVector& aElemNum,
const TStringVector& aElemNames)
{
return PElemInfo(new TTElemInfo
(theMeshInfo,
theNbElem,
theFamNum,
aElemNum,
aElemNames));
}
//----------------------------------------------------------------------------
PElemInfo
TWrapper
::GetPElemInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
EConnectivite theConnMode,
TErr* theErr)
{
EMaillage aType = theMeshInfo->GetType();
if (aType == eNON_STRUCTURE) {
switch (theGeom) {
case ePOINT1:
if (theEntity == eNOEUD)
return GetPNodeInfo(theMeshInfo, theErr);
return GetPCellInfo(theMeshInfo, theEntity, theGeom, theConnMode, theErr);
break;
case ePOLYGONE:
return GetPPolygoneInfo(theMeshInfo, theEntity, theGeom, theConnMode);
break;
case ePOLYEDRE:
return GetPPolyedreInfo(theMeshInfo, theEntity, theGeom, theConnMode);
break;
default:
return GetPCellInfo(theMeshInfo, theEntity, theGeom, theConnMode, theErr);
}
}
else {
PGrilleInfo aGrille = GetPGrilleInfo(theMeshInfo);
TInt nbElems;
EBooleen theIsElemNum = eFAUX;
// nodes
switch (theGeom) {
case ePOINT1:
nbElems = aGrille->GetNbNodes();
theIsElemNum = eVRAI;
break;
case eSEG2:
case eQUAD4:
case eHEXA8:
nbElems = aGrille->GetNbCells();
break;
default:
nbElems = 0;
}
TIntVector aFamNum;
TIntVector aElemNum;
TStringVector aElemNames;
PElemInfo aElemInfo;
if (theGeom == ePOINT1) {
aElemInfo = CrElemInfo(theMeshInfo,
nbElems,
theIsElemNum);
MED::TElemInfo &aTElemInfo = *aElemInfo;
// must be reimplemente in connection with mesh type eSTRUCTURE
// GetNumeration(aTElemInfo,
// nbElems,
// theEntity,
// theGeom,
// theErr);
GetFamilies(aTElemInfo,
nbElems,
theEntity,
theGeom,
theErr);
// must be reimplemente in connection with mesh type eSTRUCTURE
// GetNames(aTElemInfo,
// nbElems,
// theEntity,
// theGeom,
// theErr);
}
else {
aElemInfo = CrElemInfo(theMeshInfo,
nbElems,
aFamNum,
aElemNum,
aElemNames);
}
return aElemInfo;
}
return PElemInfo();
}
//----------------------------------------------------------------------------
TInt
TWrapper
::GetNbPolygones(const MED::TMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
EConnectivite theConnMode,
TErr* theErr)
{
return GetNbCells(theMeshInfo, theEntity, theGeom, theConnMode, theErr);
}
//----------------------------------------------------------------------------
TInt
TWrapper
::GetPolygoneConnSize(const MED::TMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
EConnectivite theConnMode,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return 0;
MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
med_int aTaille = 0;
med_bool chgt,trsf;
aTaille=MEDmeshnEntity(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
med_entity_type(theEntity),
med_geometry_type(theGeom),
MED_CONNECTIVITY,
med_connectivity_mode(theConnMode),
&chgt,
&trsf);
if (aTaille < 0)
EXCEPTION(std::runtime_error, "GetPolygoneInfo - MEDmeshnEntity(...)");
return TInt(aTaille);
}
//-----------------------------------------------------------------
void
TWrapper
::GetPolygoneInfo(MED::TPolygoneInfo& theInfo,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return;
MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
TValueHolder<TString, char > aMeshName(aMeshInfo.myName);
TValueHolder<TElemNum, med_int > anIndex (theInfo.myIndex);
TValueHolder<TElemNum, med_int > aConn (theInfo.myConn);
TValueHolder<EEntiteMaillage, med_entity_type > anEntity (theInfo.myEntity);
TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theInfo.myGeom);
TValueHolder<EConnectivite, med_connectivity_mode> aConnMode(theInfo.myConnMode);
TInt aNbElem = (TInt)theInfo.myElemNum->size();
TErr aRet;
aRet = MEDmeshPolygon2Rd(myFile->Id(), &aMeshName,
MED_NO_DT, MED_NO_IT,
anEntity, aGeom,
aConnMode, &anIndex, &aConn);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "GetPolygoneInfo - MEDmeshPolygonRd(...)");
if (theInfo.myIsElemNames) {
GetNames(theInfo, aNbElem, theInfo.myEntity, theInfo.myGeom, &aRet);
if (theErr)
*theErr = aRet;
}
if (theInfo.myIsElemNum) {
GetNumeration(theInfo, aNbElem, theInfo.myEntity, theInfo.myGeom, &aRet);
if (theErr)
*theErr = aRet;
}
GetFamilies(theInfo, aNbElem, theInfo.myEntity, theInfo.myGeom, &aRet);
if (theErr)
*theErr = aRet;
}
//----------------------------------------------------------------------------
void
TWrapper
::SetPolygoneInfo(const MED::TPolygoneInfo& theInfo,
TErr* theErr)
{
SetPolygoneInfo(theInfo, eLECTURE_ECRITURE, theErr);
}
//----------------------------------------------------------------------------
void
TWrapper
::SetPolygoneInfo(const MED::TPolygoneInfo& theInfo,
EModeAcces theMode,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, theMode, theErr, myMinor);
if (theErr && *theErr < 0)
return;
MED::TPolygoneInfo& anInfo = const_cast<MED::TPolygoneInfo&>(theInfo);
MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
TValueHolder<TString, char > aMeshName(aMeshInfo.myName);
TValueHolder<TElemNum, med_int > anIndex (anInfo.myIndex);
TValueHolder<TElemNum, med_int > aConn (anInfo.myConn);
TValueHolder<EEntiteMaillage, med_entity_type > anEntity (anInfo.myEntity);
TValueHolder<EGeometrieElement, med_geometry_type> aGeom (anInfo.myGeom);
TValueHolder<EConnectivite, med_connectivity_mode> aConnMode(anInfo.myConnMode);
TErr aRet = MEDmeshPolygon2Wr(myFile->Id(), &aMeshName,
MED_NO_DT, MED_NO_IT, MED_UNDEF_DT,
anEntity, aGeom,
aConnMode, anInfo.myNbElem + 1,
&anIndex, &aConn);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "SetPolygoneInfo - MEDmeshPolygonWr(...)");
SetNames(anInfo, theInfo.myEntity, anInfo.myGeom, &aRet);
if (theErr)
*theErr = aRet;
SetNumeration(anInfo, theInfo.myEntity, anInfo.myGeom, &aRet);
if (theErr)
*theErr = aRet;
SetFamilies(anInfo, theInfo.myEntity, anInfo.myGeom, &aRet);
if (theErr)
*theErr = aRet;
}
//----------------------------------------------------------------------------
PPolygoneInfo
TWrapper
::CrPolygoneInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TInt theNbElem,
TInt theConnSize,
EConnectivite theConnMode,
EBooleen theIsElemNum,
EBooleen theIsElemNames)
{
return PPolygoneInfo(new TTPolygoneInfo
(theMeshInfo,
theEntity,
theGeom,
theNbElem,
theConnSize,
theConnMode,
theIsElemNum,
theIsElemNames));
}
//----------------------------------------------------------------------------
PPolygoneInfo
TWrapper
::CrPolygoneInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
const TIntVector& theIndexes,
const TIntVector& theConnectivities,
EConnectivite theConnMode,
const TIntVector& theFamilyNums,
const TIntVector& theElemNums,
const TStringVector& theElemNames)
{
return PPolygoneInfo(new TTPolygoneInfo
(theMeshInfo,
theEntity,
theGeom,
theIndexes,
theConnectivities,
theConnMode,
theFamilyNums,
theElemNums,
theElemNames));
}
//----------------------------------------------------------------------------
PPolygoneInfo
TWrapper
::CrPolygoneInfo(const PMeshInfo& theMeshInfo,
const PPolygoneInfo& theInfo)
{
return PPolygoneInfo(new TTPolygoneInfo
(theMeshInfo,
theInfo));
}
//----------------------------------------------------------------------------
PPolygoneInfo
TWrapper
::GetPPolygoneInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
EConnectivite theConnMode)
{
if (theMeshInfo->GetType() != eNON_STRUCTURE)
return PPolygoneInfo();
TInt aNbElem = GetNbPolygones(theMeshInfo, theEntity, theGeom, theConnMode);
TInt aConnSize = GetPolygoneConnSize(theMeshInfo, theEntity, theGeom, theConnMode);
PPolygoneInfo anInfo = CrPolygoneInfo(theMeshInfo, theEntity, theGeom, aNbElem, aConnSize, theConnMode);
GetPolygoneInfo(anInfo);
#ifdef _DEBUG_
INITMSG("GetPPolygoneInfo"<<
" - theGeom = "<<theGeom<<
"; aNbElem = "<<aNbElem<<": ");
for (TInt iElem = 1; iElem < aNbElem; iElem++) {
TCConnSlice aConnSlice = anInfo->GetConnSlice(iElem);
TInt aConnDim = aConnSlice.size();
for (TInt iConn = 0; iConn < aConnDim; iConn++) {
ADDMSG(aConnSlice[iConn]<<",");
}
ADDMSG(" ");
}
ADDMSG(std::endl);
#endif
return anInfo;
}
//----------------------------------------------------------------------------
TInt
TWrapper
::GetNbPolyedres(const MED::TMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
EConnectivite theConnMode,
TErr* theErr)
{
return GetNbCells(theMeshInfo, theEntity, theGeom, theConnMode, theErr);
}
//----------------------------------------------------------------------------
void
TWrapper
::GetPolyedreConnSize(const TMeshInfo& theMeshInfo,
TInt& theNbFaces,
TInt& theConnSize,
EConnectivite theConnMode,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
EXCEPTION(std::runtime_error, "GetPolyedreConnSize - (...)");
MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
TValueHolder<EConnectivite, med_connectivity_mode> aConnMode(theConnMode);
//TValueHolder<TInt, med_int> aNbFaces(theNbFaces);
//TValueHolder<TInt, med_int> aConnSize(theConnSize);
med_bool chgt, trsf;
theNbFaces = MEDmeshnEntity(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_CELL,
MED_POLYHEDRON,
MED_INDEX_NODE,
aConnMode,
&chgt,
&trsf);
theConnSize = MEDmeshnEntity(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_CELL,
MED_POLYHEDRON,
MED_CONNECTIVITY,
aConnMode,
&chgt,
&trsf);
if (theNbFaces < 0 || theConnSize<0)
EXCEPTION(std::runtime_error, "GetPolygoneInfo - MEDmeshnEntity(...)");
}
//-----------------------------------------------------------------
void
TWrapper
::GetPolyedreInfo(TPolyedreInfo& theInfo,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return;
MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
TInt aNbElem = (TInt)theInfo.myElemNum->size();
TValueHolder<TElemNum, med_int> anIndex(theInfo.myIndex);
TValueHolder<TElemNum, med_int> aFaces(theInfo.myFaces);
TValueHolder<TElemNum, med_int> aConn(theInfo.myConn);
TValueHolder<EConnectivite, med_connectivity_mode> aConnMode(theInfo.myConnMode);
TErr aRet;
aRet = MEDmeshPolyhedronRd(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_CELL,
aConnMode,
&anIndex,
&aFaces,
&aConn);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "GetPolygoneInfo - MEDmeshPolyhedronRd(...)");
if (theInfo.myIsElemNames) {
GetNames(theInfo, aNbElem, theInfo.myEntity, ePOLYEDRE, &aRet);
if (theErr)
*theErr = aRet;
}
if (theInfo.myIsElemNum) {
GetNumeration(theInfo, aNbElem, theInfo.myEntity, ePOLYEDRE, &aRet);
if (theErr)
*theErr = aRet;
}
GetFamilies(theInfo, aNbElem, theInfo.myEntity, ePOLYEDRE, &aRet);
if (theErr)
*theErr = aRet;
}
//----------------------------------------------------------------------------
void
TWrapper
::SetPolyedreInfo(const TPolyedreInfo& theInfo,
TErr* theErr)
{
SetPolyedreInfo(theInfo, eLECTURE_ECRITURE, theErr);
}
//----------------------------------------------------------------------------
void
TWrapper
::SetPolyedreInfo(const MED::TPolyedreInfo& theInfo,
EModeAcces theMode,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, theMode, theErr, myMinor);
if (theErr && *theErr < 0)
return;
MED::TPolyedreInfo& anInfo = const_cast<MED::TPolyedreInfo&>(theInfo);
MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
TValueHolder<TElemNum, med_int> anIndex(anInfo.myIndex);
TValueHolder<TElemNum, med_int> aFaces(anInfo.myFaces);
TValueHolder<TElemNum, med_int> aConn(anInfo.myConn);
TValueHolder<EConnectivite, med_connectivity_mode> aConnMode(anInfo.myConnMode);
TErr aRet;
aRet = MEDmeshPolyhedronWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_UNDEF_DT,
MED_CELL,
aConnMode,
anInfo.myNbElem+1,
&anIndex,
(TInt)anInfo.myFaces->size(),
&aFaces,
&aConn);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "SetPolyedreInfo - MEDmeshPolyhedronWr(...)");
TValueHolder<EEntiteMaillage, med_entity_type> anEntity(anInfo.myEntity);
if (theInfo.myIsElemNames) {
TValueHolder<TString, char> anElemNames(anInfo.myElemNames);
aRet = MEDmeshEntityNameWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
anEntity,
MED_POLYHEDRON,
(TInt)anInfo.myElemNames->size(),
&anElemNames);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "SetPolyedreInfo - MEDmeshEntityNameWr(...)");
}
if (theInfo.myIsElemNum) {
TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
aRet = MEDmeshEntityNumberWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
anEntity,
MED_POLYHEDRON,
(TInt)anInfo.myElemNum->size(),
&anElemNum);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "SetPolyedreInfo - MEDmeshEntityNumberWr(...)");
}
TValueHolder<TElemNum, med_int> aFamNum(anInfo.myFamNum);
aRet = MEDmeshEntityFamilyNumberWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
anEntity,
MED_POLYHEDRON,
(TInt)anInfo.myFamNum->size(),
&aFamNum);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "SetPolyedreInfo - MEDmeshEntityFamilyNumberWr(...)");
}
//----------------------------------------------------------------------------
PPolyedreInfo
TWrapper
::CrPolyedreInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TInt theNbElem,
TInt theNbFaces,
TInt theConnSize,
EConnectivite theConnMode,
EBooleen theIsElemNum,
EBooleen theIsElemNames)
{
return PPolyedreInfo(new TTPolyedreInfo
(theMeshInfo,
theEntity,
theGeom,
theNbElem,
theNbFaces,
theConnSize,
theConnMode,
theIsElemNum,
theIsElemNames));
}
//----------------------------------------------------------------------------
PPolyedreInfo
TWrapper
::CrPolyedreInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
const TIntVector& theIndexes,
const TIntVector& theFaces,
const TIntVector& theConnectivities,
EConnectivite theConnMode,
const TIntVector& theFamilyNums,
const TIntVector& theElemNums,
const TStringVector& theElemNames)
{
return PPolyedreInfo(new TTPolyedreInfo
(theMeshInfo,
theEntity,
theGeom,
theIndexes,
theFaces,
theConnectivities,
theConnMode,
theFamilyNums,
theElemNums,
theElemNames));
}
//----------------------------------------------------------------------------
PPolyedreInfo
TWrapper
::CrPolyedreInfo(const PMeshInfo& theMeshInfo,
const PPolyedreInfo& theInfo)
{
return PPolyedreInfo(new TTPolyedreInfo
(theMeshInfo,
theInfo));
}
//----------------------------------------------------------------------------
PPolyedreInfo
TWrapper
::GetPPolyedreInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
EConnectivite theConnMode)
{
if (theMeshInfo->GetType() != eNON_STRUCTURE)
return PPolyedreInfo();
TInt aNbElem = GetNbPolyedres(theMeshInfo, theEntity, theGeom, theConnMode);
TInt aNbFaces, aConnSize;
GetPolyedreConnSize(theMeshInfo, aNbFaces, aConnSize, theConnMode);
PPolyedreInfo anInfo = CrPolyedreInfo(theMeshInfo, theEntity, theGeom, aNbElem, aNbFaces, aConnSize, theConnMode);
GetPolyedreInfo(anInfo);
#ifdef _DEBUG_
INITMSG("GetPPolyedreInfo"<<
" - theGeom = "<<theGeom<<
"; aNbElem = "<<aNbElem<<": ");
for (TInt iElem = 0; iElem < aNbElem; iElem++) {
TCConnSliceArr aConnSliceArr = anInfo->GetConnSliceArr(iElem);
TInt aNbFaces = aConnSliceArr.size();
ADDMSG("{");
for (TInt iFace = 0; iFace < aNbFaces; iFace++) {
TCConnSlice aConnSlice = aConnSliceArr[iFace];
TInt aNbConn = aConnSlice.size();
ADDMSG("[");
for (TInt iConn = 0; iConn < aNbConn; iConn++) {
ADDMSG(aConnSlice[iConn]<<",");
}
ADDMSG("] ");
}
ADDMSG("} ");
}
ADDMSG(std::endl);
#endif
return anInfo;
}
//-----------------------------------------------------------------
TEntityInfo
TWrapper
::GetEntityInfo(const MED::TMeshInfo& theMeshInfo,
EConnectivite theConnMode,
TErr* theErr)
{
TEntityInfo anInfo;
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return anInfo;
if (theMeshInfo.GetType() == eNON_STRUCTURE) {
TInt aNbElem = GetNbNodes(theMeshInfo);
if (aNbElem > 0) {
anInfo[eNOEUD][ePOINT1] = aNbElem;
const TEntity2GeomSet& anEntity2GeomSet = GetEntity2GeomSet();
TEntity2GeomSet::const_iterator anIter = anEntity2GeomSet.begin();
TEntity2GeomSet::const_iterator anIterEnd = anEntity2GeomSet.end();
for (; anIter != anIterEnd; anIter++) {
const EEntiteMaillage& anEntity = anIter->first;
const TGeomSet& aGeomSet = anIter->second;
TGeomSet::const_iterator anIter2 = aGeomSet.begin();
TGeomSet::const_iterator anIterEnd2 = aGeomSet.end();
for (; anIter2 != anIterEnd2; anIter2++) {
const EGeometrieElement& aGeom = *anIter2;
aNbElem = GetNbCells(theMeshInfo, anEntity, aGeom, theConnMode, theErr);
if (aNbElem > 0) {
if (anEntity == eSTRUCT_ELEMENT) {
const TInt nbStructTypes = aNbElem;
for (TInt structType = 0; structType < nbStructTypes; ++structType) {
// check type name to keep only "MED_BALL" structured element
TValueHolder<TString, char> aMeshName((TString&) theMeshInfo.myName);
char geotypename[ MED_NAME_SIZE + 1] = "";
med_geometry_type geotype;
MEDmeshEntityInfo(myFile->Id(), &aMeshName, MED_NO_DT, MED_NO_IT,
med_entity_type(anEntity), structType+1,
geotypename, &geotype);
if (strcmp(geotypename, MED_BALL_NAME) == 0) {
aNbElem = GetNbCells(theMeshInfo, anEntity, EGeometrieElement(geotype),
theConnMode, theErr);
if (aNbElem > 0)
anInfo[anEntity][EGeometrieElement(geotype)] = aNbElem;
}
}
}
else {
anInfo[anEntity][aGeom] = aNbElem;
}
}
}
}
}
}
else { // eSTRUCTURE
EGrilleType aGrilleType;
TInt aNbNodes = 1;
TInt aNbElem = 1;
TInt aNbSub = 0;
TInt aDim = theMeshInfo.GetDim();
EGeometrieElement aGeom, aSubGeom;
EEntiteMaillage aSubEntity = eMAILLE;
GetGrilleType(theMeshInfo, aGrilleType);
TIntVector aStruct(aDim);
if (aGrilleType == eGRILLE_STANDARD)
{
GetGrilleStruct(theMeshInfo, aStruct, theErr);
}
else
{ // eGRILLE_CARTESIENNE and eGRILLE_POLAIRE
ETable aTable[3] = { eCOOR_IND1, eCOOR_IND2, eCOOR_IND3 };
for (med_int anAxis = 0; anAxis < aDim; anAxis++)
aStruct[ anAxis ] = GetNbNodes(theMeshInfo, aTable[anAxis]);
}
for (med_int i = 0; i < aDim; i++) {
aNbNodes = aNbNodes * aStruct[i];
aNbElem = aNbElem * (aStruct[i] - 1);
}
switch (aDim) {
case 1:
aGeom = eSEG2;
break;
case 2:
aGeom = eQUAD4;
aSubGeom = eSEG2;
aSubEntity = eARETE;
aNbSub =
(aStruct[0]) * (aStruct[1]-1) +
(aStruct[0]-1) * (aStruct[1]);
break;
case 3:
aGeom = eHEXA8;
aSubGeom = eQUAD4;
aSubEntity = eFACE;
aNbSub =
(aStruct[0]) * (aStruct[1]-1) * (aStruct[2]-1) +
(aStruct[0]-1) * (aStruct[1]) * (aStruct[2]-1) +
(aStruct[0]-1) * (aStruct[1]-1) * (aStruct[2]);
break;
}
anInfo[eNOEUD][ePOINT1] = aNbNodes;
anInfo[eMAILLE][aGeom] = aNbElem;
if (aDim > 1)
anInfo[aSubEntity][aSubGeom] = aNbSub;
}
return anInfo;
}
//-----------------------------------------------------------------
TInt
TWrapper
::GetNbCells(const MED::TMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
EConnectivite theConnMode,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return -1;
MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
med_bool chgt, trsf;
switch (theGeom)
{
case MED::ePOLYGONE:
case MED::ePOLYGON2:
{
return MEDmeshnEntity(myFile->Id(), &aMeshName,
MED_NO_DT, MED_NO_IT,
med_entity_type(theEntity), med_geometry_type(theGeom),
MED_INDEX_NODE, med_connectivity_mode(theConnMode),
&chgt, &trsf)-1;
}
case MED::ePOLYEDRE:
{
return MEDmeshnEntity(myFile->Id(), &aMeshName,
MED_NO_DT, MED_NO_IT,
med_entity_type(theEntity), MED_POLYHEDRON,
MED_INDEX_FACE, med_connectivity_mode(theConnMode),
&chgt, &trsf)-1;
}
case MED::eBALL:
{
return GetNbBalls(theMeshInfo);
}
default:
{
return MEDmeshnEntity(myFile->Id(), &aMeshName,
MED_NO_DT, MED_NO_IT,
med_entity_type(theEntity), med_geometry_type(theGeom),
MED_CONNECTIVITY, med_connectivity_mode(theConnMode),
&chgt, &trsf);
}
}
return 0;
}
//----------------------------------------------------------------------------
void
TWrapper
::GetCellInfo(MED::TCellInfo& theInfo,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return;
MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
TValueHolder<TString, char> aMeshName (aMeshInfo.myName);
TValueHolder<TElemNum, med_int> aConn (theInfo.myConn);
TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch (theInfo.myModeSwitch);
TValueHolder<TString, char> anElemNames (theInfo.myElemNames);
TValueHolder<EBooleen, med_bool> anIsElemNames(theInfo.myIsElemNames);
TValueHolder<TElemNum, med_int> anElemNum (theInfo.myElemNum);
TValueHolder<EBooleen, med_bool> anIsElemNum (theInfo.myIsElemNum);
TValueHolder<TElemNum, med_int> aFamNum (theInfo.myFamNum);
TValueHolder<EBooleen, med_bool> anIsFamNum (theInfo.myIsFamNum);
TValueHolder<EEntiteMaillage, med_entity_type> anEntity (theInfo.myEntity);
TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theInfo.myGeom);
TValueHolder<EConnectivite, med_connectivity_mode> aConnMode (theInfo.myConnMode);
TErr aRet;
med_bool dummy;
aRet = MEDmeshnEntity(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
anEntity,
aGeom,
MED_NAME,
aConnMode,
&dummy, &dummy);
if ( aRet > 0 )
{
// names are present in the file, they will be read in spite of theInfo.myIsElemNames
theInfo.myIsElemNames = eVRAI;
theInfo.myElemNames.reset( new TString( theInfo.myNbElem * GetPNOMLength() + 1 ));
anElemNames.myRepresentation = & ((TString&) theInfo.myElemNames )[0];
}
aRet = MEDmeshElementRd(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
anEntity,
aGeom,
aConnMode,
aModeSwitch,
&aConn,
&anIsElemNames,
&anElemNames,
&anIsElemNum,
&anElemNum,
&anIsFamNum,
&aFamNum);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "GetCellInfo - MEDmeshElementRd(...)");
if (anIsFamNum == MED_FALSE)
{
int mySize = (int) theInfo.myFamNum->size();
theInfo.myFamNum->clear();
theInfo.myFamNum->resize(mySize, 0);
}
}
//----------------------------------------------------------------------------
void
TWrapper
::SetCellInfo(const MED::TCellInfo& theInfo,
TErr* theErr)
{
SetCellInfo(theInfo, eLECTURE_ECRITURE, theErr);
}
//----------------------------------------------------------------------------
void
TWrapper
::SetCellInfo(const MED::TCellInfo& theInfo,
EModeAcces theMode,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, theMode, theErr, myMinor);
if (theErr && *theErr < 0)
return;
MED::TCellInfo& anInfo = const_cast<MED::TCellInfo&>(theInfo);
MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
TValueHolder<TString, char> aMeshName (aMeshInfo.myName);
TValueHolder<TElemNum, med_int> aConn (anInfo.myConn);
TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch (anInfo.myModeSwitch);
TValueHolder<TString, char> anElemNames (anInfo.myElemNames);
TValueHolder<EBooleen, med_bool> anIsElemNames(anInfo.myIsElemNames);
TValueHolder<TElemNum, med_int> anElemNum (anInfo.myElemNum);
TValueHolder<EBooleen, med_bool> anIsElemNum (anInfo.myIsElemNum);
TValueHolder<TElemNum, med_int> aFamNum (anInfo.myFamNum);
TValueHolder<EBooleen, med_bool> anIsFamNum (anInfo.myIsFamNum);
TValueHolder<EEntiteMaillage, med_entity_type> anEntity (anInfo.myEntity);
TValueHolder<EGeometrieElement, med_geometry_type> aGeom (anInfo.myGeom);
TValueHolder<EConnectivite, med_connectivity_mode> aConnMode (anInfo.myConnMode);
TValueHolder<TInt, med_int> aNbElem (anInfo.myNbElem);
TErr aRet;
aRet = MEDmeshElementConnectivityWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_UNDEF_DT,
anEntity,
aGeom,
aConnMode,
aModeSwitch,
aNbElem,
&aConn);
MEDmeshEntityFamilyNumberWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
anEntity,
aGeom,
aNbElem,
&aFamNum);
if (anIsElemNames)
MEDmeshEntityNameWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
anEntity,
aGeom,
aNbElem,
&anElemNames);
if (anIsElemNum)
MEDmeshEntityNumberWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
anEntity,
aGeom,
aNbElem,
&anElemNum);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "SetCellInfo - MEDmeshElementWr(...), ret="<< aRet);
}
//----------------------------------------------------------------------------
PCellInfo
TWrapper
::CrCellInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TInt theNbElem,
EConnectivite theConnMode,
EBooleen theIsElemNum,
EBooleen theIsElemNames,
EModeSwitch theMode)
{
return PCellInfo(new TTCellInfo
(theMeshInfo,
theEntity,
theGeom,
theNbElem,
theConnMode,
theIsElemNum,
theIsElemNames,
theMode));
}
//----------------------------------------------------------------------------
PCellInfo
TWrapper
::CrCellInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
const TIntVector& theConnectivities,
EConnectivite theConnMode,
const TIntVector& theFamilyNums,
const TIntVector& theElemNums,
const TStringVector& theElemNames,
EModeSwitch theMode)
{
return PCellInfo(new TTCellInfo
(theMeshInfo,
theEntity,
theGeom,
theConnectivities,
theConnMode,
theFamilyNums,
theElemNums,
theElemNames,
theMode));
}
//----------------------------------------------------------------------------
PCellInfo
TWrapper
::CrCellInfo(const PMeshInfo& theMeshInfo,
const PCellInfo& theInfo)
{
return PCellInfo(new TTCellInfo
(theMeshInfo,
theInfo));
}
//----------------------------------------------------------------------------
PCellInfo
TWrapper
::GetPCellInfo(const PMeshInfo& theMeshInfo,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
EConnectivite theConnMode,
TErr* theErr)
{
if (theMeshInfo->GetType() != eNON_STRUCTURE)
return PCellInfo();
TInt aNbElem = GetNbCells(theMeshInfo, theEntity, theGeom, theConnMode);
PCellInfo anInfo = CrCellInfo(theMeshInfo, theEntity, theGeom, aNbElem, theConnMode);
GetCellInfo(anInfo, theErr);
#ifdef _DEBUG_
TInt aConnDim = anInfo->GetConnDim();
INITMSG("GetPCellInfo - theEntity = "<<theEntity<<"; theGeom = "<<theGeom<<"; aConnDim: "<<aConnDim<<"\n");
BEGMSG("GetPCellInfo - aNbElem: "<<aNbElem<<": ");
for (TInt iElem = 0; iElem < aNbElem; iElem++) {
TCConnSlice aConnSlice = anInfo->GetConnSlice(iElem);
for (TInt iConn = 0; iConn < aConnDim; iConn++) {
ADDMSG(aConnSlice[iConn]<<",");
}
ADDMSG(" ");
}
ADDMSG(std::endl);
BEGMSG("GetPCellInfo - GetFamNum: ");
for (TInt iElem = 0; iElem < aNbElem; iElem++) {
ADDMSG(anInfo->GetFamNum(iElem)<<", ");
}
ADDMSG(std::endl);
if (anInfo->IsElemNum()) {
BEGMSG("GetPCellInfo - GetElemNum: ");
for (TInt iElem = 0; iElem < aNbElem; iElem++) {
ADDMSG(anInfo->GetElemNum(iElem)<<", ");
}
ADDMSG(std::endl);
}
ADDMSG(std::endl);
#endif
return anInfo;
}
//----------------------------------------------------------------------------
EGeometrieElement
TWrapper
::GetBallGeom(const TMeshInfo& /*theMeshInfo*/)
{
TErr anError;
TFileWrapper aFileWrapper(myFile, eLECTURE, &anError, myMinor);
// read med_geometry_type of "MED_BALL" element
char geotypename[ MED_NAME_SIZE + 1] = MED_BALL_NAME;
return EGeometrieElement(MEDstructElementGeotype(myFile->Id(), geotypename));
}
//----------------------------------------------------------------------------
TInt
TWrapper
::GetNbBalls(const TMeshInfo& theMeshInfo)
{
TErr anError;
TFileWrapper aFileWrapper(myFile, eLECTURE, &anError, myMinor);
EGeometrieElement ballType = GetBallGeom(theMeshInfo);
if (ballType < 0)
return 0;
return GetNbCells(theMeshInfo, eSTRUCT_ELEMENT, ballType, eNOD);
}
//----------------------------------------------------------------------------
void
TWrapper
::GetBallInfo(TBallInfo& theInfo,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
// check geometry of MED_BALL
if (theInfo.myGeom == eBALL)
{
theInfo.myGeom = GetBallGeom(*theInfo.myMeshInfo);
if (theInfo.myGeom < 0) {
if (!theErr)
EXCEPTION(std::runtime_error, "GetBallInfo - no balls in the mesh");
*theErr = theInfo.myGeom;
return;
}
}
// read nodes ids
GetCellInfo(theInfo);
// read diameters
TValueHolder<TString, char> aMeshName (theInfo.myMeshInfo->myName);
TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theInfo.myGeom);
TValueHolder<TFloatVector, void> aDiam (theInfo.myDiameters);
char varattname[ MED_NAME_SIZE + 1] = MED_BALL_DIAMETER;
TErr aRet = MEDmeshStructElementVarAttRd(myFile->Id(), &aMeshName,
MED_NO_DT, MED_NO_IT,
aGeom,
varattname,
&aDiam);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "GetBallInfo - pb at reading diameters");
}
//----------------------------------------------------------------------------
void
TWrapper
::SetBallInfo(const TBallInfo& theInfo,
TErr* theErr)
{
SetBallInfo(theInfo, eLECTURE_ECRITURE, theErr);
}
//----------------------------------------------------------------------------
void
TWrapper
::SetBallInfo(const TBallInfo& theInfo,
EModeAcces theMode,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, theMode, theErr, myMinor);
TErr ret;
char ballsupportname[MED_NAME_SIZE+1] = "BALL_SUPPORT_MESH";
EGeometrieElement ballGeom = GetBallGeom(*theInfo.myMeshInfo);
if (ballGeom < 0)
{
// no ball model in the file, create support mesh for it
char dummyname [MED_NAME_SIZE*3+1] = "";
if ((ret = MEDsupportMeshCr(myFile->Id(),
ballsupportname,
theInfo.myMeshInfo->GetSpaceDim(),
theInfo.myMeshInfo->GetDim(),
"Support mesh for a ball model",
MED_CARTESIAN,
/*axisname=*/dummyname,
/*unitname=*/dummyname)) < 0) {
if (!theErr)
EXCEPTION(std::runtime_error, "SetBallInfo - MEDsupportMeshCr");
*theErr = ret;
return;
}
// write coordinates of 1 node
med_float coord[3] = {0, 0, 0};
if ((ret = MEDmeshNodeCoordinateWr(myFile->Id(),
ballsupportname, MED_NO_DT, MED_NO_IT, 0.0,
MED_FULL_INTERLACE, /*nnode=*/1, coord)) < 0) {
if (!theErr)
EXCEPTION(std::runtime_error, "SetBallInfo - MEDmeshNodeCoordinateWr");
*theErr = ret;
return;
}
// ball model creation
char geotypename[ MED_NAME_SIZE + 1] = MED_BALL_NAME;
if ((ballGeom = (EGeometrieElement) MEDstructElementCr(myFile->Id(),
geotypename,
theInfo.myMeshInfo->GetSpaceDim(),
ballsupportname,
MED_NODE,MED_NONE)) < 0) {
if (!theErr)
EXCEPTION(std::runtime_error, "SetBallInfo - MEDstructElementCr");
*theErr = ret;
return;
}
// create diameter attribute
if ((ret = MEDstructElementVarAttCr(myFile->Id(),
geotypename, MED_BALL_DIAMETER,
MED_ATT_FLOAT64, /*ncomp=*/1)) < 0) {
if (!theErr)
EXCEPTION(std::runtime_error, "SetBallInfo - MEDstructElementVarAttCr");
*theErr = ret;
return;
}
} // ballGeom < 0
TBallInfo& aBallInfo = ((TBallInfo&) theInfo);
aBallInfo.myGeom = ballGeom;
// write node ids
SetCellInfo(theInfo, theMode, theErr);
if (theErr && *theErr < 0)
return;
// write diameter
TValueHolder<TString, char> aMeshName (aBallInfo.myMeshInfo->myName);
TValueHolder<EGeometrieElement, med_geometry_type> aGeom (aBallInfo.myGeom);
TValueHolder<TFloatVector, void> aDiam (aBallInfo.myDiameters);
ret = MEDmeshStructElementVarAttWr(myFile->Id(), &aMeshName,
MED_NO_DT, MED_NO_IT,
aGeom, MED_BALL_DIAMETER,
theInfo.myNbElem, &aDiam);
if (theErr)
*theErr = ret;
else if (ret < 0)
EXCEPTION(std::runtime_error, "SetBallInfo - MEDmeshStructElementVarAttWr");
}
//----------------------------------------------------------------------------
PBallInfo
TWrapper
::CrBallInfo(const PMeshInfo& theMeshInfo,
TInt theNbBalls,
EBooleen theIsElemNum)
{
return PBallInfo(new TTBallInfo(theMeshInfo, theNbBalls, theIsElemNum));
}
//----------------------------------------------------------------------------
PBallInfo
TWrapper
::CrBallInfo(const PMeshInfo& theMeshInfo,
const TIntVector& theNodes,
TFloatVector& theDiameters,
const TIntVector& theFamilyNums,
const TIntVector& theElemNums)
{
return PBallInfo(new TTBallInfo(theMeshInfo, theNodes, theDiameters,
theFamilyNums, theElemNums));
}
//----------------------------------------------------------------------------
PBallInfo
TWrapper
::CrBallInfo(const PMeshInfo& theMeshInfo,
const PBallInfo& theInfo)
{
return PBallInfo(new TTBallInfo(theMeshInfo, theInfo));
}
//----------------------------------------------------------------------------
PBallInfo
TWrapper
::GetPBallInfo(const PMeshInfo& theMeshInfo)
{
TInt nbBalls = GetNbBalls(theMeshInfo);
if (nbBalls < 1) return PBallInfo();
PBallInfo anInfo = CrBallInfo(theMeshInfo, nbBalls);
GetBallInfo(anInfo);
return anInfo;
}
//-----------------------------------------------------------------
TInt
TWrapper
::GetNbFields(TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return -1;
return MEDnField(myFile->Id());
}
//----------------------------------------------------------------------------
TInt
TWrapper
::GetNbComp(TInt theFieldId,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return -1;
return MEDfieldnComponent(myFile->Id(), theFieldId);
}
//----------------------------------------------------------------------------
void
TWrapper
::GetFieldInfo(TInt theFieldId,
MED::TFieldInfo& theInfo,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return;
TString aFieldName(256); // Protect from memory problems with too long names
TValueHolder<ETypeChamp, med_field_type> aType(theInfo.myType);
TValueHolder<TString, char> aCompNames(theInfo.myCompNames);
TValueHolder<TString, char> anUnitNames(theInfo.myUnitNames);
MED::TMeshInfo& aMeshInfo = theInfo.myMeshInfo;
TErr aRet;
med_bool local;
char dtunit[MED_SNAME_SIZE+1];
char local_mesh_name[MED_NAME_SIZE+1]="";
med_int nbofstp;
theInfo.myNbComp = MEDfieldnComponent(myFile->Id(), theFieldId);
aRet = MEDfieldInfo(myFile->Id(),
theFieldId,
&aFieldName[0],
local_mesh_name,
&local,
&aType,
&aCompNames,
&anUnitNames,
dtunit,
&nbofstp);
if (strcmp(&aMeshInfo.myName[0], local_mesh_name) != 0) {
if (theErr)
*theErr = -1;
return;
}
theInfo.SetName(aFieldName);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "GetFieldInfo - MEDfieldInfo(...)");
}
//----------------------------------------------------------------------------
void
TWrapper
::SetFieldInfo(const MED::TFieldInfo& theInfo,
TErr* theErr)
{
TErr aRet;
SetFieldInfo(theInfo, eLECTURE_ECRITURE, &aRet);
if (aRet < 0)
SetFieldInfo(theInfo, eLECTURE_AJOUT, &aRet);
if (theErr)
*theErr = aRet;
}
//----------------------------------------------------------------------------
void
TWrapper
::SetFieldInfo(const MED::TFieldInfo& theInfo,
EModeAcces theMode,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, theMode, theErr, myMinor);
if (theErr && *theErr < 0)
return;
MED::TFieldInfo& anInfo = const_cast<MED::TFieldInfo&>(theInfo);
TValueHolder<TString, char> aFieldName(anInfo.myName);
TValueHolder<ETypeChamp, med_field_type> aType(anInfo.myType);
TValueHolder<TString, char> aCompNames(anInfo.myCompNames);
TValueHolder<TString, char> anUnitNames(anInfo.myUnitNames);
MED::TMeshInfo& aMeshInfo = anInfo.myMeshInfo;
TErr aRet;
char dtunit[MED_SNAME_SIZE+1];
std::fill(dtunit, dtunit+MED_SNAME_SIZE+1, '\0');
aRet = MEDfieldCr(myFile->Id(),
&aFieldName,
aType,
anInfo.myNbComp,
&aCompNames,
&anUnitNames,
dtunit,
&aMeshInfo.myName[0]);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "SetFieldInfo - MEDfieldCr(...)");
}
//----------------------------------------------------------------------------
PFieldInfo
TWrapper
::CrFieldInfo(const PMeshInfo& theMeshInfo,
TInt theNbComp,
ETypeChamp theType,
const std::string& theValue,
EBooleen theIsLocal,
TInt theNbRef)
{
return PFieldInfo(new TTFieldInfo
(theMeshInfo,
theNbComp,
theType,
theValue,
theIsLocal,
theNbRef));
}
//----------------------------------------------------------------------------
PFieldInfo
TWrapper
::CrFieldInfo(const PMeshInfo& theMeshInfo,
const PFieldInfo& theInfo)
{
return PFieldInfo(new TTFieldInfo
(theMeshInfo,
theInfo));
}
//----------------------------------------------------------------------------
PFieldInfo
TWrapper
::GetPFieldInfo(const PMeshInfo& theMeshInfo,
TInt theId,
TErr* theErr)
{
TInt aNbComp = GetNbComp(theId);
PFieldInfo anInfo = CrFieldInfo(theMeshInfo, aNbComp);
GetFieldInfo(theId, *anInfo, theErr);
#ifdef _DEBUG_
INITMSG("GetPFieldInfo "<<
"- aName = '"<<anInfo->GetName()<<"'"<<
"; aType = "<<anInfo->GetType()<<
"; aNbComp = "<<aNbComp<<
std::endl);
#endif
return anInfo;
}
//----------------------------------------------------------------------------
TInt
TWrapper
::GetNbGauss(TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return -1;
return MEDnLocalization(myFile->Id());
}
//----------------------------------------------------------------------------
TGaussInfo::TInfo
TWrapper
::GetGaussPreInfo(TInt theId,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return TGaussInfo::TInfo(TGaussInfo::TKey(ePOINT1, ""), 0);
med_int aNbGaussPoints = med_int();
TVector<char> aName(GetNOMLength()+1);
med_geometry_type aGeom = MED_NONE;
TErr aRet;
med_int dim;
char geointerpname[MED_NAME_SIZE+1] = "";
char ipointstructmeshname[MED_NAME_SIZE+1] = "";
med_int nsectionmeshcell;
med_geometry_type sectiongeotype;
aRet = MEDlocalizationInfo (myFile->Id(),
theId,
&aName[0],
&aGeom,
&dim,
&aNbGaussPoints,
geointerpname,
ipointstructmeshname,
&nsectionmeshcell,
&sectiongeotype);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "GetGaussPreInfo - MEDlocalizationInfo(...)");
return TGaussInfo::TInfo(TGaussInfo::TKey(EGeometrieElement(aGeom), &aName[0]),
TInt(aNbGaussPoints));
}
//----------------------------------------------------------------------------
void
TWrapper
::GetGaussInfo(TInt /*theId*/,
TGaussInfo& theInfo,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return;
TValueHolder<TNodeCoord, med_float> aRefCoord(theInfo.myRefCoord);
TValueHolder<TNodeCoord, med_float> aGaussCoord(theInfo.myGaussCoord);
TValueHolder<TWeight, med_float> aWeight(theInfo.myWeight);
TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(theInfo.myModeSwitch);
TValueHolder<TString, char> aGaussName(theInfo.myName);
TErr aRet;
aRet = MEDlocalizationRd(myFile->Id(),
&aGaussName,
aModeSwitch,
&aRefCoord,
&aGaussCoord,
&aWeight);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "GetGaussInfo - MEDlocalizationRd(...)");
}
//----------------------------------------------------------------------------
PGaussInfo
TWrapper
::CrGaussInfo(const TGaussInfo::TInfo& theInfo,
EModeSwitch theMode)
{
return PGaussInfo(new TTGaussInfo
(theInfo,
theMode));
}
//-----------------------------------------------------------------
TInt
TWrapper
::GetNbTimeStamps(const MED::TFieldInfo& theInfo,
const MED::TEntityInfo& theEntityInfo,
EEntiteMaillage& theEntity,
TGeom2Size& theGeom2Size,
TErr* theErr)
{
theEntity = EEntiteMaillage(-1);
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr) {
if (theEntityInfo.empty())
*theErr = -1;
if (*theErr < 0)
return -1;
}
else if (theEntityInfo.empty())
EXCEPTION(std::runtime_error, "GetNbTimeStamps - There is no any Entity on the Mesh");
bool anIsPerformAdditionalCheck = GetNbMeshes() > 1;
theGeom2Size.clear();
TInt aNbTimeStamps = 0;
TIdt anId = myFile->Id();
MED::TFieldInfo& anInfo = const_cast<MED::TFieldInfo&>(theInfo);
TValueHolder<TString, char> aFieldName(anInfo.myName);
MED::TMeshInfo& aMeshInfo = anInfo.myMeshInfo;
// workaround for IPAL13676
MED::TEntityInfo localEntityInfo = theEntityInfo;
TEntityInfo::iterator anLocalIter = localEntityInfo.find(eMAILLE);
if (anLocalIter != localEntityInfo.end()) {
localEntityInfo[eNOEUD_ELEMENT] = anLocalIter->second;
}
TEntityInfo::const_iterator anIter = localEntityInfo.begin();
for (; anIter != localEntityInfo.end(); anIter++) {
med_entity_type anEntity = med_entity_type(anIter->first);
const TGeom2Size& aGeom2Size = anIter->second;
TGeom2Size::const_iterator anGeomIter = aGeom2Size.begin();
for (; anGeomIter != aGeom2Size.end(); anGeomIter++) {
med_geometry_type aGeom = med_geometry_type(anGeomIter->first);
char aMeshName[MED_NAME_SIZE+1];
med_bool islocal;
med_field_type ft;
char dtunit[MED_SNAME_SIZE+1];
med_int myNbComp = MEDfieldnComponentByName(anId, &aFieldName);
char *cname=new char[myNbComp*MED_SNAME_SIZE+1];
char *unitname=new char[myNbComp*MED_SNAME_SIZE+1];
TInt aNbStamps;
MEDfieldInfoByName(anId,
&aFieldName,
aMeshName,
&islocal,
&ft,
cname,
unitname,
dtunit,
&aNbStamps);
delete [] cname;
delete [] unitname;
med_int nval = 0;
med_int aNumDt;
med_int aNumOrd;
med_float aDt;
if (aNbStamps > 0)
{
MEDfieldComputingStepInfo(anId,
&aFieldName,
1,
&aNumDt,
&aNumOrd,
&aDt);
char profilename[MED_NAME_SIZE+1];
char locname[MED_NAME_SIZE+1];
med_int profilsize;
med_int aNbGauss;
// protection from crash (division by zero)
// inside MEDfieldnValueWithProfile function
// caused by the workaround for IPAL13676 (see above)
if (anEntity == MED_NODE_ELEMENT && aGeom % 100 == 0)
continue;
nval = MEDfieldnValueWithProfile(anId,
&aFieldName,
aNumDt,
aNumOrd,
anEntity,
med_geometry_type(aGeom),
1,
MED_COMPACT_STMODE,
profilename,
&profilsize,
locname,
&aNbGauss);
}
bool anIsSatisfied =(nval > 0);
if (anIsSatisfied) {
INITMSG("GetNbTimeStamps aNbTimeStamps = "<<aNbStamps<<
"; aGeom = "<<aGeom<<"; anEntity = "<<anEntity<<"\n");
if (anIsPerformAdditionalCheck) {
anIsSatisfied = !strcmp(&aMeshName[0], &aMeshInfo.myName[0]);
if (!anIsSatisfied) {
INITMSG("GetNbTimeStamps aMeshName = '"<<&aMeshName[0]<<"' != "<<
"; aMeshInfo.myName = '"<<&aMeshInfo.myName[0]<<"'\n");
}
}
}
if (anIsSatisfied) {
theGeom2Size[EGeometrieElement(aGeom)] = anGeomIter->second;
theEntity = EEntiteMaillage(anEntity);
aNbTimeStamps = aNbStamps;
}
}
if (!theGeom2Size.empty())
break;
}
return aNbTimeStamps;
}
//----------------------------------------------------------------------------
void
TWrapper
::GetTimeStampInfo(TInt theTimeStampId,
MED::TTimeStampInfo& theInfo,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
const TGeom2Size& aGeom2Size = theInfo.myGeom2Size;
if (theErr) {
if (aGeom2Size.empty())
*theErr = -1;
if (*theErr < 0)
return;
}
else if (aGeom2Size.empty())
EXCEPTION(std::runtime_error, "GetTimeStampInfo - There is no any cell");
MED::TFieldInfo& aFieldInfo = *theInfo.myFieldInfo;
MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo;
TValueHolder<TString, char> aFieldName(aFieldInfo.myName);
TValueHolder<EEntiteMaillage, med_entity_type> anEntity(theInfo.myEntity);
TValueHolder<TInt, med_int> aNumDt(theInfo.myNumDt);
TValueHolder<TInt, med_int> aNumOrd(theInfo.myNumOrd);
TValueHolder<TString, char> anUnitDt(theInfo.myUnitDt);
TValueHolder<TFloat, med_float> aDt(theInfo.myDt);
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
TValueHolder<EBooleen, med_bool> anIsLocal(aFieldInfo.myIsLocal);
TValueHolder<TInt, med_int> aNbRef(aFieldInfo.myNbRef);
TGeom2NbGauss& aGeom2NbGauss = theInfo.myGeom2NbGauss;
// just to get a time stamp unit (anUnitDt)
med_field_type aFieldType;
med_int aNbComp = MEDfieldnComponentByName(myFile->Id(), &aFieldName);
char *aCompName = new char[aNbComp*MED_SNAME_SIZE+1];
char *aCompUnit = new char[aNbComp*MED_SNAME_SIZE+1];
TInt aNbStamps;
MEDfieldInfoByName(myFile->Id(),
&aFieldName,
&aMeshName,
&anIsLocal,
&aFieldType,
aCompName,
aCompUnit,
&anUnitDt,
&aNbStamps);
delete [] aCompName;
delete [] aCompUnit;
TGeom2Size::const_iterator anIter = aGeom2Size.begin();
for (; anIter != aGeom2Size.end(); anIter++) {
const EGeometrieElement& aGeom = anIter->first;
med_int aNbGauss = -1;
TErr aRet;
aRet = MEDfieldComputingStepInfo(myFile->Id(),
&aFieldName,
theTimeStampId,
&aNumDt,
&aNumOrd,
&aDt);
char profilename[MED_NAME_SIZE+1];
med_int profilsize;
char locname[MED_NAME_SIZE+1];
MEDfieldnValueWithProfile(myFile->Id(),
&aFieldName,
aNumDt,
aNumOrd,
anEntity,
med_geometry_type(aGeom),
1,
MED_COMPACT_STMODE,
profilename,
&profilsize,
locname,
&aNbGauss);
static TInt MAX_NB_GAUSS_POINTS = 32;
if (aNbGauss <= 0 || aNbGauss > MAX_NB_GAUSS_POINTS)
aNbGauss = 1;
aGeom2NbGauss[aGeom] = aNbGauss;
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "GetTimeStampInfo - MEDfieldnValueWithProfile(...)");
}
}
//----------------------------------------------------------------------------
PTimeStampInfo
TWrapper
::CrTimeStampInfo(const PFieldInfo& theFieldInfo,
EEntiteMaillage theEntity,
const TGeom2Size& theGeom2Size,
const TGeom2NbGauss& theGeom2NbGauss,
TInt theNumDt,
TInt theNumOrd,
TFloat theDt,
const std::string& theUnitDt,
const TGeom2Gauss& theGeom2Gauss)
{
return PTimeStampInfo(new TTTimeStampInfo
(theFieldInfo,
theEntity,
theGeom2Size,
theGeom2NbGauss,
theNumDt,
theNumOrd,
theDt,
theUnitDt,
theGeom2Gauss));
}
//----------------------------------------------------------------------------
PTimeStampInfo
TWrapper
::CrTimeStampInfo(const PFieldInfo& theFieldInfo,
const PTimeStampInfo& theInfo)
{
return PTimeStampInfo(new TTTimeStampInfo
(theFieldInfo,
theInfo));
}
//----------------------------------------------------------------------------
PTimeStampInfo
TWrapper
::GetPTimeStampInfo(const PFieldInfo& theFieldInfo,
EEntiteMaillage theEntity,
const TGeom2Size& theGeom2Size,
TInt theId,
TErr* theErr)
{
PTimeStampInfo anInfo = CrTimeStampInfo(theFieldInfo, theEntity, theGeom2Size);
GetTimeStampInfo(theId, *anInfo, theErr);
#ifdef _DEBUG_
INITMSG("GetPTimeStampInfo - anEntity = "<<anInfo->GetEntity()<<"\n");
TGeom2NbGauss& aGeom2NbGauss = anInfo->myGeom2NbGauss;
TGeom2NbGauss::const_iterator anIter = aGeom2NbGauss.begin();
for (; anIter != aGeom2NbGauss.end(); anIter++) {
const EGeometrieElement& aGeom = anIter->first;
INITMSG("aGeom = "<<aGeom<<" - "<<aGeom2NbGauss[aGeom]<<";\n");
}
#endif
return anInfo;
}
//----------------------------------------------------------------------------
TInt
TWrapper
::GetNbProfiles(TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return -1;
return MEDnProfile(myFile->Id());
}
//----------------------------------------------------------------------------
TProfileInfo::TInfo
TWrapper
::GetProfilePreInfo(TInt theId,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return TProfileInfo::TInfo();
med_int aSize = -1;
TVector<char> aName(GetNOMLength()+1);
TErr aRet;
aRet = MEDprofileInfo(myFile->Id(),
theId,
&aName[0],
&aSize);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "GetProfilePreInfo - MEDprofileInfo(...)");
return TProfileInfo::TInfo(&aName[0], aSize);
}
//----------------------------------------------------------------------------
void
TWrapper
::GetProfileInfo(TInt /*theId*/,
TProfileInfo& theInfo,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return;
TProfileInfo& anInfo = const_cast<TProfileInfo&>(theInfo);
TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
TValueHolder<TString, char> aProfileName(anInfo.myName);
TErr aRet;
aRet = MEDprofileRd(myFile->Id(),
&aProfileName,
&anElemNum);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "GetProfileInfo - MEDprofileRd(...)");
}
//----------------------------------------------------------------------------
void
TWrapper
::SetProfileInfo(const TProfileInfo& theInfo,
TErr* theErr)
{
TErr aRet;
SetProfileInfo(theInfo, eLECTURE_ECRITURE, &aRet);
if (aRet < 0)
SetProfileInfo(theInfo, eLECTURE_AJOUT, &aRet);
if (aRet < 0)
SetProfileInfo(theInfo, eCREATION, &aRet);
if (theErr)
*theErr = aRet;
}
//----------------------------------------------------------------------------
void
TWrapper
::SetProfileInfo(const TProfileInfo& theInfo,
EModeAcces theMode,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, theMode, theErr, myMinor);
if (theErr && *theErr < 0)
return;
TProfileInfo& anInfo = const_cast<TProfileInfo&>(theInfo);
TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
TValueHolder<TString, char> aProfileName(anInfo.myName);
TErr aRet;
aRet = MEDprofileWr(myFile->Id(), // descripteur du fichier.
&aProfileName, // tableau de valeurs du profil.
theInfo.GetSize(), // taille du profil.
&anElemNum); // nom profil.
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "SetProfileInfo - MEDprofileWr(...)");
}
//----------------------------------------------------------------------------
PProfileInfo
TWrapper
::CrProfileInfo(const TProfileInfo::TInfo& theInfo,
EModeProfil theMode)
{
return PProfileInfo(new TTProfileInfo
(theInfo,
theMode));
}
//----------------------------------------------------------------------------
PProfileInfo
TWrapper
::GetPProfileInfo(TInt theId,
EModeProfil theMode,
TErr* theErr)
{
TProfileInfo::TInfo aPreInfo = GetProfilePreInfo(theId);
PProfileInfo anInfo = CrProfileInfo(aPreInfo, theMode);
GetProfileInfo(theId, *anInfo, theErr);
return anInfo;
}
//----------------------------------------------------------------------------
void
TWrapper
::GetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
const TMKey2Profile& theMKey2Profile,
const TKey2Gauss& theKey2Gauss,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return;
TIdt anId = myFile->Id();
TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(theTimeStampValue->myModeSwitch);
MED::TGeom2Profile& aGeom2Profile = theTimeStampValue->myGeom2Profile;
MED::PTimeStampInfo aTimeStampInfo = theTimeStampValue->myTimeStampInfo;
TValueHolder<EEntiteMaillage, med_entity_type> anEntity(aTimeStampInfo->myEntity);
TValueHolder<TInt, med_int> aNumDt(aTimeStampInfo->myNumDt);
TValueHolder<TInt, med_int> aNumOrd(aTimeStampInfo->myNumOrd);
MED::PFieldInfo aFieldInfo = aTimeStampInfo->myFieldInfo;
TValueHolder<TString, char> aFieldName(aFieldInfo->myName);
TValueHolder<EBooleen, med_bool> anIsLocal(aFieldInfo->myIsLocal);
MED::PMeshInfo aMeshInfo = aFieldInfo->myMeshInfo;
TValueHolder<TString, char> aMeshName(aMeshInfo->myName);
TGeom2Gauss& aGeom2Gauss = aTimeStampInfo->myGeom2Gauss;
TVector<char> aGaussName(GetNOMLength()+1);
med_storage_mode aProfileMode = med_storage_mode(boost::get<0>(theMKey2Profile));
MED::TKey2Profile aKey2Profile = boost::get<1>(theMKey2Profile);
TVector<char> aProfileName(GetNOMLength()+1);
TGeom2Size& aGeom2Size = aTimeStampInfo->myGeom2Size;
TGeom2Size::iterator anIter = aGeom2Size.begin();
for (; anIter != aGeom2Size.end(); anIter++) {
EGeometrieElement aGeom = anIter->first;
TInt aNbElem = anIter->second;
med_int profilesize, aNbGauss;
TInt aNbVal = MEDfieldnValueWithProfile(anId,
&aFieldName,
aNumDt,
aNumOrd,
anEntity,
med_geometry_type(aGeom),
1,
aProfileMode,
&aProfileName[0],
&profilesize,
&aGaussName[0],
&aNbGauss);
if (aNbVal <= 0) {
if (theErr) {
*theErr = -1;
return;
}
EXCEPTION(std::runtime_error, "GetTimeStampValue - MEDfieldnValueWithProfile(...) - aNbVal == "<<aNbVal<<" <= 0");
}
TInt aNbComp = aFieldInfo->myNbComp;
TInt aNbValue = aNbVal;// / aNbGauss; rules in MED changed
theTimeStampValue->AllocateValue(aGeom,
aNbValue,
aNbGauss,
aNbComp);
TInt aValueSize = theTimeStampValue->GetValueSize(aGeom);
INITMSG("TWrapper::GetTimeStampValue - aGeom = "<<aGeom<<
"; aNbVal = "<<aNbVal<<
"; aNbValue = "<<aNbValue<<
"; aNbGauss = "<<aNbGauss<<
"; aNbComp = "<<aNbComp<<
std::endl);
TErr aRet = MEDfieldValueWithProfileRd(anId,
&aFieldName,
aNumDt,
aNumOrd,
anEntity,
med_geometry_type(aGeom),
aProfileMode,
&aProfileName[0],
aModeSwitch,
MED_ALL_CONSTITUENT,
theTimeStampValue->GetValuePtr(aGeom));
if (aRet < 0) {
if (theErr) {
*theErr = MED_FALSE;
return;
}
EXCEPTION(std::runtime_error, "GetTimeStampValue - MEDfieldValueWithProfileRd(...)");
}
MED::PGaussInfo aGaussInfo;
TGaussInfo::TKey aKey(aGeom, &aGaussName[0]);
if (strcmp(&aGaussName[0], "") != 0) {
MED::TKey2Gauss::const_iterator anIter = theKey2Gauss.find(aKey);
if (anIter != theKey2Gauss.end()) {
aGaussInfo = anIter->second;
aGeom2Gauss[aGeom] = aGaussInfo;
}
}
MED::PProfileInfo aProfileInfo;
if (strcmp(&aProfileName[0], MED_NO_PROFILE) != 0) {
MED::TKey2Profile::const_iterator anIter = aKey2Profile.find(&aProfileName[0]);
if (anIter != aKey2Profile.end()) {
aProfileInfo = anIter->second;
aGeom2Profile[aGeom] = aProfileInfo;
}
}
if (aGaussInfo && aNbGauss != aGaussInfo->GetNbGauss()) {
if (theErr) {
*theErr = MED_FALSE;
return;
}
EXCEPTION(std::runtime_error, "GetTimeStampValue - aNbGauss != aGaussInfo->GetNbGauss()");
}
if (aProfileInfo && aProfileInfo->IsPresent()) {
TInt aNbSubElem = aProfileInfo->GetSize();
TInt aProfileSize = aNbSubElem*aNbComp*aNbGauss;
if (aProfileSize != aValueSize) {
if (theErr) {
*theErr = -1;
return;
}
EXCEPTION(std::runtime_error,
"GetTimeStampValue - aProfileSize("<<aProfileSize<<
") != aValueSize("<<aValueSize<<
"); aNbVal = "<<aNbVal<<
"; anEntity = "<<anEntity<<
"; aGeom = "<<aGeom<<
"; aNbElem = "<<aNbElem<<
"; aNbSubElem = "<<aNbSubElem<<
"; aNbComp = "<<aNbComp<<
"; aNbGauss = "<<aNbGauss<<
"");
}
}
else{
if ((aProfileMode == MED_GLOBAL_STMODE) && (aNbElem != aNbValue)) {
if (theErr) {
*theErr = -1;
return;
}
EXCEPTION(std::runtime_error,
"GetTimeStampValue - aNbElem("<<aNbElem<<
") != aNbValue("<<aNbValue<<
"); aNbVal = "<<aNbVal<<
"; anEntity = "<<anEntity<<
"; aGeom = "<<aGeom<<
"; aNbElem = "<<aNbElem<<
"; aNbComp = "<<aNbComp<<
"; aNbGauss = "<<aNbGauss<<
"");
}
}
}
}
//----------------------------------------------------------------------------
void
TWrapper
::SetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
TErr* theErr)
{
TErr aRet;
SetTimeStampValue(theTimeStampValue, eLECTURE_ECRITURE, &aRet);
if (aRet < 0)
SetTimeStampValue(theTimeStampValue, eLECTURE_AJOUT, &aRet);
if (theErr)
*theErr = aRet;
}
//----------------------------------------------------------------------------
void
TWrapper
::SetTimeStampValue(const MED::PTimeStampValueBase& theTimeStampValue,
EModeAcces theMode,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, theMode, theErr, myMinor);
if (theErr && *theErr < 0)
return;
TErr aRet;
TIdt anId = myFile->Id();
TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(theTimeStampValue->myModeSwitch);
MED::TGeom2Profile& aGeom2Profile = theTimeStampValue->myGeom2Profile;
MED::PTimeStampInfo aTimeStampInfo = theTimeStampValue->myTimeStampInfo;
TValueHolder<EEntiteMaillage, med_entity_type> anEntity(aTimeStampInfo->myEntity);
TValueHolder<TInt, med_int> aNumDt(aTimeStampInfo->myNumDt);
TValueHolder<TInt, med_int> aNumOrd(aTimeStampInfo->myNumOrd);
TValueHolder<TString, char> anUnitDt(aTimeStampInfo->myUnitDt);
TValueHolder<TFloat, med_float> aDt(aTimeStampInfo->myDt);
MED::TGeom2Gauss& aGeom2Gauss = aTimeStampInfo->myGeom2Gauss;
MED::PFieldInfo aFieldInfo = aTimeStampInfo->myFieldInfo;
TValueHolder<TString, char> aFieldName(aFieldInfo->myName);
MED::PMeshInfo aMeshInfo = aFieldInfo->myMeshInfo;
TValueHolder<TString, char> aMeshName(aMeshInfo->myName);
const TGeomSet& aGeomSet = theTimeStampValue->myGeomSet;
TGeomSet::const_iterator anIter = aGeomSet.begin();
for (; anIter != aGeomSet.end(); anIter++) {
EGeometrieElement aGeom = *anIter;
TVector<char> aGaussName(GetNOMLength()+1);
MED::TGeom2Gauss::const_iterator aGaussIter = aGeom2Gauss.find(aGeom);
if (aGaussIter != aGeom2Gauss.end()) {
MED::PGaussInfo aGaussInfo = aGaussIter->second;
strcpy(&aGaussName[0], &aGaussInfo->myName[0]);
}
TVector<char> aProfileName(GetNOMLength()+1);
med_storage_mode aProfileMode = med_storage_mode(eNO_PFLMOD);
MED::TGeom2Profile::const_iterator aProfileIter = aGeom2Profile.find(aGeom);
if (aProfileIter != aGeom2Profile.end()) {
MED::PProfileInfo aProfileInfo = aProfileIter->second;
aProfileMode = med_storage_mode(aProfileInfo->myMode);
strcpy(&aProfileName[0], &aProfileInfo->myName[0]);
}
med_int aNbVal = theTimeStampValue->GetNbVal(aGeom);
aRet = MEDfieldValueWithProfileWr(anId,
&aFieldName,
aNumDt,
aNumOrd,
aDt,
anEntity,
med_geometry_type(aGeom),
aProfileMode,
&aProfileName[0],
&aGaussName[0],
aModeSwitch,
MED_ALL_CONSTITUENT,
aNbVal,
theTimeStampValue->GetValuePtr(aGeom));
if (aRet < 0) {
if (theErr) {
*theErr = MED_FALSE;
break;
}
EXCEPTION(std::runtime_error, "SetTimeStampValue - MEDfieldValueWithProfileWr(...)");
}
}
INITMSG("TWrapper::SetTimeStampValue - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
}
//----------------------------------------------------------------------------
PTimeStampValueBase
TWrapper
::CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
ETypeChamp theTypeChamp,
const TGeom2Profile& theGeom2Profile,
EModeSwitch theMode)
{
if (theTypeChamp == eFLOAT64)
return PTimeStampValueBase(new TTTimeStampValue<TFloatMeshValue>
(theTimeStampInfo,
theTypeChamp,
theGeom2Profile,
theMode));
return PTimeStampValueBase(new TTTimeStampValue<TIntMeshValue>
(theTimeStampInfo,
theTypeChamp,
theGeom2Profile,
theMode));
}
//----------------------------------------------------------------------------
PTimeStampValueBase
TWrapper
::CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
const TGeom2Profile& theGeom2Profile,
EModeSwitch theMode)
{
PFieldInfo aFieldInfo = theTimeStampInfo->GetFieldInfo();
return CrTimeStampValue(theTimeStampInfo,
aFieldInfo->GetType(),
theGeom2Profile,
theMode);
}
//----------------------------------------------------------------------------
PTimeStampValueBase
TWrapper
::CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
const PTimeStampValueBase& theInfo,
ETypeChamp theTypeChamp)
{
if (theTypeChamp == eFLOAT64)
return PTimeStampValueBase(new TTTimeStampValue<TFloatMeshValue>
(theTimeStampInfo,
theInfo,
theTypeChamp));
return PTimeStampValueBase(new TTTimeStampValue<TIntMeshValue>
(theTimeStampInfo,
theInfo,
theTypeChamp));
}
//----------------------------------------------------------------------------
PTimeStampValueBase
TWrapper
::CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
const PTimeStampValueBase& theInfo)
{
PFieldInfo aFieldInfo = theTimeStampInfo->GetFieldInfo();
return CrTimeStampValue(theTimeStampInfo,
theInfo,
aFieldInfo->GetType());
}
//----------------------------------------------------------------------------
PTimeStampValueBase
TWrapper
::GetPTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
const TMKey2Profile& theMKey2Profile,
const TKey2Gauss& theKey2Gauss,
TErr* theErr)
{
PFieldInfo aFieldInfo = theTimeStampInfo->GetFieldInfo();
PTimeStampValueBase anInfo = CrTimeStampValue(theTimeStampInfo,
aFieldInfo->GetType());
GetTimeStampValue(anInfo,
theMKey2Profile,
theKey2Gauss,
theErr);
#ifdef _DEBUG_
if (aFieldInfo->GetType() == eFLOAT64)
Print<TFloatTimeStampValue>(anInfo);
else
Print<TIntTimeStampValue>(anInfo);
#endif
return anInfo;
}
//----------------------------------------------------------------------------
void
TWrapper
::GetTimeStampVal(const PTimeStampVal& theVal,
const TMKey2Profile& theMKey2Profile,
const TKey2Gauss& theKey2Gauss,
TErr* theErr)
{
PTimeStampInfo aTimeStampInfo = theVal->GetTimeStampInfo();
PFieldInfo aFieldInfo = aTimeStampInfo->GetFieldInfo();
if (aFieldInfo->GetType() == eFLOAT64)
GetTimeStampValue(theVal,
theMKey2Profile,
theKey2Gauss,
theErr);
else{
PTimeStampValueBase aVal = CrTimeStampValue(aTimeStampInfo,
theVal,
eINT);
GetTimeStampValue(aVal,
theMKey2Profile,
theKey2Gauss,
theErr);
CopyTimeStampValueBase(aVal, theVal);
}
}
//----------------------------------------------------------------------------
void
TWrapper
::SetTimeStamp(const PTimeStampVal& theVal,
TErr* theErr)
{
PTimeStampInfo aTimeStampInfo = theVal->GetTimeStampInfo();
PFieldInfo aFieldInfo = aTimeStampInfo->GetFieldInfo();
if (aFieldInfo->GetType() == eFLOAT64)
SetTimeStampValue(theVal, theErr);
else{
PTimeStampValueBase aVal = CrTimeStampValue(aTimeStampInfo,
eINT,
theVal->GetGeom2Profile(),
theVal->GetModeSwitch());
CopyTimeStampValueBase(theVal, aVal);
SetTimeStampValue(aVal, theErr);
}
}
//----------------------------------------------------------------------------
PTimeStampVal
TWrapper
::CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
const TGeom2Profile& theGeom2Profile,
EModeSwitch theMode)
{
return CrTimeStampValue(theTimeStampInfo,
eFLOAT64,
theGeom2Profile,
theMode);
}
//----------------------------------------------------------------------------
PTimeStampVal
TWrapper
::CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
const PTimeStampVal& theInfo)
{
return CrTimeStampValue(theTimeStampInfo,
theInfo,
eFLOAT64);
}
//----------------------------------------------------------------------------
PTimeStampVal
TWrapper
::GetPTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
const TMKey2Profile& theMKey2Profile,
const TKey2Gauss& theKey2Gauss,
TErr* theErr)
{
PTimeStampVal anInfo = CrTimeStampVal(theTimeStampInfo);
GetTimeStampVal(anInfo,
theMKey2Profile,
theKey2Gauss,
theErr);
return anInfo;
}
//----------------------------------------------------------------------------
PGrilleInfo
TWrapper
::GetPGrilleInfo(const PMeshInfo& theMeshInfo)
{
if (theMeshInfo->GetType() != eSTRUCTURE)
return PGrilleInfo();
EGrilleType type;
GetGrilleType(*theMeshInfo, type);
PGrilleInfo anInfo;
if (type == eGRILLE_STANDARD) {
const TInt nnoeuds = GetNbNodes(*theMeshInfo);
anInfo = CrGrilleInfo(theMeshInfo, type, nnoeuds);
}
else {
TIntVector aVec;
aVec.resize(theMeshInfo->GetDim());
for (int aAxe=0;aAxe<theMeshInfo->GetDim();aAxe++) {
ETable aATable = eCOOR_IND1;
switch (aAxe) {
case 0:
aATable = eCOOR_IND1;
break;
case 1:
aATable = eCOOR_IND2;
break;
case 2:
aATable = eCOOR_IND3;
break;
}
aVec[aAxe] = GetNbNodes(*theMeshInfo, aATable);
}
anInfo = CrGrilleInfo(theMeshInfo, type, aVec);
}
GetGrilleInfo(anInfo);
anInfo->SetGrilleType(type);
#ifdef _DEBUG_
INITMSG("GetPGrilleInfo: ");
{
TInt aNbElem = anInfo->GetNbNodes();
BEGMSG("GetFamNumNode: ");
for (TInt iElem = 0; iElem < aNbElem; iElem++) {
ADDMSG(anInfo->GetFamNumNode(iElem)<<", ");
}
TInt aNbCells = anInfo->GetNbCells();
BEGMSG("GetFamNum: ");
for (TInt iElem = 0; iElem < aNbCells; iElem++) {
ADDMSG(anInfo->GetFamNum(iElem)<<", ");
}
ADDMSG(std::endl);
BEGMSG("GetCoordName: ");
for (TInt iElem = 0; iElem < theMeshInfo->GetDim(); iElem++) {
ADDMSG(anInfo->GetCoordName(iElem)<<", ");
}
ADDMSG(std::endl);
BEGMSG("GetCoordUnit: ");
for (TInt iElem = 0; iElem < theMeshInfo->GetDim(); iElem++) {
ADDMSG(anInfo->GetCoordUnit(iElem)<<", ");
}
ADDMSG(std::endl);
}
#endif
return anInfo;
}
//----------------------------------------------------------------------------
PGrilleInfo
TWrapper
::GetPGrilleInfo(const PMeshInfo& theMeshInfo,
const PGrilleInfo& theInfo)
{
PGrilleInfo anInfo = CrGrilleInfo(theMeshInfo, theInfo);
return anInfo;
}
//----------------------------------------------------------------------------
void
TWrapper
::GetGrilleInfo(TGrilleInfo& theInfo,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return;
MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
EMaillage aMaillageType = aMeshInfo.myType;
GetGrilleType(aMeshInfo, theInfo.myGrilleType, theErr);
EGrilleType aGrilleType = theInfo.myGrilleType;
TErr aRet = 0;
if (aMaillageType == eSTRUCTURE && aGrilleType == eGRILLE_STANDARD) {
GetGrilleStruct(aMeshInfo, theInfo.myGrilleStructure, theErr);
TValueHolder<TNodeCoord, med_float> aCoord(theInfo.myCoord);
TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(theInfo.myModeSwitch);
TValueHolder<TString, char> aCoordNames(theInfo.myCoordNames);
TValueHolder<TString, char> aCoordUnits(theInfo.myCoordUnits);
//med_axis_type aRepere;
aRet = MEDmeshNodeCoordinateRd(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
aModeSwitch,
&aCoord);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "GetGrilleInfo - MEDmeshNodeCoordinateRd(...)");
//TInt aNbNodes = theInfo.GetNbNodes();//GetNbFamilies(aMeshInfo);
TValueHolder<TElemNum, med_int> aFamNumNode(theInfo.myFamNumNode);
aRet = MEDmeshEntityFamilyNumberRd(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_NODE,
MED_NO_GEOTYPE,
&aFamNumNode);
if (aRet < 0) {
// if (aRet == MED_ERR_DOESNTEXIST) // --- only valid with MED3.x files
{
int mySize = (int)theInfo.myFamNumNode.size();
theInfo.myFamNumNode.clear();
theInfo.myFamNumNode.resize(mySize,0);
aRet = 0;
}
// else
// EXCEPTION(std::runtime_error, "GetGrilleInfo - MEDmeshEntityFamilyNumberRd(...)");
}
if (theErr)
*theErr = aRet;
//============================
}
if (aMaillageType == eSTRUCTURE && aGrilleType != eGRILLE_STANDARD) {
ETable aTable = eCOOR_IND1;
for (med_int anAxis = 1; anAxis <= aMeshInfo.myDim; anAxis++) {
switch (anAxis) {
case 1:
aTable = eCOOR_IND1;
break;
case 2:
aTable = eCOOR_IND2;
break;
case 3:
aTable = eCOOR_IND3;
break;
default:
aRet = -1;
}
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "GetGrilleInfo - anAxis number out of range(...)");
TInt aNbIndexes = GetNbNodes(aMeshInfo, aTable);
if (aNbIndexes < 0)
EXCEPTION(std::runtime_error, "GetGrilleInfo - Erreur a la lecture de la taille de l'indice");
TValueHolder<TFloatVector, med_float> anIndexes(theInfo.GetIndexes(anAxis-1));
//TValueHolder<ETable, med_data_type > table(aTable);
//char aCompNames[MED_SNAME_SIZE+1];
//char anUnitNames[MED_SNAME_SIZE+1];
aRet=MEDmeshGridIndexCoordinateRd(myFile->Id(),
&aMeshName,
MED_NO_DT,MED_NO_IT,
anAxis,
&anIndexes);
//theInfo.SetCoordName(anAxis-1, aCompNames);
//theInfo.SetCoordUnit(anAxis-1, anUnitNames);
theInfo.SetGrilleStructure(anAxis-1, aNbIndexes);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "GetGrilleInfo - MEDindicesCoordLire(...)");
}
}
EGeometrieElement aGeom = theInfo.GetGeom();
EEntiteMaillage aEntity = theInfo.GetEntity();
TInt aNbCells = theInfo.GetNbCells();
theInfo.myFamNum.resize(aNbCells);
TValueHolder<TElemNum, med_int> aFamNum(theInfo.myFamNum);
aRet = MEDmeshEntityFamilyNumberRd(myFile->Id(),
&aMeshName, MED_NO_DT, MED_NO_IT, med_entity_type(aEntity),
med_geometry_type(aGeom), &aFamNum);
if (aMeshInfo.myDim == 3)
{
aGeom = theInfo.GetSubGeom();
aEntity = theInfo.GetSubEntity();
aNbCells = theInfo.GetNbSubCells();
theInfo.myFamSubNum.resize(aNbCells, 0);
TValueHolder<TElemNum, med_int> aFamNum(theInfo.myFamSubNum);
aRet = MEDmeshEntityFamilyNumberRd(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
med_entity_type(aEntity),
med_geometry_type(aGeom),
&aFamNum);
}
if (aRet < 0) {
// if (aRet == MED_ERR_DOESNTEXIST) // --- only valid with MED3.x files
{
int mySize = (int)theInfo.myFamNumNode.size();
theInfo.myFamNumNode.clear();
theInfo.myFamNumNode.resize(mySize, 0);
aRet = 0;
}
// else
// EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshEntityFamilyNumberRd(...)");
}
if (theErr)
*theErr = aRet;
}
//----------------------------------------------------------------------------
void
TWrapper
::SetGrilleInfo(const MED::TGrilleInfo& theInfo,
TErr* theErr)
{
SetGrilleInfo(theInfo, eLECTURE_ECRITURE, theErr);
}
//----------------------------------------------------------------------------
void
TWrapper
::SetGrilleInfo(const MED::TGrilleInfo& theInfo,
EModeAcces theMode,
TErr* theErr)
{
if (theInfo.myMeshInfo->myType != eSTRUCTURE)
return;
TFileWrapper aFileWrapper(myFile, theMode, theErr, myMinor);
if (theErr && *theErr < 0)
return;
MED::TGrilleInfo& anInfo = const_cast<MED::TGrilleInfo&>(theInfo);
MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
TValueHolder<EGrilleType, med_grid_type > aGrilleType(anInfo.myGrilleType);
TErr aRet = 0;
aRet = MEDmeshGridTypeRd(myFile->Id(),
&aMeshName,
&aGrilleType);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "SetGrilleInfo - MEDmeshGridTypeRd(...)");
if (anInfo.myGrilleType == eGRILLE_STANDARD) {
TValueHolder<TNodeCoord, med_float> aCoord(anInfo.myCoord);
TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(anInfo.myModeSwitch);
TValueHolder<TString, char> aCoordNames(anInfo.myCoordNames);
TValueHolder<TString, char> aCoordUnits(anInfo.myCoordUnits);
med_int aNbNoeuds = med_int(anInfo.myCoord.size() / aMeshInfo.myDim);
//med_axis_type aRepere = MED_CARTESIAN;
aRet = MEDmeshNodeCoordinateWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_UNDEF_DT,
aModeSwitch,
aNbNoeuds,
&aCoord);
if (aRet < 0)
EXCEPTION(std::runtime_error, "SetGrilleInfo - MEDmeshNodeCoordinateWr(...)");
TValueHolder<TIntVector, med_int> aGrilleStructure(anInfo.myGrilleStructure);
aRet = MEDmeshGridStructWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_UNDEF_DT,
&aGrilleStructure);
if (aRet < 0)
EXCEPTION(std::runtime_error, "SetGrilleInfo - MEDmeshGridStructWr(...)");
}
else {
for (med_int aAxis = 0; aAxis < aMeshInfo.myDim; aAxis++) {
aRet = MEDmeshGridIndexCoordinateWr(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
MED_UNDEF_DT,
aAxis+1,
anInfo.GetIndexes(aAxis).size(),
&anInfo.GetIndexes(aAxis)[0]);
if (aRet < 0)
EXCEPTION(std::runtime_error, "SetGrilleInfo - MEDmeshGridIndexCoordinateWr(...)");
}
}
return;
}
//----------------------------------------------------------------------------
PGrilleInfo
TWrapper
::CrGrilleInfo(const PMeshInfo& theMeshInfo,
const PGrilleInfo& theInfo)
{
return PGrilleInfo(new TTGrilleInfo
(theMeshInfo,
theInfo));
}
//----------------------------------------------------------------------------
PGrilleInfo
TWrapper
::CrGrilleInfo(const PMeshInfo& /*theMeshInfo*/)
{
return PGrilleInfo(); // not implemented????
}
//----------------------------------------------------------------------------
PGrilleInfo
TWrapper
::CrGrilleInfo(const PMeshInfo& theMeshInfo,
const EGrilleType& type)
{
return PGrilleInfo(new TTGrilleInfo
(theMeshInfo,
type));
}
//----------------------------------------------------------------------------
PGrilleInfo
TWrapper
::CrGrilleInfo(const PMeshInfo& theMeshInfo,
const EGrilleType& type,
const TInt& nbNodes)
{
return PGrilleInfo(new TTGrilleInfo
(theMeshInfo,
type,
nbNodes));
}
//----------------------------------------------------------------------------
PGrilleInfo
TWrapper
::CrGrilleInfo(const PMeshInfo& theMeshInfo,
const EGrilleType& type,
const MED::TIntVector& nbNodeVec)
{
return PGrilleInfo(new TTGrilleInfo
(theMeshInfo,
type,
nbNodeVec));
}
//----------------------------------------------------------------------------
void
TWrapper
::GetGrilleType(const MED::TMeshInfo& theMeshInfo,
EGrilleType& theGridType,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
EXCEPTION(std::runtime_error, " GetGrilleType - aFileWrapper (...)");
MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
if (aMeshInfo.myType == eSTRUCTURE) {
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
TValueHolder<EGrilleType, med_grid_type> aGridType(theGridType);
TErr aRet = MEDmeshGridTypeRd(myFile->Id(),
&aMeshName,
&aGridType);
if (aRet < 0)
EXCEPTION(std::runtime_error, "GetGrilleInfo - MEDmeshGridTypeRd(...)");
}
}
//----------------------------------------------------------------------------
void
TWrapper
::GetGrilleStruct(const MED::TMeshInfo& theMeshInfo,
TIntVector& theStruct,
TErr* theErr)
{
TFileWrapper aFileWrapper(myFile, eLECTURE, theErr, myMinor);
if (theErr && *theErr < 0)
return;
TErr aRet;
MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
TValueHolder<TIntVector, med_int> aGridStructure(theStruct);
aRet = MEDmeshGridStructRd(myFile->Id(),
&aMeshName,
MED_NO_DT,
MED_NO_IT,
&aGridStructure);
if (theErr)
*theErr = aRet;
else if (aRet < 0)
EXCEPTION(std::runtime_error, "GetGrilleInfo - MEDmeshGridStructRd(...)");
}
}
Reference in New Issue View Git Blame Copy Permalink