ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-11-11 16:19:16 +05:00
Code Issues Packages Projects Releases Wiki Activity

Revert wrongly integrated merge

Browse Source 
This reverts commit a463e46431, reversing
changes made to 1c35693208.
This commit is contained in:
vsr 2021-03-22 10:14:46 +03:00
parent a463e46431
commit 13e344b872
47 changed files with 83 additions and 6813 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
CMakeLists.txt
View File

@ -195,15 +195,6 @@ IF(NOT WITH_SHAPER_STUDY AND SALOME_BUILD_TESTS)
MESSAGE(WARNING "SHAPERSTUDY is not found; the corresponding tests will be omitted")
ENDIF()
# Find MEDCoupling
# ================
SET(MEDCOUPLING_ROOT_DIR $ENV{MEDCOUPLING_ROOT_DIR} CACHE PATH "Path to the MEDCoupling tool")
IF(EXISTS ${MEDCOUPLING_ROOT_DIR})
FIND_PACKAGE(SalomeMEDCoupling REQUIRED) # will reload HDF5, MEDFile, XDR, etc ...
ELSE(EXISTS ${MEDCOUPLING_ROOT_DIR})
MESSAGE(FATAL_ERROR "We absolutely need the MEDCoupling tool, please define MEDCOUPLING_ROOT_DIR !")
ENDIF(EXISTS ${MEDCOUPLING_ROOT_DIR})
##
## SMESH specifics
##
@ -289,16 +280,6 @@ MARK_AS_ADVANCED(SALOME_INSTALL_PYTHON SALOME_INSTALL_PYTHON_SHARED)
MARK_AS_ADVANCED(SALOME_INSTALL_AMCONFIG_LOCAL SALOME_INSTALL_DOC)
MARK_AS_ADVANCED(SALOME_SMESH_INSTALL_RES_DATA SALOME_SMESH_INSTALL_PLUGINS)
# Specific to ADAPT:
# SET(SALOME_ADAPT_INSTALL_RES_DATA "${SALOME_INSTALL_RES}/adapt" CACHE PATH
# "Install path: SALOME ADAPT specific data")
SET(SALOME_ADAPT_INSTALL_SAMPLES share/salome/adaptsamples CACHE PATH
"Install path: SALOME ADAPT samples")
SET(SALOME_ADAPT_INSTALL_TEST ${SALOME_INSTALL_SCRIPT_SCRIPTS}/test CACHE PATH
"Install path: SALOME ADAPT Test files")
SET(SALOME_ADAPT_INSTALL_RES_DATA "${SALOME_INSTALL_RES}/adapt" CACHE PATH
"Install path: SALOME ADAPT specific data")
# Accumulate environment variables for SMESH module
SALOME_ACCUMULATE_ENVIRONMENT(PYTHONPATH NOCHECK ${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_BINS}
${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_PYTHON}

1
doc/salome/examples/CMakeLists.txt
View File

@ -47,4 +47,3 @@ INSTALL(FILES CTestTestfileInstall.cmake
DESTINATION ${TEST_INSTALL_DIRECTORY}
RENAME CTestTestfile.cmake)
INSTALL(FILES tests.set DESTINATION ${TEST_INSTALL_DIRECTORY})
INSTALL(DIRECTORY MGAdapt_med_files DESTINATION ${TEST_INSTALL_DIRECTORY})

472
doc/salome/examples/MGAdaptTests_without_session.py
View File

@ -1,472 +0,0 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Tests des adaptations par MGAdapt en standalone
Copyright 2021 EDF
Gérald NICOLAS
+33.1.78.19.43.52
"""
__revision__ = "V04.04"
#========================= Les imports - Début ===================================
import sys
import os
import salome
salome.standalone()
salome.salome_init()
import SMESH
from salome.smesh import smeshBuilder
smesh = smeshBuilder.New()
#========================== Les imports - Fin ====================================
#========================= Paramétrage - Début ===================================
# 1. REPDATA = répertoire du cas
REPDATA = "MGAdapt_med_files"
#
# 2. Repérage des données
D_DATA = dict()
D_DATA["01"] = "01" # 2D plan ; carte locale
D_DATA["02"] = "02" # 2D plan ; carte en arrière-plan
D_DATA["03"] = "01" # 2D plan ; taille constante
D_DATA["04"] = "04" # 3D ; carte locale et dernier pas de temps
D_DATA["05"] = "04" # 3D ; carte locale et pas de temps n°1
D_DATA["06"] = "06" # 2D non plan; carte locale
D_DATA["07"] = "07" # 2D plan ; carte locale anisotrope
D_DATA["08"] = "08" # 3D ; carte en arrière-plan anisotrope
D_DATA["10"] = "10" # 2D plan ; carte locale et maillage initial quadratique
D_DATA["11"] = "11" # 2D plan ; carte locale et maillage initial en quadrangles
D_DATA["13"] = "13" # 3D ; carte locale en simple précision et dernier pas de temps
#========================== Paramétrage - Fin ====================================
class MGAdaptTest (object):
"""Test de l'adaptation par MGAdapt
Options facultatives
********************
Le(s) nom du/des tests à passer. Si aucun n'est donné, tous les cas sont passés.
"""
# A. La base
message_info = ""
_verbose = 0
_verbose_max = 0
affiche_aide_globale = 0
# B. Les variables
l_cas = None
rep_test = None
nro_cas = None
cas = None
#=========================== Début de la méthode =================================
def __init__ ( self, liste_option ):
"""Le constructeur de la classe MGAdaptTest"""
self.l_cas = list()
for option in liste_option :
#print (option)
saux = option.upper()
#print (saux)
if saux in ( "-H", "-HELP" ):
self.affiche_aide_globale = 1
elif saux == "-V" :
self._verbose = 1
elif saux == "-VMAX" :
self._verbose = 1
self._verbose_max = 1
else :
self.l_cas.append(option)
if not self.l_cas:
for cle in D_DATA:
self.l_cas.append(cle)
self.l_cas.sort()
if self._verbose_max:
print ("Liste des cas : {}".format(self.l_cas))
#=========================== Fin de la méthode ==================================
#=========================== Début de la méthode =================================
def __del__(self):
"""A la suppression de l'instance de classe"""
if self._verbose_max:
print ("Suppression de l'instance de la classe.")
#=========================== Fin de la méthode ==================================
#=========================== Début de la méthode =================================
def _add_file_in (self, objet_adapt):
"""Ajout du fichier med d'entrée
Entrées/Sorties :
:objet_adapt: l'objet du module
"""
if self._verbose_max:
print ("_add_file_in pour {}".format(self.nro_cas))
ficmed = os.path.join (REPDATA, "test_{}.med".format(D_DATA[self.nro_cas]))
if self._verbose_max:
print ("Fichier {}".format(ficmed))
if not os.path.isfile(ficmed):
erreur = 1
message = "Le fichier {} est inconnu.".format(ficmed)
else:
objet_adapt.setMEDFileIn(ficmed)
erreur = 0
message = ""
return erreur, message
#=========================== Fin de la méthode ==================================
#=========================== Début de la méthode =================================
def _add_file_out (self, objet_adapt):
"""Ajout du fichier de sortie
Entrées/Sorties :
:objet_adapt: l'objet du module
"""
if self._verbose_max:
print ("_add_file_out pour {}".format(self.nro_cas))
ficmed = os.path.join (REPDATA, "test_{}.adapt.tui.med".format(self.nro_cas))
if os.path.isfile(ficmed):
os.remove(ficmed)
objet_adapt.setMEDFileOut(ficmed)
if self._verbose:
print (". Maillage adapté dans le fichier {}".format(ficmed))
return
#=========================== Fin de la méthode ==================================
#=========================== Début de la méthode =================================
def _add_file_bkg (self, objet_adapt):
"""Ajout du fichier med de fond
Entrées/Sorties :
:objet_adapt: l'objet du module
"""
if self._verbose_max:
print ("_add_file_bkg pour {}".format(self.nro_cas))
ficmed = os.path.join (REPDATA, "test_{}_bg.med".format(D_DATA[self.nro_cas]))
if self._verbose_max:
print ("Fichier {}".format(ficmed))
if not os.path.isfile(ficmed):
erreur = 1
message = "Le fichier {} est inconnu.".format(ficmed)
else:
objet_adapt.setMEDFileBackground(ficmed)
erreur = 0
message = ""
return erreur, message
#=========================== Fin de la méthode ==================================
#=========================== Début de la méthode =================================
def _hypo_creation (self, maptype, option, niveau=3):
"""Création d'une hypothèse
Entrées :
:maptype: type de carte : "Local", "Background", "Constant"
:option: nom du champ si "Local" ou "Background", valeur si "Constant"
:niveau: niveau de verbosité
Sortie :
:hypo: l'objet hypothèse
"""
if self._verbose_max:
print ("_hypo_creation pour {} avec {}".format(maptype,option))
erreur = 0
message = ""
while not erreur :
#--- Création de l'hypothèse ---
hypo = smesh.CreateAdaptationHypothesis()
# Type de données
if ( maptype in ("Local", "Background", "Constant") ):
hypo.setSizeMapType(maptype)
else:
message = "Le type de carte {} est inconnu.".format(maptype)
erreur = 2
break
# Valeur
if ( maptype in ("Local", "Background") ):
hypo.setSizeMapFieldName(option)
else:
hypo.setConstantSize(option)
# Verbosité
self._hypo_verbose (hypo, niveau)
break
return erreur, message, hypo
#=========================== Fin de la méthode ==================================
#=========================== Début de la méthode =================================
def _hypo_verbose (self, hypo, niveau=10):
"""Débogage des hypothèses
Entrées :
:niveau: niveau de verbosité
Entrées/Sorties :
:hypo: l'objet hypothèse
"""
hypo.setVerbosityLevel(niveau)
if self._verbose_max:
hypo.setPrintLogInFile(True)
hypo.setKeepWorkingFiles(True)
hypo.setRemoveOnSuccess(False)
return
#=========================== Fin de la méthode ==================================
#=========================== Début de la méthode =================================
def _calcul (self, objet_adapt, hypo):
"""Calcul
Entrées :
:objet_adapt: l'objet du module
:hypo: l'objet hypothèse
"""
#--- association de l'hypothese à l'objet de l'adaptation
objet_adapt.AddHypothesis(hypo)
#-- Calcul
if self._verbose_max:
print (hypo.getCommandToRun())
erreur = objet_adapt.Compute(False)
if erreur:
message = "Echec dans l'adaptation."
else:
message = ""
return erreur, message
#=========================== Fin de la méthode ==================================
#=========================== Début de la méthode =================================
def _test_00 (self, objet_adapt):
"""Test générique
Entrées/Sorties :
:objet_adapt: l'objet du module
"""
erreur = 0
message = ""
while not erreur :
#--- les fichiers MED ---#
erreur, message = self._add_file_in (objet_adapt)
if erreur:
break
self._add_file_out (objet_adapt)
if self.nro_cas in ("02", "08"):
erreur, message = self._add_file_bkg (objet_adapt)
if erreur:
break
#--- Création de l'hypothèse ---
if self.nro_cas in ("01", "04", "05", "06", "07", "10", "11", "13"):
maptype = "Local"
if self.nro_cas in ("01", "04", "05", "06", "07", "10"):
option = "TAILLE"
elif self.nro_cas in ("11",):
option = "Taille de maille"
elif self.nro_cas in ("13",):
option = "Elevation"
elif self.nro_cas in ("02", "08"):
maptype = "Background"
option = "TAILLE"
elif self.nro_cas in ("03",):
maptype = "Constant"
option = 0.5
if self._verbose:
niveau = 3
elif self._verbose_max:
niveau = 10
else:
niveau = 0
erreur, message, hypo = self._hypo_creation(maptype, option, niveau)
if erreur:
break
#-- Ajout des options
if self.nro_cas in ("04", "06", "07", "08", "10", "11"):
hypo.setTimeStepRankLast()
elif self.nro_cas in ("05",):
hypo.setTimeStepRank(1,1)
elif self.nro_cas in ("13",):
hypo.setTimeStepRank(0,0)
# options facultatives
if self.nro_cas in ("03",):
hypo.setOptionValue("adaptation", "surface")
#-- Calcul
try :
erreur, message = self._calcul (objet_adapt, hypo)
except :
erreur = 1871
message = "Erreur dans le calcul par SMESH"
break
return erreur, message
#=========================== Fin de la méthode ==================================
#=========================== Début de la méthode =================================
def _traitement_cas (self ):
"""Traitement d'un cas
Sorties :
:erreur: code d'erreur
:message: message d'erreur
"""
nom_fonction = __name__ + "/_traitement_cas"
blabla = "\nDans {} :".format(nom_fonction)
if self._verbose_max:
print (blabla)
# 1. Préalables
erreur = 0
message = ""
if self._verbose:
print ("Passage du cas '{}'".format(self.nro_cas))
if ( self.nro_cas in ("01", "02", "03", "04", "05", "06", "07", "08", "10" ,"11" ,"13") ):
objet_adapt = smesh.Adaptation('MG_Adapt')
erreur, message = self._test_00 (objet_adapt)
del objet_adapt
else:
erreur = 1
message = "Le cas '{}' est inconnu.".format(self.nro_cas)
return erreur, message
#=========================== Fin de la méthode ==================================
#=========================== Début de la méthode =================================
def lancement (self):
"""Lancement
Sorties :
:erreur: code d'erreur
:message: message d'erreur
"""
nom_fonction = __name__ + "/lancement"
blabla = "\nDans {} :".format(nom_fonction)
erreur = 0
message = ""
if self._verbose_max:
print (blabla)
for nom_cas in self.l_cas:
self.nro_cas = nom_cas
erreur_t, message_t = self._traitement_cas ()
if erreur_t:
erreur += 1
message += "\nErreur n° {} pour le cas {} :\n".format(erreur_t,nom_cas)
message += message_t
if ( erreur and self._verbose_max ):
print (blabla, message)
return erreur, message
#=========================== Fin de la méthode ==================================
#========================== Fin de la classe ====================================
#==================================================================================
# Lancement
#==================================================================================
if __name__ == "__main__" :
# 1. Options
L_OPTIONS = list()
#L_OPTIONS.append("-h")
#L_OPTIONS.append("-v")
#L_OPTIONS.append("-vmax")
L_OPTIONS.append("01")
L_OPTIONS.append("02")
L_OPTIONS.append("03")
L_OPTIONS.append("07")
L_OPTIONS.append("10")
L_OPTIONS.append("11")
L_OPTIONS.append("04")
L_OPTIONS.append("05")
L_OPTIONS.append("06")
L_OPTIONS.append("08")
#L_OPTIONS.append("13")
# 2. Lancement de la classe
#print ("L_OPTIONS :", L_OPTIONS)
MGADAPT_TEST = MGAdaptTest(L_OPTIONS)
if MGADAPT_TEST.affiche_aide_globale:
sys.stdout.write(MGADAPT_TEST.__doc__+"\n")
else:
ERREUR, MESSAGE_ERREUR = MGADAPT_TEST.lancement()
if ERREUR:
sys.stdout.write(MGADAPT_TEST.__doc__+"\n")
MESSAGE_ERREUR += "\n {} erreur(s)\n".format(ERREUR)
sys.stderr.write(MESSAGE_ERREUR)
#raise Exception(MESSAGE_ERREUR)
assert(False)
del MGADAPT_TEST
#sys.exit(0)

BIN
doc/salome/examples/MGAdapt_med_files/test_01.med
View File

Binary file not shown.

BIN
doc/salome/examples/MGAdapt_med_files/test_02.med
View File

Binary file not shown.

BIN
doc/salome/examples/MGAdapt_med_files/test_02_bg.med
View File

Binary file not shown.

BIN
doc/salome/examples/MGAdapt_med_files/test_04.med
View File

Binary file not shown.

BIN
doc/salome/examples/MGAdapt_med_files/test_06.med
View File

Binary file not shown.

BIN
doc/salome/examples/MGAdapt_med_files/test_07.med
View File

Binary file not shown.

BIN
doc/salome/examples/MGAdapt_med_files/test_08.med
View File

Binary file not shown.

BIN
doc/salome/examples/MGAdapt_med_files/test_08_bg.med
View File

Binary file not shown.

BIN
doc/salome/examples/MGAdapt_med_files/test_10.med
View File

Binary file not shown.

BIN
doc/salome/examples/MGAdapt_med_files/test_11.med
View File

Binary file not shown.

BIN
doc/salome/examples/MGAdapt_med_files/test_13.med
View File

Binary file not shown.

1
doc/salome/examples/tests.set
View File

@ -45,7 +45,6 @@ SET(BAD_TESTS
radial_prism_3d_algo.py
test_smeshplugin_mg_tetra_parallele.py
test_smeshplugins.py
MGAdaptTests_without_session.py
)
SET(GOOD_TESTS

BIN
doc/salome/gui/SMESH/images/adaptation_01.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 27 KiB

BIN
doc/salome/gui/SMESH/images/adaptation_02.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 27 KiB

38
doc/salome/gui/SMESH/input/adaptation.rst
View File

@ -1,38 +0,0 @@
.. _adaptation_page:
**********
Adaptation
**********
Mesh module provides the possibility to perform different adaptations of a mesh.
.. note::
A mesh adaptation based on splitting is available by the HOMARD module.
.. _mg_adapt_anchor:
MG_Adapt
########
For meshes made of triangles and/or tetrahedra, remeshing operations are available with the MG-Adapt plugin. The remeshing is based on wanted mesh sizes defined over the mesh or as a constant. The boundaries are dedeuced from the initial mesh.
To start **Remeshing** operation, select **MG Adapt** tab in **Adaptation** dialog.
.. image:: ../images/adaptation_01.png
:align: center
* **Mesh In** is the initial mesh to remesh.
* **Mesh Out** is the resulting mesh after remeshing. By default, the name of the initial mesh is kept and the file name is based on the name of the initial mesh.
* **Size map definition** is a choice between **Local**, **Background** and **Constant**.
- If the choice is **Background**, the name of the MED file must be given.
- If the choice is **Local** or **Background**, the name of the field must be selected from the list, together with time step.
.. image:: ../images/adaptation_02.png
:align: center
.. note::
The exhaustive description of MG-Adapt can be read into its documentation. It can be reached by the general help button.
**See Also** a sample TUI Script of :ref:`tui_adaptation_page`.

2
doc/salome/gui/SMESH/input/index.rst
View File

@ -23,7 +23,6 @@ Introduction to Mesh module
* :ref:`creating groups <grouping_elements_page>` of mesh elements;
* filtering mesh entities (nodes or elements) using :ref:`Filters <filters_page>` functionality for :ref:`creating groups <grouping_elements_page>` and applying :ref:`mesh modifications <modifying_meshes_page>`;
* :ref:`viewing meshes <viewing_meshes_overview_page>` in the VTK viewer and :ref:`getting info <mesh_infos_page>` on mesh and its sub-objects;
* :ref:`remeshing meshes <adaptation_page>`;
* applying to meshes :ref:`Quality Controls <quality_page>`, allowing to highlight important elements;
* taking various :ref:`measurements <measurements_page>` of the mesh objects.
@ -53,7 +52,6 @@ Mesh module preferences are described in the :ref:`mesh_preferences_page` sectio
grouping_elements
about_filters
about_quality_controls
adaptation
measurements
viewing_meshes_overview
smeshpy_interface

1
doc/salome/gui/SMESH/input/smeshpy_interface.rst
View File

@ -95,7 +95,6 @@ the following links:
tui_transforming_meshes
tui_viewing_meshes
tui_quality_controls
tui_adaptation
tui_measurements
tui_work_on_objects_from_gui
tui_notebook_smesh

18
doc/salome/gui/SMESH/input/tui_adaptation.rst
View File

@ -1,18 +0,0 @@
.. _tui_adaptation_page:
**********
Adaptation
**********
.. _tui_mg_adapt:
MG_Adapt
========
.. literalinclude:: ../../../examples/adaptation_ex01.py
:language: python
:download:`Download this script <../../../examples/adaptation_ex01.py>`
**See Also** the GUI :ref:`adaptation_page`.

1
idl/CMakeLists.txt
View File

@ -36,7 +36,6 @@ SET(SalomeIDLSMESH_IDLSOURCES
SMESH_Pattern.idl
SMESH_MeshEditor.idl
SMESH_Measurements.idl
MG_ADAPT.idl
)
SET(_idl_include_dirs

152
idl/MG_ADAPT.idl
View File

@ -1,152 +0,0 @@
// Copyright (C) 2011-2020 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/
//
// File : MG_ADAPT.hxx
//
#ifndef MG_ADAPT_IDL
#define MG_ADAPT_IDL
#include "SALOME_Component.idl"
#include "SALOME_Exception.idl"
#include "SALOME_GenericObj.idl"
#include "SALOMEDS.idl"
#include "SMESH_Mesh.idl"
module SMESH{
typedef sequence<string> str_array ;
struct MgAdaptHypothesisData
{
string myFileInDir, myMeshFileIn, myInMeshName, myMeshFileBackground, myOutMeshName,
myMeshFileOut, myFileOutDir, myFileSizeMapDir, myFieldName;
boolean fromMedFile;
boolean myPublish, myMeshOutMed;
boolean myUseLocalMap, myUseBackgroundMap, myUseConstantValue;
double myConstantValue;
long myRank, myTimeStep;
boolean myUseNoTimeStep, myUseLastTimeStep, myUseChosenTimeStep;
string myWorkingDir, myLogFile;
boolean myPrintLogInFile, myKeepFiles, myRemoveLogOnSuccess;
long myVerboseLevel;
};
interface MG_ADAPT : SALOME::GenericObj
{
//MG_ADAPT CreateMG_ADAPT(in PortableServer::POA_var poa);
void setData( inout MgAdaptHypothesisData data);
void setMedFileIn(in string MedFileIn );
string getMedFileIn();
void setMedFileOut(in string MedFileOut);
string getMedFileOut();
void setMeshName(in string s);
string getMeshName();
void setMeshNameOut(in string s);
string getMeshNameOut();
void setMeshOutMed(in boolean b);
boolean getMeshOutMed();
void setPublish(in boolean b);
boolean getPublish();
void setSizeMapFieldName(in string s);
string getSizeMapFieldName();
void setTimeStep(in long s);
long getTimeStep() ;
void setTimeStepRank(in long s, in long f);
long getRank();
void setTimeStepRankLast();
void setNoTimeStep();
void setLogFile(in string f);
string getLogFile();
void setVerbosityLevel(in long f);
long getVerbosityLevel();
void setRemoveOnSuccess(in boolean f);
boolean getRemoveOnSuccess();
MgAdaptHypothesisData getData();
void setUseLocalMap(in boolean f);
boolean getUseLocalMap();
void setUseBackgroundMap(in boolean f);
boolean getUseBackgroundMap();
void setUseConstantValue(in boolean f);
boolean getUseConstantValue();
void setConstantSize(in double f);
double getConstantSize() ;
void setSizeMapFile(in string f);
string getSizeMapFile();
void setFromMedFile(in boolean f);
boolean isFromMedFile();
void setKeepWorkingFiles(in boolean f);
boolean getKeepWorkingFiles();
void setPrintLogInFile(in boolean f);
boolean getPrintLogInFile();
void setWorkingDir(in string f);
string getWorkingDir() ;
void setSizeMapType(in string f);
boolean setAll();
string getCommandToRun() ;
void compute() raises(SALOME::SALOME_Exception);
string getErrMsg();
string getFileName() ;
string getExeName();
void copyMgAdaptHypothesisData(in MgAdaptHypothesisData f ) ;
//void checkDirPath(inout string f);
boolean hasOptionDefined( in string optionName ) ;
void setOptionValue(in string optionName, in string optionValue) raises (SALOME::SALOME_Exception);
string getOptionValue(in string optionName, inout boolean isDefault) raises (SALOME::SALOME_Exception);
str_array getCustomOptionValuesStrVec() ;
str_array getOptionValuesStrVec() ;
};
typedef MG_ADAPT MG_ADAPT_HYPOTHESIS;
interface MG_ADAPT_OBJECT : SALOME::GenericObj
{
void setMeshIn(in SMESH_Mesh theMesh ) raises (SALOME::SALOME_Exception);
void setMEDFileIn(in string f) raises (SALOME::SALOME_Exception);
void setMEDFileOut(in string f) raises (SALOME::SALOME_Exception);
void setMEDFileBackground(in string f) raises (SALOME::SALOME_Exception);
void AddHypothesis(in MG_ADAPT mg) raises (SALOME::SALOME_Exception);
long Compute(in boolean Publish) raises (SALOME::SALOME_Exception);
};
};
#endif // MG_ADAPT_IDL

6
idl/SMESH_Gen.idl
View File

@ -43,8 +43,6 @@ module SMESH
interface FilterManager;
interface SMESH_Pattern;
interface Measurements;
interface MG_ADAPT;
interface MG_ADAPT_OBJECT;
/*!
* Tags definition
@ -138,6 +136,7 @@ module SMESH
SMESH_Pattern GetPattern();
Measurements CreateMeasurements();
/*!
Set the current mode
*/
@ -586,9 +585,6 @@ module SMESH
in double theTolerance );
MG_ADAPT CreateMG_ADAPT();
MG_ADAPT_OBJECT Adaptation(in string adaptType);
MG_ADAPT CreateAdaptationHypothesis();
};
};

