if ( myStudyContextMap.find( studyId ) == myStudyContextMap.end() ) {
myStudyContextMap[ studyId ] = new StudyContext;
}
- SetStudyID(studyId);
// set current study for geom engine
/*
if ( !CORBA::is_nil( GetGeomEngine() ) )
SMESH::SMESH_Hypothesis_var hyp = this->createHypothesis( theHypName, theLibName );
// Publish hypothesis/algorithm in the study
- if ( CanPublishInStudy( hyp ) )
- PublishHypothesis( myCurrentStudy, hyp );
+ if ( CanPublishInStudy( hyp ) ) {
+ SALOMEDS::SObject_var aSO = PublishHypothesis( myCurrentStudy, hyp );
+ if ( !aSO->_is_nil() ) {
+ // Update Python script
+ TCollection_AsciiString aStr (aSO->GetID());
+ aStr += " = smesh.CreateHypothesis(\"";
+ aStr += Standard_CString(theHypName);
+ aStr += "\", \"";
+ aStr += Standard_CString(theLibName);
+ aStr += "\")";
+
+ AddToCurrentPyScript(aStr);
+ }
+ }
return hyp._retn();
}
-
+
//=============================================================================
/*!
* SMESH_Gen_i::CreateMesh
throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
- using namespace SMESH;
- FactoryHandler aFactory;
-
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
// create mesh
SMESH::SMESH_Mesh_var mesh = this->createMesh();
SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( mesh ).in() );
ASSERT( meshServant );
meshServant->SetShape( theShapeObject );
- // publish mesh in the study
- if ( CanPublishInStudy( mesh ) )
- PublishMesh( myCurrentStudy, mesh.in() );
- CORBA::String_var anEntry = theShapeObject->GetEntry();
- aFactory->Register(TInvocationID(TResultCont(1,meshServant->GetID()),
- GetID(),
- "SMESH_Mesh",
- "CreateMesh",
- TArgumentCont(),
- anEntry.in()));
+ // publish mesh in the study
+ if ( CanPublishInStudy( mesh ) ) {
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ aStudyBuilder->NewCommand(); // There is a transaction
+ SALOMEDS::SObject_var aSO = PublishMesh( myCurrentStudy, mesh.in() );
+ aStudyBuilder->CommitCommand();
+ if ( !aSO->_is_nil() ) {
+ // Update Python script
+ TCollection_AsciiString aStr (aSO->GetID());
+ aStr += " = smesh.CreateMesh(";
+ SMESH_Gen_i::AddObject(aStr, theShapeObject) += ")";
+
+ AddToCurrentPyScript(aStr);
+ }
+ }
return mesh._retn();
}
SMESH::SMESH_Mesh_var aMesh = createMesh();
string aFileName; // = boost::filesystem::path(theFileName).leaf();
// publish mesh in the study
- if ( CanPublishInStudy( aMesh ) )
- PublishMesh( myCurrentStudy, aMesh.in(), aFileName.c_str() );
+ if ( CanPublishInStudy( aMesh ) ) {
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ aStudyBuilder->NewCommand(); // There is a transaction
+ SALOMEDS::SObject_var aSO = PublishMesh( myCurrentStudy, aMesh.in(), aFileName.c_str() );
+ aStudyBuilder->CommitCommand();
+ if ( !aSO->_is_nil() ) {
+ // Update Python script
+ TCollection_AsciiString aStr (aSO->GetID());
+ aStr += " = smesh.CreateMeshesFromUNV(\"";
+ aStr += Standard_CString(theFileName);
+ aStr += "\")";
+
+ AddToCurrentPyScript(aStr);
+ }
+ }
SMESH_Mesh_i* aServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( aMesh ).in() );
ASSERT( aServant );
throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
- using namespace SMESH;
- FactoryHandler aFactory;
-
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMeshFromMED" );
+ // Python Dump
+ TCollection_AsciiString aStr ("([");
+
// Retrieve mesh names from the file
DriverMED_R_SMESHDS_Mesh myReader;
myReader.SetFile( theFileName );
list<string> aNames = myReader.GetMeshNames(aStatus);
SMESH::mesh_array_var aResult = new SMESH::mesh_array();
theStatus = (SMESH::DriverMED_ReadStatus)aStatus;
- if(theStatus == SMESH::DRS_OK){
+ if (theStatus == SMESH::DRS_OK) {
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ aStudyBuilder->NewCommand(); // There is a transaction
aResult->length( aNames.size() );
- TResultCont aResultCont;
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 += ", ";
+
// create mesh
SMESH::SMESH_Mesh_var mesh = createMesh();
// publish mesh in the study
+ SALOMEDS::SObject_var aSO;
if ( CanPublishInStudy( mesh ) )
- PublishMesh( myCurrentStudy, mesh.in(), (*it).c_str() );
-
+ aSO = PublishMesh( myCurrentStudy, mesh.in(), (*it).c_str() );
+ if ( !aSO->_is_nil() ) {
+ // Python Dump
+ aStr += aSO->GetID();
+ } else {
+ // Python Dump
+ aStr += "mesh_";
+ aStr += TCollection_AsciiString(i);
+ }
+
// Read mesh data (groups are published automatically by ImportMEDFile())
SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( mesh ).in() );
ASSERT( meshServant );
theStatus = status1;
aResult[i++] = SMESH::SMESH_Mesh::_duplicate( mesh );
-
- aResultCont.push_back(meshServant->GetID());
}
- aFactory->Register(TInvocationID(aResultCont,
- GetID(),
- "SMESH_Mesh",
- "CreateMeshesFromMED",
- TArgumentCont(1,std::string(theFileName)),
- ""));
+ aStudyBuilder->CommitCommand();
}
+
+ // Update Python script
+ aStr += "], status) = smesh.CreateMeshesFromMED(\"";
+ aStr += Standard_CString(theFileName);
+ aStr += "\")";
+
+ AddToCurrentPyScript(aStr);
+
return aResult._retn();
}
SMESH::SMESH_Mesh_var aMesh = createMesh();
string aFileName; // = boost::filesystem::path(theFileName).leaf();
// publish mesh in the study
- if ( CanPublishInStudy( aMesh ) )
- PublishInStudy( myCurrentStudy, SALOMEDS::SObject::_nil(), aMesh.in(), aFileName.c_str() );
+ if ( CanPublishInStudy( aMesh ) ) {
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder();
+ aStudyBuilder->NewCommand(); // There is a transaction
+ SALOMEDS::SObject_var aSO = PublishInStudy
+ ( myCurrentStudy, SALOMEDS::SObject::_nil(), aMesh.in(), aFileName.c_str() );
+ aStudyBuilder->CommitCommand();
+ if ( !aSO->_is_nil() ) {
+ // Update Python script
+ TCollection_AsciiString aStr (aSO->GetID());
+ aStr += " = smesh.CreateMeshesFromSTL(\"";
+ aStr += Standard_CString(theFileName);
+ aStr += "\")";
+
+ AddToCurrentPyScript(aStr);
+ }
+ }
SMESH_Mesh_i* aServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( aMesh ).in() );
ASSERT( aServant );
THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference",
SALOME::BAD_PARAM );
+ // Update Python script
+ TCollection_AsciiString aStr ("isDone = smesh.Compute(");
+ SMESH_Gen_i::AddObject(aStr, theMesh) += ", ";
+ SMESH_Gen_i::AddObject(aStr, theShapeObject) += ")";
+
+ AddToCurrentPyScript(aStr);
+
+ aStr = "if isDone == 0: print \"Mesh ";
+ SMESH_Gen_i::AddObject(aStr, theMesh) += " computation failed\"";
+ AddToCurrentPyScript(aStr);
+
try {
// get mesh servant
SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() );
{
INFOS( "SMESH_Gen_i::Save" );
- CORBA::Boolean anIsValidScript;
- SALOMEDS::Study_var aStudy = theComponent->GetStudy();
- SALOMEDS::TMPFile_var aDump = DumpPython(aStudy,false,anIsValidScript);
-
// ASSERT( theComponent->GetStudy()->StudyId() == myCurrentStudy->StudyId() )
// san -- in case <myCurrentStudy> differs from theComponent's study,
// use that of the component
theComponent->GetStudy()->StudyId() != myCurrentStudy->StudyId() )
SetCurrentStudy( theComponent->GetStudy() );
+ // Store study contents as a set of python commands
+ SavePython(myCurrentStudy);
+
StudyContext* myStudyContext = GetCurrentStudyContext();
// Declare a byte stream
char* hypname_str = new char[ size ];
aDataset->ReadFromDisk( hypname_str );
hypname = string( hypname_str );
- delete hypname_str;
+ delete [] hypname_str;
aDataset->CloseOnDisk();
}
// --> get hypothesis plugin library name
aDataset->ReadFromDisk( libname_str );
if(MYDEBUG) SCRUTE( libname_str );
libname = string( libname_str );
- delete libname_str;
+ delete [] libname_str;
aDataset->CloseOnDisk();
}
// --> get hypothesis data
char* hypdata_str = new char[ size ];
aDataset->ReadFromDisk( hypdata_str );
hypdata = string( hypdata_str );
- delete hypdata_str;
+ delete [] hypdata_str;
aDataset->CloseOnDisk();
}
}
char* hypname_str = new char[ size ];
aDataset->ReadFromDisk( hypname_str );
hypname = string( hypname_str );
- delete hypname_str;
+ delete [] hypname_str;
aDataset->CloseOnDisk();
}
// --> get algorithm plugin library name
aDataset->ReadFromDisk( libname_str );
if(MYDEBUG) SCRUTE( libname_str );
libname = string( libname_str );
- delete libname_str;
+ delete [] libname_str;
aDataset->CloseOnDisk();
}
// --> get algorithm data
aDataset->ReadFromDisk( hypdata_str );
if(MYDEBUG) SCRUTE( hypdata_str );
hypdata = string( hypdata_str );
- delete hypdata_str;
+ delete [] hypdata_str;
aDataset->CloseOnDisk();
}
}
if(hasData) {
// Read sub-meshes from MED
- if(MYDEBUG) MESSAGE("JFA - Create all sub-meshes");
+ if(MYDEBUG) MESSAGE("Create all sub-meshes");
myReader.CreateAllSubMeshes();
}
else // NODE IDS
{
- int* ids = new int [ aDataset->GetSize() ];
+ int aSize = aDataset->GetSize();
+
+ // for reading files, created from 18.07.2005 till 10.10.2005
+ if (aDataset->GetType() == HDF_STRING)
+ aSize /= sizeof(int);
+
+ int* ids = new int [aSize];
aDataset->ReadFromDisk( ids );
// on face or nodes?
if ( strncmp( aDSName, aEid_DSName, strlen( aEid_DSName )) == 0 ) {
aEids = ids;
- nbEids = aDataset->GetSize();
+ nbEids = aSize;
}
else {
aFids = ids;
- nbFids = aDataset->GetSize();
+ nbFids = aSize;
}
}
} // loop on 5 datasets
// Recompute State (as computed sub-meshes are restored from MED)
if ( !aShapeObject->_is_nil() ) {
- MESSAGE("JFA - Compute State Engine ...");
+ MESSAGE("Compute State Engine ...");
TopoDS_Shape myLocShape = GeomObjectToShape( aShapeObject );
myNewMeshImpl->GetImpl().GetSubMesh(myLocShape)->ComputeStateEngine
(SMESH_subMesh::SUBMESH_RESTORED);
- MESSAGE("JFA - Compute State Engine finished");
+ MESSAGE("Compute State Engine finished");
}
// try to get groups