#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();
int major, minor, release;
- if( !MED::getMEDVersion( theFileName, major, minor, release ) )
- major = minor = release = -1;
+ major = minor = release = 0;
+ MED::GetMEDVersion(theFileName, major, minor, release);
_medFileInfo = new SMESH::MedFileInfo();
_medFileInfo->fileName = theFileName;
_medFileInfo->fileSize = 0;
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);
}
*/
//================================================================================
-char* SMESH_Mesh_i::GetVersionString(SMESH::MED_VERSION version, CORBA::Short nbDigits)
+char* SMESH_Mesh_i::GetVersionString(CORBA::Long minor, CORBA::Short nbDigits)
{
- string ver = DriverMED_W_SMESHDS_Mesh::GetVersionString(MED::EVersion(version),
+ string ver = DriverMED_W_SMESHDS_Mesh::GetVersionString(minor,
nbDigits);
return CORBA::string_dup( ver.c_str() );
}
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 );
+
+ TPythonDump pyDump; // Suppress dump from RemoveGroup()
- SMDS_ElemIteratorPtr nIt = e->nodesIterator();
- while ( nIt->more() )
- nodeIds.push_back( nIt->next()->GetID() );
+ // 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()->RemoveElement( e );
+ _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
*/
//=============================================================================
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();
{
if ( _preMeshInfo )
_preMeshInfo->ForgetOrLoad();
+
+ SMESH::SMESH_Mesh_var mesh = _this();
+ _gen_i->UpdateIcons( mesh );
}
//=============================================================================
//================================================================================
/*!
- * \brief Export to med file
+ * \brief Export to MED file
*/
//================================================================================
-void SMESH_Mesh_i::ExportToMEDX (const char* file,
- CORBA::Boolean auto_groups,
- SMESH::MED_VERSION theVersion,
- CORBA::Boolean overwrite,
- CORBA::Boolean autoDimension)
+void SMESH_Mesh_i::ExportMED(const char* file,
+ CORBA::Boolean auto_groups,
+ CORBA::Long minor,
+ CORBA::Boolean overwrite,
+ CORBA::Boolean autoDimension)
throw(SALOME::SALOME_Exception)
{
+ //MESSAGE("MED minor version: "<< minor);
SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
string aMeshName = prepareMeshNameAndGroups(file, overwrite);
- _impl->ExportMED( file, aMeshName.c_str(), auto_groups, theVersion, 0, autoDimension );
+ _impl->ExportMED( file, aMeshName.c_str(), auto_groups, minor, 0, autoDimension );
- TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportToMEDX( r'"
- << file << "', " << auto_groups << ", "
- << theVersion << ", " << overwrite << ", "
- << autoDimension << " )";
+ TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportMED( r'"
+ << file << "', "
+ << "auto_groups=" <<auto_groups << ", "
+ << "minor=" << minor << ", "
+ << "overwrite=" << overwrite << ", "
+ << "meshPart=None, "
+ << "autoDimension=" << autoDimension << " )";
SMESH_CATCH( SMESH::throwCorbaException );
}
-//================================================================================
-/*!
- * \brief Export a mesh to a med file
- */
-//================================================================================
-
-void SMESH_Mesh_i::ExportToMED (const char* file,
- CORBA::Boolean auto_groups,
- SMESH::MED_VERSION theVersion)
- throw(SALOME::SALOME_Exception)
-{
- ExportToMEDX(file,auto_groups,theVersion,true);
-}
-
-//================================================================================
-/*!
- * \brief Export a mesh to a med file
- */
-//================================================================================
-
-void SMESH_Mesh_i::ExportMED (const char* file,
- CORBA::Boolean auto_groups)
- throw(SALOME::SALOME_Exception)
-{
- ExportToMEDX(file,auto_groups,SMESH::MED_V2_2,true);
-}
-
//================================================================================
/*!
* \brief Export a mesh to a SAUV file
void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
CORBA::Boolean auto_groups,
- SMESH::MED_VERSION version,
+ CORBA::Long minor,
CORBA::Boolean overwrite,
CORBA::Boolean autoDimension,
const GEOM::ListOfFields& fields,
const char* geomAssocFields)
throw (SALOME::SALOME_Exception)
{
+ //MESSAGE("MED minor version: "<< minor);
SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
SMESH::DownCast< SMESH_Mesh_i* >( meshPart ))
{
aMeshName = prepareMeshNameAndGroups(file, overwrite);
- _impl->ExportMED( file, aMeshName.c_str(), auto_groups,
- version, 0, autoDimension, /*addODOnVertices=*/have0dField);
+ _impl->ExportMED( file, aMeshName.c_str(), auto_groups, minor,
+ 0, autoDimension, /*addODOnVertices=*/have0dField);
meshDS = _impl->GetMeshDS();
}
else
}
SMESH_MeshPartDS* partDS = new SMESH_MeshPartDS( meshPart );
- _impl->ExportMED( file, aMeshName.c_str(), auto_groups,
- version, partDS, autoDimension, /*addODOnVertices=*/have0dField);
+ _impl->ExportMED( file, aMeshName.c_str(), auto_groups, minor,
+ partDS, autoDimension, /*addODOnVertices=*/have0dField);
meshDS = tmpDSDeleter._obj = partDS;
}
goList[i] = gbo;
}
TPythonDump() << _this() << ".ExportPartToMED( "
- << meshPart << ", r'" << file << "', "
- << auto_groups << ", " << version << ", " << overwrite << ", "
- << autoDimension << ", " << goList
- << ", '" << ( geomAssocFields ? geomAssocFields : "" ) << "'" << " )";
+ << meshPart << ", r'"
+ << file << "', "
+ << auto_groups << ", "
+ << minor << ", "
+ << overwrite << ", "
+ << autoDimension << ", "
+ << goList << ", '"
+ << ( geomAssocFields ? geomAssocFields : "" ) << "'" << " )";
SMESH_CATCH( SMESH::throwCorbaException );
}
void SMESH_Mesh_i::ExportCGNS(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
- CORBA::Boolean overwrite)
+ CORBA::Boolean overwrite,
+ CORBA::Boolean groupElemsByType)
throw (SALOME::SALOME_Exception)
{
#ifdef WITH_CGNS
CORBA::String_var name = so->GetName();
meshName = name.in();
}
+ SMESH_TRY;
+
SMESH_MeshPartDS partDS( meshPart );
- _impl->ExportCGNS(file, &partDS, meshName.c_str() );
+ _impl->ExportCGNS(file, &partDS, meshName.c_str(), groupElemsByType );
+
+ SMESH_CATCH( SMESH::throwCorbaException );
TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportCGNS( "
<< meshPart<< ", r'" << file << "', " << overwrite << ")";
_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
SMESH::SMESH_Mesh_var mesh = meshPart->GetMesh();
SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
+ mesh_i->Load();
_meshDS = mesh_i->GetImpl().GetMeshDS();
SetPersistentId( _meshDS->GetPersistentId() );
myInfo = tmpInfo;
}
// -------------------------------------------------------------------------------------
+const SMDS_MeshElement * SMESH_MeshPartDS::FindElement(int IDelem) const
+{
+ if ( _meshDS ) return _meshDS->FindElement( IDelem );
+
+ TElemID elem( IDelem );
+ for ( int iType = SMDSAbs_Edge; iType < SMDSAbs_NbElementTypes; ++iType )
+ if ( !_elements[ iType ].empty() )
+ {
+ TIDSortedElemSet::const_iterator it = _elements[ iType ].find( &elem );
+ if ( it != _elements[ iType ].end() )
+ return *it;
+ }
+ return 0;
+}
+// -------------------------------------------------------------------------------------
SMDS_ElemIteratorPtr SMESH_MeshPartDS::elementGeomIterator(SMDSAbs_GeometryType geomType) const
{
if ( _meshDS ) return _meshDS->elementGeomIterator( geomType );
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() )); \
}
// -------------------------------------------------------------------------------------