1
resources/CMakeLists.txt
View File

@ -22,7 +22,6 @@
SET(SMESH_RESOURCES_FILES
ModuleMesh.png
adapt_mg_adapt.png
advanced_mesh_info.png
bare_border_face.png
bare_border_volume.png

8
resources/SalomeApp.xml.in
View File

@ -98,11 +98,6 @@
<parameter name="vol_precision" value="-6" />
<parameter name="selection_increment" value="0" />
<parameter name="controls_increment" value="2" />
<!-- Adaptation -->
<parameter name="mg_adapt_file_mesh_out" value="true" />
<parameter name="mg_adapt_publish_mesh_out" value="false" />
<parameter name="mg_adapt_size_map" value="Local" />
<parameter name="mg_adapt_time_step" value="None" />
</section>
<section name="smesh_help" >
<parameter name="User's Guide/Mesh module/User's Guide" value="%SMESH_ROOT_DIR%/share/doc/salome/gui/SMESH/index.html;;http://docs.salome-platform.org/latest/gui/SMESH/index.html"/>
@ -111,9 +106,6 @@
<parameter name="User's Guide/Mesh module/Plug-ins/MacMesh plugin" value="%SMESH_ROOT_DIR%/share/doc/salome/gui/SMESH/MacMesh/index.html;;http://docs.salome-platform.org/latest/gui/SMESH/MacMesh/index.html"/>
<parameter name="User's Guide/Mesh module/Plug-ins/blocFissure plugin" value="%SMESH_ROOT_DIR%/share/doc/salome/gui/SMESH/blocFissure/index.html;;http://docs.salome-platform.org/latest/gui/SMESH/blocFissure/index.html"/>
<parameter name="User's Guide/Mesh module/Plug-ins/SpherePadder plugin" value="%SMESH_ROOT_DIR%/share/doc/salome/gui/SMESH/padder/index.html;;http://docs.salome-platform.org/latest/gui/SMESH/padder/index.html"/>
<parameter name="User's Guide/Mesh module/MG-Adapt plugin/User's Guide" value="%SMESH_ROOT_DIR%/share/doc/salome/gui/SMESH/index.html#adaptation;;http://docs.salome-platform.org/latest/gui/SMESH/index.html#adaptation"/>
<parameter name="User's Guide/Mesh module/MG-Adapt plugin/Reference" value="%MESHGEMS_ROOT_DIR%/Docs/mg-adapt_api_manual.pdf"/>
<parameter name="User's Guide/Mesh module/MG-Adapt plugin/Manual" value="%MESHGEMS_ROOT_DIR%/Docs/mg-adapt_user_manual.pdf"/>
<parameter name="User's Guide/Mesh module/MGCleaner plugin/User's Guide" value="%SMESH_ROOT_DIR%/share/doc/salome/gui/SMESH/MGCleaner/index.html;;http://docs.salome-platform.org/latest/gui/SMESH/MGCleaner/index.html"/>
<parameter name="User's Guide/Mesh module/MGCleaner plugin/Reference" value="%MESHGEMS_ROOT_DIR%/Docs/mg-cleaner_api_manual.pdf"/>
<parameter name="User's Guide/Mesh module/MGCleaner plugin/Manual" value="%MESHGEMS_ROOT_DIR%/Docs/mg-cleaner_user_manual.pdf"/>

BIN
resources/adapt_mg_adapt.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 2.6 KiB

4
src/SMESH/CMakeLists.txt
View File

@ -38,7 +38,6 @@ INCLUDE_DIRECTORIES(
${PROJECT_SOURCE_DIR}/src/SMDS
${PROJECT_SOURCE_DIR}/src/SMESHDS
${PROJECT_SOURCE_DIR}/src/SMESHUtils
${MEDCOUPLING_INCLUDE_DIRS}
)
# additional preprocessor / compiler flags
@ -68,7 +67,6 @@ SET(_link_LIBRARIES
MeshDriverUNV
MeshDriverGMF
${DriverCGNS_LIB}
${MEDCoupling_medloader}
)
# --- headers ---
@ -88,7 +86,6 @@ SET(SMESHimpl_HEADERS
SMESH_MesherHelper.hxx
SMESH_ProxyMesh.hxx
SMESH_SMESH.hxx
MG_ADAPT.hxx
)
# --- sources ---
@ -107,7 +104,6 @@ SET(SMESHimpl_SOURCES
SMESH_HypoFilter.cxx
SMESH_ProxyMesh.cxx
SMESH_MesherHelper.cxx
MG_ADAPT.cxx
)
# --- rules ---

1575
src/SMESH/MG_ADAPT.cxx
View File

File diff suppressed because it is too large Load Diff

340
src/SMESH/MG_ADAPT.hxx
View File

@ -1,340 +0,0 @@
// Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File : MG_ADAPT.hxx
//
#ifndef MG_ADAPT_HXX
#define MG_ADAPT_HXX
#include <string>
# include <sstream>
#include <map>
#include <vector>
#include <set>
#include <fstream>
#include "MCAuto.hxx"
#include "MCType.hxx"
#include "MEDFileMesh.hxx"
#include <med.h>
// SMESH includes
//~#include <med.h>
std::string remove_extension(const std::string& filename);
namespace MG_ADAPT{
class MgAdapt;
typedef std::map< std::string, std::string > TOptionValues;
typedef std::set< std::string > TOptionNames;
struct MgAdaptHypothesisData
{
std::string myFileInDir, myMeshFileIn, myInMeshName, myMeshFileBackground, myOutMeshName,
myMeshFileOut, myFileOutDir, myFileSizeMapDir, myFieldName;
bool fromMedFile;
bool myPublish, myMeshOutMed;
bool myUseLocalMap, myUseBackgroundMap, myUseConstantValue;
double myConstantValue;
int myRank, myTimeStep;
bool myUseNoTimeStep, myUseLastTimeStep, myUseChosenTimeStep;
std::string myWorkingDir, myLogFile;
bool myPrintLogInFile, myKeepFiles, myRemoveLogOnSuccess;
int myVerboseLevel;
};
class outFileStream : public std::ofstream{
public:
~outFileStream(){close();} //to close file at dtor
};
/*!
* \brief Class to generate string from any type
*/
class ToComment : public std::string
{
std::ostringstream _s ;
public :
ToComment():std::string("") {}
ToComment(const ToComment& c):std::string() {
_s << c.c_str() ;
this->std::string::operator=( _s.str() );
}
ToComment & operator=(const ToComment& c) {
_s << c.c_str() ;
this->std::string::operator=( _s.str() );
return *this;
}
template <class T>
ToComment( const T &anything ) {
_s << anything ;
this->std::string::operator=( _s.str() );
}
template <class T>
ToComment & operator<<( const T &anything ) {
_s << anything ;
this->std::string::operator=( _s.str() );
return *this ;
}
operator char*() const {
return (char*)c_str();
}
std::ostream& Stream() {
return _s;
}
};
class MgAdapt
{
public:
MgAdapt();
MgAdapt(MgAdaptHypothesisData*);
MgAdapt(const MgAdapt&);
~MgAdapt();
void buildModel();
void setData( MgAdaptHypothesisData* data);
void setMedFileIn(std::string fileName);
std::string getMedFileIn();
void setMedFileOut(std::string fileOut);
std::string getMedFileOut();
void setMeshName(std::string name);
std::string getMeshName();
void setMeshNameOut(std::string name);
std::string getMeshNameOut();
void setMeshOutMed(bool mybool);
bool getMeshOutMed();
void setPublish(bool mybool);
bool getPublish();
void setFieldName(std::string myFieldName);
std::string getFieldName();
void setTimeStep(int time);
int getTimeStep() const;
void setRankTimeStep(int time, int myRank);
int getRank();
void setTimeStepRankLast();
void setNoTimeStep();
void setChosenTimeStepRank();
void updateTimeStepRank();
void setLogFile(std::string);
std::string getLogFile();
void setVerbosityLevel(int verbosity);
int getVerbosityLevel();
void setRemoveOnSuccess(bool mybool);
bool getRemoveOnSuccess();
MgAdaptHypothesisData* getData() const;
void setUseLocalMap(bool mybool);
bool getUseLocalMap();
void setUseBackgroundMap(bool mybool);
bool getUseBackgroundMap();
void setUseConstantValue(bool mybool);
bool getUseConstantValue();
void setConstantValue(double cnst);
double getConstantValue() const;
void setSizeMapFile(std::string mapFile);
std::string getSizeMapFile();
void setFromMedFile(bool mybool);
bool isFromMedFile();
void setKeepWorkingFiles(bool mybool);
bool getKeepWorkingFiles();
void setPrintLogInFile(bool mybool);
bool getPrintLogInFile();
void setWorkingDir(std::string dir);
std::string getWorkingDir() const;
bool setAll();
static std::string getCommandToRun(MgAdapt* );
std::string getCommandToRun() ;
int compute(std::string& errStr);
std::string getFileName() const;
static std::string getExeName();
void copyMgAdaptHypothesisData( const MgAdaptHypothesisData* from) ;
void checkDirPath(std::string& dirPath);
bool hasOptionDefined( const std::string& optionName ) const;
void setOptionValue(const std::string& optionName,
const std::string& optionValue) throw (std::invalid_argument);
std::string getOptionValue(const std::string& optionName,
bool* isDefault=0) const throw (std::invalid_argument);
std::vector <std::string> getCustomOptionValuesStrVec() const;
std::vector <std::string> getOptionValuesStrVec() const;
TOptionValues getOptionValues() const;
const TOptionValues& getCustomOptionValues() const ;
static double toDbl(const std::string&, bool* isOk = 0) throw (std::invalid_argument);
static bool toBool(const std::string&, bool* isOk = 0) throw (std::invalid_argument);
static int toInt(const std::string&, bool* isOk = 0 ) throw (std::invalid_argument);
static std::string toLowerStr(const std::string& str);
/* default values */
static std::string defaultWorkingDirectory();
static std::string defaultLogFile();
static bool defaultKeepFiles();
static bool defaultRemoveLogOnSuccess();
static int defaultVerboseLevel();
static bool defaultPrintLogInFile();
static bool defaultFromMedFile();
static bool defaultMeshOutMed();
static bool defaultPublish();
static bool defaultUseLocalMap();
static bool defaultUseBackgroundMap();
static bool defaultUseConstantValue();
static bool defaultUseNoTimeStep();
static bool defaultUseLastTimeStep();
static bool defaultUseChosenTimeStep();
static double defaultMaximumMemory();
static bool isFileExist(const std::string& fName);
enum Status {
DRS_OK,
DRS_EMPTY, // a file contains no mesh with the given name
DRS_WARN_RENUMBER, // a file has overlapped ranges of element numbers,
// so the numbers from the file are ignored
DRS_WARN_SKIP_ELEM, // some elements were skipped due to incorrect file data
DRS_WARN_DESCENDING, // some elements were skipped due to descending connectivity
DRS_FAIL, // general failure (exception etc.)
DRS_NO_TIME_STEP // general failure (exception etc.)
};
struct group {
std::string _name;
std::vector<MEDCoupling::mcIdType> _famListId;
std::vector<std::string> _famNames;
group(std::string name, std::vector<MEDCoupling::mcIdType> famListId, std::vector<std::string> famNames):_name(name)
{
std::vector<MEDCoupling::mcIdType>::iterator it = famListId.begin();
for (; it!=famListId.end(); ++it)
_famListId.push_back(*it);
std::vector<std::string>::iterator itt = famNames.begin();
for (; itt!=famNames.end(); ++itt)
_famNames.push_back(*itt);
}
};
struct family {
std::string _famName;
mcIdType _famId;
family(std::string famName, MEDCoupling::mcIdType famId):_famName(famName), _famId(famId) {}
};
private :
bool fromMedFile;
std::string medFileIn;
std::string medFileOut;
std::string meshName;
std::string meshNameOut;
bool publish, meshOutMed;
bool useLocalMap, useBackgroundMap, useConstantValue;
bool myUseLastTimeStep, myUseNoTimeStep, myUseChosenTimeStep;
std::string sizeMapFile;
std::string fieldName;
double constantValue;
int rank, timeStep;
/* advanced options */
std::string logFile;
std::string workingDir;
int verbosityLevel;
bool removeOnSuccess;
bool toKeepWorkingFiles;
bool printLogInFile;
/* Model DATA */
MgAdaptHypothesisData* data;
/* */
TOptionValues _option2value, _customOption2value; // user defined values
TOptionValues _defaultOptionValues; // default values
TOptionNames _doubleOptions, _charOptions, _boolOptions; // to find a type of option
std::vector <std::string> _myErrorMessages;
Status _myStatus;
std::string meshFormatOutputMesh;
std::vector< std::string> solFormatOutput;
std::vector <group> groupVec;
std::vector <family> famVec;
std::vector< std::string> tmpFilesToBeDeleted;
/* convert MED-->.mesh format */
void convertMedFile(std::string& meshIn,std::string& solFileIn, std::string& sizeMapIn) ;
void storeGroups(MEDCoupling::MEDFileMesh* fileMesh);
void restoreGroups(MEDCoupling::MEDFileMesh* fileMesh) const;
void storefams(MEDCoupling::MEDFileMesh* fileMesh);
void restorefams(MEDCoupling::MEDFileMesh* fileMesh) const;
void storeGroupsAndFams(MEDCoupling::MEDFileMesh* fileMesh);
void restoreGroupsAndFams(MEDCoupling::MEDFileMesh* fileMesh) const;
void convertMeshFile(std::string& meshFormatIn, std::vector< std::string>& solFieldFileNames) const ;
void buildConstantSizeMapSolFile(const std::string& solFormatFieldFileName, const int dim, const int version, const mcIdType nbNodes) const;
void buildBackGroundMeshAndSolFiles(const std::vector<std::string>& fieldFileNames, const std::string& meshFormatsizeMapFile) const;
void getTimeStepInfos(std::string aFile, med_int& numdt, med_int& numit);
Status addMessage(const std::string& msg, const bool isFatal = false);
med_idt openMedFile(const std::string aFile) ;
void execCmd( const char* cmd, int& err);
void cleanUp();
void appendMsgToLogFile(std::string& msg);
std::vector<std::string> getListFieldsNames(std::string fileIn) ;
void checkDimensionOptionAdaptation() ;
void checkFieldName(std::string fileIn) ;
void checkTimeStepRank(std::string fileIn) ;
};
}
#endif // MG_ADAPT_HXX

10
src/SMESHGUI/CMakeLists.txt
View File

@ -45,7 +45,6 @@ INCLUDE_DIRECTORIES(
${PROJECT_SOURCE_DIR}/src/SMESH_I
${PROJECT_BINARY_DIR}
${PROJECT_BINARY_DIR}/idl
${MEDCOUPLING_INCLUDE_DIRS}
)
# additional preprocessor / compiler flags
@ -76,7 +75,6 @@ SET(_link_LIBRARIES
SMESHControls
SMESHObject
SMESHEngine
${MEDCoupling_medloader}
)
# --- headers ---
@ -149,9 +147,6 @@ SET(_moc_HEADERS
SMESHGUI_SplitBiQuad.h
SMESHGUI_IdPreview.h
SMESHGUI_PreVisualObj.h
SMESHGUI_AdaptDlg.h
SMESHGUI_MG_ADAPTDRIVER.h
MG_ADAPTGUI.hxx # to replace in ../ADAPTGUI/
)
# header files / no moc processing
@ -174,7 +169,6 @@ SET(_other_HEADERS
SMESHGUI_FileValidator.h
SMESHGUI_SelectionProxy.h
SMESH_SMESHGUI.hxx
#~MG_ADAPT.hxx # to replace in ../ADAPT/
)
# header files / to install
@ -268,10 +262,6 @@ SET(_other_SOURCES
SMESHGUI_SplitBiQuad.cxx
SMESHGUI_PreVisualObj.cxx
SMESHGUI_IdPreview.cxx
SMESHGUI_AdaptDlg.cxx
SMESHGUI_MG_ADAPTDRIVER.cxx
MG_ADAPTGUI.cxx # to replace in ../ADAPTGUI/
#MG_ADAPT.cxx
)
# sources / to compile

1365
src/SMESHGUI/MG_ADAPTGUI.cxx
View File

File diff suppressed because it is too large Load Diff

329
src/SMESHGUI/MG_ADAPTGUI.hxx
View File

@ -1,329 +0,0 @@
// Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESHGUI : GUI for the adaptation in the SMESH component
// File : MG_ADAPTGUI.hxx
//
#ifndef MG_ADAPTGUI_HXX
#define MG_ADAPTGUI_HXX
#include <set>
// SMESH includes
// Qt includes
#include <QDialog>
#include <QTreeWidget>
#include<QItemDelegate>
#include "LightApp_DataOwner.h"
#include "SalomeApp_Application.h"
#include <SALOMEconfig.h>
#include <SALOME_ListIO.hxx>
#include "SalomeApp_Module.h"
#include "SalomeApp_Study.h"
#include <med.h>
#include <map>
// model
//~#include "MG_ADAPT.hxx"
#include CORBA_SERVER_HEADER(MG_ADAPT)
class SUIT_ViewWindow;
class SUIT_Desktop;
class SUIT_Study;
class SUIT_ResourceMgr;
class CAM_Module;
class SALOMEDSClient_Study;
class SALOMEDSClient_SObject;
class SalomeApp_Study;
class SalomeApp_Module;
class LightApp_SelectionMgr;
class QButtonGroup;
class QLineEdit;
class QGroupBox;
class QRadioButton;
class QLabel;
class QCheckBox;
class QGridLayout;
class QTabWidget;
class QDoubleSpinBox;
class QSpinBox;
class QTreeWidget;
class QTreeWidgetItem;
class QSpacerItem;
class QHBoxLayout;
class QItemDelegate;
class QComboBox;
// IDL includes
#include <SALOMEconfig.h>
class SVTK_ViewWindow;
class SVTK_Selector;
class SMESHGUI_MgAdaptDlg;
class SMESHGUI_MgAdaptArguments;
class SMESHGUI_SpinBox;
class MgAdaptAdvWidgetTreeWidget;
class MgAdaptAdvWidget;
//~class MgAdapt;
class QHeaderView;
class QFileDialog;
std::map<QString, int> GetListeChamps(QString aFile, bool errorMessage = true);
QString lireNomMaillage(QString aFile, med_int& meshDim);
std::string remove_extension(const std::string& filename);
enum ADAPTATION_MODE{
SURFACE,
VOLUME,
BOTH
};
//=================================================================================
// class : SMESHGUI_MgAdaptDlg
// purpose :
//=================================================================================
class SMESHGUI_MgAdaptDlg : public QDialog
{
Q_OBJECT;
public:
//! Property type
enum Mode { Arguments, AdvancedOptions};
SMESHGUI_MgAdaptDlg( SalomeApp_Module*, SMESH::MG_ADAPT_ptr, QWidget* parent= 0,bool isCreation = true );
~SMESHGUI_MgAdaptDlg();
void buildDlg();
void reject();
bool checkParams(QString& msg) ;
//~void setModel(MgAdapt*);
SMESH::MG_ADAPT_ptr getModel() const;
public slots:
protected slots:
virtual bool PushOnApply();
private slots:
virtual void PushOnHelp();
virtual void PushOnOK();
protected :
SMESHGUI_MgAdaptArguments* myArgs;
MgAdaptAdvWidget* myAdvOpt;
bool readParamsFromHypo( ) const ;
bool readParamsFromWidgets( ) ;
bool storeParamsToHypo( const SMESH::MgAdaptHypothesisData & ) const;
private:
SalomeApp_Module* mySMESHGUI; /* Current SMESHGUI object */
QTabWidget* myTabWidget;
SMESH::MgAdaptHypothesisData* myData;
SMESH::MG_ADAPT_ptr model;
};
class SMESHGUI_MgAdaptArguments : public QWidget
{
Q_OBJECT;
public:
//! Property type
enum Mode { Mesh, Browser};
enum SIZEMAP { Local, Background, Constant};
SMESHGUI_MgAdaptArguments( QWidget* parent);
~SMESHGUI_MgAdaptArguments();
void setMode( const Mode, const SIZEMAP );
QString* myFileInDir;
QString* myFileOutDir;
QString* myFileSizeMapDir;
QGroupBox* aMeshIn ;
QRadioButton* aMedfile;
QRadioButton* aBrowser ;
QLineEdit* aBrowserObject;
QPushButton* selectMedFilebutton ;
QSpacerItem* hspacer;
QLineEdit* selectMedFileLineEdit ;
QButtonGroup* meshInGroup ;
QGridLayout* meshIn ;
QGroupBox* aMeshOut ;
QLabel* meshName;
QLineEdit* meshNameLineEdit;
QSpacerItem* secondHspacer;
QCheckBox* medFileCheckBox;
QPushButton* selectOutMedFilebutton;
QLineEdit* selectOutMedFileLineEdit;
QSpacerItem* thirdHspacer;
QCheckBox* publishOut;
QGridLayout* meshOut ;
QGroupBox* sizeMapDefinition ;
QRadioButton* localButton;
QRadioButton* backgroundButton ;
QRadioButton* constantButton ;
QLabel* medFileBackground;
QPushButton* selectMedFileBackgroundbutton;
QLineEdit* selectMedFileBackgroundLineEdit;
QLabel* valueLabel;
QDoubleSpinBox* dvalue;
QButtonGroup* sizeMapDefGroup ;
QGridLayout* sizeMapDefGroupLayout;
QGroupBox* sizeMapField;
QLabel* fieldName;
QComboBox* fieldNameCmb;
QRadioButton* noTimeStep;
QRadioButton* lastTimeStep ;
QRadioButton* chosenTimeStep;
QLabel* timeStepLabel;
QSpinBox* timeStep;
QLabel* rankLabel;
QSpinBox* rankSpinBox;
QButtonGroup* timeStepGroup;
QGridLayout* sizeMapFieldGroupLayout;
signals:
void updateSelection();
void toExportMED(const char *);
void meshDimSignal(ADAPTATION_MODE aMode);
public slots:
protected slots:
private slots:
void modeChanged( int);
void sizeMapDefChanged(int);
void timeStepGroupChanged(int timeStepType, bool disableOther = false, int vmax = 0);
void onSelectMedFilebuttonClicked();
void clear();
void onMedFileCheckBox(int);
void onPublishOut(int);
void onSelectOutMedFilebutton();
void onSelectMedFileBackgroundbutton();
void onLocalSelected(QString);
void onNoTimeStep(bool disableOther = false);
void onLastTimeStep(bool disableOther = false);
void onChosenTimeStep(bool disableOther = false, int vmax = 0);
void visibleTimeStepRankLabel(bool visible);
void valueAdaptation ();
private:
QString getMedFileName(bool avertir);
LightApp_SelectionMgr* selMgr ;
med_int meshDim;
med_int meshDimBG;
std::map<QString, int> myFieldList;
};
enum {
OPTION_ID_COLUMN = 0,
OPTION_TYPE_COLUMN,
OPTION_NAME_COLUMN = 0,
OPTION_VALUE_COLUMN,
NB_COLUMNS,
};
//////////////////////////////////////////
// MgAdaptAdvWidget
//////////////////////////////////////////
class MgAdaptAdvWidget : public QWidget
{
Q_OBJECT
public:
MgAdaptAdvWidget( QWidget* = 0, std::vector <std::string> * = nullptr, Qt::WindowFlags = 0 );
~MgAdaptAdvWidget();
std::vector < std::string > * myOptions;
QGridLayout *gridLayout_4;
MgAdaptAdvWidgetTreeWidget *myOptionTable;
QPushButton *addBtn;
QSpacerItem *horizontalSpacer;
QGroupBox *logGroupBox;
QGridLayout *gridLayout_2;
QGridLayout *gridLayout;
QLabel *workingDirectoryLabel;
QLineEdit *workingDirectoryLineEdit;
QPushButton *workingDirectoryPushButton;
QLabel *verboseLevelLabel;
QSpinBox *verboseLevelSpin;
QHBoxLayout *horizontalLayout;
QCheckBox *logInFileCheck;
QCheckBox *removeLogOnSuccessCheck;
QCheckBox *keepWorkingFilesCheck;
void AddOption( const char* name_value_type, bool isCustom = false );
void GetOptionAndValue( QTreeWidgetItem * tblRow, QString& option, QString& value, bool& dflt );
void setupWidget();
public slots:
void onAddOption();
void itemChanged(QTreeWidgetItem * tblRow, int column);
void onMeshDimChanged(ADAPTATION_MODE aMode);
private slots:
void _onWorkingDirectoryPushButton();
private:
void setOptionValue(QString& option, QString& value);
std::map<QString, QTreeWidgetItem *> optionTreeWidgetItem;
QTreeWidgetItem* getNewQTreeWidgetItem(QTreeWidget* table, const char* option, QString& name, bool isCustom);
};
enum { EDITABLE_ROLE = Qt::UserRole + 1, PARAM_NAME,
NAME_COL = 0, VALUE_COL
};
class ItemDelegate: public QItemDelegate
{
public:
ItemDelegate(QObject* parent=0): QItemDelegate(parent) {}
QWidget* createEditor(QWidget *parent, const QStyleOptionViewItem &o, const QModelIndex &index) const;
};
class MgAdaptAdvWidgetTreeWidget : public QTreeWidget
{
Q_OBJECT
public:
MgAdaptAdvWidgetTreeWidget( QWidget* );
protected:
QModelIndex moveCursor( CursorAction, Qt::KeyboardModifiers );
void keyPressEvent( QKeyEvent* );
};
#endif // MG_ADAPTGUI_HXX

114
src/SMESHGUI/SMESHGUI.cxx
View File

@ -30,7 +30,6 @@
// SMESH includes
#include "SMESHGUI.h"
#include "SMESHGUI_AdaptDlg.h"
#include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
#include "SMESHGUI_AddMeshElementDlg.h"
#include "SMESHGUI_AddQuadraticElementDlg.h"
@ -3043,13 +3042,6 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
}
break;
}
// Adaptation - begin
case SMESHOp::OpMGAdapt:
{
SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
SMESHGUI_AdaptDlg *objet = new SMESHGUI_AdaptDlg( this, theCommandID, aMesh);
}
// Adaptation - end
case SMESHOp::OpSplitBiQuadratic:
case SMESHOp::OpConvertMeshToQuadratic:
case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
@ -4287,10 +4279,6 @@ void SMESHGUI::initialize( CAM_Application* app )
createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
// Adaptation - begin
createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
// Adaptation - end
createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
@ -4332,7 +4320,6 @@ void SMESHGUI::initialize( CAM_Application* app )
meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
@ -4505,10 +4492,6 @@ void SMESHGUI::initialize( CAM_Application* app )
createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
// Adaptation - begin
createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
// Adaptation - end
createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
createMenu( SMESHOp::OpAngle, measureId, -1 );
@ -4523,7 +4506,22 @@ void SMESHGUI::initialize( CAM_Application* app )
connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
// ----- create toolbars --------------
int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ) ;
int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
//renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
createTool( SMESHOp::OpCreateMesh, meshTb );
createTool( SMESHOp::OpCreateSubMesh, meshTb );
createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
@ -4535,30 +4533,25 @@ void SMESHGUI::initialize( CAM_Application* app )
createTool( SMESHOp::OpEvaluate, meshTb );
createTool( SMESHOp::OpMeshOrder, meshTb );
int infoTb = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ) ;
createTool( SMESHOp::OpMeshInformation, infoTb );
//createTool( SMESHOp::OpStdInfo, meshTb );
//createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
createTool( SMESHOp::OpFindElementByPoint, infoTb );
int groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ) ;
createTool( SMESHOp::OpCreateGroup, groupTb );
createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
createTool( SMESHOp::OpConstructGroup, groupTb );
createTool( SMESHOp::OpEditGroup, groupTb );
int ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ) ;
createTool( SMESHOp::OpMeshInformation, info );
//createTool( SMESHOp::OpStdInfo, meshTb );
//createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
createTool( SMESHOp::OpFindElementByPoint, info );
createTool( SMESHOp::OpFreeNode, ctrl0dTb );
createTool( SMESHOp::OpEqualNode, ctrl0dTb );
//createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
int ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ) ;
createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
createTool( SMESHOp::OpLength, ctrl1dTb );
createTool( SMESHOp::OpConnection, ctrl1dTb );
createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
int ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ) ;
createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
createTool( SMESHOp::OpFreeFace, ctrl2dTb );
createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
@ -4575,7 +4568,6 @@ void SMESHGUI::initialize( CAM_Application* app )
createTool( SMESHOp::OpEqualFace, ctrl2dTb );
createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
int ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ) ;
createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
createTool( SMESHOp::OpVolume, ctrl3dTb );
createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
@ -4583,7 +4575,6 @@ void SMESHGUI::initialize( CAM_Application* app )
createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
int addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ) ;
createTool( SMESHOp::OpNode, addElemTb );
createTool( SMESHOp::OpElem0D, addElemTb );
createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
@ -4599,7 +4590,6 @@ void SMESHGUI::initialize( CAM_Application* app )
createTool( SMESHOp::OpHexagonalPrism, addElemTb );
createTool( SMESHOp::OpPolyhedron, addElemTb );
int addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ) ;
createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
@ -4613,17 +4603,14 @@ void SMESHGUI::initialize( CAM_Application* app )
createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
int remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ) ;
createTool( SMESHOp::OpRemoveNodes, remTb );
createTool( SMESHOp::OpRemoveElements, remTb );
createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
createTool( SMESHOp::OpClearMesh, remTb );
// int renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ) ;
//createTool( SMESHOp::OpRenumberingNodes, renumbTb );
//createTool( SMESHOp::OpRenumberingElements, renumbTb );
int transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ) ;
createTool( SMESHOp::OpMergeNodes, transformTb );
createTool( SMESHOp::OpMergeElements, transformTb );
createTool( SMESHOp::OpTranslation, transformTb );
@ -4634,7 +4621,6 @@ void SMESHGUI::initialize( CAM_Application* app )
createTool( SMESHOp::OpSewing, transformTb );
createTool( SMESHOp::OpDuplicateNodes, transformTb );
int modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ) ;
createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
createTool( SMESHOp::OpExtrusion, modifyTb );
@ -4652,15 +4638,8 @@ void SMESHGUI::initialize( CAM_Application* app )
createTool( SMESHOp::OpSmoothing, modifyTb );
createTool( SMESHOp::OpPatternMapping, modifyTb );
// Adaptation - begin
int adaptTb = createTool( tr( "TB_ADAPTATION" ),QString( "SMESHAdaptationToolbar" ) ) ;
createTool( SMESHOp::OpMGAdapt, adaptTb );
// Adaptation - end
int measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ) ;
createTool( SMESHOp::OpMinimumDistance, measuremTb );
int dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
createTool( SMESHOp::OpUpdate, dispModeTb );
QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
@ -4736,11 +4715,9 @@ void SMESHGUI::initialize( CAM_Application* app )
popupMgr()->insert( separator(), -1, 0 );
createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
popupMgr()->insert( separator(), -1, 0 );
//popupMgr()->insert( separator(), -1, 0 );
// Adaptation - begin
createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
// Adaptation - end
//popupMgr()->insert( separator(), -1, 0 );
QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
@ -5162,7 +5139,7 @@ bool SMESHGUI::activateModule( SUIT_Study* study )
lab = lab + tr("INFO_COMPUTE") + "<br/>";
lab = lab + tr("INFO_REFINE") + ":";
items << wrap(tr("INFO_REFINE_LOCAL_SIZE"), "li")
<< wrap(tr("INFO_REFINE_SUBMESH"), "li");
<< wrap(tr("INFO_REFINE_SUBMESH"), "li");
lab = lab + wrap(items.join(""), "ul");
items.clear();
@ -5170,11 +5147,11 @@ bool SMESHGUI::activateModule( SUIT_Study* study )
gb = app->infoPanel()->addGroup(tr("INFO_GRP_IMPORT_MESH"));
items << wrap("UNV", "li")
<< wrap("MED", "li")
<< wrap("STL", "li")
<< wrap("CGNS", "li")
<< wrap("SAUV", "li")
<< wrap("GMF", "li");
<< wrap("MED", "li")
<< wrap("STL", "li")
<< wrap("CGNS", "li")
<< wrap("SAUV", "li")
<< wrap("GMF", "li");
lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
items.clear();
@ -5183,9 +5160,9 @@ bool SMESHGUI::activateModule( SUIT_Study* study )
gb = app->infoPanel()->addGroup(tr("INFO_GRP_CHECK_MESH"));
lab = tr("INFO_DISPLAY") + "<br/>";
items << wrap(tr("INFO_QUALITY_AREA"), "li")
<< wrap(tr("INFO_QUALITY_VOLUME"), "li")
<< wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
<< wrap("...", "li");
<< wrap(tr("INFO_QUALITY_VOLUME"), "li")
<< wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
<< wrap("...", "li");
lab = lab + tr("INFO_QUALITY_INFO") + ":" + wrap(items.join(""), "ul");
items.clear();
lab = lab + tr("INFO_CLIPPING");
@ -5774,29 +5751,6 @@ void SMESHGUI::createPreferences()
setPreferenceProperty( coloringType, "indexes", indices );
addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
// Adaptation - begin
// Adaptation tab ------------------------------------------------------------------------
int adaptTab = addPreference( tr( "ADAPT_PREF_TAB_GENERAL" ) );
int bloc, pref ;
// MG-Adapt
bloc = addPreference( tr( "ADAPT_PREF_MG_ADAPT" ), adaptTab );
setPreferenceProperty( bloc, "columns", 1 );
pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_FILE_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_file_mesh_out" );
pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_publish_mesh_out" );
pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_size_map" );
QStringList aListOfSizeMap;
aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_LOCAL" );
aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_BACKGROUND" );
aListOfSizeMap << tr( "ADAPT_PREF_NONE" );;
setPreferenceProperty( pref, "strings", aListOfSizeMap );
pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_time_step" );
QStringList aListOfTimeStep;
aListOfTimeStep << tr( "ADAPT_PREF_NONE" );
aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_LAST" );
aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_C" );;
setPreferenceProperty( pref, "strings", aListOfTimeStep );
// Adaptation - end
}
void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
@ -6010,10 +5964,6 @@ LightApp_Operation* SMESHGUI::createOperation( const int id ) const
case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
op = new SMESHGUI_Add0DElemsOnAllNodesOp();
break;
// Adaptation - begin
case SMESHOp::OpMGAdapt:
break;
// Adaptation - end
default:
break;
}

