-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2016 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
CORBA::Long studyId )
: SALOME::GenericObj_i( thePOA )
{
- MESSAGE("SMESH_Mesh_i");
_impl = NULL;
_gen_i = gen_i;
_id = _idGenerator++;
SMESH_Mesh_i::~SMESH_Mesh_i()
{
- MESSAGE("~SMESH_Mesh_i");
-
// destroy groups
map<int, SMESH::SMESH_GroupBase_ptr>::iterator itGr;
for (itGr = _mapGroups.begin(); itGr != _mapGroups.end(); itGr++)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
- _preMeshInfo->ForgetAllData();
+ _preMeshInfo->ForgetOrLoad(); // load in case if !HasShapeToMesh()
try {
_impl->Clear();
catch(SALOME_Exception & S_ex) {
THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
}
- _impl->GetMeshDS()->Modified();
TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".Clear()";
}
SMESH_TRY;
// Read mesh with name = <theMeshName> into SMESH_Mesh
- _impl->STLToMesh( theFileName );
+ std::string name = _impl->STLToMesh( theFileName );
+ if ( !name.empty() )
+ {
+ SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
+ SALOMEDS::SObject_wrap meshSO = _gen_i->ObjectToSObject( study, _this() );
+ _gen_i->SetName( meshSO, name.c_str() );
+ }
SMESH_CATCH( SMESH::throwCorbaException );
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 ( n->NbInverseElements() == 0 )
_impl->GetMeshDS()->RemoveFreeNode( n, /*sm=*/0 );
- TPythonDump pyDump; // Supress dump from RemoveGroup()
+ TPythonDump pyDump; // Suppress dump from RemoveGroup()
// Update Python script (theGroup must be alive for this)
pyDump << SMESH::SMESH_Mesh_var(_this())
if ( !aFile.openForWriting() ) {
msg << "You cannot create the file "
<< aFile.getName()
- << ". Check the directory existance and access rights";
+ << ". Check the directory existence and access rights";
}
aFile.remove();
}
CORBA::Boolean autoDimension)
throw(SALOME::SALOME_Exception)
{
+ //MESSAGE("SMESH::MED_VERSION:"<< theVersion);
SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
SMESH::MED_VERSION theVersion)
throw(SALOME::SALOME_Exception)
{
+ //MESSAGE("SMESH::MED_VERSION:"<< theVersion);
ExportToMEDX(file,auto_groups,theVersion,true);
}
CORBA::Boolean auto_groups)
throw(SALOME::SALOME_Exception)
{
- ExportToMEDX(file,auto_groups,SMESH::MED_V2_2,true);
+ //MESSAGE("SMESH::MED_VERSION:"<< SMESH::MED_LATEST);
+ ExportToMEDX(file,auto_groups,SMESH::MED_LATEST,true);
}
//================================================================================
TPythonDump() << SMESH::SMESH_Mesh_var(_this())
<< ".ExportSTL( r'" << file << "', " << isascii << " )";
+ CORBA::String_var name;
+ SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
+ SALOMEDS::SObject_wrap so = _gen_i->ObjectToSObject( study, _this() );
+ if ( !so->_is_nil() )
+ name = so->GetName();
+
// Perform Export
- PrepareForWriting(file);
- _impl->ExportSTL(file, isascii);
+ PrepareForWriting( file );
+ _impl->ExportSTL( file, isascii, name.in() );
}
//================================================================================
( !geomAssocFields || !geomAssocFields[0] ))
return;
- std::vector< double > dblVals( meshDS->MaxShapeIndex()+1 );
- std::vector< int > intVals( meshDS->MaxShapeIndex()+1 );
- std::vector< int > subIdsByDim[ 4 ];
+ std::vector< std::vector< double > > dblVals;
+ std::vector< std::vector< int > > intVals;
+ std::vector< int > subIdsByDim[ 4 ];
const double noneDblValue = 0.;
const double noneIntValue = 0;
for ( size_t iC = 0; iC < comps->length(); ++iC )
fieldWriter.SetCompName( iC, comps[ iC ].in() );
+ dblVals.resize( comps->length() );
+ intVals.resize( comps->length() );
+
// find sub-shape IDs
std::vector< int >& subIds = subIdsByDim[ dim ];
fieldWriter.SetDtIt( int( stamp ), int( id ));
// fill dblVals or intVals
+ for ( size_t iC = 0; iC < comps->length(); ++iC )
+ if ( dataType == GEOM::FDT_Double )
+ {
+ dblVals[ iC ].clear();
+ dblVals[ iC ].resize( meshDS->MaxShapeIndex()+1, 0 );
+ }
+ else
+ {
+ intVals[ iC ].clear();
+ intVals[ iC ].resize( meshDS->MaxShapeIndex()+1, 0 );
+ }
switch ( dataType )
{
case GEOM::FDT_Double:
GEOM::GEOM_DoubleFieldStep_var dblStep = GEOM::GEOM_DoubleFieldStep::_narrow( step );
if ( dblStep->_is_nil() ) continue;
GEOM::ListOfDouble_var vv = dblStep->GetValues();
- if ( vv->length() != subIds.size() )
+ if ( vv->length() != subIds.size() * comps->length() )
THROW_SALOME_CORBA_EXCEPTION( METH "BUG: wrong nb subIds", SALOME::INTERNAL_ERROR );
- for ( size_t i = 0; i < vv->length(); ++i )
- dblVals[ subIds[ i ]] = vv[ i ];
+ for ( size_t iS = 0, iV = 0; iS < subIds.size(); ++iS )
+ for ( size_t iC = 0; iC < comps->length(); ++iC )
+ dblVals[ iC ][ subIds[ iS ]] = vv[ iV++ ];
break;
}
case GEOM::FDT_Int:
GEOM::GEOM_IntFieldStep_var intStep = GEOM::GEOM_IntFieldStep::_narrow( step );
if ( intStep->_is_nil() ) continue;
GEOM::ListOfLong_var vv = intStep->GetValues();
- if ( vv->length() != subIds.size() )
+ if ( vv->length() != subIds.size() * comps->length() )
THROW_SALOME_CORBA_EXCEPTION( METH "BUG: wrong nb subIds", SALOME::INTERNAL_ERROR );
- for ( size_t i = 0; i < vv->length(); ++i )
- intVals[ subIds[ i ]] = (int) vv[ i ];
+ for ( size_t iS = 0, iV = 0; iS < subIds.size(); ++iS )
+ for ( size_t iC = 0; iC < comps->length(); ++iC )
+ intVals[ iC ][ subIds[ iS ]] = (int) vv[ iV++ ];
break;
}
case GEOM::FDT_Bool:
GEOM::GEOM_BoolFieldStep_var boolStep = GEOM::GEOM_BoolFieldStep::_narrow( step );
if ( boolStep->_is_nil() ) continue;
GEOM::short_array_var vv = boolStep->GetValues();
- if ( vv->length() != subIds.size() )
+ if ( vv->length() != subIds.size() * comps->length() )
THROW_SALOME_CORBA_EXCEPTION( METH "BUG: wrong nb subIds", SALOME::INTERNAL_ERROR );
- for ( size_t i = 0; i < vv->length(); ++i )
- intVals[ subIds[ i ]] = (int) vv[ i ];
+ for ( size_t iS = 0, iV = 0; iS < subIds.size(); ++iS )
+ for ( size_t iC = 0; iC < comps->length(); ++iC )
+ intVals[ iC ][ subIds[ iS ]] = (int) vv[ iV++ ];
break;
}
default: continue;
{
const SMDS_MeshElement* e = elemIt->next();
const int shapeID = e->getshapeId();
- if ( shapeID < 1 || shapeID >= (int) dblVals.size() )
- fieldWriter.AddValue( noneDblValue );
+ if ( shapeID < 1 || shapeID >= (int) dblVals[0].size() )
+ for ( size_t iC = 0; iC < comps->length(); ++iC )
+ fieldWriter.AddValue( noneDblValue );
else
- fieldWriter.AddValue( dblVals[ shapeID ]);
+ for ( size_t iC = 0; iC < comps->length(); ++iC )
+ fieldWriter.AddValue( dblVals[ iC ][ shapeID ]);
}
else
while ( elemIt->more() )
{
const SMDS_MeshElement* e = elemIt->next();
const int shapeID = e->getshapeId();
- if ( shapeID < 1 || shapeID >= (int) intVals.size() )
- fieldWriter.AddValue( (double) noneIntValue );
+ if ( shapeID < 1 || shapeID >= (int) intVals[0].size() )
+ for ( size_t iC = 0; iC < comps->length(); ++iC )
+ fieldWriter.AddValue( (double) noneIntValue );
else
- fieldWriter.AddValue( (double) intVals[ shapeID ]);
+ for ( size_t iC = 0; iC < comps->length(); ++iC )
+ fieldWriter.AddValue( (double) intVals[ iC ][ shapeID ]);
}
// write a step
PrepareForWriting(file);
+ CORBA::String_var name;
+ SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
+ SALOMEDS::SObject_wrap so = _gen_i->ObjectToSObject( study, meshPart );
+ if ( !so->_is_nil() )
+ name = so->GetName();
+
SMESH_MeshPartDS partDS( meshPart );
- _impl->ExportSTL(file, isascii, &partDS);
+ _impl->ExportSTL( file, isascii, name.in(), &partDS );
TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportPartToSTL( "
<< meshPart<< ", r'" << file << "', " << isascii << ")";
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 << ")";
SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const bool iselem )
throw (SALOME::SALOME_Exception)
{
- SMESH::ElementType type;
+ SMESH::ElementType type = SMESH::ALL;
SMESH_TRY;
if ( _preMeshInfo )
SMESH::ElementType SMESH_Mesh_i::GetSubMeshElementType(const CORBA::Long ShapeID)
throw (SALOME::SALOME_Exception)
{
- SMESH::ElementType type;
+ SMESH::ElementType type = SMESH::ALL;
SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
CORBA::LongLong pointeur = CORBA::LongLong(_impl);
- if ( MYDEBUG )
- MESSAGE("CORBA::LongLong SMESH_Mesh_i::GetMeshPtr() "<<pointeur);
+ if ( MYDEBUG ) MESSAGE("CORBA::LongLong SMESH_Mesh_i::GetMeshPtr() "<<pointeur);
return pointeur;
}
return elemID;
}
+//================================================================================
+/*!
+ * \brief Return elements including all given nodes.
+ */
+//================================================================================
+
+SMESH::long_array* SMESH_Mesh_i::GetElementsByNodes(const SMESH::long_array& nodes,
+ SMESH::ElementType elemType)
+{
+ if ( _preMeshInfo )
+ _preMeshInfo->FullLoadFromFile();
+
+ SMESH::long_array_var result = new SMESH::long_array();
+
+ if ( SMESHDS_Mesh* mesh = _impl->GetMeshDS() )
+ {
+ vector< const SMDS_MeshNode * > nn( nodes.length() );
+ for ( CORBA::ULong i = 0; i < nodes.length(); ++i )
+ nn[i] = mesh->FindNode( nodes[i] );
+
+ std::vector<const SMDS_MeshElement *> elems;
+ mesh->GetElementsByNodes( nn, elems, (SMDSAbs_ElementType) elemType );
+ result->length( elems.size() );
+ for ( size_t i = 0; i < elems.size(); ++i )
+ result[i] = elems[i]->GetID();
+ }
+ return result._retn();
+}
+
//=============================================================================
/*!
* Returns true if given element is polygon
{
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.
*/
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
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();
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 );
