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
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() );
+ 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 );
Unexpect aCatch(SALOME_SalomeException);
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() );
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 );
aResult[i++] = SMESH::SMESH_Mesh::_duplicate( mesh );
}
+ 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() );
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
}
}
}
- // maybe a shape was deleted in the study
- if ( !shapeRefFound && !mySMESHDSMesh->ShapeToMesh().IsNull() ) {
- TopoDS_Shape nullShape;
- myLocMesh.ShapeToMesh( nullShape ); // remove shape referring data
- }
// write applied hypotheses if exist
SALOMEDS::SObject_var myHypBranch;
// write applied algorithms if exist
SALOMEDS::SObject_var myAlgoBranch;
found = gotBranch->FindSubObject( GetRefOnAppliedAlgorithmsTag(), myAlgoBranch );
- if ( found && !shapeRefFound ) { // remove applied hyps
+ if ( found && !shapeRefFound ) { // remove applied algos
myCurrentStudy->NewBuilder()->RemoveObjectWithChildren( myAlgoBranch );
}
if ( found && shapeRefFound ) {
mySMESHDSMesh->GetHypothesis( S );
list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
while ( hyp != hypList.end() ) {
- int hypID = (*hyp++)->GetID(); // goto next here because
+ int hypID = (*hyp++)->GetID(); // goto next hyp here because
myLocMesh.RemoveHypothesis( S, hypID ); // hypList changes here
}
}
}
}
// All sub-meshes will be stored in MED file
- myWriter.AddAllSubMeshes();
+ if ( shapeRefFound )
+ myWriter.AddAllSubMeshes();
// groups root sub-branch
SALOMEDS::SObject_var myGroupsBranch;
// Flush current mesh information into MED file
myWriter.Perform();
+ // maybe a shape was deleted in the study
+ if ( !shapeRefFound && !mySMESHDSMesh->ShapeToMesh().IsNull() ) {
+ TopoDS_Shape nullShape;
+ myLocMesh.ShapeToMesh( nullShape ); // remove shape referring data
+ }
// Store node positions on sub-shapes (SMDS_Position):
// Write datasets
if ( nbNodes )
{
- aSize[ 0 ] = nbNodes;
+ aSize[ 0 ] = nbNodes*sizeof(int);
// IDS
string aDSName( onFace ? "Nodes on Faces" : "Nodes on Edges");
- aDataset = new HDFdataset( (char*)aDSName.c_str(), aGroup, HDF_INT32, aSize, 1 );
+ aDataset = new HDFdataset( (char*)aDSName.c_str(), aGroup, HDF_STRING, aSize, 1 );
aDataset->CreateOnDisk();
aDataset->WriteOnDisk( aNodeIDs );
aDataset->CloseOnDisk();
+ aSize[ 0 ] = nbNodes;
// U Positions
aDSName = ( onFace ? "Face U positions" : "Edge positions");
aDataset = new HDFdataset( (char*)aDSName.c_str(), aGroup, HDF_FLOAT64, aSize, 1);
}
}
- // try to get applied hypotheses
- if ( aTopGroup->ExistInternalObject( "Applied Hypotheses" ) ) {
- aGroup = new HDFgroup( "Applied Hypotheses", aTopGroup );
+ // try to get applied algorithms
+ if ( aTopGroup->ExistInternalObject( "Applied Algorithms" ) ) {
+ aGroup = new HDFgroup( "Applied Algorithms", aTopGroup );
aGroup->OpenOnDisk();
- // get number of applied hypotheses
+ // get number of applied algorithms
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->InternalObjectIndentify( j, name_dataset );
- // check if it is a hypothesis
- if ( string( name_dataset ).substr( 0, 3 ) == string( "Hyp" ) ) {
+ // check if it is an algorithm
+ if ( string( name_dataset ).substr( 0, 4 ) == string( "Algo" ) ) {
aDataset = new HDFdataset( name_dataset, aGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
aDataset->ReadFromDisk( refFromFile );
aDataset->CloseOnDisk();
- // san - it is impossible to recover applied hypotheses using their entries within Load() method
+ // san - it is impossible to recover applied algorithms using their entries within Load() method
//SALOMEDS::SObject_var hypSO = myCurrentStudy->FindObjectID( refFromFile );
//CORBA::Object_var hypObject = SObjectToObject( hypSO );
aGroup->CloseOnDisk();
}
- // try to get applied algorithms
- if ( aTopGroup->ExistInternalObject( "Applied Algorithms" ) ) {
- aGroup = new HDFgroup( "Applied Algorithms", aTopGroup );
+ // try to get applied hypotheses
+ if ( aTopGroup->ExistInternalObject( "Applied Hypotheses" ) ) {
+ aGroup = new HDFgroup( "Applied Hypotheses", aTopGroup );
aGroup->OpenOnDisk();
- // get number of applied algorithms
+ // get number of applied hypotheses
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->InternalObjectIndentify( j, name_dataset );
- // check if it is an algorithm
- if ( string( name_dataset ).substr( 0, 4 ) == string( "Algo" ) ) {
+ // check if it is a hypothesis
+ if ( string( name_dataset ).substr( 0, 3 ) == string( "Hyp" ) ) {
aDataset = new HDFdataset( name_dataset, aGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
aDataset->ReadFromDisk( refFromFile );
aDataset->CloseOnDisk();
- // san - it is impossible to recover applied algorithms using their entries within Load() method
+ // san - it is impossible to recover applied hypotheses using their entries within Load() method
//SALOMEDS::SObject_var hypSO = myCurrentStudy->FindObjectID( refFromFile );
//CORBA::Object_var hypObject = SObjectToObject( hypSO );
// myReader.GetSubMesh( aSubMeshDS, subid );
// }
- // try to get applied hypotheses
- if ( aSubGroup->ExistInternalObject( "Applied Hypotheses" ) ) {
- // open "applied hypotheses" HDF group
- aSubSubGroup = new HDFgroup( "Applied Hypotheses", aSubGroup );
+ // try to get applied algorithms
+ if ( aSubGroup->ExistInternalObject( "Applied Algorithms" ) ) {
+ // open "applied algorithms" HDF group
+ aSubSubGroup = new HDFgroup( "Applied Algorithms", aSubGroup );
aSubSubGroup->OpenOnDisk();
- // get number of applied hypotheses
+ // get number of applied algorithms
int aNbSubObjects = aSubSubGroup->nInternalObjects();
for ( int l = 0; l < aNbSubObjects; l++ ) {
char name_dataset[ HDF_NAME_MAX_LEN+1 ];
aSubSubGroup->InternalObjectIndentify( l, name_dataset );
- // check if it is a hypothesis
- if ( string( name_dataset ).substr( 0, 3 ) == string( "Hyp" ) ) {
+ // check if it is an algorithm
+ if ( string( name_dataset ).substr( 0, 4 ) == string( "Algo" ) ) {
aDataset = new HDFdataset( name_dataset, aSubSubGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
char* refFromFile = new char[ size ];
aDataset->ReadFromDisk( refFromFile );
aDataset->CloseOnDisk();
-
+
//SALOMEDS::SObject_var hypSO = myCurrentStudy->FindObjectID( refFromFile );
//CORBA::Object_var hypObject = SObjectToObject( hypSO );
int id = atoi( refFromFile );
}
}
}
- // close "applied hypotheses" HDF group
+ // close "applied algorithms" HDF group
aSubSubGroup->CloseOnDisk();
}
-
- // try to get applied algorithms
- if ( aSubGroup->ExistInternalObject( "Applied Algorithms" ) ) {
- // open "applied algorithms" HDF group
- aSubSubGroup = new HDFgroup( "Applied Algorithms", aSubGroup );
+
+ // try to get applied hypotheses
+ if ( aSubGroup->ExistInternalObject( "Applied Hypotheses" ) ) {
+ // open "applied hypotheses" HDF group
+ aSubSubGroup = new HDFgroup( "Applied Hypotheses", aSubGroup );
aSubSubGroup->OpenOnDisk();
- // get number of applied algorithms
+ // get number of applied hypotheses
int aNbSubObjects = aSubSubGroup->nInternalObjects();
for ( int l = 0; l < aNbSubObjects; l++ ) {
char name_dataset[ HDF_NAME_MAX_LEN+1 ];
aSubSubGroup->InternalObjectIndentify( l, name_dataset );
- // check if it is an algorithm
- if ( string( name_dataset ).substr( 0, 4 ) == string( "Algo" ) ) {
+ // check if it is a hypothesis
+ if ( string( name_dataset ).substr( 0, 3 ) == string( "Hyp" ) ) {
aDataset = new HDFdataset( name_dataset, aSubSubGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
char* refFromFile = new char[ size ];
aDataset->ReadFromDisk( refFromFile );
aDataset->CloseOnDisk();
-
+
//SALOMEDS::SObject_var hypSO = myCurrentStudy->FindObjectID( refFromFile );
//CORBA::Object_var hypObject = SObjectToObject( hypSO );
int id = atoi( refFromFile );
}
}
}
- // close "applied algorithms" HDF group
+ // close "applied hypotheses" HDF group
aSubSubGroup->CloseOnDisk();
}
-
+
// close submesh HDF group
aSubGroup->CloseOnDisk();
}
}
else // NODE IDS
{
- int* ids = new int [ aDataset->GetSize() ];
+ int aSize = aDataset->GetSize()/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