162
src/SMESHGUI/SMESHGUI_AdaptDlg.cxx
View File

@ -1,162 +0,0 @@
// Copyright (C) 2011-2020 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESHGUI : GUI for the adaptation in the SMESH component
// File : SMESHGUI_AdaptDlg.cxx
// Author : Gerald NICOLAS, EDF
// SMESH includes
#include "SMESHGUI.h"
#include "SMESHGUI_AdaptDlg.h"
#include "SMESHGUI_MG_ADAPTDRIVER.h"
//~#include "MG_ADAPT_i.hxx"
//~#include "MG_ADAPT.hxx"
// SALOME GUI includes
#include <SUIT_Desktop.h>
#include <SUIT_ResourceMgr.h>
#include <SUIT_Session.h>
#include <SalomeApp_Application.h>
#include <SalomeApp_Study.h>
// SALOME KERNEL includes
#include "utilities.h"
#include <SALOME_LifeCycleCORBA.hxx>
//=================================================================================
// function : SMESHGUI_AdaptDlg()
// purpose :
//=================================================================================
SMESHGUI_AdaptDlg::SMESHGUI_AdaptDlg( SMESHGUI* theModule,
int theCommandID,
SMESH::SMESH_Mesh_ptr theMesh )
: mySMESHGUI( theModule )
{
action( theCommandID ) ;
}
//=================================================================================
// function : ~SMESHGUI_AdaptDlg()
// purpose : Destroys the object and frees any allocated resources
//=================================================================================
SMESHGUI_AdaptDlg::~SMESHGUI_AdaptDlg()
{
}
/*!
* \brief Pilote les actions d'adaption de maillage
* \param
* \return bool OK/notOK
*/
void SMESHGUI_AdaptDlg::action (int theCommandID)
//=======================================================================
{
// std::cout << "SMESHGUI_AdaptDlg::action avec theCommandID : " << theCommandID << std::endl;
// Preferences
// recupPreferences();
// Menus and actions
bool ok = OnGUIEvent (theCommandID) ;
if ( ! ok ) INFOS("Erreur");
return ;
}
// /*!
// * \brief Gets the preferences for the adaptation
// * \param
// * \return
// *
// * Pour chaque valeur, le defaut est la valeur definie dans ADAPT_Gen
// * . Si la recuperation dans config/salome s'est bien passee a la creation de ADAPT_Gen
// * ces valeurs sont les valeurs definies.
// * . Si cela ne s'est pas bien passe, ce sont les valeurs par defaut de ADAPT_Gen
// */
// void SMESHGUI_AdaptDlg::recupPreferences()
// {
// INFOS("Début de recupPreferences")
// //
// // A. Declarations
// //
// SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
// SALOME_LifeCycleCORBA* ls = new SALOME_LifeCycleCORBA(app->namingService());
// Engines::EngineComponent_var comp = ls->FindOrLoad_Component("FactoryServer", "SMESH");
// ADAPT::ADAPT_Gen_var adaptGen = ADAPT::ADAPT_Gen::_narrow(comp);
// if (!CORBA::is_nil(adaptGen))
// adaptGen->UpdateStudy();
//
// SUIT_ResourceMgr* resMgr = mySMESHGUI->getApp()->resourceMgr();
//
// }
/*!
* \brief Launches the GUI for the adaptation
* \param theCommandID - the integer that references the operation
* \return bool OK/notOK
*/
bool SMESHGUI_AdaptDlg::OnGUIEvent (int theCommandID)
{
// std::cout << "SMESHGUI_AdaptDlg:OnGUIEvent avec theCommandID : " << theCommandID << std::endl;
// A. Controles
SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
if ( !app ) return false;
SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*> ( app->activeStudy() );
if ( !aStudy )
{
INFOS ( "FAILED to cast active study to SalomeApp_Study" );
return false;
}
SUIT_Desktop* parent = SUIT_Session::session()->activeApplication()->desktop();
SALOME_LifeCycleCORBA* ls = new SALOME_LifeCycleCORBA(app->namingService());
Engines::EngineComponent_var comp = ls->FindOrLoad_Component("FactoryServer", "SMESH");
// ADAPT::ADAPT_Gen_var adaptGen = ADAPT::ADAPT_Gen::_narrow(comp);
// if (!CORBA::is_nil(adaptGen))
// adaptGen->UpdateStudy();
mySMESHGUI->getApp()->updateObjectBrowser();
//
// B. Choix selon les commandes
bool ok = true ;
SCRUTE(theCommandID);
switch (theCommandID)
{
case 8020: // Adaptation avec MG-Adpat
{
// INFOS("Interface avec MG-Adapt" );
SMESH::MG_ADAPT_ptr model = SMESHGUI::GetSMESHGen()->CreateMG_ADAPT();
bool isCreation = false;
if (mySMESHGUI->isStudyLocked()) break;
mySMESHGUI->EmitSignalDeactivateDialog();
SMESHGUI_MG_ADAPTDRIVER *mgAdapt = new SMESHGUI_MG_ADAPTDRIVER(mySMESHGUI, model, isCreation);
mgAdapt->show();
break;
}
}
mySMESHGUI->getApp()->updateObjectBrowser();
return ok;
}

