-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2013 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
#include "DriverMED_R_SMESHDS_Mesh.h"
#include "DriverMED_W_SMESHDS_Mesh.h"
+#include "MED_Factory.hxx"
#include "SMDS_EdgePosition.hxx"
#include "SMDS_ElemIterator.hxx"
#include "SMDS_FacePosition.hxx"
#include "SMDS_IteratorOnIterators.hxx"
+#include "SMDS_MeshGroup.hxx"
#include "SMDS_SetIterator.hxx"
#include "SMDS_VolumeTool.hxx"
#include "SMESHDS_Command.hxx"
#include "SMESHDS_CommandType.hxx"
+#include "SMESHDS_Group.hxx"
#include "SMESHDS_GroupOnGeom.hxx"
+#include "SMESH_Controls.hxx"
#include "SMESH_Filter_i.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Group.hxx"
#include "SMESH_Group_i.hxx"
-#include "SMESH_MEDMesh_i.hxx"
#include "SMESH_MeshEditor.hxx"
#include "SMESH_MeshEditor_i.hxx"
+#include "SMESH_MeshPartDS.hxx"
#include "SMESH_MesherHelper.hxx"
#include "SMESH_PreMeshInfo.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_CorbaException.hxx>
#include <Utils_ExceptHandlers.hxx>
#include <Utils_SINGLETON.hxx>
#include <utilities.h>
+
#include <GEOMImpl_Types.hxx>
+#include <GEOM_wrap.hxx>
// OCCT Includes
#include <BRep_Builder.hxx>
#include <OSD_File.hxx>
#include <OSD_Path.hxx>
#include <OSD_Protection.hxx>
+#include <Standard_OutOfMemory.hxx>
#include <TColStd_MapIteratorOfMapOfInteger.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <TColStd_SequenceOfInteger.hxx>
#include <TCollection_AsciiString.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
-#include <TopoDS_Compound.hxx>
-#include <TopTools_MapOfShape.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>
#ifdef _DEBUG_
int SMESH_Mesh_i::_idGenerator = 0;
-//To disable automatic genericobj management, the following line should be commented.
-//Otherwise, it should be uncommented. Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
-#define WITHGENERICOBJ
-
//=============================================================================
/*!
* Constructor
: SALOME::GenericObj_i( thePOA )
{
MESSAGE("SMESH_Mesh_i");
- _impl = NULL;
- _gen_i = gen_i;
- _id = _idGenerator++;
- _studyId = studyId;
+ _impl = NULL;
+ _gen_i = gen_i;
+ _id = _idGenerator++;
+ _studyId = studyId;
_preMeshInfo = NULL;
}
{
MESSAGE("~SMESH_Mesh_i");
-#ifdef WITHGENERICOBJ
// destroy groups
map<int, SMESH::SMESH_GroupBase_ptr>::iterator itGr;
- for (itGr = _mapGroups.begin(); itGr != _mapGroups.end(); itGr++) {
- if ( CORBA::is_nil( itGr->second ))
- continue;
- SMESH_GroupBase_i* aGroup = dynamic_cast<SMESH_GroupBase_i*>(SMESH_Gen_i::GetServant(itGr->second).in());
- if (aGroup) {
- // this method is called from destructor of group (PAL6331)
+ for (itGr = _mapGroups.begin(); itGr != _mapGroups.end(); itGr++)
+ if (SMESH_GroupBase_i* aGroup = SMESH::DownCast<SMESH_GroupBase_i*>(itGr->second))
+ {
+ // _impl->RemoveGroup() is called by ~SMESH_GroupBase_i() (PAL6331)
//_impl->RemoveGroup( aGroup->GetLocalID() );
aGroup->myMeshServant = 0;
aGroup->UnRegister();
}
- }
_mapGroups.clear();
// destroy submeshes
map<int, SMESH::SMESH_subMesh_ptr>::iterator itSM;
- for ( itSM = _mapSubMeshIor.begin(); itSM != _mapSubMeshIor.end(); itSM++ ) {
- if ( CORBA::is_nil( itSM->second ))
- continue;
- SMESH_subMesh_i* aSubMesh = dynamic_cast<SMESH_subMesh_i*>(SMESH_Gen_i::GetServant(itSM->second).in());
- if (aSubMesh) {
+ for ( itSM = _mapSubMeshIor.begin(); itSM != _mapSubMeshIor.end(); itSM++ )
+ if ( SMESH_subMesh_i* aSubMesh = SMESH::DownCast<SMESH_subMesh_i*>( itSM->second ))
+ {
aSubMesh->UnRegister();
}
- }
_mapSubMeshIor.clear();
// destroy hypotheses
map<int, SMESH::SMESH_Hypothesis_ptr>::iterator itH;
- for ( itH = _mapHypo.begin(); itH != _mapHypo.end(); itH++ ) {
- if ( CORBA::is_nil( itH->second ))
- continue;
- SMESH_Hypothesis_i* aHypo = dynamic_cast<SMESH_Hypothesis_i*>(SMESH_Gen_i::GetServant(itH->second).in());
- if (aHypo) {
+ for ( itH = _mapHypo.begin(); itH != _mapHypo.end(); itH++ )
+ if ( SMESH_Hypothesis_i* aHypo = SMESH::DownCast<SMESH_Hypothesis_i*>( itH->second ))
+ {
aHypo->UnRegister();
}
- }
_mapHypo.clear();
-#endif
delete _impl; _impl = NULL;
-
- if ( _preMeshInfo ) delete _preMeshInfo; _preMeshInfo = NULL;
+ delete _preMeshInfo; _preMeshInfo = NULL;
}
//=============================================================================
catch(SALOME_Exception & S_ex) {
THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
}
+ _impl->GetMeshDS()->Modified();
+
TPythonDump() << _this() << ".Clear()";
}
catch(SALOME_Exception & S_ex) {
THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
}
+ _impl->GetMeshDS()->Modified();
+
+ TPythonDump() << _this() << ".ClearSubMesh( " << ShapeID << " )";
}
//=============================================================================
/*!
- *
+ * Convert enum Driver_Mesh::Status to SMESH::DriverMED_ReadStatus
*/
//=============================================================================
res = SMESH::DRS_WARN_RENUMBER; break;
case DriverMED_R_SMESHDS_Mesh::DRS_WARN_SKIP_ELEM:
res = SMESH::DRS_WARN_SKIP_ELEM; break;
+ case DriverMED_R_SMESHDS_Mesh::DRS_WARN_DESCENDING:
+ res = SMESH::DRS_WARN_DESCENDING; break;
case DriverMED_R_SMESHDS_Mesh::DRS_FAIL:
default:
res = SMESH::DRS_FAIL; break;
return res;
}
+//=============================================================================
+/*!
+ * Convert ::SMESH_ComputeError to SMESH::ComputeError
+ */
+//=============================================================================
+
+static SMESH::ComputeError* ConvertComputeError( SMESH_ComputeErrorPtr errorPtr )
+{
+ SMESH::ComputeError_var errVar = new SMESH::ComputeError();
+ errVar->subShapeID = -1;
+ errVar->hasBadMesh = false;
+
+ if ( !errorPtr || errorPtr->IsOK() )
+ {
+ errVar->code = SMESH::COMPERR_OK;
+ }
+ else
+ {
+ errVar->code = ConvertDriverMEDReadStatus( errorPtr->myName );
+ errVar->comment = errorPtr->myComment.c_str();
+ }
+ return errVar._retn();
+}
+
//=============================================================================
/*!
* ImportMEDFile
int major, minor, release;
if( !MED::getMEDVersion( theFileName, major, minor, release ) )
major = minor = release = -1;
- _medFileInfo = new SALOME_MED::MedFileInfo();
+ _medFileInfo = new SMESH::MedFileInfo();
_medFileInfo->fileName = theFileName;
_medFileInfo->fileSize = 0;
#ifdef WIN32
int SMESH_Mesh_i::ImportUNVFile( const char* theFileName )
throw ( SALOME::SALOME_Exception )
{
+ SMESH_TRY;
+
// Read mesh with name = <theMeshName> into SMESH_Mesh
_impl->UNVToMesh( theFileName );
CreateGroupServants();
+ SMESH_CATCH( SMESH::throwCorbaException );
+
return 1;
}
int SMESH_Mesh_i::ImportSTLFile( const char* theFileName )
throw ( SALOME::SALOME_Exception )
{
+ SMESH_TRY;
+
// Read mesh with name = <theMeshName> into SMESH_Mesh
_impl->STLToMesh( theFileName );
+ SMESH_CATCH( SMESH::throwCorbaException );
+
return 1;
}
+//================================================================================
+/*!
+ * \brief Function used in SMESH_CATCH by ImportGMFFile()
+ */
+//================================================================================
+
+namespace
+{
+ SMESH_ComputeErrorPtr exceptionToComputeError(const char* excText)
+ {
+ return SMESH_ComputeError::New( Driver_Mesh::DRS_FAIL, excText );
+ }
+}
+
+//================================================================================
+/*!
+ * \brief Imports data from a GMF file and returns an error description
+ */
+//================================================================================
+
+SMESH::ComputeError* SMESH_Mesh_i::ImportGMFFile( const char* theFileName,
+ bool theMakeRequiredGroups )
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_ComputeErrorPtr error;
+
+#undef SMESH_CAUGHT
+#define SMESH_CAUGHT error =
+ SMESH_TRY;
+
+ error = _impl->GMFToMesh( theFileName, theMakeRequiredGroups );
+
+ SMESH_CATCH( exceptionToComputeError );
+#undef SMESH_CAUGHT
+#define SMESH_CAUGHT
+
+ CreateGroupServants();
+
+ return ConvertComputeError( error );
+}
+
//=============================================================================
/*!
*
if(MYDEBUG) MESSAGE( " AddHypothesis(): status = " << status );
// Update Python script
- if(_impl->HasShapeToMesh()) {
+ //if(_impl->HasShapeToMesh()) {
TPythonDump() << "status = " << _this() << ".AddHypothesis( "
<< aSubShapeObject << ", " << anHyp << " )";
- }
- else {
- TPythonDump() << "status = " << _this() << ".AddHypothesis( "<< anHyp << " )";
- }
+ // }
+ // else {
+ // TPythonDump() << "status = " << _this() << ".AddHypothesis( "<< anHyp << " )";
+ // }
return ConvertHypothesisStatus(status);
}
status = _impl->AddHypothesis(myLocSubShape, hypId);
if ( !SMESH_Hypothesis::IsStatusFatal(status) ) {
_mapHypo[hypId] = SMESH::SMESH_Hypothesis::_duplicate( myHyp );
-#ifdef WITHGENERICOBJ
_mapHypo[hypId]->Register();
-#endif
// assure there is a corresponding submesh
if ( !_impl->IsMainShape( myLocSubShape )) {
int shapeId = _impl->GetMeshDS()->ShapeToIndex( myLocSubShape );
if ( subMesh->_is_nil() )
subMesh = createSubMesh( aSubShapeObject );
if ( _gen_i->CanPublishInStudy( subMesh )) {
- SALOMEDS::SObject_var aSO =
+ SALOMEDS::SObject_wrap aSO =
_gen_i->PublishSubMesh(_gen_i->GetCurrentStudy(), aMesh,
subMesh, aSubShapeObject, theName );
if ( !aSO->_is_nil()) {
//=============================================================================
void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
- throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
- if(MYDEBUG) MESSAGE("SMESH_Mesh_i::RemoveSubMesh");
+ SMESH_TRY;
+
if ( theSubMesh->_is_nil() )
return;
GEOM::GEOM_Object_var aSubShapeObject;
- SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
+ SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
if ( !aStudy->_is_nil() ) {
// Remove submesh's SObject
- SALOMEDS::SObject_var anSO = _gen_i->ObjectToSObject( aStudy, theSubMesh );
+ SALOMEDS::SObject_wrap anSO = _gen_i->ObjectToSObject( aStudy, theSubMesh );
if ( !anSO->_is_nil() ) {
long aTag = SMESH_Gen_i::GetRefOnShapeTag();
- SALOMEDS::SObject_var anObj, aRef;
- if ( anSO->FindSubObject( aTag, anObj ) && anObj->ReferencedObject( aRef ) )
- aSubShapeObject = GEOM::GEOM_Object::_narrow( aRef->GetObject() );
-
-// if ( aSubShapeObject->_is_nil() ) // not published shape (IPAL13617)
-// aSubShapeObject = theSubMesh->GetSubShape();
+ SALOMEDS::SObject_wrap anObj, aRef;
+ if ( anSO->FindSubObject( aTag, anObj.inout() ) &&
+ anObj->ReferencedObject( aRef.inout() ))
+ {
+ CORBA::Object_var obj = aRef->GetObject();
+ aSubShapeObject = GEOM::GEOM_Object::_narrow( obj );
+ }
+ // if ( aSubShapeObject->_is_nil() ) // not published shape (IPAL13617)
+ // aSubShapeObject = theSubMesh->GetSubShape();
- aStudy->NewBuilder()->RemoveObjectWithChildren( anSO );
+ SALOMEDS::StudyBuilder_var builder = aStudy->NewBuilder();
+ builder->RemoveObjectWithChildren( anSO );
// Update Python script
TPythonDump() << _this() << ".RemoveSubMesh( " << anSO << " )";
if ( removeSubMesh( theSubMesh, aSubShapeObject.in() ))
if ( _preMeshInfo )
_preMeshInfo->ForgetOrLoad();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=============================================================================
SMESH::SMESH_Group::_narrow( createGroup( theElemType, theName ));
if ( _gen_i->CanPublishInStudy( aNewGroup ) ) {
- SALOMEDS::SObject_var aSO =
+ SALOMEDS::SObject_wrap aSO =
_gen_i->PublishGroup(_gen_i->GetCurrentStudy(), _this(),
aNewGroup, GEOM::GEOM_Object::_nil(), theName);
if ( !aSO->_is_nil()) {
( createGroup( theElemType, theName, aShape ));
if ( _gen_i->CanPublishInStudy( aNewGroup ) ) {
- SALOMEDS::SObject_var aSO =
+ SALOMEDS::SObject_wrap aSO =
_gen_i->PublishGroup(_gen_i->GetCurrentStudy(), _this(),
aNewGroup, theGeomObj, theName);
if ( !aSO->_is_nil()) {
if ( _gen_i->CanPublishInStudy( aNewGroup ) )
{
- SALOMEDS::SObject_var aSO =
+ SALOMEDS::SObject_wrap aSO =
_gen_i->PublishGroup(_gen_i->GetCurrentStudy(), _this(), aNewGroup,
GEOM::GEOM_Object::_nil(), theName);
if ( !aSO->_is_nil()) {
if ( theGroup->_is_nil() )
return;
+ SMESH_TRY;
+
SMESH_GroupBase_i* aGroup =
dynamic_cast<SMESH_GroupBase_i*>( SMESH_Gen_i::GetServant( theGroup ).in() );
if ( !aGroup )
return;
- SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
+ SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
if ( !aStudy->_is_nil() ) {
- SALOMEDS::SObject_var aGroupSO = _gen_i->ObjectToSObject( aStudy, theGroup );
+ SALOMEDS::SObject_wrap aGroupSO = _gen_i->ObjectToSObject( aStudy, theGroup );
if ( !aGroupSO->_is_nil() ) {
// Update Python script
TPythonDump() << _this() << ".RemoveGroup( " << aGroupSO << " )";
// Remove group's SObject
- aStudy->NewBuilder()->RemoveObjectWithChildren( aGroupSO );
+ SALOMEDS::StudyBuilder_var builder = aStudy->NewBuilder();
+ builder->RemoveObjectWithChildren( aGroupSO );
}
}
// Remove the group from SMESH data structures
removeGroup( aGroup->GetLocalID() );
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=============================================================================
void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup )
throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
else
aMeshEditor->RemoveElements( anIds );
+ // Update Python script (theGroup must be alive for this)
+ pyDump << _this() << ".RemoveGroupWithContents( " << theGroup << " )";
+
// Remove group
RemoveGroup( theGroup );
- // Update Python script
- pyDump << _this() << ".RemoveGroupWithContents( " << theGroup << " )";
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//================================================================================
// Python Dump
TPythonDump aPythonDump;
- if ( !_mapGroups.empty() ) // (IMP13463) avoid "SyntaxError: can't assign to []"
+ if ( !_mapGroups.empty() )
+ {
aPythonDump << "[ ";
-
- try {
- aList->length( _mapGroups.size() );
- int i = 0;
- map<int, SMESH::SMESH_GroupBase_ptr>::iterator it = _mapGroups.begin();
- for ( ; it != _mapGroups.end(); it++ ) {
- if ( CORBA::is_nil( it->second )) continue;
- aList[i++] = SMESH::SMESH_GroupBase::_duplicate( it->second );
- // Python Dump
- if (i > 1) aPythonDump << ", ";
- aPythonDump << it->second;
+ try {
+ aList->length( _mapGroups.size() );
+ int i = 0;
+ map<int, SMESH::SMESH_GroupBase_ptr>::iterator it = _mapGroups.begin();
+ for ( ; it != _mapGroups.end(); it++ ) {
+ if ( CORBA::is_nil( it->second )) continue;
+ aList[i++] = SMESH::SMESH_GroupBase::_duplicate( it->second );
+ // Python Dump
+ if (i > 1) aPythonDump << ", ";
+ aPythonDump << it->second;
+ }
+ aList->length( i );
+ }
+ catch(SALOME_Exception & S_ex) {
+ THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
}
- aList->length( i );
- }
- catch(SALOME_Exception & S_ex) {
- THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
- }
-
- // Update Python script
- if ( !_mapGroups.empty() ) // (IMP13463) avoid "SyntaxError: can't assign to []"
aPythonDump << " ] = " << _this() << ".GetGroups()";
-
+ }
return aList._retn();
}
const char* theName )
throw (SALOME::SALOME_Exception)
{
+ SMESH::SMESH_Group_var aResGrp;
+
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- try
- {
- if ( theGroup1->_is_nil() || theGroup2->_is_nil() ||
- theGroup1->GetType() != theGroup2->GetType() )
- return SMESH::SMESH_Group::_nil();
+ if ( theGroup1->_is_nil() || theGroup2->_is_nil() ||
+ theGroup1->GetType() != theGroup2->GetType() )
+ return SMESH::SMESH_Group::_nil();
- // Create Union
- SMESH::SMESH_Group_var aResGrp = CreateGroup( theGroup1->GetType(), theName );
- if ( aResGrp->_is_nil() )
- return SMESH::SMESH_Group::_nil();
+ TPythonDump pyDump;
- SMESH::long_array_var anIds1 = theGroup1->GetListOfID();
- SMESH::long_array_var anIds2 = theGroup2->GetListOfID();
+ // Create Union
+ aResGrp = CreateGroup( theGroup1->GetType(), theName );
+ if ( aResGrp->_is_nil() )
+ return SMESH::SMESH_Group::_nil();
- TColStd_MapOfInteger aResMap;
+ SMESH::long_array_var anIds1 = theGroup1->GetListOfID();
+ SMESH::long_array_var anIds2 = theGroup2->GetListOfID();
- for ( int i1 = 0, n1 = anIds1->length(); i1 < n1; i1++ )
- aResMap.Add( anIds1[ i1 ] );
+ TColStd_MapOfInteger aResMap;
- for ( int i2 = 0, n2 = anIds2->length(); i2 < n2; i2++ )
- aResMap.Add( anIds2[ i2 ] );
+ for ( int i1 = 0, n1 = anIds1->length(); i1 < n1; i1++ )
+ aResMap.Add( anIds1[ i1 ] );
- SMESH::long_array_var aResIds = new SMESH::long_array;
- aResIds->length( aResMap.Extent() );
+ for ( int i2 = 0, n2 = anIds2->length(); i2 < n2; i2++ )
+ aResMap.Add( anIds2[ i2 ] );
- int resI = 0;
- TColStd_MapIteratorOfMapOfInteger anIter( aResMap );
- for( ; anIter.More(); anIter.Next() )
- aResIds[ resI++ ] = anIter.Key();
+ SMESH::long_array_var aResIds = new SMESH::long_array;
+ aResIds->length( aResMap.Extent() );
- aResGrp->Add( aResIds );
+ int resI = 0;
+ TColStd_MapIteratorOfMapOfInteger anIter( aResMap );
+ for( ; anIter.More(); anIter.Next() )
+ aResIds[ resI++ ] = anIter.Key();
- // Clear python lines, created by CreateGroup() and Add()
- SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
- _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
- _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
+ aResGrp->Add( aResIds );
- // Update Python script
- TPythonDump() << aResGrp << " = " << _this() << ".UnionGroups( "
- << theGroup1 << ", " << theGroup2 << ", '"
- << theName << "' )";
+ // Update Python script
+ pyDump << aResGrp << " = " << _this() << ".UnionGroups( "
+ << theGroup1 << ", " << theGroup2 << ", '"
+ << theName << "' )";
- return aResGrp._retn();
- }
- catch( ... )
- {
- return SMESH::SMESH_Group::_nil();
- }
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ return aResGrp._retn();
}
//=============================================================================
/*!
\brief Union list of groups. New group is created. All mesh elements that are
- present in initial groups are added to the new one.
+ present in initial groups are added to the new one.
\param theGroups list of groups
\param theName name of group to be created
\return pointer on the group
//=============================================================================
SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups& theGroups,
const char* theName )
-throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
if ( !theName )
return SMESH::SMESH_Group::_nil();
- try
- {
- vector< int > anIds;
- SMESH::ElementType aType = SMESH::ALL;
- for ( int g = 0, n = theGroups.length(); g < n; g++ )
- {
- SMESH::SMESH_GroupBase_var aGrp = theGroups[ g ];
- if ( CORBA::is_nil( aGrp ) )
- continue;
+ SMESH::SMESH_Group_var aResGrp;
- // check type
- SMESH::ElementType aCurrType = aGrp->GetType();
- if ( aType == SMESH::ALL )
- aType = aCurrType;
- else
- {
- if ( aType != aCurrType )
- return SMESH::SMESH_Group::_nil();
- }
+ SMESH_TRY;
- // unite ids
- SMESH::long_array_var aCurrIds = aGrp->GetListOfID();
- for ( int i = 0, n = aCurrIds->length(); i < n; i++ )
- {
- int aCurrId = aCurrIds[ i ];
- anIds.push_back( aCurrId );
- }
- }
+ vector< int > anIds;
+ SMESH::ElementType aType = SMESH::ALL;
+ for ( int g = 0, n = theGroups.length(); g < n; g++ )
+ {
+ SMESH::SMESH_GroupBase_var aGrp = theGroups[ g ];
+ if ( CORBA::is_nil( aGrp ) )
+ continue;
- // Create group
- SMESH::SMESH_Group_var aResGrp = CreateGroup( aType, theName );
- if ( aResGrp->_is_nil() )
- return SMESH::SMESH_Group::_nil();
-
- // Create array of identifiers
- SMESH::long_array_var aResIds = new SMESH::long_array;
- aResIds->length( anIds.size() );
-
- //NCollection_Map< int >::Iterator anIter( anIds );
- for ( int i = 0; i<anIds.size(); i++ )
+ // check type
+ SMESH::ElementType aCurrType = aGrp->GetType();
+ if ( aType == SMESH::ALL )
+ aType = aCurrType;
+ else
{
- aResIds[ i ] = anIds[i];
+ if ( aType != aCurrType )
+ return SMESH::SMESH_Group::_nil();
}
- aResGrp->Add( aResIds );
- // Clear python lines, created by CreateGroup() and Add()
- SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
- _gen_i->RemoveLastFromPythonScript( aStudy->StudyId() );
- _gen_i->RemoveLastFromPythonScript( aStudy->StudyId() );
+ // unite ids
+ SMESH::long_array_var aCurrIds = aGrp->GetListOfID();
+ for ( int i = 0, n = aCurrIds->length(); i < n; i++ )
+ {
+ int aCurrId = aCurrIds[ i ];
+ anIds.push_back( aCurrId );
+ }
+ }
- // Update Python script
-
- TPythonDump() << aResGrp << " = " << _this() << ".UnionListOfGroups( "
- << &theGroups << ", '" << theName << "' )";
+ TPythonDump pyDump;
- return aResGrp._retn();
- }
- catch( ... )
- {
+ // Create group
+ aResGrp = CreateGroup( aType, theName );
+ if ( aResGrp->_is_nil() )
return SMESH::SMESH_Group::_nil();
- }
+
+ // Create array of identifiers
+ SMESH::long_array_var aResIds = new SMESH::long_array;
+ aResIds->length( anIds.size() );
+
+ for ( size_t i = 0; i<anIds.size(); i++ )
+ aResIds[ i ] = anIds[i];
+ aResGrp->Add( aResIds );
+
+ // Update Python script
+ pyDump << aResGrp << " = " << _this() << ".UnionListOfGroups( "
+ << &theGroups << ", '" << theName << "' )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ return aResGrp._retn();
}
//=============================================================================
//=============================================================================
SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
- const char* theName )
+ const char* theName )
throw (SALOME::SALOME_Exception)
{
+ SMESH::SMESH_Group_var aResGrp;
+
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
theGroup1->GetType() != theGroup2->GetType() )
return SMESH::SMESH_Group::_nil();
+ TPythonDump pyDump;
+
// Create Intersection
- SMESH::SMESH_Group_var aResGrp = CreateGroup( theGroup1->GetType(), theName );
+ aResGrp = CreateGroup( theGroup1->GetType(), theName );
if ( aResGrp->_is_nil() )
return aResGrp;
aMap1.Add( anIds1[ i1 ] );
TColStd_SequenceOfInteger aSeq;
-
for ( int i2 = 0, n2 = anIds2->length(); i2 < n2; i2++ )
if ( aMap1.Contains( anIds2[ i2 ] ) )
aSeq.Append( anIds2[ i2 ] );
SMESH::long_array_var aResIds = new SMESH::long_array;
aResIds->length( aSeq.Length() );
-
- for ( int resI = 0, resN = aSeq.Length(); resI < resN; resI++ )
+ for ( size_t resI = 0, resN = aSeq.Length(); resI < resN; resI++ )
aResIds[ resI ] = aSeq( resI + 1 );
-
aResGrp->Add( aResIds );
- // Clear python lines, created by CreateGroup() and Add()
- SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
- _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
- _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
-
// Update Python script
- TPythonDump() << aResGrp << " = " << _this() << ".IntersectGroups( "
- << theGroup1 << ", " << theGroup2 << ", '" << theName << "')";
+ pyDump << aResGrp << " = " << _this() << ".IntersectGroups( "
+ << theGroup1 << ", " << theGroup2 << ", '" << theName << "')";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
return aResGrp._retn();
}
const char* theName )
throw (SALOME::SALOME_Exception)
{
+ SMESH::SMESH_Group_var aResGrp;
+
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
if ( !theName )
return SMESH::SMESH_Group::_nil();
- try
+ NCollection_DataMap< int, int > anIdToCount;
+ SMESH::ElementType aType = SMESH::ALL;
+ for ( int g = 0, n = theGroups.length(); g < n; g++ )
{
- NCollection_DataMap< int, int > anIdToCount;
- SMESH::ElementType aType = SMESH::ALL;
- for ( int g = 0, n = theGroups.length(); g < n; g++ )
- {
- SMESH::SMESH_GroupBase_var aGrp = theGroups[ g ];
- if ( CORBA::is_nil( aGrp ) )
- continue;
-
- // check type
- SMESH::ElementType aCurrType = aGrp->GetType();
- if ( aType == SMESH::ALL )
- aType = aCurrType;
- else
- {
- if ( aType != aCurrType )
- return SMESH::SMESH_Group::_nil();
- }
+ SMESH::SMESH_GroupBase_var aGrp = theGroups[ g ];
+ if ( CORBA::is_nil( aGrp ) )
+ continue;
- // calculates number of occurance ids in groups
- SMESH::long_array_var aCurrIds = aGrp->GetListOfID();
- for ( int i = 0, n = aCurrIds->length(); i < n; i++ )
- {
- int aCurrId = aCurrIds[ i ];
- if ( !anIdToCount.IsBound( aCurrId ) )
- anIdToCount.Bind( aCurrId, 1 );
- else
- anIdToCount( aCurrId ) = anIdToCount( aCurrId ) + 1;
- }
- }
-
- // create map of ids
- int nbGrp = theGroups.length();
- vector< int > anIds;
- NCollection_DataMap< int, int >::Iterator anIter( anIdToCount );
- for ( ; anIter.More(); anIter.Next() )
+ // check type
+ SMESH::ElementType aCurrType = aGrp->GetType();
+ if ( aType == SMESH::ALL )
+ aType = aCurrType;
+ else
{
- int aCurrId = anIter.Key();
- int aCurrNb = anIter.Value();
- if ( aCurrNb == nbGrp )
- anIds.push_back( aCurrId );
+ if ( aType != aCurrType )
+ return SMESH::SMESH_Group::_nil();
}
- // Create group
- SMESH::SMESH_Group_var aResGrp = CreateGroup( aType, theName );
- if ( aResGrp->_is_nil() )
- return SMESH::SMESH_Group::_nil();
-
- // Create array of identifiers
- SMESH::long_array_var aResIds = new SMESH::long_array;
- aResIds->length( anIds.size() );
-
- //NCollection_Map< int >::Iterator aListIter( anIds );
- for ( int i = 0; i<anIds.size(); i++ )
+ // calculates number of occurance ids in groups
+ SMESH::long_array_var aCurrIds = aGrp->GetListOfID();
+ for ( int i = 0, n = aCurrIds->length(); i < n; i++ )
{
- aResIds[ i ] = anIds[i];
+ int aCurrId = aCurrIds[ i ];
+ if ( !anIdToCount.IsBound( aCurrId ) )
+ anIdToCount.Bind( aCurrId, 1 );
+ else
+ anIdToCount( aCurrId ) = anIdToCount( aCurrId ) + 1;
}
- aResGrp->Add( aResIds );
+ }
- // Clear python lines, created by CreateGroup() and Add()
- SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
- _gen_i->RemoveLastFromPythonScript( aStudy->StudyId() );
- _gen_i->RemoveLastFromPythonScript( aStudy->StudyId() );
+ // create map of ids
+ int nbGrp = theGroups.length();
+ vector< int > anIds;
+ NCollection_DataMap< int, int >::Iterator anIter( anIdToCount );
+ for ( ; anIter.More(); anIter.Next() )
+ {
+ int aCurrId = anIter.Key();
+ int aCurrNb = anIter.Value();
+ if ( aCurrNb == nbGrp )
+ anIds.push_back( aCurrId );
+ }
- // Update Python script
-
- TPythonDump() << aResGrp << " = " << _this() << ".IntersectListOfGroups( "
- << &theGroups << ", '" << theName << "' )";
+ TPythonDump pyDump;
- return aResGrp._retn();
- }
- catch( ... )
- {
+ // Create group
+ aResGrp = CreateGroup( aType, theName );
+ if ( aResGrp->_is_nil() )
return SMESH::SMESH_Group::_nil();
- }
+
+ // Create array of identifiers
+ SMESH::long_array_var aResIds = new SMESH::long_array;
+ aResIds->length( anIds.size() );
+
+ for ( size_t i = 0; i<anIds.size(); i++ )
+ aResIds[ i ] = anIds[i];
+ aResGrp->Add( aResIds );
+
+ // Update Python script
+ pyDump << aResGrp << " = " << _this() << ".IntersectListOfGroups( "
+ << &theGroups << ", '" << theName << "' )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ return aResGrp._retn();
}
//=============================================================================
const char* theName )
throw (SALOME::SALOME_Exception)
{
+ SMESH::SMESH_Group_var aResGrp;
+
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
theGroup1->GetType() != theGroup2->GetType() )
return SMESH::SMESH_Group::_nil();
+ TPythonDump pyDump;
+
// Perform Cutting
- SMESH::SMESH_Group_var aResGrp = CreateGroup( theGroup1->GetType(), theName );
+ aResGrp = CreateGroup( theGroup1->GetType(), theName );
if ( aResGrp->_is_nil() )
return aResGrp;
for ( int resI = 0, resN = aSeq.Length(); resI < resN; resI++ )
aResIds[ resI ] = aSeq( resI + 1 );
-
aResGrp->Add( aResIds );
- // Clear python lines, created by CreateGroup() and Add()
- SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
- _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
- _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
-
// Update Python script
- TPythonDump() << aResGrp << " = " << _this() << ".CutGroups( "
- << theGroup1 << ", " << theGroup2 << ", '"
- << theName << "' )";
+ pyDump << aResGrp << " = " << _this() << ".CutGroups( "
+ << theGroup1 << ", " << theGroup2 << ", '"
+ << theName << "' )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
return aResGrp._retn();
}
const char* theName )
throw (SALOME::SALOME_Exception)
{
+ SMESH::SMESH_Group_var aResGrp;
+
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
if ( !theName )
return SMESH::SMESH_Group::_nil();
- try
+ set< int > aToolIds;
+ SMESH::ElementType aType = SMESH::ALL;
+ int g, n;
+ // iterate through tool groups
+ for ( g = 0, n = theToolGroups.length(); g < n; g++ )
{
- set< int > aToolIds;
- SMESH::ElementType aType = SMESH::ALL;
- int g, n;
- // iterate through tool groups
- for ( g = 0, n = theToolGroups.length(); g < n; g++ )
- {
- SMESH::SMESH_GroupBase_var aGrp = theToolGroups[ g ];
- if ( CORBA::is_nil( aGrp ) )
- continue;
-
- // check type
- SMESH::ElementType aCurrType = aGrp->GetType();
- if ( aType == SMESH::ALL )
- aType = aCurrType;
- else
- {
- if ( aType != aCurrType )
- return SMESH::SMESH_Group::_nil();
- }
+ SMESH::SMESH_GroupBase_var aGrp = theToolGroups[ g ];
+ if ( CORBA::is_nil( aGrp ) )
+ continue;
- // unite tool ids
- SMESH::long_array_var aCurrIds = aGrp->GetListOfID();
- for ( int i = 0, n = aCurrIds->length(); i < n; i++ )
- {
- int aCurrId = aCurrIds[ i ];
- aToolIds.insert( aCurrId );
- }
+ // check type
+ SMESH::ElementType aCurrType = aGrp->GetType();
+ if ( aType == SMESH::ALL )
+ aType = aCurrType;
+ else
+ {
+ if ( aType != aCurrType )
+ return SMESH::SMESH_Group::_nil();
}
- vector< int > anIds; // result
-
- // Iterate through main group
- for ( g = 0, n = theMainGroups.length(); g < n; g++ )
+ // unite tool ids
+ SMESH::long_array_var aCurrIds = aGrp->GetListOfID();
+ for ( int i = 0, n = aCurrIds->length(); i < n; i++ )
{
- SMESH::SMESH_GroupBase_var aGrp = theMainGroups[ g ];
- if ( CORBA::is_nil( aGrp ) )
- continue;
+ int aCurrId = aCurrIds[ i ];
+ aToolIds.insert( aCurrId );
+ }
+ }
- // check type
- SMESH::ElementType aCurrType = aGrp->GetType();
- if ( aType == SMESH::ALL )
- aType = aCurrType;
- else
- {
- if ( aType != aCurrType )
- return SMESH::SMESH_Group::_nil();
- }
+ vector< int > anIds; // result
- // unite tool ids
- SMESH::long_array_var aCurrIds = aGrp->GetListOfID();
- for ( int i = 0, n = aCurrIds->length(); i < n; i++ )
- {
- int aCurrId = aCurrIds[ i ];
- if ( !aToolIds.count( aCurrId ) )
- anIds.push_back( aCurrId );
- }
- }
+ // Iterate through main group
+ for ( g = 0, n = theMainGroups.length(); g < n; g++ )
+ {
+ SMESH::SMESH_GroupBase_var aGrp = theMainGroups[ g ];
+ if ( CORBA::is_nil( aGrp ) )
+ continue;
- // Create group
- SMESH::SMESH_Group_var aResGrp = CreateGroup( aType, theName );
- if ( aResGrp->_is_nil() )
- return SMESH::SMESH_Group::_nil();
-
- // Create array of identifiers
- SMESH::long_array_var aResIds = new SMESH::long_array;
- aResIds->length( anIds.size() );
-
- for (int i=0; i<anIds.size(); i++ )
+ // check type
+ SMESH::ElementType aCurrType = aGrp->GetType();
+ if ( aType == SMESH::ALL )
+ aType = aCurrType;
+ else
{
- aResIds[ i ] = anIds[i];
+ if ( aType != aCurrType )
+ return SMESH::SMESH_Group::_nil();
}
- aResGrp->Add( aResIds );
- // Clear python lines, created by CreateGroup() and Add()
- SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
- _gen_i->RemoveLastFromPythonScript( aStudy->StudyId() );
- _gen_i->RemoveLastFromPythonScript( aStudy->StudyId() );
+ // unite tool ids
+ SMESH::long_array_var aCurrIds = aGrp->GetListOfID();
+ for ( int i = 0, n = aCurrIds->length(); i < n; i++ )
+ {
+ int aCurrId = aCurrIds[ i ];
+ if ( !aToolIds.count( aCurrId ) )
+ anIds.push_back( aCurrId );
+ }
+ }
- // Update Python script
+ TPythonDump pyDump;
- TPythonDump() << aResGrp << " = " << _this() << ".CutListOfGroups( "
- << &theMainGroups << ", " << &theToolGroups << ", '"
- << theName << "' )";
-
- return aResGrp._retn();
- }
- catch( ... )
- {
+ // Create group
+ aResGrp = CreateGroup( aType, theName );
+ if ( aResGrp->_is_nil() )
return SMESH::SMESH_Group::_nil();
- }
+
+ // Create array of identifiers
+ SMESH::long_array_var aResIds = new SMESH::long_array;
+ aResIds->length( anIds.size() );
+
+ for (int i=0; i<anIds.size(); i++ )
+ aResIds[ i ] = anIds[i];
+ aResGrp->Add( aResIds );
+
+ // Update Python script
+ pyDump << aResGrp << " = " << _this() << ".CutListOfGroups( "
+ << &theMainGroups << ", " << &theToolGroups << ", '"
+ << theName << "' )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ return aResGrp._retn();
}
//=============================================================================
/*!
\brief Create groups of entities from existing groups of superior dimensions
- System
+ 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
*/
//=============================================================================
+
SMESH::SMESH_Group_ptr
SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfGroups& theGroups,
SMESH::ElementType theElemType,
const char* theName )
throw (SALOME::SALOME_Exception)
{
+ SMESH::SMESH_Group_var aResGrp;
+
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
SMDSAbs_ElementType anElemType = (SMDSAbs_ElementType)theElemType;
- try
- {
- // Create map of nodes from all groups
+ // Create a group
- set< int > aNodeMap;
-
- for ( int g = 0, n = theGroups.length(); g < n; g++ )
- {
- SMESH::SMESH_GroupBase_var aGrp = theGroups[ g ];
- if ( CORBA::is_nil( aGrp ) )
- continue;
+ TPythonDump pyDump;
- SMESH::ElementType aType = aGrp->GetType();
- if ( aType == SMESH::ALL )
- continue;
- else if ( aType == SMESH::NODE )
- {
- SMESH::long_array_var aCurrIds = aGrp->GetListOfID();
- for ( int i = 0, n = aCurrIds->length(); i < n; i++ )
- {
- int aCurrId = aCurrIds[ i ];
- const SMDS_MeshNode* aNode = aMeshDS->FindNode( aCurrId );
- if ( aNode )
- aNodeMap.insert( aNode->GetID() );
- }
- }
- else
- {
- SMESH::long_array_var aCurrIds = aGrp->GetListOfID();
- for ( int i = 0, n = aCurrIds->length(); i < n; i++ )
- {
- int aCurrId = aCurrIds[ i ];
- const SMDS_MeshElement* anElem = aMeshDS->FindElement( aCurrId );
- if ( !anElem )
- continue;
- SMDS_ElemIteratorPtr aNodeIter = anElem->nodesIterator();
- while( aNodeIter->more() )
- {
- const SMDS_MeshNode* aNode =
- dynamic_cast<const SMDS_MeshNode*>( aNodeIter->next() );
- if ( aNode )
- aNodeMap.insert( aNode->GetID() );
- }
- }
- }
- }
+ aResGrp = CreateGroup( theElemType, theName );
+ if ( aResGrp->_is_nil() )
+ return SMESH::SMESH_Group::_nil();
- // Get result identifiers
+ SMESHDS_GroupBase* groupBaseDS =
+ SMESH::DownCast<SMESH_GroupBase_i*>( aResGrp )->GetGroupDS();
+ SMDS_MeshGroup& resGroupCore = static_cast< SMESHDS_Group* >( groupBaseDS )->SMDSGroup();
- vector< int > aResultIds;
- if ( theElemType == SMESH::NODE )
+ for ( int g = 0, n = theGroups.length(); g < n; g++ ) // loop on theGroups
+ {
+ SMESH::SMESH_GroupBase_var aGrp = theGroups[ g ];
+ if ( CORBA::is_nil( aGrp ) )
+ continue;
+
+ groupBaseDS = SMESH::DownCast<SMESH_GroupBase_i*>( aGrp )->GetGroupDS();
+ SMDS_ElemIteratorPtr elIt = groupBaseDS->GetElements();
+
+ if ( theElemType == SMESH::NODE ) // get all nodes of elements
{
- //NCollection_Map< int >::Iterator aNodeIter( aNodeMap );
- set<int>::iterator iter = aNodeMap.begin();
- for ( ; iter != aNodeMap.end(); iter++ )
- aResultIds.push_back( *iter);
+ while ( elIt->more() ) {
+ const SMDS_MeshElement* el = elIt->next();
+ SMDS_ElemIteratorPtr nIt = el->nodesIterator();
+ while ( nIt->more() )
+ resGroupCore.Add( nIt->next() );
+ }
}
- else
+ else // get elements of theElemType based on nodes of every element of group
{
- // Create list of elements of given dimension constructed on the nodes
- vector< int > anElemList;
- //NCollection_Map< int >::Iterator aNodeIter( aNodeMap );
- //for ( ; aNodeIter.More(); aNodeIter.Next() )
- set<int>::iterator iter = aNodeMap.begin();
- for ( ; iter != aNodeMap.end(); iter++ )
- {
- const SMDS_MeshElement* aNode =
- dynamic_cast<const SMDS_MeshElement*>( aMeshDS->FindNode( *iter ) );
- if ( !aNode )
- continue;
-
- SMDS_ElemIteratorPtr anElemIter = aNode->elementsIterator( anElemType );
- while( anElemIter->more() )
- {
- const SMDS_MeshElement* anElem =
- dynamic_cast<const SMDS_MeshElement*>( anElemIter->next() );
- if ( anElem && anElem->GetType() == anElemType )
- anElemList.push_back( anElem->GetID() );
- }
- }
-
- // check whether all nodes of elements are present in nodes map
- for (int i=0; i< anElemList.size(); i++)
+ while ( elIt->more() )
{
- const SMDS_MeshElement* anElem = aMeshDS->FindElement( anElemList[i] );
- if ( !anElem )
- continue;
-
- bool isOk = true;
- SMDS_ElemIteratorPtr aNodeIter = anElem->nodesIterator();
- while( aNodeIter->more() )
+ const SMDS_MeshElement* el = elIt->next(); // an element of group
+ TIDSortedElemSet elNodes( el->begin_nodes(), el->end_nodes() );
+ TIDSortedElemSet checkedElems;
+ SMDS_ElemIteratorPtr nIt = el->nodesIterator();
+ while ( nIt->more() )
{
- const SMDS_MeshNode* aNode =
- dynamic_cast<const SMDS_MeshNode*>( aNodeIter->next() );
- if ( !aNode || !aNodeMap.count( aNode->GetID() ) )
+ const SMDS_MeshNode* n = static_cast<const SMDS_MeshNode*>( nIt->next() );
+ SMDS_ElemIteratorPtr elOfTypeIt = n->GetInverseElementIterator( anElemType );
+ // check nodes of elements of theElemType around el
+ while ( elOfTypeIt->more() )
{
- isOk = false;
- break;
+ const SMDS_MeshElement* elOfType = elOfTypeIt->next();
+ if ( !checkedElems.insert( elOfType ).second ) continue;
+
+ SMDS_ElemIteratorPtr nIt2 = elOfType->nodesIterator();
+ bool allNodesOK = true;
+ while ( nIt2->more() && allNodesOK )
+ allNodesOK = elNodes.count( nIt2->next() );
+ if ( allNodesOK )
+ resGroupCore.Add( elOfType );
}
- }
- if ( isOk )
- aResultIds.push_back( anElem->GetID() );
+ }
}
}
+ }
- // Create group
-
- SMESH::SMESH_Group_var aResGrp = CreateGroup( theElemType, theName );
- if ( aResGrp->_is_nil() )
- return SMESH::SMESH_Group::_nil();
-
- // Create array of identifiers
- SMESH::long_array_var aResIds = new SMESH::long_array;
- aResIds->length( aResultIds.size() );
-
- for (int i=0; i< aResultIds.size(); i++)
- aResIds[ i ] = aResultIds[i];
- aResGrp->Add( aResIds );
-
- // Remove strings corresponding to group creation
- SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
- _gen_i->RemoveLastFromPythonScript( aStudy->StudyId() );
- _gen_i->RemoveLastFromPythonScript( aStudy->StudyId() );
+ // Update Python script
+ pyDump << aResGrp << " = " << _this() << ".CreateDimGroup( "
+ << &theGroups << ", " << theElemType << ", '" << theName << "' )";
- // Update Python script
-
- TPythonDump() << aResGrp << " = " << _this() << ".CreateDimGroup( "
- << &theGroups << ", " << theElemType << ", '" << theName << "' )";
+ SMESH_CATCH( SMESH::throwCorbaException );
- return aResGrp._retn();
- }
- catch( ... )
- {
- return SMESH::SMESH_Group::_nil();
- }
+ return aResGrp._retn();
}
//================================================================================
if ( CORBA::is_nil( theGeomObj ) || theGeomObj->GetType() != GEOM_GROUP )
return;
// group SO
- SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
- SALOMEDS::SObject_var groupSO = _gen_i->ObjectToSObject( study, theGeomObj );
+ SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
+ SALOMEDS::SObject_wrap groupSO = _gen_i->ObjectToSObject( study, theGeomObj );
if ( groupSO->_is_nil() )
return;
// group indices
GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine();
- GEOM::GEOM_IGroupOperations_var groupOp =
+ GEOM::GEOM_IGroupOperations_wrap groupOp =
geomGen->GetIGroupOperations( _gen_i->GetCurrentStudyID() );
GEOM::ListOfLong_var ids = groupOp->GetObjects( theGeomObj );
// get geom group
SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
if ( study->_is_nil() ) return newShape; // means "not changed"
- SALOMEDS::SObject_var groupSO = study->FindObjectID( groupData._groupEntry.c_str() );
+ SALOMEDS::SObject_wrap groupSO = study->FindObjectID( groupData._groupEntry.c_str() );
if ( !groupSO->_is_nil() )
{
CORBA::Object_var groupObj = _gen_i->SObjectToObject( groupSO );
// get indices of group items
set<int> curIndices;
GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine();
- GEOM::GEOM_IGroupOperations_var groupOp =
+ GEOM::GEOM_IGroupOperations_wrap groupOp =
geomGen->GetIGroupOperations( _gen_i->GetCurrentStudyID() );
- GEOM::ListOfLong_var ids = groupOp->GetObjects( geomGroup );
+ GEOM::ListOfLong_var ids = groupOp->GetObjects( geomGroup );
for ( int i = 0; i < ids->length(); ++i )
curIndices.insert( ids[i] );
TCollection_AsciiString groupIOR = geomGen->GetStringFromIOR( geomGroup );
geomClient->RemoveShapeFromBuffer( groupIOR );
newShape = _gen_i->GeomObjectToShape( geomGroup );
- }
+ }
if ( newShape.IsNull() ) {
// geom group becomes empty - return empty compound
list<const SMESHDS_Hypothesis*>& hyps = indS_hyps->second;
int oldID = geom._index;
int newID = meshDS->ShapeToIndex( geom._shape );
- if ( !newID )
- continue;
if ( oldID == 1 ) { // main shape
newID = 1;
geom._shape = newShape;
}
+ if ( !newID )
+ continue;
for ( hypIt = hyps.begin(); hypIt != hyps.end(); ++hypIt )
_impl->AddHypothesis( geom._shape, (*hypIt)->GetID());
// care of submeshes
if ( _mapGroups.find( oldID ) == _mapGroups.end() )
continue;
// get group name
- SALOMEDS::SObject_var groupSO = _gen_i->ObjectToSObject( study,_mapGroups[oldID] );
- CORBA::String_var name = groupSO->GetName();
+ SALOMEDS::SObject_wrap groupSO = _gen_i->ObjectToSObject( study,_mapGroups[oldID] );
+ CORBA::String_var name = groupSO->GetName();
// update
- SMESH_GroupBase_i* group_i = SMESH::DownCast<SMESH_GroupBase_i*>(_mapGroups[oldID] );
+ SMESH_GroupBase_i* group_i = SMESH::DownCast<SMESH_GroupBase_i*>(_mapGroups[oldID] );
int newID;
if ( group_i && _impl->AddGroup( geomType->second, name.in(), newID, geom._shape ))
group_i->changeLocalId( newID );
// Update icons
CORBA::Long newNbEntities = NbNodes() + NbElements();
- list< SALOMEDS::SObject_var > soToUpdateIcons;
+ list< SALOMEDS::SObject_wrap > soToUpdateIcons;
if ( newNbEntities != nbEntities )
{
// Add all SObjects with icons to soToUpdateIcons
soToUpdateIcons.push_back( _gen_i->ObjectToSObject( study, i_gr->second ));
}
- list< SALOMEDS::SObject_var >::iterator so = soToUpdateIcons.begin();
+ list< SALOMEDS::SObject_wrap >::iterator so = soToUpdateIcons.begin();
for ( ; so != soToUpdateIcons.end(); ++so )
_gen_i->SetPixMap( *so, "ICON_SMESH_TREE_MESH_WARN" );
}
//=============================================================================
SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroup )
+ throw (SALOME::SALOME_Exception)
{
+ SMESH::SMESH_Group_var aGroup;
+
+ SMESH_TRY;
+
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESH::SMESH_Group_var aGroup;
if ( theGroup->_is_nil() )
return aGroup._retn();
- Unexpect aCatch(SALOME_SalomeException);
-
SMESH_GroupBase_i* aGroupToRem =
dynamic_cast<SMESH_GroupBase_i*>( SMESH_Gen_i::GetServant( theGroup ).in() );
if ( !aGroupToRem )
_mapGroups.erase( anId );
SALOMEDS::StudyBuilder_var builder;
- SALOMEDS::SObject_var aGroupSO;
- SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
- if ( !aStudy->_is_nil() ) {
- builder = aStudy->NewBuilder();
+ SALOMEDS::SObject_wrap aGroupSO;
+ SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
+ if ( !aStudy->_is_nil() ) {
+ builder = aStudy->NewBuilder();
aGroupSO = _gen_i->ObjectToSObject( aStudy, theGroup );
- if ( !aGroupSO->_is_nil() ) {
-
+ if ( !aGroupSO->_is_nil() )
+ {
// remove reference to geometry
- SALOMEDS::ChildIterator_var chItr = aStudy->NewChildIterator(aGroupSO);
+ SALOMEDS::ChildIterator_wrap chItr = aStudy->NewChildIterator(aGroupSO);
for ( ; chItr->More(); chItr->Next() )
// Remove group's child SObject
builder->RemoveObject( chItr->Value() );
const int isEmpty = ( elemTypes->length() == 0 );
if ( !isEmpty )
{
- SALOMEDS::GenericAttribute_var anAttr =
+ SALOMEDS::GenericAttribute_wrap anAttr =
builder->FindOrCreateAttribute( aGroupSO, "AttributePixMap" );
- SALOMEDS::AttributePixMap_var pm = SALOMEDS::AttributePixMap::_narrow( anAttr );
+ SALOMEDS::AttributePixMap_wrap pm = anAttr;
pm->SetPixMap( "ICON_SMESH_TREE_GROUP" );
}
}
}
}
- // PAL7962: san -- To ensure correct mapping of servant and correct reference counting in GenericObj_i
- SMESH_Gen_i::GetPOA()->activate_object( aGroupImpl );
- aGroupImpl->Register();
- // PAL7962: san -- To ensure correct mapping of servant and correct reference counting in GenericObj_i
-
// remember new group in own map
aGroup = SMESH::SMESH_Group::_narrow( aGroupImpl->_this() );
_mapGroups[anId] = SMESH::SMESH_GroupBase::_duplicate( aGroup );
// register CORBA object for persistence
- /*int nextId =*/ _gen_i->RegisterObject( aGroup );
+ _gen_i->RegisterObject( aGroup );
+
+ CORBA::String_var ior = _gen_i->GetORB()->object_to_string( aGroup );
+ builder->SetIOR( aGroupSO, ior.in() );
- builder->SetIOR( aGroupSO, _gen_i->GetORB()->object_to_string( aGroup ) );
+ SMESH_CATCH( SMESH::throwCorbaException );
return aGroup._retn();
}
// register CORBA object for persistence
int nextId = _gen_i->RegisterObject( subMesh );
- if(MYDEBUG) MESSAGE( "Add submesh to map with id = "<< nextId);
+ if(MYDEBUG) { MESSAGE( "Add submesh to map with id = "<< nextId); }
+ else { nextId = 0; } // avoid "unused variable" warning in release mode
// to track changes of GEOM groups
addGeomGroupData( theSubShapeObject, subMesh );
else
aGroupImpl = new SMESH_Group_i( SMESH_Gen_i::GetPOA(), this, anId );
- // PAL7962: san -- To ensure correct mapping of servant and correct reference counting in GenericObj_i
- SMESH_Gen_i::GetPOA()->activate_object( aGroupImpl );
- aGroupImpl->Register();
- // PAL7962: san -- To ensure correct mapping of servant and correct reference counting in GenericObj_i
-
aGroup = SMESH::SMESH_GroupBase::_narrow( aGroupImpl->_this() );
_mapGroups[anId] = SMESH::SMESH_GroupBase::_duplicate( aGroup );
// register CORBA object for persistence
int nextId = _gen_i->RegisterObject( aGroup );
- if(MYDEBUG) MESSAGE( "Add group to map with id = "<< nextId);
+ if(MYDEBUG) { MESSAGE( "Add group to map with id = "<< nextId); }
+ else { nextId = 0; } // avoid "unused variable" warning in release mode
// to track changes of GEOM groups
if ( !theShape.IsNull() ) {
//=============================================================================
SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet)
-throw(SALOME::SALOME_Exception)
+ throw(SALOME::SALOME_Exception)
{
+ SMESH::log_array_var aLog;
+
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESH::log_array_var aLog;
- try{
- list < SMESHDS_Command * >logDS = _impl->GetLog();
- aLog = new SMESH::log_array;
- int indexLog = 0;
- int lg = logDS.size();
- SCRUTE(lg);
- aLog->length(lg);
- list < SMESHDS_Command * >::iterator its = logDS.begin();
- while(its != logDS.end()){
- SMESHDS_Command *com = *its;
- int comType = com->GetType();
- //SCRUTE(comType);
- int lgcom = com->GetNumber();
- //SCRUTE(lgcom);
- const list < int >&intList = com->GetIndexes();
- int inum = intList.size();
- //SCRUTE(inum);
- list < int >::const_iterator ii = intList.begin();
- const list < double >&coordList = com->GetCoords();
- int rnum = coordList.size();
- //SCRUTE(rnum);
- list < double >::const_iterator ir = coordList.begin();
- aLog[indexLog].commandType = comType;
- aLog[indexLog].number = lgcom;
- aLog[indexLog].coords.length(rnum);
- aLog[indexLog].indexes.length(inum);
- for(int i = 0; i < rnum; i++){
- aLog[indexLog].coords[i] = *ir;
- //MESSAGE(" "<<i<<" "<<ir.Value());
- ir++;
- }
- for(int i = 0; i < inum; i++){
- aLog[indexLog].indexes[i] = *ii;
- //MESSAGE(" "<<i<<" "<<ii.Value());
- ii++;
- }
- indexLog++;
- its++;
+ list < SMESHDS_Command * >logDS = _impl->GetLog();
+ aLog = new SMESH::log_array;
+ int indexLog = 0;
+ int lg = logDS.size();
+ SCRUTE(lg);
+ aLog->length(lg);
+ list < SMESHDS_Command * >::iterator its = logDS.begin();
+ while(its != logDS.end()){
+ SMESHDS_Command *com = *its;
+ int comType = com->GetType();
+ //SCRUTE(comType);
+ int lgcom = com->GetNumber();
+ //SCRUTE(lgcom);
+ const list < int >&intList = com->GetIndexes();
+ int inum = intList.size();
+ //SCRUTE(inum);
+ list < int >::const_iterator ii = intList.begin();
+ const list < double >&coordList = com->GetCoords();
+ int rnum = coordList.size();
+ //SCRUTE(rnum);
+ list < double >::const_iterator ir = coordList.begin();
+ aLog[indexLog].commandType = comType;
+ aLog[indexLog].number = lgcom;
+ aLog[indexLog].coords.length(rnum);
+ aLog[indexLog].indexes.length(inum);
+ for(int i = 0; i < rnum; i++){
+ aLog[indexLog].coords[i] = *ir;
+ //MESSAGE(" "<<i<<" "<<ir.Value());
+ ir++;
}
- if(clearAfterGet)
- _impl->ClearLog();
- }
- catch(SALOME_Exception & S_ex){
- THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
+ for(int i = 0; i < inum; i++){
+ aLog[indexLog].indexes[i] = *ii;
+ //MESSAGE(" "<<i<<" "<<ii.Value());
+ ii++;
+ }
+ indexLog++;
+ its++;
}
+ if(clearAfterGet)
+ _impl->ClearLog();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+
return aLog._retn();
}
void SMESH_Mesh_i::ClearLog() throw(SALOME::SALOME_Exception)
{
- if(MYDEBUG) MESSAGE("SMESH_Mesh_i::ClearLog");
+ SMESH_TRY;
_impl->ClearLog();
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=============================================================================
CORBA::Long SMESH_Mesh_i::GetId()throw(SALOME::SALOME_Exception)
{
- if(MYDEBUG) MESSAGE("SMESH_Mesh_i::GetId");
return _id;
}
//=============================================================================
SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor()
+ throw (SALOME::SALOME_Exception)
{
+ SMESH::SMESH_MeshEditor_var aMeshEdVar;
+
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
// Create MeshEditor
SMESH_MeshEditor_i *aMeshEditor = new SMESH_MeshEditor_i( this, false );
- SMESH::SMESH_MeshEditor_var aMesh = aMeshEditor->_this();
+ aMeshEdVar = aMeshEditor->_this();
// Update Python script
TPythonDump() << aMeshEditor << " = " << _this() << ".GetMeshEditor()";
- return aMesh._retn();
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ return aMeshEdVar._retn();
}
//=============================================================================
//=============================================================================
SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditPreviewer()
+ throw (SALOME::SALOME_Exception)
{
+ SMESH::SMESH_MeshEditor_var aMeshEdVar;
+
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
SMESH_MeshEditor_i *aMeshEditor = new SMESH_MeshEditor_i( this, true );
- SMESH::SMESH_MeshEditor_var aMesh = aMeshEditor->_this();
- return aMesh._retn();
+ aMeshEdVar = aMeshEditor->_this();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ return aMeshEdVar._retn();
}
//================================================================================
// Perform Export
PrepareForWriting(file, overwrite);
string aMeshName = "Mesh";
- SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
+ SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
if ( !aStudy->_is_nil() ) {
- SALOMEDS::SObject_var aMeshSO = _gen_i->ObjectToSObject( aStudy, _this() );
+ SALOMEDS::SObject_wrap aMeshSO = _gen_i->ObjectToSObject( aStudy, _this() );
if ( !aMeshSO->_is_nil() ) {
CORBA::String_var name = aMeshSO->GetName();
aMeshName = name;
// asv : 27.10.04 : fix of 6903: check for StudyLocked before adding attributes
if ( !aStudy->GetProperties()->IsLocked() )
{
- SALOMEDS::GenericAttribute_var anAttr;
+ SALOMEDS::GenericAttribute_wrap anAttr;
SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
- SALOMEDS::AttributeExternalFileDef_var aFileName;
anAttr=aStudyBuilder->FindOrCreateAttribute(aMeshSO, "AttributeExternalFileDef");
- aFileName = SALOMEDS::AttributeExternalFileDef::_narrow(anAttr);
+ SALOMEDS::AttributeExternalFileDef_wrap aFileName = anAttr;
ASSERT(!aFileName->_is_nil());
aFileName->SetValue(file);
- SALOMEDS::AttributeFileType_var aFileType;
anAttr=aStudyBuilder->FindOrCreateAttribute(aMeshSO, "AttributeFileType");
- aFileType = SALOMEDS::AttributeFileType::_narrow(anAttr);
+ SALOMEDS::AttributeFileType_wrap aFileType = anAttr;
ASSERT(!aFileType->_is_nil());
aFileType->SetValue("FICHIERMED");
}
void SMESH_Mesh_i::ExportToMEDX (const char* file,
CORBA::Boolean auto_groups,
SMESH::MED_VERSION theVersion,
- CORBA::Boolean overwrite)
+ CORBA::Boolean overwrite,
+ CORBA::Boolean autoDimension)
throw(SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
string aMeshName = prepareMeshNameAndGroups(file, overwrite);
TPythonDump() << _this() << ".ExportToMEDX( r'"
- << file << "', " << auto_groups << ", " << theVersion << ", " << overwrite << " )";
+ << file << "', " << auto_groups << ", "
+ << theVersion << ", " << overwrite << ", "
+ << autoDimension << " )";
- _impl->ExportMED( file, aMeshName.c_str(), auto_groups, theVersion );
+ _impl->ExportMED( file, aMeshName.c_str(), auto_groups, theVersion, 0, autoDimension );
}
//================================================================================
_impl->ExportSTL(file, isascii);
}
-//=============================================================================
-/*!
- * \brief Class providing SMESHDS_Mesh API to SMESH_IDSource.
- * It is used to export a part of mesh as a whole mesh.
- */
-class SMESH_MeshPartDS : public SMESHDS_Mesh
-{
-public:
- SMESH_MeshPartDS(SMESH::SMESH_IDSource_ptr meshPart);
-
- virtual SMDS_NodeIteratorPtr nodesIterator (bool idInceasingOrder=false) const;
- virtual SMDS_EdgeIteratorPtr edgesIterator (bool idInceasingOrder=false) const;
- virtual SMDS_FaceIteratorPtr facesIterator (bool idInceasingOrder=false) const;
- virtual SMDS_VolumeIteratorPtr volumesIterator (bool idInceasingOrder=false) const;
-
- virtual SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type=SMDSAbs_All) const;
- virtual SMDS_ElemIteratorPtr elementGeomIterator(SMDSAbs_GeometryType type) const;
- virtual SMDS_ElemIteratorPtr elementEntityIterator(SMDSAbs_EntityType type) const;
-
-private:
- TIDSortedElemSet _elements[ SMDSAbs_NbElementTypes ];
- SMESHDS_Mesh* _meshDS;
- /*!
- * \brief Class used to access to protected data of SMDS_MeshInfo
- */
- struct TMeshInfo : public SMDS_MeshInfo
- {
- void Add(const SMDS_MeshElement* e) { SMDS_MeshInfo::addWithPoly( e ); }
- };
-};
-
//================================================================================
/*!
* \brief Export a part of mesh to a med file
const char* file,
CORBA::Boolean auto_groups,
::SMESH::MED_VERSION version,
- ::CORBA::Boolean overwrite)
+ ::CORBA::Boolean overwrite,
+ ::CORBA::Boolean autoDimension)
throw (SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
- if ( _preMeshInfo )
- _preMeshInfo->FullLoadFromFile();
+ TPythonDump pyDump;
- PrepareForWriting(file, overwrite);
+ if ( SMESH_Mesh_i * mesh = SMESH::DownCast< SMESH_Mesh_i* >( meshPart ))
+ {
+ mesh->ExportToMEDX( file, auto_groups, version, autoDimension );
+ }
+ else
+ {
+ if ( _preMeshInfo )
+ _preMeshInfo->FullLoadFromFile();
- string aMeshName = "Mesh";
- SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
- if ( !aStudy->_is_nil() ) {
- SALOMEDS::SObject_var SO = _gen_i->ObjectToSObject( aStudy, meshPart );
- if ( !SO->_is_nil() ) {
- CORBA::String_var name = SO->GetName();
- aMeshName = name;
+ 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 );
+ if ( !SO->_is_nil() ) {
+ CORBA::String_var name = SO->GetName();
+ aMeshName = name;
+ }
}
+ SMESH_MeshPartDS partDS( meshPart );
+ _impl->ExportMED( file, aMeshName.c_str(), auto_groups, version, &partDS, autoDimension );
}
- SMESH_MeshPartDS partDS( meshPart );
- _impl->ExportMED( file, aMeshName.c_str(), auto_groups, version, &partDS );
-
- TPythonDump() << _this() << ".ExportPartToMED( " << meshPart << ", r'" << file << "', "
- << auto_groups << ", " << version << ", " << overwrite << " )";
+ pyDump << _this() << ".ExportPartToMED( " << meshPart << ", r'" << file << "', "
+ << auto_groups << ", " << version << ", " << overwrite << ", "
+ << autoDimension << " )";
}
//================================================================================
#endif
}
-//=============================================================================
+//================================================================================
/*!
- * Return implementation of SALOME_MED::MESH interfaces
+ * \brief Export a part of mesh to a GMF file
*/
-//=============================================================================
+//================================================================================
-SALOME_MED::MESH_ptr SMESH_Mesh_i::GetMEDMesh()throw(SALOME::SALOME_Exception)
+void SMESH_Mesh_i::ExportGMF(::SMESH::SMESH_IDSource_ptr meshPart,
+ const char* file,
+ bool withRequiredGroups)
+ throw (SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESH_MEDMesh_i *aMedMesh = new SMESH_MEDMesh_i(this);
- SALOME_MED::MESH_var aMesh = aMedMesh->_this();
- return aMesh._retn();
+ PrepareForWriting(file,/*overwrite=*/true);
+
+ SMESH_MeshPartDS partDS( meshPart );
+ _impl->ExportGMF(file, &partDS, withRequiredGroups);
+
+ TPythonDump() << _this() << ".ExportGMF( "
+ << meshPart<< ", r'"
+ << file << "', "
+ << withRequiredGroups << ")";
}
//=============================================================================
+/*!
+ * Return computation progress [0.,1]
+ */
+//=============================================================================
+
+CORBA::Double SMESH_Mesh_i::GetComputeProgress()
+{
+ SMESH_TRY;
+
+ return _impl->GetComputeProgress();
+
+ SMESH_CATCH( SMESH::doNothing );
+ return 0.;
+}
CORBA::Long SMESH_Mesh_i::NbNodes()throw(SALOME::SALOME_Exception)
{
return _impl->NbTriangles();
}
+CORBA::Long SMESH_Mesh_i::NbBiQuadTriangles()throw(SALOME::SALOME_Exception)
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ if ( _preMeshInfo )
+ return _preMeshInfo->NbBiQuadTriangles();
+
+ return _impl->NbBiQuadTriangles();
+}
+
CORBA::Long SMESH_Mesh_i::NbQuadrangles()throw(SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const bool iselem )
throw (SALOME::SALOME_Exception)
{
+ SMESH::ElementType type;
+ SMESH_TRY;
+
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- return ( SMESH::ElementType )_impl->GetElementType( id, iselem );
+ type = ( SMESH::ElementType ) _impl->GetElementType( id, iselem );
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ return type;
}
//=============================================================================
SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID)
throw (SALOME::SALOME_Exception)
{
+ SMESH::long_array_var aResult = new SMESH::long_array();
+
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESH::long_array_var aResult = new SMESH::long_array();
-
SMESH_subMesh* SM = _impl->GetSubMeshContaining(ShapeID);
if(!SM) return aResult._retn();
aResult[i++] = eIt->next()->GetID();
}
+ SMESH_CATCH( SMESH::throwCorbaException );
+
return aResult._retn();
}
CORBA::Boolean all)
throw (SALOME::SALOME_Exception)
{
+ SMESH::long_array_var aResult = new SMESH::long_array();
+
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESH::long_array_var aResult = new SMESH::long_array();
-
SMESH_subMesh* SM = _impl->GetSubMeshContaining(ShapeID);
if(!SM) return aResult._retn();
for ( itElem = theElems.begin(); itElem != theElems.end(); itElem++ )
aResult[i++] = *itElem;
+ SMESH_CATCH( SMESH::throwCorbaException );
+
return aResult._retn();
}
SMESH::ElementType SMESH_Mesh_i::GetSubMeshElementType(const CORBA::Long ShapeID)
throw (SALOME::SALOME_Exception)
{
+ SMESH::ElementType type;
+
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
SMDS_ElemIteratorPtr eIt = SDSM->GetElements();
const SMDS_MeshElement* anElem = eIt->next();
- return ( SMESH::ElementType ) anElem->GetType();
+
+ type = ( SMESH::ElementType ) anElem->GetType();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ return type;
}
return aNodePosition;
}
+//=============================================================================
+/*!
+ * \brief Return position of an element on shape
+ */
+//=============================================================================
+
+SMESH::ElementPosition SMESH_Mesh_i::GetElementPosition(CORBA::Long ElemID)
+{
+ if ( _preMeshInfo )
+ _preMeshInfo->FullLoadFromFile();
+
+ SMESH::ElementPosition anElementPosition;
+ anElementPosition.shapeID = 0;
+ anElementPosition.shapeType = GEOM::SHAPE;
+
+ SMESHDS_Mesh* mesh = _impl->GetMeshDS();
+ if ( !mesh ) return anElementPosition;
+
+ if ( const SMDS_MeshElement* anElem = mesh->FindElement( ElemID ) )
+ {
+ anElementPosition.shapeID = anElem->getshapeId();
+ const TopoDS_Shape& aSp = mesh->IndexToShape( anElem->getshapeId() );
+ if ( !aSp.IsNull() ) {
+ switch ( aSp.ShapeType() ) {
+ case TopAbs_EDGE:
+ anElementPosition.shapeType = GEOM::EDGE;
+ break;
+ case TopAbs_FACE:
+ anElementPosition.shapeType = GEOM::FACE;
+ break;
+ case TopAbs_VERTEX:
+ anElementPosition.shapeType = GEOM::VERTEX;
+ break;
+ case TopAbs_SOLID:
+ anElementPosition.shapeType = GEOM::SOLID;
+ break;
+ case TopAbs_SHELL:
+ anElementPosition.shapeType = GEOM::SHELL;
+ break;
+ default:;
+ }
+ }
+ }
+ return anElementPosition;
+}
+
//=============================================================================
/*!
* If given element is node returns IDs of shape from position
if(!elem)
return -1;
- //SMESH::SMESH_MeshEditor_var aMeshEditor = SMESH_Mesh_i::GetMeshEditor();
::SMESH_MeshEditor aMeshEditor(_impl);
int index = aMeshEditor.FindShape( elem );
if(index>0)
if ( !( nn[i] = mesh->FindNode( nodes[i] )))
return elemID;
- const SMDS_MeshElement* elem = mesh->FindElement( nn );
+ const SMDS_MeshElement* elem = mesh->FindElement( nn, SMDSAbs_All, /*noMedium=*/false );
if ( !elem && ( _impl->NbEdges ( ORDER_QUADRATIC ) ||
_impl->NbFaces ( ORDER_QUADRATIC ) ||
_impl->NbVolumes( ORDER_QUADRATIC )))
return aResult._retn();
}
+//================================================================================
+/*!
+ * \brief Create a group of elements preventing computation of a sub-shape
+ */
+//================================================================================
+
+SMESH::ListOfGroups*
+SMESH_Mesh_i::MakeGroupsOfBadInputElements( int theSubShapeID,
+ const char* theGroupName )
+ throw ( SALOME::SALOME_Exception )
+{
+ Unexpect aCatch(SALOME_SalomeException);
+
+ if ( !theGroupName || strlen( theGroupName) == 0 )
+ THROW_SALOME_CORBA_EXCEPTION( "empty group name",SALOME::BAD_PARAM );
+
+ SMESH::ListOfGroups_var groups = new SMESH::ListOfGroups;
+
+ // submesh by subshape id
+ if ( !_impl->HasShapeToMesh() ) theSubShapeID = 1;
+ if ( SMESH_subMesh * sm = _impl->GetSubMeshContaining( theSubShapeID ))
+ {
+ // compute error
+ SMESH_ComputeErrorPtr error = sm->GetComputeError();
+ if ( error && !error->myBadElements.empty())
+ {
+ // sort bad elements by type
+ vector< const SMDS_MeshElement* > elemsByType[ SMDSAbs_NbElementTypes ];
+ list<const SMDS_MeshElement*>::iterator elemIt = error->myBadElements.begin();
+ list<const SMDS_MeshElement*>::iterator elemEnd = error->myBadElements.end();
+ for ( ; elemIt != elemEnd; ++elemIt )
+ {
+ const SMDS_MeshElement* elem = *elemIt;
+ if ( !elem ) continue;
+
+ if ( elem->GetID() < 1 )
+ {
+ // elem is a temporary element, make a real element
+ vector< const SMDS_MeshNode* > nodes;
+ SMDS_NodeIteratorPtr nIt = elem->nodeIterator();
+ while ( nIt->more() && elem )
+ {
+ nodes.push_back( nIt->next() );
+ if ( nodes.back()->GetID() < 1 )
+ elem = 0; // a temporary element on temporary nodes
+ }
+ if ( elem )
+ {
+ ::SMESH_MeshEditor editor( _impl );
+ elem = editor.AddElement( nodes, elem->GetType(), elem->IsPoly() );
+ }
+ }
+ if ( elem )
+ elemsByType[ elem->GetType() ].push_back( elem );
+ }
+
+ // how many groups to create?
+ int nbTypes = 0;
+ for ( int i = 0; i < SMDSAbs_NbElementTypes; ++i )
+ nbTypes += int( !elemsByType[ i ].empty() );
+ groups->length( nbTypes );
+
+ // create groups
+ for ( int i = 0, iG = -1; i < SMDSAbs_NbElementTypes; ++i )
+ {
+ vector< const SMDS_MeshElement* >& elems = elemsByType[ i ];
+ if ( elems.empty() ) continue;
+
+ groups[ ++iG ] = createGroup( SMESH::ElementType(i), theGroupName );
+ if ( _gen_i->CanPublishInStudy( groups[ iG ] ))
+ {
+ SALOMEDS::SObject_wrap aSO =
+ _gen_i->PublishGroup(_gen_i->GetCurrentStudy(), _this(), 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;
+
+ if ( SMESHDS_Group* grpDS = dynamic_cast< SMESHDS_Group* >( grp_i->GetGroupDS() ))
+ for ( size_t iE = 0; iE < elems.size(); ++iE )
+ grpDS->SMDSGroup().Add( elems[ iE ]);
+ }
+ }
+ }
+
+ return groups._retn();
+}
//=============================================================================
/*!
*/
//=============================================================================
-void SMESH_Mesh_i::CreateGroupServants()
+void SMESH_Mesh_i::CreateGroupServants()
{
- SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
+ SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
set<int> addedIDs;
::SMESH_Mesh::GroupIteratorPtr groupIt = _impl->GetGroups();
aGroupImpl = new SMESH_Group_i( SMESH_Gen_i::GetPOA(), this, anId );
}
- // To ensure correct mapping of servant and correct reference counting in GenericObj_i
- SMESH_Gen_i::GetPOA()->activate_object( aGroupImpl );
- aGroupImpl->Register();
-
SMESH::SMESH_GroupBase_var groupVar =
SMESH::SMESH_GroupBase::_narrow( aGroupImpl->_this() );
_mapGroups[anId] = SMESH::SMESH_GroupBase::_duplicate( groupVar );
// register CORBA object for persistence
int nextId = _gen_i->RegisterObject( groupVar );
- if(MYDEBUG) MESSAGE( "Add group to map with id = "<< nextId);
+ if(MYDEBUG) { MESSAGE( "Add group to map with id = "<< nextId); }
+ else { nextId = 0; } // avoid "unused variable" warning in release mode
// publishing the groups in the study
if ( !aStudy->_is_nil() ) {
*/
//=============================================================================
-SALOME_MED::MedFileInfo* SMESH_Mesh_i::GetMEDFileInfo()
+SMESH::MedFileInfo* SMESH_Mesh_i::GetMEDFileInfo()
{
- SALOME_MED::MedFileInfo_var res( _medFileInfo );
+ SMESH::MedFileInfo_var res( _medFileInfo );
if ( !res.operator->() ) {
- res = new SALOME_MED::MedFileInfo;
+ res = new SMESH::MedFileInfo;
res->fileName = "";
res->fileSize = res->major = res->minor = res->release = -1;
}
if ( !nbGrp )
return;
- SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
+ SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
if ( aStudy->_is_nil() )
return; // nothing to do
SMESH::SMESH_GroupBase_ptr aGrp = (*grpList)[ gIndx ];
if ( !aGrp )
continue;
- SALOMEDS::SObject_var aGrpSO = _gen_i->ObjectToSObject( aStudy, aGrp );
+ SALOMEDS::SObject_wrap aGrpSO = _gen_i->ObjectToSObject( aStudy, aGrp );
if ( aGrpSO->_is_nil() )
continue;
// correct name of the mesh group if necessary
//=============================================================================
void SMESH_Mesh_i::SetParameters(const char* theParameters)
{
- // SMESH_Gen_i::GetSMESHGen()->UpdateParameters(SMESH::SMESH_Mesh::_narrow(_this()),
- // CORBA::string_dup(theParameters));
- SMESH_Gen_i::GetSMESHGen()->UpdateParameters(theParameters);
+ SMESH_Gen_i::GetSMESHGen()->UpdateParameters( CORBA::Object_var( _this() ).in(),
+ theParameters );
}
//=============================================================================
SMESH_Gen_i *gen = SMESH_Gen_i::GetSMESHGen();
if(gen) {
char *aParameters = GetParameters();
- SALOMEDS::Study_ptr aStudy = gen->GetCurrentStudy();
+ SALOMEDS::Study_var aStudy = gen->GetCurrentStudy();
if(!aStudy->_is_nil()) {
SALOMEDS::ListOfListOfStrings_var aSections = aStudy->ParseVariables(aParameters);
if(aSections->length() > 0) {
//=============================================================================
/*!
- * \brief Returns statistic of mesh elements
+ * \brief Returns number of mesh elements per each \a EntityType
*/
//=============================================================================
//=============================================================================
/*!
- * \brief Collect statistic of mesh elements given by iterator
+ * \brief Returns number of mesh elements per each \a ElementType
+ */
+//=============================================================================
+
+SMESH::long_array* SMESH_Mesh_i::GetNbElementsByType()
+{
+ SMESH::long_array_var aRes = new SMESH::long_array();
+ aRes->length(SMESH::NB_ELEMENT_TYPES);
+ for (int i = 0; i < SMESH::NB_ELEMENT_TYPES; i++)
+ aRes[ i ] = 0;
+
+ const SMDS_MeshInfo* meshInfo = 0;
+ if ( _preMeshInfo )
+ meshInfo = _preMeshInfo;
+ else if ( SMESHDS_Mesh* meshDS = _impl->GetMeshDS() )
+ meshInfo = & meshDS->GetMeshInfo();
+
+ if (meshInfo)
+ for (int i = 0; i < SMESH::NB_ELEMENT_TYPES; i++)
+ aRes[i] = meshInfo->NbElements((SMDSAbs_ElementType)i);
+
+ return aRes._retn();
+}
+
+//=============================================================================
+/*
+ * Collect statistic of mesh elements given by iterator
*/
//=============================================================================
}
//=============================================================================
-/*!
- * \brief mapping of mesh dimension into shape type
+namespace /* Iterators used in SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_var obj,
+ * SMESH::ElementType type) */
+{
+ using namespace SMESH::Controls;
+ //-----------------------------------------------------------------------------
+ struct PredicateIterator : public SMDS_ElemIterator
+ {
+ SMDS_ElemIteratorPtr _elemIter;
+ PredicatePtr _predicate;
+ const SMDS_MeshElement* _elem;
+
+ PredicateIterator( SMDS_ElemIteratorPtr iterator,
+ PredicatePtr predicate):
+ _elemIter(iterator), _predicate(predicate)
+ {
+ next();
+ }
+ virtual bool more()
+ {
+ return _elem;
+ }
+ virtual const SMDS_MeshElement* next()
+ {
+ const SMDS_MeshElement* res = _elem;
+ _elem = 0;
+ while ( _elemIter->more() && !_elem )
+ {
+ _elem = _elemIter->next();
+ if ( _elem && ( !_predicate->IsSatisfy( _elem->GetID() )))
+ _elem = 0;
+ }
+ return res;
+ }
+ };
+
+ //-----------------------------------------------------------------------------
+ struct IDSourceIterator : public SMDS_ElemIterator
+ {
+ const CORBA::Long* _idPtr;
+ const CORBA::Long* _idEndPtr;
+ SMESH::long_array_var _idArray;
+ const SMDS_Mesh* _mesh;
+ const SMDSAbs_ElementType _type;
+ const SMDS_MeshElement* _elem;
+
+ IDSourceIterator( const SMDS_Mesh* mesh,
+ const CORBA::Long* ids,
+ const int nbIds,
+ SMDSAbs_ElementType type):
+ _idPtr( ids ), _idEndPtr( ids + nbIds ), _mesh( mesh ), _type( type ), _elem( 0 )
+ {
+ if ( _idPtr && nbIds && _mesh )
+ next();
+ }
+ IDSourceIterator( const SMDS_Mesh* mesh,
+ SMESH::long_array* idArray,
+ SMDSAbs_ElementType type):
+ _idPtr( 0 ), _idEndPtr( 0 ), _idArray( idArray), _mesh( mesh ), _type( type ), _elem( 0 )
+ {
+ if ( idArray && _mesh )
+ {
+ _idPtr = &_idArray[0];
+ _idEndPtr = _idPtr + _idArray->length();
+ next();
+ }
+ }
+ virtual bool more()
+ {
+ return _elem;
+ }
+ virtual const SMDS_MeshElement* next()
+ {
+ const SMDS_MeshElement* res = _elem;
+ _elem = 0;
+ while ( _idPtr < _idEndPtr && !_elem )
+ {
+ if ( _type == SMDSAbs_Node )
+ {
+ _elem = _mesh->FindNode( *_idPtr++ );
+ }
+ else if ((_elem = _mesh->FindElement( *_idPtr++ )) &&
+ _elem->GetType() != _type )
+ {
+ _elem = 0;
+ }
+ }
+ return res;
+ }
+ };
+ //-----------------------------------------------------------------------------
+
+ struct NodeOfElemIterator : public SMDS_ElemIterator
+ {
+ TColStd_MapOfInteger _checkedNodeIDs;
+ SMDS_ElemIteratorPtr _elemIter;
+ SMDS_ElemIteratorPtr _nodeIter;
+ const SMDS_MeshElement* _node;
+
+ NodeOfElemIterator( SMDS_ElemIteratorPtr iter ): _elemIter( iter ), _node( 0 )
+ {
+ if ( _elemIter && _elemIter->more() )
+ {
+ _nodeIter = _elemIter->next()->nodesIterator();
+ next();
+ }
+ }
+ virtual bool more()
+ {
+ return _node;
+ }
+ virtual const SMDS_MeshElement* next()
+ {
+ const SMDS_MeshElement* res = _node;
+ _node = 0;
+ while (( _elemIter->more() || _nodeIter->more() ) && !_node )
+ {
+ if ( _nodeIter->more() )
+ {
+ _node = _nodeIter->next();
+ if ( !_checkedNodeIDs.Add( _node->GetID() ))
+ _node = 0;
+ }
+ else
+ {
+ _nodeIter = _elemIter->next()->nodesIterator();
+ }
+ }
+ return res;
+ }
+ };
+}
+
+//=============================================================================
+/*
+ * Return iterator on elements of given type in given object
*/
//=============================================================================
-static TopAbs_ShapeEnum shapeTypeByDim(const int theDim)
+SMDS_ElemIteratorPtr SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_ptr theObject,
+ SMESH::ElementType theType)
+{
+ SMDS_ElemIteratorPtr elemIt;
+ bool typeOK = false;
+ SMDSAbs_ElementType elemType = SMDSAbs_ElementType( theType );
+
+ SMESH::SMESH_Mesh_var meshVar = theObject->GetMesh();
+ SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( meshVar );
+ if ( !mesh_i ) return elemIt;
+ SMESHDS_Mesh* meshDS = mesh_i->GetImpl().GetMeshDS();
+
+ if ( SMESH::DownCast<SMESH_Mesh_i*>( theObject ))
+ {
+ elemIt = meshDS->elementsIterator( elemType );
+ typeOK = true;
+ }
+ else if ( SMESH_subMesh_i* submesh_i = SMESH::DownCast<SMESH_subMesh_i*>( theObject ))
+ {
+ SMESHDS_SubMesh* sm = ((SMESHDS_Mesh*) meshDS)->MeshElements( submesh_i->GetId() );
+ if ( sm )
+ {
+ elemIt = sm->GetElements();
+ if ( elemType != SMDSAbs_Node )
+ {
+ 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 ))
+ {
+ elemIt = groupDS->GetElements();
+ typeOK = ( groupDS->GetType() == elemType );
+ }
+ }
+ else if ( SMESH::Filter_i* filter_i = SMESH::DownCast<SMESH::Filter_i*>( theObject ))
+ {
+ if ( filter_i->GetElementType() == theType || elemType == SMDSAbs_Node )
+ {
+ 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 );
+ }
+ }
+ }
+ else
+ {
+ SMESH::array_of_ElementType_var types = theObject->GetTypes();
+ const bool isNodes = ( types->length() == 1 && types[0] == SMESH::NODE );
+ if ( isNodes && elemType != SMDSAbs_Node )
+ return elemIt;
+ if ( SMESH_MeshEditor_i::IsTemporaryIDSource( theObject ))
+ {
+ int nbIds;
+ if ( CORBA::Long* ids = SMESH_MeshEditor_i::GetTemporaryIDs( theObject, nbIds ))
+ elemIt = SMDS_ElemIteratorPtr( new IDSourceIterator( meshDS, ids, nbIds, elemType ));
+ }
+ else
+ {
+ SMESH::long_array_var ids = theObject->GetIDs();
+ elemIt = SMDS_ElemIteratorPtr( new IDSourceIterator( meshDS, ids._retn(), elemType ));
+ }
+ typeOK = ( isNodes == ( elemType == SMDSAbs_Node ));
+ }
+
+ if ( elemIt && elemIt->more() && !typeOK )
+ {
+ if ( elemType == SMDSAbs_Node )
+ {
+ elemIt = SMDS_ElemIteratorPtr( new NodeOfElemIterator( elemIt ));
+ }
+ else
+ {
+ elemIt = SMDS_ElemIteratorPtr();
+ }
+ }
+ return elemIt;
+}
+
+//=============================================================================
+namespace // Finding concurrent hypotheses
+//=============================================================================
+{
+
+/*!
+ * \brief mapping of mesh dimension into shape type
+ */
+TopAbs_ShapeEnum shapeTypeByDim(const int theDim)
{
TopAbs_ShapeEnum aType = TopAbs_SOLID;
switch ( theDim ) {
return aType;
}
-//=============================================================================
+//-----------------------------------------------------------------------------
/*!
* \brief Internal structure used to find concurent submeshes
*
* with another submesh. In other words, it is dimension of a hypothesis assigned
* to submesh.
*/
-//=============================================================================
-
class SMESH_DimHyp
{
public:
int _ownDim; //!< dimension of shape of _subMesh (>=_dim)
TopTools_MapOfShape _shapeMap;
SMESH_subMesh* _subMesh;
- list<const SMESHDS_Hypothesis*> _hypothesises; //!< algo is first, then its parameters
+ list<const SMESHDS_Hypothesis*> _hypotheses; //!< algo is first, then its parameters
+ //-----------------------------------------------------------------------------
+ // Return the algorithm
+ const SMESH_Algo* GetAlgo() const
+ { return _hypotheses.empty() ? 0 : dynamic_cast<const SMESH_Algo*>( _hypotheses.front() ); }
+
+ //-----------------------------------------------------------------------------
//! Constructors
- SMESH_DimHyp(const SMESH_subMesh* theSubMesh,
- const int theDim,
- const TopoDS_Shape& theShape)
+ SMESH_DimHyp(const SMESH_subMesh* theSubMesh,
+ const int theDim,
+ const TopoDS_Shape& theShape)
{
_subMesh = (SMESH_subMesh*)theSubMesh;
SetShape( theDim, theShape );
}
+ //-----------------------------------------------------------------------------
//! set shape
void SetShape(const int theDim,
const TopoDS_Shape& theShape)
{
_dim = theDim;
- _ownDim = (int)SMESH_Gen::GetShapeDim(theShape);
+ _ownDim = SMESH_Gen::GetShapeDim(theShape);
if (_dim >= _ownDim)
_shapeMap.Add( theShape );
else {
}
}
+ //-----------------------------------------------------------------------------
//! Check sharing of sub-shapes
static bool isShareSubShapes(const TopTools_MapOfShape& theToCheck,
const TopTools_MapOfShape& theToFind,
return isShared;
}
+ //-----------------------------------------------------------------------------
//! check algorithms
static bool checkAlgo(const SMESHDS_Hypothesis* theA1,
const SMESHDS_Hypothesis* theA2)
{
- if ( theA1->GetType() == SMESHDS_Hypothesis::PARAM_ALGO ||
+ if ( !theA1 || !theA2 ||
+ theA1->GetType() == SMESHDS_Hypothesis::PARAM_ALGO ||
theA2->GetType() == SMESHDS_Hypothesis::PARAM_ALGO )
return false; // one of the hypothesis is not algorithm
// check algorithm names (should be equal)
}
+ //-----------------------------------------------------------------------------
//! Check if sub-shape hypotheses are concurrent
bool IsConcurrent(const SMESH_DimHyp* theOther) const
{
// if ( <own dim of either of submeshes> == <concurrent dim> &&
// any of the two submeshes is not on COMPOUND shape )
// -> no concurrency
- bool meIsCompound = (_subMesh->GetSubMeshDS() && _subMesh->GetSubMeshDS()->IsComplexSubmesh());
- bool otherIsCompound = (theOther->_subMesh->GetSubMeshDS() && theOther->_subMesh->GetSubMeshDS()->IsComplexSubmesh());
+ bool meIsCompound = (_subMesh->GetSubMeshDS() &&
+ _subMesh->GetSubMeshDS()->IsComplexSubmesh());
+ bool otherIsCompound = (theOther->_subMesh->GetSubMeshDS() &&
+ theOther->_subMesh->GetSubMeshDS()->IsComplexSubmesh());
if ( (_ownDim == _dim || theOther->_ownDim == _dim ) && (!meIsCompound || !otherIsCompound))
return false;
return false;
// check algorithms to be same
- if (!checkAlgo( _hypothesises.front(), theOther->_hypothesises.front() ))
- return true; // different algorithms
-
+ if ( !checkAlgo( this->GetAlgo(), theOther->GetAlgo() ))
+ return true; // different algorithms -> concurrency !
+
// check hypothesises for concurrence (skip first as algorithm)
int nbSame = 0;
- // pointers should be same, becase it is referenes from mesh hypothesis partition
- list <const SMESHDS_Hypothesis*>::const_iterator hypIt = _hypothesises.begin();
- list <const SMESHDS_Hypothesis*>::const_iterator otheEndIt = theOther->_hypothesises.end();
- for ( hypIt++ /*skip first as algo*/; hypIt != _hypothesises.end(); hypIt++ )
- if ( find( theOther->_hypothesises.begin(), otheEndIt, *hypIt ) != otheEndIt )
+ // pointers should be same, because it is referened from mesh hypothesis partition
+ list <const SMESHDS_Hypothesis*>::const_iterator hypIt = _hypotheses.begin();
+ list <const SMESHDS_Hypothesis*>::const_iterator otheEndIt = theOther->_hypotheses.end();
+ for ( hypIt++ /*skip first as algo*/; hypIt != _hypotheses.end(); hypIt++ )
+ if ( find( theOther->_hypotheses.begin(), otheEndIt, *hypIt ) != otheEndIt )
nbSame++;
// the submeshes are concurrent if their algorithms has different parameters
- return nbSame != theOther->_hypothesises.size() - 1;
+ return nbSame != theOther->_hypotheses.size() - 1;
+ }
+
+ // Return true if algorithm of this SMESH_DimHyp is used if no
+ // sub-mesh order is imposed by the user
+ bool IsHigherPriorityThan( const SMESH_DimHyp* theOther ) const
+ {
+ // NeedDiscreteBoundary() algo has a higher priority
+ if ( this ->GetAlgo()->NeedDiscreteBoundary() !=
+ theOther->GetAlgo()->NeedDiscreteBoundary() )
+ return !this->GetAlgo()->NeedDiscreteBoundary();
+
+ return ( this->_subMesh->GetId() < theOther->_subMesh->GetId() );
}
}; // end of SMESH_DimHyp
+//-----------------------------------------------------------------------------
+
+typedef list<const SMESH_DimHyp*> TDimHypList;
-typedef list<SMESH_DimHyp*> TDimHypList;
+//-----------------------------------------------------------------------------
-static void addDimHypInstance(const int theDim,
- const TopoDS_Shape& theShape,
- const SMESH_Algo* theAlgo,
- const SMESH_subMesh* theSubMesh,
- const list <const SMESHDS_Hypothesis*>& theHypList,
- TDimHypList* theDimHypListArr )
+void addDimHypInstance(const int theDim,
+ const TopoDS_Shape& theShape,
+ const SMESH_Algo* theAlgo,
+ const SMESH_subMesh* theSubMesh,
+ const list <const SMESHDS_Hypothesis*>& theHypList,
+ TDimHypList* theDimHypListArr )
{
TDimHypList& listOfdimHyp = theDimHypListArr[theDim];
if ( listOfdimHyp.empty() || listOfdimHyp.back()->_subMesh != theSubMesh ) {
SMESH_DimHyp* dimHyp = new SMESH_DimHyp( theSubMesh, theDim, theShape );
+ dimHyp->_hypotheses.push_front(theAlgo);
listOfdimHyp.push_back( dimHyp );
}
- SMESH_DimHyp* dimHyp = listOfdimHyp.back();
- dimHyp->_hypothesises.push_front(theAlgo);
- list <const SMESHDS_Hypothesis*>::const_iterator hypIt = theHypList.begin();
- for( ; hypIt != theHypList.end(); hypIt++ )
- dimHyp->_hypothesises.push_back( *hypIt );
+ SMESH_DimHyp* dimHyp = const_cast<SMESH_DimHyp*>( listOfdimHyp.back() );
+ dimHyp->_hypotheses.insert( dimHyp->_hypotheses.end(),
+ theHypList.begin(), theHypList.end() );
+}
+
+//-----------------------------------------------------------------------------
+void addInOrderOfPriority( const SMESH_DimHyp* theDimHyp,
+ TDimHypList& theListOfConcurr)
+{
+ if ( theListOfConcurr.empty() )
+ {
+ theListOfConcurr.push_back( theDimHyp );
+ }
+ else
+ {
+ TDimHypList::iterator hypIt = theListOfConcurr.begin();
+ while ( hypIt != theListOfConcurr.end() &&
+ !theDimHyp->IsHigherPriorityThan( *hypIt ))
+ ++hypIt;
+ theListOfConcurr.insert( hypIt, theDimHyp );
+ }
}
-static void findConcurrents(const SMESH_DimHyp* theDimHyp,
- const TDimHypList& theListOfDimHyp,
- TListOfInt& theListOfConcurr )
+//-----------------------------------------------------------------------------
+void findConcurrents(const SMESH_DimHyp* theDimHyp,
+ const TDimHypList& theListOfDimHyp,
+ TDimHypList& theListOfConcurrHyp,
+ set<int>& theSetOfConcurrId )
{
TDimHypList::const_reverse_iterator rIt = theListOfDimHyp.rbegin();
- for ( ; rIt != theListOfDimHyp.rend(); rIt++ ) {
+ for ( ; rIt != theListOfDimHyp.rend(); rIt++ )
+ {
const SMESH_DimHyp* curDimHyp = *rIt;
if ( curDimHyp == theDimHyp )
break; // meet own dimHyp pointer in same dimension
- else if ( theDimHyp->IsConcurrent( curDimHyp ) )
- if ( find( theListOfConcurr.begin(),
- theListOfConcurr.end(),
- curDimHyp->_subMesh->GetId() ) == theListOfConcurr.end() )
- theListOfConcurr.push_back( curDimHyp->_subMesh->GetId() );
+
+ if ( theDimHyp->IsConcurrent( curDimHyp ) &&
+ theSetOfConcurrId.insert( curDimHyp->_subMesh->GetId() ).second )
+ {
+ addInOrderOfPriority( curDimHyp, theListOfConcurrHyp );
+ }
}
}
-static void unionLists(TListOfInt& theListOfId,
- TListOfListOfInt& theListOfListOfId,
- const int theIndx )
+//-----------------------------------------------------------------------------
+void unionLists(TListOfInt& theListOfId,
+ TListOfListOfInt& theListOfListOfId,
+ const int theIndx )
{
TListOfListOfInt::iterator it = theListOfListOfId.begin();
for ( int i = 0; it != theListOfListOfId.end(); it++, i++ ) {
otherListOfId.clear();
}
}
+//-----------------------------------------------------------------------------
//! free memory allocated for dimension-hypothesis objects
-static void removeDimHyps( TDimHypList* theArrOfList )
+void removeDimHyps( TDimHypList* theArrOfList )
{
for (int i = 0; i < 4; i++ ) {
TDimHypList& listOfdimHyp = theArrOfList[i];
}
}
+//-----------------------------------------------------------------------------
+/*!
+ * \brief find common submeshes with given submesh
+ * \param theSubMeshList list of already collected submesh to check
+ * \param theSubMesh given submesh to intersect with other
+ * \param theCommonSubMeshes collected common submeshes
+ */
+void findCommonSubMesh (list<const SMESH_subMesh*>& theSubMeshList,
+ const SMESH_subMesh* theSubMesh,
+ set<const SMESH_subMesh*>& theCommon )
+{
+ if ( !theSubMesh )
+ return;
+ list<const SMESH_subMesh*>::const_iterator it = theSubMeshList.begin();
+ for ( ; it != theSubMeshList.end(); it++ )
+ theSubMesh->FindIntersection( *it, theCommon );
+ theSubMeshList.push_back( theSubMesh );
+ //theCommon.insert( theSubMesh );
+}
+
+} // namespace
+
//=============================================================================
/*!
* \brief Return submesh objects list in meshing order
TListOfListOfInt anOrder = mesh.GetMeshOrder(); // is there already defined order?
if ( !anOrder.size() ) {
- // collect submeshes detecting concurrent algorithms and hypothesises
+ // 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();
::SMESH_subMesh* sm = (*i_sm).second;
// shape of submesh
const TopoDS_Shape& aSubMeshShape = sm->GetSubShape();
-
+
// list of assigned hypothesises
const list <const SMESHDS_Hypothesis*>& hypList = mesh.GetHypothesisList(aSubMeshShape);
// Find out dimensions where the submesh can be concurrent.
anAlgo = mesh.GetGen()->GetAlgo( mesh, anExp.Current() );
}
if (!anAlgo)
- continue; // no assigned algorithm to current submesh
+ continue; // no algorithm assigned to a current submesh
int dim = anAlgo->GetDim(); // top concurrent dimension (see comment to SMESH_DimHyp)
// the submesh can concurrent at <dim> (or lower dims if !anAlgo->NeedDiscreteBoundary())
// iterate on created dimension-hypotheses and check for concurrents
for ( int i = 0; i < 4; i++ ) {
- const list<SMESH_DimHyp*>& listOfDimHyp = dimHypListArr[i];
+ const TDimHypList& listOfDimHyp = dimHypListArr[i];
// check for concurrents in own and other dimensions (step-by-step)
TDimHypList::const_iterator dhIt = listOfDimHyp.begin();
for ( ; dhIt != listOfDimHyp.end(); dhIt++ ) {
const SMESH_DimHyp* dimHyp = *dhIt;
- TListOfInt listOfConcurr;
+ TDimHypList listOfConcurr;
+ set<int> setOfConcurrIds;
// looking for concurrents and collect into own list
for ( int j = i; j < 4; j++ )
- findConcurrents( dimHyp, dimHypListArr[j], listOfConcurr );
+ findConcurrents( dimHyp, dimHypListArr[j], listOfConcurr, setOfConcurrIds );
// check if any concurrents found
if ( listOfConcurr.size() > 0 ) {
// add own submesh to list of concurrent
- listOfConcurr.push_front( dimHyp->_subMesh->GetId() );
- anOrder.push_back( listOfConcurr );
+ addInOrderOfPriority( dimHyp, listOfConcurr );
+ list<int> listOfConcurrIds;
+ TDimHypList::iterator hypIt = listOfConcurr.begin();
+ for ( ; hypIt != listOfConcurr.end(); ++hypIt )
+ listOfConcurrIds.push_back( (*hypIt)->_subMesh->GetId() );
+ anOrder.push_back( listOfConcurrIds );
}
}
}
return aResult._retn();
}
-//=============================================================================
-/*!
- * \brief find common submeshes with given submesh
- * \param theSubMeshList list of already collected submesh to check
- * \param theSubMesh given submesh to intersect with other
- * \param theCommonSubMeshes collected common submeshes
- */
-//=============================================================================
-
-static void findCommonSubMesh (list<const SMESH_subMesh*>& theSubMeshList,
- const SMESH_subMesh* theSubMesh,
- set<const SMESH_subMesh*>& theCommon )
-{
- if ( !theSubMesh )
- return;
- list<const SMESH_subMesh*>::const_iterator it = theSubMeshList.begin();
- for ( ; it != theSubMeshList.end(); it++ )
- theSubMesh->FindIntersection( *it, theCommon );
- theSubMeshList.push_back( theSubMesh );
- //theCommon.insert( theSubMesh );
-}
-
//=============================================================================
/*!
* \brief Set submesh object order
}
}
// -------------------------------------------------------------------------------------
+SMESH_MeshPartDS::SMESH_MeshPartDS(const std::list< const SMDS_MeshElement* > & meshPart):
+ SMESHDS_Mesh( /*meshID=*/-1, /*isEmbeddedMode=*/true), _meshDS(0)
+{
+ TMeshInfo tmpInfo;
+ list< const SMDS_MeshElement* >::const_iterator partIt = meshPart.begin();
+ for ( ; partIt != meshPart.end(); ++partIt )
+ if ( const SMDS_MeshElement * e = *partIt )
+ if ( _elements[ e->GetType() ].insert( e ).second )
+ {
+ tmpInfo.Add( e );
+ SMDS_ElemIteratorPtr nIt = e->nodesIterator();
+ while ( nIt->more() )
+ {
+ const SMDS_MeshNode * n = (const SMDS_MeshNode*) nIt->next();
+ if ( _elements[ SMDSAbs_Node ].insert( n ).second )
+ tmpInfo.Add( n );
+ }
+ }
+ myInfo = tmpInfo;
+}
+// -------------------------------------------------------------------------------------
SMDS_ElemIteratorPtr SMESH_MeshPartDS::elementGeomIterator(SMDSAbs_GeometryType geomType) const
{
if ( _meshDS ) return _meshDS->elementGeomIterator( geomType );
// END Implementation of SMESH_MeshPartDS
//
//================================================================================
+
+
