-// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2010 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
// File : SMESH_Gen_i.cxx
// Author : Paul RASCLE, EDF
// Module : SMESH
-//
+
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#ifdef WNT
#include <windows.h>
+ #include <process.h>
#else
#include <dlfcn.h>
#endif
#include "SMDS_EdgePosition.hxx"
#include "SMDS_FacePosition.hxx"
-#include "SMDS_VertexPosition.hxx"
-#include "SMDS_SpacePosition.hxx"
#include "SMDS_PolyhedralVolumeOfNodes.hxx"
+#include "SMDS_SetIterator.hxx"
+#include "SMDS_SpacePosition.hxx"
+#include "SMDS_VertexPosition.hxx"
#include CORBA_SERVER_HEADER(SMESH_Group)
#include CORBA_SERVER_HEADER(SMESH_Filter)
#include "GEOM_Client.hxx"
#include "Utils_ExceptHandlers.hxx"
+#include "memoire.h"
#include "Basics_Utils.hxx"
#include <map>
try {
PortableServer::Servant aServant = GetPOA()->reference_to_servant( theObject );
return aServant;
- }
+ }
catch (...) {
- INFOS( "GetServant - Unknown exception was caught!!!" );
+ INFOS( "GetServant - Unknown exception was caught!!!" );
return NULL;
}
}
/*!
* GetNS [ static ]
*
- * Get SALOME_NamingService object
+ * Get SALOME_NamingService object
*/
//=============================================================================
*
* Get SALOME_LifeCycleCORBA object
*/
-//=============================================================================
+//=============================================================================
SALOME_LifeCycleCORBA* SMESH_Gen_i::GetLCC() {
if ( myLCC == NULL ) {
myLCC = new SALOME_LifeCycleCORBA( GetNS() );
*
* Get GEOM::GEOM_Gen reference
*/
-//=============================================================================
+//=============================================================================
GEOM::GEOM_Gen_ptr SMESH_Gen_i::GetGeomEngine() {
//CCRT GEOM::GEOM_Gen_var aGeomEngine =
//CCRT GEOM::GEOM_Gen::_narrow( GetLCC()->FindOrLoad_Component("FactoryServer","GEOM") );
//CCRT return aGeomEngine._retn();
if(CORBA::is_nil(myGeomGen))
{
- Engines::Component_ptr temp=GetLCC()->FindOrLoad_Component("FactoryServer","GEOM");
+ Engines::EngineComponent_ptr temp=GetLCC()->FindOrLoad_Component("FactoryServer","GEOM");
myGeomGen=GEOM::GEOM_Gen::_narrow(temp);
}
return myGeomGen;
//=============================================================================
/*!
- * SMESH_Gen_i::SMESH_Gen_i
+ * SMESH_Gen_i::SMESH_Gen_i
*
* Standard constructor, used with Container
*/
SMESH_Gen_i::SMESH_Gen_i( CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
- PortableServer::ObjectId* contId,
- const char* instanceName,
+ PortableServer::ObjectId* contId,
+ const char* instanceName,
const char* interfaceName )
: Engines_Component_i( orb, poa, contId, instanceName, interfaceName )
{
myOrb = CORBA::ORB::_duplicate(orb);
myPoa = PortableServer::POA::_duplicate(poa);
-
+
_thisObj = this ;
_id = myPoa->activate_object( _thisObj );
-
+
myIsEmbeddedMode = false;
myShapeReader = NULL; // shape reader
mySMESHGen = this;
}
myStudyContextMap.clear();
// delete shape reader
- if ( !myShapeReader )
+ if ( !myShapeReader )
delete myShapeReader;
}
-
+
//=============================================================================
/*!
* SMESH_Gen_i::createHypothesis
}
else
{
- //try to use new format
+ //try to use new format
#ifdef WNT
aPlatformLibName = new char[ libNameLen + 5 ];
aPlatformLibName[0] = '\0';
// activate the CORBA servant of hypothesis
hypothesis_i = SMESH::SMESH_Hypothesis::_narrow( myHypothesis_i->_this() );
int nextId = RegisterObject( hypothesis_i );
- if(MYDEBUG) MESSAGE( "Add hypo to map with id = "<< nextId );
+ if(MYDEBUG) MESSAGE( "Add hypo to map with id = "<< nextId );
return hypothesis_i._retn();
}
// create a new mesh object servant, store it in a map in study context
SMESH_Mesh_i* meshServant = new SMESH_Mesh_i( GetPOA(), this, GetCurrentStudyID() );
// create a new mesh object
+ MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode);
meshServant->SetImpl( myGen.CreateMesh( GetCurrentStudyID(), myIsEmbeddedMode ));
// activate the CORBA servant of Mesh
GEOM_Client* SMESH_Gen_i::GetShapeReader()
{
// create shape reader if necessary
- if ( !myShapeReader )
+ if ( !myShapeReader )
myShapeReader = new GEOM_Client(GetContainerRef());
ASSERT( myShapeReader );
return myShapeReader;
void SMESH_Gen_i::SetEmbeddedMode( CORBA::Boolean theMode )
{
myIsEmbeddedMode = theMode;
+ MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode);
if ( !myIsEmbeddedMode ) {
//PAL10867: disable signals catching with "noexcepthandler" option
// create study context, if it doesn't exist and set current study
int studyId = GetCurrentStudyID();
if ( myStudyContextMap.find( studyId ) == myStudyContextMap.end() ) {
- myStudyContextMap[ studyId ] = new StudyContext;
+ myStudyContextMap[ studyId ] = new StudyContext;
}
// myCurrentStudy may be nil
if ( !CORBA::is_nil( myCurrentStudy ) ) {
- SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
if( !myCurrentStudy->FindComponent( "GEOM" )->_is_nil() )
aStudyBuilder->LoadWith( myCurrentStudy->FindComponent( "GEOM" ), GetGeomEngine() );
//=============================================================================
/*!
- * SMESH_Gen_i::GetCurrentStudyContext
+ * SMESH_Gen_i::GetCurrentStudyContext
*
* Get current study context
*/
//=============================================================================
/*!
- * SMESH_Gen_i::CreateHypothesis
+ * SMESH_Gen_i::CreateHypothesis
*
* Create hypothesis/algorothm of given type and publish it in the study
*/
void SMESH_Gen_i::SetDefaultNbSegments(CORBA::Long theNbSegments)
throw ( SALOME::SALOME_Exception )
{
- if ( theNbSegments )
+ if ( theNbSegments > 0 )
myGen.SetDefaultNbSegments( int(theNbSegments) );
else
THROW_SALOME_CORBA_EXCEPTION( "non-positive number of segments", SALOME::BAD_PARAM );
aStudyBuilder->CommitCommand();
if ( !aSO->_is_nil() ) {
// Update Python script
- TPythonDump() << aSO << " = smeshgen.CreateMeshesFromUNV('" << theFileName << "')";
+ TPythonDump() << aSO << " = smeshgen.CreateMeshesFromUNV(r'" << theFileName << "')";
}
}
aServant->ImportUNVFile( theFileName );
// Dump creation of groups
- aServant->GetGroups();
+ SMESH::ListOfGroups_var groups = aServant->GetGroups();
+ aServant->GetImpl().GetMeshDS()->Modified();
return aMesh._retn();
}
// Python Dump
TPythonDump aPythonDump;
aPythonDump << "([";
- //TCollection_AsciiString aStr ("([");
if (theStatus == SMESH::DRS_OK) {
SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
aStudyBuilder->NewCommand(); // There is a transaction
aResult->length( aNames.size() );
int i = 0;
-
+
// Iterate through all meshes and create mesh objects
for ( list<string>::iterator it = aNames.begin(); it != aNames.end(); it++ ) {
// Python Dump
- //if (i > 0) aStr += ", ";
if (i > 0) aPythonDump << ", ";
// create mesh
SMESH::SMESH_Mesh_var mesh = createMesh();
-
+
// publish mesh in the study
SALOMEDS::SObject_var aSO;
if ( CanPublishInStudy( mesh ) )
if ( !aSO->_is_nil() ) {
// Python Dump
aPythonDump << aSO;
- //aStr += aSO->GetID();
} else {
// Python Dump
aPythonDump << "mesh_" << i;
-// aStr += "mesh_";
-// aStr += TCollection_AsciiString(i);
}
// Read mesh data (groups are published automatically by ImportMEDFile())
theStatus = status1;
aResult[i++] = SMESH::SMESH_Mesh::_duplicate( mesh );
+ meshServant->GetImpl().GetMeshDS()->Modified();
}
aStudyBuilder->CommitCommand();
}
// Update Python script
- aPythonDump << "], status) = " << this << ".CreateMeshesFromMED('" << theFileName << "')";
+ aPythonDump << "], status) = " << this << ".CreateMeshesFromMED(r'" << theFileName << "')";
}
// Dump creation of groups
for ( int i = 0; i < aResult->length(); ++i )
- aResult[ i ]->GetGroups();
+ SMESH::ListOfGroups_var groups = aResult[ i ]->GetGroups();
return aResult._retn();
}
aStudyBuilder->CommitCommand();
if ( !aSO->_is_nil() ) {
// Update Python script
- TPythonDump() << aSO << " = " << this << ".CreateMeshesFromSTL('" << theFileName << "')";
+ TPythonDump() << aSO << " = " << this << ".CreateMeshesFromSTL(r'" << theFileName << "')";
}
}
SMESH_Mesh_i* aServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( aMesh ).in() );
ASSERT( aServant );
aServant->ImportSTLFile( theFileName );
+ aServant->GetImpl().GetMeshDS()->Modified();
return aMesh._retn();
}
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IsReadyToCompute" );
if ( CORBA::is_nil( theShapeObject ) )
- THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
+ THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
SALOME::BAD_PARAM );
if ( CORBA::is_nil( theMesh ) )
*/
//================================================================================
-SMESH::compute_error_array* SMESH_Gen_i::GetComputeErrors( SMESH::SMESH_Mesh_ptr theMesh,
+SMESH::compute_error_array* SMESH_Gen_i::GetComputeErrors( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theSubObject )
throw ( SALOME::SALOME_Exception )
{
shape = GeomObjectToShape( theSubObject );
else
shape = SMESH_Mesh::PseudoShape();
-
+
::SMESH_Mesh& mesh = meshServant->GetImpl();
error_array->length( mesh.GetMeshDS()->MaxShapeIndex() );
return error_array._retn();
}
-//
+//
//================================================================================
/*!
* \brief Return mesh elements preventing computation of a subshape
*/
//================================================================================
-SMESH::algo_error_array* SMESH_Gen_i::GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
+SMESH::algo_error_array* SMESH_Gen_i::GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theSubObject )
throw ( SALOME::SALOME_Exception )
{
myLocShape = GeomObjectToShape( theSubObject );
else
myLocShape = SMESH_Mesh::PseudoShape();
-
+
::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
list< ::SMESH_Gen::TAlgoStateError > error_list;
list< ::SMESH_Gen::TAlgoStateError >::iterator error;
try
{
TopoDS_Shape myMainShape = GeomObjectToShape(theMainShapeObject);
- TopTools_IndexedMapOfShape myIndexToShape;
+ TopTools_IndexedMapOfShape myIndexToShape;
TopExp::MapShapes(myMainShape,myIndexToShape);
for ( int i = 0; i < theListOfSubShapeObject.length(); i++ )
GEOM::GEOM_Object_ptr theShapeObject )
throw ( SALOME::SALOME_Exception )
{
+ MEMOSTAT;
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Compute" );
if ( CORBA::is_nil( theShapeObject ) && theMesh->HasShapeToMesh())
- THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
+ THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
SALOME::BAD_PARAM );
if ( CORBA::is_nil( theMesh ) )
myLocShape = SMESH_Mesh::PseudoShape();
// call implementation compute
::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
- return myGen.Compute( myLocMesh, myLocShape);
+#ifdef WITH_SMESH_CANCEL_COMPUTE
+ myGen.PrepareCompute( myLocMesh, myLocShape);
+#endif
+ bool ok = myGen.Compute( myLocMesh, myLocShape);
+ meshServant->CreateGroupServants(); // algos can create groups (issue 0020918)
+ myLocMesh.GetMeshDS()->Modified();
+ return ok;
}
}
catch ( std::bad_alloc ) {
return false;
}
+//=============================================================================
+/*!
+ * SMESH_Gen_i::CancelCompute
+ *
+ * Cancel Compute mesh on a shape
+ */
+//=============================================================================
+
+void SMESH_Gen_i::CancelCompute( SMESH::SMESH_Mesh_ptr theMesh,
+ GEOM::GEOM_Object_ptr theShapeObject )
+{
+#ifdef WITH_SMESH_CANCEL_COMPUTE
+ SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() );
+ ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
+ TopoDS_Shape myLocShape;
+ if(theMesh->HasShapeToMesh())
+ myLocShape = GeomObjectToShape( theShapeObject );
+ else
+ myLocShape = SMESH_Mesh::PseudoShape();
+ myGen.CancelCompute( myLocMesh, myLocShape);
+#endif
+}
+
//=============================================================================
/*!
* SMESH_Gen_i::Precompute
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Precompute" );
if ( CORBA::is_nil( theShapeObject ) && theMesh->HasShapeToMesh())
- THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
+ THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
SALOME::BAD_PARAM );
if ( CORBA::is_nil( theMesh ) )
SMESH_subMesh* sm = myLocMesh.GetSubMeshContaining(*idIt);
if ( !sm || !sm->IsMeshComputed() )
continue;
-
+
const TopoDS_Shape& aSh = sm->GetSubShape();
const int shDim = myGen.GetShapeDim( aSh );
if ( shDim < 1 || shDim > theDimension )
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Evaluate" );
if ( CORBA::is_nil( theShapeObject ) && theMesh->HasShapeToMesh())
- THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
+ THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
SALOME::BAD_PARAM );
if ( CORBA::is_nil( theMesh ) )
MapShapeNbElemsItr anIt = aResMap.begin();
for(; anIt!=aResMap.end(); anIt++) {
const vector<int>& aVec = (*anIt).second;
- for(i = SMESH::Entity_Node; i < SMESH::Entity_Last; i++) {
- nbels[i] += aVec[i];
+ for(i = SMESH::Entity_Node; i < aVec.size(); i++) {
+ int nbElem = aVec[i];
+ if ( nbElem < 0 ) // algo failed, check that it has reported a message
+ {
+ SMESH_subMesh* sm = anIt->first;
+ SMESH_ComputeErrorPtr& error = sm->GetComputeError();
+ const SMESH_Algo* algo = myGen.GetAlgo( myLocMesh, sm->GetSubShape());
+ if ( (algo && !error.get()) || error->IsOK() )
+ error.reset( new SMESH_ComputeError( COMPERR_ALGO_FAILED,"Failed to evaluate",algo));
+ }
+ else
+ {
+ nbels[i] += aVec[i];
+ }
}
}
-#ifdef _DEBUG_
- cout<<endl;
-#endif
return nbels._retn();
}
}
throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
-
+
GEOM::GEOM_Object_var geom = FindGeometryByMeshElement(theMesh, theElementID);
if ( !geom->_is_nil() ) {
GEOM::GEOM_Object_var mainShape = theMesh->GetShapeToMesh();
//================================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::Concatenate(const SMESH::mesh_array& theMeshesArray,
- CORBA::Boolean theUniteIdenticalGroups,
- CORBA::Boolean theMergeNodesAndElements,
+ CORBA::Boolean theUniteIdenticalGroups,
+ CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance)
throw ( SALOME::SALOME_Exception )
{
SMESH::SMESH_Mesh_ptr
SMESH_Gen_i::ConcatenateWithGroups(const SMESH::mesh_array& theMeshesArray,
- CORBA::Boolean theUniteIdenticalGroups,
- CORBA::Boolean theMergeNodesAndElements,
+ CORBA::Boolean theUniteIdenticalGroups,
+ CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance)
throw ( SALOME::SALOME_Exception )
{
SMESH::SMESH_Mesh_ptr
SMESH_Gen_i::ConcatenateCommon(const SMESH::mesh_array& theMeshesArray,
- CORBA::Boolean theUniteIdenticalGroups,
- CORBA::Boolean theMergeNodesAndElements,
+ CORBA::Boolean theUniteIdenticalGroups,
+ CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance,
CORBA::Boolean theCommonGroups)
throw ( SALOME::SALOME_Exception )
// create mesh
SMESH::SMESH_Mesh_var aNewMesh = CreateEmptyMesh();
-
+
+ SMESHDS_Mesh* aNewMeshDS = 0;
if ( !aNewMesh->_is_nil() ) {
SMESH_Mesh_i* aNewImpl = dynamic_cast<SMESH_Mesh_i*>( GetServant( aNewMesh ).in() );
if ( aNewImpl ) {
::SMESH_Mesh& aLocMesh = aNewImpl->GetImpl();
- SMESHDS_Mesh* aNewMeshDS = aLocMesh.GetMeshDS();
+ aNewMeshDS = aLocMesh.GetMeshDS();
TGroupsMap aGroupsMap;
TListOfNewGroups aListOfNewGroups;
// creates a corresponding element on existent nodes in new mesh
if ( anElem->IsPoly() && anElemType == SMDSAbs_Volume )
{
- const SMDS_PolyhedralVolumeOfNodes* aVolume =
- dynamic_cast<const SMDS_PolyhedralVolumeOfNodes*> (anElem);
+ const SMDS_VtkVolume* aVolume =
+ dynamic_cast<const SMDS_VtkVolume*> (anElem);
if ( aVolume ) {
- aNewElem = aNewMeshDS->AddPolyhedralVolume(aNodesArray,
- aVolume->GetQuanities());
+ aNewElem = aNewMeshDS->AddPolyhedralVolume(aNodesArray,
+ aVolume->GetQuantities());
elemsMap.insert(make_pair(anElem->GetID(), aNewElem->GetID()));
if( theCommonGroups )
anIDsVolumes[anNbVolumes++] = aNewElem->GetID();
}
}
else {
-
+
aNewElem = aNewEditor.AddElement(aNodesArray,
anElemType,
anElem->IsPoly());
else if( anElemType == SMDSAbs_Volume )
anIDsVolumes[anNbVolumes++] = aNewElem->GetID();
}
- }
+ }
}//elems loop
-
+
+ // copy orphan nodes
+ SMDS_NodeIteratorPtr itNodes = anInitMeshDS->nodesIterator();
+ while ( itNodes->more() )
+ {
+ const SMDS_MeshNode* aNode = itNodes->next();
+ if ( aNode->NbInverseElements() == 0 )
+ {
+ const SMDS_MeshNode* aNewNode =
+ aNewMeshDS->AddNode(aNode->X(), aNode->Y(), aNode->Z());
+ nodesMap.insert( make_pair(aNode->GetID(), aNewNode->GetID()) );
+ if( theCommonGroups )
+ anIDsNodes[anNbNodes++] = aNewNode->GetID();
+ }
+ }
+
+
aListOfGroups = anInitImpl->GetGroups();
SMESH::SMESH_GroupBase_ptr aGroup;
default:
break;
}
-
+
aListOfNewGroups.clear();
aListOfNewGroups.push_back(aNewGroup);
aGroupsMap.insert(make_pair( make_pair(aGroupName, aGroupType), aListOfNewGroups ));
for (int j = 0; j < anInitIDs->length(); j++) {
anNewIDs[j] = elemsMap.find(anInitIDs[j])->second;
}
-
+
// check that current group name and type don't have identical ones in union mesh
if ( anIter == aGroupsMap.end() ) {
// add a new group in the mesh
aNewGroup = aNewImpl->CreateGroup(aGroupType, aGroupName);
// add elements into new group
aNewGroup->Add( anNewIDs );
-
+
aListOfNewGroups.push_back(aNewGroup);
aGroupsMap.insert(make_pair( make_pair(aGroupName, aGroupType), aListOfNewGroups ));
}
// rename identical groups
aNewGroup = aNewImpl->CreateGroup(aGroupType, aGroupName);
aNewGroup->Add( anNewIDs );
-
+
TListOfNewGroups& aNewGroups = anIter->second;
string aNewGroupName;
if (aNewGroups.size() == 1) {
if (theMergeNodesAndElements) {
// merge nodes
- set<const SMDS_MeshNode*> aMeshNodes; // no input nodes
+ TIDSortedNodeSet aMeshNodes; // no input nodes
SMESH_MeshEditor::TListOfListOfNodes aGroupsOfNodes;
aNewEditor.FindCoincidentNodes( aMeshNodes, theMergeTolerance, aGroupsOfNodes );
aNewEditor.MergeNodes( aGroupsOfNodes );
}
}
}
-
+
// Update Python script
aPythonDump << aNewMesh << " = " << this;
if( !theCommonGroups )
SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
aPixmap->SetPixMap("ICON_SMESH_TREE_MESH");
}
-
+ if (aNewMeshDS)
+ aNewMeshDS->Modified();
return aNewMesh._retn();
}
+//================================================================================
+/*!
+ * \brief Create a mesh by copying a part of another mesh
+ * \param meshPart - a part of mesh to copy
+ * \param toCopyGroups - to create in the new mesh groups
+ * the copied elements belongs to
+ * \param toKeepIDs - to preserve IDs of the copied elements or not
+ * \retval SMESH::SMESH_Mesh_ptr - the new mesh
+ */
+//================================================================================
+
+SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
+ const char* meshName,
+ CORBA::Boolean toCopyGroups,
+ CORBA::Boolean toKeepIDs)
+{
+ Unexpect aCatch(SALOME_SalomeException);
+
+ TPythonDump* pyDump = new TPythonDump; // prevent dump from CreateMesh()
+
+ // 1. Get source mesh
+
+ if ( CORBA::is_nil( meshPart ))
+ THROW_SALOME_CORBA_EXCEPTION( "bad IDSource", SALOME::BAD_PARAM );
+
+ SMESH::SMESH_Mesh_var srcMesh = meshPart->GetMesh();
+ SMESH_Mesh_i* srcMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( srcMesh );
+ if ( !srcMesh_i )
+ THROW_SALOME_CORBA_EXCEPTION( "bad mesh of IDSource", SALOME::BAD_PARAM );
+
+ SMESHDS_Mesh* srcMeshDS = srcMesh_i->GetImpl().GetMeshDS();
+
+ // 2. Make a new mesh
+
+ SMESH::SMESH_Mesh_var newMesh = CreateMesh(GEOM::GEOM_Object::_nil());
+ SMESH_Mesh_i* newMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( newMesh );
+ if ( !newMesh_i )
+ THROW_SALOME_CORBA_EXCEPTION( "can't create a mesh", SALOME::INTERNAL_ERROR );
+ SALOMEDS::SObject_var meshSO = ObjectToSObject(myCurrentStudy, newMesh );
+ if ( !meshSO->_is_nil() )
+ {
+ SetName( meshSO, meshName, "Mesh" );
+ SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED");
+ }
+ SMESHDS_Mesh* newMeshDS = newMesh_i->GetImpl().GetMeshDS();
+ ::SMESH_MeshEditor editor( &newMesh_i->GetImpl() );
+
+ // 3. Get elements to copy
+
+ SMDS_ElemIteratorPtr srcElemIt;
+ TIDSortedElemSet srcElems;
+ SMESH::array_of_ElementType_var srcElemTypes = meshPart->GetTypes();
+ if ( SMESH::DownCast<SMESH_Mesh_i*>( meshPart ))
+ {
+ srcElemIt = srcMeshDS->elementsIterator();
+ }
+ else
+ {
+ SMESH::long_array_var ids = meshPart->GetIDs();
+ if ( srcElemTypes->length() == 1 && srcElemTypes[0] == SMESH::NODE ) // group of nodes
+ {
+ for (int i=0; i < ids->length(); i++)
+ if ( const SMDS_MeshElement * elem = srcMeshDS->FindNode( ids[i] ))
+ srcElems.insert( elem );
+ }
+ else
+ {
+ for (int i=0; i < ids->length(); i++)
+ if ( const SMDS_MeshElement * elem = srcMeshDS->FindElement( ids[i] ))
+ srcElems.insert( elem );
+ }
+ if ( srcElems.empty() )
+ return newMesh._retn();
+
+ typedef SMDS_SetIterator< SMDS_pElement, TIDSortedElemSet::const_iterator > ElIter;
+ srcElemIt = SMDS_ElemIteratorPtr( new ElIter( srcElems.begin(), srcElems.end() ));
+ }
+
+ // 4. Copy elements
+
+ typedef map<SMDS_pElement, SMDS_pElement, TIDCompare> TE2EMap;
+ TE2EMap e2eMapByType[ SMDSAbs_NbElementTypes ];
+ TE2EMap& n2nMap = e2eMapByType[ SMDSAbs_Node ];
+ int iN;
+ const SMDS_MeshNode *nSrc, *nTgt;
+ vector< const SMDS_MeshNode* > nodes;
+ while ( srcElemIt->more() )
+ {
+ const SMDS_MeshElement * elem = srcElemIt->next();
+ nodes.resize( elem->NbNodes());
+ SMDS_ElemIteratorPtr nIt = elem->nodesIterator();
+ if ( toKeepIDs ) {
+ for ( iN = 0; nIt->more(); ++iN )
+ {
+ nSrc = static_cast<const SMDS_MeshNode*>( nIt->next() );
+ nTgt = newMeshDS->FindNode( nSrc->GetID());
+ if ( !nTgt )
+ nTgt = newMeshDS->AddNodeWithID( nSrc->X(), nSrc->Y(), nSrc->Z(), nSrc->GetID());
+ nodes[ iN ] = nTgt;
+ }
+ }
+ else {
+ for ( iN = 0; nIt->more(); ++iN )
+ {
+ nSrc = static_cast<const SMDS_MeshNode*>( nIt->next() );
+ TE2EMap::iterator n2n = n2nMap.insert( make_pair( nSrc, SMDS_pNode(0) )).first;
+ if ( !n2n->second )
+ n2n->second = newMeshDS->AddNode( nSrc->X(), nSrc->Y(), nSrc->Z() );
+ nodes[ iN ] = (const SMDS_MeshNode*) n2n->second;
+ }
+ }
+ if ( elem->GetType() != SMDSAbs_Node )
+ {
+ int ID = toKeepIDs ? elem->GetID() : 0;
+ const SMDS_MeshElement * newElem = editor.AddElement( nodes,
+ elem->GetType(),
+ elem->IsPoly(),
+ ID);
+ if ( toCopyGroups && !toKeepIDs )
+ e2eMapByType[ elem->GetType() ].insert( make_pair( elem, newElem ));
+ }
+ }
+
+ // 5. Copy groups
+
+ int nbNewGroups = 0;
+ if ( toCopyGroups )
+ {
+ SMESH_Mesh::GroupIteratorPtr gIt = srcMesh_i->GetImpl().GetGroups();
+ while ( gIt->more() )
+ {
+ SMESH_Group* group = gIt->next();
+ const SMESHDS_GroupBase* groupDS = group->GetGroupDS();
+
+ // Check group type. We copy nodal groups containing nodes of copied element
+ SMDSAbs_ElementType groupType = groupDS->GetType();
+ if ( groupType != SMDSAbs_Node &&
+ newMeshDS->GetMeshInfo().NbElements( groupType ) == 0 )
+ continue; // group type differs from types of meshPart
+
+ // Find copied elements in the group
+ vector< const SMDS_MeshElement* > groupElems;
+ SMDS_ElemIteratorPtr eIt = groupDS->GetElements();
+ if ( toKeepIDs )
+ {
+ const SMDS_MeshElement* foundElem;
+ if ( groupType == SMDSAbs_Node )
+ {
+ while ( eIt->more() )
+ if (( foundElem = newMeshDS->FindNode( eIt->next()->GetID() )))
+ groupElems.push_back( foundElem );
+ }
+ else
+ {
+ while ( eIt->more() )
+ if (( foundElem = newMeshDS->FindElement( eIt->next()->GetID() )))
+ groupElems.push_back( foundElem );
+ }
+ }
+ else
+ {
+ TE2EMap & e2eMap = e2eMapByType[ groupDS->GetType() ];
+ if ( e2eMap.empty() ) continue;
+ int minID = e2eMap.begin()->first->GetID();
+ int maxID = e2eMap.rbegin()->first->GetID();
+ TE2EMap::iterator e2e;
+ while ( eIt->more() && groupElems.size() < e2eMap.size())
+ {
+ const SMDS_MeshElement* e = eIt->next();
+ if ( e->GetID() < minID || e->GetID() > maxID ) continue;
+ if ((e2e = e2eMap.find( e )) != e2eMap.end())
+ groupElems.push_back( e2e->second );
+ }
+ }
+ // Make a new group
+ if ( !groupElems.empty() )
+ {
+ SMESH::SMESH_Group_var newGroupObj =
+ newMesh->CreateGroup( SMESH::ElementType(groupType), group->GetName() );
+ if ( SMESH_GroupBase_i* newGroup_i = SMESH::DownCast<SMESH_GroupBase_i*>( newGroupObj))
+ {
+ SMESHDS_GroupBase * newGroupDS = newGroup_i->GetGroupDS();
+ SMDS_MeshGroup& smdsGroup = ((SMESHDS_Group*)newGroupDS)->SMDSGroup();
+ for ( unsigned i = 0; i < groupElems.size(); ++i )
+ smdsGroup.Add( groupElems[i] );
+
+ nbNewGroups++;
+ }
+ }
+ }
+ }
+
+ *pyDump << newMesh << " = " << this
+ << ".CopyMesh( " << meshPart << ", "
+ << "'" << meshName << "', "
+ << toCopyGroups << ", "
+ << toKeepIDs << ")";
+
+ delete pyDump; pyDump = 0; // allow dump in GetGroups()
+
+ if ( nbNewGroups > 0 ) // dump created groups
+ SMESH::ListOfGroups_var groups = newMesh->GetGroups();
+
+ return newMesh._retn();
+}
+
//================================================================================
/*!
* SMESH_Gen_i::GetMEDVersion
// ASSERT( theComponent->GetStudy()->StudyId() == myCurrentStudy->StudyId() )
// san -- in case <myCurrentStudy> differs from theComponent's study,
// use that of the component
- if ( myCurrentStudy->_is_nil() ||
+ if ( myCurrentStudy->_is_nil() ||
theComponent->GetStudy()->StudyId() != myCurrentStudy->StudyId() )
SetCurrentStudy( theComponent->GetStudy() );
aFileSeq->length( NUM_TMP_FILES );
TCollection_AsciiString aStudyName( "" );
- if ( isMultiFile )
+ if ( isMultiFile )
aStudyName = ( (char*)SALOMEDS_Tool::GetNameFromPath( myCurrentStudy->URL() ).c_str() );
// Set names of temporary files
DriverMED_W_SMESHDS_Mesh myWriter;
myWriter.SetFile( meshfile.ToCString() );
+ // IMP issue 20918
+ // SetStoreName() to groups before storing hypotheses to let them refer to
+ // groups using "store name", which is "Group <group_persistent_id>"
+ {
+ SALOMEDS::ChildIterator_var itBig = myCurrentStudy->NewChildIterator( theComponent );
+ for ( ; itBig->More(); itBig->Next() ) {
+ SALOMEDS::SObject_var gotBranch = itBig->Value();
+ if ( gotBranch->Tag() > GetAlgorithmsRootTag() ) {
+ CORBA::Object_var anObject = SObjectToObject( gotBranch );
+ if ( !CORBA::is_nil( anObject ) ) {
+ SMESH::SMESH_Mesh_var myMesh = SMESH::SMESH_Mesh::_narrow( anObject ) ;
+ if ( !myMesh->_is_nil() ) {
+ SMESH::ListOfGroups_var groups = myMesh->GetGroups();
+ for ( int i = 0; i < groups->length(); ++i )
+ {
+ SMESH_GroupBase_i* grImpl = SMESH::DownCast<SMESH_GroupBase_i*>( groups[i]);
+ if ( grImpl )
+ {
+ CORBA::String_var objStr = GetORB()->object_to_string( grImpl->_this() );
+ int anId = myStudyContext->findId( string( objStr.in() ) );
+ char grpName[ 30 ];
+ sprintf( grpName, "Group %d", anId );
+ SMESHDS_GroupBase* aGrpBaseDS = grImpl->GetGroupDS();
+ aGrpBaseDS->SetStoreName( grpName );
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
// Write data
// ---> create HDF file
aFile = new HDFfile( (char*) filename.ToCString() );
aDataset->WriteOnDisk( anAutoColor );
aDataset->CloseOnDisk();
+ // issue 0020693. Store _isModified flag
+ int isModified = myLocMesh.GetIsModified();
+ aSize[ 0 ] = 1;
+ aDataset = new HDFdataset( "_isModified", aTopGroup, HDF_INT32, aSize, 1 );
+ aDataset->CreateOnDisk();
+ aDataset->WriteOnDisk( &isModified );
+ aDataset->CloseOnDisk();
+
+ // issue 20918. Store Persistent Id of SMESHDS_Mesh
+ int meshPersistentId = mySMESHDSMesh->GetPersistentId();
+ aSize[ 0 ] = 1;
+ aDataset = new HDFdataset( "meshPersistentId", aTopGroup, HDF_INT32, aSize, 1 );
+ aDataset->CreateOnDisk();
+ aDataset->WriteOnDisk( &meshPersistentId );
+ aDataset->CloseOnDisk();
+
// write reference on a shape if exists
SALOMEDS::SObject_var myRef;
bool shapeRefFound = false;
if ( ok ) {
// san - it is impossible to recover applied hypotheses
// using their entries within Load() method,
- // for there are no AttributeIORs in the study when Load() is working.
+ // for there are no AttributeIORs in the study when Load() is working.
// Hence, it is better to store persistent IDs of hypotheses as references to them
//string myRefOnObject = myRefOnHyp->GetID();
if ( ok ) {
// san - it is impossible to recover applied algorithms
// using their entries within Load() method,
- // for there are no AttributeIORs in the study when Load() is working.
+ // for there are no AttributeIORs in the study when Load() is working.
// Hence, it is better to store persistent IDs of algorithms as references to them
//string myRefOnObject = myRefOnAlgo->GetID();
dynamic_cast<SMESH_GroupBase_i*>( GetServant( aSubObject ).in() );
if ( !myGroupImpl )
continue;
-
+ SMESHDS_GroupBase* aGrpBaseDS = myGroupImpl->GetGroupDS();
+ if ( !aGrpBaseDS )
+ continue;
+
CORBA::String_var objStr = GetORB()->object_to_string( aSubObject );
int anId = myStudyContext->findId( string( objStr.in() ) );
-
+
// For each group, create a dataset named "Group <group_persistent_id>"
// and store the group's user name into it
- char grpName[ 30 ];
- sprintf( grpName, "Group %d", anId );
+ const char* grpName = aGrpBaseDS->GetStoreName();
char* aUserName = myGroupImpl->GetName();
aSize[ 0 ] = strlen( aUserName ) + 1;
-
+
aDataset = new HDFdataset( grpName, aGroup, HDF_STRING, aSize, 1 );
aDataset->CreateOnDisk();
aDataset->WriteOnDisk( aUserName );
aDataset->WriteOnDisk( anRGB );
aDataset->CloseOnDisk();
- // Store the group contents into MED file
- if ( myLocMesh.GetGroup( myGroupImpl->GetLocalID() ) ) {
-
- if(MYDEBUG) MESSAGE( "VSR - SMESH_Gen_i::Save(): saving group with StoreName = "
- << grpName << " to MED file" );
- SMESHDS_GroupBase* aGrpBaseDS =
- myLocMesh.GetGroup( myGroupImpl->GetLocalID() )->GetGroupDS();
- aGrpBaseDS->SetStoreName( grpName );
-
- // Pass SMESHDS_Group to MED writer
- SMESHDS_Group* aGrpDS = dynamic_cast<SMESHDS_Group*>( aGrpBaseDS );
- if ( aGrpDS )
- myWriter.AddGroup( aGrpDS );
-
- // write reference on a shape if exists
- SMESHDS_GroupOnGeom* aGeomGrp =
- dynamic_cast<SMESHDS_GroupOnGeom*>( aGrpBaseDS );
- if ( aGeomGrp ) {
- SALOMEDS::SObject_var mySubRef, myShape;
- if (mySObject->FindSubObject( GetRefOnShapeTag(), mySubRef ) &&
- mySubRef->ReferencedObject( myShape ) &&
- !CORBA::is_nil( myShape->GetObject() ))
- {
- string myRefOnObject = myShape->GetID();
- if ( myRefOnObject.length() > 0 ) {
- char aRefName[ 30 ];
- sprintf( aRefName, "Ref on shape %d", anId);
- aSize[ 0 ] = myRefOnObject.length() + 1;
- aDataset = new HDFdataset(aRefName, aGroup, HDF_STRING, aSize, 1);
- aDataset->CreateOnDisk();
- aDataset->WriteOnDisk( ( char* )( myRefOnObject.c_str() ) );
- aDataset->CloseOnDisk();
- }
- }
- else // shape ref is invalid:
- {
- // save a group on geometry as ordinary group
- myWriter.AddGroup( aGeomGrp );
+ // Pass SMESHDS_Group to MED writer
+ SMESHDS_Group* aGrpDS = dynamic_cast<SMESHDS_Group*>( aGrpBaseDS );
+ if ( aGrpDS )
+ myWriter.AddGroup( aGrpDS );
+
+ // write reference on a shape if exists
+ SMESHDS_GroupOnGeom* aGeomGrp =
+ dynamic_cast<SMESHDS_GroupOnGeom*>( aGrpBaseDS );
+ if ( aGeomGrp ) {
+ SALOMEDS::SObject_var mySubRef, myShape;
+ if (mySObject->FindSubObject( GetRefOnShapeTag(), mySubRef ) &&
+ mySubRef->ReferencedObject( myShape ) &&
+ !CORBA::is_nil( myShape->GetObject() ))
+ {
+ string myRefOnObject = myShape->GetID();
+ if ( myRefOnObject.length() > 0 ) {
+ char aRefName[ 30 ];
+ sprintf( aRefName, "Ref on shape %d", anId);
+ aSize[ 0 ] = myRefOnObject.length() + 1;
+ aDataset = new HDFdataset(aRefName, aGroup, HDF_STRING, aSize, 1);
+ aDataset->CreateOnDisk();
+ aDataset->WriteOnDisk( ( char* )( myRefOnObject.c_str() ) );
+ aDataset->CloseOnDisk();
}
}
+ else // shape ref is invalid:
+ {
+ // save a group on geometry as ordinary group
+ myWriter.AddGroup( aGeomGrp );
+ }
}
}
}
aGroup->CloseOnDisk();
}
- } // loop on groups
-
+ } // loop on groups
+
if ( strcmp( strHasData.c_str(), "1" ) == 0 )
{
// Flush current mesh information into MED file
myWriter.Perform();
-
+
// maybe a shape was deleted in the study
if ( !shapeRefFound && !mySMESHDSMesh->ShapeToMesh().IsNull() && hasShape) {
TopoDS_Shape nullShape;
myLocMesh.ShapeToMesh( nullShape ); // remove shape referring data
}
-
+
if ( !mySMESHDSMesh->SubMeshes().empty() )
{
// Store submeshes
// ----------------
aGroup = new HDFgroup( "Submeshes", aTopGroup );
aGroup->CreateOnDisk();
-
+
// each element belongs to one or none submesh,
// so for each node/element, we store a submesh ID
-
+
// Make maps of submesh IDs of elements sorted by element IDs
typedef int TElemID;
typedef int TSubMID;
for ( itElem = aSubMesh->GetElements(); itElem->more(); ++hint)
hint = eId2smId.insert( hint, make_pair( itElem->next()->GetID(), aSubMeID ));
}
-
+
// Care of elements that are not on submeshes
if ( mySMESHDSMesh->NbNodes() != nId2smId.size() ) {
for ( itNode = mySMESHDSMesh->nodesIterator(); itNode->more(); )
for ( itElem = mySMESHDSMesh->elementsIterator(); itElem->more(); )
eId2smId.insert( make_pair( itElem->next()->GetID(), 0 ));
}
-
+
// Store submesh IDs
for ( int isNode = 0; isNode < 2; ++isNode )
{
//
delete[] smIDs;
}
-
+
// Store node positions on sub-shapes (SMDS_Position):
// ----------------------------------------------------
-
+
aGroup = new HDFgroup( "Node Positions", aTopGroup );
aGroup->CreateOnDisk();
-
+
// in aGroup, create 5 datasets to contain:
// "Nodes on Edges" - ID of node on edge
// "Edge positions" - U parameter on node on edge
// "Nodes on Faces" - ID of node on face
// "Face U positions" - U parameter of node on face
// "Face V positions" - V parameter of node on face
-
+
// Find out nb of nodes on edges and faces
// Collect corresponing sub-meshes
int nbEdgeNodes = 0, nbFaceNodes = 0;
continue; // submesh containing other submeshs
int nbNodes = aSubMesh->NbNodes();
if ( nbNodes == 0 ) continue;
-
+
int aShapeID = (*itSubM).first;
+ if ( aShapeID < 1 || aShapeID > mySMESHDSMesh->MaxShapeIndex() )
+ continue;
int aShapeType = mySMESHDSMesh->IndexToShape( aShapeID ).ShapeType();
// write only SMDS_FacePosition and SMDS_EdgePosition
switch ( aShapeType ) {
int* aNodeIDs = new int [ nbNodes ];
double* aUPos = new double [ nbNodes ];
double* aVPos = ( onFace ? new double[ nbNodes ] : 0 );
-
+
// Fill arrays
// loop on sub-meshes
list<SMESHDS_SubMesh*> * pListSM = ( onFace ? &aFaceSM : &aEdgeSM );
for ( ; itSM != pListSM->end(); itSM++ )
{
SMESHDS_SubMesh* aSubMesh = (*itSM);
-
+
SMDS_NodeIteratorPtr itNode = aSubMesh->GetNodes();
// loop on nodes in aSubMesh
while ( itNode->more() )
//node ID
const SMDS_MeshNode* node = itNode->next();
aNodeIDs [ iNode ] = node->GetID();
-
+
// Position
const SMDS_PositionPtr pos = node->GetPosition();
if ( onFace ) { // on FACE
const SMDS_FacePosition* fPos =
- dynamic_cast<const SMDS_FacePosition*>( pos.get() );
+ dynamic_cast<const SMDS_FacePosition*>( pos );
if ( fPos ) {
aUPos[ iNode ] = fPos->GetUParameter();
aVPos[ iNode ] = fPos->GetVParameter();
}
else { // on EDGE
const SMDS_EdgePosition* ePos =
- dynamic_cast<const SMDS_EdgePosition*>( pos.get() );
+ dynamic_cast<const SMDS_EdgePosition*>( pos );
if ( ePos ) {
aUPos[ iNode ] = ePos->GetUParameter();
iNode++;
}
} // loop on nodes in aSubMesh
} // loop on sub-meshes
-
+
// Write datasets
if ( nbNodes )
{
aDataset->CreateOnDisk();
aDataset->WriteOnDisk( aNodeIDs );
aDataset->CloseOnDisk();
-
+
// U Positions
aDSName = ( onFace ? "Face U positions" : "Edge positions");
aDataset = new HDFdataset( (char*)aDSName.c_str(), aGroup, HDF_FLOAT64, aSize, 1);
delete [] aNodeIDs;
delete [] aUPos;
if ( aVPos ) delete [] aVPos;
-
+
} // treat positions on edges or faces
-
+
// close "Node Positions" group
- aGroup->CloseOnDisk();
-
+ aGroup->CloseOnDisk();
+
} // if ( there are submeshes in SMESHDS_Mesh )
} // if ( hasData )
-
+
// close mesh HDF group
aTopGroup->CloseOnDisk();
}
}
}
}
-
+
// close HDF file
aFile->CloseOnDisk();
delete aFile;
aStreamFile = SALOMEDS_Tool::PutFilesToStream( tmpDir.ToCString(), aFileSeq.in(), isMultiFile );
// Remove temporary files and directory
- if ( !isMultiFile )
+ if ( !isMultiFile )
SALOMEDS_Tool::RemoveTemporaryFiles( tmpDir.ToCString(), aFileSeq.in(), true );
INFOS( "SMESH_Gen_i::Save() completed" );
buffer[size * 3] = '\0';
SALOMEDS::TMPFile_var anAsciiStreamFile = new SALOMEDS::TMPFile(size*3, size*3, buffer, 1);
-
+
return anAsciiStreamFile._retn();
}
if ( aStudy->_is_nil() )
return;
- SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
+ SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
aStudyBuilder->LoadWith( theCompRoot, GetGeomEngine() );
}
//=============================================================================
}
PositionCreator() {
myFuncTable.resize( (size_t) TopAbs_SHAPE, & PositionCreator::defaultPosition );
- myFuncTable[ TopAbs_FACE ] = & PositionCreator::facePosition;
- myFuncTable[ TopAbs_EDGE ] = & PositionCreator::edgePosition;
+ myFuncTable[ TopAbs_SOLID ] = & PositionCreator::volumePosition;
+ myFuncTable[ TopAbs_FACE ] = & PositionCreator::facePosition;
+ myFuncTable[ TopAbs_EDGE ] = & PositionCreator::edgePosition;
myFuncTable[ TopAbs_VERTEX ] = & PositionCreator::vertexPosition;
}
private:
SMDS_PositionPtr edgePosition() const { return SMDS_PositionPtr( new SMDS_EdgePosition ); }
SMDS_PositionPtr facePosition() const { return SMDS_PositionPtr( new SMDS_FacePosition ); }
+ SMDS_PositionPtr volumePosition() const { return SMDS_PositionPtr( new SMDS_SpacePosition ); }
SMDS_PositionPtr vertexPosition() const { return SMDS_PositionPtr( new SMDS_VertexPosition); }
SMDS_PositionPtr defaultPosition() const { return SMDS_SpacePosition::originSpacePosition(); }
typedef SMDS_PositionPtr (PositionCreator:: * FmakePos)() const;
{
INFOS( "SMESH_Gen_i::Load" );
- if ( myCurrentStudy->_is_nil() ||
+ if ( myCurrentStudy->_is_nil() ||
theComponent->GetStudy()->StudyId() != myCurrentStudy->StudyId() )
SetCurrentStudy( theComponent->GetStudy() );
// Get temporary files location
TCollection_AsciiString tmpDir =
isMultiFile ? TCollection_AsciiString( ( char* )theURL ) : ( char* )SALOMEDS_Tool::GetTmpDir().c_str();
-
+
INFOS( "THE URL++++++++++++++" )
INFOS( theURL );
INFOS( "THE TMP PATH+++++++++" );
tmpDir.ToCString(),
isMultiFile );
TCollection_AsciiString aStudyName( "" );
- if ( isMultiFile )
+ if ( isMultiFile )
aStudyName = ( (char*)SALOMEDS_Tool::GetNameFromPath( myCurrentStudy->URL() ).c_str() );
// Set names of temporary files
list< pair< SMESH_Mesh_i*, HDFgroup* > > meshGroupList;
// get total number of top-level groups
- int aNbGroups = aFile->nInternalObjects();
+ int aNbGroups = aFile->nInternalObjects();
if ( aNbGroups > 0 ) {
// --> in first turn we should read&create hypotheses
if ( aFile->ExistInternalObject( "Hypotheses" ) ) {
// open hypotheses root HDF group
- aTopGroup = new HDFgroup( "Hypotheses", aFile );
+ aTopGroup = new HDFgroup( "Hypotheses", aFile );
aTopGroup->OpenOnDisk();
// get number of hypotheses
- int aNbObjects = aTopGroup->nInternalObjects();
+ int aNbObjects = aTopGroup->nInternalObjects();
for ( int j = 0; j < aNbObjects; j++ ) {
// try to identify hypothesis
char hypGrpName[ HDF_NAME_MAX_LEN+1 ];
if ( string( hypGrpName ).substr( 0, 10 ) == string( "Hypothesis" ) ) {
// open hypothesis group
- aGroup = new HDFgroup( hypGrpName, aTopGroup );
+ aGroup = new HDFgroup( hypGrpName, aTopGroup );
aGroup->OpenOnDisk();
// --> get hypothesis id
// --> then we should read&create algorithms
if ( aFile->ExistInternalObject( "Algorithms" ) ) {
// open algorithms root HDF group
- aTopGroup = new HDFgroup( "Algorithms", aFile );
+ aTopGroup = new HDFgroup( "Algorithms", aFile );
aTopGroup->OpenOnDisk();
// get number of algorithms
- int aNbObjects = aTopGroup->nInternalObjects();
+ int aNbObjects = aTopGroup->nInternalObjects();
for ( int j = 0; j < aNbObjects; j++ ) {
// try to identify algorithm
char hypGrpName[ HDF_NAME_MAX_LEN+1 ];
if ( string( hypGrpName ).substr( 0, 9 ) == string( "Algorithm" ) ) {
// open algorithm group
- aGroup = new HDFgroup( hypGrpName, aTopGroup );
+ aGroup = new HDFgroup( hypGrpName, aTopGroup );
aGroup->OpenOnDisk();
// --> get algorithm id
continue;
// open mesh HDF group
- aTopGroup = new HDFgroup( meshName, aFile );
+ aTopGroup = new HDFgroup( meshName, aFile );
aTopGroup->OpenOnDisk();
// get number of child HDF objects
- int aNbObjects = aTopGroup->nInternalObjects();
+ int aNbObjects = aTopGroup->nInternalObjects();
if ( aNbObjects > 0 ) {
// create mesh
if(MYDEBUG) MESSAGE( "VSR - load mesh : id = " << id );
}
}
}
+
+ // issue 0020693. Restore _isModified flag
+ if( aTopGroup->ExistInternalObject( "_isModified" ) )
+ {
+ aDataset = new HDFdataset( "_isModified", aTopGroup );
+ aDataset->OpenOnDisk();
+ size = aDataset->GetSize();
+ int* isModified = new int[ size ];
+ aDataset->ReadFromDisk( isModified );
+ aDataset->CloseOnDisk();
+ myNewMeshImpl->GetImpl().SetIsModified( bool(*isModified));
+ }
+
+ // issue 20918. Restore Persistent Id of SMESHDS_Mesh
+ if( aTopGroup->ExistInternalObject( "meshPersistentId" ) )
+ {
+ aDataset = new HDFdataset( "meshPersistentId", aTopGroup );
+ aDataset->OpenOnDisk();
+ size = aDataset->GetSize();
+ int* meshPersistentId = new int[ size ];
+ aDataset->ReadFromDisk( meshPersistentId );
+ aDataset->CloseOnDisk();
+ myNewMeshImpl->GetImpl().GetMeshDS()->SetPersistentId( *meshPersistentId );
+ }
}
}
}
aGroup = new HDFgroup( "Applied Algorithms", aTopGroup );
aGroup->OpenOnDisk();
// get number of applied algorithms
- int aNbSubObjects = aGroup->nInternalObjects();
+ int aNbSubObjects = aGroup->nInternalObjects();
if(MYDEBUG) MESSAGE( "VSR - number of applied algos " << aNbSubObjects );
for ( int j = 0; j < aNbSubObjects; j++ ) {
char name_dataset[ HDF_NAME_MAX_LEN+1 ];
aGroup = new HDFgroup( "Applied Hypotheses", aTopGroup );
aGroup->OpenOnDisk();
// get number of applied hypotheses
- int aNbSubObjects = aGroup->nInternalObjects();
+ int aNbSubObjects = aGroup->nInternalObjects();
for ( int j = 0; j < aNbSubObjects; j++ ) {
char name_dataset[ HDF_NAME_MAX_LEN+1 ];
aGroup->InternalObjectIndentify( j, name_dataset );
aGroup->OpenOnDisk();
// get number of submeshes
- int aNbSubMeshes = aGroup->nInternalObjects();
+ int aNbSubMeshes = aGroup->nInternalObjects();
for ( int k = 0; k < aNbSubMeshes; k++ ) {
// identify submesh
char name_submeshgroup[ HDF_NAME_MAX_LEN+1 ];
aSubSubGroup = new HDFgroup( "Applied Algorithms", aSubGroup );
aSubSubGroup->OpenOnDisk();
// get number of applied algorithms
- int aNbSubObjects = aSubSubGroup->nInternalObjects();
+ int aNbSubObjects = aSubSubGroup->nInternalObjects();
for ( int l = 0; l < aNbSubObjects; l++ ) {
char name_dataset[ HDF_NAME_MAX_LEN+1 ];
aSubSubGroup->InternalObjectIndentify( l, name_dataset );
aSubSubGroup = new HDFgroup( "Applied Hypotheses", aSubGroup );
aSubSubGroup->OpenOnDisk();
// get number of applied hypotheses
- int aNbSubObjects = aSubSubGroup->nInternalObjects();
+ int aNbSubObjects = aSubSubGroup->nInternalObjects();
for ( int l = 0; l < aNbSubObjects; l++ ) {
char name_dataset[ HDF_NAME_MAX_LEN+1 ];
aSubSubGroup->InternalObjectIndentify( l, name_dataset );
else
{
// open a group
- aGroup = new HDFgroup( "Submeshes", aTopGroup );
+ aGroup = new HDFgroup( "Submeshes", aTopGroup );
aGroup->OpenOnDisk();
- int maxID = mySMESHDSMesh->MaxShapeIndex();
+ int maxID = Max( mySMESHDSMesh->MaxSubMeshIndex(), mySMESHDSMesh->MaxShapeIndex() );
vector< SMESHDS_SubMesh * > subMeshes( maxID + 1, (SMESHDS_SubMesh*) 0 );
- vector< TopAbs_ShapeEnum > smType ( maxID + 1, TopAbs_SHAPE );
+ vector< TopAbs_ShapeEnum > smType ( maxID + 1, TopAbs_SHAPE );
PositionCreator aPositionCreator;
// add
if ( isNode ) {
SMDS_PositionPtr pos = aPositionCreator.MakePosition( smType[ smID ]);
- pos->SetShapeId( smID );
SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( static_cast<const SMDS_MeshNode*>( elem ));
node->SetPosition( pos );
sm->AddNode( node );
double *aEpos = 0, *aFupos = 0, *aFvpos = 0;
// open a group
- aGroup = new HDFgroup( "Node Positions", aTopGroup );
+ aGroup = new HDFgroup( "Node Positions", aTopGroup );
aGroup->OpenOnDisk();
// loop on 5 data sets
// not fixed bugs in SMDS_MeshInfo
if ( aPos->GetTypeOfPosition() == SMDS_TOP_FACE ) {
SMDS_FacePosition* fPos = const_cast<SMDS_FacePosition*>
- ( static_cast<const SMDS_FacePosition*>( aPos.get() ));
+ ( static_cast<const SMDS_FacePosition*>( aPos ));
fPos->SetUParameter( aUPos[ iNode ]);
fPos->SetVParameter( aVPos[ iNode ]);
}
// ASSERT( aPos->GetTypeOfPosition() == SMDS_TOP_EDGE );-- issue 20182
if ( aPos->GetTypeOfPosition() == SMDS_TOP_EDGE ) {
SMDS_EdgePosition* fPos = const_cast<SMDS_EdgePosition*>
- ( static_cast<const SMDS_EdgePosition*>( aPos.get() ));
+ ( static_cast<const SMDS_EdgePosition*>( aPos ));
fPos->SetUParameter( aUPos[ iNode ]);
}
}
} // if ( aTopGroup->ExistInternalObject( "Node Positions" ) )
} // if ( hasData )
- // Recompute State (as computed sub-meshes are restored from MED)
- if ( !aShapeObject->_is_nil() || !myNewMeshImpl->HasShapeToMesh()) {
- MESSAGE("Compute State Engine ...");
- TopoDS_Shape myLocShape;
- if(myNewMeshImpl->HasShapeToMesh())
- myLocShape = GeomObjectToShape( aShapeObject );
- else
- myLocShape = SMESH_Mesh::PseudoShape();
-
- myNewMeshImpl->GetImpl().GetSubMesh(myLocShape)->ComputeStateEngine
- (SMESH_subMesh::SUBMESH_RESTORED);
- MESSAGE("Compute State Engine finished");
- }
-
// try to get groups
for ( int ii = GetNodeGroupsTag(); ii <= GetVolumeGroupsTag(); ii++ ) {
char name_group[ 30 ];
aGroup = new HDFgroup( name_group, aTopGroup );
aGroup->OpenOnDisk();
// get number of groups
- int aNbSubObjects = aGroup->nInternalObjects();
+ int aNbSubObjects = aGroup->nInternalObjects();
for ( int j = 0; j < aNbSubObjects; j++ ) {
char name_dataset[ HDF_NAME_MAX_LEN+1 ];
aGroup->InternalObjectIndentify( j, name_dataset );
SMESH::ElementType type = (SMESH::ElementType)(ii - GetNodeGroupsTag() + 1);
SMESH::SMESH_GroupBase_var aNewGroup = SMESH::SMESH_GroupBase::_duplicate
( myNewMeshImpl->createGroup( type, nameFromFile, aShape ) );
- // Obtain a SMESHDS_Group object
+ // Obtain a SMESHDS_Group object
if ( aNewGroup->_is_nil() )
continue;
aGroup->CloseOnDisk();
}
}
+
// read submeh order if any
if( aTopGroup->ExistInternalObject( "Mesh Order" ) ) {
aDataset = new HDFdataset( "Mesh Order", aTopGroup );
anOrderIds.push_back( TListOfInt() );
else
anOrderIds.back().push_back(smIDs[ i ]);
-
+
myNewMeshImpl->GetImpl().SetMeshOrder( anOrderIds );
}
+ } // loop on meshes
+
+ // notify algos on completed restoration
+ for ( meshi_group = meshGroupList.begin(); meshi_group != meshGroupList.end(); ++meshi_group )
+ {
+ SMESH_Mesh_i* myNewMeshImpl = meshi_group->first;
+ ::SMESH_Mesh& myLocMesh = myNewMeshImpl->GetImpl();
+
+ TopoDS_Shape myLocShape;
+ if(myLocMesh.HasShapeToMesh())
+ myLocShape = myLocMesh.GetShapeToMesh();
+ else
+ myLocShape = SMESH_Mesh::PseudoShape();
+
+ myLocMesh.GetSubMesh(myLocShape)->
+ ComputeStateEngine (SMESH_subMesh::SUBMESH_RESTORED);
+ }
+
+ for ( hyp_data = hypDataList.begin(); hyp_data != hypDataList.end(); ++hyp_data )
+ {
+ SMESH_Hypothesis_i* hyp = hyp_data->first;
+ hyp->UpdateAsMeshesRestored(); // for hyps needing full mesh data restored (issue 20918)
}
+
// close mesh group
if(aTopGroup)
- aTopGroup->CloseOnDisk();
+ aTopGroup->CloseOnDisk();
}
// close HDF file
aFile->CloseOnDisk();
delete aFile;
// Remove temporary files created from the stream
- if ( !isMultiFile )
+ if ( !isMultiFile )
SALOMEDS_Tool::RemoveTemporaryFiles( tmpDir.ToCString(), aFileSeq.in(), true );
INFOS( "SMESH_Gen_i::Load completed" );
}
SALOMEDS::TMPFile_var aRealStreamFile = new SALOMEDS::TMPFile(real_size, real_size, buffer, 1);
-
+
return Load( theComponent, *(aRealStreamFile._retn()), theURL, isMultiFile );
}
// printf( "--------------------------- SMESH_Gen_i::Close, delete aGroup = %p \n", i_mesh->second );
// delete i_mesh->second;
// }
-
+
// delete SMESHDS_Mesh's
// it's too long on big meshes
// delete context->myDocument;
// context->myDocument = 0;
// }
-
+
myCurrentStudy = SALOMEDS::Study::_nil();
return;
}
//=============================================================================
/*!
* SMESH_Gen_i::ComponentDataType
- *
+ *
* Get component data type
*/
//=============================================================================
return CORBA::string_dup( "SMESH" );
}
-
+
//=============================================================================
/*!
* SMESH_Gen_i::IORToLocalPersistentID
- *
+ *
* Transform data from transient form to persistent
*/
//=============================================================================
{
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IORToLocalPersistentID" );
StudyContext* myStudyContext = GetCurrentStudyContext();
-
+
if ( myStudyContext && strcmp( IORString, "" ) != 0 ) {
int anId = myStudyContext->findId( IORString );
if ( anId ) {
//=======================================================================
//function : RegisterObject
-//purpose :
+//purpose :
//=======================================================================
int SMESH_Gen_i::RegisterObject(CORBA::Object_ptr theObject)
{
return myCurrentStudy->_is_nil() || myCurrentStudy->_non_existent() ? -1 : myCurrentStudy->StudyId();
}
-
+
//=============================================================================
-/*!
+/*!
* SMESHEngine_factory
*
- * C factory, accessible with dlsym, after dlopen
+ * C factory, accessible with dlsym, after dlopen
*/
//=============================================================================
extern "C"
{ SMESH_I_EXPORT
PortableServer::ObjectId* SMESHEngine_factory( CORBA::ORB_ptr orb,
- PortableServer::POA_ptr poa,
+ PortableServer::POA_ptr poa,
PortableServer::ObjectId* contId,
- const char* instanceName,
+ const char* instanceName,
const char* interfaceName )
{
if(MYDEBUG) MESSAGE( "PortableServer::ObjectId* SMESHEngine_factory()" );
