From 61e8600e2d8f6b99dd3d919d9e2570a516a338a5 Mon Sep 17 00:00:00 2001 From: Christian Van Wambeke Date: Tue, 24 Jun 2014 16:39:30 +0200 Subject: [PATCH] with hybrid parameters --- doc/salome/examples/hybrid_enfmesh.py | 46 +- idl/HYBRIDPlugin_Algorithm.idl | 56 ++- resources/HYBRIDPlugin.xml | 2 +- src/GUI/HYBRIDPluginGUI.cxx | 1 + src/GUI/HYBRIDPluginGUI_HypothesisCreator.cxx | 175 +++++-- src/GUI/HYBRIDPluginGUI_HypothesisCreator.h | 26 +- src/GUI/HYBRIDPlugin_msg_en.ts | 36 ++ src/HYBRIDPlugin/HYBRIDPluginBuilder.py | 60 +++ src/HYBRIDPlugin/HYBRIDPlugin_HYBRID.cxx | 320 +------------ src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.cxx | 442 ++++++++++++------ src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.hxx | 75 ++- .../HYBRIDPlugin_Hypothesis_i.cxx | 166 ++++++- .../HYBRIDPlugin_Hypothesis_i.hxx | 25 + 13 files changed, 904 insertions(+), 526 deletions(-) diff --git a/doc/salome/examples/hybrid_enfmesh.py b/doc/salome/examples/hybrid_enfmesh.py index 80bf527..0fb3f06 100644 --- a/doc/salome/examples/hybrid_enfmesh.py +++ b/doc/salome/examples/hybrid_enfmesh.py @@ -1,3 +1,4 @@ +# -*- coding: utf-8 -*- # It is possible to constrain HYBRID with another mesh or group. # The constraint can refer to the nodes, edges or faces. @@ -45,14 +46,10 @@ BLSURF_Parameters2.SetGeometricMesh( 1 ) # 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) @@ -72,36 +69,25 @@ Mesh_box_tri.AddHypothesis( BLSURF ) 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 diff --git a/idl/HYBRIDPlugin_Algorithm.idl b/idl/HYBRIDPlugin_Algorithm.idl index 407a440..35f57b2 100644 --- a/idl/HYBRIDPlugin_Algorithm.idl +++ b/idl/HYBRIDPlugin_Algorithm.idl @@ -96,6 +96,58 @@ module HYBRIDPlugin */ 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 */ @@ -181,8 +233,8 @@ module HYBRIDPlugin * 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); diff --git a/resources/HYBRIDPlugin.xml b/resources/HYBRIDPlugin.xml index 294ccc7..e72e347 100644 --- a/resources/HYBRIDPlugin.xml +++ b/resources/HYBRIDPlugin.xml @@ -55,7 +55,7 @@ resourceMgr()->loadPixmap("GEOM", tr("ICON_OBJBROWSER_VERTEX"))); iconCompound = QPixmap(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_OBJBROWSER_COMPOUND"))); // mySelectionMgr = SMESH::GetSelectionMgr(SMESHGUI::GetSMESHGUI()); @@ -364,6 +364,7 @@ GEOM::GEOM_Gen_var HYBRIDPluginGUI_HypothesisCreator::getGeomEngine() 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 ); @@ -391,18 +392,51 @@ QFrame* HYBRIDPluginGUI_HypothesisCreator::buildFrame() } 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 @@ -424,8 +458,7 @@ QFrame* HYBRIDPluginGUI_HypothesisCreator::buildFrame() 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" )); @@ -436,6 +469,16 @@ QFrame* HYBRIDPluginGUI_HypothesisCreator::buildFrame() 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" )); @@ -615,9 +658,15 @@ QFrame* HYBRIDPluginGUI_HypothesisCreator::buildFrame() // 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() ) ); @@ -645,6 +694,7 @@ QFrame* HYBRIDPluginGUI_HypothesisCreator::buildFrame() // 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; } @@ -1373,17 +1423,19 @@ void HYBRIDPluginGUI_HypothesisCreator::onDirBtnClicked() 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 ); } } @@ -1421,8 +1473,18 @@ void HYBRIDPluginGUI_HypothesisCreator::retrieveParams() const 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 ); @@ -1665,6 +1727,16 @@ bool HYBRIDPluginGUI_HypothesisCreator::readParamsFromHypo( HYBRIDHypothesisData 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(); @@ -1735,39 +1807,57 @@ bool HYBRIDPluginGUI_HypothesisCreator::storeParamsToHypo( const HYBRIDHypothesi 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(); @@ -1859,6 +1949,17 @@ bool HYBRIDPluginGUI_HypothesisCreator::readParamsFromWidgets( HYBRIDHypothesisD 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(); diff --git a/src/GUI/HYBRIDPluginGUI_HypothesisCreator.h b/src/GUI/HYBRIDPluginGUI_HypothesisCreator.h index 0ac08d0..55e230e 100644 --- a/src/GUI/HYBRIDPluginGUI_HypothesisCreator.h +++ b/src/GUI/HYBRIDPluginGUI_HypothesisCreator.h @@ -150,6 +150,14 @@ typedef struct short myVerboseLevel; TEnfVertexList myEnforcedVertices; TEnfMeshList myEnforcedMeshes; + bool myBoundaryLayersInward, + myElemGenTetraDominant, + myAddMultinormals, + mySmoothNormals; + double myHeightFirstLayer, + myBoundaryLayersProgression, + myMultinormalsAngle; + short myNbOfBoundaryLayers; } HYBRIDHypothesisData; /*! @@ -215,8 +223,11 @@ private: QCheckBox* myToMeshHolesCheck; QCheckBox* myToMakeGroupsOfDomains; QComboBox* myOptimizationLevelCombo; - - QWidget* myAdvGroup; + QCheckBox* myBoundaryLayersInwardCheck; + QCheckBox* myElemGenTetraDominantCheck; + QCheckBox* myAddMultinormalsCheck; + QCheckBox* mySmoothNormals; + QWidget* myAdvGroup; HYBRIDPluginGUI_AdvWidget* myAdvWidget; QWidget* myEnfGroup; @@ -245,9 +256,14 @@ private: 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 diff --git a/src/GUI/HYBRIDPlugin_msg_en.ts b/src/GUI/HYBRIDPlugin_msg_en.ts index 77fd925..d9e22f3 100644 --- a/src/GUI/HYBRIDPlugin_msg_en.ts +++ b/src/GUI/HYBRIDPlugin_msg_en.ts @@ -27,6 +27,42 @@ HYBRID_TITLE Hypothesis Construction + + HYBRID_LAYERS_INWARD + Inward growth of boundary layers + + + HYBRID_LAYERS_Outward + Outward growth growth of boundary layers if deselected + + + HYBRID_TETRA_DOMINANT + Mesh with tetrahedra in the remaining volume + + + HYBRID_ADD_MULTINORMALS + Add extra normals at opening ridges and corners + + + HYBRID_MULTINORMAL_ANGLE + Multinormals angle threshold + + + HYBRID_SMOOTH_NORMALS + Smooth normals at closed ridges and corners + + + HYBRID_HeightFirstLayer + Height of first layer + + + HYBRID_NbOfBoundaryLayers + Number of boundary layers + + + HYBRID_BoundaryLayersProgression + Geometric progression of boundary layers + HYBRID_TO_MESH_HOLES Mesh holes diff --git a/src/HYBRIDPlugin/HYBRIDPluginBuilder.py b/src/HYBRIDPlugin/HYBRIDPluginBuilder.py index 4c4b9b7..b289070 100644 --- a/src/HYBRIDPlugin/HYBRIDPluginBuilder.py +++ b/src/HYBRIDPlugin/HYBRIDPluginBuilder.py @@ -1,3 +1,4 @@ +# -*- coding: utf-8 -*- # Copyright (C) 2007-2013 CEA/DEN, EDF R&D # # This library is free software; you can redistribute it and/or @@ -80,6 +81,8 @@ class HYBRID_Algorithm(Mesh_Algorithm): 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): @@ -119,6 +122,63 @@ class HYBRID_Algorithm(Mesh_Algorithm): 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 diff --git a/src/HYBRIDPlugin/HYBRIDPlugin_HYBRID.cxx b/src/HYBRIDPlugin/HYBRIDPlugin_HYBRID.cxx index 1c17bc8..9153b2b 100644 --- a/src/HYBRIDPlugin/HYBRIDPlugin_HYBRID.cxx +++ b/src/HYBRIDPlugin/HYBRIDPlugin_HYBRID.cxx @@ -274,7 +274,7 @@ static char* readMapIntLine(char* ptr, int tab[]) { //================================================================================ /*! * \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 */ //================================================================================ @@ -314,8 +314,8 @@ static bool isTmpFace(const SMDS_MeshNode* node1, //======================================================================= //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 //======================================================================= @@ -1101,8 +1101,8 @@ static bool writeGMFFile(const char* theMesh if (!idx) return false; - /* ========================== FACES ========================== */ - /* TRIANGLES ========================== */ + // ========================== FACES ========================== + // TRIANGLES ========================== SMDS_ElemIteratorPtr eIt = hasGeom ? theProxyMesh.GetFaces( theHelper.GetSubShape()) : theProxyMesh.GetFaces(); while ( eIt->more() ) @@ -1120,7 +1120,7 @@ static bool writeGMFFile(const char* theMesh } } - /* EDGES ========================== */ + //EDGES ========================== // Iterate over the enforced edges for(elemIt = theEnforcedEdges.begin() ; elemIt != theEnforcedEdges.end() ; ++elemIt) { @@ -1175,7 +1175,7 @@ static bool writeGMFFile(const char* theMesh } } - /* ENFORCED TRIANGLES ========================== */ + //ENFORCED TRIANGLES ========================== // Iterate over the enforced triangles for(elemIt = theEnforcedTriangles.begin() ; elemIt != theEnforcedTriangles.end() ; ++elemIt) { @@ -1255,7 +1255,7 @@ static bool writeGMFFile(const char* theMesh } - /* ========================== NODES ========================== */ + //========================== NODES ========================== vector theOrderedNodes, theRequiredNodes; std::set< std::vector > nodesCoords; vector::const_iterator hybridNodeIt = theNodeByHybridId.begin(); @@ -1439,7 +1439,7 @@ static bool writeGMFFile(const char* theMesh // 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); } @@ -2453,7 +2453,7 @@ static bool readResultFile(const int fileOpen, #ifdef WIN32 const char* fileName, #endif - HYBRIDPlugin_HYBRID* theAlgo, + HYBRIDPlugin_HYBRID* theAlgo, SMESH_MesherHelper& theHelper, TopoDS_Shape tabShape[], double** tabBox, @@ -2820,7 +2820,7 @@ static bool readResultFile(const int fileOpen, //============================================================================= bool HYBRIDPlugin_HYBRID::Compute(SMESH_Mesh& theMesh, - const TopoDS_Shape& theShape) + const TopoDS_Shape& theShape) { bool Ok(false); //SMESHDS_Mesh* meshDS = theMesh.GetMeshDS(); @@ -3080,8 +3080,8 @@ bool HYBRIDPlugin_HYBRID::Compute(SMESH_Mesh& theMesh, // #ifdef WIN32 // aResultFileName.ToCString(), // #endif -// this, -// /*theMesh, */helper, tabShape, tabBox, _nbShape, +// this, //theMesh, +// helper, tabShape, tabBox, _nbShape, // aHybridIdToNodeMap, aNodeId2NodeIndexMap, // toMeshHoles, // nbEnforcedVertices, nbEnforcedNodes, @@ -3094,7 +3094,8 @@ bool HYBRIDPlugin_HYBRID::Compute(SMESH_Mesh& theMesh, aNodeGroupByHybridId, anEdgeGroupByHybridId, aFaceGroupByHybridId, groupsToRemove, toMakeGroupsOfDomains, toMeshHoles); - removeEmptyGroupsOfDomains( helper.GetMesh(), /*notEmptyAsWell =*/ !toMakeGroupsOfDomains ); + //removeEmptyGroupsOfDomains( helper.GetMesh(), notEmptyAsWell ); + removeEmptyGroupsOfDomains( helper.GetMesh(), !toMakeGroupsOfDomains ); //} @@ -3155,7 +3156,7 @@ bool HYBRIDPlugin_HYBRID::Compute(SMESH_Mesh& theMesh, */ //============================================================================= bool HYBRIDPlugin_HYBRID::Compute(SMESH_Mesh& theMesh, - SMESH_MesherHelper* theHelper) + SMESH_MesherHelper* theHelper) { MESSAGE("HYBRIDPlugin_HYBRID::Compute()"); @@ -3332,7 +3333,8 @@ bool HYBRIDPlugin_HYBRID::Compute(SMESH_Mesh& theMesh, 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; @@ -3399,289 +3401,11 @@ static const char* translateError(const int errNum) { 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"; } //================================================================================ @@ -3712,7 +3436,7 @@ static char* getIds( char* ptr, int nbIds, vector& ids ) //================================================================================ 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")); diff --git a/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.cxx b/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.cxx index 68971c6..9fd8e6d 100644 --- a/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.cxx +++ b/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.cxx @@ -46,6 +46,14 @@ HYBRIDPlugin_Hypothesis::HYBRIDPlugin_Hypothesis(int hypId, int studyId, SMESH_G 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()), @@ -196,6 +204,179 @@ HYBRIDPlugin_Hypothesis::OptimizationLevel HYBRIDPlugin_Hypothesis::GetOptimizat 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 //======================================================================= @@ -1008,6 +1189,69 @@ bool HYBRIDPlugin_Hypothesis::DefaultStandardOutputLog() // 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 @@ -1015,22 +1259,22 @@ bool HYBRIDPlugin_Hypothesis::DefaultStandardOutputLog() 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__ "; } @@ -1117,25 +1361,55 @@ std::istream & HYBRIDPlugin_Hypothesis::LoadFrom(std::istream & load) 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()); @@ -1167,35 +1441,6 @@ std::istream & HYBRIDPlugin_Hypothesis::LoadFrom(std::istream & load) 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; @@ -1460,104 +1705,31 @@ std::string HYBRIDPlugin_Hypothesis::CommandToRun(const HYBRIDPlugin_Hypothesis* { 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 @@ -1579,7 +1751,7 @@ std::string HYBRIDPlugin_Hypothesis::GetFileName(const HYBRIDPlugin_Hypothesis* if(lastChar != '\\') aTmpDir+='\\'; #else if(lastChar != '/') aTmpDir+='/'; -#endif +#endif TCollection_AsciiString aGenericName = (char*)aTmpDir.c_str(); aGenericName += "HYBRID_"; @@ -1598,7 +1770,7 @@ std::string HYBRIDPlugin_Hypothesis::GetFileName(const HYBRIDPlugin_Hypothesis* std::string HYBRIDPlugin_Hypothesis::GetExeName() { - return "mg-tetra.exe"; + return "mg-hybrid.exe"; } //================================================================================ diff --git a/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.hxx b/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.hxx index 31150ad..0580024 100644 --- a/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.hxx +++ b/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.hxx @@ -148,6 +148,56 @@ public: 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 */ @@ -302,7 +352,15 @@ public: 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();} @@ -311,8 +369,8 @@ public: 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();} @@ -353,7 +411,16 @@ private: 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; diff --git a/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.cxx b/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.cxx index 105ccfb..0a8cb7a 100644 --- a/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.cxx +++ b/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.cxx @@ -47,7 +47,6 @@ //======================================================================= //function : HYBRIDPlugin_Hypothesis_i //======================================================================= - HYBRIDPlugin_Hypothesis_i::HYBRIDPlugin_Hypothesis_i (PortableServer::POA_ptr thePOA, int theStudyId, ::SMESH_Gen* theGenImpl) @@ -63,7 +62,6 @@ HYBRIDPlugin_Hypothesis_i::HYBRIDPlugin_Hypothesis_i (PortableServer::POA_ptr th //======================================================================= //function : ~HYBRIDPlugin_Hypothesis_i //======================================================================= - HYBRIDPlugin_Hypothesis_i::~HYBRIDPlugin_Hypothesis_i() { MESSAGE( "HYBRIDPlugin_Hypothesis_i::~HYBRIDPlugin_Hypothesis_i" ); @@ -190,7 +188,6 @@ CORBA::Short HYBRIDPlugin_Hypothesis_i::GetOptimizationLevel() //======================================================================= //function : SetWorkingDirectory //======================================================================= - void HYBRIDPlugin_Hypothesis_i::SetWorkingDirectory(const char* path) throw ( SALOME::SALOME_Exception ) { if (!path ) @@ -214,7 +211,6 @@ void HYBRIDPlugin_Hypothesis_i::SetWorkingDirectory(const char* path) throw ( SA //======================================================================= //function : GetWorkingDirectory //======================================================================= - char* HYBRIDPlugin_Hypothesis_i::GetWorkingDirectory() { ASSERT(myBaseImpl); @@ -224,7 +220,6 @@ char* HYBRIDPlugin_Hypothesis_i::GetWorkingDirectory() //======================================================================= //function : SetKeepFiles //======================================================================= - void HYBRIDPlugin_Hypothesis_i::SetKeepFiles(CORBA::Boolean toKeep) { ASSERT(myBaseImpl); @@ -235,7 +230,6 @@ void HYBRIDPlugin_Hypothesis_i::SetKeepFiles(CORBA::Boolean toKeep) //======================================================================= //function : GetKeepFiles //======================================================================= - CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetKeepFiles() { ASSERT(myBaseImpl); @@ -245,7 +239,6 @@ CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetKeepFiles() //======================================================================= //function : SetVerboseLevel //======================================================================= - void HYBRIDPlugin_Hypothesis_i::SetVerboseLevel(CORBA::Short level) throw ( SALOME::SALOME_Exception ) { @@ -260,7 +253,6 @@ void HYBRIDPlugin_Hypothesis_i::SetVerboseLevel(CORBA::Short level) //======================================================================= //function : GetVerboseLevel //======================================================================= - CORBA::Short HYBRIDPlugin_Hypothesis_i::GetVerboseLevel() { ASSERT(myBaseImpl); @@ -354,7 +346,6 @@ CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetToRemoveCentralPoint() //======================================================================= //function : SetTextOption //======================================================================= - void HYBRIDPlugin_Hypothesis_i::SetTextOption(const char* option) { ASSERT(myBaseImpl); @@ -365,7 +356,6 @@ void HYBRIDPlugin_Hypothesis_i::SetTextOption(const char* option) //======================================================================= //function : GetTextOption //======================================================================= - char* HYBRIDPlugin_Hypothesis_i::GetTextOption() { ASSERT(myBaseImpl); @@ -400,7 +390,6 @@ CORBA::Double HYBRIDPlugin_Hypothesis_i::GetGradation() //======================================================================= //function : SetStandardOutputLog //======================================================================= - void HYBRIDPlugin_Hypothesis_i::SetStandardOutputLog(CORBA::Boolean logInStandardOutput) { ASSERT(myBaseImpl); @@ -411,7 +400,6 @@ void HYBRIDPlugin_Hypothesis_i::SetStandardOutputLog(CORBA::Boolean logInStandar //======================================================================= //function : GetStandardOutputLog //======================================================================= - CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetStandardOutputLog() { ASSERT(myBaseImpl); @@ -421,7 +409,6 @@ CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetStandardOutputLog() //======================================================================= //function : SetRemoveLogOnSuccess //======================================================================= - void HYBRIDPlugin_Hypothesis_i::SetRemoveLogOnSuccess(CORBA::Boolean removeLogOnSuccess) { ASSERT(myBaseImpl); @@ -432,13 +419,164 @@ void HYBRIDPlugin_Hypothesis_i::SetRemoveLogOnSuccess(CORBA::Boolean removeLogOn //======================================================================= //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 //======================================================================= diff --git a/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.hxx b/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.hxx index 3dbe108..9359d3b 100644 --- a/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.hxx +++ b/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.hxx @@ -144,6 +144,31 @@ class HYBRIDPLUGIN_EXPORT HYBRIDPlugin_Hypothesis_i: */ 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 */ -- 2.39.2