-// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2015 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.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include "SMESH_Mesh_i.hxx"
#include "DriverMED_R_SMESHDS_Mesh.h"
+#include "DriverMED_W_Field.h"
#include "DriverMED_W_SMESHDS_Mesh.h"
#include "MED_Factory.hxx"
#include "SMDS_EdgePosition.hxx"
#include "SMESHDS_Group.hxx"
#include "SMESHDS_GroupOnGeom.hxx"
#include "SMESH_Controls.hxx"
+#include "SMESH_File.hxx"
#include "SMESH_Filter_i.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Group.hxx"
#include "SMESH_Group_i.hxx"
+#include "SMESH_Mesh.hxx"
+#include "SMESH_MeshAlgos.hxx"
#include "SMESH_MeshEditor.hxx"
#include "SMESH_MeshEditor_i.hxx"
#include "SMESH_MeshPartDS.hxx"
#include "SMESH_PythonDump.hxx"
#include "SMESH_subMesh_i.hxx"
-#include <OpUtil.hxx>
#include <SALOMEDS_Attributes_wrap.hxx>
#include <SALOMEDS_wrap.hxx>
-#include <SALOME_NamingService.hxx>
#include <Utils_ExceptHandlers.hxx>
-#include <Utils_SINGLETON.hxx>
#include <utilities.h>
#include <GEOMImpl_Types.hxx>
// OCCT Includes
#include <BRep_Builder.hxx>
-#include <OSD_Directory.hxx>
-#include <OSD_File.hxx>
-#include <OSD_Path.hxx>
-#include <OSD_Protection.hxx>
-#include <Standard_OutOfMemory.hxx>
-#include <TColStd_MapIteratorOfMapOfInteger.hxx>
+#include <Standard_ErrorHandler.hxx>
#include <TColStd_MapOfInteger.hxx>
-#include <TColStd_SequenceOfInteger.hxx>
-#include <TCollection_AsciiString.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopTools_MapIteratorOfMapOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopoDS_Compound.hxx>
-#include "SMESH_TryCatch.hxx" // include after OCCT headers!
-
// STL Includes
#include <algorithm>
-#include <string>
#include <iostream>
#include <sstream>
-#include <sys/stat.h>
+#include <vtkUnstructuredGridWriter.h>
+
+// to pass CORBA exception through SMESH_TRY
+#define SMY_OWN_CATCH catch( SALOME::SALOME_Exception& se ) { throw se; }
+
+#include "SMESH_TryCatch.hxx" // include after OCCT headers!
#ifdef _DEBUG_
static int MYDEBUG = 0;
SMESH_Mesh_i::SMESH_Mesh_i( PortableServer::POA_ptr thePOA,
SMESH_Gen_i* gen_i,
- CORBA::Long studyId )
+ CORBA::Long studyId )
: SALOME::GenericObj_i( thePOA )
{
MESSAGE("SMESH_Mesh_i");
_editor = NULL;
_previewEditor = NULL;
_preMeshInfo = NULL;
+ _mainShapeTick = 0;
}
//=============================================================================
}
_mapHypo.clear();
+ // clear cashed shapes if no more meshes remain; (the cash is blame,
+ // together with publishing, of spent time increasing in issue 22874)
+ if ( _impl->NbMeshes() == 1 )
+ _gen_i->GetShapeReader()->ClearClientBuffer();
+
delete _editor; _editor = NULL;
delete _previewEditor; _previewEditor = NULL;
delete _impl; _impl = NULL;
// to track changes of GEOM groups
SMESH::SMESH_Mesh_var mesh = _this();
addGeomGroupData( theShapeObject, mesh );
+ if ( !CORBA::is_nil( theShapeObject ))
+ _mainShapeTick = theShapeObject->GetTick();
}
//================================================================================
try {
_impl->Clear();
- CheckGeomGroupModif(); // issue 20145
+ //CheckGeomGroupModif(); // issue 20145
}
catch(SALOME_Exception & S_ex) {
THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
_medFileInfo->major = major;
_medFileInfo->minor = minor;
_medFileInfo->release = release;
-#ifdef WIN32
- struct _stati64 d;
- if ( ::_stati64( theFileName, &d ) != -1 )
-#else
- struct stat64 d;
- if ( ::stat64( theFileName, &d ) != -1 )
-#endif
- _medFileInfo->fileSize = d.st_size;
+ _medFileInfo->fileSize = SMESH_File( theFileName ).size();
return ConvertDriverMEDReadStatus(status);
}
RETURNCASE( HYP_BAD_SUBSHAPE );
RETURNCASE( HYP_BAD_GEOMETRY );
RETURNCASE( HYP_NEED_SHAPE );
+ RETURNCASE( HYP_INCOMPAT_HYPS );
default:;
}
return SMESH::HYP_UNKNOWN_FATAL;
*/
//=============================================================================
-SMESH::Hypothesis_Status SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject,
- SMESH::SMESH_Hypothesis_ptr anHyp)
+SMESH::Hypothesis_Status
+SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubShape,
+ SMESH::SMESH_Hypothesis_ptr anHyp,
+ CORBA::String_out anErrorText)
throw(SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
_preMeshInfo->ForgetOrLoad();
- SMESH_Hypothesis::Hypothesis_Status status = addHypothesis( aSubShapeObject, anHyp );
+ std::string error;
+ SMESH_Hypothesis::Hypothesis_Status status = addHypothesis( aSubShape, anHyp, &error );
+ anErrorText = error.c_str();
SMESH::SMESH_Mesh_var mesh( _this() );
if ( !SMESH_Hypothesis::IsStatusFatal(status) )
{
SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
- _gen_i->AddHypothesisToShape( study, mesh, aSubShapeObject, anHyp );
+ _gen_i->AddHypothesisToShape( study, mesh, aSubShape, anHyp );
}
if(MYDEBUG) MESSAGE( " AddHypothesis(): status = " << status );
// Update Python script
- //if(_impl->HasShapeToMesh())
- {
- TPythonDump() << "status = " << mesh << ".AddHypothesis( "
- << aSubShapeObject << ", " << anHyp << " )";
- }
- // else {
- // TPythonDump() << "status = " << mesh << ".AddHypothesis( "<< anHyp << " )";
- // }
+ TPythonDump() << "status = " << mesh << ".AddHypothesis( "
+ << aSubShape << ", " << anHyp << " )";
return ConvertHypothesisStatus(status);
}
//=============================================================================
SMESH_Hypothesis::Hypothesis_Status
-SMESH_Mesh_i::addHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject,
- SMESH::SMESH_Hypothesis_ptr anHyp)
+SMESH_Mesh_i::addHypothesis(GEOM::GEOM_Object_ptr aSubShape,
+ SMESH::SMESH_Hypothesis_ptr anHyp,
+ std::string* anErrorText)
{
if(MYDEBUG) MESSAGE("addHypothesis");
- if (CORBA::is_nil( aSubShapeObject ) && HasShapeToMesh())
+ if (CORBA::is_nil( aSubShape ) && HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference",SALOME::BAD_PARAM);
if (CORBA::is_nil( anHyp ))
TopoDS_Shape myLocSubShape;
//use PseudoShape in case if mesh has no shape
if(HasShapeToMesh())
- myLocSubShape = _gen_i->GeomObjectToShape( aSubShapeObject);
+ myLocSubShape = _gen_i->GeomObjectToShape( aSubShape);
else
myLocSubShape = _impl->GetShapeToMesh();
const int hypId = anHyp->GetId();
- status = _impl->AddHypothesis(myLocSubShape, hypId);
- if ( !SMESH_Hypothesis::IsStatusFatal(status) ) {
+ std::string error;
+ status = _impl->AddHypothesis( myLocSubShape, hypId, &error );
+ if ( !SMESH_Hypothesis::IsStatusFatal(status) )
+ {
_mapHypo[hypId] = SMESH::SMESH_Hypothesis::_duplicate( anHyp );
anHyp->Register();
// assure there is a corresponding submesh
if ( !_impl->IsMainShape( myLocSubShape )) {
int shapeId = _impl->GetMeshDS()->ShapeToIndex( myLocSubShape );
if ( _mapSubMesh_i.find( shapeId ) == _mapSubMesh_i.end() )
- SMESH::SMESH_subMesh_var( createSubMesh( aSubShapeObject ));
+ SMESH::SMESH_subMesh_var( createSubMesh( aSubShape ));
}
}
+ else if ( anErrorText )
+ {
+ *anErrorText = error;
+ }
}
catch(SALOME_Exception & S_ex)
{
*/
//=============================================================================
-SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject,
+SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp)
throw(SALOME::SALOME_Exception)
{
if ( _preMeshInfo )
_preMeshInfo->ForgetOrLoad();
- SMESH_Hypothesis::Hypothesis_Status status = removeHypothesis( aSubShapeObject, anHyp );
+ SMESH_Hypothesis::Hypothesis_Status status = removeHypothesis( aSubShape, anHyp );
SMESH::SMESH_Mesh_var mesh = _this();
if ( !SMESH_Hypothesis::IsStatusFatal(status) )
{
SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
- _gen_i->RemoveHypothesisFromShape( study, mesh, aSubShapeObject, anHyp );
+ _gen_i->RemoveHypothesisFromShape( study, mesh, aSubShape, anHyp );
}
// Update Python script
if(_impl->HasShapeToMesh())
TPythonDump() << "status = " << mesh << ".RemoveHypothesis( "
- << aSubShapeObject << ", " << anHyp << " )";
+ << aSubShape << ", " << anHyp << " )";
else
TPythonDump() << "status = " << mesh << ".RemoveHypothesis( "
<< anHyp << " )";
//=============================================================================
SMESH_Hypothesis::Hypothesis_Status
-SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject,
+SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp)
{
if(MYDEBUG) MESSAGE("removeHypothesis()");
- if (CORBA::is_nil( aSubShapeObject ) && HasShapeToMesh())
+ if (CORBA::is_nil( aSubShape ) && HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM);
if (CORBA::is_nil( anHyp ))
TopoDS_Shape myLocSubShape;
//use PseudoShape in case if mesh has no shape
if( _impl->HasShapeToMesh() )
- myLocSubShape = _gen_i->GeomObjectToShape( aSubShapeObject );
+ myLocSubShape = _gen_i->GeomObjectToShape( aSubShape );
else
myLocSubShape = _impl->GetShapeToMesh();
//=============================================================================
SMESH::ListOfHypothesis *
-SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShapeObject)
+SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape)
throw(SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
if (MYDEBUG) MESSAGE("GetHypothesisList");
- if (_impl->HasShapeToMesh() && CORBA::is_nil(aSubShapeObject))
+ if (_impl->HasShapeToMesh() && CORBA::is_nil(aSubShape))
THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM);
SMESH::ListOfHypothesis_var aList = new SMESH::ListOfHypothesis();
try {
- TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(aSubShapeObject);
+ TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(aSubShape);
if ( myLocSubShape.IsNull() && !_impl->HasShapeToMesh() )
myLocSubShape = _impl->GetShapeToMesh();
const list<const SMESHDS_Hypothesis*>& aLocalList = _impl->GetHypothesisList( myLocSubShape );
*/
//=============================================================================
-SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShapeObject,
+SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShape,
const char* theName )
throw(SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
- if (CORBA::is_nil(aSubShapeObject))
+ if (CORBA::is_nil(aSubShape))
THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM);
SMESH::SMESH_subMesh_var subMesh;
SMESH::SMESH_Mesh_var aMesh = _this();
try {
- TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(aSubShapeObject);
+ TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(aSubShape);
//Get or Create the SMESH_subMesh object implementation
// create a new subMesh object servant if there is none for the shape
if ( subMesh->_is_nil() )
- subMesh = createSubMesh( aSubShapeObject );
+ subMesh = createSubMesh( aSubShape );
if ( _gen_i->CanPublishInStudy( subMesh ))
{
SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
SALOMEDS::SObject_wrap aSO =
- _gen_i->PublishSubMesh( study, aMesh, subMesh, aSubShapeObject, theName );
+ _gen_i->PublishSubMesh( study, aMesh, subMesh, aSubShape, theName );
if ( !aSO->_is_nil()) {
// Update Python script
TPythonDump() << aSO << " = " << aMesh << ".GetSubMesh( "
- << aSubShapeObject << ", '" << theName << "' )";
+ << aSubShape << ", '" << theName << "' )";
}
}
}
if ( theSubMesh->_is_nil() )
return;
- GEOM::GEOM_Object_var aSubShapeObject;
+ GEOM::GEOM_Object_var aSubShape;
SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
if ( !aStudy->_is_nil() ) {
// Remove submesh's SObject
anObj->ReferencedObject( aRef.inout() ))
{
CORBA::Object_var obj = aRef->GetObject();
- aSubShapeObject = GEOM::GEOM_Object::_narrow( obj );
+ aSubShape = GEOM::GEOM_Object::_narrow( obj );
}
- // if ( aSubShapeObject->_is_nil() ) // not published shape (IPAL13617)
- // aSubShapeObject = theSubMesh->GetSubShape();
+ // if ( aSubShape->_is_nil() ) // not published shape (IPAL13617)
+ // aSubShape = theSubMesh->GetSubShape();
SALOMEDS::StudyBuilder_var builder = aStudy->NewBuilder();
builder->RemoveObjectWithChildren( anSO );
}
}
- if ( removeSubMesh( theSubMesh, aSubShapeObject.in() ))
+ if ( removeSubMesh( theSubMesh, aSubShape.in() ))
if ( _preMeshInfo )
_preMeshInfo->ForgetOrLoad();
builder->RemoveObjectWithChildren( aGroupSO );
}
}
+ aGroup->Modified(/*removed=*/true); // notify dependent Filter with FT_BelongToMeshGroup criterion
// Remove the group from SMESH data structures
removeGroup( aGroup->GetLocalID() );
if ( theGroup->_is_nil() )
return;
+ vector<int> nodeIds; // to remove nodes becoming free
+ if ( !theGroup->IsEmpty() )
+ {
+ CORBA::Long elemID = theGroup->GetID( 1 );
+ int nbElemNodes = GetElemNbNodes( elemID );
+ if ( nbElemNodes > 0 )
+ nodeIds.reserve( theGroup->Size() * nbElemNodes );
+ }
+
// Remove contents
SMESH::SMESH_IDSource_var idSrc = SMESH::SMESH_IDSource::_narrow( theGroup );
SMDS_ElemIteratorPtr elemIt = GetElements( idSrc, theGroup->GetType() );
while ( elemIt->more() )
- _impl->GetMeshDS()->RemoveElement( elemIt->next() );
+ {
+ const SMDS_MeshElement* e = elemIt->next();
+
+ SMDS_ElemIteratorPtr nIt = e->nodesIterator();
+ while ( nIt->more() )
+ nodeIds.push_back( nIt->next()->GetID() );
+
+ _impl->GetMeshDS()->RemoveElement( e );
+ }
+
+ // Remove free nodes
+ if ( theGroup->GetType() != SMESH::NODE )
+ for ( size_t i = 0 ; i < nodeIds.size(); ++i )
+ if ( const SMDS_MeshNode* n = _impl->GetMeshDS()->FindNode( nodeIds[i] ))
+ if ( n->NbInverseElements() == 0 )
+ _impl->GetMeshDS()->RemoveFreeNode( n, /*sm=*/0 );
TPythonDump pyDump; // Supress dump from RemoveGroup()
if ( aType == SMESH::ALL )
aType = aGrp->GetType();
else if ( aType != aGrp->GetType() )
- THROW_SALOME_CORBA_EXCEPTION("UnionListOfGroups(): different group types",
+ THROW_SALOME_CORBA_EXCEPTION("CutListOfGroups(): different group types",
SALOME::BAD_PARAM);
if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( aGrp ))
if ( SMESHDS_GroupBase* grpDS = grp_i->GetGroupDS() )
if ( CORBA::is_nil( aGrp ) )
continue;
if ( aType != aGrp->GetType() )
- THROW_SALOME_CORBA_EXCEPTION("UnionListOfGroups(): different group types",
+ THROW_SALOME_CORBA_EXCEPTION("CutListOfGroups(): different group types",
SALOME::BAD_PARAM);
if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( aGrp ))
if ( SMESHDS_GroupBase* grpDS = grp_i->GetGroupDS() )
// Update Python script
pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var( _this() )
- << ".CutListOfGroups( " << theMainGroups
+ << ".CutListOfGroups( " << theMainGroups << ", "
<< theToolGroups << ", '" << theName << "' )";
SMESH_CATCH( SMESH::throwCorbaException );
return aResGrp._retn();
}
+namespace // functions making checks according to SMESH::NB_COMMON_NODES_ENUM
+{
+ bool isAllNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners,
+ bool & toStopChecking )
+ {
+ toStopChecking = ( nbCommon < nbChecked );
+ return nbCommon == nbNodes;
+ }
+ bool isMainNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners,
+ bool & toStopChecking )
+ {
+ toStopChecking = ( nbCommon < nbChecked || nbChecked >= nbCorners );
+ return nbCommon == nbCorners;
+ }
+ bool isAtLeastOneNodeCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners,
+ bool & toStopChecking )
+ {
+ return nbCommon > 0;
+ }
+ bool isMajorityOfNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners,
+ bool & toStopChecking )
+ {
+ return nbCommon >= (nbNodes+1) / 2;
+ }
+}
+
//=============================================================================
/*!
- \brief Create groups of entities from existing groups of superior dimensions
- System
- 1) extract all nodes from each group,
- 2) combine all elements of specified dimension laying on these nodes.
- \param theGroups list of source groups
- \param theElemType dimension of elements
- \param theName name of new group
- \return pointer on new group
- *
- IMP 19939
+ * Create a group of entities basing on nodes of other groups.
+ * \param [in] theGroups - list of either groups, sub-meshes or filters.
+ * \param [in] anElemType - a type of elements to include to the new group.
+ * \param [in] theName - a name of the new group.
+ * \param [in] theNbCommonNodes - criterion of inclusion of an element to the new group.
+ * \param [in] theUnderlyingOnly - if \c True, an element is included to the
+ * new group provided that it is based on nodes of an element of \a aListOfGroups
+ * \return SMESH_Group - the created group
*/
+// IMP 19939, bug 22010, IMP 22635
//=============================================================================
SMESH::SMESH_Group_ptr
-SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfGroups& theGroups,
- SMESH::ElementType theElemType,
- const char* theName )
+SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfIDSources& theGroups,
+ SMESH::ElementType theElemType,
+ const char* theName,
+ SMESH::NB_COMMON_NODES_ENUM theNbCommonNodes,
+ CORBA::Boolean theUnderlyingOnly)
throw (SALOME::SALOME_Exception)
{
SMESH::SMESH_Group_var aResGrp;
SMDSAbs_ElementType anElemType = (SMDSAbs_ElementType)theElemType;
+ bool (*isToInclude)(int nbChecked, int nbCommon, int nbNodes, int nbCorners, bool & toStop);
+ SMESH_Comment nbCoNoStr( "SMESH.");
+ switch ( theNbCommonNodes ) {
+ case SMESH::ALL_NODES : isToInclude = isAllNodesCommon; nbCoNoStr<<"ALL_NODES" ;break;
+ case SMESH::MAIN : isToInclude = isMainNodesCommon; nbCoNoStr<<"MAIN" ;break;
+ case SMESH::AT_LEAST_ONE: isToInclude = isAtLeastOneNodeCommon; nbCoNoStr<<"AT_LEAST_ONE";break;
+ case SMESH::MAJORITY : isToInclude = isMajorityOfNodesCommon; nbCoNoStr<<"MAJORITY" ;break;
+ default: return aResGrp._retn();
+ }
+ int nbChecked, nbCommon, nbNodes, nbCorners;
+
// Create a group
TPythonDump pyDump;
SMESH::DownCast<SMESH_GroupBase_i*>( aResGrp )->GetGroupDS();
SMDS_MeshGroup& resGroupCore = static_cast< SMESHDS_Group* >( groupBaseDS )->SMDSGroup();
+ vector<bool> isNodeInGroups;
+
for ( int g = 0, n = theGroups.length(); g < n; g++ ) // loop on theGroups
{
- SMESH::SMESH_GroupBase_var aGrp = theGroups[ g ];
+ SMESH::SMESH_IDSource_var aGrp = theGroups[ g ];
if ( CORBA::is_nil( aGrp ) )
continue;
+ SMESH::SMESH_Mesh_var mesh = aGrp->GetMesh();
+ if ( mesh->_is_nil() || mesh->GetId() != this->GetId() )
+ continue;
- groupBaseDS = SMESH::DownCast<SMESH_GroupBase_i*>( aGrp )->GetGroupDS();
- SMDS_ElemIteratorPtr elIt = groupBaseDS->GetElements();
+ SMDS_ElemIteratorPtr elIt = GetElements( aGrp, SMESH::ALL );
+ if ( !elIt ) continue;
if ( theElemType == SMESH::NODE ) // get all nodes of elements
{
resGroupCore.Add( nIt->next() );
}
}
- else // get elements of theElemType based on nodes of every element of group
+ // get elements of theElemType based on nodes of every element of group
+ else if ( theUnderlyingOnly )
{
while ( elIt->more() )
{
- const SMDS_MeshElement* el = elIt->next(); // an element of group
+ const SMDS_MeshElement* el = elIt->next(); // an element of ref group
TIDSortedElemSet elNodes( el->begin_nodes(), el->end_nodes() );
TIDSortedElemSet checkedElems;
- SMDS_ElemIteratorPtr nIt = el->nodesIterator();
+ SMDS_NodeIteratorPtr nIt = el->nodeIterator();
while ( nIt->more() )
{
- const SMDS_MeshNode* n = static_cast<const SMDS_MeshNode*>( nIt->next() );
+ const SMDS_MeshNode* n = nIt->next();
SMDS_ElemIteratorPtr elOfTypeIt = n->GetInverseElementIterator( anElemType );
// check nodes of elements of theElemType around el
while ( elOfTypeIt->more() )
{
const SMDS_MeshElement* elOfType = elOfTypeIt->next();
if ( !checkedElems.insert( elOfType ).second ) continue;
-
+ nbNodes = elOfType->NbNodes();
+ nbCorners = elOfType->NbCornerNodes();
+ nbCommon = 0;
+ bool toStopChecking = false;
SMDS_ElemIteratorPtr nIt2 = elOfType->nodesIterator();
- bool allNodesOK = true;
- while ( nIt2->more() && allNodesOK )
- allNodesOK = elNodes.count( nIt2->next() );
- if ( allNodesOK )
- resGroupCore.Add( elOfType );
+ for ( nbChecked = 1; nIt2->more() && !toStopChecking; ++nbChecked )
+ if ( elNodes.count( nIt2->next() ) &&
+ isToInclude( nbChecked, ++nbCommon, nbNodes, nbCorners, toStopChecking ))
+ {
+ resGroupCore.Add( elOfType );
+ break;
+ }
+ }
+ }
+ }
+ }
+ // get all nodes of elements of groups
+ else
+ {
+ while ( elIt->more() )
+ {
+ const SMDS_MeshElement* el = elIt->next(); // an element of group
+ SMDS_NodeIteratorPtr nIt = el->nodeIterator();
+ while ( nIt->more() )
+ {
+ const SMDS_MeshNode* n = nIt->next();
+ if ( n->GetID() >= isNodeInGroups.size() )
+ isNodeInGroups.resize( n->GetID() + 1, false );
+ isNodeInGroups[ n->GetID() ] = true;
+ }
+ }
+ }
+ }
+
+ // Get elements of theElemType based on a certain number of nodes of elements of groups
+ if ( !theUnderlyingOnly && !isNodeInGroups.empty() )
+ {
+ const SMDS_MeshNode* n;
+ vector<bool> isElemChecked( aMeshDS->MaxElementID() + 1 );
+ const int isNodeInGroupsSize = isNodeInGroups.size();
+ for ( int iN = 0; iN < isNodeInGroupsSize; ++iN )
+ {
+ if ( !isNodeInGroups[ iN ] ||
+ !( n = aMeshDS->FindNode( iN )))
+ continue;
+
+ // check nodes of elements of theElemType around n
+ SMDS_ElemIteratorPtr elOfTypeIt = n->GetInverseElementIterator( anElemType );
+ while ( elOfTypeIt->more() )
+ {
+ const SMDS_MeshElement* elOfType = elOfTypeIt->next();
+ vector<bool>::reference isChecked = isElemChecked[ elOfType->GetID() ];
+ if ( isChecked )
+ continue;
+ isChecked = true;
+
+ nbNodes = elOfType->NbNodes();
+ nbCorners = elOfType->NbCornerNodes();
+ nbCommon = 0;
+ bool toStopChecking = false;
+ SMDS_ElemIteratorPtr nIt = elOfType->nodesIterator();
+ for ( nbChecked = 1; nIt->more() && !toStopChecking; ++nbChecked )
+ {
+ const int nID = nIt->next()->GetID();
+ if ( nID < isNodeInGroupsSize && isNodeInGroups[ nID ] &&
+ isToInclude( nbChecked, ++nbCommon, nbNodes, nbCorners, toStopChecking ))
+ {
+ resGroupCore.Add( elOfType );
+ break;
}
}
}
// Update Python script
pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var( _this())
<< ".CreateDimGroup( "
- << theGroups << ", " << theElemType << ", '" << theName << "' )";
+ << theGroups << ", " << theElemType << ", '" << theName << "', "
+ << nbCoNoStr << ", " << theUnderlyingOnly << ")";
SMESH_CATCH( SMESH::throwCorbaException );
groupData._indices.insert( ids[i] );
// SMESH object
groupData._smeshObject = CORBA::Object::_duplicate( theSmeshObj );
+ // shape index in SMESHDS
+ // TopoDS_Shape shape = _gen_i->GeomObjectToShape( theGeomObj );
+ // groupData._dsID = shape.IsNull() ? 0 : _impl->GetSubMesh( shape )->GetId();
}
//================================================================================
namespace
{
- //=============================================================================
+ //-----------------------------------------------------------------------------
/*!
* \brief Storage of shape and index used in CheckGeomGroupModif()
*/
- //=============================================================================
struct TIndexedShape
{
int _index;
TopoDS_Shape _shape;
TIndexedShape( int i, const TopoDS_Shape& s ):_index(i), _shape(s) {}
};
+ //-----------------------------------------------------------------------------
+ /*!
+ * \brief Data to re-create a group on geometry
+ */
+ struct TGroupOnGeomData
+ {
+ int _oldID;
+ int _shapeID;
+ SMDSAbs_ElementType _type;
+ std::string _name;
+ Quantity_Color _color;
+ };
+}
+
+//=============================================================================
+/*!
+ * \brief Update data if geometry changes
+ *
+ * Issue 0022501
+ */
+//=============================================================================
+
+void SMESH_Mesh_i::CheckGeomModif()
+{
+ if ( !_impl->HasShapeToMesh() ) return;
+
+ SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
+ if ( study->_is_nil() ) return;
+
+ GEOM::GEOM_Object_var mainGO = _gen_i->ShapeToGeomObject( _impl->GetShapeToMesh() );
+ if ( mainGO->_is_nil() ) return;
+
+ if ( mainGO->GetType() == GEOM_GROUP ||
+ mainGO->GetTick() == _mainShapeTick )
+ {
+ CheckGeomGroupModif();
+ return;
+ }
+
+ GEOM_Client* geomClient = _gen_i->GetShapeReader();
+ if ( !geomClient ) return;
+ GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine();
+ if ( geomGen->_is_nil() ) return;
+
+ CORBA::String_var ior = geomGen->GetStringFromIOR( mainGO );
+ geomClient->RemoveShapeFromBuffer( ior.in() );
+
+ // Update data taking into account that
+ // all sub-shapes change but IDs of sub-shapes remain (except for geom groups)
+
+ _impl->Clear();
+ TopoDS_Shape newShape = _gen_i->GeomObjectToShape( mainGO );
+ if ( newShape.IsNull() )
+ return;
+
+ _mainShapeTick = mainGO->GetTick();
+
+ SMESHDS_Mesh * meshDS = _impl->GetMeshDS();
+
+ // store data of groups on geometry
+ vector< TGroupOnGeomData > groupsData;
+ const set<SMESHDS_GroupBase*>& groups = meshDS->GetGroups();
+ groupsData.reserve( groups.size() );
+ set<SMESHDS_GroupBase*>::const_iterator g = groups.begin();
+ for ( ; g != groups.end(); ++g )
+ if ( const SMESHDS_GroupOnGeom* group = dynamic_cast< SMESHDS_GroupOnGeom* >( *g ))
+ {
+ TGroupOnGeomData data;
+ data._oldID = group->GetID();
+ data._shapeID = meshDS->ShapeToIndex( group->GetShape() );
+ data._type = group->GetType();
+ data._name = group->GetStoreName();
+ data._color = group->GetColor();
+ groupsData.push_back( data );
+ }
+ // store assigned hypotheses
+ vector< pair< int, THypList > > ids2Hyps;
+ const ShapeToHypothesis & hyps = meshDS->GetHypotheses();
+ for ( ShapeToHypothesis::Iterator s2hyps( hyps ); s2hyps.More(); s2hyps.Next() )
+ {
+ const TopoDS_Shape& s = s2hyps.Key();
+ const THypList& hyps = s2hyps.ChangeValue();
+ ids2Hyps.push_back( make_pair( meshDS->ShapeToIndex( s ), hyps ));
+ }
+
+ // change shape to mesh
+ int oldNbSubShapes = meshDS->MaxShapeIndex();
+ _impl->ShapeToMesh( TopoDS_Shape() );
+ _impl->ShapeToMesh( newShape );
+
+ // re-add shapes of geom groups
+ list<TGeomGroupData>::iterator data = _geomGroupData.begin();
+ for ( ; data != _geomGroupData.end(); ++data )
+ {
+ TopoDS_Shape newShape = newGroupShape( *data );
+ if ( !newShape.IsNull() )
+ {
+ if ( meshDS->ShapeToIndex( newShape ) > 0 ) // a group reduced to one sub-shape
+ {
+ TopoDS_Compound compound;
+ BRep_Builder().MakeCompound( compound );
+ BRep_Builder().Add( compound, newShape );
+ newShape = compound;
+ }
+ _impl->GetSubMesh( newShape );
+ }
+ }
+ if ( oldNbSubShapes != meshDS->MaxShapeIndex() )
+ THROW_SALOME_CORBA_EXCEPTION( "SMESH_Mesh_i::CheckGeomModif() bug",
+ SALOME::INTERNAL_ERROR );
+
+ // re-assign hypotheses
+ for ( size_t i = 0; i < ids2Hyps.size(); ++i )
+ {
+ const TopoDS_Shape& s = meshDS->IndexToShape( ids2Hyps[i].first );
+ const THypList& hyps = ids2Hyps[i].second;
+ THypList::const_iterator h = hyps.begin();
+ for ( ; h != hyps.end(); ++h )
+ _impl->AddHypothesis( s, (*h)->GetID() );
+ }
+
+ // restore groups
+ for ( size_t i = 0; i < groupsData.size(); ++i )
+ {
+ const TGroupOnGeomData& data = groupsData[i];
+
+ map<int, SMESH::SMESH_GroupBase_ptr>::iterator i2g = _mapGroups.find( data._oldID );
+ if ( i2g == _mapGroups.end() ) continue;
+
+ SMESH_GroupBase_i* gr_i = SMESH::DownCast<SMESH_GroupBase_i*>( i2g->second );
+ if ( !gr_i ) continue;
+
+ int id;
+ SMESH_Group* g = _impl->AddGroup( data._type, data._name.c_str(), id,
+ meshDS->IndexToShape( data._shapeID ));
+ if ( !g )
+ {
+ _mapGroups.erase( i2g );
+ }
+ else
+ {
+ g->GetGroupDS()->SetColor( data._color );
+ gr_i->changeLocalId( id );
+ _mapGroups[ id ] = i2g->second;
+ if ( data._oldID != id )
+ _mapGroups.erase( i2g );
+ }
+ }
+
+ // update _mapSubMesh
+ map<int, ::SMESH_subMesh*>::iterator i_sm = _mapSubMesh.begin();
+ for ( ; i_sm != _mapSubMesh.end(); ++i_sm )
+ i_sm->second = _impl->GetSubMesh( meshDS->IndexToShape( i_sm->first ));
+
}
+
//=============================================================================
/*!
* \brief Update objects depending on changed geom groups
- *
+ *
* NPAL16168: geometrical group edition from a submesh don't modifiy mesh computation
* issue 0020210: Update of a smesh group after modification of the associated geom group
*/
void SMESH_Mesh_i::PrepareForWriting (const char* file, bool overwrite)
{
- TCollection_AsciiString aFullName ((char*)file);
- OSD_Path aPath (aFullName);
- OSD_File aFile (aPath);
- if (aFile.Exists()) {
+ SMESH_File aFile( file );
+ SMESH_Comment msg;
+ if (aFile.exists()) {
// existing filesystem node
- if (aFile.KindOfFile() == OSD_FILE) {
- if (aFile.IsWriteable()) {
- if (overwrite) {
- aFile.Reset();
- aFile.Remove();
- }
- if (aFile.Failed()) {
- TCollection_AsciiString msg ("File ");
- msg += aFullName + " cannot be replaced.";
- THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM);
+ if ( !aFile.isDirectory() ) {
+ if ( aFile.openForWriting() ) {
+ if ( overwrite && ! aFile.remove()) {
+ msg << "Can't replace " << aFile.getName();
}
} else {
- TCollection_AsciiString msg ("File ");
- msg += aFullName + " cannot be overwritten.";
- THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM);
+ msg << "Can't write into " << aFile.getName();
}
} else {
- TCollection_AsciiString msg ("Location ");
- msg += aFullName + " is not a file.";
- THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM);
+ msg << "Location " << aFile.getName() << " is not a file";
}
- } else {
+ }
+ else {
// nonexisting file; check if it can be created
- aFile.Reset();
- aFile.Build(OSD_WriteOnly, OSD_Protection());
- if (aFile.Failed()) {
- TCollection_AsciiString msg ("You cannot create the file ");
- msg += aFullName + ". Check the directory existance and access rights.";
- THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM);
- } else {
- aFile.Close();
- aFile.Remove();
+ if ( !aFile.openForWriting() ) {
+ msg << "You cannot create the file "
+ << aFile.getName()
+ << ". Check the directory existance and access rights";
}
+ aFile.remove();
+ }
+
+ if ( !msg.empty() )
+ {
+ msg << ".";
+ THROW_SALOME_CORBA_EXCEPTION(msg.c_str(), SALOME::BAD_PARAM);
}
}
_preMeshInfo->FullLoadFromFile();
string aMeshName = prepareMeshNameAndGroups(file, overwrite);
+ _impl->ExportMED( file, aMeshName.c_str(), auto_groups, theVersion, 0, autoDimension );
+
TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportToMEDX( r'"
<< file << "', " << auto_groups << ", "
<< theVersion << ", " << overwrite << ", "
<< autoDimension << " )";
- _impl->ExportMED( file, aMeshName.c_str(), auto_groups, theVersion, 0, autoDimension );
-
SMESH_CATCH( SMESH::throwCorbaException );
}
*/
//================================================================================
-void SMESH_Mesh_i::ExportPartToMED(::SMESH::SMESH_IDSource_ptr meshPart,
- const char* file,
- CORBA::Boolean auto_groups,
- ::SMESH::MED_VERSION version,
- ::CORBA::Boolean overwrite,
- ::CORBA::Boolean autoDimension)
+void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
+ const char* file,
+ CORBA::Boolean auto_groups,
+ SMESH::MED_VERSION version,
+ CORBA::Boolean overwrite,
+ CORBA::Boolean autoDimension,
+ const GEOM::ListOfFields& fields,
+ const char* geomAssocFields)
throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
- TPythonDump pyDump;
+ SMESH_TRY;
+ if ( _preMeshInfo )
+ _preMeshInfo->FullLoadFromFile();
- if ( SMESH_Mesh_i * mesh = SMESH::DownCast< SMESH_Mesh_i* >( meshPart ))
+ // check fields
+ bool have0dField = false;
+ if ( fields.length() > 0 )
{
- mesh->ExportToMEDX( file, auto_groups, version, autoDimension );
+ GEOM::GEOM_Object_var shapeToMesh = GetShapeToMesh();
+ if ( shapeToMesh->_is_nil() )
+ THROW_SALOME_CORBA_EXCEPTION( "No shape to mesh", SALOME::INTERNAL_ERROR );
+
+ for ( size_t i = 0; i < fields.length(); ++i )
+ {
+ if ( fields[i]->GetDataType() == GEOM::FDT_String )
+ THROW_SALOME_CORBA_EXCEPTION
+ ( "Export of string fields is not supported", SALOME::BAD_PARAM);
+ GEOM::GEOM_Object_var fieldShape = fields[i]->GetShape();
+ if ( fieldShape->_is_nil() )
+ THROW_SALOME_CORBA_EXCEPTION( "Null shape under a field", SALOME::INTERNAL_ERROR );
+ if ( !fieldShape->IsSame( shapeToMesh ) )
+ THROW_SALOME_CORBA_EXCEPTION
+ ( "Field defined not on shape", SALOME::BAD_PARAM);
+ if ( fields[i]->GetDimension() == 0 )
+ have0dField = true;
+ }
+ if ( geomAssocFields )
+ for ( int i = 0; geomAssocFields[i]; ++i )
+ switch ( geomAssocFields[i] ) {
+ case 'v':case 'e':case 'f':case 's': break;
+ case 'V':case 'E':case 'F':case 'S': break;
+ default: THROW_SALOME_CORBA_EXCEPTION
+ ( "geomAssocFields can include only [vefs] characters", SALOME::BAD_PARAM);
+ }
+ }
+
+ SMESHDS_Mesh* meshDS = _impl->GetMeshDS();
+
+ // write mesh
+
+ string aMeshName = "Mesh";
+ SMESHUtils::Deleter< SMESH_MeshPartDS > tmpDSDeleter(0);
+ if ( CORBA::is_nil( meshPart ) ||
+ SMESH::DownCast< SMESH_Mesh_i* >( meshPart ))
+ {
+ aMeshName = prepareMeshNameAndGroups(file, overwrite);
+ _impl->ExportMED( file, aMeshName.c_str(), auto_groups,
+ version, 0, autoDimension, /*addODOnVertices=*/have0dField);
+ meshDS = _impl->GetMeshDS();
}
else
{
PrepareForWriting(file, overwrite);
- string aMeshName = "Mesh";
SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
if ( !aStudy->_is_nil() ) {
SALOMEDS::SObject_wrap SO = _gen_i->ObjectToSObject( aStudy, meshPart );
aMeshName = name;
}
}
- SMESH_MeshPartDS partDS( meshPart );
- _impl->ExportMED( file, aMeshName.c_str(), auto_groups, version, &partDS, autoDimension );
+ SMESH_MeshPartDS* partDS = new SMESH_MeshPartDS( meshPart );
+ _impl->ExportMED( file, aMeshName.c_str(), auto_groups,
+ version, partDS, autoDimension, /*addODOnVertices=*/have0dField);
+ meshDS = tmpDSDeleter._obj = partDS;
}
- pyDump << SMESH::SMESH_Mesh_var(_this()) << ".ExportPartToMED( "
- << meshPart << ", r'" << file << "', "
- << auto_groups << ", " << version << ", " << overwrite << ", "
- << autoDimension << " )";
+
+ // write fields
+
+ if ( _impl->HasShapeToMesh() )
+ {
+ DriverMED_W_Field fieldWriter;
+ fieldWriter.SetFile( file );
+ fieldWriter.SetMeshName( aMeshName );
+ fieldWriter.AddODOnVertices( have0dField );
+
+ exportMEDFields( fieldWriter, meshDS, fields, geomAssocFields );
+ }
+
+ // dump
+ GEOM::ListOfGBO_var goList = new GEOM::ListOfGBO;
+ goList->length( fields.length() );
+ for ( size_t i = 0; i < fields.length(); ++i )
+ {
+ GEOM::GEOM_BaseObject_var gbo = GEOM::GEOM_BaseObject::_narrow( fields[i] );
+ goList[i] = gbo;
+ }
+ TPythonDump() << _this() << ".ExportPartToMED( "
+ << meshPart << ", r'" << file << "', "
+ << auto_groups << ", " << version << ", " << overwrite << ", "
+ << autoDimension << ", " << goList
+ << ", '" << ( geomAssocFields ? geomAssocFields : "" ) << "'" << " )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
+//================================================================================
+/*!
+ * Write GEOM fields to MED file
+ */
+//================================================================================
+
+void SMESH_Mesh_i::exportMEDFields( DriverMED_W_Field& fieldWriter,
+ SMESHDS_Mesh* meshDS,
+ const GEOM::ListOfFields& fields,
+ const char* geomAssocFields)
+{
+#define METH "SMESH_Mesh_i::exportMEDFields() "
+
+ if (( fields.length() < 1 ) &&
+ ( !geomAssocFields || !geomAssocFields[0] ))
+ return;
+
+ std::vector< double > dblVals( meshDS->MaxShapeIndex()+1 );
+ std::vector< int > intVals( meshDS->MaxShapeIndex()+1 );
+ std::vector< int > subIdsByDim[ 4 ];
+ const double noneDblValue = 0.;
+ const double noneIntValue = 0;
+
+ for ( size_t iF = 0; iF < fields.length(); ++iF )
+ {
+ // set field data
+
+ int dim = fields[ iF ]->GetDimension();
+ SMDSAbs_ElementType elemType;
+ TopAbs_ShapeEnum shapeType;
+ switch ( dim ) {
+ case 0: elemType = SMDSAbs_0DElement; shapeType = TopAbs_VERTEX; break;
+ case 1: elemType = SMDSAbs_Edge; shapeType = TopAbs_EDGE; break;
+ case 2: elemType = SMDSAbs_Face; shapeType = TopAbs_FACE; break;
+ case 3: elemType = SMDSAbs_Volume; shapeType = TopAbs_SOLID; break;
+ default:
+ continue; // skip fields on whole shape
+ }
+ GEOM::field_data_type dataType = fields[ iF ]->GetDataType();
+ if ( dataType == GEOM::FDT_String )
+ continue;
+ GEOM::ListOfLong_var stepIDs = fields[ iF ]->GetSteps();
+ if ( stepIDs->length() < 1 )
+ continue;
+ GEOM::string_array_var comps = fields[ iF ]->GetComponents();
+ if ( comps->length() < 1 )
+ continue;
+ CORBA::String_var name = fields[ iF ]->GetName();
+
+ if ( !fieldWriter.Set( meshDS,
+ name.in(),
+ elemType,
+ comps->length(),
+ /*isIntData=*/false ))//( dataType == GEOM::FDT_Int )))
+ continue;
+
+ for ( size_t iC = 0; iC < comps->length(); ++iC )
+ fieldWriter.SetCompName( iC, comps[ iC ].in() );
+
+ // find sub-shape IDs
+
+ std::vector< int >& subIds = subIdsByDim[ dim ];
+ if ( subIds.empty() )
+ for ( int id = 1; id <= meshDS->MaxShapeIndex(); ++id )
+ if ( meshDS->IndexToShape( id ).ShapeType() == shapeType )
+ subIds.push_back( id );
+
+ // write steps
+
+ SMDS_ElemIteratorPtr elemIt = fieldWriter.GetOrderedElems();
+ if ( !elemIt )
+ continue;
+
+ for ( size_t iS = 0; iS < stepIDs->length(); ++iS )
+ {
+ GEOM::GEOM_FieldStep_var step = fields[ iF ]->GetStep( stepIDs[ iS ]);
+ if ( step->_is_nil() )
+ continue;
+
+ CORBA::Long stamp = step->GetStamp();
+ CORBA::Long id = step->GetID();
+ fieldWriter.SetDtIt( int( stamp ), int( id ));
+
+ // fill dblVals or intVals
+ switch ( dataType )
+ {
+ case GEOM::FDT_Double:
+ {
+ GEOM::GEOM_DoubleFieldStep_var dblStep = GEOM::GEOM_DoubleFieldStep::_narrow( step );
+ if ( dblStep->_is_nil() ) continue;
+ GEOM::ListOfDouble_var vv = dblStep->GetValues();
+ if ( vv->length() != subIds.size() )
+ THROW_SALOME_CORBA_EXCEPTION( METH "BUG: wrong nb subIds", SALOME::INTERNAL_ERROR );
+ for ( size_t i = 0; i < vv->length(); ++i )
+ dblVals[ subIds[ i ]] = vv[ i ];
+ break;
+ }
+ case GEOM::FDT_Int:
+ {
+ GEOM::GEOM_IntFieldStep_var intStep = GEOM::GEOM_IntFieldStep::_narrow( step );
+ if ( intStep->_is_nil() ) continue;
+ GEOM::ListOfLong_var vv = intStep->GetValues();
+ if ( vv->length() != subIds.size() )
+ THROW_SALOME_CORBA_EXCEPTION( METH "BUG: wrong nb subIds", SALOME::INTERNAL_ERROR );
+ for ( size_t i = 0; i < vv->length(); ++i )
+ intVals[ subIds[ i ]] = (int) vv[ i ];
+ break;
+ }
+ case GEOM::FDT_Bool:
+ {
+ GEOM::GEOM_BoolFieldStep_var boolStep = GEOM::GEOM_BoolFieldStep::_narrow( step );
+ if ( boolStep->_is_nil() ) continue;
+ GEOM::short_array_var vv = boolStep->GetValues();
+ if ( vv->length() != subIds.size() )
+ THROW_SALOME_CORBA_EXCEPTION( METH "BUG: wrong nb subIds", SALOME::INTERNAL_ERROR );
+ for ( size_t i = 0; i < vv->length(); ++i )
+ intVals[ subIds[ i ]] = (int) vv[ i ];
+ break;
+ }
+ default: continue;
+ }
+
+ // pass values to fieldWriter
+ elemIt = fieldWriter.GetOrderedElems();
+ if ( dataType == GEOM::FDT_Double )
+ while ( elemIt->more() )
+ {
+ const SMDS_MeshElement* e = elemIt->next();
+ const int shapeID = e->getshapeId();
+ if ( shapeID < 1 || shapeID >= dblVals.size() )
+ fieldWriter.AddValue( noneDblValue );
+ else
+ fieldWriter.AddValue( dblVals[ shapeID ]);
+ }
+ else
+ while ( elemIt->more() )
+ {
+ const SMDS_MeshElement* e = elemIt->next();
+ const int shapeID = e->getshapeId();
+ if ( shapeID < 1 || shapeID >= intVals.size() )
+ fieldWriter.AddValue( (double) noneIntValue );
+ else
+ fieldWriter.AddValue( (double) intVals[ shapeID ]);
+ }
+
+ // write a step
+ fieldWriter.Perform();
+ SMESH_ComputeErrorPtr res = fieldWriter.GetError();
+ if ( res && res->IsKO() )
+ {
+ if ( res->myComment.empty() )
+ { THROW_SALOME_CORBA_EXCEPTION( METH "Fatal error", SALOME::INTERNAL_ERROR ); }
+ else
+ { THROW_SALOME_CORBA_EXCEPTION( res->myComment.c_str(), SALOME::INTERNAL_ERROR ); }
+ }
+
+ } // loop on steps
+ } // loop on fields
+
+ if ( !geomAssocFields || !geomAssocFields[0] )
+ return;
+
+ // write geomAssocFields
+
+ std::vector< int > shapeDim( TopAbs_SHAPE + 1 );
+ shapeDim[ TopAbs_COMPOUND ] = 3;
+ shapeDim[ TopAbs_COMPSOLID ] = 3;
+ shapeDim[ TopAbs_SOLID ] = 3;
+ shapeDim[ TopAbs_SHELL ] = 2;
+ shapeDim[ TopAbs_FACE ] = 2;
+ shapeDim[ TopAbs_WIRE ] = 1;
+ shapeDim[ TopAbs_EDGE ] = 1;
+ shapeDim[ TopAbs_VERTEX ] = 0;
+ shapeDim[ TopAbs_SHAPE ] = 3;
+
+ for ( int iF = 0; geomAssocFields[ iF ]; ++iF )
+ {
+ std::vector< std::string > compNames;
+ switch ( geomAssocFields[ iF ]) {
+ case 'v': case 'V':
+ fieldWriter.Set( meshDS, "_vertices_", SMDSAbs_Node, /*nbComps=*/2, /*isInt=*/false );
+ compNames.push_back( "dim" );
+ break;
+ case 'e': case 'E':
+ fieldWriter.Set( meshDS, "_edges_", SMDSAbs_Edge, /*nbComps=*/1, /*isInt=*/false );
+ break;
+ case 'f': case 'F':
+ fieldWriter.Set( meshDS, "_faces_", SMDSAbs_Face, /*nbComps=*/1, /*isInt=*/false );
+ break;
+ case 's': case 'S':
+ fieldWriter.Set( meshDS, "_solids_", SMDSAbs_Volume, /*nbComps=*/1, /*isInt=*/false );
+ break;
+ default: continue;
+ }
+ compNames.push_back( "id" );
+ for ( size_t iC = 0; iC < compNames.size(); ++iC )
+ fieldWriter.SetCompName( iC, compNames[ iC ].c_str() );
+
+ fieldWriter.SetDtIt( -1, -1 );
+
+ SMDS_ElemIteratorPtr elemIt = fieldWriter.GetOrderedElems();
+ if ( !elemIt )
+ continue;
+
+ if ( compNames.size() == 2 ) // _vertices_
+ while ( elemIt->more() )
+ {
+ const SMDS_MeshElement* e = elemIt->next();
+ const int shapeID = e->getshapeId();
+ if ( shapeID < 1 )
+ {
+ fieldWriter.AddValue( (double) -1 );
+ fieldWriter.AddValue( (double) -1 );
+ }
+ else
+ {
+ const TopoDS_Shape& S = meshDS->IndexToShape( shapeID );
+ fieldWriter.AddValue( (double) ( S.IsNull() ? -1 : shapeDim[ S.ShapeType() ]));
+ fieldWriter.AddValue( (double) shapeID );
+ }
+ }
+ else
+ while ( elemIt->more() )
+ {
+ const SMDS_MeshElement* e = elemIt->next();
+ const int shapeID = e->getshapeId();
+ if ( shapeID < 1 )
+ fieldWriter.AddValue( (double) -1 );
+ else
+ fieldWriter.AddValue( (double) shapeID );
+ }
+
+ // write a step
+ fieldWriter.Perform();
+ SMESH_ComputeErrorPtr res = fieldWriter.GetError();
+ if ( res && res->IsKO() )
+ {
+ if ( res->myComment.empty() )
+ { THROW_SALOME_CORBA_EXCEPTION( METH "Fatal error", SALOME::INTERNAL_ERROR ); }
+ else
+ { THROW_SALOME_CORBA_EXCEPTION( res->myComment.c_str(), SALOME::INTERNAL_ERROR ); }
+ }
+
+ } // loop on geomAssocFields
+
+#undef METH
}
//================================================================================
return ( SMESH::EntityType ) e->GetEntityType();
}
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+SMESH::GeometryType SMESH_Mesh_i::GetElementShape( const CORBA::Long id )
+ throw (SALOME::SALOME_Exception)
+{
+ if ( _preMeshInfo )
+ _preMeshInfo->FullLoadFromFile();
+
+ const SMDS_MeshElement* e = _impl->GetMeshDS()->FindElement(id);
+ if ( !e )
+ THROW_SALOME_CORBA_EXCEPTION( "invalid element id", SALOME::BAD_PARAM );
+
+ return ( SMESH::GeometryType ) e->GetGeomType();
+}
+
//=============================================================================
/*!
* Returns ID of elements for given submesh
// find inverse elements
SMDS_ElemIteratorPtr eIt = aNode->GetInverseElementIterator();
- TColStd_SequenceOfInteger IDs;
- while(eIt->more()) {
+ aResult->length( aNode->NbInverseElements() );
+ for( int i = 0; eIt->more(); ++i )
+ {
const SMDS_MeshElement* elem = eIt->next();
- IDs.Append(elem->GetID());
- }
- if(IDs.Length()>0) {
- aResult->length(IDs.Length());
- int i = 1;
- for(; i<=IDs.Length(); i++) {
- aResult[i-1] = IDs.Value(i);
- }
+ aResult[ i ] = elem->GetID();
}
return aResult._retn();
}
return aResult._retn();
}
+//=======================================================================
+//function : GetElemFaceNodes
+//purpose : Returns three components of normal of given mesh face.
+//=======================================================================
+
+SMESH::double_array* SMESH_Mesh_i::GetFaceNormal(CORBA::Long elemId,
+ CORBA::Boolean normalized)
+{
+ if ( _preMeshInfo )
+ _preMeshInfo->FullLoadFromFile();
+
+ SMESH::double_array_var aResult = new SMESH::double_array();
+
+ if ( SMESHDS_Mesh* mesh = _impl->GetMeshDS() )
+ {
+ gp_XYZ normal;
+ if ( SMESH_MeshAlgos::FaceNormal( mesh->FindElement(elemId), normal, normalized ))
+ {
+ aResult->length( 3 );
+ aResult[ 0 ] = normal.X();
+ aResult[ 1 ] = normal.Y();
+ aResult[ 2 ] = normal.Z();
+ }
+ }
+ return aResult._retn();
+}
+
//=======================================================================
//function : FindElementByNodes
//purpose : Returns an element based on all given nodes.
SALOMEDS::SObject_wrap aSO =
_gen_i->PublishGroup( study, mesh, groups[ iG ],
GEOM::GEOM_Object::_nil(), theGroupName);
- aSO->_is_nil(); // avoid "unused variable" warning
}
SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( groups[ iG ]);
if ( !grp_i ) continue;
while (theItr->more())
theInfo[ theItr->next()->GetEntityType() ]++;
}
+//=============================================================================
+/*
+ * Returns mesh unstructed grid information.
+ */
+//=============================================================================
+
+SALOMEDS::TMPFile* SMESH_Mesh_i::GetVtkUgStream()
+{
+ SALOMEDS::TMPFile_var SeqFile;
+ if ( SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS() ) {
+ SMDS_UnstructuredGrid* aGrid = aMeshDS->getGrid();
+ if(aGrid) {
+ vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New();
+ aWriter->WriteToOutputStringOn();
+ aWriter->SetInputData(aGrid);
+ aWriter->SetFileTypeToBinary();
+ aWriter->Write();
+ char* str = aWriter->GetOutputString();
+ int size = aWriter->GetOutputStringLength();
+
+ //Allocate octect buffer of required size
+ CORBA::Octet* OctetBuf = SALOMEDS::TMPFile::allocbuf(size);
+ //Copy ostrstream content to the octect buffer
+ memcpy(OctetBuf, str, size);
+ //Create and return TMPFile
+ SeqFile = new SALOMEDS::TMPFile(size, size, OctetBuf, 1);
+ aWriter->Delete();
+ }
+ }
+ return SeqFile._retn();
+}
//=============================================================================
namespace /* Iterators used in SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_var obj,
_elem = _mesh->FindNode( *_idPtr++ );
}
else if ((_elem = _mesh->FindElement( *_idPtr++ )) &&
- _elem->GetType() != _type )
+ (_elem->GetType() != _type && _type != SMDSAbs_All ))
{
_elem = 0;
}
if ( sm )
{
elemIt = sm->GetElements();
- if ( elemType != SMDSAbs_Node )
+ if ( elemType != SMDSAbs_Node && elemType != SMDSAbs_All )
{
typeOK = ( elemIt && elemIt->more() && elemIt->next()->GetType() == elemType );
elemIt = typeOK ? sm->GetElements() : SMDS_ElemIteratorPtr();
else if ( SMESH_GroupBase_i* group_i = SMESH::DownCast<SMESH_GroupBase_i*>( theObject ))
{
SMESHDS_GroupBase* groupDS = group_i->GetGroupDS();
- if ( groupDS && ( groupDS->GetType() == elemType || elemType == SMDSAbs_Node ))
+ if ( groupDS && ( elemType == groupDS->GetType() ||
+ elemType == SMDSAbs_Node ||
+ elemType == SMDSAbs_All ))
{
elemIt = groupDS->GetElements();
- typeOK = ( groupDS->GetType() == elemType );
+ typeOK = ( groupDS->GetType() == elemType || elemType == SMDSAbs_All );
}
}
else if ( SMESH::Filter_i* filter_i = SMESH::DownCast<SMESH::Filter_i*>( theObject ))
{
- if ( filter_i->GetElementType() == theType || elemType == SMDSAbs_Node )
+ if ( filter_i->GetElementType() == theType ||
+ elemType == SMDSAbs_Node ||
+ elemType == SMDSAbs_All)
{
SMESH::Predicate_i* pred_i = filter_i->GetPredicate_i();
if ( pred_i && pred_i->GetPredicate() )
SMDSAbs_ElementType filterType = SMDSAbs_ElementType( filter_i->GetElementType() );
SMDS_ElemIteratorPtr allElemIt = meshDS->elementsIterator( filterType );
elemIt = SMDS_ElemIteratorPtr( new PredicateIterator( allElemIt, pred_i->GetPredicate() ));
- typeOK = ( filterType == elemType );
+ typeOK = ( filterType == elemType || elemType == SMDSAbs_All );
}
}
}
{
SMESH::array_of_ElementType_var types = theObject->GetTypes();
const bool isNodes = ( types->length() == 1 && types[0] == SMESH::NODE );
- if ( isNodes && elemType != SMDSAbs_Node )
+ if ( isNodes && elemType != SMDSAbs_Node && elemType != SMDSAbs_All )
return elemIt;
if ( SMESH_MeshEditor_i::IsTemporaryIDSource( theObject ))
{
SMESH::long_array_var ids = theObject->GetIDs();
elemIt = SMDS_ElemIteratorPtr( new IDSourceIterator( meshDS, ids._retn(), elemType ));
}
- typeOK = ( isNodes == ( elemType == SMDSAbs_Node ));
+ typeOK = ( isNodes == ( elemType == SMDSAbs_Node )) || ( elemType == SMDSAbs_All );
}
if ( elemIt && elemIt->more() && !typeOK )
//theCommon.insert( theSubMesh );
}
+//-----------------------------------------------------------------------------
+bool isSubMeshInList ( int smID, const TListOfListOfInt& smLists )
+{
+ TListOfListOfInt::const_iterator listsIt = smLists.begin();
+ for ( ; listsIt != smLists.end(); ++listsIt )
+ {
+ const TListOfInt& smIDs = *listsIt;
+ if ( std::find( smIDs.begin(), smIDs.end(), smID ) != smIDs.end() )
+ return true;
+ }
+ return false;
+}
+
} // namespace
+//=============================================================================
+/*!
+ * \brief Return \c true if a meshing order not yet set for a concurrent sub-mesh
+ */
+//=============================================================================
+
+CORBA::Boolean SMESH_Mesh_i::IsUnorderedSubMesh(CORBA::Long submeshID)
+{
+ TListOfListOfInt anOrder = GetImpl().GetMeshOrder(); // already defined order
+ if ( isSubMeshInList( submeshID, anOrder ))
+ return false;
+
+ TListOfListOfInt allConurrent = findConcurrentSubMeshes();
+ return isSubMeshInList( submeshID, allConurrent );
+}
+
//=============================================================================
/*!
* \brief Return submesh objects list in meshing order
SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
if ( !aMeshDS )
return aResult._retn();
-
- ::SMESH_Mesh& mesh = GetImpl();
- TListOfListOfInt anOrder = mesh.GetMeshOrder(); // is there already defined order?
- if ( !anOrder.size() ) {
+ TListOfListOfInt anOrder = GetImpl().GetMeshOrder(); // already defined order
+ TListOfListOfInt allConurrent = findConcurrentSubMeshes();
+ anOrder.splice( anOrder.end(), allConurrent );
+
+ int listIndx = 0;
+ TListOfListOfInt::iterator listIt = anOrder.begin();
+ for(; listIt != anOrder.end(); listIt++, listIndx++ )
+ unionLists( *listIt, anOrder, listIndx + 1 );
+
+ // convert submesh ids into interface instances
+ // and dump command into python
+ convertMeshOrder( anOrder, aResult, false );
+
+ return aResult._retn();
+}
+
+//=============================================================================
+/*!
+ * \brief Finds concurrent sub-meshes
+ */
+//=============================================================================
+
+TListOfListOfInt SMESH_Mesh_i::findConcurrentSubMeshes()
+{
+ TListOfListOfInt anOrder;
+ ::SMESH_Mesh& mesh = GetImpl();
+ {
// collect submeshes and detect concurrent algorithms and hypothesises
TDimHypList dimHypListArr[4]; // dimHyp list for each shape dimension
-
+
map<int, ::SMESH_subMesh*>::iterator i_sm = _mapSubMesh.begin();
for ( ; i_sm != _mapSubMesh.end(); i_sm++ ) {
::SMESH_subMesh* sm = (*i_sm).second;
for(; listIt != anOrder.end(); listIt++, listIndx++ )
unionLists( *listIt, anOrder, listIndx + 1 );
}
- // convert submesh ids into interface instances
- // and dump command into python
- convertMeshOrder( anOrder, aResult, false );
- return aResult._retn();
+ return anOrder;
}
//=============================================================================
{
const SMESH::submesh_array& aSMArray = theSubMeshArray[i];
TListOfInt subMeshIds;
+ if ( i > 0 )
+ aPythonDump << ", ";
aPythonDump << "[ ";
// Collect subMeshes which should be clear
// do it list-by-list, because modification of submesh order
SMESH::submesh_array_var aResSubSet = new SMESH::submesh_array();
aResSubSet->length(aSubOrder.size());
TListOfInt::const_iterator subIt = aSubOrder.begin();
- for( int j = 0; subIt != aSubOrder.end(); subIt++ ) {
+ int j;
+ for( j = 0; subIt != aSubOrder.end(); subIt++ ) {
if ( _mapSubMeshIor.find(*subIt) == _mapSubMeshIor.end() )
continue;
SMESH::SMESH_subMesh_var subMesh =
}
if ( theIsDump )
aPythonDump << " ]";
- theResOrder[ listIndx++ ] = aResSubSet;
+ if ( j > 1 )
+ theResOrder[ listIndx++ ] = aResSubSet;
}
// correct number of lists
theResOrder.length( listIndx );
}
myInfo = tmpInfo;
+ ShapeToMesh( _meshDS->ShapeToMesh() );
+
_meshDS = 0; // to enforce iteration on _elements and _nodes
}
}