+# -*- coding: utf-8 -*-
# It is possible to constrain HYBRID with another mesh or group.
# The constraint can refer to the nodes, edges or faces.
# Create the 3D algorithm and hypothesis
HYBRID = smesh.CreateHypothesis('HYBRID_3D', 'HYBRIDEngine')
-HYBRID_Parameters_node = smesh.CreateHypothesis('HYBRID_Parameters', 'HYBRIDEngine')
-#HYBRID_Parameters_node.SetToMeshHoles( 1 )
-HYBRID_Parameters_edge = smesh.CreateHypothesis('HYBRID_Parameters', 'HYBRIDEngine')
-#HYBRID_Parameters_edge.SetToMeshHoles( 1 )
-HYBRID_Parameters_face = smesh.CreateHypothesis('HYBRID_Parameters', 'HYBRIDEngine')
-HYBRID_Parameters_face.SetToMeshHoles( 1 ) # to mesh inside the cylinder
-HYBRID_Parameters_mesh = smesh.CreateHypothesis('HYBRID_Parameters', 'HYBRIDEngine')
-HYBRID_Parameters_mesh.SetToMeshHoles( 1 ) # to mesh inside the cylinder
+HYBRID_Parameters_in = smesh.CreateHypothesis('HYBRID_Parameters', 'HYBRIDEngine')
+HYBRID_Parameters_in.SetBoundaryLayersInward( True )
+HYBRID_Parameters_out = smesh.CreateHypothesis('HYBRID_Parameters', 'HYBRIDEngine')
+HYBRID_Parameters_out.SetBoundaryLayersInward( False ) # to mesh outside the cylinder
# Create the mesh on the cylinder
Mesh_cylindre = smesh.Mesh(cylindre)
Mesh_box_tri.AddHypothesis( BLSURF_Parameters )
Mesh_box_tri.Compute()
-# Create 4 copies of the 2D mesh to test the 3 types of contraints (NODE, EDGE, FACE)
+# Create 2 copies of the 2D mesh to test the 2 types of BoundaryLayers (inward outward)
# from the whole mesh and from groups of elements.
# Then the 3D algo and hypothesis are assigned to them.
-mesh_mesh = smesh.CopyMesh( Mesh_box_tri, 'Enforced by faces of mesh', 0, 0)
-mesh_mesh.AddHypothesis( HYBRID )
-mesh_mesh.AddHypothesis( HYBRID_Parameters_mesh)
+mesh_in = smesh.CopyMesh( Mesh_box_tri, 'inward', 0, 0)
+mesh_in.AddHypothesis( HYBRID )
+mesh_in.AddHypothesis( HYBRID_Parameters_in)
-mesh_node = smesh.CopyMesh( Mesh_box_tri, 'Enforced by group of nodes', 0, 0)
-mesh_node.AddHypothesis( HYBRID )
-mesh_node.AddHypothesis( HYBRID_Parameters_node)
+mesh_out = smesh.CopyMesh( Mesh_box_tri, 'outward', 0, 0)
+mesh_out.AddHypothesis( HYBRID )
+mesh_out.AddHypothesis( HYBRID_Parameters_out)
-mesh_edge = smesh.CopyMesh( Mesh_box_tri, 'Enforced by group of edges', 0, 0)
-mesh_edge.AddHypothesis( HYBRID )
-mesh_edge.AddHypothesis( HYBRID_Parameters_edge)
-
-mesh_face = smesh.CopyMesh( Mesh_box_tri, 'Enforced by group of faces', 0, 0)
-mesh_face.AddHypothesis( HYBRID )
-mesh_face.AddHypothesis( HYBRID_Parameters_face)
# Add the enforced elements
-HYBRID_Parameters_mesh.SetEnforcedMeshWithGroup(Mesh_cylindre.GetMesh(),SMESH.FACE,"faces from cylinder")
-HYBRID_Parameters_node.SetEnforcedMeshWithGroup(face_cyl_nodes,SMESH.NODE,"nodes from face_cyl_nodes")
-HYBRID_Parameters_edge.SetEnforcedMeshWithGroup(face_cyl_edges,SMESH.EDGE,"edges from face_cyl_edges")
-HYBRID_Parameters_face.SetEnforcedMeshWithGroup(face_cyl_faces,SMESH.FACE,"faces from face_cyl_faces")
+#HYBRID_Parameters_in.SetEnforcedMeshWithGroup(Mesh_cylindre.GetMesh(),SMESH.FACE,"faces from cylinder")
+#HYBRID_Parameters_out.SetEnforcedMeshWithGroup(face_cyl_nodes,SMESH.NODE,"nodes from face_cyl_nodes")
#Compute the meshes
-mesh_node.Compute()
-mesh_edge.Compute()
-mesh_face.Compute()
-mesh_mesh.Compute()
+mesh_in.Compute()
+mesh_out.Compute()
# End of script
*/
void SetOptimizationLevel(in short level) raises (SALOME::SALOME_Exception);
short GetOptimizationLevel();
+
+
+ /*!
+ * To mesh Boundary Layers growing inward or outward.
+ * Default is inward.
+ */
+ void SetBoundaryLayersInward(in boolean toBoundaryLayersInward);
+ boolean GetBoundaryLayersInward();
+ /*!
+ * To mesh with element type Tetra Dominant or hexa Dominant in the boundary layers.
+ * Default is Tetra Dominant.
+ */
+ void SetElemGenTetraDominant(in boolean toElemGenTetraDominant);
+ boolean GetElemGenTetraDominant();
+ /*!
+ * To mesh adding extra normals at opening ridges and corners.
+ * Default is no.
+ */
+ void SetAddMultinormals(in boolean toAddMultinormals);
+ boolean GetAddMultinormals();
+ /*!
+ * To mesh smoothing normals at closed ridges and corners.
+ * Default is no.
+ */
+ void SetSmoothNormals(in boolean toSmoothNormals);
+ boolean GetSmoothNormals();
+ /*!
+ * To set height of the first layer.
+ */
+ void SetHeightFirstLayer(in double HFL) raises (SALOME::SALOME_Exception);
+ double GetHeightFirstLayer();
+ /*!
+ * To set boundary layers coefficient of geometric progression.
+ * Default is 1.0
+ */
+ void SetBoundaryLayersProgression(in double BLP) raises (SALOME::SALOME_Exception);
+ double GetBoundaryLayersProgression();
+ /*!
+ * To set multinormals angle threshold at opening ridges.
+ * Default is 30.0
+ */
+ void SetMultinormalsAngle(in double MNA) raises (SALOME::SALOME_Exception);
+ double GetMultinormalsAngle();
+ /*!
+ * To set number of boundary layers.
+ * Default is 1
+ */
+ void SetNbOfBoundaryLayers(in short NBL) raises (SALOME::SALOME_Exception);
+ short GetNbOfBoundaryLayers();
+
+
+
/*!
* Path to working directory
*/
* Set/get/unset an enforced vertex (private method for GUI)
*/
boolean p_SetEnforcedVertex(in double size, in double x, in double y, in double z,
- in string theVertexName, in string theVertexEntry, in string groupName,
- in boolean isCompound) raises (SALOME::SALOME_Exception);
+ in string theVertexName, in string theVertexEntry, in string groupName,
+ in boolean isCompound) raises (SALOME::SALOME_Exception);
boolean SetEnforcedMesh(in SMESH::SMESH_IDSource theSource, in SMESH::ElementType elementType) raises (SALOME::SALOME_Exception);
boolean SetEnforcedMeshWithGroup(in SMESH::SMESH_IDSource theSource, in SMESH::ElementType elementType, in string groupName) raises (SALOME::SALOME_Exception);
<algorithms>
<algorithm type="HYBRID_3D"
- label-id="Tetrahedron (HYBRID)"
+ label-id="Tetrahedron and hexahedron (HYBRID)"
icon-id="mesh_tree_hypo_hybrid.png"
input="TRIA,QUAD"
need-geom="false"
SMESHGUI_GenericHypothesisCreator* GetHypothesisCreator( const QString& aHypType )
{
SMESHGUI_GenericHypothesisCreator* aCreator = NULL;
+
if ( aHypType == "HYBRID_Parameters" )
aCreator = new HYBRIDPluginGUI_HypothesisCreator( aHypType );
return aCreator;
{
GeomToolSelected = NULL;
GeomToolSelected = getGeomSelectionTool();
-
+
iconVertex = QPixmap(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_OBJBROWSER_VERTEX")));
iconCompound = QPixmap(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_OBJBROWSER_COMPOUND")));
// mySelectionMgr = SMESH::GetSelectionMgr(SMESHGUI::GetSMESHGUI());
QFrame* HYBRIDPluginGUI_HypothesisCreator::buildFrame()
{
+ std::cout << std::endl << "!!!!!!!!!!!!!!!!!!!!buildFrame TOVERIFY" << std::endl;
QFrame* fr = new QFrame( 0 );
QVBoxLayout* lay = new QVBoxLayout( fr );
lay->setMargin( 5 );
}
myToMeshHolesCheck = new QCheckBox( tr( "HYBRID_TO_MESH_HOLES" ), myStdGroup );
- aStdLayout->addWidget( myToMeshHolesCheck, row, 0, 1, 1 );
+ //aStdLayout->addWidget( myToMeshHolesCheck, row, 0, 1, 1 );
+ myToMeshHolesCheck->hide();
myToMakeGroupsOfDomains = new QCheckBox( tr( "HYBRID_TO_MAKE_DOMAIN_GROUPS" ), myStdGroup );
- aStdLayout->addWidget( myToMakeGroupsOfDomains, row++, 1, 1, 1 );
-
- aStdLayout->addWidget( new QLabel( tr( "HYBRID_OPTIMIZATIOL_LEVEL" ), myStdGroup ), row, 0, 1, 1 );
+ //aStdLayout->addWidget( myToMakeGroupsOfDomains, row++, 1, 1, 1 );
+ myToMakeGroupsOfDomains->hide();
+ //aStdLayout->addWidget( new QLabel( tr( "HYBRID_OPTIMIZATIOL_LEVEL" ), myStdGroup ), row, 0, 1, 1 );
myOptimizationLevelCombo = new QComboBox( myStdGroup );
- aStdLayout->addWidget( myOptimizationLevelCombo, row++, 1, 1, 1 );
+ //aStdLayout->addWidget( myOptimizationLevelCombo, row++, 1, 1, 1 );
+ myOptimizationLevelCombo->hide();
QStringList types;
types << tr( "LEVEL_NONE" ) << tr( "LEVEL_LIGHT" ) << tr( "LEVEL_MEDIUM" ) << tr( "LEVEL_STANDARDPLUS" ) << tr( "LEVEL_STRONG" );
myOptimizationLevelCombo->addItems( types );
+ myBoundaryLayersInwardCheck = new QCheckBox( tr( "HYBRID_LAYERS_INWARD" ), myStdGroup );
+ aStdLayout->addWidget( myBoundaryLayersInwardCheck, row++, 0, 1, 1 );
+ myBoundaryLayersInwardCheck->setToolTip(tr( "HYBRID_LAYERS_Outward" ) ); //"Outward growth if deselected");
+
+ aStdLayout->addWidget( new QLabel( tr( "HYBRID_HeightFirstLayer" ), myStdGroup ), row, 0, 1, 1 );
+ myHeightFirstLayerSpin = new SMESHGUI_SpinBox( myStdGroup );
+ myHeightFirstLayerSpin->RangeStepAndValidator(0., 100., .1, "HeightFirstLayer");
+ aStdLayout->addWidget( myHeightFirstLayerSpin, row++, 1, 1, 1 );
+
+ aStdLayout->addWidget( new QLabel( tr( "HYBRID_NbOfBoundaryLayers" ), myStdGroup ), row, 0, 1, 1 );
+ myNbOfBoundaryLayersSpin = new QSpinBox( myStdGroup );
+ aStdLayout->addWidget( myNbOfBoundaryLayersSpin, row++, 1, 1, 1 );
+
+ aStdLayout->addWidget( new QLabel( tr( "HYBRID_BoundaryLayersProgression" ), myStdGroup ), row, 0, 1, 1 );
+ myBoundaryLayersProgressionSpin = new SMESHGUI_SpinBox( myStdGroup );
+ myBoundaryLayersProgressionSpin->RangeStepAndValidator(0., 10., .1, "BoundaryLayersProgression");
+ aStdLayout->addWidget( myBoundaryLayersProgressionSpin, row++, 1, 1, 1 );
+
+ myElemGenTetraDominantCheck = new QCheckBox( tr( "HYBRID_TETRA_DOMINANT" ), myStdGroup );
+ aStdLayout->addWidget( myElemGenTetraDominantCheck, row++, 0, 1, 1 );
+
+ myAddMultinormalsCheck = new QCheckBox( tr( "HYBRID_ADD_MULTINORMALS" ), myStdGroup );
+ aStdLayout->addWidget( myAddMultinormalsCheck, row++, 0, 1, 1 );
+
+ aStdLayout->addWidget( new QLabel( tr( "HYBRID_MULTINORMAL_ANGLE" ), myStdGroup ), row, 0, 1, 1 );
+ myMultinormalsAngleSpin = new SMESHGUI_SpinBox( myStdGroup );
+ myMultinormalsAngleSpin->RangeStepAndValidator(0., 90., 2., "threshold");
+ aStdLayout->addWidget( myMultinormalsAngleSpin, row++, 1, 1, 1 );
+
+ mySmoothNormalsCheck = new QCheckBox( tr( "HYBRID_SMOOTH_NORMALS" ), myStdGroup );
+ aStdLayout->addWidget( mySmoothNormalsCheck, row++, 0, 1, 1 );
aStdLayout->setRowStretch( row, 10 );
// advanced parameters
myAdvWidget->initialMemoryLabel ->setText (tr( "MEGABYTE" ));
myAdvWidget->maxMemoryLabel ->setText (tr( "MEGABYTE" ));
-
- myAdvWidget->workingDirectoryLabel ->setText (tr( "WORKING_DIR" ));
+
myAdvWidget->workingDirectoryPushButton ->setText (tr( "SELECT_DIR" ));
myAdvWidget->keepWorkingFilesCheck ->setText (tr( "KEEP_WORKING_FILES" ));
myAdvWidget->verboseLevelLabel ->setText (tr( "VERBOSE_LEVEL" ));
myAdvWidget->logGroupBox ->setTitle(tr( "LOG_GROUP_TITLE" ));
myAdvWidget->advancedMeshingGroupBox ->setTitle(tr( "ADVANCED_MESHING_GROUP_TITLE" ));
+ myAdvWidget->memoryGroupBox->hide();
+
+ myAdvWidget->createNewNodesCheck->hide();
+ //myAdvWidget->createNewNodesLabel->hide();
+ myAdvWidget->removeInitialCentralPointCheck->hide();
+ myAdvWidget->boundaryRecoveryCheck->hide();
+ myAdvWidget->FEMCorrectionCheck->hide();
+ myAdvWidget->gradationLabel->hide();
+ myAdvWidget->gradationSpinBox->hide();
+
myAdvWidget->createNewNodesCheck ->setText (tr( "TO_ADD_NODES" ));
myAdvWidget->removeInitialCentralPointCheck->setText (tr( "NO_INITIAL_CENTRAL_POINT" ));
myAdvWidget->boundaryRecoveryCheck ->setText (tr( "RECOVERY_VERSION" ));
// connections
//connect( myToMeshHolesCheck, SIGNAL( toggled( bool ) ), this, SLOT( onToMeshHoles(bool)));
- connect( myAdvWidget->maxMemoryCheck, SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
- connect( myAdvWidget->initialMemoryCheck, SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
- connect( myAdvWidget->boundaryRecoveryCheck, SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
+ //connect( myAdvWidget->maxMemoryCheck, SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
+ //connect( myAdvWidget->initialMemoryCheck, SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
+ //connect( myAdvWidget->boundaryRecoveryCheck, SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
+
+ connect( myBoundaryLayersInwardCheck, SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
+ connect( myElemGenTetraDominantCheck, SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
+ connect( myAddMultinormalsCheck, SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
+ connect( mySmoothNormalsCheck, SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
+
connect( myAdvWidget->logInFileCheck, SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
connect( myAdvWidget->keepWorkingFilesCheck, SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
connect( myAdvWidget->workingDirectoryPushButton, SIGNAL( clicked() ), this, SLOT( onDirBtnClicked() ) );
// connect( myEnfMeshConstraint, SIGNAL( currentIndexChanged(int) ), this, SLOT( checkEnfMeshIsDefined() ) );
// connect( this, SIGNAL( enfMeshDefined(bool) ), addEnfMeshButton, SLOT( setEnabled(bool) ) );
+ std::cout << std::endl << "!!!!!!!!!!!!!!!!!!!!buildFrame TOVERIFY end" << std::endl;
return fr;
}
void HYBRIDPluginGUI_HypothesisCreator::updateWidgets()
{
+ //customs automatic set
//myToMakeGroupsOfDomains->setEnabled( myToMeshHolesCheck->isChecked() );
- myAdvWidget->maxMemorySpin->setEnabled( myAdvWidget->maxMemoryCheck->isChecked() );
- myAdvWidget->initialMemoryCheck->setEnabled( !myAdvWidget->boundaryRecoveryCheck->isChecked() );
- myAdvWidget->initialMemorySpin->setEnabled( myAdvWidget->initialMemoryCheck->isChecked() && !myAdvWidget->boundaryRecoveryCheck->isChecked() );
- myOptimizationLevelCombo->setEnabled( !myAdvWidget->boundaryRecoveryCheck->isChecked() );
+ //myAdvWidget->maxMemorySpin->setEnabled( myAdvWidget->maxMemoryCheck->isChecked() );
+ //myAdvWidget->initialMemoryCheck->setEnabled( !myAdvWidget->boundaryRecoveryCheck->isChecked() );
+ //myAdvWidget->initialMemorySpin->setEnabled( myAdvWidget->initialMemoryCheck->isChecked() && !myAdvWidget->boundaryRecoveryCheck->isChecked() );
+ //myOptimizationLevelCombo->setEnabled( !myAdvWidget->boundaryRecoveryCheck->isChecked() );
+ myMultinormalsAngleSpin->setEnabled( myAddMultinormalsCheck->isChecked() );
if ( sender() == myAdvWidget->logInFileCheck ||
sender() == myAdvWidget->keepWorkingFilesCheck )
{
bool logFileRemovable = myAdvWidget->logInFileCheck->isChecked() &&
!myAdvWidget->keepWorkingFilesCheck->isChecked();
-
+
myAdvWidget->removeLogOnSuccessCheck->setEnabled( logFileRemovable );
}
}
myAdvWidget->initialMemoryCheck ->setChecked ( data.myInitialMemory > 0 );
myAdvWidget->initialMemorySpin ->setValue ( qMax( data.myInitialMemory,
myAdvWidget->initialMemorySpin->minimum() ));
+
+ myBoundaryLayersInwardCheck -> setChecked ( data.myBoundaryLayersInward );
+ myElemGenTetraDominantCheck -> setChecked ( data.myElemGenTetraDominant );
+ myAddMultinormalsCheck -> setChecked ( data.myAddMultinormals );
+ mySmoothNormalsCheck -> setChecked ( data.mySmoothNormals );
+ myHeightFirstLayerSpin -> setValue( data.myHeightFirstLayer );
+ myNbOfBoundaryLayersSpin -> setValue( data.myNbOfBoundaryLayers );
+ myBoundaryLayersProgressionSpin -> setValue( data.myBoundaryLayersProgression );
+ myMultinormalsAngleSpin -> setValue( data.myMultinormalsAngle );
+
myAdvWidget->workingDirectoryLineEdit ->setText ( data.myWorkingDir );
- myAdvWidget->keepWorkingFilesCheck ->setChecked ( data.myKeepFiles );
+ myAdvWidget->keepWorkingFilesCheck ->setChecked ( data.myKeepFiles );
myAdvWidget->verboseLevelSpin ->setValue ( data.myVerboseLevel );
myAdvWidget->createNewNodesCheck ->setChecked ( data.myToCreateNewNodes );
myAdvWidget->removeInitialCentralPointCheck ->setChecked ( data.myRemoveInitialCentralPoint );
h_data.myInitialMemory = h->GetInitialMemory();
h_data.myInitialMemory = h->GetInitialMemory();
h_data.myOptimizationLevel = h->GetOptimizationLevel();
+
+ h_data.myBoundaryLayersInward = h->GetBoundaryLayersInward();
+ h_data.myElemGenTetraDominant = h->GetElemGenTetraDominant();
+ h_data.myAddMultinormals = h->GetAddMultinormals();
+ h_data.mySmoothNormals = h->GetSmoothNormals();
+ h_data.myHeightFirstLayer = h->GetHeightFirstLayer();
+ h_data.myBoundaryLayersProgression = h->GetBoundaryLayersProgression();
+ h_data.myMultinormalsAngle = h->GetMultinormalsAngle();
+ h_data.myNbOfBoundaryLayers = h->GetNbOfBoundaryLayers();
+
h_data.myKeepFiles = h->GetKeepFiles();
h_data.myWorkingDir = h->GetWorkingDirectory();
h_data.myVerboseLevel = h->GetVerboseLevel();
SMESH::SetName( SMESH::FindSObject( h ), h_data.myName.toLatin1().constData() );
if ( h->GetToMeshHoles() != h_data.myToMeshHoles ) // avoid duplication of DumpPython commands
- h->SetToMeshHoles ( h_data.myToMeshHoles );
+ h->SetToMeshHoles ( h_data.myToMeshHoles );
if ( h->GetToMakeGroupsOfDomains() != h_data.myToMakeGroupsOfDomains )
h->SetToMakeGroupsOfDomains( h_data.myToMakeGroupsOfDomains );
if ( h->GetMaximumMemory() != h_data.myMaximumMemory )
- h->SetMaximumMemory ( h_data.myMaximumMemory );
+ h->SetMaximumMemory ( h_data.myMaximumMemory );
if ( h->GetInitialMemory() != h_data.myInitialMemory )
- h->SetInitialMemory ( h_data.myInitialMemory );
+ h->SetInitialMemory ( h_data.myInitialMemory );
if ( h->GetInitialMemory() != h_data.myInitialMemory )
- h->SetInitialMemory ( h_data.myInitialMemory );
+ h->SetInitialMemory ( h_data.myInitialMemory );
if ( h->GetOptimizationLevel() != h_data.myOptimizationLevel )
h->SetOptimizationLevel( h_data.myOptimizationLevel );
- if ( h->GetKeepFiles() != h_data.myKeepFiles )
- h->SetKeepFiles ( h_data.myKeepFiles );
+
+ if ( h->GetBoundaryLayersInward() != h_data.myBoundaryLayersInward )
+ h->SetBoundaryLayersInward ( h_data.myBoundaryLayersInward );
+ if ( h->GetElemGenTetraDominant() != h_data.myElemGenTetraDominant )
+ h->SetElemGenTetraDominant ( h_data.myElemGenTetraDominant );
+ if ( h->GetAddMultinormals() != h_data.myAddMultinormals )
+ h->SetAddMultinormals ( h_data.myAddMultinormals );
+ if ( h->GetSmoothNormals() != h_data.mySmoothNormals )
+ h->SetSmoothNormals ( h_data.mySmoothNormals );
+ if ( h->GetHeightFirstLayer() != h_data.myHeightFirstLayer )
+ h->SetHeightFirstLayer ( h_data.myHeightFirstLayer );
+ if ( h->GetBoundaryLayersProgression() != h_data.myBoundaryLayersProgression )
+ h->SetBoundaryLayersProgression ( h_data.myBoundaryLayersProgression );
+ if ( h->GetMultinormalsAngle() != h_data.myMultinormalsAngle )
+ h->SetMultinormalsAngle ( h_data.myMultinormalsAngle );
+ if ( h->GetNbOfBoundaryLayers() != h_data.myNbOfBoundaryLayers )
+ h->SetNbOfBoundaryLayers ( h_data.myNbOfBoundaryLayers );
+
+ if ( h->GetKeepFiles() != h_data.myKeepFiles)
+ h->SetKeepFiles ( h_data.myKeepFiles);
if ( h->GetWorkingDirectory() != h_data.myWorkingDir )
- h->SetWorkingDirectory ( h_data.myWorkingDir.toLatin1().constData() );
- if ( h->GetVerboseLevel() != h_data.myVerboseLevel )
- h->SetVerboseLevel ( h_data.myVerboseLevel );
+ h->SetWorkingDirectory ( h_data.myWorkingDir.toLatin1().constData() );
+ if ( h->GetVerboseLevel() != h_data.myVerboseLevel )
+ h->SetVerboseLevel ( h_data.myVerboseLevel );
if ( h->GetToCreateNewNodes() != h_data.myToCreateNewNodes )
- h->SetToCreateNewNodes( h_data.myToCreateNewNodes );
+ h->SetToCreateNewNodes ( h_data.myToCreateNewNodes );
if ( h->GetToRemoveCentralPoint() != h_data.myRemoveInitialCentralPoint )
- h->SetToRemoveCentralPoint( h_data.myRemoveInitialCentralPoint );
+ h->SetToRemoveCentralPoint ( h_data.myRemoveInitialCentralPoint );
if ( h->GetToUseBoundaryRecoveryVersion() != h_data.myBoundaryRecovery )
- h->SetToUseBoundaryRecoveryVersion( h_data.myBoundaryRecovery );
+ h->SetToUseBoundaryRecoveryVersion ( h_data.myBoundaryRecovery );
if ( h->GetFEMCorrection() != h_data.myFEMCorrection )
- h->SetFEMCorrection ( h_data.myFEMCorrection );
- if ( h->GetGradation() != h_data.myGradation )
- h->SetGradation ( h_data.myGradation );
- if ( h->GetTextOption() != h_data.myTextOption )
+ h->SetFEMCorrection ( h_data.myFEMCorrection );
+ if ( h->GetGradation() != h_data.myGradation )
+ h->SetGradation ( h_data.myGradation );
+ if ( h->GetTextOption() != h_data.myTextOption )
h->SetTextOption ( h_data.myTextOption.toLatin1().constData() );
- if ( h->GetStandardOutputLog() != h_data.myLogInStandardOutput )
- h->SetStandardOutputLog( h_data.myLogInStandardOutput );
- if ( h->GetRemoveLogOnSuccess() != h_data.myRemoveLogOnSuccess )
- h->SetRemoveLogOnSuccess( h_data.myRemoveLogOnSuccess );
+ if ( h->GetStandardOutputLog() != h_data.myLogInStandardOutput )
+ h->SetStandardOutputLog ( h_data.myLogInStandardOutput );
+ if ( h->GetRemoveLogOnSuccess() != h_data.myRemoveLogOnSuccess )
+ h->SetRemoveLogOnSuccess ( h_data.myRemoveLogOnSuccess );
// Enforced vertices
int nbVertex = (int) h_data.myEnforcedVertices.size();
h_data.myMaximumMemory = myAdvWidget->maxMemoryCheck->isChecked() ? myAdvWidget->maxMemorySpin->value() : -1;
h_data.myInitialMemory = myAdvWidget->initialMemoryCheck->isChecked() ? myAdvWidget->initialMemorySpin->value() : -1;
h_data.myOptimizationLevel = myOptimizationLevelCombo->currentIndex();
+
+ h_data.myBoundaryLayersInward = myBoundaryLayersInwardCheck->isChecked();
+ h_data.myElemGenTetraDominant = myElemGenTetraDominantCheck->isChecked();
+ h_data.myAddMultinormals = myAddMultinormalsCheck->isChecked();
+ h_data.mySmoothNormals = mySmoothNormalsCheck->isChecked();
+
+ h_data.myHeightFirstLayer = myHeightFirstLayerSpin -> value();
+ h_data.myNbOfBoundaryLayers = myNbOfBoundaryLayersSpin -> value();
+ h_data.myBoundaryLayersProgression = myBoundaryLayersProgressionSpin -> value();
+ h_data.myMultinormalsAngle = myMultinormalsAngleSpin -> value();
+
h_data.myKeepFiles = myAdvWidget->keepWorkingFilesCheck->isChecked();
h_data.myWorkingDir = myAdvWidget->workingDirectoryLineEdit->text().trimmed();
h_data.myVerboseLevel = myAdvWidget->verboseLevelSpin->value();
short myVerboseLevel;
TEnfVertexList myEnforcedVertices;
TEnfMeshList myEnforcedMeshes;
+ bool myBoundaryLayersInward,
+ myElemGenTetraDominant,
+ myAddMultinormals,
+ mySmoothNormals;
+ double myHeightFirstLayer,
+ myBoundaryLayersProgression,
+ myMultinormalsAngle;
+ short myNbOfBoundaryLayers;
} HYBRIDHypothesisData;
/*!
QCheckBox* myToMeshHolesCheck;
QCheckBox* myToMakeGroupsOfDomains;
QComboBox* myOptimizationLevelCombo;
-
- QWidget* myAdvGroup;
+ QCheckBox* myBoundaryLayersInwardCheck;
+ QCheckBox* myElemGenTetraDominantCheck;
+ QCheckBox* myAddMultinormalsCheck;
+ QCheckBox* mySmoothNormals;
+ QWidget* myAdvGroup;
HYBRIDPluginGUI_AdvWidget* myAdvWidget;
QWidget* myEnfGroup;
QPushButton* addEnfMeshButton;
QPushButton* removeEnfMeshButton;
- GeomSelectionTools* GeomToolSelected;
-// SVTK_Selector* mySelector;
-// LightApp_SelectionMgr* mySelectionMgr; /* User shape selection */
+ GeomSelectionTools* GeomToolSelected;
+
+ SMESHGUI_SpinBox* myHeightFirstLayerSpin;
+ QSpinBox* myNbOfBoundaryLayersSpin;
+ SMESHGUI_SpinBox* myBoundaryLayersProgressionSpin;
+ SMESHGUI_SpinBox* myMultinormalsAngleSpin;
+ QCheckBox* mySmoothNormalsCheck;
+
};
class EnforcedVertexTableWidgetDelegate : public QItemDelegate
<source>HYBRID_TITLE</source>
<translation>Hypothesis Construction</translation>
</message>
+ <message>
+ <source>HYBRID_LAYERS_INWARD</source>
+ <translation>Inward growth of boundary layers</translation>
+ </message>
+ <message>
+ <source>HYBRID_LAYERS_Outward</source>
+ <translation>Outward growth growth of boundary layers if deselected</translation>
+ </message>
+ <message>
+ <source>HYBRID_TETRA_DOMINANT</source>
+ <translation>Mesh with tetrahedra in the remaining volume</translation>
+ </message>
+ <message>
+ <source>HYBRID_ADD_MULTINORMALS</source>
+ <translation>Add extra normals at opening ridges and corners</translation>
+ </message>
+ <message>
+ <source>HYBRID_MULTINORMAL_ANGLE</source>
+ <translation>Multinormals angle threshold</translation>
+ </message>
+ <message>
+ <source>HYBRID_SMOOTH_NORMALS</source>
+ <translation>Smooth normals at closed ridges and corners</translation>
+ </message>
+ <message>
+ <source>HYBRID_HeightFirstLayer</source>
+ <translation>Height of first layer</translation>
+ </message>
+ <message>
+ <source>HYBRID_NbOfBoundaryLayers</source>
+ <translation>Number of boundary layers</translation>
+ </message>
+ <message>
+ <source>HYBRID_BoundaryLayersProgression</source>
+ <translation>Geometric progression of boundary layers</translation>
+ </message>
<message>
<source>HYBRID_TO_MESH_HOLES</source>
<translation>Mesh holes</translation>
+# -*- coding: utf-8 -*-
# Copyright (C) 2007-2013 CEA/DEN, EDF R&D
#
# This library is free software; you can redistribute it and/or
pass
return self.params
+ """
+ obsolete
## To mesh "holes" in a solid or not. Default is to mesh.
# @param toMesh "mesh holes" flag value
def SetToMeshHoles(self, toMesh):
def SetInitialMemory(self, MB):
self.Parameters().SetInitialMemory(MB)
pass
+ """
+
+ ## To mesh Boundary Layers growing inward or outward.
+ # Default is inward.
+ # @param inward boolean value
+ def SetBoundaryLayersInward(self, inward):
+ self.Parameters().SetBoundaryLayersInward(inward)
+ pass
+
+ ## To mesh with element type Tetra Dominant or hexa Dominant in the boundary layers.
+ # Default is Tetra Dominant.
+ # @param tetraDominant boolean value
+ def SetElemGenTetraDominant(self, tetraDominant);
+ self.Parameters().SetElemGenTetraDominant(tetraDominant)
+ pass
+
+ ## To mesh adding extra normals at opening ridges and corners.
+ # Default is no.
+ # @param addMultinormals boolean value
+ def SetAddMultinormals(self, addMultinormals);
+ self.Parameters().SetAddMultinormals(addMultinormals)
+ pass
+
+ ## To mesh smoothing normals at closed ridges and corners.
+ # Default is no.
+ # @param smoothNormals boolean value
+ def SetSmoothNormals(self, smoothNormals);
+ self.Parameters().SetSmoothNormals(smoothNormals)
+ pass
+
+ ## To set height of the first layer.
+ # Default is 0.0
+ # @param heightFirstLayer double value
+ def SetHeightFirstLayer(self, heightFirstLayer);
+ self.Parameters().SetHeightFirstLayer(heightFirstLayer)
+ pass
+
+ ## To set boundary layers coefficient of geometric progression.
+ # Default is 1.0
+ # @param boundaryLayersProgression double value
+ def SetBoundaryLayersProgression(self, boundaryLayersProgression);
+ self.Parameters().SetBoundaryLayersProgression(boundaryLayersProgression)
+ pass
+
+ ## To set multinormals angle threshold at opening ridges.
+ # Default is 30.0
+ # @param multinormalsAngle double value
+ def SetMultinormalsAngle(self, multinormalsAngle);
+ self.Parameters().SetMultinormalsAngle(multinormalsAngle)
+ pass
+
+ ## To set number of boundary layers.
+ # Default is 1
+ # @param nbOfBoundaryLayers int value
+ def SetNbOfBoundaryLayers(self, nbOfBoundaryLayers);
+ self.Parameters().SetNbOfBoundaryLayers(nbOfBoundaryLayers)
+ pass
## Set path to working directory.
# @param path working directory
//================================================================================
/*!
* \brief returns true if a triangle defined by the nodes is a temporary face on a
- * side facet of pyramid and defines sub-domian inside the pyramid
+ * side facet of pyramid and defines sub-domain inside the pyramid
*/
//================================================================================
//=======================================================================
//function : findShapeID
//purpose : find the solid corresponding to HYBRID sub-domain following
-// the technique proposed in HYBRID manual (available within
-// hybrid installation) in chapter "B.4 Subdomain (sub-region) assignment".
+// the technique proposed in GHS3D manual (available within
+// ghs3d installation) in chapter "B.4 Subdomain (sub-region) assignment".
// In brief: normal of the triangle defined by the given nodes
// points out of the domain it is associated to
//=======================================================================
if (!idx)
return false;
- /* ========================== FACES ========================== */
- /* TRIANGLES ========================== */
+ // ========================== FACES ==========================
+ // TRIANGLES ==========================
SMDS_ElemIteratorPtr eIt =
hasGeom ? theProxyMesh.GetFaces( theHelper.GetSubShape()) : theProxyMesh.GetFaces();
while ( eIt->more() )
}
}
- /* EDGES ========================== */
+ //EDGES ==========================
// Iterate over the enforced edges
for(elemIt = theEnforcedEdges.begin() ; elemIt != theEnforcedEdges.end() ; ++elemIt) {
}
}
- /* ENFORCED TRIANGLES ========================== */
+ //ENFORCED TRIANGLES ==========================
// Iterate over the enforced triangles
for(elemIt = theEnforcedTriangles.begin() ; elemIt != theEnforcedTriangles.end() ; ++elemIt) {
}
- /* ========================== NODES ========================== */
+ //========================== NODES ==========================
vector<const SMDS_MeshNode*> theOrderedNodes, theRequiredNodes;
std::set< std::vector<double> > nodesCoords;
vector<const SMDS_MeshNode*>::const_iterator hybridNodeIt = theNodeByHybridId.begin();
// GmfVertices
std::cout << "Begin writting required nodes in GmfVertices" << std::endl;
std::cout << "Nb vertices: " << theOrderedNodes.size() << std::endl;
- GmfSetKwd(idx, GmfVertices, theOrderedNodes.size()/*+solSize*/);
+ GmfSetKwd(idx, GmfVertices, theOrderedNodes.size()); //theOrderedNodes.size()+solSize)
for (hybridNodeIt = theOrderedNodes.begin();hybridNodeIt != theOrderedNodes.end();++hybridNodeIt) {
GmfSetLin(idx, GmfVertices, (*hybridNodeIt)->X(), (*hybridNodeIt)->Y(), (*hybridNodeIt)->Z(), dummyint);
}
#ifdef WIN32
const char* fileName,
#endif
- HYBRIDPlugin_HYBRID* theAlgo,
+ HYBRIDPlugin_HYBRID* theAlgo,
SMESH_MesherHelper& theHelper,
TopoDS_Shape tabShape[],
double** tabBox,
//=============================================================================
bool HYBRIDPlugin_HYBRID::Compute(SMESH_Mesh& theMesh,
- const TopoDS_Shape& theShape)
+ const TopoDS_Shape& theShape)
{
bool Ok(false);
//SMESHDS_Mesh* meshDS = theMesh.GetMeshDS();
// #ifdef WIN32
// aResultFileName.ToCString(),
// #endif
-// this,
-// /*theMesh, */helper, tabShape, tabBox, _nbShape,
+// this, //theMesh,
+// helper, tabShape, tabBox, _nbShape,
// aHybridIdToNodeMap, aNodeId2NodeIndexMap,
// toMeshHoles,
// nbEnforcedVertices, nbEnforcedNodes,
aNodeGroupByHybridId, anEdgeGroupByHybridId, aFaceGroupByHybridId,
groupsToRemove, toMakeGroupsOfDomains, toMeshHoles);
- removeEmptyGroupsOfDomains( helper.GetMesh(), /*notEmptyAsWell =*/ !toMakeGroupsOfDomains );
+ //removeEmptyGroupsOfDomains( helper.GetMesh(), notEmptyAsWell );
+ removeEmptyGroupsOfDomains( helper.GetMesh(), !toMakeGroupsOfDomains );
//}
*/
//=============================================================================
bool HYBRIDPlugin_HYBRID::Compute(SMESH_Mesh& theMesh,
- SMESH_MesherHelper* theHelper)
+ SMESH_MesherHelper* theHelper)
{
MESSAGE("HYBRIDPlugin_HYBRID::Compute()");
groupsToRemove, toMakeGroupsOfDomains);
updateMeshGroups(theHelper->GetMesh(), groupsToRemove);
- removeEmptyGroupsOfDomains( theHelper->GetMesh(), /*notEmptyAsWell =*/ !toMakeGroupsOfDomains );
+ //removeEmptyGroupsOfDomains( theHelper->GetMesh(), notEmptyAsWell );
+ removeEmptyGroupsOfDomains( theHelper->GetMesh(), !toMakeGroupsOfDomains );
if ( Ok ) {
HYBRIDPlugin_Hypothesis* that = (HYBRIDPlugin_Hypothesis*)this->_hyp;
{
switch ( errNum ) {
case 0:
- return "The surface mesh includes a face of type other than edge, "
- "triangle or quadrilateral. This face type is not supported.";
+ return "error distene 0";
case 1:
- return "Not enough memory for the face table.";
- case 2:
- return "Not enough memory.";
- case 3:
- return "Not enough memory.";
- case 4:
- return "Face is ignored.";
- case 5:
- return "End of file. Some data are missing in the file.";
- case 6:
- return "Read error on the file. There are wrong data in the file.";
- case 7:
- return "the metric file is inadequate (dimension other than 3).";
- case 8:
- return "the metric file is inadequate (values not per vertices).";
- case 9:
- return "the metric file contains more than one field.";
- case 10:
- return "the number of values in the \".bb\" (metric file) is incompatible with the expected"
- "value of number of mesh vertices in the \".noboite\" file.";
- case 12:
- return "Too many sub-domains.";
- case 13:
- return "the number of vertices is negative or null.";
- case 14:
- return "the number of faces is negative or null.";
- case 15:
- return "A face has a null vertex.";
- case 22:
- return "incompatible data.";
- case 131:
- return "the number of vertices is negative or null.";
- case 132:
- return "the number of vertices is negative or null (in the \".mesh\" file).";
- case 133:
- return "the number of faces is negative or null.";
- case 1000:
- return "A face appears more than once in the input surface mesh.";
- case 1001:
- return "An edge appears more than once in the input surface mesh.";
- case 1002:
- return "A face has a vertex negative or null.";
- case 1003:
- return "NOT ENOUGH MEMORY.";
- case 2000:
- return "Not enough available memory.";
- case 2002:
- return "Some initial points cannot be inserted. The surface mesh is probably very bad "
- "in terms of quality or the input list of points is wrong.";
- case 2003:
- return "Some vertices are too close to one another or coincident.";
- case 2004:
- return "Some vertices are too close to one another or coincident.";
- case 2012:
- return "A vertex cannot be inserted.";
- case 2014:
- return "There are at least two points considered as coincident.";
- case 2103:
- return "Some vertices are too close to one another or coincident.";
- case 3000:
- return "The surface mesh regeneration step has failed.";
- case 3009:
- return "Constrained edge cannot be enforced.";
- case 3019:
- return "Constrained face cannot be enforced.";
- case 3029:
- return "Missing faces.";
- case 3100:
- return "No guess to start the definition of the connected component(s).";
- case 3101:
- return "The surface mesh includes at least one hole. The domain is not well defined.";
- case 3102:
- return "Impossible to define a component.";
- case 3103:
- return "The surface edge intersects another surface edge.";
- case 3104:
- return "The surface edge intersects the surface face.";
- case 3105:
- return "One boundary point lies within a surface face.";
- case 3106:
- return "One surface edge intersects a surface face.";
- case 3107:
- return "One boundary point lies within a surface edge.";
- case 3108:
- return "Insufficient memory ressources detected due to a bad quality surface mesh leading "
- "to too many swaps.";
- case 3109:
- return "Edge is unique (i.e., bounds a hole in the surface).";
- case 3122:
- return "Presumably, the surface mesh is not compatible with the domain being processed.";
- case 3123:
- return "Too many components, too many sub-domain.";
- case 3209:
- return "The surface mesh includes at least one hole. "
- "Therefore there is no domain properly defined.";
- case 3300:
- return "Statistics.";
- case 3400:
- return "Statistics.";
- case 3500:
- return "Warning, it is dramatically tedious to enforce the boundary items.";
- case 4000:
- return "Not enough memory at this time, nevertheless, the program continues. "
- "The expected mesh will be correct but not really as large as required.";
- case 4002:
- return "see above error code, resulting quality may be poor.";
- case 4003:
- return "Not enough memory at this time, nevertheless, the program continues (warning).";
- case 8000:
- return "Unknown face type.";
- case 8005:
- case 8006:
- return "End of file. Some data are missing in the file.";
- case 9000:
- return "A too small volume element is detected.";
- case 9001:
- return "There exists at least a null or negative volume element.";
- case 9002:
- return "There exist null or negative volume elements.";
- case 9003:
- return "A too small volume element is detected. A face is considered being degenerated.";
- case 9100:
- return "Some element is suspected to be very bad shaped or wrong.";
- case 9102:
- return "A too bad quality face is detected. This face is considered degenerated.";
- case 9112:
- return "A too bad quality face is detected. This face is degenerated.";
- case 9122:
- return "Presumably, the surface mesh is not compatible with the domain being processed.";
- case 9999:
- return "Abnormal error occured, contact hotline.";
- case 23600:
- return "Not enough memory for the face table.";
- case 23601:
- return "The algorithm cannot run further. "
- "The surface mesh is probably very bad in terms of quality.";
- case 23602:
- return "Bad vertex number.";
- case 1001200:
- return "Cannot close mesh file NomFil.";
- case 1002010:
- return "There are wrong data.";
- case 1002120:
- return "The number of faces is negative or null.";
- case 1002170:
- return "The number of vertices is negative or null in the '.sol' file.";
- case 1002190:
- return "The number of tetrahedra is negative or null.";
- case 1002210:
- return "The number of vertices is negative or null.";
- case 1002211:
- return "A face has a vertex negative or null.";
- case 1002270:
- return "The field is not a size in file NomFil.";
- case 1002280:
- return "A count is wrong in the enclosing box in the .boite.mesh input "
- "file (option '--read_boite').";
- case 1002290:
- return "A tetrahedron has a vertex with a negative number.";
- case 1002300:
- return "the 'MeshVersionFormatted' is not 1 or 2 in the '.mesh' file or the '.sol'.";
- case 1002370:
- return "The number of values in the '.sol' (metric file) is incompatible with "
- "the expected value of number of mesh vertices in the '.mesh' file.";
- case 1003000:
- return "Not enough memory.";
- case 1003020:
- return "Not enough memory for the face table.";
- case 1003050:
- return "Insufficient memory ressources detected due to a bad quality "
- "surface mesh leading to too many swaps.";
- case 1005010:
- return "The surface coordinates of a vertex are differing from the "
- "volume coordinates, probably due to a precision problem.";
- case 1005050:
- return "Invalid dimension. Dimension 3 expected.";
- case 1005100:
- return "A point has a tag 0. This point is probably outside the domain which has been meshed.";
- case 1005103:
- return "The vertices of an element are too close to one another or coincident.";
- case 1005104:
- return "There are at least two points whose distance is very small, and considered as coincident.";
- case 1005105:
- return "Two vertices are too close to one another or coincident.";
- case 1005106:
- return "A vertex cannot be inserted.";
- case 1005107:
- return "Two vertices are too close to one another or coincident. Note : When "
- "this error occurs during the overconstrained processing phase, this is only "
- "a warning which means that it is difficult to break some overconstrained facets.";
- case 1005110:
- return "Two surface edges are intersecting.";
- case 1005120:
- return "A surface edge intersects a surface face.";
- case 1005150:
- return "A boundary point lies within a surface face.";
- case 1005160:
- return "A boundary point lies within a surface edge.";
- case 1005200:
- return "A surface mesh appears more than once in the input surface mesh.";
- case 1005210:
- return "An edge appears more than once in the input surface mesh.";
- case 1005225:
- return "Surface with unvalid triangles.";
- case 1005270:
- return "The metric in the '.sol' file contains more than one field.";
- case 1005300:
- return "The surface mesh includes at least one hole. The domain is not well defined.";
- case 1005301:
- return "Presumably, the surface mesh is not compatible with the domain being processed (warning).";
- case 1005302:
- return "Probable faces overlapping somewher.";
- case 1005320:
- return "The quadratic version does not work with prescribed free edges.";
- case 1005321:
- return "The quadratic version does not work with a volume mesh.";
- case 1005370:
- return "The metric in the '.sol' file is inadequate (values not per vertices).";
- case 1005371:
- return "The number of vertices in the '.sol' is different from the one in the "
- "'.mesh' file for the required vertices (option '--required_vertices').";
- case 1005372:
- return "More than one type in file NomFil. The type must be equal to 1 in the '.sol'"
- "for the required vertices (option '--required_vertices').";
- case 1005515:
- return "Bad vertex number.";
- case 1005560:
- return "No guess to start the definition of the connected component(s).";
- case 1005602:
- return "Some initial points cannot be inserted.";
- case 1005620:
- return "A too bad quality face is detected. This face is considered degenerated.";
- case 1005621:
- return "A too bad quality face is detected. This face is degenerated.";
- case 1005622:
- return "The algorithm cannot run further.";
- case 1005690:
- return "A too small volume element is detected.";
- case 1005691:
- return "A tetrahedra is suspected to be very bad shaped or wrong.";
- case 1005692:
- return "There is at least a null or negative volume element. The resulting mesh"
- "may be inappropriate.";
- case 1005693:
- return "There are some null or negative volume element. The resulting mesh may"
- "be inappropriate.";
- case 1005820:
- return "An edge is unique (i.e., bounds a hole in the surface).";
- case 1007000:
- return "Abnormal or internal error.";
- case 1007010:
- return "Too many components with respect to too many sub-domain.";
- case 1007400:
- return "An internal error has been encountered or a signal has been received. "
- "Current mesh will not be saved.";
- case 1008491:
- return "Impossible to define a component.";
- case 1008410:
- return "There are some overconstrained edges.";
- case 1008420:
- return "There are some overconstrained facets.";
- case 1008422:
- return "Give the number of missing faces (information given when regeneration phase failed).";
- case 1008423:
- return "A constrained face cannot be enforced (information given when regeneration phase failed).";
- case 1008441:
- return "A constrained edge cannot be enforced.";
- case 1008460:
- return "It is dramatically tedious to enforce the boundary items.";
- case 1008480:
- return "The surface mesh regeneration step has failed. A .boite.mesh and .boite.map files are created.";
- case 1008490:
- return "Invalid resulting mesh.";
- case 1008495:
- return "P2 correction not successful.";
- case 1009000:
- return "Program has received an interruption or a termination signal sent by the "
- "user or the system administrator. Current mesh will not be saved.";
+ return "error distene 1";
}
- return "";
+ return "unknown distene error";
}
//================================================================================
//================================================================================
bool HYBRIDPlugin_HYBRID::storeErrorDescription(const TCollection_AsciiString& logFile,
- const _Ghs2smdsConvertor & toSmdsConvertor )
+ const _Ghs2smdsConvertor & toSmdsConvertor )
{
if(_compute_canceled)
return error(SMESH_Comment("interruption initiated by user"));
myMaximumMemory(-1),
myInitialMemory(-1),
myOptimizationLevel(DefaultOptimizationLevel()),
+ myBoundaryLayersInward(DefaultBoundaryLayersInward()),
+ myElemGenTetraDominant(DefaultElemGenTetraDominant()),
+ myAddMultinormals(DefaultAddMultinormals()),
+ mySmoothNormals(DefaultSmoothNormals()),
+ myHeightFirstLayer(DefaultHeightFirstLayer()),
+ myBoundaryLayersProgression(DefaultBoundaryLayersProgression()),
+ myMultinormalsAngle(DefaultMultinormalsAngle()),
+ myNbOfBoundaryLayers(DefaultNbOfBoundaryLayers()),
myWorkingDirectory(DefaultWorkingDirectory()),
myKeepFiles(DefaultKeepFiles()),
myVerboseLevel(DefaultVerboseLevel()),
return (OptimizationLevel) myOptimizationLevel;
}
+
+//=======================================================================
+//function : SetBoundaryLayersInward
+//=======================================================================
+
+void HYBRIDPlugin_Hypothesis::SetBoundaryLayersInward(bool toBoundaryLayersInward)
+{
+ if ( myBoundaryLayersInward != toBoundaryLayersInward ) {
+ myBoundaryLayersInward = toBoundaryLayersInward;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : GetBoundaryLayersInward
+//=======================================================================
+
+bool HYBRIDPlugin_Hypothesis::GetBoundaryLayersInward() const
+{
+ return myBoundaryLayersInward;
+}
+
+//=======================================================================
+//function : SetElemGenTetraDominant
+//=======================================================================
+
+void HYBRIDPlugin_Hypothesis::SetElemGenTetraDominant(bool toElemGenTetraDominant)
+{
+ if ( myElemGenTetraDominant != toElemGenTetraDominant ) {
+ myElemGenTetraDominant = toElemGenTetraDominant;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : GetElemGenTetraDominant
+//=======================================================================
+
+bool HYBRIDPlugin_Hypothesis::GetElemGenTetraDominant() const
+{
+ return myElemGenTetraDominant;
+}
+
+//=======================================================================
+//function : SetAddMultinormals
+//=======================================================================
+
+void HYBRIDPlugin_Hypothesis::SetAddMultinormals(bool toAddMultinormals)
+{
+ if ( myAddMultinormals != toAddMultinormals ) {
+ myAddMultinormals = toAddMultinormals;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : GetAddMultinormals
+//=======================================================================
+
+bool HYBRIDPlugin_Hypothesis::GetAddMultinormals() const
+{
+ return myAddMultinormals;
+}
+
+//=======================================================================
+//function : SetSmoothNormals
+//=======================================================================
+
+void HYBRIDPlugin_Hypothesis::SetSmoothNormals(bool toSmoothNormals)
+{
+ if ( mySmoothNormals != toSmoothNormals ) {
+ mySmoothNormals = toSmoothNormals;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : GetSmoothNormals
+//=======================================================================
+
+bool HYBRIDPlugin_Hypothesis::GetSmoothNormals() const
+{
+ return mySmoothNormals;
+}
+
+//=======================================================================
+//function : SetHeightFirstLayer
+//=======================================================================
+
+void HYBRIDPlugin_Hypothesis::SetHeightFirstLayer(double toHeightFirstLayer)
+{
+ if ( myHeightFirstLayer != toHeightFirstLayer ) {
+ myHeightFirstLayer = toHeightFirstLayer;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : GetHeightFirstLayer
+//=======================================================================
+
+double HYBRIDPlugin_Hypothesis::GetHeightFirstLayer() const
+{
+ return myHeightFirstLayer;
+}
+
+//=======================================================================
+//function : SetBoundaryLayersProgression
+//=======================================================================
+
+void HYBRIDPlugin_Hypothesis::SetBoundaryLayersProgression(double toBoundaryLayersProgression)
+{
+ if ( myBoundaryLayersProgression != toBoundaryLayersProgression ) {
+ myBoundaryLayersProgression = toBoundaryLayersProgression;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : GetBoundaryLayersProgression
+//=======================================================================
+
+double HYBRIDPlugin_Hypothesis::GetBoundaryLayersProgression() const
+{
+ return myBoundaryLayersProgression;
+}
+
+//=======================================================================
+//function : SetMultinormalsAngle
+//=======================================================================
+
+void HYBRIDPlugin_Hypothesis::SetMultinormalsAngle(double toMultinormalsAngle)
+{
+ if ( myMultinormalsAngle != toMultinormalsAngle ) {
+ myMultinormalsAngle = toMultinormalsAngle;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : GetMultinormalsAngle
+//=======================================================================
+
+double HYBRIDPlugin_Hypothesis::GetMultinormalsAngle() const
+{
+ return myMultinormalsAngle;
+}
+
+//=======================================================================
+//function : SetNbOfBoundaryLayers
+//=======================================================================
+
+void HYBRIDPlugin_Hypothesis::SetNbOfBoundaryLayers(short toNbOfBoundaryLayers)
+{
+ if ( myNbOfBoundaryLayers != toNbOfBoundaryLayers ) {
+ myNbOfBoundaryLayers = toNbOfBoundaryLayers;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : GetMultinormalsAngle
+//=======================================================================
+
+short HYBRIDPlugin_Hypothesis::GetNbOfBoundaryLayers() const
+{
+ return myNbOfBoundaryLayers;
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+
+
//=======================================================================
//function : SetWorkingDirectory
//=======================================================================
// return HYBRIDPlugin_Hypothesis::TID2SizeMap();
// }
+//=======================================================================
+//function : DefaultBoundaryLayersInward
+//=======================================================================
+bool HYBRIDPlugin_Hypothesis::DefaultBoundaryLayersInward()
+{
+ return true;
+}
+
+//=======================================================================
+//function : DefaultElemGenTetraDominant
+//=======================================================================
+bool HYBRIDPlugin_Hypothesis::DefaultElemGenTetraDominant()
+{
+ return true;
+}
+
+//=======================================================================
+//function : DefaultAddMultinormals
+//=======================================================================
+bool HYBRIDPlugin_Hypothesis::DefaultAddMultinormals()
+{
+ return false;
+}
+
+//=======================================================================
+//function : DefaultSmoothNormals
+//=======================================================================
+bool HYBRIDPlugin_Hypothesis::DefaultSmoothNormals()
+{
+ return false;
+}
+
+//=======================================================================
+//function : DefaultHeightFirstLayer
+//=======================================================================
+double HYBRIDPlugin_Hypothesis::DefaultHeightFirstLayer()
+{
+ return 0.0; //or epsilon?
+}
+
+//=======================================================================
+//function : DefaultBoundaryLayersProgression
+//=======================================================================
+double HYBRIDPlugin_Hypothesis::DefaultBoundaryLayersProgression()
+{
+ return 1.0;
+}
+
+//=======================================================================
+//function : DefaultMultinormalsAngle
+//=======================================================================
+double HYBRIDPlugin_Hypothesis::DefaultMultinormalsAngle()
+{
+ return 30.0;
+}
+
+//=======================================================================
+//function : DefaultNbOfBoundaryLayers
+//=======================================================================
+short HYBRIDPlugin_Hypothesis::DefaultNbOfBoundaryLayers()
+{
+ return 1;
+}
//=======================================================================
//function : SaveTo
std::ostream & HYBRIDPlugin_Hypothesis::SaveTo(std::ostream & save)
{
- save << (int) myToMeshHoles << " ";
- save << myMaximumMemory << " ";
- save << myInitialMemory << " ";
- save << myOptimizationLevel << " ";
- save << myWorkingDirectory << " ";
- save << (int)myKeepFiles << " ";
- save << myVerboseLevel << " ";
- save << (int)myToCreateNewNodes << " ";
- save << (int)myToUseBoundaryRecoveryVersion << " ";
- save << (int)myToUseFemCorrection << " ";
- save << (int)myToRemoveCentralPoint << " ";
- save << myGradation << " ";
- save << myToMakeGroupsOfDomains << " ";
+ save << (int) myBoundaryLayersInward << " ";
+ save << (int) myElemGenTetraDominant << " ";
+ save << (int) myAddMultinormals << " ";
+ save << (int) mySmoothNormals << " ";
+
+ save << myNbOfBoundaryLayers << " ";
+ save << myHeightFirstLayer << " ";
+ save << myBoundaryLayersProgression << " ";
+ save << myMultinormalsAngle << " ";
+
+ save << (int) myKeepFiles << " ";
+ save << myWorkingDirectory << " ";
+ save << myVerboseLevel << " ";
if (!myTextOption.empty()) {
save << "__OPTIONS_BEGIN__ ";
- save << myTextOption << " ";
+ save << myTextOption << " ";
save << "__OPTIONS_END__ ";
}
isOK = (load >> i);
if (isOK)
- myToMeshHoles = i;
+ myBoundaryLayersInward = (bool) i;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> i);
+ if (isOK)
+ myElemGenTetraDominant = (bool) i;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> i);
+ if (isOK)
+ myAddMultinormals = (bool) i;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> i);
+ if (isOK)
+ mySmoothNormals = (bool) i;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> i);
+ if (isOK)
+ myNbOfBoundaryLayers = (short) i;
else
load.clear(ios::badbit | load.rdstate());
isOK = (load >> d);
if (isOK)
- myMaximumMemory = d;
+ myHeightFirstLayer = d;
else
load.clear(ios::badbit | load.rdstate());
isOK = (load >> d);
if (isOK)
- myInitialMemory = d;
+ myBoundaryLayersProgression = d;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> d);
+ if (isOK)
+ myMultinormalsAngle = d;
else
load.clear(ios::badbit | load.rdstate());
isOK = (load >> i);
if (isOK)
- myOptimizationLevel = i;
+ myKeepFiles = (bool) i;
else
load.clear(ios::badbit | load.rdstate());
else
load.clear(ios::badbit | load.rdstate());
- isOK = (load >> i);
- if (isOK)
- myToCreateNewNodes = (bool) i;
- else
- load.clear(ios::badbit | load.rdstate());
-
- isOK = (load >> i);
- if (isOK)
- myToUseBoundaryRecoveryVersion = (bool) i;
- else
- load.clear(ios::badbit | load.rdstate());
-
- isOK = (load >> i);
- if (isOK)
- myToUseFemCorrection = (bool) i;
- else
- load.clear(ios::badbit | load.rdstate());
-
- isOK = (load >> i);
- if (isOK)
- myToRemoveCentralPoint = (bool) i;
- else
- load.clear(ios::badbit | load.rdstate());
-
- isOK = (load >> d);
- if (isOK)
- myGradation = d;
- else
- load.clear(ios::badbit | load.rdstate());
std::string separator;
bool hasOptions = false;
{
TCollection_AsciiString cmd = GetExeName().c_str();
// check if any option is overridden by hyp->myTextOption
- bool m = hyp ? ( hyp->myTextOption.find("-m") == std::string::npos ) : true;
- bool M = hyp ? ( hyp->myTextOption.find("-M") == std::string::npos ) : true;
- bool c = hyp ? ( hyp->myTextOption.find("-c") == std::string::npos ) : true;
- bool o = hyp ? ( hyp->myTextOption.find("-o") == std::string::npos ) : true;
- bool p0 = hyp ? ( hyp->myTextOption.find("-p0") == std::string::npos ) : true;
- bool C = hyp ? ( hyp->myTextOption.find("-C") == std::string::npos ) : true;
- bool v = hyp ? ( hyp->myTextOption.find("-v") == std::string::npos ) : true;
- bool fem = hyp ? ( hyp->myTextOption.find("-FEM")== std::string::npos ) : true;
- bool rem = hyp ? ( hyp->myTextOption.find("-no_initial_central_point")== std::string::npos ) : true;
- bool gra = hyp ? ( hyp->myTextOption.find("-Dcpropa")== std::string::npos ) : true;
-
- // if use boundary recovery version, few options are allowed
- bool useBndRecovery = !C;
- if ( !useBndRecovery && hyp )
- useBndRecovery = hyp->myToUseBoundaryRecoveryVersion;
-
- // hybrid needs to know amount of memory it may use (MB).
- // Default memory is defined at hybrid installation but it may be not enough,
- // so allow to use about all available memory
- if ( m ) {
- double aMaximumMemory = hyp ? hyp->myMaximumMemory : -1;
- cmd += " -m ";
- if ( aMaximumMemory < 0 )
- cmd += DefaultMaximumMemory();
- else
- cmd += aMaximumMemory;
- }
- if ( M && !useBndRecovery ) {
- double aInitialMemory = hyp ? hyp->myInitialMemory : -1;
- cmd += " -M ";
- if ( aInitialMemory > 0 )
- cmd += aInitialMemory;
- else
- cmd += "100";
- }
- // component to mesh
- // 0 , all components to be meshed
- // 1 , only the main ( outermost ) component to be meshed
- if ( c && !useBndRecovery ) {
- // We always run HYBRID with "to mesh holes'==TRUE (see PAL19680)
- if ( hasShapeToMesh )
- cmd += " -c 0";
- else {
- bool aToMeshHoles = hyp ? hyp->myToMeshHoles : DefaultMeshHoles();
- if ( aToMeshHoles )
- cmd += " -c 0";
- else
- cmd += " -c 1";
- }
- }
-
- // optimization level
- if ( o && hyp && !useBndRecovery ) {
- if ( hyp->myOptimizationLevel >= 0 && hyp->myOptimizationLevel < 5 ) {
- const char* level[] = { "none" , "light" , "standard" , "standard+" , "strong" };
- cmd += " -o ";
- cmd += level[ hyp->myOptimizationLevel ];
- }
- }
-
- // to create internal nodes
- if ( p0 && hyp && !hyp->myToCreateNewNodes ) {
- cmd += " -p0";
- }
+ bool p_v = hyp ? ( hyp->myTextOption.find("-v") == std::string::npos ) : true;
+ //bool p_i = hyp ? ( hyp->myTextOption.find("-i") == std::string::npos ) : true;
+ bool p_o = hyp ? ( hyp->myTextOption.find("-o") == std::string::npos ) : true;
+ bool p_blsi = hyp ? ( hyp->myTextOption.find("-blsi") == std::string::npos ) : true;
+ bool p_blsd = hyp ? ( hyp->myTextOption.find("-blsd") == std::string::npos ) : true;
+ bool p_hotfl = hyp ? ( hyp->myTextOption.find("-hotfl") == std::string::npos ) : true;
+ bool p_nobl = hyp ? ( hyp->myTextOption.find("-nobl") == std::string::npos ) : true;
+ bool p_blgp = hyp ? ( hyp->myTextOption.find("-blgp") == std::string::npos ) : true;
+ bool p_eg = hyp ? ( hyp->myTextOption.find("-eg") == std::string::npos ) : true;
+ bool p_am = hyp ? ( hyp->myTextOption.find("-am") == std::string::npos ) : true;
+ bool p_mat = hyp ? ( hyp->myTextOption.find("-mat") == std::string::npos ) : true;
+ bool p_sn = hyp ? ( hyp->myTextOption.find("-sn") == std::string::npos ) : true;
// verbose mode
- if ( v && hyp ) {
+ if ( p_v && hyp ) {
cmd += " -v ";
cmd += hyp->myVerboseLevel;
}
- // boundary recovery version
- if ( useBndRecovery ) {
- cmd += " -C";
- }
-
- // to use FEM correction
- if ( fem && hyp && hyp->myToUseFemCorrection) {
- cmd += " -FEM";
- }
-
- // to remove initial central point.
- if ( rem && hyp && hyp->myToRemoveCentralPoint) {
- cmd += " -no_initial_central_point";
- }
-
// options as text
if ( hyp && !hyp->myTextOption.empty() ) {
cmd += " ";
cmd += (char*) hyp->myTextOption.c_str();
}
- // to define volumic gradation.
- if ( gra && hyp) {
- cmd += " -Dcpropa=";
- cmd += hyp->myGradation;
- }
-
#ifdef WIN32
cmd += " < NUL";
#endif
if(lastChar != '\\') aTmpDir+='\\';
#else
if(lastChar != '/') aTmpDir+='/';
-#endif
+#endif
TCollection_AsciiString aGenericName = (char*)aTmpDir.c_str();
aGenericName += "HYBRID_";
std::string HYBRIDPlugin_Hypothesis::GetExeName()
{
- return "mg-tetra.exe";
+ return "mg-hybrid.exe";
}
//================================================================================
enum OptimizationLevel { None = 0, Light, Medium, StandardPlus, Strong };
void SetOptimizationLevel(OptimizationLevel level);
OptimizationLevel GetOptimizationLevel() const;
+
+ /*!
+ * To mesh Boundary Layers growing inward or outward.
+ * Default is inward.
+ */
+ void SetBoundaryLayersInward(bool toBoundaryLayersInward);
+ bool GetBoundaryLayersInward() const;
+ /*!
+ * To mesh with element type Tetra Dominant or hexa Dominant in the boundary layers.
+ * Default is Tetra Dominant.
+ */
+ void SetElemGenTetraDominant(bool toElemGenTetraDominant);
+ bool GetElemGenTetraDominant() const;
+ /*!
+ * To mesh adding extra normals at opening ridges and corners.
+ * Default is no.
+ */
+ void SetAddMultinormals(bool toAddMultinormals);
+ bool GetAddMultinormals() const;
+ /*!
+ * To mesh smoothing normals at closed ridges and corners.
+ * Default is no.
+ */
+ void SetSmoothNormals(bool toSmoothNormals);
+ bool GetSmoothNormals() const;
+ /*!
+ * To set height of the first layer.
+ */
+ void SetHeightFirstLayer(double HFL);
+ double GetHeightFirstLayer() const;
+ /*!
+ * To set boundary layers coefficient of geometric progression.
+ * Default is 1.0
+ */
+ void SetBoundaryLayersProgression(double BLP);
+ double GetBoundaryLayersProgression() const;
+ /*!
+ * To set multinormals angle threshold at opening ridges.
+ * Default is 30.0
+ */
+ void SetMultinormalsAngle(double MNA);
+ double GetMultinormalsAngle() const;
+ /*!
+ * To set number of boundary layers.
+ * Default is 1
+ */
+ void SetNbOfBoundaryLayers(short NBL);
+ short GetNbOfBoundaryLayers() const;
+
+
/*!
* Path to working directory
*/
static bool DefaultStandardOutputLog();
static bool DefaultRemoveLogOnSuccess();
static double DefaultGradation();
-
+ static bool DefaultBoundaryLayersInward();
+ static bool DefaultElemGenTetraDominant();
+ static bool DefaultAddMultinormals();
+ static bool DefaultSmoothNormals();
+ static short DefaultNbOfBoundaryLayers();
+ static double DefaultHeightFirstLayer();
+ static double DefaultBoundaryLayersProgression();
+ static double DefaultMultinormalsAngle();
+
static THYBRIDEnforcedVertex DefaultHYBRIDEnforcedVertex() {return THYBRIDEnforcedVertex();}
static THYBRIDEnforcedVertexList DefaultHYBRIDEnforcedVertexList() {return THYBRIDEnforcedVertexList();}
static THYBRIDEnforcedVertexCoordsValues DefaultHYBRIDEnforcedVertexCoordsValues() {return THYBRIDEnforcedVertexCoordsValues();}
static TGeomEntryHYBRIDEnforcedVertexMap DefaultGeomEntryHYBRIDEnforcedVertexMap() {return TGeomEntryHYBRIDEnforcedVertexMap();}
static TGroupNameHYBRIDEnforcedVertexMap DefaultGroupNameHYBRIDEnforcedVertexMap() {return TGroupNameHYBRIDEnforcedVertexMap();}
- static THYBRIDEnforcedMesh DefaultHYBRIDEnforcedMesh() {return THYBRIDEnforcedMesh();}
- static THYBRIDEnforcedMeshList DefaultHYBRIDEnforcedMeshList() {return THYBRIDEnforcedMeshList();}
+ static THYBRIDEnforcedMesh DefaultHYBRIDEnforcedMesh() {return THYBRIDEnforcedMesh();}
+ static THYBRIDEnforcedMeshList DefaultHYBRIDEnforcedMeshList() {return THYBRIDEnforcedMeshList();}
static TEntryHYBRIDEnforcedMeshListMap DefaultEntryHYBRIDEnforcedMeshListMap() {return TEntryHYBRIDEnforcedMeshListMap();}
static TIDSortedNodeGroupMap DefaultIDSortedNodeGroupMap() {return TIDSortedNodeGroupMap();}
static TIDSortedElemGroupMap DefaultIDSortedElemGroupMap() {return TIDSortedElemGroupMap();}
bool myRemoveLogOnSuccess;
std::string myTextOption;
double myGradation;
-
+
+ bool myBoundaryLayersInward;
+ bool myElemGenTetraDominant;
+ bool myAddMultinormals;
+ bool mySmoothNormals;
+ double myHeightFirstLayer;
+ double myBoundaryLayersProgression;
+ double myMultinormalsAngle;
+ short myNbOfBoundaryLayers;
+
THYBRIDEnforcedVertexList _enfVertexList;
THYBRIDEnforcedVertexCoordsValues _enfVertexCoordsSizeList;
THYBRIDEnforcedVertexEntryValues _enfVertexEntrySizeList;
//=======================================================================
//function : HYBRIDPlugin_Hypothesis_i
//=======================================================================
-
HYBRIDPlugin_Hypothesis_i::HYBRIDPlugin_Hypothesis_i (PortableServer::POA_ptr thePOA,
int theStudyId,
::SMESH_Gen* theGenImpl)
//=======================================================================
//function : ~HYBRIDPlugin_Hypothesis_i
//=======================================================================
-
HYBRIDPlugin_Hypothesis_i::~HYBRIDPlugin_Hypothesis_i()
{
MESSAGE( "HYBRIDPlugin_Hypothesis_i::~HYBRIDPlugin_Hypothesis_i" );
//=======================================================================
//function : SetWorkingDirectory
//=======================================================================
-
void HYBRIDPlugin_Hypothesis_i::SetWorkingDirectory(const char* path) throw ( SALOME::SALOME_Exception )
{
if (!path )
//=======================================================================
//function : GetWorkingDirectory
//=======================================================================
-
char* HYBRIDPlugin_Hypothesis_i::GetWorkingDirectory()
{
ASSERT(myBaseImpl);
//=======================================================================
//function : SetKeepFiles
//=======================================================================
-
void HYBRIDPlugin_Hypothesis_i::SetKeepFiles(CORBA::Boolean toKeep)
{
ASSERT(myBaseImpl);
//=======================================================================
//function : GetKeepFiles
//=======================================================================
-
CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetKeepFiles()
{
ASSERT(myBaseImpl);
//=======================================================================
//function : SetVerboseLevel
//=======================================================================
-
void HYBRIDPlugin_Hypothesis_i::SetVerboseLevel(CORBA::Short level)
throw ( SALOME::SALOME_Exception )
{
//=======================================================================
//function : GetVerboseLevel
//=======================================================================
-
CORBA::Short HYBRIDPlugin_Hypothesis_i::GetVerboseLevel()
{
ASSERT(myBaseImpl);
//=======================================================================
//function : SetTextOption
//=======================================================================
-
void HYBRIDPlugin_Hypothesis_i::SetTextOption(const char* option)
{
ASSERT(myBaseImpl);
//=======================================================================
//function : GetTextOption
//=======================================================================
-
char* HYBRIDPlugin_Hypothesis_i::GetTextOption()
{
ASSERT(myBaseImpl);
//=======================================================================
//function : SetStandardOutputLog
//=======================================================================
-
void HYBRIDPlugin_Hypothesis_i::SetStandardOutputLog(CORBA::Boolean logInStandardOutput)
{
ASSERT(myBaseImpl);
//=======================================================================
//function : GetStandardOutputLog
//=======================================================================
-
CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetStandardOutputLog()
{
ASSERT(myBaseImpl);
//=======================================================================
//function : SetRemoveLogOnSuccess
//=======================================================================
-
void HYBRIDPlugin_Hypothesis_i::SetRemoveLogOnSuccess(CORBA::Boolean removeLogOnSuccess)
{
ASSERT(myBaseImpl);
//=======================================================================
//function : GetRemoveLogOnSuccess
//=======================================================================
-
CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetRemoveLogOnSuccess()
{
ASSERT(myBaseImpl);
return this->GetImpl()->GetRemoveLogOnSuccess();
}
+//=======================================================================
+//function : SetBoundaryLayersInward
+//=======================================================================
+void HYBRIDPlugin_Hypothesis_i::SetBoundaryLayersInward(CORBA::Boolean toBoundaryLayersInward)
+{
+ ASSERT(myBaseImpl);
+ this->GetImpl()->SetBoundaryLayersInward(toBoundaryLayersInward);
+ SMESH::TPythonDump() << _this() << ".SetBoundaryLayersInward( " << toBoundaryLayersInward << " )";
+}
+
+//=======================================================================
+//function : GetBoundaryLayersInward
+//=======================================================================
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetBoundaryLayersInward()
+{
+ ASSERT(myBaseImpl);
+ return this->GetImpl()->GetBoundaryLayersInward();
+}
+
+//=======================================================================
+//function : SetElemGenTetraDominant
+//=======================================================================
+void HYBRIDPlugin_Hypothesis_i::SetElemGenTetraDominant(CORBA::Boolean toElemGenTetraDominant)
+{
+ ASSERT(myBaseImpl);
+ this->GetImpl()->SetElemGenTetraDominant(toElemGenTetraDominant);
+ SMESH::TPythonDump() << _this() << ".SetElemGenTetraDominant( " << toElemGenTetraDominant << " )";
+}
+
+//=======================================================================
+//function : GetElemGenTetraDominant
+//=======================================================================
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetElemGenTetraDominant()
+{
+ ASSERT(myBaseImpl);
+ return this->GetImpl()->GetElemGenTetraDominant();
+}
+
+//=======================================================================
+//function : SetAddMultinormals
+//=======================================================================
+void HYBRIDPlugin_Hypothesis_i::SetAddMultinormals(CORBA::Boolean toAddMultinormals)
+{
+ ASSERT(myBaseImpl);
+ this->GetImpl()->SetAddMultinormals(toAddMultinormals);
+ SMESH::TPythonDump() << _this() << ".SetAddMultinormals( " << toAddMultinormals << " )";
+}
+
+//=======================================================================
+//function : GetAddMultinormals
+//=======================================================================
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetAddMultinormals()
+{
+ ASSERT(myBaseImpl);
+ return this->GetImpl()->GetAddMultinormals();
+}
+
+//=======================================================================
+//function : SetSmoothNormals
+//=======================================================================
+void HYBRIDPlugin_Hypothesis_i::SetSmoothNormals(CORBA::Boolean toSmoothNormals)
+{
+ ASSERT(myBaseImpl);
+ this->GetImpl()->SetSmoothNormals(toSmoothNormals);
+ SMESH::TPythonDump() << _this() << ".SetSmoothNormals( " << toSmoothNormals << " )";
+}
+
+//=======================================================================
+//function : GetSmoothNormals
+//=======================================================================
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetSmoothNormals()
+{
+ ASSERT(myBaseImpl);
+ return this->GetImpl()->GetSmoothNormals();
+}
+
+//=======================================================================
+//function : SetHeightFirstLayer
+//=======================================================================
+void HYBRIDPlugin_Hypothesis_i::SetHeightFirstLayer(CORBA::Double toHeightFirstLayer)
+{
+ ASSERT(myBaseImpl);
+ this->GetImpl()->SetHeightFirstLayer(toHeightFirstLayer);
+ SMESH::TPythonDump() << _this() << ".SetHeightFirstLayer( " << toHeightFirstLayer << " )";
+}
+
+//=======================================================================
+//function : GetHeightFirstLayer
+//=======================================================================
+CORBA::Double HYBRIDPlugin_Hypothesis_i::GetHeightFirstLayer()
+{
+ ASSERT(myBaseImpl);
+ return this->GetImpl()->GetHeightFirstLayer();
+}
+
+//=======================================================================
+//function : SetBoundaryLayersProgression
+//=======================================================================
+void HYBRIDPlugin_Hypothesis_i::SetBoundaryLayersProgression(CORBA::Double toBoundaryLayersProgression)
+{
+ ASSERT(myBaseImpl);
+ this->GetImpl()->SetBoundaryLayersProgression(toBoundaryLayersProgression);
+ SMESH::TPythonDump() << _this() << ".SetBoundaryLayersProgression( " << toBoundaryLayersProgression << " )";
+}
+
+//=======================================================================
+//function : GetBoundaryLayersProgression
+//=======================================================================
+CORBA::Double HYBRIDPlugin_Hypothesis_i::GetBoundaryLayersProgression()
+{
+ ASSERT(myBaseImpl);
+ return this->GetImpl()->GetBoundaryLayersProgression();
+}
+
+//=======================================================================
+//function : SetMultinormalsAngle
+//=======================================================================
+void HYBRIDPlugin_Hypothesis_i::SetMultinormalsAngle(CORBA::Double toMultinormalsAngle)
+{
+ ASSERT(myBaseImpl);
+ this->GetImpl()->SetMultinormalsAngle(toMultinormalsAngle);
+ SMESH::TPythonDump() << _this() << ".SetMultinormalsAngle( " << toMultinormalsAngle << " )";
+}
+
+//=======================================================================
+//function : GetMultinormalsAngle
+//=======================================================================
+CORBA::Double HYBRIDPlugin_Hypothesis_i::GetMultinormalsAngle()
+{
+ ASSERT(myBaseImpl);
+ return this->GetImpl()->GetMultinormalsAngle();
+}
+
+//=======================================================================
+//function : SetNbOfBoundaryLayers
+//=======================================================================
+void HYBRIDPlugin_Hypothesis_i::SetNbOfBoundaryLayers(CORBA::Short toNbOfBoundaryLayers)
+{
+ ASSERT(myBaseImpl);
+ this->GetImpl()->SetNbOfBoundaryLayers(toNbOfBoundaryLayers);
+ SMESH::TPythonDump() << _this() << ".SetNbOfBoundaryLayers( " << toNbOfBoundaryLayers << " )";
+}
+
+//=======================================================================
+//function : GetNbOfBoundaryLayers
+//=======================================================================
+CORBA::Short HYBRIDPlugin_Hypothesis_i::GetNbOfBoundaryLayers()
+{
+ ASSERT(myBaseImpl);
+ return this->GetImpl()->GetNbOfBoundaryLayers();
+}
+
//=======================================================================
//function : SetEnforcedVertex
//=======================================================================
*/
void SetRemoveLogOnSuccess(CORBA::Boolean removeLogOnSuccess);
CORBA::Boolean GetRemoveLogOnSuccess();
+
+ void SetBoundaryLayersInward(CORBA::Boolean toBoundaryLayersInward);
+ CORBA::Boolean GetBoundaryLayersInward();
+
+ void SetElemGenTetraDominant(CORBA::Boolean toElemGenTetraDominant);
+ CORBA::Boolean GetElemGenTetraDominant();
+
+ void SetAddMultinormals(CORBA::Boolean toAddMultinormals);
+ CORBA::Boolean GetAddMultinormals();
+
+ void SetSmoothNormals(CORBA::Boolean toSmoothNormals);
+ CORBA::Boolean GetSmoothNormals();
+
+ void SetHeightFirstLayer(CORBA::Double toHeightFirstLayer);
+ CORBA::Double GetHeightFirstLayer();
+
+ void SetBoundaryLayersProgression(CORBA::Double toBoundaryLayersProgression);
+ CORBA::Double GetBoundaryLayersProgression();
+
+ void SetMultinormalsAngle(CORBA::Double toMultinormalsAngle);
+ CORBA::Double GetMultinormalsAngle();
+
+ void SetNbOfBoundaryLayers(CORBA::Short toNbOfBoundaryLayers);
+ CORBA::Short GetNbOfBoundaryLayers();
+
/*!
* To set an enforced vertex
*/
