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