-// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024 CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include <SALOMEDS_wrap.hxx>
#include <utilities.h>
+#include <Basics_OCCTVersion.hxx>
#include <Resource_DataMapOfAsciiStringAsciiString.hxx>
+#if OCC_VERSION_LARGE < 0x07050000
#include <Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString.hxx>
+#endif
#include "SMESH_Gen_i.hxx"
/* SALOME headers that include CORBA headers that include windows.h
#include <unistd.h>
#endif
-IMPLEMENT_STANDARD_RTTIEXT(_pyObject ,Standard_Transient);
-IMPLEMENT_STANDARD_RTTIEXT(_pyCommand ,Standard_Transient);
-IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesisReader,Standard_Transient);
-IMPLEMENT_STANDARD_RTTIEXT(_pyGen ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyMesh ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pySubMesh ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyMeshEditor ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesis ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pySelfEraser ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyGroup ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyFilter ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyAlgorithm ,_pyHypothesis);
-IMPLEMENT_STANDARD_RTTIEXT(_pyComplexParamHypo,_pyHypothesis);
-IMPLEMENT_STANDARD_RTTIEXT(_pyNumberOfSegmentsHyp,_pyHypothesis);
-IMPLEMENT_STANDARD_RTTIEXT(_pyLayerDistributionHypo,_pyHypothesis);
-IMPLEMENT_STANDARD_RTTIEXT(_pySegmentLengthAroundVertexHyp,_pyHypothesis);
+IMPLEMENT_STANDARD_RTTIEXT(_pyObject ,Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(_pyCommand ,Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesisReader,Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(_pyGen ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyMesh ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pySubMesh ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyMeshEditor ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesis ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pySelfEraser ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyGroup ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyFilter ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyAlgorithm ,_pyHypothesis)
+IMPLEMENT_STANDARD_RTTIEXT(_pyComplexParamHypo,_pyHypothesis)
+IMPLEMENT_STANDARD_RTTIEXT(_pyNumberOfSegmentsHyp,_pyHypothesis)
+IMPLEMENT_STANDARD_RTTIEXT(_pyLayerDistributionHypo,_pyHypothesis)
+IMPLEMENT_STANDARD_RTTIEXT(_pySegmentLengthAroundVertexHyp,_pyHypothesis)
using namespace std;
using SMESH::TPythonDump;
// - FT_Deflection2D = 22
// v 9.3.0: FT_Undefined == 50, new items:
// - FT_Length3D = 22
+ // v 9.12.0: FT_Undefined == 51, new items:
+ // - FT_ScaledJacobian = 8
+ // v 9.12.0: FT_Undefined == 52, new items:
+ // - FT_Warping3D = 4
//
// It's necessary to continue recording this history and to fill
// undef2newItems (see below) accordingly.
undef2newItems[ 48 ].push_back( 22 );
undef2newItems[ 49 ].push_back( 22 );
undef2newItems[ 50 ].push_back( 22 );
+ undef2newItems[ 51 ].push_back( 8 );
+ undef2newItems[ 52 ].push_back( 4 );
ASSERT( undef2newItems.rbegin()->first == SMESH::FT_Undefined );
}
initialized = true;
filteredArgs.push_back( "SMESH.MED_V2_1" );
filteredArgs.push_back( "SMESH.MED_V2_2" );
- }
+ }
return std::find( filteredArgs.begin(), filteredArgs.end(), theArg ) != filteredArgs.end();
}
}
// find a GEOM (aPass == 0) and SHAPERSTUDY (aPass == 1) entries
for(int aPass = 0; aPass < 2; aPass++) {
_pyID geomID;
- SALOMEDS::SComponent_wrap geomComp = SMESH_Gen_i::getStudyServant()->
+ SALOMEDS::SComponent_wrap geomComp = SMESH_Gen_i::GetSMESHGen()->getStudyServant()->
FindComponent(aPass == 0 ? "GEOM" : "SHAPERSTUDY");
if (geomComp->_is_nil()) continue;
CORBA::String_var entry = geomComp->GetID();
if ( objID == this->GetID() || objID == SMESH_2smeshpy::GenName())
{
this->Process( aCommand );
+
//addFilterUser( aCommand, theGen ); // protect filters from clearing
return aCommand;
}
meshID = aCommand->GetResultValue();
else if ( method == "MakeBoundaryMesh")
meshID = aCommand->GetResultValue(1);
- else if ( method == "MakeBoundaryElements")
+ else if ( method == "MakeBoundaryElements" || method == "MakeBoundaryOfEachElement" )
meshID = aCommand->GetResultValue(2);
if ( method.Search("MakeGroups") != -1 ||
groups = aCommand->GetResultValue();
else if ( method == "MakeBoundaryMesh" )
groups = aCommand->GetResultValue(2);
- else if ( method == "MakeBoundaryElements")
+ else if ( method == "MakeBoundaryElements" || method == "MakeBoundaryOfEachElement" )
groups = aCommand->GetResultValue(3);
else if ( method == "Create0DElementsOnAllNodes" &&
aCommand->GetArg(2).Length() > 2 ) // group name != ''
"Geom_POLYHEDRA", "Geom_BALL" };
if ( -1 < iGeom && iGeom < nbTypes )
Threshold = SMESH + types[ iGeom ];
-#ifdef _DEBUG_
- // is types complete? (compilation failure mains that enum GeometryType changed)
- int _asrt[( sizeof(types) / sizeof(const char*) == nbTypes ) ? 2 : -1 ]; _asrt[0]=_asrt[1];
-#endif
+
+ if (SALOME::VerbosityActivated())
+ {
+ // is types complete? (compilation failure means that enum GeometryType changed)
+ static_assert( sizeof(types) / sizeof(const char*) == nbTypes,
+ "Update names of GeometryType's!!!" );
+ }
}
if (Type == "SMESH.FT_EntityType")
{
"Entity_Polyhedra", "Entity_Quad_Polyhedra", "Entity_Ball" };
if ( -1 < iGeom && iGeom < nbTypes )
Threshold = SMESH + types[ iGeom ];
-#ifdef _DEBUG_
- // is 'types' complete? (compilation failure mains that enum EntityType changed)
- int _asrt[( sizeof(types) / sizeof(const char*) == nbTypes ) ? 2 : -1 ]; _asrt[0]=_asrt[1];
-#endif
+
+ if (SALOME::VerbosityActivated())
+ {
+ // is 'types' complete? (compilation failure means that enum EntityType changed)
+ static_assert( sizeof(types) / sizeof(const char*) == nbTypes,
+ "Update names of EntityType's!!!" );
+ }
}
}
if ( ThresholdID.Length() != 2 ) // neither '' nor ""
// Concatenate( [mesh1, ...], ... )
// CreateHypothesis( theHypType, theLibName )
// Compute( mesh, geom )
+ // CheckCompute( mesh )
// Evaluate( mesh, geom )
// mesh creation
TCollection_AsciiString method = theCommand->GetMethod();
{
Handle(_pyMesh) mesh = new _pyMesh( theCommand );
AddObject( mesh );
+ // set mesh name
+ _pyID id = mesh->GetID(), comma("'");
+ if ( myObjectNames.IsBound( id ))
+ theCommand->SetArg( theCommand->GetNbArgs() + 1,
+ comma + myObjectNames( id ) + comma);
return;
}
if ( method == "CreateMeshesFromUNV" ||
method == "CreateMeshesFromSTL" ||
+ method == "CreateDualMesh" ||
method == "CopyMesh" ) // command result is a mesh
{
Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue() );
return;
}
if ( method == "CreateMeshesFromMED" ||
- method == "CreateMeshesFromSAUV"||
method == "CreateMeshesFromCGNS" ||
method == "CreateMeshesFromGMF" ) // command result is ( [mesh1,mesh2], status )
{
}
}
+ // smeshgen.CheckCompute( mesh ) --> mesh.CheckCompute()
+ if ( method == "CheckCompute" )
+ {
+ const _pyID& meshID = theCommand->GetArg( 1 );
+ map< _pyID, Handle(_pyMesh) >::iterator id_mesh = myMeshes.find( meshID );
+ if ( id_mesh != myMeshes.end() ) {
+ theCommand->SetObject( meshID );
+ theCommand->RemoveArgs();
+ id_mesh->second->Process( theCommand );
+ id_mesh->second->AddProcessedCmd( theCommand );
+ return;
+ }
+ }
+
+
// smeshgen.Evaluate( mesh, geom ) --> mesh.Evaluate(geom)
if ( method == "Evaluate" )
{
*/
//================================================================================
-void _pyGen::PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const
+void _pyGen::PlaceSubmeshAfterItsCreation( Handle(_pyCommand) /*theCmdUsingSubmesh*/ ) const
{
// map< _pyID, Handle(_pyObject) >::const_iterator id_obj = myObjects.begin();
// for ( ; id_obj != myObjects.end(); ++id_obj )
// either the SMESH object is not in study or it is a GEOM object
if ( IsGeomObject( theObjID ))
{
- SALOMEDS::SObject_wrap so = SMESH_Gen_i::getStudyServant()->FindObjectID( theObjID.ToCString() );
+ SALOMEDS::SObject_wrap so = SMESH_Gen_i::GetSMESHGen()->getStudyServant()->FindObjectID( theObjID.ToCString() );
if ( so->_is_nil() ) return true;
CORBA::Object_var obj = so->GetObject();
return CORBA::is_nil( obj );
}
else if ( theCreationCmd->GetMethod().Search("MakeMesh") != -1 ||
theCreationCmd->GetMethod() == "MakeBoundaryMesh" ||
- theCreationCmd->GetMethod() == "MakeBoundaryElements" )
+ theCreationCmd->GetMethod() == "MakeBoundaryElements" ||
+ theCreationCmd->GetMethod() == "MakeBoundaryOfEachElement" )
{
// this mesh depends on a source mesh
// (theCreationCmd is already Process()ed by _pyMeshEditor)
const _pyID& meshID = theCreationCmd->GetObject();
addFatherMesh( meshID );
}
-
+
// convert my creation command
Handle(_pyCommand) creationCmd = GetCreationCmd();
creationCmd->SetObject( SMESH_2smeshpy::SmeshpyName() );
}
Flush();
}
+ // in snapshot mode, clear the previous CheckCompute()
+ else if ( method == "CheckCompute" )
+ {
+ if ( !theGen->IsToKeepAllCommands() ) // !historical
+ {
+ if ( !myLastCheckCmd.IsNull() )
+ {
+ // check if the previously computed mesh has been edited,
+ // if so then we do not clear the previous Compute()
+ bool toClear = true;
+ list< Handle(_pyMeshEditor)>::iterator e = myEditors.begin();
+ for ( ; e != myEditors.end() && toClear; ++e )
+ {
+ list< Handle(_pyCommand)>& cmds = (*e)->GetProcessedCmds();
+ list< Handle(_pyCommand) >::reverse_iterator cmd = cmds.rbegin();
+ if ( cmd != cmds.rend() &&
+ (*cmd)->GetOrderNb() > myLastCheckCmd->GetOrderNb() )
+ toClear = false;
+ }
+ if ( toClear )
+ myLastCheckCmd->Clear();
+ }
+ myLastCheckCmd = theCommand;
+ }
+ }
// ----------------------------------------------------------------------
else if ( method == "Clear" ) // in snapshot mode, clear all previous commands
{
static TStringSet sameMethods;
if ( sameMethods.empty() ) {
const char * names[] =
- { "ExportDAT","ExportUNV","ExportSTL","ExportSAUV", "RemoveGroup","RemoveGroupWithContents",
+ { "ExportDAT","ExportUNV","ExportSTL", "RemoveGroup","RemoveGroupWithContents",
"GetGroups","UnionGroups","IntersectGroups","CutGroups","CreateDimGroup","GetLog","GetId",
"ClearLog","HasDuplicatedGroupNamesMED","GetMEDMesh","NbNodes","NbElements",
"NbEdges","NbEdgesOfOrder","NbFaces","NbFacesOfOrder","NbTriangles",
"GetElemNode","IsMediumNode","IsMediumNodeOfAnyElem","ElemNbEdges","ElemNbFaces",
"GetElemFaceNodes", "GetFaceNormal", "FindElementByNodes",
"IsPoly","IsQuadratic","BaryCenter","GetHypothesisList", "SetAutoColor", "GetAutoColor",
- "Clear", "ConvertToStandalone", "GetMeshOrder", "SetMeshOrder"
+ "Clear", "ConvertToStandalone", "GetMeshOrder", "SetMeshOrder",
+ "SetNbThreads", "CheckCompute"
,"" }; // <- mark of end
sameMethods.Insert( names );
}
list< Handle(_pySubMesh) >::iterator sm = mySubmeshes.begin();
for ( ; sm != mySubmeshes.end(); ++sm )
(*sm)->ClearCommands();
-
+
list< Handle(_pyGroup) >::iterator gr = myGroups.begin();
for ( ; gr != myGroups.end(); ++gr )
(*gr)->ClearCommands();
static TStringSet sameMethods;
if ( sameMethods.empty() ) {
const char * names[] = {
- "RemoveElements","RemoveNodes","RemoveOrphanNodes",
+ "RemoveElements","RemoveNodes","RemoveOrphanNodes","RemoveNodeWithReconnection",
"AddNode","Add0DElement","AddEdge","AddFace","AddPolygonalFace","AddBall",
- "AddVolume","AddPolyhedralVolume","AddPolyhedralVolumeByFaces",
- "MoveNode", "MoveClosestNodeToPoint",
- "InverseDiag","DeleteDiag","Reorient","ReorientObject","Reorient2DBy3D",
+ "AddVolume","AddPolyhedralVolume","AddPolyhedralVolumeByFaces","AddNodeOnSegment",
+ "MoveNode", "MoveClosestNodeToPoint","InverseDiag","DeleteDiag","AddNodeOnFace",
+ "Reorient","ReorientObject","Reorient2DBy3D","Reorient2DByNeighbours",
"TriToQuad","TriToQuadObject", "QuadTo4Tri", "SplitQuad","SplitQuadObject",
"BestSplit","Smooth","SmoothObject","SmoothParametric","SmoothParametricObject",
"ConvertToQuadratic","ConvertFromQuadratic","RenumberNodes","RenumberElements",
"ExtrusionByNormal", "ExtrusionSweepObject2D","ExtrusionAlongPath","ExtrusionAlongPathObject",
"ExtrusionAlongPathX","ExtrusionAlongPathObject1D","ExtrusionAlongPathObject2D",
"ExtrusionSweepObjects","RotationSweepObjects","ExtrusionAlongPathObjects",
- "Mirror","MirrorObject","Translate","TranslateObject","Rotate","RotateObject",
+ "Mirror","MirrorObject","Translate","TranslateObject","Rotate","RotateObject","Offset",
"FindCoincidentNodes","MergeNodes","FindEqualElements","FillHole",
"MergeElements","MergeEqualElements","SewFreeBorders","SewConformFreeBorders",
"FindCoincidentFreeBorders", "SewCoincidentFreeBorders",
"GetLastCreatedElems", "FaceGroupsSeparatedByEdges",
"MirrorMakeMesh","MirrorObjectMakeMesh","TranslateMakeMesh","TranslateObjectMakeMesh",
"Scale","ScaleMakeMesh","RotateMakeMesh","RotateObjectMakeMesh","MakeBoundaryMesh",
- "MakeBoundaryElements", "SplitVolumesIntoTetra","SplitHexahedraIntoPrisms",
+ "MakeBoundaryElements", "MakeBoundaryOfEachElement", "SplitVolumesIntoTetra","SplitHexahedraIntoPrisms",
"DoubleElements","DoubleNodes","DoubleNode","DoubleNodeGroup","DoubleNodeGroups",
"DoubleNodeElem","DoubleNodeElemInRegion","DoubleNodeElemGroup","AffectedElemGroupsInRegion",
"DoubleNodeElemGroupInRegion","DoubleNodeElemGroups","DoubleNodeElemGroupsInRegion",
// 1. Remove "MakeGroups" from the Command
TCollection_AsciiString aMethod = theCommand->GetMethod();
int nbArgsToAdd = diffLastTwoArgsMethods.Contains(aMethod) ? 2 : 1;
-
+
if(is0DmethObj)
pos = pos-2; //Remove "0D" from the Command too
aMethod.Trunc(pos-1);
//================================================================================
/*!
- * \brief Return true if a setting parameter command ha been used to compute mesh
+ * \brief Return true if a setting parameter command has been used to compute mesh
*/
//================================================================================
list< Handle(_pyCommand) >::iterator cmd = myArgCommands.begin();
_pyID prevNewName;
for ( cmd = myArgCommands.begin(); cmd != myArgCommands.end(); ++cmd )
- {
+ {
const _pyID& hyp1dID = (*cmd)->GetArg( 1 );
if ( hyp1dID.IsEmpty() ) continue;
}
newName += "_Distribution";
prevNewName = newName;
-
+
hyp1d->GetCreationCmd()->SetResultValue( newName );
}
list< Handle(_pyCommand) >& cmds = theGen->GetCommands();
if ( pos == UNKNOWN )
{
pos = GetBegPos( METHOD_IND ) + myMeth.Length();
- if ( pos < 1 )
+ if ( pos < 1 && Length() >= 4 )
pos = myString.Location( "(", 4, Length() ); // 4 = strlen("b.c(")
}
return pos;
}
theStartPos = beg;
//cout << theString << " ---- " << beg << " - " << end << endl;
+ if ( end > theString.Length() )
+ {
+ theStartPos = EMPTY;
+ return theEmptyString;
+ }
return theString.SubString( beg, end );
}
*/
//================================================================================
-bool _pySubMesh::CanBeArgOfMethod(const _AString& theMethodName)
+bool _pySubMesh::CanBeArgOfMethod(const _AString& /*theMethodName*/)
{
return false;
// names of all methods where a sub-mesh can be used as argument
//================================================================================
/*!
- * \brief Check if "[ group1, group2 ] = mesh.GetGroups()" creation command
+ * \brief Check if "[ group1, group2 ] = mesh.GetGroups()" creation command
* can be cleared
*/
//================================================================================
if ( !myNewID.IsEmpty() )
theCommand->SetObject( myNewID );
-
+
// Convert the following set of commands into smesh.GetFilterFromCriteria(criteria)
// aFilter0x2aaab0487080 = aFilterManager.CreateFilter()
// aFilter0x2aaab0487080.SetCriteria(aCriteria)
void _pyFilter::Flush()
{
if ( myNewID.IsEmpty() ) return;
-
+
list< Handle(_pyCommand) >::iterator cmd = myArgCmds.begin();
for ( ; cmd != myArgCmds.end(); ++cmd )
if ( !(*cmd)->IsEmpty() )
// ...
// dim="2">
// <python-wrap>
- // <accumulative-methods>
+ // <accumulative-methods>
// SetEnforcedVertex,
// SetEnforcedVertexNamed
// </accumulative-methods>