77
src/SMESHGUI/SMESHGUI_AdaptDlg.h
View File

@ -1,77 +0,0 @@
// Copyright (C) 2011-2020 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESHGUI : GUI for the adaptation in the SMESH component
// File : SMESHGUI_AdaptDlg.h
// Author : Gérald NICOLAS, EDF
//
#ifndef SMESHGUI_ADAPTDLG_H
#define SMESHGUI_ADAPTDLG_H
// SMESH includes
#include "SMESH_SMESHGUI.hxx"
// Qt includes
#include <QDialog>
// IDL includes
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Mesh)
class SMESHGUI;
//=================================================================================
// class : SMESHGUI_AdaptDlg
// purpose :
//=================================================================================
class SMESHGUI_EXPORT SMESHGUI_AdaptDlg : public QWidget
{
public:
SMESHGUI_AdaptDlg( SMESHGUI*,
int theCommandID,
SMESH::SMESH_Mesh_ptr = SMESH::SMESH_Mesh::_nil() );
~SMESHGUI_AdaptDlg();
void action (int theCommandID);
virtual bool OnGUIEvent (int theCommandID);
// static ADAPT::ADAPT_Gen_var InitAdaptGen(SalomeApp_Application*);
public slots:
protected slots:
private slots:
private:
// void recupPreferences();
SMESHGUI* mySMESHGUI; /* Current SMESHGUI object */
QString _ObjectName;
QString _LanguageShort ;
int _PublisMeshIN ;
int _PublisMeshOUT ;
int _YACSMaxIter ;
int _YACSMaxNode ;
int _YACSMaxElem ;
int _YACSTypeTest ;
};
#endif // SMESHGUI_ADAPTDLG_H

758
src/SMESHGUI/SMESHGUI_MG_ADAPTDRIVER.cxx
View File

