#include "DriverMED_W_Field.h"
#include "DriverMED_W_SMESHDS_Mesh.h"
#include "MED_Factory.hxx"
+#include "SMDS_LinearEdge.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_StdIterator.hxx"
#include "SMDS_VolumeTool.hxx"
#include "SMESHDS_Command.hxx"
#include "SMESHDS_CommandType.hxx"
}
_mapHypo.clear();
- // clear cashed shapes if no more meshes remain; (the cash is blame,
+ // clear cached shapes if no more meshes remain; (the cache is blame,
// together with publishing, of spent time increasing in issue 22874)
if ( _impl->NbMeshes() == 1 )
_gen_i->GetShapeReader()->ClearClientBuffer();
}
TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".Clear()";
+
+ SMESH::SMESH_Mesh_var mesh = _this();
+ _gen_i->UpdateIcons( mesh );
}
//================================================================================
CreateGroupServants();
+ _medFileInfo = new SMESH::MedFileInfo();
+ _medFileInfo->fileName = theFileName;
+ _medFileInfo->major = 0;
+ _medFileInfo->minor = 0;
+ _medFileInfo->release = 0;
+ _medFileInfo->fileSize = SMESH_File( theFileName ).size();
+
return ConvertDriverMEDReadStatus(status);
}
+//================================================================================
+/*!
+ * \brief Return string representation of a MED file version comprising nbDigits
+ */
+//================================================================================
+
+char* SMESH_Mesh_i::GetVersionString(CORBA::Long minor, CORBA::Short nbDigits)
+{
+ string ver = DriverMED_W_SMESHDS_Mesh::GetVersionString(minor,
+ nbDigits);
+ return CORBA::string_dup( ver.c_str() );
+}
+
+//================================================================================
+/*!
+ * Return the list of med versions compatibles for write/append,
+ * encoded in 10*major+minor (for instance, code for med 3.2.1 is 32)
+ */
+//================================================================================
+SMESH::long_array* SMESH_Mesh_i::GetMEDVersionsCompatibleForAppend()
+{
+ SMESH::long_array_var aResult = new SMESH::long_array();
+ std::vector<int> mvok = MED::GetMEDVersionsAppendCompatible();
+ long nbver = mvok.size();
+ aResult->length( nbver );
+ for ( int i = 0; i < nbver; i++ )
+ aResult[i] = mvok[i];
+ return aResult._retn();
+}
+
//=============================================================================
/*!
* ImportUNVFile
CreateGroupServants();
+ _medFileInfo = new SMESH::MedFileInfo();
+ _medFileInfo->fileName = theFileName;
+ _medFileInfo->major = 0;
+ _medFileInfo->minor = 0;
+ _medFileInfo->release = 0;
+ _medFileInfo->fileSize = SMESH_File( theFileName ).size();
+
SMESH_CATCH( SMESH::throwCorbaException );
return 1;
SALOMEDS::SObject_wrap meshSO = _gen_i->ObjectToSObject( _this() );
_gen_i->SetName( meshSO, name.c_str() );
}
+ _medFileInfo = new SMESH::MedFileInfo();
+ _medFileInfo->fileName = theFileName;
+ _medFileInfo->major = 0;
+ _medFileInfo->minor = 0;
+ _medFileInfo->release = 0;
+ _medFileInfo->fileSize = SMESH_File( theFileName ).size();
SMESH_CATCH( SMESH::throwCorbaException );
error = _impl->GMFToMesh( theFileName, theMakeRequiredGroups );
+ _medFileInfo = new SMESH::MedFileInfo();
+ _medFileInfo->fileName = theFileName;
+ _medFileInfo->major = 0;
+ _medFileInfo->minor = 0;
+ _medFileInfo->release = 0;
+ _medFileInfo->fileSize = SMESH_File( theFileName ).size();
+
SMESH_CATCH( exceptionToComputeError );
#undef SMESH_CAUGHT
#define SMESH_CAUGHT
switch (theStatus) {
RETURNCASE( HYP_OK );
RETURNCASE( HYP_MISSING );
- RETURNCASE( HYP_CONCURENT );
+ RETURNCASE( HYP_CONCURRENT );
RETURNCASE( HYP_BAD_PARAMETER );
RETURNCASE( HYP_HIDDEN_ALGO );
RETURNCASE( HYP_HIDING_ALGO );
if ( !SMESH_Hypothesis::IsStatusFatal(status) )
{
_gen_i->AddHypothesisToShape( mesh, aSubShape, anHyp );
+ _gen_i->UpdateIcons( mesh );
}
if(MYDEBUG) MESSAGE( " AddHypothesis(): status = " << status );
if ( !SMESH_Hypothesis::IsStatusFatal(status) )
{
_gen_i->RemoveHypothesisFromShape( mesh, aSubShape, anHyp );
+ _gen_i->UpdateIcons( mesh );
}
// Update Python script
if(_impl->HasShapeToMesh())
return;
vector<int> nodeIds; // to remove nodes becoming free
- if ( !theGroup->IsEmpty() )
+ bool isNodal = ( theGroup->GetType() == SMESH::NODE );
+ if ( !isNodal && !theGroup->IsEmpty() )
{
CORBA::Long elemID = theGroup->GetID( 1 );
int nbElemNodes = GetElemNbNodes( elemID );
nodeIds.reserve( theGroup->Size() * nbElemNodes );
}
- // Remove contents
+ // Retrieve contents
SMESH::SMESH_IDSource_var idSrc = SMESH::SMESH_IDSource::_narrow( theGroup );
SMDS_ElemIteratorPtr elemIt = GetElements( idSrc, theGroup->GetType() );
- while ( elemIt->more() )
- {
- const SMDS_MeshElement* e = elemIt->next();
+ SMDS_StdIterator< const SMDS_MeshElement*, SMDS_ElemIteratorPtr > elemBeg( elemIt ), elemEnd;
+ std::vector< const SMDS_MeshElement* > elems( theGroup->Size() );
+ elems.assign( elemBeg, elemEnd );
- SMDS_ElemIteratorPtr nIt = e->nodesIterator();
- while ( nIt->more() )
- nodeIds.push_back( nIt->next()->GetID() );
+ TPythonDump pyDump; // Suppress dump from RemoveGroup()
- _impl->GetMeshDS()->RemoveElement( e );
+ // Remove group
+ RemoveGroup( theGroup );
+
+ // Remove contents
+ for ( size_t i = 0; i < elems.size(); ++i )
+ {
+ // if ( !_impl->GetMeshDS()->Contains( elems[i] ))
+ // continue;
+ if ( !isNodal )
+ {
+ for ( SMDS_ElemIteratorPtr nIt = elems[i]->nodesIterator(); nIt->more(); )
+ nodeIds.push_back( nIt->next()->GetID() );
+
+ _impl->GetMeshDS()->RemoveFreeElement( elems[i], /*sm=*/0 );
+ }
+ else
+ {
+ _impl->GetMeshDS()->RemoveElement( elems[i] );
+ }
}
// Remove free nodes
- if ( theGroup->GetType() != SMESH::NODE )
- for ( size_t i = 0 ; i < nodeIds.size(); ++i )
- if ( const SMDS_MeshNode* n = _impl->GetMeshDS()->FindNode( nodeIds[i] ))
- if ( n->NbInverseElements() == 0 )
- _impl->GetMeshDS()->RemoveFreeNode( n, /*sm=*/0 );
-
- TPythonDump pyDump; // Suppress dump from RemoveGroup()
+ for ( size_t i = 0 ; i < nodeIds.size(); ++i )
+ if ( const SMDS_MeshNode* n = _impl->GetMeshDS()->FindNode( nodeIds[i] ))
+ if ( n->NbInverseElements() == 0 )
+ _impl->GetMeshDS()->RemoveFreeNode( n, /*sm=*/0 );
// Update Python script (theGroup must be alive for this)
pyDump << SMESH::SMESH_Mesh_var(_this())
<< ".RemoveGroupWithContents( " << theGroup << " )";
- // Remove group
- RemoveGroup( theGroup );
-
SMESH_CATCH( SMESH::throwCorbaException );
}
/*!
* \brief Update objects depending on changed geom groups
*
- * NPAL16168: geometrical group edition from a submesh don't modifiy mesh computation
+ * NPAL16168: geometrical group edition from a submesh don't modify mesh computation
* issue 0020210: Update of a smesh group after modification of the associated geom group
*/
//=============================================================================
if(MYDEBUG) MESSAGE( "createSubMesh" );
TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(theSubShapeObject);
::SMESH_subMesh * mySubMesh = _impl->GetSubMesh(myLocSubShape);
- const int subMeshId = mySubMesh->GetId();
+ int subMeshId = 0;
+
+ SMESH_subMesh_i * subMeshServant;
+ if ( mySubMesh )
+ {
+ subMeshId = mySubMesh->GetId();
+ subMeshServant = new SMESH_subMesh_i(myPOA, _gen_i, this, subMeshId);
+ }
+ else // "invalid sub-mesh"
+ {
+ // The invalid sub-mesh is created for the case where a valid sub-shape not found
+ // by SMESH_Gen_i::CopyMeshWithGeom(). The invalid sub-mesh has GetId() < 0.
+ if ( _mapSubMesh.empty() )
+ subMeshId = -1;
+ else
+ subMeshId = _mapSubMesh.begin()->first - 1;
+ subMeshServant = new SMESH_Invalid_subMesh_i(myPOA, _gen_i, this, subMeshId, theSubShapeObject);
+ }
- SMESH_subMesh_i * subMeshServant = new SMESH_subMesh_i(myPOA, _gen_i, this, subMeshId);
SMESH::SMESH_subMesh_var subMesh = subMeshServant->_this();
_mapSubMesh [subMeshId] = mySubMesh;
else { nextId = 0; } // avoid "unused variable" warning
// to track changes of GEOM groups
- addGeomGroupData( theSubShapeObject, subMesh );
+ if ( subMeshId > 0 )
+ addGeomGroupData( theSubShapeObject, subMesh );
return subMesh._retn();
}
if ( theSubShapeObject->_is_nil() ) // not published shape (IPAL13617)
{
- if ( _mapSubMesh.find( subMeshId ) != _mapSubMesh.end())
+ if ( _mapSubMesh.find( subMeshId ) != _mapSubMesh.end() &&
+ _mapSubMesh[ subMeshId ])
{
TopoDS_Shape S = _mapSubMesh[ subMeshId ]->GetSubShape();
if ( !S.IsNull() )
const SMESH_PredicatePtr& thePredicate )
{
std::string newName;
- if ( !theName || strlen( theName ) == 0 )
+ if ( !theName || !theName[0] )
{
std::set< std::string > presentNames;
std::map<int, SMESH::SMESH_GroupBase_ptr>::const_iterator i_gr = _mapGroups.begin();
SMESH_Mesh_i* _mesh;
TCallUp_i(SMESH_Mesh_i* mesh):_mesh(mesh) {}
virtual void RemoveGroup (const int theGroupID) { _mesh->removeGroup( theGroupID ); }
- virtual void HypothesisModified () { _mesh->onHypothesisModified(); }
+ virtual void HypothesisModified (int theHypID) { _mesh->onHypothesisModified( theHypID ); }
virtual void Load () { _mesh->Load(); }
};
}
*/
//================================================================================
-void SMESH_Mesh_i::onHypothesisModified()
+void SMESH_Mesh_i::onHypothesisModified(int theHypID)
{
if ( _preMeshInfo )
_preMeshInfo->ForgetOrLoad();
+
+ SMESH::SMESH_Mesh_var mesh = _this();
+ _gen_i->UpdateIcons( mesh );
+
+ // mark a hypothesis as valid after edition
+ SALOMEDS::SComponent_wrap smeshComp = _gen_i->PublishComponent();
+ SALOMEDS::SObject_wrap hypRoot;
+ if ( !smeshComp->_is_nil() &&
+ smeshComp->FindSubObject( _gen_i->GetHypothesisRootTag(), hypRoot.inout() ))
+ {
+ SALOMEDS::ChildIterator_wrap anIter = _gen_i->getStudyServant()->NewChildIterator( hypRoot );
+ for ( ; anIter->More(); anIter->Next() )
+ {
+ SALOMEDS::SObject_wrap hypSO = anIter->Value();
+ CORBA::Object_var obj = _gen_i->SObjectToObject( hypSO );
+ SMESH::SMESH_Hypothesis_var hyp = SMESH::SMESH_Hypothesis::_narrow( obj );
+ if ( !hyp->_is_nil() && hyp->GetId() == theHypID )
+ _gen_i->HighLightInvalid( hyp, false );
+ }
+ }
}
//=============================================================================
void SMESH_Mesh_i::ExportMED(const char* file,
CORBA::Boolean auto_groups,
+ CORBA::Long version,
CORBA::Boolean overwrite,
CORBA::Boolean autoDimension)
throw(SALOME::SALOME_Exception)
{
- //MESSAGE("SMESH::MED_VERSION:"<< theVersion);
+ //MESSAGE("MED minor version: "<< minor);
SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
string aMeshName = prepareMeshNameAndGroups(file, overwrite);
- _impl->ExportMED( file, aMeshName.c_str(), auto_groups, 0, autoDimension );
+ _impl->ExportMED( file, aMeshName.c_str(), auto_groups, version, 0, autoDimension );
TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportMED( r'"
- << file << "', " << auto_groups << ", "
- << overwrite << ", "
- << autoDimension << " )";
+ << file << "', "
+ << "auto_groups=" <<auto_groups << ", "
+ << "minor=" << version << ", "
+ << "overwrite=" << overwrite << ", "
+ << "meshPart=None, "
+ << "autoDimension=" << autoDimension << " )";
SMESH_CATCH( SMESH::throwCorbaException );
}
void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
CORBA::Boolean auto_groups,
+ CORBA::Long version,
CORBA::Boolean overwrite,
CORBA::Boolean autoDimension,
const GEOM::ListOfFields& fields,
const char* geomAssocFields)
throw (SALOME::SALOME_Exception)
{
+ MESSAGE("MED version: "<< version);
SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
SMESH::DownCast< SMESH_Mesh_i* >( meshPart ))
{
aMeshName = prepareMeshNameAndGroups(file, overwrite);
- _impl->ExportMED( file, aMeshName.c_str(), auto_groups,
+ _impl->ExportMED( file, aMeshName.c_str(), auto_groups, version,
0, autoDimension, /*addODOnVertices=*/have0dField);
meshDS = _impl->GetMeshDS();
}
}
SMESH_MeshPartDS* partDS = new SMESH_MeshPartDS( meshPart );
- _impl->ExportMED( file, aMeshName.c_str(), auto_groups,
+ _impl->ExportMED( file, aMeshName.c_str(), auto_groups, version,
partDS, autoDimension, /*addODOnVertices=*/have0dField);
meshDS = tmpDSDeleter._obj = partDS;
}
goList[i] = gbo;
}
TPythonDump() << _this() << ".ExportPartToMED( "
- << meshPart << ", r'" << file << "', "
- << auto_groups << ", " << overwrite << ", "
- << autoDimension << ", " << goList
- << ", '" << ( geomAssocFields ? geomAssocFields : "" ) << "'" << " )";
+ << meshPart << ", r'"
+ << file << "', "
+ << auto_groups << ", "
+ << version << ", "
+ << overwrite << ", "
+ << autoDimension << ", "
+ << goList << ", '"
+ << ( geomAssocFields ? geomAssocFields : "" ) << "'" << " )";
SMESH_CATCH( SMESH::throwCorbaException );
}
_preMeshInfo->FullLoadFromFile();
SMESH::long_array_var aResult = new SMESH::long_array();
- SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
+ SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
- if ( aSMESHDS_Mesh == NULL )
+ if ( aMeshDS == NULL )
return aResult._retn();
long nbNodes = NbNodes();
aResult->length( nbNodes );
- SMDS_NodeIteratorPtr anIt = aSMESHDS_Mesh->nodesIterator(/*idInceasingOrder=*/true);
+ SMDS_NodeIteratorPtr anIt = aMeshDS->nodesIterator();
for ( int i = 0, n = nbNodes; i < n && anIt->more(); i++ )
aResult[i] = anIt->next()->GetID();
_preMeshInfo->FullLoadFromFile();
SMESH::double_array_var aResult = new SMESH::double_array();
- SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
- if ( aSMESHDS_Mesh == NULL )
+ SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+ if ( aMeshDS == NULL )
return aResult._retn();
// find node
- const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(id);
+ const SMDS_MeshNode* aNode = aMeshDS->FindNode(id);
if(!aNode)
return aResult._retn();
_preMeshInfo->FullLoadFromFile();
SMESH::long_array_var aResult = new SMESH::long_array();
- SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
- if ( aSMESHDS_Mesh == NULL )
+ SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+ if ( aMeshDS == NULL )
return aResult._retn();
// find node
- const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(id);
+ const SMDS_MeshNode* aNode = aMeshDS->FindNode(id);
if(!aNode)
return aResult._retn();
case SMDS_TOP_EDGE:
aNodePosition->shapeType = GEOM::EDGE;
aNodePosition->params.length(1);
- aNodePosition->params[0] =
- static_cast<SMDS_EdgePosition*>( pos )->GetUParameter();
+ aNodePosition->params[0] = SMDS_EdgePositionPtr( pos )->GetUParameter();
break;
- case SMDS_TOP_FACE:
+ case SMDS_TOP_FACE: {
+ SMDS_FacePositionPtr fPos = pos;
aNodePosition->shapeType = GEOM::FACE;
aNodePosition->params.length(2);
- aNodePosition->params[0] =
- static_cast<SMDS_FacePosition*>( pos )->GetUParameter();
- aNodePosition->params[1] =
- static_cast<SMDS_FacePosition*>( pos )->GetVParameter();
+ aNodePosition->params[0] = fPos->GetUParameter();
+ aNodePosition->params[1] = fPos->GetVParameter();
break;
+ }
case SMDS_TOP_VERTEX:
aNodePosition->shapeType = GEOM::VERTEX;
break;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
- if ( aSMESHDS_Mesh == NULL )
+ SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+ if ( aMeshDS == NULL )
return -1;
// try to find node
- const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(id);
+ const SMDS_MeshNode* aNode = aMeshDS->FindNode(id);
if(aNode) {
return aNode->getshapeId();
}
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
- if ( aSMESHDS_Mesh == NULL )
+ SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+ if ( aMeshDS == NULL )
return -1;
// try to find element
- const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
+ const SMDS_MeshElement* elem = aMeshDS->FindElement(id);
if(!elem)
return -1;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
- if ( aSMESHDS_Mesh == NULL ) return -1;
+ SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+ if ( aMeshDS == NULL ) return -1;
// try to find element
- const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
+ const SMDS_MeshElement* elem = aMeshDS->FindElement(id);
if(!elem) return -1;
return elem->NbNodes();
}
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
- if ( aSMESHDS_Mesh == NULL ) return -1;
- const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
+ SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+ if ( aMeshDS == NULL ) return -1;
+ const SMDS_MeshElement* elem = aMeshDS->FindElement(id);
if(!elem) return -1;
if( index>=elem->NbNodes() || index<0 ) return -1;
return elem->GetNode(index)->GetID();
_preMeshInfo->FullLoadFromFile();
SMESH::long_array_var aResult = new SMESH::long_array();
- if ( SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS() )
+ if ( SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS() )
{
- if ( const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id) )
+ if ( const SMDS_MeshElement* elem = aMeshDS->FindElement(id) )
{
aResult->length( elem->NbNodes() );
for ( int i = 0; i < elem->NbNodes(); ++i )
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
- if ( aSMESHDS_Mesh == NULL ) return false;
+ SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+ if ( aMeshDS == NULL ) return false;
// try to find node
- const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(idn);
+ const SMDS_MeshNode* aNode = aMeshDS->FindNode(idn);
if(!aNode) return false;
// try to find element
- const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(ide);
+ const SMDS_MeshElement* elem = aMeshDS->FindElement(ide);
if(!elem) return false;
return elem->IsMediumNode(aNode);
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
- if ( aSMESHDS_Mesh == NULL ) return false;
+ SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+ if ( aMeshDS == NULL ) return false;
// try to find node
- const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(idn);
+ const SMDS_MeshNode* aNode = aMeshDS->FindNode(idn);
if(!aNode) return false;
SMESH_MesherHelper aHelper( *(_impl) );
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
- if ( aSMESHDS_Mesh == NULL ) return -1;
- const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
+ SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+ if ( aMeshDS == NULL ) return -1;
+ const SMDS_MeshElement* elem = aMeshDS->FindElement(id);
if(!elem) return -1;
return elem->NbEdges();
}
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
- if ( aSMESHDS_Mesh == NULL ) return -1;
- const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
+ SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+ if ( aMeshDS == NULL ) return -1;
+ const SMDS_MeshElement* elem = aMeshDS->FindElement(id);
if(!elem) return -1;
return elem->NbFaces();
}
_preMeshInfo->FullLoadFromFile();
SMESH::long_array_var aResult = new SMESH::long_array();
- if ( SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS() )
+ if ( SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS() )
{
- if ( const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(elemId) )
+ if ( const SMDS_MeshElement* elem = aMeshDS->FindElement(elemId) )
{
SMDS_VolumeTool vtool( elem );
if ( faceIndex < vtool.NbFaces() )
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
- if ( aSMESHDS_Mesh == NULL ) return false;
- const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
+ SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+ if ( aMeshDS == NULL ) return false;
+ const SMDS_MeshElement* elem = aMeshDS->FindElement(id);
if(!elem) return false;
return elem->IsPoly();
}
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
- if ( aSMESHDS_Mesh == NULL ) return false;
- const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
+ SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+ if ( aMeshDS == NULL ) return false;
+ const SMDS_MeshElement* elem = aMeshDS->FindElement(id);
if(!elem) return false;
return elem->IsQuadratic();
}
_preMeshInfo->FullLoadFromFile();
if ( const SMDS_BallElement* ball =
- dynamic_cast<const SMDS_BallElement*>( _impl->GetMeshDS()->FindElement( id )))
+ SMDS_Mesh::DownCast<SMDS_BallElement>( _impl->GetMeshDS()->FindElement( id )))
return ball->GetDiameter();
return 0;
_preMeshInfo->FullLoadFromFile();
SMESH::double_array_var aResult = new SMESH::double_array();
- SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
- if ( aSMESHDS_Mesh == NULL )
+ SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+ if ( aMeshDS == NULL )
return aResult._retn();
- const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
+ const SMDS_MeshElement* elem = aMeshDS->FindElement(id);
if(!elem)
return aResult._retn();
{
// compute error
SMESH_ComputeErrorPtr error = sm->GetComputeError();
- if ( error && !error->myBadElements.empty())
+ if ( error && error->HasBadElems() )
{
// 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();
+ const list<const SMDS_MeshElement*>& badElems =
+ static_cast<SMESH_BadInputElements*>( error.get() )->myBadElements;
+ list<const SMDS_MeshElement*>::const_iterator elemIt = badElems.begin();
+ list<const SMDS_MeshElement*>::const_iterator elemEnd = badElems.end();
for ( ; elemIt != elemEnd; ++elemIt )
{
const SMDS_MeshElement* elem = *elemIt;
}
}
+//=============================================================================
+/*!
+ * \brief Return true if all sub-meshes are computed OK - to update an icon
+ */
+//=============================================================================
+
+bool SMESH_Mesh_i::IsComputedOK()
+{
+ return _impl->IsComputedOK();
+}
+
//=============================================================================
/*!
* \brief Return groups cantained in _mapGroups by their IDs
return res._retn();
}
+//=======================================================================
+//function : FileInfoToString
+//purpose : Persistence of file info
+//=======================================================================
+
+std::string SMESH_Mesh_i::FileInfoToString()
+{
+ std::string s;
+ if ( &_medFileInfo.in() && _medFileInfo->fileName[0] )
+ {
+ s = SMESH_Comment( _medFileInfo->fileSize )
+ << " " << _medFileInfo->major
+ << " " << _medFileInfo->minor
+ << " " << _medFileInfo->release
+ << " " << _medFileInfo->fileName;
+ }
+ return s;
+}
+
+//=======================================================================
+//function : FileInfoFromString
+//purpose : Persistence of file info
+//=======================================================================
+
+void SMESH_Mesh_i::FileInfoFromString(const std::string& info)
+{
+ std::string size, major, minor, release, fileName;
+ std::istringstream is(info);
+ is >> size >> major >> minor >> release;
+ fileName = info.data() + ( size.size() + 1 +
+ major.size() + 1 +
+ minor.size() + 1 +
+ release.size()+ 1 );
+
+ _medFileInfo = new SMESH::MedFileInfo();
+ _medFileInfo->fileName = fileName.c_str();
+ _medFileInfo->fileSize = atoi( size.c_str() );
+ _medFileInfo->major = atoi( major.c_str() );
+ _medFileInfo->minor = atoi( minor.c_str() );
+ _medFileInfo->release = atoi( release.c_str() );
+}
+
//=============================================================================
/*!
* \brief Pass names of mesh groups from study to mesh DS
{
SALOMEDS::TMPFile_var SeqFile;
if ( SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS() ) {
- SMDS_UnstructuredGrid* aGrid = aMeshDS->getGrid();
+ SMDS_UnstructuredGrid* aGrid = aMeshDS->GetGrid();
if(aGrid) {
vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New();
aWriter->WriteToOutputStringOn();
{
const SMDS_MeshElement* res = _node;
_node = 0;
- while (( _elemIter->more() || _nodeIter->more() ) && !_node )
+ while ( !_node && ( _elemIter->more() || _nodeIter->more() ))
{
if ( _nodeIter->more() )
{
//-----------------------------------------------------------------------------
/*!
- * \brief Internal structure used to find concurent submeshes
+ * \brief Internal structure used to find concurrent submeshes
*
- * It represents a pair < submesh, concurent dimension >, where
- * 'concurrent dimension' is dimension of shape where the submesh can concurent
+ * It represents a pair < submesh, concurrent dimension >, where
+ * 'concurrent dimension' is dimension of shape where the submesh can concurrent
* with another submesh. In other words, it is dimension of a hypothesis assigned
* to submesh.
*/
class SMESH_DimHyp
{
public:
- //! fileds
+ //! fields
int _dim; //!< a dimension the algo can build (concurrent dimension)
int _ownDim; //!< dimension of shape of _subMesh (>=_dim)
TopTools_MapOfShape _shapeMap;
removeDimHyps(dimHypListArr);
- // now, minimise the number of concurrent groups
+ // now, minimize the number of concurrent groups
// Here we assume that lists of submeshes can have same submesh
// in case of multi-dimension algorithms, as result
// list with common submesh has to be united into one list
mesh.SetMeshOrder( subMeshOrder );
res = true;
+ SMESH::SMESH_Mesh_var me = _this();
+ _gen_i->UpdateIcons( me );
+
return res;
}
continue;
if ( theIsDump )
aPythonDump << "[ ";
- // convert shape indeces into interfaces
+ // convert shape indices into interfaces
SMESH::submesh_array_var aResSubSet = new SMESH::submesh_array();
aResSubSet->length(aSubOrder.size());
TListOfInt::const_iterator subIt = aSubOrder.begin();
}
}
+namespace // utils used by SMESH_MeshPartDS
+{
+ /*!
+ * \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 Element holing its ID only
+ */
+ struct TElemID : public SMDS_LinearEdge
+ {
+ TElemID(int ID) : SMDS_LinearEdge(0,0) { setID( ID ); }
+ };
+}
+
//================================================================================
//
// Implementation of SMESH_MeshPartDS
SMDS_MeshElement::GeomFilter
> TIter;
- SMDSAbs_ElementType type = SMDS_MeshCell::toSmdsType( geomType );
+ SMDSAbs_ElementType type = SMDS_MeshCell::ElemType( geomType );
return SMDS_ElemIteratorPtr( new TIter( _elements[type].begin(),
_elements[type].end(),
SMDS_MeshElement::EntityFilter
> TIter;
- SMDSAbs_ElementType type = SMDS_MeshCell::toSmdsType( entity );
+ SMDSAbs_ElementType type = SMDS_MeshCell::ElemType( entity );
return SMDS_ElemIteratorPtr( new TIter( _elements[type].begin(),
_elements[type].end(),
}
// -------------------------------------------------------------------------------------
#define _GET_ITER_DEFINE( iterType, methName, elem, elemType) \
- iterType SMESH_MeshPartDS::methName( bool idInceasingOrder) const \
+ iterType SMESH_MeshPartDS::methName() const \
{ \
typedef SMDS_SetIterator<const elem*, TIDSortedElemSet::const_iterator > TIter; \
- return _meshDS ? _meshDS->methName(idInceasingOrder) : iterType \
+ return _meshDS ? _meshDS->methName() : iterType \
( new TIter( _elements[elemType].begin(), _elements[elemType].end() )); \
}
// -------------------------------------------------------------------------------------