-// 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 "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_MeshAlgos.hxx"
#include "SMESH_MeshEditor.hxx"
#include "SMESH_MeshEditor_i.hxx"
#include "SMESH_MeshPartDS.hxx"
: SALOME::GenericObj_i( thePOA )
{
MESSAGE("SMESH_Mesh_i");
- _impl = NULL;
- _gen_i = gen_i;
- _id = _idGenerator++;
- _studyId = studyId;
- _preMeshInfo = NULL;
+ _impl = NULL;
+ _gen_i = gen_i;
+ _id = _idGenerator++;
+ _studyId = studyId;
+ _editor = NULL;
+ _previewEditor = NULL;
+ _preMeshInfo = NULL;
}
//=============================================================================
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();
+ SMESH::SMESH_GroupBase_var( itGr->second );
}
_mapGroups.clear();
if ( SMESH_subMesh_i* aSubMesh = SMESH::DownCast<SMESH_subMesh_i*>( itSM->second ))
{
aSubMesh->UnRegister();
+ SMESH::SMESH_subMesh_var( itSM->second );
}
_mapSubMeshIor.clear();
- // destroy hypotheses
+ // destroy hypotheses. _mapHypo contains all hyps ever been assigned
map<int, SMESH::SMESH_Hypothesis_ptr>::iterator itH;
- for ( itH = _mapHypo.begin(); itH != _mapHypo.end(); itH++ )
- if ( SMESH_Hypothesis_i* aHypo = SMESH::DownCast<SMESH_Hypothesis_i*>( itH->second ))
- {
- aHypo->UnRegister();
- }
+ for ( itH = _mapHypo.begin(); itH != _mapHypo.end(); itH++ ) {
+ if ( SMESH_Hypothesis_i* hyp_i = SMESH::DownCast<SMESH_Hypothesis_i*>( itH->second ))
+ if ( SMESH_Hypothesis * smHyp = _impl->GetHypothesis( itH->first ))
+ if ( _impl->GetMeshDS()->IsUsedHypothesis( smHyp ))
+ hyp_i->UnRegister();
+
+ SMESH::SMESH_Hypothesis_var( itH->second ); // decref CORBA object
+ }
_mapHypo.clear();
+ delete _editor; _editor = NULL;
+ delete _previewEditor; _previewEditor = NULL;
delete _impl; _impl = NULL;
delete _preMeshInfo; _preMeshInfo = NULL;
}
THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
}
// to track changes of GEOM groups
- addGeomGroupData( theShapeObject, _this() );
+ SMESH::SMESH_Mesh_var mesh = _this();
+ addGeomGroupData( theShapeObject, mesh );
}
//================================================================================
}
_impl->GetMeshDS()->Modified();
- TPythonDump() << _this() << ".Clear()";
+ TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".Clear()";
}
//================================================================================
}
_impl->GetMeshDS()->Modified();
- TPythonDump() << _this() << ".ClearSubMesh( " << ShapeID << " )";
+ TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ClearSubMesh( " << ShapeID << " )";
}
//=============================================================================
}
else
{
- errVar->code = ConvertDriverMEDReadStatus( errorPtr->myName );
+ errVar->code = ConvertDriverMEDReadStatus( errorPtr->myName );
errVar->comment = errorPtr->myComment.c_str();
}
return errVar._retn();
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;
+ _medFileInfo->major = major;
+ _medFileInfo->minor = minor;
+ _medFileInfo->release = release;
#ifdef WIN32
struct _stati64 d;
if ( ::_stati64( theFileName, &d ) != -1 )
if ( ::stat64( theFileName, &d ) != -1 )
#endif
_medFileInfo->fileSize = d.st_size;
- _medFileInfo->major = major;
- _medFileInfo->minor = minor;
- _medFileInfo->release = release;
return ConvertDriverMEDReadStatus(status);
}
char* SMESH_Mesh_i::GetVersionString(SMESH::MED_VERSION version, CORBA::Short nbDigits)
{
string ver = DriverMED_W_SMESHDS_Mesh::GetVersionString(MED::EVersion(version),
- nbDigits);
+ nbDigits);
return CORBA::string_dup( ver.c_str() );
}
SMESH_Hypothesis::Hypothesis_Status status = addHypothesis( aSubShapeObject, anHyp );
+ SMESH::SMESH_Mesh_var mesh( _this() );
if ( !SMESH_Hypothesis::IsStatusFatal(status) )
- _gen_i->AddHypothesisToShape(_gen_i->GetCurrentStudy(), _this(),
- aSubShapeObject, anHyp );
-
+ {
+ SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
+ _gen_i->AddHypothesisToShape( study, mesh, aSubShapeObject, anHyp );
+ }
if(MYDEBUG) MESSAGE( " AddHypothesis(): status = " << status );
// Update Python script
- if(_impl->HasShapeToMesh()) {
- TPythonDump() << "status = " << _this() << ".AddHypothesis( "
+ //if(_impl->HasShapeToMesh())
+ {
+ TPythonDump() << "status = " << mesh << ".AddHypothesis( "
<< aSubShapeObject << ", " << anHyp << " )";
}
- else {
- TPythonDump() << "status = " << _this() << ".AddHypothesis( "<< anHyp << " )";
- }
-
+ // else {
+ // TPythonDump() << "status = " << mesh << ".AddHypothesis( "<< 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 aSubShapeObject,
+ SMESH::SMESH_Hypothesis_ptr anHyp)
{
if(MYDEBUG) MESSAGE("addHypothesis");
- if (CORBA::is_nil(aSubShapeObject) && HasShapeToMesh())
- THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference",
- SALOME::BAD_PARAM);
+ if (CORBA::is_nil( aSubShapeObject ) && HasShapeToMesh())
+ THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference",SALOME::BAD_PARAM);
- SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(anHyp);
- if (CORBA::is_nil(myHyp))
- THROW_SALOME_CORBA_EXCEPTION("bad hypothesis reference",
- SALOME::BAD_PARAM);
+ if (CORBA::is_nil( anHyp ))
+ THROW_SALOME_CORBA_EXCEPTION("bad hypothesis reference",SALOME::BAD_PARAM);
SMESH_Hypothesis::Hypothesis_Status status = SMESH_Hypothesis::HYP_OK;
try
else
myLocSubShape = _impl->GetShapeToMesh();
- int hypId = myHyp->GetId();
+ const int hypId = anHyp->GetId();
status = _impl->AddHypothesis(myLocSubShape, hypId);
if ( !SMESH_Hypothesis::IsStatusFatal(status) ) {
- _mapHypo[hypId] = SMESH::SMESH_Hypothesis::_duplicate( myHyp );
- _mapHypo[hypId]->Register();
+ _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() )
- createSubMesh( aSubShapeObject );
+ SMESH::SMESH_subMesh_var( createSubMesh( aSubShapeObject ));
}
}
}
SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject,
SMESH::SMESH_Hypothesis_ptr anHyp)
- throw(SALOME::SALOME_Exception)
+ throw(SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
_preMeshInfo->ForgetOrLoad();
SMESH_Hypothesis::Hypothesis_Status status = removeHypothesis( aSubShapeObject, anHyp );
+ SMESH::SMESH_Mesh_var mesh = _this();
if ( !SMESH_Hypothesis::IsStatusFatal(status) )
- _gen_i->RemoveHypothesisFromShape(_gen_i->GetCurrentStudy(), _this(),
- aSubShapeObject, anHyp );
-
- // Update Python script
- // Update Python script
- if(_impl->HasShapeToMesh()) {
- TPythonDump() << "status = " << _this() << ".RemoveHypothesis( "
- << aSubShapeObject << ", " << anHyp << " )";
+ {
+ SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
+ _gen_i->RemoveHypothesisFromShape( study, mesh, aSubShapeObject, anHyp );
}
- else {
- TPythonDump() << "status = " << _this() << ".RemoveHypothesis( "
+ // Update Python script
+ if(_impl->HasShapeToMesh())
+ TPythonDump() << "status = " << mesh << ".RemoveHypothesis( "
+ << aSubShapeObject << ", " << anHyp << " )";
+ else
+ TPythonDump() << "status = " << mesh << ".RemoveHypothesis( "
<< anHyp << " )";
- }
return ConvertHypothesisStatus(status);
}
SMESH::SMESH_Hypothesis_ptr anHyp)
{
if(MYDEBUG) MESSAGE("removeHypothesis()");
- // **** proposer liste de sub-shape (selection multiple)
- if (CORBA::is_nil(aSubShapeObject) && HasShapeToMesh())
+ if (CORBA::is_nil( aSubShapeObject ) && HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM);
- SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(anHyp);
- if (CORBA::is_nil(myHyp))
+ if (CORBA::is_nil( anHyp ))
THROW_SALOME_CORBA_EXCEPTION("bad hypothesis reference", SALOME::BAD_PARAM);
SMESH_Hypothesis::Hypothesis_Status status = SMESH_Hypothesis::HYP_OK;
{
TopoDS_Shape myLocSubShape;
//use PseudoShape in case if mesh has no shape
- if(HasShapeToMesh())
- myLocSubShape = _gen_i->GeomObjectToShape( aSubShapeObject);
+ if( _impl->HasShapeToMesh() )
+ myLocSubShape = _gen_i->GeomObjectToShape( aSubShapeObject );
else
myLocSubShape = _impl->GetShapeToMesh();
- int hypId = myHyp->GetId();
+ const int hypId = anHyp->GetId();
status = _impl->RemoveHypothesis(myLocSubShape, hypId);
-// if ( !SMESH_Hypothesis::IsStatusFatal(status) ) EAP: hyp can be used on many sub-shapes
-// _mapHypo.erase( hypId );
+ if ( !SMESH_Hypothesis::IsStatusFatal(status) )
+ {
+ // _mapHypo.erase( hypId ); EAP: hyp can be used on many sub-shapes
+ anHyp->UnRegister();
+ }
}
catch(SALOME_Exception & S_ex)
{
//=============================================================================
SMESH::ListOfHypothesis *
- SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShapeObject)
+SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShapeObject)
throw(SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
int i = 0, n = aLocalList.size();
aList->length( n );
- for ( list<const SMESHDS_Hypothesis*>::const_iterator anIt = aLocalList.begin(); i < n && anIt != aLocalList.end(); anIt++ ) {
- SMESHDS_Hypothesis* aHyp = (SMESHDS_Hypothesis*)(*anIt);
- if ( _mapHypo.find( aHyp->GetID() ) != _mapHypo.end() )
- aList[i++] = SMESH::SMESH_Hypothesis::_narrow( _mapHypo[aHyp->GetID()] );
+ list<const SMESHDS_Hypothesis*>::const_iterator aHyp = aLocalList.begin();
+ std::map<int, SMESH::SMESH_Hypothesis_ptr>::iterator id_hypptr;
+ for ( ; i < n && aHyp != aLocalList.end(); aHyp++ )
+ {
+ id_hypptr = _mapHypo.find( (*aHyp)->GetID() );
+ if ( id_hypptr != _mapHypo.end() )
+ aList[i++] = SMESH::SMESH_Hypothesis::_narrow( id_hypptr->second );
}
-
aList->length( i );
}
catch(SALOME_Exception & S_ex) {
// Update Python script
if ( !_mapSubMeshIor.empty() )
- aPythonDump << " ] = " << _this() << ".GetSubMeshes()";
+ aPythonDump << " ] = " << SMESH::SMESH_Mesh_var( _this() ) << ".GetSubMeshes()";
return aList._retn();
}
*
*/
//=============================================================================
+
SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShapeObject,
const char* theName )
throw(SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
- MESSAGE("SMESH_Mesh_i::GetSubMesh");
if (CORBA::is_nil(aSubShapeObject))
- THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference",
- SALOME::BAD_PARAM);
+ THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM);
SMESH::SMESH_subMesh_var subMesh;
- SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow(_this());
+ SMESH::SMESH_Mesh_var aMesh = _this();
try {
TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(aSubShapeObject);
// create a new subMesh object servant if there is none for the shape
if ( subMesh->_is_nil() )
subMesh = createSubMesh( aSubShapeObject );
- if ( _gen_i->CanPublishInStudy( subMesh )) {
+ if ( _gen_i->CanPublishInStudy( subMesh ))
+ {
+ SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
SALOMEDS::SObject_wrap aSO =
- _gen_i->PublishSubMesh(_gen_i->GetCurrentStudy(), aMesh,
- subMesh, aSubShapeObject, theName );
+ _gen_i->PublishSubMesh( study, aMesh, subMesh, aSubShapeObject, theName );
if ( !aSO->_is_nil()) {
// Update Python script
- TPythonDump() << aSO << " = " << _this() << ".GetSubMesh( "
+ TPythonDump() << aSO << " = " << aMesh << ".GetSubMesh( "
<< aSubShapeObject << ", '" << theName << "' )";
}
}
throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
-
+
if ( theSubMesh->_is_nil() )
return;
builder->RemoveObjectWithChildren( anSO );
// Update Python script
- TPythonDump() << _this() << ".RemoveSubMesh( " << anSO << " )";
+ TPythonDump() << SMESH::SMESH_Mesh_var( _this() ) << ".RemoveSubMesh( " << anSO << " )";
}
}
SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType,
const char* theName )
- throw(SALOME::SALOME_Exception)
+ throw(SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
SMESH::SMESH_Group_var aNewGroup =
SMESH::SMESH_Group::_narrow( createGroup( theElemType, theName ));
- if ( _gen_i->CanPublishInStudy( aNewGroup ) ) {
+ if ( _gen_i->CanPublishInStudy( aNewGroup ) )
+ {
+ SMESH::SMESH_Mesh_var mesh = _this();
+ SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
SALOMEDS::SObject_wrap aSO =
- _gen_i->PublishGroup(_gen_i->GetCurrentStudy(), _this(),
- aNewGroup, GEOM::GEOM_Object::_nil(), theName);
- if ( !aSO->_is_nil()) {
+ _gen_i->PublishGroup( study, mesh, aNewGroup, GEOM::GEOM_Object::_nil(), theName);
+ if ( !aSO->_is_nil())
// Update Python script
- TPythonDump() << aSO << " = " << _this() << ".CreateGroup( "
+ TPythonDump() << aSO << " = " << mesh << ".CreateGroup( "
<< theElemType << ", '" << theName << "' )";
- }
}
return aNewGroup._retn();
}
-
//=============================================================================
/*!
*
SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType theElemType,
const char* theName,
GEOM::GEOM_Object_ptr theGeomObj)
- throw(SALOME::SALOME_Exception)
+ throw(SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
TopoDS_Shape aShape = _gen_i->GeomObjectToShape( theGeomObj );
if ( !aShape.IsNull() )
{
- aNewGroup = SMESH::SMESH_GroupOnGeom::_narrow
- ( createGroup( theElemType, theName, aShape ));
+ aNewGroup =
+ SMESH::SMESH_GroupOnGeom::_narrow( createGroup( theElemType, theName, aShape ));
- if ( _gen_i->CanPublishInStudy( aNewGroup ) ) {
+ if ( _gen_i->CanPublishInStudy( aNewGroup ) )
+ {
+ SMESH::SMESH_Mesh_var mesh = _this();
+ SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
SALOMEDS::SObject_wrap aSO =
- _gen_i->PublishGroup(_gen_i->GetCurrentStudy(), _this(),
- aNewGroup, theGeomObj, theName);
- if ( !aSO->_is_nil()) {
- // Update Python script
- TPythonDump() << aSO << " = " << _this() << ".CreateGroupFromGEOM("
+ _gen_i->PublishGroup( study, mesh, aNewGroup, theGeomObj, theName );
+ if ( !aSO->_is_nil())
+ TPythonDump() << aSO << " = " << mesh << ".CreateGroupFromGEOM( "
<< theElemType << ", '" << theName << "', " << theGeomObj << " )";
- }
}
}
SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType,
const char* theName,
SMESH::Filter_ptr theFilter )
- throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
if ( _gen_i->CanPublishInStudy( aNewGroup ) )
{
+ SMESH::SMESH_Mesh_var mesh = _this();
+ SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
SALOMEDS::SObject_wrap aSO =
- _gen_i->PublishGroup(_gen_i->GetCurrentStudy(), _this(), aNewGroup,
- GEOM::GEOM_Object::_nil(), theName);
- if ( !aSO->_is_nil()) {
- // Update Python script
- pd << aSO << " = " << _this() << ".CreateGroupFromFilter("
+ _gen_i->PublishGroup( study, mesh, aNewGroup, GEOM::GEOM_Object::_nil(), theName );
+
+ if ( !aSO->_is_nil())
+ pd << aSO << " = " << mesh << ".CreateGroupFromFilter( "
<< theElemType << ", '" << theName << "', " << theFilter << " )";
- }
}
-
return aNewGroup._retn();
}
//=============================================================================
void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
- throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
if ( theGroup->_is_nil() )
return;
SMESH_TRY;
- SMESH_GroupBase_i* aGroup =
- dynamic_cast<SMESH_GroupBase_i*>( SMESH_Gen_i::GetServant( theGroup ).in() );
+ SMESH_GroupBase_i* aGroup = SMESH::DownCast<SMESH_GroupBase_i*>( theGroup );
if ( !aGroup )
return;
SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
- if ( !aStudy->_is_nil() ) {
+ if ( !aStudy->_is_nil() )
+ {
SALOMEDS::SObject_wrap aGroupSO = _gen_i->ObjectToSObject( aStudy, theGroup );
-
- if ( !aGroupSO->_is_nil() ) {
+ if ( !aGroupSO->_is_nil() )
+ {
// Update Python script
- TPythonDump() << _this() << ".RemoveGroup( " << aGroupSO << " )";
+ TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".RemoveGroup( " << aGroupSO << " )";
// Remove group's SObject
SALOMEDS::StudyBuilder_var builder = aStudy->NewBuilder();
if ( theGroup->_is_nil() )
return;
- SMESH_GroupBase_i* aGroup =
- dynamic_cast<SMESH_GroupBase_i*>( SMESH_Gen_i::GetServant( theGroup ).in() );
- if ( !aGroup )
- return;
-
- SMESH::long_array_var anIds = aGroup->GetListOfID();
- SMESH::SMESH_MeshEditor_var aMeshEditor = SMESH_Mesh_i::GetMeshEditor();
-
- TPythonDump pyDump; // Supress dump from RemoveNodes/Elements() and RemoveGroup()
-
// Remove contents
- if ( aGroup->GetType() == SMESH::NODE )
- aMeshEditor->RemoveNodes( anIds );
- else
- aMeshEditor->RemoveElements( anIds );
+ 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() );
+
+ TPythonDump pyDump; // Supress dump from RemoveGroup()
// Update Python script (theGroup must be alive for this)
- pyDump << _this() << ".RemoveGroupWithContents( " << theGroup << " )";
+ pyDump << SMESH::SMESH_Mesh_var(_this())
+ << ".RemoveGroupWithContents( " << theGroup << " )";
// Remove group
RemoveGroup( theGroup );
//================================================================================
/*!
* \brief Get the list of groups existing in the mesh
- * \retval SMESH::ListOfGroups * - list of groups
+ * \retval SMESH::ListOfGroups * - list of groups
*/
//================================================================================
// 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 );
}
- aList->length( i );
- }
- catch(SALOME_Exception & S_ex) {
- THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
+ catch(SALOME_Exception & S_ex) {
+ THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
+ }
+ aPythonDump << " ] = " << SMESH::SMESH_Mesh_var(_this()) << ".GetGroups()";
}
-
- // Update Python script
- if ( !_mapGroups.empty() ) // (IMP13463) avoid "SyntaxError: can't assign to []"
- aPythonDump << " ] = " << _this() << ".GetGroups()";
-
return aList._retn();
}
}
//=============================================================================
-/*! UnionGroups
- * New group is created. All mesh elements that are
- * present in initial groups are added to the new one
+/*!
+ * New group including all mesh elements present in initial groups is created.
*/
//=============================================================================
+
SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionGroups( 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;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- if ( theGroup1->_is_nil() || theGroup2->_is_nil() ||
- theGroup1->GetType() != theGroup2->GetType() )
- return SMESH::SMESH_Group::_nil();
-
+ if ( theGroup1->_is_nil() || theGroup2->_is_nil() )
+ THROW_SALOME_CORBA_EXCEPTION("UnionGroups(): NULL Group",
+ SALOME::BAD_PARAM);
+ if ( theGroup1->GetType() != theGroup2->GetType() )
+ THROW_SALOME_CORBA_EXCEPTION("UnionGroups(): different group types",
+ SALOME::BAD_PARAM);
TPythonDump pyDump;
// Create Union
if ( aResGrp->_is_nil() )
return SMESH::SMESH_Group::_nil();
- SMESH::long_array_var anIds1 = theGroup1->GetListOfID();
- SMESH::long_array_var anIds2 = theGroup2->GetListOfID();
-
- TColStd_MapOfInteger aResMap;
-
- for ( int i1 = 0, n1 = anIds1->length(); i1 < n1; i1++ )
- aResMap.Add( anIds1[ i1 ] );
-
- for ( int i2 = 0, n2 = anIds2->length(); i2 < n2; i2++ )
- aResMap.Add( anIds2[ i2 ] );
-
- SMESH::long_array_var aResIds = new SMESH::long_array;
- aResIds->length( aResMap.Extent() );
-
- int resI = 0;
- TColStd_MapIteratorOfMapOfInteger anIter( aResMap );
- for( ; anIter.More(); anIter.Next() )
- aResIds[ resI++ ] = anIter.Key();
-
- aResGrp->Add( aResIds );
+ aResGrp->AddFrom( theGroup1 );
+ aResGrp->AddFrom( theGroup2 );
// Update Python script
- pyDump << aResGrp << " = " << _this() << ".UnionGroups( "
- << theGroup1 << ", " << theGroup2 << ", '"
- << theName << "' )";
+ pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var(_this())
+ << ".UnionGroups( " << theGroup1 << ", " << theGroup2 << ", '" << theName << "' )";
SMESH_CATCH( SMESH::throwCorbaException );
//=============================================================================
/*!
- \brief Union list of groups. New group is created. All mesh elements that are
- 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
-*/
+ * \brief New group including all mesh elements present in initial groups is created.
+ * \param theGroups list of groups
+ * \param theName name of group to be created
+ * \return pointer to the new group
+ */
//=============================================================================
+
SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups& theGroups,
const char* theName )
throw (SALOME::SALOME_Exception)
{
+ SMESH::SMESH_Group_var aResGrp;
+
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
if ( !theName )
return SMESH::SMESH_Group::_nil();
- SMESH::SMESH_Group_var aResGrp;
-
SMESH_TRY;
- vector< int > anIds;
+ // check types
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();
- }
-
- // 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 );
- }
+ aType = aGrp->GetType();
+ else if ( aType != aGrp->GetType() )
+ THROW_SALOME_CORBA_EXCEPTION("UnionListOfGroups(): different group types",
+ SALOME::BAD_PARAM);
}
+ if ( aType == SMESH::ALL )
+ return SMESH::SMESH_Group::_nil();
TPythonDump pyDump;
- // Create group
+ // Create Union
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 << "' )";
+ pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var(_this()) << ".UnionListOfGroups([ ";
+ for ( int g = 0, n = theGroups.length(); g < n; g++ )
+ {
+ SMESH::SMESH_GroupBase_var aGrp = theGroups[ g ];
+ if ( !CORBA::is_nil( aGrp ) )
+ {
+ aResGrp->AddFrom( aGrp );
+ if ( g > 0 ) pyDump << ", ";
+ pyDump << aGrp;
+ }
+ }
+ pyDump << " ], '" << theName << "' )";
SMESH_CATCH( SMESH::throwCorbaException );
}
//=============================================================================
-/*! IntersectGroups
+/*!
* New group is created. All mesh elements that are
* present in both initial groups are added to the new one.
*/
//=============================================================================
+
SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName )
SMESH::SMESH_Group_var aResGrp;
SMESH_TRY;
+
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- if ( theGroup1->_is_nil() || theGroup2->_is_nil() ||
- theGroup1->GetType() != theGroup2->GetType() )
- return SMESH::SMESH_Group::_nil();
-
+ if ( theGroup1->_is_nil() || theGroup2->_is_nil() )
+ THROW_SALOME_CORBA_EXCEPTION("IntersectGroups(): NULL Group",
+ SALOME::BAD_PARAM);
+ if ( theGroup1->GetType() != theGroup2->GetType() )
+ THROW_SALOME_CORBA_EXCEPTION("IntersectGroups(): different group types",
+ SALOME::BAD_PARAM);
TPythonDump pyDump;
// Create Intersection
aResGrp = CreateGroup( theGroup1->GetType(), theName );
if ( aResGrp->_is_nil() )
- return aResGrp;
+ return aResGrp._retn();
- SMESH::long_array_var anIds1 = theGroup1->GetListOfID();
- SMESH::long_array_var anIds2 = theGroup2->GetListOfID();
+ SMESHDS_GroupBase* groupDS1 = 0;
+ if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( theGroup1 ))
+ groupDS1 = grp_i->GetGroupDS();
- TColStd_MapOfInteger aMap1;
+ SMESHDS_GroupBase* groupDS2 = 0;
+ if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( theGroup2 ))
+ groupDS2 = grp_i->GetGroupDS();
- for ( int i1 = 0, n1 = anIds1->length(); i1 < n1; i1++ )
- 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 ( size_t resI = 0, resN = aSeq.Length(); resI < resN; resI++ )
- aResIds[ resI ] = aSeq( resI + 1 );
- aResGrp->Add( aResIds );
+ SMESHDS_Group* resGroupDS = 0;
+ if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( aResGrp ))
+ resGroupDS = dynamic_cast<SMESHDS_Group*>( grp_i->GetGroupDS() );
+ if ( groupDS1 && groupDS2 && resGroupDS && !groupDS2->IsEmpty() )
+ {
+ SMDS_ElemIteratorPtr elemIt1 = groupDS1->GetElements();
+ while ( elemIt1->more() )
+ {
+ const SMDS_MeshElement* e = elemIt1->next();
+ if ( groupDS2->Contains( e ))
+ resGroupDS->SMDSGroup().Add( e );
+ }
+ }
// Update Python script
- pyDump << aResGrp << " = " << _this() << ".IntersectGroups( "
+ pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var(_this()) << ".IntersectGroups( "
<< theGroup1 << ", " << theGroup2 << ", '" << theName << "')";
SMESH_CATCH( SMESH::throwCorbaException );
SMESH::SMESH_Group_var aResGrp;
SMESH_TRY;
+
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
if ( !theName )
return SMESH::SMESH_Group::_nil();
- NCollection_DataMap< int, int > anIdToCount;
+ // check types and get SMESHDS_GroupBase's
SMESH::ElementType aType = SMESH::ALL;
+ vector< SMESHDS_GroupBase* > groupVec;
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();
- }
-
- // 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;
- }
- }
+ aType = aGrp->GetType();
+ else if ( aType != aGrp->GetType() )
+ THROW_SALOME_CORBA_EXCEPTION("IntersectListOfGroups(): different group types",
+ SALOME::BAD_PARAM);
- // 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 );
+ if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( aGrp ))
+ if ( SMESHDS_GroupBase* grpDS = grp_i->GetGroupDS() )
+ {
+ if ( grpDS->IsEmpty() )
+ {
+ groupVec.clear();
+ break;
+ }
+ groupVec.push_back( grpDS );
+ }
}
+ if ( aType == SMESH::ALL ) // all groups are nil
+ return SMESH::SMESH_Group::_nil();
TPythonDump pyDump;
- // Create group
+ // Create a 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() );
+ SMESHDS_Group* resGroupDS = 0;
+ if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( aResGrp ))
+ resGroupDS = dynamic_cast<SMESHDS_Group*>( grp_i->GetGroupDS() );
+ if ( !resGroupDS || groupVec.empty() )
+ return aResGrp._retn();
- for ( size_t i = 0; i<anIds.size(); i++ )
- aResIds[ i ] = anIds[i];
- aResGrp->Add( aResIds );
+ // Fill the group
+ size_t i, nb = groupVec.size();
+ SMDS_ElemIteratorPtr elemIt1 = groupVec[0]->GetElements();
+ while ( elemIt1->more() )
+ {
+ const SMDS_MeshElement* e = elemIt1->next();
+ bool inAll = true;
+ for ( i = 1; ( i < nb && inAll ); ++i )
+ inAll = groupVec[i]->Contains( e );
+
+ if ( inAll )
+ resGroupDS->SMDSGroup().Add( e );
+ }
// Update Python script
- pyDump << aResGrp << " = " << _this() << ".IntersectListOfGroups( "
- << &theGroups << ", '" << theName << "' )";
+ pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var( _this() )
+ << ".IntersectListOfGroups( " << theGroups << ", '" << theName << "' )";
SMESH_CATCH( SMESH::throwCorbaException );
}
//=============================================================================
-/*! CutGroups
+/*!
* New group is created. All mesh elements that are present in
- * main group but do not present in tool group are added to the new one
+ * a main group but is not present in a tool group are added to the new one
*/
//=============================================================================
+
SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName )
SMESH::SMESH_Group_var aResGrp;
SMESH_TRY;
+
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- if ( theGroup1->_is_nil() || theGroup2->_is_nil() ||
- theGroup1->GetType() != theGroup2->GetType() )
- return SMESH::SMESH_Group::_nil();
-
+ if ( theGroup1->_is_nil() || theGroup2->_is_nil() )
+ THROW_SALOME_CORBA_EXCEPTION("CutGroups(): NULL Group",
+ SALOME::BAD_PARAM);
+ if ( theGroup1->GetType() != theGroup2->GetType() )
+ THROW_SALOME_CORBA_EXCEPTION("CutGroups(): different group types",
+ SALOME::BAD_PARAM);
TPythonDump pyDump;
- // Perform Cutting
aResGrp = CreateGroup( theGroup1->GetType(), theName );
if ( aResGrp->_is_nil() )
- return aResGrp;
-
- SMESH::long_array_var anIds1 = theGroup1->GetListOfID();
- SMESH::long_array_var anIds2 = theGroup2->GetListOfID();
-
- TColStd_MapOfInteger aMap2;
+ return aResGrp._retn();
- for ( int i2 = 0, n2 = anIds2->length(); i2 < n2; i2++ )
- aMap2.Add( anIds2[ i2 ] );
+ SMESHDS_GroupBase* groupDS1 = 0;
+ if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( theGroup1 ))
+ groupDS1 = grp_i->GetGroupDS();
- TColStd_SequenceOfInteger aSeq;
- for ( int i1 = 0, n1 = anIds1->length(); i1 < n1; i1++ )
- if ( !aMap2.Contains( anIds1[ i1 ] ) )
- aSeq.Append( anIds1[ i1 ] );
+ SMESHDS_GroupBase* groupDS2 = 0;
+ if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( theGroup2 ))
+ groupDS2 = grp_i->GetGroupDS();
- SMESH::long_array_var aResIds = new SMESH::long_array;
- aResIds->length( aSeq.Length() );
-
- for ( int resI = 0, resN = aSeq.Length(); resI < resN; resI++ )
- aResIds[ resI ] = aSeq( resI + 1 );
- aResGrp->Add( aResIds );
+ SMESHDS_Group* resGroupDS = 0;
+ if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( aResGrp ))
+ resGroupDS = dynamic_cast<SMESHDS_Group*>( grp_i->GetGroupDS() );
+ if ( groupDS1 && groupDS2 && resGroupDS )
+ {
+ SMDS_ElemIteratorPtr elemIt1 = groupDS1->GetElements();
+ while ( elemIt1->more() )
+ {
+ const SMDS_MeshElement* e = elemIt1->next();
+ if ( !groupDS2->Contains( e ))
+ resGroupDS->SMDSGroup().Add( e );
+ }
+ }
// Update Python script
- pyDump << aResGrp << " = " << _this() << ".CutGroups( "
- << theGroup1 << ", " << theGroup2 << ", '"
- << theName << "' )";
+ pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var(_this()) << ".CutGroups( "
+ << theGroup1 << ", " << theGroup2 << ", '" << theName << "')";
SMESH_CATCH( SMESH::throwCorbaException );
SMESH::SMESH_Group_var aResGrp;
SMESH_TRY;
+
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
if ( !theName )
return SMESH::SMESH_Group::_nil();
- set< int > aToolIds;
+ // check types and get SMESHDS_GroupBase's
SMESH::ElementType aType = SMESH::ALL;
- int g, n;
- // iterate through tool groups
- for ( g = 0, n = theToolGroups.length(); g < n; g++ )
+ vector< SMESHDS_GroupBase* > toolGroupVec;
+ vector< SMDS_ElemIteratorPtr > mainIterVec;
+
+ for ( int g = 0, n = theMainGroups.length(); g < n; g++ )
{
- SMESH::SMESH_GroupBase_var aGrp = theToolGroups[ g ];
+ SMESH::SMESH_GroupBase_var aGrp = theMainGroups[ 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();
- }
-
- // 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 );
- }
+ aType = aGrp->GetType();
+ else if ( aType != aGrp->GetType() )
+ THROW_SALOME_CORBA_EXCEPTION("UnionListOfGroups(): 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 ( !grpDS->IsEmpty() )
+ mainIterVec.push_back( grpDS->GetElements() );
}
+ if ( aType == SMESH::ALL ) // all main groups are nil
+ return SMESH::SMESH_Group::_nil();
+ if ( mainIterVec.empty() ) // all main groups are empty
+ return aResGrp._retn();
- vector< int > anIds; // result
-
- // Iterate through main group
- for ( g = 0, n = theMainGroups.length(); g < n; g++ )
+ for ( int g = 0, n = theToolGroups.length(); g < n; g++ )
{
- SMESH::SMESH_GroupBase_var aGrp = theMainGroups[ 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();
- }
-
- // 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 );
- }
+ if ( aType != aGrp->GetType() )
+ THROW_SALOME_CORBA_EXCEPTION("UnionListOfGroups(): 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() )
+ toolGroupVec.push_back( grpDS );
}
TPythonDump pyDump;
- // Create group
+ // Create a 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() );
+ SMESHDS_Group* resGroupDS = 0;
+ if ( SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( aResGrp ))
+ resGroupDS = dynamic_cast<SMESHDS_Group*>( grp_i->GetGroupDS() );
+ if ( !resGroupDS )
+ return aResGrp._retn();
+
+ // Fill the group
+ size_t i, nb = toolGroupVec.size();
+ SMDS_ElemIteratorPtr mainElemIt
+ ( new SMDS_IteratorOnIterators
+ < const SMDS_MeshElement*, vector< SMDS_ElemIteratorPtr > >( mainIterVec ));
+ while ( mainElemIt->more() )
+ {
+ const SMDS_MeshElement* e = mainElemIt->next();
+ bool isIn = false;
+ for ( i = 0; ( i < nb && !isIn ); ++i )
+ isIn = toolGroupVec[i]->Contains( e );
- for (int i=0; i<anIds.size(); i++ )
- aResIds[ i ] = anIds[i];
- aResGrp->Add( aResIds );
+ if ( !isIn )
+ resGroupDS->SMDSGroup().Add( e );
+ }
// Update Python script
- pyDump << aResGrp << " = " << _this() << ".CutListOfGroups( "
- << &theMainGroups << ", " << &theToolGroups << ", '"
- << theName << "' )";
+ pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var( _this() )
+ << ".CutListOfGroups( " << theMainGroups
+ << theToolGroups << ", '" << theName << "' )";
SMESH_CATCH( SMESH::throwCorbaException );
}
// Update Python script
- pyDump << aResGrp << " = " << _this() << ".CreateDimGroup( "
- << &theGroups << ", " << theElemType << ", '" << theName << "' )";
+ pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var( _this())
+ << ".CreateDimGroup( "
+ << theGroups << ", " << theElemType << ", '" << theName << "' )";
SMESH_CATCH( SMESH::throwCorbaException );
if ( CORBA::is_nil( theGeomObj ) || theGeomObj->GetType() != GEOM_GROUP )
return;
// group SO
- SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
+ SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
SALOMEDS::SObject_wrap groupSO = _gen_i->ObjectToSObject( study, theGeomObj );
if ( groupSO->_is_nil() )
return;
for ( int i = 0; i < ids->length(); ++i )
groupData._indices.insert( ids[i] );
// SMESH object
- groupData._smeshObject = theSmeshObj;
+ groupData._smeshObject = CORBA::Object::_duplicate( theSmeshObj );
}
//================================================================================
GEOM_Client* geomClient = _gen_i->GetShapeReader();
if ( !geomClient ) return newShape;
- TCollection_AsciiString groupIOR = geomGen->GetStringFromIOR( geomGroup );
- geomClient->RemoveShapeFromBuffer( groupIOR );
+ CORBA::String_var groupIOR = geomGen->GetStringFromIOR( geomGroup );
+ geomClient->RemoveShapeFromBuffer( groupIOR.in() );
newShape = _gen_i->GeomObjectToShape( geomGroup );
}
if ( !submesh->_is_nil() ) // -------------- Sub mesh ---------------------
{
int oldID = submesh->GetId();
- if ( _mapSubMeshIor.find( oldID ) == _mapSubMeshIor.end() )
+ if ( !_mapSubMeshIor.count( oldID ))
continue;
TopoDS_Shape oldShape = _mapSubMesh[oldID]->GetSubShape();
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 ( theGroup->_is_nil() )
return aGroup._retn();
- SMESH_GroupBase_i* aGroupToRem =
- dynamic_cast<SMESH_GroupBase_i*>( SMESH_Gen_i::GetServant( theGroup ).in() );
+ SMESH_GroupBase_i* aGroupToRem = SMESH::DownCast<SMESH_GroupBase_i*>( theGroup );
if ( !aGroupToRem )
return aGroup._retn();
const bool isOnFilter = ( SMESH::DownCast< SMESH_GroupOnFilter_i* > ( theGroup ));
- int anId = aGroupToRem->GetLocalID();
+ const int anId = aGroupToRem->GetLocalID();
if ( !_impl->ConvertToStandalone( anId ) )
return aGroup._retn();
removeGeomGroupData( theGroup );
SMESH_GroupBase_i* aGroupImpl = new SMESH_Group_i( SMESH_Gen_i::GetPOA(), this, anId );
// remove old instance of group from own map
+ { SMESH::SMESH_GroupBase_var var( _mapGroups[anId] ); } // decref CORBA object
_mapGroups.erase( anId );
SALOMEDS::StudyBuilder_var builder;
- SALOMEDS::SObject_wrap aGroupSO;
+ SALOMEDS::SObject_wrap aGroupSO;
SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
if ( !aStudy->_is_nil() ) {
builder = aStudy->NewBuilder();
builder->RemoveObject( chItr->Value() );
// Update Python script
- TPythonDump() << aGroupSO << " = " << _this() << ".ConvertToStandalone( "
- << aGroupSO << " )";
+ TPythonDump() << aGroupSO << " = " << SMESH::SMESH_Mesh_var(_this())
+ << ".ConvertToStandalone( " << aGroupSO << " )";
// change icon of Group on Filter
if ( isOnFilter )
_gen_i->RegisterObject( aGroup );
CORBA::String_var ior = _gen_i->GetORB()->object_to_string( aGroup );
- builder->SetIOR( aGroupSO, ior.in() );
+ builder->SetIOR( aGroupSO, ior.in() ); // == aGroup->Register();
+ //aGroup->Register();
+ aGroupToRem->UnRegister();
SMESH_CATCH( SMESH::throwCorbaException );
SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::createSubMesh( GEOM::GEOM_Object_ptr theSubShapeObject )
{
if(MYDEBUG) MESSAGE( "createSubMesh" );
- TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(theSubShapeObject);
-
+ TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(theSubShapeObject);
::SMESH_subMesh * mySubMesh = _impl->GetSubMesh(myLocSubShape);
- int subMeshId = _impl->GetMeshDS()->ShapeToIndex( myLocSubShape );
- SMESH_subMesh_i *subMeshServant = new SMESH_subMesh_i(myPOA, _gen_i, this, subMeshId);
- SMESH::SMESH_subMesh_var subMesh
- = SMESH::SMESH_subMesh::_narrow(subMeshServant->_this());
+ const int subMeshId = mySubMesh->GetId();
- _mapSubMesh[subMeshId] = mySubMesh;
- _mapSubMesh_i[subMeshId] = subMeshServant;
- _mapSubMeshIor[subMeshId] = SMESH::SMESH_subMesh::_duplicate(subMesh);
+ SMESH_subMesh_i * subMeshServant = new SMESH_subMesh_i(myPOA, _gen_i, this, subMeshId);
+ SMESH::SMESH_subMesh_var subMesh = subMeshServant->_this();
+
+ _mapSubMesh [subMeshId] = mySubMesh;
+ _mapSubMesh_i [subMeshId] = subMeshServant;
+ _mapSubMeshIor[subMeshId] = SMESH::SMESH_subMesh::_duplicate( subMesh );
+
+ subMeshServant->Register();
// 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
// to track changes of GEOM groups
addGeomGroupData( theSubShapeObject, subMesh );
return SMESH::SMESH_subMesh::_duplicate( (*it).second );
}
-
//=============================================================================
/*!
*
if ( theSubMesh->_is_nil() /*|| theSubShapeObject->_is_nil()*/ )
return isHypChanged;
+ const int subMeshId = theSubMesh->GetId();
+
if ( theSubShapeObject->_is_nil() ) // not published shape (IPAL13617)
{
- CORBA::Long shapeId = theSubMesh->GetId();
- if ( _mapSubMesh.find( shapeId ) != _mapSubMesh.end())
+ if ( _mapSubMesh.find( subMeshId ) != _mapSubMesh.end())
{
- TopoDS_Shape S = _mapSubMesh[ shapeId ]->GetSubShape();
+ TopoDS_Shape S = _mapSubMesh[ subMeshId ]->GetSubShape();
if ( !S.IsNull() )
{
list<const SMESHDS_Hypothesis*> hyps = _impl->GetHypothesisList( S );
}
removeGeomGroupData( theSubShapeObject );
}
- int subMeshId = theSubMesh->GetId();
+
+ // remove a servant
+ std::map<int, SMESH_subMesh_i*>::iterator id_smi = _mapSubMesh_i.find( subMeshId );
+ if ( id_smi != _mapSubMesh_i.end() )
+ id_smi->second->UnRegister();
+
+ // remove a CORBA object
+ std::map<int, SMESH::SMESH_subMesh_ptr>::iterator id_smptr = _mapSubMeshIor.find( subMeshId );
+ if ( id_smptr != _mapSubMeshIor.end() )
+ SMESH::SMESH_subMesh_var( id_smptr->second );
_mapSubMesh.erase(subMeshId);
_mapSubMesh_i.erase(subMeshId);
std::set< std::string > presentNames;
std::map<int, SMESH::SMESH_GroupBase_ptr>::const_iterator i_gr = _mapGroups.begin();
for ( ; i_gr != _mapGroups.end(); ++i_gr )
- presentNames.insert( i_gr->second->GetName() );
+ {
+ CORBA::String_var name = i_gr->second->GetName();
+ presentNames.insert( name.in() );
+ }
do {
newName = "noname_Group_" + SMESH_Comment( presentNames.size() + 1 );
} while ( !presentNames.insert( newName ).second );
else
aGroupImpl = new SMESH_Group_i( SMESH_Gen_i::GetPOA(), this, anId );
- aGroup = SMESH::SMESH_GroupBase::_narrow( aGroupImpl->_this() );
+ aGroup = aGroupImpl->_this();
_mapGroups[anId] = SMESH::SMESH_GroupBase::_duplicate( aGroup );
+ aGroupImpl->Register();
// 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() ) {
{
if(MYDEBUG) MESSAGE("SMESH_Mesh_i::removeGroup()" );
if ( _mapGroups.find( theId ) != _mapGroups.end() ) {
- SMESH::SMESH_GroupBase_ptr group = _mapGroups[theId];
+ SMESH::SMESH_GroupBase_var group = _mapGroups[theId];
_mapGroups.erase( theId );
removeGeomGroupData( group );
- if (! _impl->RemoveGroup( theId ))
+ if ( !_impl->RemoveGroup( theId ))
{
// it seems to be a call up from _impl caused by hyp modification (issue 0020918)
RemoveGroup( group );
}
+ group->UnRegister();
}
}
_preMeshInfo->FullLoadFromFile();
// Create MeshEditor
- SMESH_MeshEditor_i *aMeshEditor = new SMESH_MeshEditor_i( this, false );
- aMeshEdVar = aMeshEditor->_this();
+ if ( !_editor )
+ _editor = new SMESH_MeshEditor_i( this, false );
+ aMeshEdVar = _editor->_this();
// Update Python script
- TPythonDump() << aMeshEditor << " = " << _this() << ".GetMeshEditor()";
+ TPythonDump() << _editor << " = "
+ << SMESH::SMESH_Mesh_var(_this()) << ".GetMeshEditor()";
SMESH_CATCH( SMESH::throwCorbaException );
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESH_MeshEditor_i *aMeshEditor = new SMESH_MeshEditor_i( this, true );
- aMeshEdVar = aMeshEditor->_this();
+ if ( !_previewEditor )
+ _previewEditor = new SMESH_MeshEditor_i( this, true );
+ aMeshEdVar = _previewEditor->_this();
SMESH_CATCH( SMESH::throwCorbaException );
_impl->SetAutoColor(theAutoColor);
TPythonDump pyDump; // not to dump group->SetColor() from below code
- pyDump<<_this()<<".SetAutoColor( "<<theAutoColor<<" )";
+ pyDump << SMESH::SMESH_Mesh_var(_this()) <<".SetAutoColor( "<<theAutoColor<<" )";
std::list<SALOMEDS::Color> aReservedColors;
map<int, SMESH::SMESH_GroupBase_ptr>::iterator it = _mapGroups.begin();
}
// Update Python script
// set name of mesh before export
- TPythonDump() << _gen_i << ".SetName(" << _this() << ", '" << aMeshName.c_str() << "')";
+ TPythonDump() << _gen_i << ".SetName("
+ << SMESH::SMESH_Mesh_var(_this()) << ", '" << aMeshName.c_str() << "')";
// check names of groups
checkGroupNames();
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);
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
string aMeshName = prepareMeshNameAndGroups(file, overwrite);
- TPythonDump() << _this() << ".ExportToMEDX( r'"
- << file << "', " << auto_groups << ", " << theVersion << ", " << overwrite << " )";
+ 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 );
- _impl->ExportMED( file, aMeshName.c_str(), auto_groups, theVersion );
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//================================================================================
_preMeshInfo->FullLoadFromFile();
string aMeshName = prepareMeshNameAndGroups(file, true);
- TPythonDump() << _this() << ".ExportSAUV( r'" << file << "', " << auto_groups << " )";
+ TPythonDump() << SMESH::SMESH_Mesh_var( _this())
+ << ".ExportSAUV( r'" << file << "', " << auto_groups << " )";
_impl->ExportSAUV(file, aMeshName.c_str(), auto_groups);
}
// Update Python script
// check names of groups
checkGroupNames();
- TPythonDump() << _this() << ".ExportDAT( r'" << file << "' )";
+ TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportDAT( r'" << file << "' )";
// Perform Export
PrepareForWriting(file);
// Update Python script
// check names of groups
checkGroupNames();
- TPythonDump() << _this() << ".ExportUNV( r'" << file << "' )";
+ TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportUNV( r'" << file << "' )";
// Perform Export
PrepareForWriting(file);
// Update Python script
// check names of groups
checkGroupNames();
- TPythonDump() << _this() << ".ExportSTL( r'" << file << "', " << isascii << " )";
+ TPythonDump() << SMESH::SMESH_Mesh_var(_this())
+ << ".ExportSTL( r'" << file << "', " << isascii << " )";
// Perform Export
PrepareForWriting(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_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;
+ 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 << SMESH::SMESH_Mesh_var(_this()) << ".ExportPartToMED( "
+ << meshPart << ", r'" << file << "', "
+ << auto_groups << ", " << version << ", " << overwrite << ", "
+ << autoDimension << " )";
}
//================================================================================
SMESH_MeshPartDS partDS( meshPart );
_impl->ExportDAT(file,&partDS);
- TPythonDump() << _this() << ".ExportPartToDAT( " << meshPart << ", r'" << file << "' )";
+ TPythonDump() << SMESH::SMESH_Mesh_var(_this())
+ << ".ExportPartToDAT( " << meshPart << ", r'" << file << "' )";
}
//================================================================================
/*!
SMESH_MeshPartDS partDS( meshPart );
_impl->ExportUNV(file, &partDS);
- TPythonDump() << _this() << ".ExportPartToUNV( " << meshPart<< ", r'" << file << "' )";
+ TPythonDump() << SMESH::SMESH_Mesh_var(_this())
+ << ".ExportPartToUNV( " << meshPart<< ", r'" << file << "' )";
}
//================================================================================
/*!
SMESH_MeshPartDS partDS( meshPart );
_impl->ExportSTL(file, isascii, &partDS);
- TPythonDump() << _this() << ".ExportPartToSTL( "
+ TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportPartToSTL( "
<< meshPart<< ", r'" << file << "', " << isascii << ")";
}
SMESH_MeshPartDS partDS( meshPart );
_impl->ExportCGNS(file, &partDS);
- TPythonDump() << _this() << ".ExportCGNS( "
+ TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportCGNS( "
<< meshPart<< ", r'" << file << "', " << overwrite << ")";
#else
THROW_SALOME_CORBA_EXCEPTION("CGNS library is unavailable", SALOME::INTERNAL_ERROR);
SMESH_MeshPartDS partDS( meshPart );
_impl->ExportGMF(file, &partDS, withRequiredGroups);
- TPythonDump() << _this() << ".ExportGMF( "
+ TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportGMF( "
<< meshPart<< ", r'"
<< file << "', "
<< withRequiredGroups << ")";
//=============================================================================
/*!
- * Return implementation of SALOME_MED::MESH interfaces
+ * Return computation progress [0.,1]
*/
//=============================================================================
-SALOME_MED::MESH_ptr SMESH_Mesh_i::GetMEDMesh()throw(SALOME::SALOME_Exception)
+CORBA::Double SMESH_Mesh_i::GetComputeProgress()
{
- Unexpect aCatch(SALOME_SalomeException);
- if ( _preMeshInfo )
- _preMeshInfo->FullLoadFromFile();
+ SMESH_TRY;
- SMESH_MEDMesh_i *aMedMesh = new SMESH_MEDMesh_i(this);
- SALOME_MED::MESH_var aMesh = aMedMesh->_this();
- return aMesh._retn();
-}
+ 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::long_array* SMESH_Mesh_i::GetElementsId()
- throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
int i = 0;
- SMDS_ElemIteratorPtr anIt = aSMESHDS_Mesh->elementsIterator();
- while ( i < nbElements && anIt->more() ) {
- const SMDS_MeshElement* anElem = anIt->next();
- if ( theElemType == SMESH::ALL || anElem->GetType() == (SMDSAbs_ElementType)theElemType )
- aResult[i++] = anElem->GetID();
- }
+ SMDS_ElemIteratorPtr anIt = aSMESHDS_Mesh->elementsIterator( (SMDSAbs_ElementType)theElemType );
+ while ( i < nbElements && anIt->more() )
+ aResult[i++] = anIt->next()->GetID();
aResult->length( i );
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
return aResult._retn();
}
-
//=============================================================================
/*!
* Returns ID of nodes for given submesh
* returns only nodes on shapes.
*/
//=============================================================================
+
SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID,
CORBA::Boolean all)
throw (SALOME::SALOME_Exception)
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)
+{
+ 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=*/true ))
+ {
+ 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.
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::Study_var study = _gen_i->GetCurrentStudy();
+ SMESH::SMESH_Mesh_var mesh = _this();
+ 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;
+
+ 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()
{
- SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
+ SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
+ SMESH::SMESH_Mesh_var aMesh = _this();
set<int> addedIDs;
::SMESH_Mesh::GroupIteratorPtr groupIt = _impl->GetGroups();
aGroupImpl = new SMESH_Group_i( SMESH_Gen_i::GetPOA(), this, anId );
}
- SMESH::SMESH_GroupBase_var groupVar =
- SMESH::SMESH_GroupBase::_narrow( aGroupImpl->_this() );
+ SMESH::SMESH_GroupBase_var groupVar = aGroupImpl->_this();
_mapGroups[anId] = SMESH::SMESH_GroupBase::_duplicate( groupVar );
+ aGroupImpl->Register();
// 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() ) {
GEOM::GEOM_Object_var shapeVar = _gen_i->ShapeToGeomObject( shape );
- _gen_i->PublishGroup( aStudy, _this(), groupVar, shapeVar, groupVar->GetName());
+ _gen_i->PublishGroup( aStudy, aMesh, groupVar, shapeVar, group->GetName());
}
}
if ( !addedIDs.empty() )
{
map<int, SMESH::SMESH_GroupBase_ptr>::iterator it = _mapGroups.find(*id);
int i = std::distance( _mapGroups.begin(), it );
- TPythonDump() << it->second << " = " << _this() << ".GetGroups()[ "<< i << " ]";
+ TPythonDump() << it->second << " = " << aMesh << ".GetGroups()[ "<< i << " ]";
}
}
}
*/
//=============================================================================
-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;
}
//=============================================================================
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 );
}
//=============================================================================
* \brief Returns list of notebook variables used for Mesh operations separated by ":" symbol
*/
//=============================================================================
+
char* SMESH_Mesh_i::GetParameters()
{
- SMESH_Gen_i *gen = SMESH_Gen_i::GetSMESHGen();
- return CORBA::string_dup(gen->GetParameters(SMESH::SMESH_Mesh::_narrow(_this())));
+ return SMESH_Gen_i::GetSMESHGen()->GetParameters( SMESH::SMESH_Mesh_var( _this()) );
}
//=============================================================================
SMESH::string_array_var aResult = new SMESH::string_array();
SMESH_Gen_i *gen = SMESH_Gen_i::GetSMESHGen();
if(gen) {
- char *aParameters = GetParameters();
- SALOMEDS::Study_var aStudy = gen->GetCurrentStudy();
- if(!aStudy->_is_nil()) {
+ CORBA::String_var aParameters = GetParameters();
+ SALOMEDS::Study_var aStudy = gen->GetCurrentStudy();
+ if ( !aStudy->_is_nil()) {
SALOMEDS::ListOfListOfStrings_var aSections = aStudy->ParseVariables(aParameters);
if(aSections->length() > 0) {
SALOMEDS::ListOfStrings aVars = aSections[aSections->length()-1];
//=============================================================================
/*!
- * \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
*/
//=============================================================================
theInfo[ theItr->next()->GetEntityType() ]++;
}
+//=============================================================================
+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
+ */
+//=============================================================================
+
+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
//=============================================================================
//-----------------------------------------------------------------------------
//! 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 );
const TopoDS_Shape& theShape)
{
_dim = theDim;
- _ownDim = (int)SMESH_Gen::GetShapeDim(theShape);
+ _ownDim = SMESH_Gen::GetShapeDim(theShape);
if (_dim >= _ownDim)
_shapeMap.Add( theShape );
else {
::SMESH_Mesh& mesh = GetImpl();
TPythonDump aPythonDump; // prevent dump of called methods
- aPythonDump << "isDone = " << _this() << ".SetMeshOrder( [ ";
+ aPythonDump << "isDone = " << SMESH::SMESH_Mesh_var(_this()) << ".SetMeshOrder( [ ";
TListOfListOfInt subMeshOrder;
for ( int i = 0, n = theSubMeshArray.length(); i < n; i++ )
if ( theIsDump ) {
// finilise python dump
aPythonDump << " ]";
- aPythonDump << " = " << _this() << ".GetMeshOrder()";
+ aPythonDump << " = " << SMESH::SMESH_Mesh_var(_this()) << ".GetMeshOrder()";
}
}