@ -1,758 +0,0 @@
// Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File : SMESHGUI_MG_ADAPTDRIVER.cxx
#include "SMESHGUI_MG_ADAPTDRIVER.h"
#include "SUIT_Desktop.h"
#include "SUIT_Application.h"
#include "SUIT_Session.h"
#include "SalomeApp_Application.h"
#include "SalomeApp_Module.h"
#include "SalomeApp_Study.h"
#include "SMESH_Comment.hxx"
#include "SMESH_Actor.h"
#include "SMESHGUI.h"
#include "SMESHGUI_FilterDlg.h"
#include "SMESHGUI_Selection.h"
#include <SUIT_MessageBox.h>
#include "SMESHGUI_IdValidator.h"
#include "SMESHGUI_Utils.h"
#include "SMESHGUI_MeshEditPreview.h"
#include "SMESHGUI_VTKUtils.h"
#include <SMESH_TypeFilter.hxx>
#include <SMESH_MeshAlgos.hxx>
#include <SMESH_LogicalFilter.hxx>
#include <SMDS_Mesh.hxx>
#include <SMDS_MeshNode.hxx>
#include "SMESHGUI_SpinBox.h"
#include <LightApp_SelectionMgr.h>
#include <SUIT_OverrideCursor.h>
#include <SUIT_ResourceMgr.h>
#include <SVTK_ViewWindow.h>
#include <SALOME_ListIO.hxx>
#include <SUIT_FileDlg.h>
#include "SMESHGUI_MeshUtils.h"
#include <QApplication>
#include <QButtonGroup>
#include <QGridLayout>
#include <QGroupBox>
#include <QHBoxLayout>
#include <QKeyEvent>
#include <QLabel>
#include <QLineEdit>
#include <QCheckBox>
#include <QPushButton>
#include <QRadioButton>
#include <QTabWidget>
#include <QVBoxLayout>
#include <QDoubleSpinBox>
#include <QSpinBox>
#include <QTreeWidget>
#include <QTreeWidgetItem>
#include <QSpacerItem>
#include <QString>
#include <QHeaderView>
#include <QItemDelegate>
#include <QFileDialog>
#include <QMessageBox>
#include <QComboBox>
#include <vtkPoints.h>
#include <vtkUnstructuredGrid.h>
#include <vtkIdList.h>
#include <vtkCellArray.h>
#include <vtkUnsignedCharArray.h>
#include <vtkDataSetMapper.h>
#include <VTKViewer_CellLocationsArray.h>
#include <vtkProperty.h>
#include <ElCLib.hxx>
// SALOME KERNEL includes
#include <SALOMEDS_SComponent.hxx>
#include <SALOMEDS_SObject.hxx>
#include <SALOMEDS_Study.hxx>
#include <SALOMEDS_wrap.hxx>
#include "SalomeApp_Tools.h"
#include <SALOMEconfig.h>
#include <med.h>
#include <utilities.h>
#include <TCollection_AsciiString.hxx>
const int SPACING = 6; // layout spacing
const int MARGIN = 9; // layout margin
SALOME_ListIO mySelected;
//================================================================
// Function : firstIObject
// Purpose : Return the first selected object in the selected object list
//================================================================
Handle(SALOME_InteractiveObject) firstIObject()
{
const SALOME_ListIO& aList = selectedIO();
return aList.Extent() > 0 ? aList.First() : Handle(SALOME_InteractiveObject)();
}
//================================================================
// Function : selectedIO
// Return the list of selected SALOME_InteractiveObject's
//================================================================
const SALOME_ListIO& selectedIO()
{
SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* > ( SUIT_Session::session()->activeApplication() );
LightApp_SelectionMgr* aSelectionMgr = app->selectionMgr();
if( aSelectionMgr )
{
aSelectionMgr->selectedObjects( mySelected );
for (SALOME_ListIteratorOfListIO it (mySelected); it.More(); it.Next())
SCRUTE(it.Value()->getEntry());
};
return mySelected;
}
//================================================================
// Function : getStudy
// Returne un pointeur sur l'etude active
//================================================================
_PTR(Study) getStudy()
{
static _PTR(Study) _study;
if(!_study)
_study = SalomeApp_Application::getStudy();
return _study;
}
bool createAndPublishMed(QString fileName)
{
SMESH::DriverMED_ReadStatus res;
SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
// SMESHGUI aGui;
aMeshes = SMESHGUI::GetSMESHGen()->CreateMeshesFromMED( fileName.toUtf8().constData(), res );
_PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[0] );
_PTR(Study) aStudy = SMESH::getStudy();
QStringList anEntryList;
// bool isEmpty;
if ( aMeshSO )
{
_PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
_PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
anEntryList.append( aMeshSO->GetID().c_str() );
}
else
{
// isEmpty = true;
return false;
}
SMESHGUI::GetSMESHGUI()->updateObjBrowser();
// browse to the published meshes
if( LightApp_Application* anApp =
dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
anApp->browseObjects( anEntryList );
return true;
}
bool createMgAdaptObject(MgAdapt *myMgAdapt )
{
// SMESH::SMESH_Mesh_var newMesh = SMESHGUI::GetSMESHGen()->CreateEmptyMesh();
// _PTR(SObject) aHypothesis;
_PTR(Study) aStudy = SMESH::getStudy();
QStringList anEntryList;
_PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
_PTR(SComponent) mgadapt = aStudy->FindComponent("MG-ADAPT");
_PTR(GenericAttribute) ga;
if (!aBuilder->FindAttribute(mgadapt, ga, "AttributeName") )
{
mgadapt = aBuilder->NewComponent("MG-ADAPT");
_PTR(AttributeName) Name = aBuilder->FindOrCreateAttribute(mgadapt, "AttributeName");
Name->SetValue("MG-ADAPT");
_PTR(AttributePixMap) myPixmap = aBuilder->FindOrCreateAttribute( mgadapt, "AttributePixMap" );
myPixmap->SetPixMap( "ICON_MG_ADAPT" );
anEntryList.append( mgadapt->GetID().c_str() );
}
_PTR(SObject) obj = aBuilder->NewObject(mgadapt);
_PTR(AttributeName) myName = aBuilder->FindOrCreateAttribute(obj, "AttributeName");
myName->SetValue("hypo");
_PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( obj, "AttributePixMap" );
aPixmap->SetPixMap( "ICON_SMESH_TREE_HYPO" );
anEntryList.append( obj->GetID().c_str() );
SMESHGUI::GetSMESHGUI()->updateObjBrowser();
// // browse to the published meshes
if( LightApp_Application* anApp =
dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
anApp->browseObjects( anEntryList );
return true;
}
// MG ADAPT UTILS
//================================================================
// Function : IObjectCount
// Return the number of selected objects
//================================================================
int IObjectCount()
{
SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
LightApp_SelectionMgr* aSelectionMgr = app->selectionMgr();
if( aSelectionMgr )
{
aSelectionMgr->selectedObjects( mySelected );
SCRUTE(mySelected.Extent());
return mySelected.Extent();
}
return 0;
}
SMESHGUI_MG_ADAPTDRIVER::SMESHGUI_MG_ADAPTDRIVER( SMESHGUI* theModule, SMESH::MG_ADAPT_ptr myModel, bool isCreation )
: mySMESHGUI( theModule ),
myFilterDlg(0),
myIsApplyAndClose( false ),
SMESHGUI_MgAdaptDlg((SalomeApp_Module*)theModule, myModel, SMESHGUI::desktop(), isCreation)
{
resMgr = resourceMgr();
selMgr = selectionMgr();
// connections
connect(myArgs, SIGNAL(updateSelection()), this, SLOT(updateSelection()));
connect(myArgs, SIGNAL(toExportMED(const char*)), this, SLOT(exportMED(const char*)));
}
SUIT_ResourceMgr* SMESHGUI_MG_ADAPTDRIVER::resourceMgr()
{
return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
}
LightApp_SelectionMgr* SMESHGUI_MG_ADAPTDRIVER::selectionMgr()
{
SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
if( anApp )
return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
else
return 0;
}
void SMESHGUI_MG_ADAPTDRIVER::updateSelection()
{
disconnect( selMgr, 0, this, 0 );
selMgr->clearFilters();
SMESH::SetPointRepresentation( true );
if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow() )
aViewWindow->SetSelectionMode( ActorSelection );
if (myArgs->aBrowser->isChecked())
{
connect( selMgr, SIGNAL( currentSelectionChanged() ), this, SLOT( selectionChanged() ));
selectionChanged();
}
}
void SMESHGUI_MG_ADAPTDRIVER::selectionChanged()
{
//~ get selected mesh
SALOME_ListIO aList;
selMgr->selectedObjects(aList);
QString aString = "";
int nbSel = aList.Extent();
if (nbSel != 1)
return;
Handle(SALOME_InteractiveObject) IO = aList.First();
SMESH::SMESH_Mesh_var mesh = SMESH::GetMeshByIO(IO);
if ( !mesh->_is_nil() )
{
myMesh = mesh;
mySelectedObject = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>( IO );
if ( mySelectedObject->_is_nil() )
return;
}
else
return;
SMESH::GetNameOfSelectedIObjects( selMgr, aString );
if ( aString.isEmpty() ) aString = " ";
else aString = aString.trimmed();
bool ok = !aString.isEmpty();
if ( !mesh->_is_nil() )
{
myArgs->aBrowserObject->setText( aString );
myArgs->meshNameLineEdit->setText( aString );
myArgs->selectOutMedFileLineEdit->setText(aString+QString(".med"));
ADAPTATION_MODE aMode;
int nbVolumes = myMesh->NbVolumes();
int nbFaces = myMesh->NbFaces();
if(nbFaces > 0 && nbVolumes > 0) aMode = ADAPTATION_MODE::BOTH;
else if(nbFaces > 0) aMode = ADAPTATION_MODE::SURFACE;
else aMode = ADAPTATION_MODE::VOLUME;
emit myArgs->meshDimSignal(aMode);
}
}
void SMESHGUI_MG_ADAPTDRIVER::exportMED(const char* tmp_file)
{
bool toOverwrite = true;
bool toFindOutDim = true;
myMesh->ExportMED(tmp_file, false, -1, toOverwrite, toFindOutDim);
}
void SMESHGUI_MG_ADAPTDRIVER::setMyMesh(SMESH::SMESH_Mesh_var mesh)
{
myMesh = mesh;
}
SMESH::SMESH_Mesh_var SMESHGUI_MG_ADAPTDRIVER::getMyMesh()
{
return myMesh;
}
//=================================================================================
// function : PushOnOk()
// purpose :
//=================================================================================
void SMESHGUI_MG_ADAPTDRIVER::PushOnOK()
{
setIsApplyAndClose( true );
bool ret = PushOnApply();
// std::cout << "SMESHGUI_MG_ADAPTDRIVER::PushOnOK ret : " <<ret<<std::endl;
if ( ret ) reject();
}
bool SMESHGUI_MG_ADAPTDRIVER::PushOnApply()
{
MESSAGE("PushOnApply");
if ( SMESHGUI::isStudyLocked() )
return false;
if( !isValid() )
return false;
bool ok = SMESHGUI_MgAdaptDlg::PushOnApply();
// std::cout << "SMESHGUI_MG_ADAPTDRIVER::PushOnApply ok 1 : " <<ok<<std::endl;
if ( ok )
{
ok = execute();
if (getModel()->getPublish()) this->createMeshInObjectBrowser();
// std::cout << "SMESHGUI_MG_ADAPTDRIVER::PushOnApply ok 2 : " <<ok<<std::endl;
if ( ok )
{
QMessageBox::information( 0, QObject::tr(""),
QObject::tr("MG_ADAPT_DIAG_1") );
}
else
{
QMessageBox::critical( 0, QObject::tr("MG_ADAPT_ERROR"),
QObject::tr("MG_ADAPT_DIAG_2") );
}
}
return ok;
}
bool SMESHGUI_MG_ADAPTDRIVER::execute()
{
int err = 1;
char* errStr;
try
{
getModel()->compute();
err = 0;
errStr = getModel()->getErrMsg();
std::string msg = err == 0 ? " ok" : std::string("Not ok \n")+CORBA::string_dup(errStr) ;
}
catch (const std::exception& e)
{
std::cerr<<e.what();
}
return err == 0;
}
//=================================================================================
// function : Init()
// purpose :
//=================================================================================
void SMESHGUI_MG_ADAPTDRIVER::Init (bool ResetControls)
{
myBusy = false;
if ( ResetControls )
{
myLineEditElements->clear();
myNbOkElements = 0;
buttonOk->setEnabled(false);
buttonApply->setEnabled(false);
//~myActor = 0;
myMesh = SMESH::SMESH_Mesh::_nil();
myIdSourceCheck->setChecked(true);
onConstructor( 0 );
}
}
//=======================================================================
//function : onConstructor
//purpose : switch operation mode
//=======================================================================
void SMESHGUI_MG_ADAPTDRIVER::onConstructor( int withGeom )
{
myGeomLabel ->setVisible( withGeom );
myGeomNameEdit ->setVisible( withGeom );
myReuseHypCheck ->setVisible( withGeom );
myCopyElementsCheck->setVisible( withGeom );
myFilterBtn ->setVisible( !withGeom );
myIdSourceCheck ->setVisible( !withGeom );
if ( !withGeom )
myMeshNameEdit->setText( SMESH::UniqueMeshName("Mesh"));
}
//~void SMESHGUI_MG_ADAPTDRIVER::onSelectIdSource( bool )
//~{}
//=================================================================================
// function : enterEvent()
// purpose :
//=================================================================================
void SMESHGUI_MG_ADAPTDRIVER::enterEvent (QEvent*)
{
// if ( !ConstructorsBox->isEnabled() ) {
// SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI );
// if ( aViewWindow && !mySelector ) {
// mySelector = aViewWindow->GetSelector();
// }
// activateThisDialog();
// }
}
//=================================================================================
// function : keyPressEvent()
// purpose :
//=================================================================================
void SMESHGUI_MG_ADAPTDRIVER::keyPressEvent( QKeyEvent* e )
{
QDialog::keyPressEvent( e );
if ( e->isAccepted() )
return;
if ( e->key() == Qt::Key_F1 )
{
e->accept();
PushOnHelp();
}
}
//=================================================================================
// function : PushOnHelp()
// purpose :
//=================================================================================
void SMESHGUI_MG_ADAPTDRIVER::PushOnHelp()
{
QString aHelpFile = "adaptation.html#_mg_adapt_anchor";
SMESH::ShowHelpFile( aHelpFile );
}
//=======================================================================
//function : getErrorMsg
//purpose : Return an error message and entries of invalid smesh object
//=======================================================================
QString SMESHGUI_MG_ADAPTDRIVER::getErrorMsg( SMESH::string_array_var theInvalidEntries,
QStringList & theEntriesToBrowse )
{
if ( theInvalidEntries->length() == 0 )
return tr("OPERATION_FAILED");
// theInvalidEntries - SObject's that hold geometry objects whose
// counterparts are not found in the newGeometry, followed by SObject's
// holding mesh sub-objects that are invalid because they depend on a not found
// preceding sub-shape
QString msg = tr("SUBSHAPES_NOT_FOUND_MSG") + "\n";
QString objString;
for ( CORBA::ULong i = 0; i < theInvalidEntries->length(); ++i )
{
_PTR(SObject) so = SMESH::getStudy()->FindObjectID( theInvalidEntries[i].in() );
int objType = SMESHGUI_Selection::type( theInvalidEntries[i].in() );
if ( objType < 0 ) // geom object
{
objString += "\n";
if ( so )
objString += so->GetName().c_str();
else
objString += theInvalidEntries[i].in(); // it's something like "FACE #2"
}
else // smesh object
{
theEntriesToBrowse.push_back( theInvalidEntries[i].in() );
objString += "\n ";
switch ( objType ) {
case SMESH::MESH:
objString += tr("SMESH_MESH");
break;
case SMESH::HYPOTHESIS:
objString += tr("SMESH_HYPOTHESIS");
break;
case SMESH::ALGORITHM:
objString += tr("SMESH_ALGORITHM");
break;
case SMESH::SUBMESH_VERTEX:
case SMESH::SUBMESH_EDGE:
case SMESH::SUBMESH_FACE:
case SMESH::SUBMESH_SOLID:
case SMESH::SUBMESH_COMPOUND:
case SMESH::SUBMESH:
objString += tr("SMESH_SUBMESH");
break;
case SMESH::GROUP:
objString += tr("SMESH_GROUP");
break;
default:
;
}
objString += " \"";
if ( so )
objString += so->GetName().c_str();
objString += "\" (";
objString += theInvalidEntries[i].in();
objString += ")";
}
}
if ( !objString.isEmpty() )
msg += objString;
return msg;
}
//=================================================================================
// function : isValid
// purpose :
//=================================================================================
bool SMESHGUI_MG_ADAPTDRIVER::isValid()
{
bool ok = true;
return ok;
}
bool SMESHGUI_MG_ADAPTDRIVER::createMeshInObjectBrowser()
{
QString filename(getModel()->getMedFileOut());
QStringList errors;
QStringList anEntryList;
bool isEmpty = false;
bool ok = false;
SMESH::SMESH_Gen_var SMESH_Gen_ptr = SMESHGUI::GetSMESHGen();
if (!SMESH_Gen_ptr) {
std::cerr << "Could not retrieve SMESH_Gen_ptr" << std::endl;
throw SALOME_Exception(LOCALIZED("Could not retrieve SMESH::GetSMESHGen()"));
}
SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
aMeshes->length( 1 ); // one mesh only
SMESH::DriverMED_ReadStatus res;
aMeshes = SMESH_Gen_ptr->CreateMeshesFromMED( filename.toUtf8().constData(), res );
if ( res != SMESH::DRS_OK ) {
errors.append( QString( "%1 :\n\t%2" ).arg( filename ).arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
}
_PTR(Study) aStudy = SMESH::getStudy();
for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
{
_PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
if ( aMeshSO )
{
_PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
_PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" ); // put REFINED mesh ico
anEntryList.append( aMeshSO->GetID().c_str() );
}
else
{
isEmpty = true;
}
}
// update Object browser
SMESHGUI::GetSMESHGUI()->updateObjBrowser();
// browse to the published meshes
if( LightApp_Application* anApp =
dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
anApp->browseObjects( anEntryList );
// show Error message box if there were errors
if ( errors.count() > 0 ) {
SUIT_MessageBox::critical( SMESHGUI::desktop(),
QObject::tr( "SMESH_ERROR" ),
QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
}
// show warning message box, if some imported mesh is empty
if ( isEmpty ) {
SUIT_MessageBox::warning( SMESHGUI::desktop(),
QObject::tr( "SMESH_WRN_WARNING" ),
QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
}
return true;
}
//================================================================
// function : setIsApplyAndClose
// Purpose : Set value of the flag indicating that the dialog is
// accepted by Apply & Close button
//================================================================
void SMESHGUI_MG_ADAPTDRIVER::setIsApplyAndClose( const bool theFlag )
{
myIsApplyAndClose = theFlag;
}//================================================================
// function : isApplyAndClose
// Purpose : Get value of the flag indicating that the dialog is
// accepted by Apply & Close button
//================================================================
bool SMESHGUI_MG_ADAPTDRIVER::isApplyAndClose() const
{
return myIsApplyAndClose;
}
//=================================================================================
// function : DeactivateActiveDialog()
// purpose :
//=================================================================================
void SMESHGUI_MG_ADAPTDRIVER::deactivateActiveDialog()
{
if (ConstructorsBox->isEnabled())
{
ConstructorsBox->setEnabled(false);
GroupArguments->setEnabled(false);
GroupButtons->setEnabled(false);
mySMESHGUI->ResetState();
mySMESHGUI->SetActiveDialogBox(0);
if ( selMgr )
selMgr->removeFilter( myIdSourceFilter );
}
}
//=================================================================================
// function : ActivateThisDialog()
// purpose :
//=================================================================================
void SMESHGUI_MG_ADAPTDRIVER::activateThisDialog()
{
/* Emit a signal to deactivate the active dialog */
// mySMESHGUI->EmitSignalDeactivateDialog();
// ConstructorsBox->setEnabled(true);
// GroupArguments->setEnabled(true);
// GroupButtons->setEnabled(true);
// mySMESHGUI->SetActiveDialogBox((QDialog*)this);
// onSelectIdSource( myIdSourceCheck->isChecked() );
// SelectionIntoArgument();
}
//=================================================================================
// function : setFilters()
// purpose : SLOT. Called when "Filter" button pressed.
//=================================================================================
void SMESHGUI_MG_ADAPTDRIVER::setFilters()
{
if(myMesh->_is_nil())
{
SUIT_MessageBox::critical(this,
tr("SMESH_ERROR"),
tr("NO_MESH_SELECTED"));
return;
}
if ( !myFilterDlg )
myFilterDlg = new SMESHGUI_FilterDlg( mySMESHGUI, SMESH::ALL );
QList<int> types;
if ( myMesh->NbEdges() ) types << SMESH::EDGE;
if ( myMesh->NbFaces() ) types << SMESH::FACE;
if ( myMesh->NbVolumes() ) types << SMESH::VOLUME;
if ( myMesh->NbBalls() ) types << SMESH::BALL;
if ( myMesh->Nb0DElements()) types << SMESH::ELEM0D;
if ( types.count() > 1 ) types << SMESH::ALL;
myFilterDlg->Init( types );
myFilterDlg->SetSelection();
myFilterDlg->SetMesh( myMesh );
myFilterDlg->SetSourceWg( myLineEditElements );
myFilterDlg->show();
}
//=================================================================================
// function : onOpenView()
// purpose :
//=================================================================================
void SMESHGUI_MG_ADAPTDRIVER::onOpenView()
{
if ( mySelector ) {
SMESH::SetPointRepresentation(false);
}
else {
mySelector = SMESH::GetViewWindow( mySMESHGUI )->GetSelector();
activateThisDialog();
}
}
//=================================================================================
// function : onCloseView()
// purpose :
//=================================================================================
void SMESHGUI_MG_ADAPTDRIVER::onCloseView()
{
deactivateActiveDialog();
mySelector = 0;
}

210
src/SMESHGUI/SMESHGUI_MG_ADAPTDRIVER.h
View File

@ -1,210 +0,0 @@
// Copyright (C) 2011-2020 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESHGUI : GUI for the adaptation in the SMESH component
// File : SMESHGUI_MG_ADAPTDRIVER.h
//
#ifndef SMESHGUI_MG_ADAPTDRIVER_H
#define SMESHGUI_MG_ADAPTDRIVER_H
#include <set>
// SMESH includes
#include "SMESH_SMESHGUI.hxx"
// Qt includes
#include <QDialog>
#include <QTreeWidget>
#include<QItemDelegate>
#include <QThread>
#include "LightApp_DataOwner.h"
#include "SalomeApp_Application.h"
#include <SALOMEconfig.h>
#include <SALOME_ListIO.hxx>
#include "SalomeApp_Module.h"
#include "SalomeApp_Study.h"
#include <med.h>
#include <QObject>
// model
#include "MG_ADAPTGUI.hxx"
#include CORBA_SERVER_HEADER(MG_ADAPT)
class SUIT_ViewWindow;
class SUIT_Desktop;
class SUIT_Study;
class SUIT_ResourceMgr;
class CAM_Module;
class SALOMEDSClient_Study;
class SALOMEDSClient_SObject;
class SalomeApp_Study;
class SalomeApp_Module;
class LightApp_SelectionMgr;
class SUIT_SelectionFilter;
class QButtonGroup;
class QLineEdit;
class QGroupBox;
class QRadioButton;
class QLabel;
class QCheckBox;
class QGridLayout;
class QTabWidget;
class QDoubleSpinBox;
class QSpinBox;
class QTreeWidget;
class QTreeWidgetItem;
class QSpacerItem;
class QHBoxLayout;
class QItemDelegate;
class QComboBox;
class QObject;
// IDL includes
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Mesh)
#include CORBA_SERVER_HEADER(SMESH_Gen)
class SMESHGUI;
class SMESHGUI_MgAdaptDlg;
class SMESHGUI_IdValidator;
class SMESHGUI_FilterDlg;
class MgAdapt;
class QHeaderView;
class QFileDialog;
int IObjectCount();
const SALOME_ListIO& selectedIO();
_PTR(Study) getStudy();
Handle(SALOME_InteractiveObject) firstIObject();
bool createAndPublishMed(QString fileName);
bool createMgAdaptObject(MgAdapt* myMgAdapt = 0);
class SMESHGUI_MG_ADAPTDRIVER : public SMESHGUI_MgAdaptDlg
{
Q_OBJECT;
public :
SMESHGUI_MG_ADAPTDRIVER( SMESHGUI*, SMESH::MG_ADAPT_ptr, bool isCreation = true );
void setMyMesh(SMESH::SMESH_Mesh_var);
SMESH::SMESH_Mesh_var getMyMesh() ;
private :
SMESHGUI* mySMESHGUI; /* Current SMESHGUI object */
LightApp_SelectionMgr* selMgr ;
SUIT_ResourceMgr* resMgr;
SUIT_ResourceMgr* resourceMgr();
LightApp_SelectionMgr* selectionMgr();
SMESH::SMESH_Mesh_var myMesh ;
void Init( bool = true );
void enterEvent( QEvent* ); /* mouse enter the QWidget */
void keyPressEvent( QKeyEvent* );
QString getErrorMsg( SMESH::string_array_var invalidEntries,
QStringList & entriesToBrowse );
bool isValid();
bool createMeshInObjectBrowser();
void setIsApplyAndClose( const bool theFlag );
bool isApplyAndClose() const;
bool execute();
SMESHGUI_IdValidator* myIdValidator;
int myNbOkElements; /* to check when elements are defined */
SVTK_Selector* mySelector;
bool myBusy;
GEOM::GEOM_Object_var myNewGeometry;
//~SMESH_Actor* myActor; //
SUIT_SelectionFilter* myIdSourceFilter;
SMESH::SMESH_IDSource_var mySelectedObject;
QTabWidget* myTabWidget;
QButtonGroup* GroupConstructors;
QGroupBox* ConstructorsBox;
QGroupBox* GroupArguments;
QGroupBox* GroupButtons;
QPushButton* buttonOk;
QPushButton* buttonCancel;
QPushButton* buttonApply;
QPushButton* buttonHelp;
QLabel* myTextLabelElements;
QLabel* myGeomLabel;
QLineEdit* myLineEditElements;
QLineEdit* myMeshNameEdit;
QLineEdit* myGeomNameEdit;
QCheckBox* myIdSourceCheck;
QCheckBox* myCopyGroupsCheck;
QCheckBox* myReuseHypCheck;
QCheckBox* myCopyElementsCheck;
QCheckBox* myKeepIdsCheck;
QPushButton* myFilterBtn;
SMESHGUI_FilterDlg* myFilterDlg;
QString myHelpFileName;
bool myIsApplyAndClose;
QString inputMeshName;
QString outputMeshName;
private slots:
void selectionChanged();
void updateSelection();
protected slots :
private slots:
void exportMED(const char* );
virtual bool PushOnApply();
virtual void PushOnOK();
virtual void PushOnHelp();
void deactivateActiveDialog();
void activateThisDialog();
void onConstructor( int );
//~void onTextChange( const QString& );
//~void onSelectIdSource( bool );
void setFilters();
void onOpenView();
void onCloseView();
};
#endif // SMESHGUI_MG_ADAPTDRIVER_H

2
src/SMESHGUI/SMESHGUI_Operations.h
View File

@ -186,8 +186,6 @@ namespace SMESHOp {
OpConvertMeshToQuadratic = 4513, // MENU MODIFICATION - CONVERT TO/FROM QUADRATIC
OpCreateBoundaryElements = 4514, // MENU MODIFICATION - CREATE BOUNDARY ELEMENTS
OpSplitBiQuadratic = 4515, // MENU MODIFICATION - SPLIT BI-QUADRATIC TO LINEAR
// Adaptation ---------------------//--------------------------------
OpMGAdapt = 8020, // MENU ADAPTATION - MG-ADAPT
// Measurements -------------------//--------------------------------
OpPropertiesLength = 5000, // MENU MEASUREMENTS - BASIC PROPERTIES - LENGTH
OpPropertiesArea = 5001, // MENU MEASUREMENTS - BASIC PROPERTIES - AREA

4
src/SMESHGUI/SMESH_images.ts
View File

@ -83,10 +83,6 @@
<source>ICON_CREATE_GEO_GROUP</source>
<translation>mesh_groups_from_gemetry.png</translation>
</message>
<message>
<source>ICON_MG_ADAPT</source>
<translation>adapt_mg_adapt.png</translation>
</message>
<message>
<source>ICON_CONV_TO_QUAD</source>
<translation>mesh_conv_to_quad.png</translation>

216
src/SMESHGUI/SMESH_msg_en.ts
View File

@ -340,126 +340,6 @@
<source>MEN_CONSTRUCT_GROUP</source>
<translation>Construct Group</translation>
</message>
<message>
<source>MEN_MG_ADAPT</source>
<translation>Remesh with MG_Adapt</translation>
</message>
<message>
<source>Args</source>
<translation>Arguments</translation>
</message>
<message>
<source>MeshOut</source>
<translation>Mesh Out</translation>
</message>
<message>
<source>MeshIn</source>
<translation>Mesh In</translation>
</message>
<message>
<source>MEDFile</source>
<translation>MED file</translation>
</message>
<message>
<source>Browser</source>
<translation>Browser</translation>
</message>
<message>
<source>Publish_MG_ADAPT</source>
<translation>Publish</translation>
</message>
<message>
<source>SIZE_MAP_FIELD</source>
<translation>Size map field</translation>
</message>
<message>
<source>MG_ADAPT_FIELD_NAME</source>
<translation>Field Name</translation>
</message>
<message>
<source>MG_ADAPT_MED_FILE_1</source>
<translation>This MED file cannot be read.</translation>
</message>
<message>
<source>MG_ADAPT_MED_FILE_2</source>
<translation>No mesh in this MED file.</translation>
</message>
<message>
<source>MG_ADAPT_MED_FILE_3</source>
<translation>More than one mesh in this MED file.</translation>
</message>
<message>
<source>MG_ADAPT_MED_FILE_4</source>
<translation>The mesh in this MED file cannot be read.</translation>
</message>
<message>
<source>MG_ADAPT_MED_FILE_5</source>
<translation>No field in this MED file.</translation>
</message>
<message>
<source>MG_ADAPT_ERROR</source>
<translation>Error</translation>
</message>
<message>
<source>MG_ADAPT_CH_ST</source>
<translation>Chosen time step</translation>
</message>
<message>
<source>MG_ADAPT_RANK</source>
<translation>Rank</translation>
</message>
<message>
<source>MG_ADAPT_TSTP</source>
<translation>Time step </translation>
</message>
<message>
<source>MG_ADAPT_NO_T_ST</source>
<translation>No time step</translation>
</message>
<message>
<source>MG_ADAPT_L_ST</source>
<translation>Last time step</translation>
</message>
<message>
<source>MeshName</source>
<translation>Mesh name</translation>
</message>
<message>
<source>LOCAL_MG_ADAPT</source>
<translation>Local</translation>
</message>
<message>
<source>BACKGRND_MG_ADAPT</source>
<translation>Background</translation>
</message>
<message>
<source>CNST_MG_ADAPT</source>
<translation>Constant</translation>
</message>
<message>
<source>MED_FILE_BCKG</source>
<translation>MED file background size map</translation>
</message>
<message>
<source>VALUE_MG_ADAPT</source>
<translation>Value</translation>
</message>
<message>
<source>SIZE_MAP_DEF</source>
<translation>Size map definition</translation>
</message>
<message>
<source>ADVOP</source>
<translation>Advanced Options</translation>
</message>
<message>
<source>MG_ADAPT_DIAG_1</source>
<translation>Adaptation succeeded.</translation>
</message>
<message>
<source>MG_ADAPT_DIAG_2</source>
<translation>Adaptation failed.</translation>
</message>
<message>
<source>MEN_CONV_TO_QUAD</source>
<translation>Convert to/from quadratic</translation>
@ -908,10 +788,6 @@
<source>MEN_MODIFY</source>
<translation>Modification</translation>
</message>
<message>
<source>MEN_ADAPT</source>
<translation>Adaptation</translation>
</message>
<message>
<source>MEN_MEASURE</source>
<translation>Measurements</translation>
@ -1626,10 +1502,6 @@ Please enter correct values and try again</translation>
<source>SMESH_AVAILABLE</source>
<translation>Available</translation>
</message>
<message>
<source>SMESH_NOT_AVAILABLE</source>
<translation>Not available</translation>
</message>
<message>
<source>SMESH_AVAILABLE_ALGORITHMS</source>
<translation>Available algorithms</translation>
@ -3025,82 +2897,6 @@ Check algorithm documentation for supported geometry</translation>
<source>SMESH_MULTICOLOR</source>
<translation>Multicolor</translation>
</message>
<message>
<source>ADAPT_PREF_TAB_GENERAL</source>
<translation>Adaptation</translation>
</message>
<message>
<source>ADAPT_PREF_NONE</source>
<translation>None</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT</source>
<translation>Adaptation with MG-Adapt</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_FILE_MAILLAGE_OUT</source>
<translation>Write the OUT mesh</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_PUBLICATION_MAILLAGE_OUT</source>
<translation>Publication of the OUT mesh</translation>
</message>
<message>
<source>OPTION_VALUE_COLUMN</source>
<translation>Option</translation>
</message>
<message>
<source>OPTION_NAME_COLUMN</source>
<translation>Value</translation>
</message>
<message>
<source>compute_ridges</source>
<translation>Compute ridges</translation>
</message>
<message>
<source>max_memory</source>
<translation>Maximum memory (Mb)</translation>
</message>
<message>
<source>Adaption</source>
<translation>adaptation</translation>
</message>
<message>
<source>components</source>
<translation>Components</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_SIZE_MAP</source>
<translation>Size map</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_SIZE_MAP_LOCAL</source>
<translation>Local</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_SIZE_MAP_BACKGROUND</source>
<translation>Background</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_TIME_STEP_LAST</source>
<translation>Last</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_TIME_STEP</source>
<translation>Choosen time step</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_TIME_STEP_C</source>
<translation>Value</translation>
</message>
<message>
<source>MG_ADAPT_SELECT_FILE_0</source>
<translation>MG-ADAPT select file</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_ADVOP</source>
<translation>Advanced Options</translation>
</message>
<message>
<source>SMESH_VISU_PROBLEM</source>
<translation>Mesh visualization failed</translation>
@ -3316,10 +3112,6 @@ Use Display Entity menu command to show them.
<source>STB_CONSTRUCT_GROUP</source>
<translation>Construct Group</translation>
</message>
<message>
<source>STB_MG_ADAPT</source>
<translation>Remesh with MG_Adapt</translation>
</message>
<message>
<source>STB_CONV_TO_QUAD</source>
<translation>Convert to/from quadratic</translation>
@ -3916,10 +3708,6 @@ Use Display Entity menu command to show them.
<source>TB_CTRL3D</source>
<translation>Volume Controls Toolbar</translation>
</message>
<message>
<source>TB_ADAPTATION</source>
<translation>Adaptation Toolbar</translation>
</message>
<message>
<source>TB_MEASUREM</source>
<translation>Measurements Toolbar</translation>
@ -4024,10 +3812,6 @@ Use Display Entity menu command to show them.
<source>TOP_CONSTRUCT_GROUP</source>
<translation>Construct Group</translation>
</message>
<message>
<source>TOP_MG_ADAPT</source>
<translation>Remesh with MG_Adapt</translation>
</message>
<message>
<source>TOP_CONV_TO_QUAD</source>
<translation>Convert to/from quadratic</translation>

214
src/SMESHGUI/SMESH_msg_fr.ts
View File

@ -340,126 +340,6 @@
<source>MEN_CONSTRUCT_GROUP</source>
<translation>Construire un groupe</translation>
</message>
<message>
<source>MEN_MG_ADAPT</source>
<translation>Remaillage avec MG_Adapt</translation>
</message>
<message>
<source>Args</source>
<translation>Arguments</translation>
</message>
<message>
<source>MeshOut</source>
<translation>Maillage en sortie</translation>
</message>
<message>
<source>MeshIn</source>
<translation>Maillage en entrée</translation>
</message>
<message>
<source>MEDFile</source>
<translation>Fichier MED</translation>
</message>
<message>
<source>Browser</source>
<translation>Arbre d'études</translation>
</message>
<message>
<source>Publish_MG_ADAPT</source>
<translation>Publication</translation>
</message>
<message>
<source>SIZE_MAP_FIELD</source>
<translation>Champ de la carte de taille</translation>
</message>
<message>
<source>MG_ADAPT_FIELD_NAME</source>
<translation>Nom du champ</translation>
</message>
<message>
<source>MG_ADAPT_MED_FILE_1</source>
<translation>Ce fichier MED est illisible.</translation>
</message>
<message>
<source>MG_ADAPT_MED_FILE_2</source>
<translation>Ce fichier MED ne contient aucun maillage.</translation>
</message>
<message>
<source>MG_ADAPT_MED_FILE_3</source>
<translation>Ce fichier MED contient plus d'un maillage.</translation>
</message>
<message>
<source>MG_ADAPT_MED_FILE_4</source>
<translation>Impossible de lire le maillage de ce fichier MED.</translation>
</message>
<message>
<source>MG_ADAPT_MED_FILE_5</source>
<translation>Ce fichier MED ne contient aucun champ.</translation>
</message>
<message>
<source>MG_ADAPT_ERROR</source>
<translation>Erreur</translation>
</message>
<message>
<source>MG_ADAPT_CH_ST</source>
<translation>Pas de temps choisi</translation>
</message>
<message>
<source>MG_ADAPT_RANK</source>
<translation>Numéro d'ordre</translation>
</message>
<message>
<source>MG_ADAPT_TSTP</source>
<translation>Pas de temps </translation>
</message>
<message>
<source>MG_ADAPT_NO_T_ST</source>
<translation>Sans pas de temps</translation>
</message>
<message>
<source>MG_ADAPT_L_ST</source>
<translation>Dernier pas de temps</translation>
</message>
<message>
<source>MeshName</source>
<translation>Nom du maillage</translation>
</message>
<message>
<source>LOCAL_MG_ADAPT</source>
<translation>Locale</translation>
</message>
<message>
<source>BACKGRND_MG_ADAPT</source>
<translation>Arrière-plan</translation>
</message>
<message>
<source>CNST_MG_ADAPT</source>
<translation>Constante</translation>
</message>
<message>
<source>MED_FILE_BCKG</source>
<translation>Fichier MED de la carte en arrière-plan</translation>
</message>
<message>
<source>VALUE_MG_ADAPT</source>
<translation>Valeur</translation>
</message>
<message>
<source>SIZE_MAP_DEF</source>
<translation>Définition de la carte de taille</translation>
</message>
<message>
<source>ADVOP</source>
<translation>Options avancées</translation>
</message>
<message>
<source>MG_ADAPT_DIAG_1</source>
<translation>Adaptation réussie.</translation>
</message>
<message>
<source>MG_ADAPT_DIAG_2</source>
<translation>Echec de l'adaptation.</translation>
</message>
<message>
<source>MEN_CONV_TO_QUAD</source>
<translation>Convertir vers/depuis quadratique</translation>
@ -602,7 +482,7 @@
</message>
<message>
<source>MEN_EDIT</source>
<translation>Editer</translation>
<translation>Edition</translation>
</message>
<message>
<source>MEN_EDIT_GROUP</source>
@ -908,10 +788,6 @@
<source>MEN_MODIFY</source>
<translation>Modification</translation>
</message>
<message>
<source>MEN_ADAPT</source>
<translation>Adaptation</translation>
</message>
<message>
<source>MEN_MEASURE</source>
<translation>Outils de mesure</translation>
@ -3019,82 +2895,6 @@ Référez-vous à la documentation sur l'algorithme et la géométrie supportée
<source>SMESH_MULTICOLOR</source>
<translation>Multicouleur</translation>
</message>
<message>
<source>ADAPT_PREF_TAB_GENERAL</source>
<translation>Adaptation</translation>
</message>
<message>
<source>ADAPT_PREF_NONE</source>
<translation>Sans</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT</source>
<translation>Adaptation avec MG-Adapt</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_FILE_MAILLAGE_OUT</source>
<translation>Ecriture du maillage de sortie</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_PUBLICATION_MAILLAGE_OUT</source>
<translation>Publication du maillage de sortie</translation>
</message>
<message>
<source>OPTION_VALUE_COLUMN</source>
<translation>Option</translation>
</message>
<message>
<source>OPTION_NAME_COLUMN</source>
<translation>Valeur</translation>
</message>
<message>
<source>compute_ridges</source>
<translation>Calcul des crêtes</translation>
</message>
<message>
<source>max_memory</source>
<translation>Maximum mémoire (Mb)</translation>
</message>
<message>
<source>Adaption</source>
<translation>Adaptation</translation>
</message>
<message>
<source>components</source>
<translation>Composantes</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_SIZE_MAP</source>
<translation>Carte de tailles</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_SIZE_MAP_LOCAL</source>
<translation>Locale</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_SIZE_MAP_BACKGROUND</source>
<translation>Arrière-plan</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_TIME_STEP_LAST</source>
<translation>Dernier</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_TIME_STEP</source>
<translation>Choix du pas de temps</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_TIME_STEP_C</source>
<translation>Valeur</translation>
</message>
<message>
<source>MG_ADAPT_SELECT_FILE_0</source>
<translation>MG-ADAPT selection fichier MED</translation>
</message>
<message>
<source>ADAPT_PREF_MG_ADAPT_ADVOP</source>
<translation>Options avancées</translation>
</message>
<message>
<source>SMESH_VISU_PROBLEM</source>
<translation>Impossible de visualiser le maillage, probablement à cause d'un manque de mémoire</translation>
@ -3311,10 +3111,6 @@ Utilisez le menu &quot;Visualiser une entité&quot; pour les afficher.
<source>STB_CONSTRUCT_GROUP</source>
<translation>Construire un groupe</translation>
</message>
<message>
<source>STB_MG_ADAPT</source>
<translation>Remaillage avec MG_Adapt</translation>
</message>
<message>
<source>STB_CONV_TO_QUAD</source>
<translation>Convertir vers/depuis quadratique</translation>
@ -3911,10 +3707,6 @@ Utilisez le menu &quot;Visualiser une entité&quot; pour les afficher.
<source>TB_CTRL3D</source>
<translation>Barre des contrôles des volumes</translation>
</message>
<message>
<source>TB_ADAPTATION</source>
<translation>Barre de l'adaptation</translation>
</message>
<message>
<source>TB_MEASUREM</source>
<translation>Barre des mesures</translation>
@ -4019,10 +3811,6 @@ Utilisez le menu &quot;Visualiser une entité&quot; pour les afficher.
<source>TOP_CONSTRUCT_GROUP</source>
<translation>Construire un groupe</translation>
</message>
<message>
<source>TOP_MG_ADAPT</source>
<translation>Remaillage avec MG_Adapt</translation>
</message>
<message>
<source>TOP_CONV_TO_QUAD</source>
<translation>Convertir vers/de quadratique</translation>

4
src/SMESH_I/CMakeLists.txt
View File

@ -40,7 +40,6 @@ INCLUDE_DIRECTORIES(
${PROJECT_SOURCE_DIR}/src/SMESHUtils
${PROJECT_BINARY_DIR}
${PROJECT_BINARY_DIR}/idl
${MEDCOUPLING_INCLUDE_DIRS}
)
# additional preprocessor / compiler flags
@ -85,7 +84,6 @@ SET(_link_LIBRARIES
SMESHDS
SMESHControls
MeshDriverMED
${MEDCoupling_medloader}
)
# --- headers ---
@ -115,7 +113,6 @@ SET(SMESHEngine_HEADERS
SMESH_MeshPartDS.hxx
SMESH.hxx
SMESH_Component_Generator.hxx
MG_ADAPT_i.hxx
)
# --- sources ---
@ -144,7 +141,6 @@ SET(SMESHEngine_SOURCES
SMESH_Measurements_i.cxx
SMESH_PreMeshInfo.cxx
SMESH_Component_Generator.cxx
MG_ADAPT_i.cxx
)
# --- rules ---

528
src/SMESH_I/MG_ADAPT_i.cxx
View File

@ -1,528 +0,0 @@
// Copyright (C) 2011-2020 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "MG_ADAPT_i.hxx"
#include "string.h"
#include "SMESH_Gen_i.hxx"
#include <SMESH_Gen.hxx>
#include <SALOMEconfig.h>
#include CORBA_CLIENT_HEADER(SALOMEDS)
//=============================================================================
/*!
* SMESH_Gen_i::CreateMG_ADAPT
*
* Create measurement instance
*/
//=============================================================================
using namespace SMESH;
void MG_ADAPT_i::copyHypothesisDataToImpl(const SMESH::MgAdaptHypothesisData& from, ::MG_ADAPT::MgAdaptHypothesisData* to) const
{
to->myFileInDir = from.myFileInDir;
to->myMeshFileIn = from.myMeshFileIn;
to->myMeshFileBackground = from.myMeshFileBackground;
to->myOutMeshName = from.myOutMeshName;
to->myMeshFileOut = from.myMeshFileOut;
to->myFileOutDir = from.myFileOutDir;
to->myFileSizeMapDir = from.myFileSizeMapDir;
to->myFieldName = from.myFieldName;
to->fromMedFile = from.fromMedFile;
to->myPublish = from.myPublish;
to->myMeshOutMed = from.myMeshOutMed;
to->myUseLocalMap = from.myUseLocalMap;
to->myUseBackgroundMap = from.myUseBackgroundMap;
to->myUseConstantValue = from.myUseConstantValue;
to->myConstantValue = from.myConstantValue;
to->myTimeStep = from.myTimeStep;
to->myRank = from.myRank;
to->myUseNoTimeStep = from.myUseNoTimeStep;
to->myUseLastTimeStep = from.myUseLastTimeStep;
to->myUseChosenTimeStep = from.myUseChosenTimeStep;
to->myWorkingDir = from.myWorkingDir;
to->myLogFile = from.myLogFile;
to->myPrintLogInFile = from.myPrintLogInFile;
to->myKeepFiles = from.myKeepFiles;
to->myRemoveLogOnSuccess = from.myRemoveLogOnSuccess;
to->myVerboseLevel = from.myVerboseLevel;
}
void MG_ADAPT_i::copyHypothesisDataFromImpl(const ::MG_ADAPT::MgAdaptHypothesisData* from, SMESH::MgAdaptHypothesisData* to) const
{
to->myFileInDir = CORBA::string_dup(from->myFileInDir.c_str());
to->myMeshFileIn = CORBA::string_dup(from->myMeshFileIn.c_str());
to->myMeshFileBackground = CORBA::string_dup(from->myMeshFileBackground.c_str());
to->myOutMeshName = CORBA::string_dup(from->myOutMeshName.c_str());
to->myMeshFileOut = CORBA::string_dup(from->myMeshFileOut.c_str());
to->myFileOutDir = CORBA::string_dup(from->myFileOutDir.c_str());
to->myFileSizeMapDir = CORBA::string_dup(from->myFileSizeMapDir.c_str());
to->myFieldName = CORBA::string_dup(from->myFieldName.c_str());
to->fromMedFile = from->fromMedFile;
to->myPublish = from->myPublish;
to->myMeshOutMed = from->myMeshOutMed;
to->myUseLocalMap = from->myUseLocalMap;
to->myUseBackgroundMap = from->myUseBackgroundMap;
to->myUseConstantValue = from->myUseConstantValue;
to->myConstantValue = from->myConstantValue;
to->myTimeStep = from->myTimeStep;
to->myRank = from->myRank;
to->myUseNoTimeStep = from->myUseNoTimeStep;
to->myUseLastTimeStep = from->myUseLastTimeStep;
to->myUseChosenTimeStep = from->myUseChosenTimeStep;
to->myWorkingDir = CORBA::string_dup(from->myWorkingDir.c_str());
to->myLogFile = CORBA::string_dup(from->myLogFile.c_str());
to->myPrintLogInFile = from->myPrintLogInFile;
to->myKeepFiles = from->myKeepFiles;
to->myRemoveLogOnSuccess = from->myRemoveLogOnSuccess;
to->myVerboseLevel = from->myVerboseLevel;
}
SMESH::MG_ADAPT_ptr SMESH_Gen_i::CreateMG_ADAPT()
{
SMESH::MG_ADAPT_i* aMGadapt = new SMESH::MG_ADAPT_i();
SMESH::MG_ADAPT_var anObj = aMGadapt->_this();
return anObj._retn();
}
SMESH::MG_ADAPT_ptr SMESH_Gen_i::CreateAdaptationHypothesis()
{
SMESH::MG_ADAPT_i* aMGadapt = new SMESH::MG_ADAPT_i();
SMESH::MG_ADAPT_var anObj = aMGadapt->_this();
return anObj._retn();
}
SMESH::MG_ADAPT_OBJECT_ptr SMESH_Gen_i::Adaptation( const char* adaptationType)
{
if (!strcmp(adaptationType, "MG_Adapt"))
{
SMESH::MG_ADAPT_OBJECT_i* mg_adapt_object = new SMESH::MG_ADAPT_OBJECT_i();
SMESH::MG_ADAPT_OBJECT_var anObj = mg_adapt_object->_this();
return anObj._retn();
}
}
//~SMESH::MG_ADAPT_ptr MG_ADAPT_i::CreateMG_ADAPT()
//~{
//~SMESH_Gen_i* smeshGen_i = SMESH_Gen_i::GetSMESHGen();
//~SMESH::MG_ADAPT_i* aMGadapt = new SMESH::MG_ADAPT_i(smeshGen_i->GetPOA());
//~SMESH::MG_ADAPT_var anObj = aMGadapt->_this();
//~return anObj._retn();
//~}
//=============================================================================
/*!
* standard constructor
*/
//=============================================================================
MG_ADAPT_i::MG_ADAPT_i(): SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
{
myMgAdapt = new ::MG_ADAPT::MgAdapt();
}
//~MG_ADAPT_i::MG_ADAPT_i(PortableServer::POA_var myPoa): SALOME::GenericObj_i( myPoa )
//~{
//~myMgAdapt = new ::MG_ADAPT::MgAdapt();
//~}
//=============================================================================
/*!
* standard constructor
*/
//=============================================================================
//~MG_ADAPT_i::MG_ADAPT_i( CORBA::ORB_ptr orb,
//~ADAPT::ADAPT_Gen_var engine )
//~{
//~_gen_i = engine;
//~_orb = orb;
//~myMgAdapt = new MgAdapt();
//~}
//=============================================================================
/*!
* standard destructor
*/
//=============================================================================
MG_ADAPT_i::~MG_ADAPT_i()
{
}
void MG_ADAPT_i::setData( SMESH::MgAdaptHypothesisData& data)
{
::MG_ADAPT::MgAdaptHypothesisData* baseData = new ::MG_ADAPT::MgAdaptHypothesisData();
copyHypothesisDataToImpl(data, baseData);
myMgAdapt->setData(baseData);
delete baseData;
}
void MG_ADAPT_i::setMedFileIn(const char* str)
{
myMgAdapt->setMedFileIn(str);
}
char* MG_ADAPT_i::getMedFileIn()
{
return CORBA::string_dup(myMgAdapt->getMedFileIn().c_str());
}
void MG_ADAPT_i::setMedFileOut(const char* str)
{
myMgAdapt->setMedFileOut(str);
}
char* MG_ADAPT_i::getMedFileOut()
{
return CORBA::string_dup(myMgAdapt->getMedFileOut().c_str());
}
void MG_ADAPT_i::setMeshName(const char* str)
{
myMgAdapt->setMeshName(str);
}
char* MG_ADAPT_i::getMeshName()
{
return CORBA::string_dup(myMgAdapt->getMeshName().c_str());
}
void MG_ADAPT_i::setMeshNameOut(const char* str)
{
myMgAdapt->setMeshNameOut(str);
}
char* MG_ADAPT_i::getMeshNameOut()
{
return CORBA::string_dup(myMgAdapt->getMeshNameOut().c_str());
}
void MG_ADAPT_i::setMeshOutMed(bool mybool)
{
myMgAdapt->setMeshOutMed(mybool);
}
bool MG_ADAPT_i::getMeshOutMed()
{
return myMgAdapt->getMeshOutMed();
}
void MG_ADAPT_i::setPublish(bool mybool)
{
myMgAdapt->setPublish(mybool);
}
bool MG_ADAPT_i::getPublish()
{
return myMgAdapt->getPublish();
}
void MG_ADAPT_i::setSizeMapFieldName(const char* str)
{
myMgAdapt->setFieldName(str);
}
char* MG_ADAPT_i::getSizeMapFieldName()
{
return CORBA::string_dup(myMgAdapt->getFieldName().c_str());
}
void MG_ADAPT_i::setTimeStep(CORBA::Long t)
{
myMgAdapt->setTimeStep(t);
}
CORBA::Long MG_ADAPT_i::getTimeStep()
{
return myMgAdapt->getTimeStep();
}
void MG_ADAPT_i::setTimeStepRank(CORBA::Long t, CORBA::Long r)
{
myMgAdapt->setChosenTimeStepRank();
myMgAdapt->setRankTimeStep(t, r);
}
CORBA::Long MG_ADAPT_i::getRank()
{
return myMgAdapt->getRank();
}
void MG_ADAPT_i::setTimeStepRankLast()
{
myMgAdapt->setTimeStepRankLast();
}
void MG_ADAPT_i::setNoTimeStep()
{
myMgAdapt->setNoTimeStep();
}
void MG_ADAPT_i::setLogFile(const char* str)
{
myMgAdapt->setLogFile(str);
}
char* MG_ADAPT_i::getLogFile()
{
return CORBA::string_dup(myMgAdapt->getLogFile().c_str());
}
void MG_ADAPT_i::setVerbosityLevel(CORBA::Long v)
{
myMgAdapt->setVerbosityLevel(v);
}
CORBA::Long MG_ADAPT_i::getVerbosityLevel()
{
return myMgAdapt->getVerbosityLevel();
}
void MG_ADAPT_i::setRemoveOnSuccess(bool mybool)
{
myMgAdapt->setRemoveOnSuccess(mybool);
}
bool MG_ADAPT_i::getRemoveOnSuccess()
{
myMgAdapt->getRemoveOnSuccess();
}
SMESH::MgAdaptHypothesisData* MG_ADAPT_i::getData()
{
SMESH::MgAdaptHypothesisData* result = new SMESH::MgAdaptHypothesisData();
::MG_ADAPT::MgAdaptHypothesisData* from = myMgAdapt->getData();
copyHypothesisDataFromImpl(from, result);
return result;
}
void MG_ADAPT_i::setUseLocalMap(bool mybool)
{
myMgAdapt->setUseLocalMap(mybool);
}
bool MG_ADAPT_i::getUseLocalMap()
{
return myMgAdapt->getUseLocalMap();
}
void MG_ADAPT_i::setUseBackgroundMap(bool mybool)
{
myMgAdapt->setUseBackgroundMap(mybool);
}
bool MG_ADAPT_i::getUseBackgroundMap()
{
return myMgAdapt->getUseBackgroundMap();
}
void MG_ADAPT_i::setUseConstantValue(bool mybool)
{
myMgAdapt->setUseConstantValue(mybool);
}
bool MG_ADAPT_i::getUseConstantValue()
{
return myMgAdapt->getUseConstantValue();
}
void MG_ADAPT_i::setConstantSize(double value)
{
myMgAdapt->setConstantValue(value);
}
double MG_ADAPT_i::getConstantSize()
{
return myMgAdapt->getConstantValue();
}
void MG_ADAPT_i::setSizeMapFile(const char* str)
{
myMgAdapt->setSizeMapFile(str);
}
char* MG_ADAPT_i::getSizeMapFile()
{
return CORBA::string_dup(myMgAdapt->getSizeMapFile().c_str());
}
void MG_ADAPT_i::setFromMedFile(bool mybool)
{
myMgAdapt->setFromMedFile(mybool);
}
bool MG_ADAPT_i::isFromMedFile()
{
return myMgAdapt->isFromMedFile();
}
void MG_ADAPT_i::setKeepWorkingFiles(bool mybool)
{
myMgAdapt->setKeepWorkingFiles(mybool);
}
bool MG_ADAPT_i::getKeepWorkingFiles()
{
return myMgAdapt->getKeepWorkingFiles();
}
//~void MG_ADAPT_i::setPrCORBA::LongLogInFile(bool);
//~bool MG_ADAPT_i::getPrCORBA::LongLogInFile();
void MG_ADAPT_i::setSizeMapType(const char* type)
{
setUseLocalMap(false);
setUseBackgroundMap(false);
setUseConstantValue(false);
if (!strcmp("Local", type))
setUseLocalMap(true);
else if (!strcmp("Background", type))
setUseBackgroundMap(true);
else
setUseConstantValue(true);
}
void MG_ADAPT_i::setWorkingDir(const char* dir)
{
myMgAdapt->setWorkingDir(dir);
}
char* MG_ADAPT_i::getWorkingDir()
{
return CORBA::string_dup(myMgAdapt->getWorkingDir().c_str());
}
bool MG_ADAPT_i::setAll()
{
return myMgAdapt->setAll();
}
char* MG_ADAPT_i::getCommandToRun()
{
return CORBA::string_dup(myMgAdapt->getCommandToRun().c_str());
}
void MG_ADAPT_i::compute()
{
errStr = "";
try
{
myMgAdapt->compute(errStr);
}
catch (const std::exception& e)
{
std::ostringstream oss; oss << "Exception thrown on MG_ADAPT_i::compute invocation with error message \"" << errStr
<< "\" with exception message \"" << e.what() << "\"";
THROW_SALOME_CORBA_EXCEPTION(oss.str().c_str(),SALOME::INTERNAL_ERROR);
}
if(myMgAdapt->getPublish())
{
SMESH_Gen_i* smeshGen_i = SMESH_Gen_i::GetSMESHGen();
SMESH::DriverMED_ReadStatus theStatus;
smeshGen_i->CreateMeshesFromMED(myMgAdapt->getMedFileOut().c_str(), theStatus);
}
}
char* MG_ADAPT_i::getErrMsg()
{
return CORBA::string_dup(errStr.c_str());
}
char* MG_ADAPT_i::getFileName()
{
return CORBA::string_dup(myMgAdapt->getFileName().c_str());
}
char* MG_ADAPT_i::getExeName()
{
return CORBA::string_dup(myMgAdapt->getExeName().c_str());
}
void MG_ADAPT_i::copyMgAdaptHypothesisData( const SMESH::MgAdaptHypothesisData& data)
{
::MG_ADAPT::MgAdaptHypothesisData* baseData = new ::MG_ADAPT::MgAdaptHypothesisData();
copyHypothesisDataToImpl(data, baseData);
myMgAdapt->copyMgAdaptHypothesisData(baseData);
delete baseData;
}
//~void MG_ADAPT_i::checkDirPath(char*& str)
//~{
//~myMgAdapt->checkDirPath(str);
//~}
bool MG_ADAPT_i::hasOptionDefined( const char* optionName )
{
return myMgAdapt->hasOptionDefined(optionName);
}
void MG_ADAPT_i::setOptionValue(const char* optionName,
const char* optionValue) throw (std::invalid_argument)
{
myMgAdapt->setOptionValue(optionName, optionValue);
}
char* MG_ADAPT_i::getOptionValue(const char* optionName,
bool& isDefault) throw (std::invalid_argument)
{
return CORBA::string_dup(myMgAdapt->getOptionValue(optionName, &isDefault).c_str());
}
str_array* MG_ADAPT_i::getCustomOptionValuesStrVec()
{
SMESH::str_array_var result = new SMESH::str_array();
std::vector <std::string> vals = myMgAdapt->getCustomOptionValuesStrVec();
result->length(vals.size());
for (int i = 0; i<vals.size(); i++) result[i] = CORBA::string_dup(vals[i].c_str());
return result._retn();
}
str_array* MG_ADAPT_i::getOptionValuesStrVec()
{
SMESH::str_array_var result = new SMESH::str_array();
std::vector <std::string> vals = myMgAdapt->getOptionValuesStrVec();
result->length(vals.size());
for (int i = 0; i<vals.size(); i++) result[i] = CORBA::string_dup(vals[i].c_str());
return result._retn();
}
void MG_ADAPT_i::setPrintLogInFile(bool mybool)
{
myMgAdapt->setPrintLogInFile(mybool);
}
bool MG_ADAPT_i::getPrintLogInFile()
{
return myMgAdapt->getPrintLogInFile();
}
//~TOptionValues MG_ADAPT_i::getOptionValues() const;
//~const TOptionValues& MG_ADAPT_i::getCustomOptionValues() const ;
MG_ADAPT_OBJECT_i::MG_ADAPT_OBJECT_i(): SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
{
medFileIn="";
medFileOut="";
medFileBackground="";
publish = false;
//~myMesh = CORBA::nil;
}
void MG_ADAPT_OBJECT_i::setMeshIn(SMESH::SMESH_Mesh_ptr theMesh )
{
myMesh = SMESH::SMESH_Mesh::_duplicate(theMesh);
}
void MG_ADAPT_OBJECT_i::setMEDFileIn(const char* f)
{
medFileIn = f;
}
void MG_ADAPT_OBJECT_i::setMEDFileOut(const char* f)
{
medFileOut = f;
}
void MG_ADAPT_OBJECT_i::setMEDFileBackground(const char* f)
{
medFileBackground = f;
}
void MG_ADAPT_OBJECT_i::AddHypothesis(SMESH::MG_ADAPT_ptr mg)
{
mg->setMedFileIn(medFileIn.c_str());
mg->setMedFileOut(medFileOut.c_str());
mg->setSizeMapFile(medFileBackground.c_str());
hypothesis = SMESH::MG_ADAPT::_duplicate(mg);
}
CORBA::Long MG_ADAPT_OBJECT_i::Compute(bool publish)
{
if(!checkMeshFileIn()){
std::cerr<< "\n Error : Please check the MED file input or mesh input. \n";
return -1;
}
hypothesis->setPublish(publish);
hypothesis->compute();
return 0;
}
bool MG_ADAPT_OBJECT_i::checkMeshFileIn()
{
bool ret = false; // 1 ok , 0 nook
if(!::MG_ADAPT::MgAdapt::isFileExist(medFileIn))
{
if(!myMesh->_is_nil())
{
bool toOverwrite = true;
bool toFindOutDim = true;
medFileIn = hypothesis->getFileName();
medFileIn+= ".med";
myMesh->ExportMED(medFileIn.c_str(), false, -1, toOverwrite, toFindOutDim);
hypothesis->setMedFileIn(medFileIn.c_str());
ret = true;
}
}
else
ret = true;
return ret;
}

162
src/SMESH_I/MG_ADAPT_i.hxx
View File

@ -1,162 +0,0 @@
#ifndef MG_ADAPT_I_HXX
#define MG_ADAPT_I_HXX
#include "MG_ADAPT.hxx"
#include "SMESH.hxx"
#include <SALOMEconfig.h>
//~#include CORBA_SERVER_HEADER(ADAPT_Gen)
#include CORBA_SERVER_HEADER(MG_ADAPT)
#include "SALOME_GenericObj_i.hh"
#include "SALOME_Component_i.hxx"
#include "SALOME_NamingService.hxx"
#include "Utils_CorbaException.hxx"
#include <vector>
#include <algorithm>
#include <iterator>
#include <string>
//~struct MgAdaptHypothesisData;
//~static void copyHypothesisDataToImpl(SMESH::MgAdaptHypothesisData& from, MG_ADAPT::MgAdaptHypothesisData* to);
//~static void copyHypothesisDataFromImpl(MG_ADAPT::MgAdaptHypothesisData* from, SMESH::MgAdaptHypothesisData& to);
//~class MgAdapt;
namespace SMESH
{
class SMESH_I_EXPORT MG_ADAPT_i :
public virtual SALOME::GenericObj_i,
public virtual POA_SMESH::MG_ADAPT
{
public:
//~MG_ADAPT_i( CORBA::ORB_ptr orb, ADAPT::ADAPT_Gen_var gen_i );
//~static SMESH::MG_ADAPT_ptr CreateMG_ADAPT();
//~MG_ADAPT_i(PortableServer::POA_var poa);
MG_ADAPT_i();
virtual ~MG_ADAPT_i();
//~void setData( SMESH::MgAdaptHypothesisData* data);
void setData( SMESH::MgAdaptHypothesisData& data);
void setMedFileIn(const char* str);
char* getMedFileIn();
void setMedFileOut(const char* str);
char* getMedFileOut();
void setMeshName(const char* str);
char* getMeshName();
void setMeshNameOut(const char* str);
char* getMeshNameOut();
void setMeshOutMed(bool mybool);
bool getMeshOutMed();
void setPublish(bool mybool);
bool getPublish();
void setSizeMapFieldName(const char* str);
char* getSizeMapFieldName();
void setTimeStep(CORBA::Long t);
CORBA::Long getTimeStep() ;
void setTimeStepRank(CORBA::Long t, CORBA::Long r );
CORBA::Long getRank();
void setTimeStepRankLast();
void setNoTimeStep();
void setLogFile(const char* str);
char* getLogFile();
void setVerbosityLevel(CORBA::Long v);
CORBA::Long getVerbosityLevel();
void setRemoveOnSuccess(bool mybool);
bool getRemoveOnSuccess();
SMESH::MgAdaptHypothesisData* getData() ;
void setSizeMapType(const char* type);
void setUseLocalMap(bool mybool);
bool getUseLocalMap();
void setUseBackgroundMap(bool mybool);
bool getUseBackgroundMap();
void setUseConstantValue(bool mybool);
bool getUseConstantValue();
void setConstantSize(double value);
double getConstantSize();
void setSizeMapFile(const char* str);
char* getSizeMapFile();
void setFromMedFile(bool mybool);
bool isFromMedFile();
void setKeepWorkingFiles(bool mybool);
bool getKeepWorkingFiles();
//~void setPrCORBA::LongLogInFile(bool);
//~bool getPrCORBA::LongLogInFile();
void setWorkingDir(const char* str);
char* getWorkingDir() ;
void setPrintLogInFile(bool mybool);
bool getPrintLogInFile();
bool setAll();
char* getCommandToRun() ;
void compute();
char* getFileName();
char* getExeName();
void copyMgAdaptHypothesisData( const SMESH::MgAdaptHypothesisData& data ) ;
//~void copyMgAdaptHypothesisData( const SMESH::MgAdaptHypothesisData& data ) {
//~copyMgAdaptHypothesisData(&data);
//~}
//~void checkDirPath(char*& str);
bool hasOptionDefined( const char* optionName ) ;
void setOptionValue(const char* optionName,
const char* optionValue) throw (std::invalid_argument);
char* getOptionValue(const char* optionName,
bool& isDefault) throw (std::invalid_argument);
str_array* getCustomOptionValuesStrVec() ;
str_array* getOptionValuesStrVec() ;
void copyHypothesisDataFromImpl(const ::MG_ADAPT::MgAdaptHypothesisData* from, SMESH::MgAdaptHypothesisData* to) const;
void copyHypothesisDataToImpl(const SMESH::MgAdaptHypothesisData& from, ::MG_ADAPT::MgAdaptHypothesisData* to) const;
//~TOptionValues getOptionValues() const;
//~const TOptionValues& getCustomOptionValues() const ;
char* getErrMsg();
private:
::MG_ADAPT::MgAdapt* myMgAdapt;
std::string errStr;
//~CORBA::ORB_ptr _orb;
//~ADAPT::ADAPT_Gen_var _gen_i;
};
class SMESH_I_EXPORT MG_ADAPT_OBJECT_i:
public virtual SALOME::GenericObj_i,
public virtual POA_SMESH::MG_ADAPT_OBJECT {
public :
MG_ADAPT_OBJECT_i();
void setMeshIn( SMESH::SMESH_Mesh_ptr theMesh );
void setMEDFileIn(const char* f);
void setMEDFileOut(const char* f);
void setMEDFileBackground(const char* f);
void AddHypothesis(SMESH::MG_ADAPT_ptr);
CORBA::Long Compute(bool Publish);
private:
std::string medFileIn, medFileOut, medFileBackground;
bool checkMeshFileIn();
bool publish;
SMESH::SMESH_Mesh_ptr myMesh;
SMESH::MG_ADAPT_ptr hypothesis;
};
}
#endif // MG_ADAPT_I_HXX

4
src/SMESH_I/SMESH_Gen_i.hxx
View File

@ -477,10 +477,6 @@ public:
int CountInPyDump(const TCollection_AsciiString& text);
SMESH::MG_ADAPT_ptr CreateMG_ADAPT();
SMESH::MG_ADAPT_ptr CreateAdaptationHypothesis();
SMESH::MG_ADAPT_OBJECT_ptr Adaptation( const char* adaptationType);
// *****************************************
// Internal methods
// *****************************************